ActiveMQ使用线程池实现消息的生产与消费 .
来源:互联网 发布:模拟人生3 for mac 编辑:程序博客网 时间:2024/05/18 12:44
1。 首先先引入相关的lib包,重点需引用activemq-client-5.8.0.jar,activemq-core-5.7.0.jar,activemq-pool-5.8.0.jar,activemq-protobuf-1.1.jar等包,其他包
自行配置。
2。 一些公共工具类的代码:
JMSProducer.java
- package com.ffcs.icity.jms;
- import java.util.Map;
- import java.util.Set;
- import java.util.concurrent.ExecutorService;
- import java.util.concurrent.Executors;
- import javax.jms.Connection;
- import javax.jms.DeliveryMode;
- import javax.jms.Destination;
- import javax.jms.ExceptionListener;
- import javax.jms.JMSException;
- import javax.jms.MapMessage;
- import javax.jms.Message;
- import javax.jms.MessageProducer;
- import javax.jms.Session;
- import org.apache.activemq.ActiveMQConnectionFactory;
- import org.apache.activemq.pool.PooledConnectionFactory;
- /**
- * JMS消息生产者
- * @author linwei
- *
- */
- public class JMSProducer implements ExceptionListener{
- //设置连接的最大连接数
- public final static int DEFAULT_MAX_CONNECTIONS=5;
- private int maxConnections = DEFAULT_MAX_CONNECTIONS;
- //设置每个连接中使用的最大活动会话数
- private int maximumActiveSessionPerConnection = DEFAULT_MAXIMUM_ACTIVE_SESSION_PER_CONNECTION;
- public final static int DEFAULT_MAXIMUM_ACTIVE_SESSION_PER_CONNECTION=300;
- //线程池数量
- private int threadPoolSize = DEFAULT_THREAD_POOL_SIZE;
- public final static int DEFAULT_THREAD_POOL_SIZE=50;
- //强制使用同步返回数据的格式
- private boolean useAsyncSendForJMS = DEFAULT_USE_ASYNC_SEND_FOR_JMS;
- public final static boolean DEFAULT_USE_ASYNC_SEND_FOR_JMS=true;
- //是否持久化消息
- private boolean isPersistent = DEFAULT_IS_PERSISTENT;
- public final static boolean DEFAULT_IS_PERSISTENT=true;
- //连接地址
- private String brokerUrl;
- private String userName;
- private String password;
- private ExecutorService threadPool;
- private PooledConnectionFactory connectionFactory;
- public JMSProducer(String brokerUrl, String userName, String password) {
- this(brokerUrl, userName, password, DEFAULT_MAX_CONNECTIONS, DEFAULT_MAXIMUM_ACTIVE_SESSION_PER_CONNECTION, DEFAULT_THREAD_POOL_SIZE, DEFAULT_USE_ASYNC_SEND_FOR_JMS, DEFAULT_IS_PERSISTENT);
- }
- public JMSProducer(String brokerUrl, String userName, String password, int maxConnections, int maximumActiveSessionPerConnection, int threadPoolSize,boolean useAsyncSendForJMS, boolean isPersistent) {
- this.useAsyncSendForJMS = useAsyncSendForJMS;
- this.isPersistent = isPersistent;
- this.brokerUrl = brokerUrl;
- this.userName = userName;
- this.password = password;
- this.maxConnections = maxConnections;
- this.maximumActiveSessionPerConnection = maximumActiveSessionPerConnection;
- this.threadPoolSize = threadPoolSize;
- init();
- }
- private void init() {
- //设置JAVA线程池
- this.threadPool = Executors.newFixedThreadPool(this.threadPoolSize);
- //ActiveMQ的连接工厂
- ActiveMQConnectionFactory actualConnectionFactory = new ActiveMQConnectionFactory(this.userName, this.password, this.brokerUrl);
- actualConnectionFactory.setUseAsyncSend(this.useAsyncSendForJMS);
- //Active中的连接池工厂
- this.connectionFactory = new PooledConnectionFactory(actualConnectionFactory);
- this.connectionFactory.setCreateConnectionOnStartup(true);
- this.connectionFactory.setMaxConnections(this.maxConnections);
- this.connectionFactory.setMaximumActiveSessionPerConnection(this.maximumActiveSessionPerConnection);
- }
- /**
- * 执行发送消息的具体方法
- * @param queue
- * @param map
- */
- public void send(final String queue, final Map<String, Object> map) {
- //直接使用线程池来执行具体的调用
- this.threadPool.execute(new Runnable(){
- @Override
- public void run() {
- try {
- sendMsg(queue,map);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- });
- }
- /**
- * 真正的执行消息发送
- * @param queue
- * @param map
- * @throws Exception
- */
- private void sendMsg(String queue, Map<String, Object> map) throws Exception {
- Connection connection = null;
- Session session = null;
- try {
- //从连接池工厂中获取一个连接
- connection = this.connectionFactory.createConnection();
- /*createSession(boolean transacted,int acknowledgeMode)
- transacted - indicates whether the session is transacted acknowledgeMode - indicates whether the consumer or the client
- will acknowledge any messages it receives; ignored if the session is transacted.
- Legal values are Session.AUTO_ACKNOWLEDGE, Session.CLIENT_ACKNOWLEDGE, and Session.DUPS_OK_ACKNOWLEDGE.
- */
- //false 参数表示 为非事务型消息,后面的参数表示消息的确认类型
- session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
- //Destination is superinterface of Queue
- //PTP消息方式
- Destination destination = session.createQueue(queue);
- //Creates a MessageProducer to send messages to the specified destination
- MessageProducer producer = session.createProducer(destination);
- //set delevery mode
- producer.setDeliveryMode(this.isPersistent ? DeliveryMode.PERSISTENT : DeliveryMode.NON_PERSISTENT);
- //map convert to javax message
- Message message = getMessage(session, map);
- producer.send(message);
- } finally {
- closeSession(session);
- closeConnection(connection);
- }
- }
- private Message getMessage(Session session, Map<String, Object> map) throws JMSException {
- MapMessage message = session.createMapMessage();
- if (map != null && !map.isEmpty()) {
- Set<String> keys = map.keySet();
- for (String key : keys) {
- message.setObject(key, map.get(key));
- }
- }
- return message;
- }
- private void closeSession(Session session) {
- try {
- if (session != null) {
- session.close();
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- private void closeConnection(Connection connection) {
- try {
- if (connection != null) {
- connection.close();
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- @Override
- public void onException(JMSException e) {
- e.printStackTrace();
- }
- }
package com.ffcs.icity.jms;import java.util.Map;import java.util.Set;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import javax.jms.Connection;import javax.jms.DeliveryMode;import javax.jms.Destination;import javax.jms.ExceptionListener;import javax.jms.JMSException;import javax.jms.MapMessage;import javax.jms.Message;import javax.jms.MessageProducer;import javax.jms.Session;import org.apache.activemq.ActiveMQConnectionFactory;import org.apache.activemq.pool.PooledConnectionFactory;/** * JMS消息生产者 * @author linwei * */public class JMSProducer implements ExceptionListener{//设置连接的最大连接数public final static int DEFAULT_MAX_CONNECTIONS=5;private int maxConnections = DEFAULT_MAX_CONNECTIONS;//设置每个连接中使用的最大活动会话数private int maximumActiveSessionPerConnection = DEFAULT_MAXIMUM_ACTIVE_SESSION_PER_CONNECTION;public final static int DEFAULT_MAXIMUM_ACTIVE_SESSION_PER_CONNECTION=300;//线程池数量private int threadPoolSize = DEFAULT_THREAD_POOL_SIZE;public final static int DEFAULT_THREAD_POOL_SIZE=50;//强制使用同步返回数据的格式private boolean useAsyncSendForJMS = DEFAULT_USE_ASYNC_SEND_FOR_JMS;public final static boolean DEFAULT_USE_ASYNC_SEND_FOR_JMS=true;//是否持久化消息private boolean isPersistent = DEFAULT_IS_PERSISTENT;public final static boolean DEFAULT_IS_PERSISTENT=true; //连接地址private String brokerUrl;private String userName;private String password;private ExecutorService threadPool;private PooledConnectionFactory connectionFactory;public JMSProducer(String brokerUrl, String userName, String password) {this(brokerUrl, userName, password, DEFAULT_MAX_CONNECTIONS, DEFAULT_MAXIMUM_ACTIVE_SESSION_PER_CONNECTION, DEFAULT_THREAD_POOL_SIZE, DEFAULT_USE_ASYNC_SEND_FOR_JMS, DEFAULT_IS_PERSISTENT);}public JMSProducer(String brokerUrl, String userName, String password, int maxConnections, int maximumActiveSessionPerConnection, int threadPoolSize,boolean useAsyncSendForJMS, boolean isPersistent) {this.useAsyncSendForJMS = useAsyncSendForJMS;this.isPersistent = isPersistent;this.brokerUrl = brokerUrl;this.userName = userName;this.password = password;this.maxConnections = maxConnections;this.maximumActiveSessionPerConnection = maximumActiveSessionPerConnection;this.threadPoolSize = threadPoolSize;init();} private void init() {//设置JAVA线程池this.threadPool = Executors.newFixedThreadPool(this.threadPoolSize);//ActiveMQ的连接工厂ActiveMQConnectionFactory actualConnectionFactory = new ActiveMQConnectionFactory(this.userName, this.password, this.brokerUrl);actualConnectionFactory.setUseAsyncSend(this.useAsyncSendForJMS);//Active中的连接池工厂this.connectionFactory = new PooledConnectionFactory(actualConnectionFactory);this.connectionFactory.setCreateConnectionOnStartup(true);this.connectionFactory.setMaxConnections(this.maxConnections);this.connectionFactory.setMaximumActiveSessionPerConnection(this.maximumActiveSessionPerConnection);}/** * 执行发送消息的具体方法 * @param queue * @param map */public void send(final String queue, final Map<String, Object> map) {//直接使用线程池来执行具体的调用this.threadPool.execute(new Runnable(){@Overridepublic void run() {try {sendMsg(queue,map);} catch (Exception e) {e.printStackTrace();}}});}/** * 真正的执行消息发送 * @param queue * @param map * @throws Exception */private void sendMsg(String queue, Map<String, Object> map) throws Exception {Connection connection = null;Session session = null;try {//从连接池工厂中获取一个连接connection = this.connectionFactory.createConnection();/*createSession(boolean transacted,int acknowledgeMode) transacted - indicates whether the session is transacted acknowledgeMode - indicates whether the consumer or the client will acknowledge any messages it receives; ignored if the session is transacted. Legal values are Session.AUTO_ACKNOWLEDGE, Session.CLIENT_ACKNOWLEDGE, and Session.DUPS_OK_ACKNOWLEDGE.*///false 参数表示 为非事务型消息,后面的参数表示消息的确认类型session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);//Destination is superinterface of Queue//PTP消息方式 Destination destination = session.createQueue(queue);//Creates a MessageProducer to send messages to the specified destinationMessageProducer producer = session.createProducer(destination);//set delevery modeproducer.setDeliveryMode(this.isPersistent ? DeliveryMode.PERSISTENT : DeliveryMode.NON_PERSISTENT);//map convert to javax messageMessage message = getMessage(session, map);producer.send(message);} finally {closeSession(session);closeConnection(connection);}}private Message getMessage(Session session, Map<String, Object> map) throws JMSException {MapMessage message = session.createMapMessage();if (map != null && !map.isEmpty()) {Set<String> keys = map.keySet();for (String key : keys) {message.setObject(key, map.get(key));}}return message;}private void closeSession(Session session) {try {if (session != null) {session.close();}} catch (Exception e) {e.printStackTrace();}}private void closeConnection(Connection connection) {try {if (connection != null) {connection.close();}} catch (Exception e) {e.printStackTrace();}}@Overridepublic void onException(JMSException e) {e.printStackTrace();}}
JMSConsumer.java
- package com.ffcs.icity.jms;
- import javax.jms.Connection;
- import javax.jms.ConnectionFactory;
- import javax.jms.Destination;
- import javax.jms.ExceptionListener;
- import javax.jms.JMSException;
- import javax.jms.MessageConsumer;
- import javax.jms.MessageListener;
- import javax.jms.Session;
- import org.apache.activemq.ActiveMQConnection;
- import org.apache.activemq.ActiveMQConnectionFactory;
- import org.apache.activemq.ActiveMQPrefetchPolicy;
- /**
- * JMS消息消费者
- * @author linwei
- *
- */
- public class JMSConsumer implements ExceptionListener {
- //队列预取策略
- private int queuePrefetch=DEFAULT_QUEUE_PREFETCH;
- public final static int DEFAULT_QUEUE_PREFETCH=10;
- private String brokerUrl;
- private String userName;
- private String password;
- private MessageListener messageListener;
- private Connection connection;
- private Session session;
- //队列名
- private String queue;
- /**
- * 执行消息获取的操作
- * @throws Exception
- */
- public void start() throws Exception {
- //ActiveMQ的连接工厂
- ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(this.userName, this.password, this.brokerUrl);
- connection = connectionFactory.createConnection();
- //activeMQ预取策略
- ActiveMQPrefetchPolicy prefetchPolicy = new ActiveMQPrefetchPolicy();
- prefetchPolicy.setQueuePrefetch(queuePrefetch);
- ((ActiveMQConnection) connection).setPrefetchPolicy(prefetchPolicy);
- connection.setExceptionListener(this);
- connection.start();
- //会话采用非事务级别,消息到达机制使用自动通知机制
- session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
- Destination destination = session.createQueue(this.queue);
- MessageConsumer consumer = session.createConsumer(destination);
- consumer.setMessageListener(this.messageListener);
- }
- /**
- * 关闭连接
- */
- public void shutdown(){
- try {
- if (session != null) {
- session.close();
- session=null;
- }
- if (connection != null) {
- connection.close();
- connection=null;
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- @Override
- public void onException(JMSException e) {
- e.printStackTrace();
- }
- public String getBrokerUrl() {
- return brokerUrl;
- }
- public void setBrokerUrl(String brokerUrl) {
- this.brokerUrl = brokerUrl;
- }
- public String getUserName() {
- return userName;
- }
- public void setUserName(String userName) {
- this.userName = userName;
- }
- public String getPassword() {
- return password;
- }
- public void setPassword(String password) {
- this.password = password;
- }
- public String getQueue() {
- return queue;
- }
- public void setQueue(String queue) {
- this.queue = queue;
- }
- public MessageListener getMessageListener() {
- return messageListener;
- }
- public void setMessageListener(MessageListener messageListener) {
- this.messageListener = messageListener;
- }
- public int getQueuePrefetch() {
- return queuePrefetch;
- }
- public void setQueuePrefetch(int queuePrefetch) {
- this.queuePrefetch = queuePrefetch;
- }
- }
package com.ffcs.icity.jms;import javax.jms.Connection;import javax.jms.ConnectionFactory;import javax.jms.Destination;import javax.jms.ExceptionListener;import javax.jms.JMSException;import javax.jms.MessageConsumer;import javax.jms.MessageListener;import javax.jms.Session;import org.apache.activemq.ActiveMQConnection;import org.apache.activemq.ActiveMQConnectionFactory;import org.apache.activemq.ActiveMQPrefetchPolicy;/** * JMS消息消费者 * @author linwei * */public class JMSConsumer implements ExceptionListener {//队列预取策略private int queuePrefetch=DEFAULT_QUEUE_PREFETCH;public final static int DEFAULT_QUEUE_PREFETCH=10;private String brokerUrl;private String userName;private String password;private MessageListener messageListener;private Connection connection;private Session session;//队列名private String queue;/** * 执行消息获取的操作 * @throws Exception */public void start() throws Exception {//ActiveMQ的连接工厂ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(this.userName, this.password, this.brokerUrl);connection = connectionFactory.createConnection();//activeMQ预取策略ActiveMQPrefetchPolicy prefetchPolicy = new ActiveMQPrefetchPolicy();prefetchPolicy.setQueuePrefetch(queuePrefetch);((ActiveMQConnection) connection).setPrefetchPolicy(prefetchPolicy);connection.setExceptionListener(this);connection.start();//会话采用非事务级别,消息到达机制使用自动通知机制session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);Destination destination = session.createQueue(this.queue);MessageConsumer consumer = session.createConsumer(destination);consumer.setMessageListener(this.messageListener);}/** * 关闭连接 */public void shutdown(){try {if (session != null) {session.close();session=null;}if (connection != null) {connection.close();connection=null;}} catch (Exception e) {e.printStackTrace();}}@Overridepublic void onException(JMSException e) {e.printStackTrace();}public String getBrokerUrl() {return brokerUrl;}public void setBrokerUrl(String brokerUrl) {this.brokerUrl = brokerUrl;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public String getQueue() {return queue;}public void setQueue(String queue) {this.queue = queue;}public MessageListener getMessageListener() {return messageListener;}public void setMessageListener(MessageListener messageListener) {this.messageListener = messageListener;}public int getQueuePrefetch() {return queuePrefetch;}public void setQueuePrefetch(int queuePrefetch) {this.queuePrefetch = queuePrefetch;}}
MessageHandler.java
- package com.ffcs.icity.jms;
- import javax.jms.Message;
- /**
- * 提供消息操作的回调接口
- * @author linwei
- *
- */
- public interface MessageHandler {
- /**
- * 消息回调提供的调用方法
- * @param message
- */
- public void handle(Message message);
- }
package com.ffcs.icity.jms;import javax.jms.Message;/** * 提供消息操作的回调接口 * @author linwei * */public interface MessageHandler {/** * 消息回调提供的调用方法 * @param message */public void handle(Message message);}
MultiThreadMessageListener.java
- package com.ffcs.icity.jms;
- import java.util.concurrent.ExecutorService;
- import javax.jms.Message;
- import javax.jms.MessageListener;
- /**
- * 消息消费者中使用的多线程消息监听服务
- * @author linwei
- *
- */
- public class MultiThreadMessageListener implements MessageListener {
- //默认线程池数量
- public final static int DEFAULT_HANDLE_THREAD_POOL=10;
- //最大的处理线程数.
- private int maxHandleThreads;
- //提供消息回调调用接口
- private MessageHandler messageHandler;
- private ExecutorService handleThreadPool;
- public MultiThreadMessageListener(MessageHandler messageHandler){
- this(DEFAULT_HANDLE_THREAD_POOL, messageHandler);
- }
- public MultiThreadMessageListener(int maxHandleThreads,MessageHandler messageHandler){
- this.maxHandleThreads=maxHandleThreads;
- this.messageHandler=messageHandler;
- //支持阻塞的固定大小的线程池(自行手动创建的)
- this.handleThreadPool = new FixedAndBlockedThreadPoolExecutor(this.maxHandleThreads);
- }
- /**
- * 监听程序中自动调用的方法
- */
- @Override
- public void onMessage(final Message message) {
- //使用支持阻塞的固定大小的线程池来执行操作
- this.handleThreadPool.execute(new Runnable() {
- public void run() {
- try {
- MultiThreadMessageListener.this.messageHandler.handle(message);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- });
- }
- }
package com.ffcs.icity.jms;import java.util.concurrent.ExecutorService;import javax.jms.Message;import javax.jms.MessageListener;/** * 消息消费者中使用的多线程消息监听服务 * @author linwei * */public class MultiThreadMessageListener implements MessageListener {//默认线程池数量public final static int DEFAULT_HANDLE_THREAD_POOL=10;//最大的处理线程数.private int maxHandleThreads;//提供消息回调调用接口private MessageHandler messageHandler;private ExecutorService handleThreadPool;public MultiThreadMessageListener(MessageHandler messageHandler){this(DEFAULT_HANDLE_THREAD_POOL, messageHandler);}public MultiThreadMessageListener(int maxHandleThreads,MessageHandler messageHandler){this.maxHandleThreads=maxHandleThreads;this.messageHandler=messageHandler;//支持阻塞的固定大小的线程池(自行手动创建的)this.handleThreadPool = new FixedAndBlockedThreadPoolExecutor(this.maxHandleThreads);}/** * 监听程序中自动调用的方法 */@Overridepublic void onMessage(final Message message) {//使用支持阻塞的固定大小的线程池来执行操作this.handleThreadPool.execute(new Runnable() {public void run() {try {MultiThreadMessageListener.this.messageHandler.handle(message);} catch (Exception e) {e.printStackTrace();}}});}}
FixedAndBlockedThreadPoolExecutor.java
- package com.ffcs.icity.jms;
- import java.util.concurrent.BlockingQueue;
- import java.util.concurrent.LinkedBlockingQueue;
- import java.util.concurrent.ThreadPoolExecutor;
- import java.util.concurrent.TimeUnit;
- import java.util.concurrent.locks.Condition;
- import java.util.concurrent.locks.ReentrantLock;
- /**
- * 支持阻塞的固定大小的线程池
- * @author linwei
- *
- */
- public class FixedAndBlockedThreadPoolExecutor extends ThreadPoolExecutor {
- //一个可重入的互斥锁 Lock,它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义,但功能更强大。
- //使用 lock 块来调用 try,在之前/之后的构造中
- private ReentrantLock lock = new ReentrantLock();
- private Condition condition = this.lock.newCondition();
- public FixedAndBlockedThreadPoolExecutor(int size) {
- super(size, size, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
- }
- /**
- * 当线程池中没有空闲线程时,会挂起此方法的调用线程.直到线程池中有线程有空闲线程.
- */
- @Override
- public void execute(Runnable command) {
- //进行同步锁定
- this.lock.lock();
- super.execute(command);
- try {
- //如果线程池的数量已经达到最大线程池的数量,则进行挂起操作
- if (getPoolSize() == getMaximumPoolSize()) {
- this.condition.await();
- }
- } catch (InterruptedException e) {
- e.printStackTrace();
- } finally {
- this.lock.unlock();
- }
- }
- @Override
- protected void afterExecute(Runnable r, Throwable t) {
- super.afterExecute(r, t);
- try {
- this.lock.lock();
- this.condition.signal();
- } finally {
- this.lock.unlock();
- }
- }
- }
package com.ffcs.icity.jms;import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.ReentrantLock;/** * 支持阻塞的固定大小的线程池 * @author linwei * */public class FixedAndBlockedThreadPoolExecutor extends ThreadPoolExecutor {//一个可重入的互斥锁 Lock,它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义,但功能更强大。//使用 lock 块来调用 try,在之前/之后的构造中private ReentrantLock lock = new ReentrantLock();private Condition condition = this.lock.newCondition();public FixedAndBlockedThreadPoolExecutor(int size) {super(size, size, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());}/** * 当线程池中没有空闲线程时,会挂起此方法的调用线程.直到线程池中有线程有空闲线程. */@Overridepublic void execute(Runnable command) {//进行同步锁定this.lock.lock();super.execute(command);try {//如果线程池的数量已经达到最大线程池的数量,则进行挂起操作if (getPoolSize() == getMaximumPoolSize()) {this.condition.await();}} catch (InterruptedException e) {e.printStackTrace();} finally {this.lock.unlock();}}@Overrideprotected void afterExecute(Runnable r, Throwable t) {super.afterExecute(r, t);try {this.lock.lock();this.condition.signal();} finally {this.lock.unlock();}}}
3. 调用例子说明:
生产者调用代码,JMSProducerTest.java
- package com.ffcs.icity.test;
- import java.util.HashMap;
- import java.util.Map;
- import com.ffcs.icity.jms.JMSProducer;
- public class JMSProducerTest {
- public static void main(String[] args) {
- locationTest();
- System.out.println("over.");
- }
- private static void locationTest() {
- //** JMSProducer 可以设置成全局的静态变量,只需实例化一次即可使用,禁止循环重复实例化JMSProducer(因为其内部存在一个线程池)
- //支持openwire协议的默认连接为 tcp://localhost:61616,支持 stomp协议的默认连接为tcp://localhost:61613。
- //tcp和nio的区别
- //nio://localhost:61617 以及 tcp://localhost:61616均可在 activemq.xml配置文件中进行配置
- JMSProducer producer = new JMSProducer("nio://localhost:61617", "system", "manager");
- Map<String, Object> map = new HashMap<String, Object>();
- map.put("id", "1");
- map.put("name", "sss1113333");
- map.put("password", "password");
- producer.send("test", map);
- }
- }
package com.ffcs.icity.test;import java.util.HashMap;import java.util.Map;import com.ffcs.icity.jms.JMSProducer;public class JMSProducerTest {public static void main(String[] args) {locationTest();System.out.println("over.");}private static void locationTest() {//** JMSProducer 可以设置成全局的静态变量,只需实例化一次即可使用,禁止循环重复实例化JMSProducer(因为其内部存在一个线程池)//支持openwire协议的默认连接为 tcp://localhost:61616,支持 stomp协议的默认连接为tcp://localhost:61613。 //tcp和nio的区别//nio://localhost:61617 以及 tcp://localhost:61616均可在 activemq.xml配置文件中进行配置JMSProducer producer = new JMSProducer("nio://localhost:61617", "system", "manager");Map<String, Object> map = new HashMap<String, Object>();map.put("id", "1");map.put("name", "sss1113333");map.put("password", "password");producer.send("test", map);}}
消费者调用代码,JMSConsumerTest.java
- package com.ffcs.icity.test;
- import javax.jms.MapMessage;
- import javax.jms.Message;
- import com.ffcs.icity.jms.JMSConsumer;
- import com.ffcs.icity.jms.MessageHandler;
- import com.ffcs.icity.jms.MultiThreadMessageListener;
- public class JMSConsumerTest {
- public static void main(String[] args) throws Exception {
- //** JMSConsumer 可以设置成全局的静态变量,只需实例化一次即可使用,禁止循环重复实例化JMSConsumer(因为其内部存在一个线程池)
- JMSConsumer consumer = new JMSConsumer();
- consumer.setBrokerUrl("tcp://localhost:61616");
- consumer.setQueue("test");
- consumer.setUserName("system");
- consumer.setPassword("manager");
- consumer.setQueuePrefetch(500);
- consumer.setMessageListener(new MultiThreadMessageListener(50,new MessageHandler() {
- public void handle(Message message) {
- try {
- System.out.println("name is " + ((MapMessage)message).getString("name"));
- Thread.sleep(5000);
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- }));
- consumer.start();
- // Thread.sleep(5000);
- // consumer.shutdown();
- }
- }
package com.ffcs.icity.test;import javax.jms.MapMessage;import javax.jms.Message;import com.ffcs.icity.jms.JMSConsumer;import com.ffcs.icity.jms.MessageHandler;import com.ffcs.icity.jms.MultiThreadMessageListener;public class JMSConsumerTest {public static void main(String[] args) throws Exception {//** JMSConsumer 可以设置成全局的静态变量,只需实例化一次即可使用,禁止循环重复实例化JMSConsumer(因为其内部存在一个线程池)JMSConsumer consumer = new JMSConsumer();consumer.setBrokerUrl("tcp://localhost:61616");consumer.setQueue("test");consumer.setUserName("system");consumer.setPassword("manager");consumer.setQueuePrefetch(500);consumer.setMessageListener(new MultiThreadMessageListener(50,new MessageHandler() {public void handle(Message message) {try {System.out.println("name is " + ((MapMessage)message).getString("name"));Thread.sleep(5000);} catch (Exception e) {e.printStackTrace();}}}));consumer.start();//Thread.sleep(5000);//consumer.shutdown();}}
0 0
- ActiveMQ使用线程池实现消息的生产与消费
- ActiveMQ使用线程池实现消息的生产与消费 .
- ActiveMQ使用线程池实现消息的生产与消费
- ActiveMQ使用线程池实现消息的生产与消费
- ActiveMQ使用线程池实现消息的生产与消费
- ActiveMQ消息队列之java消息生产与消费
- 初次尝试ActiveMQ,实现简单的消息生产和消息消费
- ActiveMQ五种消息类型生产消费
- 经典的生产与消费线程同步问题
- SpringCloud Stream-----2、消息生产与消费
- java线程之生产与消费
- java线程之生产与消费
- rocketMq的消息的生产和消费
- 线程的简单生产消费模式
- 使用Lock与ReentrantLock模拟消息队列阻塞,生产与消费问题模拟
- 线程生产消费模式
- 线程---生产消费问题
- 生产/消费模型的java实现
- iOS开发--从TQRichTextViewDemo中学会分析工程
- Eclipse 中 按 Ctrl+Shift+F 格式化代码时每行容纳的字符数
- PJSIP开发手册之即时消息(十六)
- python官网及说明资料
- Android 5.0(L) ToolBar(替代ActionBar) 实战(四)
- ActiveMQ使用线程池实现消息的生产与消费 .
- 关路灯(MM不哭)解题报告
- JAVA 对象引用,以及对象赋值
- iOS8 UIDatePicker 键盘没有弹出的解决方法
- IO-Blocking和Synchronous
- 8、Ken Burns特效的幻灯片
- 数据缓存
- Mac os10.10 下php redis 的安装
- 【POJ1328】Radar Installation 贪心