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);
                 }
             }
         }
     }

 }