JavaEE知识整理系列(六)JMS .

转载 2013年12月04日 10:37:38
 DIY例子

使用JMS不仅能发送(send)/发布(publish)消息,也能获得(receive)/订阅(subscribe)的消息,消息的发送(send)/发布(publish)和(receive)/订阅(subscribe)和JBOSS的相对位置是无关的,这个在实际应用中非常有用。在C/S架构的软件中,一般S端部署了JBOSS,作为JMS的publisher,而C端一般是Java程序,作为JMS的subscriber。这里以topic的形式举例说明,注:下面以可序列化的Map作为消息传输载体。

 

  1. import org.martin.common.communication.jms.JmsService;  
  2. import org.martin.common.communication.jms.JmsServiceImpl;  
  3.   
  4. public class ServiceAccess  
  5. {  
  6.     public static JmsService  getJMSService(){  
  7.         return new JmsServiceImpl();  
  8.     }  
  9. }  
  10. package org.martin.common.communication.jms;  
  11. public class Constants  
  12. {  
  13.     public static final int DEST_TYPE_TOPIC=1;  
  14.     public static final int DEST_TYPE_QUEUE=2;  
  15.     public static final int DEST_OPER_ADD=1;  
  16.     public static final int DEST_OPER_DELETE=2;  
  17. }  
  18. public class JmsAsyncReceiver  
  19. {  
  20.   
  21.     private TopicConnection topicConnection;  
  22.     private TopicSession    topicSession;  
  23.     private TopicSubscriber topicSubscriber;  
  24.     private Topic           topic;  
  25.       
  26.     @SuppressWarnings("unchecked")  
  27.     public JmsAsyncReceiver(String factoryJNDI, String topicJNDI,  
  28.          MessageListener messagelistener) throws JMSException,NamingException  
  29.     {  
  30.         Hashtable props = new Hashtable();  
  31.         props.put(Context.INITIAL_CONTEXT_FACTORY,  
  32.                         "org.jnp.interfaces.NamingContextFactory");  
  33.         props.put(Context.PROVIDER_URL, "localhost:1099");  
  34.         props.put("java.naming.rmi.security.manager""yes");  
  35.         props.put(Context.URL_PKG_PREFIXES, "org.jboss.naming");  
  36.         Context context = new InitialContext(props);  
  37.         TopicConnectionFactory topicFactory = (TopicConnectionFactory)  
  38.                                           context.lookup(factoryJNDI);  
  39.         topicConnection = topicFactory.createTopicConnection();  
  40.         topicSession = topicConnection.createTopicSession(false,  
  41.                                              Session.AUTO_ACKNOWLEDGE);  
  42.         topic = (Topic) context.lookup(topicJNDI);  
  43.         topicSubscriber = topicSession.createSubscriber(topic);  
  44.         topicSubscriber.setMessageListener(messagelistener);  
  45.         System.out.println("AsyncReceiver subscribed to topic: " + topicJNDI);  
  46.         topicConnection.start();  
  47.     }  
  48.       
  49.     public void close() throws JMSException  
  50.     {  
  51.         topicSession.close();  
  52.         topicConnection.close();  
  53.     }  
  54. }  
  55. public class JmsHelper  
  56. {  
  57.     public static void addDestination(String destName){  
  58.         try{  
  59.             invokeViaMBean("createTopic", destName);  
  60.         }catch(Exception e){  
  61.             //e.printStackTrace();   
  62.             try{  
  63.                 invokeViaMBeanInDiffJVM("createTopic",  destName);  
  64.             }catch(Exception e1){  
  65.                 //e1.printStackTrace();   
  66.             }  
  67.         }  
  68.     }  
  69.       
  70.     private static void invokeViaMBean(String method, String destName) throws Exception  
  71.     {  
  72.         MBeanServer server = (MBeanServer) MBeanServerFactory.findMBeanServer(null)  
  73.                         .iterator().next();  
  74.         server.invoke(new ObjectName("jboss.mq""service""DestinationManager"), method,  
  75.                         new Object[] { destName }, new String[] { "java.lang.String" });  
  76.     }  
  77.       
  78.     private static void invokeViaMBeanInDiffJVM(String method, String destName)throws Exception{  
  79.         Context context;  
  80.         Hashtable <String, String> jndi = new Hashtable <String, String>();  
  81.         jndi.put(Context.INITIAL_CONTEXT_FACTORY, "org.jnp.interfaces.NamingContextFactory");  
  82.         jndi.put(Context.URL_PKG_PREFIXES, "org.jboss.naming:org.jnp.interfaces");  
  83.         jndi.put(Context.PROVIDER_URL, "localhost:1099");  
  84.   
  85.         context = new InitialContext(jndi);  
  86.         MBeanServerConnection server = (MBeanServerConnection) context.lookup("jmx/invoker/RMIAdaptor");  
  87.         server.invoke(new ObjectName("jboss.mq:service=DestinationManager"),  
  88.                         method,  
  89.                       new Object[] {destName, "topic/" + destName},  
  90.                       new String[] {"java.lang.String""java.lang.String"});  
  91.     }  
  92. }  
  93. public interface JmsReceiveListener  
  94. {  
  95.     void onMessage(Object msg);  
  96. }  
  97. public class JmsReceiveScheduler implements MessageListener  
  98. {  
  99.     private JmsAsyncReceiver regInfo;  
  100.     private ConcurrentHashMap<String, JmsReceiveListener> listenerMap   
  101.                 = new ConcurrentHashMap<String, JmsReceiveListener>();  
  102.     private String destination=null;  
  103.       
  104.     public JmsReceiveScheduler(String destination)   
  105.     throws JMSException, NamingException  
  106.     {  
  107.         this.destination=destination;  
  108.         JmsService service=ServiceAccess.getJMSService();  
  109.         regInfo = service.registAsyncReceive(Constants.DEST_TYPE_TOPIC,   
  110.                         this.destination, this);  
  111.     }  
  112.       
  113.     public  void registerListener(String clientID, JmsReceiveListener listener)  
  114.     {  
  115.         listenerMap.put(clientID, listener);  
  116.     }  
  117.       
  118.     public  void unregisterListener(String id)  
  119.     {  
  120.         listenerMap.remove(id);  
  121.     }  
  122.       
  123.     public  void close() throws JMSException  
  124.     {  
  125.         regInfo.close();  
  126.     }  
  127.   
  128.     @SuppressWarnings("unchecked")  
  129.     public void onMessage(Message msgIn)  
  130.     {  
  131.         ObjectMessage objMsg = (ObjectMessage) msgIn;  
  132.         Map map=null;  
  133.         try{  
  134.             map = (HashMap) objMsg.getObject();  
  135.         }catch(JMSException e){  
  136.             e.printStackTrace();  
  137.         }  
  138.         String clientID = (String) map.get("CLIENT_ID");  
  139.         JmsReceiveListener listener = listenerMap.get(clientID);  
  140.         if(listener != null)  
  141.         {  
  142.             listener.onMessage(map.get("DATA"));  
  143.         }  
  144.     }  
  145. }  
  146. public class JmsSender  
  147. {  
  148.     private TopicConnection topicConnection;  
  149.     private TopicSession    topicSession;  
  150.     private TopicPublisher  topicPublisher;  
  151.     private Topic           topic;  
  152.       
  153.     @SuppressWarnings("unchecked")  
  154.     public JmsSender(String factoryJNDI, String topicJNDI)   
  155.            throws JMSException,NamingException  
  156.     {  
  157.         Hashtable props = new Hashtable();  
  158.         props.put(Context.INITIAL_CONTEXT_FACTORY,  
  159.                         "org.jnp.interfaces.NamingContextFactory");  
  160.         props.put(Context.PROVIDER_URL, "localhost:1099");  
  161.         props.put("java.naming.rmi.security.manager""yes");  
  162.         props.put(Context.URL_PKG_PREFIXES, "org.jboss.naming");  
  163.         Context context = new InitialContext(props);  
  164.         TopicConnectionFactory topicFactory = (TopicConnectionFactory) context  
  165.                         .lookup(factoryJNDI);  
  166.         topicConnection = topicFactory.createTopicConnection();  
  167.         topicSession = topicConnection  
  168.                         .createTopicSession(false, Session.AUTO_ACKNOWLEDGE);  
  169.           
  170.         topic = (Topic) context.lookup(topicJNDI);  
  171.         topicPublisher = topicSession.createPublisher(topic);  
  172.           
  173.     }  
  174.       
  175.     @SuppressWarnings("unchecked")  
  176.     public void publish(Map msg) throws JMSException  
  177.     {  
  178.         ObjectMessage  message = topicSession.createObjectMessage();  
  179.         message.setObject((Serializable) msg);  
  180.         topicPublisher.publish(topic, message);   
  181.     }  
  182.       
  183.     public void close() throws JMSException  
  184.     {  
  185.         topicSession.close();  
  186.         topicConnection.close();  
  187.     }  
  188.   
  189. }  
  190. public class JmsSenderWrapped  
  191. {  
  192.   
  193.     private static JmsSender sender;  
  194.   
  195.     public JmsSenderWrapped(String destination)   
  196.     throws JMSException, NamingException{  
  197.         JmsService  jmsService = ServiceAccess.getJMSService();  
  198.         sender = jmsService.getSender(Constants.DEST_TYPE_TOPIC, destination);  
  199.     }  
  200.   
  201.     @SuppressWarnings("unchecked")  
  202.     public  void sendJMSMessage(String clientID, Serializable dataIn)   
  203.     throws JMSException  
  204.     {  
  205.         Map map = new HashMap();  
  206.         map.put("CLIENT_ID", clientID);  
  207.         map.put("DATA", dataIn);  
  208.         sender.publish( map);  
  209.     }  
  210.       
  211.     public void close() throws JMSException{  
  212.         sender.close();  
  213.     }  
  214. }  
  215. public interface JmsService  
  216. {  
  217.     JmsAsyncReceiver registAsyncReceive(int destType,String destination,  
  218.        MessageListener listener) throws JMSException, NamingException;  
  219.   
  220.     JmsSender getSender(int destType, String destination) throws JMSException,   
  221.     NamingException;  
  222.       
  223.     public void operDestination(int operType,int destType, String destination);  
  224. }  
  225. public class JmsServiceImpl implements JmsService  
  226. {  
  227.     public JmsAsyncReceiver registAsyncReceive(int destType, String destination,  
  228.     MessageListener listener) throws JMSException, NamingException  
  229.     {  
  230.         if(destType==Constants.DEST_TYPE_TOPIC){  
  231.             JmsAsyncReceiver receivere = new JmsAsyncReceiver  
  232.             ("TopicConnectionFactory","topic/"+destination, listener);  
  233.             return receivere;  
  234.         }else if(destType==Constants.DEST_TYPE_QUEUE){  
  235.               
  236.         }  
  237.         return null;  
  238.     }  
  239.   
  240.     public JmsSender getSender(int destType, String destination)   
  241.     throws JMSException, NamingException  
  242.     {  
  243.         if(destType==Constants.DEST_TYPE_TOPIC){  
  244.             JmsSender sender=new JmsSender  
  245.             ( "ConnectionFactory",  "topic/"+destination);  
  246.             return sender;  
  247.         }  
  248.         return null;  
  249.     }  
  250.   
  251.     public void operDestination(int operType,int destType, String destination)  
  252.     {  
  253.         if(destType==Constants.DEST_TYPE_TOPIC){  
  254.             if(operType==Constants.DEST_OPER_ADD){  
  255.                 JmsHelper.addDestination(destination);  
  256.             }  
  257.         }  
  258.           
  259.     }    
  260.       
  261. }  
  262. public class ReceiveTest  
  263. {  
  264.     public static void main(String[]args){  
  265.         String destName="MyTestDestination";  
  266.         String clientName="MyTClientName";  
  267.         JmsService service=ServiceAccess.getJMSService();  
  268.         service.operDestination(Constants.DEST_OPER_ADD,  
  269.                         Constants.DEST_TYPE_TOPIC, destName);  
  270.           
  271.         JmsReceiveScheduler schedul=null;  
  272.         try{  
  273.             schedul=new JmsReceiveScheduler(destName);  
  274.         }catch(JMSException e){  
  275.             e.printStackTrace();  
  276.         }catch(NamingException e){  
  277.             e.printStackTrace();  
  278.         }  
  279.         schedul.registerListener(clientName, new JmsReceiveListener(){  
  280.   
  281.             public void onMessage(Object msg)  
  282.             {  
  283.                 System.out.println(msg);  
  284.             }   
  285.         });  
  286.     }  
  287. }  
  288. public class SendTest  
  289. {  
  290.     public static void main(String[]args){  
  291.         String destName="MyTestDestination";  
  292.         String clientName="MyTClientName";  
  293.         JmsService service=ServiceAccess.getJMSService();  
  294.         service.operDestination(Constants.DEST_OPER_ADD,  
  295.                         Constants.DEST_TYPE_TOPIC, destName);  
  296.           
  297.         JmsSenderWrapped send=null;  
  298.         try{  
  299.             send=new JmsSenderWrapped(destName);  
  300.         }catch(JMSException e){  
  301.             e.printStackTrace();  
  302.         }catch(NamingException e){  
  303.             e.printStackTrace();  
  304.         }  
  305.         for(int i=0;i<10;i++){  
  306.             try{  
  307.                 send.sendJMSMessage(clientName, "count:"+i);  
  308.             }catch(JMSException e){  
  309.                 e.printStackTrace();  
  310.             }  
  311.         }  
  312.     }  
  313. }  

相关文章推荐

JBoss 系列六:JBoss 7/WildFly中配置使用JMS消息队列

内容概要 JBoss 系列六主要目的是演示如何在JBoss 7/WildFly中配置使用JMS消息队列,本文章分三部分:在JBoss服务器上创建消息队列,在JBoss服务器上创建安全Applicati...

原生态JAVAEE酒店管理系统系列六

酒店管理系统系列先暂告一段落了,最近要开始忙实习的事情了,开始复习刷题 后期如果有时间,会完善一下,加入组合查询和分页的功能 项目地址:139.129.12.4:8080/hotel a...

javaee.jar+jms.jar

  • 2011-12-16 12:12
  • 878KB
  • 下载

JBoss 系列六十二:深入理解 jBPM Human Task - II(使用JMS做传输媒介执行Human Task)

概述 本文是继深入理解 jBPM Human Task - I,对使用JMS做传输类型过程中服务器端和客户端业务逻辑的明细。本文也是基于之前代码分析系列: 服务器端代码 - jBPM Human ...

jms--javaee 培训材料

  • 2012-11-24 18:55
  • 1.53MB
  • 下载

JMS消息服务器(一)——基础知识

1、概述 异构集成(heterogeneous integration)是消息传送机制在其中起关键作用的一个领域。无论它的成因是合并、并购、业务需求,或者仅仅是技术方向上的一个变化,越来越多的公司都...

JBoss 系列八十四: 使用 JMS session 时的一个误区

概述 我们通常使用 JMS session 连接JMS消息队列,创建生产者往队列发送消息,或创建消费者从队列消费消息,BaseJMSTaskServer.java中的start()方法就是一个例子,...

JMS&MQ系列之简单示例

1. 发送Message /** * * @author geloin * @date 2012-9-10 下午6:22:43 */ package com.geloin.activemq...
  • geloin
  • geloin
  • 2012-09-11 15:33
  • 1043

MOM系列文章之 - JMS2 spec. 解读

JMS 2是Java EE 7的一个重要特性之一,如下图:   本文重点关注的是JMS 2规范,通过近4个小时的阅读(156 Page),谈谈自己对新规范的一些理解,后续会陆续发表一些Commo...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)