This example application
demonstrates Oracle's support for the EJB
3.0 JPA specification using an Entity and
further demonstrates the use of the container-managed EntityManager API from web container. It provides an example of using the new EJB 3.0 entity
from a Web application. It pacakges the entity in the web module in a jar file in WEB-INF/lib directory
In EJB 3.0, development is greatly simplified due to the following specifications:
The bean class can be a plain java class (POJO)
No interfaces are required for an entity bean
Annotations are used for O-R Mapping
This demonstration uses the Employee entity to demonstrate a entity bean using EJB 3.0.
Entity
example using EJB 3.0
The bean class
is a plain java class that is annotated with @Entity to mark it as an entity.
@Entity
@Table(name = "EMP")
public class Employee implements java.io.Serializable
{
private int empNo;
private String eName;
private double sal;
@Id
@Column(name="EMPNO")
public int getEmpNo()
{
return empNo;
}
..
}
The @Table annotation
is used to specify the table name to be used by this Entity bean.
The @Id annotation is used to mark the empNo field
as the primary key of the entity bean.
The @Column annotation is used to specify that
the empNo field is mapped to the EMPNO column in the table.
Using EntityManager API from Web Module
The javax.persistence.EntityManager API is used for creating,
finding and updating entity bean instances. Oracle
Application Server 10g 10.1.3.1 does allow you to grab an instance of EntityManager from a
web
module
using following three ways:
A container-managed using PersistenceContext dependency injection. This is not recommended because EntityManager is not guaranteed to be thread-safe in nature. However Oracle's implementation of EntityManager is thread-safe is nature.
A container-managed EntityManager using JNDI lookup. You have define the reference to the persistence context either using PersistenceContext annotation or persistence-context-ref in web.xml
An application-managed entity manager by injecting an instance of PersistenceUnit and then creating an EntityManager by using the createEntityManager() method.
The EntityManager API is required to
be used within a transaction, so the web module must manually demarcate
the transaction using the UserTransaction API.
In this example,
the InsertServlet looks up the EntityManager instance
and then persists entity instance as follows:
@PersistenceContext(name="howto/EntityManager",unitName="howto") public class InsertServlet extends HttpServlet {
..
ut = (UserTransaction)initCtx.lookup("java:comp/UserTransaction"); ut.begin();
Context context = new InitialContext();
Employee employee = new Employee();
employee.setEmpNo(empId);
employee.setEname(name);
employee.setSal(sal); EntityManager em = (EntityManager)context.lookup("java:comp/howto/EntityManager"); em.persist(employee); ut.commit();
..}
Web modules can lookup the EntityManager using the JNDI binding of java:comp/ejb/<persistence-context-ref-name>
Prerequisites
What you need to know
In order to complete the example application, you should
be familiar with the following:
EJB 2.1
EJB 3.0
For further information on EJB 3.0, see the following
documents on OTN:
etc - all necessary files to package the application
lib - holds the application archives that could be deployed
script - contains SQL script to create a table
doc - the How-to document and Javadoc's
javadoc - the javadoc of the different source files
how-to-ejb30-emAPIfromweb.html - this How-to page
src - the source of the demo
ejb - contains the sample entity bean code
web- contains application
2. Configure the Environment
Ensure
the following environment variables are defined:
%ORACLE_HOME% - The directory where you installed OC4J.
%JAVA_HOME% - The directory where you installed
the J2SE 5.0
%PATH% - includes %ORACLE_HOME% /ant/bin
Configure Database
This example is based on the EMP table from the SCOTT schema in an Oracle database. If you do not have SCOTT schema installed in your Oracle database, or are using a database other than Oracle, then the table will be automatically created during deployment of your applications because automatic table creation is switched. You can also manually create the table usingthe table.sql script in the %HOWTO_HOME%/scripts directory.
Configure Data Source
This example requires a DataSource to be configured to connect to the database
that contains the EMP table.
For OC4J, you must configure a datasource in the %ORACLE_HOME%/j2ee/home/config/data-sources.xml file
and point it at the schema that owns the EMP table.
Start OC4J stand alone using the following command after you make the above changes.
>%ORACLE_HOME%/bin/oc4j -start
If you are using an OracleAS managed install, start using the following command after you make the above changes.
> %ORACLE_HOME%/opmn/bin/opmnctl startall
4. Generate, Compile, and Deploy the Application
Ant 1.6.2 is shipped with OC4J and you have to set your PATH environment variable to $ORACLE_HOME/ant/bin. On some operating systems, Ant does not currently support the use of environment variables. If this is the case for your operating system, please modify the ant-oracle.xml file located in the %HOWTO_HOME% directory.
Edit ant-oracle.properties (in the demodirectory) and ensure the following properties are set to the correct values, as indicated below for OC4J standalone:
oc4j.host: host where OC4J is running (default localhost)
oc4j.admin.port: RMI port number (default 23791)
oc4j.admin.user: admin user name (default oc4jadmin)
oc4j.admin.password: admin user password (default welcome)
oc4j.binding.module: website name where deployed web modules are bound (default http-web-site)
If you are using OracleAS managed install then you have appropriately change the following properties beside changing oc4j.admin.user and oc4j.admin.password for your managed OC4J instance in OracleAS install.
opmn.host: the hostname/IP where OracleAS is running (default localhost)
opmn.port: OPMN request port (default 6003) for the OracleAS install
oc4j.instance: admin user name (default oc4jadmin)
You have to uncomment appropriate deployer.uri in the ant-oracle.properties based on your environment i.e. a single instance OC4J or a clustered OC4J instance/group managed by OPMN.
To build the application, type the following command
from the %HOWTO_HOME% directory:
>ant
You should now have the newly created ejb30entity.ear in your
%HOWTO_HOME%/lib directory.
This command will attempt to deploy the application archive if the build is
successful. It will first test whether OC4J is running before attempting the
deployment operation.
Note that you can also deploy the application
separately .
Ensure the %ORACLE_HOME% environment variable is defined,
and from the %HOWTO_HOME%
directory, type the command:
>ant deploy
5. Run
the Application
Run
the sample by providing invoking the following URL from your favorite browser:
http://localhost:8888/ejb30EMfromweb
In this page, enter employee no, Name and Salary and then click on Add Employee button.
The InsertServlet will be invoked that will try to create
the bean instance using EntityManager API.
You will be redirected
to a success page if your record was inserted successfully. You can also
check the database table to ensure the record was created.
Summary
In this document, you should have learned how to:
Develop a simple Entity bean using EJB
3.0
Use the EntityManager API from a web module
Deploy an execute the simple Entity bean using Oracle Application
Server 10g 10.1.3.1
Bookmark
