WebLogicJMS

Using WebLogic JMS from NetBeans


Contents


JMS Queue Creation Sample

In order to create JMS Queue we need to access admin console. Project specific JMS resources are not yet supported in the IDE.

WebLogic Server Registration

The first thing we need is to register and start server. We are using WebLogic 10.3.5 in our sample.

To register the server we select Services tab and right-click the Server node. From context menu we choose Add Server. In the wizard we select Oracle WebLogic Server.

Registration step 1

In next step we have to select our installation.

Registration step 2

And in the last step we specify a domain, username and password.

Registration step 3

After successful registration you should see a new WebLogic node. Now you can right click the WebLogic node and choose Start item. You should see the WebLogic log in the output window.

Server running

JMS Queue Configuration

In order to make things really simple for our demonstration we use single server domain and we do not specify any persistent store for the queue.

To open admin console right-click the WebLogic node and click View Admin Console item. In the browser window fill in username and password and log in to admin console.

First we need to create a JMS Server. In Domain Structure view click on Services, Messaging and JMS Servers and click New button in the table.

Server creation step 1

Enter the server name you like and click next.

Server creation step 2

Select the admin server as target and click finish. You should see the new JMS server as presented on the next picture.

Server creation step 3

Next we need to create JMS module. In Domain Structure view click on Services, Messaging and JMS Modules and click New button in the table. Enter the module name and click next.

JMS Module creation step 1

In the next step select the admin server as target and click next.

JMS Module creation step 2

As we want to create JMS Queue in the module mark the checkbox asking us about that and click finish.

JMS Module creation step 3

Now the empty JMS module is created and we have to click on New button in Resources table to add a queue.

JMS Module creation step 4

Select the Queue resource as shown below and click next.

JMS Module creation step 5

Enter the name of the queue and its JNDI name and click next again.

JMS Module creation step 6

In order to properly configure a target for the JMS queue we click on "Create a New Subdeployment" button.

JMS Module creation step 7

Enter the subdeployment name and click OK.

JMS Module creation step 8

Finally choose the target - the JMS server we created before and finish the wizard.

JMS Module creation step 9

We have just created simple JMS queue.

JMS Module creation step 10

Message-driven EJB

With all the things preconfigured we can create a message driven bean using the queue. First we have to create the EJB project targeting WebLogic server.

In order to do that select File in main menu than New Project and in Java EE category select EJB module and click next.

EJB Module step 1

Specify the name of the project and click next again.

EJB Module step 2

In the last step select the server we registered in the beginning and finish the wizard.

EJB Module step 3

To create a MDB right click the created project node and select New -> Message-Driven Bean from the context menu. In the MDB wizard fill in the bean name and select the the message queue we have created in admin console.

Message driven bean

When finished the IDE will generate following class for you.

@MessageDriven(mappedName = "jms/Queue-0", activationConfig = {
    @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
})
public class MyMessageBean implements MessageListener {
    
    public MyMessageBean() {
    }
    
    @Override
    public void onMessage(Message message) {
    }
}

We will only change the onMessage() method slightly to give us some simple feedback when message arrives.

@MessageDriven(mappedName = "jms/Queue-0", activationConfig = {
    @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
})
public class MyMessageBean implements MessageListener {
    
    public MyMessageBean() {
    }
    
    @Override
    public void onMessage(Message message) {
        try {
            if (message instanceof TextMessage) {
                System.out.println(((TextMessage) message).getText());
            } else {
                System.out.println(message.getJMSMessageID());
            }
        } catch (JMSException ex) {
            Logger.getLogger(NewMessageBean.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

Now we can run our EJB module on WebLogic server by hitting the F6 key.

Web Application

To test the MDB and the JMS queue actually works we will create a simple web application with one servlet producing the messages. We have to create the Web Application project first. To do that click on File in main menu and select New Project. In the wizard choose Java Web category and Web Application project and click next.

Web Application step 1

Configure the name and location of the project and continue to the next step.

Web Application step 2

In the last step select the WebLogic server we have registered and finish the wizard.

Web Application step 3

To create a simple servlet right click the created project node and select New -> Servlet from the context menu. In the Servlet wizard fill in the servlet name and proceed to the next step.

Servlet step 1

Here you can configure the URL for the servlet. It is safe to use the defaults.

Servlet step 2

After finishing the wizard the IDE will generate the following servlet code for us.

public class MyServlet extends HttpServlet {

    /** 
     * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            /* TODO output your page here
            out.println("<html>");
            out.println("<head>");
            out.println("<title>Servlet MyServlet</title>");  
            out.println("</head>");
            out.println("<body>");
            out.println("<h1>Servlet MyServlet at " + request.getContextPath () + "</h1>");
            out.println("</body>");
            out.println("</html>");
             */
        } finally {
            out.close();
        }
    }

...
}

We will reuse it to generate sample Hello messages. We use Java EE 5 annotations to inject default connection factory and our JMS queue. On every request we create a message and we send it to the queue.

public class MyServlet extends HttpServlet {

    @Resource(mappedName="weblogic.jms.ConnectionFactory")
    private ConnectionFactory connectionFactory;
    
    @Resource(mappedName="jms/Queue-0")
    private Queue queue;

    /** 
     * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            Connection connection = connectionFactory.createConnection();
            try {
                Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
                try {
                    MessageProducer messageProducer = session.createProducer(queue);
                    out.println("<html>");
                    out.println("<head>");
                    out.println("<title>Servlet NewServlet</title>");
                    out.println("</head>");
                    out.println("<body>");
                    out.println("<h1>Servlet NewServlet at " + request.getContextPath () + "</h1>"); out.println("</body>");
                    Message message = session.createTextMessage("Hello");
                    messageProducer.send(message);
                    out.println("Sent message Hello");
                    out.println("</html>");
                } finally {
                    session.close();
                }
            } finally {
                connection.close();
            }
        } catch (JMSException ex) {
            throw new ServletException(ex);
        } finally {            
            out.close();
        }
    }

...
}

Now we are ready to run the web application on our WebLogic server by hitting the F6 key.

Sending Messages

By default when you run the web application it opens the index.jsp. We need to navigate to our servlet to send a JMS message. The URL of the servlet used in our sample is http://localhost:7001/MyWebApplication/MyServlet.

Servlet

By invoking the servlet the message in via the queue delivered to our MDB and the content of the message in printed to server log as shown below.

Hello Message
Not logged in. Log in, Register

By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2012, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo