If you need to map Java 5 Enums to Hibernate using JPA annotations
this is
you are looking for.
First, a sample POJO from AppFuse Persistence tutorial to demo how
to use
the annotations.
--- cut here -------------------------------------
package org.appfuse.tutorial.model;
@Entity
@Table(name="t_person")
public class Person extends BaseObject {
// Enumerations ---------------------------
public enum Sex{
MALE(1),
FEMALE(2);
private int value;
Sex(int value) {
this.value = value;
}
// the identifierMethod
public int toInt() {
return value;
}
// the valueOfMethod
public static Sex fromInt(int value) {
switch(value) {
case 1: return MALE;
case 2: return FEMALE;
default:
return UNKNOW;
}
}
public String toString() {
switch(this) {
case MALE:
return "Male";
case FEMALE:
return "Female";
}
}
}
// Attributes ---------------------------
@Id
@Column(name= "person_id")
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Column(name="person_firstname", length = 50, nullable = false)
private String firstName;
@Column(name="person_lastname", length = 50, nullable = false)
private String lastName;
@Column(name= "person_sex", columnDefinition="integer", nullable
= true)
@Type(type =
"org.appfuse.tutorial.commons.hibernate.GenericEnumUserType
",
parameters = {
@Parameter(
name = "enumClass",
value = "org.appfuse.tutorial.model.Person$Sex"),
@Parameter(
name = "identifierMethod",
value = "toInt"),
@Parameter(
name = "valueOfMethod",
value = "fromInt")
}
)
private IdentidadeDocTipos tipo;
/*
Getters and Setters ...
*/
}
2) Now, use the "Flexible solution - working version" (thanks to
Martin
Kersten)
from the article Java 5 EnumUserType, see http://www.hibernate.org/272.html
to map the Sex attribute.
--- cut here -------------------------------------
package org.appfuse.tutorial.commons.hibernate;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
import org.hibernate.HibernateException;
import org.hibernate.type.NullableType;
import org.hibernate.type.TypeFactory;
import org.hibernate.usertype.ParameterizedType;
import org.hibernate.usertype.UserType ;
/**
* Implements a generic enum user type identified / represented by a
single
identifier / column.
* <p><ul>
* <li>The enum type being represented by the certain user type
must be
set
* by using the 'enumClass' property.</li>
* <li>The identifier representing a enum value is retrieved by the
identifierMethod.
* The name of the identifier method can be specified by the
* 'identifierMethod' property and by default the name()
method is
used.</li>
* <li>The identifier type is automatically determined by
* the return-type of the identifierMethod.</li>
* <li>The valueOfMethod is the name of the static factory method
returning
* the enumeration object being represented by the given
indentifier.
* The valueOfMethod's name can be specified by setting the
'valueOfMethod'
* property. The default valueOfMethod's name is 'valueOf'.</li>
* </p>
* <p>
* Example of an enum type represented by an int value:
* <code>
* public enum SimpleNumber {
* Unknown(-1), Zero(0), One(1), Two(2), Three(3);
* int value;
* protected SimpleNumber(int value) {
* this.value = value;
* }
*
* public int toInt() { return value; }
* public SimpleNumber fromInt(int value) {
* switch(value) {
* case 0: return Zero;
* case 1: return One;
* case 2: return Two;
* case 3: return Three;
* default:
* return Unknown;
* }
* }
* }
* </code>
* <p>
* The Mapping would look like this:
* <code>
* <typedef name="SimpleNumber" class="GenericEnumUserType">
* SimpleNumber
* toInt
* fromInt
* </typedef>
* <class ...>
* ...
* <property name="number" column="number" type="SimpleNumber"/>
* </class>
* </code>
*
* @author Martin Kersten
* @since 05.05.2005
*/
public class GenericEnumUserType implements UserType,
ParameterizedType {
private static final String DEFAULT_IDENTIFIER_METHOD_NAME =
"name";
private static final String DEFAULT_VALUE_OF_METHOD_NAME =
"valueOf";
private Class<? extends Enum> enumClass;
private Class<?> identifierType;
private Method identifierMethod;
private Method valueOfMethod;
private NullableType type;
private int[] sqlTypes;
public void setParameterValues(Properties parameters) {
String enumClassName = parameters.getProperty ("enumClass");
try {
enumClass =
Class.forName(enumClassName).asSubclass(Enum.class);
System.out.println(">>>enumClass: " +
enumClass.toString());
} catch (ClassNotFoundException cfne) {
throw new HibernateException("Enum class not found", cfne);
}
String identifierMethodName =
parameters.getProperty("identifierMethod",
DEFAULT_IDENTIFIER_METHOD_NAME);
try {
identifierMethod =
enumClass.getMethod(identifierMethodName, new
Class[0]);
identifierType = identifierMethod.getReturnType();
// XXX
System.out.println (">>>identifierMethod: " +
identifierMethod.toString());
System.out.println(">>>identifierType: " +
identifierType.toString());
} catch (Exception e) {
throw new HibernateException("Failed to obtain identifier
method", e);
}
type = (NullableType)
TypeFactory.basic(identifierType.getName());
if (type == null)
throw new HibernateException("Unsupported identifier type
" +
identifierType.getName ());
sqlTypes = new int[] { type.sqlType() };
String valueOfMethodName =
parameters.getProperty("valueOfMethod",
DEFAULT_VALUE_OF_METHOD_NAME);
System.out.println(">>>valueOfMethodName: " +
valueOfMethodName);
try {
valueOfMethod = enumClass.getMethod(valueOfMethodName, new
Class[] { identifierType });
System.out.println(">>>valueOfMethod: " +
valueOfMethod.toString
());
} catch (Exception e) {
throw new HibernateException("Failed to obtain valueOf
method",
e);
}
}
public Class returnedClass() {
return enumClass;
}
public Object nullSafeGet(ResultSet rs, String[] names, Object
owner)
throws HibernateException, SQLException {
Object identifier = type.get(rs, names[0]);
if (identifier == null) {
return null;
}
try {
return valueOfMethod.invoke(enumClass, new Object[]
{ identifier
});
} catch (Exception e) {
throw new HibernateException("Exception while invoking
valueOf
method '" + valueOfMethod.getName() + "' of " +
"enumeration class '" + enumClass + "'", e);
}
}
public void nullSafeSet(PreparedStatement st, Object value, int
index)
throws HibernateException, SQLException {
try {
if (value == null) {
st.setNull(index, type.sqlType());
} else {
Object identifier = identifierMethod.invoke(value, new
Object[0]);
type.set(st, identifier, index);
}
} catch (Exception e) {
throw new HibernateException("Exception while invoking
identifierMethod '" + identifierMethod.getName () + "' of " +
"enumeration class '" + enumClass + "'", e);
}
}
public int[] sqlTypes() {
return sqlTypes;
}
public Object assemble(Serializable cached, Object owner) throws
HibernateException {
return cached;
}
public Object deepCopy(Object value) throws HibernateException {
return value;
}
public Serializable disassemble(Object value) throws
HibernateException
{
return (Serializable) value;
}
public boolean equals(Object x, Object y) throws
HibernateException {
return x == y;
}
public int hashCode(Object x) throws HibernateException {
return x.hashCode();
}
public boolean isMutable() {
return false;
}
public Object replace(Object original, Object target, Object owner)
throws HibernateException {
return original;
}
}
--- cut here -------------------------------------
So, that's it! Maybe this helps someone!
Thank you all AppFusers!
--
celeraman +
--
View this message in context:
http://www.nabble.com/Java-5-Enums-Persistence-%3A%3A-How-to-tf3865408s2369.html#a10950327
Sent from the AppFuse - User mailing list archive at Nabble.com.
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
