Hibernater入门-01

最新推荐文章于 2020-05-14 17:37:55 发布

绿谷小初九

最新推荐文章于 2020-05-14 17:37:55 发布

阅读量1k

点赞数

分类专栏： SSH

本文链接：https://blog.csdn.net/qq_36974281/article/details/81369715

版权

SSH 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

框架和CRM项目的整体介绍

什么是CRM

CRM（==Customer Relationship Management==）客户关系管理，是利用相应的信息技术以及互联网技术来协调企业与顾客间在销售、营销和服务上的交互，向客户提供创新式的个性化的客户交互和服务的过程
其最终目标是将面向客户的各项信息和活动集成起来，组建一个以客户为中心的企业，实现对面向客户的活动的全面管理

CRM的模块

CRM系统实现了对企业销售、营销、服务等各阶段的客户信息、客户活动进行统一管理。
CRM系统功能涵盖企业销售、营销、用户服务等各各业务流程，业务流程中与客户相关活动都会在CRM系统统一管理。
下边列出一些基本的功能模块，包括：
- 客户信息管理
- 联系人管理
- 商机管理
- 统计分析等

模块的具体功能

客户信息管理
- 对客户信息统一维护，客户是指存量客户或拟营销的客户，通过员工录入形成公司的“客户库”是公司最重要的数据资源。
联系人管理
- 对客户的联系人信息统一管理，联系人是指客户企业的联系人，即企业的业务人员和客户的哪些人在打交道。
客户拜访管理
- 业务员要开发客户需要去拜访客户，客户拜访信息记录了业务员与客户沟通交流方面的不足、采取的策略不当、有待改进的地方或值得分享的沟通技巧等方面的信息。
综合查询
- 客户相关信息查询，包括：客户信息查询、联系人信息查询、商机信息查询等
统计分析
- 按分类统计客户信息，包括：客户信息来源统计、按行业统计客户、客户发展数量统计等
系统管理
系统管理属于crm系统基础功能模块，包括：数据字典、账户管理、角色管理、权限管理、操作日志管理等

Hibernate框架的学习路线

1. 注意：Hibernate框架知识点非常多，比较杂乱，大家要做好笔记记录的工作
2. 学习的路线
    * 第一天：主要是学习框架的入门，自己搭建框架，完成增删改查的操作 
    * 第二天：主要学习一级缓存、事务管理和基本的查询
    * 第三天：主要学习一对多和多对多的操作等
    * 第四天：基本查询和查询的优化

Hibernate框架的概述

Hibernate是一个开放源代码的对象关系映射（ORM）框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用。
Hibernate是轻量级JavaEE应用的持久层解决方案，是一个关系数据库ORM框架
==记住：Hibernate是一个持久层的ORM框架==！！！

什么是ORM(对象关系映射)

ORM映射：Object Relational Mapping
- O：面向对象领域的Object（JavaBean对象）
- R：关系数据库领域的Relational（表的结构）
- M：映射Mapping（XML的配置文件）

简单一句话：Hibernate使程序员通过操作对象的方式来操作数据库表记录

Hibernate优点

Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码
Hibernate是一个基于jdbc的主流持久化框架，是一个优秀的orm实现，它很大程度的简化了dao层编码工作
Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系

Hibernate框架的快速入门

案例一：完成客户的CRUD的操作

需求分析

1. CRM系统中客户信息管理模块功能包括

* 新增客户信息
* 客户信息查询
* 修改客户信息
* 删除客户信息

2. 要实现客户的新增功能

第一步：下载Hibernate5的运行环境

下载相应的jar包等

http://sourceforge.net/projects/hibernate/files/hibernate-orm/5.0.7.Final/hibernate-release-5.0.7.Final.zip/download

解压后对目录结构有一定的了解

第二步：创建表结构

Create database hibernate_day01;
Use hibernate_day01;
CREATE TABLE `cst_customer` (
  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  `cust_user_id` bigint(32) DEFAULT NULL COMMENT '负责人id',
  `cust_create_id` bigint(32) DEFAULT NULL COMMENT '创建人id',
  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  `cust_linkman` varchar(64) DEFAULT NULL COMMENT '联系人',
  `cust_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
  `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=94 DEFAULT CHARSET=utf8;

第三步：搭建Hibernate的开发环境

创建WEB工程，引入Hibernate开发所需要的jar包
* MySQL的驱动jar包
* Hibernate开发需要的jar包（资料/hibernate-release-5.0.7.Final/lib/required/所有jar包）
* 日志jar包（资料/jar包/log4j/所有jar包）

第四步：编写JavaBean实体类

Customer类的代码如下：

public class Customer {
    private Long cust_id;
    private String cust_name;
    private Long cust_user_id;
    private Long cust_create_id;
    private String cust_source;
    private String cust_industry;
    private String cust_level;
    private String cust_linkman;
    private String cust_phone;
    private String cust_mobile;
    // 省略get和set方法
}

第五步：创建类与表结构的映射

1. 在JavaBean所在的包下创建映射的配置文件
* 默认的命名规则为：实体类名.hbm.xml
* 在xml配置文件中引入约束（引入的是hibernate3.0的dtd约束，不要引入4的约束）

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

2. 如果不能上网，编写配置文件是没有提示的，需要自己来配置

先复制http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd --> window
--> preferences --> 搜索xml --> 选择xml catalog --> 点击add --> 现在URI
--> 粘贴复制的地址 --> 选择location，选择本地的DTD的路径

3. 编写映射的配置文件

<?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.itheima.domain.Customer" table="cst_customer">
        <!-- 配置id(主键) 
            见到name属性，JavaBean的属性
            见到column属性，是表结构的字段
        -->
        <id name="cust_id" column="cust_id">
            <!-- 主键的生成策略(本地策略) -->
            <generator class="native"/>
        </id>

        <!-- 配置其他的属性(普通属性) -->
        <property name="cust_name" column="cust_name"/>
        <property name="cust_user_id" column="cust_user_id"/>
        <property name="cust_create_id" column="cust_create_id"/>
        <property name="cust_source" column="cust_source"/>
        <property name="cust_industry" column="cust_industry"/>
        <property name="cust_level" column="cust_level"/>
        <property name="cust_linkman" column="cust_linkman"/>
        <property name="cust_phone" column="cust_phone"/>
        <property name="cust_mobile" column="cust_mobile"/>

    </class>

</hibernate-mapping>

第六步：编写Hibernate核心的配置文件

在src目录下，创建名称为hibernate.cfg.xml的配置文件(名称位置都固定)
在XML中引入DTD约束

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

配置信息
可以打开：资料/hibernate-release-5.0.7.Final/project/etc/hibernate.properties，查看具体的配置信息

* 必须配置的4大参数(根据空格划分) 
    hibernate.connection.driver_class com.mysql.jdbc.Driver
    hibernate.connection.url jdbc:mysql:///test  <!--访问本机-->
    hibernate.connection.username gavin
    hibernate.connection.password

* 数据库的方言（必须配置的）
    hibernate.dialect org.hibernate.dialect.MySQLDialect

* 可选的配置
    hibernate.show_sql true
    hibernate.format_sql true
    hibernate.hbm2ddl.auto update

* 引入映射配置文件（一定要注意，要引入映射文件，框架需要加载映射文件）
    * <mapping resource="com/itheima/domain/Customer.hbm.xml"/>

具体的配置如下

<?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_day01</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

<mapping resource="com/itheima/domain/Customer.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

第七步：编写Hibernate入门代码

1. 具体的代码如下

/**
 * 测试保存客户
 */
@Test
public void testSave(){
    // 先加载配置文件
    Configuration config = new Configuration();
    // 默认加载src目录下的配置文件
    config.configure();
    // 创建SessionFactory对象
    SessionFactory factory = config.buildSessionFactory();
    // 创建session对象
    Session session = factory.openSession();
    // 开启事务
    Transaction tr = session.beginTransaction();
    // 编写保存代码
    Customer c = new Customer();
    // c.setCust_id(cust_id);   已经自动递增
    c.setCust_name("测试名称");
    c.setCust_mobile("110");
    // 保存客户
    session.save(c);
    // 提交事务
    tr.commit();
    // 释放资源
    session.close();
    factory.close();
}

回忆：快速入门

下载Hibernate框架的开发包
编写数据库和表结构
创建WEB的项目，导入了开发的jar包
- MySQL驱动包、Hibernate开发的必须要有的jar包、日志的jar包
编写JavaBean，以后不使用基本数据类型，使用包装类
编写映射的配置文件（核心），先导入开发的约束，里面正常配置标签
编写hibernate的核心的配置文件，里面的内容是固定的
编写代码，使用的类和方法

Hibernate常用的配置文件详解

主配置文件

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

    <!-- 记住：先配置SessionFactory标签，一个数据库对应一个SessionFactory标签 -->
    <session-factory>

<!--      必须配置的元素
    1.数据库方言
        #hibernate.dialect org.hibernate.dialect.MySQLDialect
        #hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
        #hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect
    2.配置数据库的4大参数
        #hibernate.connection.driver_class com.mysql.jdbc.Driver
        #hibernate.connection.url jdbc:mysql:///test
        #hibernate.connection.username gavin
        #hibernate.connection.password
 -->
        <!-- 必须要配置的参数有5个，4大参数，数据库的方言 -->
        <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.show_sql true 打印sql语句
           #hibernate.format_sql true 格式化sql语句
        ## auto schema export  自动导出表结构. 自动建表(分为4个选项)
            #hibernate.hbm2ddl.auto create
                    自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
            #hibernate.hbm2ddl.auto create-drop
                    自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
            #hibernate.hbm2ddl.auto update
                    (推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
            #hibernate.hbm2ddl.auto validate
                    校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败抛出异常
 -->


        <!-- 数据库的方言(尽量选择这个 这个所有引擎都兼容) -->
        <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>
        <!--生成数据库的表结构-->
        <!--
            update:如果有表就不会创建,直接操作数据;
                   如果没表创建该表;
                   还支持更改表结构(只能添加不能删除);
        -->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!--
            设置数据库的隔离级别，就使用默认值就OK
            <property name="hibernate.connection.isolation">4</property>
        -->

        <!--开启绑定本地的Session(固定写法)-->
        <property name="hibernate.current_session_context_class">thread</property>


        <!--引入映射配置文件-->
        <mapping resource="com/xiaoming/day01/domain/Customer.hbm.xml"></mapping>
        <mapping resource="com/xiaoming/day01/domain/Linkman.hbm.xml"/>
        <mapping resource="com/xiaoming/day01/domain/User.hbm.xml"/>
        <mapping resource="com/xiaoming/day01/domain/Role.hbm.xml"/>


    </session-factory>

</hibernate-configuration>

映射配置文件hbm.xml

标签– 用来将类与数据库表建立映射关系
- name – 类的全路径
- table – 表名.(类名与表名一致,那么table属性也可以省略)
- catalog– 数据库的名称，基本上都会省略不写
标签 – 用来将类中的属性与表中的主键建立映射，id标签就是用来配置主键的。
- name – 类中属性名
- column – 表中的字段名.(如果类中的属性名与表中的字段名一致,那么column可以省略.)
- length– 字段的程度，如果数据库已经创建好了，那么length可以不写。如果没有创建好，生成表结构时，length最好指定。
– 用来将类中的普通属性与表中的字段建立映射.
- name – 类中属性名
- column– 表中的字段名.(如果类中的属性名与表中的字段名一致,那么column可以省略.)
- length– 数据长度
- type – 数据类型（一般都不需要编写，如果写需要按着规则来编写）
  - Hibernate的数据类型 type=”string”
  - Java的数据类型type=”java.lang.String”
  - 数据库字段的数据类型

配置如下

<?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">


   <!-- 配置表与实体对象的关系 -->
   <!-- package属性:填写一个包名.在元素内部凡是需要书写完整类名的属性,可以直接写简答类名了. -->
<hibernate-mapping package="cn.itheima.domain" >
    <!-- 
        class元素: 配置实体与表的对应关系的
            name: 完整类名
            table:数据库表名
     -->
    <class name="Customer" table="cst_customer" >
        <!-- id元素:配置主键映射的属性
                name: 填写主键对应属性名
                column(可选): 填写表中的主键列名.默认值:列名会默认使用属性名
                type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型.
                        每个类型有三种填法: java类型|hibernate类型|数据库类型
                not-null(可选):配置该属性(列)是否不能为空. 默认值:false
                length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度
         -->
        <id name="cust_id"  >
            <!-- generator:主键生成策略(明天讲) -->
            <generator class="native"></generator>
        </id>
        <!-- property元素:除id之外的普通属性映射
                name: 填写属性名
                column(可选): 填写列名,默认使用属性名
                type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型.
                        每个类型有三种填法: java类型|hibernate类型|数据库类型
                not-null(可选):配置该属性(列)是否不能为空. 默认值:false
                length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度
         -->
        <property name="cust_name" column="cust_name" >
            <!--  <column name="cust_name" sql-type="varchar" ></column> -->
        </property>
        <property name="cust_source" column="cust_source" ></property>
        <property name="cust_industry" column="cust_industry" ></property>
        <property name="cust_level" column="cust_level" ></property>
        <property name="cust_linkman" column="cust_linkman" ></property>
        <property name="cust_phone" column="cust_phone" ></property>
        <property name="cust_mobile" column="cust_mobile" ></property>
    </class>
</hibernate-mapping>

核心配置文件

核心配置文件的两种方式

1.属性文件的方式(properties配置文件)

hibernate.properties

    hibernate.connection.driver_class=com.mysql.jdbc.Driver

缺点

不能加载映射的配置文件，需要手动编写代码去加载

2.XML配置方式(推荐)

hibernate.cfg.xml

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

优点
- 格式比较清晰
- 编写有提示
- 可以在该配置文件中加载映射的配置文件（最主要的）

hibernate.cfg.xml的配置详解

必须有的配置

数据库连接信息:

hibernate.connection.driver_class   -- 连接数据库驱动程序
hibernate.connection.url    -- 连接数据库URL
hibernate.connection.username  -- 数据库用户名
hibernate.connection.password       -- 数据库密码

方言:

hibernate.dialect   -- 操作数据库方言

可选的配置

* hibernate.show_sql    -- 显示SQL
* hibernate.format_sql  -- 格式化SQL
* hibernate.hbm2ddl.auto-- 通过映射转成DDL语句
    * create-- 每次都会创建一个新的表.---测试的时候
    * create-drop   -- 每次都会创建一个新的表,当执行结束之后,将创建的这个表删除.---测试的时候
    * update-- 如果有表,使用原来的表.没有表,创建一个新的表.同时更新表结构.
    * validate-- 如果有表,使用原来的表.同时校验映射文件与表中字段是否一致如果不一致就会报错.

* 加载映射
    * 如果XML方式：<mapping resource="cn/itcast/hibernate/domain/User.hbm.xml" />

Hibernate常用的接口和类

Configuration类和作用

Configuration类

Configuration对象用于配置并且启动Hibernate。
Hibernate应用通过该对象来获得对象-关系映射文件中的元数据，以及动态配置Hibernate的属性，然后创建SessionFactory对象。
简单一句话：加载Hibernate的配置文件，可以获取SessionFactory对象。

Configuration类的其他应用（了解）

加载配置文件的种类，Hibernate支持xml和properties类型的配置文件，在开发中基本都使用XML配置文件的方式。
- 如果采用的是properties的配置文件，那么通过Configuration configuration = new Configuration();就可以加载配置文件
  - 但是需要自己手动加载映射文件
  - 例如：config.addResource(“cn/itcast/domain/Student.hbm.xml”);
- 如果采用的XML的配置文件，通过Configuration configuration = new Configuration().configure();加载配置文件

SessionFactory：(重要)

概述

是工厂类，是生成Session对象的工厂类

SessionFactory类的特点

由Configuration通过加载配置文件创建该对象。
SessionFactory对象中保存了当前的数据库配置信息和所有映射关系以及预定义的SQL语句。同时，SessionFactory还负责维护Hibernate的二级缓存。

* 预定义SQL语句
    * 使用Configuration类创建了SessionFactory对象是，已经在SessionFacotry对象中缓存了一些SQL语句
    * 常见的SQL语句是增删改查（通过主键来查询）
    * 这样做的目的是效率更高

一个SessionFactory实例对应一个数据库，应用从该对象中获得Session实例。
SessionFactory是线程安全的，意味着它的一个实例可以被应用的多个线程共享。
SessionFactory是重量级的，意味着不能随意创建或销毁它的实例。如果只访问一个数据库，只需要创建一个SessionFactory实例，且在应用初始化的时候完成。
SessionFactory需要一个较大的缓存，用来存放预定义的SQL语句及实体的映射信息。另外可以配置一个缓存插件，这个插件被称之为Hibernate的二级缓存，被多线程所共享

总结

一般应用使用一个SessionFactory,最好是应用启动时就完成初始化。

编写HibernateUtil的工具类

public class HibernateUtil {
    private static final Configuration cfg;
    private static final SessionFactory factory;
    static{
// 给常量赋值 
// 加载配置文件
cfg = new Configuration().configure();
// 生成factory对象
factory = cfg.buildSessionFactory();
    }
    // 获取Session对象
    public static Session openSession(){
return factory.openSession();
    }
}

Session接口(很重要)

概述

Session是在Hibernate中使用最频繁的接口。也被称之为持久化管理器。它提供了和持久化有关的操作，比如添加、修改、删除、加载和查询实体对象
Session 是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心
Session是线程不安全的
所有持久化对象必须在 session 的管理下才可以进行持久化操作
Session 对象有一个一级缓存，显式执行 flush 之前，所有的持久化操作的数据都缓存在 session 对象处
持久化类与 Session 关联起来后就具有了持久化的能力

特点

不是线程安全的。应避免多个线程使用同一个Session实例
Session是轻量级的，它的创建和销毁不会消耗太多的资源。应为每次客户请求分配独立的Session实例
Session有一个缓存，被称之为Hibernate的一级缓存。每个Session实例都有自己的缓存

常用的方法

save(obj)
delete(obj)
get(Class,id)
update(obj)
saveOrUpdate(obj) –保存或者修改（如果没有数据，保存数据。如果有，修改数据）
createQuery() – HQL语句的查询的方式

Transaction接口

概述

Transaction是事务的接口
常用的方法

commit()-- 提交事务
rollback()  -- 回滚事务

特点
- Hibernate框架默认情况下事务不自动提交.需要手动提交事务
- 如果没有开启事务，那么每个Session的操作，都相当于一个独立的事务

测试代码

package com.itheima.test;

import java.util.List;

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

import com.itheima.domain.Customer;
import com.itheima.utils.HibernateUtils;

/**
 * 测试Hibernate框架
 * @author Administrator
 */
public class Demo1 {

    /**
     * 测试保存
     */
    @Test
    public void testSave3(){
        Session session = null;
        Transaction tr = null;
        try {
            // 获取session
            session = HibernateUtils.getSession();
            // 开启事务
            tr = session.beginTransaction();
            // 执行代码
            Customer c = new Customer();
            c.setCust_name("哈哈");
            // 保存
            session.save(c);
            // 提交事务事务
            tr.commit();
        } catch (Exception e) {
            // 回滚事务
            tr.rollback();
            e.printStackTrace();
        }finally{
            // 释放资源
            session.close();
        }
    }


    /**
     * 测试查询的方法
     */
    @Test
    public void testSel(){
        // 原来：加载配置文件，获取Factory对象，获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        // 创建查询的接口
        Query query = session.createQuery("from Customer");
        // 查询所有的数据 select * from 表
        List<Customer> list = query.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }

        // 提交事务
        tr.commit();
        // 释放资源
        session.close();
    }

    /**
     * 测试添加或者修改
     */
    @Test
    public void testSaveOrUpdate(){
        // 原来：加载配置文件，获取Factory对象，获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();

        /*// 演示错误
        Customer c = new Customer();
        // c.setCust_id(10L);   千万不能自己设置
        c.setCust_name("测试");

        // 保存或者修改
        session.saveOrUpdate(c);*/

        // 先查询再改
        Customer c = session.get(Customer.class, 6L);
        c.setCust_name("小泽");

        session.saveOrUpdate(c);

        // 提交事务
        tr.commit();
        // 释放资源
        session.close();
    }

    /**
     * 测试修改
     */
    @Test
    public void testUpdate(){
        // 原来：加载配置文件，获取Factory对象，获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        // 测试查询的方法 2个参数：arg0查询JavaBean的class对象 arg1主键的值
        Customer c = session.get(Customer.class, 6L);

        // 设置客户的信息
        c.setCust_name("小苍");
        c.setCust_level("3");

        // 修改
        session.update(c);

        // 提交事务
        tr.commit();
        // 释放资源
        session.close();
    }

    /**
     * 测试删除的方法
     * 注意：删除或者修改，先查询再删除或者修改
     */
    @Test
    public void testDel(){
        // 原来：加载配置文件，获取Factory对象，获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        // 测试查询的方法 2个参数：arg0查询JavaBean的class对象 arg1主键的值
        Customer c = session.get(Customer.class, 7L);

        // 删除客户
        session.delete(c);

        // 提交事务
        tr.commit();
        // 释放资源
        session.close();
    }

    /**
     * 测试get()方法，获取查询，通过主键来查询一条记录
     */
    @Test
    public void testGet(){
        // 原来：加载配置文件，获取Factory对象，获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        // 测试查询的方法 2个参数：arg0查询JavaBean的class对象 arg1主键的值
        Customer c = session.get(Customer.class, 7L);
        System.out.println(c);
        // 提交事务
        tr.commit();
        // 释放资源
        session.close();
    }

    /**
     * 测试工具类
     */
    @Test
    public void testSave2(){
        // 原来：加载配置文件，获取Factory对象，获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();
        Customer c = new Customer();
        c.setCust_name("小风");
        session.save(c);
        // 提交事务
        tr.commit();
        // 释放资源
        session.close();
    }

    /**
     * 测试保存客户
     */
    @Test
    public void testSave(){
        /**
         *  1. 先加载配置文件
         *  2. 创建SessionFactory对象，生成Session对象
         *  3. 创建session对象
         *  4. 开启事务
         *  5. 编写保存的代码
         *  6. 提交事务
         *  7. 释放资源
         */
        /*// 1. 先加载配置文件
        Configuration config = new Configuration();
        // 默认加载src目录下hibernate.cfg.xml的配置文件
        config.configure();
        // 了解，手动加载
        // config.addResource("com/itheima/domain/Customer.hbm.xml");
         */     

        // 简写的方法
        Configuration config = new Configuration().configure();

        // 2. 创建SessionFactory对象
        SessionFactory factory = config.buildSessionFactory();
        // 3. 创建session对象
        Session session = factory.openSession();
        // 4. 开启事务
        Transaction tr = session.beginTransaction();

        // 5. 编写保存的代码
        Customer c = new Customer();
        // c.setCust_id(cust_id);   主键是自动递增了
        c.setCust_name("测试3");
        c.setCust_level("2");
        c.setCust_phone("110");

        // 保存数据，操作对象就相当于操作数据库的表结构
        session.save(c);

        // 6. 提交事务
        tr.commit();
        // 7. 释放资源
        session.close();
        factory.close();
    }

}