快速了解Hibernate的使用

Posted 2020-10-18 hhua

了解hibernate的使用

hibernate是作用于传统的mvc开发dao层的框架

在以往的开发中我们如何的编写dao的代码呢

               1.原始的jdbc操作，在dao中到操作Connection/Statement/ResultSet

               2.自定义一个持久层的框架，对上述的crud进行了封装。

 　　　　3.dbutils组件，是阿帕奇提供的一个轻量级的组件

　　　　4.Hibernate技术，是一个开放源代码的对象关系映射框架。 【hibernate最终执行的也是jdbc代码！】

了解ORM概念

在学习hibernate之前我们必须了解orm概念

O,  Object  对象

R， Realtion 关系  (关系型数据库: mysql, Oracle…)                ---------->ORM, 对象关系映射！（说白了是类和表的一种对应关系，目的是将对象保存到表中）

M，Mapping  映射

思考：

ORM, 解决什么问题？

        存储：   能否把对象的数据直接保存到数据库？

　　获取：  能否直接从数据库拿到一个对象？

　　想做到上面2点，必须要有映射！

即：我们通过映射关系，将类和表相对应，对象和表中的元组（每一条记录）相对应，类的属性和表中的字段（列）相对应，属性的类型和字段的类型相对应。

 

思考： Hibernate与ORM的关系？

            Hibernate是ORM的实现！（也就是说orm是一种思想，hibernate只不过是一种实现而已，其他的实现还有 ibatise等）

 

第一个hibernate的案例

　　首先对于一个组件/框架的学习我们一般通过以下几个步骤完成。

                       1.引入相应的jar文件

                       2.配置

                       3.api的学习    

hibernate的配置相对的比较麻烦，我们在这里只做简单的介绍，详细的配置介绍会在后边的学习中进行详细的介绍

　　搭建一个Hibernate环境，开发步骤：

　　　　1. 下载源码

        　　　　我用的版本：hibernate-distribution-3.6.0.Final  （注意不同的版本你的的配置过程可能稍微有所不同，不过大同小异）

　　　　2. 引入jar文件

         　　hibernate3.jar核心  +  required 必须引入的(6个) +  jpa 目录  + 数据库驱动包

　　3. 写对象以及对象的映射

         　　Employee.java            对象（测试对象，员工对象）

        　　 Employee.hbm.xml        对象的映射 (映射文件，注意这是命名规范我们必须这样写)

　　4. src/hibernate.cfg.xml  主配置文件

         　　-à 数据库连接配置

        　　-à 加载所用的映射(*.hbm.xml)

　　5. App.java  测试

首先我们写对象和对象的映射

employee.java

public class Employee {
    private int empId;
    private String empName;
    private Date empDate;
    public int getEmpId() {
        return empId;
    }
    public void setEmpId(int empId) {
        this.empId = empId;
    }
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }
    public Date getEmpDate() {
        return empDate;
    }
    public void setEmpDate(Date empDate) {
        this.empDate = empDate;
    }
    @Override
    public String toString() {
        return "Employee [empId=" + empId + ", empName=" + empName + ", empDate=" + empDate + "]";
    }

}

 

映射文件 Employee.hbm.xml 
这里的package表示的是映射的实体类所在的包名（有关这里的文件怎么写。后续会做详细的讲解，大家可以参考我们下载的src源码中写好的. xml文件 直接搜 *.*.xml  ）

<?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">
<hibernate-mapping package="cn.best.test">
    <!-- 指明类和表的对应关系 table：表名 name：类名 -->
    <class table="employee" name="Employee">
        <!-- 配置我们的映射关系 -->
        <!-- 主键映射关系 -->
        <id name="empId" column="id">
            <generator class="native" />
        </id>
        <!-- 配置非主键属性 -->
        <property name="empName" column="name"></property>
        <property name="empDate" column="date"></property>
    </class>
</hibernate-mapping>

这里大家会发现，我们并没有配置属性和字段类型的对应方式，如果我们不配置的话，默认是按照属性中的类型进行对应。详细我们将会后边进行讲解

接下来我么来写src中的主配置文件

src/hibernate.cfg.xml  主配置文件（我们可以仿照原码src下的\\project\\etc 文件中的该文件来写）

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <!-- session的工厂 创造session，我们与数据库之间的会话 -->
    <session-factory>
        <!-- 首先我们要对需要连接数据进行配置 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysqL:///hib_demo</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">yujiaming</property>
        <!-- 区别不同的sql语言，要告诉本数据库的方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="hibernate.show_sql">true</property>

        <!-- 加载映射文件 -->
        <mapping resource="cn/hhua/test/Employee.hbm.xml" />
    </session-factory>

</hibernate-configuration>

 

接下来我么拿来做一个测试案例：

 1 @Test
 2     public void test() {
 3         // 创建模拟数据对象
 4         Employee employee = new Employee();
 5         employee.setEmpName("faker");
 6         employee.setEmpDate(new Date());
 7         // 1.首先我们创建加载配置文件管理对象
 8         Configuration configuration = new Configuration();
 9         // 加载配置文件，默认加载src/hibernate.hbm.xml
10         configuration.configure();
11         // 2.创建session工厂对象
12         SessionFactory buildSessionFactory = configuration.buildSessionFactory();
13         // 创建session（代表一个回话，与数据库连接的会话）
14         Session session = buildSessionFactory.openSession();
15         // 开启事务
16         Transaction beginTransaction = session.beginTransaction();
17         // 执行crud
18         session.save(employee);
19         // 提交事务
20         beginTransaction.commit();
21         // 关闭session 和工厂
22         session.close();
23         buildSessionFactory.close();
24 
25     }

  注意 主键一定是非空唯一且递增。

 

 

Hibernate  Api

|-- Configuration       配置管理类对象

         1.  config.configure();    加载主配置文件的方法(hibernate.cfg.xml)

                                                     默认加载src/hibernate.cfg.xml

    public Configuration configure() throws HibernateException {
        configure( "/hibernate.cfg.xml" );
        return this;
    }

        2.config.configure(“cn/config/hibernate.cfg.xml”);   加载指定路径下指定名称的主配置文件

        3.config.buildSessionFactory();   创建session的工厂对象

 

|-- SessionFactory     session的工厂（或者说代表了这个hibernate.cfg.xml配置文件）

        1. sf.openSession();   创建一个sesison对象

        2.sf.getCurrentSession();  创建session或取出session对象（这个相对上边功能更强大）

         3.sf.close（）；关闭工厂方法

 

|--Session       session对象维护了一个连接(Connection), 代表了与数据库连接的会话。

                         是 Hibernate最重要的对象： 只要使用hibernate与数据库操作，都用到这个对象

                 1. session.beginTransaction(); 开启一个事务； hibernate要求所有的与数据库的操作必须有事务的环境，否则报错！

                 2.更新操作：

                           session.save(Object obj);  保存一个对象

　　　　　　     session.update(Object obj);  更新一个对象、注意必须是有主键的对象。

  　　　　　　   session.delete(Object obj);  删除一个对象

　　　　　　　  session.saveOrUpdate(emp);  保存或者更新的方法：

                                                           　   à没有设置主键，执行保存；

　　　　　　　　　　　　　　　　　　à有设置主键，执行更新操作;

　　　　　　　　　　　　　　　　　　à如果设置主键不存在报错！

                        举例：

//模拟天更新操作
Employee employee = new Employee();
        employee.setEmpId(1);
        employee.setEmpName("bang");
        employee.setEmpDate(new Date());
        openSession.update(employee);
        beginTransaction.commit()

 

               3.查询操作

                    主键查询：

         　　　　　　session.get(Employee.class, 1);    主键查询，返回的是一个具体的对象。

　　　　　　　　 session.load(Employee.class, 1);   主键查询 (支持懒加载)。

//模拟主键查询操作
　　　　Object object = openSession.get(Employee.class, 1);
        System.out.println(object);

 

　　　　　　HQL查询（常用）：

        　　　　　　 HQL查询与SQL查询区别：

                　　　    SQL: (结构化查询语句)查询的是表以及字段;  不区分大小写。

                               HQL: hibernate  query  language 即hibernate提供的面向对象的查询语言，查询的是对象以及对象的属性， 区分大小写。

                               方法：Query  createQuery(); .穿件hql查询语句

                                          query.list(); 返回查询到的集合

               　　　　　　     query.setParameter(int index, Obejct obj); 设置查询预处理的参数，如果知道具体的参数类型也可以用setString() .等

                                            注意：这里的index是从0开始的和我们的sql中的不同

//模拟hql查询
Query createQuery = openSession.createQuery("from Employee where empId =?");
        createQuery.setParameter(0, 1);
        List list = createQuery.list();
        System.out.println(list);
//结果为[Employee [empId=1, empName=bang, empDate=2017-12-17 00:00:00.0]]

 

                      sql查询：

                             hibernate也为我们提供的sql查询，复杂的查询，就要使用原生态的sql查询，也可以，就是本地sql查询的支持！ (缺点： 不能跨数据库平台！)

                              方法：  createSQLQuery（sql语句）；  构建sql语句

                                            setParameter（int index，Object object）; 设置参数 注意这里的index是从1开始的

//sql语句查询
SQLQuery createSQLQuery = openSession.createSQLQuery("select * from employee where id = ?");
        createSQLQuery.setParameter(0, 1);
        List list =  createSQLQuery.list();
        System.out.println(list);
//结果为[[Ljava.lang.Object;@217ed35e]

　　　　　　查询结果并没范返回的也是一个list，但是list中并没有封装一个对象，而是将对象的属性封装在一个数组中，将数组存到了list集合中

   SQLQuery createSQLQuery = openSession.createSQLQuery("select * from employee where id = ?");
        createSQLQuery.setParameter(0, 1);
        List list = createSQLQuery.list();
        Object[] arr = (Object[]) list.get(0);
        for (Object o : arr) {
            System.out.println(o);
        }
　　　　//查询结果为：1 bang 2017-12-17                        

　　　　Criteria查询：

          　　　　完全面向对象的查询。也称为QBC查询 。

        //指定查询的结果集的对象，其实也是在通过映射指明表 
        Criteria criteria = session.createCriteria(Employee.class);
        // 指明条件，注意是对象的属性，映射表的字段
        criteria.add(Restrictions.eq("empId", 1));
        // 查询全部
        List<Employee> list = criteria.list();
        System.out.println(list);
//查询结果为：[Employee [empId=1, empName=bang, empDate=2017-12-17 00:00:00.0]]

 

|-- Transaction    hibernate事务对象。

           transaction.commit(); 表示事务的提交。

 

对于hibernate的初识，我们就讲到这里。这是我的第一篇博客，很高兴您能看完，如果其中的点滴语句能给你几分帮助，这再好不过，也是给我最大的鼓励--谢谢。