亚洲色中文字幕在线播放,亚洲国产精品无码久久98,国产午夜亚洲精品不卡免下载

Open Session In View

semovy — Sun, 09 Sep 2007 10:15:00 GMT

在没有��?/font>Spring提供�?/span>Open Session In View情况下，因需要在service(or Dao)层里�?/span>session关闭�Q�所�?/span>lazy loading �?/span>true的话�Q�要在应用层内把关系集合都初始化�Q�如 company.getEmployees()�Q�否�?/span>Hibernate�?/span>session already closed Exception; Open Session In View提供了一�U�简便的�Ҏ��Q�较好地解决�?/span>lazy loading问题.

它有两种配置方式OpenSessionInViewInterceptor�?span style="font-size: 10pt; color: #4b4b4b; font-family: Verdana">OpenSessionInViewFilter(具体参看SpringSide)�Q�功能相同，只是一个在web.xml配置�Q�另一个在application.xml配置而已�?/span>

Open Session In View�?/span>request�?/span>session�l�定到当�?/span>thread期间一直保�?/span>hibernate session�?/span>open状态，�?/span>session�?/span>request的整个期间都可以使用�Q�如�?/span>View层里PO也可�?/span>lazy loading数据�Q�如 ${ company.employees }。当View 层逻辑完成后，才会通过Filter�?/span>doFilter�Ҏ��?/span>Interceptor�?/span>postHandle�Ҏ��自动关闭session�?/span>

OpenSessionInViewInterceptor配置

<beans>
   <bean name="openSessionInViewInterceptor" class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
         <property name="sessionFactory">
         <ref bean="sessionFactory"/>
    property>
   bean>
   <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
       <property name="interceptors">
         <list>
            <ref bean="openSessionInViewInterceptor"/>
       list>
     property>
     <property name="mappings">
     ...
    property>
   bean> ...
beans>

OpenSessionInViewFilter配置

<web-app>
...
  <filter>
     <filter-name>hibernateFilterfilter-name>
     <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter filter-class>

    <init-param>
       <param-name>singleSessionparam-name>
       <param-value>trueparam-value>
    init-param>
  filter>
...
  <filter-mapping>
     <filter-name>hibernateFilterfilter-name>
     <url-pattern>*.dourl-pattern>
   filter-mapping>
...
web-app>

很多人在使用OpenSessionInView�q�程中提及一个错误：

org.springframework.dao.InvalidDataAccessApiUsageException: Write operations are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into FlushMode.AUTO or remove 'readOnly' marker from transaction definition

看看OpenSessionInViewFilter里的opensession�Ҏ��

protected Session openSession(SessionFactory sessionFactory) throws DataAccessResourceFailureException {
    Session session = SessionFactoryUtils.getSession(sessionFactory, true);
    session.setFlushMode(FlushMode.NEVER);
    return session;
}

可以看到OpenSessionInViewFilter在getSession的时�?会把获取回来的session的flush mode 设�ؓFlushMode.NEVER。然后把该sessionFactory�l�定到TransactionSynchronizationManager�Q��request的整个过�E�都使用同一个session�Q�在��h��q�后再接除该sessionFactory的绑定，最�?span class="me1">closeSessionIfNecessary�Ҏ��该session是否已和transaction�l�定来决定是否关闭session。在�q�个�q�程中，若HibernateTemplate 发现自当前session有不是readOnly的transaction�Q�就会获取到FlushMode.AUTO Session�Q��Ҏ��拥有写权限�?/p>

也即是，如果有不是readOnly的transaction��可以由Flush.NEVER转�ؓFlush.AUTO,拥有insert,update,delete操作权限�Q�如果没有transaction�Q��ƈ且没有另外�h为地设flush model的话�Q�则doFilter的整个过�E�都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有�?/p>

采用spring的事务声�?使方法受transaction控制

    <bean id="baseTransaction" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"       abstract="true">
         <property name="transactionManager" ref="transactionManager"/>
         <property name="proxyTargetClass" value="true"/>
         <property name="transactionAttributes">
             <props>
                 <prop key="get*">PROPAGATION_REQUIRED,readOnlyprop>
                 <prop key="find*">PROPAGATION_REQUIRED,readOnlyprop>
                 <prop key="load*">PROPAGATION_REQUIRED,readOnlyprop>
                 <prop key="save*">PROPAGATION_REQUIREDprop>
                 <prop key="add*">PROPAGATION_REQUIREDprop>
                 <prop key="update*">PROPAGATION_REQUIREDprop>
                 <prop key="remove*">PROPAGATION_REQUIREDprop>
             props>
         property>
     bean>

     <bean id="userService" parent="baseTransaction">
         <property name="target">
             <bean class="com.phopesoft.security.service.impl.UserServiceImpl"/>
         property>
    bean>

对于上例�Q�则以save,add,update,remove开头的�Ҏ��拥有可写的事务，如果当前有某个方法，如命名�ؓimportExcel()�Q�则因没有transaction而没有写权限�Q�这时若�Ҏ��内有insert,update,delete操作的话�Q�则需要手动设�|�flush model为Flush.AUTO,�?/p>

session.setFlushMode(FlushMode.AUTO);
session.save(user);
session.flush();

��管Open Session In View看�v来还不错�Q�其实副作用不少。看回上面OpenSessionInViewFilter的doFilterInternal�Ҏ��代码�Q�这个方法实际上是被父类的doFilter调用的，因此�Q�我们可以大�U�了解的OpenSessionInViewFilter调用��程: request(��h��)->open session�q�开始transaction->controller->View(Jsp)->�l�束transaction�q�close session.

一切看��h��很正��，��其是在本地开发测试的时候没出现问题�Q�但试想下如果流�E�中的某一步被��d��的话�Q�那在这期间connection��׃��直被占用而不释放。最有可能被��d��的就是在写Jsp�q�步�Q�一斚w��可能是页面内容大�Q�response.write的时间长�Q�另一斚w��可能是网速慢�Q�服务器与用户间传输旉��久。当大量�q�样的情况出现时�Q�就有连接池�q�接不��Q�造成��面假死现象�?/p>

Open Session In View是个双刃剑，攑֜�公网上内容多��量大的�|�站��h��用�?/p>

hibernate open session in view 抛出异常解决�Ҏ��

在��用open-session-in-view的时候，如果使用不当�Q�有可能抛出两种异常
1�Q�NonUniqueObjectException
2�Q�在配合spring使用的时候会可能会抛出org.springframework.dao.InvalidDataAccessApiUsageException

先说1�Q�这个异常的抛出原因和解军_��法见�q�里�Q?br /> javaeye上有了很好的事例:http://www.javaeye.com/topic/11581
解决办法可以用merge�Q�也可以别的办法�?br /> 出现的原因，可以参考一下我前边的文章中��merge和update的区别的内容�?br /> http://m.tkk7.com/dreamstone/archive/2007/07/29/133071.html

2的解军_��法：在这�?br /> springside的一��文章做了详�l�说�?br /> http://calvin.blog.javascud.org/post/46.htm

好了�Q�现在问题解决了�Q�但关于open-session-in-view的��用还有一些探讨，是否应该使用�Q��用的好处与坏处�?br /> 见这两篇jdon上的文章:
http://www.jdon.com/jivejdon/thread/22374.html
http://www.jdon.com/jivejdon/thread/28955.html

semovy 2007-09-09 18:15 发表评论

Spring �?Hibernate 的�g�q�加载和 Dao 模式

semovy — Sat, 08 Sep 2007 14:49:00 GMT

摘要: Hibernate 与�g�q�加载： Hibernate 对象关系映射提供延迟的与非�g�q�的对象初始化。非延迟加蝲在读取一个对象的时候会��与�q�个对象所有相关的其他对象一赯��取出来。这有时会导致成癄��Q�如果不是成千的话） select 语句在读取对象的时候执行。这个问题有时出现在使用双向关系的时候，�l�常会导致整个数据库都在初始化的阶段被读出来了。当�Ӟ��你可以不厌其烦地��查每一个对象与其他对象的关�p?.. 阅读全文

semovy 2007-09-08 22:49 发表评论

hibernate延迟加蝲

semovy — Fri, 07 Sep 2007 07:05:00 GMT

延迟加蝲的对象：
hibernate 2针对实体对象和集�?br /> hibernate 3同时提供了属性的延迟加蝲功能�?br /> 其中寚w��合的延迟加蝲�Ҏ��意义最为重大�?/p>

实体对象的�g�q�加�?
1.在hibernate配置文�g中的class指定

集合�c�d��的�g�q�加载：
在set中指定lazy=true
�q�样只有实际加蝲与对象相兌��的集合对象的时候，再通过session从数据库中加载实际的数据集�?br /> Hibernate.initialize�Ҏ��可以强制Hibernate立即加蝲兌��的对象集�Q�例如：
Hibernate.initialize(user.getAddress());
集合�c�d��的缓存：
如果为某个集合类讑֮�了缓存，�?br />      name="address"
     table="t_address"
     lazy="true"
     ......
>




Hibernate寚w��合类型进行缓存的时候，分两部分保存。首先是�q�个集合中所有实体的id列表�Q�其�ơ才是各个实体对象�?br /> �q�里制定了cache usage="read-only"只会使得Hibernate�Ҏ��据烦引进行缓存。也��是说只�~�存了集合中的数据烦引，�q�不包含集合中的各个实体元素�?br /> 如果指定cache usage="read-write"才会寚w��合中的实体进行缓存�?/p>

属性的延迟加蝲�Q?br /> 在property节点中声明lazy=true,而且�q�需要借助Hibernate�c�d��强器对POJO�cȝ��二进制Class文�g�q�行强化处理�?/p>

hibernate中的Collection
Hibernate对JDK Collention接口的独立实玎ͼ�
�׃��传统的Java Set, Map, List实现不能满��要求�Q�Hibernate�Ҏ��q�些接口提供了自��q��实现�?br /> Hibernate的实玎ͼ�
无序集：Set, Bag, Map
有序集：List
Bag相当于一个允讔R��复元素存在的Set�?br /> 因�ؓHibernate是自��q��Collection实现�Q�所以如下语句会出错�Q?br /> Set hset = (HashSet)user.getAddresses();
会在�q�行期报告一个java.lang.ClassCastException,因�ؓ实际上返回的是一个类型�ؓorg.hibernate.collention.Set的对象�?br /> 所有我们在写POJO�Ӟ��必须用JDK Collection Interface(如Set, Map)�Q�而非特定的JDK Collection实现�c?如HashSet, HashMap)声明Collection型属性的原因。例如：
应该是private Set addresses;
而不是private HashSet addresses;

collection�c�d��属性的保存�q�程�?br /> 例如
public class TUser implements Serializable {
private Set addresses = new HashSet();
......
}

然后创徏一个TUser实例后，��可以�ؓ其添加关联的address对象�Q?br /> TUser user = new TUser();
TAddress addr = new TAddress();
addr.setAddress("HongKong");
user.getAddress().add(addr);
session.save(user);
user对象在经�q�Hibernate处理后发生了变化�Q�首先，�׃��insert操作�Q��生了id��|��q�填充到user对象的id属性，另一斚w��Hibernate使用了自��q��collection实现对user中的HashSet型addresses属性进行了替换�Q��ƈ用数据对其进行了填充�?/p>

semovy 2007-09-07 15:05 发表评论

Hibernate延迟加蝲机制[转]

semovy — Thu, 16 Aug 2007 08:36:00 GMT

Hibernate延迟加蝲机制

2007�q?7�?6�?星期�?下午 04:00

延迟加蝲�Q?/span>

延迟加蝲机制是�ؓ了避免一些无谓的性能开销而提出来的，所谓�g�q�加载就是当在真正需要数据的时候，才真正执行数据加载操作。在Hibernate中提供了对实体对象的延迟加蝲以及寚w��合的延迟加蝲�Q�另外在Hibernate3中还提供了对属性的延迟加蝲。下面我们就分别介绍�q�些�U�类的�g�q�加载的�l�节�?/span>

A�?/span>实体对象的�g�q�加载：

如果惛_��实体对象使用延迟加蝲�Q�必��要在实体的映射配置文�g中进行相应的配置�Q�如下所�C�：

lazy=”true”>

……

通过��?/span>class�?/span>lazy属性设�|��ؓtrue�Q�来开启实体的延迟加蝲�Ҏ��。如果我们运行下面的代码�Q?/span>

User user=(User)session.load(User.class,”1”);�Q?/span>1�Q?/span>

System.out.println(user.getName());�Q?/span>2�Q?/span>

当运行到(1)处时�Q?/span>Hibernate�q�没有发起对数据的查询，如果我们此时通过一些调试工�?/span>(比如JBuilder2005�?/span>Debug工具)�Q�观察此�?/span>user对象的内存快照，我们会惊奇的发现�Q�此时返回的可能�?/span>User$EnhancerByCGLIB$$bede8986�c�d��的对象，而且其属性�ؓnull,�q�是怎么回事�Q�还记得前面我曾讲过session.load()�Ҏ��Q�会�q�回实体对象的代理类对象�Q�这里所�q�回的对象类型就�?/span>User对象的代理类对象。在Hibernate中通过使用CGLIB,来实现动态构造一个目标对象的代理�c�d��象，�q�且在代理类对象中包含目标对象的所有属性和�Ҏ��Q�而且所有属性均被赋��gؓnull。通过调试器显�C�的内存快照�Q�我们可以看出此时真正的User对象�Q�是包含在代理对象的CGLIB$CALBACK_0.target属性中�Q�当代码�q�行刎ͼ�2�Q�处�Ӟ��此时调用user.getName()�Ҏ��Q�这旉��过CGLIB赋予的回调机�Ӟ��实际上调�?/span>CGLIB$CALBACK_0.getName()�Ҏ��Q�当调用该方法时�Q?/span>Hibernate会首先检�?/span>CGLIB$CALBACK_0.target属性是否�ؓnull�Q�如果不为空�Q�则调用目标对象�?/span>getName�Ҏ��Q�如果�ؓ�I�，则会发�v数据库查询，生成�c�M��q�样�?/span>SQL语句�Q?/span>select * from user where id=’1’;来查询数据，�q�构造目标对象，�q�且��它赋值到CGLIB$CALBACK_0.target属性中�?/span>

�q�样�Q�通过一个中间代理对象，Hibernate实现了实体的延迟加蝲�Q�只有当用户真正发�v获得实体对象属性的动作�Ӟ��才真正会发�v数据库查询操作。所以实体的延迟加蝲是用通过中间代理�c�d��成的�Q�所以只�?/span>session.load()�Ҏ��才会利用实体延迟加蝲�Q�因为只�?/span>session.load()�Ҏ��才会�q�回实体�cȝ��代理�c�d��象�?/span>

B�?span style="FONT: 7pt Times New Roman"> 集合�c�d��的�g�q�加载：

�?/span>Hibernate的�g�q�加载机制中�Q�针寚w��合类型的应用�Q�意义是最为重大的�Q�因��有可能��性能得到大幅度的提高�Q��ؓ�?/span>Hibernate�q�行了大量的努力�Q�其中包括对JDK Collection的独立实玎ͼ�我们在一对多兌��中，定义的用来容�U�_��联对象的Set集合�Q��ƈ不是java.util.Set�c�d��或其子类型，而是net.sf.hibernate.collection.Set�c�d��Q�通过使用自定义集合类的实玎ͼ�Hibernate实现了集合类型的延迟加蝲。�ؓ了对集合�c�d��使用延迟加蝲�Q�我们必��d��下配�|�我们的实体�cȝ��关于兌��的部分：

…..

lazy=”true” inverse=”true”>

通过��?/span>元素�?/span>lazy属性设�|��ؓtrue来开启集合类型的延迟加蝲�Ҏ��。我们看下面的代码：

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

Collection addset=user.getAddresses(); (1)

Iterator it=addset.iterator(); (2)

while(it.hasNext()){

Address address=(Address)it.next();

System.out.println(address.getAddress());

}

当程序执行到(1)处时�Q�这时�ƈ不会发�v对关联数据的查询来加载关联数据，只有�q�行�?/span>(2)处时�Q�真正的数据��d��操作才会开始，�q�时Hibernate会根据缓存中�W�合条�g的数据烦引，来查扄��合条件的实体对象�?/span>

�q�里我们引入了一个全新的概念——数据烦引，下面我们首先��接一下什么是数据索引。在Hibernate中对集合�c�d��q�行�~�存�Ӟ��是分两部分进行缓存的�Q�首先缓存集合中所有实体的id列表�Q�然后缓存实体对象，�q�些实体对象�?/span>id列表�Q�就是所谓的数据索引。当查找数据索引�Ӟ��如果没有扑ֈ�对应的数据烦引，�q�时��׃��一�?/span>select SQL的执行，获得�W�合条�g的数据，�q�构造实体对象集合和数据索引�Q�然后返回实体对象的集合�Q��ƈ且将实体对象和数据烦引纳�?/span>Hibernate的缓存之中。另一斚w��Q�如果找到对应的数据索引�Q�则从数据烦引中取出id列表�Q�然后根�?/span>id在缓存中查找对应的实体，如果扑ֈ��׃��~�存中返回，如果没有扑ֈ��Q�在发�vselect SQL查询。在�q�里我们看出了另外一个问题，�q�个问题可能会对性能产生影响�Q�这��是集合�c�d��的缓存策略。如果我们如下配�|�集合类型：

…..

lazy=”true” inverse=”true”>

�q�里我们应用�?/span>配置�Q�如果采用这�U�策略来配置集合�c�d��Q?/span>Hibernate��只会对数据索引�q�行�~�存�Q�而不会对集合中的实体对象�q�行�~�存。如上配�|�我们运行下面的代码�Q?/span>

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

Collection addset=user.getAddresses();

Iterator it=addset.iterator();

while(it.hasNext()){

Address address=(Address)it.next();

System.out.println(address.getAddress());

}

System.out.println(“Second query……”);

User user2=(User)session.load(User.class,”1”);

Collection it2=user2.getAddresses();

while(it2.hasNext()){

Address address2=(Address)it2.next();

System.out.println(address2.getAddress());

}

�q�行�q�段代码�Q�会得到�c�M��下面的输出：

Select * from user where id=’1’;

Select * from address where user_id=’1’;

Tianjin

Dalian

Second query……

Select * from address where id=’1’;

Select * from address where id=’2’;

Tianjin

Dalian

我们看到�Q�当�W�二�ơ执行查询时�Q�执行了两条�?/span>address表的查询操作�Q��ؓ什么会�q�样�Q�这是因为当�W�一�ơ加载实体后�Q�根据集合类型缓存策略的配置�Q�只寚w��合数据烦引进行了�~�存�Q�而�ƈ没有寚w��合中的实体对象进行缓存，所以在�W�二�ơ再�ơ加载实体时�Q?/span>Hibernate扑ֈ�了对应实体的数据索引�Q�但是根据数据烦引，却无法在�~�存中找到对应的实体�Q�所�?/span>Hibernate�Ҏ��扑ֈ�的数据烦引发起了两条select SQL的查询操作，�q�里造成了对性能的浪费，怎样才能避免�q�种情况呢？我们必须寚w��合类型中的实体也指定�~�存�{�略�Q�所以我们要如下寚w��合类型进行配�|�：

…..

lazy=”true” inverse=”true”>

此时Hibernate会对集合�c�d��中的实体也进行缓存，如果�Ҏ��q�个配置再次�q�行上面的代码，��会得到�c�M��如下的输出：

Select * from user where id=’1’;

Select * from address where user_id=’1’;

Tianjin

Dalian

Second query……

Tianjin

Dalian

�q�时��不会再有根据数据烦引进行查询的SQL语句�Q�因为此时可以直接从�~�存中获得集合类型中存放的实体对象�?/span>

C�?span style="FONT: 7pt Times New Roman"> 属性�g�q�加载：

�?/span>Hibernate3中，引入了一�U�新的特性——属性的延迟加蝲�Q�这个机制又��取高性能查询提供了有力的工具。在前面我们讲大数据对象��d��Ӟ��?/span>User对象中有一�?/span>resume字段�Q�该字段是一�?/span>java.sql.Clob�c�d��Q�包含了用户的简历信息，当我们加载该对象�Ӟ��我们不得不每一�ơ都要加载这个字�D�，而不论我们是否真的需要它�Q�而且�q�种大数据对象的��d��本��n会带来很大的性能开销。在Hibernate2中，我们只有通过我们前面讲过的面性能的粒度细分，来分�?/span>User�c�，来解册��个问题（请参照那一节的��Q�，但是�?/span>Hibernate3中，我们可以通过属性�g�q�加载机�Ӟ��来��我们获得只有当我们真正需要操作这个字�D�|��Q�才去读取这个字�D�|��据的能力�Q��ؓ此我们必��d��下配�|�我们的实体�c�：

……

lazy=”true”/>

通过�?/span>元素�?/span>lazy属性设�|?/span>true来开启属性的延迟加蝲�Q�在Hibernate3中�ؓ了实现属性的延迟加蝲�Q��用了�c�d��强器来对实体�cȝ��Class文�g�q�行强化处理�Q�通过增强器的增强�Q�将CGLIB的回调机刉��辑�Q�加入实体类�Q�这里我们可以看出属性的延迟加蝲�Q�还是通过CGLIB来实现的�?/span>CGLIB�?/span>Apache的一个开源工�E�，�q�个�c�d��可以操纵java�cȝ��字节码，�Ҏ��字节码来动态构造符合要求的�c�d��象。根据上面的配置我们�q�行下面的代码：

String sql=”from User user where user.name=’zx’ ”;

Query query=session.createQuery(sql); (1)

List list=query.list();

for(int i=0;i

User user=(User)list.get(i);

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

System.out.println(user.getResume()); (2)

}

当执行到(1)处时�Q�会生成�c�M��如下�?/span>SQL语句�Q?/span>

Select id,age,name from user where name=’zx’;

�q�时Hibernate会检�?/span>User实体中所有非延迟加蝲属性对应的字段数据�Q�当执行�?/span>(2)处时�Q�会生成�c�M��如下�?/span>SQL语句�Q?/span>

Select resume from user where id=’1’;

�q�时会发起对resume字段数据真正的读取操作�?/span>

semovy 2007-08-16 16:36 发表评论

spring中配�|�二�U�缓�?

semovy — Thu, 16 Aug 2007 06:12:00 GMT

1.首先,在spring的hibernate配置�?我的是applicationContext-hibernate.xml) 加上如下属�?

    org/appfteaching/model/TArticleclass.hbm.xml




    ${hibernate.dialect}
          ${hibernate.show_sql}
          ${hibernate.jdbc.fetch_size}
          ${hibernate.jdbc.batch_size}
          true
          org.hibernate.cache.EhCacheProvider

2.其次,在src目录下的ehcache.xml中配�|�如下信�?如果是默认ehcache.xml则会�?lt;cache name="sampleCache1">�?lt;cache name="sampleCache2>",��L��)

        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="4200"
        overflowToDisk="true"
        />

            maxElementsInMemory="5000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        />

3.��你要缓存的model加进ehcache.xml�?/p>

    maxElementsInMemory="1000"
        eternal="false"
        timeToIdleSeconds="100"
        timeToLiveSeconds="4200"
        overflowToDisk="true"
    />

4.最后一�?在TArticleclass.hbm.xml里加�?/p>

启动Tomcat,如发现如下错�?/p>

Could not find configuration [org.hibernate.cache.UpdateTimestampsCache]; using defaults.
Could not find configuration [org.hibernate.cache.StandardQueryCache]; using defaults.

则是�W�二步没有做,加上卛_��.配置完毕

semovy 2007-08-16 14:12 发表评论

criteria

semovy — Sat, 11 Aug 2007 03:52:00 GMT

16.1. 创徏一�?tt class=literal>Criteria 实例

org.hibernate.Criteria接口表示特定持久�cȝ��一个查询�?tt class=literal>Session�?Criteria实例的工厂�?

Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();

16.2. 限制�l�果集内�?/h2>

一个单独的查询条�g�?tt class=literal>org.hibernate.criterion.Criterion 接口的一个实例�?tt class=literal>org.hibernate.criterion.Restrictions�c?定义了获得某些内�|?tt class=literal>Criterion�c�d��的工厂方法�?

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�?

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

{alias}占位�W�应当被替换��查询实体的列别名�?

Property实例是获得一个条件的另外一�U�途径。你可以通过调用Property.forName() 创徏一�?tt class=literal>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();

16.3. �l�果集排�?/h2>

你可以��?tt class=literal>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();

16.4. 兌��

你可以��?tt class=literal>createCriteria()非常�Ҏ��的在互相兌��的实体间建立 �U�束�?

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 集合中的元素�?

接下来，替换形态在某些情况下也是很有用的�?

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的。如果你希望只获得符合条件的kittens�Q?你必��M��?tt class=literal>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");
}

16.5. 动态关联抓�?/h2>

你可以��?tt class=literal>setFetchMode()在运行时定义动态关联抓取的语义�?

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

�q�个查询可以通过外连接抓�?tt class=literal>mate�?tt class=literal>kittens�?查看�W?nbsp;20.1 �?“ 抓取�{�略(Fetching strategies) ”可以获得更多信息�?

16.6. 查询�C�Z��

org.hibernate.criterion.Example�c�d��怽�通过一个给定实�?构徏一个条件查询�?

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

版本属性、标识符和关联被忽略。默认情况下��gؓnull的属性将被排除�?

你可以自行调�?tt class=literal>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�?

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

16.7. 投媄(Projections)、聚合（aggregation�Q�和分组�Q�grouping�Q?/h2>

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��型就是被定义�?span class=emphasis> 分组投媄�Q�他们也出现在SQL�?tt class=literal>group by子句中�?

你可以选择把一个别名指�z��一个投影，�q�样可以使投影��D��U�束或排序所引用。下面是两种不同的实现方式：

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()�?tt class=literal>as()�Ҏ��便的��一个投影实例包装到另外一�?别名�?tt class=literal>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();

16.8. ��ȝ��(detached)查询和子查询

DetachedCriteria�c�M��你在一个session范围之外创徏一个查询，�q�且可以使用��L��?Session来执行它�?

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

DetachedCriteria也可以用以表�C�子查询。条件实例包含子查询可以通过 Subqueries或�?tt class=literal>Property获得�?

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?

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

semovy 2007-08-11 11:52 发表评论

兌��关系映射

semovy — Fri, 10 Aug 2007 06:01:00 GMT

�W?nbsp;8 �?nbsp;兌��关系映射

8.1. 介绍

兌��关系映射通常情况是最��N��|�正��的。在�q�个部分中，我们从单向关�p�L��开始，然后考虑双向关系映射�Q�由��至��p��q�C��遍典型的案例。在所有的例子中，我们都��?Person�?tt class=literal>Address�?

我们�Ҏ��映射关系是否涉及�q�接表以及多��h��来划分兌��c�d��?

在传�l�的数据建模中，允许为Null值的外键被认为是一�U�不好的实践�Q�因此我们所有的例子中都使用不允��ؓNull的外键。这�q�不是Hibernate的要求，即��你删除掉不允��ؓNull的约束，Hibernate映射一样可以工作的很好�?

8.2. 单向兌��Q�Unidirectional associations�Q?/h2>

8.2.1. 多对一(many to one)

单向many-to-one兌��是最常见的单向关联关�p�R�?

create table Person ( personId bigint not null primary key, addressId bigint not null )
create table Address ( addressId bigint not null primary key )

8.2.2. 一对一�Q�one to one�Q?/h3>

��Z��外键兌��的单向一对一兌���?span class=emphasis>单向多对一兌��几乎是一��L��。唯一的不同就是单向一对一兌��中的外键字段��h��唯一性约束�?

create table Person ( personId bigint not null primary key, addressId bigint not null unique )
create table Address ( addressId bigint not null primary key )

��Z��主键兌��的单向一对一兌��通常使用一个特定的id生成器。（��h��意，在这个例子中我们掉换了关联的方向。）









person

create table Person ( personId bigint not null primary key )
create table Address ( personId bigint not null primary key )

8.2.3. 一对多�Q�one to many�Q?/h3>

��Z��外键兌��的单向一对多兌��是一�U�很��见的情况，�q�不推荐使用�?

create table Person ( personId bigint not null primary key )
create table Address ( addressId bigint not null primary key, personId bigint not null )

我们认�ؓ对于�q�种兌��关系最好��用连接表�?

8.3. 使用�q�接表的单向兌��Q�Unidirectional associations with join tables�Q?/h2>

8.3.1. 一对多(one to many)

��Z��q�接表的单向一对多兌�� 应该优先被采用。请注意�Q�通过指定unique="true"�Q�我们可以把多样性从多对多改变�ؓ一对多�?

create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId not null, addressId bigint not null primary key )
create table Address ( addressId bigint not null primary key )

8.3.2. 多对一�Q�many to one�Q?/h3>

��Z��q�接表的单向多对一兌��在关联关�p�d��选的情况下应用也很普遍�?

create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null primary key, addressId bigint not null )
create table Address ( addressId bigint not null primary key )

8.3.3. 一对一�Q�one to one�Q?/h3>

��Z��q�接表的单向一对一兌��非常��见�Q�但也是可行的�?

create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique )
create table Address ( addressId bigint not null primary key )

8.3.4. 多对多（many to many�Q?/h3>

最后，�q�有 单向多对多关�?/em>.

create table Person ( personId bigint not null primary key ) create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) ) create table Address ( addressId bigint not null primary key )

8.4. 双向兌��Q�Bidirectional associations�Q?/h2>

8.4.1. 一对多�Q�one to many) / 多对一�Q�many to one�Q?/h3>

双向多对一兌�� 是最常见的关联关�p�R��（�q�也是标准的�?子关联关�p�R��）

create table Person ( personId bigint not null primary key, addressId bigint not null ) create table Address ( addressId bigint not null primary key )

8.4.2. 一对一�Q�one to one�Q?/h3>

��Z��外键兌��的双向一对一兌��也很常见�?

create table Person ( personId bigint not null primary key, addressId bigint not null unique ) create table Address ( addressId bigint not null primary key )

��Z��主键兌��的一对一兌��需要��用特定的id生成器�?

person

create table Person ( personId bigint not null primary key ) create table Address ( personId bigint not null primary key )

8.5. 使用�q�接表的双向兌��Q�Bidirectional associations with join tables�Q?/h2>

8.5.1. 一对多�Q�one to many�Q?/多对一�Q?many to one�Q?/h3>

��Z��q�接表的双向一对多兌��。注�?tt class=literal>inverse="true"可以出现在关联的��L��一端，即collection端或者join端�?

create table Person ( personId bigint not null primary key ) create table PersonAddress ( personId bigint not null, addressId bigint not null primary key ) create table Address ( addressId bigint not null primary key )

8.5.2. 一对一�Q�one to one�Q?/h3>

��Z��q�接表的双向一对一兌��极�ؓ�|�见�Q�但也是可行的�?

create table Person ( personId bigint not null primary key ) create table PersonAddress ( personId bigint not null primary key, addressId bigint not null unique ) create table Address ( addressId bigint not null primary key )

8.5.3. 多对多（many to many�Q?/h3>

最后，�q�有 双向多对多关�?/em>.

create table Person ( personId bigint not null primary key ) create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) ) create table Address ( addressId bigint not null primary key )

�W?nbsp;9 �?nbsp;�l��g�Q�Component�Q�映��?/h2>

Component�q�个概念在Hibernate中几处不同的地方��Z��不同的目的被重复使用.

9.1. 依赖对象�Q�Dependent objects�Q?/h2>

Component是一个被包含的对�?它作为值类型被持久化，而非一个被引用的实体�?#8220;component(�l��g)”�q�一术语指的是面向对象的合成概念�Q�而�ƈ不是�pȝ��构架层次上的�l��g的概念）举个例子, 你可以对人（Person)如以下这��h��建模�Q?

public class Person { private java.util.Date birthday; private Name name; private String key; public String getKey() { return key; } private void setKey(String key) { this.key=key; } public java.util.Date getBirthday() { return birthday; } public void setBirthday(java.util.Date birthday) { this.birthday = birthday; } public Name getName() { return name; } public void setName(Name name) { this.name = name; } ...... ...... }

public class Name { char initial; String first; String last; public String getFirst() { return first; } void setFirst(String first) { this.first = first; } public String getLast() { return last; } void setLast(String last) { this.last = last; } public char getInitial() { return initial; } void setInitial(char initial) { this.initial = initial; } }

现在,姓名(Name)是作�?tt class=literal>�?Person)的一个组成部分。需要注意的�?需要对姓名 的持久化属性定义getter和setter�Ҏ��,但是不需要实��C�Q何的接口或申明标识符字段�?

以下是这个例子的Hibernate映射文�g:

人员(Person)表中��包�?tt class=literal>pid, birthday, initial, first�?last�{�字�D�c�?

��像所有的值类型一�? Component不支持共享引用�?换句话说�Q�两个�h可能重名�Q�但是两个person对象应该包含两个独立的name对象�Q�只不过是具�?#8220;同样”的倹{�?Component的��gؓ�I�Z��语义学上来讲�?span class=emphasis>专有�?ad hoc)�?每当重新加蝲一个包含组件的对象,如果component的所有字�D��ؓ�I�，那么��Hibernate��假定整个component�?�I�。对于绝大多数目�?�q�样假定是没有问题的�?

Component的属性可以是Hibernate�c�d��Q�包括Collections, many-to-one 兌��Q?以及其它Component �{�等�Q�。嵌套Component不应该作为特�D�的应用被考虑(Nested components should not be considered an exotic usage)�?Hibernate��向于支持设计细�?fine-grained)的对象模型�?

元素�q�允许有子元�?�Q�用来表明component�c�M��的一个属性返回包含它的实体的引用�?

>

9.2. 在集合中出现的依赖对�?/h2>

Hibernate支持component的集�?例如: 一个元素是“姓名”�q�种�c�d��的数�l?�?你可以��?tt class=literal>标签替代标签来定义你的component集合�?

注意�Q�如果你军_��定义一个元素是联合元素�?tt class=literal>Set�Q�正��地实现equals()�?tt class=literal>hashCode()是非帔R��要的�?

�l�合元素可以包含component但是不能包含集合。如果你的组合元素自�w�包含component, 必须使用标签。这是一个相当特�D�的案例 - �l�合元素的集合自�w�可以包含component�?�q�个时候你��应该考虑一下��用one-to-many兌��是否会更恰当�?��试对这个组合元素重新徏模�ؓ一个实体－但是需要注意的是，虽然Java模型和重新徏模前是一��L��Q�关�p�L��型和持久性语义上仍然存在��d��的区别�?

��h��意如果你使用标签,一个组合元素的映射不支持可能�ؓ�I�的属�? 当删除对象时, Hibernate必须使用每一个字�D늚�来确定一条记�?在组合元素表中，没有单个的关键字�D?, 如果有�ؓnull的字�D�，�q�样做就不可能了。你必须作出一个选择�Q�要么在�l�合元素中��用不能�ؓ�I�的属性，要么选择使用, , 或�?而不�?�?

�l�合元素有个特别的案例，是组合元素可以包含一�?tt class=literal> 元素。类��D��L��映射允许你映��一个many-to-mang兌��表作为组合元素额外的字段�?A mapping like this allows you to map extra columns of a many-to-many association table to the composite element class.) 接下来的的例子是�?tt class=literal>Order�?tt class=literal>Item的一个多对多的关联关�p?�?purchaseDate, price �?quantity �?tt class=literal>Item的关联属性�?

....

当然�Q�在另一斚w��Q�无法存在指向purchase的关联，因此不能实现双向兌��查询。记住组建是值类型，�q�且不允许共享关联。单�?tt class=literal>Purchase 可以攑֜�包含Order的集合中�Q�但它不能同时被Item所兌��?

即��三重或多重管理都是可能的:

....

在查询中�Q�组合元素��用的语法是和兌��到其他实体的语法一��L��?

9.3. �l��g作�ؓMap的烦引（Components as Map indices �Q?/h2>

元素允许你映��一个Component�c�M��?tt class=literal>Map的key�Q?但是你必��ȝ��定你正确的在�q�个�c�M��重写�?tt class=literal>hashCode() �?equals()�Ҏ��?

9.4. �l��g作�ؓ联合标识�W?Components as composite identifiers)

你可以��用一个component作�ؓ一个实体类的标识符�?你的component�c�d��L��以下要求：

它必��d��?tt class=literal>java.io.Serializable接口

它必��重新实�?tt class=literal>equals()�?tt class=literal>hashCode()�Ҏ��, 始终和组合关键字在数据库中的概念保持一�?

注意�Q�在Hibernate3中，�W�二�U�要求�ƈ非是Hibernate强制必须的。但最好这样做�?/em>

你不能��用一�?tt class=literal>IdentifierGenerator产生�l�合关键字。作为替代应用程序必��d��配它自己的标识符�?

使用标签(�q�且内嵌元素)代替通常�?tt class=literal>标签�?比如,OrderLine�c�d��有一个依�?tt class=literal>Order�?联合)主键的主键�?

....

现在�Q��Q何关联到OrderLine 的外键都是复合的。在你的映射文�g中，必须为其他类也这样声明。指�?tt class=literal>OrderLine的关联可能被�q�样映射�Q?

�Q�注意在各个地方标签都是column属性的替代写法。）

指向OrderLine�?tt class=literal>多对�?/tt>兌��也��用联合外�?

�?tt class=literal>Order�? OrderLine的集合则是这�?

(与通常一�?元素不声明�Q何列.)

假若OrderLine本��n拥有一个集�?它也��h��l�合外键�?

.... .... ...

9.5. 动态组�?�Q�Dynamic components�Q?/h2>

你甚臛_��以映��?tt class=literal>Map�c�d��的属性：

�?tt class=literal>映射的语义上来讲�Q�它�?tt class=literal>是相同的�?�q�种映射�c�d��的优点在于通过修改映射文�g�Q�就可以��h��在部�|�时��真实属性的能力.利用一个DOM解析器，是有可能在运行时��L��作映��文件的�?更好的是�Q�你可以通过Configuration对象来访问（或者修改）Hibernate的运行时元模型�?

�W?nbsp;10 �?nbsp;�l�承映射(Inheritance Mappings)

10.1. 三种�{�略

Hibernate支持三种基本的��承映��策略：

每个�c�d��层结构一张表(table per class hierarchy)

每个子类一张表(table per subclass)

每个具体�c�M��张表(table per concrete class)

此外�Q�Hibernate�q�支持第四种�E�有不同的多态映��策略：

隐式多�?implicit polymorphism)

对于同一个��承层�ơ内的不同分支，可以采用不同的映��策略，然后用隐式多态来完成跨越整个层次的多态。但是在同一�?tt class=literal>根元�?下，Hibernate不支持�؜合了元素�?�?tt class=literal> 的映��。在同一�?tt class=literal>元素下，可以混合使用 “每个�c�d��层结构一张表”�Q�table per hierarchy�Q?�?#8220;每个子类一张表”�Q�table per subclass�Q?�q�两�U�映��策略，�q�是通过�l�合元素�?来实现的�Q�见后）�?

10.1.1. 每个�c�d��层结构一张表(Table per class hierarchy)

假设我们有接�?tt class=literal>Payment和它的几个实现类�Q?CreditCardPayment, CashPayment, �?tt class=literal>ChequePayment。则“每个�c�d��层结构一张表”(Table per class hierarchy)的映��代码如下所�C�：

... ... ... ...

采用�q�种�{�略只需要一张表卛_��。它有一个很大的限制�Q�要求那些由子类定义的字�D�， �?tt class=literal>CCTYPE�Q�不能有非空(NOT NULL)�U�束�?

10.1.2. 每个子类一张表(Table per subclass)

对于上例中的几个�c�而言�Q�采�?#8220;每个子类一张表”的映��策略，代码如下所�C�：

... ... ... ...

需要四张表。三个子�c�表通过主键兌��到超�c�表(因而关�p�L��型实际上是一对一兌��)�?

10.1.3. 每个子类一张表(Table per subclass)�Q��用��L别标�?Discriminator)

注意�Q�对“每个子类一张表”的映��策略，Hibernate的实��C��需要��L别字�D�，而其�?的对�?关系映射工具使用了一�U�不同于Hibernate的实现方法，该方法要求在��类表中有一个类型��L别字�D?type discriminator column)。Hibernate采用的方法更隑֮�玎ͼ�但从关系�Q�数据库�Q�这点上来看�Q�按理说它更正确。若你愿意��用带有��L别字 �D늚�“每个子类一张表”的策略，你可以结合��?tt class=literal> �?tt class=literal>�Q�如下所�C�：

... ... ... ...

可选的声明fetch="select"�Q�是用来告诉Hibernate�Q�在查询��类�Ӟ�� 不要使用外部�q�接(outer join)来抓取子�c?tt class=literal>ChequePayment的数据�?

10.1.4. 混合使用“每个�c�d��层结构一张表”�?#8220;每个子类一张表”

你甚臛_��以采取如下方法�؜和��?#8220;每个�c�d��层结构一张表”�?#8220;每个子类一张表”�q�两�U�策略：

... ... ... ...

对上�q�C�Q何一�U�映��策略而言�Q�指向根�c?tt class=literal>Payment�?兌��是��?tt class=literal>�q�行映射的�?

10.1.5. 每个具体�c�M��张表(Table per concrete class)

对于“每个具体�c�M��张表”的映��策略，可以采用两种�Ҏ��。第一�U�方法是使用 �?

... ... ... ...

�q�里涉及三张表。每张表为对应类的所有属性（包括从超�cȝ��承的属性）定义相应字段�?

�q�种方式的局限在于，如果一个属性在��类中做了映��，其字�D�名必须与所有子�c?表中定义的相同�?我们可能会在Hibernate的后�l�发布版本中攑֮�此限制�? 不允许在联合子类(union subclass)的��承层�ơ中使用标识生成器策�?identity generator strategy), 实际�? 主键的种�?primary key seed)不得不�ؓ同一�l�承层次中的全部被联合子�c�L��q��.

10.1.6. Table per concrete class, using implicit polymorphism

10.1.6. Table per concrete class, using implicit polymorphism

另一�U�可供选择的方法是采用隐式多态：

... ... ...

注意�Q�我们没有在��M��地方明确的提及接�?tt class=literal>Payment。同时注�?Payment的属性在每个子类中都�q�行了映��。如果你想避免重复，可以考虑使用XML实体(例如�Q�位�?tt class=literal>DOCTYPE声明内的 [ ] 和映��中�?tt class=literal>&allproperties;)�?

�q�种�Ҏ��的缺陷在于，在Hibernate执行多态查询时(polymorphic queries)无法生成�?UNION的SQL语句�?

对于�q�种映射�{�略而言�Q�通常�?tt class=literal>来实现到 Payment的多态关联映��?

10.1.7. 隐式多态和其他�l�承映射混合使用

对这一映射�q�有一炚w��要注意。因为每个子�c�都在各自独立的元素中映��?�q�且Payment只是一个接�?�Q�每个子�c�d��以很�Ҏ��的成为另一个��承体�p�M��的一部分�Q?你仍然可以对接口Payment使用多态查询�?

... ... ... ...

我们�q�是没有明确的提�?tt class=literal>Payment�?如果我们针对接口Payment执行查询 ——如from Payment—�?Hibernate 自动�q�回CreditCardPayment(和它的子�c�，因�ؓ 它们也实��C��接口Payment)�?CashPayment�?tt class=literal>Chequepayment的实例，但不�q�回NonelectronicTransaction的实例�?

10.2. 限制

�?#8220;每个具体�c�L��一张表”�Q�table per concrete-class�Q�的映射�{�略而言�Q�隐式多态的方式有一定的限制。�?tt class=literal>映射的限制则没有�?么严根{�?

下面表格中列��Z��在Hibernte�?#8220;每个具体�c�M��张表”的策略和隐式多态的限制�?

�?nbsp;10.1. �l�承映射�Ҏ�?Features of inheritance mappings)

�l�承�{�略(Inheritance strategy) 多态多对一多态一对一多态一对多多态多对多多�?load()/get() 多态查�?/th> 多态连�?join) 外连�?Outer join)抓取

每个�c�d��层结构一张表 s.get(Payment.class, id) from Payment p from Order o join o.payment p 支持

每个子类一张表 s.get(Payment.class, id) from Payment p from Order o join o.payment p 支持

每个具体�c�M��张表(union-subclass) (仅对�?tt class=literal>inverse="true"的情�? s.get(Payment.class, id) from Payment p from Order o join o.payment p 支持

每个具体�c�M��张表(隐式多�? 不支�?/em> 不支�?/em> s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult() from Payment p 不支�?/em> 不支�?/em>

semovy 2007-08-10 14:01 发表评论

�l�承�{�略(Inheritance strategy)	多态一对一	多态一对多	多�?`load()/get()`	多态查�?/th>	多态连�?join)	外连�?Outer join)抓取
每个�c�d��层结构一张表			`s.get(Payment.class, id)`	`from Payment p`	`from Order o join o.payment p`	支持
每个子类一张表			`s.get(Payment.class, id)`	`from Payment p`	`from Order o join o.payment p`	支持
每个具体�c�M��张表(union-subclass)		(仅对�?tt class=literal>inverse="true"的情�?	`s.get(Payment.class, id)`	`from Payment p`	`from Order o join o.payment p`	支持
每个具体�c�M��张表(隐式多�?	不支�?/em>	不支�?/em>	`s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()`	`from Payment p`	不支�?/em>	不支�?/em>

Hibernate查询语言

semovy — Fri, 10 Aug 2007 05:55:00 GMT
     摘要: �W?nbsp;14 �?nbsp;扚w��处理�Q�Batch processing�Q? 使用Hibernate��?100 000 条记录插入到数据库的一个很自然的做法可能是�q�样�? Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); for...  阅读全文

semovy 2007-08-10 13:55 发表评论

有关Criteria

semovy — Thu, 09 Aug 2007 05:57:00 GMT

Criteria:

Criteria criteria = session.createCriteria(User.class);

1)criteria.add(Restrictions.gt("age", new Integer(20)));

2)criteria.add(Restrictions.lt("age", new Integer(40)));

3)criteria.add(Restrictions.or(Restrictions.eq("age", new Integer(20)), Restrictions.isNull("age")));

crit.add(Restrictions.ilike("name","1", MatchMode.END));

// // ilike�?/span>i�?/span>ignore之意,所�?/span>�q?/span>�?/span>查询�?/span>englishName"Optima?XL?100K?Ultracentrifuge"�Q�忽略大��写�Q�的记录

4)criteria.add(Restrictions.sqlRestriction("{alias}.name LIKE (?)", "cater%", Hibernate.STRING));

5) Integer[] ages = {new Integer(20), new Integer(40)};

Type[] types = {Hibernate.INTEGER, Hibernate.INTEGER};

criteria.add(Restrictions.sqlRestriction("{alias}.age BETWEEN (?) AND (?)", ages, types));

6) criteria.setFirstResult(51);

criteria.setMaxResult(50);

  7) �l�计�?/span>rowCount()�?/span>count()�?/span>max()�?/span>min()�?/span>countDistinct()

criteria.setProjection(Projections.avg("age"));

  8)分组20,20,25,30 à 20.25.30

      criteria.setProjection(Projections.groupProperty("age"));

9)�l�合�l�计分组

   ProjectionList projectionList = Projections.projectionList();

projectionList.add(Projections.groupProperty("age"));

projectionList.add(Projections.rowCount());

Criteria criteria = session.createCriteria(User.class);

criteria.setProjection(projectionList);

10) Query Criteria Id: data type Long

projectionList.add(crit.add( Expression.idEq( 11111L) );

11) Query Criteria Id: Not Equal

crit.add( Expression.ne( "name", "noName" ) );)

12)crit.setProjection(Projections.rowCount());

13�Q?/span>�q?/span>�?/span>�?/span>�C�Z��?/span>复记�?/span>

criteria.setResultTransformer(criteria.DISTINCT_ROOT_ENTITY);

List users = criteria.list();

Restrictions的幾個常用限�?/span>�?/span>詢方法如下表所�C�：

�Ҏ��

�?/span>�?/span>

Restrictions.eq

�{�於

Restrictions.allEq

使用Map�Q��?/span>key/value進行多個等於的比對

Restrictions.gt

大於 >

Restrictions.ge

大於�{�於 >=

Restrictions.lt

��於 <

Restrictions.le

��於�{�於 <=

Restrictions.between

��應SQL�?/span>BETWEEN子句

Restrictions.like

��應SQL�?/span>LIKE子句

Restrictions.in

��應SQL�?/span>in子句

Restrictions.and

and關係

Restrictions.or

or關係

Restrictions.sqlRestriction

SQL限定�?/span>�?/span>

HQL�Q?/span>Hibernate Query Language�Q?/span>

PS:

1:HOL是不区分大小写的,但名�U�是区分大小写的.

     2:如果User��別提供有適當的建構�Ҏ��Q�則可以在��?/span>HQL時直接指定新��Z��個物件傳�?/span>

Query query = session.createQuery("select new User(user.name, user.age) from User as user");

    3. 如果試圖使用Session�?/span>saveOrupdate()�Ҏ��Q�則會新增一�{�資料而不是更新原有的資料�?/span>

   4. 還可以結�?/span>having子句�Q�例如只��^均大�?/span>20的資料分�i�顯�C�出來：

Query query = session.createQuery("select user.sex, avg(user.age) from User user group by user.sex having avg(user.age) > 20");

   5. 更新与删除的时�?/span>

             Session session = sessionFactory.openSession();

Transaction tx= session.beginTransaction();

Query query = session.createQuery("update User set name='momor' where name='bbb'");

query.executeUpdate();

tx.commit();

session.close();

Hibernate:HQL/QBC查询�?/span>�a��?/span>�?/span>的用�?/span>

Hib�?/span>��索方�?/span>
1'�?/span>�?/span>�?/span>�?/span>图检索方式。�?/span>�q?/span>�?/span>�l?/span>�?/span>�?/span>�?/span>�?/span>象，�?/span>�?/span>.iterator()�Ҏ��可以得到order�?/span>�?/span>
如果是首��?/span>�?/span>行此�Ҏ��Q?/span>Hib会从数据�?/span>�?/span>载关�?/span>�?/span>order�?/span>象，�?/span>�?/span>��׃��~?/span>存中得到�?/span>
2'OID��索方式。�?/span>�q?/span>session�?/span>get�Q?/span>load�Ҏ��知道�?/span>OID的情况下可以使用
3'HQL��索方式。��用面�?/span>�?/span>象的HQL查询�?/span>�?/span>session�?/span>find�Ҏ��利用HQL�?/span>查询
4'QBC��索方式�?/span>利用QBCAPI�?/span>��索它是封装了��Z��字符串的查询�?/span>�?/span>
5'本地�?/span>SQL��索方式。��用本地数�?/span>�?/span>�?/span>SQL查询�?/span>�?/span>Hib�?/span>负责�?/span>��索到�?/span>JDBC�l?/span>果集映射�?/span>持久�?/span>�?/span>�?/span>�?/span>�?/span>

�?/span>�U�检索方式的使用�?/span>合和特点�Q?/span>

HQL �Q?/span> 是面�?/span>�?/span>象的查询�?/span>�a��Q�同SQL有些�怼��?/span>Hib中最常用的方式�?/span>
       查询�?/span>定各�U�查�?/span>条�g�?/span>
       支持投媄查询�Q?/span>��索出�?/span>象的部分属性�?/span>
       支持�?/span>��|��?/span>�Q�允�?/span>使用having�?/span>group by
       提供内制的聚集函敎ͼ�sum()�Q?/span>min()�Q?/span>max()
       �?/span>�?/span>用用�?/span>的自�?/span>�?/span>SQL
       支持�?/span>查询�Q�嵌入式查询
       支持动态绑定参�?/span>
�?/span>�?/span>使用Query接口�?/span>�?/span>session�?/span>find�Ҏ��?/span>
   Query Q = session.createQuery("from customer as c where c.name = :customerName" + "and c.age = :customerAge");
   query.setString ("customerName" , "tom");
   query.setInteger("customerAge" , "21");
   list result = query.list();
QBC :  QBCAPI提供了另一�U?/span>方式�Q�主要是Criteria接口�?/span>Criterion接口�?/span>Expression�c?/span>
   Criteria criteria = session.createCriteria(customer.class);
   Criterion criterion1 = Expression.like("name","t%");
   Criterion criterion2 = Expression.eq("age",new Integer(21));
   Critera = criteria.add(criterion1) ;
   Critera = criteria.add(criterion2) ;
   list result = criteria.list();
   或是�Q?/span> list result = session.createCriteria(Customer.class).add(Expression.eq("this.name","tom")).list();
SQL :  采用HQL�?/span>QBC��?/span>�?/span>�Q?/span>Hib生成SQL�?/span>句适用所有数�?/span>�?/span>�?/span>
   Query query  = session.createSQLQuery("select {c.*} from customers c where c.name like : customername " + "and c.age = :customerage","c",customer.calss);
   query.setString("customername","tom");
   query.setInteger("customerage","21");
   list result = query.list();
/////////////�?/span>态查�?/span>
   HQL �Q?/span>session.createQuery("from employee");
   QBC �Q?/span>session.createCriteria(employee.class);
   HQL : session.createQuery("from hourlyEmployee");
   QBC : session.createCriteria(hourlyEmployee.class);
   下面�?/span>HQL查询�?/span>句将��索出所有的持久�?/span>�?/span>象：
   from java.lang.Object ;
   from java.io.serializable ;
////////////查询的排�?/span>
   1'查询�l?/span>果按照客�?/span>姓名升序排列�Q?/span>
   HQL �Q?/span>
        Query query = session.createQuery ("from customer c order by c.name");
   QBC �Q?/span>
        Criteria criteria = session.createCriteria(customer.class);
        criteria.addOrder(order.asc("name"));
   HQL :
        Query query = session.createQuery ("from customer c order by c.name asc , c.age desc");
   QBC :
        Criteria criteria = session.createCriteria(customer.class);
        criteria.addOrder(order.asc ("name"));
        criteria.addOrder(order.desc("age"));

        import net.sf.hibernate.pression.Order
        import mypack.Order
        ...........
        Criteria criteria = session.createCritria (mypack.Order.class);
        criteria.addOrder(net.sf.hibernate.Order.asc("name"));
///////////HQL�?/span>句的参数�l?/span>�?/span>Query接口提供�?/span>�l?/span>定各�U?/span>Hib映射�c?/span>型的�Ҏ��?/span>
        setBinary()
        setString()
        setBoolean()
        setByte()
        setCalendar()
        setCharacter()
        setDate()
        setDouble()
        setText()
        setTime()
        setTimestamp()
        setEntity()//把参��C��一个持久化�c?/span>的事�?/span>�l?/span>�?/span>lsit result = session.createQuery("from order o where o.customer =            :customer").setEntity("customer" , customer).list ;
        setParameter()//�l?/span>定�Q�?/span>�c?/span>型的参数
        setProperties()//把命名参��C��一�?/span>�?/span>象的属�?/span>值绑�?/span> Query query = session.createQuery("from customer c where c.name =:     name " + "and c.age =:age" );
        Query.setProperties(customer);

semovy 2007-08-09 13:57 发表评论

关于DetachedCriteria

semovy — Wed, 08 Aug 2007 15:16:00 GMT

DetachedCriteria detachedCriteria =DetachedCriteria.forClass(UserVO.class)
//.add(Restrictions.like("username","sz",MatchMode.ANYWHERE));
   .add(org.hibernate.criterion.Expression.disjunction() //or查询把add攑ֈ�外面是and查询,MatchMode.ANYWHERE�p�查�?br>        .add(org.hibernate.criterion.Property.forName("username").like("s", MatchMode.ANYWHERE))
        .add(org.hibernate.criterion.Property.forName("password").like("c", MatchMode.ANYWHERE))
        );

多对一情况
DetachedCriteria zlbdc=DetachedCriteria.forClass(ZlZlxm.class, "zlb");
                     // .createAlias("zlb.zl", "t")
                        // .setProjection(Property.forName("t.id").count())
                       //.add(Property.forName("t.id").eq(new Long(1)))
                       org.hibernate.criterion.Projection projection=org.hibernate.criterion.Projections.projectionList()
                                   .add(org.hibernate.criterion.Property.forName("zlb.fdxx"),"id");
                       zlbdc.setProjection(projection);
                                     //zlbdc.createCriteria("zl");//加上�q�句是内联接(inner join)zl为集�?br>投媄查询�Q�得��C��是object[]

  DetachedCriteria zlbdc=DetachedCriteria.forClass(ZlZlxm.class, "zlb")
  //zlbdc.createCriteria("zl"); //此处为对�?br>                       .createAlias("zlb.zl", "t") //别名
                       .setProjection(Property.forName("t.id").count())
                       .add(Property.forName("t.id").eq(new Long(1))); //�q�里�l�计的是个数内联�?inner join)
         //zladc.setFetchMode("zla.zlZlxm", org.hibernate.FetchMode.JOIN);//无作�?集合lazy)�Q�？�Q�，如果not lazy��会是全部查�?/p>

semovy 2007-08-08 23:16 发表评论

Criteria Query

semovy — Wed, 08 Aug 2007 15:00:00 GMT

Criteria Query

Criteria Query通过面向对象化的设计�Q�将数据查询条�g��装��Z��个对象。简单来

�Ԍ��Criteria Query可以看作是传�l?/span>SQL的对象化表示�Q�如�Q?span>

Criteria criteria = session.createCriteria(User.class);

criteria.add(Expression.eq("name","Erica"));

criteria.add(Expression.eq("sex",new Integer(1)));

�q�里�?/span>criteria 实例实际上是SQL “Select * from t_user where

name=’Erica’ and sex=1”的封装（我们可以打开Hibernate �?/span>show_sql 选项�Q?span>

以观�?/span>Hibernate在运行期生成�?/span>SQL语句�Q��?span>

Hibernate 在运行期会根�?/span>Criteria 中指定的查询条�g�Q�也��是上面代码中通过

criteria.add�Ҏ��d��的查询表辑ּ��Q�生成相应的SQL语句�?span>

�q�种方式的特�Ҏ��比较�W�合Java �E�序员的�~�码习惯�Q��ƈ且具备清晰的可读性。正�?span>

为此�Q�不��?/span>ORM实现中都提供了类似的实现机制�Q�如Apache OJB�Q��?span>

对于Hibernate的初学者，特别是对SQL了解有限的程序员而言�Q?/span>Criteria Query

无疑是上手的极佳途径�Q�相�?/span>HQL�Q?/span>Criteria Query提供了更易于理解的查询手�D�，�?span>

�?/span>IDE�?/span>Coding Assist机制�Q?/span>Criteria的��用几乎不用太多的学习�?span>

Criteria 查询表达�?span>

Criteria 本��n只是一个查询容器，具体的查询条仉��要通过Criteria.add

�Ҏ��d��?/span>Criteria实例中�?span>

如前例所�C�，Expression 对象具体描述了查询条件。针�?/span>SQL 语法�Q?span>

Expression提供了对应的查询限定机制�Q�包括：

�Ҏ�� 描述

Expression.eq 对应SQL“field = value”表达式�?span>

�?/span>Expression.eq("name","Erica")

Expression.allEq 参数��Z��?/span>Map对象�Q�其中包含了多个属性－值对

应关�p�R��相当于多个Expression.eq关系的叠加�?span>

Expression.gt 对应SQL中的 “field > value ” 表达�?span>

Hibernate Developer’s Guide Version 1.0

September 2, 2004 So many open source projects. Why not Open your Documents?

Expression.ge 对应SQL中的 “field >= value” 表达�?span>

Expression.lt 对应SQL中的 “field < value” 表达�?span>

Expression.le 对应SQL中的 “field <= value” 表达�?span>

Expression.between 对应SQL中的 “between” 表达�?span>

如下面的表达式表�C�年龄（age�Q�位�?/span>13�?/span>50�?span>

间内�?span>

Expression.between("age",new

Integer(13),new Integer(50));

表达�?span>

Expression.in 对应SQL中的 ”field in …” 表达�?span>

Expression.eqProperty 用于比较两个属性之间的��|��对应SQL中的“field

= field”�?span>

如：

Expression.eqProperty(

"TUser.groupID",

"TGroup.id"

);

Expression.gtProperty 用于比较两个属性之间的��|��对应SQL中的“field

> field”�?span>

Expression.geProperty 用于比较两个属性之间的��|��对应SQL中的“field

>= field”�?span>

Expression.ltProperty 用于比较两个属性之间的��|��对应SQL中的“field

< field”�?span>

Expression.leProperty 用于比较两个属性之间的��|��对应SQL中的“field

<= field”�?span>

Expression.and and关系�l�合�?span>

如：

Expression.and(

Expression.eq("name","Erica"),

Expression.eq(

"sex",

new Integer(1)

)

);

Expression.or or关系�l�合�?span>

如：

Hibernate Developer’s Guide Version 1.0

September 2, 2004 So many open source projects. Why not Open your Documents?

Expression.or(

Expression.eq("name","Erica"),

Expression.eq("name","Emma")

);

Expression.sql 作�ؓ补充�Q�本�Ҏ��提供了原�?/span>SQL语法的支持。我

们可以通过�q�个�Ҏ��直接通过SQL语句限定查询

条�g�?span>

下面的代码返回所有名�U�C��“Erica”起始的记录：

Expression.sql(

“lower({alias}.name) like lower(?)”,

"Erica%",

Hibernate.STRING

);

其中�?#8220;{alias}”��由Hibernate在运行期�?span>

用当前关联的POJO别名替换�?span>

注意Expression 各方法中的属性名参数�Q�如Express.eq中的�W�一个参敎ͼ��Q�这�?span>

所谓属性名�?/span>POJO中对应实际库表字�D늚�属性名�Q�大��写敏感�Q�，而非库表中的�?span>

际字�D�名�U��?span>

Criteria 高��Ҏ�?span>

限定�q�回的记录范�?span>

通过criteria. setFirstResult/setMaxResults �Ҏ��可以限制一�ơ查询返�?span>

的记录范�?/span>:

Criteria criteria = session.createCriteria(TUser.class);

//限定查询�q�回��索结果中�Q�从�W�一百条�l�果开始的20条记�?span>

criteria.setFirstResult(100);

criteria.setMaxResults(20);

�Ҏ��询结果进行排�?span>

//查询所�?/span>groupId=2的记�?span>

//�q�分别按照姓�?/span>(��序)�?/span>groupId�Q�逆序�Q�排�?span>

Criteria criteria = session.createCriteria(TUser.class);

criteria.add(Expression.eq("groupId",new Integer(2)));

criteria.addOrder(Order.asc("name"));

Hibernate Developer’s Guide Version 1.0

September 2, 2004 So many open source projects. Why not Open your Documents?

criteria.addOrder(Order.desc("groupId"));

Criteria作�ؓ一�U�对象化的查询封装模式，不过�׃��Hibernate在实现过�E�中��精�?span>

更加集中�?/span>HQL查询语言上，因此Criteria的功能实现还没做到尽善尽��（�q�点上，OJB

�?/span>Criteria 实现倒是值得借鉴�Q�，因此�Q�在实际开发中�Q�徏议还是采�?/span>Hibernate �?span>

�Ҏ��荐的查询��装模式�Q?/span>HQL�?/span>

semovy 2007-08-08 23:00 发表评论

criteria与detachedcriteria

semovy — Wed, 08 Aug 2007 14:28:00 GMT

最�q�在��目中��?spring �?hibernate �q�行开发，有感�?criteria 比较好用�Q�在查询�Ҏ��设计上可�?a id=vad_1 onmouseover="if(typeof(showTitle)!='undefined'){this.title='';window.clearTimeout(hideTO);showTitle(event, this, 1,'');}" title="" onclick="" onmouseout="if(typeof(showTitle)!='undefined'){mouseIsOverLayer = false; mouseOverWhileLoad = false; hideTO = window.setTimeout('checkIfMouseOverLayer()',500);}" target=_blank>灉|��的根�?criteria 的特�Ҏ��方便地进行查询条件的�l�装。所以现在对 hibernate �?criteria 深入研究一下。�?hibernate reference 》及�|�上其它一些资料对 criteria 已经做了很多介绍。本文主要是�?criteria 的结构入手来�q�行分析�?
       如图 1 �?hibernate 设计�?criteriaspecification 作�ؓ criteria 的顶�U�接口，其下面提供了 criteria �?detachedcriteria �?

criteria �?detachedcriteria 的主要区别在于创建的形式不一��P�� criteria �?a id=vad_8 onmouseover="if(typeof(showTitle)!='undefined'){this.title='';window.clearTimeout(hideTO);showTitle(event, this, 8,'');}" title="光于华夏2 @Vogate.com" onclick="" onmouseout="if(typeof(showTitle)!='undefined'){mouseIsOverLayer = false; mouseOverWhileLoad = false; hideTO = window.setTimeout('checkIfMouseOverLayer()',500);}" target=_blank>在线的，所以它是由 hibernate session �q�行创徏的；�?detachedcriteria 是离�U�的�Q�创建时无需 session �Q?detachedcriteria 提供�?4 个静态方�?forclass(class) �?forentityname(name) �q�行 detachedcriteria 实例的创建�?spring 的框架提供了

gethibernatetemplate().findbycriteria(detachedcriteria) �Ҏ��可以很方便地�Ҏ��

detachedcriteria 来返回查询结果�?

如图 1 �Q?criteria �?detachedcriteria 均可使用 criterion �?projection 讄��查询条�g。可以设�|?fetchmode( 联合查询抓取的模�?) �Q�设�|�排序方式。对�?criteria �q�可以设�|?flushmodel �Q�冲�?session 的方式）�?lockmode �Q�数据库锁模式）�?

下面��对 criterion �?projection �q�行详细说明�?



�?1

       criterion �?criteria 的查询条件�?

criteria 提供�?add(criterion criterion) �Ҏ��来添加查询条件。图 2 �?criterion 的结构图�?criterion 接口的主�?a id=vad_9 onmouseover="if(typeof(showTitle)!='undefined'){this.title='';window.clearTimeout(hideTO);showTitle(event, this, 9,'');}" title="" onclick="" onmouseout="if(typeof(showTitle)!='undefined'){mouseIsOverLayer = false; mouseOverWhileLoad = false; hideTO = window.setTimeout('checkIfMouseOverLayer()',500);}" target=_blank>实现包括�Q?example �?junction �?simpleexpression 。�?junction 的实际��用是它的两个子类 conjunction �?disjunction �Q�分别是使用 and �?or 操作�W�进行来联结查询条�g集合�?

criterion 的实例可以通过 restrictions 工具�c�L��创徏�Q?restrictions 提供了大量的静态方法，�?eq �Q�等于）�?ge �Q�大于等于）�?between �{�来�Ҏ��的创�?criterion 查询条�g

�Q?simpleexpression 实例�Q�。除此之外， restrictions �q�提供了�Ҏ��来创�?conjunction �?disjunction 实例�Q�通过往该实例的 add(criteria) �Ҏ��来增加查询条件�Ş成一个查询条仉��合�?

至于 example 的创建有所不同�Q?example 本��n提供了一个静态方�?create(object entity) �Q�即�Ҏ��一个对象（实际使用中一般是映射到数据库的对象）来创建。然后可以设�|�一些过滤条�Ӟ��

example exampleuser =example.create(u)

.ignorecase() // 忽略大小�?

.enablelike(matchmode.anywhere);

// �?string �c�d��的属性，无论在那里值在那里都匹配。相当于 %value%

�?2



project 主要是让 criteria 能够�q�行报表查询�Q��ƈ可以实现分组�?project 主要�?simpleprojection �?projectionlist �?property 三个实现。其�?simpleprojection �?projectionlist 的实例化是由内徏�?projections 来完成，如提供的 avg �?count �?max �?min �?sum 可以让开发者很�Ҏ��Ҏ��个字�D�进行统计查询�?

       property 是对某个字段�q�行查询条�g的设�|�，如通过

      porperty.forname(“color”).in(new string[]{“black”,”red”,”write”}); 则可以创��Z��?project 实例。通过 criteria �?add(project) �Ҏ��加入到查询条件中厅R�?

�?3



       使用 criteria �q�行查询�Q�主要要清晰的是 hibernate 提供了那些类和方法来满��开发中查询条�g的创建和�l�装�Q�其�l�构层次如何。这样��用�v来便可得心应手�?

semovy 2007-08-08 22:28 发表评论

DetachedCriteria

semovy — Wed, 08 Aug 2007 08:28:00 GMT

　　Hibernate3支持DetachedCriteria�Q�这是一个非常有意义的特性！我们知道�Q�在常规的Web�~�程中，有大量的动态条件查询，即用户在�|�页上面自由选择某些条�g�Q�程序根据用��L��选择条�g�Q�动态生成SQL语句�Q�进行查询�?

　　针对�q�种需求，对于分层应用�E�序来说�Q�Web层需要传递一个查询的条�g列表�l�业务层对象�Q�业务层对象获得�q�个条�g列表之后�Q�然后依�ơ取出条�Ӟ��构造查询语句。这里的一个难�Ҏ��条�g列表用什么来构造？传统上��用Map�Q�但是这�U�方式缺陷很大，Map可以传递的信息非常有限�Q�只能传递name和value�Q�无法传递究竟要做怎样的条件运��，�I�竟是大于，��于�Q�like�Q�还是其它的什么，业务层对象必��ȝ��切掌握每条entry的隐含条件。因此一旦隐含条件改变，业务层对象的查询构造算法必��ȝ��应修改，但是�q�种查询条�g的改变是隐式�U�定的，而不是程序代码约束的�Q�因此非常容易出错�?

　　DetachedCriteria可以解决�q�个问题�Q�即在web层，�E�序员��用DetachedCriteria来构造查询条�Ӟ��然后��这个DetachedCriteria作�ؓ�Ҏ��调用参数传递给业务层对象。而业务层对象获得DetachedCriteria之后�Q�可以在session范围内直接构造Criteria�Q�进行查询。就此，查询语句的构造完全被搬离到web层实玎ͼ�而业务层则只负责完成持久化和查询的封装即可，与查询条件构造完全解耦，非常完美�Q�这恐怕也是以前很多企囑֜�web层代码中构造HQL语句的�h惛_��现的梦想吧！

　　�C�Z��代码片段如下�Q?

　　web层程序构造查询条�Ӟ��

　　java代码:

DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Department.class);
detachedCriteria.add(Restrictions.eq("name", "department")).createAlias("employees", "e").add(Restrictions.gt(("e.age"), new Integer(20)));

　　Department和Employee是一对多兌��Q�查询条件�ؓ�Q?

　　名称�?#8220;department”开发部门；
　　部门里面的雇员年龄大�?0岁；

　　业务层对象��用该条�g执行查询�Q?

　　java代码:

detachedCriteria.getExecutableCriteria(session).list();

　　最大的意义在于�Q�业务层代码是固定不变的�Q�所有查询条件的构造都在web层完成，业务层只负责在session内执行之。这样代码就可放之四��皆准，都无��M��改了�?br>
　　然而Spring和Hibernate3的DetachedCriteria有不兼容的问题，因此在Spring环境下面使用Hibernate3需要注意：

　　Spring的HibernateTemplate提供了Hibernate的完��封装，即通过匿名�c�d��现回调，来保证Session的自动资源管理和事务的管理。其中核心方法是�Q?

　　java代码:

HibernateTemplate.execute(new HibernateCallback() {
　public Object doInHibernate(Session session) throws HibernateException {
　　....
　}
}

　　回调�Ҏ��提供了session作�ؓ参数�Q�有了session�Q�就可以自由的��用Hibernate API�~�程了。��用了spring的之后，代码修改如下�Q?

　　web层代码：

　　java代码:

DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Department.class);
detachedCriteria.createAlias("employees", "e").add(Restrictions.eq("name", "department")).add(Restrictions.gt(("e.age"), new Integer(20)));
departmentManager.findByCriteria(detachedCriteria);

　　构造detachedCriteria�Q�作为参��C��递给departmentManager

　　业务层代码��用spring�Q�DepartmentManager的findByCriteria如下�Q?

　　java代码:

public List findByCriteria(final DetachedCriteria detachedCriteria) {
　return (List) getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException {
　　　Criteria criteria = detachedCriteria.getExecutableCriteria(session);
　　　return criteria.list();
　　}
　});
}

　　实际上也��是�Q?

　　java代码:

Criteria criteria = detachedCriteria.getExecutableCriteria(session);
return criteria.list();

　　而已

　　但是该程序代码执行，会抛出强制类型�{换异常！

　　我跟�t�了一下spring和Hibernate源代码，原因如下�Q?

　　spring的HibernateTemplate的execute�Ҏ��提供的回调接口具有Session作�ؓ参数�Q�但是实际上�Q�默认情况下�Q�HibernateTemplate传递给回调接口的session�q�不是org.hibernate.impl.SessionImpl�c�，而是SessionImpl�cȝ��一个Proxy�c�R��之所以替换成��Z��个Proxy�c�，HibernateTemplate的注释说明，Proxy提供了一些额外的功能�Q�包括自动设�|�Cachable�Q�Transaction的超时时��_��Session资源的更�U�极的关闭等�{��?

　　java代码:

private boolean exposeNativeSession = false;
...

　　execute�Ҏ��内部�Q?

Session sessionToExpose = (exposeNativeSession ? session : createSessionProxy(session));

　　但是遗憾的是�Q�Hibernate的DetachedCriteria的setExecutableCriteria�Ҏ��却要求将session参数强制转�ؓSessionImpl�Q�但是spring传过来的却是一个Proxy�c�，因此��报错了�?

　　java代码:

public Criteria getExecutableCriteria(Session session) {
　impl.setSession( (SessionImpl) session ); // 要求SessionImpl�Q�Spring传递的是Proxy
　return impl;
}

　　解决�Ҏ��Q�禁止Spring的HibernateTemplate传递Proxy�c�，强制要求它传递真实的SessionImpl�c�，即给exexute�Ҏ��增加一个参敎ͼ�提供参数为true�Q�如下：

　　java代码:

public List findByCriteria(final DetachedCriteria detachedCriteria) {
　return (List) getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException {
　　　Criteria criteria = detachedCriteria.getExecutableCriteria(session);
　　　return criteria.list();
　　}
　}, true);
}

semovy 2007-08-08 16:28 发表评论

MyEclipse4.1+hibernate3.05+mySql5.0开发J2EE入门

semovy — Thu, 09 Nov 2006 09:49:00 GMT

一、在MySql5.0中徏数据库Test与Employee�?br />create database Test;
use Test;
create table employee
(
      id int(11) primary key not null ,
      name varcahr(50) not null
);
二�?br />1、在MyEclipse4.1中新建Web-Project 名�ؓmyWeb.
2、选择MyEclipse选项的Add Hibernate Capabilities,以��web应用��h��hibernate性能�Q?br />在配�|�对话框的最下面的选项应选择Copy checked Library Jars to project floder and add to build-path.
�q�样��目��添加了HibernateSessionFactory的类�Q�与及hibernate的core jar包和在classes下的hibernate.cfg.xml�?br />(1)hibernate 核心jar包应该包�?
hibernate3.jar
ehcache-1.1.jar
,antlr-2.7.5H3.jar
asm.jar
jta.jar
commons-logging-1.0.4.jar
asm-attrs.jar

(2).HibernateSessionFactory�pȝ��自动�c�M�生的�Q�不可��承的�Q�其�Ҏ��是静态的�Q�直接��用，不用实例化�?br />
package com.semovy.framework.base;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

/**
* Configures and provides access to Hibernate sessions, tied to the
* current thread of execution. Follows the Thread Local Session
* pattern, see {@link http://hibernate.org/42.html}.
*/
public class HibernateSessionFactory{

    /**
     * Location of hibernate.cfg.xml file.
     * NOTICE: Location should be on the classpath as Hibernate uses
     * #resourceAsStream style lookup for its configuration file. That
     * is place the config file in a Java package - the default location
     * is the default Java package.

     * Examples:

     * CONFIG_FILE_LOCATION = "/hibernate.conf.xml".      * CONFIG_FILE_LOCATION = "/com/foo/bar/myhiberstuff.conf.xml".
     */
    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";

    /** Holds a single instance of Session */
private static final ThreadLocal threadLocal = new ThreadLocal();

    /** The single instance of hibernate configuration */
    private static final Configuration cfg = new Configuration();

    /** The single instance of hibernate SessionFactory */
    private static org.hibernate.SessionFactory sessionFactory;

    /**
     * Returns the ThreadLocal Session instance. Lazy initialize
     * the SessionFactory if needed.
     *
     * @return Session
     * @throws HibernateException
     */
    public static Session currentSession() throws HibernateException {
        Session session = (Session) threadLocal.get();

  if (session == null || !session.isOpen()) {
   if (sessionFactory == null) {
    try {
     cfg.configure(CONFIG_FILE_LOCATION);
     sessionFactory = cfg.buildSessionFactory();
    } catch (Exception e) {
     System.err
       .println("%%%% Error Creating SessionFactory %%%%");
     e.printStackTrace();
    }
   }
   session = (sessionFactory != null) ? sessionFactory.openSession()
     : null;
   threadLocal.set(session);
  }

        return session;
    }

    /**
     * Close the single hibernate session instance.
     *
     * @throws HibernateException
     */
    public static void closeSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
        threadLocal.set(null);

        if (session != null) {
            session.close();
        }
    }

    /**
     * Default constructor.
     */
    private HibernateSession() {
    }

}
(3).自动在classes下��生hibernate.cfg.xml配置文�g

          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "

  root
  jdbc:mysql://localhost:3306/test?useUnicode=true;characterEncoding=gbk
  org.hibernate.dialect.MySQLDialect
  MySqlDB
  1234
  com.mysql.jdbc.Driver
  .

三、打开MyEclipse的DB Browser选择Employee叛_��creating hibernate mapping,讄��持久�c��\径好之后�?br />便自动��生Employee持久�c�，与同一目录下的Employee.hbm.xml两个文�g

1).
package com.semovy.business.pojo;

/**
* Employee generated by MyEclipse - Hibernate Tools
*/

public class Employee implements java.io.Serializable {

    // Fields

     /**
*
*/
private static final long serialVersionUID = 1L;
private Integer id;
     private String name;

    // Constructors

    /** default constructor */
    public Employee() {
    }

/** minimal constructor */
    public Employee(Integer id) {
        this.id = id;
    }

    /** full constructor */
    public Employee(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
    // Property accessors

    public Integer getId() {
        return this.id;
    }

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

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2).Employee.hbm.xml文�g

"











四，建立Employee持久化类的业务逻辑�Q?br />package com.semovy.business.service;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.semovy.framework.base.HibernateSession;
/**
* this class supply all type of busniss service method for Employees
* @author Semovy
* @since 2006-11-08
* @version 1.0
*/
public class EmployeeService {
Session session = null;
public EmployeeService(){}
public List findAllEmployees()
{
  List employees = new ArrayList();
  try
  {
   session = HibernateSession.currentSession();
   Transaction tx = session.beginTransaction();
   employees = session.createQuery("from Employee").list();
   tx.commit();
   return employees;
  }
  catch(Exception ex)
  {
   ex.printStackTrace();
   return null;
  }
  finally
  {
   HibernateSession.closeSession();
  }
}
}
五，建立jsp��面listEmployees.jsp来调用测试hibernate.

<%@ page language="java" import="java.util.*,
com.semovy.business.pojo.Employee,com.semovy.business.service.EmployeeService"
pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>



    My JSP 'listEmployees.jsp' starting page









    This is my JSP page.

    <%

    EmployeeService es = new EmployeeService();
    List l = es.findAllEmployees();
    if(l != null)
    {
    Iterator it = l.iterator();
    while(it.hasNext())
    {
      Employee em = (Employee)it.next();
      out.print("ID: " + em.getId() + "Name: " + em.getName()+"
");

    }
    }
    %>

六、发布应�?/p>

semovy 2006-11-09 17:49 发表评论

�Ҏ��	�?/span>�?/span>
Restrictions.eq	�{�於
Restrictions.allEq	使用Map�Q��?/span>key/value進行多個等於的比對
Restrictions.gt	大於 >
Restrictions.ge	大於�{�於 >=
Restrictions.lt	��於 <
Restrictions.le	��於�{�於 <=
Restrictions.between	��應SQL�?/span>BETWEEN子句
Restrictions.like	��應SQL�?/span>LIKE子句
Restrictions.in	��應SQL�?/span>in子句
Restrictions.and	and關係
Restrictions.or	or關係
Restrictions.sqlRestriction	SQL限定�?/span>�?/span>

亚洲色中文字幕在线播放,亚洲国产精品无码久久98,国产午夜亚洲精品不卡免下载

Open Session In View

Spring �?Hibernate 的�g�q�加载和 Dao 模式

hibernate延迟加蝲

Hibernate延迟加蝲机制[转]

spring中配�|�二�U�缓�?

criteria

16.1. 创徏一�?tt class=literal>Criteria 实例

16.2. 限制�l�果集内�?/h2>

16.3. �l�果集排�?/h2>

16.4. 兌���

16.5. 动态关联抓�?/h2>

16.6. 查询�C�Z��

16.7. 投媄(Projections)、聚合（aggregation�Q�和分组�Q�grouping�Q?/h2>

16.8. ��ȝ��(detached)查询和子查询

兌���关系映射

�W?nbsp;8 �?nbsp;兌���关系映射

8.1. 介绍

8.2. 单向兌����Q�Unidirectional associations�Q?/h2>

8.2.1. 多对一(many to one)

8.2.2. 一对一�Q�one to one�Q?/h3>

8.2.3. 一对多�Q�one to many�Q?/h3>

8.3. 使用�q�接表的单向兌����Q�Unidirectional associations with join tables�Q?/h2>

8.3.1. 一对多(one to many)

8.3.2. 多对一�Q�many to one�Q?/h3>

8.3.3. 一对一�Q�one to one�Q?/h3>

8.3.4. 多对多（many to many�Q?/h3>

8.4. 双向兌����Q�Bidirectional associations�Q?/h2>

8.4.1. 一对多�Q�one to many) / 多对一�Q�many to one�Q?/h3>

8.4.2. 一对一�Q�one to one�Q?/h3>

8.5. 使用�q�接表的双向兌����Q�Bidirectional associations with join tables�Q?/h2>

8.5.1. 一对多�Q�one to many�Q?/多对一�Q?many to one�Q?/h3>

8.5.2. 一对一�Q�one to one�Q?/h3>

8.5.3. 多对多（many to many�Q?/h3>

�W?nbsp;9 �?nbsp;�l��g�Q�Component�Q�映��?/h2>

9.1. 依赖对象�Q�Dependent objects�Q?/h2>

9.2. 在集合中出现的依赖对�?/h2>

9.3. �l��g作�ؓMap的烦引（Components as Map indices �Q?/h2>

9.4. �l��g作�ؓ联合标识�W?Components as composite identifiers)

9.5. 动态组�?�Q�Dynamic components�Q?/h2>

�W?nbsp;10 �?nbsp;�l�承映射(Inheritance Mappings)

10.1. 三种�{�略

10.1.1. 每个�c�d��层结构一张表(Table per class hierarchy)

10.1.2. 每个子类一张表(Table per subclass)

10.1.3. 每个子类一张表(Table per subclass)�Q���用��L别标�?Discriminator)

10.1.4. 混合使用“每个�c�d��层结构一张表”�?#8220;每个子类一张表”

10.1.5. 每个具体�c�M��张表(Table per concrete class)

10.1.6. Table per concrete class, using implicit polymorphism

10.1.6. Table per concrete class, using implicit polymorphism

10.1.7. 隐式多态和其他�l�承映射混合使用

10.2. 限制

Hibernate查询语言

有关Criteria

关于DetachedCriteria

Criteria Query

criteria与detachedcriteria

DetachedCriteria

MyEclipse4.1+hibernate3.05+mySql5.0开发J2EE入门

16.4. 兌��

兌��关系映射

�W?nbsp;8 �?nbsp;兌��关系映射

8.2. 单向兌��Q�Unidirectional associations�Q?/h2>

8.3. 使用�q�接表的单向兌��Q�Unidirectional associations with join tables�Q?/h2>

8.4. 双向兌��Q�Bidirectional associations�Q?/h2>

8.5. 使用�q�接表的双向兌��Q�Bidirectional associations with join tables�Q?/h2>

10.1.3. 每个子类一张表(Table per subclass)�Q��用��L别标�?Discriminator)