New Tricks With Design Pattern: Java Value Types

The use of design patterns has improved software design and development productivity for more than the last 10 years. In this very familiar role, design patterns are recurring objects and the methods for using them, which can be applied to recurring software development problems. Now we have the “Java Value Types” design pattern, an extension to the value object pattern. Developers will find that, in many respects, they are like value objects on steroids.

Java Value Types (JVTs) are an application of a common value type pattern to the Java Language. These JVTs target the use of “managed entities”. They are essentially “helper” classes primarily useful for representing a snapshot of an EJBs state. They also are used to transport and adapt this state to and from other formats, such as XML. To get an idea of its usefulness, consider this example of the Java value type pattern.

This example shows a common JVT class for all ShopItems. There are 2 subclasses shown to represent Books, and Clothing. The attributes shown would be implemented as JavaBean properties, each with a setter and getter. The Book class might look like this:

public class Book extends ShopItem {
	public void setPublisher(String publisher)  { ... }
	public String getPublisher() { ... }
	public void setAuthor(String author) { .... }
	public String getAuthor() { ... }
	public void setTitle(String title) { .... }
	public String getTitle() { ... }
	public boolean equals(Object other) { … }

JVTs are pretty straight-forward, and in many ways represent a standard model of objects focused on transporting and managing state. The importance here is only exposing the specific types of the objects to those systems which access the specific types. The user interface and persistence systems can either cast to the specific class to use all the methods, or use reflection to access all the state. Other sub-systems such as billing, accounting, or the shopping cart are only exposed to the ShopItem interfaces.