JBoss Seam 3 JMS Module

Seam extends the CDI programming model into the messaging world by allowing you to inject JMS resources into your beans. Furthermore, Seam bridges the CDI event bus over JMS; this gives you the benefits of CDI-style type-safety for inter-application communication.

Seam JMS can be used by including a few libraries in your application's library folder:

If you are using Maven as your build tool use the following dependency, which will bring in both API and Implementation for Seam JMS:

<dependency>

   <groupId>org.jboss.seam.jms</groupId>

   <artifactId>seam-jms</artifactId>

   <version>${seam.jms.version}</version>

</dependency>

The runtime of Seam JMS is defined in two sections. The first section is related to creating observers, which happens within the Seam JMS CDI Extension. Observers need to be defined prior to starting up the container, and cannot be created once the application is running. This part happens automatically. The second section is related to creating listeners. This is managed in the component org.jboss.seam.jms.bridge.RouteBuilder.

<?xml version="1.0" encoding="UTF-8"?>

  <beans xmlns="http://java.sun.com/xml/ns/javaee"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:s="urn:java:ee"

    xmlns:jmsi="urn:java:org.jboss.seam.jms.inject"

    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://docs.jboss.org/cdi/beans_1_0.xsd">

    

    <jmsi:JmsConnectionFactoryProducer>

      <s:modifies />

      <jmsi:connectionFactoryJNDILocation>jms/ConnectionFactory</jmsi:connectionFactoryJNDILocation>

    </jmsi:JmsConnectionFactoryProducer>

  </beans>

    

In this chapter we'll look at how to inject some of the common JMS resource types.

@Inject @JmsDestination(jndiName="jms/MyTopic") Topic t;
@Inject @JmsDestination(jndiName="jms/MyQueue") Queue q;

@Inject @JmsSession(transacted=false, acknowledgementMode=Session.CLIENT_ACKNOWLEDGE) Session s;

The Seam JMS Messaging API is a higher level abstraction of the JMS API to provide a number of convenient methods for creating consumers, producers, etc.

@RequestScoped

@Named

public class FormBean {

  private String formData;

  @Inject QueueBuilder queueBuilder;

  @Inject TopicBuilder topicBuilder;


  public void sendFormDataToQueue() {

      queueBuilder.destination("jms/SomeQueue").sendString(formData);

  }


  public void sendFormDataToTopic() {

      topicBuilder.destination("jms/SomeTopic").sendString(formData);

  }

}

public interface MessageManager {

    public ObjectMessage createObjectMessage(Object object);

    public TextMessage createTextMessage(String string);

    public MapMessage createMapMessage(Map<Object,Object> map);

    public BytesMessage createBytesMessage(byte[] bytes);

    public void sendMessage(Message message, String... destinations);

    public void sendObjectToDestinations(Object object, String... destinations);

    public void sendTextToDestinations(String string, String... destinations);

    public void sendMapToDestinations(Map map, String... destinations);

    public void sendBytesToDestinations(byte[] bytes, String... destinations);

    public void sendMessage(Message message, Destination... destinations);

    public void sendObjectToDestinations(Object object, Destination... destinations);

    public void sendTextToDestinations(String string, Destination... destinations);

    public void sendMapToDestinations(Map map, Destination... destinations);

    public void sendBytesToDestinations(byte[] bytes, Destination... destinations);

    public Session getSession();

    public MessageProducer createMessageProducer(String destination);

    public TopicPublisher createTopicPublisher(String destination);

    public QueueSender createQueueSender(String destination);

    public MessageConsumer createMessageConsumer(String destination, MessageListener... listeners);

    public MessageConsumer createMessageConsumer(Destination destination, MessageListener... listeners);

    public TopicSubscriber createTopicSubscriber(String destination, MessageListener... listeners);

    public QueueReceiver createQueueReceiver(String destination, MessageListener... listeners);

    public TopicBuilder createTopicBuilder();

    public QueueBuilder createQueueBuilder();

}

@SessionScoped

                public class UserSession {

                    @Inject MessageManager messageManager;

                    @Inject MySessionJMSListener listener;

                    private String clientId;

                    @PostConstruct

                    public void registerListener() {

                        clientId = UUID.randomUUID().toString();

                        messageManager.createDurableSubscriber("jms/UserTopic",clientId,listener);

                    }

                    @PreDestroy

                    public void shutdownListener() {

                        messageManager.unsubscribe(clientId);

                    }

                }

                

            @Inject @Durable DurableMessageManager durableMsgManager;

            

            public void login(String clientId);

            public TopicSubscriber createDurableSubscriber(String topic, String id, MessageListener... listeners);

            public TopicSubscriber createDurableSubscriber(Topic topic, String id, MessageListener... listeners);

            public void unsubscribe(String id);

            

                //where cl is the class loader, and beanManager is the BeanManager

                MessageListener ml = new SessionListener(beanManager,cl,this);

                messageManager.createTopicSubscriber("/jms/myTopic", ml);

            

@SessionScoped

                public class SessionListener extends AbstractMessageListener {

                    private MySessionObject mso;

                    public SessionListener(BeanManager beanManager, ClassLoader classLoader,

                        MySessionObject mso){

                        super(beanManager,classLoader);

                        this.mso = mso;

                    }


                    @Override

                    protected void handlMessage(Message msg) throws JMSException {

                        //your business logic goes here

                    }

                }

                

This chapter is designed to detail how to configure the CDI to JMS event bridge. Routing has two sides, sending of events to JMS destinations and translating received messages from JMS destinations back into CDI events. The sections of this chapter describe how to achieve both.

public interface Route {
  public <D extends Destination> Route connectTo(Class<D> d, D destination);
  public Route addQualifiers(Annotation... qualifiers);

  ...
}
                

@EventRouting public Route registerMyRoute(RouteManager routeManager)
{
   Queue myQueue = lookupQueue("/jms/MyQueue");
   return routeManager.createRoute(RouteType.EGRESS, MyEvent.class).connectTo(Queue.class, myQueue);
}
                

@EventRouting public Route myConfig()
{
   return bridge.createRoute(RouteType.INGRESS, MyEvent.class).addDestinationJndiName("/jms/MyTopic");
}
                

AnnotationLiteral<Bridged> BRIDGED = new AnnotationLiteral<Bridged>() {};
@EventRouting public Route registerMyEventRoute(RouteManager routeManager)
{
   return routeManager.createRoute(RouteType.EGRESS, MyEvent.class).addQualifiers(BRIDGED).addDestinationJndiName("/jms/EventQueue");
}
            

@Inject @Bridged @Routing(RouteType.EGRESS) Event<MyEvent> event;
...
event.fire(myEvent);
                

AnnotationLiteral<Bridged> BRIDGED = new AnnotationLiteral<Bridged>() {};
@EventRouting public Route registerMyEventRoute(RouteManager routeManager)
{
   return routeManager.createRoute(RouteType.INGRESS, MyEvent.class).addQualifiers(BRIDGED).addDestinationJndiName("/jms/EventQueue");
}
        

          public void handleInboundMyEvent(@Observes @Routing(RouteType.INGRESS) MyEvent e) {
            ....
          }
            

This chapter is meant to describe the behavior of mapping interfaces, where event mapping to data flowing through JMS Queues and Topics are handled via events. These APIs are an alternate way to define routes as mentioned earlier in the document.

           public interface MappingInterface {
               @Inbound
               public void routeStringsFromTopic(@Observes String s, @JmsDestination(jndiName="jms/MyTopic") Topic t);
               
               @Outbound
               public void routeLongsToQueue(@Observes Long l, @JmsDestination(jndiName="jms/MyQueue") Queue q);

               public void bidirectionRouteDoublesToQueue(@Observes Double d, @JmsDestination(jndiName="jms/DblQueue") Queue q);
           }
       

            @Inject @Outbound Event<Double> doubleEvent
            ...
            doubleEvent.fire(d);
       

           public class MyEventObserverBean {
            public void sendMessage(@Observes @Inbound Double d) {
                System.out.println(d);
            }
           }