Demonstrate the need for test resources

1. Add a getPeopleByName() method to the EJB and @Remote interface that returns the collection provided by the business logic method by the same name. The business logic will have gotten this directly from the persistence provider. Therefore, this is the result of an EntityManager.createQuery("...").getResultList();

   $ cat ./javaeeExEJB/src/main/java/myorg/javaeeex/ejb/RegistrarRemote.java
   ...
   import java.util.Collection;
   ...
   @Remote
   public interface RegistrarRemote {
       void ping();
       Person createPerson(Person person)
           throws RegistrarException;
   
       Person getPersonById(long id)
           throws RegistrarException;
   
   
       Collection<Person> getPeopleByName(String firstName, String lastName)
           throws RegistrarException;
   }

   $ cat ./javaeeExEJB/src/main/java/myorg/javaeeex/ejb/RegistrarEJB.java
   ...
   import java.util.Collection;
   ...
       public Collection<Person> getPeopleByName(
           String firstName, String lastName)
           throws RegistrarException {
           log.debug("*** getPeopleByName() ***");
   
           try {
               return registrar.getPeopleByName(firstName, lastName);
           }
           catch (Throwable ex) {
               log.error(ex);
               throw new RegistrarException(ex.toString());
           }
       }

2. Add a test to the RMI Test that invokes the new method and attempts to inspect the contents of the collection that is returned.

   $ cat ./javaeeExTest/src/test/java/myorg/javaeeex/ejbclient/RegistrarIT.java
   ...
   import java.util.Collection;
   ...
       @Test
       public void testLazy() throws Exception {
           log.info("*** testLazy ***");
   
           for(int i=0; i<10; i++) {
               Person person = makePerson();
               person.setLastName("smith" + i);
               registrar.createPerson(person);
           }
   
               //the first time we are going to get people straight from the DAO,
               //without cleaning the managed object or creating a new DTO.
           Collection<Person> people = registrar.getPeopleByName("joe", "%");
           assertEquals("unexpected number of lazy people",10, people.size());
       }

3. Attempt to build and run the application from the root level. Note how the test fails because we have residue left over from the first test when running the second test.

   $ mvn clean install -rf :javaeeExEJB
   
    -*** testLazy ***
   Tests run: 3, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 2.704 sec <<< FAILURE!
   
   Results :
   
   Failed tests:   testLazy(myorg.javaeeex.ejbclient.RegistrarIT): unexpected number of lazy people expected:<10> but was:<11>
   
   Tests run: 3, Failures: 1, Errors: 0, Skipped: 0
   
   ...
   [INFO] Java EE Exercise EJB .............................. SUCCESS [7.366s]
   [INFO] Java EE Exercise EAR .............................. SUCCESS [1.416s]
   [INFO] Java EE Exercise Remote Test ...................... FAILURE [15.709s]
   [INFO] ------------------------------------------------------------------------
   [INFO] BUILD FAILURE

   Test set: myorg.javaeeex.ejbclient.RegistrarIT
    -------------------------------------------------------------------------------
   Tests run: 3, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 2.704 sec <<< FAILURE!
   testLazy(myorg.javaeeex.ejbclient.RegistrarIT)  Time elapsed: 0.503 sec  <<< FAILURE!
   java.lang.AssertionError: unexpected number of lazy people expected:<10> but was:<11>
           at org.junit.Assert.fail(Assert.java:93)
           at org.junit.Assert.failNotEquals(Assert.java:647)
           at org.junit.Assert.assertEquals(Assert.java:128)
           at org.junit.Assert.assertEquals(Assert.java:472)
           at myorg.javaeeex.ejbclient.RegistrarIT.testLazy(RegistrarIT.java:85)

Demonstrate Lazy Load Problem

1. Go a little deeper into the Collection returned by the EJB. Attempt to invoke a method on each member in the collection.

   $ cat ./javaeeExTest/src/test/java/myorg/javaeeex/ejbclient/RegistrarIT.java
   
   ...
       public void testLazy() throws Exception {
   
           ...
   
           Collection<Person> people = registrar.getPeopleByName("joe", "%");
           assertEquals("unexpected number of lazy people",10, people.size());
           for (Person p: people) {
               p.getAddresses().iterator().next().getZip();
           }

2. Attempt to rebuild the application from the root and note the exception. Due to LazyLoading, the information for each Address was never actually retrieved.

    -*** testLazy ***
   Tests run: 3, Failures: 0, Errors: 1, Skipped: 0, Time elapsed: 2.693 sec <<< FAILURE!
   
   Results :
   
   Tests in error: 
     testLazy(myorg.javaeeex.ejbclient.RegistrarIT): failed to lazily initialize a collection of role: 
           myorg.javaeeex.bo.Person.addresses, no session or session was closed
   
   Tests run: 3, Failures: 0, Errors: 1, Skipped: 0
   
   ...
   [INFO] Java EE Exercise EJB .............................. SUCCESS [6.687s]
   [INFO] Java EE Exercise EAR .............................. SUCCESS [0.837s]
   [INFO] Java EE Exercise Remote Test ...................... FAILURE [15.746s]
   [INFO] ------------------------------------------------------------------------
   [INFO] BUILD FAILURE

   ./javaeeExTest/target/surefire-reports/myorg.javaeeex.ejbclient.RegistrarIT.txt
   ::::::::::::::
   Test set: myorg.javaeeex.ejbclient.RegistrarIT
    -------------------------------------------------------------------------------
   Tests run: 3, Failures: 0, Errors: 1, Skipped: 0, Time elapsed: 2.692 sec <<< FAILURE!
   testLazy(myorg.javaeeex.ejbclient.RegistrarIT)  Time elapsed: 0.484 sec  <<< ERROR!
   org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: myorg.javaeeex.bo.Person.addresses, no session or session 
   was closed
       ...
           at org.hibernate.collection.internal.PersistentBag.iterator(PersistentBag.java:266)
           at myorg.javaeeex.ejbclient.RegistrarIT.testLazy(RegistrarIT.java:105)

Demonstrate a solution to Lazy Load Problem

1. Create a new method for the EJB that will hydrate the Address objects before returning the collection. This is unqiue to the @Remote interface and need not be on the business logic interface.

   $ cat ./javaeeExEJB/src/main/java/myorg/javaeeex/ejb/RegistrarRemote.java
   
   ...
   public interface RegistrarRemote {
       Collection<Person> getPeopleByNameHydrated(String firstName, String lastName)
           throws RegistrarException;
   }

   $ cat ./javaeeExEJB/src/main/java/myorg/javaeeex/ejb/RegistrarEJB.java
   
   ...
   import myorg.javaeeex.bo.Address;
   ...
       public Collection<Person> getPeopleByNameHydrated(
               String firstName, String lastName)
               throws RegistrarException {
           log.debug("*** getPeopleByNameHydrated() ***");
   
           try {
               Collection<Person> people =
                   registrar.getPeopleByName(firstName, lastName);
               for (Person p: people) {
                   hydratePerson(p);
               }
               return people;
           }
           catch (Throwable ex) {
               log.error(ex);
               throw new RegistrarException(ex.toString());
           }
       }
   
       private void hydratePerson(Person person) {
           for (Address address : person.getAddresses()) {
               address.getZip();
           }
       }

2. Update the test method to account for the LazyLoadException and now go on to test the hydrated form of the method.

   $ cat ./javaeeExTest/src/test/java/myorg/javaeeex/ejbclient/RegistrarIT.java
   
   ...
   import org.hibernate.LazyInitializationException;
   ...
       @Test
       public void testLazy() throws Exception {
   
           ...
   
           Collection<Person> people = registrar.getPeopleByName("joe", "%");
           assertEquals("unexpected number of lazy people",10, people.size());
           try {
               for (Person p: people) {
                   p.getAddresses().iterator().next().getZip();
               }
               fail("no lazy instantiation exception thrown");
           }
           catch (LazyInitializationException expected) {
               log.info("got expected lazy instantiation exception:" + expected);
           }
   
               //this time, the EJB will be asked to walk the graph returned
           people = registrar.getPeopleByNameHydrated("joe", "%");
           assertEquals("unexpected number of loaded people",10, people.size());
           for (Person p: people) {
               p.getAddresses().iterator().next().getZip();
           }

3. Rebuild from the root of the application.

   $ mvn clean install
   
   ...
   
    -*** testLazy ***
    -got expected lazy instantiation exception:org.hibernate.LazyInitializationException: 
       failed to lazily initialize a collection of role: myorg.javaeeex.bo.Person.addresses, no session or session was closed
   Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.477 sec
   
   Results :
   
   Tests run: 3, Failures: 0, Errors: 0, Skipped: 0
   
   ...
   [INFO] Java EE Exercise .................................. SUCCESS [0.658s]
   [INFO] Java EE Exercise Impl ............................. SUCCESS [15.167s]
   [INFO] Java EE Exercise EJB .............................. SUCCESS [3.415s]
   [INFO] Java EE Exercise EAR .............................. SUCCESS [2.034s]
   [INFO] Java EE Exercise Remote Test ...................... SUCCESS [14.965s]
   [INFO] ------------------------------------------------------------------------
   [INFO] BUILD SUCCESS

Demonstrate the detached, but once-managed POJOs have provider classes associated with them

1. Add a test method that returns a collection of Persons and their associated Address. Inspect the class of the collection that holds the Addresses. Note that it is a persistence provider class. If you do not have the provider's classes in your classpath you will suffer a demarshalling/class-not-found exception. With JBoss, it is version-dependent whether they provide these classes as part of their RMI client .jar file. Take a look. Your Person is not quite a "plain" POJO.

   $ cat ./javaeeExTest/src/test/java/myorg/javaeeex/ejbclient/RegistrarIT.java
   
   ...
   
       @Test
       public void testPOJO() throws Exception {
           log.info("*** testPOJO ***");
   
           for(int i=0; i<10; i++) {
               Person person = makePerson();
               person.setLastName("smith" + i);
               registrar.createPerson(person);
           }
           //the objects returned will be fully loaded, but...
           Collection<Person> people =
               registrar.getPeopleByNameHydrated("joe", "%");
           assertEquals("unexpected number of managed people",10, people.size());
   
   
               //the collection class requires hibernate to be in the path
           Class<?> clazz = people.iterator().next().getAddresses().getClass();
           log.debug("collection class=" + clazz);
           assertTrue("unexpected collection class",
                   clazz.getPackage().getName().contains("hibernate"));
   
       }

2. Rebuild your application from the root and note the output as well as the results of the above JUnit assert.

     -*** testPOJO ***
      -collection class=class org.hibernate.collection.PersistentBag

Use a cleaning approach to return plain POJOs

In this first approach we will reuse our POJO class of the entity to construct a "plain" POJO. This will involve some tedious copying of data from the provider entity object to the plain POJO object.

1. Create a new getPeopleByNameCleaned() method in the EJB. Have this method instantiate clean POJOs and populate them with the data from the managed entities. Be careful to copy data with a collection and not the entire collection itself.

   $ cat ./javaeeExEJB/src/main/java/myorg/javaeeex/ejb/RegistrarRemote.java
   
   ...
   public interface RegistrarRemote {
       ...
   
       Collection<Person> getPeopleByName(String firstName, String lastName)
           throws RegistrarException;
       Collection<Person> getPeopleByNameHydrated(String firstName, String lastName)
           throws RegistrarException;
       Collection<Person> getPeopleByNameCleaned(String firstName, String lastName)
           throws RegistrarException;
   }

   $ cat ./javaeeExEJB/src/main/java/myorg/javaeeex/ejb/RegistrarEJB.java
   
   ...
   import java.util.ArrayList;
   ...
       public Collection<Person> getPeopleByNameCleaned(
               String firstName, String lastName)
               throws RegistrarException {
           log.debug("*** getPeopleByNameCleaned() ***");
   
           try {
               Collection<Person> people = new ArrayList<Person>();
               for (Person personBO :
                   registrar.getPeopleByName(firstName, lastName)) {
   
                   Person personPOJO = new Person(personBO.getId());
                   personPOJO.setFirstName(personBO.getFirstName());
                   personPOJO.setLastName(personBO.getLastName());
                   personPOJO.setSsn(personBO.getSsn());
                   for (Address addressBO : personBO.getAddresses()) {
                       Address addressPOJO = new Address(
                               addressBO.getId(),
                               addressBO.getStreet(),
                               addressBO.getCity(),
                               addressBO.getState(),
                               addressBO.getZip());
                       personPOJO.getAddresses().add(addressPOJO);
                   }
                   people.add(personPOJO);
               }
               return people;
           }
           catch (Throwable ex) {
               log.error(ex);
               throw new RegistrarException(ex.toString());
           }
       }

2. Add a test of the cleaned approach and verify the collection and rest of the POJO is, in fact, "plain" and free of provider classes.

   $ cat ./javaeeExTest/src/test/java/myorg/javaeeex/ejbclient/RegistrarIT.java
   
   ...
       public void testPOJO() throws Exception {
   
           ...
   
               //now get a graph of objects that contain pure POJO classes. The
               //server will create fresh POJOs for DTOs and pass information from
               //the business object POJO to the data transfer object POJO.
           people = registrar.getPeopleByNameCleaned("joe", "%");
           assertEquals("unexpected number of clean people",10, people.size());
           for (Person p: people) {
               p.getAddresses().iterator().next().getZip();
           }
   
               //the POJOs are cleansed of their hibernate types
           clazz = people.iterator().next().getAddresses().getClass();
           log.debug("collection class=" + clazz);
           assertFalse("unexpected collection class",
                   clazz.getPackage().getName().contains("hibernate"));
       }

3. Rebuild the application from the root level. Note the collection class types produced and the results of the assertions included.

    -*** testPOJO ***
    -collection class=class org.hibernate.collection.PersistentBag
    -collection class=class java.util.ArrayList

Use a DTO approach to return plain POJOs

With the POJO cleaning approach, we manually instantiated and populated POJOs to be returned and used our entity classes as the implementation class for the POJOs. However, we could have also used DTOs just as easily, except for the effort of creating separate classes. See the next section for a coverage of DTOs.

Create DTOs

1. Create a set of Person and Address DTO classes to transfer information to/from the client. Have the PersonDTO not carry the Person's SSN. Be sure to make these classes Serializable. These classes can go in either the EJB module with the rest of the @Remote interfaces or in a lower-level module if they happen to get referenced (i.e., created by a DAO query) by lower-level packages. For the class project, the BO project is a safe and easy place to put them, but we will place them in the EJB module for this exercise since they are not used anywhere in the lower levels.

   $ mkdir -p javaeeExEJB/src/main/java/myorg/javaeeex/dto

   $ cat javaeeExEJB/src/main/java/myorg/javaeeex/dto/PersonDTO.java
   
   package myorg.javaeeex.dto;
   
   import java.io.Serializable;
   import java.util.ArrayList;
   import java.util.Collection;
   
   public class PersonDTO implements Serializable {
       private static final long serialVersionUID = 1L;
       private long id;
       private String firstName;
       private String lastName;
       private Collection<AddressDTO> addresses = new ArrayList<AddressDTO>();
   
       public PersonDTO() {}
       public PersonDTO(long id) { setId(id); }
   
       public long getId() {
           return id;
       }
       private void setId(long id) {
           this.id = id;
       }
       public String getFirstName() {
           return firstName;
       }
       public void setFirstName(String firstName) {
           this.firstName = firstName;
       }
       public String getLastName() {
           return lastName;
       }
       public void setLastName(String lastName) {
           this.lastName = lastName;
       }
       public Collection<AddressDTO> getAddresses() {
           return addresses;
       }
       public void setAddresses(Collection<AddressDTO> addresses) {
           this.addresses = addresses;
       }
       public String toString() {
           StringBuffer text = new StringBuffer();
           text.append("id=" + id);
           text.append(":" + firstName);
           text.append(" " + lastName);
           text.append(", addresses={");
           for (AddressDTO address : addresses) {
               text.append("{" + address.toString() + "},");
           }
           text.append("}");
           return text.toString();
       }
   }

   $ cat javaeeExEJB/src/main/java/myorg/javaeeex/dto/AddressDTO.java
   
   package myorg.javaeeex.dto;
   
   import java.io.Serializable;
   
   public class AddressDTO implements Serializable {
       private static final long serialVersionUID = 1L;
       private long id;
       private String street;
       private String city;
       private String state;
       private String zip;
   
       public AddressDTO() {}
       public AddressDTO(
               long id, String street, String city, String state, String zip) {
           this.id = id;
           this.city = city;
           this.state = state;
           this.street = street;
           this.zip = zip;
       }
   
       public long getId() {
           return id;
       }
       @SuppressWarnings("unused")
       private void setId(long id) {
           this.id = id;
       }
   
       public String getStreet() {
           return street;
       }
       public void setStreet(String street) {
           this.street = street;
       }
       public String getCity() {
           return city;
       }
       public void setCity(String city) {
           this.city = city;
       }
       public String getState() {
           return state;
       }
       public void setState(String state) {
           this.state = state;
       }
       public String getZip() {
           return zip;
       }
       public void setZip(String zip) {
           this.zip = zip;
       }
   
       public String toString() {
           StringBuilder text = new StringBuilder();
   
           text.append(street + " ");
           text.append(city + ", ");
           text.append(state + " ");
           text.append(zip);
           return text.toString();
       }
   }

2. Your EJB should now look like the following

   javaeeEx                                                                                         
   |-- javaeeExEJB                                                                               
   |   |-- pom.xml                                                                               
   |   `-- src                                                                                   
   |       `-- main                                                                              
   |           |-- java                                                                          
   |           |   `-- myorg                                                                     
   |           |       `-- javaeeex                                                              
   |           |           |-- dto                                                               
   |           |           |   |-- AddressDTO.java                                               
   |           |           |   `-- PersonDTO.java                                                
   |           |           `-- ejb                                                               
   |           |               |-- RegistrarEJB.java                                             
   |           |               |-- RegistrarLocal.java                                           
   |           |               |-- RegistrarRemote.java                                          
   |           |               |-- TestUtilEJB.java                                              
   |           |               `-- TestUtilRemote.java                                           
   |           `-- resources                                                                     
   |               `-- META-INF                                                                  
   |                   `-- persistence.xml      

Add a method to the EJB

1. Add a new getPeopleByNameDTO() method that will return the results using the DTO classes created above.

   $ cat ./javaeeExEJB/src/main/java/myorg/javaeeex/ejb/RegistrarRemote.java
   
   ...
   import myorg.javaeeex.dto.PersonDTO;
   
   public interface RegistrarRemote {
       ...
   
       Collection<Person> getPeopleByName(String firstName, String lastName)
           throws RegistrarException;
       Collection<Person> getPeopleByNameHydrated(String firstName, String lastName)
           throws RegistrarException;
       Collection<Person> getPeopleByNameCleaned(String firstName, String lastName)
           throws RegistrarException;
       Collection<PersonDTO> getPeopleByNameDTO(String firstName, String lastName)
           throws RegistrarException;
   }

   $ cat ./javaeeExEJB/src/main/java/myorg/javaeeex/ejb/RegistrarEJB.java
   
   ...
   import myorg.javaeeex.dto.AddressDTO;
   import myorg.javaeeex.dto.PersonDTO;
   ...
      public Collection<PersonDTO> getPeopleByNameDTO(
              String firstName, String lastName)
              throws RegistrarException {
          log.debug("*** getPeopleByNameDTO() ***");
   
          try {
              Collection<PersonDTO> people = new ArrayList<PersonDTO>();
              for (Person personBO :
                  registrar.getPeopleByName(firstName, lastName)) {
   
                  PersonDTO personDTO = makeDTO(personBO);
                  people.add(personDTO);
              }
              return people;
          }
          catch (Throwable ex) {
              log.error(ex);
              throw new RegistrarException(ex.toString());
          }
      }
   
      private PersonDTO makeDTO(Person personBO) {
          PersonDTO personDTO = new PersonDTO(personBO.getId());
          personDTO.setFirstName(personBO.getFirstName());
          personDTO.setLastName(personBO.getLastName());
          //note that there is no SSN in the DTO
          for (Address addressBO : personBO.getAddresses()) {
              AddressDTO addressDTO = new AddressDTO(
                      addressBO.getId(),
                      addressBO.getStreet(),
                      addressBO.getCity(),
                      addressBO.getState(),
                      addressBO.getZip());
              personDTO.getAddresses().add(addressDTO);
          }
          return personDTO;
      }

Use the new EJB method from the RMI Test

1. Add a test of the DTO capability from the RMI Test.

   $ cat ./javaeeExTest/src/test/java/myorg/javaeeex/ejbclient/RegistrarIT.java
   
   ...
   import myorg.javaeeex.dto.AddressDTO;
   import myorg.javaeeex.dto.PersonDTO;
   ...
   
       @Test
       public void testDTOs() throws Exception {
           log.info("*** testDTOs ***");
   
           for(int i=0; i<10; i++) {
               Person person = makePerson();
               person.setLastName("smith" + i);
               registrar.createPerson(person);
           }
   
           //now get a graph of objects that contain pure DTOs versus BOs
           Collection<PersonDTO>peopleDTO =
               registrar.getPeopleByNameDTO("joe", "%");
           assertEquals("unexpected number of DTO people",10, peopleDTO.size());
           for (PersonDTO p: peopleDTO) {
                   Collection<AddressDTO> a = p.getAddresses();
               a.iterator().next().getZip();
           }
           //the DTOs are POJOs that are designed to only contain what the
           //clients needs to see. It contains no server-side behavior and
           //could be represented as an XML document. In this example, we
           //have excluded the SSN from the PersonDTO.
       }

2. Rebuild and test your application from the root. We now are passing information to the RMI client using DTO classes instead of the persisted entity classes.

   $ mvn clean install -rf :javaeeExEJB
   
   ...
    -*** testDTOs ***
   Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.817 sec
   
   Results :
   
   Tests run: 5, Failures: 0, Errors: 0, Skipped: 0
   
   ...
   [INFO] Java EE Exercise EJB .............................. SUCCESS [5.273s]
   [INFO] Java EE Exercise EAR .............................. SUCCESS [1.059s]
   [INFO] Java EE Exercise Remote Test ...................... SUCCESS [13.384s]
   [INFO] ------------------------------------------------------------------------
   [INFO] BUILD SUCCESS