Websphere IBM MQ JMSWMQ0018:未能连接到队列管理器'；我的本地质量管理&x27；具有连接模式'；客户'；和主机名'；我的本地QM（1401）和x27；

我创建了一个队列管理器、队列和通道（服务器连接）。 当我尝试发送消息时，请参见以下错误： com.ibm.msg.client.jms.DetailedAllegalStateException:JMSWMQ0018:无法连接到连接模式为“客户端”且主机名为“epspa（1401）”的队列管理器“MY_LOCAL_QM”。 检查队列管理器是否已启动，如果在客户端模式下运行，请检查是否有侦听器正在运行。有关详细信息，请参阅链接的异常

也许我需要将用户设置为队列管理器？因为我使用了相同的java代码，但是尝试连接到另一个队列管理器，并且工作正常。但它不适用于我的队列管理器。 IBM MQ已安装在另一台PC上

 private static final String HOST = "epspa";
private static final int PORT = 1401;
private static final String CHANNEL = "API.SVRCONN_LOCAL";
private static final String QMN = "MY_LOCAL_QM";
private static final String QUEUE_NAME = "API.QUEUE_NAME";
private static final String message ="message";

public static String sendMessage(String message) {
    String result = "Error";
    try {
        MQQueueConnectionFactory cf = new MQQueueConnectionFactory();
        cf.setHostName(HOST);
        cf.setChannel(CHANNEL);
        cf.setPort(PORT);
        cf.setQueueManager(QMN);
        cf.setTransportType(WMQConstants.WMQ_MESSAGE_BODY_MQ);

        Destination destination = null;
        MessageProducer producer = null;

        Connection c = cf.createConnection();
        Session s = c.createSession(false, Session.AUTO_ACKNOWLEDGE);
        destination = s.createQueue(QUEUE_NAME);
        producer = s.createProducer(destination);
        TextMessage tmo = s.createTextMessage();


        ((MQDestination) destination).setMessageBodyStyle
                (WMQConstants.WMQ_MESSAGE_BODY_MQ);

        tmo.setIntProperty(WMQConstants.JMS_IBM_CHARACTER_SET, 1208);
        tmo.setIntProperty(WMQConstants.JMS_IBM_ENCODING,546);
        tmo.setText(message);
        producer.send(tmo);

        result = "Success!";
    } catch (JMSException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}

cf.setTransportType（WMQConstants.WMQ_MESSAGE_BODY_MQ）

嗯，那是不对的。应该是：

cf.setTransportType(WMQConstants.WMQ_CM_CLIENT);

JMSWMQ0018:未能连接到队列管理器

JMS错误没有提供有关MQ所抱怨内容的足够详细信息。您需要输出LinkedException

catch (JMSException e)
{
   if (e != null)
   {
      System.err.println("getLinkedException()=" + e.getLinkedException());
      System.err.println(e.getLocalizedMessage());
      e.printStackTrace();
   }
}

您确定1401的端口#正确吗？MQ的默认端口为1414。针对队列管理器启动runmqsc。i、 e

runmqsc MY_LOCAL_QM

然后发出以下命令：

DIS LISTENER(LISTENER.TCP)

端口属性的值是多少

setIntProperty（WMQConstants.JMS_IBM_CHARACTER_SET，1208）； setIntProperty（WMQConstants.JMS_IBM_ENCODING，546）

为什么要设置CCSID和编码？为什么不让JMS和MQ来处理呢

下面是一个功能完整的JMS程序，可将消息放入队列：

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Hashtable;
import javax.jms.*;

import com.ibm.mq.jms.*;
import com.ibm.msg.client.wmq.WMQConstants;

/**
 * Program Name
 *  MQTestJMS11
 *
 * Description
 *  This java JMS class will connect to a remote queue manager and put a message to a queue.
 *
 * Sample Command Line Parameters
 *  -m MQA1 -h 127.0.0.1 -p 1414 -c TEST.CHL -q TEST.Q1 -u UserID -x Password
 *
 * @author Roger Lacroix
 */
public class MQTestJMS11
{
   private static final SimpleDateFormat  LOGGER_TIMESTAMP = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");

   private Hashtable<String,String> params;
   private MQQueueConnectionFactory mqQCF = null;


   /**
    * The constructor
    */
   public MQTestJMS11()
   {
      super();
      params = new Hashtable<String,String>();
   }

   /**
    * Make sure the required parameters are present.
    * @return true/false
    */
   private boolean allParamsPresent()
   {
      boolean b = params.containsKey("-h") && params.containsKey("-p") &&
                  params.containsKey("-c") && params.containsKey("-m") &&
                  params.containsKey("-q") &&
                  params.containsKey("-u") && params.containsKey("-x");
      if (b)
      {
         try
         {
            Integer.parseInt((String) params.get("-p"));
         }
         catch (NumberFormatException e)
         {
            b = false;
         }
      }

      return b;
   }

   /**
    * Extract the command-line parameters and initialize the MQ variables.
    * @param args
    * @throws IllegalArgumentException
    */
   private void init(String[] args) throws IllegalArgumentException
   {
      if (args.length > 0 && (args.length % 2) == 0)
      {
         for (int i = 0; i < args.length; i += 2)
         {
            params.put(args[i], args[i + 1]);
         }
      }
      else
      {
         throw new IllegalArgumentException();
      }

      if (allParamsPresent())
      {
         try
         {
            mqQCF = new MQQueueConnectionFactory();
            mqQCF.setQueueManager((String) params.get("-m"));
            mqQCF.setHostName((String) params.get("-h"));
            mqQCF.setChannel((String) params.get("-c"));
            mqQCF.setTransportType(WMQConstants.WMQ_CM_CLIENT);
            try
            {
               mqQCF.setPort(Integer.parseInt((String) params.get("-p")));
            }
            catch (NumberFormatException e)
            {
               mqQCF.setPort(1414);
            }
         }
         catch (JMSException e)
         {
            if (e != null)
            {
               MQTestJMS11.logger("getLinkedException()=" + e.getLinkedException());
               MQTestJMS11.logger(e.getLocalizedMessage());
               e.printStackTrace();
            }
            throw new IllegalArgumentException();
         }
         catch (Exception e)
         {
            MQTestJMS11.logger(e.getLocalizedMessage());
            e.printStackTrace();
            throw new IllegalArgumentException();
         }
      }
      else
      {
         throw new IllegalArgumentException();
      }
   }

   /**
    * Test the connection to the queue manager.
    * @throws MQException
    */
   private void testConn()
   {
      QueueConnection conn = null;
      QueueSession session = null;
      Queue myQ = null;

      try
      {
         conn = mqQCF.createQueueConnection((String) params.get("-u"), (String) params.get("-x"));
         conn.start();

         session = conn.createQueueSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);
         MQTestJMS11.logger("successfully connected.");

         myQ = session.createQueue((String) params.get("-q"));

         MQDestination mqd = (MQDestination) myQ;
         mqd.setTargetClient(WMQConstants.WMQ_CLIENT_JMS_COMPLIANT);
//         mqd.setTargetClient(WMQConstants.WMQ_CLIENT_NONJMS_MQ);

         sendMsg( session, myQ);
      }
      catch (JMSException e)
      {
         if (e != null)
         {
            MQTestJMS11.logger("getLinkedException()=" + e.getLinkedException());
            MQTestJMS11.logger(e.getLocalizedMessage());
            e.printStackTrace();
         }
      }
      catch (Exception e)
      {
         MQTestJMS11.logger(e.getLocalizedMessage());
         e.printStackTrace();
      }
      finally
      {
         try
         {
            if (session != null)
               session.close();
         }
         catch (Exception ex)
         {
            MQTestJMS11.logger("session.close() : " + ex.getLocalizedMessage());
         }

         try
         {
            if (conn != null)
               conn.stop();
         }
         catch (Exception ex)
         {
            MQTestJMS11.logger("connection.stop() : " + ex.getLocalizedMessage());
         }

         try
         {
            if (conn != null)
               conn.close();
         }
         catch (Exception ex)
         {
            MQTestJMS11.logger("connection.close() : " + ex.getLocalizedMessage());
         }
      }
   }

   /**
    * Send a message to a queue.
    * @throws MQException
    */
   private void sendMsg(QueueSession session, Queue myQ) throws JMSException
   {
      QueueSender sender = null;

      try
      {
         TextMessage msg = session.createTextMessage();
         msg.setText("Nice simple test. Time in 'ms' is  -> " + System.currentTimeMillis());
         // msg.setJMSReplyTo(tq);
         // msg.setJMSDeliveryMode( DeliveryMode.NON_PERSISTENT);

         MQTestJMS11.logger("Sending request to " + myQ.getQueueName());
         MQTestJMS11.logger("");

         sender = session.createSender(myQ);
         sender.send(msg);
      }
      finally
      {
         try
         {
            if (sender != null)
               sender.close();
         }
         catch (Exception ex)
         {
            MQTestJMS11.logger("sender.close() : " + ex.getLocalizedMessage());
         }
      }
   }

   /**
    * A simple logger method
    * @param data
    */
   public static void logger(String data)
   {
      String className = Thread.currentThread().getStackTrace()[2].getClassName();

      // Remove the package info.
      if ( (className != null) && (className.lastIndexOf('.') != -1) )
         className = className.substring(className.lastIndexOf('.')+1);

      System.out.println(LOGGER_TIMESTAMP.format(new Date())+" "+className+": "+Thread.currentThread().getStackTrace()[2].getMethodName()+": "+data);
   }

   /**
    * mainline
    * @param args
    */
   public static void main(String[] args)
   {
      MQTestJMS11 write = new MQTestJMS11();

      try
      {
         write.init(args);
         write.testConn();
      }
      catch (IllegalArgumentException e)
      {
         MQTestJMS11.logger("Usage: java MQTestJMS11 -m QueueManagerName -h host -p port -c channel -q JMS_Queue_Name -u UserID -x Password");
         System.exit(1);
      }
      catch (Exception e)
      {
         MQTestJMS11.logger(e.getLocalizedMessage());
         System.exit(1);
      }

      System.exit(0);
   }
}

import java.text.simpleDataFormat；
导入java.util.Date；
导入java.util.Hashtable；
导入javax.jms.*；
导入com.ibm.mq.jms.*；
导入com.ibm.msg.client.wmq.WMQConstants；
/**
*程序名
*MQTestJMS11
*
*描述
*这个JavaJMS类将连接到远程队列管理器并将消息放入队列。
*
*命令行参数示例
*-MQA1-h127.0.0.1-p1414-c TEST.CHL-q TEST.Q1-u UserID-x Password
*
*@作者罗杰·拉克鲁瓦
*/
公共类MQTestJMS11
{
专用静态最终SimpleDataFormat记录器\u时间戳=新SimpleDataFormat（“yyyy/MM/dd HH:MM:ss.SSS”）；
私有哈希表参数；
私有MQQueueConnectionFactory mqQCF=null；
/**
*构造器
*/
公共MQTestJMS11（）
{
超级（）；
params=新哈希表（）；
}
/**
*确保存在所需的参数。
*@return-true/false
*/
私有布尔allParamsPresent（）
{
布尔b=params.containsKey（“-h”）和¶ms.containsKey（“-p”）&&
参数containsKey（“-c”）&参数containsKey（“-m”）&&
参数containsKey（“-q”）&&
参数containsKey（“-u”）和参数containsKey（“-x”）；
如果（b）
{
尝试
{
Integer.parseInt（（String）params.get（“-p”）；
}
捕获（数字格式）
{
b=假；
}
}
返回b；
}
/**
*提取命令行参数并初始化MQ变量。
*@param args
*@galargumentException
*/
私有void init（字符串[]args）引发IllegalArgumentException
{
如果（args.length>0&（args.length%2）==0）
{
对于（int i=0；i