Summary

In this exercise you registered the application server with the IDE.

Summary

In this exercise you created a Java EE 5 web application which will contain the entity classes and servlet.

Managing Persistence

To manage persistence in the application you only need to create a persistence unit, specify which data source and entity manager to use, and then let the container do the work of managing entities and persistence. The container discovers the entity beans at runtime.

You create a persistence unit by defining it in persistence.xml. The project does not contain a persistence.xml yet so you need to create it. The persistence.xml file is created automatically when you add a persistence unit to the project with the New Persistence Unit wizard. The wizard will help you define the properties of the persistence unit.

You can also create a persistence unit in the New Entity Class wizard. When creating an entity class, the wizard will prompt you to create a persistence unit if one does not exist.

1. Choose New File (Ctrl-N) to open the New File wizard.
2. From the Persistence category, select Persistence Unit and click Next.
3. Leave the default name for the persistence unit suggested by the wizard.
4. Use the TopLink (default) listed in the Persistence Provider drop-down list.

   The default provider is the TopLink Essential.jar. TopLink Essential.jar contains the libraries for Java Persistence. Our entity manager is located in TopLink Essential.jar.

5. Use the default jdbc/sample data source listed in the Data Source drop-down list.

   The default data source jdbc/sample is used to connect to the Java DB database that is bundled with GlassFish application server.

6. Click Finish.

When you click Finish, persistence.xml is created for your project and opens in the editor. You can click XML in the toolbar of the editor to see the XML view of persistence.xml. This file contains all the information the Java EE 5 container needs to manage the entities and persistence of our application.

Creating the Entity Classes

When developing for the J2EE 1.4 platform, when you created entity beans you placed them in an EJB module even when the application was a simple web application. Each entity bean required several interfaces, and you had to configure the deployment descriptors in ejb-jar.xml to define the entity beans, the interfaces, persistence and finder queries for each entity bean.

In Java EE 5, instead of creating entity beans and putting them in the EJB module, you can use simple entity classes, and the entity classes can be placed anywhere in a Java EE 5 application. Writing classes for Java EE 5 applications is also easier than it was for the J2EE 1.4 platform because you can use annotations to define components and inject resources.

You will now use the Entity Classes from Database wizard to create the entity classes based on the relational database.

1. Start the Java DB database server.
2. Choose New File (Ctrl-N) to open the New File wizard. Select Entity Classes from Database from the Persistence category and click Next.
3. In the Entity Classes from Database wizard, select the jdbc/sample data source for our database from the Data Source drop-down list and supply the password if necessary. (The password should be "app".) When you select the data source, a list of available tables appears in the Available Tables pane.
4. Select the CUSTOMER table from the Available Tables and click Add.

   When you click Add, any tables related to the selected table are also added. In this example, the DISCOUNT_CODE table is also added. DISCOUNT_CODE table is greyed-out because it is referenced by CUSTOMER table and an entity class for it must be generated in order to generate the Customer entity class. When you hover your mouse over a greyed-out table in the Selected Tables pane, a tooltip appears that displays the name of the table that references the greyed-out table.

5. Click Next.

   The wizard displays the selected table and any related tables. The wizard also displays the entity classes that will be created based on the selected tables. If you want to modify the name of the class that will be generated, you can type the name in the Class Name field.

6. Type ejb as the package for the generated classes. Click Finish.

When you click Finish, the IDE generates entity classes for the CUSTOMER table and the tables related to CUSTOMER table. If you expand the ejb source package in the Projects window you can see that the IDE created the Java classes Customer.java and DiscountCode.java. You can see that the IDE created only two classes, one for each of the database tables.

If you look at Customer.java in the Source Editor, you will notice that the @Entity annotation is used to declare the class an entity class. Other annotations provide additional information such as the database table and the columns that the entity class and its properties are mapped to.

You will also notice that much of the boilerplate code commonly found in entity beans is gone. Methods such as ejbRemove, setMessage, setSessionContext, ejbActivate, and ejbPassivate are no longer needed in your entity class in Java EE 5.

Coding the Servlet

You now need to add a servlet to the web application. Instead of adding resource creation and lookup code to the servlet, with Java EE 5 you can use resource injection to move that work to the container. You can use annotations to inject resources directly into the servlet, and the container will manage the creation and lookup of the requested resource. In this case, you want to use an entity manager as specified in the persistence unit.

1. Right-click the project node in the Projects window and choose New > Servlet.
2. In the New Servlet wizard, name the servlet CustomerDetails and put the servlet into a package named web. Click Finish. When you click Finish, CustomerDetails.java opens in the Source Editor.
3. In the source editor, right-click in CustomerDetails.java and choose Persistence > Use Entity Manager to inject the PersistenceContext in the class. The IDE adds the following annotation that specifies the persistence unit used by the servlet. The annotation is added above the class declaration.

     @PersistenceContext(name = "persistence/LogicalName", unitName = "CustomerBookPU")
                       

   The IDE also adds the following annotation injecting a resource for managing transaction boundaries:

     @Resource
     private javax.transaction.UserTransaction utx;

   If you expand the editor fold you can see that the IDE adds the following default persist method code to the servlet:

     public void persist(Object object) {
         try {
             Context ctx = (Context) new javax.naming.InitialContext().lookup("java:comp/env");
             utx.begin();
             EntityManager em =  (EntityManager) ctx.lookup("persistence/LogicalName");
             em.persist(object);
             utx.commit();
         } catch(Exception e) {
             Logger.getLogger(getClass().getName()).log(Level.SEVERE,"exception caught", e);
             throw new RuntimeException(e);
         }
     }

   This code looks up the persistence unit defined by @PersistenceContext and an instance of the entity manager.

4. In CustomerDetails.java, modify the generated persist method shown above to refer to our entity object. When you are finished, the modified code should look like the following (the code shown in bold indicates the changed lines):

     public Customer findByID(Integer customerNr) {
           Customer customer = null;
           try {
               Context ctx = (Context) new javax.naming.InitialContext().lookup("java:comp/env");
               utx.begin();
               EntityManager em =  (EntityManager) ctx.lookup("persistence/LogicalName");
               customer = em.find(Customer.class, customerNr);
               utx.commit();
           } catch(Exception e) {
               Logger.getLogger(getClass().getName()).log(Level.SEVERE,"exception caught", e);
               throw new RuntimeException(e);
           }
           return customer;
       }
                   

5. Uncomment the code in the processRequest method and add the following code in bold:

       protected void processRequest(HttpServletRequest request, HttpServletResponse response)
           throws ServletException, IOException {
           response.setContentType("text/html;charset=UTF-8");
           PrintWriter out = response.getWriter();
           out.println("<html>");
           out.println("<head>");
           out.println("<title>Servlet CustomerDetails</title>");
           out.println("</head>");
           out.println("<body>");
           out.println("<h1>Search Customer Information</h1>");
           String customerNr = request.getParameter("customer_nr");
           if((customerNr != null) && !(customerNr.equals(""))) {
   
               Customer customer = findByID(new Integer(customerNr));
               if(customer != null){
                   out.println("Customer's info for nr. " + customerNr + ": " + customer.getName());
               }else{
                   out.println("Customer not found.");
               }
           }
           out.println("<form>");
           out.println("Customer number: <input type='text' name='customer_nr' />");
           out.println("<input type=submit value=Select />");
           out.println("</form>");
           out.println("</body>");
           out.println("</html>");
           out.close();
       }
                       

6. Press Ctrl-Shift-I to generate any missing import statements. (The servlet requires an import statement for the Customer entity class.)

Summary

In this exercise, you built the CustomerBook application using Java EE 5 technology. You then deployed the project and tested the web application.