这里有新鲜出炉的 JSP 教程,程序狗速度看过来!
JSP 全名为 Java Server Pages - java 服务器页面是由 Sun Microsystems 公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP 技术有点类似 ASP 技术,它是在传统的网页 html(标准通用标记语言的子集)文件 (*.htm,*.html) 中插入 Java 程序段 (Scriptlet) 和 JSP 标记(tag),从而形成 JSP 文件,后缀名为(*.jsp)。
这篇文章主要介绍了 JSP 中 Hibernate 实现映射枚举类型的相关资料, 需要的朋友可以参考下
JSP 中 Hibernate 实现映射枚举类型
问题:
Java BO 类 Gender 是枚举类型,想在数据库中存成字符串格式,如何编写 hbm.xml?
- public enum Gender {
- UNKNOWN("Unknown"),
- MALE("Male"),
- FEMALE("Female");
- private String key;
- private Gender(final String key) {
- this.key = key;
- }
- public getGender(String key) {
- for (Gender gender: Gender.values()) {
- if (key.euqals(gender.getKey())) return gender;
- }
- throw new NoSuchElementException(key);
- }
- }
使用 UserType:
- public class GenderUserType implements UserType {
- private static int[] typeList = {
- Types.VARCHAR
- };
- /*
- * Return the SQL type codes for the columns mapped by this type.
- * The codes are defined on <tt>java.sql.Types</tt>. */
- /**设置和Gender类的sex属性对应的字段的SQL类型 */
- public int[] sqlTypes() {
- return typeList;
- }
- /*The class returned by <tt>nullSafeGet()</tt>.*/
- /** 设置GenderUserType所映射的Java类:Gender类 */
- public Class returnedClass() {
- return Gender.class;
- }
- /** 指明Gender类是不可变类 */
- public boolean isMutable() {
- return false;
- }
- /*
- * Return a deep copy of the persistent state, stopping at entities and at
- * collections. It is not necessary to copy immutable objects, or null
- * values, in which case it is safe to simply return the argument.
- */
- /** 返回Gender对象的快照,由于Gender类是不可变类, 因此直接将参数代表的Gender对象返回 */
- public Object deepCopy(Object value) {
- return (Gender) value;
- }
- /** 比较一个Gender对象是否和它的快照相同 */
- public boolean equals(Object x, Object y) {
- //由于内存中只可能有两个静态常量Gender实例,
- //因此可以直接按内存地址比较
- return (x == y);
- }
- public int hashCode(Object x) {
- return x.hashCode();
- }
- /*
- * Retrieve an instance of the mapped class from a JDBC resultset. Implementors
- * should handle possibility of null values.
- */
- /** 从JDBC ResultSet中读取key,然后返回相应的Gender实例 */
- public Object nullSafeGet(ResultSet rs, String[] names, Object owner) throws HibernateException,
- SQLException {
- //从ResultSet中读取key
- String sex = (String) Hibernate.STRING.nullSafeGet(rs, names[0]);
- if (sex == null) {
- return null;
- }
- //按照性别查找匹配的Gender实例
- try {
- return Gender.getGender(sex);
- } catch(java.util.NoSuchElementException e) {
- throw new HibernateException("Bad Gender value: " + sex, e);
- }
- }
- /*
- * Write an instance of the mapped class to a prepared statement. Implementors
- * should handle possibility of null values.
- * A multi-column type should be written to parameters starting from <tt>index</tt>.
- */
- /** 把Gender对象的key属性添加到JDBC PreparedStatement中 */
- public void nullSafeSet(PreparedStatement st, Object value, int index) throws HibernateException,
- SQLException {
- String sex = null;
- if (value != null) sex = ((Gender) value).getKey();
- Hibernate.String.nullSafeSet(st, sex, index);
- }
- /*
- * Reconstruct an object from the cacheable representation. At the very least this
- * method should perform a deep copy if the type is mutable. (optional operation)
- */
- public Object assemble(Serializable cached, Object owner) {
- return cached;
- }
- /*
- * Transform the object into its cacheable representation. At the very least this
- * method should perform a deep copy if the type is mutable. That may not be enough
- * for some implementations, however; for example, associations must be cached as
- * identifier values. (optional operation)
- */
- public Serializable disassemble(Object value) {
- return (Serializable) value;
- }
- /*
- * During merge, replace the existing (target) value in the entity we are merging to
- * with a new (original) value from the detached entity we are merging. For immutable
- * objects, or null values, it is safe to simply return the first parameter. For
- * mutable objects, it is safe to return a copy of the first parameter. For objects
- * with component values, it might make sense to recursively replace component values.
- */
- public Object replace(Object original, Object target, Object owner) {
- return original;
- }
- }
然后再 hbm.xml 中定义映射关系:
- <hibernate-mapping package="" default-lazy="true" default-cascade="save-update,merge,persist">
- <typedef name="Gender" class="com.alpha.hibernate.GenderUserType">
- <property name="gender" type="Gender">
- <column name="GENDER" not-null="true">
- </column>
- </property>
延伸:
为每个枚举类型定义一个 UserType 是比较麻烦的,可以定义一个抽象类。
例如扩展下例即可适用于所有保存为 index 的枚举类型
- public abstract class OrdinalEnumUserType < E extends Enum < E >> implements UserType {
- protected Class < E > clazz;
- protected OrdinalEnumUserType(Class < E > clazz) {
- this.clazz = clazz;
- }
- private static final int[] SQL_TYPES = {
- Types.NUMERIC
- };
- public int[] sqlTypes() {
- return SQL_TYPES;
- }
- public Class < ?>returnedClass() {
- return clazz;
- }
- public E nullSafeGet(ResultSet resultSet, String[] names, Object owner) throws HibernateException,
- SQLException {
- //Hibernate.STRING.nullSafeGet(rs, names[0])
- int index = resultSet.getInt(names[0]);
- E result = null;
- if (!resultSet.wasNull()) {
- result = clazz.getEnumConstants()[index];
- }
- return result;
- }
- public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index) throws HibernateException,
- SQLException {
- if (null == value) {
- preparedStatement.setNull(index, Types.NUMERIC);
- } else {
- //Hibernate.String.nullSafeSet(st, sex, index);
- preparedStatement.setInt(index, ((E) value).ordinal());
- }
- }
- public Object deepCopy(Object value) throws HibernateException {
- return value;
- }
- public boolean isMutable() {
- return false;
- }
- public Object assemble(Serializable cached, Object owner) throws HibernateException {
- return cached;
- }
- public Serializable disassemble(Object value) throws HibernateException {
- return (Serializable) value;
- }
- public Object replace(Object original, Object target, Object owner) throws HibernateException {
- return original;
- }
- public int hashCode(Object x) throws HibernateException {
- return x.hashCode();
- }
- public boolean equals(Object x, Object y) throws HibernateException {
- if (x == y) return true;
- if (null == x || null == y) return false;
- return x.equals(y);
- }
- }
来源: http://www.phperz.com/article/17/0811/338985.html