Hibernate : Une façon générique de persister les Enum

Enum

Une enum représente un type énuméré, c’est à dire un type qui n’accepte qu’un ensemble fini d’éléments. Ce nouveau type permet donc de créer simplement des énumérations qui, dans sa forme la plus basique, contient simplement la liste des valeurs possibles qu’elle peut prendre, ex :

public enum Color {
     WHITE, RED, BLUE
};

La plupart du temps ce type d’enum est persisté en stockant sa valeur ordinale (0 pour WHITE, 1 pour RED et 2 pour BLUE) ce qui ne me plait pas du tout, c’est un peu comme stocker l’index d’un élément dans une liste au lieu de l’identifiant de l’élément lui-même. La valeur de mon enum en base doit être définie quelque part et non devinée selon un pseudo-placement dans une classe.

Dans notre cas notre enum est un peu plus complexe : constructeur à plusieurs paramètres, méthodes, etc., le voici en détails :

public enum Color {
	WHITE (1, "White", 3), // => 1 : identifiant en base, "White" : son libellé, 3 : ordre des couleurs
	RED (2, "Red", 1),
	BLUE (3, "Blue", 2);
    private final Integer value;
    private final String label;
    private final Integer order;
    private Color(Integer value, String label, Integer order) {
        this.value = value;
        this.label = label;
        this.order = order;
    }
    public Integer value() { return value; }
    public String label() { return label; }
    public Integer order() { return order; }
    /**
	 * Récupère la couleur selon sa valeur.
	 * @param value
	 * @return
	 */
	public static Color fromValue(Integer value) {
		switch (value) {
		case 1: return WHITE;
		case 2: return RED;
		case 3: return BLUE;
		default: return null;
		}
	}
}

Nous souhaitons que l’objet Color soit persisté en base avec son attribut value et qu’il puisse être intégralement récupérer par le biais de cet attribut unique.
Les deux méthodes value() et fromValue() sont justement présentes pour réaliser ce mapping.

UserType

Ces deux méthodes vont nous permettre de définir un UserType Hibernate permettant d’automatiser le mécanisme de sauvegarde/récupération de l’enum et de pouvoir étendre ce principe à d’autres énumérations en un clin d’oeil.

La classe ci-après, qui sert à faire le lien entre nos emum et la base de données, a été récupéré sur le site officiel de la communauté jBoss : http://community.jboss.org/wiki/Java5EnumUserType

Ce nouveau type de valeurs est générique et utilise par défaut les méthodes value et fromValue de l’énumération, nous allons voir plus bas comment l’utiliser dans les fichiers de mapping 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;
public class GenericEnumUserType implements UserType, ParameterizedType {
	private static final String DEFAULT_IDENTIFIER_METHOD_NAME = "value";
	private static final String DEFAULT_VALUE_OF_METHOD_NAME = "fromValue";
	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);
		} 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();
		} 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);
		try {
			valueOfMethod = enumClass.getMethod(valueOfMethodName, new Class[] { identifierType });
		} 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 (rs.wasNull()) {
			return null;
		}
		try {
			Object obj = valueOfMethod.invoke(enumClass, new Object[] { identifier });
			return obj;
		} 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;
	}
}

Mapping Hibernate

Le mapping Hibernate est tout simple, nous utilisons un typedef qui permet d’assigner un nom à notre type de valeur générique et nous permet aussi de lui donner une liste de paramètres par défaut.

Voici comment procéder si les méthodes utilisées sont value et fromValue (par défaut) :

<hibernate-mapping>
	<typedef name="colorEnum" class="package.de.la.classe.GenericEnumUserType">
		<param name="enumClass">package.de.l.enum.Color</param>
	</typedef>
	<class ...>
		...
		<property name="color" type="colorEnum">
         		<column name="color" not-null="true" />
		</property>
		...
	</class>
</hibernate-mapping>

Si les méthodes de votre enum sont nommées différemment (toInt et fromInt par exemple), voici comment procéder à la surcharge de ces méthodes :

<hibernate-mapping>
	<typedef name="colorEnum" class="package.de.la.classe.GenericEnumUserType">
		<param name="enumClass">package.de.l.enum.Color</param>
		<param name="identifierMethod">toInt</param>
		<param name="valueOfMethod">fromInt</param>
	</typedef>
	<class ...>
		...
		<property name="color" type="colorEnum">
         		<column name="color" not-null="true" />
		</property>
		...
	</class>
</hibernate-mapping>

Conclusion

Les champs de vos objets du modèle peuvent à présent être de type Enum sans vous soucier de la façon dont il sont sauvegardés et récupérés. Testé et approuvé.

Cet article a été écrit par :

Mimie – qui a déjà rédigé 123 posts sur Des Geeks et des lettres.

Passionné d'informatique et développeur JavaEE de métier, je me consacre principalement à écrire des billets sur les sujets du Web et de la programmation Web. Ce blog est un espace qui me permet de partager mes découvertes avec vous et me sert accessoirement de pense bête !

Contacter l'auteur

Jetez aussi un oeil sur :

• Dozer à la rescousse du lazy-loading
• Hibernate : Pagination, Tri et Unicité avec Criteria
• Hibernate : Utilisation du ‘Cast’ avec Criteria et HQL
• Spring + Hibernate : Mise en place d’un DAO générique