- 浏览: 99214 次
- 性别:
- 来自: 上海
文章分类
最新评论
-
heihei2005:
灰常好!谢谢!
进行需求调研时的注意事项 -
yinzhiyan:
就这么点啊
数据结构 -
jeho0815:
这也太简陋了吧!。。。。
Prototype模式(原形模式) -
shanghui_12:
功能是挺齐备的,能否给个测试地址看看?
截至到2008的圣诞节,saas平台的体系结构已现端倪 -
sdh5724:
amoeba 马上要上线了, 我们测试了1个多月了。 基本稳定 ...
saas中分布式DB存储问题--草稿版
Using Flex with Spring
----on detail,please see :http://coenraets.org/flex-spring/
UPDATE (1/12/2007): I put together a Tomcat-based Test Drive Server that includes the samples described below running out-of-the box. Read this post for more info.
What is Spring?
Spring is one of the most popular Java frameworks. The foundation of the Spring framework is a lightweight component container that implements the Inversion of Control (IoC) pattern.
Using an IoC container, components don’t instantiate or even look up their dependencies (the objects they work with). The container is responsible for injecting those dependencies when it creates the components (hence the term “Dependency Injection” also used to describe this pattern).
The result is looser coupling between components. The Spring IoC container has proven to be a solid foundation for building robust enterprise applications. The components managed by the Spring IoC container are called Spring beans.
The Spring framework includes several other modules in addition to its core IoC container. These modules are not covered in this document even though we will be using the Spring JDBC abstraction framework in examples 2 and 3 below. More information on the Spring framework can be found 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 same object-oriented constructs: packages, classes, inheritance, interfaces, strong (but also dynamic) typing etc.
MXML: an XML-based language that provides an abstraction 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 Flash bytecode (.swf) that is executed at the client-side by the Flash virtual 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 HTTP requests to a server, and consume the response. Although the HTTPService is typically used to consume XML, it can be used to consume other types of responses. The Flex HTTPService is similar to the XMLHttpRequest component available in Ajax.
You can use the WebService component to invoke SOAP-based web services.
You can use the RemoteObject component to directly invoke methods of Java objects deployed in your application server, and consume the return value. The return value can be a value of a primitive data type, an object, a collection of objects, an object graph, etc. In distributed computing terminology, this approach is generally 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 Services provide an innovative and virtually code-free approach to synchronize data between the client application and the middle-tier.
In this document, we focus on the Remoting (3) and Data Management Services (4) approaches described above because they enable the tightest integration with Spring. There is no need to transform data, or to expose services in a certain way: the Flex application works directly 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 Spring beans are Java objects, aren’t we all set and ready to start accessing Spring beans from Flex clients? Almost… There is one simple element to configure.
The whole idea behind Spring IoC is to let the container instantiate components (and inject their dependencies). By default, however, components accessed remotely by a Flex client are instantiated by Flex destinations at the server-side. The key to the Flex/Spring integration is therefore to configure the Flex destinations to let the Spring container take care of instantiating Spring beans. The Flex Data Services support the concept of factory to enable this type of custom component instantiation. The role of a factory is simply to provide ready-to-use instances of components to a Flex destination (instead of letting the Flex destination instantiate these components itself).
The supporting files available with this document include a factory class (SpringFactory) that provides Flex destinations with fully initialized (dependency-injected) instances of Spring beans. Note: The SpringFactory was developed by Jeff Vroom (Flex Data Services architect) and is also available on Adobe Exchange.
The remaining of this article describes how to configure your web application to use Flex and Spring, how to configure the Spring Factory, and how to put the pieces together and start invoking Spring beans from Flex applications.
Setting Up your Web Application to Use Flex and Spring
Step 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 Services
To use the Remoting and Data Management Services data access strategies described above, you need to install the Flex Data Services. If you haven’t already done so, you can download the Flex Data Services here, 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 web application 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 Spring
Note: 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 Spring 2.0. However the integration approach described in this document (and the SpringFactory class) should work fine using Spring 1.2.8 (some of the 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 and SpringFactory$SpringFactoryInstance.class from flex-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 id="spring" class="flex.samples.factories.SpringFactory"/>
</factories>Example 1: Mortgage Calculator Using Flex Remoting
This first application is intentionally simplistic in its functionality to provide an uncluttered example of wiring Spring beans together and invoking them from a Flex application.
Step 1: Copy the application files
Copy RateFinder.class, SimpleRateFinder.class, and Mortgage.class from 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, open RateFinder.java, SimpleRateFinder.java and Mortgage.java in flex-spring-sdk\src\flex\samples\spring\mortgage to familiarize yourself with the source code. Notice that Mortgage has a dependency to a RateFinder object. Mortgage doesn’t instantiate a RateFinder object itself, doesn’t lookup up for a RateFinder object, and doesn’t even know the exact type of the object it will be dealing with (RateFinder is an inteface). An instance of a class implementing the RateFinder interface will be injected by the container (using the setRateFinder method) 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:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="rateFinderBean" class="flex.samples.spring.mortgage.SimpleRateFinder"/>
<bean id="mortgageBean" class="flex.samples.spring.mortgage.Mortgage">
<property name="rateFinder" ref="rateFinderBean"/>
</bean>
</beans>Notice that in the mortgageBean definition, we tell the container how to inject the rateFinder dependency: the rateFinder property is mapped to rateFinderBean which defines an instance of the SimpleRateFinder 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 “Register the Spring Factory”), and we provide the name of the Spring bean as defined in applicationContext.xml as the source.
Step 4: Run the Client Application
Open {context-root}\mortgage\MortgageCalc.mxml in a code editor to familiarize yourself with the application. Notice that the RemoteObject destination is the mortgageService destination defined above.
Open a browser, access http://host:port/context-root/mortgage/MortgageCalc.mxml, and test the application: Enter a loan amount and click “Calculate” to get the monthly payment for a 30 year mortgage.
Note: that there is a delay the first time you access an application in this manner. This is because we are using the web compiler which compiles your application into bytecode the first time it is accessed (similar to the JSP compilation model). Subsequent requests to the same application will be much faster since the application is already compiled. In a production environment, you would typically deploy applications that have already been compiled using the Flex compiler available 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 you typically don’t use the web compiler. If you get a java.lang.OutOfMemoryError exception while trying to access a sample for the first time, you must increase your heap size. Alternatively, you can compile the application using FlexBuilder or the command line compiler.
Example 2: Store/Inventory Management using Flex Remoting
This second example is more sophisticated and includes database connectivity. To keep the application simple and avoid dependencies on other products or frameworks, the Spring JDBC abstraction framework is used to access the database. You could use the Spring support for ORM data access (using Hibernate, JDO, Oracle TopLink, iBATIS, or JPA) as an alternative: the specific Spring data access strategy you choose has no impact on the Flex/Spring integration. We use an embedded HSQLDB database: the only installation requirement is to copy the HSQLDB driver in your web application classpath (see below). The application has two modules: a database maintenance module, and a customer-facing product 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 from flex-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 pic directory from flex-spring-sdk\flex\store to {context-root}\store
Step 2: Register Spring Beans
Before registering the Spring beans for this application, open ProductDAO.java, SimpleProductDAO.java and Product.java in flex-spring-sdk\src\flex\samples\spring\store to familiarize yourself with the source code. Notice that SimpleProductDAO extends org.springframework.jdbc.core.support.JdbcDaoSupport. JdbcDaoSupport has a dependency to a javax.sql.DataSource object (javax.sql.DataSource is an interface).
Register the dataSource and productDAOBean beans in applicationContext.xml as follows:
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="org.hsqldb.jdbcDriver"/>
<property name="url" value="jdbc:hsqldb:/flex-spring-sdk/db/store"/>
<property name="username" value="sa"/>
<property name="password" value=""/>
</bean>
<bean id="productDAOBean" class="flex.samples.spring.store.SimpleProductDAO">
<property name="dataSource" ref="dataSource"/>
</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 Application
Test 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 Services
In addition to the RPC services used in examples 1 and 2 above, the Flex Data Management Services provide an innovative and very productive approach to synchronize data between the client and the middle-tier. The Flex Data Management Services consist of a client-side API and server-side services:
At the client-side, "managed objects" keep track of changes made to the data, and notify the back-end of these changes. You don’t have to keep track of changes made to the data, nor do you have to invoke remote 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 changes and passes it to your server-side persistence components. The Data Service 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 Java Transaction API (JTA). If you are using Tomcat, or another servlet container that doesn’t provide a full implementation of the J2EE stack, you have to install a JTA implementation such as JOTM to run this example. Click here for more information.
Step 1: Copy the application files
Copy ProductAssembler.class from flex-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 id="productAssemblerBean" class="flex.samples.spring.store.ProductAssembler">
<property name="productDAO" ref="productDAOBean"/>
</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>
<metadata>
<identity property="productId"/>
</metadata>
</properties>
</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.
----on detail,please see :http://coenraets.org/flex-spring/
UPDATE (1/12/2007): I put together a Tomcat-based Test Drive Server that includes the samples described below running out-of-the box. Read this post for more info.
What is Spring?
Spring is one of the most popular Java frameworks. The foundation of the Spring framework is a lightweight component container that implements the Inversion of Control (IoC) pattern.
Using an IoC container, components don’t instantiate or even look up their dependencies (the objects they work with). The container is responsible for injecting those dependencies when it creates the components (hence the term “Dependency Injection” also used to describe this pattern).
The result is looser coupling between components. The Spring IoC container has proven to be a solid foundation for building robust enterprise applications. The components managed by the Spring IoC container are called Spring beans.
The Spring framework includes several other modules in addition to its core IoC container. These modules are not covered in this document even though we will be using the Spring JDBC abstraction framework in examples 2 and 3 below. More information on the Spring framework can be found 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 same object-oriented constructs: packages, classes, inheritance, interfaces, strong (but also dynamic) typing etc.
MXML: an XML-based language that provides an abstraction 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 Flash bytecode (.swf) that is executed at the client-side by the Flash virtual 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 HTTP requests to a server, and consume the response. Although the HTTPService is typically used to consume XML, it can be used to consume other types of responses. The Flex HTTPService is similar to the XMLHttpRequest component available in Ajax.
You can use the WebService component to invoke SOAP-based web services.
You can use the RemoteObject component to directly invoke methods of Java objects deployed in your application server, and consume the return value. The return value can be a value of a primitive data type, an object, a collection of objects, an object graph, etc. In distributed computing terminology, this approach is generally 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 Services provide an innovative and virtually code-free approach to synchronize data between the client application and the middle-tier.
In this document, we focus on the Remoting (3) and Data Management Services (4) approaches described above because they enable the tightest integration with Spring. There is no need to transform data, or to expose services in a certain way: the Flex application works directly 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 Spring beans are Java objects, aren’t we all set and ready to start accessing Spring beans from Flex clients? Almost… There is one simple element to configure.
The whole idea behind Spring IoC is to let the container instantiate components (and inject their dependencies). By default, however, components accessed remotely by a Flex client are instantiated by Flex destinations at the server-side. The key to the Flex/Spring integration is therefore to configure the Flex destinations to let the Spring container take care of instantiating Spring beans. The Flex Data Services support the concept of factory to enable this type of custom component instantiation. The role of a factory is simply to provide ready-to-use instances of components to a Flex destination (instead of letting the Flex destination instantiate these components itself).
The supporting files available with this document include a factory class (SpringFactory) that provides Flex destinations with fully initialized (dependency-injected) instances of Spring beans. Note: The SpringFactory was developed by Jeff Vroom (Flex Data Services architect) and is also available on Adobe Exchange.
The remaining of this article describes how to configure your web application to use Flex and Spring, how to configure the Spring Factory, and how to put the pieces together and start invoking Spring beans from Flex applications.
Setting Up your Web Application to Use Flex and Spring
Step 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 Services
To use the Remoting and Data Management Services data access strategies described above, you need to install the Flex Data Services. If you haven’t already done so, you can download the Flex Data Services here, 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 web application 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 Spring
Note: 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 Spring 2.0. However the integration approach described in this document (and the SpringFactory class) should work fine using Spring 1.2.8 (some of the 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 and SpringFactory$SpringFactoryInstance.class from flex-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 id="spring" class="flex.samples.factories.SpringFactory"/>
</factories>Example 1: Mortgage Calculator Using Flex Remoting
This first application is intentionally simplistic in its functionality to provide an uncluttered example of wiring Spring beans together and invoking them from a Flex application.
Step 1: Copy the application files
Copy RateFinder.class, SimpleRateFinder.class, and Mortgage.class from 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, open RateFinder.java, SimpleRateFinder.java and Mortgage.java in flex-spring-sdk\src\flex\samples\spring\mortgage to familiarize yourself with the source code. Notice that Mortgage has a dependency to a RateFinder object. Mortgage doesn’t instantiate a RateFinder object itself, doesn’t lookup up for a RateFinder object, and doesn’t even know the exact type of the object it will be dealing with (RateFinder is an inteface). An instance of a class implementing the RateFinder interface will be injected by the container (using the setRateFinder method) 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:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="rateFinderBean" class="flex.samples.spring.mortgage.SimpleRateFinder"/>
<bean id="mortgageBean" class="flex.samples.spring.mortgage.Mortgage">
<property name="rateFinder" ref="rateFinderBean"/>
</bean>
</beans>Notice that in the mortgageBean definition, we tell the container how to inject the rateFinder dependency: the rateFinder property is mapped to rateFinderBean which defines an instance of the SimpleRateFinder 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 “Register the Spring Factory”), and we provide the name of the Spring bean as defined in applicationContext.xml as the source.
Step 4: Run the Client Application
Open {context-root}\mortgage\MortgageCalc.mxml in a code editor to familiarize yourself with the application. Notice that the RemoteObject destination is the mortgageService destination defined above.
Open a browser, access http://host:port/context-root/mortgage/MortgageCalc.mxml, and test the application: Enter a loan amount and click “Calculate” to get the monthly payment for a 30 year mortgage.
Note: that there is a delay the first time you access an application in this manner. This is because we are using the web compiler which compiles your application into bytecode the first time it is accessed (similar to the JSP compilation model). Subsequent requests to the same application will be much faster since the application is already compiled. In a production environment, you would typically deploy applications that have already been compiled using the Flex compiler available 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 you typically don’t use the web compiler. If you get a java.lang.OutOfMemoryError exception while trying to access a sample for the first time, you must increase your heap size. Alternatively, you can compile the application using FlexBuilder or the command line compiler.
Example 2: Store/Inventory Management using Flex Remoting
This second example is more sophisticated and includes database connectivity. To keep the application simple and avoid dependencies on other products or frameworks, the Spring JDBC abstraction framework is used to access the database. You could use the Spring support for ORM data access (using Hibernate, JDO, Oracle TopLink, iBATIS, or JPA) as an alternative: the specific Spring data access strategy you choose has no impact on the Flex/Spring integration. We use an embedded HSQLDB database: the only installation requirement is to copy the HSQLDB driver in your web application classpath (see below). The application has two modules: a database maintenance module, and a customer-facing product 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 from flex-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 pic directory from flex-spring-sdk\flex\store to {context-root}\store
Step 2: Register Spring Beans
Before registering the Spring beans for this application, open ProductDAO.java, SimpleProductDAO.java and Product.java in flex-spring-sdk\src\flex\samples\spring\store to familiarize yourself with the source code. Notice that SimpleProductDAO extends org.springframework.jdbc.core.support.JdbcDaoSupport. JdbcDaoSupport has a dependency to a javax.sql.DataSource object (javax.sql.DataSource is an interface).
Register the dataSource and productDAOBean beans in applicationContext.xml as follows:
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="org.hsqldb.jdbcDriver"/>
<property name="url" value="jdbc:hsqldb:/flex-spring-sdk/db/store"/>
<property name="username" value="sa"/>
<property name="password" value=""/>
</bean>
<bean id="productDAOBean" class="flex.samples.spring.store.SimpleProductDAO">
<property name="dataSource" ref="dataSource"/>
</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 Application
Test 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 Services
In addition to the RPC services used in examples 1 and 2 above, the Flex Data Management Services provide an innovative and very productive approach to synchronize data between the client and the middle-tier. The Flex Data Management Services consist of a client-side API and server-side services:
At the client-side, "managed objects" keep track of changes made to the data, and notify the back-end of these changes. You don’t have to keep track of changes made to the data, nor do you have to invoke remote 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 changes and passes it to your server-side persistence components. The Data Service 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 Java Transaction API (JTA). If you are using Tomcat, or another servlet container that doesn’t provide a full implementation of the J2EE stack, you have to install a JTA implementation such as JOTM to run this example. Click here for more information.
Step 1: Copy the application files
Copy ProductAssembler.class from flex-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 id="productAssemblerBean" class="flex.samples.spring.store.ProductAssembler">
<property name="productDAO" ref="productDAOBean"/>
</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>
<metadata>
<identity property="productId"/>
</metadata>
</properties>
</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.
发表评论
-
quarter----转摘
2007-12-29 11:28 1060spring+quartz配置 一个Cron ... -
ehcache在spring+ hibernate中的配置
2007-12-26 13:31 1484大量数据流动是web应用性能问题常见的原因,而缓存被广泛的用于 ... -
cache--hibernate
2007-12-07 13:51 861哎。。。。。。。。。。。。。。 系统开发完毕,不上线不知道。上 ... -
乐观锁的实现
2007-12-07 11:51 1038hibernate推荐使用version来处理。 废话就不多说 ... -
cascade属性的用法
2007-12-07 11:35 1820cascade= none ... -
数据检索策略
2007-12-07 11:16 1154检索策略: 立即检索 延迟检索 预先抓取 批量立即加载 批 ... -
iframe与主窗口传递参数----搞笑
2007-06-08 10:20 3497我在我的主窗口隐藏值: <!-- <inpu ...
相关推荐
spring-flex-reference.pdf spring与flex的集成
很好的spring与FLEX集成例子,深层FLEX应用,例子简单易懂
hibernate+flex+spring 整合,hibernate+flex+spring 集成
SBI 项目是 SpringSource 发布的开源项目, 它是目前比较成熟的用于集成 Flex 和 Spring 的方法。
flex与spring集成详解
JBoss作为应用服务器、MySQL作为数据存储、Hibernate完成数据访问、Spring用来构建业务层、BlazeDS作为远程服务、 Flex用来构建富客户端,使用Maven及flex-...,打造全栈式Flex、BlazeDS和Spring 集成解决方案...
flex blazeds spring集成。该DEMO演示FLEX如何通过SPRING控制通信。
博文链接:https://xiaotian-ls.iteye.com/blog/229194
flex与spring的集成工程源码,内有flex端与java服务端源代码及tomcat下可运行工程包,是学习flex与spring集成的好助手
FLEX和Spring、Hibernate的集成 - Flex+Spring
adobe公司和spring公司共同开发出来的JAR包,目的是为了spring和flex集成起来更容易
Pro Flex on Spring 是一本关于建设富互联网应用程序的好书,本书讲解了具备强大用户体验的Adobe Flex与Spring框架的集成。
前言:本讲是继【第三讲:WEB项目-集成Flex3+BlazeDS3.2+Spring2.5.6】后,介绍另外一种集成方式; 集成方式二:采用Spring侦听配置模式 目标:实现集成方式二 优点: 1、一个应用可以满足多种请求 2、易于集成...
FLEX和spring、hibernate的集成 FLEX和spring、hibernate的集成 FLEX和spring、hibernate的集成
flex与+struts2+hibernate+spring集成实例项目,源码奉献,物有所值
NULL 博文链接:https://fruitking.iteye.com/blog/684427
flex4 spring3 集成项目非常详细的开发过程文档。
flex ,java, spring 如何集成为一个工程的开发步骤,有截图。给需要的朋友。
通过这篇文章,您能清晰地了解由 Flex、Spring、Hibernate 集成的 RIA 应用框架的技术细节以及怎样使用该框架开发具体的应用。