hibernate 1 连接数据库、操作表

ormapping(对象关系映射):数据库操作框架
缺点：
1.因为hql语句是hibernate内部自动生成，程序员干预不了，不可把控
2.功能比较复杂时不建议使用
优点：
1.比较简单。
2.有数据缓存，一级缓存二级缓存 查询缓存。
3.移置性好
jdbc:
缺点：
1.代码繁琐
2.频繁地进行try...catch
3.没有数据缓存
4。移置性不好(更换数据库)
有点：
1.速度比较快
2.把控性比较好

***.hbm.xml(映射文件) 的作用：表与类产生联系
类与表的关系
类中属性与表中字段的关系
类中属性类型与表中字段类型对应
把一对多和多对多关系转化成面向对象的关系

hibernate 配置文件的作用：主要是用来链接数据库的

配置hibernate
1.导入jar包
2.编写实体类
3.建立表与类之间的关系
4.配置hibernate映射文件

 /** Hibernate执行流程:
 *         Configuration:读取并解析配置文件(hibernate.cfg.xml)
 *             一个Configuration实例代表hibernate所有的java类到SQL数据库映射的集合
 *         SessionFactory:读取并解析映射信息(***.hbm.xml)
 *             将Configuration对象中的所有配置信息拷贝到SessionFactory的缓存中
 *         打开Session，让SessionFactory提供连接。
 *            SessionFactory factory = con.buildSessionFactory();
 *        Transaction:开启事务。
 *            Transaction tr = se.beginTransaction();
 *        数据库操作(get,delete,update,save)完成:提交事务、关闭Session
 *            tr.commit();
 *            se.close();
 * */

/** Hibernate对象三种状态
 *     save():将对象由瞬时态转变为持久态
 *     load()/get():获得的对象的状态处于持久态
 *     find():获得的List集合中的对象的状态处于持久态
 *     upload()/saveOrUpload()/lock():可将托管状态对象转变为持久态
 *     close():调用后，Session的缓存会被清空，缓存中所有持久态对象状态都转变为托管态
 *         处于托管状态的对象称为游离对象，当游离对象不再被引用时，将被JVM垃圾回收机制清除
 *     evict():可将Session缓存中一个指定的持久态对象删除，使其转变为托管态对象
 *         当缓存中保存了大量持久态对象时，为了节省内存空间，可以调用此方法删除一些持久态对象
 *　　　evict()与clear()区别：
 *         session.evict(obj):会把指定的缓冲对象进行删除
 *         session.clear():把缓冲区内的全部对象清除，但不包括操作中的对象　　 

如图：  Hibernate  的对象的 3 种状态的转变关系

1、person 实体类

Person.java

 package cn.gs.ly.entity;

 import java.io.Serializable;

 public class Person implements Serializable{

     private static final long serialVersionUID = 1L;

     private long pid;
     private String pname;
     private int page;

     public long getPid() {
         return pid;
     }
     public void setPid(long pid) {
         this.pid = pid;
     }
     public String getPname() {
         return pname;
     }
     public void setPname(String pname) {
         this.pname = pname;
     }
     public int getPage() {
         return page;
     }
     public void setPage(int page) {
         this.page = page;
     }

     @Override
     public String toString() {
         return "Person [pid=" + pid + ", pname=" + pname + ", page=" + page + "]";
     }

 }

2、表与类之间关系

Person.hbm.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 <!-- 配置表与实体对象的关系 -->
 <!-- package属性:填写一个包名.在元素内部凡是需要书写完整类名的属性,可以直接写简答类名了. -->
     <!-- <hibernate-mapping package="cn.gs.ly.entity"> -->
 <hibernate-mapping>
     <!--
         class:用来描述一个持久化类 ,配置实体与表的对应关系的
         name:持久化类全名
         table:数据库中表名，可以不写，默认和实体类名一致
     -->
     <class name="cn.gs.ly.entity.Person" table="Person" >
         <!--
             id:标示属性，和数据库中主键对应
             name: 填写主键对应类属性名
             column(可选): 填写表中的主键列名.默认值:列名会默认使用属性名
             type(可选):填写类中列(属性)的类型.hibernate会自动检测实体的属性类型.
                         每个类型有三种填法: java类型|hibernate类型|数据库类型
             not-null(可选):配置该属性(列)是否不能为空. 默认值:false
             length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度
         -->
         <id name="pid" column="id" type="java.lang.Long">
             <!-- generator:主键产生器。 主键生成策略-->
             <generator class="native"></generator>
         </id>
         <!--
             property元素:除id之外的普通属性映射
             name: 填写属性名
             column(可选): 填写列名
             type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型.
                         每个类型有三种填法: java类型|hibernate类型|数据库类型
             not-null(可选):配置该属性(列)是否不能为空. 默认值:false
             length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度
         -->
         <property name="pname" column="name" type="java.lang.String"></property>
         <property name="page" column="age" type="java.lang.Integer"></property>
     </class>

 </hibernate-mapping>

3、配置hibernate映射文件

hibernate.cfg.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-configuration PUBLIC
     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

 <hibernate-configuration>
     <!-- 一个session-factory只能链接一个数据库  -->
     <session-factory>
         <!--
         进行数据库连接
             driver:驱动
             url:地址
             username:数据库连接用户名
             password:数据库连接密码
             数据库方言
                   不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
               sql99标准: DDL 定义语言  库表的增删改查
                       DCL 控制语言  事务 权限
                       DML 操纵语言  增删改查
              注意: MYSQL在选择方言时,请选择最短的方言.
          -->
          <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
          <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
          <property name="connection.url">jdbc:oracle:thin:@localhost::orcl</property>
          <property name="connection.username">liuyang</property>
          <property name="connection.password">orcl</property>
          <!--
              自动建表
                ## auto schema export  自动导出表结构. 自动建表
                #hibernate.hbm2ddl.auto create      自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
                #hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
                #hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
                #hibernate.hbm2ddl.auto validate    校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
          -->
          <property name="hbm2ddl.auto">update</property>

          <!-- 将hibernate生成的sql语句打印到控制台 -->
          <property name="show_sql">true</property>    

          <!-- 添加映射文件 -->
          <mapping resource="cn/gs/ly/entity/Person.hbm.xml"></mapping>
     </session-factory>
 </hibernate-configuration>

4、测试类

 package cn.gs.ly.entity.test;

 import org.hibernate.Transaction;
 import java.util.List;

 import org.hibernate.SessionFactory;
 import org.hibernate.cfg.Configuration;
 import org.hibernate.classic.Session;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;

 import cn.gs.ly.entity.Person;

 public class createTable {

     SessionFactory factory =null;
     Session se = null;
     Transaction tr = null;

     //@Before：读取并解析配置文件、映射信息、打开Session、开启事务
     @Before
     public void test1(){
         //读取配置文件   //1 创建,调用空参构造
         Configuration con = new Configuration();
         //2 读取指定主配置文件 => 空参加载方法,加载src下的hibernate.cfg.xml文件
         con.configure();
         //创建一个session工厂      //4 根据配置信息,创建 SessionFactory对象
         factory = con.buildSessionFactory();
         //5 获得session  打开一个新的session对象
         se = factory.openSession();
         //开启事务   //开启事务并获得操作事务的tr对象(建议使用)
         tr = se.beginTransaction();
     }
     //@After：提交事务、关闭Session
     @After
     public void afterClose(){
         //提交事务
         tr.commit();
         //关闭session
         se.close();
     }

     /**向表中插入数据
      *        new 出来的对象为临时态，所以需要se.save()方法将其转为持久态
      *        se.save(p);
      * */
     @Test
     public void testSave(){
         for(int i=;i<;i++){
             Person p = new Person();
             p.setPname("liuyang"+i);
             p.setPage();
             se.save(p);
         }
     }

     /**查询表中所有数据
      *         List<Person> list = se.createQuery("from Person").list();
      *         createQuery("from TableName")
      * */
     @Test
     public void testFind(){
         //Person是实体类
         List<Person> list = se.createQuery("from Person").list();
         for(Person s:list){
             System.out.println("id:"+s.getPid()+"  name:"+s.getPname()+"  age:"+s.getPage());
         }
     }

     /**通过id查找数据
      *        //get方式是按照主键进行查询 ,第二个参数为主键id
      *        //第二个参数必须和持久化类中的标示符数据类型一致 ，long类型 '1'后面加'L'
      *        Person p = (Person)se.get(Person.class, 1L);
      * */
     @Test
     public void testFindById(){
         /**
          *     第二个参数必须和持久化类中的标示符数据类型一致
          * */
         Person p = (Person)se.get(Person.class, 1L); //get方式是按照主键进行查询 id
         System.out.println("id:"+p.getPid()+"  name:"+p.getPname());
     }

     /**更新数据
      *       快照比对
      *         hibernate 在关闭session的时候 ，会自动检测处于持久态的实体类
      *         如果实体化类有变化，则执行update操作，所以持久态更改不需要se.update(p)
      *         临时状态   修改后需se.update(p)方法转为持久态
      * */
     @Test
     public void testUpdate(){
         Person p = (Person)se.get(Person.class, 1L); //持久化状态
         //Person p = new Person(); //临时状态   修改后需se.update(p)方法转为持久态
         //p.setPid(4L);    //临时状态
         p.setPname("LC");
         //se.update(p);
     }

     /**通过主键id 删除一条数据
      *    se.delete(p);
      * */
     @Test
     public void testDeleteById(){
         Person p = (Person)se.get(Person.class, 4L); //get方式是按照主键进行查询 id
         //Person p = new Person();
         //p.setPid(4L);
         se.delete(p);
     }

     /**删除表中所有数据
      *        查询全部，遍历删除
      *      se.createQuery("from TableName");
      *      se.delete();
      * */
     @Test
     public void testDeleteAll(){
         //Person是实体类
         List<Person> list = se.createQuery("from Person").list();
         for(Person s:list){
             //System.out.println(s);
             se.delete(s);
         }
     }

 //三种状态

     /** 缓冲区内的全部对象清除  clear()
      *           持久态<-->托管态
      *        session.evict(obj)，会把指定的缓冲对象进行清除
      *       session.clear()，把缓冲区内的全部对象清除，但不包括操作中的对象
      * */
     @Test
     public void testClear(){
         Person p = (Person)se.get(Person.class, 1L);
         p.setPname("LC");
         se.clear(); //把session中所有的对象清空后  p转为托管状态
         se.update(p);  //将p托管转为持久太
     }

     /** 指定的缓冲对象进行清除  evict()
      *        session.evict(obj)，会把指定的缓冲对象进行清除
      *       session.clear()，把缓冲区内的全部对象清除，但不包括操作中的对象
      * */
     @Test
     public void testEvict(){
         Person p = (Person)se.get(Person.class, 2L);
         Person p1 = (Person)se.get(Person.class, 3L);
         p.setPname("LC2");
         p1.setPname("LC3");
         se.evict(p); //把session中指定的对象清空  。p托管  p1持久
     }

     /** New Session  开启一个新Session
      *       一个对象是否持久化是针对同一个session来说的。一个session只能对应一个事务。
      * */
     @Test
     public void testNewSession(){
         Person p = (Person)se.get(Person.class, 5L);
         p.setPname("LC0");
         tr.commit();  //提交事务 p游离态
         se.close(); //关闭session

         //一个对象是否持久化是针对同一个session来说的。一个session只能对应一个事务。
         se = factory.openSession(); //开启一个新session
         tr = se.beginTransaction(); // 开启事务
         p.setPage(); //无法生效
     }

     /**同时进行多种操作
      *        插入一条数据，更新一条数据
      * */
     @Test
     public void testInsertUpdate(){
         //插入一条数据
         Person p = new Person();
         p.setPname("superman");
         p.setPage();
         se.save(p);
         //更新一条数据
         Person p1 = (Person)se.get(Person.class, 6L);
         p1.setPname("toee");
     }

     /**一个错误示例
      *      错误原因:
      *         两个持久化对象，操作的标示符的值是一样的 会报错
      *
      * */
     @Test
     public void testWrong(){
 //        Person p = (Person)se.get(Person.class, 5L);
 //        Person p1 = new Person();
 //        p1.setPid(5L);
 //        se.update(p1);
     }

 }