BlogJava-笑着生活-随笔分类-Hibernate

林信良：Hibernate之多对多

999 — Mon, 13 Oct 2008 14:21:00 GMT

在资料库表格上要进行多对多对应，可以藉由一个中介表格来完成，也就是藉由多对一、一对多来完成多对多关联。

多对多由于使用了中介表格，在查询效率不彰，且在程式的物件模式上，多对多会使得物件与物件之间彼此依赖，并不是一个很好的设计方式，在设计上应避免使用多对多关系。

如果一定要使用多对多关系的话，在表格上先如下建立：

    create table server (
        id integer not null auto_increment,
        address varchar(255),
        primary key (id)
    )

    create table user (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )

    create table user_server (
        user_id integer not null,
        server_id integer not null,
        primary key (user_id, server_id)
    )

先设计User类别如下：

User.java

package onlyfun.caterpillar;

import java.util.Set;

public class User {
    private Integer id;
    private String name;
private Set servers;

    public User() {}

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Set getServers() {
        return servers;
    }

    public void setServers(Set servers) {
        this.servers = servers;
    }
}

再来设计Server类别如下：

Server.java

package onlyfun.caterpillar;

import java.util.Set;

public class Server {
    private Integer id;
    private String address;
private Set users;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Integer getId() {
        return id;
    }

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

    public Set getUsers() {
        return users;
    }

    public void setUsers(Set users) {
        this.users = users;
    }
}

在映射文件上，使用标签来完成映射关系：

User.hbm.xml

 
 PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 

 

     
         
             
         

         

        
             table="user_server" 
             cascade="save-update"> 

             
            
                          column="server_id"/>

注意到cascade是设定为save-update，因为在多对多的关系中，很少因为删除其中之一，而所关联的实体都要一并删除的，所以设定save- update，表示在save或update时，一并对关联的物件进行对应的save或update。

Server.hbm.xml的定义如下：

Server.hbm.xml

 
 PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 

 

     

         
             
         

         

        
             table="user_server" 
             inverse="true" 
             cascade="save-update"> 

              
             
                           column="user_id"/>

一个储存时的例子如下：

Server server1 = new Server();
server1.setAddress("PC-219");
server1.setUsers(new HashSet());

Server server2 = new Server();
server2.setAddress("PC-220");
server2.setUsers(new HashSet());

Server server3 = new Server();
server3.setAddress("PC-221");
server3.setUsers(new HashSet());

User user1 = new User();
user1.setName("caterpillar");
user1.setServers(new HashSet());

User user2 = new User();
user2.setName("momor");
user2.setServers(new HashSet());

// 多对多，互相参考
user1.getServers().add(server1);
user1.getServers().add(server2);
user1.getServers().add(server3);
server1.getUsers().add(user1);
server2.getUsers().add(user1);
server3.getUsers().add(user1);

user2.getServers().add(server1);
user2.getServers().add(server3);
server1.getUsers().add(user2);
server3.getUsers().add(user2);

Session session = HibernateUtil.getSessionFactory().openSession();
Transaction tx= session.beginTransaction();
session.save(user1);
session.save(user2);

tx.commit();
session.close();

999 2008-10-13 22:21 发表评论

林信良：Hibernate之DetchedCriteria

999 — Thu, 09 Oct 2008 13:50:00 GMT

Criteria与Session绑定，其生命周期跟随着Session结束而结束，使用Criteria时进行查询时，每次都要于执行时期动态建立物件，并加入各种查询条件，随着Session的回收，Criteria也跟着回收。

为了能够重复使用Criteria物件，在Hibernate 3中新增了org.hibernate.criterion.DetchedCriteria，您可以先建立DetchedCriteria实例，并加入各种查询条件，并于需要查询时再与Session绑定，获得一个绑定Session的Criteria物件，例如：

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

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

List users = criteria.list();

999 2008-10-09 21:50 发表评论

林信良：Hibernate之Criteria 进阶查询

999 — Thu, 09 Oct 2008 13:47:00 GMT

使用Criteria进行查询时，不仅仅能组合出SQL中where子句的功能，还可以组合出如排序、统计、分组等的查询功能。

排序

您可以使用Criteria进行查询，并使用org.hibernate.criterion.Order对结果进行排序，例如使用Oder.asc()，指定根据”age”由小到大排序（反之则使用desc()）：

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

注意在加入Order条件时，使用的是addOrder()方法，而不是add()方法，在产生SQL语句时，会使用order by与asc（desc）来进行排序指定：

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

限定查询笔数

Criteria的setMaxResults()方法可以限定查询回来的笔数，如果配合setFirstResult()设定传回查询结果第一笔资料的位置，就可以实现简单的分页，例如传回第51笔之后的50笔资料（如果有的话）：

Criteria criteria = session.createCriteria(User.class);
criteria.setFirstResult(51);
criteria.setMaxResults(50);
List users = criteria.list();

根据您所指定得资料库，Hibernate将自动产生与资料库相依的限定笔数查询子句，例如在MySQL中，将使用limit产生以下的SQL语句：

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

统计动作

您可以对查询结果进行统计动作，使用 org.hibernate.criterion.Projections的avg()、rowCount()、count()、max()、min ()、 countDistinct()等方法，再搭配Criteria的setProjection()方法加入条件设定，例如对查询结果的"age"作平均：

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

上面的程式将由Hibernate自动产生SQL的avg函数进行平均计算：

Hibernate: select avg(this_.age) as y0_ from T_USER this_

分组

还可以配合Projections的groupProperty()来对结果进行分组，例如以"age"进行分组，也就是如果资料中"age"如果有 20、20、25、30，则以下会显示20、25、30：

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

上面的程式将由Hibernate自动产生SQL的group by子句进行分组计算：

Hibernate: select this_.age as y0_ from T_USER this_ group by this_.age

如果想同时结合统计与分组功能，则可以使用org.hibernate.criterion.ProjectionList，例如下面的程式会计算每个年龄各有多少个人：

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

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

观察所产生的SQL语句，将使用group by先进行分组，再针对每个分组进行count函数的计数，

Hibernate: select this_.age as y0_, count(*) as y1_ from T_USER this_ group by this_.age

根据已知物件进行查询

设定查询条件并非一定要使用Restrictions，如果属性条件很多，使用Restrictions也不方便，如果有一个已知的物件，则可以根据这个物件作为查询的依据，看看是否有属性与之类似的物件，例如：

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

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

List users = criteria.list();

您可以透过 org.hibernate.criterion.Example的create()方法来建立Example实例，Example实作了 Criteria介面，因此可以使用add()方法加入至Criteria条件设定之中，Hibernate将自动过滤掉空属性，根据已知物件上已设定的属性，判定是否产生于where子句之中：

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

设定SQL范本

如果您了解如何撰写SQL语句，想要设定一些Hibernate产生SQL时的范本，您也可以使用Restrictions的sqlRestriction()方法，提供SQL语法范本作限定查询，例如查询name以cater开头的资料：

Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.sqlRestriction(
              "{alias}.name LIKE (?)", "cater%", Hibernate.STRING));
List users = criteria.list();

其中alias将被替换为与User类别相关的名称，而? 将被替换为cater%，也就是第二个参数所提供的值，sqlRestriction()方法第一个参数所设定的是where子句的部份，所以在SQL撰写时，不必再写where，观察所产生的SQL语句，将使用您所设定的SQL范本作为基础，来完成SQL的条件查询：

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

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

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

观察所产生的SQL语句如下：

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

999 2008-10-09 21:47 发表评论

林信良：Hibernate之Criteria 基本查询

999 — Wed, 08 Oct 2008 14:27:00 GMT

要对资料库管理系统进行操作，最基本的就是使用SQL（Standard Query Language）语句，大部份的资料库都支援标准的SQL语句，然而也有一些特定于资料库的SQL语句，应用程式配合SQL语句进行资料库查询时，若使用到特定于资料库的SQL语句，程式本身会有相依于特定资料库的问题。

使用Hibernate时，即使您不了解SQL的使用与撰写，也可以使用它所提供的API来进行SQL语句查询， org.hibernate.Criteria对SQL进行封装，您可以从Java物件的观点来组合各种查询条件，由Hibernate自动为您产生 SQL语句，而不用特别管理SQL与资料库相依的问题，就某个程度的意涵来看，这就像是在编译时期也可以得到对SQL语法的检查与验证。

以最基本的查询来说，如果您想要查询某个物件所对应的资料表中所有的内容，您可以如下进行查询：

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

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

Criteria建立后，若不给予任何的条件，预设是查询物件所对应表格之所有资料，如果您执行以上的程式片段，并于设定档中设定了了Hibernate的”show_sql”属性，则可以在主控下看到以下的SQL语句之产生：

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

org.hibernate.Criteria实际上是个条件附加的容器，如果想要设定查询条件，则要使用 org.hibernate.criterion.Restrictions的各种静态方法传回 org.hibernate.criterion.Criteria实例，传回的每个org.hibernate.criterion.Criteria 实例代表着一个条件，您要使用org.hibernate.Criteria的add()方法加入这些条件实例，例如查询” age”大于20且小于40的资料：

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

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

Restrictions的gt()方法表示大于（great than）的条件，而lt表示小于（less than）的条件，执行以上程式片段，观察所产生的SQL语句，将使用where与and子句产来完成SQL的条件查询：

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

使用add()方法加入条件时，预设是使用and来组合条件，如果要用or的方式来组合条件，则可以使用Restrictions.or()方法，例如结合age等于（eq）20或（or）age为空（isNull）的条件：

Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.or(
                   Restrictions.eq("age", new Integer(20)),
                   Restrictions.isNull("age")
               ));
List users = criteria.list();

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

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

您也可以使用Restrictions.like()方法来进行SQL中like子句的功能，例如查询”name”中名称为”just”开头的资料：

Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.like("name", "just%"));
List users = criteria.list();

观察所产生的SQL语句如下：

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

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

方法	说明
Restrictions.eq	等于
Restrictions.allEq	使用Map，使用key/value进行多个等于的比对
Restrictions.gt	大于 >
Restrictions.ge	大于等于 >=
Restrictions.lt	小于 <
Restrictions.le	小于等于 <=
Restrictions.between	对应SQL的BETWEEN子句
Restrictions.like	对应SQL的LIKE子句
Restrictions.in	对应SQL的in子句
Restrictions.and	and关系
Restrictions.or	or关系
Restrictions.sqlRestriction	SQL限定查询

999 2008-10-08 22:27 发表评论

林信良：Hibernate之实体物件生命周期

999 — Wed, 08 Oct 2008 13:32:00 GMT

Hibernate中的实体物件可以分为四种状态：Transient、 Persistent、Detached、Removed。

Transient

当您直接使用new创建出物件，例如在之前的例子中， User类别所衍生出之物件，在还没有使用save()之前都是Transient物件，这些物件还没有与资料库发生任何的关系，不对应于资料库中的任一笔资料。

Persistent

当物件与资料库中的资料有对应关系，并且与Session 实例有关联而Session 实例尚未关闭（close），则它是在Persistent状态，具体而言，如果您将Transient状态的物件使用Session的save()方法加以储存，或是使用Hibernate从资料库载入资料并封装为物件（例如使用get()、load()等查询物件的相关方法），则该物件为Persistent状态。

Persistent状态的物件对应于资料库中的一笔资料，物件的id值与资料的主键值相同，并且Session实例尚未失效，在这期间您对物件的任何状态变动，在Session实例关闭（close）或Transaction实例执行commit()之后，资料库中对应的资料也会跟着更新。

如果您将Session实例关闭（close），则Persistent状态的物件会成为Detached状态。

如果您使用Session的实例delete()方法删除资料，Persistent状态的物件由于失去了对应的资料，则它会成为Transient状态。

Detached

Detached状态的物件，其id与资料库的主键值对应，但脱离Session实例的管理，例如在使用load()方法查询到资料并封装为物件之后，将Session实例关闭，则物件由Persistent状态变为Detached状态，Detached状态的物件之任何属性变动，不会对资料库中的资料造成任何的影响。

Detached状态的物件可以使用update()方法使之与资料库中的对应资料再度发生关联，此时Detached状态的物件会变为 Persistent状态。

Detached物件，若不再被任何名称参考，则在适当的时候将被垃圾收集所回收。

Removed

如果您使用Session的实例delete()或remove()方法删除资料，Persistent状态的物件由于失去了对应的资料，则它会成为Removed状态，一个成为Removed状态的物件不应该被继续重用，您应该释放任何参考至它的名称，让该物件在适当的时候被垃圾回收。

简单的说，Transient与Detached状态的物件未受Hibernate持久层管理员管理，对这两个状态的物件作任何属性变动，不会对资料库中的资料有任何的影响，Detached状态物件可以读取数据库数据。而Persistent状态的物件受Hibernate持久层管理，对物件的属性变动，在Session实例关闭（close）或 Transaction实例执行commit()之后，资料库中对应的资料也会跟着更新。

Transient与Detached状态的物件是非管理状态，而Persistent状态的物件是管理状态，又称为Persistent Object，其与一个Persistence Context 关联。

在物件为Persistent时，如果物件的属性发生变化，并且尚未提交之前，物件所携带的资料称之为Dirty Data，Hibernate会在Persistence Context维护物件的最近读取版本，并在资料提交时检查两个版本的属性是否有变化，如果有的话，则将资料库中的资料进行更新。

999 2008-10-08 21:32 发表评论

Session管理类

999 — Tue, 07 Oct 2008 13:50:00 GMT

public class HibernateUtils {

private static SessionFactory factory;

private HibernateUtils() {}

static {
  Configuration cfg = new Configuration().configure();
  factory = cfg.buildSessionFactory();
}

public static SessionFactory getSessionFactory() {
  return factory;
}

public static Session getSession() {
  return factory.openSession();
}

public static void closeSession(Session session) {
  if (session != null) {
   if (session.isOpen()) {
    session.close();
   }
  }
}

}

999 2008-10-07 21:50 发表评论

林信良：Hibernate之session

999 — Tue, 07 Oct 2008 13:40:00 GMT

Hibernate在对资料库进行操作之前，必须先取得Session实例，相当于JDBC在对资料库操作之前，必须先取得Connection实例， Session是Hibernate操作的基础，它不是设计为执行绪安全（Thread-safe），一个Session由一个执行绪来使用。

开启Session

Session实例由SessionFactory开启获得，例如：

Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
....
tx.commit();
session.close();

开启Session不会马上取得Connection，而是在最后真正需要连接资料库进行更新或查询时才会取得Connection，如果有设定Connection pool，则从Connection pool中取得Connection，而关闭Session时，如果有设定Connection pool，则是将Connection归还给Connection pool，而不是直接关闭Connection。

在Hibernate中，开启一个Session会建立一个Persistence context，它可以进行快取管理、dirty check等，而所有的读取、更新、插入等动作，则是在Transaction中完成。

储存资料

透过Session，可以对资料库进行新增、删除、更新，例如使用save()新增一笔资料：

User user = new User();
user.setName("momor");
user.setAge(new Integer(26));

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
session.save(user);
tx.commit();
session.close();

save()之后，不会马上对资料库进行更新，而是在Transaction的commit()之后才会对资料库进行更新，在Transaction之间的操作要就全部成功，要就全部失败，如果更新失败，则在资料库层面会撤消所有更新操作，然而记忆体中的持久物件是不会回复原有状态的，事实上，当 Transaction失败，这一次的Session就要马上跟着失效，放弃所有记忆体中的物件，而不是尝试以原物件再进行更新的动作。

取得资料

您使用get()或load()方法取得id为1的资料：

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

User user = (User) session.get(User.class, new Integer(1));
tx.commit();
session.close();

如果未能发现相符合的资料，则get()方法会返回null，而load()方法会丢出ObjectNotFoundException，在进阶的应用中，load()方法可以返回代理（proxy）物件，在必要时才真正查询资料库取得对应资料，并可充分利用快取机制。

在Hibernate 3中，取消了find()方法，您必须透过Query或Criteria来进行资料查询。

删除资料

接下来看看使用Session删除资料，可使用delete()删除资料：

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
User user = (User) session.get(User.class, new Integer(1));
session.delete(user);
tx.commit();
session.close();

更新资料

当您在同一个Session中取出资料并封装为Persistence Object，接着更新物件状态，而后将Transaction commit，则物件上的状态更新将反应至资料库中，您无需额外进行任何的更新操作。

如果您开启了一个Session，从资料表中取出资料显示到使用者介面上，之后关闭Session，当使用者在介面上操作完毕并按下储存时，这时您要重新开启一个Session，使用update()方法将物件中的资料更新至对应的资料表中：

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
User user = (User) session.get(User.class, new Integer(2));
tx.commit();
session.close();
....
user.setAge(new Integer(27));
session = sessionFactory.openSession();
tx= session.beginTransaction();
session.update(user);
tx.commit();
session.close();

Session提供了一个saveOrUpdate()方法，为资料的储存或更新提供了一个统一的操作介面，藉由定义映射文件时，设定< id>标签的unsaved-value来决定什么是新的值必需，什么是已有的值必须更新：

unsaved-value可以设定的值包括：

any：总是储存
none：总是更新
null：id为null时储存（预设）
valid：id为null或是指定值时储存

这样设定之后，您可以使用Session的saveOrUpdate()方法来取代update()方法。

合并状态

以这边的例子来说：

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
User user1 = (User) session.get(User.class, new Integer(2));
tx.commit();
session.close();
....
user1.setAge(new Integer(27));

session = sessionFactory.openSession();
tx= session.beginTransaction();
User user2 = (User) session.get(User.class, new Integer(2)); // 同一个id
// user1 == user2 为 false
session.update(user1); // 丢出NonUniqueObjectException
tx.commit();
session.close();

在进行update()之前，您就先从资料库中取得另一笔资料，之后再尝试更新user1，由于目前的Persistence context已载入一笔资料，并有同一个id的User 实例了，同一个Persistence context不会有两个相同id的物件实例，因此丢出NonUniqueObjectException。

就这边的例子来说，您应该使用merge()而不是update()：

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
User user1 = (User) session.get(User.class, new Integer(2));
tx.commit();
session.close();
....
user1.setAge(new Integer(27));

session = sessionFactory.openSession();
tx= session.beginTransaction();
User user2 = (User) session.get(User.class, new Integer(2)); // 同一个id
User user3 = (User) session.merge(user1);
// user1 == user2 为 false
// user2 == user3 为 true
tx.commit();
session.close();

merge()会将user1与user2的状态合并，传回的物件实例就是user2原先所参考的实例。

999 2008-10-07 21:40 发表评论