Arun Gupta, Miles to go ...

Oracle Open World 2009 - Day 2 Report

Following from Day 1, the Day 2 started with Charles Phillips and Safra Catz keynote. The keynotes at Open World are significantly different from JavaOne or any other developer conference I've attended so far. Of course they are expected to be because Open World is not primarily a developer's conference. Oracle Develop (OD) certainly closely mimic any of the conferences I've typically attended. My "exhibitor" badge restricted me from attending any of the sessions at OD though :-(

Here are some interesting statistics about the conference:

5 content streams (Database, Applications, Industries, Management & Infrastructure, & Middleware)
314 demo kisosk
401 partners & customer exchibiting
1966 educational sessions (10% more than last year)
4500 Oracle developers/experts for you
81,266 hotel room nights
170,000 cups of coffee
182,000 online participation

Here are some interesting sightings from the Open World exhibitor pavilion:

• Tata Consultancy Services, Infosys, HCL, Wipro, Mahindra Satyam, Birlasoft, Cognizant and a host of other companies based in India are exhibiting in the pavilion. This is a pleasant surprise from JavaOne which typically does not see these many companies out of India.
• Poker, Ducati, Glider, Beatles Guitar, Sumo wrestler, Callaway Golf, Mini Cooper and other similar sightings were spotted. Check out complete set of images here.
• Lot more attendees are wearing a suit, quite unlike JavaOne or RailsConf which is typically denim/t-shirt rich.

On a personal front, everything that possibly could went wrong as part of the demo installation yesterday and rehearsal for my talks earlier today. NetBeans was not able to connect to the Oracle database (couple of machine restarts solved that), GlassFish Tools Bundle for Eclipse was timing out attempting to start GlassFish (removing workspace solved that problem), NetBeans's RESTful tooling not recognizing JPA entities, and also found a blocking bug (issue #10166) in deploying Rails app to latest GlassFish promoted build. These demos have worked seamlessly for me all the time time and fortunately worked well during the talk.

My talk at the Unconference on Creating Quick and Powerful Web applications with Oracle, GlassFish and NetBeans/Eclipse went well. It was truly an unconference event with no projector or mic in the presentation room. But the small attendance allowed us to huddle around the table and luckily all the demos worked seamlessly. The slides are available at:

Several demos shown in the talk are available at:

• Java EE 6 wizards using NetBeans and Eclipse
• Deploy on Save using NetBeans and Eclipse
• Connecting Oracle database to NetBeans
• Creating JPA entities from a sample Oracle database
• Exposing Oracle database table as RESTful entities
• Rails application using Oracle and GlassFish

The slides have pointers to several other demos as well. Also showed the simplicity of Java EE 6 development using Eclipse in Java Platform, Enterprise Edition: The Foundation and Future of Your Enterpise.

The day concluded with OTN Night in Howard St tent. Check out a brief video from the event:

Here are some pictures from earlier today:

If you are not able to attend in person, then you can follow OOW Blogs, Open World Live, @OpenWorld (twitter), Community tweets with #oow.

Back tomorrow on Day 3 with more pictures :-)

Technorati: conf oracle openworld oow glassfish javaee netbeans eclipse

Posted by Arun Gupta in General  |  Comments[1]

Oracle Open World 2009 - Day 1 Report

Sun Microsystems is the innovation sponsor of Oracle Open World 2009. And that's what was the theme of Scott McNealy's keynote on a "Sun"day. It's been a while that I've seen Scott on the keynote stage and it truly was an enjoyable experience. In his characteristic way, he gave top 10 reasons that "Engineers have gone wild" as:

10. Who needs thumb drive in the shape of sushi ?
9. "Noble prize" recently awards for gas mask bra - no more ridiculous than other noble prizes recently awarded
8. OS/2
7. Patent awarded for face mask with voice modification capability
6. I could do an entire top 10 of worlds strangest keyboards (strangest being iPhone, "Friends don't let friends type on iPhone")
5. Windows 7
4. Man uses SPARCstation for his ashses
3. New market in "family size' plots
2. Mainframe running Linux
1. Some one came up with this crazy idea for a 'Java Ring'

And then on a more serious note, and keeping with the keynote theme, top 10 innovations from Sun:

10. NFS/PC-NFS Technology (1983)
9. SPARC (1989)
8. Open Source Software (Berkeley Unix, "Red Hat of Berkeley Unix", #1 contributor to OSS community)
7. BSD + UNIX System 5 = Solaris
6. Java (Java card, EE/SE/ME, JavaFX)
5. E10K (64-way Solaris, no longer mainframe required)
4. ZFS/Open Storage/Flash (Exadata)
3. Project Blackbox, world's first modular datacenter
2. SunRay
1. Chip multithreading "CoolThreads"

And the biggest innovation from Sun:

Kicked Butt
Had Fun
Didn't CHeat
Loved our customers
Changed computing for ever

Scott explained why SPARC, Solaris, MySQL, Java are here to stay. "Kick Butt, Have Fun" is truly the spirit at Sun :-)

James Gosling, the father of Java, showed up on the stage to talk about Java's relevance for Oracle. Also showed "The Gospel of Java according to James" and the video is shown below:

John Fowler talked about several brand new Sun/Oracle world-record benchmarks. A key point from these benchmarks "Oracle and Sun were able to set the world record using 1/8th the hardware that IBM used for its largest benchmark". And we also announced F5100 Flash Array, the world's fastest solid-state flash array.

And here are some quotes from Larry Ellison's keynote appearance:

• "SPARC is a fantastic technology"
• "All Oracle software runs reliably and faster on Solaris, than ever before"
• "MySQL competes in different market", "We are going to spend more, not less, on MySQL", "Increase our rate of contribution to that product"
• "Not only invest in Sun technology, also in Sun business"
• IBM: Slower, Costs More, Not Fault Tolerant, Not Very Green (from a slide)
• 25% more throughput, (can do lot better), 16x better response time
• "IBM's processor is called "POWER", we know why ?" (because it's consumes the entire power of your data center ;-)
• "I'm not fair on IBM because they are not here to respond"
• One mans' SUNset is another man's SUNrise, We think this is SUNrise time"

It totally reminded me of Scott McNealy's "dot-not" (as compared to .NET) and "c-flat" (for C#) quotes from JavaOne :-)

Check out related articles about Sun's presence at Open World:

• GlassFish and Friends
• Java at OOW
• Solaris at OOW
• SDN Article
• Sun Bloggers at OOW
• Sun Microsystems at OOW
• Sun sessions (PDF or live list)

Here are some pictures:

If you are not able to attend in person, then you can follow OOW Blogs, Open World Live, @OpenWorld (twitter), Community tweets with #oow.

On a personal note, this is my first Open World and am totally amazed by the size of attendees, and it's only a Sunday. The entire Howard St is shutdown and tents are installed to accommodate the conference. All 3 Moscone halls (North, South, and West) are used. A scale down replica of Larry's "Rising Sun" is also displayed on Howard Street. And for the first time in 10 years, I'm getting only an Exhibitor badge at Moscone :-)

Also installed GlassFish, NetBeans/Eclipse demos on the booth machine and ready to wow the audience with Java EE 6 in the exhibitor hall for the next 3 days! And of course, I'm talking at the Unconference tomorrow at 11am on Creating Quick and Powerful Web applications with Oracle, GlassFish and NetBeans/Eclipse. Get ready to see lots and lots of demos!

Back tomorrow with more pictures :-)

Technorati: conf oracle openworld oow glassfish netbeans eclipse

Posted by Arun Gupta in General  |  Comments[0]

TOTD #112: Exposing Oracle database tables as RESTful entities using JAX-RS, GlassFish, and NetBeans

This Tip Of The Day explains how to expose an existing Oracle database table as a RESTful Web service endpoint using NetBeans tooling and deployed on GlassFish.

Lets get started!

1. Configure GlassFish v3 10/7 or a later nightly in a recent NetBeans 6.8 build (latest nightly). As issue# 9885 is fixed, so copy ojdbc6.jar in the "domains/domain1/lib/ext" directory.
2. Create a Web application
   1. Create a new "Web application" and name the project "RestfulOracle":
      
      
      
      click on "Next >".
   2. Choose the newly added server and "Java EE 6 Web" as the Java EE version:
      
      
      
      and click on "Finish".
      
3. Create JPA entities for "HR" schema. The steps outlined below uses NetBeans solely for creating the JPA entities. Alternatively, TOTD #108 explains how to define a JDBC connection pool and JDBC resource using "asadmin" CLI and then use that resource from within NetBeans. Either way, the JDBC resource is stored in the underlying "domain.xml".
   1. Right-click on the project and select "New", "Entity Classes from Database...".
   2. In "Data Source:" select "New Data Source..." as shown below:
      
      
   3. Specify the JNDI name as "jdbc/hr" and choose the pre-configured database connection as shown below:
      
      
      
      TOTD #107 explains how to configure Oracle database in NetBeans.
   4. In the list of "Available Tables:", select "EMPLOYEES" and click on "Add >" to see the following:
      
      
      
      Notice the list of related tables are included as well. Click on "Next >".
   5. Specify the package name as "model".
   6. Click on "Create Persistence Unit...", take the defaults, and click on "Create":
      
      
      
      and click on "Finish". Notice EclipseLink, the reference implementation for JPA 2.0, is used as the persistence provider. This generates POJOs that provide database access using JPA 2.0 APIs. These APIs are included as part of the Java EE 6 platform.
      
4. Create RESTful entities
   1. Right-click on the project and select "RESTful Web Services from Entity Classes...":
      
      
      
   2. Select "Employees (model.Employees)" from "Available Entity Classes:" and click on "Add >" to see the following:
      
      
      
      click on "Next >", take the defaults, and click on "Finish". This generates a bunch of wrapper classes using JAX-RS to expose the JPA Entity classes as RESTful Web services. JAX-RS 1.1 is also included as part of the Java EE 6 platform.
5. Run the Web service
   1. Right-click the project and select "Test RESTful Web Services":
      
      
      
      This deploys the created Web application on the selected GlassFish build and displays the following page in the default browser:
      
      
      
   2. Click on "deparmentss" and then on "Test" button to see the output as:
      
      
      
      Clicking the "Test" button issues a GET request to "http://localhost:8080/RestfulOracle/resources/departmentss". This uses the generated JAX-RS wrapper classes to talk to the database using JPA entity classes and query the first 10 rows from the "DEPARTMENTS" table. The response is then JSON formatted using JAX-RS wrapper classes and is returned to the requesting page which then displays it nicely formatted in the table. It also shows l-level deep department's relationship to other entities. If the "expandLevel" on the above page is set to "0", then the following output is shown:
      
      
      
      The "Raw View" (JSON data) of the original output looks like:
      
      
      
      Notice this is the raw JSON output generated by the JAX-RS wrapper classes. The "Http Monitor" traffic looks like:
      
      
      
      The format of data returned can be changed from "application/json" to "application/xml" as shown below:
      
      
      
      And even a POST request can be generated.

Do you have the need to expose your Oracle database tables as RESTful entities ?

A complete archive of all the TOTDs is available here.

This and other similar applications will be demonstrated at the upcoming Oracle Open World.

Technorati: totd oracle database glassfish v3 netbeans javaee jax-rs jpa rest

Posted by Arun Gupta in General  |  Comments[0]

TOTD #109: How to convert a JSF managed bean to JSR 299 bean (Web Beans) ?

This entry is a follow up to TOTD #95 and shows how to use the recent integrations of JSR 299 in GlassFish v3 to convert a JSF managed bean to a JSR 299 bean (aka Web Beans). The TOTD #95 describes a simple Java EE 6 web application that uses Java Server Faces 2.0 components for displaying the results of a database query conducted by EJB 3.1 and JPA 2.0 classes.

The EJB class, which also acts as the JSF managed bean, looks like:

@javax.ejb.Stateless
@ManagedBean
public class StateList {
  @PersistenceUnit
  EntityManagerFactory emf;

  public List getStates() {
    return    emf.createEntityManager().createNamedQuery(”States.findAll”).getResultList();
  }
}

Three changes are required to convert this class into a JSR 299 compliant bean (Web Bean) as listed below:

1. Add an empty "beans.xml" to the WEB-INF directory.
2. Replace "@ManagedBean" with "@javax.inject.Named annotation". "@javax.inject" annotations are defined by JSR 330.
3. Resource injection does not work with JPA classes, yet, so populate EntityManager explicitly as explained below:
   1. Replace EntityManagerFactory resource injection:
      
      

      @PersistenceUnit
      EntityManagerFactory emf;
      

      
      with:
      

      EntityManager emf = Persistence.createEntityManagerFactory("HelloEclipseLinkPU");
      

   2. Add the required entity classes explicitly to "persistence.xml". If the persistence unit is injected then the container automatically scans the web application root for any entity classes.
      1. Expand "Configuration Files" and edit "persistence.xml".
      2. Uncheck "Include All Entity Classes in ..." check box.
      3. Click on "Add Class...", select "state.States", and click on "OK".
         
         

That's it, re-deploy your application and now you are using the Web Beans integration in GlassFish v3 instead of JSF managed bean. The output is available at "http://localhost:8080/HelloEclipseLink/forwardToJSF.jsp" as shown:



This is the exact same output as shown in TOTD #95.

Now, one-by-one, JPA, EJB, Transactions and other components will start working. Read Roger's blog for another example of Web Beans in GlassFish.

A complete archive of all the tips is available here.

Technorati: totd glassfish v3 mysql javaee6 javaserverfaces webbeans jsr299 netbeans

Posted by Arun Gupta in General  |  Comments[2]

TOTD #108: Java EE 6 web application (JSF 2.0 + JPA 2.0 + EJB 3.1) using Oracle, NetBeans, and GlassFish

TOTD #106 explained how to install Oracle database 10g R2 on Mac OS X. TOTD #107 explained how to connect this Oracle database using NetBeans. This Tip Of The Day will explain how to use the sample HR database (that comes with Oracle database server) to write a simple Java EE 6 application.

This application will use Java Server Faces 2.0 for displaying the results, Enterprise Java Beans 3.1 + Java Persistence API 2.0 for middle tier, and Oracle database server + GlassFish v3 as the backend. The latest promoted build (65 of this writing) will not work because of the issue #9885 so this blog will use build 63 instead.

Several improvements have been made over NetBeans 6.8 M1 build and this blog is using the nightly build of 9/27. The environment used in this blog is:

• NetBeans 9/27 nightly
• GlassFish v3 build 63
• Oracle database server 10.2.0.4.0 R2 on Mac OS X
• Oracle JDBC Driver type 4 (ojdbc6.jar)

Lets get started!

1. Configure GlassFish v3 with JDBC connection
   1. Download and unzip build 63.
   2. Download ojdbc6.jar and copy to "glassfishv3/glassfish/domains/domain1/lib/ext" directory.
   3. Start the Application Server as:
      

      ./bin/asadmin start-domain --verbose &
      

   4. Create a JDBC connection pool as:
      

      ./bin/asadmin create-jdbc-connection-pool --datasourceclassname oracle.jdbc.pool.OracleDataSource --restype javax.sql.DataSource --property "User=hr:Password=hr:URL=jdbc\:oracle\:thin\:@localhost\:1521\:orcl" jdbc/hr
      

      
      and verify the connection pool as:
      

      ./bin/asadmin ping-connection-pool jdbc/hr
      

   5. Create a JDBC resource as:

      ./bin/asadmin create-jdbc-resource --connectionpoolid jdbc/hr jdbc/hr
      

2. Configure GlassFish v3 build 63 in NetBeans
   1. In NetBeans IDE "Services" panel, right-click on "Servers" and click on "Add Server...". Choose "GlassFish v3" and provide a name as shown below:
      
      
      
   2. Click on "Next >" and specify the unzipped GlassFish location as:
      
      
      
      and click on "Finish".
3. Create the Java EE 6 application
   1. In "Projects" pane, right-click and select "New Project...".
   2. Choose "Java Web" and "Web Application" and click on "Next". Choose the project name as "HelloOracle":
      
      
      
      and click on "Next >".
   3. Select the recently added GlassFish v3 server and choose "Java EE 6 Web" profile:
      
      
      
      and click on "Next >". Notice "Java EE 6 Web" profile is chosen as the Java EE version.
   4. Select "JavaServer Faces" on the frameworks page:
      
      
      
      and click on "Finish". Notice the JSF libraries bundled with the App Server are used.
4. Create the Java Persistence Unit
   1. Right-click on the project, select "New", "Entity Classes from Database...":
      
      
      
   2. From the Data Source, select "jdbc/hr" as shown:
      
      
      
      This is the same JDBC resource created earlier. Select "EMPLOYEES" from the Available Table, click on "Add >" to see the output as:
      
      
      
      The related tables are automatically included. Click on "Next >".
   3. Click on "Create Persistence Unit ..." and take all the defaults and click on "Create".
   4. Specify the package name as "model":
      
      
      
      and click on "Finish". This generates a JPA-compliant POJO class that provide access to tables in the underlying Oracle database. The class name corresponding to each table is shown in the wizard.
5. Create Enterprise Java Beans
   1. Right-click on the project and select "New Class...".
   2. Specify the class name as "EmployeesBean" and package as "controller", click on "Finish".
   3. Annotate the class to make it an Enterprise Java Bean and a JSF Managed Bean as:
      

      @javax.ejb.Stateless
      @javax.faces.bean.ManagedBean
      

      
      
      Notice, the EJB is bundled in the WAR file and no special type of modules are required. Java EE 6 provides simplified packaging of EJB which makes it really ease to use.
      
      Also this application is currently using JSF managed bean but will use JSR 299 (aka Web Beans) in a future blog.
   4. Inject the Persistence Unit by adding the following variable:

      @PersistenceUnit
      EntityManagerFactory emf;
      

   5. Add a new method to retrieve the list of all employees as:
      

      public List getEmployees() {
       return em.createNamedQuery("Employees.findAll").getResultList();
      }
      

      
      "Employees.findAll" is a default NamedQuery generated by NetBeans and makes it easy to query the database. Several other queries are generated for each mapped JPA class, such as "Employees.findByEmployeeId" and "Employees.findByFirstName". Custom queries can also be created and specified on the POJO class.
      
      The completed class looks like:
      

      @Stateless
      @ManagedBean
      public class EmployeesBean {
      
       @PersistenceContext
       EntityManager em;
      
       public List getEmployees() {
       return em.createNamedQuery("Employees.findAll").getResultList();
       }
      }
      

6. Use EJB in the generated JSF page
   1. JSF 2 uses Facelets as the templating mechanism and NetBeans generate a simple "index.xhtml" file to start with. Expand "Web Pages" and open "index.xhtml".
   2. Replace the body template with:
      

      <h1>First Java EE 6 app using Oracle database</>
      <h:dataTable var="emp" value="#{employeesBean.employees}" border="1">
       <h:column><h:outputText value="#{emp.lastName}"/>, <h:outputText value="#{emp.firstName}"/></h:column>
       <h:column><h:outputText value="#{emp.email}"/></h:column>
       <h:column><h:outputText value="#{emp.hireDate}"/></h:column>
       </h:dataTable>
      

      
      It uses JSF value expressions to bind the Enterprise Java Bean and dumps the HTML formatted name, email, and hire date of each employee in the database.
7. Run the project: Right-click on the project and select "Run" to see the output at "http://localhost:8080/HelloOracle/" as:
   
   

So we can easily create a Java EE 6 application using NetBeans, Oracle, and GlassFish.

A complete archive of all the TOTDs is available here.

This and other similar applications will be demonstrated at the upcoming Oracle Open World.

Technorati: totd oracle database glassfish v3 javaee javaserverfaces ejb jpa netbeans oow

Posted by Arun Gupta in General  |  Comments[0]

TOTD #107: Connect to Oracle database using NetBeans

TOTD #106 explained how to install Oracle database 10g R2 on Mac OS X. This Tip Of The Day will explain how to connect Oracle database with NetBeans to leverage all the goodness provided by NetBeans for Java EE application development, Rails, and others.

1. Download Oracle JDBC Drivers, specifically ojdbc14.jar. (ojdbc6.jar is recommended to be used with GlassFish v3).
2. Using NetBeans 6.8 M1, in Services tab, right-click on "Databases" and select "New Connection..." as shown:
   
   
   
3. Expand "Name:" and select "New Driver...":
   
   
   
4. Click on "Add..." and choose the recently downloaded JDBC driver JAR file as shown below:
   
   
   
   and click on "OK".
   
5. Enter the database values as shown below:
   
   
   
   The password is "hr" for the sample HR database. Clicking on "Show JDBC URL" also shows the complete JDBC URL. Click on "OK".
   
   You may have to unlock the "hr" user by giving the command:
   

   ALTER USER HR IDENTIFIED BY hr ACCOUNT UNLOCK;
   

   as explained in TOTD #106.
6. Select the "HR" schema as shown below:
   
   
   
   and click on "OK". The complete list of schemas is now shown in the "Databases" node as shown below:
   
   
7. Expand the "HR" node and the complete list of tables is visible now:
   
   
   
   Expanding each table shows you the complete definition as shown:
   
   
8. Right-click on "COUNTRIES" table and select "View Data..."
   
   
   
   and the result is shown as:
   
   
   
   Additionally, you can execute any SQL command by selecting "Execute Command...":
   
   

A complete archive of all the TOTDs is available here.

Subsequent blogs will show how to write a Java EE application to access the Oracle database.

Technorati: totd oracle database netbeans

Posted by Arun Gupta in General  |  Comments[0]

Track your running miles using Apache Wicket, GlassFish, NetBeans, MySQL, and YUI Charts

Content available at: http://blog.arungupta.me/2009/09/track-your-running-miles-using-apache-wicket-glassfish-netbeans-mysql-and-yui-charts/.

Posted by Arun Gupta in General  |  Comments[0]

TOTD #95: EJB 3.1 + Java Server Faces 2.0 + JPA 2.0 web application - Getting Started with Java EE 6 using NetBeans 6.8 M1 & GlassFish v3

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!

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.
   

Posted by Arun Gupta in General  |  Comments[1]

TOTD #94: A simple Java Server Faces 2.0 + JPA 2.0 application - Getting Started with Java EE 6 using NetBeans 6.8 M1 & GlassFish v3

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.

Posted by Arun Gupta in General  |  Comments[3]

TOTD #93: Getting Started with Java EE 6 using NetBeans 6.8 M1 & GlassFish v3 - A simple Servlet 3.0 + JPA 2.0 app

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:
   
   
   
   

Posted by Arun Gupta in General  |  Comments[5]

TOTD #91: Retrieve JSON libraries using Maven dependency: json-lib

So you need to include JSON libraries in your Maven project. The only option that seems to be currently available is using json-lib with the following dependencies:

Posted by Arun Gupta in web2.0  |  Comments[6]

TOTD# 86: Getting Started with Apache Wicket on GlassFish

Apache Wicket is an application framework to build web applications using HTML for markup and POJOs to capture the business logic and all other processing. Why Wicket digs more into the motivation behind this framework.

1. Create a Wicket project as:
   
   

   ~/samples/wicket >mvn archetype:create -DarchetypeGroupId=org.apache.wicket -DarchetypeArtifactId=wicket-archetype-quickstart -DarchetypeVersion=1.3.6 -DgroupId=org.glassfish.samples -DartifactId=helloworld [INFO] Scanning for projects... [INFO] Searching repository for plugin with prefix: 'archetype'. [INFO] ------------------------------------------------------------------------ [INFO] Building Maven Default Project [INFO]    task-segment: [archetype:create] (aggregator-style) [INFO] ------------------------------------------------------------------------ [INFO] Setting property: classpath.resource.loader.class => 'org.codehaus.plexus.velocity.ContextClassLoaderResourceLoader'. [INFO] Setting property: velocimacro.messages.on => 'false'. [INFO] Setting property: resource.loader => 'classpath'. [INFO] Setting property: resource.manager.logwhenfound => 'false'. [INFO] [archetype:create] [WARNING] This goal is deprecated. Please use mvn archetype:generate instead [INFO] Defaulting package to group ID: org.glassfish.samples [INFO] ---------------------------------------------------------------------------- [INFO] Using following parameters for creating OldArchetype: wicket-archetype-quickstart:1.3.6 [INFO] ---------------------------------------------------------------------------- [INFO] Parameter: groupId, Value: org.glassfish.samples [INFO] Parameter: packageName, Value: org.glassfish.samples [INFO] Parameter: package, Value: org.glassfish.samples [INFO] Parameter: artifactId, Value: helloworld [INFO] Parameter: basedir, Value: /Users/arungupta/samples/wicket [INFO] Parameter: version, Value: 1.0-SNAPSHOT [INFO] ********************* End of debug info from resources from generated POM *********************** [INFO] OldArchetype created in dir: /Users/arungupta/samples/wicket/helloworld [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESSFUL [INFO] ------------------------------------------------------------------------ [INFO] Total time: 3 seconds [INFO] Finished at: Tue Jul 28 15:30:21 PDT 2009 [INFO] Final Memory: 12M/80M [INFO] ------------------------------------------------------------------------

2. Run it using the pre-configured Jetty plugin as:
   
   

   ~/samples/wicket/helloworld >mvn jetty:run [INFO] Scanning for projects... [INFO] Searching repository for plugin with prefix: 'jetty'. [INFO] ------------------------------------------------------------------------ [INFO] Building quickstart [INFO]    task-segment: [jetty:run] [INFO] ------------------------------------------------------------------------ [INFO] Preparing jetty:run [INFO] [resources:resources] [INFO] Using default encoding to copy filtered resources. [INFO] [compiler:compile] [INFO] Compiling 2 source files to /Users/arungupta/samples/wicket/helloworld/target/classes [INFO] [resources:testResources] [INFO] Using default encoding to copy filtered resources. [INFO] [compiler:testCompile] [INFO] Compiling 2 source files to /Users/arungupta/samples/wicket/helloworld/target/test-classes [INFO] [jetty:run] [INFO] Configuring Jetty for project: quickstart [INFO] Webapp source directory = /Users/arungupta/samples/wicket/helloworld/src/main/webapp [INFO] Reload Mechanic: automatic [INFO] Classes = /Users/arungupta/samples/wicket/helloworld/target/classes 2009-07-28 15:31:35.820::INFO:  Logging to STDERR via org.mortbay.log.StdErrLog [INFO] Context path = /helloworld [INFO] Tmp directory =  determined at runtime [INFO] Web defaults = org/mortbay/jetty/webapp/webdefault.xml [INFO] Web overrides =  none . . . INFO  - WebApplication             - [WicketApplication] Started Wicket version 1.3.6 in development mode ******************************************************************** *** WARNING: Wicket is running in DEVELOPMENT mode.              *** ***                               ^^^^^^^^^^^                    *** *** Do NOT deploy to your live server(s) without changing this.  *** *** See Application#getConfigurationType() for more information. *** ******************************************************************** 2009-07-28 15:31:37.333::INFO:  Started SelectChannelConnector@0.0.0.0:8080 [INFO] Started Jetty Server

   
   And the default web page is available at "http://localhost:8080/helloworld" and looks like:
   
   
   
   A later blog will show how to run this application using Embedded GlassFish. But for now lets package the application as a WAR file and deploy it on GlassFish.
3. Download GlassFish v3 Preview and unzip.
4. Create a WAR file as:
   
   

   ~/samples/wicket/helloworld >mvn package [INFO] Scanning for projects... [INFO] ------------------------------------------------------------------------ [INFO] Building quickstart [INFO]    task-segment: [package] . . . [INFO] Processing war project [INFO] Webapp assembled in[494 msecs] [INFO] Building war: /Users/arungupta/samples/wicket/helloworld/target/helloworld-1.0-SNAPSHOT.war [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESSFUL [INFO] ------------------------------------------------------------------------ [INFO] Total time: 6 seconds [INFO] Finished at: Tue Jul 28 15:35:59 PDT 2009 [INFO] Final Memory: 14M/80M [INFO] ------------------------------------------------------------------------

   
   and deploy as:
   
   

   ~/samples/wicket/helloworld >~/tools/glassfish/v3/preview/glassfishv3/bin/asadmin deploy target/helloworld-1.0-SNAPSHOT.war Command deploy executed successfully.

   
   The app is now accessible at "http://localhost:8080/helloworld-1.0-SNAPSHOT" and looks like:
   
   

• Wicket Quickstart shows how to create a Wicket application and get started easily.
• Wicket Examples provide a flavor of how the code is structured.
• Wicket in Action is a great book that explains the concepts very well.
• May want to look at wicket-extensions for a list of gadgets/widgets that extend the core capability of the framework.

• Run Wicket application using Embedded GlassFish
• Use Servlet 3.0 web-fragments.xml and leverage GlassFish v3 Pluggability to run Wicket applications
• A Wicket version of Track your running miles application
• Deploying Wicket applications from NetBeans to GlassFish

Posted by Arun Gupta in web2.0  |  Comments[3]

Track your running miles using JRuby, Ruby-on-Rails, GlassFish, NetBeans, MySQL, and YUI Charts

This blog introduces a new application that will provide basic tracking of your running distance and generate charts to monitor progress. There are numerous similar applications that are already available/hosted and this is a very basic application. What's different about this ?

The first version of this application is built using JRuby, Ruby-on-Rails, GlassFish Gem, MySQL, and NetBeans IDE. This combination of technologies is a high quality Rails stack that is used in production deploymnet at various places. Still nothing different ?

A similar version of this application will be built using a variety of Web frameworks such as Java EE, Grails, Wicket, Spring and Struts2 (in no particular order). The goal is to provide a similar application, slightly bigger than "Hello World," built using different frameworks and deploy on GlassFish. Each framework will then be evaluated based upon the criteria ranging from the basic principles of framework, ease-of-use in design/development/testing/debugging/production of this web app, database interaction, tools support, ability to add 3rd party libraries, browser compatibility and other points. 

An important point to note is that this is not an exhaustive evaluation of different Web frameworks and the scope is limited only to this application.

A complete list of frameworks planned is available here. The criteria used to evaluate each framework is described here. Your feedback in terms of Web frameworks and evaluation criteria is highly appreciated.  Please share your feedback on the users list.

Now the first version of application. The complete instructions to check out and run the Rails version of this application are available here.

Here are some charts generated using the application:



and



YUI is used for all the charting capabilities.

And here is a short video that explains how the application work:



If you are a runner, check out the application and use it for tracking your miles. A sample runlog is available in "test/fixtures/runlogs.yml" and races in "test/fixtures/races.yml".

If you know Rails, please provide feedback if the application is DRY and using the right set of helpers.

If you'd like the existing list of web frameworks to be pruned or include another one to the list, let us know.

Share you feedback at users@runner.kenai.com.

Technorati: jruby rubyonrails glassfish netbeans mysql yahoo yui chart running miles framework

Posted by Arun Gupta in Running  |  Comments[2]

FISL 2009 Speaker Certificate

Received a "certificate of attendance as speaker" for recently concluded FISL 10.



This is sweet, thanks FISL organizers! It certainly adds a personal touch to the whole experience.

I don't remember receiving a personal certificate like this :)

Technorati: conf fisl brazil glassfish netbeans mysql eclipse

Posted by Arun Gupta in General  |  Comments[3]

FISL 2009 Wrapup - 3 talks, 1 talk show, 14 blogs, 10 videos, 275 pics, 2 GlassFish production stories

FISL 2009 wrapped up over the weekend. Even though the conference officially ended on Saturday but the connections made there will certainly allow us to continue all the great momentum. The conference celebrates open source and it was certainly great to see Federal Government and Banks with their booths in the exhibitor halls. The visit by Brazilian President Lula certainly highlights the importance of this conference to the local community. There were booths from Debian, Firefox, Ubuntu and other major open source softwares. Some commercial vendors had a booth as well and of course Sun Microsystems had a big presence with GlassFish, Open Solaris, NetBeans, MySQL and other offerings.

I delivered 3 talks and participated in 1 talk show:

• Java EE 6 (slides) & Enterprise Features of GlassFish (slides)
• Creating powerful web applications using GlassFish, MySQL and NetBeans/Eclipse slides
• Continuous Integration using Hudson (slides)
• Simon Phipps Talk Show

• GlassFish Swimming to FISL, Brazil
• Javali 2009 Trip Report
• FISL 2009 Day 1 Report
• Porto Alegre - I shoot you, you shoot me
• Running inside Parque Moinhos de Vento, Porto Alegre
• Porto Alegre - I shoot you, you shoot me
• FISL Day 2 in Pictures & Videos
• supercrud.com in Brazil picked GlassFish over JBoss - Find out why!
• Porto Alegre - I shoot you, you shoot me
• Digital TV-based Banking using GlassFish, NetBeans and MySQL - Ginga community in Brazil
• FISL 2009 Day 3 in Pictures & Videos
• Porto Alegre - I shoot you, you shoot me
• FISL 2009 Day 4 in Pictures
• Porto Alegre - I shoot you, you shoot me

Posted by Arun Gupta in General  |  Comments[2]