EJB 3.1 Cookbook

EJB 3.1 Cookbook

By : Richard M. Reese

Buy this Book

EJB 3.1 Cookbook

By: Richard M. Reese

Buy this Book

Overview of this book

Enterprise Java Beans enable rapid and simplified development of secure and portable applications based on Java technology.Creating and using EJBs can be challenging and rewarding. Among the challenges are learning the EJB technology itself, learning how to use the development environment you have chosen for EJB development, and the testing of the EJBs. This EJB 3.1 Cookbook addresses all these challenges and covers new 3.1 features, along with explanations of useful retained features from earlier versions. It brings the reader quickly up to speed on how to use EJB 3.1 techniques through the use of step-by-step examples without the need to use multiple incompatible resources. The coverage is concise and to the point, and is organized to allow you to quickly find and learn those features of interest to you. The book starts with coverage of EJB clients. The reader can choose the chapters and recipes which best address his or her specific needs. The newer EJB technologies presented include singleton beans which support application wide needs and interceptors to permit processing before and after a target method is invoked. Asynchronous invocation of methods and enhancements to the timer service are also covered. The EJB 3.1 CookBook is a very straightforward and rewarding source of techniques supporting Java EE applications.

EJB 3.1 Cookbook

Credits

About the Author

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

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

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

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

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

Querying Entities using JPQL and the Criteria API

Introduction

Populating the Patient and Medication tables

Using the Select query

Using the Where clause

Controlling the number of entities returned by a Select query

Using the Delete query

Using the Update query

Using parameters in a query

Using a Named query

Using the Criteria API

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

EJB Security

Introduction

Creating the SecurityApplication

Configuring the server to handle security

Understanding and declaring roles

Controlling security using declarations

Propagating identity

Controlling security programmatically

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

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

Web Services

Introduction

Creating an EJB-based web service using JAX-WS

Creating an EJB-based web service using JAX-RS

Using an MDB as part of a web service

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

EJB Techniques

Introduction

Exception handling and EJBs

Using logging within an EJB

Using an interceptor for logging and exception handling

Creating your own interceptor

Using time within an EJB

How to support currency

Efficient manipulation of strings

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Accessing an EJB from a Java Application using JNDI

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.

Getting ready

To use this approach we need:

A supporting EJB
JNDI code to obtain a reference to the EJB

We will be using the CapitalApplication developed in the Accessing an EJB from an Applet recipe found in this chapter. This recipe uses a CapitalBean to return the name of the capital given a state. Make sure the server and this application are executing before testing the Java application.

How to do it...

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

How it works...

The application JAR file was needed to resolve the class names and the appserv-rt.jar file was needed so JNDI could function properly. This file provided the necessary information for JNDI to locate the server and look up the name correctly.

EJB 3.1 Cookbook

By : Richard M. Reese

EJB 3.1 Cookbook

By: Richard M. Reese

Overview of this book

Related Content you might be interested in

Current Title:

EJB 3.1 Cookbook

Accessing an EJB from a Java Application using JNDI

Getting ready

How to do it...

How it works...

See also