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:1521: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=0;i<10;i++){
            Person p = new Person();
            p.setPname("liuyang"+i);
            p.setPage(20);
            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(55); //无法生效 
    }
    
    /**同时进行多种操作
     *        插入一条数据，更新一条数据
     * */
    @Test
    public void testInsertUpdate(){
        //插入一条数据
        Person p = new Person();
        p.setPname("superman");
        p.setPage(20);
        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);        
    }
    
}