Question

I would like to equip my EJBs with CRUD methods.

I have many entities and multiple persistence units.

I want to implement my CRUD methods once and invoke them on different persistence units.

I tried to achieve this using inheritance, but it isn’t working.

The CRUD class is:

public class FormEBean<T> {

    protected EntityManager em;

    public EntityManager getEm() {
        return em;
    }

    public void setEm(EntityManager em) {
        this.em = em;
    }

    public String create(T entity) {
        try {
            em.persist(entity);
            em.flush();
            return null;
        } catch (Exception ex) {
            return ex.getLocalizedMessage();
        }
    }

    public void create(List<T> entityList) {
        for (T entity : entityList) {
            em.persist(entity);
        }
    }

    public void edit(T entity) {
        em.merge(entity);
    }

    public void edit(Set<T> entitySet) {
        Iterator<T> it = entitySet.iterator();
        while (it.hasNext()) {
            T entity = it.next();
            em.merge(entity);
        }
    }

    public void remove(T entity) {
        em.remove(em.merge(entity));
    }

    public void remove(T[] listaDaRimuovere) {
        for (T entity : listaDaRimuovere) {
            em.remove(em.merge(entity));
        }
    }

    public void remove(List<T> listaDaRimuovere) {
        for (T entity : listaDaRimuovere) {
            em.remove(em.merge(entity));
        }
    }
}

So I tryed in this way:

@Stateless
@Remote(MyEBeanRemote.class)
public class MyEBean extends FormEBean<MyEntityClass> implements MyEBeanRemote {

    @PersistenceContext(unitName = "siat-ejbPU")
    private EntityManager em;

    // code here
}

Even if I haven’t got any error, the CRUD functions have no effect on my DataBase.

Instead if I insert them directly into MyEBean it behaves as expected.

I don’t want to use @PersistenceContext(unitName = "siat-ejbPU") in the FormEBean, because EJBs could use different persistence units.

Is there a way to solve this problem?

Is there a pattern I can use to reuse my code?

Edit:

The aim of this question is finding a solution that maximizes CRUD code reuse in EJBs belonging to different EJB modules and having different persistence units.

Using generic methods in a stateless session bean seems like a good solution, but only for reusing CRUD code for EJBs in the same persistence unit.

What solution could be persistence unit independent (if it exists)?

Answer 1

I found a solution that solves the problem.

It’s based on jahroy’s answer, but uses inheritance to deal with multiple persitence units.

The common code is a base class (not generic but with generic methods):

    public class FormEBean {

        final Logger logger = LoggerFactory.getLogger(FormEBean.class);

        protected EntityManager emCrud;

        public EntityManager getEmCrud() {
            return emCrud;
        }

        public void setEmCrud(EntityManager em) {
            emCrud = em;
        }

        public <T> String create(T entity) {
            String exception = null;
            try {
                emCrud.persist(entity);
                emCrud.flush();
            } catch (Exception ex) {
                //ex.printStackTrace();
                exception = ex.getLocalizedMessage();
            }
            return exception;
        }

        public <T> void create(List<T> entityList) {
            for (T entity : entityList) {
                emCrud.persist(entity);
            }
        }

        public <T> void edit(T entity) {
            emCrud.merge(entity);
        }

        public <T> void edit(Set<T> entitySet) {
            Iterator<T> it = entitySet.iterator();
            while (it.hasNext()) {
                T entity = it.next();
                emCrud.merge(entity);
                emCrud.flush();
            }
        }

        public <T> void remove(T entity) {
            emCrud.remove(emCrud.merge(entity));
        }

        public <T> void remove(T[] listaDaRimuovere) {
            for (T entity : listaDaRimuovere) {
                emCrud.remove(emCrud.merge(entity));
            }
        }

        public <T> void remove(List<T> listaDaRimuovere) {
            for (T entity : listaDaRimuovere) {
                emCrud.remove(emCrud.merge(entity));
            }
        }
     }

… and this is the interface:

public interface FormEBeanRemote {
    public void setEmCrud(EntityManager em);
    public <T> String create(T entity);
    public <T> void create(List<T> entityList);
    public <T> void edit(T entity);
    public <T> void edit(Set<T> entitySet);
    public <T> void remove(T entity);
    public <T> void remove(T[] listaDaRimuovere);
    public <T> void remove(List<T> listaDaRimuovere);
}

The EJB (stateless session bean) looks like this:

@Stateless
@Remote(MyEBean.class)
public class MyEBean extends FormEBean implements MyEBeanRemote {

    final Logger logger = LoggerFactory.getLogger(MyEBean.class);

    @PersistenceContext(unitName = "siat-ejbPU")
    private EntityManager em;

    public EntityManager getEm() {
        return em;
    }

    public void setEm(EntityManager em) {
        this.em = em;
    }

    @PostConstruct
    public void postConstruct() {
        this.setEmCrud(em);
    }

…where

@Remote
public interface MyEBeanRemote extends FormEBeanRemote {
......
}

Note that the EJB uses the postConstruct method to set the entityManager, which is delegated to perform CRUD operations on a specific persistence unit.

It’s working like a charm so far.

If someone finds any pitfalls please let me know.