国产精品一级久久久,欧美亚洲综合久久,日本在线视频一区

INFO XmlConfigurationProvider:380 - Unable to verify action class exists at initialization

junly — Thu, 27 May 2010 05:49:00 GMT

13:35:42,129 INFO EncryptLocalSessionFactoryBean:742 - Building new Hibernate SessionFactory
13:35:42,145 INFO XmlConfigurationProvider:380 - Unable to verify action class [faqAction] exists at initialization
13:35:42,254 INFO Configuration:332 - Reading mappings from file: D:\opt\ASF\Tomcat6.0\webapps\cityunion\WEB-INF\classes\com\c6\orm\model\bull\BullInfo.hbm.xml
13:35:42,442 INFO HbmBinder:322 - Mapping class: com.c6.orm.model.bull.BullInfo -> TB_BULL_INFO
13:35:42,442 INFO Configuration:332 - Reading mappings from file: D:\opt\ASF\Tomcat6.0\webapps\cityunion\WEB-INF\classes\com\c6\orm\model\coin\CardInfo.hbm.xml
13:35:42,457 INFO HbmBinder:322 - Mapping class: com.c6.orm.model.coin.CardInfo -> TB_CARD_INFO
13:35:42,473 INFO Configuration:332 - Reading mappings from file: D:\opt\ASF\Tomcat6.0\webapps\cityunion\WEB-INF\classes\com\c6\orm\model\coin\Payment.hbm.xml
13:35:42,489 INFO HbmBinder:322 - Mapping class: com.c6.orm.model.coin.Payment -> TB_PAYMENT
13:35:42,489 INFO Configuration:332 - Reading mappings from file: D:\opt\ASF\Tomcat6.0\webapps\cityunion\WEB-INF\classes\com\c6\orm\model\coin\TbBankExchangeLog.hbm.xml
。。。。。。。。。。。�?br />
描述�Q�提�C�Z��息Unable to verify action class exists at initialization
不停的加�?hbm.xml文�g�Q�导致tomcat无法启动�?br /> 被提�C�Z��息误��|��在网上找了大量资料，都没有解冟뀂原来由于自已不��心写错了配�|�文�?br />

写了两次�?br /> 出现些问题大多是因�ؓ配置文�g出错而引��L��Q�仔�l�查看最�q�修改的�|�配文�g��找到问题了

junly 2010-05-27 13:49 发表评论

由映��文件生成表

junly — Tue, 03 Nov 2009 09:57:00 GMT

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Configuration cfg=new Configuration().configure();
        SchemaExport export=new SchemaExport(cfg);
        export.create(true, true);
    }

}

junly 2009-11-03 17:57 发表评论

hibernate.cfg.xml

junly — Tue, 03 Nov 2009 09:56:00 GMT

xml version="1.0" encoding="UTF-8"?>
DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" >
<hibernate-configuration>
  <session-factory>
      <property name="connection.driver_class">com.microsoft.sqlserver.jdbc.SQLServerDriverproperty>
      <property name="connection.url">jdbc:sqlserver://localhost:1433;DatabaseName=epaiproperty>
      <property name="connection.username">saproperty>
      <property name="connection.password">accpproperty>
      <property name="hibernate.dialect">org.hibernate.dialect.SQLServerDialectproperty>
      <property name="hibernate.show_sql">trueproperty>
      <property name="hibernate.hbm2ddl.auto">updateproperty>
      <property name="hibernate.current_session_context_class">threadproperty>



      <mapping resource="org/epai/entity/Users.hbm.xml"/>
      <mapping resource="org/epai/entity/Goods.hbm.xml"/>
      <mapping resource="org/epai/entity/Bid.hbm.xml"/>
  session-factory>
hibernate-configuration>

junly 2009-11-03 17:56 发表评论

Restrictions

junly — Tue, 03 Nov 2009 09:46:00 GMT

HQL�q�算�W?/span>	QBC�q�算�W?/span>	含义
=	Restrictions.eq()	�{�于equal
<>	Restrictions.ne()	不等于not equal
>	Restrictions.gt()	大于greater than
>=	Restrictions.ge()	大于�{�于greater than or equal
<	Restrictions.lt()	��于less than
<=	Restrictions.le()	��于�{�于less than or equal
is null	Restrictions.isnull()	�{�于�I��?/span>
is not null	Restrictions.isNotNull()	非空�?/span>
like	Restrictions.like()	字符串模式匹�?/span>
and	Restrictions.and()	逻辑�?/span>
and	Restrictions.conjunction()	逻辑�?/span>
or	Restrictions.or()	逻辑�?/span>
or	Restrictions.disjunction()	逻辑�?/span>
not	Restrictions.not()	逻辑�?/span>
in(列表)	Restrictions.in()	�{�于列表中的某一个�?/span>
not in(列表)	Restrictions.not(Restrictions.in())	不等于列表中��L��一个�?/span>
between x and y	Restrictions.between()	闭区间xy中的��L��?/span>
not between x and y	Restrictions.not(Restrictions..between())	��于值X或者大于值y

//获取记录��L��
recordCount=Convert.ToInt32(criteria.SetProjection( Projections.Count(MovieUrl.__ID )) .UniqueResult(  ));

criteria.SetProjection( null );

Criteria c=session.createCriteria(Book.class);

c.add(Restrictions.like("bookname", "a",MatchMode.ANYWHERE));

c.add(Restrictions.between("bid", 1, 3));

c.add(Restrictions.not(Restrictions.in("bid", new Integer[]{1,2,4})));

c.setFirstResult(0);

c.setMaxResults(2);

List list=c.list();

Restrictions.like(“”,…,MatchMode.ANYWHERE)

AddOrder(Order.asc(“fwid”))

在oracle数据库中�Q�如果��?span style="font-size: 12pt; font-family: 宋体">Restrictions.ne("name","张三")�Q�不会包括该字段��gؓ�I�的记录

junly 2009-11-03 17:46 发表评论

DetachedCriteria

junly — Tue, 03 Nov 2009 09:41:00 GMT

org.hibernate.criterion.DetachedCriteria的用�?/p>

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

你可以��用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. 动态关联抓�?

你可以��用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?/p>

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?

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)查询和子查询

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

DetachedCriteria�c�M��你在一个session范围之外创徏一个查询，�q�且可以使用��L��?Session�?/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或�?/p>

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?

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

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

本文来自CSDN博客�Q��{载请标明出处�Q�http://blog.csdn.net/kjfcpua/archive/2009/06/21/4287248.aspx
-----------------------------------------------------------------------------------------
Hibernate一直都认�ؓ比较��?��那么媄��一下：�Q�但最�q�项目当中遇见很多问题，今天看见别�h在项目当中��用了　Hibernate3的DetachedCriteria�Q�感觉真的是太好了，于是��p��了点旉��研究了一下，希望和大家分享一下吧
　　针对�q�种需求，对于分层应用�E�序来说�Q�Web层需要传递一个查询的条�g列表�l�业务层对象�Q�业务层对象获得�q�个条�g列表之后�Q�然后依�ơ取出条�Ӟ��构造查询语句。这里的一个难�Ҏ(gu��)��条�g列表用什么来构造？传统上��用Map�Q�但是这�U�方式缺陷很大，Map可以传递的信息非常有限�Q�只能传递name�?value�Q�无法传递究竟要做怎样的条件运��，�I�竟是大于，��于�Q�like�Q�还是其它的什么，业务层对象必��ȝ��切掌握每条entry的隐含条件。因此一旦隐含条件改变，业务层对象的查询构造算法必��ȝ��应修改，但是�q�种查询条�g的改变是隐式�U�定的，而不是程序代码约束的�Q�因此非常容易出错�?/p>

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

　　�C�Z��代码片段如下�Q?/p>

　　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?/p>

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

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

　　java代码: detachedCriteria.getExecutableCriteria(session).list();
　　最大的意义在于�Q�业务层代码是固定不变的�Q�所有查询条件的构造都在web层完成，业务层只负责在session内执行之。这样代码就可放之四��皆准，都无��M��改了�?/p>

　　然而Spring和Hibernate3的DetachedCriteria有不兼容的问题，因此在Spring环境下面使用Hibernate3需要注意：

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

　　java代码:
HibernateTemplate.execute(new HibernateCallback() {
　public Object doInHibernate(Session session) throws HibernateException {
　　....
　}
}
　　回调�Ҏ(gu��)��提供了session作�ؓ参数�Q�有了session�Q�就可以自由的��用Hibernate API�~�程了。��用了spring的之后，代码修改如下�Q?/p>

　　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?/p>

　　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?/p>

　　java代码:
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
return criteria.list();
　　而已

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

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

　　spring的HibernateTemplate的execute�Ҏ(gu��)��提供的回调接口具有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�极的关闭等�{��?/p>

　　java代码:
private boolean exposeNativeSession = false;
...
　　execute�Ҏ(gu��)��内部�Q?br /> Session sessionToExpose = (exposeNativeSession ? session : createSessionProxy(session));

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

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

　　解决�Ҏ(gu��)��Q�禁止Spring的HibernateTemplate传递Proxy�c�，强制要求它传递真实的SessionImpl�c�，即给exexute�Ҏ(gu��)��增加一个参敎ͼ�提供参数为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);
}

junly 2009-11-03 17:41 发表评论

hibernate基础-HibernateTemplate

junly — Tue, 03 Nov 2009 09:20:00 GMT

1 �Q�void delete ( Object entity ) : 删除指定持久化实�?br /> public void removePerson( int personid)
{
//先加载特定的实例
Object p = getHibernateTemplate().load( Person.class , new Integer( personid));
//删除特定实例
getHibernateTemplate().delete (p);
}
2 �Q�deleteAll ( Collection entities ) : 删除集合内全部持久化�c�d��?/p>

3 �Q�find ( String queryString ) : �Ҏ(gu��)��HQL查询字符串来�q�回实例集合
Public List getPersons()
{
//�q�回Person的全部实�?br /> return getHibernateTemplate().find ( " from Person " );
}

4 �Q�findByNamedQuery ( String queryName) : �Ҏ(gu��)��命名查询�q�回实例集合

5 �Q�get ( Class entityClass , Serializable id ) : �Ҏ(gu��)��主键加蝲特定持久化类的实�?br /> public Person getPerson()
{
//�q�回特定主键对应的Person实例
return (Person)getHibernateTemplate().get (Person.class , new Integer(person id));
}
6 �Q�save ( Object entity ) : 保存新的实例

7 �Q�saveOrUpdate ( Object entity ): �Ҏ(gu��)��实例状态，选择保存或者更�?/p>

8 �Q�update ( Object entity ) : 更新实例的状态，要求entity是持久状�?/p>

9 �Q�setMaxResults ( int maxResults ) : 讄��分页的大��?/p>

HibernateTemplate�?更灵�z?的用�?�Q?br /> 更灵�zȝ��讉K��是通过以下两个�Ҏ(gu��)��完成�?
Object execute ( HibernateCallback action ) ;
List execute ( HibernateCallback action );
�q�两个方法都需要一个HibernateCallback的实例，可以在�Q何有效的hibernate数据讉K��中��用。用法灵�z�，解决了Spring��装Hibernate后灵�z�L��不��的�~�陷�?HibernateCallback 是一个接�Q�该接口只有一个方doInHibernate ( org.hibernate.Session session ), 该方法只有一个参数Session.

public class PersonDaolmpl implements PersonDao
{
// �U�有实例变量保存SessionFactory
private SessionFactory sessionFactory;
// 依赖注入必需的setter �Ҏ(gu��)��
public void setSessionFactory(SessionFactory sessionFactory)
{
this.sessionFactory = sessionFactory;
}
/**
*通过人名查找所有匹配该名的Person 实例
* @param name 匚w��的�h�?br /> * @return 匚w��该�Q命的全部Person 集合
*/
public List findPersonsByName(final String name)
//创徏HibernateTemplate实例
HibernateTemplate hibernateTemplate = new HibernateTemplate(this.sessionFactory);
//�q�回HibernateTemplate的execute 的结�?/span>
return (List) hibernateTemplate.execute (
//创徏匿名内部�c?/span>
new HibernateCallback ()
public Object doInHibernate (Session session)
throws Hibernate Exception
{
//使用条�g查询的方法返�?/span>
List result = session.createCriteria(Person.class)
.add(Restrictions.like("name", name+ " %") .list ( ) ;
return result;
} ) :
}
}

注意�Q?/span>在方法doInHibernate内可以访问到Session�Q�该session是完全绑定到当前�U�程的Session实例�Q�保证在对于复杂的持久层讉K��Ӟ��依然可以使用Hibernate的访问方式�?

junly 2009-11-03 17:20 发表评论

hibernate基础-HQL

junly — Tue, 03 Nov 2009 09:14:00 GMT

摘要: 在hql中关键字不区分大��写�Q�但是属性和�c�d��区分大不�? ��单属性查询[重要] 1 单一属性查询，�q�回�l�果集属性列�?元素�c�d��和实体类中相应的属性类型一�? List students=session.createQuery("select name from Student").list(); &nb... 阅读全文

junly 2009-11-03 17:14 发表评论

hiberante基出-�~�存

junly — Tue, 03 Nov 2009 08:49:00 GMT

一�U�缓�?br />
* 一�U�缓存是�~�存实体对象�?br /> * 如果��理一�U�缓�?br />     一�U�缓存无法取消，但可以管理clear(),evict()
* 一�U�缓存和session的生命周期一��_��一�U�缓存也叫session�U�的�~�存或事务��~�存
* 如何避免一�ơ性大量的实体数据入库��D��内存溢出
    先flush,再clear
* 如何��理一�U�缓�?br />     load,get,iterate,save都支持一�U�缓�?br /> 如果数据量特别大�Q�考虑采用jdbc实现�Q�如查jdbc也不能满��求可以考虑采用数据本��n的特定导入工�?

Student student=(Student)session.load(Student.class,1);
System.out.println("studnet.name="+student.getName());
//不会发出sql�Q�因为load使用�~�存
Student student=(Student)session.load(Student.class,1);
System.out.println("studnet.name="+student.getName());

二��~�存

* 二��~�存是缓存实体对象的�Q�普通属性不会缓�?br /> * 二��~�存是进�E��的缓�?也称为SessionFactory�U�的�~�存,可以被所有的session�׃�n
    二��~�存的生命周期和SessionFactory是一致的�Q�可以用SessionFactory��理二��~�存
* 二��~�存的配�|�和使用
    1 加入ehcache的jar�?
    2 拯��ehcache.xml文�g到src目录�?
    3 开启二�U�缓存，默认是打开的。配�|�hibernate.cfg.xml
    hibernate.cfg.xml文�g
    开启二�U�缓�?

<property name="hibernate.cache.use_second_level_cache">trueproperty>

指定�~�存产品提供�?br />

<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProviderproperty>

4 指定那些对象使用二��~�存(两种方运�?
* 在映��文件中采用标签

<class name="com.my.hibernate.User" table="t_user">
        <cache usage="read-only"/>
     <id name="id">
      <generator class="native"/>
     id>
     <property name="name"/>
     <many-to-one name="group" column="groupid" cascade="save-update"/>
    class>

* 在hibernate.cfg.xml文�g中，采用标签

<class-cache class="com.bjsxt.hibernate.Studnet" usage="read-only"/>

��理二��~�存

factory.evict(Student.class);
factory.evict(Student.class,1);

一�U�缓存和二��~�存的交互问�?br /> 1 不设�|?默认)会写入二�U�缓存，也会��d��
2 GET只读而不写入二��~�存

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

3 PUT只写入二�U�缓存页不读�?/p>

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

查询�~�存

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

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

查询�~�存的配�|�和使用
1 ��L��查询�~�存
* 配置hibernate.cfg.xml文�g

<property name="hibernate.cache.use_second_level_cache">trueproperty>

* 在程序中昑ּ��L��

query.setCacheable(true);

2 Session和查询缓存生命周期没有关�p?br /> 3 查询�~�存对query.iterate()不�v作用�Q�只用对query.list()起作�?br />

junly 2009-11-03 16:49 发表评论

junly — Tue, 03 Nov 2009 08:40:00 GMT

�(zh��n)�观�?/p>

�(zh��n)�观锁的实现�Q�通常依赖于数据库机制�Q�在整个�q�程中将数据锁定�Q�其它�Q何用户都不能��d��或修�?br /> session.load(Inventory.class, 1, LockMode.UPGRADE);

乐观�?/p>

大多数基于数据版本记录机�?version)实现�Q�一般是在数据库表中加入一个version字段
��d��数据时将版本号一同读出，之后更新数据时版本号加一�Q�如果提交数据时片本号小�?br /> 或等于数据库表中的版本号�Q�则认�ؓ数据是过期的�Q�否则给予更新�?br />

1 Inventory.java:

private int id;
private String name;
private int count;
private int version;
//version版本��L��数据库维护，我们不用��?/span>

2 Inventory.hbm.xml

<class name="Inventory" table="t_inventory2" optimistic-lock="version">
        <id name="id">
            <generator class="native"/>
        id>
        <property name="name"/>
        <property name="count"/>
        <property name="version"/>
    class>

junly 2009-11-03 16:40 发表评论

hibernate基础-Session_Flush

junly — Tue, 03 Nov 2009 08:37:00 GMT

session flush��试�Q?/p>

session flush�Ҏ(gu��)��主要做了两�g事：
1 清理�~�存
2 执行sql(不是提交事务)

session在什么情况下执行flush
1 默认在事务提交时
2 昑ּ�的调用flush
3 在执行查询前�Q�如�Q�iterate

hibernate按照save(insert),update,delete��序提交相关的操�?br /> ------------------------------------------------------------------------

  因�ؓid的主键生成策略采用的是uuid,所以调用完save后，只是��user对象�U�_��到session的管�?br />   不会发出insert语句�Q�但是id已经生成�Q�session中existsInDatebase状态�ؓfalse
  session.save(user);
  调用flush,hibernate会清理缓存，执行sql
  如果数据库的隔离�U�别为提交读�Q�那么我们可以看到flush�q�的数据
  �q�且session中existsInDatebase状态变为true
  session.flush();
  默认情况下commit操作会先执行者f(xi��)lush清理�~�存�Q�所以不用显式的调用flush
  commit后数据无法回�?br />   session.getTransaction().commit();




  如果id的主键生成策略采用的是native,调用save(user)时会发出insert语句�Q�返回由数据库生成的id,
  user对象�U�_��到session的管�?session中existsInDatebase状态�ؓtrue
-----------------------------------------------------------------



  session.save(user);
  ��user对象从session中逐出,即session的EntiryEntries属性中逐出
  session.evict(user);//清理�~�存
  无法成功提交�Q�因为hibernate在清理缓存时�Q�在session的insertions集合中取出user对象�q�行insert操作�?br />   需要更新entityEntries属性中的existsnDatabase为true,而我们采用evict已经��user从session�?br />   逐出�?所以找不到相关数据,无法更新,抛出异常
  session.getTransaction().commit();
----------------------------------------------------------------



  session.save(user);
  flush后hibernate会清理缓�?会将user对象保存到数据库�?��session中的insertions中的user
  清除,�q�且讄��session中existsInDatabase的状态�ؓtrue
  session.flush(user);
  ��user对象从session中逐出,即session的EntityEntries属性中逐出
  session.evict(user);//清理�~�存
  可以成功提交�Q�因为hibernate在清理缓存时�Q�在session的insertions集合中无法找到user对象
  所以就不会发出insert语句,也不会更新session中的existsInDatabase的状�?br />   session.getTransaction().commit();
-----------------------------------------------------------------



  session.save(user);
  ��user对象从session中逐出,即session的EntityEntries属性中逐出
  session.evict(user);//清理�~�存
  可以成功提交�Q�因为hibernate在清理缓存时�Q�在session的insertions集合中无法找到user对象
  所以就不会发出insert语句,也不会更新session中的existsInDatabase的状�?br />   session.getTransaction().commit();
-----------------------------------------------------------------



  session.save(user);
  user.setName("张三");
  session.update(user);
  User user2=new User();
  user2.setId("003");
  user2.setName("李四");
  session.getTransaction().commit();
  �l�果:
  insert into ...
  insert into ...
  update t_user ...
  hibernate按照save(insert),update,delete��序提交相关的操�?br /> -----------------------------------------------------------------



  session.save(user);
  user.setName("张三");
  session.update(user);
  因�ؓ我们在session.update(user)后执行了flush,所以在以commit清理�~�存时执行flush前的sql��׃��会发�?
  session.flush();//在这里flush操作��可以了

  User user2=new User();
  user2.setId("003");
  user2.setName("李四");
  session.getTransaction().commit();
  �l�果:
  insert into ...
  update t_user ...
  insert into ...
  按照我们惌��序save(insert),update,save(insert)的顺序提交操�?br /> -----------------------------------------------------------------

junly 2009-11-03 16:37 发表评论

hibernate基础-fetch抓取

junly — Tue, 03 Nov 2009 08:34:00 GMT

抓取�{�略(单端代理的批量抓�?
1 保持默认,也就是fetch="select"

fetch="select",另外发送一条select语句抓取当前对象兌��实体或集�?br /> 2 讄��fetch="jion"

fetch="jion",hibernate会通过select语句会��用外联接来加载其兌��实体或集�?此时lazy会失�?br /> ------------------------------------------------------------
抓取�{�略(集合代理的批量抓�?
1 保持默认,也就是fetch="select"

fetch="select",另外发送一条select语句抓取当前对象兌��实体或集�?br /> 2 讄��fetch="jion"

fetch="jion",hibernate会通过select语句会��用外联接来加载其兌��实体或集�?此时lazy会失�?br /> 3 讄��fetch="subselect"

fetch="subselect",用于createQuery()查询,另外发送一条select语句抓取在前面查询到的所有实体对象的兌��集合
----------------------------------------------------------------
抓取�{�略,batch-size�?lt;class>上的应用

batch-size属�?可能扚w��加蝲体类,参见:Classes.hbm.xml

在hibernate.cfg.xml中设�|?br /> 50

junly 2009-11-03 16:34 发表评论

hibernate基础-lazy�{�略

junly — Tue, 03 Nov 2009 08:33:00 GMT

摘要: lazy�{�略可以使用在： * 标签上，可以取��|��true/false * 标签上，可以取��|��true/false需要类增强工具 * 标签上，可以取��|��true/false/extra ... 阅读全文

junly 2009-11-03 16:33 发表评论

hibernate基础-Component+[联合]映象

junly — Tue, 03 Nov 2009 08:22:00 GMT

Component映射(值对象映��?

在hibernate�?component是某个实体的逻辑�l�成部分�Q�它与实体的�Ҏ(gu��)��区别是没有oid�Q?br /> component可以�U�Cؓ是值对象（DDD�Q?/p>

采用component映射的好处：它实��C��对象模型的细�_�度划分�Q�层�ơ会更分明，复用率会更高

<class name="User" table="t_user">
        <id name="id">
            <generator class="native"/>
        id>
        <property name="name"/>
        <component name="comtact">
            <property name="email"/>
            <property name="address"/>
            <property name="phone"/>
        component>
class>

复合�Q�联合）主键映射

通常��复合主键相关的属性，单独攑ֈ�一个类�?br /> * 此类必须实现序列化接�?br /> * 覆写hashcode和equals�Ҏ(gu��)��

<class name="com.bjsxt.hibernate.FiscalYearPeriod" table="t_fiscal_year_period">
        <composite-id name="fiscalYearPeriodPK">
            <key-property name="fiscalYear"/>
            <key-property name="fiscalPeriod"/>
        composite-id>
        <property name="beginDate"/>
        <property name="endDate"/>
        <property name="periodSts"/>
    class>

public class FiscalYearPeriodPK implements Serializable {
    //核算�q?/span>
    private int fiscalYear;
    //核算�?/span>
    private int fiscalPeriod;
    public int getFiscalYear() {
        return fiscalYear;
    }
    public void setFiscalYear(int fiscalYear) {
        this.fiscalYear = fiscalYear;
    }
    public int getFiscalPeriod() {
        return fiscalPeriod;
    }
    public void setFiscalPeriod(int fiscalPeriod) {
        this.fiscalPeriod = fiscalPeriod;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + fiscalPeriod;
        result = prime * result + fiscalYear;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final FiscalYearPeriodPK other = (FiscalYearPeriodPK) obj;
        if (fiscalPeriod != other.fiscalPeriod)
            return false;
        if (fiscalYear != other.fiscalYear)
            return false;
        return true;
    }
}

public class FiscalYearPeriod {
    private FiscalYearPeriodPK fiscalYearPeriodPK;
    //开始日�?/span>
    private Date beginDate;
    //�l�束日期
    private Date endDate;
    //状�?/span>
    private String periodSts;
}

junly 2009-11-03 16:22 发表评论

junly — Tue, 03 Nov 2009 08:19:00 GMT

1 class Node:

private int id;
private String name;
private Node parent;//交节�?/span>
private Set children;//子节�?/span>

2 Node.hbm.xml:

<class name="node" class="com.my.hibernate.Node">
        <id name="id">
                <generator class="native"/>
        id>
        <property name="name"/>
        <many-to-one name="parent" column="pid"/>
        <set name="children" lazy="false" inverse="true"  cascade="all">
                <key column="pid"/>
                <one-to-many class="com.my.hibernate.Node"/>
        set>
class>

junly 2009-11-03 16:19 发表评论

hibernate基础-其他映射

junly — Tue, 03 Nov 2009 08:17:00 GMT

set、list、array、map

Collection:
private int id;
private String name;
private Set setValue;
private List listValue;
private String[] arrayValue;
private Map mapValue;

<class name="Collection">
        <id name="id">
            <generator class="native"/>
        id>
        <property name="name"/>
        <set name="setValue" table="t_setvalue">
            <key column="setid"/>
            <element type="string" column="setvalue"/>
        set>
        <list name="listValue" table="t_listvalue">
            <key column="listid"/>
            <list-index column="listindex"/>
            <element type="string" column="listvalue"/>
        list>
        <array name="arrayValue" table="t_arrayvalue">
            <key column="arrayid"/>
            <list-index column="arrayindex"/>
            <element type="string" column="arrayvalue"/>
        array>
        <map name="mapValue" table="t_mapvalue">
            <key column="mapid"/>
            <map-key type="string" column="mapkey"/>
            <element type="string" column="mapvalue"/>
        map>
    class>

junly 2009-11-03 16:17 发表评论

hiberante基础-�l�承映射

junly — Tue, 03 Nov 2009 08:15:00 GMT

摘要: �l�承映射的三�U�策略： * 单表�l�承�Q�每��늱��l�承树��用一个表 * 具体表��承，每个子类一个表 * �c�表�l�承�Q�每个具体类一个表 ----------------------------------------------------------------- 每棵�cȝ��承树映射成一张表 1、理解如何映��? 因�ؓ�cȝ��承树肯定是对... 阅读全文

junly 2009-11-03 16:15 发表评论

hibernate基础-映射关系(一对多I多对�?.

junly — Tue, 03 Nov 2009 08:04:00 GMT

摘要: 一对多兌��映射(one-to-many) 一对多兌��映射利用了多对一兌��映射原理 * 多对一兌��映射:在多的一端加和一个外键指向一的一�?它维护的关系是多指向一�? * 一对多兌��映射:在一的一端加和一个外键指向多的一�?它维护的关系是一指向多的也就是说一对多和多对一的映��策略是一��L��,只是站的角度不同,一般都作成双项�?-------------------... 阅读全文

junly 2009-11-03 16:04 发表评论

hibernate基础-映射关系(多对一I一对一)

junly — Tue, 03 Nov 2009 07:53:00 GMT

摘要: 多对一兌��映射 many-to-one 兌��映射本质�Q? * ��关联关�p�L��到数据库，所谓的兌��关系是对象模型在内存中的一个或多个引用�? 标签会在多的一端加入一个外键，指定一的一端，�q�个外键是由中的column属性定义的�Q�如果忽略了�q�个属性那么默认的外键与实体的属性一�?<... 阅读全文

junly 2009-11-03 15:53 发表评论

junly — Tue, 03 Nov 2009 07:35:00 GMT

hibernate基本映射
实体�c?----->�?br /> 实体�cȝ��设计原则�Q?br /> * 实现一个默�?无参)的构造方�?constructor)
* 提供一个标识属�?identifier property)
* 使用非final的类
* 为持久化字段声明讉K��?accessors),即get/set�Ҏ(gu��)��
实体�c�M��的普通属�?---->表字�D?br /> 采用标签映射成数据库表，通过标签��普通属性映��成表字�D?br /> 所谓普通属性不包括自定义类、集合和数组
注意�Q�表或字�D�与sql关键字一��P��必须重名�U?br /> 标签

         schema="schemaName"                                    (1)
         catalog="catalogName"                                  (2)
         default-cascade="cascade_style"                       (3)
         default-access="field|property|ClassName"      (4)
         default-lazy="true|false"                                    (5)
         *auto-import="true|false"                                  (6)
         *package="package.name"                               (7)
/>
(6) auto-import (可�?- 默认�?true): 指定我们是否可以在查询语�a�中��用非全限定的�c�d��Q�仅限于本映��文件中的类�Q��?
(7) package (可�?: 指定一个包前缀�Q�如果在映射文档中没有指定全限定的类名， ��׃��用这个作为包名�?

<hibernate-mapping package="com.my.hibernate">
    <class name="User">
        <id name="id">
            <generator class="uuid"/>
        id>
        <property name="name"/>
        <property name="password"/>
        <property name="createTime"/>
        <property name="expireTime"/>
    class>
hibernate-mapping>

标签--�?br />         *name="ClassName"                              (1)
        *table="tableName"                             (2)
        *discriminator-value="discriminator_value"     (3)
         mutable="true|false"                          (4)
         schema="owner"                                (5)
         catalog="catalog"                             (6)
         proxy="ProxyInterface"                        (7)
        *dynamic-update="true|false"                   (8)
        *dynamic-insert="true|false"                   (9)
         select-before-update="true|false"             (10)
         polymorphism="implicit|explicit"              (11)
         where="arbitrary sql where condition"         (12)
         persister="PersisterClass"                    (13)
        *batch-size="N"                                (14)
        *optimistic-lock="none|version|dirty|all"      (15)
        *lazy="true|false"                             (16)
         entity-name="EntityName"                      (17)
         check="arbitrary sql check condition"         (18)
         rowid="rowid"                                 (19)
         subselect="SQL expression"                    (20)
        *abstract="true|false"                         (21)
         node="element-name"
/>
(1) name (可�?: 持久化类�Q�或者接口）的Java全限定名�?如果�q�个属性不存在�Q�Hibernate��假定这是一个非POJO的实体映��?
(2) table (可�?- 默认是类的非全限定名): 对应的数据库表名�?
(3) discriminator-value (可�?- 默认和类名一�?: 一个用于区分不同的子类的��|��在多态行为时使用。它可以接受的值包�?null �?not null�?
(8) dynamic-update (可�? 默认�?false): 指定用于UPDATE 的SQL��会在运行时动态生成，�q�且只更新那些改变过的字�D�c�?
(9) dynamic-insert (可�? 默认�?false): 指定用于INSERT�?SQL ��会在运行时动态生成，�q�且只包含那些非�I�值字�D�c�?
(14) batch-size (可�?默认�?) 指定一个用�?�Ҏ(gu��)��标识�W�（identifier�Q�抓取实例时使用�?batch size"�Q�批�ơ抓取数量）�?
(15) optimistic-lock�Q�乐观锁定） (可选，默认是version): 军_��乐观锁定的策略�?
(16) lazy (可�?: 通过讄��lazy="false"�Q?所有的延迟加蝲�Q�Lazy fetching�Q�功能将被全部禁用（disabled�Q��?
(21) abstract (可�?: 用于�?lt;union-subclass>的��承结�?�Q�hierarchies�Q�中标识抽象��类�?

标签 -主键
主键生成�{�略�Q?br /> uuid native 和assigned
        *name="propertyName"                                          (1)
        type="typename"                                              (2)
        *column="column_name"                                         (3)
        unsaved-value="null|any|none|undefined|id_value"             (4)
        access="field|property|ClassName"                            (5)
        node="element-name|@attribute-name|element/@attribute|.">
        *length                                                       (6)

(1) name (可�?: 标识属性的名字�?
(2) type (可�?: 标识Hibernate�c�d��的名字�?
(3) column (可�?- 默认为属性名): 主键字段的名字�?
(4) unsaved-value (可�?- 默认��Z��个切合实际（sensible�Q�的�?: 一个特定的标识属性��|��用来标志该实例是刚刚创徏的，��未保存�?�q�可以把�q�种实例和从以前的session中装载过�Q�可能又做过修改--译者注�Q?但未再次持久化的实例区分开来�?
(5) access (可�?- 默认为property): Hibernate用来讉K��属性值的�{�略�?
(6) 长度.

生成唯一的标�?br />

identity
对DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的内�|�标识字�D�|��供支持�?�q�回的标识符是long, short 或者int�c�d��的�?
sequence
在DB2,PostgreSQL, Oracle, SAP DB, McKoi中��用序列（sequence)�Q?而在Interbase中��用生成器(generator)。返回的标识�W�是long, short或�?int�c�d��的�?
uuid
用一�?28-bit的UUID��法生成字符串类型的标识�W�， �q�在一个网�l�中是唯一的（使用了IP地址�Q�。UUID被编码�ؓ一�?2�?6�q�制数字的字�W�串�?
native
�Ҏ(gu��)��底层数据库的能力选择identity, sequence 或者hilo中的一个�?
assigned
让应用程序在save()之前为对象分配一个标�C�符。这�?元素没有指定时的默认生成�{�略�?
foreign
使用另外一个相兌��的对象的标识�W�。通常�?lt;one-to-one>联合��h��使用�?

生成字段
        *name="propertyName"                                          (1)
        *column="column_name"                                         (2)
        type="typename"                                              (3)
        update="true|false"                                          (4)
        insert="true|false"                                          (4)
        formula="arbitrary SQL expression"                           (5)
        access="field|property|ClassName"                            (6)
        lazy="true|false"                                            (7)
        unique="true|false"                                          (8)
        not-null="true|false"                                        (9)
        optimistic-lock="true|false"                                 (10)
        generated="never|insert|always"                              (11)
        node="element-name|@attribute-name|element/@attribute|."
        index="index_name"
        unique_key="unique_key_id"
        length="L"
        precision="P"
        scale="S"
/>
(1) name: 属性的名字,以小写字母开头�?
(2) column (可�?- 默认为属性名�?: 对应的数据库字段名�?也可以通过嵌套�?lt;column>元素指定�?nbsp;
(4) update, insert (可�?- 默认�?true) : 表明用于UPDATE �?�?INSERT 的SQL语句中是否包含这个被映射了的字段。这二者如果都讄��为false 则表明这是一�?#8220;外源性（derived�Q?#8221;的属性，它的值来源于映射到同一个（或多个）字段的某些其他属性，或者通过一个trigger(触发器）或其他程序生成�?
(7) lazy (可�?- 默认�?false): 指定指定实例变量�W�一�ơ被讉K��Ӟ��q�个属性是否�g�q�抓取（fetched lazily�Q�（需要运行时字节码增强）�?
(8) unique (可�?: 使用DDL��字段��d��唯一的约束�?同样�Q�允许它作�ؓproperty-ref引用的目标�?
(9) not-null (可�?: 使用DDL��字段��d��可否为空�Q�nullability�Q�的�U�束�?

映射文�g中一般类型中可以省略�Q�其他不�?/span>

junly 2009-11-03 15:35 发表评论

hibernate基础-初步

junly — Tue, 03 Nov 2009 07:26:00 GMT

摘要: �c�L��框架�Q�Apache OJB,JDO,Toplink,EJB(CMP)JPA,IBatis 适合查询及单个对象的�~�辑�Q�适合于对象之间有清晰的关�p�，不适用于批量修�?关系复杂的对象及特定的sql功能 �W�一个项�?1 新徏java��目 2 创徏User Library,加入如下jar * hibernate_home/hibernate3.jar * hibe... 阅读全文

junly 2009-11-03 15:26 发表评论

国产精品一级久久久,欧美亚洲综合久久,日本在线视频一区

INFO XmlConfigurationProvider:380 - Unable to verify action class exists at initialization

由映���文件生成表

hibernate.cfg.xml

Restrictions

DetachedCriteria

hibernate基础-HibernateTemplate

hibernate基础-HQL

hiberante基出-�~�存

hibernate基础-Session_Flush

hibernate基础-fetch抓取

hibernate基础-lazy�{�略

hibernate基础-Component+[联合]映象

hibernate基础-其他映射

hiberante基础-�l�承映射

hibernate基础-映射关系(一对多I多对�?.

hibernate基础-映射关系(多对一I一对一)

hibernate基础-初步

由映��文件生成表