Introduction to Java EE 5 Technology

NetBeans IDE 6.0 has been developed in close cooperation with the Java EE and Glassfish teams to provide the tightest integration and easiest possible use of the Java EE 5 specification. NetBeans IDE 6.0 is the best way to quickly learn and become productive in Java EE 5 programming.

This document provides an introduction to the major concepts of the Java EE 5 specifications and how they relate to your hands-on programming. The following topics are covered:

• Annotations Instead of Deployment Descriptors
• Simplified EJB Software Development
• Use Dependency Injection to Access Resources
• Java Persistence API Model
• Web Services

You can find more information about developing and deploying Java EE 5 applications on the Sun Java System Application Server Platform Edition 9 in the Java EE 5 Tutorial.

Annotations Instead of Deployment Descriptors

The Java EE 5 platform simplifies deployment by removing the need for deployment descriptors, except for the deployment descriptor required by the servlet specification, the web.xml file. Other deployment descriptors, such as ejb-jar.xml and entries related to web services in web.xml, are obsolete. J2EE 1.4 deployment descriptors were often complex and it was easy to make mistakes in filling them out. Instead, the Java EE 5 platform makes use of "annotations". Annotations are Java modifiers, similar to public and private, that you specify in your code. For example, the EJB 3 specification, which is a subset of the Java EE 5 specification, defines annotations for the bean type, interface type, resource references, transaction attributes, security, and more. A similar set of annotations is provided for web services by the JAX-WS 2.0 specification. Some annotations are used for generating artifacts. Other annotations are used for documenting your code. Still others provide enhanced services such as security or runtime-specific logic. In summary, the Java EE 5 platform provides annotations for the following tasks, among others:

• Defining and using web services
• Developing EJB software applications
• Mapping Java technology classes to XML
• Mapping Java technology classes to databases
• Mapping methods to operations
• Specifying external dependencies
• Specifying deployment information, including security attributes

Annotations are marked with a @ character. In the IDE, when you create a type that makes use of annotations in Java EE 5, related placeholders are provided in the generated code. For example, when you use the IDE to create a stateless session bean, the following code is generated, which includes the @Stateless() annotation:

package mypackage;

import javax.ejb.*;

@Stateless()
public class HelloWorldSessionBean implements mypackage.HelloWorldSessionLocal {

}

Each attribute has default values. Therefore, you do not need to specify any attributes unless you want to use a value other than the default value. In simple cases, the default value is sufficient, which means that you do not even need to provide attributes at all.

Simplified EJB Software Development

The new EJB 3.0 API makes software development easier by reducing and simplifying the amount of work required from the developer. In other words, fewer classes and less code. This is possible because more of the work is now performed by the container. Here are some of the features and benefits of the new EJB 3.0 API:

• Fewer required classes and interfaces. You no longer need home and object interfaces for EJB components because the container is now responsible for exposing the necessary methods. You only need to supply a business interface. You can use annotations to declare your EJB components and the container will manage the transactions.
• No more deployment descriptors. You can use annotations directly in the class to tell the container about dependencies and configuration that you formerly defined in deployment descriptors. If there are no specific instructions, the container uses default rules to handle the most common situations.
• Simple lookups. The EJBContext enables you to lookup objects in the JNDI name space directly in the class.
• Simplified object-relational mapping. The new Java Persistence API makes object-relational mapping much simpler and transparent by allowing you to use annotations in POJOs to map Java objects to relational databases.

In the IDE, you can code enterprise beans just as you would code other Java classes, using code completion and editor hints to implement the correct methods and keep the classes in synch with their interfaces. You do not need to use special commands and dialog boxes to generate things like business methods or web service operations, although the commands are still available to help acquaint you with the syntax of Java EE 5 code.

Use Dependency Injection to Access Resources

Dependency injection enables an object to use annotations to request external resources directly. This results in cleaner code because you no longer need to clutter your code with resource creation and lookup code. You can use resource injection in EJB components, web containers, and clients.

To request injection of a resource, a component uses the @Resource annotation or, in the case of some specialized resources, the @EJB and @WebServiceRef annotations. Resources that can be injected include:

• SessionContext object
• DataSources object
• EntityManager interface
• Other enterprise beans
• Web services
• Message queues and topics
• Connection factories for resource adapters

In the IDE, the Source Editor provides full code completion for resources injection annotations provided by the Java EE 5 platform. In addition, the IDE automatically injects resources into your files when you run commands like Call EJB and Use Database.

Java Persistence API Model

The Java EE 5 platform introduces the new Java Persistence API, which was developed as part of JSR-220. The Java Persistence API can also be used outside of EJB components, for example, in web applications and application clients, and also outside the Java EE platform, in Java SE applications.

The Java Persistence API has the following key features:

• Entities are POJOs. Unlike EJB components that used container-managed persistence (CMP), entity objects using the new APIs are no longer components, and they no longer need to be in an EJB module.
• Standardized object-relational mapping. The new specification standardizes how object-relational mapping is handled, freeing the developer from learning vendor-specific strategies. The Java Persistence API uses annotations to specify object-relational mapping information, but still support XML descriptors.
• Named queries. A named query is now a static query expressed in metadata. The query can be either a Java Persistence API query or a native query. This makes reusing queries very simple.
• Simple packaging rules. Because entity beans are simple Java technology classes, they can be packaged virtually anywhere in a Java EE application. For example, entity beans can be part of an EJB JAR, application-client JAR, WEB-INF/lib, WEB-INF/classes, or even part of a utility JAR in an enterprise application archive (EAR) file. With these simple packaging rules, you no longer have to make an EAR file to use entity beans from a web application or application client.
• Detached entities. Because entity beans are POJOs, they can be serialized and sent across the network to a different address space and used in a persistence-unaware environment. As a result, you no longer need to use data transfer objects (DTOs).
• EntityManager API. Application programmers now use a standard EntityManager API to perform Create Read Update Delete (CRUD) operations that involve entities.

The IDE provides tools to work with the new Java Persistence API. You can generate entity classes automatically from a database, or code entity classes by hand. The IDE also provides templates and graphic editors for creating and maintaining persistence units.

Web Services

In the Java EE 5 platform, the use of annotations has greatly improved and simplified web services support. The following specifications contributed to this area: JSR 224, Java API for XML-Based Web Services (JAX-WS) 2.0; JSR 222, Java Architecture for XML Binding (JAXB) 2.0; and JSR 181, Web Services Metadata for the Java Platform.

Next Steps

For more information about using NetBeans IDE 5.5 to develop Java EE applications, see the following resources:

• Getting Started with JAX-WS Web Services in NetBeans IDE 6.0
• EJB 3.0 Enterprise Beans
• Introduction to Using Java Persistence in a Web Application
• Java EE Applications Learning Trail

To send comments and suggestions, get support, and keep informed on the latest developments on the NetBeans IDE Java EE development features, join the [email protected] mailing list.