Creating Persistent Java Classes in Hibernate

The entire work of Hibernate is encapsulated in its ability to take the values from Java class
attributes and persist them to a database table. the mapping docu-ment
is key in determining how Hibernate pulls the values from the classes. Unless Hibernate is
changed from its default behavior, it uses reflection to determine how to access the attributes of
the Java class. As a developer of the Java class, it’s your responsibility to create the class in a con-sistent
manner.
You need to follow some simple guidelines when developing Java classes:
❑Hibernate will only persist attributes specified in the mapping document; therefore you
can include in your class as many temporary attributes as needed. If the temporary
attributes aren’t persisted, their values will be lost when the object is loaded from perma-nent
storage in the future.
❑All attributes that will be persisted should be declared private and have setter/getting
methods defined in the JavaBean style. For example:
private String firstname;
public String getFirstname() {
return firstname;
}
public void setFirstname(String s) {
firstname = s;
}
Note that the setter/getter methods don’t need to be declared public, because Hibernate can
locate them using reflection even if they’re protected or private. Further, you can use a method
name like isFirstname() as well as set and get.
❑Hibernate can handle mapping from just about any data type. If you’re using Java primitives
and JDK types, use the type, and refer to the Hibernate types described in the Chapter 4 when
creating the mapping document.
❑If an attribute type is a collection like a Map, List, or Set, you’ll need to do additional work
when creating the mapping. For collections,
❑Mapped classes can use the concept of composition, where an attribute’s type is another class.
The last half of Chapter 6 discusses composition mapping also called components in Hibernate
in full detail.
❑All classes should contain an ID in order to allow easy identification of your objects within
Hibernate and the database. As you read in Chapter 4, IDs have values like int, long, or String.
Be sure to use the right type when defining your ID, especially if you’re using an ID generator.
❑Interfaces, final classes, and some inner classes can be mapped to permanent storage using
Hibernate. See later sections in this chapter for more information.
❑All Java classes that will be persisted need a default constructor.