![]() |
Home > Apache Geronimo v2.0 > Documentation > Sample applications > Using JNDI in Geronimo 2.0 |
Java Naming and Directory Interface (JNDI) is an interface to connection pools in the Apache Geronimo application server. Through this interface, developers have access to all Java objects, including Enterprise Java Beans (EJBs).
The following article provides concept-rich documentation on how to use JNDI
to access connection pools for data sources, Java Messaging Services (JMS), mail
sessions, and URL connections: Apache Geronimo JNDI naming and Java resource
connection pools, Part 1: Data source connections. URL: http://www-128.ibm.com/developerworks/opensource/library/os-ag-jndi1
However, the mentioned article is written for Geronimo 1.x. This sample tutorial will demonstrate something similar but using EJB 3.0.
The CustomerService application will make use of EJBs to access a database and spit it back to the screen. The point of this sample is to show that you can use JNDI to access an EJB. The overview of the structural content of the EAR file is given in the following example:
|-CustomerService-ear-2.0-SNAPSHOT.ear |-CustomerService-ejb-2.0-SNAPHOST.jar |-META-INF |-persistence.xml |-openejb-jar.xml |-CustomerService-war-2.0-SNAPSHOT.war |-WEB-INF |-web.xml |-geronimo-web.xml |-META-INF |-application.xml |-geronimo.application.xml
persistence.xml references certain Entity Beans and maps them to use certain database pools. In this case, the entity bean Customer is using the database pool CustomerServicePool.
<?xml version="1.0" encoding="UTF-8"?> <persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.0" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"> <persistence-unit name="CustomerPU"> <description>Entity Beans for Customer</description> <provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider> <class>com.service.customer.ejb.Customer</class> <properties> <property name="openjpa.jdbc.SynchronizeMappings" value="false"/> </properties> <jta-data-source>CustomerServicePool</jta-data-source> <non-jta-data-source>CustomerServicePool</non-jta-data-source> </persistence-unit> </persistence>
openejb-jar.xml is here because we are using OpenEJB. Nothing special is really defined in this file because we do not have any defined MDBs.
<?xml version="1.0" encoding="UTF-8"?> <openejb-jar xmlns="http://www.openejb.org/xml/ns/openejb-jar-2.1" xmlns:naming="http://geronimo.apache.org/xml/ns/naming-1.1" xmlns:security="http://geronimo.apache.org/xml/ns/security-1.1" xmlns:dep="http://geronimo.apache.org/xml/ns/deployment-1.2"> <dep:environment> <dep:moduleId> <dep:groupId>default</dep:groupId> <dep:artifactId>ProcessCustomerSession</dep:artifactId> <dep:version>1.0</dep:version> <dep:type>jar</dep:type> </dep:moduleId> <dep:dependencies> </dep:dependencies> <dep:hidden-classes/> <dep:non-overridable-classes/> </dep:environment> </openejb-jar>
web.xml references the EJB that was created in ProcessCustomerSessionBean.java. By doing this we are allowing the contents inside the WAR to use this EJB.
<?xml version="1.0" encoding="ISO-8859-1"?> <web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4"> <welcome-file-list> <welcome-file>index.html</welcome-file> </welcome-file-list> <ejb-local-ref> <ejb-ref-name>ejb/ProcessCustomerSessionBean</ejb-ref-name> <ejb-ref-type>Session</ejb-ref-type> <local>com.service.customer.ejb.ProcessCustomerSessionLocal</local> </ejb-local-ref> </web-app>
geronimo-application.xml specifies the module's information and the context-root in which this web application resides. Additionally, it specifies the database pool plan that we want to create while deploying along with the connector that is needed to deploy this plan into Geronimo.
<application xmlns="http://geronimo.apache.org/xml/ns/j2ee/application-1.1"> <dep:environment xmlns:dep="http://geronimo.apache.org/xml/ns/deployment-1.1"> <dep:moduleId> <dep:groupId>default</dep:groupId> <dep:artifactId>CustomerService</dep:artifactId> <dep:version>1.0</dep:version> <dep:type>ear</dep:type> </dep:moduleId> <dep:dependencies/> <dep:hidden-classes/> <dep:non-overridable-classes/> </dep:environment> <module> <connector>tranql-connector-ra-1.3.rar</connector> <alt-dd>CustomerServicePool.xml</alt-dd> </module> </application>
application.xml specifies a connector in which the EAR will use when trying to deploy the embedded database pool (CustomerServicePool.xml).
<?xml version="1.0" encoding="UTF-8"?> <application 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/application_5.xsd" version="5"> <description>Geronimo Sample EAR for CustomerService</description> <display-name>Geronimo Sample EAR for CustomerService</display-name> <module> <ejb>CustomerService-ejb-2.0-SNAPSHOT.jar</ejb> </module> <module> <web> <web-uri>CustomerService-war-2.0-SNAPSHOT.war</web-uri> <context-root>/CustomerService</context-root> </web> </module> <module> <connector>tranql-connector-ra-1.3.rar</connector> </module> </application>
CustomerServiceJavaBean.java uses JNDI to look up the ProcessCustomerSessionBean EJB.
// CustomerServiceJavaBean.java package com.service.customer.web; import com.service.customer.ejb.Customer; import com.service.customer.ejb.ProcessCustomerSessionLocal; import java.util.Locale; import java.util.ResourceBundle; import java.util.List; import javax.naming.InitialContext; public class CustomerServiceJavaBean { private ProcessCustomerSessionLocal process = null; private ResourceBundle bundle = null; private String JNDI_PROCESS_EJB = null; private String action = ""; private String customerID = ""; private String fullName = ""; private String emailAddress = ""; private String interests = ""; public CustomerServiceJavaBean() { InitialContext initial = null; bundle = ResourceBundle.getBundle("customer", Locale.getDefault(), CustomerServiceJavaBean.class.getClassLoader()); JNDI_PROCESS_EJB = bundle.getString("jndi.process.ejb"); try { initial = new InitialContext(); process = (ProcessCustomerSessionLocal) initial.lookup(JNDI_PROCESS_EJB.trim()); System.out.println("Successful looking up: '" + JNDI_PROCESS_EJB.trim() + "'"); } // end try catch (Exception e) { e.printStackTrace(); } // end catch } // end CustomerServiceJavaBean public List<Customer> getAllCustomers() { List<Customer> customerList = null; try { customerList = process.findAllCustomers(); } // end try catch (Exception e) { customerList = null; e.printStackTrace(); } // end catch return customerList; } // end getAllCustomerss } // end CustomerServiceJavaBean
ProcessCustomerSessionBean.java implements ProcessCustomerSessionLocal by grabbing an EntityManagerFactory by making use of the persistence.xml. It grabs it by using the @PersistenceUnit annotation. Since there is only one persistence unit defined in persistence.xml, we do not need to specify any additional parameters in the annotation.
package com.service.customer.ejb; import java.rmi.RemoteException; import java.util.Collection; import java.util.Iterator; import java.util.List; import javax.persistence.PersistenceUnit; import javax.ejb.EJBException; import javax.ejb.Stateless; import javax.naming.Context; import javax.naming.InitialContext; import javax.naming.NamingException; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; @Stateless public class ProcessCustomerSessionBean implements ProcessCustomerSessionLocal { @PersistenceUnit protected EntityManagerFactory emf; public ProcessCustomerSessionBean() { } public List<Customer> findAllCustomers() { EntityManager em = emf.createEntityManager(); String query = "SELECT * FROM customer"; List<Customer> customerList = (List<Customer>)em.createNativeQuery(query, Customer.class).getResultList(); em.close(); return customerList; } public Customer findCustomer(String key) { EntityManager em = emf.createEntityManager(); String query = "SELECT * FROM customer WHERE id='"+key+"'"; List<Customer> customerList = (List<Customer>)em.createNativeQuery(query, Customer.class).getResultList(); if(customerList.size() == 1) { return (Customer)customerList.get(0); } else { return null; } } }
ProcessCustomerSessionLocal.java defines the business methods that is associated with this bean.
package com.service.customer.ejb; import com.service.customer.ejb.Customer; public interface ProcessCustomerSessionLocal { public java.util.List<Customer> findAllCustomers(); public Customer findCustomer(String key); }
Customer.java is the entity bean that represents the Customer table in the database. By using @Entity, @Table(name = "customer"), and @Id it tells OpenEJB that this is an entity bean, which is representative of the table "customer" and has "customerId" as the primary key. By using these annotations no other configuration is needed inside openejb-jar.xml (no ejb-jar.xml is needed at all).
package com.service.customer.ejb; import java.io.Serializable; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.Table; @Entity @Table(name = "customer") public class Customer implements Serializable { private String customerId; private String fullName; private String emailAddress; private String interests; public Customer() { } public Customer(String customerId, String fullName, String emailAddress, String interests) { this.customerId = customerId; this.fullName = fullName; this.emailAddress = emailAddress; this.interests = interests; } @Id public String getCustomerId() { return customerId; } public String getFullName() { return fullName; } public String getEmailAddress() { return emailAddress; } public String getInterests() { return interests; } public void setCustomerId(String customerId) { this.customerId = customerId; } public void setFullName(String fullName) { this.fullName = fullName; } public void setEmailAddress(String emailAddress) { this.emailAddress = emailAddress; } public void setInterests(String interests) { this.interests = interests; } } // end Customer
The database that will be used to demonstrate this application is the built-in Derby database. The name of the database will be CustomerDB and it consists of one table:
Table Name | Fields |
---|---|
CUSTOMER | customerId (PRIMARY
KEY) fullname emailaddress interests |
The CUSTOMER table stores information about one customer.
The tools used for developing and building the Banking applications are:
Apache Derby, an Apache DB subproject, is a relational database implemented
in Java. Its footprint is so small you can easily embed it in any Java-based
solution. In addition to its embedded framework, Derby supports a more familiar
client/server framework with the Derby Network Server.
http://db.apache.org/derby/index.html
Maven is a popular open source build tool for enterprise Java projects,
designed to take much of the hard work out of the build process. Maven uses a
declarative approach, where the project structure and contents are described,
rather than the task-based approach used in Ant or in traditional make files,
for example. This helps enforce company-wide development standards and reduces
the time needed to write and maintain build scripts. The declarative,
lifecycle-based approach used by Maven 1 is, for many, a radical departure from
more traditional build techniques, and Maven 2 goes even further in this regard.
Maven 2 can be download from the following URL:
http://maven.apache.org
Download the CustomerService application from the following
link:
CustomerService
After decompressing the given file, the CustomerService directory will be created.
Configuration of the application consists of creating the database and defining the connection pool to access it.
After starting Apache Geronimo log into the console and follow the given steps to create CustomerDB.
Use a command prompt to navigate into the CustomerService directory and just give mvn clean install site command to build. It will create the CustomerService-ear-2.0-SNAPSHOT.ear under the CustomerService folder. Now, you are ready to deploy bank application in the Geronimo Application server.
Deploying sample application is pretty straight forward as we are going to use the Geronimo Console.
To test the sample web application open and browse and type http://localhost:8080/service. It will forward you to the index
page of the application which has a direct link to view the Customers.