Architectural Discussion and Design Overview 

I used the Profile Management Tool (PMT). I'm using a "stand alone" (not ND) application server because Rational doesn't require a jython/wasadmin script to deploy into this configuration. 

Global security > JAAS - J2C authentication data > new

Resources -> Data sources -> new

NOTE: You may need to add the DB2 drivers to Websphere

Right click Database Connections -> new

NOTE: Runtime and Server configured for Websphere v8.5. For development I use the "stand-alone" (not ND) application server because RAD doesn't require a wasadmin script to deploy into this environment. 

- Next

- check "add persistence support" - JPA 2.0 

- uncheck "add bundle to application (we'll create an application later for this project)

-> Next

I was previously working on Websphere Liberty... 

- leave defaults

NOTE: I'm going to try some Junit testing with this project... so I added the "driver library to build path". Normally, this isn't necessary because we'll be using a Websphere provided datasource. 

->  Next 

-> Finish

-> Next

-> Next

- no key generator

- creating a package: model

- no superclass 

-> Next

-> Finish

-> Next

- colorCode

- Not using "relationships" in this example

-> Add

Move colorcode into the "Order Attributes" 

-> OK

Make sure "convert Java set objects to Java list objects" is checked

-> Finish

===========

package model;

import java.io.Serializable;
import javax.persistence.*;


/**
* The persistent class for the COLORS database table.
*
*/
@Entity
@Table(name="COLORS")
@NamedQuery(name = "getColor", query = "SELECT c FROM Color c ORDER BY c.colorCode")
public class Color implements Serializable {
     private static final long serialVersionUID = 1L;

     @Id
     @Column(name="COLOR_CODE")
     private String colorCode;

     @Column(name="COLOR_NAME")
     private String colorName;

     public Color() {
     }

     public String getColorCode() {
          return this.colorCode;
     }

     public void setColorCode(String colorCode) {
          this.colorCode = colorCode;
     }

     public String getColorName() {
          return this.colorName;
     }

     public void setColorName(String colorName) {
          this.colorName = colorName;
     }

}

===========

----------------------------

<?xml version="1.0" encoding= "UTF-8"?>

<persistence version= "2.0" xmlns= "http://java.sun.com/xml/ns/persistence" xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

     <persistence-unit name ="jpa_osgi_example_01" transaction-type="RESOURCE_LOCAL" >

            <jta-data-source >jdbc/JPA_TEST </ jta-data-source>

           <non-jta-data-source >jdbc/JPA_TEST</ non-jta-data-source>

            <class >model.Color </class >

     </persistence-unit >

NOTE: See appendix (bottom of page) for full source list

- Select Color Entity

-> Next

- select "I want the container to inject the persistence unit..."

- We'll be generating an interface for BluePrint. So, add the "Impl" suffix to the generated Bean Name. 

-> Finish

- We'll follow the RAD package naming conventions for now

- NOTE: Don't forget to add in the "unitName" value. This is the "persistence-unit name" from "persitsence.xml".  

- We'll get Blueprint to make this happen

@SuppressWarnings("unchecked" )

public class ColorManagerImpl {

      @PersistenceUnit(unitName="jpa_osgi_example_01") // NOTE: Added this in for now - will set later in blueprint

     public ColorManager() {

right-click ColorManagerImpl -> Refactor -> Extract interface

- check  "Declare interface methods as public"

- uncheck "Declare interface methods as abstract"

-> OK

-------------

package model.controller;

import java.util.List;

import model.Color;

import com.ibm.jpa.web.Action;
import com.ibm.jpa.web.NamedQueryTarget;

public interface ColorManager {

     public void createColor(Color color) throws Exception;

     public void deleteColor(Color color) throws Exception;

     public void updateColor(Color color) throws Exception;

     public Color findColorByColorCode(String colorCode);

     public Color getNewColor();

     public List<Color> getColor();

}

------------

Blueprint helps us manage component instances and their interdependencies/wiring to each other. 

right-click project -> new -> under osgi -> blueprint file

-> next

leave default name and location:

[project_name]/BundleContent/OSGI-INF/blueprint

-> next

Because OSGi can be a little difficult to unit-test... well, I wasn't able to get jUnit running well enough for a test. So, quick workaround is to simply role-a-custom unit test harness for now (PaxExam is the recommended approach - and we'll get to that later).

This will be yet-another OSGi bundle that tests the JPA bundle... 

Accept defaults except that we set the versio nto "1.0.0"

-> Finish

accept defaults except for setting support for: JPA, Transaction, and Resource Reference

-> Finish

Blueprint ready to be used for connecting into JPA project

Edit MANIFEST.MF

Dependencies tab

1) Imported Packages -> Add

2) Select the "model" and "model.controller" packages

3) OK

- add a property and setter for reference to ColorManager (the thing we'll be testing)

- add one method for now: startUp()

NOTE: Moving more quickly through the tutorial since we already covered bean and service creation...

- Set "initialization method" to our "startUp()" method

1) Select "Blueprint" 

2) click Add

3) Select Reference

4) OK

5) Click Browse

6) Filter on "model.controller." package

7) Select the interface from the jpa_osgi_example_01 project

8) verify we're pointing to the correct project and interface

9) OK

10) manually type in the ID we'll use: ColorManagerReference

11) OK

NOTE: Do Not set "component name" (for some reason this prevented the reference from working correctly)

NOTE: Leave component name blank!

1) select ColorManagerReference

2) Click Add

3) Select Reference Listener

4) OK

1) Browse and select ColorManagerReference (don't leave it blank...)

2) Browse to referenceBind and referenceUnBind methods we created in ColorManager/ColorManagerImpl

1) Select ColorManagerReference 

2) Click Add

3) Select Property

4) OK

5) With colorManager Property selected

6) type in the property name used in JpaExapmleTest class

7) Browse Reference 

8) select ColorManagerReference

9) OK

---------------------------

<?xml version="1.0" encoding= "UTF-8"?>

<blueprint xmlns= "http://www.osgi.org/xmlns/blueprint/v1.0.0" xmlns:bpjpa= "http://aries.apache.org/xmlns/jpa/v1.0.0" xmlns:bptx= "http://aries.apache.org/xmlns/transactions/v1.0.0" xmlns:bpresref="http://www.ibm.com/appserver/schemas/8.0/blueprint/resourcereference" >

     <bean id ="JpaExampleTestBean" class= "jpa_tests.JpaExampleTest"

            init-method= "startUp">

            <property name ="colorManager" ref= "ColorManagerReference"/>

     </bean >

     <reference id ="ColorManagerReference"

            interface= "model.controller.ColorManager">

            <reference-listener bind-method ="referenceBind" unbind-method="referenceUnBind" ref ="ColorManagerReference"/>

     </reference >

- run a quick "sanity" check to make sure everything is in-place prior to coding our actual tests

-> Next

Naming it something identifiable... example: jpa_osgi_example_01_test_app

-> Next 

- jpa_osgi_example

- jpa_osgi_example test

-> Finish

-> Finish

Well, I did have a few errors (and yes... I did update the instructions!) 

1) Forgot (somehow) to save the jpa_osgi_example_01_test blueprint. Didn't have a required reference value...

2) Forgot to add "unitName" to ColorManagerImple "@PersistenceUnit" annotation

-> @PersistenceUnit(unitName="jpa_osgi_example_01") We'll later migrate this setting/value into blueprint

3) copy/paste error... pasted the "startup" sys'out message into the "onRegisterService" callback

I noticed the "waiting for" message on Websphere's "SystemOut.log" - this usually means something was missed. The missing "unitName" value caused the blueprint service to wait... (but since I've already made that mistake a few times - was easy to fix). I'll cover adding the property later in the blueprint itself. 

If everything is working properly, the startup and listener callbacks should report: 

- using CentOS v6.3 KDE console ("konsole") with a "find" left looking for "***" prefixes to all my "systemout" messages

1) ColorManagerImple.startUp() - we have ignition... 

2) ColorManagerImple.onRegisterService() - service registers with manager (called twice due to it being referenced by our test)

3) ColorManagerImple.referenceBind() - The jpa_osgi_exapmle_01_test binds to the (above) published (registered) interface

4) JpaExampleTest.startUp() - The test harness starts and is ready... for testing! 

See appendix for "JpaExampleTest.java" test code. 

- Tests execute within the "startUp()" method that's set to run, via blueprint, at jpa_osgi_example_01_test app startup

---------------------------------------

---------------------------------------

package model.controller;

import java.util.List;
import java.util.Map;

import model.Color;

import com.ibm.jpa.web.Action;
import com.ibm.jpa.web.NamedQueryTarget;

public interface ColorManager {

     public void createColor(Color color) throws Exception;

     public void deleteColor(Color color) throws Exception;

     public void updateColor(Color color) throws Exception;

     public Color findColorByColorCode(String colorCode);

     public Color getNewColor();

     public List<Color> getColor();
    
     // notifications
     // --------------------
     public void startUp();
    
     public void onRegisterService(ColorManager colorManager, Map props);

     public void onUnRegisterService(ColorManager colorManager, Map props);
    
     public void referenceBind(ColorManager colorManager);
    
     public void referenceUnBind(ColorManager colorManager);
     // --------------------
}

--------------------------------

--------------------------------

package model.controller;

import com.ibm.jpa.web.JPAManager;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;

import com.ibm.jpa.web.NamedQueryTarget;
import com.ibm.jpa.web.Action;
import javax.persistence.PersistenceUnit;
import javax.annotation.Resource;
import javax.transaction.UserTransaction;
import model.Color;
import java.util.List;
import java.util.Map;

import javax.persistence.Query;

@SuppressWarnings("unchecked")
@JPAManager(targetEntity = model.Color.class)
public class ColorManagerImpl implements ColorManager {

     @PersistenceUnit(unitName="jpa_osgi_example_01")
     private EntityManagerFactory emf;
     // Couldn't get UserTransaction working within OSGi
     //      Using EntityTransaction instead
     // @Resource
     // private UserTransaction utx;

     public ColorManagerImpl() {
    
     }

     private EntityManager getEntityManager() {
          return emf.createEntityManager();
     }

     @Override
     @Action(Action.ACTION_TYPE.CREATE)
     public void createColor(Color color) throws Exception {
          EntityManager em = this.getEntityManager();
          EntityTransaction et = em.getTransaction();
          try {
               et = em.getTransaction();
               et.begin();
               em.persist(color);
               et.commit();
          } catch (Exception ex) {
               ex.printStackTrace();
               try {
                    et.rollback();
               } catch (Exception e) {
                    ex.printStackTrace();
                    throw e;
               }
               throw ex;
          } finally {
               em.close();
          }
     }

     @Override
     @Action(Action.ACTION_TYPE.DELETE)
     public void deleteColor(Color color) throws Exception {
          EntityManager em = getEntityManager();
          EntityTransaction et = em.getTransaction();
          try {
               et.begin();
               color = em.merge(color);
               em.remove(color);
               et.commit();
          } catch (Exception ex) {
               try {
                    et.rollback();
               } catch (Exception e) {
                    ex.printStackTrace();
                    throw e;
               }
               throw ex;
          } finally {
               em.close();
          }
     }

     @Override
     @Action(Action.ACTION_TYPE.UPDATE)
     public void updateColor(Color color) throws Exception {
          EntityManager em = getEntityManager();
          EntityTransaction et = em.getTransaction();
          try {
               et.begin();
               color = em.merge(color);
               et.commit();
          } catch (Exception ex) {
               try {
                    et.rollback();
               } catch (Exception e) {
                    ex.printStackTrace();
                    throw e;
               }
               throw ex;
          } finally {
               em.close();
          }
     }

     @Override
     @Action(Action.ACTION_TYPE.FIND)
     public Color findColorByColorCode(String colorCode) {
          Color color = null;
          EntityManager em = getEntityManager();
          try {
               color = (Color) em.find(Color.class, colorCode);
          } finally {
               em.close();
          }
          return color;
     }

     @Override
     @Action(Action.ACTION_TYPE.NEW)
     public Color getNewColor() {
    
          Color color = new Color();
    
          return color;
     }

     @Override
     @NamedQueryTarget("getColor")
     public List<Color> getColor() {
          EntityManager em = getEntityManager();
          List<Color> results = null;
          try {
               Query query = em.createNamedQuery("getColor");
               results = (List<Color>) query.getResultList();
          } finally {
               em.close();
          }
          return results;
     }

     @Override
     public void startUp() {
          System.out.println("*** ColorManagerImpl.startUp()");
         
     }

     @Override
     public void onRegisterService(ColorManager colorManager, Map props) {
          System.out.println("*** ColorManagerImpl.onRegisterService()");
         
     }

     @Override
     public void onUnRegisterService(ColorManager colorManager, Map props) {
          System.out.println("*** ColorManagerImpl.onUnRegisterService()");
         
     }

     @Override
     public void referenceBind(ColorManager colorManager) {
          System.out.println("*** ColorManagerImpl.referenceBind()");
         
     }

     @Override
     public void referenceUnBind(ColorManager colorManager) {
          System.out.println("*** ColorManagerImpl.referenceUnBind()");
         
     }

}

------------------------------------

------------------------------------

package jpa_tests;

import java.util.List;

import model.Color;
import model.controller.ColorManager;

public class JpaExampleTest {
    
     private Color testColor = new Color("TestCode1","TestName1");
    
     private ColorManager colorManager = null;
    
     public ColorManager getColorManager() {
          return colorManager;
     }

     public void setColorManager(ColorManager colorManager) {
          this.colorManager = colorManager;
     }

     public void startUp() {
          System.out.println("*** JpaExampleTest.startUp CALLED");
         
          // start tests
          testAllOps();
     }
    
     public String testAllOps() {
         
         
         
         
          System.out.println("*** JpaExampleTest: STARTING TESTS");
          System.out.println("*** JpaExampleTest: ------------------");
          // ---------------------------------
          // colorManager must be set by blueprint (cannot be null)
          // ---------------------------------
          if(this.colorManager==null){
               System.out.println("*** JpaExampleTest: colorManager==null ");
               return "fail";
          }
          // ---------------------------------
         
          // ---------------------------------
          // test select
          // ---------------------------------
          System.out.println("*** JpaExampleTest: ------------------");
          System.out.println("*** JpaExampleTest: Test getColor");
          List<Color> list = null;
          try {
               list = colorManager.getColor();
          } catch (Exception e) {
               e.printStackTrace();
          }
         
          for (Color color : list) {
               System.out.println("*** color code: "+ color.getColorCode());
          }

         
         
          System.out.println("*** JpaExampleTest: createColor(myTestColor)");
          // Color myNewColor = new Color("foo","bar");
          try {
               this.colorManager.createColor(this.testColor);
               // this.colorManager.createColor(myNewColor);
               System.out.println("*** JpaExampleTest: createColor -> no errors so far");
          } catch (Exception e) {
               e.printStackTrace();
          }

         
         
          System.out.println("*** JpaExampleTest: ------------------");
          System.out.println("*** JpaExampleTest: verify Create - look up created color");
         
          Color color = this.colorManager.findColorByColorCode(this.testColor.getColorCode());
         
          if (color.getColorCode().equals(this.testColor.getColorCode())) {
               System.out.println("*** JpaExampleTest created color found: "+ color.getColorCode());
          } else {
               System.out.println("*** JpaExampleTest created color NOT FOUND!");
          }


          System.out.println("*** JpaExampleTest: ------------------");
          System.out.println("*** JpaExampleTest: update color name");
         
          Color changedColor = new Color(this.testColor.getColorCode(),
                                                this.testColor.getColorName()+"_meh");
          try {
               this.colorManager.updateColor(changedColor);
          } catch (Exception e) {
               e.printStackTrace();
          }
         
          Color myChangedSavedColor = this.colorManager.findColorByColorCode(this.testColor.getColorCode());
         
          if (myChangedSavedColor.getColorName().equals(changedColor.getColorName())) {
               System.out.println("*** JpaExampleTest changed color did change: "+ myChangedSavedColor.getColorName());
          } else {
               System.out.println("*** JpaExampleTest hanged color did NOT change!: "+ myChangedSavedColor.getColorName());
          }
    
         
          System.out.println("*** JpaExampleTest: ------------------");
          System.out.println("*** JpaExampleTest: delete test color");
          try {
               this.colorManager.deleteColor(testColor);
          } catch (Exception e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
          }
          Color myDeletedColorGone = this.colorManager.findColorByColorCode(this.testColor.getColorCode());
          if (myDeletedColorGone == null ) {
               System.out.println("*** JpaExampleTest: delete test color PASSED... NOT FOUND");
          }
         
         
         
          System.out.println("*** JpaExampleTest: DONE...");
          System.out.println("*** JpaExampleTest: ------------------");
          System.out.println("*** JpaExampleTest: ------------------");
          return "pass";
     }

}