SSH学习-Hibernate的配置及简单使用

Hibernate是一个ORM（Object Relational Mapping）开源框架，与MyBatis一样，Hibernate也是数据库操作的一种持久层框架。其基于JDBC，不用写SQL语句，在Hibernate下数据库表和实体类会有一一对应关系，即映射关系，操作数据库只需要操作实体类即可。现在Hibernate的使用比重相比MyBatis来说小很多。现在只做一般学习了解，后面如果有必要深入学习再补充添加，接下来记录Hibernate的使用方法。

Hibernate核心API

（1）configuration

（2）sessionfactory

（3）session

（4）query

（5）transaction

核心API体现在Hibernate的工作原理中，其调用后即可以完成对数据库的操作：

Hibernate启动→创建configuration(读取xml)→sessionfactory→session→创建transaction→持久化操作→提交事务→关闭session

Hibernate启动后，会加载hibernate.cfg.xml配置文件读取配置信息创建configuration对象，使用configuration对象创建sessionfactory，然后使用sessionfactory创建session，这个session是Hibernate下的session，MyBatis下也有，有点类似。创建完session后，再使用session开启transaction，然后开始持久化操作，也就是数据库的操作，最后提交事务和关闭session。

二级缓存概念

Hibernate框架提供的缓存区域，session管理的区域称为一级缓存，sessionfactory管理的区域称为二级缓存。一级缓存是Hibernate启动时就有的，二级可以手动卸载装载，需要通过配置文件的加载。另外一级存储中的数据是常用操作数据，二级缓存中的数据不常操作。

其处理流程为：请求数据→session中查找→如果session中没有查找到继续到sessionfactory中查找→前面都没查找到就查找DB。

Hibernate的使用

（1）导包 hibernate核心包(3.6.9)，数据库驱动包，javassit.jar包(3.8.0)，另外可以导入junit包进行测试

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.boe</groupId>
  <artifactId>SSH04</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  
  <dependencies>
  
    <!-- 导入Hibernate核心包 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>3.6.9.Final</version>
    </dependency>
    <!-- 导入数据库驱动包 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>    
    <!-- 导入javassit.jar包 -->
    <dependency>
        <groupId>javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.8.0.GA</version>
    </dependency>
    <!--导入junit测试包-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <classifier>sources</classifier>
    </dependency>
    
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <classifier>javadoc</classifier>
    </dependency> 
  
  </dependencies>
  
</project>

（2）相关文件的配置，配置文件hibernate.cfg.xml和映射文件(如User.hbm.xml)，前者是管理连接数据库，后者是管理表和对象的映射关系

配置文件hibernate.cfg.xml，其中主要配置连接数据库，以及映射文件位置：

<?xml version="1.0" encoding="GBK"?>
<!-- 指定Hibernate配置文件的DTD信息 -->
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<!-- 配置主配置文件-->
<hibernate-configuration>
   <session-factory>
       <!-- 指定数据库方言，用这个可以切换连接不同的数据库 -->
       <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
       <!-- 连接数据库 -->      
       <!-- 驱动，url，用户名和密码 -->
       <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
       <property name="connection.url">jdbc:mysql://localhost:3306/ssh</property>
       <property name="connection.username">root</property>
       <property name="connection.password">密码</property>
       
       <!-- 显示Hibernate持久层操作所使用的SQL -->
       <property name="show_sql">true</property>
       <!-- 将脚本格式化后再进行输出 -->
       <property name="hibernate.format_sql">true</property>
              
       <!-- 设置Mapping映射资源文件位置 -->
       <mapping resource="User.hbm.xml"/>

   </session-factory>
</hibernate-configuration>

映射文件User.hbm.xml，也可以通过eclipse插件自动生成，下面是手动配置的结果：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">    
<!-- 配置映射文件，名字一般用实体类类名.hbm.xml -->
<hibernate-mapping>

   <!-- 创建实体类和表的映射关系 -->
   <class name="Entity.User" table="user">
      <!-- 设置主键映射 -->
      <id name="id" column="id" type="int"></id>
      <!-- 设置其他非主键映射 -->
      <property name="name" column="name" type="string"></property>
      <property name="password" column="password" type="string"></property>
   </class>

</hibernate-mapping>  

User实体类：

package Entity;

import java.io.Serializable;
/**
 * 用于映射关联的实体对象
 * @author yangchaolin
 */
public class User implements Serializable{
    
    private static final long serialVersionUID = 699190475611076064L;
    
    private int id;
    private String name;
    private String password;
        
    public User() {
        super();
    }
    public User(int id, String name, String password) {
        super();
        this.id = id;
        this.name = name;
        this.password = password;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (id != other.id)
            return false;
        return true;
    }
    
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", password=" + password + "]";
    }
        

}

（3）使用框架下的API（主要是上面提到的几种），进行数据库的操作，接下来会创建一个测试类，在其中实现对user表的查询。

package TestCase;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import Entity.Student;
import Entity.Teacher;
import Entity.User;

/**
 * 测试使用Hibernate来查询数据库
 * @author yangchaolin
 */
public class testHibernate {
    
      //测试hibernate基本使用
      @Test
      public void test() {
          //读取hibernate.cfg.xml配置文件
          Configuration cfg=new Configuration();
          cfg.configure("hibernate.cfg.xml");
          //创建sessionfactory
          SessionFactory factory=cfg.buildSessionFactory();
          //创建session
          Session session=factory.openSession();
          //创建一个事务并开启事务
          Transaction trans=session.getTransaction();
          trans.begin();
          //开始执行持久层操作
          User user=(User) session.get(User.class, 1);//1代表User的id属性值
          System.out.println(user);
          //关闭session
          session.close();
      }                
}

测试结果

控制台：

数据库中数据：

从测试结果可以看出，Hibernate会自动生成SQL，完成对数据的查询，最后控制台打印出的信息跟数据库表中一一对应。

结论

（1）Hibernate是一种ORM持久层开源框架，可以简化对数据库的操作，不用写SQL，但是需要配置hibernate.cfg.xml和类名.hbm.xml文件。

（2）Hibernate调用常用的API即可以完成对数据库的操作。

参考博文：https://www.cnblogs.com/lcycn/p/8126783.html