flex+blazeds+java后台消息推送(简单示例)

现在有个问题需要大家思考一下，有个已经上线了的项目，有好好几千甚至上万的客户在使用了。现在项目开发商想发布一个通知。在今天下午6点需要重新启动服务器，想让在线的人在在预定的时间内都收到消息，让大家做好相应的准备，大家会怎么做？

1、逐个打电话

2、在前台弄一个定时器，每隔一定的时间刷新一次

3、后台消息主动往前台推送

相信你已经做出选择了。。。呵呵 ，下面讲一个简单的例子，

首先，新建一个web项目，添加开发flex需要的jar包，和blazeds相关文件，然后把web项目转成flex项目(不明白怎么弄没事，过几天会写一篇这样的文章)，然后修改一下services-config.xml和messaging-config.xml文件，添加如下代码

services-config.xml
1. <channel-definition
2. id="my-streaming-amf"
3. class="mx.messaging.channels.StreamingAMFChannel">
4. <endpoint
5. url="http://{server.name}:{server.port}/{context.root}/messagebroker/streamingamf"
6. class="flex.messaging.endpoints.StreamingAMFEndpoint"
7. />
8. <properties>
9. <idle-timeout-minutes>0</idle-timeout-minutes>
10. <max-streaming-clients>10</max-streaming-clients>
11. <server-to-client-heartbeat-millis>5000
12. </server-to-client-heartbeat-millis>
13. <user-agent-settings>
14. <user-agent
15. match-on="MSIE"
16. kickstart-bytes="2048"
17. max-streaming-connections-per-session="1"
18. />
19. <user-agent match-on="Firefox"
20. kickstart-bytes="2048"
21. max-streaming-connections-per-session="1"
22. />
23. </user-agent-settings>
24. </properties>
25. </channel-definition>
复制代码

messaging-config.xml
1. <destination
2. id="tick-data-feed">
3. <properties>
4. <server>
5. <allow-subtopics>true</allow-subtopics>
6. <subtopic-separator>.</subtopic-separator>
7. </server>
8. </properties>
9. <channels>
10. <channel
11. ref="my-polling-amf" />
12. <channelref="my-streaming-amf"
13. />
14. </channels>
15. </destination>
复制代码
OK，完了之后，我们新建一个servlet作为服务端
1. package com.serverpush;
2.
3. import java.io.IOException;
4. import
5. javax.servlet.ServletException;
6. import
7. javax.servlet.http.HttpServlet;
8. import
9. javax.servlet.http.HttpServletRequest;
10. import
11. javax.servlet.http.HttpServletResponse;
12.
13. import
14. com.model.Tick;
15.
16. import flex.messaging.MessageBroker;
17. import
18. flex.messaging.messages.AsyncMessage;
19. import
20. flex.messaging.util.UUIDUtils;
21.
22. /**
23. * Servlet implementation class
24. TickCacheServlet
25. */
26. public class TickCacheServlet extendsHttpServlet
27. {
28. private static final long serialVersionUID= 1L;
29. private static
30. FeedThread thread;
31.
32. /**
33. * @see
34. HttpServlet#HttpServlet()
35. */
36. public TickCacheServlet() {
37. super();
38. //
39. TODO Auto-generated constructor stub
40. }
41.
42. /**
43. * @see
44. HttpServlet#doGet(HttpServletRequestrequest, HttpServletResponse
45. *
46. response)
47. */
48. protected void doGet(HttpServletRequest
49. request,
50. HttpServletResponse response) throwsServletException, IOException

51. {
52. //接收前台参数
53. String cmd =request.getParameter("cmd");
54. if
55. (cmd.equals("start")) {
56. start();
57. }
58. if (cmd.equals("stop"))
59. {
60. stop();
61. }
62. }
63.
64. public void start() {
65. if (thread == null)
66. {
67. thread = new
68. FeedThread();
69. thread.start();
70. }
71. System.out.println("start!!");
72. }
73.
74. public
75. void stop() {
76. thread.running = false;
77. thread = null;
78. }
79.
80. /**
81. *
82. @see HttpServlet#doPost(HttpServletRequestrequest, HttpServletResponse
83. *
84. response)
85. */
86. protected void doPost(HttpServletRequest
87. request,
88. HttpServletResponse response) throwsServletException, IOException

89. {
90. doGet(request, response);
91. }
92. //线程类，每隔多长时间发送一次
93. public static class
94. FeedThread extends Thread {
95. public boolean running = true;
96. public void
97. run() {
98. MessageBroker msgBroker =
99. MessageBroker.getMessageBroker(null);
100. String clientID =
101. UUIDUtils.createUUID();
102. int i = 0;
103. while (running) {
104. Tick tick = new
105. Tick();
106. tick.setMessageCN("今天下午6点更新程序需重启服务器");
107. tick.setSeqNo(String.valueOf(i));
108. System.out.println(i);
109.
110. AsyncMessage
111. msg = new
112. AsyncMessage();
113. msg.setDestination("tick-data-feed");
114. msg.setHeader("DSSubtopic",
115. "tick");
116. msg.setClientId(clientID);
117. msg.setMessageId(UUIDUtils.createUUID());
118. msg.setTimestamp(System.currentTimeMillis());
119. msg.setBody(tick);
120. msgBroker.routeMessageToService(msg,
121. null);
122. i++;
123. try {
124. Thread.sleep(2000);
125. } catch (InterruptedException
126. e) {
127. }
128. }
129. }
130. }
131. }
复制代码
在新建一个model用来保存消息
1. package com.model;
2.
3. public class Tick {
4. private String
5. seqNo;
6. private String messageCN;
7.
8. public String getMessageCN()
9. {
10. return messageCN;
11. }
12.
13. public void setMessageCN(String messageCN)
14. {
15. this.messageCN = messageCN;
16. }
17.
18. public String getSeqNo()
19. {
20. return seqNo;
21. }
22.
23. public void setSeqNo(String seqNo)
24. {
25. this.seqNo = seqNo;
26. }
27. }
复制代码
后台就搞定了。下面看前台

新建一个mxml文件和一个VO文件

mxml:
1. <?xml version="1.0"
2. encoding="utf-8"?>
3. <s:Application
4. xmlns:fx="http://ns.adobe.com/mxml/2009"
5. xmlns:s="library://ns.adobe.com/flex/spark"
6. xmlns:mx="library://ns.adobe.com/flex/mx"
7. minWidth="955"
8. minHeight="600">
9. <s:layout>
10. <s:BasicLayout/>
11. </s:layout>
12.
13. <fx:Script>
14. <![CDATA[
15. import
16. mx.controls.Alert;
17. import mx.messaging.ChannelSet;
18. import
19. mx.messaging.Consumer;
20. import
21. mx.messaging.events.MessageEvent;
22.
23. protected function
24. submsg():void
25. {
26. Alert.show("click start");
27. var consumer:Consumer = new
28. Consumer();
29. consumer.destination ="tick-data-feed";
30. consumer.subtopic =
31. "tick";
32. consumer.channelSet = new
33. ChannelSet(["my-streaming-amf"]);
34. //添加message的监听，当后台有消息发送时，调用messageHandler
35.
36. consumer.addEventListener(MessageEvent.MESSAGE,messageHandler);

37.
38. consumer.subscribe();
39. }
40. private function
41. messageHandler(event:MessageEvent):void
42. {
43. var tick:TickVO =
44. event.message.body as TickVO;
45. txtTick.text = tick.messageCN+tick.seqNo;
46.
47. }
48.
49.
50. ]]>
51. </fx:Script>
52.
53. <fx:Declarations>
54. <!--
55. 将非可视元素（例如服务、值对象）放在此处 -->
56. </fx:Declarations>
57. <mx:Panel
58. x="32"
59. y="43"
60. width="362"
61. height="302"
62. layout="absolute"
63. title="Watch
64. Tick">
65. <mx:Label
66. x="72"
67. y="43"
68. text="Label"
69. id="txtTick"/>
70. <mx:Button
71. x="132"
72. y="71"
73. label="Button"
74. click="submsg()"/>
75. </mx:Panel>
76. </s:Application>
复制代码
VO，就是对应后台的model
1. package
2. {
3. //远程到后台的Tick，也就是说他们俩现在是对应的关系了，你在后台给model赋值了，在前台flex中就可以通过VO
4. //取得model中的值
5. [RemoteClass(alias="com.model.Tick")]
6.
7. [Bindable]
8. public class TickVO
9. {
10. private var
11. _seqNo:String;
12. private var _messageCN:String;
13.
14. public function
15. TickVO()
16. {
17.
18. }
19. public function get seqNo():String
20. {
21. return
22. _seqNo;
23. }
24.
25. public function setseqNo(value:String):void
26. {
27. _seqNo
28. = value;
29. }
30.
31. public function get messageCN():String
32. {
33. return
34. _messageCN;
35. }
36.
37. public function set
38. messageCN(value:String):void
39. {
40. _messageCN =
41. value;
42. }
43.
44.
45. }
46. }
复制代码
ok，下面开始测试：运行mxml，界面如下

点击button，启动监听。

然后在浏览器中输入：http://localhost:8080/serverPush/TickCacheServlet?cmd=start，表示现在我要发消息了，当你运行了这个之后看看你刚才的那个mxml是不是有变化啦

稍后奉上flex+blazeds+spring+java后台消息推送(这个稍微麻烦点)，有些配置不同了

flex+blazeds+java+spring后台消息推送，有界面维护