Hibernate第一天——入门和基本操作

第一个接触的框架就是这个Hibernate框架了，Hibernate本意是 冬眠 ，这里有必要引用CSDN上某位网友某个帖子的评论先引出框架的概念：

　　框架：一个软件半成品，帮你做了一些基础工作，你就可以在这个基础之上，来定制适合你自己的应用。

　　　　　流行的框架非常灵活，以适应不同的需求。

　　既然是软件半成品，那里面也就是一些类与接口。

　　　　说完了是什么，接下来那就自然来到它能干什么

　　作用：应用于DAO（数据库访问对象）层的持久化框架，是对JDBC的封装，是一个开源的轻量级框架

　　　　　局限：　Hibernate不适合复杂的查询操作，使用底层SQL效率更高！

　　　　　　注：版本：Hibernate3.x 4.x 5.x
　　　　　　　　4.x是一个过度的版本，使用的是5版本。

　　在此之前，有必要介绍一下Hieernate的重要思想：ORM

　　ORM：　对象关系映射（Object Relational Mapping ）

　　　　　　　让实体类和数据库中的表一一对应，私有属性对应表的字段，然后即可通过操作实体类的get/set方法，进而完成CRUD的操作
　　　　　　　也就是通过操作实体类来达到操作表的目的

　　在正式开始介绍核心接口与用法之前，我们先来搭建一下Hibernate的环境：

　　环境搭建：

　　　　　　1.导包：　　　　　　

　　　　　　　　　　　 required里面的所有+jpa里的（就是一套规范），如下图所示（请注意红线的路径）：

　　　　　　　　　　　　

　　　　　　　　    　　

　　　　　　　　　　再加上日志的jar包（其他的，非Hebernate里面的），如下图所示：
　　　　　　　　　

　　　　　　　　　　

　　　　　　　　　　　　

　　　　　　　　　　当然了，mysql的驱动包是基本包了。（原谅这一大堆的文件夹里突然冒出的jar包）

　　　　　　　　　　　　

　　　　　　　　导完所有的jar包后应该是这个样子了：

　　　　　                　

　　　　　　　　2.创建实体类（概念第二天会有详细介绍），并为实体类创建映射文件

　　　　　　　　　　　　　　建议配置文件写在实体类的包下，名称为 实体类.hbm.xml

　　　　　　　　　　

　　　　　　　　　　　　　　　　（配置文件信息会在稍后解释）

　　　　　　　3.创建核心配置文件

　　　　　　　　　　名称与位置都是固定的！！

　　　　　　　　　　　　名称：hibernate.cfg.xml

　　　　　　　　　　　　位置：src下

　　　接下来我们先对两个配置文件进行简单的配置，更多的配置会在后面逐渐加入！

　　　　先来看看我们的实体类：

package cn.entity;

public class User {

    /*Hiberbate要求属性必须有一个是唯一的（就对应表中的字段中必须要有主键一样）
     * 这样例如有多个用户用于区分
     * */
    //private int uid;
    private String uid;
    private String username;
    private String password;
    private String address;

    public User() {
    }

    public String getUid() {
        return uid;
    }

    public void setUid(String uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    //当然，测试阶段可以重写toString()

}

　　接下来我们来进行映射文件User.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>
    <!-- 映射的类 name是类的全路径  table是表名 -->
    <class name="cn.entity.User" table="t_user">
        <id name="uid" column="uid">
            <!-- 设置id增长策略 -->
            <generator class="uuid"></generator>
        </id>
        <!-- 配置其它属性 -->
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>
        <property name="address" column="address"></property>
    </class>
</hibernate-mapping>

　　接下来我们讲讲几点，第一xml第一行必须为文档声明，第二行进行约束文件的引入，约束文件中hibernate-mapping为xml根元素名称。

　　再讲讲整个配置文件：

　　　　1.根元素：<hibernate-mapping>，每一个hbm.xml文件都有唯一的一个根元素，当然，它存在以下两种写法

　　　　　其中第一种写法直接指定包名，后面的类名若不使用全限定名则使用此包名

<hibernate-mapping package="com.demo.hibernate.beans">
    <class name="User" ...>
</hibernate-mapping>

<hibernate-mapping>
    <class name="com.demo.hibernate.beans.User" ...>
</hibernate-mapping>

　　　　2.<class>标签，是更元素的子元素，表示持久化类与数据库的映射关系

　　　　上示例配置文件中

　　　　name:实体类类名

　　　　table:数据库对应的表名（建议t_xxx形式）

　　　  3.<id>标签，用于定于主键

　　　　　　主键的生成策略见day02的具体讲解！

　　　  4.<property>,用于定义其它属性，其中

　　　　　　name为实体类属性名 column为表中字段名

　　

　　接下来贴出核心配置文件，通过注释解释而不再分条赘述：

<?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://localhost:3306/hibernate</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>
        <!-- 二、配置hibernate信息 可选项 -->
        <!-- 输出底层SQL语句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化SQL语句 -->
        <property name="hibernate.format_sql">true</property>
        <!-- 如果没有表，创建  已有表 更新 -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 配置MySQL方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <!-- 三、引入映射文件 -->
        <mapping resource="cn/entity/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

　这里注意一点，使用Hibernate无需自己建表，只需自己建数据库

　　　　还有MySQL5以上版本请正确配置方言！！！org.hibernate.dialect.MySQL5InnoDBDialect

接下来再引出基本操作前我们先了解核心接口：

hibernate核心接口
　　session：负责被持久化对象CRUD操作
　　sessionFactory:负责初始化hibernate，创建session对象
　　configuration:负责配置并启动hibernate，创建SessionFactory
　　Transaction:负责事物相关的操作
　　Query和Criteria接口：负责执行各种数据库查询

　　接下来我们先列出步骤后给出一个小Demo示例（标准写法会在后面引入）：

package cn.hibernate.test;

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

import cn.entity.User;
import cn.utils.HibernateUtils;

public class HibernateDemo01 {

    @Test
    public void add(){
    /*    //第一步、加载核心配置文件
        Configuration cfg = new Configuration();
        cfg.configure();//会去指定路径加载指定名称的配置文件

        //第二步、创建sessionFactory工厂
        //读取核心配置文件，并根据映射关系创建表
        SessionFactory sessionFactory = cfg.buildSessionFactory();*/
        SessionFactory sessionFactory = HibernateUtils.getSessionFactory();

        //第三步、使用工厂创建session
        Session session = sessionFactory.openSession();

        //第四步、开启事务
        Transaction tx = session.beginTransaction();

        //完成CRUD操作
        User user = new User();
        user.setUsername("李四");
        user.setPassword("10010");
        user.setAddress("上海");
        //使用框架完成添加，通过的是对象完成操作
        session.save(user);

        //第六步、提交事务
        tx.commit();

        //第七步、关闭资源
        session.close();
        sessionFactory.close();
    }
}

这里引入一个对得到sessionFactory的简单封装，也就是我们简单提取的工具类（采用的是静态代码块实现，会在类加载时完成）

package cn.utils;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {

    private static final Configuration cfg ;
    private static final SessionFactory sessionFactory;
    //静态代码块实现
    static {
        cfg = new Configuration();
        cfg.configure();
        sessionFactory = cfg.buildSessionFactory();
    }
    //提供静态方法返回
    public static SessionFactory getSessionFactory(){
        return sessionFactory;
    }
}

这里对几个步骤进行简单的解读：

　　Hibernate的API(先看是类还是接口)：
　　　　Configuration ===加载核心配置
　　　　　　1 Configuration cfg = new Configuration();
　　　　　　2 cfg.configure();
　　　　　　会去指定路径加载指定名称的配置文件,把配置文件放到cfg对象中
　　　　　　（当然，2调用时可以指定路径，但不建议）
　　　　SessionFactory ===重要对象 一个项目就一个，类似于application (ServletContext)
　　　　　　SessionFactory sessionFactory = cfg.buildSessionFactory();
　　　　　　创建sessionFactory,读取核心配置文件，并根据映射关系创建表
　　　　　　自动创建表需要在配置文件中进行相关的配置
　　　　　　<property name="hibernate.hbm2ddl.auto">update</property>

　　　　　　创建过程中每次创建中都要创建表，比较耗资源！
　　　　　　一般一个项目中创建一个sessionFactory
　　　　　　具体实现是提取出一个工具类，在静态代码块中创建，这样，在类加载时就只执行一次
　　　　Session ===单线程对象（只能自己用，别人不能和我共用） web中的ThreadLocal<Connection> 连接与本地线程绑定
　　　　　　类似于Connction
　　　　　　调用session进行CRUD的操作
　　　　　　save 添加
　　　　　　update 修改
　　　　　　delete 删除
　　　　　　get 查询
　　　　Transaction ===事务对象
　　　　　　主要有两个操作事务的方法
　　　　　　commit() rollback()

（关于加载本地dtd文件参见另外一篇博客）