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

Using the SessionSynchronization interface with session beans

When a transaction executes as part of a stateful session bean, the bean can receive synchronous notifications of the progress of the transaction using the SessionSynchronization interface. While there is not a specific field or variable which indicates the state of a transaction when using CMT, the invocation of one of its interface methods implies the transaction's state.

One possible use of this technique is to synchronize the instance variables of the bean to their corresponding values in a database. In this recipe, we will examine how the interface works. In the next recipe, Understanding how the TransactionAttributeType affects transactions, we will demonstrate how CMT work with different transaction attribute type settings.

Getting ready

The steps for using the SessionSynchronization interface include:

Declaring that the class implements the interface
Implementing the methods of the interface

In order for a stateful session...

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

Using the SessionSynchronization interface with session beans

Getting ready