精华内容
下载资源
问答
  • java WebSocket实现Java后台消息推送
    展开全文
  • 压缩包内包含java后端、flex前端代码,配置文档,jar包
  • WebSocket实现Java后台消息推送

    千次阅读 2018-02-01 10:58:00
    alert("这是后台推送消息:"+event.data);  websocket.close();  alert("webSocket已关闭!") } //连接关闭的回调方法 websocket.onclose = function() { setMessageInnerHTML("WebSocket连接关闭"); }...

    1.什么是WebSocket

      WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端。

    2.实现原理

      在实现websocket连线过程中,需要通过浏览器发出websocket连线请求,然后服务器发出回应,这个过程通常称为“握手” 。在 WebSocket API,浏览器和服务器只需要做一个握手的动作,然后,浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。

                            

    3.优点

      在以前的消息推送机制中,用的都是 Ajax 轮询(polling),在特定的时间间隔由浏览器自动发出请求,将服务器的消息主动的拉回来,这种方式是非常消耗资源的,因为它本质还是http请求,而且显得非常笨拙。而WebSocket 在浏览器和服务器完成一个握手的动作,在建立连接之后,服务器可以主动传送数据给客户端,客户端也可以随时向服务器发送数据。

    4.WebSocket和Socket的区别

      1.WebSocket:

      1. websocket通讯的建立阶段是依赖于http协议的。最初的握手阶段是http协议,握手完成后就切换到websocket协议,并完全与http协议脱离了。

      2. 建立通讯时,也是由客户端主动发起连接请求,服务端被动监听。

      3. 通讯一旦建立连接后,通讯就是“全双工”模式了。也就是说服务端和客户端都能在任何时间自由得发送数据,非常适合服务端要主动推送实时数据的业务场景。

      4. 交互模式不再是“请求-应答”模式,完全由开发者自行设计通讯协议。

      5. 通信的数据是基于“帧(frame)”的,可以传输文本数据,也可以直接传输二进制数据,效率高。当然,开发者也就要考虑封包、拆包、编号等技术细节。

      2.Socket:

      1. 服务端监听通讯,被动提供服务;客户端主动向服务端发起连接请求,建立起通讯。

      2. 每一次交互都是:客户端主动发起请求(request),服务端被动应答(response)。

      3. 服务端不能主动向客户端推送数据。

      4. 通信的数据是基于文本格式的。二进制数据(比如图片等)要利用base64等手段转换为文本后才能传输。

    5.WebSocket客户端:

    var websocket = null;
    var host = document.location.host;  
    var username = "${loginUsername}"; // 获得当前登录人员的userName  
     // alert(username)
    //判断当前浏览器是否支持WebSocket  
    if ('WebSocket' in window) {  
    	alert("浏览器支持Websocket")
        websocket = new WebSocket('ws://'+host+'/mm-dorado/webSocket/'+username);  
    } else {  
        alert('当前浏览器 Not support websocket')  
    }  
    
    //连接发生错误的回调方法  
    websocket.onerror = function() {  
      alert("WebSocket连接发生错误")
       setMessageInnerHTML("WebSocket连接发生错误");  
    };   
      
    //连接成功建立的回调方法  
    websocket.onopen = function() {
      alert("WebSocket连接成功")  
       setMessageInnerHTML("WebSocket连接成功");  
    }  
      
    //接收到消息的回调方法  
    websocket.onmessage = function(event) {
    	alert("接收到消息的回调方法")  
    	alert("这是后台推送的消息:"+event.data); 
         websocket.close();
        alert("webSocket已关闭!")
    }  
      
    //连接关闭的回调方法  
    websocket.onclose = function() {  
        setMessageInnerHTML("WebSocket连接关闭");  
    }  
      
    //监听窗口关闭事件,当窗口关闭时,主动去关闭websocket连接,防止连接还没断开就关闭窗口,server端会抛异常。  
    window.onbeforeunload = function() {  
        closeWebSocket();  
    }  
      
    //关闭WebSocket连接  
    function closeWebSocket() {  
        websocket.close();  
    }  
    
    //将消息显示在网页上
        function setMessageInnerHTML(innerHTML) {
            document.getElementById('message').innerHTML += innerHTML + '<br/>';
        }
    

      6.WebSocket服务端(java后台):

        1.核心类:
    package com.mes.util;
    
    import java.io.IOException;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    import javax.websocket.OnClose;
    import javax.websocket.OnError;
    import javax.websocket.OnMessage;
    import javax.websocket.OnOpen;
    import javax.websocket.Session;
    import javax.websocket.server.PathParam;
    import javax.websocket.server.ServerEndpoint;
    
    import org.springframework.stereotype.Component;
    import org.springframework.stereotype.Service;
    
    import com.google.gson.JsonObject;
    
    import net.sf.json.JSONObject;
    @ServerEndpoint("/webSocket/{username}")   
    	public class WebSocket {  
    	    private static int onlineCount = 0;  
    	    private static Map<String, WebSocket> clients = new ConcurrentHashMap<String, WebSocket>();  
    	    private Session session;  
    	    private String username;  
    	      
    	    @OnOpen  
    	    public void onOpen(@PathParam("username") String username, Session session) throws IOException {  
    	  
    	        this.username = username;  
    	        this.session = session;  
    	          
    	        addOnlineCount();  
    	        clients.put(username, this); 
    	        System.out.println("已连接");
    	    }  
    	  
    	    @OnClose  
    	    public void onClose() throws IOException {  
    	        clients.remove(username);  
    	        subOnlineCount();  
    	    }  
    	  
    	    @OnMessage  
    	    public void onMessage(String message) throws IOException {  
    	  
    	        JSONObject jsonTo = JSONObject.fromObject(message);  
    	        String mes = (String) jsonTo.get("message");
    	        
    	        if (!jsonTo.get("To").equals("All")){  
    	            sendMessageTo(mes, jsonTo.get("To").toString());  
    	        }else{  
    	            sendMessageAll("给所有人");  
    	        }  
    	    }  
    	  
    	    @OnError  
    	    public void onError(Session session, Throwable error) {  
    	        error.printStackTrace();  
    	    }  
    	  
    	    public void sendMessageTo(String message, String To) throws IOException {  
    	        // session.getBasicRemote().sendText(message);  
    	        //session.getAsyncRemote().sendText(message);  
    	        for (WebSocket item : clients.values()) {  
    	            if (item.username.equals(To) )  
    	                item.session.getAsyncRemote().sendText(message);  
    	        }  
    	    }  
    	      
    	    public void sendMessageAll(String message) throws IOException {  
    	        for (WebSocket item : clients.values()) {  
    	            item.session.getAsyncRemote().sendText(message);  
    	        }  
    	    }  
    	  
    	    public static synchronized int getOnlineCount() {  
    	        return onlineCount;  
    	    }  
    	  
    	    public static synchronized void addOnlineCount() {  
    	        WebSocket.onlineCount++;  
    	    }  
    	  
    	    public static synchronized void subOnlineCount() {  
    	        WebSocket.onlineCount--;  
    	    }  
    	  
    	    public static synchronized Map<String, WebSocket> getClients() {  
    	        return clients;  
    	    }  
    }
    
      2.在自己代码中的调用:
    WebSocket ws = new WebSocket();
    JSONObject jo = new JSONObject();
    jo.put("message", "这是后台返回的消息!");
    jo.put("To",invIO.getIoEmployeeUid());
    ws.onMessage(jo.toString());
    

      7.所需maven依赖:

    <!-- webSocket 开始-->
    <dependency>
        <groupId>javax.websocket</groupId>
        <artifactId>javax.websocket-api</artifactId>
        <version>1.1</version>
        <scope>provided</scope>
    </dependency>
    
    <dependency>
        <groupId>javax</groupId>
        <artifactId>javaee-api</artifactId>
        <version>7.0</version>
        <scope>provided</scope>
    </dependency>
    <!-- webSocket 结束-->
    

      

     

    转载于:https://www.cnblogs.com/freud/p/8397934.html

    展开全文
  • 现在有个问题需要大家思考一下,有个已经上线了的项目,有好好几千甚至上万的客户在使用了。...3、后台消息主动往前台推送 相信你已经做出选择了。。。呵呵 ,下面讲一个简单的例子, 首先,新

    现在有个问题需要大家思考一下,有个已经上线了的项目,有好好几千甚至上万的客户在使用了。现在项目开发商想发布一个通知。在今天下午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后台消息推送,有界面维护


    展开全文
  • Android中实现对JPush信息的处理,后台服务器采用java开发。可以自定义要推送的信息和模式 Android中实现对JPush信息的处理,后台服务器采用java开发。可以自定义要推送的信息和模式
  • 友盟消息推送java后台模块demo,可以直接集成到项目中,在Demo.java中的main方法中启动推送
  • web创建消息推送保存至数据库后,后台从数据库获取数据并异步推送;即每次获取一条数据推送推送成功后再获取第二条数据推送,依此类推,当没有数据时处于睡眠状态。我该怎么实现。
  • 之前写过一篇文章:flex+blazeds+java后台消息推送(简单示例) ,现在要写的是这个的升级版,改动还是挺多的,在上面的基础上增加了spring配置,还有界面的维护。后台基本上全变了。呵呵 。。。下面看实现过程 大体...

    之前写过一篇文章:flex+blazeds+java后台消息推送(简单示例)  ,现在要写的是这个的升级版,改动还是挺多的,在上面的基础上增加了spring配置,还有界面的维护。后台基本上全变了。呵呵 。。。下面看实现过程
    大体的思路是:服务器启动时,查询数据库获取为推送的消息,存储到内存中,定义了一个全局变量MESSAGE_LIST,集合类型。以后的每次维护,包括(增、删、改),都同时维护两份,及数据库和内存,保证两者的一致。当一条消息推送完成,即从MESSAGE_LIST中删除。
    首先,添加spring的配置,在web-application-config.xml文件中添加

    1.   <flex:message-brokerid="_messageBroker">  

    2.          <flex:message-service  

    3.             default-channels="my-streaming-amf,my-polling-amf"/>  

    4.          </flex:message-broker>

    5.          <flex:message-destination id="tick-data-feed"channels="my-streaming-amf,my-polling-amf"allow-subtopics="true" subtopic-separator="."/>

    复制代码

    没添加之前时:

    1.   <flex:message-broker />

    复制代码

    主要是为了在后台获取message-broker,services-config.xml的配置还是一样,不变。
    然后,后台java类:

    1.           /**

    2.            * 新增消息

    3.            *@param paramMessage

    4.            *@return

    5.            *@throws ServiceException

    6.            *@throws SQLException

    7.            * @author:IT氧吧

    8.            *@createDate: 2011-5-17

    9.            *@modifiedBy:IT氧吧

    10.           *@modifiedDate:2011-5-17

    11.           */

    12.         public String savePushMessage(PushMessage paramMessage)

    13.                         throwsServiceException, SQLException {

    14.                

    15.                paramMessage.setStartDate(DateUtil.parseDate(paramMessage.getStartDateCN(),DateUtil.YMDHMS_PATTERN));

    16.                paramMessage.setEndDate(DateUtil.parseDate(paramMessage.getEndDateCN(),DateUtil.YMDHMS_PATTERN));

    17.                 Date d = systemService.getDateFromDataBase();

    18.                 if(paramMessage.getStartDate().compareTo(d)< 0 || paramMessage.getEndDate().compareTo(d) < 0){

    19.                         thrownew ServiceException("推送日期不能早于当前日期");

    20.                 }

    21.                if(paramMessage.getStartDate().compareTo(paramMessage.getEndDate()) > 0){

    22.                         thrownew ServiceException("推送起始日期不能晚于推送结束日期");

    23.                 }

    24.                 /** 保存到数据库 */

    25.                 Long messageId = systemService.savePushMessage(paramMessage);

    26.                 /** 添加到集合中 */

    27.                 GlobalNames.MESSAGE_LIST.add(paramMessage);

    28.                

    29.                 /** 集合重新排序降序

    30.                 Comparator<PushMessage> comparator = newComparator<PushMessage>(){

    31.                          @Override

    32.                       public intcompare(PushMessage o1, PushMessage o2) {

    33.                         returno1.getStartDate().compareTo(o2.getStartDate());

    34.                       }

    35.                 };

    36.                 Collections.sort(GlobalNames.MESSAGE_LIST,comparator); */

    37.                 /**

    38.                  * 如果GlobalNames.MESSAGE_LIST没有消息,此时新增消息的时候就得推送,否则只是把消息添加到GlobalNames.MESSAGE_LIST并排序

    39.                  * */

    40.                 if(GlobalNames.MESSAGE_LIST.size() == 1){

    41.                        PushMessageUtil.startPush(systemService);

    42.                 }

    43.                 return messageId.toString();

    44.          }

    复制代码

    下面看一下PushMessageUtil

    1.          public static void startPush(SystemService systemService){

    2.                  if(GlobalNames.MESSAGE_LIST.size() > 0){

    3.                          if(t ==null){

    4.                                 t = new Timer();

    5.                                 try {

    6.                                         dbDate =systemService.getDateFromDataBase();

    7.                                 } catch (ServiceException e) {

    8.                                         // TODOAuto-generated catch block

    9.                                         e.printStackTrace();

    10.                                } catch (SQLException e) {

    11.                                        // TODOAuto-generated catch block

    12.                                        e.printStackTrace();

    13.                                }

    14.                         }

    15.                         /**

    16.                          * 下面一段代码在一种情况下会报错,即系统刚启动还没有任何人登录,

    17.                          * 此时系统flex框架部分还未初始化,获取到msgBroker为空

    18.                         *  */

    19.                        msgBroker = MessageBroker.getMessageBroker("_messageBroker");

    20.                         clientID= UUIDUtils.createUUID();

    21.                        t.scheduleAtFixedRate(new TimerTask() {

    22.                                @Override

    23.                                public void run() {

    24.                                        // TODOAuto-generated method stub

    25.                                        if(msgBroker ==null){

    26.                                               msgBroker = MessageBroker.getMessageBroker("_messageBroker");

    27.                                        }

    28.                                        PushMessage message;

    29.                                       dbDate.setMinutes(dbDate.getMinutes()+1);

    30.                                        /** 每隔1分钟轮询一次 */

    31.                                        /** 注意下面的循环不能用foreach,否则报java.util.ConcurrentModificationException*/

    32.  //                                      for(PushMessagemessage : GlobalNames.MESSAGE_LIST){

    33.                                        for(inti=0;i<GlobalNames.MESSAGE_LIST.size();i++){

    34.                                               String dateStr = DateUtil.format(dbDate,DateUtil.YMDHMS_PATTERN);

    35.                                               message = GlobalNames.MESSAGE_LIST.get(i);

    36.                                               if((message.getStartDate().getMinutes()-dbDate.getMinutes())% message.getInterval() == 0){

    37.                                                       pMessage = message;

    38.                                                       start();

    39.                                               }

    40.                                               

    41.                                               //是否等于结束时间

    42.                                               if(message.getEndDateCN().substring(0, message.getEndDateCN().lastIndexOf(":")).equals(dateStr.substring(0,dateStr.lastIndexOf(":")))){

    43.                                                      GlobalNames.MESSAGE_LIST.remove(message);

    44.                                                       System.out.println("大小:"+GlobalNames.MESSAGE_LIST.size());

    45.                                                       stopMessage = message;

    46.                                                       stop();

    47.                                                       if(GlobalNames.MESSAGE_LIST.size()== 0){

    48.                                                              t.cancel();

    49.                                                              t = null;

    50.                                                              break;

    51.                                                       }

    52.                                               }

    53.                                        }

    54.                                }

    55.                         },1000*60, 1000*60);

    56.                 }

    57.          }

    58.          

    59.          /**

    60.           * 开始推送

    61.           *@author: IT氧吧

    62.           *@createDate: 2011-5-20

    63.           *@modifiedBy: IT氧吧

    64.           *@modifiedDate:2011-5-20

    65.           */

    66.         private static void start() {

    67.                 AsyncMessage msg = new AsyncMessage();

    68.                msg.setDestination("tick-data-feed");

    69.                 msg.setHeader("DSSubtopic","tick");

    70.                 msg.setClientId(clientID);

    71.                 msg.setMessageId(UUIDUtils.createUUID());

    72.                 msg.setTimestamp(System.currentTimeMillis());

    73.                 msg.setBody(pMessage);

    74.                 if(msgBroker != null){

    75.                        msgBroker.routeMessageToService(msg, null);

    76.                        System.out.println("start!!");

    77.                 }

    78.          }

    79.   

    80.          /**

    81.           * 停止推送

    82.           *@author: IT氧吧

    83.           *@createDate: 2011-5-20

    84.           * @modifiedBy:IT氧吧

    85.           *@modifiedDate:2011-5-20

    86.           */

    87.         private static void stop() {

    88.                System.out.println(stopMessage.getContent()+"  已经推送完成");

    89.          }

    复制代码

    不解释,应该都能看懂,该有的注释也都有
    前台还是一样,该添加的监听还是得添加,只是多了个,如果有多个消息同时推送时,已经推送过的消息将不会显示

    1.   private var msgList:ArrayCollection = newArrayCollection();

    2.                          privatefunction messageHandler(event:MessageEvent):void   

    3.                          {  

    4.                                 var pmsg:ServerPushMessageVO = event.message.bodyas ServerPushMessageVO;

    5.                                 /**

    6.                                  * 返回指示视图是否包含指定对象的信息。与 IViewCursor.findxxx 方法不同,

    7.                                  * 此搜索仅在找到完全与参数匹配的项目时才会成功。如果视图中包含已应用到该视图的滤镜,

    8.                                  * 则即使基本集合确实包含该项目,此方法也会返回 false。

    9.                                  * */

    10.                                if(!msgList.contains(pmsg.id))

    11.                                {

    12.                                        var showTipMessageG:ShowTipMessageG= new ShowTipMessageG();

    13.                                       msgList.addItem(pmsg.id);

    14.                                       showTipMessageG.serverPushMessageVO = pmsg;

    15.                                        PopUpEffect.show(showTipMessageG,this, true);

    16.                                }

    17.                         }  

    复制代码

    下面上几张效果图
    新增消息页面

    弹出提示页面


    ok,消息推送的到此结束。。。


    展开全文
  • 需求:项目测试,缺少用户登录失败给admin推送消息,想到这个方式,当用户登录失败时,admin用户会在页面看到咣咣乱弹的alert. 正文 pom.xml <!-- webSocket 开始--> <dependency> <groupId>...
  • 本篇文章主要介绍了PHP实现Web实时消息后台服务器推送技术,这里整理了详细的代码,有需要的小伙伴可以参考下。
  • JavaPush消息推送

    热门讨论 2013-03-04 09:02:34
    JavaPush消息推送
  • java后台向app推送消息

    2016-06-20 09:56:46
    java后台怎么向app推送消息呢,需要用到哪些技术 ?公司现在是做美容服务预约软件,有一个客户端app和一个技师端app,后台专门写了一个客户端提交订单的接口,客户提交服务订单以后后台接收订单信息,然后向预定的...
  • 越来越多的项目需要用到实时消息推送与接收,我这里推荐大家使用GoEasy, 它是一款第三方推送服务平台,使用它的API可以轻松搞定实时推送! 浏览器兼容性:GoEasy推送 支持websocket 和polling两种连接方式,从而...
  • 百度云推送 java后台可以向android推送透传消息吗?
  • 每个程序猿(媛)都有过...最近在看关于实时消息推送方面的技术文章,然后发现了一篇值得欣慰的文章,欣慰的原因是,文章里讲解如何用Java进行消息推送访问者可以一眼就看出实现思路,大家可以进去瞅一眼,这是博客网址...
  • java后台实现微信公众号和支付宝生活号消息推送,微信和支付宝的消息推送换汤不换药,实现方法类似,都需要先申请消息模板,官网有API文档,写的也很详细,具体代码如下: 微信消息推送: /** * 挂号成功消息推送 ...
  • java后台集成腾讯信鸽消息推送

    千次阅读 2018-10-26 15:40:56
    腾讯移动推送(信鸽)地址:https://xg.qq.com/ 1.注册登录后进入应用管理创建应用 服务端需要用到APP ID和SECRET KEY 后面的是安卓接入用的 2.搭建项目 导入jar包,需要方法直接调用就好(我是手动添加本地 ...
  • java后台对app推送消息

    2015-05-05 06:41:58
    公司现在是做代驾软件的,有一个客户端app和一个司机端app,后台专门写了一个客户端提交订单的接口,客户提交代驾订单以后后台接收订单信息,然后计算最近的司机,并将订单信息通过第三方推送“个推”直接推送给这个...
  • Maven添加依赖 <!--极光推送--> <dependency> <groupId>cn.jpush.api</groupId> <artifactId>jpush-client</artifactId> <version>...
  • 小程序消息推送及客服(JAVA后台)

    千次阅读 热门讨论 2019-06-12 10:43:03
    小程序客服及消息推送开发(后台JAVA) 最近公司在做小程序,涉及到客服及消息推送,简单的记录下开发过程及心得 客服 小程序自带的有客服功能只需要开启就行了. 选择开启后即可使用. 消息推送 首先在开发 ...
  • 最近需要开发微信和小程序的推送功能,需要用java后台实现推送,自己本身java和小程序都做,所以就自己动手实现下小...我的这个是跑腿抢单推送,当用户新下单时,会给跑腿员推送消息。 下面开始讲解实现步骤 ...
  • Java后台推送离线通知

    千次阅读 2019-03-15 09:41:19
    上一章节我们实现了 android使用极光推送实现单点登录,但是有些追求完美的人可能就不适用了,因为上一章节我们是通过网页方式来发送下线通知,一般情况下我们是通过后台发送离线通知的。 在此之前,没有看过...
  • 使用webSocket搭建后台消息推送服务,消息确认,消息日志,内网下app消息推送 #svg 顺便有个svg文件动态缩放功能,用到了jquery.svg.pan.zoom.js 具体操作左键双击可以放大,滚轮也可以操作 参考 ...
  • 极光推送在众多的消息推送里,口碑算是很好的,项目中我负责的是这一块,就整理了这篇博客帮助记忆; 极光推送官方SDK文档:https://docs.jiguang.cn/jpush/server/sdk/java_sdk/ 错误码信息:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,530
精华内容 14,612
关键字:

java后台消息推送

java 订阅