亚洲avav天堂av在线网爱情,亚洲成人激情小说,亚洲亚洲人成综合网络

hibernate二��~�存

胡鹏 — Mon, 06 Apr 2009 04:02:00 GMT

hibernate 二��~�存�Q?�~�存的是实体对象�Q�二�U�缓存是攑֏�化不是很大的数据)

二��~�存也称�q�程�U�的�~�存或SessionFactory�U�的�~�存�Q�而二�U�缓存可以被所有的session(hibernate中的)�׃�n二��~�存的生命周期和SessionFactory的生命周期一��_��SessionFactory可以��理二��~�存

二��~�存的配�|�和使用�Q?/p>

1.��echcache.xml文�g拯��到src�? 二��~�存hibernate默认是开启的�Q�手动开�?/p>

2.开启二�U�缓存，修改hibernate.cfg.xml文�g,

true

3.指定�~�存产品提供�?/p>

org.hibernate.cache.EhCacheProvider

4.指定那些实体�c�M��用二�U�缓存（两种�Ҏ��Q�推荐��用第二种�Q?/p>

�W�一�U�：�?.hbm.xml中，�?lt;id>之前加入

, 使用二��~�存

�W�二�U�：在hibernate.cfg.xml配置文�g�?�?lt;mapping resource=”com/Studnet.hbm.xml” />后面加上�Q?/p>

二��~�存是缓存实体对象的

了解一�U�缓存和二��~�存的交�?/p>

��试二��~�存�Q?/strong>

一�Q�开启两�?/strong>session中发��Z��?/strong>load查询�Q?/strong>get�?/strong>load一��P��同样不会查询数据库）,

Student sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

sessioin.close();

………..

       sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

开启两个session中发��Z��ơload查询�Q�第一�ơload的时候不会去查询数据库，因�ؓ他是LAZY的，当��用的时候才��L��询数据库�Q?nbsp; �W�二�ơload的时候也不会�Q�当使用的时候查询数据库�Q�开启了二��~�存�Q�也不会查询数据库�?/p>

二．开启两�?/strong>session�Q�分别调�?/strong>load�Q�再使用sessionFactory清楚二��~�存

Student sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

sessioin.close();

………..

SessionFactory factory = HibernateUtil.getSessionFactory();

//factory.evict(Student.class); //清除所有Student对象

Factory.evict(Student.class,1); //清除指定id=1 的对�?/p>

       sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

开启两个session中发��Z��ơload查询�Q�第一�ơload的时候不会去查询数据库，因�ؓ他是LAZY的，当��用的时候才��L��询数据库�Q?nbsp; �W�二�ơload的时候也不会�Q�当使用的时候查询数据库�Q�它要查询数据库�Q�因��Z��U�缓存中被清除了

三．一�U�缓存和二��~�存的交�?/strong>

session.setCacheMode(CacheMode.GET);   //讄��?只是从二�U�缓存里�?不向二��~�存里写数据

Student sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

sessioin.close();

………..

SessionFactory factory = HibernateUtil.getSessionFactory();

//factory.evict(Student.class); //清除所有Student对象

Factory.evict(Student.class,1); //清除指定id=1 的对�?/p>

       sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

开启两个session中发��Z��ơload查询�Q�第一�ơload的时候不会去查询数据库，因�ؓ他是LAZY的，当��用的时候才��L��询数据库�Q?nbsp; �W�二�ơload的时候也不会�Q�当使用的时候查询数据库�Q�它要查询数据库�Q�因�?讄��了CacheMode为GET,(load讄��成不能往二��~�冲中写数据), 所以二�U�缓冲中没有数据

session.setCacheMode(CacheMode.PUT); //讄��成只是向二��~�存里写数据�Q�不��L��?/p>
Student sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

sessioin.close();

………..

SessionFactory factory = HibernateUtil.getSessionFactory();

//factory.evict(Student.class); //清除所有Student对象

Factory.evict(Student.class,1); //清除指定id=1 的对�?/p>

       sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

开启两个session中发��Z��ơload查询�Q�第一�ơload的时候不会去查询数据库，因�ؓ他是LAZY的，当��用的时候才��L��询数据库�Q?nbsp; �W�二�ơload的时候也不会�Q�当使用的时候查询数据库�Q�它要查询数据库�Q�因��|�了CacheMode为POST,(load讄��成只是向二��~�存里写数据�Q�不��L��?

胡鹏 2009-04-06 12:02 发表评论

胡鹏 — Mon, 06 Apr 2009 03:59:00 GMT

hibernate 一�U�缓存：(�~�存的是实体对象)

一�U�缓存很短和session的生命周期一��_��一�U�缓存也叫session�U�的�~�存或事务缓�?/p>

哪些�Ҏ��支持一�U�缓存：

*get()

*load()

*iterate() (查询实体对象)

如何��理一�U�缓存：

* session.clear() session.evict()

如何避免一�ơ性大量的实体数据入库��D��内存溢出

*先flush�Q�再clear

如果数据量特别大�Q�考虑采用jdbc实现�Q�如果jdbc也不能满��求，可以考虑采用数据库本�w�的特定导入工具

一�Q?/strong>Load��试: 在同一�?/strong>session中发��Z��?/strong>load查询

       Student sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

       sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

       在同一个session中发��Z��ơload查询�Q�第一�ơload的时候不会去查询数据库，因�ؓ他是LAZY的，当��用的时候才��L��询数据库�Q?nbsp; �W�二�ơload的时候也不会�Q�当使用的时候也不会查询数据库，因�ؓ他在�~�存里找刎ͼ�不会发出sql

Load��试: 开启两�?/strong>session中发��Z��?/strong>load查询

Student sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

sessioin.close();

………..

       sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

       开启两个session中发��Z��ơload查询�Q�第一�ơload的时候不会去查询数据库，因�ؓ他是LAZY的，当��用的时候才��L��询数据库�Q?nbsp; �W�二�ơload的时候也不会�Q�当使用的时候查询数据库�Q�因为session间不能共享一�U�缓存的数据,因�ؓ他会随session的生命周期存在和消亡

二．Get��试: 在同一�?/strong>session中发��Z��?/strong>get查询

   Student sutdent = (Student)session.get(Student.class,1);

       System.out.println(student.getName());

       sutdent = (Student)session.get(Student.class,1);

       System.out.println(student.getName());

       在同一个session中发��Z��ơget查询�Q?�W�一�ơget的时候去查询数据库，�W�二�ơget的时候不会查询数据库�Q�因��Z��在缓存里扑ֈ��Q�不会发出sql

三．iterate��试: 在同一�?/strong>session中发��Z��?/strong>iterator查询

Student student = (Student)session.createQuery(“from Student s where s.id=1”).iterate().next();

System.out.println(student.getName());

student = (Student)session.createQuery(“from Student s where s.id=1”).iterate().next();

System.out.println(student.getName());

       在同一个session中发��Z��ơiterator查询�Q�第一�ơiterate().next()的时候会发出查询id的sql�Q��用的时候会发出相应的查询实体对象，�W�二�ơiterate().next()的时候会发出查询id的sql�Q�不会发出查询实体对象的sql�Q�因为iterate使用�~�存�Q�不会发出sql

四．Iterate查询属性测�?/strong>: 同一�?/strong>session中发��Z��ơ查询属�?/strong>

String name = (String)session.createQuery(“select s.name from Student s where s.id=1”).iterate().next();

System.out.println(name);

String name = (String)session.createQuery(“select s.name from Student s where s.id=1”).iterate().next();

System.out.println(name);

       在同一个session中发��Z��ơ查询属性， �W�一�ơiterate().next()的时候会发出查询属性的sql�Q�第二次iterate().next()的时候会发出查询属性的sql�Q�iterate查询普通属性，一�U�缓存不会缓存，所以会发出sql

五．同一�?/strong>session中先save�Q�再发出load查询save�q�的数据

       Student stu = new Student();

       stu.setName(“王五”);

   Serializable id = session.save(stu);

Student sutdent = (Student)session.load(Student.class,id);

       System.out.println(student.getName());



save的时候，他会在缓存里放一�?不会发出sql�Q�因为save是��用缓存的

六．同一�?/strong>session中先调用load查询�Q�然后执�?/strong>sessio.clear()�?/strong>session.evict()�Q�再调用load查询

Student sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

       session.clear();

Student sutdent = (Student)session.load(Student.class,1);

       System.out.println(student.getName());

       sessio.clear()或session.evict()可以��理一�U�缓存，一�U�缓存无法取消，但可以管�?

上面的语句都会发出sql 因�ؓ一�U�缓存中的实体被清除�?/p>

七．向数据库中批量加�?/strong>1000条数�?/strong>

for(int i=0;i<1000;i++){

       Student student = new Student();

       student.setName(“s” + i);

       session.save(student);

//�?0条数据就强制session��数据持久化�Q�同时清除缓存，避免大量数据造成内存溢出

       if( i %20 == 0 ){

              session.flush();

              session.clear();

}

}

胡鹏 2009-04-06 11:59 发表评论

hibernate查询�~�存

胡鹏 — Mon, 06 Apr 2009 03:58:00 GMT

hibernate查询�~�存(hibernate默认是关闭的)

查询�~�存是针�Ҏ��通属性结果集的缓�?/p>
对实体对象的�l�果集只�~�存id

查询�~�存的生命周期，当前兌��的表发生修改�Q�那么查询缓存生命周期结�?/p>

查询�~�存的配�|�和使用�Q?/p>
1. 启用查询�~�存�Q�在hibernate.cfg.xml中加入：

true

2. 在程序中必须手动启用查询�~�存�Q�如�Q�query.setCacheable(true);

��试查询�~�存�Q?/strong>

一�Q?nbsp; 开启查询缓存，关闭二��~�存�Q�开启一�?/strong>session�Q�分别调�?/strong>query.list �Q�查询属性）

Query query = session.createQuery(“select s.name from Student s”);

//启用查询�~�存

query.setCacheable(true);

List names = query.list();

for(Iterator iter = names.terator();iter.hasNext();){

       String name = (String)iter.next();

       System.out.println(name);

}

System.out.println(“------------------------------------------”);

query = session.createQuery(“select s.name from Student s”);

//启用查询�~�存

query.setCacheable(true);

names = query.list();

for(Iterator iter = names.terator();iter.hasNext();){

       String name = (String)iter.next();

       System.out.println(name);

}

�W�二�ơ没有去查询数据库，因�ؓ启用了查询缓�?/p>

二．开启查询缓存，关闭二��~�存�Q�开启两�?/strong>session�Q�分别调�?/strong>query.list �Q�查询属性）

Query query = session.createQuery(“select s.name from Student s”);

//启用查询�~�存

query.setCacheable(true);

List names = query.list();

for(Iterator iter = names.terator();iter.hasNext();){

       String name = (String)iter.next();

       System.out.println(name);

}

session.close();

System.out.println(“------------------------------------------”);

………

Query query = session.createQuery(“select s.name from Student s”);

//启用查询�~�存

query.setCacheable(true);

List names = query.list();

for(Iterator iter = names.terator();iter.hasNext();){

       String name = (String)iter.next();

       System.out.println(name);

}

�W�二�ơ没有去查询数据库，因�ؓ查询�~�存生命周期与session生命周期无关

三．开启查询缓存，关闭二��~�存�Q�开启两�?/strong>session�Q�分别调�?/strong>query.iterate �Q�查询属性）

Query query = session.createQuery(“select s.name from Student s”);

//启用查询�~�存

query.setCacheable(true);

for(Iterator iter =query.iterate();iter.hasNext();){

       String name = (String)iter.next();

       System.out.println(name);

}

session.close();

System.out.println(“------------------------------------------”);

………

Query query = session.createQuery(“select s.name from Student s”);

//启用查询�~�存

query.setCacheable(true);

for(Iterator iter = query.iterate();iter.hasNext();){

       String name = (String)iter.next();

       System.out.println(name);

}

�W�二��L��询数据库�Q�因为查询缓存只对query.list()起作用，对query.iterate()不�v作用,也就是说query.iterate()不��用查询缓�?/p>

四．关闭查询�~�存�Q�关闭二�U�缓存，开启两�?/strong>session�Q�分别调�?/strong>query.list �Q�查询实体对象）

Query query = session.createQuery(“ from Student s”);

//query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

session.close();

System.out.println(“------------------------------------------”);

………

Query query = session.createQuery(“ from Student s”);

//query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

�W�二��L��询数据库�Q�因为list默认每次都会发出查询sql

五．开启查询缓存，关闭二��~�存�Q�开启两�?/strong>session�Q�分别调�?/strong>query.list �Q�查询实体对象）

Query query = session.createQuery(“ from Student s”);

query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

session.close();

System.out.println(“------------------------------------------”);

………

Query query = session.createQuery(“ from Student s”);

query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

�W�二��L��询数据库�Ӟ��会发出N条sql语句�Q�因为开启了查询�~�存�Q�关闭了二��~�存�Q�那么查询缓存会�~�存实体对象的id�Q�所以hibernate会根据实体对象的id��L��询相应的实体�Q�如果缓存中不存在相应的实体�Q�那么将发出�Ҏ��实体id查询的sql语句�Q�否则不会发出sql�Q��用缓存中的数�?/p>

六．开启查询缓存，开启二�U�缓存，开启两�?/strong>session�Q�分别调�?/strong>query.list �Q�查询实体对象）

Query query = session.createQuery(“ from Student s”);

query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

session.close();

System.out.println(“------------------------------------------”);

………

Query query = session.createQuery(“ from Student s”);

query.setCacheable(true);

List students = query.list();

for(Iterator iter = students.iterate();iter.hasNext();){

       Student stu = (Student)iter.next();

       System.out.println(stu.getName());

}

�W�二不会发出sql�Q�因为开启了二��~�存和查询缓存，查询�~�存�~�存了实体对象的id列表�Q�hibernate会根据实体对象的id列表��C��U�缓存中取得相应的数�?/p>

胡鹏 2009-04-06 11:58 发表评论

胡鹏 — Mon, 06 Apr 2009 03:57:00 GMT

�?/strong>hibernate中设�|�：

查询数据库每�ơ最多返�?/strong>50条结果：

50

30条更新数据库一��?/strong>:

30

但不是所有的数据库都支持的，sqlServer �?/strong>orcale 都支持的�?/strong>

一�Q?/strong>hibernate 抓取�{�略(Fetch) 单端代理扚w��抓取

1.fetch=”select” 兌��实体

//fetch 默认是select

Student student = (Student)session.load(Student.class,1);

System.out.println(student.getName());

System.out.println(student.getClasses().getName()); //多对一中的属性班�U�，获取班��名称

Fetch=”select” ,上面�E�序会发2条sql语句�Q�第二条发送一条select语句抓取当前对象兌��实体或集�?(�q�里指是班��名称)

2.fetch=” join” 兌��实体

//fetch 讄��?join

fetch=" join ">

Student student = (Student)session.load(Student.class,1);

System.out.println(student.getName());

System.out.println(student.getClasses().getName()); //多对一中的属性班�U�，获取班��名称

fetch=” join” , 上面�E�序会发1条sql语句�Q?hibernate会通过select使用外链接来加蝲其关联实体或集合�Q�此时lazy会失�?nbsp;

二．hibernate 抓取�{�略(Fetch) 集合代理扚w��抓取

1.     fetch=”select”

//fetch 默认是select





Classes cla = (Classes)session.load(Classes.class,1);

System.out.println(cla.getName());

for(Iterator iter = cla.getStudents().iterator();iter.hasNext();){

       Student student = (Student)iter.next();

       System.out.println(student.getName());

}

fetch=”select” ,上面�E�序用到了就发sql语句,�W�二从��@环中发了N�?如果�Q�fetch=”subselect”,则只是发送一条语句，见下�?/p>

2 fetch=”join”

//fetch 讄��成join





Classes cla = (Classes)session.load(Classes.class,1);

System.out.println(cla.getName());

for(Iterator iter = cla.getStudents().iterator();iter.hasNext();){

       Student student = (Student)iter.next();

       System.out.println(student.getName());

}

Fetch=”select” ,上面�E�序只发了一条sql语句

三．hibernate 抓取�{�略(Fetch) 集合代理扚w��抓取

2.     fetch=”subselect”

//fetch讄��成subselect





List classesList = session.createQuery(“select c from Classes c where c.id in(1,2,3)”);

for(Iterator iter=classesList.iterator();iter.hasNext();){

       Classess classess = (Classess)iter.next();

       System.out.println(“classes.name=”+ classes.getName());

       for(Iterator iter1 = classess.getStudents().iterator();iter1.hasNext();){

              Student student = (Student)iter1.next();

              System.out.println(student.getName());

}

}

Fetch=”subselct” ,另外发送一条select语句抓取在前面查询到的所有实体对象的兌��集合

四．hibernate 扚w��{�略batch-size属性，可以扚w��加蝲实体�c�，

参见Classes.hbm.xml�Q�同旉��合也可以是��用，如：

在配�|�文件hbm.xml 讄��中：

List students = session.createQuery(“select s from Student s where s.id in(:ids)”).setParameterList(“:ids”,new Object[]{1,11,21,31,41,51,61,71,81,91}).list();

for(Iterator iter=students.iterator();iter.hasNext();){

       Student student = (Sutdent)iter.next();

       System.out.println(student.getName());

       System.out.println(student.getClassess().getName());

}

当第二个for循环�Ӟ��每次加蝲之前讄��?数量实体对象, 如：现在讄��3�Q�那么当Iterator iter=students.iterator();iter.hasNext();时候，他会查询�?个student对象

胡鹏 2009-04-06 11:57 发表评论

hibernate悲观�?与乐观锁

胡鹏 — Mon, 06 Apr 2009 03:57:00 GMT

悲观�?/strong>



       悲观锁的实现�Q�通常依赖于数据库机制�Q�在整个�q�程中将数据锁定�Q�其它�Q何用户都不能��d��或修攏V�?/p>

举个例子�Q?/p>
//查询id=1的那条记录，使用悲观�?/p>
User user = (User)session.load(User.class, 1 , LockMode.UPGRADE);

使用了数据库中的 for update 锁定

乐观�?/strong>

大多数基于数据版本记录机�Ӟ��version�Q�实玎ͼ�一半是在数据库表加入一个version字段�Q�读取数据时��版本号一同读出，之后更新数据时版本号加一�Q�如果提交数据时版本号小于或�{�于数据库表中的版本��P��则认为数据是�q�期的，否则�l�予更新�?/p>

其实�q��是锁�Q�是一�U�冲�H�检��?nbsp; (没有hibernate也可以��用的�Q�自��p��在数据库中徏字段来控�Ӟ��使用hibernate方便些，��装好了)

�?.hm.xml�?��d��U�色部分�Q?/p>


name="com.tao3c.orm.TbBusinessInfo" table="tb_business_info" optimistic-lock=”version”>

其中version是com.tao3c.orm.TbBusinessInfo�cȝ��属性，hiernbate会去�l�护的，不用自己去该

胡鹏 2009-04-06 11:57 发表评论

hibernate悲观�?与乐观锁

胡鹏 — Mon, 06 Apr 2009 03:57:00 GMT

悲观�?/strong>



       悲观锁的实现�Q�通常依赖于数据库机制�Q�在整个�q�程中将数据锁定�Q�其它�Q何用户都不能��d��或修攏V�?/p>

举个例子�Q?/p>
//查询id=1的那条记录，使用悲观�?/p>
User user = (User)session.load(User.class, 1 , LockMode.UPGRADE);

使用了数据库中的 for update 锁定

乐观�?/strong>

大多数基于数据版本记录机�Ӟ��version�Q�实玎ͼ�一半是在数据库表加入一个version字段�Q�读取数据时��版本号一同读出，之后更新数据时版本号加一�Q�如果提交数据时版本号小于或�{�于数据库表中的版本��P��则认为数据是�q�期的，否则�l�予更新�?/p>

其实�q��是锁�Q�是一�U�冲�H�检��?nbsp; (没有hibernate也可以��用的�Q�自��p��在数据库中徏字段来控�Ӟ��使用hibernate方便些，��装好了)

�?.hm.xml�?��d��U�色部分�Q?/p>


name="com.tao3c.orm.TbBusinessInfo" table="tb_business_info" optimistic-lock=”version”>

其中version是com.tao3c.orm.TbBusinessInfo�cȝ��属性，hiernbate会去�l�护的，不用自己去该

胡鹏 2009-04-06 11:57 发表评论

hibernate多对多映��_处理

胡鹏 — Mon, 06 Apr 2009 03:56:00 GMT

一�Q?/strong>hibernate多对多映��（单项�Q�，自动产生�W�三张表

User--à Role

user(id,name)    role(id,name)

User�c�：

private int id;   private String name; private Set roles;

Role�c�：

private int id;    private String name;

User.hbm.xml中：





�q�样�Q�hibernate会自动��生中间表t_user_role(userid,roleid) �q�且是复合主键，userid为t_user的外键，roleid为t_role的外�?/p>

二．hibernate多对多的存储

Role r1 = new Role();

r1.setName(“数据录入人员”);

Role r2 = new Role();

r2.setName(“商务�ȝ��”);

Role r3 = new Role();

r3.setName(“大区�l�理”);

User u1 = new User();

u1.setName(“10”);

Set u1Roles = new HashSet();

u1Roles.add(r1);

u1Roles.add(r2);

u1.setRoles(u1Roles);

User u2 = new User();

u1.setName(“��儿”);

Set u2Roles = new HashSet();

u2Roles.add(r2);

u2Roles.add(r3);

u2.setRoles(u2Roles);

User u3 = new User();

u3.setName(“��C�u”);

Set u3Roles = new HashSet();

u3Roles.add(r1);

u3Roles.add(r2);

u3Roles.add(r3);

u3.setRoles(u3Roles);

session.save(r1);

session.save(r2);

session.save(r3);

session.save(u1);

session.save(u2);

session.save(u3);

�l�束之后�Q�在�W�三张表中也有数�?/p>

三．hibernate多对多的加蝲

User user = (User)session.load(User.class,1);

System.out.println(user.getName());

for(Iterator iter = user.getRoles().iterator();iter.hasNext();){

       Role role = (Role)iter.next();

       System.out.println(role.getName());

}

每次加蝲都会发出sql语句

三．hibernate多对多的 双向映射

User ß--.-àRole

user(id,name)    role(id,name)

User�c�：

private int id;   private String name; private Set roles;

Role�c�：

private int id;    private String name; private Set users;

User.hbm.xml中：





Role.hbm.xml中：

   //�q�里可以讄��order-by=”userid”,�Ҏ��userid排序





注意�Q�上面中间表名字是一��L��

�q�样�Q�hibernate也会自动产生中间表t_user_role(userid,roleid) �q�且是复合主键，userid为t_user的外键，roleid为t_role的外�?/p>

胡鹏 2009-04-06 11:56 发表评论

hibernate多对多映��_处理

胡鹏 — Mon, 06 Apr 2009 03:56:00 GMT

一�Q?/strong>hibernate多对多映��（单项�Q�，自动产生�W�三张表

User--à Role

user(id,name)    role(id,name)

User�c�：

private int id;   private String name; private Set roles;

Role�c�：

private int id;    private String name;

User.hbm.xml中：





�q�样�Q�hibernate会自动��生中间表t_user_role(userid,roleid) �q�且是复合主键，userid为t_user的外键，roleid为t_role的外�?/p>

二．hibernate多对多的存储

Role r1 = new Role();

r1.setName(“数据录入人员”);

Role r2 = new Role();

r2.setName(“商务�ȝ��”);

Role r3 = new Role();

r3.setName(“大区�l�理”);

User u1 = new User();

u1.setName(“10”);

Set u1Roles = new HashSet();

u1Roles.add(r1);

u1Roles.add(r2);

u1.setRoles(u1Roles);

User u2 = new User();

u1.setName(“��儿”);

Set u2Roles = new HashSet();

u2Roles.add(r2);

u2Roles.add(r3);

u2.setRoles(u2Roles);

User u3 = new User();

u3.setName(“��C�u”);

Set u3Roles = new HashSet();

u3Roles.add(r1);

u3Roles.add(r2);

u3Roles.add(r3);

u3.setRoles(u3Roles);

session.save(r1);

session.save(r2);

session.save(r3);

session.save(u1);

session.save(u2);

session.save(u3);

�l�束之后�Q�在�W�三张表中也有数�?/p>

三．hibernate多对多的加蝲

User user = (User)session.load(User.class,1);

System.out.println(user.getName());

for(Iterator iter = user.getRoles().iterator();iter.hasNext();){

       Role role = (Role)iter.next();

       System.out.println(role.getName());

}

每次加蝲都会发出sql语句

三．hibernate多对多的 双向映射

User ß--.-àRole

user(id,name)    role(id,name)

User�c�：

private int id;   private String name; private Set roles;

Role�c�：

private int id;    private String name; private Set users;

User.hbm.xml中：





Role.hbm.xml中：

   //�q�里可以讄��order-by=”userid”,�Ҏ��userid排序





注意�Q�上面中间表名字是一��L��

�q�样�Q�hibernate也会自动产生中间表t_user_role(userid,roleid) �q�且是复合主键，userid为t_user的外键，roleid为t_role的外�?/p>

胡鹏 2009-04-06 11:56 发表评论

hibernate配置要点详谈

胡鹏 — Mon, 06 Apr 2009 03:53:00 GMT


1.两种配置文�g�Q?/p>
A.hibernate.cfg.xml和B.hibernate.properties

A中可含映��文件的配置�Q�而B中hard codes加映��文件�?/p>

A.Configuration config=new Configuration().config();

B. Configuration config=new Configuration();

config.addClass(TUser.class);

2.你不必一定用hibernate.cfg.xml或hibernate.properties�q�两文�g名，你也不一定非得把配置文�g攑֜�Classes下，　File file=new File("c:\\sample\\myhibernate.xml");　Configuration config=new Configuration().config(file);

3. session.Flush() 强制数据库立卛_��步，当用事务�Ӟ��不必用flush,事务提交自动调用flush在session关闭时也会调用flush

4. Hibernate��L��使用对象�c�d��作�ؓ字段�c�d��

5. XDoclet专门建立了hibernate doclet,��是在java代码上加上一些java docTag�Q�后来再让XDoclet分析该java代码�Q�生成映��文�?

6.HQL子句本��n大小写无养I��但是其中出现的类名和属性名必须注意大小写区分�?/p>

7.关系�Q�　Constrained : �U�束�Q�表明主控表的主键上是否存在一个外键（foreigh key�Q�对其进行约束�?/p>

property-ref:兌��c�M��用于与主控类相关联的属性名�Q�默认�ؓ兌��cȝ��主键属性名

单向一对多需在一斚w��|�，双向一对多需在双方进行配�|?/p>

8.lazy=false:被动方的记录由hibernate负责记取�Q�之后存攑֜��L��Ҏ��定的Collection�c�d��属性中

9. java.util.Set或net.sof.hibernate.collecton.Bag�c�d��的Collection

10.重要�Q�inverse:用于标识双向兌��中的被动方一端�?/p>

inverse=false的一方（��L��方）负责�l�护兌��关系.默认��|��false

11.batch-size:采用延迟加蝲特征�Ӟ��一�ơ读入的数据数昨�?/p>

12.一对多通过��L��Ҏ��斎ͼ��L��方�ؓ一�Ҏ��Q?/p>

user.getAddresses().add(addr);

session.save(user);//通过��L��对象�U�联更新

13.在one-to-many 关系中，��many 一方设��Z��动方�Q�inverse=false�Q�将有助性能的改善。在一方设�|�关�p�L��Q�inverse=true,卛_��L��权交�l�多方，　�q�样多方可主动从一方获得foreign key,然后一�ơinsert卛_��完工�?/p>

addr.setUser(user);//讄��兌��的TUser对象

user.getAddresses().add(addr);

session.save(user);//�U�联更新

14.只有设�ؓ��L��方的一�Ҏ��兛_��Q�访问）�Ҏ��的属性，被动�Ҏ��不关心对方的属性的�?/p>

15.one-to-many与many-to-one节点的配�|�属性不同：

一对多关系多了lazy和inverse两个属性多对多节点属性：

column:中间映射表中�Q�关联目标表的关联字�D?/p>

class:�c�d��Q�关联目标类

outer-join:是否使用外联�?/p>

注意:access是设�|�属性值的��d��方式�?/p>

column是设�|�关联字�D�c�?/p>

16.多对多，注意两方都要讄��inverse和lazy,cascade只能设�ؓinsert-update

多对多关�p�M��Q�由于关联关�p�L��两张表相互引用，因此在保存关�pȝ��态时必须对双方同时保存�?/p>

group1.getRoles().add(role1);　role1.getGroups().add(group1);

session.save(role1);　session.save(group1);

17.关于vo和po　vo�l�过hibernate定w��处理�Q�就变成了po(该vo的引用将被容器保存，�q�且在session关闭时flush,因此po如果再传到其它地�Ҏ��变了�Q�就危险�?　vo和po�怺�转换�Q�BeanUtils.copyProperties(anotherUser,user);

18.对于save操作而言�Q�如果对象已�l�与Session相关联（卛_��l�被加入Session的实体容器中�Q�，则无需�q�行具体的操作。因��Z��后的Session.flush�q�程中，Hibernate 会对此实体容器中的对象进行遍历，查找出发生变化的实体�Q�生成�ƈ执行相应的update 语句�?/p>

19.如果我们采用了�g�q�加载机�Ӟ��但希望在一些情况下�Q�实现非延迟加蝲时的功能�Q�也��是��_��我们希望在Session关闭后，依然允许操作user的addresses 属�?Hibernate.initialize�Ҏ��可以通过强制加蝲兌��对象实现�q�一功能�Q?�q�也正是我们��Z��么在�~�写POJO�Ӟ��必须用JDK Collection接口�Q�如Set,Map�Q? 而非特定的JDK Collection实现�c�（如HashSet、HashMap�Q�申明Collection属性的原因�?/p>

20.事务�Q�从sessionFactory获得session,其自动提交属性就已经关闭(AutoCommit=false),此时若执行了jdbc操作�Q�如果不昑ּ�调用session.BeginTransaction(),是不会执行事务操作的�?/p>

jdbc transaction:��Z��同一个session(��是同一个connection)的事�?

jta　transaction:跨session�Q�跨connection�Q�事�?

对于jta事务�Q�有三种实现�Ҏ��Q?/p>

A。UserTransaction tx=new InitialContext().lookup("...");

tx.commit();

B. 使用hibernate��装的方法：(不推�?

Transaction tx=session.beginTransaction();

tx.commit();

C. 使用ejb之sessionBean的事务技持方法，你只要在把需要在发布描述�W�中�Q�把需要jta事务的方法声明�ؓrequire卛_��

21.悲观锁，乐观锁：　乐观锁一般通过version来实玎ͼ�注意version节点必须出现在id后�?/p>

22.Hibernate中，可以通过Criteria.setFirstResult和Criteria.setFetchSize�Ҏ��讑֮�分页范围�?/p>

Query接口中也提供了与其一致的�Ҏ��Q�hibernate主要在dialect�c�M��实现在这个功能�?/p>

23.cache

……

net.sf.ehcache.hibernate.Provider　

�q�需对ecache本��n�q�配�|?/p>

之后在映��文件中指定各个映射实体的cache�{�略

....

....

***************************************************** Query.list()跟Query.iterate()的不同：对于query.list()��L��通过一条sql语句获取所有记�?然后��其��d��Q�填入pojo�q�回; 但是query.iterate()�Q�则是首先通过一条Select SQL 获取所有符合查询条件的记录�?id�Q�再对这个id 集合�q�行循环操作�Q�通过单独的Select SQL 取出每个id 所对应的记录，之后填入POJO中返回�?/p>

也就是说�Q�对于list 操作�Q�需要一条SQL 完成。而对于iterate 操作�Q�需要n+1 条SQL。，list�Ҏ��不会从Cache中读取数据。iterator却会�?/p>

24.ThreadLocal:它会为每个线�E�维护一个私有的变量�I�间。实际上�Q?其实现原理是在JVM 中维护一个Map�Q�这个Map的key ��是当前的线�E�对象，而value则是�U�程通过ThreadLocal.set�Ҏ��保存的对象实例。当�U�程调用ThreadLocal.get�Ҏ��Ӟ�� ThreadLocal会根据当前线�E�对象的引用�Q�取出Map中对应的对象�q�回�?/p>

�q�样�Q�ThreadLocal通过以各个线�E�对象的引用作�ؓ区分�Q�从而将不同�U�程的变量隔��d��来�?/p>

25.Hibernate官方开发手册标准示�?

public class HibernateUtil { private static SessionFactory sessionFactory;

static { try { // Create the SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

} catch (HibernateException ex) { throw new RuntimeException( "Configuration problem: " + ex.getMessage(), ex );

} } public static final ThreadLocal session = new ThreadLocal();

public static Session currentSession() throws HibernateException { Session s = (Session) session.get();

// Open a new Session, if this Thread has none yet if (s == null) { s = sessionFactory.openSession();

session.set(s);

} return s;

} public static void closeSession() throws HibernateException { Session s = (Session) session.get();

session.set(null);

if (s != null) s.close();

} }

26.通过filter实现session的重用：

public class PersistenceFilter implements Filter { protected static ThreadLocal hibernateHolder = new ThreadLocal();

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { hibernateHolder.set(getSession());

try { …… chain.doFilter(request, response);

…… } finally { Session sess = (Session)hibernateHolder.get();

if (sess != null) { hibernateHolder.set(null);

try { sess.close(); } catch (HibernateException ex) { throw new ServletException(ex);

} } } } ……}

胡鹏 2009-04-06 11:53 发表评论

亚洲avav天堂av在线网爱情,亚洲成人激情小说,亚洲亚洲人成综合网络

hibernate二��~�存

hibernate查询�~�存

hibernate悲观�?与乐观锁

hibernate悲观�?与乐观锁

hibernate多对多映���_处理

hibernate多对多映���_处理

hibernate配置要点详谈

hibernate多对多映��_处理

hibernate多对多映��_处理