【原创翻译】使用Hibernate持久化java 5 的枚举类型【AppFuse 2.0 文档-11】

摘要：

本文使用两个例子展示了如何使用Hibernate来持久化java 5 的枚举类型（Enum ）

Java 5 Enums Persistence with Hibernate

标题：

【原创翻译】使用Hibernate持久化java 5 的枚举类型【AppFuse 2.0 文档-11】

 

作者： Added by eboz, last edited by eboz on Jun 05, 2007 17:43

翻译者: 陈海青（josonchen）

( http://www.chq.name)

( http://www.hhrz.org)

( http://junit.vicp.net)

日期：2007.11.22

 

摘要：

本文使用两个例子展示了如何使用Hibernate来持久化java 5 的枚举类型（Enum ）

关键字：

Appfuse 2.0 , java 5,enum, annotations , Hibernate,

 

英文版网址 ： http://appfuse.org/display/APF/Java+5+Enums+Persistence+with+Hibernate

 

中文版

-------

关于本教程

如果你需要使用 JPA 的注释（ annotation ）将 Java 5 的枚举类型（ Enum ）映射到 Hibernate ，那么本文就是你需要的 .

目录

1.      书写JPA 注释(annotations)

2.      把Java 5 的枚举类型(Enums) 映射到 Hibernate

书写JPA 注释(annotations)

首先，使用一个来自 AppFuse 持久化教程的经典 POJO 的例子来展示如何使用注释 (annotation).

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 Sex sex;

    /*

     * Getters and Setters ...

     */

}

把Java 5 的枚举类型(Enum)映射到Hibernate

现在，使用以下的灵活方案 (Flexible solution) – 一个可运行版本（ working version ） 来映射 Sex 属性。这里要感谢 Martin Kersten, 他的文章 Java 5 EnumUserType 提供了帮助 .

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;

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);

        } 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 (identifier == null) {

            return null;

        }

        try {

            return valueOfMethod.invoke(enumClass, new Object[] { identifier });

        } catch (Exception e) {

            throw new HibernateException("Exception  + valueOfMethod.getName() + "' of " +while invoking valueOf method '"

                    "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  + identifierMethod.getName() + "' of " +while invoking identifierMethod '"

                    "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;

    }

}