Getting started with the Dali plugin for Eclipse supporting EJB 3.0 Persistence

EJB 3.0 Persistence is a topic that is high on our list. We have written a substantial number of blog articles on it after doing quite some research as well as roaming conferences and the internet for useful information and implementations as well as supporting tools. Now we know that the recent Oracle JDeveloper 10.1.3 release (freeware, not open source) has built in support for EJB 3.0 Persistence; for example a wizard Generate Entity Beans from Tables that creates our POJOs objects with all required EJB 3.0 Persistence Annotations. Oracle also has the lead in the Eclipse Dali plugin-project. Other parties working on Dali include JBoss (Hibernate) and SolarMetric (Kodo) – now BEA – and Versant.

The objective of Dali as found on the website http://www.eclipse.org/dali/ :”The goal of the
Dali EJB Object-Relational Mapping project is to
build extensible frameworks and exemplary tools for the
definition and editing of Object-Relational (O/R) mappings
for EJB 3.0 Entity Beans.  EJB 3.0 O/R mapping support
will focus on minimizing the complexity of mapping by
providing creation and automated initial mapping wizards,
and programming assistance such as dynamic problem identification.”  One of the objectives for EJB 3.0 Persistence is ease of development which in part is supposed to happen through IDE support for the Annotations. That is exactly what Dali is trying to accomplish.

In this article, I will report on my first steps with Dali in Eclipse 3.1. I will discuss the installation as well as the functionality available at this time. Note that there is no production release – the 0.5 release is scheduled for very late in June 2006 (thanks Jan for pointing me to this schedule; don’t know why I missed it). To be frank, you can see where Dali is going, and it is doing some useful things already, but it is a little buggy at the same time. Now is a good time to get started, but it is too early for using it in anger.

By the way, the website also explains the name Dali: “The focus of Dali
is support for EJB 3.0 Object/Relational mapping which is
concerned with the persistence of in memory
Java POJOs to relational databases. The title of the famous
painting “The Persistence of Memory” aptly describes
the goal of the EJB 3.0 specification and provides the link
to the Spanish painter Salvador Dali.”

Salvador Dalí. The
Persistence of Memory. 1931.
© 2005 Salvador
Dalí, Gala-Salvador Dalí Foundation/Artists
Rights Society (ARS), New York

To download and install:

• Install
  Eclipse 3.1.x
• Install
  the WTP (Web Tools Project) – get it using Eclipse Plugin Manager from http://download.eclipse.org/webtools/updates/
  
• Download
  the Dali plugin – http://www.eclipse.org/dali/downloads.html  – and extract the zip-archive to the
  Eclipse home directory
• Make
  sure that an EJB 3.0 Persistence API implementation is available – for
  example Glassfish RI, Hibernate 3.0 or Toplink.
• Start
  Eclipse
• Follow
  the instruction in Starting with EJB 3.0 Persistence in Eclipse 3.1 using the GlassFish Reference Implementation ,
  to create a new Java Project, with the GlassFish libraries included in the
  Build Path
• Switch
  to the “Persistence Perspective”–you don’t have to but this
  perspective contains the views that support entity editing.
  
  
• Right-click
  on a Java Project and choose Persistence -> Add Persistence.
  
• A
  window opens where you have to specify the database connection to use for
  our Persistence Project.
  
  If you do not have a database connection, you can navigate to the wizard
  to create one:
  
  
  
• Show
  the Persistence Properties view – from the Window menu, pick Show View and
  then Other. The next window is displayed; select Persistence Properties.
  
  This opens a the Persistence Properties view that we will use to define
  the Mapping details for our Entities.
  
  
• Now
  that we have set up the Dali plugin – the Persistence Perspective – we can
  start using it to help us create Mappings. Create a new class Publisher,
  from File menu, New, Other – Persistence, EJB 3.0 Entity:
  Enter the package and the name of the Entity. It is created by the wizard:
• Now
  select the Class. In the Persistence Properties view, you can now indicate
  that this class is to be mapped as Entity, to the table ALS_PUBLISHERS.
  
  The Dali plugin adds the @Entity and @Table annotations based on these
  choices:
  
• Create
  the properties Id, Name and Website in Class Publisher
  
• Use
  the option Source, Generate Getters and Setters to create the get- and
  set-methods for these properties.
• Now
  select the getId method in the source editor or in the Persistence Outline.
  We can now use the Dali Persistence Properties view to define the mapping
  for this getter:
  
  In this way, Dali is very helpful in creating the mapping annotations.
  Note that we can still manually edit the annotations as well.What Dali currently does not do, is create a class and its properties
  based on a table – something that JDeveloper can do for us.
• Where
  Dali really shines in my opinion is with more complex mappings: properties
  that represent relationships between entities.  Suppose we create a second Entity called
  Book for our ALS_BOOKS table. This entity has a number of attributes, like
  id, title, publishYear etc.:
  
  
  
• Now we
  know from our database that there is a foreign key from ALS_BOOKS to
  ALS_PUBLISHERS: every Book has one (and only one) Publisher. We would like
  to translate this to our Book and Publisher Entities: Book has a reference
  to its Publisher while Publisher has a Books collection of the contents of
  its portfolio.Let’s create an attribute Publisher in the Book Entity and let’s generate
  getters and setters for this attribute:

  Select the getPublisher() method. Now go to the Persistence Properties view
  to specify the mapping:
  
  
  

• Dali
  integrates with the RDB component of the Web Tools project for relational
  schema information.  It is currently necessary to open the Database
  Explorer View before creating or selecting a connection in the “Add
  Persistence…” wizard. When starting a new workbench session, it is
  currently necessary to re-connect to your database if you are working
  on-line with the DB.  This allows the Dali plug-in to provide DB
  related mapping assistance and validation.The WTP Database Explorer (RDB) – very similar to the Database Connection
  Navigator in JDeveloper and the stand-alone Oracle Raptor tool – allows us
  to inspect the Tables and the data in them:
  

Some additional notes from the Getting Started page on the Dali Project site:

• In order to compile EJB3 Entities, it is a requirement that the appropriate jar(s) from an EJB 3.0 runtime are available on the project classpath.  The “Add Persistence…” wizard will help you add the required library to your project classpath.  You must have previously installed a Java EE 5 or EJB3 persistence runtime implementation–one is not distributed with Dali. This functionality is currently undergoing a change to support libraries so that all the required jars can be easily included in the classpath.
• Dali integrates with the RDB component of the Web Tools project for relational schema information.  It is currently necessary to open the Database Explorer View before creating or selecting a connection in the “Add Persistence…” wizard.
• When starting a new workbench session, it is currently necessary to re-connect to your database if you are working on-line with the DB.  This allows the Dali plug-in to provide DB related mapping assistance and validation.
• When using WTP 1.0 and higher, the Persistence menu item on a Java project does not display in the J2EE perspective. To work around this, simply switch to the Java Perspective to “Add Persistence…” to the project.

Resources

Lots of information and some very instructive Viewlets can be found at: http://www.eclipse.org/dali/gettingstarted.html