JMS的代码怎么写

本篇内容介绍了“JMS的代码怎么写”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

成都一家集口碑和实力的网站建设服务商，拥有专业的企业建站团队和靠谱的建站技术，十多年企业及个人网站建设经验 ,为成都上1000家客户提供网页设计制作,网站开发,企业网站制作建设等服务,包括成都营销型网站建设，品牌网站设计，同时也为不同行业的客户提供网站制作、做网站的服务,包括成都电商型网站制作建设,装修行业网站制作建设，传统机械行业网站建设,传统农业行业网站制作建设。在成都做网站,选网站制作建设服务商就选创新互联公司。

private Session session;
private boolean transacted = false;
private MessageProducer replyProducer;
private MessageProtocol messageProtocol;

static {
    messageBrokerUrl = "tcp://localhost:61616";
    messageQueueName = "client.messages";
    ackMode = Session.AUTO_ACKNOWLEDGE;
}

public Server() {
    try {
        //This message broker is embedded
        BrokerService broker = new BrokerService();
        broker.setPersistent(false);
        broker.setUseJmx(false);
        broker.addConnector(messageBrokerUrl);
        broker.start();
    } catch (Exception e) {
        //Handle the exception appropriately
    }

    //Delegating the handling of messages to another class, instantiate it before setting up JMS so it
    //is ready to handle messages
    this.messageProtocol = new MessageProtocol();
    this.setupMessageQueueConsumer();
}

private void setupMessageQueueConsumer() {
    ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(messageBrokerUrl);
    Connection connection;
    try {
        connection = connectionFactory.createConnection();
        connection.start();
        this.session = connection.createSession(this.transacted, ackMode);
        Destination adminQueue = this.session.createQueue(messageQueueName);

        //Setup a message producer to respond to messages from clients, we will get the destination
        //to send to from the JMSReplyTo header field from a Message
        this.replyProducer = this.session.createProducer(null);
        this.replyProducer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

        //Set up a consumer to consume messages off of the admin queue
        MessageConsumer consumer = this.session.createConsumer(adminQueue);
        consumer.setMessageListener(this);
    } catch (JMSException e) {
        //Handle the exception appropriately
    }
}

public void onMessage(Message message) {
    try {
        TextMessage response = this.session.createTextMessage();
        if (message instanceof TextMessage) {
            TextMessage txtMsg = (TextMessage) message;
            String messageText = txtMsg.getText();
            response.setText(this.messageProtocol.handleProtocolMessage(messageText));
        }

        //Set the correlation ID from the received message to be the correlation id of the response message
        //this lets the client identify which message this is a response to if it has more than
        //one outstanding message to the server
        response.setJMSCorrelationID(message.getJMSCorrelationID());

        //Send the response to the Destination specified by the JMSReplyTo field of the received message,
        //this is presumably a temporary queue created by the client
        this.replyProducer.send(message.getJMSReplyTo(), response);
    } catch (JMSException e) {
        //Handle the exception appropriately
    }
}

public static void main(String[] args) {
    new Server();
}

private boolean transacted = false;
private MessageProducer producer;

static {
    clientQueueName = "client.messages";
    ackMode = Session.AUTO_ACKNOWLEDGE;
}

public Client() {
    ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
    Connection connection;
    try {
        connection = connectionFactory.createConnection();
        connection.start();
        Session session = connection.createSession(transacted, ackMode);
        Destination adminQueue = session.createQueue(clientQueueName);

        //Setup a message producer to send message to the queue the server is consuming from
        this.producer = session.createProducer(adminQueue);
        this.producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

        //Create a temporary queue that this client will listen for responses on then create a consumer
        //that consumes message from this temporary queue...for a real application a client should reuse
        //the same temp queue for each message to the server...one temp queue per client
        Destination tempDest = session.createTemporaryQueue();
        MessageConsumer responseConsumer = session.createConsumer(tempDest);

        //This class will handle the messages to the temp queue as well
        responseConsumer.setMessageListener(this);

        //Now create the actual message you want to send
        TextMessage txtMessage = session.createTextMessage();
        txtMessage.setText("MyProtocolMessage");

        //Set the reply to field to the temp queue you created above, this is the queue the server
        //will respond to
        txtMessage.setJMSReplyTo(tempDest);

        //Set a correlation ID so when you get a response you know which sent message the response is for
        //If there is never more than one outstanding message to the server then the
        //same correlation ID can be used for all the messages...if there is more than one outstanding
        //message to the server you would presumably want to associate the correlation ID with this
        //message somehow...a Map works good
        String correlationId = this.createRandomString();
        txtMessage.setJMSCorrelationID(correlationId);
        this.producer.send(txtMessage);
    } catch (JMSException e) {
        //Handle the exception appropriately
    }
}

private String createRandomString() {
    Random random = new Random(System.currentTimeMillis());
    long randomLong = random.nextLong();
    return Long.toHexString(randomLong);
}

public void onMessage(Message message) {
    String messageText = null;
    try {
        if (message instanceof TextMessage) {
            TextMessage textMessage = (TextMessage) message;
            messageText = textMessage.getText();
            System.out.println("messageText = " + messageText);
        }
    } catch (JMSException e) {
        //Handle the exception appropriately
    }
}

public static void main(String[] args) {
    new Client();
}

    return responseText;
}

“JMS的代码怎么写”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！