changes

MyPersistentBean pojo = new MyPersistentBean();
pojo.setProperty(...)

GenericDao<MyPersistentBean> dao = 
      DaoRegistry.getInstance().createGenericDao(MyPersistentBean.class);

dao.save(pojo);

ProjectEntityDao<MyPersistentBean> dao = 
      DaoRegistry.getInstance().createProjectEntityDao(MyPersistentBean.class);

...

dao.save(pojo);

Evaluation getEvaluation(User, AbstractAlternative, Criterion);
int getEvaluationCount(AbstractAlternative);
int getEvaluationCount(Criterion);
int getEvaluationCount(User);
List<Evaluation> getEvaluations(User);

public class WeightedSumActivator extends AbstractPluginActivator
{

}

A step by step migration example

This section provides a cost-to-coast example of migrating a plugin to the 1.1 architecture. It is assumed that you develop within Eclipse.

A few steps must be performed to migrate your plugin to D2 1.1. To avoid potential collisions, you may want to work in a fresh new workspace.

1. Rename your project

   If your project doesn't follow the reverse dns naming convention, please rename it for the sake of uniformity (although this isn't required). For instance : org.decisiondeck.methods.iris.

2. Import the D2 bundles into your workspace

   Please refer to the plugin guide to read more about the options that are offered to you.

3. Import your plugin project into the the workspace

   This is achieved through Eclipse import feature (File/Import.. > Existing projects into workspace). Be sure to check the "Copy project into workspace" option.

4. Update your project classpath

   Open your project Java Build path property page and remove all project references and referenced libraries (either external or internal). Obviously, when you close the dialog the project won't build : don't worry, this is expected.

5. Convert your project to a Plugin project

   In the project contextual menu open the "PDE Tools" submenu and select "Convert projects to plug-in Projects...". Select your project and press Finish. Eclipse updates your project metadata (.project file) and creates a few files : META-INF/MANIFEST.MF and build.properties.

   Open the MANIFEST file. In the "Overview" tab, check that the "ID" is correct, and provide a better "Name" for your plugin.

   Open the "Dependencies" tab. For each project that were previously referenced in the Java Build Path, add a "Required Plug-in" entry (button "Add..")

   

   Open the "Runtime" tab. If you used external libraries, and those libraries are not already provided by antoher plugin (see for instance, org.decisiondeck.lib.*) and you don't want to share those libraries, create a lib (for instance) folder at the root of the project, and copy your libraries there ; then add a new entry in the "Classpath" list (bottom right of the page) using the "Add..." button.

   

   In the same tab, in the "Exported packages" section, select all the packages you want to expose to the outside world (only the selected packages will be accessible by other plugins).

   Last, if your plugin contributes to the model (by providing new entities) - and it will probably do, you need to do some manual tweakings. Open the MANIFEST.MF tab. Add the following lines at the end of the file:

   Eclipse-RegisterBuddy: org.decisiondeck.dao.core,
    org.decisiondeck.lib.hibernate
   

   This makes your plugin classes (see "Exported classes" above) visible to Hibernate and Dao Core plugins. This is required because of the dynamic classloading model of Hibernate. Please note that you need an empty line at the end of the file (anyway Eclipse will scold you if there isn't).

6. Create the activator

   In the MANIFEST.MF editor, Overview tab, click the "Activator" link to create a new Activator for your plugin. Make it inherit from AbstractPluginActivator (provided by the org.decisiondeck.plugin.manager bundle).

7. Update the model

   This step basically consists in annotating your entities. For each persistent property, you need to feed Hibernate with the correct mapping information. For instance (example taken from the project generated by the Eclipse "New Decision-Deck Project" Wizard):

   @Entity
   @Table(name="UNIQUE_PREFIX_A")
   public class A extends AbstractProjectEntity
   {
           @OneToMany(cascade=CascadeType.ALL, mappedBy="a", fetch=FetchType.LAZY)
       private List<B> coll = new ArrayList<B>();
       
       @ManyToOne(cascade={CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH}, fetch=FetchType.EAGER)
       @JoinColumn(name="User_ID", unique=false, nullable=false, insertable=true, updatable=true)
       private User user;
       
       @Column(name="Value", unique=false, nullable=true, insertable=true, updatable=true)
       private Float value;
   
       ..... 
       
       setter/getter    
   }      
   

   You may want to read the JPA documentation and Hibernate documentation (see References).

   Be careful to note reference Hibernate annotations but rather JPA ones. Hibernate ones may be used to refine JPA, but can't be substituted.

8. Update the DAOs

   You need to reimplement all your data access operations. Hopefully this will be quick. Your best bet is to inherit from either GenericDao or ProjectEntityDao (if the managed entity is an AbstractProjectEntity - see above).

   Generic operations (Create, Read, Update, Delete) are all already implemented in the aforementionned superclasses. So you just need to implement those custom queries. You may want to prefer Hibernate Criteria API over the query API.

   Please note that the Query API doesn't support persistence by reachibility - which means that a query such as "delete from Bar e where e.foo=:foo" won't cascade, for cascading sake you will need to access the session :

   getSession().delete(myPersistentObject);
   

9. Update the service layer

   This step basically consists in resolving build errors that may arise after all the courageous changes you've done.

10. Update the plugin descriptor

    Remove all XML elements but id, version, className, and services elements.

    If your refine the model by providing new entities, add a refines element such as:

    <refines>
        <entityProvider>
            <id>org.decisiondeck.iris</id>
            <entityNames>
                <!-- Add all your persistent entities here (referenced by qualified name). For instance : -->
                <entityName>org.decisiondeck.monplugin.model.MyPersistentBean</entityName>
                ....
            </entityNames>
        </entityProvider>
    </refines> 
    

    Here's a concrete example taken from the WeightedSum plugin:

    Before - After

11. Run the platform

    Please refer to the plugin guide for more information on running the platform from within Eclipse.

Once done, you can test your plugin : run the config. Some minor tweaks may need to be done, but that's basically it.

Before checking in your plugin, you may want to tag/branch in CVS so that the 1.0.x version of your plugin can be easily retrieved.

References

1. Java Persistence API
2. JPA explained @ sun
3. Hibernate Documentation
4. OSGI in a nutshell
5. Equinox home
6. Using Hibernate in a thick client environment
7. D2 plugin guide