- 浏览: 1529148 次
- 性别:
- 来自: 厦门
文章分类
- 全部博客 (516)
- Java (49)
- Java/Struts 2.0 (25)
- Java/Spring、Spring MVC (11)
- Java/Quartz (3)
- Java/Lucene (6)
- Java/Hibernate (19)
- Java/openJPA (7)
- Java/DWR (7)
- Java/Security、Spring Security/OAuth2 (6)
- Java/Threading (9)
- Java/XML (22)
- java/design pattern (4)
- Android (2)
- JavaScript (46)
- jquery (3)
- DB/MySQL (23)
- DB/Oracle (16)
- PHP (25)
- CSS (20)
- Linux (38)
- C/C++、DLL、Makefile、VC++ (31)
- 正则 (9)
- Eclipse (4)
- 安全、网络等概念 (25)
- 集群 (7)
- 网页 (5)
- 视频\音频 (1)
- HTML (6)
- 计算机数学/算法 (3)
- Virtualbox (1)
- LDAP (2)
- 数据挖掘 (6)
- 工具破解 (1)
- 其他 (13)
- Mail (1)
- 药材 (3)
- 游戏 (2)
- hadoop (13)
- 压力测试 (3)
- 设计模式 (3)
- java/Swing (2)
- 缓存/Memcache (0)
- 缓存/Redis (1)
- OSGI (2)
- OSGI/Gemini (0)
- 文档写作 (0)
- java/Servlet (3)
- MQ/RabbitMQ (2)
- MQ/RocketMQ (0)
- MQ/Kafka (1)
- maven (0)
- SYS/linux (1)
- cache/redis (1)
- DB/Mongodb (2)
- nginx (1)
- postman (1)
- 操作系统/ubuntu (1)
- golang (1)
- dubbo (1)
- 技术管理岗位 (0)
- mybatis-plus (0)
最新评论
-
pgx89112:
大神,请赐我一份这个示例的项目代码吧,万分感谢,1530259 ...
spring的rabbitmq配置 -
string2020:
不使用增强器 怎么弄?
OpenJPA的增强器 -
孟江波:
学习了,楼主,能否提供一份源代码啊,学习一下,十分感谢!!!4 ...
spring的rabbitmq配置 -
eachgray:
...
spring-data-redis配置事务 -
qljoeli:
学习了,楼主,能否提供一份源代码啊,学习一下,十分感谢!!!1 ...
spring的rabbitmq配置
http://www.hibernate.org/282.html
在该文最下面的有一小段文字,其中写道:
With UserType s, also specify the sql-type. In xdoclet , we map user types this way
@hibernate.property type = "com.pfn.wirepower.srv.persistence.userTypes.OurCustomUserType" @hibernate.column name = "CustomObjectCol" sql-type="VARCHAR(50)"
/** 缩略图列表,按fileName1.xxx;fileName2.xxx;fileName3.xxx;... */ private Map<String, String> fileNames; /** * @hibernate.property type="com.sunsci.material.ext.hibernate.MapType" * @hibernate.column name="fileNames" sql-type="text" * @return */ public Map<String, String> getFileNames() { return fileNames; } public void setFileNames(Map<String, String> fileNames) { this.fileNames = fileNames; }
import java.io.Serializable; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Types; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import org.apache.commons.lang.StringUtils; import org.hibernate.Hibernate; import org.hibernate.HibernateException; import org.hibernate.usertype.UserType; public class ListType implements UserType { private static final String SPLITTER = ";"; private static final int[] TYPES = new int[] { Types.VARCHAR }; public Object assemble(Serializable serializable, Object object) throws HibernateException { return deepCopy(serializable); } public Object deepCopy(Object object) throws HibernateException { List sourceSet = (List) object; List targetSet = new ArrayList(); if (sourceSet != null) { targetSet.addAll(sourceSet); } return targetSet; } public Serializable disassemble(Object object) throws HibernateException { return (Serializable) deepCopy(object); } public boolean equals(Object one, Object other) throws HibernateException { if (one == other) {// 如果两个对象的指针是指向同一位置。 return true; } if (one != null && other != null) { List set0 = (List) one; List set1 = (List) other; if (set0.size() != set1.size()) {// 如果列表的长度不相等 return false; } Object[] s0 = set0.toArray(); Object[] s1 = set1.toArray(); if (s0.length != s1.length) {// 如果列表的长度不相等 return false; } for (int i = 0; i < s0.length; i++) { Object id0 = s0[i]; Object id1 = s1[i]; if (!id0.equals(id1)) {// 如果在列表中相同位置上的对象不相等 return false; } } return true; } return false; } public int hashCode(Object object) throws HibernateException { List s = (List) object; return s.hashCode(); } public boolean isMutable() { return false; } public Object nullSafeGet(ResultSet resultSet, String[] stringArray, Object object) throws HibernateException, SQLException { String value = (String) Hibernate.STRING.nullSafeGet(resultSet, stringArray[0]); if (value != null) { return parse(value); } else { return new ArrayList(); } } private List parse(String value) { String[] strs = StringUtils.split(value, SPLITTER); List set = new ArrayList(); for (int i = 0; i < strs.length; i++) { if (StringUtils.isNotBlank(strs[i])) { set.add(strs[i]); // set.add(new Long(Long.parseLong(strs[i]))); } } return set; } public void nullSafeSet(PreparedStatement preparedStatement, Object object, int _int) throws HibernateException, SQLException { if (object != null) { String str = assemble((List) object); Hibernate.STRING.nullSafeSet(preparedStatement, str, _int); } else { Hibernate.STRING.nullSafeSet(preparedStatement, "", _int); } } private String assemble(List set) { StringBuffer sb = new StringBuffer(); Iterator it = set.iterator(); while (it.hasNext()) { sb.append(it.next()); sb.append(SPLITTER); } String fs = sb.toString(); if (fs != null && fs.length() > 0 && fs.endsWith(SPLITTER)) { fs = fs.substring(0, fs.length() - 1); } return fs; } public Object replace(Object object, Object object1, Object object2) throws HibernateException { return object; } public Class returnedClass() { return List.class; } public int[] sqlTypes() { return TYPES; } }
import java.io.Serializable; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Types; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import org.apache.commons.collections.map.LinkedMap; import org.hibernate.Hibernate; import org.hibernate.HibernateException; import org.hibernate.usertype.UserType; /** * @author linzq * */ public class MapType implements UserType, Serializable { private static final long serialVersionUID = -8041009346154850427L; public MapType() { super(); } public MapType(Map attributeMap) { super(); this.attributeMap = attributeMap; } private Map attributeMap; public static final String SPLITTER = ";"; public static final String SEPARATOR = ":"; public static final String VALUE_BREAK = ","; public static final char BRACKET_LEFT = '{'; public static final char BRACKET_RIGHT = '}'; public static final int[] SQLTYPES = new int[] { Types.VARCHAR}; public boolean isMutable() { return false; } public int[] sqlTypes() { return SQLTYPES; } public Object assemble(Serializable id, Object obj) throws HibernateException { return null; } /** * 将Map类型的属性拼接成字符串 * * @param attributeList * @return * @throws HibernateException */ public Object assemble(Map attributeMap) throws HibernateException { if (attributeMap == null) { return null; } StringBuffer asbl = new StringBuffer(); Iterator itr = attributeMap.keySet().iterator(); String _key = null; while (itr.hasNext()) { _key = (String) itr.next(); asbl.append(SPLITTER).append(BRACKET_LEFT).append(_key).append(SEPARATOR).append(attributeMap.get(_key)).append(BRACKET_RIGHT); } return asbl.toString().replaceFirst(SPLITTER, ""); } /** * 自定义类型的完全复制方法,返回一个和原自定义数据相同的新对象 * * @param value * the object to be cloned, which may be null * @return Object a copy * @see org.hibernate.usertype.UserType#deepCopy(java.lang.Object) */ public Object deepCopy(Object value) throws HibernateException { if (value == null) { return null; } Map sourceMap = (Map) value; Map targetMap = new HashMap(); targetMap.putAll(sourceMap); return targetMap; } /** * 自定义数据类型的比较方法 * * @param x * @param y * @return boolean * @see org.hibernate.usertype.UserType#equals(java.lang.Object, * java.lang.Object) */ public boolean equals(Object x, Object y) throws HibernateException { if (x == y) { return true; } if (x != null && y != null) { Map xMap = (Map) x; Map yMap = (Map) y; if (xMap.size() != yMap.size()) { return false; } List<String> _xList = new ArrayList(xMap.keySet()); List<String> _yList = new ArrayList(xMap.keySet()); Collections.sort(_xList); Collections.sort(_yList); for (int i = 0; i < xMap.size(); i++) { if (!_xList.get(i).equals(_yList.get(i))) { return false; } if (!xMap.get(_xList.get(i)).equals(yMap.get(_yList.get(i)))) { return false; } } return true; } return false; } public int hashCode(Object arg0) throws HibernateException { return attributeMap.hashCode(); } /** * 将以格式为{key:value};{key:value1,value2}的字符串数组解析成一个Map * * @param value * @return */ public Map parse(String value) { if (value == null) { return null; } String[] strs = org.apache.commons.lang.StringUtils.split(value.trim(), SPLITTER); Map attributeMap = new LinkedMap(); String _temp = null; for (int i = 0; i < strs.length; i++) { _temp = strs[i].substring(1, strs[i].length() - 1); attributeMap.put(_temp.split(SEPARATOR, 2)[0], _temp.split(SEPARATOR, 2)[1]); } return attributeMap; } /** * 从JDBC的ResultSet中读取数据,并将其转换为自定义类型后返回。 此方法要求对可能出现null的情况做处理。 * names中包含了当前自定义类型的映射字段名称。 * * @param rs * a JDBC result set * @param names * the column names * @param owner * the containing entity * @return Object * @throws HibernateException * @throws SQLException * @see org.hibernate.usertype.UserType#nullSafeGet(java.sql.ResultSet, * java.lang.String[], java.lang.Object) */ public Object nullSafeGet(ResultSet rs, String[] names, Object owner) throws HibernateException, SQLException { String value = (String) Hibernate.STRING.nullSafeGet(rs, names[0]); if (value != null) { attributeMap = parse(value); return attributeMap; } return null; } /** * 在Hibernate进行数据保存时被调用 可以通过PreparedStatement将自定义数据写入对应的数据库字段中 * names中包含了当前自定义类型的映射字段名称。 * * @param st * a JDBC prepared statement * @param value * the object to write * @param index * statement parameter index * @throws HibernateException * @throws SQLException * @see org.hibernate.usertype.UserType#nullSafeGet(java.sql.ResultSet, * java.lang.String[], java.lang.Object) */ public void nullSafeSet(PreparedStatement pst, Object value, int index) throws HibernateException, SQLException { if (value != null) { Hibernate.STRING.nullSafeSet(pst, assemble((Map) value), index); } else { Hibernate.STRING.nullSafeSet(pst, value, index); } } public Class returnedClass() { return MapType.class; } public Object replace(Object arg0, Object arg1, Object arg2) throws HibernateException { return null; } public Serializable disassemble(Object arg0) throws HibernateException { return null; } public Map getAttributeMap() { return attributeMap; } public void setAttributeMap(Map attributeMap) { this.attributeMap = attributeMap; } }
发表评论
-
Hibernate延迟加载(转)
2014-05-04 15:54 765转自:http://cenjun615.blog.1 ... -
hibernate使用@subselect映射数据库视图
2013-12-21 21:15 3361文档引用:http://software-develope ... -
Hibernate annotation 自定义类型 userType
2013-04-01 17:26 1663第一步:添加自定义类: package com.a.en ... -
c3p0配置
2013-03-11 15:44 987<!--注册数据源 --> <bea ... -
hibernate之查询(设置查询提示) (转)
2012-02-03 15:36 1172转自:http://blog.csdn.net/f ... -
Hibernate的缓存策略(转)
2012-02-03 15:28 900Hibernate 的一级缓存 ... -
如何在spring配置多个Hibernate数据源链接(转)
2012-02-02 15:47 1201一、首先配置hibernate数据源: <?xm ... -
UserType 的 MapType,ListType
2011-12-07 14:42 1265import java.io.Serializable; i ... -
在Hibernate显式使用索引
2011-02-25 19:41 1341http://www.znetdevelopment.com/ ... -
Hibernate中多对多关系映射、保存、查询
2009-10-13 20:13 14217首先是一些基础模型类的建立: import java. ... -
Hibernate HQL 语法大全 查询技巧(2)
2009-09-25 19:10 179911.子查询 ... -
Hibernate HQL 语法大全 查询技巧(1)
2009-09-25 19:10 4992HQL: Hibernate查询语言 ... -
Join用法,HQL的方法,Hibernate中的fetch
2009-09-25 18:47 1778Join用法: 主要有Inner J ... -
xdoclet 2
2009-04-24 10:42 1479XDoclet 2 all XDoclet -&g ... -
hibernate 随机 查询
2009-04-03 21:36 2742/** * 随机取出N条记录 * * @p ... -
XDoclet - discriminator标签
2009-03-14 23:49 2396http://blog.csdn.net/chenjyuj/a ... -
Hibernate
2008-08-26 10:42 1140http://www.openfans.net/viewArt ... -
Hibernate 一对一
2008-08-26 10:14 1393//ClassA: import java.io.Seria ...
相关推荐
在Java开发中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者使用面向对象的方式来操作数据库,而无需关心底层SQL语句。本文将深入探讨如何在Hibernate配置中设置与数据库字段的对应关系,以及...
使用自定义类型映射 Oracle 中的 LONG 类型字段是解决 Hibernate 框架中 LONG 类型字段读写问题的一种有效方法。通过实现 UserType 接口,我们可以定制 LONG 类型字段的读写操作,并提高 Hibernate 框架的灵活性和可...
11.1.5 使用Hibernate内置映射类型 11.2 客户化映射类型 11.2.1 用客户化映射类型取代Hibernate组件 11.2.2 用UserType映射枚举类型 11.2.3 实现CompositeUserType接口 11.2.4 运行本节范例程序 11.3 ...
Hibernate是一个广泛使用的对象关系映射(ORM)框架,它使得Java开发者可以通过操作对象的方式来操作数据库,而不用直接编写SQL语句。Hibernate支持许多通用的数据库数据类型,并提供了内置的映射机制。然而,在处理...
3.3.3 使用XDoclet 3.3.4 处理全局的元数据 3.3.5 运行时操作元数据 3.4 其他实体表示法 3.4.1 创建动态的应用程序 3.4.2 表示XML中的数据 3.5 小结 第二部分 映射概念和策略 第4章 ...
为了解决这些问题,Hibernate3.2引入了`org.hibernate.type.EnumType`,这是一种定制的类型,可以将枚举直接映射到数据库的特定字段,支持多种存储策略。 1. **枚举类型映射的三种策略**: - `ORDINAL`:默认策略...
- **使用org.hibernate.usertype.CompositeUserType**: 映射复合类型。 - **类型注册**: 注册自定义类型。 #### 7. 集合映射 - **持久化集合**: 映射集合属性。 - **如何映射集合**: - **集合外键**: 使用外键...
1. Type 接口:表示 Hibernate 映射类型,是域对象映射为数据库的关系数据。提供了各种实现类,例如 org.hibernate.type.PrimitiveType Class、org.hibernate.type.DateType Class、org.hibernate.type.BinaryType ...
### Hibernate的Char问题详解 #### 一、引言 ...通过正确配置 Hibernate 映射文件、使用合适的 Hibernate 类型以及注意参数绑定时的类型一致性等方法,可以有效避免这些问题,提高应用程序的稳定性和性能。
- **Type**接口:定义了Hibernate的映射类型,将Java对象映射到数据库关系数据。预定义了许多实现,如PrimitiveType(Java基本类型)、DateType(日期类型)、BinaryType(字节数组类型)。此外,还可以通过实现...
在MySQL数据库中,Hibernate是一个非常流行的ORM(对象关系映射)框架,用于简化Java应用程序与数据库之间的交互。在处理特定类型的数据库字段时,比如`TEXT`字段,Hibernate可能需要使用特定的方言(Dialect)来...
11.1.5 使用Hibernate内置映射类型 11.2 客户化映射类型 11.2.1 用客户化映射类型取代Hibernate组件 11.2.2 用UserType映射枚举类型 11.2.3 实现CompositeUserType接口 11.2.4 运行本节范例程序 11.3 ...
11.1.5 使用Hibernate内置映射类型 11.2 客户化映射类型 11.2.1 用客户化映射类型取代Hibernate组件 11.2.2 用UserType映射枚举类型 11.2.3 实现CompositeUserType接口 11.2.4 运行本节范例程序 11.3 ...
11.1.5 使用Hibernate内置映射类型 11.2 客户化映射类型 11.2.1 用客户化映射类型取代Hibernate组件 11.2.2 用UserType映射枚举类型 11.2.3 实现CompositeUserType接口 11.2.4 运行本节范例程序 11.3 ...
在Java开发领域,Hibernate是一个非常流行的对象关系映射(ORM)框架,它简化了数据库操作,将Java对象与数据库表之间的映射关系自动化处理。本篇文章将对Hibernate的一些关键特性进行探讨,包括存取JSON数据的新...
《Hibernate3中文手册》是Java开发领域中关于对象关系映射框架Hibernate的重要参考资料,它详尽地阐述了Hibernate3的使用方法和核心概念。Hibernate是一个开放源代码的对象关系映射框架,它允许开发者将数据库操作与...
9. **mysql-connector-java.jar**:如果项目使用MySQL数据库,那么这个驱动是必需的,它使得Hibernate能够连接到MySQL服务器。 10. **postgresql-jdbc.jar**:类似地,如果使用PostgreSQL数据库,这个JDBC驱动是...
在Java世界中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者将数据库操作与业务逻辑解耦,通过面向对象的方式处理数据。本文将深入探讨如何使用Hibernate实现领域对象的自定义字段,这涉及到对...
本文将详细介绍如何在Hibernate中实现枚举类型到数据库的映射,包括对应的枚举类的定义、自定义UserType以及在映射文件hbm.xml中的配置。 首先,定义一个枚举类型Gender,它包含了性别相关的几个枚举值,分别是...