A few weeks ago an article appeared in the Netbeans Knowledge Base
about how to get started with GlassFish V2, Maven2 and Netbeans 6.0. It
is a great article doing exactly what the title says: getting you
started with Maven2 in Netbeans 6.0 and deploying the project thus
created to GlassFish V2. Despite the fact that I couldn’t get a few
steps to work correctly, I was able to connect to the Remote Session
Bean from my client app and see the log message appear in the GlassFish
log.
After having completed the instructions in the article I
felt I wanted to do a bit more. Over the past year or so I have been
developing a few small Enterprise Applications. These are applications
containing an EJB jar file and a war file packed in and deployed
through an ear file. The EJB jar contains Entities and Session Beans
and the classes in the war file make use of the (Local) Session Beans
to allow users of the web application to manage data. This article
describes the steps you need to take to create such an application with
Netbeans 6.0 (Beta 2) and Maven2.
Installing the software
To follow the steps in this article you’ll need Netbeans 6.0 and a database. Netbeans 6.0 Beta 2 can be downloaded from this link.
The "Web & Java EE" download is sufficient for the purposes of this
article since it contains the GlassFish V2 application server. If you
choose to download another variant, please make sure to install
GlassFish V2 and register your GlassFish installation with Netbeans.
GlassFish can be downloaded here.
Besides
that, you’ll need a database with a JDBC 3 compliant driver. I used
Oracle XE but any other database should do. Make sure to create a JDBC
Connection Pool and a JDBC Resource to your database so you can use it
in the Enterprise Application. For instructions on how to create a
Connection Pool and a JDBC Resource for an Oracle database, please
refer to this article of mine. The instructions in that article are for GlassFish V1 but the steps in V2 are similar.
After
having installed Netbeans, make sure the MevenIDE plugin is downloaded
and installed into Netbeans. To do so, start Netbeans and go to Tools
-> Plugins. The second tab of the frame that pops up should list
Maven under the Java Category. Select it and click the Install button
to the lower left. That’s it, you’re all set up now.
Defining the project layout
Our
application needs to contain three projects. One project will hold the
EJB content, one project the war content and one project will create
the ear file. Since these three projects will share some configuration
settings for Maven it makes sence to put all of them in a parent pom
project. this means that our application will contain this structure
Parent Pom Project
|
|— EJB Project
|
|— WAR Project
/
— EAR Project
Let’s have a look at how to create all of these projects.
The Parent POM project
To
create the parent pom project, select File -. New Project and select
Maven in the list to the left of the frame that pops up. Select Maven
Project to the right and click the Next button.
In the next frame, select the "Maven Quickstart Archetype" archetype and click the Next button.
In
the third frame specify the Project Name, Project Location, Group Id,
Version and Package. For now, the version and package don’t matter
much. But it’s nice to have some meaningful name like
"MavenEnterpriseApplication" and a meaningful Group Id like
"nl.amis.maven.enterprise".
Now
we’ll have to edit the pom.xml file by hand to make it suit our needs.
Some of the properties can be edited by right clicking the project name
and selecting properties. These properties can also directly be edited
by opening the pom.xml file and modifying the XML. Using the built in
editor saves us a lot of typing, so right click the
MavenEnterpriseApplication project name and select Properties. Since
this is our parent project that we’ll only use for general Maven
configuration purposes, we need to change the packaging from jar to pom.
Next,
select the Source category and set the Source/Binary format to 1.5.
Click OK to exit the editor and save the changes you made. Most of the
other changes we need can be made without actually editing the pom.xml
file. First of all, by default Maven creates one source class and one
test class in every project that is created. We won’t need those in
this project. Go to the Files window right of the Projects window (if
it’s not visible select the Windows menu item and then Files) and
expand the project. Select the src directory and hit the Delete button.
Next return to the Projects window.
By default Maven also generates
a JUnit dependency and we won’t need that either. so expand the Test
Libraries node, right click the junit-3.8.1.jar library and select
Remove Dependency. That’s it for now.
The EJB Project
Next
we’ll create the EJB Project. To do so, follow the same three steps as
when creating the new Parent POM Project. This time make sure the
Project Location is the root directory of the Parent POM Project. This
will make Maven recognise it as a sub-module managing the necessary
changes to the pom.xml files of both the parent and the sub-module. I
chose these settings for the EJB module:
Project Name: MavenEnterpriseApplication-ejb
Project Location: /home/wouter/NetBeansProjects/MavenEnterpriseApplication
Group Id: nl.amis.maven.enterprise
Package: nl.amis.maven.enterprise
The
package I specified is the same as the package I specified for the
Parent POM Project. Note that the Parent POM Project pom.xml file was
modified to now include a reference to the EJB module:
<modules>
<module>MavenEnterpriseApplication-ejb</module>
</modules>
The EJB module pom.xml file was created with a reference to the Parent POM Project:
<parent>
<artifactId>MavenEnterpriseApplication</artifactId>
<groupId>nl.amis.maven.enterprise</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
Right
click the MavenEnterpriseApplication-ejb project and select Properties.
This time change the packaging to "ejb". After clicking OK to save the
changes and reopening the Properties editor it is also possible to open
the Run Category and select the GlassFish V2 application server. Please
do NOT do this! It will generate errors in the Netbeans project. If you
do so and encounter problems, please remove the profile.xml file from
the MavenEnterpriseApplication-ejb project. Next, remove these lines
from the pom.xml file:
<properties>
<netbeans.hint.deploy.server>J2EE</netbeans.hint.deploy.server>
</properties>
Finally,
you need to tell Maven to make use of the version 3.0 EJB Maven plugin.
This can be done by adding these lines to the pom.xml file by hand
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-ejb-plugin</artifactId>
<configuration>
<ejbVersion>3.0</ejbVersion>
</configuration>
</plugin>
</plugins>
</build>
Let’s
create our Entities and Session Beans now. Since we didn’t connect our
EJB project to the GlassFish application server, and doing so causes
errors, we will need to use a Netbeans local database connection to
generate the beans. Later on, before deploying our project, we will
need to make adjustments to the Persistence Unit persistence.xml file
so our deployed application makes use of the datasource we defined in
Glassfish. But first things first.
Creating the beans
If
you haven’t created a database connection in Netbeans yet, this would
be a good time to do it. If you don’t Netbeans will prompt you for it
later. However, for most databases you need to register your JDBC
driver first and you won’t be able to do it when Netbeans prompts you
for a database connection. After having created the database
connection, right click the MavenEnterpriseApplication-ejb project and
select New -> Entity Classes From Database. In the wizard that pops
up, select your database connection and then select the tables you want
to create Entities for. Since I am using Oracle XE I have created a
database connection to the HR schema. Therefore I selected all tables
in the HR schema.
After
clicking next you get the chance to rename the Entity classes to your
liking and specify the package in which they will be created. More
importantly, here is where you can create a Persistence Unit. Click the
"Create Persistence Unit" button and give the Unit a more sensible
name, e.g. "MavenEnterpriseApplication-ejbPU". Finish creating the
Persistence Unit and Entities.
Besides the new Entity classes and
Persistence Unit, some changes have been made to the pom.xml file as
well. Since the Entity classes make use of the Toplink Essentials
classes, the dependencies on the toplink jars have been resolved for
us. This has been done in two ways. First of all, a reference to the java.net Maven Repository
has been added. Second, the depenency entries for toplink-essentials
and toplink-essentials-agent have been added to the pom.xml file. Since
our web project will need access to the java.net repository as well, it
is wise to move the repository reference from the EJB pom.xml to the
Parent POM pom.xml file. Besides that, we need to tell Maven not to
include the jar files for Toplink Essentials in the EJB jar file. You
need to do this by adding this line to each dependency in the pom.xml
file
<scope>provided</scope>
Since
the app I am creating for this article only is a simple one, I am only
going to modify one Entity class to contain an additional NamedQuery.
In the Employees Entity I am adding this NamedQuery which returns a
list of all available Employees
@NamedQuery(name = "Employees.getAll", query = "SELECT e FROM Employees e")
Next
create a Local Session Bean by right clicking the
MavenEnterpriseApplication-ejb project and selecting New -> Session
Bean. Provide a name for your session bean, e.g. Data, and a package,
e.g. nl.amis.maven.enterprise.ejb.session. Leave the defaults
(Stateless and Local) be. Clicking the Finish button will generate an
error in Netbeans. The new session bean will have the @Local and
@Stateless annotations and Maven is unable to resolve them. In my case
the session bean wizard even doesn’t close so I closed it by clicking
the Cancel button. Fortunately this doesn’t remove the session bean!
The
problem is that the two annotations are provided by the ejb-api.jar
file which Maven doesn’t know of. So we need to add a dependency to
that jar file by adding these lines to the EJB pom.xml file
<dependency>
<groupId>javax.ejb</groupId>
<artifactId>ejb-api</artifactId>
<version>3.0</version>
<scope>provided</scope>
</dependency>
Next add this mehtod definition to the DataLocal interface:
public int countEmployees();
and this EntityManager injection and method implementation to the DataBean class
@PersistenceContext EntityManager em;
public int countEmployees() {
return em.createNamedQuery("Employees.getAll").getResultList().size();
}
That completes the EJB project!
The WAR Project
For
this article, we will a simple Servlet which uses the DataLocal bean
that displays the number of Employees in your browser. First, create a
new Project. This time, don’t create a Maven Quickstart Archetype
project, but a Maven Webapp Archetype. I used these settings for it
Project Name: MavenEnterpriseApplication-war
Project Location: /home/wouter/NetBeansProjects/MavenEnterpriseApplication
Group Id: nl.amis.maven.enterprise
Package: nl.amis.maven.enterprise
Inspect
the project properties and make sure this time the packaging is set to
war. In order to get a proper WAR file a few modifications need to be
made to the pom.xml file. First of all, these lines need to be added
inside the <build> tag
<plugins>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
This
will make sure a Class-Path line will be added to the MANIFEST.MF file.
Next we need to add dependencies for our EJB project, the ejb-api.jar
and the servlet-api.jar by adding these lines to the pom.xml file in
the same section as the junit dependency
<dependency>
<groupId>nl.amis.maven.enterprise</groupId>
<artifactId>MavenEnterpriseApplication-ejb</artifactId>
<version>1.0-SNAPSHOT</version>
<optional>true</optional>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.ejb</groupId>
<artifactId>ejb-api</artifactId>
<version>3.0</version>
<scope>provided</scope>
</dependency>
The
<optional> tag in the MavenEnterpriseApplication-ejb dependency
will make sure that the Class-Path line in the MANIFEST.MF file will
contain the MavenEnterpriseApplication-ejb.jar file which is needed for
the Enterprise Containier of GlassFish to inject the DataLocal instance
in the servlet that we are about to create. Before we can do that,
however, we first need to resolve some conflicts that we have
introduced. Maven is not able to resolve the
MavenEnterpriseApplication-ejb dependency since we haven’t built any
code yet. Everything will work fine once we build the Parent POM
Project, but for now Netbeans cannot resolve the classes in the
MavenEnterpriseApplication-ejb project when we use them in the WAR
Project. So, right click the MavenEnterpriseApplication project and
select build. This may take a while since Maven will probably need to
download quite a buch of jar files.
Besides modifying the pom.xml
file, the web.xml file that was created also needs to be modified.
Maven creates a web.xml file that GlassFish won’t like. The first three
lines of the web.xml file (that are the lines up to and including the
line with the <web-app> tag) need to be replaced by these lines
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
Once
the build process has finished create a new servlet by right clikcing
the MavenEnterpriseApplication-war project and selecting New ->
Servlet. Give it a name, e.g. DataServlet, and specify a package, e.g.
nl.amis.maven.enterprise.web.servlets. Keep all the other default. Now,
inject your DataLocal bean and call the countEmployees method like this
@EJB DataLocal dataLocal;
/**
* Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
* @param request servlet request
* @param response servlet response
*/
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
out.println("Number of Employees in table is " + dataLocal.countEmployees());
} finally {
out.close();
}
}
The EAR Project
the
final project we need is the one that will create the ear file using
the MavenEnterpriseApplication-ejb and MavenEnterpriseApplication-war
projects. First create a new Maven Quickstart Archetype project. I used
these settings:
Project Name: MavenEnterpriseApplication-ear
Project Location: /home/wouter/NetBeansProjects/MavenEnterpriseApplication
Group Id: nl.amis.maven.enterprise
Package: nl.amis.maven.enterprise
Modify the project properties and set the Packaging to ear. Remove src
directory by going to the Files window and deleting the src directory
(duh). Remove the junit Test Library from the Projects window. Finally,
add the dependencies on the MavenEnterpriseApplication-ejb and
MavenEnterpriseApplication-war projects like this
<dependency>
<groupId>nl.amis.maven.enterprise</groupId>
<artifactId>MavenEnterpriseApplication-ejb</artifactId>
<version>1.0-SNAPSHOT</version>
<type>ejb</type>
</dependency>
<dependency>
<groupId>nl.amis.maven.enterprise</groupId>
<artifactId>MavenEnterpriseApplication-war</artifactId>
<version>1.0-SNAPSHOT</version>
<type>war</type>
</dependency>
Building the Parent POM Project should now be succesfull:
------------------------------------------------------------------------
Reactor Summary:
————————————————————————
MavenEnterpriseApplication ………………………. SUCCESS [2.374s]
MavenEnterpriseApplication-ejb …………………… SUCCESS [1.263s]
MavenEnterpriseApplication-war Maven Webapp ……….. SUCCESS [1.155s]
MavenEnterpriseApplication-ear …………………… SUCCESS [1.664s]
————————————————————————
————————————————————————
BUILD SUCCESSFUL
————————————————————————
Solving deployment issues
Now
that the project can succesfully be built, it is time to deploy the ear
file to GlassFish V2. For now use the asadmin utility that is shipped
with Glassfish V2. I am sure there is a way to deploy to GlassFish via
Maven but I haven’t found out how to do this yet. The asadmin utility
can be found in the bin directory under the directory in which
GlassFish was installed by you. On my Linux system that is
glassfish-v2-b58g/bin but you may need to look in C:/glassfish-v2-b58g
or perhaps C:/Program Files/glassfish-v2-b58g if you are on Windows. By
the way, on Windows the asadmin utility is called asadmin.bat.
To deploy the ear file, open a console and CD to the bin directory holding the asadmin utility. then issue this command
./asadmin deploy --user=admin <path to ear file>
or if you’re on Windows
asadmin.bat deploy --user=admin <path to ear file>
where
the ".bat" part in the command is optinal. Here <path to ear
file> is the path to the ear file which can be found in the target
directory of your ear project. In my case I issued this command
./asadmin deploy --user=admin ./MavenEnterpriseApplication-ear/target/MavenEnterpriseApplication-ear-1.0-SNAPSHOT.ear
the server responds with this error
CLI171 Command deploy failed : Deploying application in domain failed; The persistence-context-
ref-name [nl.amis.maven.enterprise.ejb.session.DataBean/em] in module [] resolves to a
persistence unit called [MavenEnterpriseApplication-ejbPU] which is of type RESOURCE_LOCAL.
Only persistence units with transaction type JTA can be used as a container managed entity manager.
Please verify your application.
Remember
what I said about the Persistence Unit and that creating it will make
it use a Netbeans local database connection? Well, GlassFish doesn’t
buy that. You need to use a JDBC datasource. So it’s time to modify the
Persistence Unit persistence.xml file, rebuild our project and try and
deploy it again.
All the way at the beginning of this article I
asked you to create a JDBC datasource in Glassfish. The one I created
is called jdbc/hr and I will mdoify my persistence.xml file to use
that. The file can be found in the EJB project under Other Sources
-> resources -> META-INF and mine now looks like this
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
<persistence-unit name="MavenEnterpriseApplication-ejbPU" transaction-type="JTA">
<jta-data-source>jdbc/hr</jta-data-source>
<properties/>
</persistence-unit>
</persistence>
Next rebuild the Parent POM Project and issue the asadmin command again. This time GlassFish should answer with
Command deploy executed successfully.
Browsing to the correct URL, in my case http://localhost:8280/MavenEnterpriseApplication-war/DataServlet
should reveal how many Employees are present in our EMPLOYEES table:
Number of Employees in table is 107
Please
note that using the Entity wizard again will modify the
persisntence.xml file so you need to change this file again afterwards.
Conclusion
The
Maven support in Netbeans definately has made a great leap forward with
the Netbeans 6.0 version. Despite that, there still are some issues
that need to be addressed. Having the possibility to connect a Maven
enabled project to the GlassFish application server, or simply being
able to use JEE 5 instead of J2EE 1.4, would be great. The discussions
at the MevenIDE user mailinglist at codehaus.org
show that Milos Kleint and his contributors are working on this.
Besides that, full integration of Maven into Netbeans and having the
possibility to have any kind of Netbeans project be Maven enabled would
be very neat. MevenIDE isn’t there yet, but the future looks promising.
I hope this article is "inviting and inciting you to rise" the Maven
ladder.
转自：http://technology.amis.nl/blog/?p=2489