HiberObjects is a UML tool for programmers, especially suited for Hibernate, JPA, GWT and Grails.
We want to use UML in an agile way, following these principles:
HiberObjects supports UML class diagrams, sequence diagrams and object diagrams. It can generate code for Java Persistence API (JPA) or Hibernate classes and DAO's, GWT services and unit tests.
The generated JPA classes can be used as the model in a Grails application.
PropertyChange support and DTO's for Google Web Toolkit (GWT) can also be generated.
For example, a simple domain model for ordering airplane tickets can be designed in the class diagram below:
HiberObjects will then generate Java classes with JPA annotations or Hibernate mapping files. A helper class will also be generated, so just this diagram will generate all the code we need to create a database schema and read and write Java objects in the database.
The class diagram can be used to identify behavior. For instance, when a user orders a ticket, we need to create a Ticket object. The class diagram shows that the Ticket shall be connected it to 1 Customer and 1 Flight.
So, when a customer wants to order a Ticket, we need to find or create a Customer object, and let the customer select the desired Flight.
To select a Flight, the user will go through the following steps:
We will implement this logic in a class OrderTicket.
This object will gather the information from the user input and place the order when ready.
Here is our first proposal for business methods:
1. Select an Airport to depart from
The listDepartures() method will return all available Airports,
the user will select one of them and set the departure
in the OrderTicket object.
2. Select the destination Airport
The user will view the destinations using listDestinations().
This method will return all Airports that can be reached from the selected departure.
The user will select one of them and set the destination
in the OrderTicket object.
3. Select one of the available Flights
Finally, the user will select a Flight with listFlights(),
which returns all Flights between the selected departure and destination.
Then, the user will set OrderTicket.flight to store the selection
and call placeOrder() to make the payment.
Now, we want to test our methods.
The first method, listDepartures(), should return all Airport objects in the database.
To test OrderTicket, we will create another class OrderTicketTest
that will prepare some objects, call methods in OrderTicket and verify the results.
We set the stereotype of OrderTicketTest to <<Persistent Test>>.
This will generate some code that makes it easy to test with a database.
We design some objects for OrderTicketTest in an object diagram.
HiberObjects will create a method called setUp() in the OrderTicketTest class.
This method will create the designed objects and store them in a database.
We implement testListDepartures() in Java to call listDepartures() and
verify that it returns 2 Airport objects:
public void testListDepartures() throws Exception {
List<Airport> departures = order.listDepartures();
HashSet<String> departureNames = new HashSet<String>();
for(Airport a : departures)
departureNames.add(a.getCode());
String[] expected = { "OSL", "ARL" };
assertEquals("departures", new HashSet<String>(Arrays.asList(expected)), departureNames);
}By default, HiberObjects creates a hibernate.properties file that is configured with HSQLDB running in memory as follows:
hibernate.connection.url=jdbc:hsqldb:mem:mydatabase
hibernate.hbm2ddl.auto=create-dropThis is perfect for unit testing, because we don't need to start a database server, and the database schema is created automatically at startup.
We don't expect the test to succeed, we have not even implemented listDepartures() yet.
Actually, the method will not even compile now.
So, let's implement it. Right-click on listDepartures() in the OrderTicket class
and select Edit Query.
This will open a dialog box with a suggested query in HQL (Hibernate Query Language):
from Airport a
This seems reasonable. Let's save the query and run the test in JUnit.
Success! The method works.
So what have we accomplished? We have implemented the first business method and verified that it works. We have actually created a database with 4 tables, inserted 4 rows, read 2 rows back and mapped everything to Java objects. That's not bad with this little effort!
We have also created a unit test that we can run periodically to ensure that this functionality doesn't break at a later time. We will automate this with JUnit. Automation is crucial, because it will take far too much resources to test everything manually all the time.
We have achieved this with very little Java code. All the domain objects are generated completely from a class diagram, and the test objects are designed in an object diagram. Not only is this very productive, but the diagrams are also useful for documentation and for discussions with others.
Admittedly, this was a very simple method to test, but it wouldn't be this easy to do it all in plain Java. The following pages go through more details, more unit testing and how to create DAO classes that handle the interaction with Hibernate.