activemq基础

Client

package com.my.test.activemq.client;

import java.util.UUID;

import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerService;

public class Client implements MessageListener{

	private BrokerService broker;
    private final String brokerUrl = "tcp://localhost:61616";
    private Connection connection;
    private Session session;
    private Queue tempDest;
    private MessageProducer producer;
    private MessageConsumer consumer;

    private final String requestQueue = "requestQueue";

    public void start() throws Exception {
    	/**
    	 * 获取连接
    	 */
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(brokerUrl);
        connection = connectionFactory.createConnection();
        connection.start();
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Destination adminQueue = session.createQueue(requestQueue);
        /**
         * 创建生产者
         */
        producer = session.createProducer(adminQueue);
        /**
         *传递模式
         */
        producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
        
        /**
         * createTemporaryQueue():
         * 创建临时的queue：
         * 虽然它们是由Session来创建的，但是它们的生命周期确实整个Connection。
         * 如果在一个Connection上创建了两个Session，则 一个Session创建的
         * TemporaryQueue或TemporaryTopic也可以被另一个Session访问。
         * 那如果这两个Session是由不同的Connection创建，则一个Session
         * 创建的TemporaryQueue不可以被另一个Session访问。
		      另外，它们的主要作用就是用来指定回复目的地， 即作为JMSReplyTo。
         */
        tempDest = session.createTemporaryQueue();
        
        /**
         * 创建消费者用于接受响应用于接受响应
         */
        consumer = session.createConsumer(tempDest);
        consumer.setMessageListener(this);
    }

    public void stop() throws Exception {
        producer.close();
        consumer.close();
        session.close();
        broker.stop();
    }

    public void request(String request) throws JMSException {
        System.out.println("Requesting: " + request);
        TextMessage txtMessage = session.createTextMessage();
        txtMessage.setText(request);
        txtMessage.setJMSReplyTo(tempDest);
        String correlationId = UUID.randomUUID().toString();
        txtMessage.setJMSCorrelationID(correlationId);
        this.producer.send(txtMessage);
    }

    public void onMessage(Message message) {
        try {
            System.out.println("Received response for: " + ((TextMessage) message).getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
              Client client = new Client();
              client.start();
              int i = 0;
              while (i++ < 10) {
               client.request("REQUEST-" + i);
              }
              Thread.sleep(3000);
              client.stop();
    }
	
}

Server

package com.my.test.activemq.server;

import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerService;

public class Server implements MessageListener {
	private BrokerService broker;
    private final String brokerUrl = "tcp://localhost:61616";
    private Session session;
    private MessageProducer producer;
    private MessageConsumer consumer;
    private final String requestQueue = "requestQueue";

    public void start() throws Exception {
        createBroker();
        setupConsumer();
    }

    private void createBroker() throws Exception {
        broker = new BrokerService();
        broker.setPersistent(false);
        broker.setUseJmx(false);
        broker.addConnector(brokerUrl);
        broker.start();
    }

    private void setupConsumer() throws JMSException {
    	
    	/**
    	 * 获取连接
    	 */
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(brokerUrl);
        Connection connection;
        connection = connectionFactory.createConnection();
        connection.start();
        /**
         * Session取值
	     * 	    paramA 取值有：
					1、true：支持事务
					为true时：paramB的值忽略， acknowledgment mode被jms服务器设置为SESSION_TRANSACTED 。 　
					2、false：不支持事务 
					为false时：paramB的值可为Session.AUTO_ACKNOWLEDGE、Session.CLIENT_ACKNOWLEDGE、DUPS_OK_ACKNOWLEDGE其中一个,
					为Session.SESSION_TRANSACTED时会报错!
				paramB 取值有：
					1、Session.AUTO_ACKNOWLEDGE：为自动确认，客户端发送和接收消息不需要做额外的工作。
					2、Session.CLIENT_ACKNOWLEDGE：为客户端确认。客户端接收到消息后，必须调用javax.jms.Message的acknowledge方法。jms服务器才会删除消息。 
					3、DUPS_OK_ACKNOWLEDGE：允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收；而且允许重复确认，多个重复的消息批量确认，不是逐条确认。在需要考虑资源使用时，这种模式非常有效。
					4、SESSION_TRANSACTED
					5、INDIVIDUAL_ACKNOWLEDGE：单条消息确认，它的确认时机和CLIENT_ACKNOWLEDGE几乎一样，
						当消息消费成功之后，需要调用message.acknowledege来确认此消息(单条)，而CLIENT_ACKNOWLEDGE模式先message.acknowledge()方法将导致整个session中所有消息被确认(批量确认)。 
         */
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        
        /**
         * Topic：发布订阅消息
         * Queue：点对点
         */
        Destination adminQueue = session.createQueue(requestQueue);
        producer = session.createProducer(null);
        
        /**
         *  NON_PERSISTENT
		*      这是开销最低的传递模式，因为它不需要将邮件记录到稳定的存储中。
			PERSISTENT
			      此交付模式指示JMS提供者将消息记录到稳定存储中，作为客户端发送操作的一部分。
         */
        producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
      
        consumer = session.createConsumer(adminQueue);
        consumer.setMessageListener(this);
    }

    public void stop() throws Exception {
        producer.close();
        consumer.close();
        session.close();
        broker.stop();
    }

 

    public String handleRequest(String messageText) {
        return "Response to '" + messageText + "'";
    }

    public static void main(String[] args) throws Exception {
          Server server = new Server();
          server.start();
          System.out.println();
          System.out.println("Press any key to stop the server");
          System.out.println();
          System.in.read();
          server.stop();
    }
    
	public void onMessage(Message message) {
		try {
            TextMessage response = this.session.createTextMessage();
            if (message instanceof TextMessage) {
                TextMessage txtMsg = (TextMessage) message;
                String messageText = txtMsg.getText();
                response.setText(handleRequest(messageText));
            }
            response.setJMSCorrelationID(message.getJMSCorrelationID());
            
            /**
             * 获取到所接受的消息的来源，并返回响应
             */
            producer.send(message.getJMSReplyTo(), response);
        } catch (JMSException e) {
            e.printStackTrace();
        }
	}
}