Hibernate框架(3) - 对象状态 / 一级缓存 / 映射

对象的状态

Hibernate中对象的状态 : 临时/瞬时状态、持久化状态、游离状态
- 临时状态
  - 特点：
    - 直接new出来的对象;
    - 不处于session的管理;
    - 数据库中没有对象的记录;
- 持久化状态 : 当调用session的save/saveOrUpdate/get/load/list等方法的时候，对象就是持久化状态。处于持久化状态的对象，当对对象属性进行更改的时候，会反映到数据库中!
  - 特点：
    - 处于session的管理;
    - 数据库中有对应的记录;
- 游离状态
  - 特点
    - 不处于session的管理
    - 数据库中有对应的记录
    - Session关闭后，对象的状态
对象状态的转换 :

private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }
    //1. 对象状态的转换
    @Test
    public void testSaveSet() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 创建对象                     【临时状态】
//      User user = new User();
//      user.setUserName("Jack22222");
        // 保存                           【持久化状态】
//      session.save(user);     
//      user.setUserName("Jack333333");  // 会反映到数据库
        
        // 查询
        User user = (User) session.get(User.class, 5);
        user.setUserName("Tomcat");// hibernate会自动与数据库匹配（一级缓存），如果一样就更新数据库
        
        session.getTransaction().commit();
        session.close();
    
        user.setUserName("Jack444444444");
        // 打印                           【游离状态】
        System.out.println(user.getUserId());
        System.out.println(user.getUserName());
    }

一级缓存

为什么要用缓存？
- 目的：减少对数据库的访问次数！从而提升hibernate的执行效率！
Hibernate中缓存分类 :
- 一级缓存
- 二级缓存
一级缓存概念 :
1）Hibenate中一级缓存，也叫做session的缓存，它可以在session范围内减少数据库的访问次数! 只在session范围有效！ Session关闭，一级缓存失效!
2）当调用session的save/saveOrUpdate/get/load/list/iterator方法的时候，都会把对象放入session的缓存中。
3）Session的缓存由hibernate维护，用户不能操作缓存内容；如果想操作缓存内容，必须通过hibernate提供的evit/clear方法操作。
特点：
- 只在(当前)session范围有效，作用时间短，效果不是特别明显！
- 在短时间内多次操作数据库，效果比较明显！
缓存相关几个方法的作用
- session.flush() : 让一级缓存与数据库同步
- session.evict(arg0) : 清空一级缓存中指定的对象
- session.clear() : 清空一级缓存中缓存的所有对象
在什么情况用上面方法？
- 批量操作使用使用：
  - Session.flush(); // 先与数据库同步
  - Session.clear(); // 再清空一级缓存内容
查询方法:
- list : 会放入缓存，但不会从缓存中获取数据

private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }
@Test
    public void list() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        // HQL查询
        Query q = session.createQuery("from User ");
        // list()方法
        List list = q.list();
        
        for (int i=0; i

 
  
  iterator : 会放入缓存，也会从缓存中获取数据 
  
 private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }
@Test
    public void iterator() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        // HQL查询
        Query q = session.createQuery("from User ");
        // iterator()方法
        Iterator it = q.iterate();
        while(it.hasNext()){
            // 得到当前迭代的每一个对象
            User user = it.next();
            System.out.println(user);
        }

        session.getTransaction().commit();  
        session.close();
    }
 
 懒加载(lazy) 
  
  概念：当用到数据的时候才向数据库查询，这就是hibernate的懒加载特性。 
  目的：提供程序执行效率！ 
  lazy 值 
    
    true : 使用懒加载 
    false : 关闭懒加载 
    extra : 在集合数据懒加载时候提升效率 
      
      在真正使用数据的时候才向数据库发送查询的sql；如果调用集合的size() / isEmpty()方法，只是统计，不真正查询数据！ 
     
  
   
  
  
 


    
        
            
           
        
        
        
         
             
             
         
    

 
 //1. 集合的查询()
    @Test
    public void set() {
        Session session = sf.openSession();
        session.beginTransaction();
        Dept dept = (Dept) session.get(Dept.class, 10);
        System.out.println(dept.getDeptName());
        System.out.println("------");
        System.out.println(dept.getEmps().isEmpty());  //  SQL
        
        session.getTransaction().commit();
        session.close();    
    }
 
  
  懒加载异常 
    
    Session关闭后，不能使用懒加载数据; 如果session关闭后，使用懒加载数据报错：
 org.hibernate.LazyInitializationException: could not initialize proxy - no Session  
    如何解决session关闭后不能使用懒加载数据的问题？ 
      
      方式1： 先使用一下数据 : dept.getDeptName();  
      方式2：强迫代理对象初始化 : Hibernate.initialize(dept);  
      方式3：关闭懒加载, 设置lazy=false; 
      方式4： 在使用数据之后，再关闭session！ 
     
  
   
  
  get与load方法: 
  
 private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(Dept.class)   
            .addClass(Employee.class)   // 测试时候使用
            .buildSessionFactory();
    }
    //1. 主键查询，及区别
    @Test
    public void get_load() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        Dept dept = new Dept();
        // get： 及时查询
//      dept = (Dept) session.get(Dept.class, 9);
//      System.out.println(dept.getDeptName());
        
        // load，默认懒加载， 及在使用数据的时候，才向数据库发送查询的sql语句！
        dept = (Dept)session.load(Dept.class, 9);
        // 方式1： 先使用一下数据
        //dept.getDeptName();
        // 方式2：强迫代理对象初始化
        Hibernate.initialize(dept);
        // 方式3：关闭懒加载
        
        session.getTransaction().commit();
        session.close();
        
        // 在这里使用
        System.out.println(dept.getDeptName());
    }
 
 一对一映射 
  
  基于外键的映射 
    
    IdCard.hbm.xml : 
   
  
  
 


    
        
            
           
        
        
        
         
    

 
  
  User.hbm.xml : 
  
 


    
        
            
           
        
        
          
    

 
  
  java类 
  
 private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(IdCard.class)   
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }

    @Test
    public void getSave() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 用户
        User user = new User();
        user.setUserName("Jack");
        // 身份证
        IdCard idCard = new IdCard();
        idCard.setCardNum("441202XXX");
        idCard.setPlace("广州XXX");
        // 关系
        idCard.setUser(user);
        
        // ----保存----
        session.save(idCard);
        
        session.getTransaction().commit();
        session.close();    
    }
 
  
  基于主键的映射 
    
    IdCard.hbm.xml : 
   
  
  
 


    
        
            
            
                user
            
           
        
        
        
        
        
            
    

 
  
  User.hbm.xml : 
  
 


    
        
            
           
        
        
          
    

 
  
  java类 
  
 private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(IdCard.class)   
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }
    @Test
    public void getSave() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 用户
        User user = new User();
        user.setUserName("Jack");
        // 身份证
        IdCard idCard = new IdCard();
        idCard.setCardNum("441202XXX");
        idCard.setPlace("广州XXX");
        // 关系
        idCard.setUser(user);
        
        // ----保存----
        session.save(idCard);
        
        session.getTransaction().commit();
        session.close();    
    }
 
 组件映射与继承映射 
  
   类的关系 
    
    组合关系 : 一个类中包含了另外一个类, 这两个类就是组合关系 (汽车与车轮) 
    继承关系 : 一个类继承另外一个类, 这两个类就是继承关系 
   
  
   组件映射 : 类组合关系的映射, 也叫做组件映射 (组件类和被包含的组件类，共同映射到一张表) 
    
    javaBean 
   
  
  
 public class Car {
          private int id;
          private String name;
          // 车轮
          private Wheel wheel;
}
public class Wheel {
          private int count;
          private int size;
}
 
  
  Car.hbm.xml 
  
 



    
        
            
           
        
        
        
        
            
            
                 
    

 
  
  java 
  
 private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(Car.class)   
            .buildSessionFactory();
    }
    @Test
    public void getSave() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 轮子
        Wheel wheel = new Wheel();
        wheel.setSize(38);
        wheel.setCount(4);
        // 汽车
        Car car = new Car();
        car.setName("BMW");
        car.setWheel(wheel);
        
        // 保存
        session.save(car);
        
        session.getTransaction().commit();
        session.close();    
    }
 
  
  继承映射 
    
    简单继承映射 : 有多少个子类，写多少个映射文件！ 
   
  
  
 



    
        
        
            
        
        
        
                          
    

 
 - 总结：写法较为简单, 所有子类用一个映射文件, 且映射到一张表; 但数据库设计不合理!(不推荐用)
 
  
  一个映射文件存储所有子类, 子类父类都对应表(所有子类映射到一张表) 
  
 



    
        
            
        
        
        
        
        
        
        
         
            
         
         
         
          
            
          
    

 
 - 总结 : 写法较为简单, 所有子类用一个映射文件, 且映射到一张表！但数据库设计不合理(不推荐用)
 
  
  每个类都映射一张表 
  
 



    
        
            
        
        
        
        
        
            
            
        
        
        
        
            
            
        
    

 
 - 总结 : 一个映射文件，存储所有的子类； 子类父类都对应表；
- 缺点：表结构比较复杂，插入一条子类信息，需要用2条sql(子类, 父类都需要插入数据)
 
  
  推荐 : 每个子类映射一张表， 父类不对应表 
  
 



    
    
        
        
            
        
        
        
        
        
            
        
        
        
        
            
        
    

 
 - 注意：主键不能是自增长！
 
 Hibernate中映射分类： 
  
  多对一 
  一对多 
  多对多 
  一对一 （多对一的特殊应用） 
  组件 
  继承

Hibernate框架(3) - 对象状态 / 一级缓存 / 映射

对象的状态

一级缓存

懒加载(lazy)

一对一映射

组件映射与继承映射

Hibernate中映射分类：

你可能感兴趣的:(Hibernate框架(3) - 对象状态 / 一级缓存 / 映射)