Hibernate框架基本使用

时间：2017-1-16 00:36

——什么是Hibernate

    Hibernate是一个开放源代码的关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以使用对象编程思维来操作数据库。

    Hibernate可以应用在任何使用JDBC的场景，既可以在Java的客户端程序使用，也可以在Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE框架中取代CMP，完成数据持久化的重任。

    Hibernate是轻量级JavaEE应用的持久层解决方案，是一个关系数据库ORM框架：
        *   ORM（Object Relation Mapping），对象关系映射，就是通过将Java对象映射到数据库表，通过操作Java对象，就可以完成对数据表的操作。

    Hiernate提供了对关系型数据库的增删改查操作。

    流行数据库框架：
        *   JPA（Java Persistence API），JPA通过JDK5.0注解或XML描述对象 - 关系表的映射关系（只有接口规范）
        *   Hibernate最流行ORM框架，通过对象 - 关系映射配置，可以完全脱离底层SQL。
        *   MyBatis是Apache的一个开源项目iBatis，支持普通SQL查询，存储过程和高级映射的优秀持久层框架。
        *   Apache DBUtils、SpringMVC、JDBCTemplate

——为什么学习Hibernate

1、Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码

2、Hibernate是一个基于jdbc的主流持久化框架，是一个优秀的orm实现，它很大程度的简化了dao层编码工作

3、Hibernate使用java的反射机制，而不是字节码增强程序类实现透明性

4、Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系

 

——Hibernate常用版本

Hibernate3.x版本和Hibernate4.x

Hibernate并没有提供日志的实现，所有可以下载slf4j 和 log4j 开发包，整合Hibernate的日志系统到log4j 

——Hibernate的日志记录

    日志：程序开发中的一些信息。

    通常用System.out.println();打印输出。

    但是这种方式不好：
        *   如果输出内容比较多，并且项目已经开发完毕，不想使用输出，那么需要修改源代码。

    Hibernate中使用slf4j技术。
    slf4j并不是记录日志的工具，而是用于服务其它日志的系统。

    在企业中最常用的日志记录工具：log4j
    log4j才是一个具体的日志记录工具。

    Log4J的日志级别:

        *   fatal(致命的)
        *   error(普通错误)
        *   warn(警告)
        *   info(信息)
        *   debug(调试)
        *   trace(堆栈信息).
 

 

 

    Log4J的三个组件:

        记录器（Loggers）

            *   格式：记录器 = 级别, 输出源1 , 输出源2

            *   log4j.rootLogger=info, stdout

        输出源（Appenders）

            *   log4j.appender.stdout=org.apache.log4j.ConsoleAppender：控制台进行输出.

            *   log4j.appender.file=org.apache.log4j.FileAppender：向文件进行输出.

        布局（Layouts） 

            log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

            log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

    log4j配置文件：

        ### direct log messages to stdout ###

        log4j.appender.stdout=org.apache.log4j.ConsoleAppender

        log4j.appender.stdout.Target=System.err

        log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

        log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

 

        ### direct messages to file mylog.log ###

        log4j.appender.file=org.apache.log4j.FileAppender

        log4j.appender.file.File=c\:mylog.log

        log4j.appender.file.layout=org.apache.log4j.PatternLayout

        log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

 

        ### set log levels - for more verbose logging change 'info' to 'debug' ###

 

        log4j.rootLogger=info, stdout, file

    示例代码：
         public class Log4jDemo {

            private Logger logger = Logger.getLogger(this.getClass());

 

            @Test

            public void fun() {

                logger.fatal("致命错误");

                logger.error("普通错误");

                logger.warn("警告");

                logger.info("普通信息");

                logger.debug("调试信息");

                logger.trace("堆栈信息");

            }

        }

 

——Hibernate快速入门

1、下载Hibernate的开发工具
    下载地址：http://sourceforge.net/projects/hibernate/files/hibernate3/

2、Hibernate框架目录结构
    *   documentation
        存放Hibernate文档
    *   lib
        存放Hibernate开发jar包
        >   bytecode
            操作字节码的jar包
        >   jpa
            Hibernate的实现JPA规范
        >   optional
            开发Hibernate的可选jar包
        >   required
            开发Hibernate必须jar包
    *   project
        提供的测试示例工程

3、创建一个工程（Java工程）
    1）导入jar包
        *   核心jar包
            解压根目录下：hibernate3.jar
        *   解压目录下：
            lib/required/*.jar
        *   引入JPA规范
            解压目录下：lib/jpa/hibernate-jpa-2.0-api-1.0.1.Final.jar
        *   导入日志记录包：
            log4j.jar
            slf4j.jar
        *   导入数据库驱动

        antlr-2.7.6.jar：
            一个语言转换工具，Hibernate利用它实现HQL到SQL的转换。
        commons-collections-3.1.jar：
            collections Apache 的工具集,用来增强Java对集合的处理能力

        dom4j-1.6.1.jar：
            dom4j XML 解析器

        hibernate-jpa-2.0-api-1.0.1.Final.jar：
            JPA 接口开发包

        javassist-3.12.0.GA.jar：
            代码生成工具, Hibernate用它在运行时扩展 Java类

        jta-1.1.jar：
            标准的 JAVA 事务（跨数据库）处理接口

        slf4j-api-1.6.1.jar：
            hibernate使用的一个日志系统

4、创建表（关系型数据库）
    create database hibernate3_day01;

 

    use hibernate3_day01;

 

    create table customer(

        id int primary key auto_increment,

        name varchar(20),

        age int

    );

5、创建实体类（面向对象）

    /**

     * 实体类对象

     * 

     * @author WYC

     * 

     */

    public class Customer {

        private int id;

        private String name;

        private int age;

 

        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 int getAge() {

            return age;

        }

 

        public void setAge(int age) {

            this.age = age;

        }

}

6、创建ORM的映射

映射文件只要是XML格式文件就可以，名字可以任意。
    通常情况下映射文件与实体类在同包下。
    名称规范：
        实体类名称.hbm.xml

    在XML文件中引入约束：
        在hibernate3.jar/org.hibernate.hibernate-mapping-3.0.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"?>

 

        <!-- 引入hibernate约束 -->

        <!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表示表名 -->

            <class name="com.wyc.hibernate3.demo1.Customer" table="Customer">

                <!-- 建立类中属性与表中的字段映射关系 -->

                <!-- 主键 -->

                <!-- 使用id的标签配置唯一属性 -->

                <!-- 在<id>标签中配置主键的生成策略 -->

                <id name="id" column="id">

                    <generator class="native"></generator>

                </id>

 

 

 

                <!-- 普通属性 -->

                <!-- property标签：映射类中的普通属性，name表示类中的属性名称，column表示字段名称 -->

                <!-- 

                    type的三种写法

                      *  Java类型：java.lang.String

                      *  Hibernate类型：string

                      *  SQL类型：不能直接使用type属性，需要使用子标签<column>

                           >  <property name=""><column name="" sql-type="varchar(20)"/></property>

                    通常使用Hibernate类型。

                    可以不写type，Hibernate会自动完成类型转换

                -->

                <property name="name" column="name" type="string" length="20"/>

                <property name="age" column="age" />

            </class>

        </hibernate-mapping>

---------------------------------------------------------------------------------------------------------------------------- 

7、创建Hibernate的核心配置文件
    配置Hibernate连接的数据库等信息。

    在src下创建一个配置文件：
        hibernate.cfg.xml

    在XML文件中引入约束：
        Hibernate核心包下：/org/hibernate/hibernate-configuration-3.0.dtd

    <!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>

                <!-- Hibernate中必须配置的属性 -->

                <!-- 配置数据库连接的基本信息 -->

                <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

                <property name="hibernate.connection.url">jdbc:mysql:///hibernate3_day01</property>

                <property name="hibernate.connection.username">root</property>

                <property name=hibernate.connection.password">Admin123</property>
 

                <!-- Hibernate的方言 -->

                <!-- 不同数据库底层生成的SQL语句不同 -->

                <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
 

 

 

                <!-- 可选属性 -->

                <!-- 在控制台打印生成的SQL -->

                <property name="hibernate.show_sql">true</property>
 

                <!-- 默认打印在一行，可以格式化SQL -->

                <property name="hibernate.format_sql">true</property>

                <!-- 设置是否自动提交 -->
                <property name="hibernate.connection.autocommit">false</property> 
 

                <!-- 通过映射自动创建表 -->

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

 

                <!-- 通知Hibernate加载哪些配置文件 -->

                <!-- 可以通过拖拽形式自动生成 -->

                <mapping resource="com/wyc/hibernate3/demo1/Customer.hbm.xml"/>
 

            </session-factory>

        </hibernate-configuration>

---------------------------------------------------------------------------------------------------------------------------- 

8、编写测试
    向数据库中插入一条记录。

    session.save(Object obj);

示例代码：
 

 

import java.util.List;

 

import org.hibernate.Criteria;

import org.hibernate.Query;

import org.hibernate.SQLQuery;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import org.hibernate.criterion.Restrictions;

import org.junit.Test;

 

/**

 * Hibernate入门案例测试

 * @author WYC

 *

 */

public class HibernateDemo1 {

    @Test

    public void fun(){

        /*

         * 1、使用Hibernate框架加载核心配置文件，获取连接信息。

         */

        Configuration config = new Configuration().configure();

        /*

         * 2、创建连接池SessionFactory，可以获得Session（相当于Connection）

         */

        SessionFactory factory = config.buildSessionFactory();

 

        /*

         * 3、获得Session对象

         */

        Session session = factory.openSession();

        /*

         * 4、默认情况下事务是不会自动提交的

         */

        // 开启事务

        Transaction tx = session.beginTransaction();

 

        /*

         * 5、业务逻辑操作

         */

        // 向数据库中插入一条记录

        Customer customer = new Customer();

        customer.setName("张三");

        customer.setAge(20);

 

        session.save(customer);

        /*

         * 7、提交事务

         */

        tx.commit();

 

        /*

         * 8、释放资源

         */

        session.close();

        factory.close();

    }

}

 

9、Java - Hibernate - SQL类型对应关系

    

——Hibernate的CRUD操作

1、插入数据
    session.save(customer);

2、根据主键进行查询：
    Customer customer = (Customer)session.get(Customer.class, 1);

    Customer customer = (Customer)session.load(Customer.class, 1);

    示例代码：

        public void fun2(){

            /*

             * 1、加载Hibernate配置文件

             * 2、创建SessionFactory

             * 3、通过工厂创建Session对象

             * 4、开启事务

             * 5、逻辑操作

             * 6、提交事务

             * 7、释放资源

             */

            Configuration config = new Configuration().configure();

            SessionFactory factory = config.buildSessionFactory();

            Session session = factory.openSession();

            Transaction tx = session.beginTransaction();

 

            /*

             * 根据id进行查询

             */

            // get()方法

            Customer customer = (Customer)session.get(Customer.class, 1);
 

 

            // load()方法

            // Customer customer = (Customer)session.load(Customer.class, 1);

            // System.out.println(customer);

 

            tx.commit();

 

            session.close();

            factory.close();

        }

get()方法和load()方法的区别：
        1）发送SQL的时间不同
            *   load()方法采用了一个延时加载的技术（懒加载），load()方法在调用时并没有发送SQL语句，而是在使用对象属性时才会发送一条SQL语句。
            *   get()方法采用的是立即检索，当执行session.get()方法的时候立即发送SQL语句。
            *   load()更优化

        2）返回的对象不同
            *   load()方法返回的是一个代理对象（javassist包生成），可以通过断点查看。
            *   get()方法返回的是真实对象本身。

        3）当查询数据不存在时
            *   load()方法会抛出ObjectNotFoundException异常。
            *   get()方法会返回null，如果调用方法会出现空指针异常。

3、修改操作

session.update(Object obj)

修改有两种方式：
    *   手动创建对象修改
    *   先查询再修改

// 修改记录

public void fun3(){

    /*

     * 1、加载核心配置文件

     * 2、创建Session工厂

     * 3、通过工厂创建Session对象

     * 4、开启事务

     * 5、逻辑操作

     * 6、提交事务

     * 7、释放资源

     */

    Configuration config = new Configuration().configure();

    SessionFactory factory = config.buildSessionFactory();

    Session session = factory.openSession();

    Transaction tx = session.beginTransaction();

 

    /*

     * 有两种方式可以进行修改

     *  * 手动创建对象的方式

     *  * 先查询再修改的方式

     */

//   Customer customer = new Customer();

// customer.setId(2);

// customer.setName("李四");

    /*

     * 当被修改对象不设置age等属性时，则会采用默认值的形式：0

     * 所以在定义属性时不要使用基本数据类型，因为基本数据类型的默认值是0

     * 而是使用包装类，因为包装类的默认值是null

     */

// session.update(customer);
 

 

 

    /*

     * 先查询再修改的方式

     */

    Customer customer = (Customer)session.get(Customer.class, 2);

    customer.setName("王五");

 

    session.update(customer);

 

    tx.commit();

    session.close();

    factory.close();

}

4、删除记录

    session.delete(Object obj)

删除有两种方式：
    *   手动创建对象删除
    *   先查询再删除

如果想要进行级联删除，则必须先查询再删除。

// 删除操作

public void fun4(){

    Configuration config = new Configuration().configure();

    SessionFactory factory = config.buildSessionFactory();

    Session session = factory.openSession();

    Transaction tx = session.beginTransaction();

 

 

    /*

     * 有两种删除方式：

     *  * 手动创建对象的方式

     *  * 先查询再删除的方式

     */

// Customer customer = new Customer();

// customer.setId(3);

//

// session.delete(customer);

 

    Customer customer = (Customer)session.get(Customer.class, 6);

    session.delete(customer);

 

 

    tx.commit();

    session.close();

    factory.close();

}

——查询操作

1、HQL查询
    Hibernate Query Language。
    Hibernate的查询语言，只能用于面向对象的查询。

    // HQL查询操作

    public void fun5(){

        Configuration config = new Configuration().configure();

        SessionFactory factory = config.buildSessionFactory();

        Session session = factory.openSession();

        Transaction tx = session.beginTransaction();

 

        // 查询所有客户

        // Customer表示一个类，可以不写表名，因为在配置文件中已经完成了映射

 

//     Query query = session.createQuery("from com.wyc.hibernate3.demo1.Customer");

//     List<Customer> list = query.list();

 

         // 根据姓名查询客户

//     Query query = session.createQuery("from Customer where name = ?");

         // setParameter()方法可以不设置值的类型

//     query.setParameter(0, "张三");

//       List<Customer> list = query.list();
 

 

        // 为参数起别名

        Query query = session.createQuery("from Customer where name = :name");

        query.setParameter("name", "张三");

        List<Customer> list = query.list();

 

        for(Customer c : list){

            System.out.println(c);

        }

 

 

        tx.commit();

        session.close();

        factory.close();

    }

2、QBC查询
    Query By Criteria，条件查询。

示例代码：

    public void fun6(){

        Configuration config = new Configuration().configure();

        SessionFactory factory = config.buildSessionFactory();

        Session session = factory.openSession();

 

        Transaction tx = session.beginTransaction();

 

        /*

         * 使用QBC查询

         */

//     Criteria criteria = session.createCriteria(Customer.class);

//     List<Customer> list = criteria.list();

 

        /*

         * 使用QBC进行条件查询

         */

        Criteria criteria = session.createCriteria(Customer.class);

        criteria.add(Restrictions.eq("name", "张三"));

        List<Customer> list = criteria.list();

 

        for(Customer c : list){

            System.out.println(c);

        }
 

 

 

        tx.commit();

        session.close();

        factory.close();

    }

3、SQL查询

    public void fun7(){

        Configuration config = new Configuration().configure();

        SessionFactory factory = config.buildSessionFactory();

        Session session = factory.openSession();

        Transaction tx = session.beginTransaction();

 

        /*

         * 使用SQL进行查询

         */

        // 查询所有记录

//       SQLQuery query = session.createSQLQuery("select * from customer");

//     // 一个数组表示一条记录

//     List<Object[]> list = query.list();

//

//     for(Object[] o : list){

//         System.out.println(Arrays.toString(o));

//     }

 

        SQLQuery query = session.createSQLQuery("select * from customer");

        // 指定封装对象

        query.addEntity(Customer.class);

        List<Customer> list = query.list();

        for(Customer c : list){

            System.out.println(c);

        }

 

        tx.commit();

        session.close();

        factory.close();

    }

——Hibernate常用配置

1、核心配置
    有两种方式进行配置
    1）属性文件的配置
        hibernate.properties
        格式：
            key=value
            hibernate.connection.driver_class=com.mysql.jdbc.Driver

        注意：在属性配置文件中无法完成加载映射文件，只能通过手动编码的方式进行加载。
    2）XML格式文件配置
        hibernate.cfg.xml

2、配置属性
    1）必须属性：
        连接数据库的4个基本参数
            *   hibernate.connection.driver_class：数据库驱动程序
            *   hibernate.connection.url：数据库URL
            *   hibernate.connection.username：数据库用户名
            *   hibernate.connection.password：数据库密码

        Hibernate方言：
            *   hibernate.dialect：操作数据库方言

    2）可选属性：
        hibernate.show_sql：true，会在控制台上输出SQL语句
        hibernate.format_sql：true，格式化控制台输出的SQL语句
        hibernate.connection.autocommit：true，事务是否自动提交
        hibernate.hbm2ddl.auto：
            *   create：每次执行时，都会创建一个新的表（如果这个表已经存在，那么将删除该表然后重新创建），一般用于测试。
            *   create-drop：每次执行时，都会创建一个新的表，程序执行结束后会将该表删除，一般用于测试，当SessionFactory close()之后才会执行drop操作。
            *   update：如果数据库中没有表，则会创建一个新的表，如果该表已存在，会直接使用这个表，当指定字段不存在时，会更新表结构，新添加字段的值默认为null
            *   validate：使用原有的表，并且完成校验，校验映射文件中与表配置的字段是否一致，如果不一致，则会报错。

    3）映射文件配置
        *   在核心配置文件中配置映射文件：
            <mapping resource="com/wyc/hibernate3/demo1/Customer.hbm.xml" />
        *   需要使用手动编码的方式加载

2、映射文件的配置
    主要配置的是ORM，对象和关系表的映射。
    1）配置类与表的映射
        <class name="com.wyc.hibernate3.demo1.Customer" table="Customer"></class> 
        *   name：类的完整路径
        *   table：表名（可以省略，默认使用类名，不区分大小写，但是类名不能与数据库关键字冲突）

    2）配置普通属性与字段的映射
        *   <property name="name" column="name" type="string" length="20" />
        *   如果不写length，默认255。
        *   type的三个值：
            >   Java类型：java.lang.String
            >   Hibernate类型：string
            >   SQL类型：不能直接使用type属性，需要使用子标签<column>
                <column name="name" sql-type="varchar(20)" />

    3）配置唯一标识与主键映射
        *   一个表中只有一个主键
            <id name="类中属性名" column="表中字段名" />
            >   生成策略

        *   复合主键
            必须实现序列化接口
            <composite-id> </composite-id>

    4）关联关系

    5）命名SQL
        使用的是HQL：
            <query name="findAll">
                from Customer
            </query>

        使用SQL：
            <sql-query name="sqlFindAll">
                select * from Customer
            </sql-query>

 
——Hibernate核心API

1、Configuration
    1）负责管理Hibernate的配置信息，包括如下内容：
        *   加载hibernate.properties和hibernate.cfg.xml
        *   持久化类与数据表的映射关系（*.hbm.xml）

    2）创建Configuration的两种方式：
        *   属性文件（hibernate.properties）
            Configuration config = new Configration();    // 手动加载hbm

        *   XML文件（hibernate.cfg.xml）
            ConfigURation config = new Configration().configure();
            configure()方法源代码：configure("/hibernate.cfg.xml");
            可以手动指定要加载的XML文件：configure(XML文件名称);

    3）加载映射文件
        *   第一种写法：
            configuration.addResource("com/wyc/hibernate3/demo1/Customer.hbm.xml");
        *   第二种写法（要求：映射文件名称要规范，类与映射文件要在同一个包下）
            configuration.addClass(Customer.class);

        通常会将映射文件配置在核心配置文件中，如果要使用properties配置文件，则必须使用这种方法。

2、SessionFactory工厂类
    Configuration对象根据当前的配置信息生成SessionFactory对象。
    SessionFactory对象中保存了当前数据库配置信息和所有映射关系以及预定义的SQL语句。
    SessionFactory对象是线程安全的。
    SessionFactory还负责维护Hibernate的二级缓存（Session是一级缓存）。
    SessionFactory对象根据数据库信息，维护连接池，创建Session（相当于Connection）对象。

    构造SessionFactory很耗费资源，一般情况下一个应用只初始化一个SessionFactory对象。

    练习：抽取一个HibernateUtils工具类来提供Session对象。

    示例代码：

/**

 * Hibernate工具类

 * @author WYC

 *

 */

public class HibernateUtils {

    private static Configuration config;

    private static SessionFactory factory;

 

    static {

        config = new Configuration().configure();

        factory = config.buildSessionFactory();

    }

 

    public static Session openSession(){

        return factory.openSession();

    }

}

    当openSession()方法调用时，就会通过实体类来创建映射的表，前提是在核心配置文件中进行了配置。

3、Session接口
    1）相当于JDBC的Connection
    2）Session是应用程序与数据库之间交互操作的一个单线程对象，是Hibernate的运作中心。
    3）Session是线程不安全的。
    4）所有持久化对象必须在Session的管理下才可以进行持久化操作。
    5）Session对象有一个一级缓存，显示执行flush之前，所有的持久化操作的数据都换存在Session对象中。
    6）持久化类与Session关联起来后就具有了持久化的能力。
    7）常用方法：
        *   save()、persist()：增加
            >   persist()方法是JPA提供的方法
        *   update()：修改对象
        *   saveOrUpdate()：添加或修改对象
            >   当对象存在时执行修改操作，对象不存在时执行添加操作
        *   delete()：删除对象
        *   get()、load()：根据主键查询对象。
        *   createQuery()：创建一个Query接口，编写HQL语句
        *   createSQLQuery()：创建一个SQLQuery接口，编写SQL语句
        *   createCriteria()：条件查询，会返回一个Criteria接口。

4、Transaction接口
    1）代表数据库操作的事务对象
        Transaction transaction = session.beginTransaction();
    2）提供事务管理的方法
        *   commit()：提交相关联的Session实例
        *   rollback()：撤销事务操作
        *   wasCommitted()：检察事务是否提交

    如果没有开启事务，那么每个Session的操作都相当于一个独立的事务。

5、Query接口
    1）Query代表面向对象的一个Hibernate查询操作。
    2）session.createQuery()接收的是一个HQL语句。
    3）HQL是Hibernate Query Language的缩写，语法很像SQL语法，但是完全面向对象的。
    4）使用Query对象步骤：
        *   获得Hibernate Session对象
        *   编写HQL语句
        *   调用session.createQuery()方法创建查询对象
        *   如果HQL语句包含查询条件参数，则调用Query对象的setXxx()方法设置参数
        *   调用Query对象的list()方法，或uniqueResult()方法执行查询
    5）Query还包含两个方法，用于控制返回结果
        *   setFirstResult(int firstResult)：设置返回结果从第几条开始
        *   setMaxResults(int maxResults)：设置本次返回结果记录数
        *   可以使用这两个方法进行分页查询。

    HQL入门举例：
        *   以from开头的HQL语句：
            调用list()方法返回List<Customer>，from Customer表示查询Customer表的所有数据。
        *   使用Select关键字：（查询部分对象属性）
            >   select name from Customer，返回List<String>
            >   select name, age from Customer，返回List<Object[]>
            >   select c.name from Customer as c，为Customer实例起别名
        *   使用Where添加条件：
            >   from Customer as c where c.age > :age：其中:age是参数
            >   from Customer as c where c.age > ?：其中?是参数

6、Criteria接口
    1）Criteria接口是Hibernate提供的用于条件查询接口
    2）Criteria criteria = session.createCriteria(Customer.class);
    3）使用Criteria对象步骤：
        *   获得Hibernate的Session对象
        *   通过Session获得Criteria对象
        *   使用Restrictions的静态方法创建Criteria条件对象
        *   向Criteria对象中添加Criteria查询条件
        *   执行Criteria的list()或uniqueResult()获得结果

——在Hibernate中使用C3P0连接池

1、导入C3P0的jar包

2、在核心配置文件中添加一段配置：
    <!-- C3P0连接池设定-->

    <!-- 使用c3po连接池  配置连接池提供的供应商-->

    <property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
    <!--在连接池中可用的数据库连接的最少数目 -->

    <property name="c3p0.min_size">5</property>

    <!--在连接池中所有数据库连接的最大数目  -->

    <property name="c3p0.max_size">20</property>

    <!--设定数据库连接的过期时间,以秒为单位,

    如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->

    <property name="c3p0.timeout">120</property>

    <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->

    <property name="c3p0.idle_test_period">3000</property>

 

——Hibernate持久化对象的配置和操作

1、Hibernate采用普通、传统的Java对象（POJO类），作为持久化类，与数据表进行映射。
2、编写规则：
    *   提供一个public的无参构造方法。
    *   提供一个标识属性，映射数据表主键字段。
    *   所有属性提供public访问控制符的set()/get()方法。
    *   标识属性应尽量使用基本数据类型的包装类。
    *   不要用final修饰（不能被继承，无法生成代理对象进行优化）
        当无法生成代理对象时，load()方法不会延时加载，会即时打印SQL语句。
3、持久化对象的唯一标识：OID
    *   Java根据地址区分同一个类的不同对象。
    *   关系数据库根据主键区分是否同一条记录
    *   Hibernate使用OID来建立内存中的对象和数据库记录的对应关系。
    *   对象的OID和数据库的表的主键对应，为保证OID的唯一性，应该让Hibernate来为OID赋值。

4、自然主键和代理主键
    1）自然主键
        创建一个用户表，用户表中某条记录想要被唯一确定，可以使用身份证号作为主键，身份证号本身就是一个用户的属性，这就叫自然主键。
    2）代理主键
        创建一个用户表，用户表中某条记录想要被唯一确定，但没有使用身份证号作为主键，使用一个与用户的任何信息都不相关，只具备标识的作用，这就是代理主键。

    尽量使用代理主键。

5、尽量让Hibernate自己维护主键
    涉及到主键的生成策略。

——主键的生成策略

1、increment
    自动增长，适用于数值类型，而不能使用字符串。
    不是使用数据库的自动增长机制，而是使用Hibernate框架提供的自动增长方式。

    *   首先会检查主键的最大值：select max(id) from table
    *   然后在最大值的基础上+1
    容易出现多线程的问题，不能在集群下使用。

2、identity
    自动增长，适用于数值类型，而不能使用字符串。
    采用数据库的自动增长的机制。
    不适用于Oracle数据库，因为Oracle数据库没有自动增长。

3、sequence
    序列，适用于数值类型，而不能使用字符串。
    可以应用在Oracle中，MySQL中不能使用。

4、uuid
    使用与字符串类型的主键。
    使用随机字符串作为主键。

5、native
    本地策略。
    根据底层数据库自动选择使用identity还是sequence。

6、assigned
    Hihernate框架不维护主键，由程序自动生成。

7、foreign
    主键来自外表主键。
    应用在一对一的关系表中。

——练习

    1、搭建Hibernate环境
        >   核心配置文件
        >   映射文件
    2、抽取Hibernate工具类
    3、CRUD操作

——总结

1、Hibernate框架概述
    *   是一个持久层的ORM框架
    *   ORM：Object Relational Mapping
        >   对象关系映射，将Java中实体对象与关系型数据库中的表建立一种关系，Hibernate中可以通过操作对象的方式，从而操作数据库中的表。
    *   常见持久层框架
        >   Hibernate
        >   MyBatis
        >   JPA

2、Hibernate入门
    1）下载Hibernate开发包
    2）Hibernate开发包目录结构
        *   文档
        *   开发包
            >   操作字节码
            >   必须包
            >   可选包
            >   JPA
    3）创建一个Java项目，导入相应jar包
    4）创建数据库表
    5）创建一个实体类
    6）映射配置文件
    7）核心配置文件
    8）测试程序

3、Hibernate的CRUD
    1）save()
    2）update()
    3）delete()
    4）get() / load()
        *   区别：
            >   get：采用立即检索，马上发送SQL语句。返回的是真实对象。当检索不到数据时会抛出NullPointerException
            >   load：采用延迟加载的技术，当真正使用对象的时候，才会发送SQL语句。返回的是代理对象。抛出ObjectNotFoundException

4、Hibernate的配置
    *   核心配置
        >   属性文件(properties)
            在src下创建一个hibernate.properties文件
            必须手动加载
        >   XML文件
            在src下创建一个hibernate.cfg.xml文件

        必须的配置：
            数据库连接信息
            Hibernate方言

        可选配置：
            显示SQL
            格式化SQL
            hbm2ddl.auto
                create/create-drop/update/validate

        映射文件：
            <mapping resource="" />

    *   映射配置
        >   <class>建立类与表的映射
            name：类的全路径
            table：表名称
        >   id
        >   property
            name
            column
            type
            length

5、Hibernate核心API
    *   Configuration
        >   属性文件：
            直接创建
        >   XML文件
            new Configuration().configure();

    *   SessionFactory
        >   维护二级缓存，线程安全的对象
        >   抽取工具类

    *   Session
        >   维护一级缓存，线程不安全的对象

    *   Transaction
        >   控制事务
        >   在Hibernate中默认事务不自动提交，每个Session都是一个独立的事务

    *   Query
    *   Criteria

6、Hibernate的持久化类的编写
    *   无参构造
    *   属性提供set() / get()方法
    *   属性尽量使用包装类
    *   类不要使用final
    *   提供唯一标识OID

7、自然主键和代理主键

8、Hibernate主键的生成策略
    *   increment：线程不安全，不能用于集群
    *   identity：使用数据库自动增长机制
    *   sequence：支持序列的数据库，比如Oracle
    *   uuid
    *   native：本地策略，根据本地数据库自动选择主键生成策略