JMS details 2

• Java Message Service (JMS) Details

This article introduces the Message Service JMS in Java. Java Message Service provides the point-to-point mode and the publish-subscribe mode. These two services are described in detail in this article.

 

Java Message Service (JMS Java Message Services) provides point-to-point queue and publish-subscribe modes ).

Queue only allows one message to be sent to one customer (one-to-one ):

There is no time dependency between the receiver and the sender of Java Message Service JMS. The receiver can extract information regardless of whether the receiver is running when the sender sends the message. The recipient provides a receipt for successfully processed messages.

Topics can have multiple clients (one to multiple, multiple to multiple ):

The client program that subscribes to a topic can only receive messages published after it subscribes. To receive messages, the subscriber must remain active. Therefore, there is a time dependency between the publisher and the subscriber.

The point-to-point message mode is implemented through a queue. The producer of a message writes a message to the queue, and the subscriber of the message extracts the message from the queue. The publish-subscribe message mode is implemented through a layered structure composed of a topic node. The message producer publishes messages to this hierarchy, and the subscriber of the message subscribes to the message.

The message-driven bean has only one bean class. In some respects, the JMS message-driven bean is similar to the stateless Session Bean: the message-driven bean does not retain data or conversation status for specific customers.

 
 

  
  
@MessageDriven(activationConfig={  
  
  
   @ActivationConfigProperty(propertyName="destinationType",propertyValue="javax.jms.Queue"),  
  
  
   @ActivationConfigProperty(propertyName="destination",propertyValue="queue/jms")  
  
  
}) 
 
 

@ Messagedriven the comment indicates that this is a message-driven bean and uses @ activationconfigproperty to annotate various attributes of the message. The destinationtype attribute specifies the type of the message. There are two types of messages: topics and queues, the following describes the two types of messages:

Topics can have multiple clients. Topic publishing allows one-to-multiple or multiple-to-multiple communication channels. The publisher of a message is called publisher, and the receiver of Java Message Service is called subscriber. Destinationtype attribute value: javax. JMS. Topic

Queue only allows one message to be sent to one customer. A sender puts a message into the message queue. The receiver extracts and obtains the message from the queue, and the message disappears in the queue. After the first receiver extracts and obtains the message, others cannot obtain it. Destinationtype attribute value: javax. JMS. the queue destination attribute is used to specify the message path. When a message-driven bean is published, if the path does not exist, the container automatically creates the path. when the container is closed, the path is automatically deleted.

When a message arrives in the queue/JMS queue, the onmessage method is triggered and the message is passed in as a parameter.

 
 

  
  
package com.julycn.jms;  
  
  
 
  
  
import javax.ejb.ActivationConfigProperty;  
  
  
import javax.ejb.MessageDriven;  
  
  
import javax.jms.JMSException;  
  
  
import javax.jms.Message;  
  
  
import javax.jms.MessageListener;  
  
  
import javax.jms.TextMessage;  
  
  
 
  
  
@MessageDriven(activationConfig = {  
  
  
        @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),  
  
  
        @ActivationConfigProperty(propertyName = "destination", propertyValue = "queue/jms") })  
  
  
public class MessageQueue implements MessageListener {  
  
  
 
  
  
    public MessageQueue() {  
  
  
 
  
  
    }  
  
  
 
  
  
    public void onMessage(Message message) {  
  
  
        TextMessage tmsg = (TextMessage) message;  
  
  
        try {  
  
  
            System.out.println(tmsg.getText());  
  
  
        } catch (JMSException e) {  
  
  
            e.printStackTrace();  
  
  
        }  
  
  
    }  
  
  
 
  
  
} 
 
 

 
 

  
  
PackageCom. julycn. client;
  
  
 
  
  
ImportJavax. JMS. jmsexception;
  
  
ImportJavax. JMS. Queue;
  
  
ImportJavax. JMS. queueconnection;
  
  
ImportJavax. JMS. queueconnectionfactory;
  
  
ImportJavax. JMS. queuesender;
  
  
ImportJavax. JMS. queuesession;
  
  
ImportJavax. JMS. textmessage;
  
  
ImportJavax. Naming. initialcontext;
  
  
ImportJavax. Naming. namingexception;
  
  
 
  
  
Public ClassMessagequeueclient {
  
  
 
  
  
Public Static VoidMain (string [] ARGs ){
  
  
Queueconnection conn;
  
  
Queuesession;
  
  
Queue queue;
  
  
Queuesender sender;
  
  
Textmessage MSG;
  
  
 
  
  
Try{
  
  
Initialcontext CTX =NewInitialcontext ();
  
  
Queueconnectionfactory qcf = (queueconnectionfactory) CTX
  
  
. Lookup ("connectionfactory ");
  
  
Conn = qcf. createqueueconnection ();
  
  
Session = conn. createqueuesession (False,
  
  
Queuesession. auto_acknowledge );
  
  
Queue = (Queue) CTX. Lookup ("queue/JMS ");
  
  
MSG = session. createtextmessage ("hello, I haven't seen you for a long time! ");
  
  
Sender = session. createsender (Queue );
  
  
Sender. Send (MSG );
  
  
Sender. Close ();
  
  
}Catch(Namingexception e ){
  
  
E. printstacktrace ();
  
  
}Catch(Jmsexception e ){
  
  
E. printstacktrace ();
  
  
}
  
  
 
  
  
}
  
  
 
  
  
}
 
 

(1) Get a JNDI initialization context (context );

Sample Code:

Properties props = new properties ();
Props. setproperty ("Java. Naming. Factory. Initial", "org. jnp. Interfaces. namingcontextfactory ");
Props. setproperty ("Java. Naming. provider. url", "localhost: 1099 ");
Props. setproperty ("Java. Naming. Factory. url. pkgs", "org. JBoss. Naming ");
Initialcontext CTX = new initialcontext (props );

Note: It can be written in the Code or in the JNDI. properties file.

(2) Search for a connection factory topicconnectfactory/queueconnectionfactory Based on the context (there are two connection factories, the corresponding type is used based on the topic/Queue );

Sample Code:

Queueconnectionfactory qcf = (queueconnectionfactory) CTX. Lookup ("connectionfactory ");

(3) Get a connection from the connection Factory (connect has two [topicconnection/queueconnection]);

Example code: conn = qcf. createqueueconnection ();

(4) Establish a session through a connection );

Example code: Session = conn. createqueuesession (false, queuesession. auto_acknowledge );

This Code indicates that a session that does not need transactions and can automatically receive Java Message Service receipts is established. In non-transaction sessions, there are three methods for passing JMS messages:
Session. auto_acknowledge: when the client calls the receive method and messagelistenser successfully processes the message, the session automatically receives the message receipt.

Session. client_acknowledge: the client receives a message by calling the acknowledge method of the message. The message is received at the Session Layer. When a consumed message is received, all messages that have been consumed by the session are automatically received. For example, if the consumer consumes 10 messages and receives 15 messages, the receipt of the first 10 messages will be received in the 15 messages.

Session. dups_acknowledge: indicates that the session receives messages slowly.

(5) Search for the destination (topic/Queue );

Example code: queue = (Queue) CTX. Lookup ("queue/JMS ");

(6) create a message producer (topicpublisher/queuesender) and a consumer (topicsubscriber/queuereceiver) based on the session and destination ).
Sample Code:

MSG = session. createtextmessage ("hello, I haven't seen you for a long time! ");
Sender = session. createsender (Queue );
Sender. Send (MSG );

NOTE: If javax. Naming. namenotfoundexception: JMS not bound occurs during runtime, JBoss does not create a queue object by itself. Therefore, you need to manually configure the queue object. You can create a xxx-service.xml file in the <jboss5.x installation directory>/Server/default/deploy directory, where xxx can take any value, but must be suffixed with "-service", for example, abc-service.xml. This file can be stored in deploy or its subdirectory (which can be a multi-layer subdirectory. The content of this file is as follows:

 
 

  
  
<?xml version="1.0" encoding="UTF-8"?> 
  
  
<server> 
  
  
    <mbean code="org.jboss.mq.server.jmx.Queue" name="jboss.mq.destination:service=Queue,name=jms"> 
  
  
        <depends optional-attribute-name="DestinationManager"> 
  
  
            jboss.mq:service=DestinationManager</depends> 
  
  
    </mbean> 
  
  
</server> 
 
 

<Mbean> the name attribute value of an element must be JMS, which must be consistent with the/section following queue/JMS.