Spring BlazeDS Integration 1.5.0.RELEASE 试用

 

对比起以前用FlexFactory方法，让MessageBrokerServlet直接从上下文中获得Bean，整合框架更像是一种规范的Spring MVC。MessageBroker作为控制器，从Servlet中分离出来，而且现有的Integeration版本对Spring的支持更加强大。

下载整合框架的包：

BlazeDS 4.0 http://opensource.adobe.com/wiki/display/blazeds/Downloads Binary Distribution版本

Spring BlazeDS Integration 1.5.0.REALSE ： http://www.springsource.org/spring-flex

Spring方面，利用myElcipse 8.0 引用自带的myEclipse库，我这里用的是Spring 3.0.

 

一、各种库引用

 

1.新建项目

File->New->Web Project。建立完毕后，给项目加上适当的Spring库支持，这里就不一一详述。

 

2.导入Spring BlazeDS Integeration库

Window->Preferences->Java->Build Path->User Libraries->New，输入『Spring BlazeDS Integration 1.5.0.RELEASE』。

 

Add JARs,加入下载好后的spring-flex-1.5.0.RELEASW文件内dist的spring-flex-core-1.5.0.RELEASE.jar

 

想了解具体的源代码以及说明文档，可以把其源代码以及doc也配置进去：

Source attachment可以指向src中spring-flex-core-1.5.0.RELEASE.jar解压出来的那个跟目录。

Java Doc可设为spring-flex-1.5.0.RELEASE/docs/api/

 

点击OK

 

3.加入Spring BlazeDS Integeration库引用

这里也不一一详述了。

 

4.加入BlazeDS的库引用

把下载后的blazes-bin-4.0那个文件解压缩后会得到一个blazeds.war，把此文件解压缩到项目的webroot目录下，覆盖原有的所有文件。

 

二、配置框架

 

下载好的BlazeDS框架会为你配置了一个名为MessageBrokerServlet的Servlet，可以在web.xml里面看见。

 

 

	<!-- MessageBroker Servlet -->
	<servlet>
		<servlet-name>MessageBrokerServlet</servlet-name>
		<display-name>MessageBrokerServlet</display-name>
		<servlet-class>flex.messaging.MessageBrokerServlet</servlet-class>
		<init-param>
			<param-name>services.configuration.file</param-name>
			<param-value>/WEB-INF/flex/services-config.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

 

 由于新的Spring BlazeDS 整合框架用的是Spring MVC核心Servlet DispatcherServlet作为前端控制器，并由此控制将请求分派到适合的控制器对象（Controller）。所以，这里将此段代码移除掉，其他相关的引用也同样移除掉。

 

1. 配置DispathcerServlet

 

（这里要有相关的Spring MVC的知识。具体可以查看Spring in action 2 中的第13章《开始Spring MVC之旅》）

 

首先，必须为你的Spring MVC配置一个DispatcherServlet，为此，在web.xml里面加入以下配置：

 

	<servlet>
		<servlet-name>flex</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>flex</servlet-name>
		<url-pattern>/hello/*</url-pattern>
	</servlet-mapping>

 

 这里声明了一个名为flex的servlet，并将所有对/hello这个URL的请求全部交由这个DispatcherServlet进行处理。当此servlet加载后，会从根据servlet-name中的“flex”，加载一个名为flex-servlet.xml的配置文件。这里根据Spring的分解应用上下文思想，你需要为web层独立配置flex-servlet.xml文件，当然，你可以把所有的bean都堆在这个xml文件里面。这里只作使用的示范：

 

在WEB-INF目录下，新建一个名为flex-servlet.xml的Spring上下文。该文件的名称空间声明引用到了一些flex的名称空间，以及一些flex的schema，需要做一点修改：

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:flex="http://www.springframework.org/schema/flex"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
					http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
					http://www.springframework.org/schema/flex 
 				        http://www.springframework.org/schema/flex/spring-flex-1.5.xsd">

</beans>

 

 

即加入两个关于flex的schema定位以及flex这个名称空间。

 

完成了这个修改，就可以开始配置bean了。

 

2.配置MessageBroker

 

MessageBroker是整个BlazeDS的核心，根据reference guide，你必须为你的webApplicationContext，即刚刚创建的flex-servlet.xml配置一个MessageBroker。在Spring BlazeDS Integration中，就不再是MessageBrokerServlet，而是MessageBrokerFactoryBean。它位于org.springframework.flex.core.MessageBrokerFactoryBean。而由于刚刚引入的flex的名称空间，在这个配置文件里面，可以利用标签flex:message-broker 替代这个bean的声明：

 

<flex:message-broker/>

 

 这个标签等效于声明一个了名为_messageBroker的bean，类为MessageBrokerFactoryBean，从默认WEB-INF/flex这个目录下直接读取service-config.xml配置文件。也可以利用classpath这个前缀，使用ResouceLoader从当前线程中匹配services-config.xml，并读取：

 

 

<flex:message-broker services-config-path="classpath*:services-config.xml"/>

 

等效于

<bean id="_messageBroker" class="org.springframework.flex.core.MessageBrokerFactoryBean" >
    <property name="servicesConfigPath" value="classpath*:services-config.xml" />
</bean>      

 

那我们就直接利用第一种，即直接声明一个message-broker的tag，默认配置就可以。

 

3. 将DispatcherServlet的request转发的到MessageBroker控制器

有了DispatcherServlet，有了控制器，对于Spring MVC来说就缺少一个转发映射了。如果按照上述步骤，是了messagebroker的tag，那么只需要在flex-servlet.xml中加入一个bean：

 

<bean class="org.springframework.flex.servlet.MessageBrokerHandlerAdapter"/>

 

 这个类的说明是：

 

 

HandlerAdapter for routing HTTP messages to a Spring-managed MessageBroker.

This class is automatically registered with the application context when using the message-broker tag in the xml configuration namespace.

 即默认地把所有所有http转发到message-broker tag中，其实就是等效于这样一个东西：

 

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
	<property name="mappings">
		<value>
			/*=_messageBroker
		</value>
	</property>
</bean>

 一个简单的映射。他会把所有/hello的这个URL的请求都发到messageBroker中去。

 

4.配置remoting服务

剩下的就是配置remoting-config了。

打开之前的那个service-config，为所有channel都加上一个hello路径配合转发：

 

<channel-definition id="my-amf" class="mx.messaging.channels.AMFChannel">
            <endpoint url="http://{server.name}:{server.port}/{context.root}/hello/messagebroker/amf" class="flex.messaging.endpoints.AMFEndpoint"/>
</channel-definition>

 

以前没有整合框架的时候，需要在remoting-config.xml里面配置destination，现在可以直接在context里面配置，而不用再因为忘记任何一边出错。这里声明一个简单的类名为hello：

 

package hello;

public class Hello {
	public String sayHello(){
		String hello = "hello world!";
		return hello;
	}
	public String sayShit(){
		String hello = "fuck the world!";
		return hello;
	}
}

 

 

<bean id="helloBean" class="hello.Hello">
</bean>

 

这里有两个方法，一个是标准的hellowor的，一个是天煞的f*ck the world。我只想让用户说hello，不让他乱说话，可以先这样配置：

 

在message-broker标签内声明一个remoting-servce：

 

<flex:message-broker>
    <flex:remoting-service default-adapter-id="my-default-remoting-adapter" 
        default-channels="my-amf, my-secure-amf" />
</flex:message-broker>

  然后把hello类公开：

 

<flex:remoting-destination destination-id="helloServ" ref="helloBean" include-methods="sayHello" exclude-methods="sayShit"/>
	

  将sayHello变成是include-methods即可以访问,sayShit变成是exclude-methods即不可访问。

5.配置Flex

Service.as

 

package
{
	import mx.rpc.AsyncToken;
	import mx.rpc.remoting.Operation;
	import mx.rpc.remoting.RemoteObject;

	/**
	 *  <b>Service类</b> 
	 * <br>
	 * @author Encore
	 * */
	public class Service
	{
		private var _operations:Object = new Object();
		
		private var _operationsName:Array = ["sayHello","sayShit"];
		
		private var _remoteObject:RemoteObject = new RemoteObject();
		
		public function Service()
		{
			for each (var i:String in _operationsName){
				var operation:Operation = new Operation(null,i);
				_operations[i]=operation;
			}
			_remoteObject.operations=_operations;
			_remoteObject.destination="helloServ";
			_remoteObject.endpoint="http://localhost:8080/SpringTest/hello/messagebroker/amf";
			_remoteObject.showBusyCursor=true;
		}
		
		public function sayHello():AsyncToken{
			return (_operations["sayHello"] as Operation).send();
		}
		public function sayShit():AsyncToken{
			return (_operations["sayShit"] as Operation).send();			
		}
		
	}
	
}

  Test.mxml

 

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
			   xmlns:s="library://ns.adobe.com/flex/spark" 
			   xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600" xmlns:local="*"
			   creationComplete="initial(event)">
	<fx:Script>
		<![CDATA[
			import mx.events.FlexEvent;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
			
			protected function initial(event:FlexEvent):void
			{
				// TODO Auto-generated method stub
				call.token = service.sayShit();
			}
			
			protected function call_resultHandler(event:ResultEvent):void
			{
				// TODO Auto-generated method stub
				trace(event.result);
			}
			
			protected function call_faultHandler(event:FaultEvent):void
			{
				// TODO Auto-generated method stub
				trace(event.fault.faultDetail);	
			}
			
		]]>
	</fx:Script>
	<fx:Declarations>
		<!-- 将非可视元素（例如服务、值对象）放在此处 -->
		<local:Service id="service"/>
		<s:CallResponder id="call" result="call_resultHandler(event)" fault="call_faultHandler(event)"/>
	</fx:Declarations>
</s:Application>

sayShit的调用：

 sayhello的调用

简单的试用到此。还可以配合Spring框架的更多功能，例如Spring Security等。之后再说吧。