来源：  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 id="spring" class="flex.samples.factories.SpringFactory"/>
      </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: <?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 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 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 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 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.

  

hei hei ,wo bu shi gu yi de

u r cool

你就不兴花点功夫翻译过来哟

什么是春节？春节是一个最流行的的Java框架。该基金会之春框架是一个轻量级容器thatimplements组成部分的反转控制（国际奥委会）的模式。

使用IoC容器，组件不实例，甚至期待uptheir相依（物体与他们的工作） 。集装箱isresponsible注入那些依赖关系时，它创造thecomponents （因此术语“依赖注入”也被用来describethis模式） 。

其结果是松散的耦合元件。春节IoCcontainer已被证明是一个坚实的基础建设robustenterprise应用。这些组件管理的春季IoCcontainer被称为春季豆类。

春节框架包括其他几个模块除了巨资核心IoC容器。这些模块中没有涉及这个documenteven尽管我们将利用春节JDBC抽象框架inexamples第2和第3如下。更多信息春季框架可以在http://www.springframework.org befound 。

什么是弹性？软硬度提供了一个完整的解决方案，建立丰富的互联网应用。的Flex编程模型是由：



     *动作，一个的ECMAScript标准，面向对象的程序设计模型。一些句法的差异，动作外观类似Java和支持sameobject为导向的结构：包，类，继承，接口，强大的（但也动态）打字等

     * MXML ：一种基于XML的语言，提供anabstraction顶部的动作，并允许部分申请（通常是视图）建造声明式。

     *广泛的一套一流的图书馆。在线API文档可以在这里文档样的格式。



的Flex源代码（ 。 mxml和。档案）是汇编成Flashbytecode （ 。瑞士法郎）这是在执行客户端的机器Flashvirtual使用即时编译器。

一个完整的讨论Flex是超出了这一文件。您可以找到更多的信息http://www.adobe.com

ai~一看就是直接在google上翻译的。 “春节框架”

晕倒 不会翻译就不要翻译。