WMQ队列信息发送接收监听配置

来源：互联网发布：js获取另一个页面的id 编辑：程序博客网时间：2024/06/05 07:17

1.1 context里面配置服务端发送响应队列（Tomcat会自动加载context.xml里面的内容）

QU是队列名称，name是这个资源的jndi名称

config.properties里面对名称进行了配置

1.2引用jndi资源（JndiObjectFactoryBean类是Spring专门提供引用JNDI资源的）

1.3 获取消息模板，并把消息模板注入到消息发送器（org.springframework.jms.core.JmsTemplate是spring-jms.jar包中的）

WMQ服务器资源 <jee:jndi-lookup id="connectionFactory" jndi-name="${conn.jndiName}" resource-ref="true"/> ，MQM2队列管理器。

JNDI名 conn.jndiName=java:comp/env/jms/qms/QM_APPD （查看最上面的图片）

1.4发送代码

package com.deppon.qms.module.jms.listener;

import java.util.Date;
import java.util.Map;
import java.util.UUID;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.apache.commons.lang.exception.ExceptionUtils;
import org.apache.log4j.Logger;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

import com.deppon.qms.module.jms.domain.exception.CommonExceptionInfo;
import com.deppon.qms.module.util.ESBConstants;
import com.deppon.qms.module.util.ExceptionUtil;
import com.deppon.qms.module.util.HeaderUtil;

/**
* 同步银行省市信息接口响应消息发送器
* @author 133682
* @date 2014-11-7 下午8:34:36
* @since
* @version
*/
public class ReponseInfoResponseSender {
   /**
   * 日志对象
   */
   private static Logger log = Logger.getLogger(ReponseInfoResponseSender.class);
   /**
   * JmsTemplate模板
   */
   private JmsTemplate sendJmsTemplate;// JmsTemplate

   /**
     * 提供JmsTemplate实例的set方法
     */
   public void setSendJmsTemplate(JmsTemplate sendJmsTemplate) {
       this.sendJmsTemplate = sendJmsTemplate;
   }
   /**
   * 超时时间
   */
   private static final long timeToLive = 1 * 24 * 60 * 60 * 1000;

   /**
   *
   * <p>将业务处理的返回结果发送给客户端</p>
   * @author 133682
   * @date 2014-12-24 下午3:05:47
   * @param response
   * @param map
   * @param resultCode
   * @return
   * @see
   */
   public String send(final Object response,final Map<String, Object> map,final int resultCode,final String reponseString) {
       //responseID
       final String responseID = UUID.randomUUID().toString();

       sendJmsTemplate.setTimeToLive(timeToLive);

       sendJmsTemplate.send(new MessageCreator() {
                   @SuppressWarnings("finally")
                   public Message createMessage(Session session)
                           throws JMSException {
                       //响应消息
                       Message m = null;
                       //响应消息xml字符串
                       String txtMsg = null;
                       //异常信息
                       String exceptionMsg = null;
                       try {
                           //正常消息
                           if(resultCode == ESBConstants.JMS_RESULTCODE_NORMAL){
                               //txtMsg = responseTrans.fromMessage((ProvinceCityInfoNotificationResponse)response);
                               txtMsg = reponseString;
                               log.info("response:" + txtMsg);
                               m = session.createTextMessage(txtMsg);
                               HeaderUtil.buildResponseJMSProperties(m, map, responseID, resultCode);
                               //消息段发起请求
                               String statusCode = ESBConstants.STATUS_SERVER_SENT;
                               m.setStringProperty(statusCode,String.valueOf(new Date().getTime()));
                               //异常消息
                           }else if(resultCode == ESBConstants.JMS_RESULTCODE_EXCEPTION){
                               txtMsg = ExceptionUtil.generateBody((CommonExceptionInfo)response);
                               log.info("response:" + txtMsg);
                               m = session.createTextMessage(txtMsg);
                               HeaderUtil.buildResponseJMSProperties(m, map, responseID, resultCode);
                               //消息段发起请求
                               String statusCode = ESBConstants.STATUS_SERVER_SENT;
                               m.setStringProperty(statusCode,String.valueOf(new Date().getTime()));
                           }

                           log.info("handleMessage--" + m);
                       } catch (Exception e) {
                           log.error("响应消息发送失败", e);
                           e.printStackTrace();
                           //保存异常信息
                           exceptionMsg = ExceptionUtils.getStackTrace(e);
                           //获得当前的方法名
                           String methodName = new Exception().getStackTrace()[0].getMethodName();
                           log.info("methodName="+methodName);
                           log.info("exceptionMsg="+exceptionMsg);
                           log.info("response="+response);
                       }finally{
                           return m;
                       }
                   }
               });
       log.info("\n\n send ResponseInfoResponse over!\n\n");
       return responseID;
   }

}

2.1 服务端接收请求队列 jndi名 serverin.jndiName 看上图

2.2 引用jndi资源，resourceRef属性，设置是否在J2EE容器中进行查找，如果我们查找的资源中间不包含:或者java:等前缀，我们会自动的该路径加上java:comp/env,。默认设置是false。

2.3 获取监听器

2.4代码可以根据backServiceCode 接受指定的数据，并对不同的backServiceCode进行不同的处理

package com.deppon.qms.module.jms.listener;

import com.alibaba.fastjson.JSON;
import com.deppon.qms.module.common.action.BaseAction;
import com.deppon.qms.module.common.domain.JmsLogEntity;
import com.deppon.qms.module.common.service.IJmsLogService;
import com.deppon.qms.module.jms.domain.exception.CommonExceptionInfo;
import com.deppon.qms.module.util.*;
import com.deppon.qms.module.ws.domain.ErrRequestParam;
import com.deppon.qms.module.ws.domain.ErrResponseParam;
import com.deppon.qms.module.ws.service.impl.AsyncErrorAutoReportDealServiceImpl;
import org.apache.commons.lang.exception.ExceptionUtils;
import org.apache.log4j.Logger;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.UUID;

/**
* 差错自动上报
* Created by 330537 on 2016/12/1.
*/
public class ErrorAutoReportRequestListener extends BaseAction implements MessageListener{

    private static Logger log = Logger.getLogger(QmsInfoRequestListener.class);
    // 接口响应消息发送器
    private ReponseInfoResponseSender responseSender;

    private IJmsLogService jmsLogService;

    private AsyncErrorAutoReportDealServiceImpl autoReportService;

    /**
     *
     * @Title: onMessage
     * @Description: 监听处理实现
     * @param msg
     * @author
     * @throws
     */
    @Override
    public void onMessage(Message msg) {
        log.info("handleMessage--" + msg);

        //请求消息对象字符串
        String requestText;
        //异常信息
        String exceptionMsg = null;
        //保存消息为文本消息
        TextMessage message = (TextMessage) msg;
         //保存头信息
        Map<String, Object> headers = null;
        // 发送状态码 (服务端接收到请求 302)
        //0314
        StatusUtils.send(msg, ESBConstants.STATUS_SERVER_RECEIVED);
        try {
            //服务名称
            String backServiceCode = message.getStringProperty(HeaderUtil.BACK_SERVICE_CODE);
            log.info("-----同步服务编码为-------"+backServiceCode);
          /* if(backServiceCode == null){
                log.error("backServiceCode is null! The message is :" + msg.toString());
                return;
            }*/
            /**
             * 自动上报实现
             * 服务调用编码ESB_FOSS2ESB_ERROR_AUTO_REPORT_SYNC
             * 服务提供编码QMS_ESB2QMS_ERROR_AUTO_REPORT_SYNC
             */
            //if(backServiceCode.equals(ESBConstants.ERROR_AUTO_REPORT_SYNC)){
                //获取header信息
                headers = HeaderUtil.headerConverToMap(msg);
                //获取消息体字符串
                requestText = message.getText();
                log.info("requestText="+requestText);
                // 设置发送状态码(服务端接业务处理之前 305)

                //0314
                StatusUtils.send(msg, ESBConstants.STATUS_SERVER_PROCESS);

                ErrRequestParam request=(ErrRequestParam) JsonUtil.json2reqBean(requestText,ErrRequestParam.class);
                //处理请求数据并返回响应
                log.info("--------------差错自动上报实现start-----------");

                HttpServletRequest req = null;
                HttpServletResponse res = null;

                //正式处理
                ErrResponseParam response = autoReportService.autoReportDeal(request,req,res);

                log.info("--------------差错自动上报实现end-------------");

                String info = JsonUtil.bean2json(response);
                log.info("qms给foss返回的response数据为"+info);
                //发送响应消息
                log.info("---------------发送响应start------------");
                responseSender.send(response, headers,ESBConstants.JMS_RESULTCODE_NORMAL,info);
                log.info("---------------发送响应end--------------");
         //   }

            JmsLogEntity entity = new JmsLogEntity();
            String id = UUID.randomUUID().toString();
            entity.setMsgId(id);
            entity.setMessage(JSON.toJSONString(msg));
            jmsLogService.insert(entity);

        } catch (Exception e) {
            log.error("同步接口出现异常", e);
            //保存异常信息
            exceptionMsg = ExceptionUtils.getStackTrace(e);
            //获取异常消息
            CommonExceptionInfo commonExceptionInfo = ExceptionUtil.getCommonExceptionInfo(exceptionMsg,e.getMessage());
            //发送异常消息
            responseSender.send(commonExceptionInfo, headers,ESBConstants.JMS_RESULTCODE_EXCEPTION,null);
        }finally{
            //异常信息
            String methodName = new Exception().getStackTrace()[0].getMethodName();// 获得当前的方法名
            log.error("methodName="+methodName);
            log.error("exceptionMsg="+exceptionMsg);
        }
    }




    public ReponseInfoResponseSender getResponseSender() {
        return responseSender;
    }

    public void setResponseSender(ReponseInfoResponseSender responseSender) {
        this.responseSender = responseSender;
    }

    public IJmsLogService getJmsLogService() {
        return jmsLogService;
    }

    public void setJmsLogService(IJmsLogService jmsLogService) {
        this.jmsLogService = jmsLogService;
    }

   public AsyncErrorAutoReportDealServiceImpl getAutoReportService() {
       return autoReportService;
   }

   public void setAutoReportService(
           AsyncErrorAutoReportDealServiceImpl autoReportService) {
       this.autoReportService = autoReportService;
   }




}

阅读全文

0 0