国产亚洲精品成人AA片新蒲金,久久久影院亚洲精品,久久久久se色偷偷亚洲精品av

Eric_jiang — Mon, 03 Sep 2012 02:03:00 GMT

Eric_jiang 2012-09-03 10:03 发表评论

Hibernate主键生成�{�略

Eric_jiang — Fri, 31 Aug 2012 05:29:00 GMT

1、自动增长identity

适用于MySQL、DB2、MS SQL Server�Q�采用数据库生成的主键，用于为long、short、int�c�d��生成唯一标识
使用SQL Server �?MySQL 的自增字�D�，�q�个�Ҏ(gu��)��不能攑ֈ� Oracle 中，Oracle 不支持自增字�D�，要设定sequence�Q�MySQL �?SQL Server 中很常用�Q?br />数据库中的语法如下：
MySQL�Q�create table t_user(id int auto_increment primary key, name varchar(20));
SQL Server�Q�create table t_user(id int identity(1,1) primary key, name varchar(20));

2、sequence

DB2、Oracle均支持的序列�Q�用于�ؓlong、short或int生成唯一标识
数据库中的语法如下：
Oracle�Q�create sequence seq_name increment by 1 start with 1;
需要主键值时可以调用seq_name.nextval或者seq_name.curval得到�Q�数据库会帮助我们维护这个sequence序列�Q�保证每�ơ取到的值唯一�Q�如�Q?br />insert into tbl_name(id, name) values(seq_name.nextval, ‘Jimliu’);

       seq_name


如果我们没有指定sequence参数�Q�则Hibernate会访问一个默认的sequence�Q�是hibernate_sequence�Q�我们也需要在数据库中建立�q�个sequence
此外�Q�sequence�q�可以有另外一个参数是paramters�Q�可以查看Hibernate的API了解它的用法�Q�见org.hibernate.id.SequenceGenerator
调用数据库的sequence来生成主键，要设定序列名�Q�不然hibernate无法扑ֈ��Q?br />NAME_SEQ�Q�Oracle中很常用�Q?/p>

3、hilo

使用一个高/低位��法生成的long、short或int�c�d��的标识符�Q�给定一个表和字�D�作为高位值的来源�Q�默认的表是hibernate_unique_key�Q�默认的字段是next_hi。它?y��u)��id的��生源分成两部分，DB+内存�Q�然后按照算法结合在一起��生id��|��可以在很��的�q�接�ơ数内��生多条记录，提高效率

MySQL�Q�create table hi_value(next_hi integer not null);

insert into hi_value(next_hi) values(1);

       hi_value
       next_hi
       100


在hibernate持久化的时候，由hibernate负责生成低位倹{��hilo标识�W�生成器在生成标识符旉��要从hi_value表中取出next_hi的当前��|��然后修改该��|��q�个操作是在单独的事务中完成的。最大的低值在属性max_lo中配�|�，但在Hibernate内存中生成的低位��D��q�此值时�Q�就有需要到数据库的hi_value表中再次��d��高位��g��
使用hilo生成�{�略�Q�要在数据库中徏立一张额外的表，默认表名为hibernate_unique_key,默认字段为integer�c�d��Q�名�U�是next_hi�Q�比较少用）
我们也可以自��p��|�自定义的表名和字段�?br />

4、native

会根据底层数据库的能力，从identity、sequence、hilo中选择一个，灉|��性更强，但此�Ӟ��如果选择sequence或者hilo�Q�则所有的表的主键都会从Hibernate默认的sequence或者hilo表中取。�ƈ且，有的数据库对于默认情况主键生成测试的支持�Q�效率�ƈ不是很高
对于 oracle 采用 Sequence 方式�Q�对于MySQL �?SQL Server 采用identity�Q�自增主键生成机�Ӟ��Q�native��是��主键的生成工作交由数据库完成，hibernate不管�Q�很常用�Q?/p>

5、seqhilo

sequence和hilo的结合，hilo的高位由sequence产生�Q�所以也需要底层数据库的支�?br />通过hilo��法实现�Q�但是主键历史保存在Sequence中，适用于支�?Sequence 的数据库�Q�如 Oracle�Q�比较少用）

      seq_name
      100


6、increment

�q�个是由Hibernate在内存中生成主键�Q�每�ơ增量�ؓ1�Q�不依赖于底层的数据库，因此所有的数据库都可以使用�Q�但问题也随之而来�Q�由于是Hibernate生成的，所以只

能有一个Hibernate应用�q�程讉K��数据库，否则��׃��产生主键冲突�Q�不能在集群情况下��?br />插入数据的时候hibernate会给主键��d��一个自增的主键�Q�但是一个hibernate实例��q��护一个计数器�Q�所以在多个实例�q�行的时候不能��用这个方�?br />

7�?/p>

uuid.hex

使用一�?28-bit的UUID��法生成字符串类型的标识�W�，UUID被编码成一�?2�?6�q�制数字的字�W�串。UUID包含�Q�IP地址、JVM启动旉��、系�l�时��_��_��?/4�U�）和一个计数器��|��JVM中唯一�Q?br />hibernate会算��Z��?28位的唯一值插�?/p>

uuid.string
hibernate会算��Z��?6位的值插�?/p>

8、assigned

由应用程序负责生成主键标识符�Q�往往使用在数据库中没有代理主键，使用的主键与业务相关的情况，如：

�q�种主键的生成方式不��使用�Q�在数据库表设计时就应该使用代理主键�Q�surrogate key�Q�，不应使用自然主键�Q�natural key��h��业务含义�Q�，在没有指�?lt;generator>标签�Ӟ��默认��是assigned主键的生成方�?br />在插入数据的时候主键由用户自己��d��Q�hibernate也不��?/p>

9、foreign
使用外部表的字段作�ؓ主键

10、select
使用触发器生成主键（主要用于早期的数据库主键生成机制�Q�少用）

ps:

代理主键是指与业务无关且能唯一标识数据库中记录,一般是数据库自动生成的,比如mysql可以使用auto_increment,Sql2000可以使用identity生成方式,oracle可以使用sequence生成方式自然主键指业务相�?��q��h��?且能唯一标识数据库中的�Q意一条记�?/span>

��介版�Q?/span>

increment�Q�代理主键，适合于所有数据库�Q�由hibernate�l�护主键自增�Q�和底层数据库无养I��但是不适合�?个或以上hibernate�q�程�?/p>

identity�Q�代理主键，适合于Mysql或ms sql server�{�支持自增的dbms�Q�主键��g��由hibernate�l�护�?/span>

sequence�Q�代理主键，适合于oracle�{�支持序列的dbms�Q�主键��g��由hibernate�l�护�Q�由序列产生�?/span>

native�Q�代理主键，�Ҏ(gu��)��底层数据库的具体�Ҏ(gu��)��选择适合的主键生成策略，如果是mysql或sqlserver�Q�选择identity�Q�如果是oracle�Q�选择sequence�?/p>

hilo�Q�代理主键，hibernate把特定表的字�D�作为hign��|��生成主键�?/p>

uuid.hex�Q�代理主键，hibernate采用uuid 128位算法生成基于字�W�串的主键�?/p>

assign�Q�适合于应用程序维护的自然主键�?/p>

Eric_jiang 2012-08-31 13:29 发表评论

Equals and HashCode

Eric_jiang — Sat, 02 Jul 2011 06:06:00 GMT

Java's Collections and Relational database (and thus Hibernate) relies heavily on being able to distinguish objects in a unified way. In Relational database's this is done with primary keys, in Java we have equals() and hashCode() methods on the objects. This page tries to discuss the best strategies for implementation of equals() and hashcode() in your persistent classes.

Why are equals() and hashcode() important
Normally, most Java objects provide a built-in equals() and hashCode() based on the object's identity; so each new() object will be different from all others.

This is generally what you want in ordinary Java programming. And if all your objects are in memory, this is a fine model. Hibernate's whole job, of course, is to move your objects out of memory. But Hibernate works hard to prevent you from having to worry about this.

Hibernate uses the Hibernate session to manage this uniqueness. When you create an object with new(), and then save it into a session, Hibernate now knows that whenever you query for an object and find that particular object, Hibernate should return you that instance of the object. And Hibernate will do just that.

However, once you close the Hibernate session, all bets are off. If you keep holding onto an object that you either created or loaded in a Hibernate session that you have now closed, Hibernate has no way to know about those objects. So if you open another session and query for "the same" object, Hibernate will return you a new instance. Hence, if you keep collections of objects around between sessions, you will start to experience odd behavior (duplicate objects in collections, mainly).

The general contract is: if you want to store an object in a List, Map or a Set then it is an requirement that equals and hashCode are implemented so they obey the standard contract as specified in the documentation.

What is the problem after all?
So let's say you do want to keep objects around from session to session, e.g. in a Set related to a particular application user or some other scope that spans several Hibernate sessions.

The most natural idea that comes to mind is implementing equals() and hashCode() by comparing the property you mapped as a database identifier (ie. the primary key attribute). This will cause problems, however, for newly created objects, because Hibernate sets the identifier value for you after storing new objects. Each new instance therefore has the same identifier, null (or 0). For example, if you add some new objects to a Set:

// Suppose UserManager and User are Beans mapped with Hibernate

UserManager u = session.load(UserManager.class, id);

u.getUserSet().add(new User("newUsername1")); // adds a new Entity with id = null or id = 0
u.getUserSet().add(new User("newUsername2")); // has id=null, too so overwrites last added object.

// u.getUserSet() now contains only the second User
As you can see relying on database identifier comparison for persistent classes can get you into trouble if you use Hibernate generated ids, because the identifier value won't be set before the object has been saved. The identifier value will be set when session.save() is called on your transient object, making it persistent.

If you use manually assigned ids (e.g. the "assigned" generator), you are not in trouble at all, you just have to make sure to set the identifier value before adding the object to the Set. This is, on the other hand, quite difficult to guarantee in most applications.

Separating object id and business key
To avoid this problem we recommend using the "semi"-unique attributes of your persistent class to implement equals() (and hashCode()). Basically you should think of your database identifier as not having business meaning at all (remember, surrogate identifier attributes and automatically generated vales are recommended anyway). The database identifier property should only be an object identifier, and basically should be used by Hibernate only. Of course, you may also use the database identifier as a convenient read-only handle, e.g. to build links in web applications.

Instead of using the database identifier for the equality comparison, you should use a set of properties for equals() that identify your individual objects. For example, if you have an "Item" class and it has a "name" String and "created" Date, I can use both to implement a good equals() method. No need to use the persistent identifier, the so called "business key" is much better. It's a natural key, but this time there is nothing wrong in using it!

The combination of both fields is stable enough for the life duration of the Set containing your Items. It is not as good as a primary key, but it's certainly a candidate key. You can think of this as defining a "relational identity" for your object -- the key fields that would likely be your UNIQUE fields in your relational model, or at least immutable properties of your persistent class (the "created" Date never changes).

In the example above, you could probably use the "username" property.

Note that this is all that you have to know about equals()/hashCode() in most cases. If you read on, you might find solutions that don't work perfectly or suggestions that don't help you much. Use any of the following at your own risk.

Workaround by forcing a save/flush
If you really can't get around using the persistent id for equals() / hashCode(), and if you really have to keep objects around from session to session (and hence can't just use the default equals() / hashCode()), you can work around by forcing a save() / flush() after object creation and before insertion into the set:

// Suppose UserManager and User are Beans mapped with Hibernate

UserManager u = session.load(UserManager.class, id);

User newUser = new User("newUsername1");
// u.getUserSet().add(newUser); // DO NOT ADD TO SET YET!
session.save(newUser);
session.flush(); // The id is now assigned to the new User object
u.getUserSet().add(newUser); // Now OK to add to set.
newUser = new User("newUsername2");
session.save(newUser);
session.flush();
u.getUserSet().add(newUser); // Now userSet contains both users.

Note that it's highly inefficient and thus not recommended. Also note that it is fragile when using disconnected object graphs on a thin client:

// on client, let's assume the UserManager is empty:
UserManager u = userManagerSessionBean.load(UserManager.class, id);
User newUser = new User("newUsername1");
u.getUserSet().add(newUser); // have to add it to set now since client cannot save it
userManagerSessionBean.updateUserManager(u);

// on server:
UserManagerSessionBean updateUserManager (UserManager u) {
// get the first user (this example assumes there's only one)
User newUser = (User)u.getUserSet().iterator().next();
session.saveOrUpdate(u);
if (!u.getUserSet().contains(newUser)) System.err.println("User set corrupted.");
}

This will actually print "User set corrupted." since newUser's hashcode will change due to the saveOrUpdate call.

This is all frustrating because Java's object identity seems to map directly to Hibernate-assigned database identity, but in reality the two are different -- and the latter doesn't even exist until an object is saved. The object's identity shouldn't depend on whether it's been saved yet or not, but if your equals() and hashCode() methods use the Hibernate identity, then the object id does change when you save.

It's bothersome to write these methods, can't Hibernate help?
Well, the only "helping" hand Hibernate can provide is hbm2java.

hbm2java does not (anymore) generate equals/hashcode based on id's because of the described issues in this page.

You can though mark certain properties with true to tell hbm2java to generate a proper equals/hashcode.

Summary
To sum all this stuff up, here is a listing of what will work or won't work with the different ways to handle equals/hashCode:

no eq/hC at all eq/hC with the id property eq/hC with buisness key
use in a composite-id No Yes Yes
multiple new instances in set Yes No Yes
equal to same object from other session No Yes Yes
collections intact after saving Yes No Yes

Where the various problems are as follows:

use in a composite-id:

To use an object as a composite-id, it has to implement equals/hashCode in some way, == identity will not be enough in this case.

multiple new instances in set:

Will the following work or not:

HashSet someSet = new HashSet();
someSet.add(new PersistentClass());
someSet.add(new PersistentClass());
assert(someSet.size() == 2);

equal to same object from another session:

Will the following work or not:

PersistentClass p1 = sessionOne.load(PersistentClass.class, new Integer(1));
PersistentClass p2 = sessionTwo.load(PersistentClass.class, new Integer(1));
assert(p1.equals(p2));

collections intact after saving:

Will the following work or not:

HashSet set = new HashSet();
User u = new User();
set.add(u);
session.save(u);
assert(set.contains(u));

Any best practicies for equals and hashcode
Read the links in 'Background material' and the API docs - they provide the gory details.

Furthermore I encourage anyone with information and tips about equals and hashcode implementations to come forward and show their "patterns" - I might even try to incorporate them inside hbm2java to make it even more helpful ;)

Background material:
Effective Java Programming Language Guide, sample chapter about equals() and hashCode()

Java theory and practice: Hashing it out, Article from IBM

Sam Pullara (BEA) comments on object identity: Blog comment

Article about how to implement equals and hashCode correctly by Manish Hatwalne: Equals and HashCode

Forum thread discussing implementation possibilities without defining a business identity: Equals and hashCode: Is there *any* non-broken approach?

According to The java.lang.Object documentation it should be perfectly ok to always return 0 for the hashCode(). The positive effect of implementing hashCode() to return unique numbers for unique objects, is that it might increase performance. The downside is that the behavior of hashCode() must be consistent with equals(). For object a and b, if a.equals(b) is true, than a.hashCode() == b.hashCode() must be true. But if a.equals(b) returns false, a.hashCode() == b.hashCode() may still be true. Implementing hashCode() as 'return 0' meets these criteria, but it will be extremely inefficient in Hash based collection such as a HashSet or HashMap.

Eric_jiang 2011-07-02 14:06 发表评论

Eric_jiang — Mon, 16 Aug 2010 14:43:00 GMT

要对资料库管理系�l�进行操作，最基本的就是��用SQL�Q�Standard Query Language�Q�语句，大部份的资料库都支援标准的SQL语句�Q�然而也有一些特定于资料库的SQL语句�Q�应用程式配合SQL语句�q�行资料库查询时�Q�若使用到特定于资料库的SQL语句�Q�程式本�w�会有相依于特定资料库的问题�?br />
使用Hibernate�Ӟ��即��(zh��n)�不了解SQL的��用与撰写�Q�也可以使用它所提供的API来进行SQL语句查询�Q�org.hibernate.Criteria对SQL�q�行��装�Q��?zh��n)�可以从Java物�g的观�Ҏ(gu��)��l�合各种查询条�g�Q�由Hibernate自动为�?zh��n)�产生SQL语句�Q�而不用特别管理SQL与资料库�怾�的问题�?br />
以最基本的查询来��_��如果�(zh��n)�想要查询某个物件所对应的资料表中所有的内容�Q��?zh��n)�可以如下�q�行查询�Q?br />
Criteria criteria = session.createCriteria(User.class);
List users = criteria.list();

for(Iterator it = users.iterator(); it.hasNext(); ) {
User user = (User) it.next();
System.out.println(user.getId() +
" "t " + user.getName() +
"/" + user.getAge());
}

Criteria建立后，若不�l�予��M��的条�Ӟ��预设是查询物件所对应表格之所有资料，如果�(zh��n)�执行以上的�E�式片段�Q��ƈ于设定档中设定了了Hibernate�?#8221;show_sql”属性，则可以在��L��下看��C��下的SQL语句之��生：

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_

Criteria基本查询条�g讑֮�

org.hibernate.Criteria实际上是个条仉��加的容器�Q�如果想要设定查询条�Ӟ��则要使用org.hibernate.criterion.Restrictions的各�U�静态方法传回org.hibernate.criterion.Criteria实例�Q�传回的每个org.hibernate.criterion.Criteria实例代表着一个条�Ӟ��(zh��n)�要使用org.hibernate.Criteria的add()�Ҏ(gu��)��加入�q�些条�g实例�Q�例如查�?#8221;age”大于20且小�?0的资料：

Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.gt("age", new Integer(20)));
criteria.add(Restrictions.lt("age", new Integer(40)));
List users = criteria.list();

for(Iterator it = users.iterator(); it.hasNext(); ) {
User user = (User) it.next();
System.out.println(user.getId() +
" "t " + user.getName() +
"/" + user.getAge());
}

Restrictions的gt()�Ҏ(gu��)��表示大于�Q�great than�Q�的条�g�Q�而lt表示��于�Q�less than�Q�的条�g�Q�执行以上程式片�D�，观察所产生的SQL语句�Q�将使用where与and子句产来完成SQL的条件查询：

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where this_.age>? and this_.age

使用add()�Ҏ(gu��)��加入条�g�Ӟ��预设是��用and来组合条�Ӟ��如果要用or的方式来�l�合条�g�Q�则可以使用Restrictions.or()�Ҏ(gu��)��Q�例如结合age�{�于�Q�eq�Q?0或（or�Q�age为空�Q�isNull�Q�的条�g�Q?br />
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.or(
Restrictions.eq("age", new Integer(20)),
Restrictions.isNull("age")
));
List users = criteria.list();

观察所产生的SQL语句�Q�将使用where与or子句完成SQL的条件查询：

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where (this_.age=? or this_.age is null)

�(zh��n)�也可以使用Restrictions.like()�Ҏ(gu��)��来进行SQL中like子句的功能，例如查询”name”中名�U�Cؓ”just”开头的资料�Q?br />
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.like("name", "just%"));
List users = criteria.list();

观察所产生的SQL语句如下�Q?br />
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where this_.name like ?

Restrictions的几个常用限定查询方法如下表所�C�：

�Ҏ(gu��)�� 说明
Restrictions.eq �{�于
Restrictions.allEq 使用Map�Q��用key/value�q�行多个�{�于的比�?br /> Restrictions.gt 大于 >
Restrictions.ge 大于�{�于 >=
Restrictions.lt ��于 <
Restrictions.le ��于�{�于 <=
Restrictions.between 对应SQL的BETWEEN子句
Restrictions.like 对应SQL的LIKE子句
Restrictions.in 对应SQL的in子句
Restrictions.and and关係
Restrictions.or or关係

Criteria�q�阶查询条�g讑֮�

使用Criteria�q�行查询�Ӟ��不仅仅能�l�合出SQL中where子句的功能，�q�可以组合出如排序、统计、分�l�等的查询功能�?br />
排序

�(zh��n)�可以��用Criteria�q�行查询�Q��ƈ使用org.hibernate.criterion.Order对结果进行排序，例如使用Oder.asc()�Q�指定根�?#8221;age”由小到大排序�Q�反之则使用desc()�Q�：

Criteria criteria = session.createCriteria(User.class);
criteria.addOrder(Order.asc("age"));
List users = criteria.list();

注意在加入Order条�g�Ӟ��使用的是addOrder()�Ҏ(gu��)��Q�而不是add()�Ҏ(gu��)��Q�在产生SQL语句�Ӟ��会��用order by与asc�Q�desc�Q�来�q�行排序指定�Q?br />
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ order by this_.age asc

限定查询�W�数

Criteria的setMaxResults()�Ҏ(gu��)��可以限定查询回来的笔敎ͼ�如果配合setFirstResult()讑֮�传回查询�l�果�W�一�W�资料的位置�Q�就可以实现��单的分页�Q�例如传回第51�W�之后的50�W�资料（如果有的话）�Q?br />
Criteria criteria = session.createCriteria(User.class);
criteria.setFirstResult(51);
criteria.setMaxResults(50);
List users = criteria.list();

�Ҏ(gu��)��(zh��n)�所指定得资料库�Q�Hibernate��自动��生与资料库相依的限定�W�数查询子句�Q�例如在MySQL中，��用limit产生以下的SQL语句�Q?br />
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ limit ?, ?

�l�计动作

�(zh��n)�可以对查询�l�果�q�行�l�计动作�Q��用org.hibernate.criterion.Projections的avg()、rowCount()、count()、max()、min()�?countDistinct()�{�方法，再搭配Criteria的setProjection()�Ҏ(gu��)��加入条�g讑֮��Q�例如对查询�l�果�?age"作��^均：

Criteria criteria = session.createCriteria(User.class);
criteria.setProjection(Projections.avg("age"));
List users = criteria.list();

上面的程式将由Hibernate自动产生SQL的avg函数�q�行�q�_��计算�Q?br />
Hibernate: select avg(this_.age) as y0_ from T_USER this_

分组

�q�可以配合Projections的groupProperty()来对�l�果�q�行分组�Q�例如以"age"�q�行分组�Q�也��是如果资料�?age"如果�?20�?0�?5�?0�Q�则以下会显�C?0�?5�?0�Q?br />
Criteria criteria = session.createCriteria(User.class);
criteria.setProjection(Projections.groupProperty("age"));
List users = criteria.list();

上面的程式将由Hibernate自动产生SQL的group by子句�q�行分组计算�Q?br />
Hibernate: select this_.age as y0_ from T_USER this_ group by this_.age

如果惛_��时结合统计与分组功能�Q�则可以使用org.hibernate.criterion.ProjectionList�Q�例如下面的�E�式会计��每个年龄各有多��个人：

ProjectionList projectionList = Projections.projectionList();
projectionList.add(Projections.groupProperty("age"));
projectionList.add(Projections.rowCount());

Criteria criteria = session.createCriteria(User.class);
criteria.setProjection(projectionList);
List users = criteria.list();

观察所产生的SQL语句�Q�将使用group by先进行分�l�，再针�Ҏ(gu��)��个分�l�进行count函数的计�?br />
Hibernate: select this_.age as y0_, count(*) as y1_ from T_USER this_ group by this_.age

�Ҏ(gu��)��已知物�g�q�行查询

讑֮�查询条�g�q��一定要使用Restrictions�Q�如果属性条件很多，使用Restrictions也不方便�Q�如果有一个已知的物�g�Q�则可以�Ҏ(gu��)��q�个物�g作�ؓ查询的依据，看看是否有属性与之类似的物�g�Q�例如：

User user = new User();
user.setAge(new Integer(30));

Criteria criteria = session.createCriteria(User.class);
criteria.add(Example.create(user));

List users = criteria.list();

�(zh��n)�可以透过org.hibernate.criterion.Example的create()�Ҏ(gu��)��来徏立Example实例�Q�Example实作了Criteria介面�Q�因此可以��用add()�Ҏ(gu��)��加入至Criteria条�g讑֮�之中�Q�Hibernate��自动过滤掉�I�属性，�Ҏ(gu��)��已知物�g上已讑֮�的属性，判定是否产生于where子句之中�Q?br />
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where (this_.age=?)

讑֮�SQL范本

如果�(zh��n)�了解如何撰写SQL语句�Q�想要设定一些Hibernate产生SQL时的范本�Q��?zh��n)�也可以��用Restrictions的sqlRestriction()�Ҏ(gu��)��Q�提供SQL语法范本作限定查询，例如查询name以cater开头的资料�Q?br />
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.sqlRestriction("{alias}.name LIKE (?)", "cater%", Hibernate.STRING));
List users = criteria.list();

其中alias��被替换��Z��User�c�d��相关的名�U�ͼ��?��被替换为cater%�Q�也��是�W�二个参数所提供的��|��sqlRestriction() �Ҏ(gu��)��W�一个参数所讑֮�的是where子句的部份，所以在SQL撰写�Ӟ��不必再写where�Q�观察所产生的SQL语句�Q�将使用�(zh��n)�所讑֮�的SQL范本作�ؓ基础�Q�来完成SQL的条件查询：

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where this_.name LIKE (?)

如果有多个查询条�Ӟ��例如between子句的查询，则可以如下：

Criteria criteria = session.createCriteria(User.class);
Integer[] ages = {new Integer(20), new Integer(40)};
Type[] types = {Hibernate.INTEGER, Hibernate.INTEGER};
criteria.add(Restrictions.sqlRestriction("{alias}.age BETWEEN (?) AND (?)", ages, types));
List users = criteria.list();

观察所产生的SQL语句如下�Q?br />
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where this_.age BETWEEN (?) AND (?)

使用DetchedCriteria

Criteria与Session�l�定�Q�其生命週期跟随着Session�l�束而结束，使用Criteria时进行查询时�Q�每�ơ都要于执行时期动态徏立物�Ӟ��q�加入各�U�查询条�Ӟ��随着Session的回�Ӟ��Criteria也跟着回收�?br />
��Z��能够重複使用Criteria物�g�Q�在Hibernate 3中新增了org.hibernate.criterion.DetchedCriteria�Q��?zh��n)�可以先徏立DetchedCriteria实例�Q��ƈ加入各种查询条�g�Q��ƈ于需要查询时再与Session�l�定�Q�获得一个绑定Session的Criteria物�g�Q�例如：

// 先徏立DetchedCriteria物�g
DetachedCriteria detchedCriteria = DetachedCriteria.forClass(User.class);
// 加入查询条�g
detchedCriteria.add(Restrictions.ge("age",new Integer(25)));

Session session = sessionFactory.openSession();
// �l�定Session�q�返回一个Criteria实例
Criteria criteria = detchedCriteria.getExecutableCriteria(session);

List users = criteria.list();

�l�论

Hibernate的Criteria API可以让�?zh��n)�使用物�g的方式，�l�合出查询资料库�pȝ��的条�Ӟ��Hibernate会自动依�(zh��n)�所使用的资料库�Q�动态��生SQL语句�Q�让�(zh��n)�的应用�E�式在存取资料库�Ӟ��不致于因撰写了特定的SQL而相依于特定的资料库�Q�如果�?zh��n)�的开发�h员不熟�?zh��n)�SQL语句的撰写，也可以试着使用Criteria来解��x��询资料库的需求�?

Eric_jiang 2010-08-16 22:43 发表评论

hibernate 3.0 多条件查询方�?

Eric_jiang — Thu, 12 Aug 2010 13:02:00 GMT

此方法可多条件查询且可以�Ҏ(gu��)��兌��的表条�g�q�行查询
如查询某个商品：
表结构如下：
goods(商品�?
goodsid(商品id) goodsname(名称) typeid(分类-外键) supplierid(供应�?外键)

type(分类�?
typeid(id主键) typename(分类名称)

supplier(供应商表)
supplierid(ID主键) suppliername( 供应商名�U?

你可��Z��个查询条件的�c�，里面包括你要查询的所有字�D?br /> �? public class Query{
    private String suppliername;
    private String goodsname;
    private String typename;
..................
get/set�Ҏ(gu��)��................
}

得到查询条�g后，可以把此�cȝ��一个对象传入自己做的方法，此方法可以根据条件的个数及是否输入条件进行查询：
public static List query_goods(Query query){
        Session session = SessionFactory.getSession();
        Criteria criteria = session.createCriteria(Goods.class);
        Criteria type = criteria.createCriteria("type");
        Criteria supplier= criteria.createCriteria("supplier");

        if(null!=query.getGoodsname() && !"".equels(query.getGoodsname() ))
            criteria.add(Restrictions.like("goodsname","%"+query.getGoodsname()+"%"));

       if(null!=query.getSuppliername() && !"".equels(query.getSuppliername() ))
            supplier.add(Restrictions.like("suppliername","%"+query.getSuppliername()+"%"));

        if(null!=query.getTypename() && !"".equels(query.getTypename() ))
            type.add(Restrictions.like("typename","%"+query.getTypename+"%"));

        List list = criteria.list();

        session.clear();
        session.close();
        return list;
    }

以上斚w��q�可多层的嵌套，如type里还有外键，可以按照以上�Ҏ(gu��)��q�行嵌套。注意，查询时所有涉及到的数据都��一�ơ性写入类的属性中�Q�包括有兌��的，��x��时goods的关联�g�q�加载无效，我觉得这一炚w��常的好。呵呵，有什么好处，可以自己好好的想惟�?br /> 有许多�h曄��提到�q�用Example�Q�就不用自己判断了，如果没有兌��条�g查询的话�Q�确实是好，可它的缺点就是不能查询关联中的条件�?

Eric_jiang 2010-08-12 21:02 发表评论

Hibernate中Criteria的完整用�?

Eric_jiang — Thu, 12 Aug 2010 12:51:00 GMT

�q�在��目中��?Spring �?Hibernate �q�行开发，有感�?Criteria 比较好用�Q�在查询�Ҏ(gu��)��

设计上可以灵�zȝ��Ҏ(gu��)�� Criteria 的特�Ҏ(gu��)��方便地进行查询条件的�l�装。现在对 Hibernate的Criteria 的用法进行�ȝ��Q?br />         Hibernate 设计�?CriteriaSpecification 作�ؓ Criteria 的父接口�Q�下面提供了 Criteria和DetachedCriteria �?
       Criteria �?DetachedCriteria 的主要区别在于创建的形式不一��P�� Criteria 是在�U�的�Q�所以它是由 Hibernate Session �q�行创徏的；�?DetachedCriteria 是离�U�的�Q�创建时无需 Session�Q�DetachedCriteria 提供�?2 个静态方�?forClass(Class) �?forEntityName(Name) �q�行DetachedCriteria 实例的创建�?Spring 的框架提供了getHibernateTemplate().findByCriteria(detachedCriteria) �Ҏ(gu��)��可以很方便地�Ҏ(gu��)��DetachedCriteria 来返回查询结
果�?
        Criteria �?DetachedCriteria 均可使用 Criterion �?Projection 讄��查询条�g。可以设�|?FetchMode( 联合查询抓取的模�?) �Q�设�|�排序方式。对�?Criteria �q�可以设�|?FlushModel �Q�冲�?Session 的方式）�?LockMode �Q�数据库锁模式）�?
下面�?Criterion �?Projection �q�行详细说明�?br />          Criterion �?Criteria 的查询条件。Criteria 提供�?add(Criterion criterion) �Ҏ(gu��)��来添加查询条件�?br />          Criterion 接口的主要实现包括： Example �?Junction �?SimpleExpression 。�?Junction 的实际��用是它的两个子类 conjunction �?disjunction �Q�分别是使用 AND �?OR 操作�W�进行来联结查询条�g集合�?br />          Criterion 的实例可以通过 Restrictions 工具�c�L��创徏�Q�Restrictions 提供了大量的静态方法，�?eq �Q�等于）�?ge �Q�大于等于）�?between �{�来�Ҏ(gu��)��的创�?Criterion 查询条�g �Q�SimpleExpression 实例�Q�。除此之外， Restrictions �q�提供了�Ҏ(gu��)��来创�?conjunction �?disjunction 实例�Q�通过往该实例的 add(Criteria) �Ҏ(gu��)��来增加查询条件�Ş成一个查询条仉��合�?br />         至于 Example 的创建有所不同�Q?Example 本��n提供了一个静态方�?create(Object entity) �Q�即�Ҏ(gu��)��一个对象（实际使用中一般是映射到数据库的对象）来创建。然后可以设�|�一些过滤条�Ӟ��
Example exampleUser =Example.create(u)
.ignoreCase() // 忽略大小�?
.enableLike(MatchMode.ANYWHERE);
/ / �?String �c�d��的属性，无论在那里值在那里都匹配。相当于 %value%
Project 主要是让 Criteria 能够�q�行报表查询�Q��ƈ可以实现分组�?Project 主要�?SimpleProjection �?ProjectionList �?Property 三个实现。其�?SimpleProjection �?
ProjectionList 的实例化是由内徏�?Projections 来完成，如提供的 avg �?count �?max �?min �?sum 可以让开发者很�Ҏ(gu��)��Ҏ(gu��)��个字�D�进行统计查询�?
       Property 是对某个字段�q�行查询条�g的设�|�，如通过Porperty.forName(“color”).in (new String[]{“black”,”red”,”write”}); 则可以创��Z��?Project 实例。通过
criteria �?add(Project) �Ҏ(gu��)��加入到查询条件中厅R�?
       使用 Criteria �q�行查询�Q�主要要清晰的是 Hibernate 提供了那些类和方法来满��开发中查询条�g的创建和�l�装�Q�下面介�l�几�U�用法：
1. 创徏一个Criteria 实例
org.hibernate.Criteria接口表示特定持久�cȝ��一个查询。Session�?Criteria实例的工厂�?br /> Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();

2. 限制�l�果集内�?br /> 一个单独的查询条�g是org.hibernate.criterion.Criterion 接口的一个实例�?/p>

org.hibernate.criterion.Restrictions�c?定义了获得某些内�|�Criterion�c�d��的工厂方法�?br /> List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.between("weight", minWeight, maxWeight) )
    .list();

�U�束可以按逻辑分组�?

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.or(
        Restrictions.eq( "age", new Integer(0) ),
        Restrictions.isNull("age")
    ) )
    .list();

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
    .add( Restrictions.disjunction()
        .add( Restrictions.isNull("age") )
        .add( Restrictions.eq("age", new Integer(0) ) )
        .add( Restrictions.eq("age", new Integer(1) ) )
        .add( Restrictions.eq("age", new Integer(2) ) )
    ) )
    .list();

Hibernate提供了相当多的内�|�criterion�c�d��(Restrictions 子类), 但是��其有用的是可以允许

你直接��用SQL�?/p>

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%",

Hibernate.STRING) )
.list();

{alias}占位�W�应当被替换��查询实体的列别名�?
Property实例是获得一个条件的另外一�U�途径。你可以通过调用Property.forName() 创徏一�?/p>

Property�?

Property age = Property.forName("age");
List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.disjunction()
        .add( age.isNull() )
        .add( age.eq( new Integer(0) ) )
        .add( age.eq( new Integer(1) ) )
        .add( age.eq( new Integer(2) ) )
    ) )
    .add( Property.forName("name").in( new String[] { "Fritz", "Izi", "Pk" } ) )
    .list();

3. �l�果集排�?br /> 你可以��用org.hibernate.criterion.Order来�ؓ查询�l�果排序�?

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "F%")
    .addOrder( Order.asc("name") )
    .addOrder( Order.desc("age") )
    .setMaxResults(50)
    .list();

List cats = sess.createCriteria(Cat.class)
    .add( Property.forName("name").like("F%") )
    .addOrder( Property.forName("name").asc() )
    .addOrder( Property.forName("age").desc() )
    .setMaxResults(50)
    .list();

4. 兌��
你可以��用createCriteria()非常�Ҏ(gu��)��的在互相兌��的实体间建立 �U�束�?/p>

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "F%")
    .createCriteria("kittens")
        .add( Restrictions.like("name", "F%")
    .list();

注意�W�二�?createCriteria()�q�回一个新�?Criteria实例�Q�该实例引用kittens 集合中的元素�?
接下来，替换形态在某些情况下也是很有用的�?/p>

List cats = sess.createCriteria(Cat.class)
    .createAlias("kittens", "kt")
    .createAlias("mate", "mt")
    .add( Restrictions.eqProperty("kt.name", "mt.name") )
    .list();

(createAlias()�q�不创徏一个新�?Criteria实例�?
Cat实例所保存的之前两�ơ查询所�q�回的kittens集合�?没有被条仉��q��o的。如果你希望只获�?/p>

�W�合条�g的kittens�Q?你必��M��用returnMaps()�?

List cats = sess.createCriteria(Cat.class)
    .createCriteria("kittens", "kt")
    .add( Restrictions.eq("name", "F%") )
    .returnMaps()
    .list();
Iterator iter = cats.iterator();
while ( iter.hasNext() ) {
    Map map = (Map) iter.next();
    Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
    Cat kitten = (Cat) map.get("kt");
}

5. 动态关联抓�?br /> 你可以��用setFetchMode()在运行时定义动态关联抓取的语义�?

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .setFetchMode("mate", FetchMode.EAGER)
    .setFetchMode("kittens", FetchMode.EAGER)
    .list();

�q�个查询可以通过外连接抓取mate和kittens�?/p>

6. 查询�C�Z��
org.hibernate.criterion.Example�c�d��怽�通过一个给定实�?构徏一个条件查询�?/p>

Cat cat = new Cat();
cat.setSex('F');
cat.setColor(Color.BLACK);
List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.list();

版本属性、标识符和关联被忽略。默认情况下��gؓnull的属性将被排除�?
可以自行调整Example使之更实用�?

Example example = Example.create(cat)
    .excludeZeroes()           //exclude zero valued properties
    .excludeProperty("color") //exclude the property named "color"
    .ignoreCase()              //perform case insensitive string comparisons
    .enableLike();             //use like for string comparisons
List results = session.createCriteria(Cat.class)
    .add(example)
    .list();

甚至可以使用examples在关联对象上攄��条�g�?/p>

List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .createCriteria("mate")
        .add( Example.create( cat.getMate() ) )
    .list();

7. 投媄(Projections)、聚合（aggregation�Q�和分组�Q�grouping�Q?br /> org.hibernate.criterion.Projections�?Projection 的实例工厂。我们通过调用

setProjection()应用投媄��C��个查询�?

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.rowCount() )
    .add( Restrictions.eq("color", Color.BLACK) )
    .list();

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount() )
        .add( Projections.avg("weight") )
        .add( Projections.max("weight") )
        .add( Projections.groupProperty("color") )
    )
    .list();

在一个条件查询中没有必要昑ּ�的��?"group by" 。某些投��q��型就是被定义�?分组投媄�Q�他

们也出现在SQL的group by子句中�?

可以选择把一个别名指�z��一个投影，�q�样可以使投影��D��U�束或排序所引用。下面是两种不同�?/p>

实现方式�Q?/p>

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.alias( Projections.groupProperty("color"), "colr" ) )
    .addOrder( Order.asc("colr") )
    .list();

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.groupProperty("color").as("colr") )
    .addOrder( Order.asc("colr") )
    .list();

alias()和as()�Ҏ(gu��)��便的��一个投影实例包装到另外一�?别名的Projection实例中。简而言之，

当你��d��一个投影到一个投影列表中�?你可以�ؓ它指定一个别名：

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount(), "catCountByColor" )
        .add( Projections.avg("weight"), "avgWeight" )
        .add( Projections.max("weight"), "maxWeight" )
        .add( Projections.groupProperty("color"), "color" )
    )
    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();

List results = session.createCriteria(Domestic.class, "cat")
    .createAlias("kittens", "kit")
    .setProjection( Projections.projectionList()
        .add( Projections.property("cat.name"), "catName" )
        .add( Projections.property("kit.name"), "kitName" )
    )
    .addOrder( Order.asc("catName") )
    .addOrder( Order.asc("kitName") )
    .list();

也可以��用Property.forName()来表�C�投影：

List results = session.createCriteria(Cat.class)
    .setProjection( Property.forName("name") )
    .add( Property.forName("color").eq(Color.BLACK) )
    .list();
List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount().as("catCountByColor") )
        .add( Property.forName("weight").avg().as("avgWeight") )
        .add( Property.forName("weight").max().as("maxWeight") )
        .add( Property.forName("color").group().as("color" )
    )
    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();

8. ��ȝ��(detached)查询和子查询
DetachedCriteria�c�M��你在一个session范围之外创徏一个查询，�q�且可以使用��L��?Session�?/p>

执行它�?/p>

DetachedCriteria query = DetachedCriteria.forClass(Cat.class)
.add( Property.forName("sex").eq('F') );
//创徏一个Session
Session session = .;
Transaction txn = session.beginTransaction();
List results = query.getExecutableCriteria(session).setMaxResults(100).list();
txn.commit();
session.close();

DetachedCriteria也可以用以表�C�子查询。条件实例包含子查询可以通过 Subqueries或�?br /> Property获得�?/p>

DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight").avg() );
session.createCriteria(Cat.class)
    .add( Property.forName("weight).gt(avgWeight) )
    .list();
DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight") );
session.createCriteria(Cat.class)
    .add( Subqueries.geAll("weight", weights) )
    .list();

�怺�兌��的子查询也是有可能的�Q?/p>

DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")
    .setProjection( Property.forName("weight").avg() )
    .add( Property.forName("cat2.sex").eqProperty("cat.sex") );
session.createCriteria(Cat.class, "cat")
    .add( Property.forName("weight).gt(avgWeightForSex) )
    .list();

Eric_jiang 2010-08-12 20:51 发表评论

Hibernate 对象三种状�?瞬时�?持久�?��q��?以及 save update saveOrUpdate merge�{�的使用

Eric_jiang — Tue, 10 Aug 2010 15:39:00 GMT

      Hibernate的对象有3�U�状态，分别为：瞬时�?Transient)�?持久�?Persistent)、脱��?Detached)。处于持久态的对象也称为PO(Persistence Object)�Q�瞬时对象和��q��对象也称为VO�Q�Value Object�Q��?br />
   * 瞬时�?br />
   由new命��o开辟内存空间的java对象�Q?br />
   eg. Person person = new Person("amigo", "�?);

   如果没有变量对该对象�q�行引用�Q�它?y��u)��被java虚拟机回收�?br />
   瞬时对象在内存孤立存在，它是携带信息的蝲体，不和数据库的数据有�Q何关联关�p�，在Hibernate中，可通过session的save()�?saveOrUpdate()�Ҏ(gu��)��瞬时对象与数据库相兌��Q��ƈ��数据对应的插入数据库中�Q�此时该瞬时对象转变�?span style="color: red;">持久化对�?/span>�?br />
   * 持久�?br />
   处于该状态的对象在数据库中具有对应的记录�Q��ƈ拥有一个持久化标识。如果是用hibernate的delete()�Ҏ(gu��)��Q�对应的持久对象��变�?span style="color: red;">瞬时对象�Q�因数据库中的对应数据已被删除，该对象不再与数据库的记录兌��?br />    当一个session执行close()或clear()、evict()之后�Q�持久对象变�?span style="color: red;">��q��对象�Q�此时持久对象会变成��q��对象�Q�此时该对象虽然��h��数据库识别��|��但它已不在HIbernate持久层的��理之下�?br />
   持久对象��h��如下特点�Q?br />
   1. 和session实例兌��Q?br />    2. 在数据库中有与之兌��的记�?/span>�?br />
   * ��q��?br />
   当与某持久对象关联的session被关闭后�Q�该持久对象转变��对象。当��q��对象被重新关联到session上时�Q��ƈ再次转变成持久对象�?br />    ��q��对象拥有数据库的识别��|��可通过update()、saveOrUpdate()�{�方法，转变�?span style="color: red;">持久对象�?br />
   ��q��对象��h��如下特点�Q?br />
   1. 本质上与瞬时对象相同�Q�在没有��M��变量引用它时�Q�JVM会在适当的时候将它回�?/span>�Q?br />    2. 比瞬时对象多了一个数据库记录标识�?/span>�?br />

   瞬�?Transient)�Q�也叫��(f��)时态。处于这�U�状态的对象具备的特征如下：

       不在Session的缓存中�Q�不与�Q何的Session实例相关联�?nbsp;

       在数据库中没有与之相对应的记录�?nbsp;

   持久�?Persistent)�Q�处于这�U�状态的对象具备的特征如下：

       在Session的缓存中�Q�与Session实例相关联�?nbsp;

       在数据库中存在与之相对应的记录�?nbsp;

   ��q��?Detached)�Q�也叫游��L��。处于这�U�状态的对象具备的特征如下：

       不在Session的缓存中�Q�不与�Q何的Session实例相关联�?nbsp;

       在数据库中存在与之相对应的记录�?前提条�g是没有其他Session实例删除该条记录)�?nbsp;

一、预备知�?br /> 对于hibernate�Q�它的对象有三种状态，transient、persistent、detached
下边是常见的��译办法�Q?br /> transient�Q�瞬态或者自由�?br />    (new DeptPo(1,”行政�?#8221;,20,”行政相关”)�Q�该po的实例和session没有兌��Q�该po的实例处于transient)
persistent�Q�持久化状�?br />    (和数据库中记录想影射的Po实例�Q�它的状态是persistent, 通过get和load�{�得到的对象都是persistent)
detached�Q�脱��状态或者游��L�?br />    (1)当通过get或load�Ҏ(gu��)��得到的po对象它们都处于persistent,但如果执行delete(po)�?但不能执行事�?,该po状态就处于detached, (表示和session��q��兌��),因delete而变成游��L��可以通过save或saveOrUpdate()变成持久�?br />    (2)当把session关闭�Ӟ��session�~�存中的persistent的po对象也变成detached

因关闭session而变成游��L��的可以通过lock、save、update变成持久�?br /> 持久态实例可以通过调用 delete()变成��q��状态�?br /> 通过get()或load()�Ҏ(gu��)��得到的实例都是持久化状态的�?br /> ��q��状态的实例可以通过调用lock()或者replicate()�q�行持久化�?br /> save()和persist()��会引发SQL的INSERT�Q�delete()会引发SQLDELETE�Q?br /> 而update()或merge()会引发SQL UPDATE。对持久化（persistent�Q�实例的修改在刷新提交的时候会被检��到�Q�它也会引�vSQL UPDATE�?br /> saveOrUpdate()或者replicate()会引发SQL INSERT或者UPDATE

二、save 和update区别
   把这一�Ҏ(gu��)��在第一位的原因是因��一�Ҏ(gu��)��最常用的�?br />    save的作用是把一个新的对象保�?br />    update是把一个脱��状态的对象或自由态对象（一定要和一个记录对应）更新到数据库
三、update 和saveOrUpdate区别
   �q�个是比较好理解的，��֐�思义�Q�saveOrUpdate基本上就是合成了save和update,而update只是update;引用hibernate reference中的一�D�话来解释他们的使用场合和区�?br />    通常下面的场景会使用update()或saveOrUpdate()�Q?br />    �E�序在第一个session中加载对�?接着把session关闭
   该对象被传递到表现�?br />    对象发生了一些改�?br />    该对象被�q�回��C��务逻辑层最�l�到持久�?br />    �E�序创徏�W�二session调用�W�二个session的update()�Ҏ(gu��)��持久�q�些改动
   saveOrUpdate(po)做下面的�?
   如果该po对象已经在本session中持久化了，在本session中执行saveOrUpdate不做��M��?br />    如果savaOrUpdate(新po)与另一个与本session兌��的po对象拥有相同的持久化标识(identifier)�Q�抛��Z��个异�?br />    org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: [org.itfuture.www.po.Xtyhb#5]
   saveOrUpdate如果对象没有持久化标�?identifier)属性，对其调用save() �Q�否则update() �q�个对象
四、persist和save区别
   �q�个是最�q�L(f��ng)��的一对，表面上看��h��使用哪个都行�Q�在hibernate reference文档中也没有明确的区分他�?
   �q�里�l�出一个明��的区分。（可以跟进src看一下，虽然实现步骤�c�M��Q�但是还是有�l�微的差别）
   主要内容区别�Q?br />    1�Q�persist把一个瞬态的实例持久化，但是�q?不保�?标识�W?identifier主键对应的属�?被立��d��入到持久化实例中�Q�标识符的填入可能被推迟到flush的时候�?br />    2�Q�save, 把一个瞬态的实例持久化标识符�Q�及时的产生,它要�q�回标识�W�，所以它会立��x��行Sql insert
五、saveOrUpdate,merge和update区别
   比较update和merge
   update的作用上边说了，�q�里说一下merge�?br />    如果session中存在相同持久化标识(identifier)的实例，用用��L(f��ng)��出的对象覆盖session已有的持久实�?br />    (1)当我们��用update的时候，执行完成后，会抛出异�?br />    (2)但当我们使用merge的时候，把处理自由态的po对象A的属性copy到session当中处于持久态的po的属性中�Q�执行完成后原来是持久状态还是持久态，而我们提供的A�q�是自由�?br /> 六、flush和update区别
   �q�两个的区别好理�?br />    update操作的是在自由态或��q��状�?因session的关闭而处于脱��状�?的对�?/updateSQL
   而flush是操作的在持久状态的对象�?br />    默认情况下，一个持久状态的对象的改动（包含set容器�Q�是不需要update的，只要你更改了对象的��|��{�待hibernate flush��p��动更新或保存到数据库了。hibernate flush发生在以下几�U�情况中�Q?br />    1�Q?调用某些查询的和手动flush(),session的关闭、SessionFactory关闭�l�合
   get()一个对象，把对象的属性进行改�?把资源关闭�?br />    2�Q�transaction commit的时候（包含了flush�Q?br /> 七、lock和update区别
   update是把一个已�l�更改过的脱��状态的对象变成持久状�?br />    lock是把一个没有更改过的脱��状态的对象变成持久状�?针对的是因Session的关闭而处于脱��状态的po对象(2)�Q�不能针对因delete而处于脱��状态的po对象)
   对应更改一个记录的内容�Q�两个的操作不同�Q?br />    update的操作步骤是�Q?br />    (1)属性改动后的脱��的对象的修�?>调用update
   lock的操作步骤是�Q?br />    (2)调用lock把未修改的对象从��q��状态变成持久状�?->更改持久状态的对象的内�?->�{�待f(xi��)lush或者手动flush
八、clear和evcit的区�?br />    clear完整的清除session�~�存
   evcit(obj)把某个持久化对象从session的缓存中清空�?nbsp;

Eric_jiang 2010-08-10 23:39 发表评论

解决hibernate 删除异常�Q�deleted object would be re-saved by cascade (remove deleted object from

Eric_jiang — Sat, 31 Jul 2010 12:58:00 GMT

我遇到到是第三种

解决hibernate 删除异常�Q?deleted object would be re-saved by cascade (remove deleted object from associations) 收藏
在hibernate 删除兌��时会出现eleted object would be re-saved by cascade (remove deleted object from associations)的异常，�l�合别�h的和自己的经验通常有三�U�解决的�Ҏ(gu��)��Q?/font>

�Ҏ(gu��)��1 删除Set方的cascade�Q?br /> �Ҏ(gu��)��2 解决兌��关系后，再删�?/font>

onside.getManys().remove(thisMany); //在所兌��的一方的set中移走当前要删除的对�?br /> thisMany.setOne(null); //讄��所对应的一方�ؓ�I�，解除它们之间的关�p?br /> manyDao.delete(thisMany);
�Ҏ(gu��)��3 在many-to-one方增加cascade 但��g��能是none

Eric_jiang 2010-07-31 20:58 发表评论

Eric_jiang — Wed, 23 Jun 2010 15:23:00 GMT

其实�q�个异常写的非常之清楚，��是会话关闭�Q�无法对Hibernate实体�q�行操作。造成�q�样的情冉|��很多�Q�什么书写错误啊�Q�逻辑错误 �?�{�等.不过,偶是因�ؓLAZY.

�? 于lazy机制�Q?/font>

延迟初始化错误是�q�用Hibernate开发项目时最常见的错误。如果对一个类或者集合配�|�了延迟�� 索策略，那么必须当代理类实例或代理集合处于持久化状态（卛_��于Session范围内）�Ӟ��才能初始化它。如果在游离状态时才初始化它，��׃��产生延迟初始化错误�?/font>

下面把Customer.hbm.xml文�g�?lt;class>元素的lazy属性设为true�Q�表�C�Z��用�g�q�检索策略：

当执行Session的load()�Ҏ(gu��)��Ӟ��Hibernate不会立即执行查询CUSTOMERS表的select语句�Q�仅仅返�? Customer�cȝ��代理�cȝ��实例�Q�这个代理类��L(f��ng)��以下特征�Q?/font>

�Q?�Q? 由Hibernate在运行时动态生成，它扩展了Customer�c�，因此它��承了Customer�cȝ��所有属性和�Ҏ(gu��)��Q�但它的实现对于应用�E�序是透明的�?br /> �Q?�Q? 当Hibernate创徏Customer代理�c�d��例时�Q�仅仅初始化了它的OID属性，其他属性都为null�Q�因此这个代理类实例占用的内存很��?br /> �Q?�Q�当应用�E�序�W�一�ơ访问Customer代理�c�d��例时�Q�例如调用customer.getXXX()或customer.setXXX()�Ҏ(gu��)��Q�， Hibernate会初始化代理�c�d��例，在初始化�q�程中执行select语句�Q�真正从数据库中加蝲Customer对象的所有数据。但有个例外�Q�那��是�? 应用�E�序讉K��Customer代理�c�d��例的getId()�Ҏ(gu��)��Ӟ��Hibernate不会初始化代理类实例�Q�因为在创徏代理�c�d��例时OID��存在了�Q�不�? 到数据库中去查询�?/font>

提示�Q�Hibernate采用CGLIB工具来生成持久化�cȝ��代理�c�R��CGLIB是一个功能强大的Java字节码生成工��P��它能够在�E? 序运行时动态生成扩�? Java�c�L��者实现Java接口的代理类。关于CGLIB的更多知识，请参考：

http://cglib.sourceforge.net/�?/font>

以下代码先通过Session的load()�Ҏ(gu��)��加蝲Customer对象�Q�然后访问它的name属性：

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
customer.getName();
tx.commit();

在运行session.load()�Ҏ(gu��)��时Hibernate不执行�Q何select语句�Q�仅仅返回Customer�cȝ��代理�cȝ��? 例，它的OID�?�Q�这是由load()�Ҏ(gu��)��的第二个参数指定的。当应用�E�序调用customer.getName()�Ҏ(gu��)��Ӟ��Hibernate会初�? 化Customer代理�c�d��例，从数据库中加载Customer对象的数据，执行以下select语句�Q?/font>

select * from CUSTOMERS where ID=1;
select * from ORDERS where CUSTOMER_ID=1;

�?lt;class>元素的lazy属性�ؓtrue�Q�会影响Session的load()�Ҏ(gu��)��的各�U�运行时行�ؓ�Q�下面�D例说明�?/font>

1�Q�如果加载的Customer对象在数据库中不存在�Q�Session的load()�Ҏ(gu��)��不会抛出异常�Q�只有当�q�行 customer.getName()�Ҏ(gu��)��时才会抛��Z��下异常：

ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.ObjectNotFoundException: No row with the given identifier exists: 1, of class:
mypack.Customer

2�Q�如果在整个Session范围内，应用�E�序没有讉K��q�Customer对象�Q�那么Customer代理�cȝ��实例一直不会被初始化，Hibernate不会执行��M��select语句。以下代码试囑֜�关闭Session后访问Customer游离对象�Q?/font>

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
tx.commit();
session.close();
customer.getName();

�׃��引用变量customer引用的Customer代理�cȝ��实例在Session范围内始�l�没有被初始化，因此在执�? customer.getName()�Ҏ(gu��)��Ӟ��Hibernate会抛��Z��下异常：

ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed

由此可见�Q�Customer代理�cȝ��实例只有在当前Session范围内才能被初始化�?/font>

3�Q�net.sf.hibernate.Hibernate�cȝ��initialize()静态方法用于在Session范围内显式初�? 化代理类实例�Q�isInitialized()�Ҏ(gu��)��用于判断代理�c�d��例是否已�l�被初始化。例如：

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
if(!Hibernate.isInitialized(customer))
Hibernate.initialize(customer);
tx.commit();
session.close();
customer.getName();

以上代码在Session范围内通过Hibernate�cȝ��initialize()�Ҏ(gu��)��昑ּ�初始化了Customer代理�c�d��例，�? 此当Session关闭后，可以正常讉K��Customer游离对象�?/font>

4�Q�当应用�E�序讉K��代理�c�d��例的getId()�Ҏ(gu��)��Ӟ��不会触发Hibernate初始化代理类实例的行为，例如�Q?/font>

tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
customer.getId();
tx.commit();
session.close();
customer.getName();

当应用程序访问customer.getId()�Ҏ(gu��)��Ӟ��该方法直接返回Customer代理�c�d��例的OID��|��无需查询数据库。由�? 引用变量 customer始终引用的是没有被初始化的Customer代理�c�d��例，因此当Session关闭后再执行customer.getName()�Ҏ(gu��)��Q? Hibernate会抛��Z��下异常：

ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed

解决�Ҏ(gu��)��Q?/p>

�׃��hibernate采用了lazy=true,�q�样当你用hibernate查询�?�q�回实际为利用cglib增强的代理类,但其�q�没有实际填 �?当你在前�?利用它来取�?getXXX)�?�q�时Hibernate才会到数据库执行查询,�q�填充对�?但此时如果和�q�个代理�cȝ��关的 session已关闭掉,��׃��产生�U�错�?
在做一对多�Ӟ��有时会出�?could not initialize proxy - clothe owning Session was sed,�q�个好像是hibernate的缓存问�?问题解决:需要在里设�|�lazy="false". 但有可能会引发另一个异常叫

failed to lazily initialize a collection of role: XXXXXXXX, no session or session was closed

此异常解��x��案请察看本�h博客�Q�http://hi.baidu.com/kekemao1�Q�的Hibernate异常中的《failed to lazily initialize a collection of role异常�?/p>

?
解决�Ҏ(gu��)��:在web.xml中加�?br />
    hibernateFilter

     org.springframework.orm.hibernate3.support.OpenSessionInViewFilter


    hibernateFilter
    *.do

��可以了;

参考了:
Hibernate与�g�q�加载：

Hibernate对象关系映射提供延迟的与非�g�q�的对象初始化。非延迟加蝲在读取一个对象的时候会��与�q�个对象所有相关的其他对象一赯��取出来�? �q�有时会��D��成百的（如果不是成千的话�Q�select语句在读取对象的时候执行。这个问题有时出现在使用双向关系的时候，�l�常会导致整个数据库都在初始�? 的阶�D�被��d��来了。当�Ӟ��你可以不厌其烦地��查每一个对象与其他对象的关�p�，�q�把那些最昂贵的删除，但是到最后，我们可能会因此失��M��本想在ORM工具�? 获得的便利�?/p>

一个明昄��解决�Ҏ(gu��)��是��用Hibernate提供的�g�q�加载机制。这�U�初始化�{�略只在一个对象调用它的一对多或多对多关系时才��关�p�d��象读取出来。这个过 �E�对开发者来说是透明的，而且只进行了很少的数据库操作��h��Q�因此会得到比较明显的性能提升。这��Ҏ(gu��)��术的一个缺��h��延迟加蝲技术要求一�? Hibernate会话要在对象使用的时候一直开着。这会成为通过使用DAO模式��持久层抽象出来时的一个主要问题。�ؓ了将持久化机制完全地抽象出来�Q�所有的数据库逻辑�Q�包括打开或关闭会话，都不能在应用层出现。最常见的是�Q�一些实��C��单接口的DAO实现�c�d��数据库逻辑完全��装��h��了。一�U�快速但是笨�? 的解��x��法是攑ּ�DAO模式�Q�将数据库连接逻辑加到应用层中来。这可能对一些小的应用程序有效，但是在大的系�l�中�Q�这是一个严重的设计�~�陷�Q�妨��了�pȝ��? 可扩展性�?/p>

在Web层进行�g�q�加�?/p>

�q�运的是�Q�Spring框架为Hibernate延迟加蝲与DAO模式的整合提供了一�U�方便的解决�Ҏ(gu��)��。对那些不熟�(zh��n)�Spring�? Hibernate集成使用的�h�Q�我不会在这里讨��多的�l�节�Q�但是我��你去了解Hibernate与Spring集成的数据访问。以一个Web应用�? 例，Spring提供了OpenSessionInViewFilter和OpenSessionInViewInterceptor。我们可以随意选择一个类来实现相同的功能。两�U�方法唯一的不同就在于interceptor在Spring容器中运行�ƈ被配�|�在web应用的上下文中，而Filter�? Spring之前�q�行�q�被配置在web.xml中。不��用哪个�Q�他们都在请求将当前会话与当前（数据库）�U�程�l�定时打开Hibernate会话。一旦已�l? 定到�U�程�Q�这个打开了的Hibernate会话可以在DAO实现�c�M��透明��C��用。这个会话会为�g�q�加载数据库中值对象的视图保持打开状态。一旦这个逻辑�? 囑֮�成了�Q�Hibernate会话会在Filter的doFilter�Ҏ(gu��)��或者Interceptor的postHandle�Ҏ(gu��)��中被关闭。下面是每个�l? 件的配置�C�Z��Q?/p>

Interceptor的配�|?

class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

class="org.springframework.orm.hibernate.support.OpenSessionInViewInterceptor">

Filter的配�|?/p>

hibernateFilter

org.springframework.orm.hibernate.support.OpenSessionInViewFilter

hibernateFilter
*. spring

实现Hibernate的Dao接口来��用打开的会话是很容易的。事实上�Q�如果你已经使用了Spring框架来实��C��的Hibernate Dao,很可能你不需要改变�Q何东�ѝ��方便的HibernateTemplate公用�l��g使访问数据库变成��菜一��，而DAO接口只有通过�q�个�l��g才可�? 讉K��到数据库。下面是一个示例的DAO�Q?/p>

public class HibernateProductDAO extends HibernateDaoSupport implements ProductDAO {

public Product getProduct(Integer productId) {
return (Product)getHibernateTemplate().load(Product.class, productId);
}

public Integer saveProduct(Product product) {
return (Integer) getHibernateTemplate().save(product);
}

public void updateProduct(Product product) {
getHibernateTemplate().update(product);
}
}

在业务逻辑层中使用延迟加蝲

即��在视囑֤�面，Spring框架也通过使用AOP 拦截�? HibernateInterceptor来��得�g�q�加载变得很�Ҏ(gu��)��实现。这个Hibernate 拦截器透明地将调用配置在Spring应用�E�序上下文中的业务对象中�Ҏ(gu��)��的请求拦截下来，在调用方法之前打开一个Hibernate会话�Q�然后在�Ҏ(gu��)��执行完之后将会话关闭。让我们来看一个简单的例子�Q�假设我们有一个接口BussinessObject�Q?/p>

public interface BusinessObject {
public void doSomethingThatInvolvesDaos();
}
�c�BusinessObjectImpl实现了BusinessObject接口:

public     class    BusinessObjectImpl    implements    BusinessObject     {
public     void    doSomethingThatInvolvesDaos()     {
//    lots of logic that calls
//    DAO classes Which access
//    data objects lazily
}
}

通过在Spring应用�E�序上下文中的一些配�|�，我们可以让将调用BusinessObject的方法拦截下来，再��o它的�Ҏ(gu��)��支持延迟加蝲。看看下面的一个程序片�D�：

com.acompany.BusinessObject

hibernateInterceptor

当businessObject被调用的时候，HibernateInterceptor打开一个Hibernate会话�Q��ƈ��调用请求传递给 BusinessObjectImpl对象。当BusinessObjectImpl执行完成后，HibernateInterceptor透明地关闭了会话。应用层的代码不用了解�Q何持久层逻辑�Q�还是实��C��延迟加蝲�?/p>

在单元测试中��试延迟加蝲

最后，我们需要用J-Unit来测试我们的延迟加蝲�E�序。我们可以轻易地通过重写TestCase�c�M��的setUp和tearDown�Ҏ(gu��)��来实现这个要求。我比较喜欢用这个方便的抽象�c�M��为我所有测试类的基�c�R�?/p>

public abstract class MyLazyTestCase extends TestCase {

private SessionFactory sessionFactory;
private Session session;

public void setUp() throws Exception {
super.setUp();
SessionFactory sessionFactory = (SessionFactory) getBean("sessionFactory");
session = SessionFactoryUtils.getSession(sessionFactory, true);
Session s = sessionFactory.openSession();
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));

}

protected Object getBean(String beanName) {
//Code to get objects from Spring application context
}

public void tearDown() throws Exception {
super.tearDown();
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
Session s = holder.getSession();
s.flush();
TransactionSynchronizationManager.unbindResource(sessionFactory);
SessionFactoryUtils.closeSessionIfNecessary(s, sessionFactory);
}

Eric_jiang 2010-06-23 23:23 发表评论

关于An association from the table refers to an unmapped class

Eric_jiang — Wed, 12 May 2010 07:24:00 GMT

1,��查你的hibernate.cfg.xml文�g中是否添加了
2,��查你的hibernate.cfg.xml文�g中的相关联的两个的顺序，可能有其中一个需要引用另一个，但是另一个却�q�没有编译，��是说被用作外键的表要放在前�?br /> 3,��查你�?.hbm.xml文�g名是否正��?br /> 4, ��查你�?.hbm.xml里面�c�d��?

Eric_jiang 2010-05-12 15:24 发表评论

Eric_jiang — Tue, 11 May 2010 09:15:00 GMT

摘要: �?-4 3�U�数据类型之间的对应关系 Hibernate映射�c�d�� Java�c�d�� 标准SQL�c�d�� ... 阅读全文

Eric_jiang 2010-05-11 17:15 发表评论

Java数据�c�d��Q�Hibernate数据�c�d��Q�标准sql数据�c�d��之间的对应表

Eric_jiang — Tue, 11 May 2010 08:49:00 GMT

Java数据�c�d��Q�Hibernate数据�c�d��Q�标准sql数据�c�d��之间的对应表

Java数据�c�d��	Hibernate数据�c�d��	标准SQL数据�c�d�� (PS:对于不同的DB可能有所差异)
byte、java.lang.Byte	byte	TINYINT
short、java.lang.Short	short	SMALLINT
int、java.lang.Integer	integer	INGEGER
long、java.lang.Long	long	BIGINT
float、java.lang.Float	float	FLOAT
double、java.lang.Double	double	DOUBLE
java.math.BigDecimal	big_decimal	NUMERIC
char、java.lang.Character	character	CHAR(1)
boolean、java.lang.Boolean	boolean	BIT
java.lang.String	string	VARCHAR
boolean、java.lang.Boolean	yes_no	CHAR(1)('Y'�?N')
boolean、java.lang.Boolean	true_false	CHAR(1)('Y'�?N')
java.util.Date、java.sql.Date	date	DATE
java.util.Date、java.sql.Time	time	TIME
java.util.Date、java.sql.Timestamp	timestamp	TIMESTAMP
java.util.Calendar	calendar	TIMESTAMP
java.util.Calendar	calendar_date	DATE
byte[]	binary	VARBINARY、BLOB
java.lang.String	text	CLOB
java.io.Serializable	serializable	VARBINARY、BLOB
java.sql.Clob	clob	CLOB
java.sql.Blob	blob	BLOB
java.lang.Class	class	VARCHAR
java.util.Locale	locale	VARCHAR
java.util.TimeZone	timezone	VARCHAR
java.util.Currency	currency	VARCHAR

Eric_jiang 2010-05-11 16:49 发表评论

hibernate的表�l�构以及表之间的关系的　*.hbm.xml

Eric_jiang — Tue, 11 May 2010 06:06:00 GMT

假设有一个实体类�Q�用于存攄��户信息，其定义如下：

package events;

import java.util.*;

public class Person {

    private Long id;
    private int age;
    private String firstname;
    private String lastname;

public Person() {}

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getFirstname() {
        return firstname;
    }

    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }

    public String getLastname() {
        return lastname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

private Set emailAddresses = new HashSet();

    public Set getEmailAddresses() {
        return emailAddresses;
    }

    public void setEmailAddresses(Set emailAddresses) {
        this.emailAddresses = emailAddresses;
    }

private Set events = new HashSet();

    // Defensive, convenience methods
    protected Set getEvents() {
        return events;
    }

    protected void setEvents(Set events) {
        this.events = events;
    }

    public void addToEvent(Event event) {
        this.getEvents().add(event);
        event.getParticipants().add(this);
    }

    public void removeFromEvent(Event event) {
        this.getEvents().remove(event);
        event.getParticipants().remove(this);
    }

}

则相应的描述POJO--->Person.hbm.xml中的配置信息如下�Q?br />

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"

说明�Q?/div>

�Q�．class 节点

name: �c�d��

table: �c�d��应表名，默认为类名称

dynamic-update: 生成更新字段�Ӟ��只包含发生变动的字段�Q�默认�ؓfalse�?br />
dynamic-insert:　生成insert语句时仅包含非null字段

Proxy: 代理�c�，默认为空

discriminator-value: 子类辨别标识用于多态支�?br />
where:　通过限定条�g查询�l�果集。如�Q�查询有�c�在校学生的信息可以使用"where studentstatus='0'"

2.id节点

1.column               字段名称
2.type                 字段�c�d��
3.length               字段长度
4.unsaved-value        用于判断对象值是否已�l�保�?br /> 5.generator-class      主键产生方式
                       assigned
                       hilo
                       seqhilo
                       increment
                       identity
                       sequence
                       native
                       uuid.hex
                       uuid.string
                       foreign

3.property 节点

1.column               数据库表字段名称
2.type                 �c�d��
3.length               长度
4.not-null             字段是否允许为空
5.unique               字段是否允许唯一�Q�是否允讔R��复��|��
6.insert               insert操作�Ӟ��是否允许包含本字�D�|��?br /> 7.update               update操作�Ӟ��是否包含本字�D�|��?/p>

Event.hbm.xml

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"

Eric_jiang 2010-05-11 14:06 发表评论

使用Hibernate的客户化映射�c�d��

Eric_jiang — Tue, 11 May 2010 03:40:00 GMT

Hibernate提供客户化映��类型接口，使用戯��以编�E�方式创��定义的映��类型来��持久化�c�M�Q意类型的属性映��到数据库中。��用客户化映射�c�d��Q�需要实现org.hibernate.usertype.UserType接口。这是个强大的功能，也是Hibernate的最�?j��ng)_��践之一。我们经常提到ORM中很困难的一点便是O的属性和R的属性不能一一映射�Q�而Hibernate提供的UserType无疑�l�出了一个很好的解决�Ҏ(gu��)��。本文给��Z��用客户化映射�c�d��的两个例子，��是对Hibernate初学者的抛砖�?br /> �W�一个例子是使用UserType映射枚�D�c�d��。假设Account表中含有一sex列，�c�d��为tinyint�Q�当前其0代表��P��1代表奻I��来可能出现2�{�代表其他性别�c�d��Q�；我们当然可以在对应的Account�c�M��d��int�c�d��的sex属性，但这�U�数字化无显�C�意义且�c�d��不安全的枚�D不是很好的解��x��式，�q�里��采用了java5的enum来作为Account�cȝ��性别属性（如果不熟�(zh��n)�java5的enum�Q�也可采用《effective java》中提到的经典的�c�d��安全的枚举方案）。在Account��d��enum Gender�Q?br />

public class Account extends AbstractDomain<Long>{

    public enum Gender{
        Male("male",0),
        Female("female",1);

        private String name;
        private int value;

        public String getName() {
            return name;
        }
        public int getValue() {
            return value;
        }

        private Gender(String name,int value){
            this.name = name;
            this.value = value;
        }

        public static Gender getGender(int value){
            if(0 == value)return Male;
            else if(1 == value)return Female;
            else throw new RuntimeException();
        }

    }

    private Gender gender;
    public Gender getGender() {
        return gender;
    }
    public void setGender(Gender gender) {
        this.gender = gender;
    }
       //省略其他
}

接下来定义实现UserType接口的GenderUserType�Q?br />

public class GenderUserType implements UserType{

    public Object assemble(Serializable arg0, Object arg1) throws HibernateException {
        return null;
    }

    /*
     *  �q�是用于Hibernate�~�存生成的快照，�׃��Gender是不可变的，直接�q�回��好了�?br />      */
    public Object deepCopy(Object arg0) throws HibernateException {
        return arg0;
    }

    public Serializable disassemble(Object arg0) throws HibernateException {
        return null;
    }

    /*
     * �׃��Gender是不可变的，因此直接==了，�q�个�Ҏ(gu��)��在insert、update时用到�?br />      */
    public boolean equals(Object x, Object y) throws HibernateException {
        return x == y;
    }

    public int hashCode(Object o) throws HibernateException {
        return o.hashCode();
    }

    /*
     * 表明Gender是不是可变类�Q�很重要的概念哦�Q�，�q�里的Gender�׃��是枚举所以是不可变的
     */
    public boolean isMutable() {
        return false;
    }

    /*
     *  从ResultSet��d��sex�q�返回Gender实例�Q�这个方法是在从数据库查询数据时用到�?br />      */
    public Object nullSafeGet(ResultSet rs, String[] names, Object owner) throws HibernateException, SQLException {
        int value = rs.getInt(names[0]);
        return Account.Gender.getGender(value);
    }

    /*
     *  ��Gender的value讄��到PreparedStatement�?br />      */
    public void nullSafeSet(PreparedStatement ps, Object value, int index) throws HibernateException, SQLException {
        if(value == null){
            ps.setInt(index,Account.Gender.Male.getValue());
        }else{
            ps.setInt(index,((Account.Gender)value).getValue());
        }
    }

    public Object replace(Object arg0, Object arg1, Object arg2) throws HibernateException {
        return null;
    }

    /*
     * 讄��映射的Gender�c?br />      */
    public Class returnedClass() {
        return Account.Gender.class;
    }

    /*
     *  讄��Gender枚�D中的value属性对应的Account表中的sex列的SQL�c�d��
     */
    public int[] sqlTypes() {
        int[] typeList = {Types.TINYINT};
        return typeList;
    }
}

   最后在Account的配�|�文件中配置gender属性就好了�Q?br />
   除了可以使用 UserType映射枚�D�c�d��Q�也可以使用Hibernate的PersistentEnum来实现同��L(f��ng)��功能�Q�感兴趣的朋友可以参考文章http://www.hibernate.org/203.html�?br />

   �W�二个例子是关于email的。假设Account表中email是一个varchar型的字段�Q�而Account中的Email是如下的�c�：

public class Email {
    String username;

    String domain;

    public Email() {
    }

    public Email(String username, String domain) {
        this.username = username;
        this.domain = domain;
    }

    public String getUsername() {
        return username;
    }

    public String getDomain() {
        return domain;
    }


    public void setDomain(String domain) {
        this.domain = domain;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String toString() {
        return username + '@' + domain;
    }

    public static Email parse(String email) {
        Email e = new Email();
        int at = email.indexOf('@');
        if (at == -1) {
            throw new IllegalArgumentException("Invalid email address");
        }

        e.username = email.substring(0, at);
        e.domain = email.substring(at + 1);

        return e;
    }

    @Override
    public int hashCode() {
        final int PRIME = 31;
        int result = 1;
        result = PRIME * result + ((domain == null) ? 0 : domain.hashCode());
        result = PRIME * result + ((username == null) ? 0 : username.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)    return true;
      if(null == obj)return false;
        if (getClass() != obj.getClass())
            return false;
        final Email other = (Email) obj;
        if (domain == null) {
            if (other.domain != null)
                return false;
        } else if (!domain.equals(other.domain))
            return false;
        if (username == null) {
            if (other.username != null)
                return false;
        } else if (!username.equals(other.username))
            return false;
        return true;
    }
}
    email是Account�cȝ��一个属性：
public class Account extends AbstractDomain<Long>{

    private Email email;
    public Email getEmail() {
        return email;
    }
    public void setEmail(Email email) {
        this.email = email;
    }

    //省略其他
}

�q�样的情况下�Q�需要将email的username + '@' + domain映射到Account表的email列，定义一个EmailUserType如下�Q?br />

   public class EmailUserType implements UserType{

    public Object assemble(Serializable arg0, Object arg1) throws HibernateException {
        return null;
    }

    public Object deepCopy(Object o) throws HibernateException {
        if(null == o)return null;
        Email e = (Email)o;
        return new Email(e.getUsername(),e.getDomain());
    }

    public Serializable disassemble(Object arg0) throws HibernateException {
        return null;
    }

    public boolean equals(Object x, Object y) throws HibernateException {
        if(x == y)return true;
        if(x == null || y == null)return false;
        boolean  f = x.equals(y);
        return f;
    }

    public int hashCode(Object o) throws HibernateException {
        return o.hashCode();
    }

    public boolean isMutable() {
        return true;
    }

    public Object nullSafeGet(ResultSet rs, String[] names, Object o) throws HibernateException, SQLException {
        String email = rs.getString(names[0]);
        if(email == null)return null;
        int index = email.indexOf("@");
        if(index < 0)throw new RuntimeException();
        return new Email(email.substring(0,index),email.substring(index+1));
    }

    public void nullSafeSet(PreparedStatement ps, Object o, int index) throws HibernateException, SQLException {
        if(o == null )ps.setNull(index, Types.VARCHAR);
        else{
            Email e = (Email)o;
            if(e.getDomain() == null || e.getUsername() == null)ps.setNull(index, Types.VARCHAR);
            else{
                String email = e.getUsername() + "@" + e.getDomain();
                ps.setString(index, email);
            }
        }

    }

    public Object replace(Object arg0, Object arg1, Object arg2) throws HibernateException {
        return null;
    }

    public Class returnedClass() {
        return Email.class;
    }

    public int[] sqlTypes() {
        int[] typeList = {Types.VARCHAR};
        return typeList;
    }
}

最后配�|�下 email 属性：

相比于Gedner�Q�Email是一个可变类�Q�如果想��其变�ؓ不可变类�Q�只需要去掉属性的set�Ҏ(gu��)��Q�，因此EmailUserType中的equals要用到Email的equals�Q�hashCode()�Q�方法，而deepCopy(Object o) 要做到是深拷贝，否则即便Email属性内�Ҏ(gu��)��变，�׃��Hibernate�~�存中的快照指向的对象不变，在update时可能不起作用（在指定了dynamic-update属性的清况下）�?br />

Eric_jiang 2010-05-11 11:40 发表评论

国产亚洲精品成人AA片新蒲金,久久久影院亚洲精品,久久久久se色偷偷亚洲精品av

Hibernate主键生成�{�略

Equals and HashCode

hibernate 3.0 多条件查询方�?

Hibernate中Criteria的完整用�?

Hibernate 对象 三种状�?瞬时�?持久�?��q���?以及 save update saveOrUpdate merge�{�的使用

解决hibernate 删除异常�Q�deleted object would be re-saved by cascade (remove deleted object from

关于An association from the table refers to an unmapped class

Java数据�c�d���Q�Hibernate数据�c�d���Q�标准sql数据�c�d��之间的对应表

hibernate的表�l�构以及表之间的关系的 *.hbm.xml

使用Hibernate的客户化映射�c�d��

Hibernate 对象三种状�?瞬时�?持久�?��q��?以及 save update saveOrUpdate merge�{�的使用

Java数据�c�d��Q�Hibernate数据�c�d��Q�标准sql数据�c�d��之间的对应表

hibernate的表�l�构以及表之间的关系的　*.hbm.xml