PlanetMysql.ru - информация о СУБД MySQL » totd

TOTD #150: Collection of GlassFish, NetBeans, JPA, JSF, JAX-WS, EJB, Jersey, MySQL, Rails, Eclipse, and OSGi tips

Arun Gupta — Thu, 18 Nov 2010 14:00:23 +0000

This is the 150th tip published on this blog so decided to make it a collection of all the previous ones. Here is a tag cloud (created from wordle.net/create) from title of all the tips:

As expected GlassFish is the most prominent topic. And then there are several entries on NetBeans, JRuby/Rails, several Java EE 6 technologies like JPA, JAX-WS, JAX-RS, EJB, and JSF, and more entries on Eclipse, OSGi and some other tecnhologies too. Here is a complete collection of all the tips published so far:

Just for fun, here is another tag cloud:

You can access all the tips here. And keep those suggestions coming!

Technorati: totd glassfish netbeans jpa jsf jaxws jersey mysql rails osgi eclipse

PlanetMySQL Voting: Vote UP / Vote DOWN

TOTD #122: Creating a JPA Persistence Unit using NetBeans 6.8

Arun Gupta — Wed, 10 Feb 2010 07:08:43 +0000

Taking TOTD #121 forward, this blog explains how to create a JPA Persistence Unit for a MySQL sample database and package it as a library. This JAR file can then be easily included in other web applications.

Lets get started!

Configure GlassFish for using the MySQL sample database (sakila) as described in TOTD #121.
Add the GlassFish instance in NetBeans IDE using "Services" panel.

Create JPA entities using NetBeans IDE.

Create a Java class library:

Our ultimate goal is to create a reusable JAR file and that's why this project type is chosen.
Specify the name of project as "SakilaPU":
Right-click on the project and select "New", "Entity Classes from Database ..." to initiate the process of entity generation:
Choose the database connection as:

If not configured, then can be easily done by clicking on "New Database Connection ..." in the list box.
1. Click on "Add All >>" to generate the mapped JPA entities for all tables and views.
2. The views do not have primary keys and will need to be appropriately annotated (described later).
3. Click on "Next >".
Give the package name as:

and specify the package name as "sakila". Click on "Create Persistence Unit ...".
Change the default PU name from "SakilaPUPU" to "SakilaPU":

and click on "Finish". Notice that "EclipseLink", the Reference Implementation of JPA 2.0, is used as the persistence library.

Add "@javax.persistence.Id" annotation to the following class/field combination:

Class	Field
sakila.SalesByFilmCategory	category
sakila.ActorInfo	actorId
sakila.FilmList	fid
sakila.CustomerList	id
sakila.NicerButSlowerFilmList	fid
sakila.StaffList	id
sakila.SalesByStore	store

This is required because none of the "views" are defined with a primary key.

Right-click on the project and select "Clean & Build". This generates "dist/SakilaPU.jar" and the structure looks like:

This JAR file can now be included in any web application. The pre-built JAR file can also be downloaded here. The key items to note about this pre-built JAR:

Persistence Unit Name: "SakilaPU"
All classes are in "sakila.*" package.
Each class has a pre-defined ".findAll" named query that returns all elements from the underlying view/table.
Can be easily added in "WEB-INF/lib" directory of your web application.

Even though this blog uses a MySQL sample database, these steps can be easily followed for any other database such as Oracle or JavaDB.

Technorati: totd javaee glassfish v3 jpa eclipselink persistenceunit mysql sakila netbeans

PlanetMySQL Voting: Vote UP / Vote DOWN

TOTD #121: JDBC resource for MySQL and Oracle sample database in GlassFish v3

Arun Gupta — Tue, 09 Feb 2010 07:00:17 +0000

This blog clearly explains how to configure the MySQL sample database (sakila) with GlassFish. Even though the instructions use a specific database but should work for other databases (such as Oracle, JavaDB, PostgreSQL, and others) as well. The second half of the blog provide specific syntax for the Oracle sample database.

Download sakila sample database and unzip the archive.
Install the database as described here - basically load and run "sakila-schema.sql" and "sakila-data.sql" extracted from the archive.

Create a new MySQL user account using MySQL CLI Admin and assign the privileges

Using "root" user (sudo mysql --user root)

CREATE USER glassfish IDENTIFIED BY 'glassfish';
GRANT ALL PRIVILEGES ON *.* TO 'glassfish'@'localhost' IDENTIFIED BY 'glassfish';
FLUSH PRIVILEGES;

Using "glassfish" user (sudo mysql --user glassfish)
```
source sakila-schema.sql;
source sakila-data.sql;
```

Download Connector/J, unzip and copy "mysql-connector-java-5.x.x-bin.jar" to "glassfish/domains/domain1/lib/ext" directory.
Start GlassFish server as:
```
asadmin start-domain
```

Create a JDBC resource

Create JDBC connection pool as:

asadmin create-jdbc-connection-pool --datasourceclassname com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource --restype javax.sql.DataSource --property "User=glassfish:Password=glassfish:URL=jdbc\:mysql\://localhost/sakila" jdbc/sakilaPool

Test the JDBC connection pool as:

asadmin ping-connection-pool jdbc/sakilaPool

Create the JDBC resource as:

asadmin create-jdbc-resource --connectionpoolid jdbc/sakilaPool jdbc/sakila

That's it!

Creating a JDBC resource for any other database requires the following updates to the steps mentioned above. Lets consider modifying these steps for the Oracle sample database.

Use the client interface SQL*PLus and connect as:

sqlplus "/ as sysdba"

create user and grant the privileges as:

CREATE USER glassfish IDENTIFIED BY glassfish DEFAULT tablespace users TEMPORARY tablespace temp;
GRANT CONNECT TO glassfish IDENTIFIED BY glassfish;
GRANT UNLIMITED TABLESPACE TO glassfish;
GRANT CREATE TABLE TO glassfish;
GRANT CREATE SEQUENCE TO glassfish;

Copy the appropriate JDBC driver (ojdbc6.jar).

Create the JDBC resource as:

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
asadmin ping-connection-pool jdbc/hr
asadmin create-jdbc-resource --connectionpoolid jdbc/hr jdbc/hr

as explained in TOTD #108.

Here are a few other related entries:

Technorati: totd javaee glassfish v3 jpa mysql sakila oracle

PlanetMySQL Voting: Vote UP / Vote DOWN

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

Arun Gupta — Fri, 02 Oct 2009 22:40:00 +0000

Content available at http://blog.arungupta.me/2009/10/totd-109-how-to-convert-a-jsf-managed-bean-to-jsr-299-bean-web-beans/.
PlanetMySQL Voting: Vote UP / Vote DOWN

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

Arun Gupta — Mon, 17 Aug 2009 10:00:00 +0000

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

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 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.

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).

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 getStates() {
        return emf.createEntityManager().createNamedQuery("States.findAll").getResultList();
    }
}

and

@ManagedBean
public class StateList {
    @EJB StateBeanBean bean;

    public List getStates() {
        return bean.getStates();
    }
}

In fact the EJB code can be further simplified to:

@Stateless
public class StateBeanBean {
    @PersistenceContext
    EntityManager em;

    public List 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

PlanetMySQL Voting: Vote UP / Vote DOWN

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

Arun Gupta — Fri, 14 Aug 2009 10:00:00 +0000

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.

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.

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 getStates() {
        return emf.createEntityManager().createNamedQuery("States.findAll").getResultList();
    }
}

Here are the main characterisitcs of this class:

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.
The persistence unit created in TOTD #93 is injected using @PersistenceUnit annotation.
The POJO has one getter method that queries the database and return the list of all the states.

In the generated file "template-client.xhtml", change the "head" template to:

Show States

and "body" template to:

value expression

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

PlanetMySQL Voting: Vote UP / Vote DOWN

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

Arun Gupta — Thu, 13 Aug 2009 10:00:00 +0000

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.

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.

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

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.

Download NetBeans 6.8 M1 and install "All" version. Expand "Servers" node and add the recently installed GlassFish server.
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.
Create the Persistence Unit

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:
Select "STATES" table in "Available Tables:" and click on "Add >" and then "Next >".
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:
Enter the package name as "server" and click on "Finish".

Create a Servlet to retrieve and display all the information from the database

Right click on the project, "New", "Servlet ...".
Give the Servlet name "ShowStates" and package "server".
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.
Inject the Persistence Unit as:

@PersistenceUnit
EntityManagerFactory emf;

right above "processRequest" method.

Change the "try" block of "processRequest" method to:

            List list = emf.createEntityManager().createNamedQuery("States.findAll").getResultList();
            out.println("");
            for (States state : list) {
                out.println("");
            }
            out.println("

" + state.getAbbrev() +
"

" + state.getName() +
"

");

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

Run the project

Right click on the project, select "Properties" and change the "Relative URL" to "/ShowStates". This is the exact URL that you specified earlier.
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
PlanetMySQL Voting: Vote UP / Vote DOWN