HibernateDay01(框架的搭建 核心和基本文件配置 基础crud)

1、CRM
    CRM（Customer Relationship Management）客户关系管理，利用相应的信息技术以及互联网技术来协调企业和客户间在销售、营销和服务商的交互，
    向客户通过创新式的个性化的客户交互和服务的过程。

    其最终目标是将面向客户的各项信息和活动集成起来，组建一个以客户为中心的企业，实现对面向客户的活动的全面管理
2、CRM的模块
    CRM系统熟悉了对企业销售、营销、服务等各阶段的客户信息、客户获得进行统一管理
    CRM系统功能涵盖企业销售、营销、用户服务等各各业务流程，业务流程中与客户相关获得都会在CRM系统统一管理
    基本的功能模块
        客户信息管理
        联系人管理
        商机管理
        统计分析等

Hirbernate框架概述
1、Hibernate     
    是一个开放源代码的对象关系映射（ORM）框架，对JDBC进行了非常轻量级的对象封装，使得JAVA程序员可以使用对象编程思维来操纵数据库

    可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/jsp的web应用中使用
    是轻量级JAVAEE应用的持久层解决方案，是一个关系数据库ORM框架

2、Hibernate是一个持久层的ORM框架

ORM映射 
1、Object Relational Mapping
    O：面向对象领域的Object（JavaBean对象）
    R：关系数据库领域的Relational（表的结构）
    M：映射Mapping（XML的配置文件）
2、Hibernate通过操作对象的方式来操作数据库表记录

优点
    对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码
    基于Jdbc的主流持久化框架，是一个优秀的orm实现，很大程度的简化了dao层编码工作
    性能非常好，是一个轻量级框架，映射的灵活性很出色，支持很多关系型数据库，从一对多到多对多的各种复杂关系
    EJB:SUN公司提供编写JavaEE的整体框架【重量级】

下载相应的jar包
    http://sourceforge.net/projects/hibernate/files/hibernate-orm/5.0.7.Final/hibernate-release-5.0.7.Final.zip/download

创建类与表结构的映射
在JavaBean所在的包下创建映射的配置文件
    默认的命名规则为：实体类名.hbm.xml
    在xml配置文件中引入约束（引入的是hibernate3.0的dtd约束，不要引入4的约束）
        <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EB"
         "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

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

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

Hibernate核心的配置文件    
hibernate-release-5.0.7.Final\project\etc 可以看hibernate.cfg.xml配置不同数据库文件的格式

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

Hibernate配置文件之映射配置文件
1、映射文件，即Stu.hbm.xml的配置文件
    <class>标签           用来将类与数据库表建立映射关系
        name            类的全路径
        table           表名（类名与表名一致，那么table属性也可以忽略）
        catalog         数据库的名称，基本都会省略不写

    <id>标签              用来将类中的属性与表中的主键建立映射，id标签就是用来配置主键的
        name            类中属性名
        column          类中的字段名，（如果类中的属性名和表中的字段名一致，那么column可以省略）
        length          字段的长度，如果数据库已经创建好了，那么length可以不写，如果没有创建好，生成表结构时，length最好指定

    <property>          用来将类中的普通属性与表中的字段建立映射
        name            类中属性名
        column          表中的字段名（如果类中的属性名与表中的字段名一致，那么column可以省略）
        length          数据长度
        type            数据类型（一般不需要写，如果写要按照规则来编写）
            Hibernate的数据类型 type="string"
            Java的数据类型      type="java.lang.String"
            数据库字段的数据类型 <column name="name" sql-type="varchar"/>

核心配置文件
1、核心配置文件的两种方式
    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>
        优点
            格式比较清晰
            编写有提示
            可以在该配置文件中加载映射的配置文件（最主要）
2、关于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="my/hibernate/domain/User.hbm.xml"

Configuration类和作用
1、Configuration类
    Configuration对象用于配置并启动Hibernate
    Hibernate应用通过该对象来获取对象-关系映射文件中的元数据，以及动态配置Hibernate的属性，然后创建SessionFactory对象

    一句话：加载Hibernate的配置文件，可以获取SessionFactory对象

2、Configuration类的其他应用
    加载配置文件的种类，Hibernate支持xml和properties类型的配置文件，在开发中基本都使用XML配置文件的方式
        如果才有properties的配置，那么通过Configuration configuration = new Configuration(),就可以加载配置文件
            但是需要自己手动加载映射文件
            例如config.addResource("my/customer/Customer.hbm.xml");

        如果采用XML配置文件 通过Configuration configuration = new Configuration().configure();加载配置文件

SessionFactory
1、是工厂类，是生成Session对象的工厂类
2、SessionFactory类的特点
    由Configuration通过加载配置文件创建对象
    SessionFactory对象中保存了当前的数据库配置信息和所有映射关系以及预定义的SQL语句，同时，SessionFactory还负责维护Hibernate的耳机缓存
        预定义SQL语句
            使用Configuration类创建了SessionFactory对象时，已经在SessionFactory对象中缓存了一些SQL语句
            创建的SQL语句是增删改查（通过主键来查询）
            这样做的目的是效率更高

    一个SessionFactory实例对应一个数据库，应用从该对象中获取Session实例
    SessionFactory是线程安全的，意味着一个实例可以被应用的多个线程共享
    SessionFactory是重量级的，意味着不能随意创建或销毁它的实例。
    如果只访问一个数据库，只需要创建一个SessionFactory实例，且在应用初始化的时候完成

    SessionFactory需要一个较大的缓存，用来存放预定义的SQL语句以及实体的映射信息，
    另外可以配置一个缓存插件，这个插件被称为Hibernate的二级缓存，被多线程所共享
3、总结
    一般应用使用一个SessionFactory，最好是应用启动时就完成初始化

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

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

3、常用的方法
    save(obj)
    delete(obj)
    get(Class.id)
    update(obj)
    saveOrUpdate(obj)       保存或者修改（如果没有数据，保存数据，如果有，修改数据）
    createQuery()           HQL语句的查询的方式 ("from Customer")

Transaction接口
1、Transaction是事务的接口
2、常用的方法
    commit()    提交事务
    rollback()  回滚事务
3、特点
    Hibernate框架默认情况下事务不自动提交，需要手动提交事务
    如果没有开启事务，那么每个Session的操作，都相当于一个独立的事务

domain&sql

public class 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) NOT NULL COMMENT '客户信息来源',
     `cust_industry` VARCHAR(32) NOT NULL COMMENT '客户所属行业',
     `cust_level` VARCHAR(32) NOT NULL COMMENT '客户级别',
     `cust_linkman` VARCHAR(64) NOT NULL COMMENT '联系人',
     `cust_phone` VARCHAR(64) NOT NULL COMMENT '固定电话',
     `cust_mobile` VARCHAR(64) NOT NULL COMMENT '移动电话',
      PRIMARY KEY(`cust_id`)
 */
    //以后使用包装类，默认值是null 更符合实际
    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;
    private String info;

hibernate.cfg.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>
    <!-- 先配置SessionFactory标签：一个数据库对应一个SessionFactory -->
    <session-factory>
        <!-- 必须要配置的参数有5个，4大参数，数据库的方言 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_day01</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123</property>
        <!-- 数据库的方言(使用不同的数据库) -->
        <property name="hibernate.dialet">org.hibernate.dialect.MySQLDialect</property>
        <!-- 可选配置 -->
        <!-- 显示SQL语句，在控制台显示 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 格式化SQL语句 -->
        <property name="hibernate.format_sql">true</property>
        <!-- 生成数据库的表结构 
            create 删掉之前的重新创建一般用来测试 create-drop删了之前了创建完再删
            update：如果没有表结构，创建表结构。如果存在，不会创建，添加数据
            validate:进行校验 如果字段和数据库中的不同会报错
        -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        <!-- 映射配置文件，需要引入映射的配置文件 -->
        <mapping resource="my/customer/Customer.hbm.xml"/>
    </session-factory>
</hibernate-configuration>  

Customer.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>
    <!-- 配置类和表结构的映射 -->
    <class name="my.customer.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"/>
        <property name="info" column="info"/>

    </class>
</hibernate-mapping>

Demo 测试crud

/**
 * 测试hibernate
 * @author Administrator
 *
 */
public class Demo1 {
    /**
     * 测试保存客户
     */
    @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("");
        //简写的方法
        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("测试11");
        c.setCust_level("2");
        c.setCust_phone("110"); 
//      c.setCust_create_id((long) 11.1);
//      c.setCust_industry("abc");
//      c.setCust_linkman("a");
//      c.setCust_mobile("112");
//      c.setCust_source("sds");
//      c.setCust_user_id((long) 11);

        //保存数据，操作对象就相当于操作数据库的表结构
        session.save(c);
        //6、提交事务
        tr.commit();
        //7、释放资源
        session.close();
        factory.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();

    }
    /**
     * 测试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,1L );
        System.out.println(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,1L );

        //删除客户
        session.delete(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,2L );

        //设置客户的信息
        c.setCust_name("wide");
        c.setCust_level("3");
        //修改
        session.update(c);
        //提交事务
        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(1L);//千万不能自己设置主键id值
        c.setCust_name("aa");
        session.saveOrUpdate(c);*/
        //先查询再改
        Customer c = session.get(Customer.class, 6L);
        c.setCust_name("word");

        session.saveOrUpdate(c);
        //提交事务
        tr.commit();
        //释放资源  工厂一个项目一个不用释放
        session.close();

    }

    /**
     * 测试查询的方法
     */
    @Test
    public void testSel() {
        //原来：加载配置文件，获取Factory对象，获取session
        Session session = HibernateUtils.getSession();
        Transaction tr = session.beginTransaction();

        //创建查询的接口
        Query query =  session.createQuery("from Customer");//hql
        //查询所有的数据 select * from 表
        List<Customer> list = query.list();
        for(Customer c :list) {
            System.out.println(c);
        }
        //提交事务
        tr.commit();
        //释放资源  工厂一个项目一个不用释放
        session.close();

    }
    /**
     * 测试保存
     */
    @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("abc");
            //保存
            session.save(c);
            //提交事务
            tr.commit();
        } catch(Exception e) {
            //回滚事务
            tr.rollback();
            e.printStackTrace();

        } finally {
            //释放资源
            session.close();
        }

    }
}

dao

public class CustomerDao {

    /**
     * 保存客户
     */
    public void save(Customer c) {
        //先获取session
        Session session = HibernateUtils.getSession();
        //开启事务
        Transaction tr = session.beginTransaction();
        //保存用户
        session.save(c);
        //提交事务
        tr.commit();
        //关闭资源
        session.close();
    }
}

Service

public class CustomerService {

    /**
     * 保存客户
     * @param c
     */
    public void saveCustomer(Customer c) {
        new CustomerDao().save(c);
    }
}

Servlet

@WebServlet("/saveCustomer")
public class saveCustomer extends HttpServlet {
    private static final long serialVersionUID = 1L;

    /**
     * @see HttpServlet#HttpServlet()
     */
    public saveCustomer() {
        super();
        // TODO Auto-generated constructor stub
    }


    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //接受请求的参数
        request.setCharacterEncoding("utf-8");
        Map<String,String[]> map = request.getParameterMap();
        //封装数据，使用BeanUtils工具
        Customer c = new Customer();
        try {
            //封装数据
            BeanUtils.populate(c, map);
            //调用业务层
            new CustomerService().saveCustomer(c);
            System.out.println("成功了");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

}

HibernateUtils

/**
 * Hibernate框架的工具类
 * @author Administrator
 *
 */
public class HibernateUtils {
    //ctrl + shift + x 大写
    private static final Configuration CONFIG;
    private static final SessionFactory FACTORY;

    //编写静态代码块
    static {
        //加载XML的配置文件
        CONFIG = new Configuration().configure();
        //构建工厂
        FACTORY = CONFIG.buildSessionFactory();
    }

    /**
     * 从工厂中获取Session对象
     * @return
     */
    public static Session getSession() {
        return FACTORY.openSession();
    }
}