摘要: 1111-1234 re \d{5}(-\d{4})? ?指前面的子项可有可无 11111 re (\d)\1{4} 1221 re (\d)(\d)\2\1 RegExp对象 创建方式: 1 使用RegExp对象显式构造函数new RegExp("pattern"[,"flags"]) 2 使用RegExp对象隐式构造函数/pattern/[flags] flags参数 g 用...  阅读全文

 大清早struts2的配置文件报错The content of element type "package" must match "(result-types?,interceptors?,default-interceptor-ref?,default-action

意思是我在配置文件中：
result-types
interceptors
default-interceptor-ref
default-action-ref
default-class-ref
global-results
global-exception-mappings
action*(就是所有的action放到最后)
的顺序有问题，仔细检查了一遍也没发现有什么错误，想想是不是action里面的顺序有问题，（action里面的顺序是可以任意放的）最终刷新了一下页
面好了，是IDE在作怪吧，记录一下，以防下次再遇到。  

HQL运算符	QBC运算符	含义
=	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()	等于空值
is not null	Restrictions.isNotNull()	非空值
like	Restrictions.like()	字符串模式匹配
and	Restrictions.and()	逻辑与
and	Restrictions.conjunction()	逻辑与
or	Restrictions.or()	逻辑或
or	Restrictions.disjunction()	逻辑或
not	Restrictions.not()	逻辑非
in(列表)	Restrictions.in()	等于列表中的某一个值
not in(列表)	Restrictions.not(Restrictions.in())	不等于列表中任意一个值
between x and y	Restrictions.between()	闭区间xy中的任意值
not between x and y	Restrictions.not(Restrictions..between())	小于值X或者大于值y

在oracle数据库中，如果使用Restrictions.ne("name","张三")，不会包括该字段值为空的记录 junit简介：
 * 创建test目录与src同级，同时建立相同的包目录
 * 编写测试类xxxTest,需要继承TestCase
 * 编写单元测试方法，测试方法必须以test开头，测试方法不能含有参数和返回值，如：
   public void testHello(){}
 * 最好单元测试的代码单独建立一个目录
 * 断言
   this.assertEquals("消息",2,hello.add(1,1));
 * protected void setUp() throws exception{}//相当于init方法，可以自动调用 jdbc:mysql://127.0.0.1:3306/test_hibernate2?useUnicode=true&characterEncoding=UTF-8

org.hibernate.criterion.DetachedCriteria的用法

一 Hibernate 设计了 CriteriaSpecification 作为 Criteria 的父接口，下面提供了 Criteria和DetachedCriteria 。
   1 Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样， Criteria 是在线的，所
以它是由 Hibernate Session 进行创建的；而 DetachedCriteria 是离线的，创建时无需Session，DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name)
进行DetachedCriteria 实例的创建。 Spring 的框架提供了getHibernateTemplate().findByCriteria(detachedCriteria) 方法可以很方便地根据DetachedCriteria 来返回查询结果。
   2 Criteria 和 DetachedCriteria 均可使用 Criterion 和 Projection 设置查询条件。可以设
置 FetchMode( 联合查询抓取的模式 ) ，设置排序方式。对于 Criteria 还可以设置 FlushModel
（冲刷 Session 的方式）和 LockMode （数据库锁模式）。
二 下面对 Criterion 和 Projection 进行详细说明：
   1 Criterion 是 Criteria 的查询条件。Criteria 提供了 add(Criterion criterion) 方法来
添加查询条件。
   2 Criterion 接口的主要实现包括： Example 、 Junction 和 SimpleExpression 。而
Junction 的实际使用是它的两个子类 conjunction 和 disjunction ，分别是使用 AND 和 OR 操
作符进行来联结查询条件集合。
   3 Criterion 的实例可以通过 Restrictions 工具类来创建，Restrictions 提供了大量的静态
方法，如 eq （等于）、 ge （大于等于）、 between 等来方法的创建 Criterion 查询条件
（SimpleExpression 实例）。除此之外， Restrictions 还提供了方法来创建 conjunction 和
disjunction 实例，通过往该实例的 add(Criteria) 方法来增加查询条件形成一个查询条件集合。
   4 至于 Example 的创建有所不同， Example 本身提供了一个静态方法 create(Object entity)，
即根据一个对象（实际使用中一般是映射到数据库的对象）来创建。然后可以设置一些过滤条件：
Example exampleUser =Example.create(u).ignoreCase() // 忽略大小写
                                      .enableLike(MatchMode.ANYWHERE);
           // 对 String 类型的属性，无论在那里值在那里都匹配。相当于 %value%
   5 Project 主要是让 Criteria 能够进行报表查询，并可以实现分组。 Project 主要有
SimpleProjection 、 ProjectionList 和 Property 三个实现。其中 SimpleProjection 和
ProjectionList 的实例化是由内建的 Projections 来完成，如提供的 avg 、 count 、 max 、
min 、 sum 可以让开发者很容易对某个字段进行统计查询。
   6 Property 是对某个字段进行查询条件的设置，如通过Porperty.forName(“color”).in
(new String[]{“black”,”red”,”write”}); 则可以创建一个 Project 实例。通过
criteria 的 add(Project) 方法加入到查询条件中去。
   使用 Criteria 进行查询，主要要清晰的是 Hibernate 提供了那些类和方法来满足开发中查
询条件的创建和组装，下面介绍几种用法：
   1. 创建一个Criteria 实例
   org.hibernate.Criteria接口表示特定持久类的一个查询。Session是 Criteria实例的工厂。
   Criteria crit = sess.createCriteria(Cat.class);
   crit.setMaxResults(50);
   List cats = crit.list();
 
   2. 限制结果集内容
   一个单独的查询条件是org.hibernate.criterion.Criterion 接口的一个实例。
   org.hibernate.criterion.Restrictions类 定义了获得某些内置Criterion类型的工厂方法。

   List cats = sess.createCriteria(Cat.class)
                   .add( Restrictions.like("name", "Fritz%") )
                   .add( Restrictions.between("weight", minWeight, maxWeight) )
                   .list();

   约束可以按逻辑分组。

 

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类型(Restrictions 子类), 但是尤其有用的是可以允许

你直接使用SQL。

 

List cats = sess.createCriteria(Cat.class)

    .add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%",

Hibernate.STRING) )

    .list();

 

{alias}占位符应当被替换为被查询实体的列别名。

Property实例是获得一个条件的另外一种途径。你可以通过调用Property.forName() 创建一个

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. 结果集排序

你可以使用org.hibernate.criterion.Order来为查询结果排序。

 

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()非常容易的在互相关联的实体间建立 约束。

 

List cats = sess.createCriteria(Cat.class)

    .add( Restrictions.like("name", "F%")

    .createCriteria("kittens")

        .add( Restrictions.like("name", "F%")

    .list();

 

注意第二个 createCriteria()返回一个新的 Criteria实例，该实例引用kittens 集合中的元素。

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

 

List cats = sess.createCriteria(Cat.class)

    .createAlias("kittens", "kt")

    .createAlias("mate", "mt")

    .add( Restrictions.eqProperty("kt.name", "mt.name") )

    .list();

 

(createAlias()并不创建一个新的 Criteria实例。)

Cat实例所保存的之前两次查询所返回的kittens集合是 没有被条件预过滤的。如果你希望只获得

符合条件的kittens， 你必须使用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();

 

这个查询可以通过外连接抓取mate和kittens。

 

6. 查询示例

org.hibernate.criterion.Example类允许你通过一个给定实例 构建一个条件查询。

 

Cat cat = new Cat();

cat.setSex('F');

cat.setColor(Color.BLACK);

List results = session.createCriteria(Cat.class)

    .add( Example.create(cat) )

    .list();

 

版本属性、标识符和关联被忽略。默认情况下值为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在关联对象上放置条件。

 

List results = session.createCriteria(Cat.class)

    .add( Example.create(cat) )

    .createCriteria("mate")

        .add( Example.create( cat.getMate() ) )

    .list();

 

7. 投影(Projections)、聚合（aggregation）和分组（grouping）

org.hibernate.criterion.Projections是 Projection 的实例工厂。我们通过调用

setProjection()应用投影到一个查询。

 

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" 。某些投影类型就是被定义为 分组投影，他

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

可以选择把一个别名指派给一个投影，这样可以使投影值被约束或排序所引用。下面是两种不同的

实现方式：

 

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()方法简便的将一个投影实例包装到另外一个 别名的Projection实例中。简而言之，

当你添加一个投影到一个投影列表中时 你可以为它指定一个别名：

 

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()来表示投影：

 

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层，程序员使用DetachedCriteria来构造查询条件，然后将这个DetachedCriteria作为方法调用参数传递给业务层对象。而业务层对象获得DetachedCriteria之后，可以在session范围内直接构造Criteria，进行查询。就此，查询语句的构造完全被搬离到web层实现，而业务层则只负责完成持久化和查询的封装即可，与查询条件构造完全解耦，非常完美！这恐怕也是以前很多企图在web层代码中构造HQL语句的人想实现的梦想吧！

DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来

执行它。

 

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也可以用以表示子查询。条件实例包含子查询可以通过 Subqueries或者

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

相互关联的子查询也是有可能的：

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博客，转载请标明出处：http://blog.csdn.net/kjfcpua/archive/2009/06/21/4287248.aspx
-----------------------------------------------------------------------------------------
Hibernate一直都认为比较简单 就那么影射一下：）但最近项目当中遇见很多问题，今天看见别人在项目当中使用了　Hibernate3的DetachedCriteria，感觉真的是太好了，于是就花了点时间研究了一下，希望和大家分享一下吧
　　针对这种需求，对于分层应用程序来说，Web层需要传递一个查询的条件列表给业务层对象，业务层对象获得这个条件列表之后，然后依次取出条件，构造查询语句。这里的一个难点是条件列表用什么来构造？传统上使用Map，但是这种方式缺陷很大，Map可以传递的信息非常有限，只能传递name和 value，无法传递究竟要做怎样的条件运算，究竟是大于，小于，like，还是其它的什么，业务层对象必须确切掌握每条entry的隐含条件。因此一旦隐含条件改变，业务层对象的查询构造算法必须相应修改，但是这种查询条件的改变是隐式约定的，而不是程序代码约束的，因此非常容易出错。

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

　　示例代码片段如下：

　　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是一对多关联，查询条件为：

　　名称是“department”开发部门；
　　部门里面的雇员年龄大于20岁；

　　业务层对象使用该条件执行查询：

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

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

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

　　java代码:
HibernateTemplate.execute(new HibernateCallback() {
　public Object doInHibernate(Session session) throws HibernateException {
　　....
　}
}
　　回调方法提供了session作为参数，有了session，就可以自由的使用Hibernate API编程了。使用了spring的之后，代码修改如下：

　　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，作为参数传递给departmentManager

　　业务层代码使用spring，DepartmentManager的findByCriteria如下：

　　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();
　　}
　});
}
　　实际上也就是：

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

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

　　我跟踪了一下spring和Hibernate源代码，原因如下：

　　spring的HibernateTemplate的execute方法提供的回调接口具有Session作为参数，但是实际上，默认情况下， HibernateTemplate传递给回调接口的session并不是org.hibernate.impl.SessionImpl类，而是 SessionImpl类的一个Proxy类。之所以替换成为一个Proxy类，HibernateTemplate的注释说明，Proxy提供了一些额外的功能，包括自动设置Cachable，Transaction的超时时间，Session资源的更积极的关闭等等。

　　java代码:
private boolean exposeNativeSession = false;
...
　　execute方法内部：
Session sessionToExpose = (exposeNativeSession ? session : createSessionProxy(session));

　　但是遗憾的是，Hibernate的DetachedCriteria的setExecutableCriteria方法却要求将session参数强制转为SessionImpl，但是spring传过来的却是一个Proxy类，因此就报错了。

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

　　解决方法，禁止Spring的HibernateTemplate传递Proxy类，强制要求它传递真实的SessionImpl类，即给exexute方法增加一个参数，提供参数为true，如下：

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

 

文章来源:http://www.cnblogs.com/ycoe/archive/2006/09/28/516810.html

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

3 ，find ( String queryString ) : 根据HQL查询字符串来返回实例集合
Public List getPersons()
{
//返回Person的全部实例
return getHibernateTemplate().find ( " from Person " );
}

4 ，findByNamedQuery ( String queryName) : 根据命名查询返回实例集合

5 ，get ( Class entityClass , Serializable id ) : 根据主键加载特定持久化类的实例
public Person getPerson()
{  
//返回特定主键对应的Person实例
return (Person)getHibernateTemplate().get (Person.class , new Integer(person id));
}
6 ，save ( Object entity ) : 保存新的实例

7 ，saveOrUpdate ( Object entity ): 根据实例状态，选择保存或者更新

8 ，update ( Object entity ) : 更新实例的状态，要求entity是持久状态

9 ，setMaxResults ( int maxResults ) : 设置分页的大小。

HibernateTemplate的 更灵活 的用法 ：
更灵活的访问是通过以下两个方法完成的:
Object execute ( HibernateCallback action ) ;
List execute ( HibernateCallback action );
这两个方法都需要一个HibernateCallback的实例，可以在任何有效的hibernate数据访问中使用。用法灵活，解决了Spring封装Hibernate后灵活性不足的缺陷。 HibernateCallback 是一个接，该接口只有一个方doInHibernate ( org.hibernate.Session session ), 该方法只有一个参数Session.
注意：在方法doInHibernate内可以访问到Session，该session是完全绑定到当前线程的Session实例，保证在对于复杂的持久层访问时，依然可以使用Hibernate的访问方式。