精华内容
下载资源
问答
  • 2020-04-21 23:56:00

    解决方法如下:

    例如队列管理器名字叫做QM.SWITCH,你通过WAS控制台连接MQ的连接通道名字叫做"SYSTEM.ADMIN.SVRCONN",用mqm用户(或者root用户连接到MQ服务器上)操作内容如下:

    runmqsc QM.SWITCH

        ALTER CHL(SYSTEM.ADMIN.SVRCONN) CHLTYPE(SVRCONN) MCAUSER('mqm')

        START CHL(SYSTEM.ADMIN.SVRCONN)

    END

     

    或者:停止通道认证功能。

    ALTER QMGR CHLAUTH(DISABLED)

    警告:对于生产环境,停止该功能是不推荐的。因为停止该功能,将导致队列管理器接受所有的管理权限的连接,这就需要用户付出更大的努力去管理这些连接。因此,出于安全考虑,请保持通道认证记录功能启用。

    更多相关内容
  • wmq.jmsra-7.0.1.12.rar

    2018-03-21 15:40:48
    wildfly standalone deployments中的wmq.jmsra-7.0.1.12.rar
  • WMQ WMQ消息队列 消息发布和订阅,基于传统的topic模型。 架构和数据流 如图
  • wmq-monitoring

    2017-11-22 09:44:41
    一个基于WEB的IBM MQ 监控工具。 监控多个主机是的多个队列管理器。 使用相关统计和自定义设置监视MQ对象。例如,您可以监视orders.queue的currentqdpeth和折线图显示状态。 为每个监视器定义警报条件规则,以...
  • wmq-go http protocol

    2018-04-24 17:11:02
    Wrapped message queue which based on rabbitmq,support http protocol
  • wmq.jmsra-7.0.1.3.rar

    2018-04-28 10:15:12
    wildfly standalone deployments中的wmq.jmsra-7.0.1.3.rar
  • WMQ Telemetry 性能评估

    2015-06-19 15:12:35
    IBM官方针对MQ Telemetry MQTT性能评估
  • WMQ MB SSL

    2013-04-26 17:06:51
    WMQ MB SSL
  • 骆驼-wmq-amq Camel IBM Websphere MQ 到 Active MQ 桥接路由 先决条件 IBM 为安装在 Fuse 上的 MQ 客户端提供了 OSGi jar 文件IBM_MQ_INSTALL_DIR/java/lib/OSGi 运行 AMQ 代理 带有填充属性的 JBOSS_FUSE_INSTALL...
  • IBM WMQ 培训教材

    2012-02-12 20:33:01
    IBM WMQ 培训教材 ppt文档,初步配合图形讲解了MQ的安装,MQ管理,MQ开发,便于用户的直观理解
  • jar包,官方版本,自测可用
  • jar包,官方版本,自测可用
  • jar包,官方版本,自测可用
  • Java客户端将消息发送到客户端队列,消息经过通道到达远程队列。使用java服务端程序读取消息
  • WMQ服务器资源 ${conn.jndiName}" resource-ref="true"/> ,MQM2队列管理器。 JNDI名 conn.jndiName=java:comp/env/jms/qms/QM_APPD (查看最上面的图片) 1.4发送代码 package ...

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

        
        
        
    }


    展开全文
  • 去队列里面一直获取消息,一开始想到了两种解决方案: 第一:订阅一次获取一次消息,正常的话每次都能获取到,但是要及时去清理订阅并且时间粒度不好控制 第二:订阅一次,再获取消息这里加死循环,超时MQ已经做了...

    去队列里面一直获取消息,一开始想到了两种解决方案:

    第一:订阅一次获取一次消息,正常的话每次都能获取到,但是要及时去清理订阅并且时间粒度不好控制

    第二:订阅一次,再获取消息这里加死循环,超时MQ已经做了,所以可以不用控制线程等待,获取到消息了以后,直接通过自定义事件的机制去及时处理消息

    从最终实验结果来看,第二种是最优的做法,可以做到随时获取到消息,又不占用资源。接下来我把最终的实现代码分享处理,希望对大家有所帮助,有不对的地方,请及时联系我。

    订阅主题:

            private IIBMWMQMsgHandler _msgHandler;
    
            public IBMWMQHelper()
            {
                _msgHandler = new DefaultIBMWMQMsgHandler();
            }
    
            public IBMWMQHelper(IIBMWMQMsgHandler msgHandler)
            {
                _msgHandler = msgHandler;
            }

     

    /// <summary>
            /// 订阅主题。订阅一次并尝试一直获取消息
            /// </summary>
            public void SubTopic1(string business, bool isGetMsg = true)
            {
                IBMWMQEventSource eventSource = new IBMWMQEventSource();
                IBMWMQMsgEventListener msgEventListener = new IBMWMQMsgEventListener(_msgHandler);
                MQSubscription subs = null;
                try
                {
                    //订阅事件
                    msgEventListener.Subscribe(eventSource);
                    //MQEnvironment.CCSID = 1381;
    
                    using (var mqmgr = MQQueueManager.Connect(IBMWMQConfig.QUEUE_MGR_NAME, MQC.MQCO_NONE, IBMWMQConfig.CHANNEL, IBMWMQConfig.CONNECTION_INFO))
                    {
                        subs = new MQSubscription(mqmgr);
                        if (mqmgr.IsConnected)
                        {
                            this.TryAdd(business, subs);
    
                            int option = MQC.MQSO_CREATE + MQC.MQSO_RESUME + MQC.MQSO_NON_DURABLE + MQC.MQSO_MANAGED + MQC.MQSO_FAIL_IF_QUIESCING;
                            string subName = string.Format(IBMWMQConfig.SUBSCRIPTION_TEMPLATE, business);
                            string topicName = string.Format(IBMWMQConfig.TOPIC_TEMPLATE, business);
    
                            try
                            {
                                subs.Subscribe(subName, option, topicName);
                            }
                            catch (MQException ex)
                            {
                                string code = ex.Reason.ToString();
                                //引发事件
                                eventSource.RaiseErroeMsgEvent(business, code);
                            }
    
                            while (isGetMsg)
                            {
                                eventSource.RaiseErroeMsgEvent(business, string.Format("开始尝试获取 {0} 消息...", business));
                                try
                                {
                                    MQMessage incoming = new MQMessage()
                                    {
                                        CharacterSet = MQC.CODESET_UTF,
                                        Encoding = MQC.MQENC_NORMAL
                                    };
                                    MQGetMessageOptions gmo = new MQGetMessageOptions();
                                    gmo.WaitInterval = 10 * 1000; //MQC.MQWI_UNLIMITED;
                                    gmo.Options |= MQC.MQGMO_WAIT;
                                    gmo.Options |= MQC.MQGMO_SYNCPOINT;
    
                                    subs.Get(incoming, gmo);
                                    string message = incoming.ReadAll();
    
                                    if (!string.IsNullOrEmpty(message))
                                    {
                                        //引发事件
                                        eventSource.RaiseNewMsgEvent(business, message);
                                    }
                                }
                                catch (MQException ex)
                                {
                                    string code = ex.Reason.ToString();
                                    //引发事件
                                    eventSource.RaiseErroeMsgEvent(business, code);
                                }
                            }
                        }
                    }
                }
                catch (MQException e)
                {
                    string code = e.Reason.ToString();
                    //引发事件
                    eventSource.RaiseErroeMsgEvent(business, code);
                }
                finally
                {
                    //if (subs != null)
                    //{
                    //    subs.Close(MQC.MQCO_REMOVE_SUB, closeSubQueue: true, closeSubQueueOptions: MQC.MQCO_NONE);
                    //}
                }
            }

    接下来开始自定义事件:

    定义事件中心:

    public class IBMWMQEventSource
        {
            /// <summary>
            /// 新消息处理委托
            /// </summary>
            /// <param name="business"></param>
            /// <param name="msg"></param>
            public delegate void NewMsgHandler(string business, string msg);
            /// <summary>
            /// 新消息处理事件
            /// </summary>
            public event NewMsgHandler NewMsgEventHandler;
    
            /// <summary>
            /// 错误消息处理委托
            /// </summary>
            /// <param name="errorCode"></param>
            public delegate void ErrorMsgHandler(string business, string errorCode);
            /// <summary>
            /// 错误消息处理事件
            /// </summary>
            public event ErrorMsgHandler ErrorMsgEventHandler;
    
            /// <summary>
            /// 引发新消息处理事件的方法
            /// </summary>
            /// <param name="business"></param>
            /// <param name="msg"></param>
            public void RaiseNewMsgEvent(string business, string msg)
            {
                if (NewMsgEventHandler != null)
                {
                    NewMsgEventHandler.Invoke(business, msg);
                }
            }
    
            /// <summary>
            /// 引发错误消息处理事件的方法
            /// </summary>
            /// <param name="business"></param>
            /// <param name="errorCode"></param>
            public void RaiseErroeMsgEvent(string business, string errorCode)
            {
                if (ErrorMsgEventHandler != null)
                {
                    ErrorMsgEventHandler.Invoke(business, errorCode);
                }
            }
        }

    定义事件监听器:

    public class IBMWMQMsgEventListener
        {
            private readonly IIBMWMQMsgHandler _msgHandler;
    
            public IBMWMQMsgEventListener(IIBMWMQMsgHandler msgHandler)
            {
                _msgHandler = msgHandler;
            }
    
            /// <summary>
            /// 订阅事件
            /// </summary>
            public void Subscribe(IBMWMQEventSource eventSource)
            {
                eventSource.NewMsgEventHandler += _msgHandler.OnNewMsgHandler;
                eventSource.ErrorMsgEventHandler += _msgHandler.OnErrorMsgHandler;
            }
    
            /// <summary>
            /// 取消订阅事件
            /// </summary>
            public void UnSubscribe(IBMWMQEventSource eventSource)
            {
                eventSource.NewMsgEventHandler -= _msgHandler.OnNewMsgHandler;
                eventSource.ErrorMsgEventHandler -= _msgHandler.OnErrorMsgHandler;
            }
        }

    定义消息处理接口:

    public interface IIBMWMQMsgHandler
        {
            /// <summary>
            /// 处理新消息
            /// </summary>
            /// <param name="business">业务代码</param>
            /// <param name="msg">消息包</param>
            void OnNewMsgHandler(string business, string msg);
    
            /// <summary>
            /// 处理错误消息
            /// </summary>
            /// <param name="business">业务代码</param>
            /// <param name="errorCode">错误码</param>
            void OnErrorMsgHandler(string business, string errorCode);
        }

    默认消息处理机制:

    public class DefaultIBMWMQMsgHandler : IIBMWMQMsgHandler
        {
            /// <summary>
            /// 处理新消息
            /// </summary>
            /// <param name="business">业务代码</param>
            /// <param name="msg">消息包</param>
            public void OnNewMsgHandler(string business, string msg)
            {
                Trace.WriteLine(string.Format("新消息到达,数据包:{0}", msg));
            }
    
            /// <summary>
            /// 处理错误消息
            /// </summary>
            /// <param name="business">业务代码</param>
            /// <param name="errorCode">错误码</param>
            public void OnErrorMsgHandler(string business, string errorCode)
            {
                Trace.WriteLine(string.Format("处理错误消息,错误码:{0}", errorCode));
            }
        }

    定义消息处理方法:

    public class CustomIBMWMQMsgHandler : BaseJobManager, IIBMWMQMsgHandler
        {
            /// <summary>
            /// 消息自定义业务处理
            /// </summary>
            private static CustomBusinessHandler customBusinessHandler = new CustomBusinessHandler();
    
            /// <summary>
            /// 处理新消息
            /// </summary>
            /// <param name="business"></param>
            /// <param name="msg"></param>
            public void OnNewMsgHandler(string business, string msg)
            {
                //获取配置文件
                List<JobConfigEntity> configs = InitJobConfig();
                string businessName = configs.First(c => c.JobName.Replace("_", "").Contains(business)).Name;
    
                switch (business)
                {
                    case IBMWMQConfig.BUSINESS_NAME_ZDFZ09:
                        msg = customBusinessHandler.RemoveMsgHeader(msg, IBMWMQConfig.BUSINESS_NAME_ZDF_Z09);
                        customBusinessHandler.DO_ZDF_Z09(business, msg);
                        break;
                    case IBMWMQConfig.BUSINESS_NAME_ZAPZ10:
                        msg = customBusinessHandler.RemoveMsgHeader(msg, IBMWMQConfig.BUSINESS_NAME_ZAP_Z10);
                        customBusinessHandler.DO_ZAP_Z10(business, msg);
                        break;
                    case IBMWMQConfig.BUSINESS_NAME_OULR24:
                        msg = customBusinessHandler.RemoveMsgHeader(msg, IBMWMQConfig.BUSINESS_NAME_OUL_R24);
                        customBusinessHandler.DO_OUL_R24(business, msg);
                        break;
                }
    
                this.WriteInfo(this.GetType(), string.Format("收到来自{0}的消息,数据包:{1}", businessName, msg));
            }
    
            /// <summary>
            /// 处理错误消息
            /// </summary>
            /// <param name="business"></param>
            /// <param name="errorCode"></param>
            public void OnErrorMsgHandler(string business, string errorCode)
            {
                if (!string.IsNullOrEmpty(errorCode))
                {
                    //获取配置文件
                    List<JobConfigEntity> configs = InitJobConfig();
                    string businessName = configs.First(c => c.JobName.Replace("_", "").Contains(business)).Name;
    
                    //TODO 其他消息内容校验
                    if (errorCode.Equals("2033"))
                    {
                        this.WriteInfo(this.GetType(), string.Format("MQRC_NO_MSG_AVAILABLE.{0} 无消息({1})。", businessName, errorCode));
                    }
                    else if (errorCode.Equals("2085"))
                    {
                        this.WriteInfo(this.GetType(), string.Format("MQRC_UNKNOWN_OBJECT_NAME.{0} 主题不存在({1})。", businessName, errorCode));
                    }
                    else if (errorCode.Equals("2429"))
                    {
                        this.WriteInfo(this.GetType(), string.Format("MQRC_SUBSCRIPTION_IN_USE.{0} 主题已被订阅({1})。", businessName, errorCode));
                    }
                    else if (errorCode.Equals("2537"))
                    {
                        this.WriteInfo(this.GetType(), string.Format("MQRC_CHANNEL_NOT_AVAILABLE.频道不可用({0})。", errorCode));
                    }
                    else if (errorCode.Equals("2538"))
                    {
                        this.WriteInfo(this.GetType(), string.Format("MQRC_HOST_NOT_AVAILABLE.无法连接消息队列主机({0})。", errorCode));
                    }
                    else if (errorCode.Equals("2539"))
                    {
                        this.WriteInfo(this.GetType(), string.Format("MQRC_CHANNEL_CONFIG_ERROR.频道配置错误({0})。", errorCode));
                    }
                    else if (errorCode.Equals("2540"))
                    {
                        this.WriteInfo(this.GetType(), string.Format("MQRC_UNKNOWN_CHANNEL_NAME.未知频道称({0})。", errorCode));
                    }
                    else
                    {
                        if (errorCode.Length == 4)
                        {
                            this.WriteInfo(this.GetType(), string.Format("未知错误消息,错误原因编码:{0}。", errorCode));
                        }
                        else
                        {
                            this.WriteInfo(this.GetType(), string.Format("{0} {1}", businessName, errorCode));
                        }
                    }
                }
            }
        }

    去掉消息头:

    /// <summary>
            /// 去掉消息头
            /// </summary>
            /// <param name="msg"></param>
            /// <param name="name"></param>
            /// <returns></returns>
            public string RemoveMsgHeader(string msg, string name)
            {
                msg = msg.Trim();
    
                //去掉消息头
                int index = msg.IndexOf("<" + name, StringComparison.Ordinal);
                if (index > 0)
                {
                    string temp = msg.Substring(0, index);
                    msg = msg.Substring(index, msg.Length - temp.Length);
                    msg = msg.Trim();
                }
    
                return msg;
            }

    配置信息:

    public class IBMWMQConfig
        {
            /// <summary>
            /// MQ主机地址
            /// </summary>
            private static readonly string CONNECTION_HOST = ConfigHelper.GetValue("IBM_WMQ_CONNECTION_HOST");
            /// <summary>
            /// 通讯端口
            /// </summary>
            private const int CONNECTION_PORT = 4421;
            /// <summary>
            /// CLIENT_ID
            /// </summary>
            private const string CLIENT_ID = "";
            /// <summary>
            /// 通道名称
            /// </summary>
            public const string CHANNEL = "";
            /// <summary>
            /// 队列管理器名称
            /// </summary>
            public const string QUEUE_MGR_NAME = "";
            /// <summary>
            /// 订阅主题持久化标识,{0}标识具体业务
            /// </summary>
            public static readonly string SUBSCRIPTION_TEMPLATE = "JMS:" + QUEUE_MGR_NAME + ":" + CLIENT_ID + "_{0}.REQ:{0}.REQ";
            /// <summary>
            /// 主题名称模板,{0}标识具体业务
            /// </summary>
            public static readonly string TOPIC_TEMPLATE = "{0}.REQ";
            /// <summary>
            /// IBM.WMQ连接字符串
            /// </summary>
            public static readonly string CONNECTION_INFO = string.Format("{0}({1})", CONNECTION_HOST, CONNECTION_PORT);
            
        }

    调用:

    IBMWMQHelper helper = new IBMWMQHelper(new CustomIBMWMQMsgHandler());
    helper.SubTopic1(IBMWMQConfig.BUSINESS_NAME_ZAPZ10);

     

    转载于:https://www.cnblogs.com/zhao-yi/p/10616580.html

    展开全文
  • IBM.WMQ订阅消息

    2019-03-20 11:16:00
    IBM.WMQ连接字符串 /// public static readonly string CONNECTION_INFO = string .Format( " {0}({1}) " , CONNECTION_HOST, CONNECTION_PORT); } 订阅消息: /// /// 订阅主题 ...

    网上关于IBM这个消息队列中间件的资料相对比较少,C#相关的资料就更少了,最近因为要对接这个队列中间件,花了不少功夫去搜索、整理各种资料,遇到很多问题,因此记录下来。

    1、基于 amqmdnet.dll 进行开发,这个是官方提供的DLL,安装了IBM WebSphere MQ后在安装目录可以找到(C:\Program Files\IBM\WebSphere MQ\bin)

    2、基于 MmqiNetLite.dll 开发,这是一个开源组件,地址:https://github.com/fglaeser/mmqinet,这个项目代码有部分未完善,原作者也是好几年没更新,但是基础功能可以使用,本文代码主要基于此编写

    源码如下:

    public class IBMWMQConfig
        {
            /// <summary>
            /// MQ主机地址
            /// </summary>
            private const string CONNECTION_HOST = "";
            /// <summary>
            /// 通讯端口
            /// </summary>
            private const int CONNECTION_PORT = 4421;
            /// <summary>
            /// CLIENT_ID
            /// </summary>
            private const string CLIENT_ID = "";
            /// <summary>
            /// 通道名称
            /// </summary>
            public const string CHANNEL = "SYSTEM.ADMIN.SVRCONN";
            /// <summary>
            /// 队列管理器名称
            /// </summary>
            public const string QUEUE_MGR_NAME = "PHIBHUBGW1";
            /// <summary>
            /// 订阅主题持久化标识,{0}标识具体业务
            /// </summary>
            public static readonly string SUBSCRIPTION_TEMPLATE = "JMS:" + QUEUE_MGR_NAME + ":" + CLIENT_ID + "_{0}.REQ:{0}.REQ";
            /// <summary>
            /// 主题名称模板,{0}标识具体业务
            /// </summary>
            public static readonly string TOPIC_TEMPLATE = "{0}.REQ";
            /// <summary>
            /// IBM.WMQ连接字符串
            /// </summary>
            public static readonly string CONNECTION_INFO = string.Format("{0}({1})", CONNECTION_HOST, CONNECTION_PORT);
        }

    订阅消息:

    /// <summary>
            /// 订阅主题
            /// </summary>
            /// <param name="business"></param>
            /// <returns></returns>
            private string SubTopic(string business)
            {
                string message = string.Empty;
                try
                {
                    using (var mqmgr = MQQueueManager.Connect(IBMWMQConfig.QUEUE_MGR_NAME, MQC.MQCO_NONE, IBMWMQConfig.CHANNEL, IBMWMQConfig.CONNECTION_INFO))
                    {
                        MQSubscription subs = new MQSubscription(mqmgr);
                        if (mqmgr.IsConnected)
                        {
                            int option = MQC.MQSO_CREATE + MQC.MQSO_RESUME + MQC.MQSO_NON_DURABLE + MQC.MQSO_MANAGED + MQC.MQSO_FAIL_IF_QUIESCING;
                            string subName = string.Format(IBMWMQConfig.SUBSCRIPTION_TEMPLATE, business);
                            string topicName = string.Format(IBMWMQConfig.TOPIC_TEMPLATE, business);
    
                            subs.Subscribe(subName, option, topicName);
    
                            MQMessage incoming = new MQMessage();
                            MQGetMessageOptions gmo = new MQGetMessageOptions();
                            gmo.WaitInterval = 10 * 1000;//MQC.MQWI_UNLIMITED;
                            gmo.Options |= MQC.MQGMO_WAIT;
                            gmo.Options |= MQC.MQGMO_SYNCPOINT;
    
                            subs.Get(incoming, gmo);
                            message = incoming.ReadAll();
    
                            //subs.Close(MQC.MQCO_REMOVE_SUB, closeSubQueue: true, closeSubQueueOptions: MQC.MQCO_NONE);
                        }
                    }
                }
                catch (MQException e)
                {
                    message = e.Reason.ToString();
                }
                return message;
            }

    向队列推送一条消息:

    /// <summary>
            /// 向消息队列推送一条消息
            /// </summary>
            /// <param name="msg">消息内容</param>
            /// <param name="queueName">队列名称</param>
            public void PushMsgToQueue(string msg, string queueName)
            {
                using (var mqmgr = MQQueueManager.Connect(IBMWMQConfig.QUEUE_MGR_NAME, MQC.MQCO_NONE, IBMWMQConfig.CHANNEL, IBMWMQConfig.CONNECTION_INFO))
                using (var q = new MQQueue(mqmgr, queueName, MQC.MQOO_INPUT_AS_Q_DEF + MQC.MQOO_OUTPUT + MQC.MQOO_FAIL_IF_QUIESCING))
                {
                    var outgoing = new MQMessage()
                    {
                        CharacterSet = MQC.CODESET_UTF,
                        Encoding = MQC.MQENC_NORMAL
                    };
                    outgoing.WriteString(msg);
                    q.Put(outgoing, new MQPutMessageOptions());
                }
            }
    
            /// <summary>
            /// 向消息队列推送一条消息
            /// </summary>
            /// <param name="msg">消息内容</param>
            /// <param name="queueName">队列名称</param>
            public void PushMsgToQueue1(string msg, string queueName)
            {
                using (var mqmgr = MQQueueManager.Connect(IBMWMQConfig.QUEUE_MGR_NAME, MQC.MQCO_NONE, IBMWMQConfig.CHANNEL, IBMWMQConfig.CONNECTION_INFO))
                {
                    if (mqmgr.IsConnected)
                    {
                        var outgoing = new MQMessage()
                        {
                            CharacterSet = MQC.CODESET_UTF,
                            Encoding = MQC.MQENC_NORMAL
                        };
                        outgoing.WriteString(msg);
    
                        var od = new MQObjectDescriptor
                        {
                            ObjectType = MQC.MQOT_Q,
                            ObjectName = queueName
                        };
                        mqmgr.Put1(od, outgoing, new MQPutMessageOptions());
                    }
                }
            }

     

    转载于:https://www.cnblogs.com/zhao-yi/p/10563745.html

    展开全文
  • wmq配置及编程

    2008-06-11 11:27:46
    wmq配置及编程,调优,接口等
  • IBM WMQ7.0环境备份及导入操作

    千次阅读 2017-05-10 10:41:15
    备份 用户切换至MQ用户 本人mq用户为mbadmin  命令su - mbadmin 输入dspmq确认队列管理器是否正常启动 以下为正常启动状态 QMNAME(MB7QMGR) STATUS(Running) 一下为正常停止状态 QMNAME(MB7QMGR)
  • 题目连接点这里 神套路题 因为m为素数所以必定有原根,设为x, 根据原根那套理论,x^(0)mod m,x^(1)mod m,,,,x^(m-2)mod m,的值互不相同,取遍 1到m-1.所以我们可以把原数组的每个数根据mod m等于多少,可以唯一...
  • ibm.wmq 安装程序 存档日期:2019年5月13日 | 上次更新时间:2014年6月30日 | 首次发布:2014年2月24日 在BlueMix中编写,部署,运行和管理一个简单的Node.js文件上传应用程序。 此内容不再被更新或维护。 全文以PDF...
  • wmq的A×B Problem

    2017-04-12 01:17:00
    wmq的A×B Problem 题目链接:http://oj.xjtuacm.com/problem/13/ 题目大意:$T$组数据,每组给出$n$个数$a_i$及一个素数$m$,求这$n$个数两两相乘模$m$余$k$有多少个($0\leqslant k < m$). 数论+FFT 原根...
  • wmq的A×B Problem 发布时间: 2017年4月9日 17:06 最后更新: 2017年4月9日 17:07 时间限制: 3000ms 内存限制: 512M 描述 这是一个非常简单的问题。 wmq如今开始学习乘法了!他为了训练自己的乘法计算能力,...
  • wmq的数学课

    2021-12-21 16:26:35
    原文链接: wmq的数学课 上一篇: ...
  • 题目链接:wmq的队伍dp[i][j] 表示第i个人且他是逆序序列的第j个时的方案数。 dp[i][j]=∑i−1k=1dp[k][j−1]dp[i][j]=\sum_{k=1}^{i-1}dp[k][j-1] 可以用树状数组来维护 ∑ki=1dp[i][j]\sum_{i=1}^{k}dp[i][j]#...
  • 包括WAS、WMQ在安装、巡检、监控、优化过程中的常见难点。安装1、was 负载均衡的机制的粘连性,was负载均衡异常?有一个case系统,部署在was集群环境,应用是集群环境,有的时候当一个节点异常的时,客户端访问该...
  • wmqjava

    2012-11-06 12:19:00
    运行WMQ的java样例MQSample.java所需的jar包: connector.jar com.ibm.mq.jmqi.jar com.ibm.mq.jar com.ibm.mq.headers.jar com.ibm.mq.commonservices.jar [img]...
  • Question You create a new queue manager in WebSphere MQ 7.1 and you try to use a user id that is an MQ Administrator to remotely access the queue manager via a client connection. You get an error wit

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,296
精华内容 518
关键字:

WMQ

友情链接: ReactOS-0.4.7-PressKit3.zip