blazeds服务端推送数据

研究了几天，上网搜索了很多，才发现很多人都是这抄抄那抄抄，写出来的东西都是垃圾，跑也跑不动，解释不周全（可能是知识有限）

Blazeds的message消息订阅机制使得服务端可以主动的向客户端（已订阅）推送数据，配置的地方可能在channel稍微复杂一点。下面的例子整合了spring-integration

<?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">
	
	<fx:Script>
		<![CDATA[
			import mx.messaging.ChannelSet;
			import mx.messaging.channels.AMFChannel;
			import mx.messaging.events.ChannelFaultEvent;
			import mx.messaging.events.MessageEvent;
			import mx.messaging.events.MessageFaultEvent;
			
			private var toggled:Boolean;
			private var isSub:Boolean;
			
			protected function feedBtn_clickHandler(event:MouseEvent):void
			{
				if(!toggled){
					feed.start();
				}else{
					feed.stop();
				}
	
				toggled=!toggled;
			}
			
			protected function consumer_messageHandler(event:MessageEvent):void
			{
				publishInput.text=""+event.message.body;
			}
			
			protected function consumer_channelFaultHandler(event:ChannelFaultEvent):void
			{
				trace(event.faultDetail);
			}
			
			protected function consumer_faultHandler(event:MessageFaultEvent):void
			{
				trace(event.faultDetail);
			}
			
			protected function subBtn_clickHandler(event:MouseEvent):void
			{
				if(!isSub){
//					var amfChanel1:AMFChannel=new AMFChannel("my-streaming-amf","http://localhost:8080/bingya/messagebroker/streamingamf");
//					var amfChanel2:AMFChannel=new AMFChannel("my-polling-amf","messagebroker/my-polling-amf");  
					//创建我们想要的chanelset，并把可行的chanel放进去     
//					var chanelSet:ChannelSet=new ChannelSet();  
//					chanelSet.addChannel(amfChanel1);  
//					chanelSet.addChannel(amfChanel2);  
//					consumer.channelSet=chanelSet;  
					consumer.subscribe();
					
					consumer.addEventListener(MessageEvent.MESSAGE,consumer_messageHandler);
					consumer.addEventListener(ChannelFaultEvent.FAULT,consumer_channelFaultHandler);
					consumer.addEventListener(MessageFaultEvent.FAULT,consumer_faultHandler); 
				}else{
					consumer.removeEventListener(MessageEvent.MESSAGE,consumer_messageHandler);
					consumer.removeEventListener(ChannelFaultEvent.FAULT,consumer_channelFaultHandler);
					consumer.removeEventListener(MessageFaultEvent.FAULT,consumer_faultHandler);
					consumer.unsubscribe();
				}
				
				isSub=!isSub;
			}
			
		]]>
	</fx:Script>
	
	<fx:Declarations>
		<s:ChannelSet id="channgelSet">
			<s:StreamingAMFChannel url="messagebroker/streamingamf"/>
		</s:ChannelSet>
		<s:RemoteObject id="feed" destination="feed" endpoint="messagebroker/amf"
						showBusyCursor="true"/>
		<s:Consumer id="consumer" destination="feedMessageService" channelSet="{channgelSet}"/>
	</fx:Declarations>
	<s:Button id="feedBtn" label="启动/关闭" click="feedBtn_clickHandler(event)"/>
	<s:Button id="subBtn" label="订阅/退订" click="subBtn_clickHandler(event)" horizontalCenter="0"
			  verticalCenter="0"/>
	<s:TextInput id="publishInput" x="400" y="400"/>
</s:Application>

 

再修改一下service-config.xml文件，加入以下通道定义：

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

 

在spring的上下文文件当中加入：

<flex:message-broker id="_messageBroker">
		<!-- <flex:remoting-service default-adapter-id="my-default-remoting-adapter" -->
		<!-- default-channels="my-amf, my-secure-amf" /> -->
<!-- 		<flex:secured> -->
<!-- 		</flex:secured> -->
		<flex:message-service default-adapter-id="my-default-messaging-adapter"
			default-channels="my-streaming-amf,my-polling-amf" />
	</flex:message-broker>
	<flex:message-destination id="feedMessageService"
		message-broker="_messageBroker" channels="my-streaming-amf,my-polling-amf" />
	<bean class="org.springframework.flex.servlet.MessageBrokerHandlerAdapter" />

定义一个feedMessageService的服务端点。

package com.myflex.platform.service.impl;

import java.util.*;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.flex.remoting.RemotingDestination;
import org.springframework.stereotype.Service;

import flex.messaging.MessageBroker;
import flex.messaging.messages.AsyncMessage;
import flex.messaging.util.UUIDUtils;

@Service(value = "feed")
@RemotingDestination(value = "feed", channels = { "my-amf",
		"my-secure-amf" })
public class Feed {
	private static FeedThread thread;

	@Autowired
	private MessageBroker msgBroker;
	
	public Feed() {
	}

	public void start() {
		if (thread == null) {
			thread = new FeedThread();
			thread.msgBroker=msgBroker;
			thread.start();
		}
	}

	public void stop() {
		thread.running = false;
		thread = null;
	}

	public static class FeedThread extends Thread {

		public boolean running = true;

		public MessageBroker msgBroker;
		
		public void run() {
//			MessageBroker msgBroker = MessageBroker.getMessageBroker(null);
//			MessageBroker msgBroker = MessageBroker.getMessageBroker(null);
			String clientID = UUIDUtils.createUUID();

			Random random = new Random();
			double initialValue = 35;
			double currentValue = 35;
			double maxChange = initialValue * 0.005;

			while (running) {
				double change = maxChange - random.nextDouble() * maxChange * 2;
				double newValue = currentValue + change;

				if (currentValue < initialValue + initialValue * 0.15
						&& currentValue > initialValue - initialValue * 0.15) {
					currentValue = newValue;
				} else {
					currentValue -= change;
				}

				AsyncMessage msg = new AsyncMessage();
				msg.setDestination("feedMessageService");
				msg.setClientId(clientID);
				msg.setMessageId(UUIDUtils.createUUID());
				msg.setTimestamp(System.currentTimeMillis());
				msg.setBody(new Double(currentValue));
				msgBroker.routeMessageToService(msg, null);

				System.out.println("" + currentValue);

				try {
					Thread.sleep(300);
				} catch (InterruptedException e) {
				}

			}
		}
	}

}

 

注入一个MessageBroker实例，将Feed作为一个服务类暴露出来，启动线程的时候，向前端推送数据。