Flex與Spring集成【轉】

來源： http://coenraets.org/flex-spring

What is Spring?Spring is one of the most popular Java frameworks. The foundation ofthe Spring framework is a lightweight component container thatimplements the Inversion of Control (IoC) pattern.
Using an IoC container, components don’t instantiate or even look uptheir dependencies (the objects they work with). The container isresponsible for injecting those dependencies when it creates thecomponents (hence the term “Dependency Injection” also used to describethis pattern).
The result is looser coupling between components. The Spring IoCcontainer has proven to be a solid foundation for building robustenterprise applications. The components managed by the Spring IoCcontainer are called Spring beans.
The Spring framework includes several other modules in addition toits core IoC container. These modules are not covered in this documenteven though we will be using the Spring JDBC abstraction framework inexamples 2 and 3 below. More information on the Spring framework can befound at http://www.springframework.org.
What is Flex? Flex provides a complete solution for building Rich Internet Applications. The Flex programming model is made of:
ActionScript, an ECMAScript compliant,object-oriented programming model. With some syntactical differences,ActionScript looks and feels similar to Java, and supports the sameobject-oriented constructs: packages, classes, inheritance, interfaces,strong (but also dynamic) typing etc. MXML: an XML-based language that provides anabstraction on top of ActionScript, and allows parts of an application(typically the View) to be built declaratively. An extensive set of class libraries. The online API documentation is available here in a Javadoc-like format. The Flex source code (.mxml and .as files) is compiled into Flashbytecode (.swf) that is executed at the client-side by the Flashvirtual machine using a Just-In-Time compiler.
A complete discussion of Flex is beyond the scope of this document. You can find more information at http://www.adobe.com/products/flex.
How does Flex access back-end systems?When writing Flex applications, you can access back-end systems using four different strategies:
You can use the HTTPService component to send HTTPrequests to a server, and consume the response. Although theHTTPService is typically used to consume XML, it can be used to consumeother types of responses. The Flex HTTPService is similar to theXMLHttpRequest component available in Ajax. You can use the WebService component to invoke SOAP-based web services. You can use the RemoteObject component to directlyinvoke methods of Java objects deployed in your application server, andconsume the return value. The return value can be a value of aprimitive data type, an object, a collection of objects, an objectgraph, etc. In distributed computing terminology, this approach isgenerally referred to as “remoting”. This is also the terminology used in Spring to describe how different clients can access Spring beans remotely. In addition to the RPC-type services described above, the Flex Data Management Servicesprovide an innovative and virtually code-free approach to synchronizedata between the client application and the middle-tier. In this document, we focus on the Remoting (3) and Data ManagementServices (4) approaches described above because they enable thetightest integration with Spring. There is no need to transform data,or to expose services in a certain way: the Flex application worksdirectly with the beans registered in the Spring IoC container.
How does Flex access Spring beans? So, if Flex clients can remotely access Java objects, and if Springbeans are Java objects, aren’t we all set and ready to start accessingSpring beans from Flex clients? Almost… There is one simple element toconfigure.
The whole idea behind Spring IoC is to let the container instantiatecomponents (and inject their dependencies). By default, however,components accessed remotely by a Flex client are instantiated by Flexdestinations at the server-side. The key to the Flex/Spring integrationis therefore to configure the Flex destinations to let the Springcontainer take care of instantiating Spring beans. The Flex DataServices support the concept of factory to enable this type of customcomponent instantiation. The role of a factory is simply to provideready-to-use instances of components to a Flex destination (instead ofletting the Flex destination instantiate these components itself).
The supporting files available with this document include a factoryclass (SpringFactory) that provides Flex destinations with fullyinitialized (dependency-injected) instances of Spring beans. Note: TheSpringFactory was developed by Jeff Vroom (Flex Data Servicesarchitect) and is also available on Adobe Exchange.
The remaining of this article describes how to configure your webapplication to use Flex and Spring, how to configure the SpringFactory, and how to put the pieces together and start invoking Springbeans from Flex applications.
Setting Up your Web Application to Use Flex and SpringStep 1: Install the supporting files Download flex-spring.zip here Expand flex-spring.zip flex-spring.zip includes the Spring factory as well as the supporting files for the examples below.
Step 2: Install Flex Data ServicesTo use the Remoting and Data Management Services data accessstrategies described above, you need to install the Flex Data Services.If you haven’t already done so, you can download the Flex Data Serviceshere, and follow the installation instructions.
The installation process will install three web applications (flex,samples, and flex-admin). You can use either the flex or samples webapplication to run the examples below.
You can read more information on the installation process here: http://www.adobe.com/support/documentation/en/flex/2/install.html#installingfds2
Step 3: Install SpringNote: A complete discussion of the Spring installation process is beyond the scope of this article. Refer to http://www.springframework.org for more information. The steps below describe a basic configuration that is sufficient for the purpose of this article.
Download the Spring framework (version 2.0) at http://www.springframework.org/download (the version without dependencies is sufficient to complete the examples in this article).
Note: The examples below have been developed and tested using Spring2.0. However the integration approach described in this document (andthe SpringFactory class) should work fine using Spring 1.2.8 (some ofthe examples might not work because they use Spring 2.0 features). Expand the downloaded file Locate spring.jar in the dist directory and copy it in the {context-root}\WEB-INF\lib directory of your web application Modify the web.xml file of your web application. Add the context-param and listener definitions as follows:<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> Step 4: Register the Spring Factory Copy SpringFactory.class andSpringFactory$SpringFactoryInstance.class fromflex-spring-sdk\bin\flex\samples\factories to{context-root}\WEB-INF\classes\flex\samples\factories Register the Spring factory in {context-root}\WEB-INF\flex\services-config.xml:<factories>
<factory class="flex.samples.factories.SpringFactory" id="spring">
</factory></factories> Example 1: Mortgage Calculator Using Flex RemotingThis first application is intentionally simplistic in itsfunctionality to provide an uncluttered example of wiring Spring beanstogether and invoking them from a Flex application.
Step 1: Copy the application files Copy RateFinder.class, SimpleRateFinder.class, and Mortgage.classfrom flex-spring-sdk\bin\flex\samples\spring\mortgage to{context-root}\WEB-INF\classes\flex\samples\spring\mortgage Copy mortgage.mxml from flex-spring-sdk\flex\mortgage to {context-root}\mortgage Step 2: Register Spring Beans Before registering the Spring beans for this application, openRateFinder.java, SimpleRateFinder.java and Mortgage.java inflex-spring-sdk\src\flex\samples\spring\mortgage to familiarizeyourself with the source code. Notice that Mortgage has a dependency toa RateFinder object. Mortgage doesn’t instantiate a RateFinder objectitself, doesn’t lookup up for a RateFinder object, and doesn’t evenknow the exact type of the object it will be dealing with (RateFinderis an inteface). An instance of a class implementing the RateFinderinterface will be injected by the container (using the setRateFindermethod) when it instantiates the component. If it doesn’t already exist, create a file named applicationContext.xml in {context-root}\WEB-INF. Register the rateFinderBean and mortgageBean beans in applicationContext.xml as follows:


<beans>

<bean class="flex.samples.spring.mortgage.SimpleRateFinder" id="rateFinderBean">

<bean class="flex.samples.spring.mortgage.Mortgage" id="mortgageBean">
<property ref="rateFinderBean" name="rateFinder">
</property>

</bean></bean></beans>Notice that in the mortgageBean definition, we tell the containerhow to inject the rateFinder dependency: the rateFinder property ismapped to rateFinderBean which defines an instance of theSimpleRateFinder class. Step 3: Configure the Flex Remoting Destination Open remoting-config.xml in {context-root}\WEB-INF\flex. Add a mortgageService destination as follows: <destination id="mortgageService">
<properties>
<factory>spring</factory>
<source>mortgageBean</source>
</properties>
</destination>Notice that we use the spring factory defined above (see “Registerthe Spring Factory”), and we provide the name of the Spring bean asdefined in applicationContext.xml as the source. Step 4: Run the Client Application Open {context-root}\mortgage\MortgageCalc.mxml in a code editor tofamiliarize yourself with the application. Notice that the RemoteObjectdestination is the mortgageService destination defined above. Open a browser, acceshttp://host:port/context-root/mortgage/MortgageCalc.mxml, and test theapplication: Enter a loan amount and click “Calculate” to get themonthly payment for a 30 year mortgage. Note: that there is a delay the first time you access an applicationin this manner. This is because we are using the web compiler whichcompiles your application into bytecode the first time it is accessed(similar to the JSP compilation model). Subsequent requests to the sameapplication will be much faster since the application is alreadycompiled. In a production environment, you would typically deployapplications that have already been compiled using the Flex compileravailable as a command-line utility or fully integrated in FlexBuilder(the Eclipse-based development environment for Flex).
Depending on your configuration, you may need to increase the heap size of your application server’s JVM to use the web compiler.This would not be required in a production environment since youtypically don’t use the web compiler. If you get ajava.lang.OutOfMemoryError exception while trying to access a samplefor the first time, you must increase your heap size. Alternatively,you can compile the application using FlexBuilder or the command linecompiler.
Example 2: Store/Inventory Management using Flex RemotingThis second example is more sophisticated and includes databaseconnectivity. To keep the application simple and avoid dependencies onother products or frameworks, the Spring JDBC abstraction framework isused to access the database. You could use the Spring support for ORMdata access (using Hibernate, JDO, Oracle TopLink, iBATIS, or JPA) asan alternative: the specific Spring data access strategy you choose hasno impact on the Flex/Spring integration. We use an embedded HSQLDBdatabase: the only installation requirement is to copy the HSQLDBdriver in your web application classpath (see below). The applicationhas two modules: a database maintenance module, and a customer-facingproduct catalog with filtering capabilities.
Step 1: Copy the application files Copy hsqldb.jar to {context-root}\WEB-INF\lib. You can download the hsqldb driver at http://www.hsqldb.org/. Copy ProductDAO.class, SimpleProductDAO.class,SimpleProductDAO$1.class, and Product.class fromflex-spring-sdk\bin\flex\samples\spring\store to{context-root}\WEB-INF\classes\flex\samples\spring\store Copy admin.mxml, ProductForm.mxml, store.mxml, Thumb.mxml,AnimatedTileList.as, Product.as, logo.jpg, store.css and the picdirectory from flex-spring-sdk\flex\store to {context-root}\store Step 2: Register Spring Beans Before registering the Spring beans for this application, openProductDAO.java, SimpleProductDAO.java and Product.java inflex-spring-sdk\src\flex\samples\spring\store to familiarize yourselfwith the source code. Notice that SimpleProductDAO extendsorg.springframework.jdbc.core.support.JdbcDaoSupport. JdbcDaoSupporthas a dependency to a javax.sql.DataSource object (javax.sql.DataSourceis an interface). Register the dataSource and productDAOBean beans in applicationContext.xml as follows: <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
<property value="org.hsqldb.jdbcDriver" name="driverClassName">
<property value="jdbc:hsqldb:/flex-spring-sdk/db/store" name="url">
<property value="sa" name="username">
<property value="" name="password">
</property>

<bean class="flex.samples.spring.store.SimpleProductDAO" id="productDAOBean">
<property ref="dataSource" name="dataSource">
</property> </bean></property> </property> </property> </bean>Note: If you didn’t unzip flex-spring-sdk in your root directory, adjust the JDBC url accordingly. Step 3: Configure the Flex Remoting Destination Open remoting-config.xml in {context-root}\WEB-INF\flex. Add the productService destination as follows: <destination id="productService">
<properties>
<factory>spring</factory>
<source>productDAOBean</source>
</properties>
</destination> Step 4: Run the Client ApplicationTest the database maintenance module:
Open {context-root}\store\admin.mxml in a code editor and familiarize yourself with the application. Open a browser, access http://host:port/context-root/store/admin.mxml, and test the application. Test the store module:
Open {context-root}\store\store.mxml in a code editor and familiarize yourself with the application. Open a browser, access http://host:port/context-root/store/store.mxml, and test the application. Example 3: Data Management ServicesIn addition to the RPC services used in examples 1 and 2 above, theFlex Data Management Services provide an innovative and very productiveapproach to synchronize data between the client and the middle-tier.The Flex Data Management Services consist of a client-side API andserver-side services:
At the client-side, "managed objects" keep track of changes made tothe data, and notify the back-end of these changes. You don’t have tokeep track of changes made to the data, nor do you have to invokeremote services to notify the back-end of the changes (create, update,delete) made at the client side. At the server-side, the Data Service receives the list of changesand passes it to your server-side persistence components. The DataService also pushes the changes to other clients. This application provides an example of using the Flex Data Management Services with the Spring IoC container.
Note: The Flex Data Management Services leverage the JavaTransaction API (JTA). If you are using Tomcat, or another servletcontainer that doesn’t provide a full implementation of the J2EE stack,you have to install a JTA implementation such as JOTM to run thisexample. Click here for more information.
Step 1: Copy the application files Copy ProductAssembler.class fromflex-spring-sdk\bin\flex\samples\spring\store to{context-root}\WEB-INF\classes\flex\samples\spring\store Copy dms.mxml and Product.as from flex-spring-sdk\flex\dms to {context-root}\dms Step 2: Register Spring Beans Open ProductAssembler.java in a code editor. Notice that ProductAssembler has a dependency to a ProductDAO object. Register the productAssemblerBean in applicationContext.xml as follows:<bean class="flex.samples.spring.store.ProductAssembler" id="productAssemblerBean">
<property ref="productDAOBean" name="productDAO">
</property> </bean> Step 3: Configure the Flex Data Management Services Destination Open data-management-config.xml in {context-root}\WEB-INF\flex. Add the product destination as follows:<destination id="product">
<adapter ref="java-dao">
<properties>
<source>productAssemblerBean</source>
<factory>spring</factory>

<identity property="productId">
</identity>

</properties> </adapter></destination> Step 4: Run the Client Application Open {context-root}\dms\dms.mxml in a code editor and familiarize yourself with the application. Open a browser, access http://host:port/context-root/dms/dms.mxml, and test the application.