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

1

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

 

 

Share.

About Author

Lucas Jellema, active in IT (and with Oracle) since 1994. Oracle ACE Director for Fusion Middleware. Consultant, trainer and instructor on diverse areas including Oracle Database (SQL & PLSQL), Service Oriented Architecture, BPM, ADF, Java in various shapes and forms and many other things. Author of the Oracle Press book: Oracle SOA Suite 11g Handbook. Frequent presenter on conferences such as JavaOne, Oracle OpenWorld, ODTUG Kaleidoscope, Devoxx and OBUG. Presenter for Oracle University Celebrity specials.

1 Comment