2、eclipse或者myeclipse。我是用的是eclipse3.4于MyEclipse7.5。

3、Java Development Kit（JDK），版本1.5以上（包括1.5）。作者使用的是1.6。

4、BlazeDS。我显得是最新版的

5、Tomcat。作者使用的6.0。

（关于开发环境的安装和配置，就不在此絮叨了，网上N多，请百度或Google）

现在就开始了；
1.将Spring的jar包拷贝到WEB-INF的lib下；
2.在web.xml中注册Spring，如下配置：

 1<!-- Spring configuration file (Not needed if you don't use Spring) -->
 2    <context-param>
 3        <param-name>contextConfigLocation</param-name>
 4        <param-value>/WEB-INF/applicationContext.xml</param-value>
 5    </context-param>
 6
 7<!-- Spring ContextLoaderListener (Not needed if you don't use Spring) -->
 8    <listener>
 9        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
10    </listener>
11
12

 3、增加SpringFactory.java，代码如下（注：此代码是从王大大的blog上复制过来的，请对他表示感谢并请不要告诉他，（没得到的他的同意，请保密））

  1package com.samples.factories;
  2
  3import org.springframework.context.ApplicationContext;
  4import org.springframework.web.context.support.WebApplicationContextUtils;
  5import org.springframework.beans.BeansException;
  6import org.springframework.beans.factory.NoSuchBeanDefinitionException;
  7
  8import flex.messaging.FactoryInstance;
  9import flex.messaging.FlexFactory;
 10import flex.messaging.config.ConfigMap;
 11import flex.messaging.services.ServiceException;
 12
 13/** *//**
 14 * This interface is implemented by factory components which provide
 15 * instances to the flex messaging framework.  To configure flex data services
 16 * to use this factory, add the following lines to your services-config.xml
 17 * file (located in the WEB-INF/flex directory of your web application).
 18 *
 19 * &lt;factories&gt;
 20 *     &lt;factory id="spring" class="flex.samples.factories.SpringFactory" /&gt;
 21 *  &lt;/factories&gt;
 22 *
 23 * You also must configure the web application to use spring and must copy the spring.jar
 24 * file into your WEB-INF/lib directory.  To configure your app server to use spring,
 25 * you add the following lines to your WEB-INF/web.xml file:
 26 *
 27 *   &lt;context-param&gt;
 28 *        &lt;param-name&gt;contextConfigLocation&lt;/param-name&gt;
 29 *        &lt;param-value&gt;/WEB-INF/applicationContext.xml&lt;/param-value&gt;
 30 *   &lt;/context-param&gt;
 31 *
 32 *   &lt;listener&gt;
 33 *       &lt;listener-class&gt;org.springframework.web.context.ContextLoaderListener&lt;/listener-class&gt;
 34 *   &lt;/listener&gt;
 35 * 
 36 * Then you put your spring bean configuration in WEB-INF/applicationContext.xml (as per the
 37 * line above).  For example:
 38 * 
 39 *  &lt;?xml version="1.0" encoding="UTF-8"?&gt;
 40 *  &lt;!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"&gt;
 41 *   
 42 *  &lt;beans&gt;
 43 *    &lt;bean name="weatherBean" class="dev.weather.WeatherService" singleton="true"/&gt;
 44 *  &lt;/beans&gt;
 45 *  
 46 * Now you are ready to define a destination in flex that maps to this existing service. 
 47 * To do this you'd add this to your WEB-INF/flex/remoting-config.xml:
 48 *
 49 *  &lt;destination id="WeatherService"&gt;
 50 *      &lt;properties&gt;
 51 *          &lt;factory&gt;spring&lt;/factory&gt;
 52 *          &lt;source&gt;weatherBean&lt;/source&gt;
 53 *      &lt;/properties&gt;
 54 *  &lt;/destination&gt;
 55 *
 56 * @author Jeff Vroom
 57 */
 58public class SpringFactory implements FlexFactory
 59{
 60    private static final String SOURCE = "source";
 61
 62    /** *//**
 63     * This method can be used to initialize the factory itself.  It is called with configuration
 64     * parameters from the factory tag which defines the id of the factory.  
 65     */
 66    public void initialize(String id, ConfigMap configMap) {}
 67
 68    /** *//**
 69     * This method is called when we initialize the definition of an instance 
 70     * which will be looked up by this factory.  It should validate that
 71     * the properties supplied are valid to define an instance.
 72     * Any valid properties used for this configuration must be accessed to 
 73     * avoid warnings about unused configuration elements.  If your factory 
 74     * is only used for application scoped components, this method can simply
 75     * return a factory instance which delegates the creation of the component
 76     * to the FactoryInstance's lookup method.
 77     */
 78    public FactoryInstance createFactoryInstance(String id, ConfigMap properties)
 79    {
 80        SpringFactoryInstance instance = new SpringFactoryInstance(this, id, properties);
 81        instance.setSource(properties.getPropertyAsString(SOURCE, instance.getId()));
 82        System.out.println("SpringSpringSpring" + instance.toString());
 83        return instance;
 84    } // end method createFactoryInstance()
 85
 86    /** *//**
 87     * Returns the instance specified by the source
 88     * and properties arguments.  For the factory, this may mean
 89     * constructing a new instance, optionally registering it in some other
 90     * name space such as the session or JNDI, and then returning it
 91     * or it may mean creating a new instance and returning it.
 92     * This method is called for each request to operate on the
 93     * given item by the system so it should be relatively efficient.
 94     * <p>
 95     * If your factory does not support the scope property, it
 96     * report an error if scope is supplied in the properties
 97     * for this instance.
 98     */
 99    public Object lookup(FactoryInstance inst)
100    {
101        SpringFactoryInstance factoryInstance = (SpringFactoryInstance) inst;
102        return factoryInstance.lookup();
103    } 
104
105
106    static class SpringFactoryInstance extends FactoryInstance
107    {
108        SpringFactoryInstance(SpringFactory factory, String id, ConfigMap properties)
109        {
110            super(factory, id, properties);
111        }
112
113
114        public String toString()
115        {
116            return "SpringFactory instance for id=" + getId() + " source=" + getSource() + " scope=" + getScope();
117        }
118
119        public Object lookup() 
120        {
121            ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(flex.messaging.FlexContext.getServletConfig().getServletContext());
122            String beanName = getSource();
123
124            try
125            {
126                return appContext.getBean(beanName);
127            }
128            catch (NoSuchBeanDefinitionException nexc)
129            {
130                ServiceException e = new ServiceException();
131                String msg = "Spring service named '" + beanName + "' does not exist.";
132                e.setMessage(msg);
133                e.setRootCause(nexc);
134                e.setDetails(msg);
135                e.setCode("Server.Processing");
136                throw e;
137            }
138            catch (BeansException bexc)
139            {
140                ServiceException e = new ServiceException();
141                String msg = "Unable to create Spring service named '" + beanName + "' ";
142                e.setMessage(msg);
143                e.setRootCause(bexc);
144                e.setDetails(msg);
145                e.setCode("Server.Processing");
146                throw e;
147            } 
148        }
149        
150    } 
151
152} 
153

4.在services-config.xml中注册SpringFacotry，配置如下： 

1<factories>
2     <factory id="spring" class="com.samples.factories.SpringFactory"/>
3    </factories>
4
5

5.接下来就要在applicationContext.mxl中注册helloJavaFlexBean，配置如下

1<bean id="helloJavaFlexBean" class="com.test.HelloJavaFlex">
2    </bean>

6.在remoting-config.xml中将SpringBean公开给Flex客户端，配置如下：

1<destination id="helloJavaFlex"> 
2    <properties>
3      <factory>spring</factory>
4      <source>helloJavaFlexBean</source>
5     </properties>
6    </destination>

至此flex于spring的整合就ok。如果你有看王大大blog，那么你将获取相关的一些demo。解下来就是与hibernate的整合了
7.把Hibernate相关jar包拷贝到WEB-INF的lib下
8.添加hibernate.cfg.xml文件到src下
9.在applicationContext.xml中配置，通过Spring方式整合Hibernate

1<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
2        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
3    </bean>

10.增加Hibernate的对象映射文件，User.hbm.xml

 1<?xml version="1.0" encoding="utf-8"?>
 2<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4<!-- 
 5    Mapping file autogenerated by MyEclipse Persistence Tools
 6-->
 7<hibernate-mapping>
 8    <class name="com.model.User" table="user" catalog="test">
 9        <id name="id" type="java.lang.Integer">
10            <column name="id" />
11            <generator class="native" />
12        </id>
13        <property name="username" type="java.lang.String">
14            <column name="username" />
15        </property>
16        <property name="password" type="java.lang.String">
17            <column name="password" />
18        </property>
19    </class>
20</hibernate-mapping>
21

11.在applicationContext.xml中配置Dao

1<bean id="userService" class="com.dao.impl.UserDaoImpl" >
2        <property name="sessionFactory" ref="sessionFactory"></property>
3    </bean>

这样flex和spring和hibernate就整合好了。

读者在读取上面的文章如果觉得很乱的话，可先请阅读王大大的文章后再来看作者的文章。
我会将我demo上传，大家可以下载
（注意在放整合是hibernate和spring的jar中有重复请自行排除重复的jar包，不过请一定注意对于asm.jar和asm-2.2.3.jar请排除asm-2.2.3.jar，作者在整合是根据jar版本排除时，先是留的asm_2.2.3.jar，结果启动tomcat报错：NoClassDefFoundError: org/objectweb/asm/Type ，将asm.jar重新拷回，排除asm_2.2.3.jar后运行tomgcat通过（orz，人品问题吧））

http://www.rayfile.com/files/8864c370-6656-11df-b657-0015c55db73d/ 这个是我的demo的下载链接。