Hibernate day01

本节内容：

1.hibernate概述

2.hibernate入门案例

3.hibernate配置文件

4.hibernate的api使用

一、hibernate概述

    Hibernate框架是当今主流的java持久层框架之一，由于它简单易学，灵活性强，扩展性强等特点，能够大大的简化代码量，提高工作效率，因此受到广大开发人员的喜爱。Hibernate是一个开放源代码ORM（Object Relational Mapping，对象关系映射）框架，它对JDBC进行了轻量级的对象封装，使得Java开发人员可以使用面向对象的编程思想来操作数据库

Hibernate就是一个持久层的ORM的框架

ORM：Object Relational Mapping，对象关系映射

所谓的ORM就是利用描述对象和数据库表之间的元数据，自动把java应用程序中的对象，持久化到关系型数据库的表中。通过操作java对象，就可以完成对数据库表的操作。可以把ORM理解为关系型数据与对象之间的一个纽带，开发人员只需要关注一端映射的对象即可

二、Hibernate入门案例

  1.下载Hibernate5

https://sourceforge.net/projects/hibernate/

解压后的目录

 documentation文件夹:存放hibernate的相关文档，包括参考文档的API文档

 lib文件夹：存放Hibernate编译和运行所依赖的JAR包，其中required子目录下包含了运行Hibernate5项目必须的JAR包

project文件夹：存放Hibernate各种相关的源代码

2.在数据库创建表：商品表 shop:

CREATE TABLE `shop` (
  `s_id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `s_name` varchar(20) NOT NULL COMMENT '商品名',
  `s_describe` varchar(100) DEFAULT NULL COMMENT '商品描述',
  `s_stock` int(11) NOT NULL COMMENT '库存',
  `s_price` double NOT NULL COMMENT '价格',
  PRIMARY KEY (`s_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

3.创建一个java项目

引入jar包：

hibernate的jar包

log4j支持包：日志包

需要数据库驱动jar：

4.创建实体类（持久化类）

持久化类是程序中的业务实体类，这里的持久化是指类的对象能够被持久化保存到数据库中。Hibernate使用普通java对象（Plain Old java Object）即：POJP的编程模式来进行持久化，POJO类中包含的是与数据库表相对应的各个属性，这些属性通过get与set方法类访问，对外部隐藏了内部的实现细节。

package com.hibernate.pojo;

/**
 * 商品实体类 与数据库表对应
 */
public class Shop {

//    实体类中必须有一个属性作为唯一标识的主键对应表中的主键
    private Integer s_id;

    private String s_name;

    private String s_describe;

    private Integer s_stock;

    private double s_price;

    public Integer getS_id() {
        return s_id;
    }

    public void setS_id(Integer s_id) {
        this.s_id = s_id;
    }

    public String getS_name() {
        return s_name;
    }

    public void setS_name(String s_name) {
        this.s_name = s_name;
    }

    public String getS_describe() {
        return s_describe;
    }

    public void setS_describe(String s_describe) {
        this.s_describe = s_describe;
    }

    public Integer getS_stock() {
        return s_stock;
    }

    public void setS_stock(Integer s_stock) {
        this.s_stock = s_stock;
    }

    public double getS_price() {
        return s_price;
    }

    public void setS_price(double s_price) {
        this.s_price = s_price;
    }
}

5.创建映射文件

  实体类不具备持久化的能力，而我们的Hibernate需要知道实体类与数据库那张表进行映射，以及类中的那个属性与表中的字段进行对应，这些都需要在配置文件中进行配置。

在实体类的包下创建一个名称为实体类名.hbm.xml的映射文件，在映射文件中定义实体类与表之间的映射。

映射文件没有固定位置，建议在实体类的包下创建：实体类名.hbm.xml  在配置文件中引入xml的dtd约束

<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<?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属性：类的全路径
    table属性：表名（如果类名与表名是一致的，那么table属性可以省略）
    catalog属性：数据库名称，可以省略
    -->
    <class name="com.hibernate.pojo.Shop" table="shop">
        <!--建立类中的属性与表中的主键的映射-->

        <!--id标签：用来建立类中的属性与表中的主键字段对应
          name 属性：类中的属性名
          column：表中的字段名（如果表中的字段名与类中的属性名一致，那么省略column）
          length属性：字段的长度
          type属性：类型写java数据类型，Hibernate数据类型（默认）SQL类型

        -->
        <id name="s_id" column="s_id">
            <!--主键生成策略-->
           <generator class="native"></generator>
        </id>
          <!--建立类中的普通属性与表中字段的映射-->
         <!--
         property标签：用来建立类中的普通属性与表中的字段对应
         name属性：类中的属性名
         column属性：表中字段名（如果表中的字段名与类中的属性名一致，那么省略column）
         length属性：字段的长度
         type属性：类型写java数据类型，Hibernate数据类型（默认）SQL类型
         -->
        <property name="s_describe" column="s_describe"></property>
        <property name="s_stock" column="s_stock"></property>
        <property name="s_price" column="s_price"></property>
        
    </class>


</hibernate-mapping>

6.创建hibernate的核心配置文件

Hibernate的映射配置文件反映了持久化类和数据库表的映射信息，而Hibernate的配置文件则主要用来配置数据库链接以及Hibernate运行时所需要的各个属性的值，在src目录下新建一个名称为：hibernate.cfg.xml的文件

引入约束：

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<?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-factory>
        <!--必要的配置信息：连接数据库的基本参数-->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

        <property name="hibernate.connection.url">jdbc:mysql:///hibernate</property>
        
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>

        <!--hibernate的属性-->
        <!--hibernate的方言：作用，根据配置的方言生成相应的sql语句-->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL57Dialect</property>
         <!--hibernate:显示SQL语句-->
         <property name="hibernate.show_sql">true</property>
            <!--hibernate格式化SQL语句-->
        <property name="hibernate.format_sql">true</property>

            <!--Hibernate的hbm2ddl（数据库定义语言：create drop alter...）属性-->
        <!--
        hbm2ddl.auto的取值：
          none:  不用Hibernate自动生成表
          create：每次都会创建一个新的表
          create-drop：每次都会创建一个新表，执行程序结束后删除这个表
          update:如果数据库有表，使用原来的表，如果没有表创建新表，可以更新表结构

        -->
         <property name="hibernate.hbm2ddl.auto">update</property>

         <!--hibernate加载映射-->
        <mapping resource="com/hibernate/pojo/Shop.hbm.xml"></mapping>


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

7.测试：

package com.hibernate.pojo;

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


public class HibernateTest {



    @Test
    public void test(){
        //1.加载配置文件
        Configuration configuration = new Configuration ();
        //自动在src下查找hibernate.cfg.xml文件
        configuration.configure ();
        //2.创建一个SessionFactory
        SessionFactory sessionFactory = configuration.buildSessionFactory ();

        //3.创建一个session对象  session对象类似于connection

        Session session = sessionFactory.openSession ();

        //4.开启事务
        Transaction transaction = session.beginTransaction ();
        //5.执行相关操作
         Shop shop = new Shop ();
         shop.setS_name ("面条");
         shop.setS_describe ("意大利面");
         shop.setS_stock (123);
         shop.setS_price (10.0);

         session.save (shop);



        //6.事务提交
        transaction.commit ();

        //7.释放资源
        session.close ();
        sessionFactory.close ();




    }
}

首先创建Configuration类的实例，并通过它来读取并解析配置文件hibernate.cfg.xml.然后创建SessionFactory读取解析映射文件信息，并将Configuration对象中的所有配置信息拷贝到SessionFactory内存中。接下来，打开session让SessionFactory提供链接，并开启一个事务，之后创建对象，向对象中添加数据，通过Session.save()方法完成向数据库保存数据的操作，最后提交事务，并关闭资源。

三、Hibernate配置文件

Hibernate映射配置文件

1. 映射配置文件名称与位置没有固定要求
2. 映射配置文件中，标签name属性值写实体类的属性

           （1） class标签name属性值实体全类名

           （2） id标签与property标签name属性值为实体类属性名称

       3.id标签和property标签中的column属性可以省略  不写与name属性值一样

       4. property的属性 type属性设置关于表字段的类型，自动对应类型。

Hibernate核心配置文件

1. 配置文件的名称与位置是固定的在src下 配置文件名：hibernate.cfg.xml
2. 配置3部分要求  数据库部分是必须的 hibernate部分可选 映射文件必须的
3. 配置文件标签都写在：
   

   

         标签内部

四、HibernateAPI使用

Configuration：配置对象：用来加载hibernate框架的核心配置文件

在使用Hibernate时，首先要创建Configuration实例，Configuration实例主要用于启动、加载、管理hibernate的配置文件信息。在启动hibernate的过程中，Configuration实例首先确定hibernate配置文件的位置，然后读取相关配置，最后创建一个唯一的SessionFactory实例，Configuration对象只存在于系统初始化阶段，它将SessionFactory创建完成，就完成了自己的使命

hibernate通常使用

Configuration configuration = new Configuration ().configure ();
创建实例此种方式默认会去src下读取hibernate.cfg.xml配置文件。如果不想使用默认的配置文件而是指定目录下的配置文件需要向configure ()方法中传递一个文件路径参数


SessionFactory：Session工厂对象
SessionFactory接口负责Hibernate的初始化和建立Session对象，它在hibernate中起到一个缓冲区作用，Hibernate可以将自动生成的SQL语句、映射数据以及某些可以重复利用的数据放在这个
缓冲区中。同时它还保存了对数据库配置的所有映射关系，维护了当前的二级缓存
SessionFactory实例通过Configuration 对象来获取

SessionFactory sessionFactory = configuration.buildSessionFactory ();

SessionFactory的特点：
它是线程安全的，它的同一个实例对象可以供多个线程共享
它是重量级的，不能随便创建于销毁
由于SessionFactory的这些特点：一般情况下，一个项目中只需要一个SessionFactory，只有当应用中存在多个数据源时才为每一个数据源建立一个SessionFactory实例

Session：

Session是应用程序与数据库之间交互操作的一个单线程对象，是Hibernate运作中心，它的主要功能是为持久化对象提供创建、读取、和删除的能力，所以持久化对象必须在Session的管理下才可以进行持久化操作。

  创建SessionFactory实例后，乐意通过他获取Session实例，获取Session实例有2种方式：

  Session session = sessionFactory.openSession ();

 Session session = sessionFactory.getCurrentSession ();

以上2中获取session实例方式的主要区别是：采用openSession方法获取session实例时，SessionFactory直接创建一个新的Session实例，并且在使用完后需要调用

close方法进行手动关闭，而getCurrentSession方法创建的Session实例会被绑定到当前线程中，它在提交或者回滚的时候会自动关闭。

Session是线程不安全的，并发多个线程同时操作一个Session实例时，就可能导致Session数据存取的混乱（方法内部定义和使用session时，不会出现线程问题）。所以在设计软件结构时，应避免多个线程共享一个Session实例。

session中提供了大量常用方法：

save、update、saveOrUpdate方法：用于增加和修改对象

delete：用户删除对象

get和load：根据主键查询

createQuery 和createSQLQuery用户操作数据库对象

CreateCriteria：条件查询。

Transaction：

Transaction接口主要用于管理事务，他是hibernate的数据库事务接口，且对底层事务接口进行了封装。Transaction接口的事务对象是通过Session对象开启的

Transaction transaction = session.beginTransaction ();
在Transaction中提供了事务管理的常用方法：
commit  提交事务
rollback 回滚事务
Session执行完数据库操作后，要使用Transaction接口的commit方法进行事务提交，才能将数据操作同步到数据库，发生异常时需要rollback方法进行事务回滚，以避免数据发生错误，
因此在持久化操作后，必须调用Transaction接口的commit或者rollback如果没有开启事务，那么每个Session操作，都相当于一个独立操作。