DZone
Java Zone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
  • Refcardz
  • Trend Reports
  • Webinars
  • Zones
  • |
    • Agile
    • AI
    • Big Data
    • Cloud
    • Database
    • DevOps
    • Integration
    • IoT
    • Java
    • Microservices
    • Open Source
    • Performance
    • Security
    • Web Dev
DZone > Java Zone > A Generic CRUD Facade For Your @Entity Beans

A Generic CRUD Facade For Your @Entity Beans

Felipe Gaúcho user avatar by
Felipe Gaúcho
·
Apr. 20, 09 · Java Zone · Interview
Like (0)
Save
Tweet
29.88K Views

Join the DZone community and get the full member experience.

Join For Free

CRUD (create-read-update-delete) is a repetitive code in Java EE projects but it can be isolated in a unique class through the usage of JPA annotations and Generics - a class I call CRUDEntityFacade. This is not a new pattern and the goal of this blog entry is just to prepare you to read my next entries about JAXB and JPA together. I am doing really nice things with Jersey and Glassfish, and before to expose complicated inventions I decided to register the basics of the persistence layer (also very nice for my own future reference).

Complete sample projects

The code I am publishing here is just to avoid you to checkout a full project and to dig to inspect my CRUD strategy. But if you want to see this technique in action, please be my guest to checkout one of my open-source projects. The projects are built by Maven and were created in Eclipse - but you should be able to run it on your preferred IDE without any problems. Both projects requires minimum Java 6.

  • Example #1: the Footprint project, what includes a RESTful service coded with the Jersey framework. Subversion checkout:

    svn checkout https://footprint.dev.java.net/svn/footprint/trunk footprint --username username

  • Example #2: the Cejug-Classifieds project, a WSDL first web-service coded with the JAX-WS framework. Subversion checkout:

    svn checkout https://cejug-classifieds.dev.java.net/svn/cejug-classifieds/trunk cejug-classifieds --username username

username is your java.net login, or you can use guest without password to get a read only copy.

The generic CRUD implemented with generics and JPA annotations

  1. Defining the persistence interface containing the persistence operations we want to share between all entities. Note that I replicated the runtime exceptions because it is an interface and we expect interfaces to be the most document and self-understandable artifacts in our project.

    public interface FootprintEntityFacade {
    T create(T entity) throws EntityExistsException, IllegalStateException,
    IllegalArgumentException, TransactionRequiredException;

    T read(Serializable primaryKey) throws IllegalStateException,
    IllegalArgumentException;

    void update(T entity) throws IllegalStateException,
    IllegalArgumentException, TransactionRequiredException;

    void deleteO(T entity) throws IllegalStateException,
    IllegalArgumentException, TransactionRequiredException,
    PersistenceException;
    }

     

     

  2. To define a superclass of all entities. This is an important step, since we want to use generics we must have a unique type to pass in our interface implementation. The mapped superclass is also useful to share the ID attribute.

    @MappedSuperclass
    public abstract class AbstractFootprintEntity implements Serializable {
    @Transient public static final long serialVersionUID = 196919661993L;

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    // getters & setters
    }

     

     

  3. Then we need some entities. I will use an example of the Footprint entity that represents Events (JUG meetings, courses or conferences).

    @Entity
    public class FpEvent extends AbstractFootprintEntity {
    @Transient private static final long serialVersionUID = 196919661993L;

    @Column(nullable = false)
    private String name;

    @Column(nullable = true)
    private String website;

    @Version
    private long updatedTime;

    // getters & setters
    }

     

     

  4. Now an important step, the realization of our generic CRUD interface to our Event Entity. In theory this empty interface is not necessary, but my experiments proved that this is the best way to go. It opens a chance for the customization of the persistence interface and - the main reason - it avoids conflicts between different entity instances using a same interface. You will have 1 empty interface for each Entity in your project, an oddity I couldn't rid off - if you know how to avoid it, please tell me.

    @Local
    public interface EventFacadeLocal extends FootprintEntityFacade<FpEvent> {
    }

     

     

  5. Now we just need to implement the CRUD. A special note about the empty constructor, that uses reflection to get the class of the generic type - this is the hidden trick that makes the magic possible.

    @Stateless
    public class CRUDEntityFacade<T extends AbstractFootprintEntity> implements FootprintEntityFacade<T> {

    private transient final Class entityClass;

    @SuppressWarnings("unchecked")
    public CRUDEntityFacade() {
    entityClass = (Class) ((java.lang.reflect.ParameterizedType) this
    .getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    @PersistenceContext(name = "footprint")
    protected transient EntityManager manager;

    public T create(final T entity) throws EntityExistsException,
    IllegalStateException, IllegalArgumentException,
    TransactionRequiredException {
    manager.persist(entity);
    manager.flush();
    return entity;
    }

    public T read(final Serializable primaryKey) throws IllegalStateException,
    IllegalArgumentException {
    return manager.find(entityClass, primaryKey);
    }

    public void update(final T entity) throws IllegalStateException,
    IllegalArgumentException, TransactionRequiredException {
    manager.merge(entity);
    manager.flush();
    }

    public void delete(final T entity) throws IllegalStateException,
    IllegalArgumentException, TransactionRequiredException,
    PersistenceException {
    manager.remove(entity);
    manager.flush();
    }
    }

     

     

  6. It is done, now we can persist any entity of the type AbstractFootprintEntity (remember to create the empty sub-interface for each new entity you want to persist). Below you find an example of the CRUD usage in a Jersey resource:

    @Path("/event")
    public class EventResource {
    @EJB
    private EventFacadeLocal eventFacade;

    @Produces( { MediaType.APPLICATION_XML })
    @Consumes(MediaType.APPLICATION_XML)
    @POST
    @Path("/test2")
    public FpEvent postJAXBElement(FpEvent e) {
    return eventFacade.create(e);
    }
    }

     

     

In my next entries I will show you how to use dual annotation (JAXB + JPA) in order to minimize the impedance mismatch between the persistence layer and the serialization of element used in the services endpoints - REST or SOAP.

From http://weblogs.java.net/blog/felipegaucho

entity

Opinions expressed by DZone contributors are their own.

Popular on DZone

  • 27 Free Web UI Mockup Tools
  • Modernizing Testing With Data Pipelines
  • Pattern Matching for Switch
  • Adding Authentication to a Web Application with Auth0, React, and JWT

Comments

Java Partner Resources

X

ABOUT US

  • About DZone
  • Send feedback
  • Careers
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • MVB Program
  • Become a Contributor
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 600 Park Offices Drive
  • Suite 300
  • Durham, NC 27709
  • support@dzone.com
  • +1 (919) 678-0300

Let's be friends:

DZone.com is powered by 

AnswerHub logo