Generic CRUD service bean

[Piotr Nowicki]

Howdy Ranchers!

I'm a beginner in EJB world, so I will be glad for your advice how to solve this problem. Thanks in advance!

I use many business objects in my application, where a great vast of them use the basic CRUD operations. I'm looking for some unified way to implement those basic features.

In other words, there is a solution proposed by Adam Bien (http://www.adam-bien.com/roller/abien/entry/generic_crud_components_with_java).

The generic interface is fine, but I still need to implement basic operations for each of my Business Objects.
The second solution (bean implementation) is great, but... how should I use it?

1. Should I use composition and inject this CrudServiceBean into mine business object and perhaps delegate all CRUD operations to this EJB, somewhat like this:

@Stateless
public class MyBusinessObject {

@EJB
CrudServiceBean crud;

...
    public void delete(MyEntityObject t) {
       crud.delete(t);  // Delegation to Crud Service EJB
    }

    public MyEntityObject update(Serializable t) {
        return crud.update(t);  // Delegation to Crud Service EJB
    }
...
}

In this way I still need to write every CRUD method in my business object class (just a delegation but still in 90% it's just the same plain delegation code).

2. I can extend the CrudServiceBean like the code below:

@Stateless
public class MyBusinessObject extends CrudServiceBean {

    // All CRUD operations are available out-of-the-box
}

Can I extend another EJB?
If I cannot, than this CrudServiceBean must be a POJO and therefore it will not have EntityManager injected. This sucks pretty badly...

3. I can extend the CrudServiceBean (plain POJO) and modify it to use a method like getEntityManager() within:

public abstract class GenericCrudServiceBean {
  
    // No EntityManger defined, as this is a plain POJO! Overriding EJB must provide this method implementation!
    abstract EntityManager getEntityManager(); 

    public Serializable create(Serializable t) {
        // Notice the getEntityManager() instead of injected EM field is used!
        getEntityManager().persist(t);
        return t;
    }

    public Serializable update(Serializable t) {
        return getEntityManager().merge(t);
    }
}

However, in this solution the getEntityManager() method must be at least package-visible (because of the overriding method from business object). I am not sure if this is the correct approach, as it exposes the EntityManager for other BusinessObjects...

Which approach would you choose and what is the rationale?

Thanks in advance!

Cheers!