JMS常用基类

import javax.jms.ExceptionListener;
import javax.jms.JMSException;

import com.lenovo.lps.log.Log;

public class JmsExceptionListener implements ExceptionListener{

    private Log log = Log.getInstance(this.getClass());
    
    public void onException(JMSException e) {
        log.error("Jms connection error! ", e);
    }
}

import com.lenovo.lps.LpsRuntimeException;


public class JMSRuntimeException extends LpsRuntimeException{

    private static final long serialVersionUID = 4562443620320605420L;

    public JMSRuntimeException() {
        super();
    }

    public JMSRuntimeException(String msg) {
        super(msg);
    }

    public JMSRuntimeException(Throwable cause) {
        super(cause);
    }

    public JMSRuntimeException(String msg, Throwable cause) {
        super(msg, cause);
    }

}

public interface JmsSender {
    
    public void sendJmsMessage(Object obj);

}

import javax.jms.JMSException;

import org.springframework.jms.listener.SimpleMessageListenerContainer;

import com.lenovo.lps.log.Log;

public class LpsMessageListenerContainer extends SimpleMessageListenerContainer {

    protected Log log = Log.getInstance(this.getClass());

    @Override
    protected void doInitialize() throws JMSException {
        super.doInitialize();
        log.info("Start Jms ReceiverContainer[" + this.getClass().getName()
                + "] succeed!");
    }

}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.lenovo.lps.log.Log;
import com.lenovo.lps.util.IocUtils;

/**
 * 多线程的Jms消息发送器 该类的初始化工作由Spring设置好属性后完成
 *
 *
 *
 */
public class MultiThreadJmsSender {
    protected ExecutorService executor;

    protected BlockingQueue<JmsSender> jmsSenderQueue;

    protected int senderNum;

    protected boolean inited;

    protected String jmsSenderName;

    /**任务队列的最大容量*/
    protected int taskSize;

    protected Log log = Log.getInstance(this.getClass());

    public void send(Object msg) {
        if (!inited) {
            init();
        }
        executor.execute(new SendTask(msg));
    }

    protected Object beforeSend(Object obj) {
        return obj;
    }

    /**
     * 做初始化工作
     */
    public void init() {
        if (executor == null) {
            if (taskSize > 0) {
                executor = new ThreadPoolExecutor(senderNum, senderNum, 0L,
                        TimeUnit.MILLISECONDS,
                        new ArrayBlockingQueue<Runnable>(taskSize),
                        new ThreadPoolExecutor.DiscardOldestPolicy());
            }else{
                executor = Executors.newFixedThreadPool(senderNum);
            }
        }
        jmsSenderQueue = new LinkedBlockingQueue<JmsSender>();
        for (int i = 0; i < senderNum; i++) {
            jmsSenderQueue.offer((JmsSender) IocUtils.getBean(jmsSenderName));
        }
        inited = true;
    }

    public ExecutorService getExecutor() {
        return executor;
    }

    public void setExecutor(ExecutorService executor) {
        this.executor = executor;
    }

    public BlockingQueue<JmsSender> getJmsSenderQueue() {
        return jmsSenderQueue;
    }

    public void setJmsSenderQueue(BlockingQueue<JmsSender> jmsSenderQueue) {
        this.jmsSenderQueue = jmsSenderQueue;
    }

    public int getSenderNum() {
        return senderNum;
    }

    public void setSenderNum(int senderNum) {
        this.senderNum = senderNum;
    }

    public boolean isInited() {
        return inited;
    }

    public void setInited(boolean inited) {
        this.inited = inited;
    }

    public String getJmsSenderName() {
        return jmsSenderName;
    }

    public void setJmsSenderName(String jmsSenderName) {
        this.jmsSenderName = jmsSenderName;
    }

    public int getTaskSize() {
        return taskSize;
    }

    public void setTaskSize(int taskSize) {
        this.taskSize = taskSize;
    }


    protected class SendTask implements Runnable {

        protected Object content;

        protected SendTask() {
        }

        protected SendTask(Object content) {
            this.content = content;
        }

        public Object getContent() {
            return content;
        }

        public void setContent(Object content) {
            this.content = content;
        }

        public void run() {
            JmsSender sender = null;
            try {
                sender = jmsSenderQueue.take();
                sender.sendJmsMessage(beforeSend(content));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();//恢复中断
            } catch (Exception e) {
                log.error("Send message failed!", e);
            } finally {
                if (sender != null) {
                    jmsSenderQueue.offer(sender);
                }
            }
        }
    }

}