JavaEE6 Weblogic exercice 1

Add a servlet, run the project

Create a standard dynamic web project using Eclipse, call it for example "Exo1WebProfile". Click twice on the next button and in the last screen, check "Generate web.xml descriptor". Normally we do not need any XML settings in that file (JavaEE 6 replaced the need to XML settings by code annotations) but it will be useful to set the starting URL when we run the project in that file.

Add a Servlet in the project, call it TestServlet, and add it in a package named "servlets". Click finish. Add some lines in the doGet() method, like these:

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		 // Set the response message's MIME type.
	      response.setContentType("text/html;charset=UTF-8");
	      // Allocate a output writer to write the response message into the network socket.
	      PrintWriter out = response.getWriter();
	      
	      out.println("<h1>Welcome to Exo1 test servlet!</h1>");
}

 Then modify the web.xml file in order to start the project directly with this servlet. If you look at the Servlet code you will find an annotation that set the URL pattern for the servlet: @WebServlet("/TestServlet"), so let's modifiy the <welcome-file> entry in the web.xml descriptor:

 <welcome-file-list>
    <welcome-file>TestServlet</welcome-file>
  </welcome-file-list>

Then right click the project, do Run As/Run on server. The first time you will be asked to choose a server. Select "weblogic 12c", check the checkbox so that thos will be a default value for this project and click finish. This should launch weblogic, the console tab should appear, etc. And after a while you should see a browser inside Eclipse showing "Welcome to Exo1 test servlet!".

Add a stateless session bean EJB

Now we will add a stateless session bean EJB to the project. Select as the type of element to add to the project "session bean (EJB 3.x)", add it in a package named "sessions" and name it "HelloWorldBean". Notice that in the wizard you have a select menu for stateless/stateful/singleton and below you may choose to implement some local or remote interfaces. For the moment leave everything with default values (stateless, no interface). Click finish.

Add a method to this EJB. The code should look like this:

package sessions;

import javax.ejb.LocalBean;
import javax.ejb.Stateless;

/**
 * Session Bean implementation class HelloWorldBean
 */
@Stateless
@LocalBean
public class HelloWorldBean {

    /**
     * Default constructor. 
     */
    public HelloWorldBean() {
        // TODO Auto-generated constructor stub
    }
    
    public String helloWorld() {
    	return "hello world!";
    }
}

Notice the @Stateless and @LocalBean that indicates that we have a stateless session bean that can be only called from the same JVM. Remote session beans are not allowed in a web profile project.

Call the session bean from the servlet

In order to call the bean from the servlet, we need to add a few lines of code. 

Inject the EJB reference into the servlet: add these line below the class declaration:

	@EJB
	HelloWorldBean bean;

 Fix the imports then add these lines in the doGet() method:

  out.println("The call to the HelloWorld EJB returned: " + bean.helloWorld());

Then run the project. If everything was ok, you should see a message : "The call to the HelloWorld EJB returned: hello world!".

The @EJB annotation has injected a reference to an instance of the HelloWorld bean. You do not now if a "new" has been performed or if an existing instance has been used or if there are more than one instance running in the web server.

Check that Derby/JavaDB is running, connect the sample database to Eclipse and to Weblogic

Normally you should have installed a Derby/JavaDB database to your system using informations from:  Weblogic / Java EE6 FAQ and Guides. Check that you added the database both in Eclipse and in Weblogic.

If you followed the instructions in Eclipse, in the java EE perspective, under the "Data Source Explorer" tab you should see the "sample" javaDB database, and be able to consult the data in the different tables:

And the data:

Add JPA facet to the project

Eclipse may help you a lot working with JPA but you need to add a JPA facet to the project. Right click on the project then properties/project facets and check the JPA facet. Validate.
 

Look at your project, a persistence.xml file has been added under META-INF but there is also a new node in your project called "JPAcContent" that makes persistence.xml easier to access.

This file is used for configuring the different persistence units that you will use in your project. A persistence unit is an object you will use from your code that works with a given database, using an Object Relational Mapping tool like Hibernate, Eclipse Link, Toplink, etc. This file also is useful for specifying if you are allowed to create tables, alter or delete tables, etc. 

Current persistence.xml file:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Exo1WebProfile" transaction-type="RESOURCE_LOCAL">
		<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
		<properties>
			<property name="eclipselink.target-server" value="WebLogic"          />
		</properties>
	</persistence-unit>
</persistence>

 As you may see it says that we are going to work woth eclipseLink (provider node...), that we are going to work with a local database (transaction-type), etc... these values are not sufficient for what we want to do.

Configure the persistence.xml file using the design tool

Double click on the persistence.xml file, it shoud bring a designer. We are going to configure the database connection, so click on the connection tab at the bottom of the designer. We are using a remote database through a connection pool open on the we logic server. We will just need the JNDI name of the database. 

Change the Transaction type from "RESOURCE LOCAL" to "JTA" in the wizard, and enter the JNDI name of the sample database as it has been configured in WebLogic. If you followed the instructions from:  Weblogic / Java EE6 FAQ and Guides it should be "sample".  Ok, you are done with persistence.xml for the moment...

Add a JPA entity class mapped to the Manufacturer table of the sample database

Let's add an entity class generated from the Manufacturer table of the sample database... add a "jpa entity from table" to the project. If asked to what project you want to add the entity, select the current project. Click next.

Then you are asked to choose the connection and table. Select the connection you added to Eclipse + select APP as a schema. The table will appear, then check MANUFACTURER

Click twice next. Enter "entities" as the package name.

On the last screen you may change the name of the class but it is better to leave the proposed name ("Manufacturer") unchanged.

Click finished. Look at your project, under the "entities" package you should have a Manufacturer.java file that looks like this:

@Entity
public class Manufacturer implements Serializable {
	private static final long serialVersionUID = 1L;

	@Id
	@Column(name="MANUFACTURER_ID")
	private int manufacturerId;

	private String addressline1;

	private String addressline2;

	private String city;

	private String email;

	private String fax;

	private String name;

	private String phone;

	private String rep;

	private String state;

	private String zip;

    public Manufacturer() {
    }
    ... // Getters and Setters...
}

The @Entity annotation says "I'm mapped to a table whose name of my name capitalized" (in that case, the MANUFACTURER table).

The other annotation @Id says that the field is a primary key, and the @Column indicated the name of the column because default rules could not be applied here (defaut = name of the field in upper cases).

Write a stateless session bean facade for this entity class

Usually, one best practice consists in associating a "facade" with each entity class. A facade is a staless or stafull session bean that will provide CRUD operations on the associated model/entity, as well as convenience functions. Some IDEs like Netbeans or IDEA propose wizards that automate this process. Oracle Enterprise Pack for Eclipse proposes also such a wizard but only for oracle ADF projects ("Application Development Framework"). These are projects that use JSF and some special faces libraries from Oracle. They will not be studied during this training.

So let's add a stateless session facade for Manufacturers to this project. Add a new stateless session bean, put it in the "sessions" package, name it ManufacturerFacade.

Add in that bean an EntityManager so that we will be able to "talk" to the database and do other interesting things. Just add these two lines as class attributes:

    @PersistenceContext
    EntityManager em;

Add also a method that gets all the existing manufacturers from the table (the JPQL request is equivalent to a SQL select *...). Your session facade should look like that:

package sessions;

import java.util.List;

import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import entities.Manufacturer;

@Stateless
@LocalBean
public class ManufacturerFacade {
    @PersistenceContext
    EntityManager em;	 
    
    public List<Manufacturer> getManufacturers() {
        return (List<Manufacturer>)em.createQuery("select m from Manufacturer m").getResultList();
     }
}

Notice that executing this request does not return tuples but a Collection of Objects (in our case a List of instances of Manufacturer).

Let's the servlet use the session bean facade

In order to use our new EJB from the Servlet, simply inect it using the @EJB annotation, exactly like we did with the HelloWorldBean. Let's ass this on the Servlet, as well as a call to the getManufacturers() method. We will just display the resulting list by generating some HTML in the response:

Here is the new code of the Servlet:

package servlet;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Collection;

import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import entities.Manufacturer;
import sessions.HelloWorldBean;
import sessions.ManufacturerFacade;


@WebServlet("/TestServlet")
public class TestServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
	
	@EJB
	HelloWorldBean bean;
	@EJB
	ManufacturerFacade mf;   

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	      // Set the response message's MIME type.
	      response.setContentType("text/html;charset=UTF-8");
	      // Allocate a output writer to write the response message into the network socket.
	      PrintWriter out = response.getWriter();
	      
	      out.println("<h1>Welcome to Exo1 test servlet!</h1>");
	      
	      out.println("The call to the HelloWorld EJB returned: " + bean.helloWorld());
	      
	      out.println("<h1>List of manufacturers in the sample database</h1>");

              // Use session facade to get all manufacturers	      
	      Collection<Manufacturer> manufacturers = mf.getManufacturers();

              // Iterate the Collection and diplay manufacturers ids + names in a table		
	      out.println("<TABLE border='2' frame='box'>");
	      for (Manufacturer m : manufacturers) {
	         out.println("<TR>");
			
                 out.println("<TD>" + m.getManufacturerId() + "</TD><TD>" + m.getName() +"</TD>");
            
                  out.println("</TR>");
              }
              out.println("</TABLE>");

	}
}

 Run the project, it should display the list of all the manufacturers from the MANUFACTURER table of the sample database.

Modify the servlet so that the request if forwarded to a JSP for displaying the data

Modify the servlet so that the HTTP request is passed to a JSP for finishing the treatment (generating the view). The trick consists in a adding to the request the data to be displayed before forwarding the request to the JSP:

New version of the servlet :

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		
		  // delegate business to the session bean facade
		  Collection<Manufacturer> manufacturers = mf.getManufacturers();

		  // Put data to display on the request
		  request.setAttribute("manufacturers", manufacturers);
		  
		  // Forward the request to the view. Servlet and JSP are parts of same request
		  RequestDispatcher dispatcher = request.getRequestDispatcher("DisplayManufacturers.jsp");
		  dispatcher.forward( request, response );
}

Add a JSP page for viewing the data, using JSTL and EL

Add a JSP file in your project, name it "DisplayManufacturers.jsp" and replace the generated content by this one:

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
No<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix ="c" %>
<!DOCTYPE HTML>

<html>
<head>
<title>List of Manufacturers</title>
</head>
<body>


<table border="2" frame="box">
	<tr>
		<th>Id</th>
		<th>Name</th>
		<th>Phone</th>
		<th>Email</th>
	</tr>
	
	<c:forEach var="m" items="${manufacturers}">
		<tr>
			<td>${m.manufacturerId}</td>
			<td>${m.name}</td>
			<td>${m.phone}</td>
			<td>${m.email}</td>
		</tr>
	</c:forEach>
</table>

</body>
</html>

Notice the line:

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix ="c" %>

That indicates that we are going to use the JSP Standard Tag Library (JSTL), all elements with the namespace c: will use the core part of the JSTL (if, then, else, forEach, etc). In order to display the manufacturers' properties we use the EL expression langage. For example, ${m.name} will call the getName() accessor of the bean Manufacturer.java, if there is no such method, we would get "EL property not found" errors.

The line: 

<c:forEach var="m" items="${manufacturers}">

Defines a loop on a collection named "manufacturers". This collection will be searched in different scopes: the page, the request, the session, the context, etc. As in the servlet we put an attribute named "manufacturers" in the request, it is the one that will be found. 

More informations about JSTL and EL are available here:

• JSTL: http://en.wikipedia.org/wiki/JavaSer...rd_Tag_Library
• EL: http://en.wikipedia.org/wiki/Unified...ssion_Language