Blaze DS and Spring :: Part 1

import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;

import flex.messaging.FactoryInstance;
import flex.messaging.FlexFactory;
import flex.messaging.config.ConfigMap;
import flex.messaging.services.ServiceException;

/**
* This interface is implemented by factory components which provide instances
* to the flex messaging framework. To configure flex data services to use this
* factory, add the following lines to your services-config.xml file (located in
* the WEB-INF/flex directory of your web application).
*
* <factories> <factory id="spring"
* class="flex.samples.factories.SpringFactory" /> </factories>
*
* You also must configure the web application to use spring and must copy the
* spring.jar file into your WEB-INF/lib directory. To configure your app server
* to use spring, you add the following lines to your WEB-INF/web.xml file:
*
* <context-param>
* <param-name>contextConfigLocation</param-name>
* <param-value>/WEB-INF/applicationContext.xml</param-value>
* </context-param>
*
* <listener>
* <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
* </listener>
*
* Then you put your spring bean configuration in WEB-INF/applicationContext.xml
* (as per the line above). For example:
*
* <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC
* "-//SPRING//DTD BEAN//EN"
* "http://www.springframework.org/dtd/spring-beans.dtd">
*
* <beans> <bean name="weatherBean" class="dev.weather.WeatherService"
* singleton="true"/> </beans>
*
* Now you are ready to define a destination in flex that maps to this existing
* service. To do this you'd add this to your WEB-INF/flex/remoting-config.xml:
*
* <destination id="WeatherService"> <properties>
* <factory>spring</factory>
* <source>weatherBean</source> </properties>
* </destination>
*
* @author Jeff Vroom
*/
public class SpringFactory implements FlexFactory {
private static final String SOURCE = "source";

/**
* This method can be used to initialize the factory itself. It is called with
* configuration parameters from the factory tag which defines the id of the
* factory. {@inheritDoc}
*/
public void initialize(final String id, final ConfigMap configMap) {
}

/**
* This method is called when we initialize the definition of an instance
* which will be looked up by this factory. It should validate that the
* properties supplied are valid to define an instance. Any valid properties
* used for this configuration must be accessed to avoid warnings about unused
* configuration elements. If your factory is only used for application scoped
* components, this method can simply return a factory instance which
* delegates the creation of the component to the FactoryInstance's lookup
* method. {@inheritDoc}
*/
public FactoryInstance createFactoryInstance(final String id, final ConfigMap properties) {
final SpringFactoryInstance instance = new SpringFactoryInstance(this, id, properties);
instance.setSource(properties.getPropertyAsString(SOURCE, instance.getId()));
return instance;
} // end method createFactoryInstance()

/**
* Returns the instance specified by the source and properties arguments. For
* the factory, this may mean constructing a new instance, optionally
* registering it in some other name space such as the session or JNDI, and
* then returning it or it may mean creating a new instance and returning it.
* This method is called for each request to operate on the given item by the
* system so it should be relatively efficient.
* <p>
* If your factory does not support the scope property, it report an error if
* scope is supplied in the properties for this instance. {@inheritDoc}
*/
public Object lookup(final FactoryInstance inst) {
final SpringFactoryInstance factoryInstance = (SpringFactoryInstance) inst;
return factoryInstance.lookup();
}

/**
* Inner class for Spring factory instance.
*/
static class SpringFactoryInstance extends FactoryInstance {
/**
* Constructor.
*
* @param factory
* reference to SpringFactory
* @param id
* id (of the bean?)
* @param properties
* map with configuration properties.
*/
SpringFactoryInstance(final SpringFactory factory, final String id, final ConfigMap properties) {
super(factory, id, properties);
}

/**
* {@inheritDoc}
*/
public String toString() {
return "SpringFactory instance for id=" + getId() + " source=" + getSource() + " scope=" + getScope();
}

/**
* {@inheritDoc}
*/
public Object lookup() {
final ApplicationContext appContext = WebApplicationContextUtils
.getWebApplicationContext(flex.messaging.FlexContext.getServletConfig().getServletContext());
final String beanName = getSource();

try {
return appContext.getBean(beanName);
} catch (NoSuchBeanDefinitionException nexc) {
final ServiceException e = new ServiceException();
final String msg = "Spring service named '" + beanName + "' does not exist.";
e.setMessage(msg);
e.setRootCause(nexc);
e.setDetails(msg);
e.setCode("Server.Processing");
throw e;
} catch (BeansException bexc) {
final ServiceException e = new ServiceException();
final String msg = "Unable to create Spring service named '" + beanName + "' ";
e.setMessage(msg);
e.setRootCause(bexc);
e.setDetails(msg);
e.setCode("Server.Processing");
throw e;
}
}

}

}

<factories>
      <factory id="spring" class="nl.wowww.flex.presentation.task.manager.core.spring.SpringFactory" />
   </factories>