Intégration de Flex 3, BlazeDS et Spring sous Flex Builder 3

C:\>java -version

java version "1.5.0_08"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_08-b03)
Java HotSpot(TM) Client VM (build 1.5.0_08-b03, mixed mode)

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical" width="451" height="168" 
    paddingBottom="0" paddingLeft="0" paddingRight="0" paddingTop="0">

    <mx:Script>
        <![CDATA[
            import mx.rpc.events.FaultEvent;
            import mx.rpc.events.ResultEvent;
            
            private function doCall():void{
                // Appeler le service distant
                roWelcomeService.sayHello(tiLogin.text);
            }
            
            /**
             * Méthode invoquée en cas de succès de l'appel RPC 
             */ 
            private function onResult(event : ResultEvent):void{
                // Afficher la réponse
                taReponse.text = event.result as String;
            }
            
            /**
             * Méthode invoquée en cas d'échec de l'appel RPC 
             */ 
            private function onFault(event : FaultEvent):void{
                // Afficher le message d'erreur
                taReponse.text = event.fault.message;
            }
        
        ]]>
    </mx:Script>

    <mx:RemoteObject id="roWelcomeService" 
                     destination="welcomeServiceDest"
                     result="onResult(event)"
                     fault="onFault(event)"/>
    <mx:Panel width="451" height="168" layout="absolute" title="Hello World">
        <mx:Label x="10" y="10" text="Login : "/>
        <mx:TextInput id="tiLogin" text="Guest"
                      x="66" y="8" />
        <mx:Button id="btnAppel" label="Appel de WelcomeService"
                   x="234" y="8" 
                   click="doCall()"/>
        <mx:Label x="10" y="38" text="Réponse :"/>
        <mx:TextArea id="taReponse" 
                     x="81" y="37" width="327" height="81"/>
    </mx:Panel>
</mx:Application>

package com.developpez.service;

public class WelcomeService {

    public String sayHello(String pLogin){
        return "Bienvenue "+pLogin;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<service id="remoting-service" 
    class="flex.messaging.services.RemotingService">

    <adapters>
        <adapter-definition id="java-object" class="flex.messaging.services.remoting.adapters.JavaAdapter" default="true"/>
    </adapters>

    <default-channels>
        <channel ref="my-amf"/>
    </default-channels>
 
    <destination id="welcomeServiceDest">
        <properties>
            <source>com.developpez.service.WelcomeService</source>
            <scope>application</scope>
        </properties>
    </destination>    
</service>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
       
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
    <display-name>FBSIntegration</display-name>
    <description>BlazeDS Application</description>

    <context-param>
        <param-name>flex.class.path</param-name>
        <param-value>/WEB-INF/flex/hotfixes,/WEB-INF/flex/jars</param-value>
    </context-param>

    <!-- Chemin d'acces au fichier de configuration Spring -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/classes/webApplicationContext.xml</param-value>
    </context-param>

    <!-- Spring listener -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    ...
</web-app>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
    <bean id="welcomeServiceBean" class="com.developpez.service.WelcomeService"/>                                  
</beans>

package com.developpez.web;

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

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.  
     */
    public void initialize(String id, 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.
     */
    public FactoryInstance createFactoryInstance(String id, ConfigMap properties)
    {
        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.
     */
    public Object lookup(FactoryInstance inst)
    {
        SpringFactoryInstance factoryInstance = (SpringFactoryInstance) inst;
        return factoryInstance.lookup();
    } 


    static class SpringFactoryInstance extends FactoryInstance
    {
        SpringFactoryInstance(SpringFactory factory, String id, ConfigMap properties)
        {
            super(factory, id, properties);
        }


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

        public Object lookup() 
        {
            ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(flex.messaging.FlexContext.getServletConfig().getServletContext());
            String beanName = getSource();

            try
            {
                return appContext.getBean(beanName);
            }
            catch (NoSuchBeanDefinitionException nexc)
            {
                ServiceException e = new ServiceException();
                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)
            {
                ServiceException e = new ServiceException();
                String msg = "Unable to create Spring service named '" + beanName + "' ";
                e.setMessage(msg);
                e.setRootCause(bexc);
                e.setDetails(msg);
                e.setCode("Server.Processing");
                throw e;
            } 
        }
    } 
}

<?xml version="1.0" encoding="UTF-8"?>
<services-config>
    <factories>
        <factory id="SpringFactory" class="com.developpez.web.SpringFactory" />
    </factories>
...
</services-config>

<destination id="welcomeServiceDest">
    <properties>
        <factory>SpringFactory</factory>
        <source>welcomeServiceBean</source>
    </properties>
</destination>

INFO: Initializing Spring root WebApplicationContext
...…
INFO: Loading XML bean definitions from ServletContext resource [/WEB-INF/classes/webApplicationContext.xml]
...
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@7f58ef: defining beans [welcomeServiceBean]; root of factory hierarchy
...
INFO: Root WebApplicationContext: initialization completed in 242 ms