Introduction
In the first part, Eclipse, and JBoss were tested
by building a web application and a stateless EJB. In this section
an entity EJB is created to test the database connectivity. Once
this section has been completed, the infrastructure is known to
be complete and functioning.
The source code for parts one and two of the installation
tests can be downloaded as a zip archive from here.
Create Database Tables
A terminal window is opened, and mySQL command tool
started on the same host as the mysql server.
Note: It
is possible to access the server remotely. On Linux systems
remote access for the mysql root user may not be enabled by default,
as it poses a security risk.
Below is a sample session using the mysql command
line tool. It is used to create a database called "shoestring".
A new user called "user" with a password value of "password" is
assigned to the shoestring database, with all privileges. Later
on the new user can connect to mysql locally, or remotely, to create
tables and add or delete data, in the shoestring database.
prompt> mysql -u root -p
Enter password: ********
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 5 to server version: 5.0.18-standard
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql> create database shoestring;
Query OK, 1 row affected (0.00 sec)
mysql> grant all privileges on shoestring.* to user identified by 'password';
Query OK, 0 rows affected (0.00 sec)
mysql> flush privileges;
Query OK, 0 rows affected (0.02 sec)
mysql> select user, password, host from mysql.user where user='user';
+------+-------------------------------------------+------+
| user | password | host |
+------+-------------------------------------------+------+
| user | *2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19 | % |
+------+-------------------------------------------+------+
1 row in set (0.02 sec)
mysql> quit
Bye
Now that the new database and user is created. All operations on the
database can be carried out using the username 'user'. This includes
launching the mysql command line tool. The command tool can be
launched with the -h hostname command line parameter if the server
is not running on the same machine as the command line tool.
A script file is created called "createTestTable.sql".
The contents are shown below, note that it deletes
any existing database called shoestring:
DROP DATABASE IF EXISTS `shoestring`;
CREATE DATABASE `shoestring`;
USE `shoestring`;
CREATE TABLE `Address` (
`id` int(10) unsigned NOT NULL auto_increment,
`line1` varchar(255) default NULL,
`line2` varchar(255) default NULL,
`line3` varchar(255) default NULL,
`line4` varchar(255) default NULL,
`country` varchar(150) default NULL,
`postcode` varchar(50) default NULL,
PRIMARY KEY (`id`)
);
CREATE TABLE `Person` (
`firstName` varchar(255) default NULL,
`lastName` varchar(255) default NULL,
`addressId` int(10) unsigned default NULL,
`title` varchar(45) default NULL,
`gender` varchar(20) default NULL,
`dateOfBirth` datetime default NULL,
`suffix` varchar(45) default NULL,
`daytimePhone` varchar(45) default NULL,
`eveningPhone` varchar(45) default NULL,
`webSite` varchar(255) default NULL,
`maritalStatus` varchar(20) default NULL,
`id` int(10) unsigned NOT NULL auto_increment,
`password` varchar(64) NOT NULL,
`email` varchar(255) NOT NULL,
`localeLanguage` varchar(2) default NULL,
`localeCountry` varchar(2) default NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `FK_person_2` (`email`),
KEY `FK_person_1` (`addressId`)
);
ALTER TABLE `Person`
ADD FOREIGN KEY (`addressId`) REFERENCES `Address` (`id`);
The command line tool is launched to run the script file in mysql,
note that the user 'user' creates the table, not the mysql user
root:
prompt> mysql -u user -p < createTestTable.sql
Enter password: ********
prompt>
At this point, t he database, user and table are all created and working.
We can check this from mysql. By logging on as the user 'user',
the mysql system database is not visible. The shoestring database,
to which the user has access, is visible:
prompt> mysql -u user -p Enter password: ********
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 16 to server version: 5.0.18-standard
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| shoestring |
| test |
+--------------------+
2 rows in set (0.00 sec)
mysql> use shoestring;
Database changed
mysql> show tables;
+----------------------+
| Tables_in_shoestring |
+----------------------+
| Address |
| Person |
+----------------------+
1 row in set (0.00 sec)
mysql>
A test record is added to the Person table:
mysql> insert into Person (firstName, lastName, email)
values ('Fred', 'Marzo','marzo@mail.com');
Query OK, 1 row affected (0.00 sec)
mysql> select firstName, lastName, email from Person;
+-----------+----------+----------------+
| firstName | lastName | email |
+-----------+----------+----------------+
| Fred | Marzo | marzo@mail.com |
+-----------+----------+----------------+
1 row in set (0.00 sec)
mysql> quit
At this point, the database is ready, with test data. The next step
is to write some code to access the database.
Create An Entity EJB
In the Eclipse IDE's package explorer, com.j3ltd.test.ejbs
is right clicked to create a new class:

The class is called Person, that is the same as
the table in the database. It implements java.io.Serializable,
so that the data can be passed to a web application.
The Person.java entity looks like this:
package com.j3ltd.test.ejbs;
import javax.persistence.*;
@Entity
public class Person implements java.io.Serializable {
private int id;
private String email;
private String firstName;
private String lastName;
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
@Id
@GeneratedValue
public int getId() { return id; } public void setId(int id) { this.id = id; }
}
The class is annotated with @Entity to
denote that it is an entity bean. The get method for the id field
is annotated with @Id to denote
that id is the primary key in the table, id is also annotated
with @GeneratedValue to
denote that the key value is generated by the database.
That completes the entity EJB.
Use The Entity EJB
The entity EJB is used to get all the Person records
in the table. The Stateless EJB developed in part
one of this
article is used to get a list of Person records.
The interface TestStateless.java is updated with
a new method signature:
package com.j3ltd.test.ejbs;
import javax.ejb.Remote;
import java.util.*;
@Remote
public interface TestStateless {
public String testBean();
public List<Person> getAllPersons();
}
The implementation class TestStatelessBean
is updated to use the entity EJB Person to get all the records
in the database and to return the list:
package com.j3ltd.test.ejbs;
import java.util.*;
import javax.ejb.Stateless;
import javax.persistence.*;
public @Stateless class TestStatelessBean implements TestStateless {
@PersistenceContext(unitName="shoestringPU") private EntityManager em;
public String testBean() {
return "the server returned this string";
}
public List<Person> getAllPersons() {
ArrayList<Person> toReturn = new ArrayList();
Query q = em.createQuery("SELECT o FROM Person o");
for (Object po : q.getResultList()) {
toReturn.add((Person) po);
}
return toReturn;
}
}
Persistence.xml And The EntityManager
The EntityManager in the TestStatelessBean.java source (see previous
section), uses the name "shoestringPU" to
identify the persistence unit to use. This persistence unit is
defined in a new file called persistence.xml,
which is in the src folder of this project. The file's contents
are as follows:
<?xml version="1.0" encoding="UTF-8"?>
<persistence>
<persistence-unit name="shoestringPU">
<jta-data-source>java:/ShoestringDS</jta-data-source>
<properties>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
</properties>
</persistence-unit>
</persistence>
The persistence.xml file makes a link between the
persistence unit and the datasource. The datasource was created
and installed in JBoss during the installation section of this
article (see
here). The property hibernate.hbm2ddl.auto is
not specified in the <properties> section. Valid values for hibernate.hbm2ddl.auto are
create, create-drop and update. In this article, the database
tables are not maintained by hibernate, they are created manually.
The file persistence.xml must be packaged along with the EJB class
files. This is done by accessing the project properties, and
selecting the packaging section:

The TestInstallation.ejb3 package is selected and right clicked to
add the persistence.xml project file (which is in the src folder):
The Prefix entered is META-INF. This is the location within the archive
where persistence.xml should be placed.
Update The Servlet
The servlet is updated to get the list of Person
records and display them in the browser:
package com.j3ltd.test.web;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.naming.*;
import java.io.*;
import java.util.*;
import com.j3ltd.test.ejbs.*;
public class TestStatelessEJBServlet extends HttpServlet {
private TestStateless statelessBean;
public void init() throws ServletException {
try {
Context context = new InitialContext();
statelessBean = (TestStateless) context.lookup("TestStatelessBean/remote");
} catch (NamingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
doGet(req, resp);
}
public void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
PrintWriter writer = resp.getWriter();
writer.write("The stateless bean returned this string: " +
statelessBean.testBean() + "\n");
List<person> people = statelessBean.getAllPersons();
for (Person person : people) {
writer.write("Email retrieved: " + person.getEmail() + "\n");
}
}
}
That completes the coding. The files are all saved. And the packages
built:

JBoss is launched from Eclipse, in debug mode:
Once JBoss has started up, the packages are deployed:
A browser is started and the url http://localhost:8080/TestInstallation/testStatetelessEJB is
entered.
The browser displays the two test results performed by the servlet.
The second line clearly shows the database record.
This completes the installation tests. At this stage Linux, Eclipse,
JBoss, and MySQL are all working in harmony. The next
step is
to develop a realistic project that makes use of all the components
installed and tested so far.
|