Hibernate框架详解

■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■↓↓↓↓↓↓↓↓↓ Ｈｉｂｅｒｎａｔｅ框架 ↓↓↓↓↓↓↓↓↓↓↓■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■


Hibernate框架；
     为什么要有？
      框架是为了简化开发人员的代码,
      和提高开发人员的开发效率，
      而在现时的项目中都是基于MVC三层架构的，
      可是在dao层中的代码出现大量的冗余，
     
      因为这些冗余代码基本只是对数据操作方式的不同，从而只有小部分代码不同而已。
     
     
     
     是什么？
    是一个应用于MVC三层开发架构中的dao层的框架，是由一群Java爱好者开发的。
     
           
     作用；
        可以简化MVC三层开发架构的dao层开发的代码，以及提高开发效率
        
        
     特点；
        1.基于ORM思想的一个框架
        2.对dao层的代码封装的很深，从而使得效率有点低下。
  3.对数据库是强事务的操作
◆ 4.底层对JDBC的代码封装
◆ 5.在一定的程度上是一个强主键的dao层框架，
  因为Hibernate框架对数据操作都是按照id进行操作的。
  ◆◆◆建议；创建表的时候，必须要有id
 
  6.是使用代理类对需要进行操作的数据类进代理模式的操作
  7.是实现了JPA接口(标准)【JPA是SUN公司定义用于ORM思想框架对Java的实现标准】


◆◆◆注；Hibernate只有对单表进行操作的时候是一个轻量级的框架。




----------------------------↓↓↓↓↓↓↓↓↓ Ｈｉｂｅｒｎａｔｅ框架　——　ＯＲＭ思想 ↓↓↓↓↓↓↓↓↓↓↓-------------------------------------------




ORM思想；
是什么？
Object Relation Mappping 对象关系映射，是一个dao层框架的设计思想。


使用效果；
Java开发人员只是需要管理对象，间接的管理与数据之间的关系 


好处；
    1) 面向对象
    2) 可以不写sql语句
    3) 查询更加方便，因为直接返回对象


弊端；
    1) 如果封装的越复杂，对ORM思想的封装越彻底则越慢
    

基于ORM思想框架；
DBUtils ---> 是一个简单的ORM思想的框架不纯粹。
Hibernate ---> 是一个相对复杂的ORM思想的框架，相对的纯粹。
MyBatis ---> 是一个一般的ORM思想的框架
TopLink ---> 是IBM的框架的
。。。。。。

速度(快)的比较；
      DBUtils ---> MyBatis ---> Hibernate      
         







----------------------------↓↓↓↓↓↓↓↓↓ Ｈｉｂｅｒｎａｔｅ框架基本开发步骤 ↓↓↓↓↓↓↓↓↓↓↓-------------------------------------------




Hibernate开发步骤；
 1.导包
  必须要导入\lib\required文件夹中的所有jar包，
  因为这个包的所有jar包都是Hibernate框架的必须包。
 
 2.编写Hibernate启动配置文件 ---> 看 00_框架.txt ---> 现用框架设计的基本设计
 
   必配；
  A_ 配置连接数据库基本参数

B_ 配置数据库的运行环境

C_ 建数据库表

D_ 建立javaBean，和数据库的表映射的JavaBean

E_ 创建表-对象映射文件
i) 配置ORM映射 ---> Object Relation Mapping 对象关系映射

 3. 编写对数据库进行操作的代码
 
i) 编写读取src下的hibernate.cfg.xml文件的对象

ii) 创建服务注册器对象

iii) 使用读取sec下的hibernate.cfg.xml文件类的，
方法创建会话工厂对象维护所有的映射文件

iiii) 使用会话工厂对象创建具体的会话对象

iiiii) 使用具体的会话对象对数据库的数据进行操作

◆◆◆◆◆◆记得开启事务，关闭事务，关闭连接









----------------------------↓↓↓↓↓↓↓↓↓ Ｈｉｂｅｒｎａｔｅ框架基本开发实现 ↓↓↓↓↓↓↓↓↓↓↓-------------------------------------------



基本开发实现；
    1.导包
  antlr-2.7.7.jar    〓 ---> Hierbante辅助包
  dom4j-1.6.1.jar    〓 ---> dom4J技术对xml文件解析包
  hibernate-commons-annotations-4.0.5.Final.jar 〓 ---> Hibernate注解核心包 
  hibernate-core-4.3.8.Final.jar           〓 ---> Hibernate框架核心包
  hibernate-jpa-2.1-api-1.0.0.Final.jar 〓 ---> JPA框架支持包，融合了JPA框架
  jandex-1.1.0.Final.jar 〓 ---> Hibernate辅助包
  javassist-3.18.1-GA.jar       〓 ---> 字节码辅助包
  jboss-logging-3.1.3.GA.jar      〓 ---> 日志包
  jboss-logging-annotations-1.2.0.Beta1.jar   〓 ---> 注解日志包
  jboss-transaction-api_1.2_spec-1.0.0.Final.jar  〓 ---> 事务支持包




    2.编写Hibernate框架启动配置文件
  
  ◆建议；先确定表，确定对象在编写配置文件    

A_ 建立数据库表

B_ 创建对应的映射javaBean类

   ◆◆ Ｃ_ 编写类和数据库表的映射文件

  a)引入Hibernate框架核心包下的映射dtd约束文件，位于Hibernate核心jar包下的org.hibernate
   "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
   "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

  b) 根据dtd映射约束文件编写相应的代码























  ◆◆◆映射文件小结；
    1.如果name的值和column的值相同则column可以省略不写

    2.在使用组件策略的时候是使用数据库或Hibernate框架维护，
        那么则开发人员赋值可能无效，只会使用底层自动生成的值

◆◆ 3.映射的文件名建议是；javaBean映射类 + .hbm.xml命名，
◆◆◆ 并且一个javaBean映射类对应一个*.hbm.xml文件
 
 ◆ 4.在使用··维护主键策略的时候，
  之前设置的主键的值必须要是符合这个底层维护的
    
    5.在使用type属性的时候最好使用数据库的类型，
    因为避免类型的变化和预想的类型不一样，如类型的大小等......
    
    6.建议；javaBean映射类的属性和数据库的表的字段名相同，便于后期的维护。
    
    7.建议；在当前javaBean映射类的包下创建映射文件
 
 ◆ 8.属性技巧；
         name 是类属性或类
         column 是表或字段
         key 是表
◆◆◆重◆◆◆注；因为Hibernate框架的对数据库的数据进行操作基本都是通过表的主键，
◆◆◆所以在建立表的时候必须要赋予一个主键。


   
   ◆◆ Ｄ_编写Hibernate配置文件；

 a) 引入Hierbante框架核心包下的dtd约束文件，位于Hibernate核心jar包下的org.hibernate
---> ▲▲▲注意；映射文件的dtd，文件名

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

 b) 根据dtd配置约束文件编写相应的代码
 
 
 
 
  com.mysql.jdbc.Driver
  jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
  xxx
  xxx
 
 
  org.hibernate.dialect.MySQL5InnoDBDialect
 
 
 
 
 
 
 
  是设置如果没有表则创建，
      并且只会创建一次，如果有了表则直接对这个表进行维护
 
  create ---> 是使用每一次对数据库的数据进行操作的时候，
  旧表都会删除，重新创建一张新的表。
  -->
  update
 
 
 
 
 

◆◆◆◆◆注；一般是要设置某一个文件的路径，那么则是使用 ( / ) 
如果是设置某一个类的路径则是 ( . )




   ◆◆ Ｅ.编写对应的类连接数据库，并且对数据库的数据进行操作
   
    //1.调用Configuration的方法读取src下的hibernate.cfg.xml文件
   
    Configuration config = new Configuration().configure();
   
    //另；在3.0之前是直接使用Configuration的方法创建SessionFacotry对象
       // SessionFactory before = config.buildSessionFactory();
   
    //2.创建服务注册器对象，这个是在3.0之后推出的 ---> 速度可能快一点
   
    ServiceRegistry registry = new StandardServiceRegistryBuilder().applySettings(config.getProperties()).build();
   
    //3.使用Configuration的方法创建SessionFactory对象传入一个服务注册器对象
    //作用；SessionFactory类是使用加载所有的javaBean映射类的映射文件的

SessionFactory factory = registry.buildSessionFactory(registry);

//4.使用SessionFactory类的方法获取到具体的Session对象

Session session = factory.openSession();

//5.因为Hibernate框架是一个强事务的框架，所以必须要开启事物

session.beginTransaction();

//6.使用Session类的方法对数据库的数据进行操作

Student stu = new Student("小明",16);
session.save(stu);

//7.提交事务

session.getTransaction().commit();

//8.关闭连接

session.close;
factory.close();

◆◆◆◆◆注意；必须要开启事务和提交事务，
否则如果对数据库的数据进行操作的话则会无效



映射文件的type属性；
  type 是设置这个映射类属性对应的数据库类型
  而这个设置的类型的值有三种，hibernate、数据库、Java_API

+------>  对象的常用类型值；  
|   Java_API hibernate MySql
|     ↓↓↓   ↓↓↓ ↓↓↓
|   文件；    
| java.util.String string/text       varchar/text/longtext
| Java.util.Byte[]【数组[]】  binary       blob/mediumblob/longblob
|   
|   整数；
| java.lang.Integer integer       int
| java.lang.Short short       short
|   
|   小数；
| java.lang.Double double       double
| java.lang.Float float               float
|   
|   日期；
| java.lang.Date date       date/datetime/timpstamp
|
|
|
|
|
|
|  
|  
|  
|
|
|
|
|
|
————====|========———————=======〓〓〓 Ｈｉｂｅｒｎａｔｅ框架对数据基本操作 〓〓〓======——————————=============———————————————————————————————————
|
|
| Hibernate对数据基本操作；
| 为什么要有？
| 因为Hibernate框架是一个在MVC＋三层开发模式的开发中是位于dao层的，
| 而dao层是对数据库的数据进行操作的。
|
| 所以Hibernate框架必须要可以对数据库的数据进行操作。
|
| 特点；
|     1.都是使用Session类的方法对数据库的数据进行操作
|     2.必须要开启事务，因为hibernate是强事务的
|     
|     
|     
|     
|     
--------|------------------------------↓↓↓↓↓↓↓↓↓ 对数据进行添加操作 ↓↓↓↓↓↓↓↓↓↓↓-------------------------------------------
|
|     
| 对数据添加操作；
| 1.创建表   ---> test
| 2.创建对应的javaBean映射类   ---> Student
| 3.编写类映射文件   ---> student.hbm.xml
| 4.编写hibernate配置文件 ---> hibernate.cfg.xml
|
| 5.编写对数据库数据操作的代码
|
| //1.使用Configuration的方法读取src下的hibernate.cfg.xml文件，并且获取到Configuration对象     
|     Configuration config = new Configuration().configure();
|     
| //2.创建一个服务注册器对象
| //传入config.getProperties()方法的数据，
//使用hibernate.cfg.xml文件配置的连接数据库的参数
|     ServiceRegistry registry = new StandardServiceResgitryBuild().applySettings(config.getProperties()).build();
|     
| //3.使用Configuration的方法传入一个ServiceRegistry对象创建SessionFactory对象，维护所有的映射文件
|     SessionFactory factory = config.buildSessionFactory(resgitry);
|
| //4.使用SessionFactory的方法获取到具体的Session对象
|     Session session = factory.openSession();
|
| //5.因为hibenrate是一个强事务的框架，所以必须要开启事务
|     session.beginTransaction();
|
| //6.使用Session类的方法对数据库的数据进行···保存···操作
|     
|     a_ 方式一；使用save()方法进行保存数据，如果主键是手动的，那么则相同的主键则报错
|     Student s = new Student();
|     s.setName("小宝");
|     s.setAge(18);
|     
|     session.save(s)
|
|     b_ 方式二；使用saveOrUpdate()方法保存数据，如果主键相同则不会报错会进行一个更改操作
| session.saveOrUpdate();
|
| //提交事务
|     session.getTransaction().commit();
|
| //关闭连接
|     session.close();
|     session.close();
|     
|
|
|  
|  
--------|------------------------------↓↓↓↓↓↓↓↓↓ 对数据进行查找操作 ↓↓↓↓↓↓↓↓↓↓↓-------------------------------------------
|
|
| 对数据查找操作；
| 1.创建表   ---> test
| 2.创建javaBean映射类   ---> Student
| 3.编写类映射文件   ---> student.hbm.xml
| 4.编写配置文件   ---> hibernate.cfg.xml
|
| 5. 编写对数据库数据进行操作代码
|
| //1.使用Configuration的方法读取src下的hibernate.cfg.xml文件
| Configuration config = new Configuration().configure();
|
| //2.创建服务注册器对象
| //传入config.getProperties()方法的数据，
//使用hibernate.cfg.xml文件配置的连接数据库的参数
| ServiceRegistry registry = new StandardServiceRegistryBuilder().applySettings(config.getProperties()).build();
|
| //3.使用Configuration的方法传入一个服务注册器对象创建SessionFactory对象，用于维护所有的映射文件
| SessionFactory factory = config.buildSessionFactory(registry);
|
| //4.使用SessionFactory方法，创建一个具体的Session对象
| Session session = factory.openSession();
|
| //5.Hibernate是一个强事务的dao层框架所以要开启事物
| session.beginTransaction();
|
| //6.使用Session类的方法对数据库的数据进行···查找···操作
|
| a_ 方式一；用get()方法，传入一个对应的javaBean映射类的类对象，
| 并且通过传入一个数据库的主键的值，因为主键是唯一。
| ---> 获取某一个具体数据
| Student stu = (Student)session.get(Student.class,1);
|
| b_ 方式二；用load()方法，传入对应javaBean映射类的类对象，
| 并且通过传入一个数据库的主键的值，因为主键是唯一。
| load()和get()有区别↓↓↓立即加载vs延迟加载
|
| Student stu = (Student)session.load(Student.class,1);
|
| c_ 方式三；使用hibernate定义的对数据库操作的语句 ---> 获取所有的数据
|
| Query query = session.createQuery("select s from Student s");
| List list = query.list();
|
| for(Student s : list){
| sysout(s);
| }
|
|
| c_ 方式四；使用hibernate定义HQL语句的对数据库操作的语句，定义的是预定义的语句
|
| Query query = session.createQuery("select s from Student s where id=?");
|
| ◆◆◆ //对于预定义语句的值，必须是从0开始的
| query.setParameter(0,1);
|
| Student s = (Student)query.uniqueResult();
|
| d_ 方式五；使用hibernate定义的QBC语句的对数据查找的语句，也是有预定义的值的
|
| Criteria criteria = session.createCriteria("select s from Student s where id=2");
| //使用Restrictions的对应数据库的语句，存入对应的属性字段名，并且设置值
| crriteria.add(Restrictions.eq("salary",6000));
| List stu = critera.list();
| for(Student s : list){
| sysout(s);
| }
|
| //7.提交事务
| session.getTransaction().commit();
|
| //8.关闭连接
| sesion.close();
| factory.close();
|
|
| ◆◆◆具体查找语句看↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓Ｈｉｂｅｒｎａｔｅ框架查询数据
|
| ◆◆◆注；查找数据，并没有对数据起到了操作的作用，
| 所有也可以不开启事务，但是开启事务符合标准规范。     
|     
| ◆◆◆注；在使用Hibernate定义的对数据库的数据进行查找的语句，
| 如果返回的是多个对象，则是使用list()方法，
| 如果是单个则使用uqueResult()方法。
|     
|     
--------|------------------------------↓↓↓↓↓↓↓↓↓ 对数据进行更新操作 ↓↓↓↓↓↓↓↓↓↓↓-------------------------------------------
|
|
| 对数据更新操作；
| 1.创建表   ---> test
| 2.创建对应的javaBean映射类对象   ---> Student
| 3.编写类映射文件   ---> student.hbm.xml
| 4.编写配置文件   ---> hibernate.cfg.xml
|
| 5.编写对数据库操作的代码
|
| //1.使用Configuration的方法读取src文件下的hibernate.cfg.xml文件
| Configuration config = new Configuration().configure();
|
| //2.创建服务注册器对象，注册服务器连接
| //传入config.getProperties()方法的数据，
//使用hibernate.cfg.xml文件配置的连接数据库的参数
| ServiceRegistry registry = new StandardServiceRegisryBuilder().applySettings(config.getProperties()).build();
|
| //3.使用Configuration的方法传入一个服务注册器对象创建SessionFactory对象，用于维护所有的映射文件
| SessionFactory factory = config.build(registry);
|
| //4.创建具体的Session对象
| Session session = factory.openSession();
|
| //5.因为Hibernate是一个强事务的框架，所以要开启事务
| session.getTransaction();
|
| //6.使用Session的方法对数据库的数据进行···更改···的操作
|
| a_ 方式一；定义一个需要更改的对应的javaBean映射类，使用Session的方法进行操作
| Student s = new Student();
| s.setId(2);
| s.setName("小明");
| s.setAge(20);
|
| session.update(s);
|
| c_ 方法二；使用saveOrUpdate()方法，没有数据则保存，有数据则进行更改
| session.saveOrUpdate(s);
|
| b_ 方式二；使用查找出来的对象，对这个对象的数据进行更改并且提交
| Student s = (Student) session.get(Student.class,2);
| s.setName("小黑");
| s.setAge(18);
|
|
|
| //7.提交事务
| session.getTransaction().commit();
|
| //8.关闭连接
| session.close();
| session.close();
|
| ◆◆◆建议；使用先查找后修改的方式
|
|
|
|     
|     
|     
--------|------------------------------↓↓↓↓↓↓↓↓↓ 对数据进行删除操作 ↓↓↓↓↓↓↓↓↓↓↓-------------------------------------------
|
|
| 对数据删除操作；
| 1.创建表 ---> test
| 2.创建对象的javaBean映射类 ---> Student
| 3.配置对象的类的映射文件 --->  student.hbm.xml
| 4.编写hibernate框架的配置文件 ---> hibernate.cfg.xml
|
| 5.编写对数据库数据进行操作的代码
|
| //1.使用Configuration的方法读取src下的hibernate.cfg.xml文件
| Configuration config = new Configuration().configure();
|
| //2.创建服务注册器对象
| //传入config.getProperties()方法的数据，
| //使用hibernate.cfg.xml文件配置的连接数据库的参数
| ServiceRegistry registry = new StandardServiceRehgistryBuilder().applySettings(config.getProperty).build();
|
| //3.使用Configuration类的方法传入一个ServiceRegistry对象创建SessionFactory对象用于维护所有的的映射文件
| SessionFactory factory = config.buildSessionFactory(registry);
|
| //4.使用SessionFactory的方法创建具体的Session对象
| Session session = config.openSession();
|
| //5.因为Hibernate框架是一个强事务的dao层的框架，所以要开启事物
| session.beginTransaction();
|
| //6.使用Session的方法对数据库的数据进行···删除···操作
|
| ◆建议；先查找在删除，可以避免各种问题......
|
| a_ 使用查找到的对象进行删除，因为查找到的对象包括了主键
| Student s = session.get(Student.class,1);
| session.delete(s);
|
| b_ 自定义一个对象，因为Hibernate是根据主键进行删除的， ---> 不建议
| 所以只需要设置这个对象的主键的值就可以了。
| Student s = new Student();
| s.setId(5);
| session.delete(s);
|
| //提交事务
| session.commit();
|
| //关闭连接
| session.close();
| factory.close();
|
|
|
|
|
————————|—————————————————————————————————— Ｈｉｂｅｒｎａｔｅ框架 —— 存储文件 —————————————————————————————————————————————————————————————————————
|
|
| 存储文件；
| 为什么要存储文件？
| 虽然数据库资源很宝贵，所以不建议存储数据，
| 但是有一些机密的数据需要存储到数据库中。
|  
| 特点；必须要使用对应的类型进行操作
|
| 文件类型；
+---------------------->  二进制类型；↑↑↑↑↑↑↑↑↑↑↑↑看上类型↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ ---> byte[] 
+---------------------->  文本类型；↑↑↑↑↑↑↑↑↑↑↑↑↑看上类型↑↑↑↑↑↑↑↑↑↑↑↑↑↑ ---> String









-------------------------↓↓↓↓↓↓↓↓↓ Ｈｉｂｅｒｎａｔｅ框架 —— 存储文件实现代码 ↓↓↓↓↓↓↓↓↓↓↓-------------------------------------------
 
  
文件实现代码；
    1.创建表 ---> test === 要有对应的文件类型的字段                    <--|
    2.创建javaBean映射类 ---> Student === 必须要有对应的文件类型的属性 <--|
    3.编写类映射文件 ---> studen.cfg.xml
    4.编写hibernate配置文件 ---> hibernate.cfg.xml
    
    5.操作文件数据实现代码
    //1.创建Configuration对象，使用这个类的方法读取src下的hibernate.cfg.xml文件
    Configuration config = new Configuration().configure();
   
    //2.创建ServiceRegistry对象
    //传入config.getProperties()方法的数据，
//使用hibernate.cfg.xml文件配置的连接数据库的参数
    ServiceRegistry registry = new StandardServiceResgiryBuilder().applySeyttings(config.getProperties()).build();
   
    //3.使用Configuration的方法传入一个注册服务的对象用于创建SessionFactory对象，用于维护所有的映射文件
    SessionFactory factory = config.buildSessionFactory(registry);
   
    //4.使用会话工厂对象的方法创建具体的Session对象
    Session session = factory.openSession();
   
    //5.因为Hibernate是一个强事务的dao层框架，所以要开启事物
    session.beginTransaction();
   
    //6.使用session的方法对数据进行保存 


———————=============———————=======〓〓〓 Ｈｉｂｅｒｎａｔｅ框架数据映射 〓〓〓======——————————=============———————————————————————————————————


数据映射；
为什么要有？
在各种项目的数据存放到数据库中，
一个项目基本都会有几个表等，
但是这些表之间可能有关联，
那么在使用Hibernate对数据库的数据进行查找的时候，
怎么查找出关联的数据？


是什么？
是Hibernate定义的一个重要的功能。


作用；
     用于查询数据库的表数据的时候，也查询到这个表的关联表的数据。
 
 
特点；
     1.都是有关联关系的。
     2.数据库最少有两张表
       



----------------------------------------- Ｈｉｂｅｒｎａｔｅ框架数据映射分类 -----------------------------------------


数据映射分类；
    类型分类；
         基本属性映射；
       Set集合
       List集合
       Map集合
       
    ◆注；普通的属性映射，使用集合的时候，
    是按照使用的这个集合的特性进行使用的。
    如；Set是无序的，那么存放则是无序的
   
            
         对象映射；
一对多 ---> 单向
    多对一 ---> 单向
   
    一对多(多对一) ---> 单向
               
                多对多 ---> 双向
一对一 ---> 双向/单向


——————————————————————————————————— Ｈｉｂｅｒｎａｔｅ框架基本类型映射实现代码 ———————————————————————————————————————————————————————

------------------------------------------------ Ｓｅｔ集合映射 -------------------------------------------------------


Set集合
   特点；无序，在一次使用(存储到集合)的时候不可重复，
    如果这个对象在集合中销毁了才可以重复
   
a_ 创建表 ---> student
b_ 创建对应的表的javaBean类 ---> Student

▲ 在编写这个类的时候需要指定集合成员变量,并且提供对应的get()和set()方法
Set address;

◆◆◆ 建议；加上泛型，可以控制数据的完整性和安全性

c_ 编写hibernate.cfg.xml文件
d_ 编写对应的类的映射文件

▲ 编写对应的集合成员变量的表映射


   
   


说明；
    是用于配置对应javaBean映射类的Set集合成员变量
    name 是这个成员变量位于这个javaBean的成员变量名
   
    是设置这个副表和主表之间的外键
    column 是这个副表的外键字段名，会自动使用主键的

是设置这个副表存放数据的字段，
因为在集合中是存放数据的，
而集合中的数据中就是存放到数据库的。

type 可以查看↑↑↑↑↑↑↑↑Ｈｉｂｅｒｎａｔｅ框架基本开发实现,
映射文件的type属性。
column 是可以设置这个集合的数据存放的字段

◆◆◆注；这些属性是必须要配置的，缺一不可。  



e_ 在操作类中编写代码

//1.创建Configuration类对象，并且使用这个类的方法读取src下的hibernate配置文件
Configuration config = new Configuration().config();

//2.创建注册服务器对象
//传入config.getProperties()方法的数据，
//使用hibernate.cfg.xml文件配置的连接数据库的参数
ServiceRegistry registry = new StandardServiceRegistry().applySettings(config.getProperties()).build();

//3.通过Configutaion的方法创建SessionFactory对象，
// 用于维护所有的映射文件以及二级缓存，并且传入一个ServiceRegistry的对象
SessionFactory factory = config,buildSessionFactory(registry);

//4.使用会话工厂的方法创建一个具体的Session对象
Session session = factory.openSession();

//5.因为Hibernate框架是一个强事务的框架，所以必须要开启事务
session.beginTransaction();

//6.设置数据
Set set = new Set();
set.add("广州中山大道西");

Student stu = new Student();
stu.setAddress(set);

//7.提交事务
session.getTransaction().commit();

//8.关闭连接
session.close();
factory.close();





---------------------------------------------- Ｌｉｓｔ集合映射 -------------------------------------------------------


List集合；
     特点；有序，存储到集合的数据是可以重复的。
     
a_ 创建表 ---> student
b_ 创建对应的javaBean映射类对象 ---> Student

▲ 在Student映射类中需要创建这个List集合类型的成员变量，
并且必须要提供get()和set()方法。
List address;

◆◆◆ 建议；加上泛型，可以控制数据的完整性和安全性

c_ 编写对应的javaBean类的映射文件

▲ 编写javaBean类的List集合成员变量的映射







说明；
    是定义这个映射类中的List集合的属性的数据映射
    name 是这个List集合在映射类中的成员变量名
   
是设置当前这个类位于这个集合对应的数据库表(副表)的外键
column 是这个外键的字段名

因为List集合是一个有序的，
而如果是使用主键(id)可能出现不符合有序(小到大)特点

如；删除了id=2的数据，那么则可能出现一个空行

column 是这个序号的值字段名

是这个集合数据的存储的字段

type 可以查看↑↑↑↑↑↑↑↑Ｈｉｂｅｒｎａｔｅ框架基本开发实现,
映射文件的type属性。
column 是指定这个字段的值
d_ 编写hibernate配置文件

e_ 编写操作数据的代码

//1.创建Configuration对象读取src下的hibernate.cfg.xml
Configuration config = new Configuration().configure();

//2.创建注册服务器对象，
//传入config.getProperties()方法的数据，
//使用hibernate.cfg.xml文件配置的连接数据库的参数
ServiceRegistry registry = new StandardServiceRegistry().applySettings(config.getProperties()).build();

//3.通过Configuration的方法传入服务注册的对象创建会话工厂对象，用于维护所有的映射文件和二级缓存。
SessionFactory factory = config.buildSessionFactory();

//4.通过会话工厂对象创建具体的会话
Session session = factory.buildSession();

//5.因为Hibernate框架是一个强事务的框架，所以要开启事物
session.beginTransaction();

//6.操作数据

List list = new List();
list.add("上海体育路");

Student student = new Student();
student.setList(list);

session.save(student);

//7.提交事务
session.getTransaction().commit();

//关闭连接
session.close();
factory.close();





------------------------------------------------ Ｍａｐ集合映射 -------------------------------------------------------


Map集合；
特点；保存在Map集合的数据，key是不可重复的，并且Map是无序的，但在映射中...... --->+
         |
 +<----------------------------------------------------------------------------------------+
 |
 |  a_ 创建表 ---> student
 |  b_ 创建表对应的javaBean映射类 ---> Student
 |  
 |   ▲ 在这个映射类中要创建一个Map集合类型的成员变量，并且提供get()和set()方法
 |
 | Map cargo;
 |
 |  c_ 编写javaBean类的映射文件
 |  
 |   ▲ 编写javaBean映射类的Map成员变量的映射
 |  
 |  
 |  
 |   说明；
 |