Miles to go …

TOTD #97 showed how to install GlassFish Tools Bundle for Eclipse 1.1. Basically there are two options – either install Eclipse 3.4.2 with WTP and pre-bundled/configured with GlassFish v2/v3, MySQL JDBC driver and other features. Or if you are using Eclipse 3.5, then you can install the plug-in separately and get most of the functionality.

TOTD #98 showed how to create a simple Metro/JAX-WS compliant Web service using that bundle and deploy on GlassFish.

This Tip Of The Day (TOTD) shows how to create a simple Java EE 6 application that reads data from a MySQL database using JPA 2.0 and Servlet 3.0 and display the results. A more formal support of Java EE 6/Servlet 3.0 is coming but in the meanwhile the approach mentioned below will work.

Lets get started!

1. Configure database connection – The key point to notice here is that the MySQL Connector/J driver is already built into the tool so there is no need to configure it explicitly.
   1. From "Window", "Show Perspective", change to the database perspective as shown below:

      

   2. In the "Data Source Explorer", right-click and click on "Database Connections" and select "New …":

      

   3. Search for "mysql" and type the database name as "sakila":

      

      This blog uses MySQL sample database sakila. So please download and install the sample database before proceeding further.

   4. Click on "Next >" and specify the database configuration:

      

      Notice the "Drivers" indicate that the JDBC driver is pre-bundled so there is no extra configuration required. If you are using a stand-alone Eclipse bunde and installing the plugin separately, then you need to configure the MySQL JDBC driver explictily.

      The URL indicates the application is connecting to the sakila database. Click on "Test Connection" to test connection with the database and see the output as:

      

      and click on "Finish" to complete. The expanded database in the explorer looks like:

      

      The expanded view shows all the tables in the database.

2. Create the Web project & configure JPA
   1. Switch to JavaEE perspective by clicking "Window", "Choose Perspective", "Other …" and choosing "Java EE".
   2. Create a new dynamic web project with the following settings:

      

      Only the project name needs to be specified and everything else is default. Notice the target runtime indicates that this is a Java EE 6 application. Click on "Finish".

   3. Right-click on the project, search for "facets" and enable "Java Persistence" as shown below:

      

   4. Click on "Further configuration available …" and modify the facet as shown below:

      

      Make sure to disable "orm.xml" since we are generating a standard Java EE 6 web application. Choose "sakila" as the database. Click on "OK" and again on "OK" to complete the dialog.

3. Generate the JPA entities
   1. Right-click on the project, select "JPA Tools", "Generate Entities" as shown:

      

   2. Choose the schema "sakila":

      

      and click on "Next >". If no values are shown in the schema drop-down, then click on "Reconnect …".

   3. Specify a package name for the generated entities as "model" and select "film" and "language" table:

      

      and click on "Finish". The "film" and "language" table are related so it would be nice if all the related tables can be identified and picked accordingly.

      Anyway this generates "model.Film" and "model.Language" classes and "persistence.xml" as shown below:

      

      Also notice that "web.xml" and "sun-web.xml" have been explicitly removed since they are not required by a Java EE 6 application.

   4. "model.Film" class needs to modified slightly because one of the columns is mapped to "Object" which is not a Serializable obect. So change the type of "specialFeatures" from Object to String and also change the corresponding getters/setters accordingly. The error message clearly conveyed during the initial deployment and so could be fixed. But it would be nice to generate the classes that will work out-of-the-box.
4. Create a Servlet client to retrieve/display data from the database
   1. Right-click on the project, select "New", "Class" and specify the values as:

      

      and click on "Finish". This class will be our Servlet client.

   2. Change the class such that it looks like:
      

      @WebServlet(urlPatterns="/ServletClient")
      public class ServletClient extends HttpServlet {
      @PersistenceUnit
      EntityManagerFactory factory;
      protected void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
      ServletOutputStream out = resp.getOutputStream();
      List list = factory.createEntityManager().createQuery("select f from Film f where f.title like 'GL%';").getResultList();
      out.println("<html><table>");
      for (Object film : list) {
      out.print("<tr><td>" + ((Film)film).getTitle() + "</tr></td>");
      }
      out.println("</table></html>");
      }
      }
      

      and the imports as:
      

      import java.io.IOException;
      import java.util.List;
      import javax.persistence.EntityManagerFactory;
      import javax.persistence.PersistenceUnit;
      import javax.servlet.ServletException;
      import javax.servlet.ServletOutputStream;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import model.Film;
      

      Basically, this is a Servlet 3.0 specification compliant Servlet that uses @WebServlet annotation. It uses @PersistenceUnit to inject the generated JPA Persistence Unit which is then used to query the database. The database query return all the movies whose title start with "GL" and the response is displayed in an HTML formatted table.

   3. Right-click on the project and select "Run As", "Run on Server" and select GlassFish v3 latest promoted build (this blog used build 61) as:

      

      and click on "Finish". The output at "http://localhost:8080/HelloJPA/ServletClient" looks like:

      

Simple, easy and clean!

How are you using Eclipse and GlassFish – the consolidated bundle or standalone Eclipse + GlassFish plugin ?

Download GlassFish Tools Bundle for Eclipse now.

Please send your questions and comments to .

Please leave suggestions on other TOTD that you’d like to see. A complete archive of all the tips is available here.

Technorati: glassfish eclipse mysql jpa database

svn.dev.java.net is down … what’s new!

Here is how it looks like …

Do "+1" every time and any time in the comments you see java.net is not behaving for you and let’s see how quickly the comments fill up!

UPDATE: Expanding this post to include failures in any java.net domain.

Technorati: java.net

Java EE 6 is developed as JSR 316 under the Java Community Process. It breaks the "one size fits all" approach with Profiles and improves on the Java EE 5 developer productivity features. Several existing specifications are getting an extreme makeover such as Java Server Faces 2.0 and Servlet 3.0. GlassFish v3 is the Reference Implementation of Java EE 6.

So you’d like to get an overview of Java EE 6 and start developing with GlassFish v3. Please register for a free webinar with coordinates:

Date: Aug 26, 2009
Time: 10am PT

Register here.

Yep, it’s starting in a few hours so make sure to sign up and be ready with your questions. Several specification leads will be available to field your questions.

Technorati: glassfish javaee webinar

A new version of GlassFish Tools Bundle for Eclipse (ver 1.1) was recently released. The build contains

• Eclipse 3.4.2 IDE with WTP Java EE support
• GlassFish v2.1 pre-registered and configured
• GlassFish v3 Prelude pre-registered and configured
• JavaDB sample database pre-registered and configured
• GlassFish Plugin (1.0.29)
• MySQL JDBC driver registered to the IDE
• Maven m2 plugins
• JAX-WS Metro plugin
• GlassFish documentation
• And optionally, a JDK 1.6.

The functionality is also available in GlassFish Plugin that can be installed on Eclipse 3.5. However because of the Eclipse bug #280365, the plugin cannot be installed directly using Server Adapters. The alternative is to install explicitly using the Update Site. The instructions to do the same are given below:

1. In “Help”, “Install New Software”, click on “Available Software Sites”:

   

2. Search for “ajax” to see the output as:

   

3. Click on “Enabled” button to enable the site and see the change as below:

   

   click on “OK”.

4. Expand the drop-down list box and chose the recently added “update site” as shown below:

   

   and it shows all the software available from that site as:

   

5. Take the defaults, click on “Next” and it shows the GlassFish plugin version number as shown below:

   

6. Click on “Next”, accept the license by clicking on  “I accept …” and click on “Finish” to start the installation.

   

   The IDE restarts after the installation is complete.

7. Now a new server can be added using “Servers” tab and it shows GlassFish as an option as shown below:

   

The screencast #28 shows how to create a simple web application using GlassFish v3. Future blogs will show how to leverage the new functionality of JAX-WS Web services plugin and JPA Dali Tooling with GlassFish.

Please leave suggestions on other TOTD that you’d like to see. A complete archive of all the tips is available here.

Technorati: totd glassfish eclipse galileo

GlassFish Monitoring allows you to monitor the state of various runtime components of the application server. This information is used to identify performance bottlenecks and tuning the system for optimal performance, to aid capacity planning, to predict failures, to do root cause analysis in case of failures and sometimes to just ensure that everything is functioning as expected.

GlassFish Management allows you to manage the running Application Server instance such as query/create/delete resources (JDBC, JMS, etc), stop/restart the instance, rotate the log and other similar functions.

GlassFish v3 exposes Monitoring and Management data using a REST Interface. This Tip Of The Day (TOTD) shows how to play with this new functionality. Rajeshwar’s blog has lot of useful information on this topic.

Most of the functionality available in web-based Admin Console and CLI (asadmin) is now available using the REST interface. Both of these are pre-built tools that ships with the GlassFish bundle. The REST interface is a lower level API that enables toolkit developers and IT administrators to write their custom scripts/clients using language of their choice such as Java, JavaScript, Ruby or Groovy.

The default URL for the REST interface of monitoring is “http://localhost:4848/monitoring/domain” and for the management is “http://localhost:4848/management/domain”. Each URL provides an XML, JSON and HTML representation of the resources. If a web browser is used then a HTML representation is returned and displayed nicely in the browser. Rajeshwar’s blog described a Java client written using Jersey Client APIs that can be used to make all the GET/PUT/POST/DELETE requests. This blog will use something more basic, and extremely popular, to make all the RESTful invocations – cURL.

At this time the monitoring resources are read-only (GET) and management can be done using GET/POST/DELETE methods. POST is used for creating and updating resources/objects and the updates can be partial.
 
Lets get started.

1. Download the latest continuous build from the trunk and unzip. This functionality is also available in the Web profile bundle. This blog is using build #2023.
2. Start the application server as:
   

   ~/tools/glassfish/v3/2023/glassfishv3 >./bin/asadmin start-domain –verbose Aug 19, 2009 9:52:45 AM com.sun.enterprise.admin.launcher.GFLauncherLogger info INFO: JVM invocation command line: /System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home/bin/java -cp . . . INFO: felix.fileinstall.dir            /Users/arungupta/tools/glassfish/v3/2023/glassfishv3/glassfish/domains/domain1/autodeploy-bundles Aug 19, 2009 9:53:05 AM  INFO: felix.fileinstall.debug          1 Aug 19, 2009 9:53:05 AM  INFO: felix.fileinstall.bundles.new.start          true

3. Monitoring information – Lets monitor this GlassFish instance using the REST interface.
   1. Retrieve JSON information – As mentioned above, the monitoring resources are read-only and so the information can be accessed as:

      ~/tools/glassfish/v3/2023/glassfishv3 >curl -H “Accept: application/json” http://localhost:4848/monitoring/domain -v * About to connect() to localhost port 4848 (#0) *   Trying ::1… connected * Connected to localhost (::1) port 4848 (#0) > GET /monitoring/domain HTTP/1.1 > User-Agent: curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3 > Host: localhost:4848 > Accept: application/json > < HTTP/1.1 200 OK < Content-Type: application/json < Transfer-Encoding: chunked < Date: Wed, 19 Aug 2009 17:40:29 GMT < {Domain:{},”child-resources”:["http://localhost:4848/monitoring/domain/server"]} * Connection #0 to host localhost left intact * Closing connection #0

      The command explicitly asks for JSON representation of the resources. The outbound headers are prepended with “>” and inbound headers with “<”. And the JSON representation is shown in the last line as:

      {Domain:{},”child-resources”:["http://localhost:4848/monitoring/domain/server"]}

      The key element to remember here is “http://localhost:4848/monitoring/domain/server” which can be used to retrieve more monitoring information.

   2. XML represetation: Lets change the command to ask for XML representation as:
      

      ~/tools/glassfish/v3/2023/glassfishv3 >curl -H “Accept: application/xml” http://localhost:4848/monitoring/domain -v * About to connect() to localhost port 4848 (#0) *   Trying ::1… connected * Connected to localhost (::1) port 4848 (#0) > GET /monitoring/domain HTTP/1.1 > User-Agent: curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3 > Host: localhost:4848 > Accept: application/xml > < HTTP/1.1 200 OK < Content-Type: application/xml < Transfer-Encoding: chunked < Date: Wed, 19 Aug 2009 17:43:51 GMT < <Domain>     <child-resource>http://localhost:4848/monitoring/domain/server</child-resource> </Domain> * Connection #0 to host localhost left intact * Closing connection #0

      The command changes the “Accept” header to “application/xml” and now the XML representation of the monitoring resources is returned as:

      <Domain>     <child-resource>http://localhost:4848/monitoring/domain/server</child-resource> </Domain>

   3. HTML representation: The command can be altered to get the HTML representation as “curl -H “Accept: text/html” http://localhost
      :4848/monitoring/domain -v“. But HTML is more pleasant when rendered by a browser and so viewing the page “http://localhost:4848/monitoring/domain” in the browser is shown as:

      

   4. Get more information: As mentioned above, more information about this GlassFish instance can be accessed by GETing from “http://localhost:4848/monitoring/domain/server” and here is the result:
      

      </tools/glassfish/v3/2023/glassfishv3 >curl -H “Accept: application/json” http://localhost:4848/monitoring/domain/server -v * About to connect() to localhost port 4848 (#0) *   Trying ::1… connected * Connected to localhost (::1) port 4848 (#0) > GET /monitoring/domain/server HTTP/1.1 > User-Agent: curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3 > Host: localhost:4848 > Accept: application/json > < HTTP/1.1 200 OK < Content-Type: application/json < Transfer-Encoding: chunked < Date: Wed, 19 Aug 2009 17:56:41 GMT < {Server:{},”child-resources”:["http://localhost:4848/monitoring/domain/server/webintegration", "http://localhost:4848/monitoring/domain/server/transaction-service", "http://localhost:4848/monitoring/domain/server/network", "http://localhost:4848/monitoring/domain/server/jvm", "http://localhost:4848/monitoring/domain/server/web", "http://localhost:4848/monitoring/domain/server/realm", "http://localhost:4848/monitoring/domain/server/http-service"]} * Connection #0 to host localhost left intact * Closing connection #0

      An HTML rendering of this representation looks like:

      

      You can keep clicking on the links and more detailed information about that resource is displayed. This is just one HTML representation and is purposely kept light-weight. You can certainly grab the XML representation and apply an XSLT to generate your own HTML rendering.

      The monitoring levels for different modules can be easily changed using the management REST interface as explained below.

4. Management of the GlassFish instance
   1. Lets see all the options supported by management REST interface as:

      ~/tools/glassfish/v3/2023/glassfishv3 >curl -X OPTIONS http://localhost:4848/management/domain -v * About to connect() to localhost port 4848 (#0) *   Trying ::1… connected * Connected to localhost (::1) port 4848 (#0) > OPTIONS /management/domain HTTP/1.1 > User-Agent: curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3 > Host: localhost:4848 > Accept: */* > < HTTP/1.1 200 OK < Content-Type: application/json < Transfer-Encoding: chunked < Date: Wed, 19 Aug 2009 18:07:14 GMT < {   “Method”:”GET”   “Method”:”PUT” } * Connection #0 to host localhost left intact * Closing connection #0

      Specifying “-X OPTIONS” switch displays the various HTTP methods supported by the REST interface. Even though the results show GET and PUT, but it really means GET and POST (issue #9177). Lets try “GET” first. 

   2. GET JSON information as:
      

      ~/tools/glassfish/v3/2023/glassfishv3 >curl -H “Accept: application/json” http://localhost:4848/management/domain -v * About to connect() to localhost port 4848 (#0) *   Trying ::1… connected * Connected to localhost (::1) port 4848 (#0) > GET /management/domain HTTP/1.1 > User-Agent: curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3 > Host: localhost:4848 > Accept: application/json > < HTTP/1.1 200 OK < Content-Type: application/json < Transfer-Encoding: chunked < Date: Wed, 19 Aug 2009 18:14:46 GMT < {Domain:{“log-root” : “${com.sun.aas.instanceRoot}/logs”,”application-root” : “${com.sun.aas.instanceRoot}/applications”,”locale” : “”,”version” : “re-continuous”},”child-resources”:["http://localhost:4848/management/domain/configs", "http://localhost:4848/management/domain/resources","http://localhost:4848/management/domain/servers", "http://localhost:4848/management/domain/property","http://localhost:4848/management/domain/applications", "http://localhost:4848/management/domain/system-applications","http://localhost:4848/management/domain/stop", "http://localhost:4848/management/domain/restart","http://localhost:4848/management/domain/uptime", "http://localhost:4848/management/domain/version","http://localhost:4848/management/domain/rotate-log", "http://localhost:4848/management/domain/host-port"]} * Connection #0 to host localhost left intact * Closing connection #0

      As the result shows, there are several RESTful URLs available (in “child-resources” element) to manage this GlassFish instance. For example:

      1. Show the host/port of GlassFish instance as:

         curl -H “Accept: application/json” http://localhost:4848/management/domain/host-port -v

         will show the result as:

         {“GetHostAndPort”:{“value” : “dhcp-usca14-132-79.SFBay.Sun.COM:8080″}}

      2. Show that web-based Admin Console is pre-installed as system application using:
         

         curl -H “Accept: application/json” http://localhost:4848/management/domain/system-applications/application/__admingui -v

         will show the result as:

         {__admingui:{“libraries” : “”,”availability-enabled” : “false”,”enabled” : “true”,”context-root” : “”,”location” : “${com.sun.aas.installRootURI}/lib/install/applications/__admingui”,”description” : “”,”name” : “__admingui”,”directory-deployed” : “true”,”object-type” : “system-admin”},”child-resources”:["http://localhost:4848/management/domain/system-applications/application/__admingui/module"]}</<br /> td>

      3. Query the monitoring levels of different modules as:
         

         curl -H “Accept: application/json” http://localhost:4848/management/domain/configs/config/server-config/monitoring-service/module-monitoring-levels -v

         to see the result as:

         {ModuleMonitoringLevels:{“transaction-service” : “OFF”,”ejb-container” : “OFF”,”jdbc-connection-pool” : “OFF”,”orb” : “OFF”,”http-service” : “OFF”,”connector-connection-pool” : “OFF”,”jms-service” : “OFF”,”connector-service” : “OFF”,”jvm” : “OFF”,”thread-pool” : “OFF”,”web-container” : “OFF”},”child-resources”:[]}

         And then change the monitoring level of Web container as:

         ~/tools/glassfish/v3/2023/glassfishv3 >curl -X POST -d “web-container=ON” -H “Accept: application/json” http://localhost:4848/management/domain/configs/config/server-config/monitoring-service/module-monitoring-levels -v * About to connect() to localhost port 4848 (#0) *   Trying ::1… connected * Connected to localhost (::1) port 4848 (#0) > POST /management/domain/configs/config/server-config/monitoring-service/module-monitoring-levels HTTP/1.1 > User-Agent: curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3 > Host: localhost:4848 > Accept: application/json > Content-Length: 16 > Content-Type: application/x-www-form-urlencoded > < HTTP/1.1 200 OK < Content-Type: application/json < Transfer-Encoding: chunked < Date: Wed, 19 Aug 2009 22:01:31 GMT < * Connection #0 to host localhost left intact * Closing connection #0 “http://localhost:4848/management/domain/configs/config/server-config/monitoring-service/module-monitoring-levels” updated successfully

         The last line shows that the monitoring level is successfull updated and can be verified again as:

         ~/tools/glassfish/v3/2023/glassfishv3 >curl -H “Accept: application/json” http://localhost:4848/management/domain/configs/config/server-config/monitoring-service/module-monitoring-levels -v * About to connect() to localhost port 4848 (#0) *   Trying ::1… connected * Connected to localhost (::1) port 4848 (#0) > GET /management/domain/configs/config/server-config/monitoring-service/module-monitoring-levels HTTP/1.1 > User-Agent: curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3 > Host: localhost:4848 > Accept: application/json > < HTTP/1.1 200 OK < Content-Type: application/json < Transfer-Encoding: chunked < Date: Wed, 19 Aug 2009 22:36:47 GMT < * Connection #0 to host localhost left intact * Closing connection #0 {ModuleMonitoringLevels:{“transaction-service” : “OFF”,”ejb-container” : “OFF”,”jdbc-connection-pool” : “OFF”,”orb” : “OFF”,”http-service” : “OFF”,”connector-connection-pool” : “OFF”,”jms-service” : “OFF”,”connector-service” : “OFF”,”jvm” : “OFF”,”thread-pool” : “OFF”,”web-container” : “ON”},”child-resources”:[]}

      4. Stop this GlassFish instance using:
         

         curl -H “Accept: application/json” http://localhost:4848/management/domain/stop -v

         Or restart the instance using:

         curl -H “Accept: application/json” http://localhost:4848/management/domain/restart -v

      5. Create a JDBC resource using an existing connection pool
         1. Lets see all the resources that are available:

            curl -H “Accept: application/json” http://localhost:4848/management/domain/resources -v

            and the results are shown as:

            {Resources:{},”child-resources”:["http://localhost:4848/management/domain/resources/jdbc-connection-pool", "http://localhost:4848/management/domain/resources/jdbc-resource"]}

         2. View all the JDBC connection pools as:
            

            curl -H “Accept: application/json” http://localhost:4848/management/domain/resources/jdbc/connection-pool -v

            and the results are shown as:

            {JdbcConnectionPool:{},”child-resources”:["http://localhost:4848/management/domain/resources/jdbc-connection-pool/__TimerPool", "http://localhost:4848/management/domain/resources/jdbc-connection-pool/DerbyPool"]}

         3. See all the JDBC resources available as:
            

            curl “Accept: application/json” http://localhost:4848/management/domain/resources/jdbc-resource -v

            and the results are shown as:

            {JdbcResource:{},”child-resources”:["http://localhost:4848/management/domain/resources/jdbc-resource/jdbc/__TimerPool", "http://localhost:4848/management/domain/resources/jdbc-resource/jdbc/__default"]}

         4. See all the OPTIONS accepted for JDBC resource creation as:
            
            

            curl -X OPTIONS -H “Accept: application/json” http://localhost:4848/management/domain/resources/jdbc-resource -v

            with the result as:

            {   “Method”:”POST”,   “Message Parameters”:{     “id”:{“Acceptable Values”:”",”Default Value”:”",”Type”:”class java.lang.String”,”Optional”:”false”},     “enabled”:{“Acceptable Values”:”",”Default Value”:”true”,”Type”:”class java.lang.Boolean”,”Optional”:”true”},     “description”:{“Acceptable Values”:”",”Default Value”:”",”Type”:”class java.lang.String”,”Optional”:”true”},     “target”:{“Acceptable Values”:”",”Default Value”:”",”Type”:”class java.lang.String”,”Optional”:”true”},     “property”:{“Acceptable Values”:”",”Default Value”:”",”Type”:”class java.util.Properties”,”Optional”:”true”},     “connectionpoolid”:{“Acceptable Values”:”",”Default Value”:”",”Type”:”class java.lang.String”,”Optional”:”false”}   }   “Method”:”GET”

         5. Finally, create the JDBC resource as:
            

            ~/tools/glassfish/v3/2023/glassfishv3 >curl -d “id=jdbc/sample&connectionpoolid=DerbyPool” http://localhost:4848/management/domain/resources/jdbc-resource -v * About to connect() to localhost port 4848 (#0) *   Trying ::1… connected * Connected to localhost (::1) port 4848 (#0) > POST /management/domain/resources/jdbc-resource HTTP/1.1 > User-Agent: curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3 > Host: localhost:4848 > Accept: */* > Content-Length: 42 > Content-Type: application/x-www-form-urlencoded > < HTTP/1.1 201 Created < Content-Type: text/html < Transfer-Encoding: chunked < Date: Wed, 19 Aug 2009 20:45:51 GMT < * Connection #0 to host localhost left intact * Closing connection #0 “http://localhost:4848/management/domain/resources/jdbc-resource/jdbc/sample” created successfully.

            Note, this is a POST request. The JDBC resource name and JDBC connection pool id are passed as CLI parameters using “-d” switch. The last line shows that the JDBC resource was created successfully.

         6. And finally query the JDBC Resources again as:
            

            curl -H “Accept: application/json” http://localhost:4848/management/domain/resources/jdbc-resource -v

            to see the updated result as:

            {JdbcResource:{},”child-resources”:["http://localhost:4848/management/domain/resources/jdbc-resource/jdbc/__TimerPool", "http://localhost:4848/management/domain/resources/jdbc-resource/jdbc/__default", "http://localhost:4848/management/domain/resources/jdbc-resource/jdbc/sample"]}

         Similarly JDBC connection pools can be created.

   3. POST can be used to update the top-level attributes such as “log-root” and “application-root”. The name of these attributes are shown in the result of GET.
   4. As earlier, XML representation of management resources can be obtained as:
      

      ~/tools/glassfish/v3/2023/glassfishv3 >curl -H “Accept: application/xml” http://localhost:4848/management/domain -v * About to connect() to localhost port 4848 (#0) *   Trying ::1… connected * Connected to localhost (::1) port 4848 (#0) > GET /management/domain HTTP/1.1 > User-Agent: curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3 > Host: localhost:4848 > Accept: application/xml > < HTTP/1.1 200 OK < Content-Type: application/xml < Transfer-Encoding: chunked < Date: Wed, 19 Aug 2009 18:17:07 GMT < <Domain log-root=”${com.sun.aas.instanceRoot}/logs” application-root=”${com.sun.aas.instanceRoot}/applications” locale=”" version=”re-continuous”>     <child-resource>http://localhost:4848/management/domain/configs</child-resource>     <child-resource>http://localhost:4848/management/domain/resources</child-resource>     <child-resource>http://localhost:4848/management/domain/servers</child-resource>     <child-resource>http://localhost:4848/management/domain/property</child-resource>     <child-resource>http://localhost:4848/management/domain/applications</child-resource>     <child-resource>http://localhost:4848/management/domain/system-applications</child-resource>     <child-resource>http://localhost:4848/management/domain/stop</child-resource>     <child-resource>http://localhost:4848/management/domain/restart</child-resource>     <child-resource>http://localhost:4848/management/domain/uptime</child-resource>     <child-resource>http://localhost:4848/management/domain/version</child-resource>     <child-resource>http://localhost:4848/management/domain/rotate-log</child-resource>     <child-resource>http://localhost:4848/management/domain/host-port</child-resource> * Connection #0 to host localhost left intact * Closing connection #0

      Just changing the “Accept” header to “application/xml” did the trick.

   5. And an HTML representation can be obtained by viewing the URL “http://localhost:4848/management/domain” in the browser with result as:

      

Just like GlassFish v3, the REST interface is extensible as well. So if a new container is plugged in that generates data (possibly through probes) captured in the runtime tree, that is automatically exposed in the RESTful interface.

Now for the Mac users, Safari prefers XML over HTML. Basically a resource, that can be served using both XML and HTML representation (as our Management and Monitoring interface), is served as XML by Safari and HTML by Firefox. So use Firefox on Mac if you want HTML rendering.

How will you use GlassFish RE
ST interface ?

Do your application server provide that level of administration capability ?

Please leave suggestions on other TOTD that you’d like to see. A complete archive of all the tips is available here.

Technorati: totd glassfish v3 rest management monitoring jersey

Java Persistence API defines a standard object/relational mapping using POJOs. In JPA, a persistence unit is described using “persistence.xml”, bundled with the web application, injected into your web application and then POJOs are used to access all the information from the underlying persistence mechanism such as a database.

JPA can injected into your application couple of different ways as shown below:

@PersistenceUnit EntityManagerFactory emf;

and

@PersistenceContext EntityManager manager;

Which one is preferred, why, and pros/cons are very clearly explained in (slightly old but very relevant) this blog. It also discusses a JNDI approach.

In case you are interested in the summary:

• Use “@PersistenceUnit EntityManagerFactory” for Servlets because of thread safety
• Use “@PersistenceContext EntityManager” in EJBs for simpler/cleaner code

Read other JPA related entries.
All previous entries in this series are archived at LOTD.

Technorati: lotd glassfish jpa javaee persistence

TOTD #93 showed how to get started with Java EE 6 using NetBeans 6.8 M1 and GlassFish v3 by building a simple Servlet 3.0 + JPA 2.0 web application. TOTD #94 built upon it by using Java Server Faces 2 instead of Servlet 3.0 for displaying the results. However we are still using a POJO for all the database interactions. This works fine if we are only reading values from the database but that’s not how a typical web application behaves. The web application would typically perform all CRUD operations. More typically they like to perform one or more CRUD operations within the context of a transaction. And how do you do transactions in the context of a web application ? Java EE 6 comes to your rescue.

The EJB 3.1 specification (another new specification in Java EE 6) allow POJO classes to be annotated with @EJB and bundled within WEB-INF/classes of a WAR file. And so you get all transactional capabilities in your web application very easily.

This Tip Of The Day (TOTD) shows how to enhance the application created in TOTD #94 and use EJB 3.1 instead of the JSF managed bean for performing the business logic. There are two ways to achieve this pattern as described below.

Lets call this TOTD #95.1

1. The easiest way to back a JSF page with an EJB is to convert the managed bean into an EJB by adding @javax.ejb.Stateless annotation. So change the  “StateList” class from TOTD #94 as shown below:

   @javax.ejb.Stateless @ManagedBean public class StateList {     @PersistenceUnit     EntityManagerFactory emf;     public List<States> getStates() {         return emf.createEntityManager().createNamedQuery(“States.findAll”).getResultList();     } }

   The change is highlighted in bold, and that’s it!

Because of “Deploy-on-save” feature in NetBeans and GlassFish v3, the application is autodeployed. Otherwise right-click on the project and select Run (default shortcut “F6″). As earlier, the results can be seen at “http://localhost:8080/HelloEclipseLink/forwardToJSF.jsp” or “http://localhost:8080/HelloEclipseLink/faces/template-client.xhtml” and looks like:

The big difference this time is that the business logic is executed by an EJB in a fully transactional manner. Even though the logic in this case is a single read-only operation to the database, but you get the idea

Alternatively, you can use the delegate pattern in the managed bean as described below. Lets call this #95.2.

1. Right-click on the project, select “New”, “Session Bean …” and create a stateless session bean by selecting the options as shown below:

   

   This creates a stateless session with the name “StateBeanBean” (bug #170392 for redundant “Bean” in the name).

2. Simplify your managed bean by refactoring all the business logic to the EJB as shown below:
   

   @Stateless public class StateBeanBean {     @PersistenceUnit     EntityManagerFactory emf;          public List<States> getStates() {         return emf.createEntityManager().createNamedQuery(“States.findAll”).getResultList();     } }

   and

   @ManagedBean public class StateList {     @EJB StateBeanBean bean;     public List<States> getStates() {         return bean.getStates();     } }

   In fact the EJB code can be further simplified to:

   @Stateless public class StateBeanBean {     @PersistenceContext     EntityManager em;         public List<States> getStates() {         return em.createNamedQuery(“States.findAll”).getResultList();     } }

   The changes are highlighted in bold.

If the application is already running then Deploy-on-Save would have automatically deployed the entire application. Otherwise right-click on the project and select Run (default shortcut “F6″). Again, the results can be seen at “http://localhost:8080/HelloEclipseLink/forwardToJSF.jsp” or “http://localhost:8080/HelloEclipseLink/faces/template-client.xhtml” and are displayed as shown in the screenshot above.

The updated directory structure looks like:

The important point to note is that our EJB is bundled in the WAR file and no additional deployment descriptors were added or existing ones modified to achieve that. Now, that’s really clean

The next blog in this series will show how managed beans can be replaced with WebBeans, err JCDI.

Also refer to other Java EE 6 blog entries.

Please leave suggestions on other TOTD that you’d like to see. A complete archive of all the tips is available here.

Technorati: totd glassfish v3 mysql javaee6 javaserverfaces jpa2 ejb netbeans

TOTD #93 showed how to get started with Java EE 6 using NetBeans 6.8 M1 and GlassFish v3 by building a simple Servlet 3.0 + JPA 2.0 web application. JPA 2.0 + Eclipselink was used for the database connectivity and Servlet 3.0 was used for displaying the results to the user. The sample demonstrated how the two technologies can be mixed to create a simple web application. But Servlets are meant for server-side processing rather than displaying the results to end user. JavaServer Faces 2 (another new specification in Java EE 6) is designed to fulfill that purpose.

This Tip Of The Day (TOTD) shows how to enhance the application created in TOTD #93 and use JSF 2 for displaying the results.

1. Right-click on the project, select “Properties”, select “Frameworks”, click on “Add …” as shown below:

   

   Select “JavaServer Faces” and click on “OK”. The following configuration screen is shown:

   

   Click on “OK” to complete the dialog. This generates a whole bunch of files (7 to be accurate) in your project. Most of these files are leftover from previous version of NetBeans and will be cleaned up. For example, “faces-config.xml” is now optional and “forwardToJSF.jsp” is redundant.

2. Anyway, lets add a POJO class that will be our managed bean. Right-click on “server” package and select “New”, “Java Class …”, give the name as “StateList”. Change the class such that it looks like:
   

   package server; import java.util.List; import javax.faces.bean.ManagedBean; import javax.persistence.EntityManagerFactory; import javax.persistence.PersistenceUnit; import states.States; /**  * @author arungupta  */ @ManagedBean public class StateList {     @PersistenceUnit     EntityManagerFactory emf;     public List<States> getStates() {         return emf.createEntityManager().createNamedQuery(“States.findAll”).getResultList();     } }

   Here are the main characterisitcs of this class:

   1. This is a POJO class with @ManagedBean annotation. This annotation makes this class a managed bean that can be used in the JSF pages. As no other annotations or parameters are specified, this is a request-scoped managed bean with the name “stateList” and lazily initialized. More details about this annotation are available in the javadocs.
   2. The persistence unit created in TOTD #93 is injected using @PersistenceUnit annotation.
   3. The POJO has one getter method that queries the database and return the list of all the states.
3. In the generated file “template-client.xhtml”, change the “head” template to:
   

   Show States

   and “body” template to:

   <h:dataTable var=”state” value=”#{stateList.states}” border=”1″>                     <h:column><h:outputText value=”#{state.abbrev}”/></h:column>                     <h:column><h:outputText value=”#{state.name}”/></h:column>                 </h:dataTable>

   This uses the standard JSF “dataTable”, “column”, and “outputText” tags and uses the value expression to fetch the values from the managed bean.

If the application is already running from TOTD #93, then Deploy-on-Save would have automatically deployed the entire application. Otherwise right-click on the project and select Run (default shortcut “F6″). The results can be seen at “http://localhost:8080/HelloEclipseLink/forwardToJSF.jsp” or “http://localhost:8080/HelloEclipseLink/faces/template-client.xhtml” and looks like:

The updated directory structure looks like:

There were multiple files added by the JSF framework support in NetBeans. But as I said earlier, they will be cleaned up before the final release.

Also refer to other Java EE 6 blog entries.

Please leave suggestions on other TOTD that you’d like to see. A complete archive of all the tips is available here.

Technorati: totd glassfish v3 mysql javaee6 javaserverfaces jpa2 netbeans

NetBeans 6.8 M1 introduces support for creating Java EE 6 applications … cool!

This Tip Of The Day (TOTD) shows how to create a simple web application using JPA 2.0 and Servlet 3.0 and deploy on GlassFish v3 latest promoted build (58 as of this writing). If you can work with the one week older build then NetBeans 6.8 M1 comes pre-bundled with 57. The example below should work fine on that as well.

1. Create the database, table, and populate some data into it as shown below:

   ~/tools/glassfish/v3/58/glassfishv3/bin >sudo mysql –user root Password: Welcome to the MySQL monitor.  Commands end with ; or \g. Your MySQL connection id is 1592 Server version: 5.1.30 MySQL Community Server (GPL) Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the buffer. mysql> create database states; Query OK, 1 row affected (0.02 sec) mysql> CREATE USER duke IDENTIFIED by ‘glassfish’; Query OK, 0 rows affected (0.00 sec) mysql> GRANT ALL on states.* TO duke; Query OK, 0 rows affected (0.24 sec) mysql> use states; Database changed mysql> CREATE TABLE STATES (     ->       id INT,     ->       abbrev VARCHAR(2),     ->       name VARCHAR(50),     ->       PRIMARY KEY (id)     -> ); Query OK, 0 rows affected (0.16 sec) mysql> INSERT INTO STATES VALUES (1, “AL”, “Alabama”); INSERT INTO STATES VALUES (2, “AK”, “Alaska”); . . . mysql> INSERT INTO STATES VALUES (49, “WI”, “Wisconsin”); Query OK, 1 row affected (0.00 sec) mysql> INSERT INTO STATES VALUES (50, “WY”, “Wyoming”); Query OK, 1 row affected (0.00 sec)

   The complete INSERT statement is available in TOTD #38. Most of this step can be executed from within the IDE as well as explained in TOTD #38.

2. Download and unzip GlassFish v3 build 58. Copy the latest MySQL Connector/J jar in “domains/domain1/lib” directory of GlassFish and start the application server as:
   

   ~/tools/glassfish/v3/58/glassfishv3/bin >asadmin start-domain

3. Create JDBC connection pool and JNDI resource as shown below:
   

   ~/tools/glassfish/v3/58/glassfishv3/bin >./asadmin create-jdbc-connection-pool –datasourceclassname com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource –restype javax.sql.DataSource –property “User=duke:Password=glassfish:URL=jdbc\:mysql\://localhost/states” jdbc/states Command create-jdbc-connection-pool executed successfully. ~/tools/glassfish/v3/58/glassfishv3/bin >./asadmin ping-connection-pool jdbc/states Command ping-connection-pool executed successfully. ~/tools/glassfish/v3/58/glassfishv3/bin >./asadmin create-jdbc-resource –connectionpoolid jdbc/states jdbc/jndi_states Command create-jdbc-resource executed successfully.

4. Download NetBeans 6.8 M1 and install “All” version. Expand “Servers” node and add the recently installed GlassFish server.
5. Create a new Web project and name it “HelloEclipseLink”. Make sure to choose “GlassFish v3″ as the server and “Java EE 6 Web” as the Java EE version as shown below:

   

   Take defaults elsewhere.

6. Create the Persistence Unit
   1. Right-click on the newly created project and select “New”, “Entity Classes from Database …”. Choose the earlier created data source “jdbc/jndi_states” as shown below:

      

   2. Select “STATES” table in “Available Tables:” and click on “Add >” and then “Next >”.
   3. Click on “Create Persistence Unit …”, take all the defaults and click on “Create”. “EclipseLink” is the Reference Implementation for JPA 2.0 is the default choosen Persistence Provider as shown below:

      

   4. Enter the package name as “server” and click on “Finish”.
7. Create a Servlet to retrieve and display all the information from the database
   1. Right click on the project, “New”, “Servlet …”.
   2. Give the Servlet name “ShowStates” and package “server”.
   3. Even though you can take all the defaults and click on “Finish” but instead click on “Next >” and the following screen is shown:

      

      Notice “Add information to deployment descriptor (web.xml)” checkbox. Servlet 3.0 makes “web.xml” optional in most of the common cases by providing corresponding annotations and NetBeans 6.8 leverages that functionality. As a result, no “web.xml” will be bundled in our WAR file. Click on “Finish” now.

      The generated servlet code looks like:

      

      Notice @WebServlet annotation, this makes “web.xml” optional. TOTD #82 provide another example on how to use Servlet 3.0 with EJB 3.1.

   4. Inject the Persistence Unit as:
      

      @PersistenceUnit     EntityManagerFactory emf;

      right above “processRequest” method.

   5. Change the “try” block of “processRequest” method to:
      

      List<States> list = emf.createEntityManager().createNamedQuery(“States.findAll”).getResultList();             out.println(“<table border=\”1\”>”);             for (States state : list) {                 out.println(“<tr><td>” + state.getAbbrev() +                         “</td><td>” + state.getName() +                         “</td></tr>”);             }             out.println(“</table>”);

      This uses a predefined query to retrieve all rows from the table and then display them in a simple formatted HTML table.

8. Run the project
   1. Right click on the project, select “Properties” and change the “Relative URL” to “/ShowStates”. This is the exact URL that you specified earlier.

      

   2. Right-click on the project and select “Run” to see the following output:

      

So we created a simple web application that uses Servlet 3.0, JPA 2.0, EclipseLink and deployed on GlassFish v3 using NetBeans 6.8 M1. NetBeans provides reasonable defaults making you a lazy programmer. Believe this is more evident when you start playing with Java EE support in other IDEs

Finally, lets look at the structure of the generated WAR file:

It’s very clean – no “web.xml”, only the relevant classes and “persistence.xml”.

Also refer to other Java EE 6 blog entries. A future blog entry will show how to use JSF 2.0 instead of Servlet for displaying the results.

Please leave suggestions on other TOTD that you’d like to see. A complete archive of all the tips is available here.

Technorati: totd glassfish v3 mysql javaee6 servlet3 jpa2 netbeans