Hibernate实战——查询缓存

╰+攻爆jí腚メ 2021-07-24 23:17 511阅读 0赞

**一 配置**

<?xml version="1.0" encoding="GBK"?>
    
    <!DOCTYPE hibernate-configuration PUBLIC
         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
         "http://hibernate.sourceforge.net/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</property>
               
               <property name="connection.username">root</property>
               
               <property name="connection.password">32147</property>
               
               <property  name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
               
               <property name="hbm2ddl.auto">update</property>
               
               <property  name="hibernate.c3p0.max_size">20</property>
               
               <property name="hibernate.c3p0.min_size">1</property>
               
               <property  name="hibernate.c3p0.timeout">5000</property>
               
               <property  name="hibernate.c3p0.max_statements">100</property>
               <property  name="hibernate.c3p0.idle_test_period">3000</property>
               <property  name="hibernate.c3p0.acquire_increment">2</property>
               <property  name="hibernate.c3p0.validate">true</property>
               <property name="hibernate.show_sql">true</property>
               <property name="hibernate.format_sql">true</property>
               
               <property  name="hibernate.cache.use_second_level_cache">true</property>
               
               <property       name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
               
               <property  name="hibernate.generate_statistics">true</property>
               
               <property  name="hibernate.cache.use_structured_entries">true</property>
               
               <property  name="hibernate.cache.use_query_cache">true</property>
         
               
               <property  name="hibernate.current_session_context_class">thread</property>
               
               <mapping class="org.crazyit.app.domain.News"/>
         </session-factory>
    </hibernate-configuration>

缓存配置

<?xml version="1.0" encoding="GBK"?>
    <ehcache>
         <diskStore path="java.io.tmpdir"/>
         <defaultCache
               maxElementsInMemory="10000"
               eternal="false"
               overflowToDisk="true"
               timeToIdleSeconds="120"
               timeToLiveSeconds="120"
               diskPersistent="false"/>
    </ehcache>

**二 PO**

package org.crazyit.app.domain;
    
    import javax.persistence.*;
    import org.hibernate.annotations.Cache;
    import org.hibernate.annotations.CacheConcurrencyStrategy;
    
    @Entity
    @Table(name="news_inf")
    @Cache(usage=CacheConcurrencyStrategy.READ_ONLY)
    public class News
    {
        // 消息类的标识属性
        @Id @Column(name="news_id")
        @GeneratedValue(strategy=GenerationType.IDENTITY)
        private Integer id;
        private String title;
        private String content;
    
        // 无参数的构造器
        public News()
        {
        }
        // 初始化全部成员变量的构造器
        public News(Integer id , String title , String content)
        {
            this.id = id;
            this.title = title;
            this.content = content;
        }
    
        // id的setter和getter方法
        public void setId(Integer id)
        {
            this.id = id;
        }
        public Integer getId()
        {
            return this.id;
        }
    
        // title的setter和getter方法
        public void setTitle(String title)
        {
            this.title = title;
        }
        public String getTitle()
        {
            return this.title;
        }
    
        // content的setter和getter方法
        public void setContent(String content)
        {
            this.content = content;
        }
        public String getContent()
        {
            return this.content;
        }
    }

**三 测试**

package lee;
    
    import org.hibernate.*;
    import org.hibernate.cfg.*;
    import org.hibernate.service.*;
    import org.hibernate.boot.registry.*;
    
    import java.util.*;
    
    import org.crazyit.app.domain.*;
    
    
    public class NewsManager
    {
        static Configuration conf = new Configuration()
            .configure();
        // 以Configuration实例创建SessionFactory实例
        static ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
            .applySettings(conf.getProperties()).build();
        static SessionFactory sf = conf.buildSessionFactory(serviceRegistry);
        public static void main(String[] args) throws Exception
        {
            NewsManager mgr = new NewsManager();
            mgr.cacheQuery();
            mgr.stat();
        }
    
        private void noCacheQuery()
        {
            Session session = sf.getCurrentSession();
            session.beginTransaction();
            List titles  = session.createQuery("select news.title from News news")
                // 其实无需设置，默认就是关闭缓存的。
                .setCacheable(false)
                .list();
            for(Object title : titles)
            {
                System.out.println(title);
            }
            System.out.println("-------------------------");
            // 第二次查询，因为没有使用查询缓存，因此会重新发出SQL语句进行查询
            titles  = session.createQuery("select news.title from News news")
                // 其实无需设置，默认就是关闭缓存的。
                .setCacheable(false)
                .list();
            for(Object title : titles)
            {
                System.out.println(title);
            }
            session.getTransaction().commit();
        }
    
        private void cacheQuery()
        {
            Session session = sf.getCurrentSession();
            session.beginTransaction();
            List titles  = session.createQuery("select news.title from News news")
                // 开启查询缓存
                .setCacheable(true)
                .list();
            for(Object title : titles)
            {
                System.out.println(title);
            }
            session.getTransaction().commit();
            System.out.println("-------------------------");
            Session sess2 = sf.getCurrentSession();
            sess2.beginTransaction();
            // 第二次查询，使用查询缓存，因此不会重新发出SQL语句进行查询
            titles  = sess2.createQuery("select news.title from News news")
                // 开启查询缓存
                .setCacheable(true)
                .list();
            for(Object title : titles)
            {
                System.out.println(title);
            }
            sess2.getTransaction().commit();
        }
    
        // 开启查询缓存，但使用iterate()方法查询，因此也不能缓存
        public static void cacheQueryIterator()
        {
            Session session = sf.getCurrentSession();
            session.beginTransaction();
            Iterator it  = session.createQuery("select news.title from News news")
                // 开启查询缓存
                .setCacheable(true)
                .iterate();
            while(it.hasNext())
            {
                System.out.println(it.next());
            }
            session.getTransaction().commit();
            System.out.println("-------------------------");
            Session sess2 = sf.getCurrentSession();
            sess2.beginTransaction();
            // 第二次查询，虽然使用了查询缓存，但由于使用iterate()获取查询结果，
            // 因此无法利用查询缓存。
            it  = sess2.createQuery("select news.title from News news")
                // 开启查询缓存
                .setCacheable(true)
                .iterate();
            while(it.hasNext())
            {
                System.out.println(it.next());
            }
            sess2.getTransaction().commit();
        }
        private void stat()
        {
            //----------统计查询缓存----------
            long hitCount = sf.getStatistics()
                //查询缓存的名字与HQL语句或SQL语句相同
                .getQueryStatistics("select news.title from News news")
                .getCacheHitCount();
            System.out.println("查询缓存命中的次数：" + hitCount);
        }
    }

**四 数据**

drop database hibernate;
    
    create database hibernate;
    
    use hibernate;
    
    create table news_inf
    (
    news_id int primary key auto_increment,
    title varchar(255),
    content varchar(255)
    );
    
    insert into news_inf
    values(null , '疯狂Java联盟' , '疯狂Java联盟成立了，网址是www.crazyit.org');
    
    insert into news_inf
    values(null , '天快亮了' , '等到那一天，四周一下光亮了，空气中酝酿着自由、民主的芬芳！');

**五 测试**

Hibernate:
        select
            news0_.title as col_0_0_
        from
            news_inf news0_
    疯狂Java联盟
    天快亮了
    -------------------------
    疯狂Java联盟
    天快亮了
    查询缓存命中的次数：1