- EJB 3.1 Cookbook
- EJB 3.1 Cookbook
- Credits
- About the Author
- About the Reviewers
- www.PacktPub.com
- Preface
- 1. Getting Started With EJBs
- Introduction
- Creating a simple session EJB
- Accessing a session bean using dependency injection
- Accessing the session bean using JNDI
- Creating a simple message-driven bean
- Sending a message to a message-driven bean
- Accessing an EJB from a web service (JAX-WS)
- Accessing an EJB from a web service (JAX-RS)
- Accessing an EJB from an Applet
- Accessing an EJB from JSP
- Calling an EJB from JSF
- Accessing an EJB from a Java Application using JNDI
- Accessing an EJB from a Java Application using an embeddable container
- Accessing the EJB container
- 2. Session Beans
- Introduction
- Creating a stateless session bean
- Creating a stateful session bean
- Creating a singleton bean
- Using multiple singleton beans
- Using container managed concurrency
- Using bean managed concurrency
- Controlling the initialization process
- Using session beans with more than one business interface
- Understanding parameter behavior and granularity
- Using an asynchronous method to create a background process
- 3. Message-Driven Beans
- Introduction
- Handling a string-based message
- Handling a byte-based message
- Handling a stream-based message
- Handling a map-based message
- Handling an object-based message
- Using an MDB in a point-to-point application
- Using MDB in a publish-and-subscribe application
- Specifying which types of message to receive using the message selector
- Browsing messages in a message queue
- 4. EJB Persistence
- Introduction
- Creating an entity
- Creating an entity facade
- Using the EntityManager
- Controlling the Object-Relationship Mapping (ORM) process
- Using embeddable classes in entities
- Using application-managed persistence
- Validating persistent fields and properties
- Validating null fields
- Validating string fields
- Validating temporal fields
- Validating using regular expressions
- Validating Boolean fields
- Validating Integer fields
- Using the Validator class
- 5. Querying Entities using JPQL and the Criteria API
- 6. Transaction Processing
- Introduction
- Creating the Demonstration classes
- Handling transactions the easy way
- Using the SessionSynchronization interface with session beans
- Understanding how the TransactionAttributeType affects transactions
- Handling transactions manually
- Rolling back a transaction
- Handling errors in a transaction
- Using timeouts with transactions
- 7. EJB Security
- 8. Interceptors
- Introduction
- Creating the Registration Application
- Defining and using interceptors
- Using the InvocationContext to verify parameters
- Using interceptors to enforce security
- Using interceptors to handle transactions
- Using interceptors to handle application statistics
- Using lifecycle methods in interceptors
- 9. Timer Services
- Introduction
- Setting up the ReportsApplication
- Creating and using declarative timers
- Creating and using programmatic timers
- Understanding calendar-based scheduling
- Using the timer interface
- Using persistent and non-persistent timers
- Creating timers upon application deployment
- Using interceptors with timers
- 10. Web Services
- 11. Packaging the EJB
- Introduction
- Understanding an application's JAR files using the jar command
- Understanding class loading
- Using deployment descriptors for interceptors
- Using deployment descriptors for timer interceptors
- Using deployment descriptor for default interceptors
- Using deployment descriptors for callback interceptors
- Using a deployment descriptors for transactions
- Using deployment descriptors for security
- 12. EJB Techniques
It would be nice if we could use dependency injection outside of a server container. However, this is not possible from a Java SE application unless we use an embeddable container. Using an embeddable container is covered in the next recipe. Here we need to use JNDI. Accessing an EJB from a Java SE application using JNDI is similar to using JNDI in other types of applications.
To use this approach we need:
- A supporting EJB
- JNDI code to obtain a reference to the EJB
We will be using the
CapitalApplicationdeveloped in the Accessing an EJB from an Applet recipe found in this chapter. This recipe uses aCapitalBeanto return the name of the capital given a state. Make sure the server and this application are executing before testing the Java application.
The EJB used here is the CapitalBean. Create a Java SE application using an IDE of your choice. It does not have to be the same one you used to develop the CapitalApplication. In the main method add:
try {
InitialContext context = new InitialContext();
String name = "java:global/CapitalApplication/CapitalBean";
CapitalBeanRemote bean = (CapitalBeanRemote)context.lookup(name);
System.out.println(bean.getCapital("India"));
}
catch(javax.naming.NoInitialContextException e) {
e.printStackTrace();
}
catch (NamingException e) {
e.printStackTrace();
}
Make sure the application's classpath contains .jar files for the CapitalBean and the appserv-rt.jar file.
When executed, the output should appear as:
New Delhi
-
No Comment