小白学习之Hibernate 学习总结

一、关于hibernate

1. hibernate是什么？

      Hibernate是使用在三层架构中的dao层的一个轻量级框架，与JDBC和myBatis是类似的技术，它也是基于ORM（对象关系映射:数据表中的字段和实体类中的属性一一对应）设计的，其实就是对JDBC的封装，封装之后的东西使用起来更加方便快捷。

      Hibernate是一个全自动的ORM框架，全自动代表数据表，SQL语句会自动生成，弊端在于不够灵活，效率低，而myBatis是一个半自动的ORM框架，mybatis可以自己写sql语句，相对来说比较灵活，所以国内大多数开发者更青睐于使用myBatis。

2.创始人

Gavin King，详情见百度百科

3.优缺点

1.无需编写SQL，操作面向对象，提高生产效率

2.开发对象化

3.移植性好（更换数据库时，只需更改相应配置文件）

4.透明持久化（对象无需继承框架任何类或接口）

5.轻量级框架（无侵入性）

6.测试方便

二、Hibernate实例

下面我们通过具体事例来了解hibernate的工作原理和实现步骤：

      开发工具：Intellij idea

      数据库：mysql

1. 新建项目

具体步骤如图所示：

1.新建Project（此处以创建web项目为例）

勾选Web Application + Hibernate同时勾选 ”Create default hibernate configuration and main class”（当然也可以不勾选，在项目创建好后再手动创建也是一样的）

2.点击next，填写项目名称，finish，完成后项目结构如图所示：

IDEA已经帮我们创建好了hibernate.cfg.xml文件、导入了相应的jar包，但需要注意的是mysql jdbc驱动jar包是需要自己自己手动添加的（其他的都为建项目的时候自动生成），注意jdbc版本，太高会出错，很头疼的一个问题。

下载mysql的jar包的方法可以参考：

https://www.cnblogs.com/NyanKoSenSei/p/11510438.html

2.连接数据库（以MySQL为例）

在连接数据库之前，需创建好数据库）找到Database，点击如图所示：

填写Database（数据库名）、User（用户名）、Password（当前用户密码）

点击“Test Connection”测试连接成功，点击“Apply”，点击OK
连接成功

3.自动生成xml文件和实体类

例如tudentEntity.hbm.xml，与StudentEntity代码(此段代码为根据数据库结构自动生成的)，如图所示：

1.选择Persistence

2.继续如下操作

选中如图所示的选项后，点击ok,xml和实体类就自动生成了，如图所示：

3.1  StudentEntity.hbm.xml代码：

<?xml version=‘1.0‘ encoding=‘utf-8‘?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="com.example.StudentEntity" table="student" schema="test">
        <id name="sid" column="sid"/>
        <property name="name" column="name"/>
        <property name="birthday" column="birthday"/>
        <property name="sex" column="sex"/>
    </class>
</hibernate-mapping>

3.2   StudentEntity代码：

package com.example;

import javax.persistence.*;
import java.util.Date;
@Entity
@Table(name = "student", schema = "test", catalog = "")
public class StudentEntity {
    private int sid;
    private String name;
    private Date birthday;
    private String sex;

    @Id
    @Column(name = "sid")
    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    @Basic
    @Column(name = "name")
    public String getName() {
        return name;
    }

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

    @Basic
    @Column(name = "birthday")
    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Basic
    @Column(name = "sex")
    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass())

        return false;
        StudentEntity that = (StudentEntity) o;
        if (sid != that.sid) return false;
        if (name != null ? !name.equals(that.name) :     that.name != null) return false;
        if (birthday != null ? !birthday.equals(that.birthday) : that.birthday!= null) return false;

        if (sex != null ? !sex.equals(that.sex) : that.sex != null) return false;
        return true;
    }

    @Override
    public int hashCode() {
        int result = sid;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + (birthday != null ? birthday.hashCode() : 0);
        result = 31 * result + (sex != null ?

        sex.hashCode(): 0);
        return result;
    }
}

4.配置 hibernate.cfg.xml

<?xml version=‘1.0‘ encoding=‘utf-8‘?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-

3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!--配置数据库通信-->
        <property name="connection.url">jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <!--配置数据库方言-->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="show_sql">true</property><!--为了让hinbernate输出执行的底层的sql语句-->
        <property name="format_sql">true</property><!--让输出的底层执行的sql语句有一定的格式-->
        <!--指定自动生成数据表的策略 -->
        <property name="hbm2ddl.auto">update</property> <!--自动创建|更新|验证数据库表结构-->
        <mapping resource="com/example/StudentEntity.hbm.xml"/><!--引入实体类配置文件-->
        <mapping class="com.example.StudentEntity"/><!--引入实体类位置-->
    </session-factory>
</hibernate-configuration>

5.测试

写测试类：StudnetTest.java 代码：

package com.example.test;

import com.example.StudentEntity;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class StudentTest {
    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;
    //插入数据
    @Test
    public void testisnert() {
        System.out.println("test....");

        //创建配置对象(读取配置文档)
        Configuration config = new  Configuration() .configure();

        //创建会话工厂对象
        sessionFactory = config.buildSessionFactory();
        //会话对象
        session = sessionFactory.openSession();
        //开启事务
        transaction = session.beginTransaction();
        StudentEntity studentEntity = new StudentEntity();
        studentEntity.setName("王五");
        try {
            Date birthday=new SimpleDateFormat("yyyy-MM-dd").parse("2000-11-11");
            studentEntity.setBirthday(birthday);
            } catch (ParseException e) {
             e.printStackTrace();
            }
        studentEntity.setSex("男");
        session.save(studentEntity);
        //提交事务
        transaction.commit();
        //关闭事务
        session.close();
        sessionFactory.close();
     }
    //更新数据
    @Test
    public void testupdate() {
        System.out.println("test....");

        //创建配置对象(读取配置文档)
        Configuration config = new Configuration().configure();
        //创建会话工厂对象
        sessionFactory = config.buildSessionFactory();
        //会话对象
        session = sessionFactory.openSession();
        //开启事务
        transaction = session.beginTransaction();
        StudentEntity studentEntity = new StudentEntity();
        studentEntity.setSid(0007);
        studentEntity.setName("李四");
        try {
            Date birthday=new SimpleDateFormat("yyyy-MM-dd").parse("2000-11-11");
            studentEntity.setBirthday(birthday);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        studentEntity.setSex("男");
        session.update(studentEntity);
        //提交事务
        transaction.commit();
        //关闭事务
        session.close();
        sessionFactory.close();
      }
    //删除数据
    @Test
    public void testdelete(){
        System.out.println("test....");

        //创建配置对象(读取配置文档)
        Configuration config = new Configuration().configure();
        //创建会话工厂对象
        sessionFactory = config.buildSessionFactory();
        //会话对象
        session = sessionFactory.openSession();
        //开启事务
        transaction = session.beginTransaction();
        StudentEntity studentEntity = session.get(StudentEntity.class, 0006);
        session.delete(studentEntity);
        //提交事务
        transaction.commit();
        //关闭事务
        session.close();
        sessionFactory.close();
    }
    //查询数据
    @Test
    public void testselect(){
        System.out.println("test....");

        //创建配置对象(读取配置文档)
        Configuration config = new Configuration().configure();
        //创建会话工厂对象
        sessionFactory = config.buildSessionFactory();
        //会话对象
        session = sessionFactory.openSession();
        //开启事务
        transaction = session.beginTransaction();
        StudentEntity studentEntity = session.get(StudentEntity.class, 0001);
        System.out.println(studentEntity.getSid()+""+studentEntity.getName()+""+studentEntity.getBirthday()+""+studentEntity.getSex());
        //提交事务
        transaction.commit();
        //关闭事务
        session.close();
        sessionFactory.close();
    }
}

控制台查询数据运行结果如图所示：

数据表内容如图所示：

至此，hibernate的实例基本结束了，下面我们来总结下知识点：

1.hibernate的开发步骤：

     1)搭建好环境

           引入hibernate最小的jar包

           准备Hibernate.cfg.xml启动配置文件

       2)写实体类(pojo)

       3)为实体类写映射文件"User.hbm.xml"

        在hibernate.cfg.xml添加映射的实体

      4)创建库表

      5)写测试类

        获得Configuration

        创建SessionFactory

        打开Session

        开启事务

        使用session操作数据

        提交事务

        关闭资源

2.hibernate的工作原理：

  1）通过Configuration config = new Configuration().configure();//读取并解析hibernate.cfg.xml配置文件

  2）由hibernate.cfg.xml中的<mapping resource="com/xx/User.hbm.xml"/>读取并解析映射信息

  3）通过SessionFactory sf = config.buildSessionFactory();//创建SessionFactory

  4）Session session = sf.openSession();//打开Sesssion

  5）Transaction tx = session.beginTransaction();//创建并启动事务Transation

  6）persistent operate操作数据，持久化操作

 7）tx.commit();//提交事务

 8）关闭Session

 9）关闭SesstionFactory

3.  Hibernate的缓存机制：

Hibernate缓存的作用：

    Hibernate是一个持久层框架，经常访问物理数据库，为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据

Hibernate缓存分类：

   Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存

Hibernate一级缓存又称为“Session的缓存”，它是内置的，意思就是说，只要你使用hibernate就必须使用session缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。在第一级缓存中，持久化类的每个实例都具有唯一的OID。

Hibernate二级缓存又称为“SessionFactory的缓存”，由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。第二级缓存是可选的，是一个可配置的插件，在默认情况下，SessionFactory不会启用这个插件。

什么样的数据适合存放到第二级缓存中？ 　　

1 很少被修改的数据 　　

2 不是很重要的数据，允许出现偶尔并发的数据 　　

3 不会被并发访问的数据 　　

4 常量数据 　　

不适合存放到第二级缓存的数据？ 　　

1 经常被修改的数据 　　

2 绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发 　　

3 与其他应用共享的数据。