Hibernate 技术(二)

╰+攻爆jí腚メ 2022-05-20 07:37 208阅读 0赞

# **Hibernate一级缓存** #

## **简介** ##

**缓存，介于应用程序和永久数据存储源之间，作用是为了降低应用程序对物理数据源访问的频率，从而提高应用的运行性能。**  
**例如我们cpu执行效率每秒处理的数据高达上千兆，而我们的硬盘读取速度却没那么高，读取几百兆，这时候我们使用缓存来存储数据，存储满后一次性交由cpu处理。**

**Hibernate中也存在缓存，同样是为了提高效率。Hibernate的缓存包括Session的缓存和SessionFactory的缓存**。

**Session的缓存是内置的，不能被卸载，也被称为Hibertnate的一级缓存。**

**SessionFactory有一个内置缓存和外置缓存。SessionFactory的外置缓存是一个可配置的缓存插件。默认情况下，Hibernate不会启用这个缓存插件。被称为Hibernate的二级缓存。**

**缓存的范围**

**缓存的范围决定了缓存的生命周期以及可以被谁访问。**

事务范围:缓存只能被当前事务访问。一级缓存是Session的缓存，Session对象生命周期通常对应一个事务，因此是事务范围的缓存。 
    
        进程范围:缓存被进程内的所有事务共享。二级缓存是可配置的缓存插件，由SessionFactory管理，SessionFactory生命周期和应用程序的进程对应，因此是进程范围的缓存。
    
        集群范围：在集群环境中，缓存被同一个机器或者多个机器上的多个进程共享。 
    
       
        
         1
         2
         3
         4
         5
         6

## **Session缓存** ##

**Session缓存是Hibernate的一级缓存。Session对象中具有一个缓存。Session的缓存是一块内存空间，存放的是持久化对象。**

**当Session通过save方法持久化一个对象时，该对象被加入到Session缓存中。**  
**当Session通过get方法获取一个持久化对象时，Session会先判断Session缓存中是否存在这个对象，如果存在，就不需要再从数据库中查找。**

========我们来测试一下缓存的存在==============

//开启事务
            Transaction ts=session.beginTransaction();
            //加上断点，当我们执行完这一步，会打印select语句，而后面的都不会打印，说明并没有从数据库中获取
            User user1=session.get(User.class, 5); 
            //这次get方法会先从session缓存中查找，由于已经存在，直接返回引用 
            User user2=session.get(User.class, 5);
            User user3=session.get(User.class, 5);
            System.out.println(user1==user2);//true
            System.out.println(user1==user3);//true
            session.close();
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10

## **脏检查及清理缓存的机制** ##

**我们先来看下面的例子**

Transaction ts=session.beginTransaction();
            User user1=session.get(User.class, 5);
            user1.setName("swaggy");
            ts.commit();
       
        
         1
         2
         3
         4

--------------------

我们发现我们改变了Name属性，这时候session缓存中的对象的name属性和数据库表中的NAME字段不一致了。但是我们并没有进行更新操作，而是直接提交了事务

幸运的是，Session中在清理缓存的时候，会自动进行脏检查。如果发现Session缓存中的持久化对象和数据库中的记录不一致，就会根据对象的最新属性去更新数据库。  
所以在本例中，Session会自动提交一个update语句对数据库进行更新。

--------------------

**Session是怎样进行脏检查的呢？**

**当一个对象被加入到Sesion缓存中时，Session会为该对象复制一份快照。当Session清理缓存时，会比较当前对象的属性和快照来判断是否发生变化，如果发生变化，就会根据最新属性来执行相关的更新操作。**

**我们看下面一个例子加深对快照的理解**

//我们从数据库中取出 id为5，name为tom，password为123456的对象
            Transaction ts=session.beginTransaction();
            User user1=session.get(User.class, 5);
            session.update(user1);
            session.close(); 
    
            过程：获取了持久化对象，放入缓存中，并创建了快照，我们执行更新，Session缓存中的对象会和快照进行比较，没有任何变化，所以不会执行update语句。
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8

//我们自己设置一个和数据库中一模一样的对象，这时候会打印update语句 Transaction ts=session.beginTransaction();
            User user=new User();
            user.setId(5);
            user.setName("tom");
            user.setPassword("123456");
            session.update(user);
            ts.commit();
            session.close();
    
            过程：因为此时我们执行update语句时会将对象直接放入缓存中，但是没有持久化对象的快照，所以进行对比结果就是不一致，所以尽管什么都没更改，还是会执行update语句，在控制台打印。 
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12

--------------------

**什么时候会清理缓存呢？**

-默认情况下，在调用commit()方法时会先清理缓存。再向数据库提交事务。 
    -当执行查询操作时，如果缓存中的持久化对象属性已经发生了改变，就会先清理缓存，同步数据，保证查询到的是正确的结果。 
    -当应用程序显式调用Session的flush()方法时 
    -Session清理缓存的例外情况，如果对象使用的是native生成策略生成OID，那么调用Session的save()方法来保存该对象时，会立刻执行向数据库的插入语句。 
       
        
         1
         2
         3
         4
         5
         6
         7
         8

**如果不希望Session在以上默认的时间点清理缓存，可以通过Session的setFlushMode()方法来设定清理缓存的时间点。**  
**FlushMode类定义了三种清理模式。**

各种查询方法          commit()方法        flush()方法 
    -FlushMode.AUTO(默认模式) 清理 清理 清理 -FlushMode.COMMIT 不清理 清理 清理 -FlushMode.NEVER 不清理 不清理 清理 
    例如Session.setFlushMode(FlushMode.AUTO) 
    
       
        
         1
         2
         3
         4
         5
         6
         7

# **Java对象在Hibernate持久化层的状态**  #

**-临时状态：刚用new语句创建对象，还没有被持久化，并且不处于Session缓存中。处于临时状态的java对象被称为临时对象。**

**-持久化状态：已经被持久化，并且加入到Session的缓存中。处于持久化状态的java对象被成为持久化对象。**

**-游离状态：已经被持久化，但不再处于Session的缓存中。处于游离状态的java对象被成为游离对象。**

//对象状态转换的过程
            Transaction ts=session.beginTransaction();
            User user =new User(); //临时状态
             user.setName("tom");
             user.setPassword("123456");
    
            session.save(user); //转变为持久化状态
            ts.commit(); //持久化状态 
    
            session.close(); //转变为游离状态
            sessionfactory.close();
            System.out.println(user.getName()); //游离状态 
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12

临时对象的特征：
            -OID为null         -不处于Session的缓存中，也可以说，不被任何一个Session实例关联         -在数据库中没有对应的记录 
    持久化对象的特征：
            -OID不为null         -位于一个Session实例的缓存中，持久化对象总是被一个Session实例关联         -持久化对象和数据库中的相关记录对应         -会根据持久化对象的属性变化，同步更新数据库。             User  user=(User)session.get(User.class,1);//获取持久化对象 持久状态
                user.setName("jerry");
                transaction.commit();
            我们发现我们没有执行update语句，却打印了update语句。Hibernate会自动将持久化对象的状态同步到数据库中。
    
    
    游离对象的特征：
            -OID不为null         -不再位于Session的缓存中，也可以说，游离对象不被Session关联         -数据库中有对应的记录 
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21

## **三种状态的转换** ##

1）临时状态转换持久化状态
            -Session的save（）方法会将临时状态转换成持久状态。
                把要保存的对象放入Session缓存中，使它进入持久化状态。使用映射文件指定的主键生成策略，为持久化对象分配唯一OID。
                save方法只是为对象分配UID。我们可以在save方法处打断点。
                当我们的主键生成策略为native时，由于我们使用mysql数据库，主键自增，所以执行完save方法后，打印insert语句，mysql数据库为我们对象自增OID 
    
                当我们的主键生成策略为incrementt时，increment是由Hibernate维护，先去表中查最大ID然后+1，我们执行完save方法之后，发现打印select查找最大id的语句，执行commit时才打印插入语句
    
    
        2)临时状态转换成游离状态
            -将临时状态的对象OID设置为数据库中对应的记录.
            User user=new User();
            user.setId(1);
    
        3)持久化状态转换成临时状态
            第一种：
                User  user=(User)session.get(User.class,1);//获取持久化对象 持久状态
                session.close(); //游离状态
                user.setId(null);//临时状态 
            第二种：
                User  user=(User)session.get(User.class,1);//获取持久化对象 持久状态
                session.evict(user); //游离状态,此方法会将session缓存中清除持久化对象，使其变为游离状态
                user.setId(null);//临时状态 
    
        4)持久化状态转换成游离状态
            第一：调用session的close方法，持久化状态变为游离状态
            第二: 调用session的evict（）方法方法，将持久状态转变为游离状态
    
    
        5)游离状态转换成临时状态
            只需要将游离状态的对象OID变为null。
    
        6)游离状态转换成持久状态
            Session的update()方法使游离状态转换成持久状态。
                User  user=(User)session.get(User.class,1);//获取持久化对象 持久状态
                session.evict(user); //游离状态,此方法会将session缓存中清除持久化对象，使其变为游离状态
                session.update(user);
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38

## **Session接口的其他API**  ##

--Session的save()和persist()方法
            两个方法都是用来保存对象，能把临时状态转变为持久化状态。 
    
        两个方法的区别在于：
        save方法持久化对象时，会返回持久化对象的OID。所以程序执行save时会立刻执行insert语句，来返回数据库生成的OID。 persist方法持久化对象时，不会保证立即为持久化对象的OID赋值，不会立即生成insert语句，而是有可能在Session清理缓存时才为OID赋值。 --Session的clear()方法 清空一级缓存 --Session的update方法 update()方法可以将游离对象转变为持久化对象。用来执行修改操作。 update()方法完成以下操作 -把游离对象加入到当前缓存中，变为持久化对象 -然后计划执行update语句 只要通过update使游离对象转变为持久化对象，即使没有修改任何属性，在清理缓存时还是会执行update语句。 如果希望Session仅当修改了属性时才执行update语句，可以在映射文件中的<class>元素中设置select-before-update="true",默认为false 这样当Session清理缓存时，会先发送一条查询语句，然后判断缓存中的对象和记录是否一致，不一致才执行update语句。 当update()方法将游离对象转变为持久化对象时，如果Session缓存中已经存在相同的OID持久化对象，那么会抛出异常。 例如： Transaction ts=session.beginTransaction();
                            User user1=session.get(User.class, 5);
                            session.evict(user1);
                            User user2=session.get(User.class, 5);
                            session.update(user1);
                            ts.commit();
    
                            因为Session的缓存是一个Map结构，OID为key，对象为value。
                            当执行session的update方法时，由于缓存中已经存在了OID为5的持久化对象，因此会抛出异常。 -Session的saveOrUpdate()方法 Session的saveOrUpdate()方法同时包含了save()和update()方法的功能 如果传入的参数是临时对象(OID为null)，就调用save方法。 如果传入的参数是游离对象(OID不为null)，就执行update方法。 
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40

# **Hibernate的一对多关联关系**  #

## **映射一对多双向关联关系** ##

例如，以客户(Customer)和订单(Order)为例，一个客户能有多个订单，一个订单只能有一个客户。 
    
    从Customer到Order是一对多关联，在java类中的面向对象设计应该一个Customer对象包含多个Order对象，因此应该定义一个集合，来包含所有的Order对象。  
    
    从Order到Customer是多对一关联，在java类中设计每个Order对象需要关联一个Customer对象，因此Order类中应该定义一个Cutomer类型的属性，来引用关联的customer对象。
    
    但是在关系数据库中，只存在主外键参照关系来表达两者的关联。 
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8

第一步：我们先创建两个实体类 Customer和Order
    
                public class Customer {
                        private Integer id;
                        private String name;
                        private Set <Order> orders=new HashSet<Order>();
                        public Integer getId() {
                            return id;
                        }
                        public void setId(Integer id) {
                            this.id = id;
                        }
                        public String getName() {
                            return name;
                        }
                        public void setName(String name) {
                            this.name = name;
                        }
                        public Set getOrders() {
                            return orders;
                        }
                        public void setOrders(Set orders) {
                            this.orders = orders;
                        }
    
                } 
    
                public class Order {
                    private Integer id;
                    private String name;
                    private Customer customer;
                    public Integer getId() {
                        return id;
                    }
                    public void setId(Integer id) {
                        this.id = id;
                    }
                    public String getName() {
                        return name;
                    }
                    public void setName(String name) {
                        this.name = name;
                    }
                    public Customer getCustomer() {
                        return customer;
                    }
                    public void setCustomer(Customer customer) {
                        this.customer = customer;
                    }
    
                }
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52

第二步：实体类写好了，使用Hibernate映射文件来映射关系。
    
                创建Customer.hbm.xml  
                 <hibernate-mapping >
                    
                    <class name="com.cad.domain.Customer" table="customer">
                        <id name="id" column="id">
                            <generator class="native"></generator>
                        </id>
                        <property name="name" column="name"></property>
                        
                        
                        <set name="orders">
                            
                            
                            <key column="cid"/>
                            <one-to-many class="com.cad.domain.Order"/> 
                        </set>
                    </class>
                 </hibernate-mapping>  
    
                Hibernate根据映射文件获得以下信息
                -<set>元素表明Customer类中的orders属性为java.util.Set集合
                -<one-to-many>元素表明orders集合中存放的是一组order对象
                -<key>元素表明orders表通过外键cid关联customer表
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27

创建Order.hbm.xml 
                <hibernate-mapping >
                    <class name="com.cad.domain.Order" table="order">
                        <id name="id" column="id">
                            <generator class="native"></generator>
                        </id>
                        <property name="name" column="name"></property>
                        
                        
                        <many-to-one name="customer" column="cid" class="com.cad.domain.Customer"></many-to-one>
                    </class>
                 </hibernate-mapping>   
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17

第三步：在hibernate.cfg.xml中配置映射文件 
    
                     <mapping resource="com/cad/domain/Customer.hbm.xml"/>
                      <mapping resource="com/cad/domain/Order.hbm.xml"/>
       
        
         1
         2
         3
         4

第四步： 我们来操作一下测试一下。 
    
                        //添加方法 
                        @Test
                        public void test() {
                            //读取配置文件
                            Configuration conf=new Configuration().configure();
    
                            //根据配置创建factory
                            SessionFactory sessionfactory=conf.buildSessionFactory();
                            session = sessionfactory.openSession(); 
                             Transaction ts=session.beginTransaction(); 
                             //创建Customer
                            Customer c=new Customer();
                            c.setName("张三"); 
                            //创建订单
                            Order o1=new Order();
                            o1.setName("矿泉水");
                            Order o2=new Order();
                            o2.setName("方便面"); 
                            //双向关联
                            c.getOrders().add(o1);
                            c.getOrders().add(o2);
                            o1.setCustomer(c);
                            o2.setCustomer(c);
                            //保存
                            session.save(c);
                            session.save(o1);
                            session.save(o2);
                            ts.commit();
                            session.close();
                            sessionfactory.close();
                        }
    
                        然后执行，控制台会打印如下语句
                                Hibernate: 
                                    insert 
                                    into
                                        customer
                                        (name) 
                                    values
                                        (?)
                                Hibernate: 
                                    insert 
                                    into
                                        orders
                                        (name, cid) 
                                    values
                                        (?, ?)
                                Hibernate: 
                                    insert 
                                    into
                                        orders
                                        (name, cid) 
                                    values
                                        (?, ?)
                                Hibernate: 
                                    update
                                        orders 
                                    set
                                        cid=? 
                                    where
                                        id=?
                                Hibernate: 
                                    update
                                        orders 
                                    set
                                        cid=? 
                                    where
                                        id=?    
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68
         69
         70
         71

我们来执行删除操作，直接删除Customer，但由于还有Order关联着Customer
                    会执行成功么？
                                @Test
                                public void test() {
                                    //读取配置文件
                                    Configuration conf=new Configuration().configure();
    
                                    //根据配置创建factory
                                    SessionFactory sessionfactory=conf.buildSessionFactory();
                                    session = sessionfactory.openSession(); 
                                     Transaction ts=session.beginTransaction();
                                     Customer c=session.get(Customer.class, 2); 
                                     //删除Customer
                                    session.delete(c);
    
                                    ts.commit();
                                    session.close();
                                    sessionfactory.close();
                                }
                            执行，打印如下语句
                                Hibernate: 
                                    select
                                        customer0_.id as id1_0_0_,
                                        customer0_.name as name2_0_0_ 
                                    from
                                        customer customer0_ 
                                    where
                                        customer0_.id=?
                                Hibernate: 
                                    update
                                        orders 
                                    set
                                        cid=null 
                                    where
                                        cid=?
                                Hibernate: 
                                    delete 
                                    from
                                        customer 
                                    where
                                        id=? 
    
            我们会发现Hibernate会自动将Order中的cid设置为null，然后执行删除操作
            我们发现Hibernate还是挺智能的，但这是由inverse属性操控的。
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44

##  **< set >元素的inverse属性**  ##

inverse所描述的是对象之间关联关系的维护方式。 inverse属性指定由哪方来维护关联关系。
    inverse默认为false，即关联关系由自己控制，若为true，则反转，关联关系由对方控制.
    Inverse属性的作用是：是否将对集合对象的修改反映到数据库中。 
    
    在映射一对多的双向关联关系中,应该在"一"方把inverse属性设为true,由对方来维护主键关联关系.
    
    所以上述例子中,inverse默认是false.即Customer维护关联关系,所以Customer会执行两条更新语句来更新Order的cid.
    但是我们Order在插入的时候已经插入cid,所以这样会影响性能,我们只需要将Customer的<set>元素的inverse属性改为true即可。 
    
    我们的删除案例中也是，Customer执行删除时，会先去把Order的主键约束解除，然后删除。
    我们只需要将Customer的inverse设置为true，然后由对方维护关联关系，我们再进行删除时，就会出现异常，因为有主键约束，我们Customer不再维护关联关系。 
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12

## **级联操纵** ##

在实际应用中，对象和对象之间是相互关联的。例如我们的一对多关联关系。  
在关系-对象映射文件中，用于映射持久化类之间关联关系的元素，如 < set>,< many-to-one>,< one-to-many>，都有一个cascade属性，用来指定如何操纵与当前对象关联的其他对象。

我们先看下面的例子，我们创建一个Customer，再创建两个Order，然后关联
        我们只保存Customer，会抛出org.hibernate.TransientObjectException异常，这是为什么呢？
    
        这是因为我们的Customer的inverse为false，关联关系由Customer维护。我们保存Customer时，
        会维护Customer中orders中的所有Order的主键，但是Order是临时对象，并没有转变为持久状态，这时候就会抛出异常。
    
                @Test
                public void test() {
                    //读取配置文件
                    Configuration conf=new Configuration().configure();
    
                    //根据配置创建factory
                    SessionFactory sessionfactory=conf.buildSessionFactory();
                    session = sessionfactory.openSession(); 
                     Transaction ts=session.beginTransaction();
                     Customer c=new Customer();
                     c.setName("jack");
                     Order o1=new Order();
                     o1.setName("苹果");
                     Order o2=new Order();
                     o2.setName("香蕉");
                     c.getOrders().add(o1);
                     c.getOrders().add(o2);
                     o1.setCustomer(c);
                     o2.setCustomer(c);
    
                     session.save(c);
    
                    ts.commit();
                    session.close();
                    sessionfactory.close();
                }
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33

当Hibernate持久化一个临时对象时，并不会自动持久化所关联的其他临时对象，所以会抛出异常。  
如果我们希望Hibernate持久化对象时自动持久化所关联的其他对象，那么就需要指定cascade属性

**级联保存和更新**

当我们持久化对象时自动持久化所关联的其他对象。 
        把cascade属性设置为save-update ,这时候我们再执行上面的代码就会自动帮我们保存Customer关联的Order对象。 当cascade属性为save-update时，表明保存或更新当前对象时，会级联保存或更新与它关联的对象。 
       
        
         1
         2
         3
         4
         5

**级联删除**

如果我们的cascade属性为delete时，我们删除当前对象，会自动删除与之关联的对象。 慎用这个delete属性。 例如：我们的Order配置了这个属性，Customer也配置了这个属性，我们删除订单时，因为是级联删除 所以会查找Customer,删除Customer，但Customer也配置了级联删除，所以会查找所有关联的订单，最后会删除该客户的所有订单和该客户。 
       
        
         1
         2
         3
         4
         5

**孤儿删除**

如果我们的对象和关联的对象解除关系后，希望自动删除不再关联的对象。
        需要将cascade设置为delete-orphan.
    
        例如 ，我们设置cascade="delete-orphan"
                         Transaction ts=session.beginTransaction();
                         Customer c=session.get(Customer.class, 7);
                         Order order=(Order) c.getOrders().iterator().next();
                         c.getOrders().remove(order);
                         order.setCustomer(null);
                         ts.commit(); 
    
        我们解除Customer和Order的关系，Hibernate就会自动删除Order。  
    
    
        当cascade的值为all时，是save-update和delete的整合。
        当cascade的值为all-dalete-orphan时，是all和delete-orphan的整合。
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16