Hibernate（4）- Session会话

淩亂°似流年 2024-04-17 23:24 54阅读 0赞

###  1.Session概述 ###

1.  Session接口数Hibernate提供的操作数据库的最主要的接口，这个接口中有一系列更新，删除，保存和加载（根据唯一的UID将数据记录转换为对象到内存中）的方法。
2.  Seesion的对象具有一个一级的缓存，位于一级缓存中的对象称之为持久化的对象（这些对象和数据库中的一些记录一一对应）。Session可以在某些时间点按照缓存中对象的变化来执行相关的SQL语句，来同步更新数据库，这一个过程称之为刷新缓存（fluseh()方法）。
3.  站在持久化的角度，Hibernate把对象分为4种状态：持久化状态，临时状态，游离状态，删除状态。Session的特定方法能使对象从一个状态转换到另外一个状态。

### 2.Session缓存 ###

1.  Session接口的实现类中包含一系列的Java的集合，这些Java的集合构成了Session缓存，只要Session的实例还没有结束生命周期，且没有清理缓存，那么这个Session对象中的缓存中的对象也不会结束生命周期，哪怕没有任何变量引用这些位于缓存中的持久化的对象。
2.  Session缓存的功能  
    Session缓存可以有效的减少HIbernate应用程序访问数据库的频率。因为它可以从缓存中拿取数据，而不必再从数据库中拿取数据。
3.  Session实例对象的方法![Center][]
    
    1.  flush缓存
        
        1.  flush:Session按照缓存中对象的属性变化来同步更新数据库
        2.  默认情况下Session在以下时间点刷新缓存：
            
            1.  显示调用Session的flush（）方法
            2.  当应用程序调用Transaction()的commit（）方法的时候，该方法先flush，然后再向数据库提交事务。
            3.  当应用程序执行一些查询（HQL，Criteria）操作时，如果缓存中持久化对象的属性已经发生了变化，会先flush缓存，以保证查询结构能够反映持久化对象的最新状态
        3.  flush缓存的例外情况：如果对象使用native生成器生成OID，那么当调用Session的save（）方法保存对象时，会立即执行向数据库插入该实体的insert语句。
        4.  commit（）和flush()方法的区别：flush执行一系列sql语句，但不提交事务；commit方法先调用flush（）方法，然后提交事务，意味着提交事务对数据库永久保存下来。
    2.  refresh
        
        1.  这个方法会强制性的发出查询（select）语句使得Session缓存中的对象和数据库中的记录保持一致，也就是保证缓存中的数据是最新的数据。  
            需要注意的是，使用这个方法前必须查看数据库针对事务的隔离级别是什么，我们必选将数据库的隔离级别设置成读已提交的即2--read\_commited才可以使refresh()方法生效。  
            MySql默认数据库隔离级别是repeatable\_read（可重复读），Oracle数据库的默认隔离级别是read\_commited。详情下图  
            ![Center 1][]![Center 2][]  
            hibernate.cfg.xml
            
                <?xml version='1.0' encoding='utf-8'?>
                <!DOCTYPE hibernate-configuration PUBLIC
                       "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
                "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
                 
                <hibernate-configuration>
                 
                	<session-factory>
                		
                		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
                		<property name="connection.url">jdbc:mysql://localhost:3306/hibernate?characterEncoding=UTF-8</property>
                		<property name="connection.username">root</property>
                		<property name="connection.password">admin</property>
                		
                		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
                		<property name="current_session_context_class">thread</property>
                		<property name="format_sql">true</property>
                		<property name="show_sql">true</property>
                		<property name="hbm2ddl.auto">update</property>
                		
                		
                		<property name="connection.isolation">2</property>
                		
                		<mapping resource="com/hibernate/News.hbm.xml" />
                	</session-factory>
                 
                </hibernate-configuration>
            
             
    3.  clear  
        顾名思义，就是清除Session实例中的缓存对象。

### 3.测试 ###

**测试的方法有：**

1.  session缓存
2.  flush测试
3.  refresh测试
4.  save测试
5.  clear测试

package com.hibernate;
     
    import java.util.Date;
     
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.cfg.Configuration;
    import org.hibernate.mapping.Set;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
     
    import com.hibernate.News;
     
    public class HibernateTest {
    	private SessionFactory sessionfactory;
    	private Session session;
    	private Transaction transaction;
     
    	/**先使用以下代码看能否正常运行，然后再测试各种方法
    	public static void main(String[] args) {
        	
            SessionFactory sf = new Configuration().configure().buildSessionFactory();//获取SessionFactory
     
            Session s = sf.openSession();//通过SessionFactory 获取一个Session
            s.beginTransaction();//在Session基础上开启一个事务
     
            News p = new News();
            p.setAuthor("yiguang");
            p.setTitle("tianshilikai");
            p.setDate(null);
            s.save(p);//通过调用Session的save方法把对象保存到数据库
             
            s.getTransaction().commit();//提交事务
            s.close();//关闭Session
            sf.close();//关闭SessionFactory
        	
        	}
       **/
    	
    	@Before
    	public void init() {
    		 sessionfactory=new Configuration().configure().buildSessionFactory();
    		 session= sessionfactory.openSession();//通过SessionFactory 获取一个Session
    		 transaction=session.beginTransaction();
    		
    	}
    	
    	@After
    	public void destroy() {
    		transaction.commit();
    		session.close();
    		sessionfactory.close();
    		
    	}
     
    	//测试clear
    	/*
    	 * clear():清理缓存
    	 */
    	@Test
    	public void testClear() {
    		News news5=(News) session.get(News.class,1);
    		System.out.println(news5);
    		
    		session.clear();
    		
    		News news6=(News) session.get(News.class,1);
    		System.out.println(news6);
    	}
    	
    	//测试refresh 
    	/*
    	 * refresh():会强制发送select语句，以使session缓存中对象的状态和数据表中的数据保持一致。
    	 */
    	@Test
    	public void refresh() {
    		News news4=(News) session.get(News.class, 1);
    		System.out.println(news4);
    		
    		session.refresh(news4);//修改Author
    		System.out.println(news4);
    	}
    	
    	//测试flush
    	/**
    	 * flush:使数据表中的记录和Session缓存中的对象的状态保持一致，为了保持一致，则可能会发送对应的sql语句。
    		1.在Transaction的commit（）方法中：先调用session的flush方法，再提交事务
    		2.flush（）方法可能会发送SQL语句，但不会提交事务。
    		3.注意：在未提交事务或显示的调用session.flush()方法之前，也有可能会进行flush（）操作。
    			1.执行HQL或QBC查询，会先进行flushz()操作，以得到数据包的最新记录。因为save方法后，必须保证对象的id是存在的。
    	 */
    	@Test
    	public void testSessionFlush() {
    		News news=(News) session.get(News.class, 1);
    		System.out.println(news);
    		
    		news.setAuthor("oracle");//开始Author为mysql
    		session.flush();
    		System.out.println(news);
    	}
    	
    	@Test
    	public void testSessionFlush2() {
    		News news3=new News("fanren1","wangyu", new Date());
    		session.save(news3);
    	}
    	
    	//session缓存测试
    	@Test
    	public void testSessionCache() {
    		//两条sql语句，但是只向数据库发送一条请求
    		News news=(News) session.get(News.class, 1);
    		System.out.println(news);
    		
    		News news2=(News) session.get(News.class, 1);
    		System.out.println(news2);
    		
            }
    	
    	//添加一条数据
    	@Test
    	public void testInsert() {
    		News news1=new News("fanren2","wangyu",new Date());
    		session.save(news1);
    	}
     	
        	
    }

[Center]: https://img-blog.csdn.net/20180105001255350?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveWlndWFuZ184MjA=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 1]: https://img-blog.csdn.net/20180105001338353?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveWlndWFuZ184MjA=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 2]: https://img-blog.csdn.net/20180105001342748?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveWlndWFuZ184MjA=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center