EJB 3.0 – Looks simply great!
It was a full house as I had predicted earlier when Linda DeMichiel, the spec lead of the EJB 3.0 expert committee presented on the plans for EJB 3.0 in the TheServerSide symposium today. So all those guys love and hate EJBs were present in the session. The main goals of EJB 3.0 are to simplify EJB for developers and make this attractive for all J2EE developers. It appears that the expert committee has kept their ears open for a while and has been trying to address all concerns around EJBs and mainly the container managed persistence. Let us see what are the plans in EJB 3.0.
Simple for Development
The current EJB is very heavy weight and confusing for developers. The developers have to create several interfaces and to write a cryptic deployment descriptor.
Following are proposals to make EJB simpler than the current model:
- Remove need for building the EJB interfaces and generating the deployment descriptors and provide ability to developers to generate these by specifying annotations as in JSR 175. This will free developers from:
- Creating deployment descriptors
- Build component Interfaces
- Simplify EJBs to resemble POJOs or Java Beans.
- Elimination of requirement to have component interfaces for EJBs.
- The entity beans do not require any component interfaces.
- The session beans will use a Plain Old Java Interface
- Elimination of requirement to implement unnecessary callback methods.
So instead of two interfaces and a bean implementation class for a Session bean and defining a deployment descriptor for the Session Bean the developer has to define the EJB as follows. The following example shows the code for a HelloWorld bean:
@Session public class HelloWorldBean {
public void sayHello (String s) {
System.out.println(“Hello:”+s);
}
}
Apparently this looks much simpler than earlier and will appeal developers to use EJBs in their business logic layer.
Hide complexity of JNDI
Every EJB developer has gone through the pain of JNDI at least once in his/her lifetime. EJB 3.0 courageously target to hide the complexity of JNDI by providing several options such as declarative expression for dependencies, container injection of resources and simple programmatic lookup mechanisms.
Here is a simple example how the JNDI lookup is being simplified. This sample illustrates a stateless session bean accessing a DataSource object.
@Session public class MySessionBean {
private DataSource customerDB;
@Inject private void setCustomerDB(DataSource customerDB) {
this.customerDB = customerDB;
}
public void myMethod (String myString) {
...
Connection conn = customerDB.getConnection();
...
}
}
The following example demonstrates a dynamic lookup with injection
@Inject private void setSessionContext(SessionContext ctx) {
this.ctx = ctx
}
...
myShoppingCart = (ShoppingCart)ctx.lookup(“shoppingCart”);
...
Simplify CMP Entity Beans
The open source Hibernate has become the darling for building the persistence layer for developers who have shunned entity beans for complexity, heavy weight and its limitations. EJB 3.0 is adopting a lightweight persistence model like Hibernate to simplify the container managed persistence. This will provide compelling reasons for EJB 3.0 CMP to become as the persistence model of choice for java developers.
Following are some of the compelling features considered for EJB 3.0:
- Entity beans will be reincarnated as POJOs
- There will be no component interfaces required for entity beans
- Improving modeling capabilities with support of inheritance and polymorphism
- Make it usable and testable outside the container
- Remove need for Dots for entity beans
- Flexible support for O-R mapping
- Major enhancements in EJB-QL. These are few niceties of SQL that EJB-QL is borrowing to satisfy the needs of enterprise.
-
Bulk update and delete operations
-
Projection list (SELECT clause)
-
Support for Group by, Having
-
Support Sub queries (correlated and not)
-
Additional SQL functions UPPER, LOWER, TRIM,etc..
-
Dynamic queries
Also interesting to note that there is a plan to support native SQL queries with entity beans.
Here is an example of a new entity bean looks like
@Entity public class Employee{
private Long empNo;
private String empEmpName;
@Nested private Address address;
private Hashmap projects = new Hashmap();
private Double salary;
@PK(generated=true) public Long getEmpNo() {
return empNo;
}
private void setEmpNo(Long empNo) {
this.empNo = empNo;
}
public String getEmpName() {
return EmpName;
}
public void setEmpName(String EmpName)j {
this.EmpName = EmpName;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public Set getProjects() {
return projects;
}
public void setProjects(Set projects) {
this.projects = projects;
}
.public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
....
}
Testability Usability Outside Container
Another major steps EJB 3.0 is taking to make EJBs usable/testable outside the EJB container. However greater details of this was not revealed in the presentation.
Miscellenous Issues
- The existing entity beans model (EJB 2.1) will still be supported.
- EJB QL will be extended to support the old EJB models.
- Container managed relationship may not be supported with new models.
- Make Session Beans/MDBs as Service beans.
Conclusion
EJB 3.0 will be complete overhaul of the EJB technology and will be much simple and for developers. It will provide a lightweight persistence model like Hibernate that will provide a compelling persistence model for J2EE applications.
12:23:15 AM 
|
