Java Web系列：Hibernate 基础

从以下5个方面学习hibernate ORM。

（1）配置文件：hibernate.cfg.xml XML文件和hibernate.properties属性文件

（2）实体映射：1对多、多对多

（3）会话工厂与会话：SessionFactory&Session

（4）查询：SQL原生查询、HQL通用查询、Criteria条件查询

（5）事务：Transanction

Hibernate的5个核心对象Conifguration、SessionFactory、Session、Query和Transanction是必须掌握的。另外，没有类似Linq的语言集成查询。

1.配置文件：hibernate.cfg.xml XML文件和hibernate.properties属性文件

Hibernate使用Configuration表示配置信息，配置文件的信息最终会适配到Configuration对象。虽然XML文件一直被hibernate支持，但使用hibernate.properties属性文件更简洁。

HSQLDB数据库是一个常用的JAVA版的测试数据库，我们通过下面两种方式演示HSQLDB数据库的配置。其中connection.driver_class, connection.url, connection.username 和 connection.password提供了JDBC使用的数据库链接信息，dialect配置SQL方言，hbm2ddl.auto配置启用自动更新数据库模式，show_sql和format_sql配置便于我们在控制台查看输出信息，generate_statistics配置生成统计信息。

（1）XML方式配置Hibernate：

 <?xml version='1.0' encoding='utf-8'?>
 <!DOCTYPE hibernate-configuration PUBLIC
     "-//Hibernate/Hibernate Configuration DTD//EN"
     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

 <hibernate-configuration>
     <session-factory>
         <property name="hibernate.connection.driver_class">org.h2.Driver</property>
         <property name="hibernate.connection.url">jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE</property>
         <property name="hibernate.connection.username">sa</property>
         <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
         <property name="hibernate.hbm2ddl.auto">update</property>
         <property name="hibernate.show_sql">true</property>
         <property name="hibernate.format_sql">true</property>
         <property name="hibernate.generate_statistics">true</property>
     </session-factory>
 </hibernate-configuration>

（2）属性文件方式配置Hibernate：

 hibernate.connection.driver_class org.h2.Driver
 hibernate.connection.url jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE
 hibernate.connection.username sa
 hibernate.dialect org.hibernate.dialect.H2Dialect
 hibernate.hbm2ddl.auto update
 hibernate.show_sql true
 hibernate.format_sql true
 hibernate.generate_statistics true

2.实体映射：1对多、多对多

Hibernate的实体映射可以采取XML和代码注解两种， .NET中的EntityFramework的实体映射也有对应的注解（特性）方式，但提供了让实体类更加干净的代码配置方式。无论是依赖注入还是实体映射，Spring和Hibernate在这方面始终相对落后和繁琐。

各种JAVA框架的核心从来不是xml，框架的核心功能和核心对象才是最重要的。注解配置的核心注解如下：

（1）@Entity：标注类为实体。

（2）@Id和@GeneratedValue：前者标注POJO字段为主键，后者标注字段为数据库自动生成。

（3）@OneToMany和@ManyToOne：在关联字段上标注1对多和多对1。

（4）@ManyToMany：在关联字段上标注多对多，cascade参数指定级联处理规则。

（5）@Version：标注字段为乐观并发控制版本字段。

下面分别演示常见的1对多、多对多的映射配置。

（1）1对多：Category-Post

Category代码：

 @Entity
 public class Category {

     @Id
     @GeneratedValue
     private int id;

     private String Name;

     @OneToMany
     private List<Post> posts = new ArrayList<Post>();

     public int getId() {
         return id;
     }

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

     public String getName() {
         return Name;
     }

     public void setName(String name) {
         Name = name;
     }

     public List<Post> getPosts() {
         return posts;
     }

     public void setPosts(List<Post> posts) {
         this.posts = posts;
     }
 }

Post代码：

@Entity
public class Post {
    @Id
    @GeneratedValue
    private int id;

    private String Name;

    private String Text;

    @ManyToOne
    private Category category;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public String getText() {
        return Text;
    }

    public void setText(String text) {
        Text = text;
    }

    public Category getCategory() {
        return category;
    }

    public void setCategory(Category category) {
        this.category = category;
    }
}

（2）多对多+乐观锁：User-Role

User代码：

 @Entity
 public class User {
     @Id
     @GeneratedValue
     private int id;

     private String userName;

     private String password;

     @Version
     private long version;

     @ManyToMany(cascade = CascadeType.ALL)
     private List<Role> roles = new ArrayList<Role>();

     public int getId() {
         return id;
     }

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

     public String getUserName() {
         return userName;
     }

     public void setUserName(String userName) {
         this.userName = userName;
     }

     public String getPassword() {
         return password;
     }

     public void setPassword(String password) {
         this.password = password;
     }

     public long getVersion() {
         return version;
     }

     public void setVersion(long version) {
         this.version = version;
     }

     public List<Role> getRoles() {
         return roles;
     }

     public void setRoles(List<Role> roles) {
         this.roles = roles;
     }

 }

Role代码：

 @Entity
 public class Role {
     @Id
     @GeneratedValue
     private int id;

     private String roleName;

     @ManyToMany(cascade = CascadeType.ALL)
     private List<User> users = new ArrayList<User>();

     public int getId() {
         return id;
     }

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

     public String getRoleName() {
         return roleName;
     }

     public void setRoleName(String roleName) {
         this.roleName = roleName;
     }

     public List<User> getUsers() {
         return users;
     }

     public void setUsers(List<User> users) {
         this.users = users;
     }
 }

3.会话工厂与会话：SessionFactory&Session

（1）会话上下文SessionFactory

SessionFactory始终是Hibernate的核心对象.通过Configuration创建的SessionFactory是Hibernate ORM的核心对象。Hibernate 4.3.5和Hibernate 5.x可以使用一致的代码创建SessionFactory，但5.x需要引入jta（javax.transaction），否则创建失败。

     public SessionFactory sessionFactory() {

         org.hibernate.cfg.Configuration configuration = new org.hibernate.cfg.Configuration();

         configuration.addAnnotatedClass(User.class);
         configuration.addAnnotatedClass(Role.class);
         configuration.addAnnotatedClass(Category.class);
         configuration.addAnnotatedClass(Post.class);

         SessionFactory sessionFactory = configuration.buildSessionFactory(new StandardServiceRegistryBuilder().build());
         return sessionFactory;

     }

（2）会话Session

Session对象类似于EntityFramework中DbContext对象。Hibernate中通过SessionFactory获取Session，有2种方式openSession()和 getCurrentSession()。openSession方式获取单个打开的Session，需要自己写代码关闭。getCurrentSession方式则可以获取自动管理的Session对象，这是依赖CurrentSessionContext接口的实现类来支持的，可以通过配置hibernate.current_session_context_class来适配，取值"jta","thread"和"managed"分别对应三个实现类。使用getCurrentSession时虽然不需要手动管理Session的关闭，但是需要手动管理Transaction事务的开启和关闭。在Spring中继承Hibernate时，Spring提供了CurrentSessionContext的实现类SpringJtaSessionContext，避免了我们手动管理事务。在不使用Spring的Servlet环境中，我们可以选择使用Filter+getSession方式使用Session。也可以配置成"thread"+手动管理事务方式。

Filter+getSession可以直接使用click-extras程序包中的Filter和SessionContext，最好是复用并修改其源码，其中SessionContext的实现核心是使用类型为ThreadLocal<Session>的静态字段实现线程级别的Session共享。

click-extras的pom如下：

 <dependency>
     <groupId>org.apache.click</groupId>
     <artifactId>click-extras</artifactId>
     <version>2.3.0</version>
 </dependency>

使用"thread"+手动管理事务方式需要先配置hibernate.properties属性文件：hibernate.current_session_context_class thread。

     private void Test(SessionFactory factory)
     {
         factory.getCurrentSession().beginTransaction();
         Query query = factory.getCurrentSession().createSQLQuery("select * from User where userName=?").addEntity(User.class);
         User user = (User) query.uniqueResult();
         factory.getCurrentSession().getTransaction().commit();
     }

4.查询：SQL原生查询、HQL通用查询、Criteria条件查询

（1）SQL原生查询：

原生查询使用Query接口的子接口SQLQuery。通过session可以创建该接口的实例。下面的代码中hsqldb的参数化查询占位符是"?"。为了便于使用，使用了SQLQuery的addEntity方法配置查询对应的实体类型。

     private User SqlQuery() {
         Session session = SessionContext.getSession();
         Query query = session.createSQLQuery("select * from User where userName=?").addEntity(User.class);
         query.setString(0, "admin");
         return (User) query.uniqueResult();
     }

（2）HQL通用查询：

Hibernate使用Query接口，通过自定义的HQL实现通用查询，HQL提供了一个中间语言，屏蔽了不同数据库的语法差异。通过session可以创建Query接口的实例。

     private User SqlQuery() {
         Session session = SessionContext.getSession();
         Query query = session.createQuery("from User where userName=:userName");
         query.setString("userName", "admin");
         return (User) query.uniqueResult();
     }

（3）Criteria条件查询：

Hibernate通过Criteria对象提供对自动化查询的方法级别的支持，辅助类Restrictions提供了大量静态方法创建Criteria对象，最大的作用就是防止写错SQL关键字。Java中没有类似.NET中Linq一样的语言集成查询。

     private User CriteriaQuery() {
         Session session = SessionContext.getSession();
         Criteria query = session.createCriteria(User.class);
         query.add(Restrictions.eq("userName", "admin"));
         return (User) query.uniqueResult();
     }

5.事务

Transanction接口是Hibernate中封装事务的接口，支持JDBC数据库事务和JTA分布式事务，可以通过Session对象使用Transanction进行事务管理。JAT事务则与JTA容器紧密相关，以后再续。

     private void Test(SessionFactory factory) {
         factory.getCurrentSession().beginTransaction();
         Query query = factory.getCurrentSession().createSQLQuery("select * from User where userName=?")
                 .addEntity(User.class);
         User user = (User) query.uniqueResult();
         factory.getCurrentSession().getTransaction().commit();
     } 

参考

（1）http://docs.jboss.org/hibernate/orm/5.0/quickstart/html/

（2）https://www.ibm.com/developerworks/cn/java/j-lo-jta/

（3）https://www.ibm.com/developerworks/cn/java/j-lo-hibernate3/