跟我StepByStep学FLEX教程－－－－－－FLEX和Spring整合

核心提示： 这个大家可能觉得很抽象，其实现在大家应该都接触过，跟我StepByStep学FLEX教程－－－－－－FLEX和Spring整合(2)，作者举两个例子：一个是WebWork框架的Intecepor就是AOP的应用；再一个大家更熟悉了，J2EE系统的Log4j的日志系统对于读者做的系统来说就是一个A

这个大家可能觉得很抽象，其实现在大家应该都接触过，作者举两个例子：一个是WebWork框架的Intecepor就是AOP的应用；再一个大家更熟悉了，J2EE系统的Log4j的日志系统对于读者做的系统来说就是一个AOP。

切面切面，就是一个截面，所做的程序不对现有系统进行破坏，但是随时可以打开关闭，这么理解就是很通俗通俗的理解了。

这儿就简单提及一下，因为主要还是讲Flex和Spring的整合，读者就一步一步来做吧：）

呵呵，大家觉得Spring的概念容易理解了吧：）

Flex和Spring的整合：

1、将Spring的jar包拷贝到WEB-INF的lib下；（这个是必须的，否则怎么整合Spring）

2、在web.xml中注册Spring，如下配置：

<!-- Spring configuration file (Not needed if you don't use Spring) -->
　　　 <context-param>
　　　　　　　 <param-name>contextConfigLocation</param-name>
　　　　　　　 <param-value>/WEB-INF/applicationContext.xml</param-value>
　　　 </context-param>

<!-- Spring ContextLoaderListener (Not needed if you don't use Spring) -->
　　　 <listener>
　　　　　　　 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
　　　 </listener>

3、增加SpringFactory.java，代码如下：

package com.samples.factories;

import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;

import flex.messaging.FactoryInstance;
import flex.messaging.FlexFactory;
import flex.messaging.config.ConfigMap;
import flex.messaging.services.ServiceException;

/**
　* This interface is implemented by factory components which provide
　* instances to the flex messaging framework.　 To configure flex data services
　* to use this factory, add the following lines to your services-config.xml
　* file (located in the WEB-INF/flex directory of your web application).
　*
　*　<factories>
　*　　　　 <factory id="spring" class="flex.samples.factories.SpringFactory" />
　*　 </factories>
　*
　* You also must configure the web application to use spring and must copy the spring.jar
　* file into your WEB-INF/lib directory.　 To configure your app server to use spring,
　* you add the following lines to your WEB-INF/web.xml file:
　*
　*　　 <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>
　*
　* Then you put your spring bean configuration in WEB-INF/applicationContext.xml (as per the
　* line above).　 For example:
　*
　*　 <?xml version="1.0" encoding="UTF-8"?>
　*　 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
　*　　
　*　 <beans>
　*　　　 <bean name="weatherBean" class="dev.weather.WeatherService" singleton="true"/>
　*　 </beans>
　*　
　* Now you are ready to define a destination in flex that maps to this existing service.
　* To do this you'd add this to your WEB-INF/flex/remoting-config.xml:
　*
　*　 <destination id="WeatherService">
　*　　　　　 <properties>
　*　　　　　　　　　 <factory>spring</factory>
　*　　　　　　　　　 <source>weatherBean</source>
　*　　　　　 </properties>
　*　 </destination>
　*
　* @author Jeff Vroom
　*/
public class SpringFactory implements FlexFactory
{
　　　 private static final String SOURCE = "source";

　　　 /**
　　　　 * This method can be used to initialize the factory itself.　 It is called with configuration
　　　　 * parameters from the factory tag which defines the id of the factory.　
　　　　 */
　　　 public void initialize(String id, ConfigMap configMap) {}

　　　 /**
　　　　 * This method is called when we initialize the definition of an instance
　　　　 * which will be looked up by this factory.　 It should validate that
　　　　 * the properties supplied are valid to define an instance.
　　　　 * Any valid properties used for this configuration must be accessed to
　　　　 * avoid warnings about unused configuration elements.　 If your factory
　　　　 * is only used for application scoped components, this method can simply
　　　　 * return a factory instance which delegates the creation of the component
　　　　 * to the FactoryInstance's lookup method.
　　　　 */
　　　 public FactoryInstance createFactoryInstance(String id, ConfigMap properties)
　　　 {
　　　　　　　 SpringFactoryInstance instance = new SpringFactoryInstance(this, id, properties);
　　　　　　　 instance.setSource(properties.getPropertyAsString(SOURCE, instance.getId()));
　　　　　　　 System.out.println("SpringSpringSpring" + instance.toString());
　　　　　　　 return instance;
　　　 } // end method createFactoryInstance()

　　　 /**
　　　　 * Returns the instance specified by the source
　　　　 * and properties arguments.　 For the factory, this may mean
　　　　 * constructing a new instance, optionally registering it in some other
　　　　 * name space such as the session or JNDI, and then returning it
　　　　 * or it may mean creating a new instance and returning it.
　　　　 * This method is called for each request to operate on the
　　　　 * given item by the system so it should be relatively efficient.
　　　　 * <p>
　　　　 * If your factory does not support the scope property, it
　　　　 * report an error if scope is supplied in the properties
　　　　 * for this instance.
　　　　 */
　　　 public Object lookup(FactoryInstance inst)
　　　 {
　　　　　　　 SpringFactoryInstance factoryInstance = (SpringFactoryInstance) inst;
　　　　　　　 return factoryInstance.lookup();
　　　 }


　　　 static class SpringFactoryInstance extends FactoryInstance
　　　 {
　　　　　　　 SpringFactoryInstance(SpringFactory factory, String id, ConfigMap properties)
　　　　　　　 {
　　　　　　　　　　　 super(factory, id, properties);
　　　　　　　 }


　　　　　　　 public String toString()
　　　　　　　 {
　　　　　　　　　　　 return "SpringFactory instance for id=" + getId() + " source=" + getSource() + " scope=" + getScope();
　　　　　　　 }

　　　　　　　 public Object lookup()
　　　　　　　 {
　　　　　　　　　　　 ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(flex.messaging.FlexContext.getServletConfig().getServletContext());
　　　　　　　　　　　 String beanName = getSource();

　　　　　　　　　　　 try
　　　　　　　　　　　 {
　　　　　　　　　　　　　　　 return appContext.getBean(beanName);
　　　　　　　　　　　 }
　　　　　　　　　　　 catch (NoSuchBeanDefinitionException nexc)
　　　　　　　　　　　 {
　　　　　　　　　　　　　　　 ServiceException e = new ServiceException();
　　　　　　　　　　　　　　　 String msg = "Spring service named '" + beanName + "' does not exist.";
　　　　　　　　　　　　　　　 e.setMessage(msg);
　　　　　　　　　　　　　　　 e.setRootCause(nexc);
　　　　　　　　　　　　　　　 e.setDetails(msg);
　　　　　　　　　　　　　　　 e.setCode("Server.Processing");
　　　　　　　　　　　　　　　 throw e;
　　　　　　　　　　　 }
　　　　　　　　　　　 catch (BeansException bexc)
　　　　　　　　　　　 {
　　　　　　　　　　　　　　　 ServiceException e = new ServiceException();
　　　　　　　　　　　　　　　 String msg = "Unable to create Spring service named '" + beanName + "' ";
　　　　　　　　　　　　　　　 e.setMessage(msg);
　　　　　　　　　　　　　　　 e.setRootCause(bexc);
　　　　　　　　　　　　　　　 e.setDetails(msg);
　　　　　　　　　　　　　　　 e.setCode("Server.Processing");
　　　　　　　　　　　　　　　 throw e;
　　　　　　　　　　　 }
　　　　　　　 }
　　　　　　　
　　　 }

}