An Introduction to Spring BlazeDS Integration

A Simple Example

To set up a simple Spring BlazeDS Integration application, you will need to:

1. Configure Spring in web.xml.
2. Configure the BlazeDS message broker as a Spring-managed bean in the application context configuration file.
3. Configure your beans and expose them as remote objects in the application context configuration file.

Note: Depending on the DispatcherServlet mapping defined in web.xml, you may also need to adjust the default channel configuration in the BlazeDS services-config.xml file.

In web.xml, you configure the DispatcherServlet to bootstrap the Spring WebApplicationContext as usual. In this simple configuration, you then map all the /messagebroker requests to the DispatcherServlet.

web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">

    <servlet>
        <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/config/web-application-config.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
        <url-pattern>/messagebroker/*</url-pattern>
    </servlet-mapping>

</web-app>

In web-application-config.xml, you first configure the BlazeDS message broker as a Spring-managed bean using the simple message-broker tag. This will bootstrap the BlazeDS message broker. When you use the message-broker tag without mapping child elements, all incoming DispatcherServlet requests are mapped to the MessageBroker. You can add mapping child elements if you need more control.

With the message-broker in place, you then configure your Spring beans as usual, and you expose the beans you want to make available for remote access using the remote-service tag.

web-application-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:flex="http://www.springframework.org/schema/flex"
       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.5.xsd
        http://www.springframework.org/schema/flex
        http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
          
<flex:message-broker/>

    <bean id="productService" class="my.package.ProductDAO" >
        <flex:remote-service />
        <constructor-arg ref="dataSource"/>
    </bean>
   
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="org.h2.Driver" />
        <property name="url" value="jdbc:h2:~/sprinflexdemodb/sprinflexdemodb" />
    </bean>
   
</beans>

The above configuration allows a Flex application to invoke the public methods of the productService bean. Here is a minimalist Flex application that populates a DataGrid with a list of products obtained by remotely invoking the findAll() method of the ProductService class.

Note that this is the same code that was used to connect to a plain BlazeDS installation: The client-side code is isolated from the specific server-side implementation.

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml">

    <mx:RemoteObject id="ro" destination="productService"/>

    <mx:DataGrid dataProvider="{ro.findAll.lastResult}" width="100%" height="100%"/>

    <mx:Button label="Get Data" click="ro.findAll()"/>
   
</mx:Application>

Integrating Security

A full description of Spring security is outside the scope of this article. You can refer to the Spring documentation for more information. Here is a basic web.xml file configured to use Spring security:

web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">

    <display-name>Spring BlazeDS Integration Samples</display-name>
   
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/config/web-application-config.xml
            /WEB-INF/config/web-application-security.xml
        </param-value>
    </context-param>
   
    <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>

    <filter-mapping>
      <filter-name>springSecurityFilterChain</filter-name>
      <url-pattern>/*</url-pattern>
    </filter-mapping>
   
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
   
    <servlet>
        <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
        <url-pattern>/messagebroker/*</url-pattern>
     </servlet-mapping>

     <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>

</web-app>

For the purpose of this introduction, a basic authentication provider can be defined in web-application-security.xml as follows:

web-application-security.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/security"
    xmlns:beans="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
                        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.1.xsd">

    <http auto-config="true" session-fixation-protection="none"/>
   
    <authentication-provider>
        <user-service>
            <user name="john" password="john" authorities="ROLE_USER, ROLE_ADMIN" />
            <user name="guest" password="guest" authorities="ROLE_GUEST" />
        </user-service>
    </authentication-provider>

</beans:beans>

In your web-application context, you can then set security as usual. The example below specifies that a user needs to be authenticated and belong to the ROLE_USER role to access the "find*" methods.

    <bean id="productService" class="flex.spring.samples.product.ProductDAO" >
        <flex:remote-service/>
        <constructor-arg ref="dataSource"/>
        <security:intercept-methods>
            <security:protect method="find*" access="ROLE_USER" />
        </security:intercept-methods>
    </bean>

If you now run the client application, you will get an Access Denied exception unless you have authenticated outside the Flex application.

The Spring security integration also allows you to authenticate from inside the Flex application using the standard channelSet.login() API. In the following version of the application, I added a simple user interface and the basic infrastructure to authenticate using the ChannelSet API.

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
    applicationComplete="applicationCompleteHandler()">

    <mx:Script>
        <![CDATA[

            import mx.messaging.ChannelSet;
            import mx.messaging.channels.AMFChannel;
            import mx.controls.Alert;
            import mx.rpc.events.FaultEvent;
           
            private function applicationCompleteHandler():void
            {
                var channel:AMFChannel = new AMFChannel("my-amf", "http://localhost:8080/messagebroker/amf");
                var channelSet:ChannelSet = new ChannelSet();
                channelSet.addChannel(channel);
                ro.channelSet = channelSet;
            }

            private function faultHandler(event:FaultEvent):void
            {
                Alert.show(event.fault.faultString, "Error accessing RemoteObject");
            }
           
            private function login():void
            {
                ro.channelSet.login(userId.text, password.text);
            }

            private function logout():void
            {
                ro.channelSet.logout();   
            }
           
        ]]>
    </mx:Script>

    <mx:RemoteObject id="ro" destination="productService" fault="faultHandler(event)"/>

    <mx:Form>
        <mx:FormItem label="User Id">
            <mx:TextInput id="userId"/>
        </mx:FormItem>
        <mx:FormItem label="Password">
            <mx:TextInput id="password" displayAsPassword="true"/>
        </mx:FormItem>
        <mx:FormItem direction="horizontal">
            <mx:Button label="Login" click="login()"/>
            <mx:Button label="Logout" click="logout()"/>
        </mx:FormItem>
    </mx:Form>
   
    <mx:DataGrid dataProvider="{ro.findAll.lastResult}" width="100%" height="100%"/>

    <mx:Button label="Get Data" click="ro.findAll()"/>
   
</mx:Application>

Status and Roadmap

The Spring  BlazeDS integration project is still a work in progress, but the Milestone 2 build that is currently available already provides very valuable features. The next milestone will provide integration with the BlazeDS Message Service. Integration with the data management services in LiveCycle Data Services ES is also on the roadmap.

Summary

The Spring BlazeDS Integration project enables you to seamlessly integrate Flex, BlazeDS, and Spring to build expressive, high-performance, and well-architected Rich Internet Applications. If you are already a Spring developer, you can leverage your existing infrastructure and simply expose your beans for remote access by Flex clients via BlazeDS remoting. If you are an existing Flex and BlazeDS developer, you can use Spring BlazeDS Integration to easily leverage the many powerful features of the Spring IoC container and other components of the Spring Framework.

• The Spring BlazeDS Integration Project
• BlazeDS Open Source Project
• Flex SDK Open Source Project
• Flex Builder Eclipse Plugin
• Test Drive - The examples discussed in this article are based on “the Spring BlazeDS Test Drive” I created to help developers get started with the integration. The Test Drive consists of a minimal version of Tomcat with BlazeDS and the “Spring / BlazeDS integration” preconfigured and ready to use. It also includes a series of samples running “out-of-the-box”.