ActiveMq使用示例

加入依賴

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
        <dependency>
          <groupId>org.apache.activemq</groupId>
          <artifactId>activemq-all</artifactId>
          <version>5.4.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.5</version>
        </dependency>

加載配置文件工具類

import java.io.InputStream;
import java.util.Map;
import java.util.Properties;

import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.log4j.Logger;


public  class ConfigUtil {
    private static final Logger log=Logger.getLogger(ConfigUtil.class);
    public static Map<String,String> dynamicConfigsCach=null;
    private static  Properties props;
    static{
        //加載properties配置
        try {
            log.info("load config from:"+ConfigUtil.class.getClassLoader().getResource("").getPath()+"config.properties" );
            InputStream propsStream = ConfigUtil.class.getClassLoader().getResourceAsStream("config.properties");
            props=new Properties();
            if(null !=propsStream){
                props.load(propsStream);
            }
        } catch (Exception e) {
            log.error("加載config.properties出錯，系統錯誤：" + e);
            e.printStackTrace();
        }
    }

    /**
     * 獲取網關類型
     * @param gateId
     * @return
     */
    public static String getGateType(String gateId){
        if(StringUtils.isNoneBlank(gateId)){
            gateId=gateId.trim();
           if(gateId.length()>2){
               return gateId.substring(gateId.length()-2);
           }
        }
        return "";
    }
    /**
     * 
     * @param name
     * @return
     */
    public static String getString(String name){
        return props.getProperty(name);
    }
       /**
     * 
     * @param name
     * @return
     */
    public static String getString(String name,String def){
      String val=props.getProperty(name);
      if(StringUtils.isBlank(val)){
        val=def;
      }
        return val;
    }

    /**
     * 
     * @param name
     * @return
     */
    public static int getInt(String name){
        String strValue=getString(name);
        return NumberUtils.toInt(strValue, 0);
    }
       /**
     * 
     * @param name
     * @return
     */
    public static int getInt(String name,int def){
        String strValue=getString(name);
        return NumberUtils.toInt(strValue, def);

    }
    /**
     * 
     * @param name
     * @return
     */
    public static boolean getBoolean(String name){
        String strValue=getString(name);
        return BooleanUtils.toBoolean(strValue);
    }
    /**
     * 
     * @param name
     * @return
     */
    public static boolean getBoolean(String name,boolean def){
        String strValue=getString(name);
        if(StringUtils.isBlank(strValue)){
            return def;
        }else if(!name.equalsIgnoreCase("true")&& !name.equalsIgnoreCase("false")){
            return def;
        }
        return BooleanUtils.toBoolean(strValue);
    }

    public static void main(String[] args) {

      log.info("tst");

    }

}

消息處理抽象類

public interface MsgHandler<T> {
    /**
     * 消息處理
     * @param msg
     */
    public void onMsg(T msg);
    /**
     * 返序列化
     * @param buf
     * @return
     */
    public T deserializer(byte[] buf);
}

類型定義

public enum JMSMode {
    TOPIC,
    QUEUE
}

生產者

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;

import javax.jms.BytesMessage;
import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.RedeliveryPolicy;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;

import com.google.common.collect.Maps;
import com.jimi.sms.utils.ConfigUtil;

public class ActiveMQProducer {
    private static final Logger logger = Logger.getLogger(ActiveMQProducer.class);

    private static final String mqUrl = ConfigUtil.getString("activemq.url","tcp://172.16.0.104:61616?wireFormat.cacheSize=2048&connectionTimeout=3&soTimeout=1000&tcpNoDelay=true");
    // private static final String url=
    private static final String user = "admin";
    private static final String password ="admin";

    /**
     * 創建Map
     */
    private static final Map<String, ActiveMQProducer> instMap = Maps.newConcurrentMap();
    /**
     * 
     */
    protected ActiveMQConnectionFactory factory;
    /**
     * 
     */
    private Connection connection;
    /**
     * 
     */
    private Session session;
    /**
    * 
    */
    private MessageProducer producer;
    /**
     * 
     */
    private String myTarget;



    /**
     * 發送消息
     * 
     * @param data
     * @return
     */
    public boolean send(byte[] data) {
        boolean success = false;
        // 如果有生產者
        if (null != producer) {
            try {
                BytesMessage msg = session.createBytesMessage();
                msg.writeBytes(data);
                producer.send(msg);
                success = true;
            } catch (Exception e) {
                logger.error(myTarget + "發送消息失敗", e);
            }
        } else {
            logger.error("Producer爲空，是否忘記調用startAsync!");
        }

        return success;
    }

    /**
     * 獲取實例
     * 
     * @param target
     * @param mode
     * @return
     */
    public static ActiveMQProducer getInstance(String target, String clientID,JMSMode mode, boolean persistent) {
        System.out.println();
        if (null != mode && null != target && null != clientID) {
            String key = target + clientID + mode;
            if (!instMap.containsKey(key)) {
                synchronized (instMap) {
                    if (!instMap.containsKey(key)) {
                        ActiveMQProducer producer = new ActiveMQProducer();
                        producer.init(clientID);
                        producer.createProducer(mode, target, persistent);
                        instMap.put(key, producer);
                    }
                }
            }
            return instMap.get(key);
        } else {
            logger.error("參數錯誤");
            return null;
        }
    }

    /**
     * 創建生產者
     */
    private void createProducer(JMSMode jmsMode, String target,boolean persistent) {
        this.myTarget = jmsMode.toString()+"."+target;

        if (null != session) {
            try {
                Destination dest = null;
                switch (jmsMode) {
                case TOPIC:
                    dest = session.createTopic(target);
                    break;
                case QUEUE:
                    dest = session.createQueue(target);
                    break;
                }
                producer = session.createProducer(dest);
                // 持久
                if (persistent) {
                    producer.setDeliveryMode(DeliveryMode.PERSISTENT);
                }

            } catch (JMSException e) {
                logger.error(myTarget + "創建失敗", e);
            }
        } else {
            logger.error("Session 爲空創建生產者失敗");
        }
    }

    /**
     * 初始化
     * 
     * @param clientID
     */
    private void init(String clientID) {

        if (null == connection) {
            try {
                // failover:(tcp://primary:61616)?timeout=3000
                String brokerURL = "failover:(" + mqUrl + ")";
                logger.info(" ready connect to activemq: " + brokerURL);
                factory = new ActiveMQConnectionFactory(brokerURL);
                factory.setUserName(user);
                factory.setPassword(password);
                // ACK配置
                // factory.setOptimizeAcknowledge(true);
                // factory.setUseAsyncSend(true);
                // factory.setUseCompression(true);
                // 預取配置
                Properties props = new Properties();
                props.setProperty("prefetchPolicy.queuePrefetch", "1");
                props.setProperty("prefetchPolicy.queueBrowserPrefetch", "1");
                props.setProperty("prefetchPolicy.durableTopicPrefetch", "100");
                props.setProperty("prefetchPolicy.topicPrefetch", "32766");
                // factory.setProperties(props);
                // // factory.setAlwaysSyncSend(true);
                // // //
                // // factory.setNonBlockingRedelivery(true);
                // // factory.setSendAcksAsync(true);
                // // // 預讀
                // // ActiveMQPrefetchPolicy prefetchPolicy = new
                // ActiveMQPrefetchPolicy();
                // // prefetchPolicy.setQueuePrefetch(15000);
                // // factory.setPrefetchPolicy(prefetchPolicy);
                // 重發策略
                RedeliveryPolicy queuePolicy = new RedeliveryPolicy();
                queuePolicy.setInitialRedeliveryDelay(0);
                queuePolicy.setRedeliveryDelay(1000);// 重發延時
                queuePolicy.setUseExponentialBackOff(false);
                queuePolicy.setMaximumRedeliveries(3);// 重發次數
                factory.setRedeliveryPolicy(queuePolicy);
                // 創建連接
                connection = factory.createConnection();
                if (StringUtils.isNotBlank(clientID)) {
                    try {
                        clientID = getClientIDString(clientID);
                        logger.info("connect activemq user ClientID:"
                                + clientID);
                        connection.setClientID(clientID);
                    } catch (JMSException e) {
                        logger.error("削費者客戶端ID：" + clientID + "失敗");
                    }
                }
            } catch (JMSException e) {
                logger.error("ActiveMq創建連接失敗", e);
            }
        }
        if (null != connection) {
            if (null == session) {
                try {
                    session = connection.createSession(false,
                            Session.AUTO_ACKNOWLEDGE);
                } catch (JMSException e) {
                    logger.error("ActiveMq創建會話失敗", e);
                }
            }
        } else {
            logger.error("連接爲空，無法創建Session");
        }

    }

    /**
     * 獲取客戶端ID
     * 
     * @return
     */
    private String getClientIDString(String clientID) {
        String ip = "UnknowHost";
        try {
            ip = InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            logger.error("獲取本機IP失敗", e);
        }
        return clientID + "@" + ip + "-" + System.currentTimeMillis();
    }
    /**
     * 關閉連接
     */
    public static void shutdown() {
        Iterator<ActiveMQProducer> ite = instMap.values().iterator();
        ActiveMQProducer inst=null;
        while (ite.hasNext()) {

            inst = ite.next();
            if(null != inst.producer){
                try {
                    inst.producer.close();
                }
                catch (JMSException e) {
                   logger.error(inst.myTarget+"關閉失敗", e);
                }
            }
        }
        if(inst== null){
            return;
        }
        if (null != inst.session) {
            try {
                inst.session.close();
            } catch (JMSException e) {
                logger.error("關閉Session異常", e);
            }
        }
        if (null != inst.connection) {
            try {
                inst.connection.close();
            } catch (JMSException e) {
                logger.error("關閉Connect異常", e);
            }
        }
    }
}

消費者

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;

import javax.jms.BytesMessage;
import javax.jms.Connection;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.RedeliveryPolicy;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;

import com.google.common.collect.Maps;
import com.jimi.sms.utils.ConfigUtil;

public class ActiveMQConsumer {

    private static final Logger logger = Logger.getLogger(ActiveMQProducer.class);

    private static final String mqUrl = ConfigUtil.getString("activemq.url",
            "tcp://172.16.0.104:61616?wireFormat.cacheSize=2048&connectionTimeout=3&soTimeout=1000&tcpNoDelay=true");
    // private static final String url=
    // private static final String user ="admin";//
    // ActiveMQConnectionFactory.DEFAULT_USER;
    private static final String user = ConfigUtil.getString("ActiveUser");// ActiveMQConnectionFactory.DEFAULT_USER;
    // private static final String password =
    // "admin";//ActiveMQConnectionFactory.DEFAULT_PASSWORD;
    private static final String password = ConfigUtil.getString("ActivePwd");;// ActiveMQConnectionFactory.DEFAULT_PASSWORD;

    /**
     * 創建Map
     */
    private static final Map<String, ActiveMQConsumer> instMap = Maps.newConcurrentMap();
    /**
     * 
     */
    protected ActiveMQConnectionFactory factory;
    /**
     * 
     */
    private Connection connection;
    /**
     * 
     */
    private Session session;
    /**
    * 
    */
    private MessageConsumer consumer;

    private String myTarget;

    /**
     * 獲取實例
     * 
     * @param <T>
     * 
     * @param target
     * @param mode
     * @return
     */
    public static <T> ActiveMQConsumer getInstance(String target, String clientID, JMSMode mode,MsgHandler<T> handler) {
        if (null != mode && null != target && null != clientID) {
            String key = target + clientID + mode;
            if (!instMap.containsKey(key)) {
                synchronized (instMap) {
                    if (!instMap.containsKey(key)) {
                        ActiveMQConsumer consumer = new ActiveMQConsumer();
                        consumer.init(clientID);
                        consumer.createConsumer(mode, target, handler);
                        instMap.put(key, consumer);
                    }
                }
            }
            return instMap.get(key);
        } else {
            logger.error("參數錯誤");
            return null;
        }
    }

    /**
     * 創建消費者
     * 
     * @param <T>
     */
    private <T> void createConsumer(JMSMode jmsMode, String target, final MsgHandler<T> handler) {

        this.myTarget = jmsMode.toString() + "." + target;

        if (null != session) {
            try {
                Destination dest = null;
                switch (jmsMode) {
                case TOPIC:
                    dest = session.createTopic(target);
                    break;
                case QUEUE:
                    dest = session.createQueue(target);
                    break;
                }
                consumer = session.createConsumer(dest);
                consumer.setMessageListener(new MessageListener() {

                    @Override
                    public void onMessage(Message message) {
                        if (message instanceof BytesMessage) {
                            BytesMessage msg = (BytesMessage) message;
                            try {
                                byte[] buf = new byte[(int) msg.getBodyLength()];
                                msg.readBytes(buf);
                                T t = handler.deserializer(buf);
                                if (null != t) {
                                    handler.onMsg(t);
                                }
                            } catch (JMSException e) {
                                logger.error("消息處理異常", e);
                            }
                        }
                    }
                });
                connection.start();

            } catch (JMSException e) {
                logger.error(myTarget + "創建失敗", e);
            }
        } else {
            logger.error("Session 爲空創建生產者失敗");
        }
    }

    /**
     * 初始化
     * 
     * @param clientID
     */
    private void init(String clientID) {

        if (null == connection) {
            try {
                // failover:(tcp://primary:61616)?timeout=3000
                String brokerURL = "failover:(" + mqUrl + ")";
                logger.info(" ready connect to activemq: " + brokerURL);
                factory = new ActiveMQConnectionFactory(brokerURL);
                factory.setUserName(user);
                factory.setPassword(password);
                // ACK配置
                // factory.setOptimizeAcknowledge(true);
                // factory.setUseAsyncSend(true);
                // factory.setUseCompression(true);
                // 預取配置
                Properties props = new Properties();
                props.setProperty("prefetchPolicy.queuePrefetch", "1");
                props.setProperty("prefetchPolicy.queueBrowserPrefetch", "1");
                props.setProperty("prefetchPolicy.durableTopicPrefetch", "100");
                props.setProperty("prefetchPolicy.topicPrefetch", "32766");
                // factory.setProperties(props);
                // // factory.setAlwaysSyncSend(true);
                // // //
                // // factory.setNonBlockingRedelivery(true);
                // // factory.setSendAcksAsync(true);
                // // // 預讀
                // // ActiveMQPrefetchPolicy prefetchPolicy = new
                // ActiveMQPrefetchPolicy();
                // // prefetchPolicy.setQueuePrefetch(15000);
                // // factory.setPrefetchPolicy(prefetchPolicy);
                // 重發策略
                RedeliveryPolicy queuePolicy = new RedeliveryPolicy();
                queuePolicy.setInitialRedeliveryDelay(0);
                queuePolicy.setRedeliveryDelay(1000);// 重發延時
                queuePolicy.setUseExponentialBackOff(false);
                queuePolicy.setMaximumRedeliveries(3);// 重發次數
                factory.setRedeliveryPolicy(queuePolicy);
                // 創建連接
                connection = factory.createConnection();
                if (StringUtils.isNotBlank(clientID)) {
                    try {
                        clientID = getClientIDString(clientID);
                        logger.info("connect activemq user ClientID:" + clientID);
                        connection.setClientID(clientID);
                    } catch (JMSException e) {
                        logger.error("削費者客戶端ID：" + clientID + "失敗");
                    }
                }
            } catch (JMSException e) {
                logger.error("ActiveMq創建連接失敗", e);
            }
        }
        if (null != connection) {
            if (null == session) {
                try {
                    session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
                } catch (JMSException e) {
                    logger.error("ActiveMq創建會話失敗", e);
                }
            }
        } else {
            logger.error("連接爲空，無法創建Session");
        }

    }

    /**
     * 獲取客戶端ID
     * 
     * @return
     */
    private String getClientIDString(String clientID) {
        String ip = "UnknowHost";
        try {
            ip = InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            logger.error("獲取本機IP失敗", e);
        }
        return clientID + "@" + ip + "-" + System.currentTimeMillis();
    }

    /**
     * 關閉連接
     */
    public static void shutdown() {
        Iterator<ActiveMQConsumer> ite = instMap.values().iterator();
        ActiveMQConsumer inst = null;
        while (ite.hasNext()) {

            inst = ite.next();
            if (null != inst.consumer) {
                try {
                    inst.consumer.close();
                } catch (JMSException e) {
                    logger.error(inst.myTarget + "關閉失敗", e);
                }
            }
        }
        if (inst == null) {
            return;
        }
        if (null != inst.session) {
            try {
                inst.session.close();
            } catch (JMSException e) {
                logger.error("關閉Session異常", e);
            }
        }
        if (null != inst.connection) {
            try {
                inst.connection.close();
            } catch (JMSException e) {
                logger.error("關閉Connect異常", e);
            }
        }
    }

}

測試類

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.apache.log4j.Logger;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.jimi.sms.bo.ReceiveSms;
import com.jimi.sms.mq.ActiveMQConsumer;
import com.jimi.sms.mq.ActiveMQProducer;
import com.jimi.sms.mq.JMSMode;
import com.jimi.sms.mq.MsgHandler;

public class TestActiveMQQueue {
    private static final Logger logger = Logger.getLogger(TestActiveMQQueue.class);

    public static void testOne(){
        ExecutorService threads=Executors.newFixedThreadPool(10);
        threads.submit(new Runnable() {

            @Override
            public void run() {
                ActiveMQConsumer.getInstance("sms.receive.test", "consumer", JMSMode.QUEUE, new MsgHandler<ReceiveSms>() {
                    @Override
                    public void onMsg(ReceiveSms msg) {
                        logger.info("收到"+msg.getPhoneNum());
                    }
                    @Override
                    public ReceiveSms deserializer(byte[] buf) {
                        String json=new String(buf);
                         return JSON.parseObject(json, ReceiveSms.class);
                    }
                });
            }
        });

    }


    public static void testTwo(){
        ExecutorService threads=Executors.newFixedThreadPool(10);
        threads.submit(new Runnable() {
            public void run() {
                ActiveMQProducer producer = ActiveMQProducer.getInstance("sms.receive.test", "producer", JMSMode.QUEUE, true);
//              while(true){
                for (int i = 0; i < 1; i++) {
                    ReceiveSms rsms = new ReceiveSms();
                    rsms.setPhoneNum("123456");
                    rsms.setContent("content");

                    String sendStr = JSONObject.toJSONString(rsms);
                    producer.send(sendStr.getBytes());
                    logger.info("發送一個queue成功");
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
//              }
            }
        });
    }
    public static void main(String[] args) {
        testOne();
        //testTwo();
    }
}