栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Hibernate之二级缓存*

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Hibernate之二级缓存*

1、为什么需要缓存?

      拉高程序的性能。

①、缓存也被称为非关系型数据库

   关系型数据库:数据与数据之间存在关系(联系)的数据库    mysql/Oracle、sqlserver
   非关系型数据库:数据与数据之间是不存在关系的,key-value
        1、基于文件存储的数据库:ehcache
        2、基于内存存储的数据库:redis、memcache
        3、基于文档存储的数据库:mongodb
今天学的是:ehcache

②、 非关系型数据库的存储是以键值对的形式存储

2. 什么样的数据需要缓存

很少被修改或根本不改的数据    数据字典
业务场景比如:耗时较高的统计分析sql、电话账单查询sql等

①、数据字典

(1)数字字典是什么:一个项目中所有的基础数据;就是项目中所有的下拉框

(2)解决的问题:100个下拉框-->100个表

         表设计:

                    数据源表:数据源标识、数据源描述;

                    数据项表:数据源标识、 数据项键、数据项值;

3. ehcache是什么?

    Ehcache 是现在最流行的纯Java开源缓存框架,配置简单、结构清晰、功能强大 ;

    注1:本章介绍的是2.X版本,3.x的版本和2.x的版本API差异比较大

4. ehcache的特点
①、 够快:Ehcache的发行有一段时长了,经过几年的努力和不计其数的性能测试,Ehcache终                      被设计于large, high concurrency systems.;

②、够简单:开发者提供的接口非常简单明了,从Ehcache的搭建到运用运行仅仅需要的是你宝                         贵的几分钟。其实很多开发者都不知道自己用在用Ehcache,Ehcache被广泛的运用                      于其他的开源项目;

③、够袖珍:关于这点的特性,官方给了一个很可爱的名字small foot print ,一般Ehcache的发布                       版本不会到2M,V 2.2.3 才 668KB。

④、够轻量:核心程序仅仅依赖slf4j这一个包,没有之一!

⑤、好扩展:Ehcache提供了对大数据的内存和硬盘的存储,最近版本允许多实例、保存对象高                         灵 活性、提供LRU、LFU、FIFO淘汰算法,基础属性支持热配置、支持的插件多;

⑥、监听器:缓存管理器监听器 (CacheManagerListener)和 缓存监听器                                                        (CacheEvenListener),做一些统计或数据一致性广播挺好用的;

⑦、分布式缓存: 从Ehcache 1.2开始,支持高性能的分布式缓存,兼具灵活性和扩展性;

5、 ehcache的使用

 ①、导入相关依赖

 ②、 核心接口
      CacheManager:缓存管理器
      Cache:缓存对象,缓存管理器内可以放置若干cache,存放数据的实质,所有cache都实现                       了Ehcache接口
      Element:单条缓存数据的组成单位

③、src:ehcache.xml

6、 hibernate缓存
   ①、 一级缓存:session

   ②、 二级缓存:SessionFactory
      可拔插式

一、Ehcache的使用

(1)导入相关依赖*


    
      	net.sf.ehcache
        ehcache
        2.10.0
    

推荐使用方法:


		UTF-8
		2.10.0


   
			net.sf.ehcache
			ehcache
			${ehcache.version}
   
1、ehcache的存取数据

①、所有相关依赖(pom.xml)


  4.0.0
  com.mwy
  Hibernate
  war
  0.0.1-SNAPSHOT
  Hibernate Maven Webapp
  http://maven.apache.org
  
  
		UTF-8
		1.8
		1.8

		4.12
		4.0.0
		5.2.12.Final
		8.0.19

		2.10.0
		1.7.7
		2.9.1
	
  
  
    
			junit
			junit
			${junit.version}
			test
		

		
			javax.servlet
			javax.servlet-api
			${servlet.version}
			provided
		

		
			org.hibernate
			hibernate-core
			${hibernate.version}
		

		
			mysql
			mysql-connector-java
			${mysql.driver.version}
		
		
		
			net.sf.ehcache
			ehcache
			${ehcache.version}
		

		
			org.hibernate
			hibernate-ehcache
			${hibernate.version}
		
		
		
		
			org.slf4j
			slf4j-api
			${slf4j-api.version}
		
		
			org.slf4j
			jcl-over-slf4j
			${slf4j-api.version}
			runtime
		

		
		
			org.apache.logging.log4j
			log4j-slf4j-impl
			${log4j-api.version}
		

		
		
			org.apache.logging.log4j
			log4j-api
			${log4j-api.version}
		
		
			org.apache.logging.log4j
			log4j-core
			${log4j-api.version}
		
  
  
    Hibernate
    
    
        
				org.apache.maven.plugins
				maven-compiler-plugin
				3.7.0
				
					1.8
					1.8
					UTF-8
				
		
    
    
  
(1)①、用map集合简易实现缓存原理
package com.mwy.ehcache.test;
import java.util.HashMap;
import java.util.Map;

public class EhcacheDemo1 {
	static Map cache = new HashMap();
	static Object getValue(String key) {
		//从缓存中取数据
		Object value = cache.get(key);
		if(value == null) {
			//没有取到
			System.out.println("hello zs");//从数据库中读取数据
			//把数据库数据同步到缓存
			cache.put(key, new String[] {"zs"});
			//进行返回
			return cache.get(key);
		}
		//取到
		return value;
	}
	public static void main(String[] args) {
		System.out.println(getValue("sname"));//数组
		System.out.println(getValue("sname"));
		//结果:hello zs  从数据库中读取数据
		//zs   返回值
		//zs
	}
}

②、怎么使用缓存
   1、优先从缓存中获取数据(因为性能好)
   2、如果获取到,那么直接返回
   3、没有获取到,那么查询数据库,将数据库对应数据放入缓存,再返回; 

注意:只要使用缓存,默认缓存中就有数据

③、得到结果

(2)演示利用缓存存储数据

①、看图

 

 ②、导入文件(ehcache.xml)



    
    
    
    
    


    
    
    
    
    
    
    
    
    
    
    
    


    
    

③、缓存工具类

package com.mwy.ehcache.util;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import java.io.InputStream;
public class EhcacheUtil {
    private static CacheManager cacheManager;

    static {
        try {
            InputStream is = EhcacheUtil.class.getResourceAsStream("/ehcache.xml");
            cacheManager = CacheManager.create(is);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private EhcacheUtil() {
    }
  //放数据
    public static void put(String cacheName, Object key, Object value) {
        Cache cache = cacheManager.getCache(cacheName);
        if (null == cache) {
            //以默认配置添加一个名叫cacheName的Cache
            cacheManager.addCache(cacheName);
            cache = cacheManager.getCache(cacheName);
        }
        cache.put(new Element(key, value));
    }
//取数据
    public static Object get(String cacheName, Object key) {
        Cache cache = cacheManager.getCache(cacheName);
        Element element = cache.get(key);
        return null == element ? null : element.getValue();
    }

    public static void remove(String cacheName, Object key) {
        Cache cache = cacheManager.getCache(cacheName);
        cache.remove(key);
    }
}

④、测试代码

package com.mwy.ehcache.test;
import com.mwy.ehcache.util.EhcacheUtil;

public class EhcacheDemo2 {
	public static void main(String[] args) {
		//默认的临时文件路径
		System.out.println(System.getProperty("java.io.tmpdir"));
		EhcacheUtil.put("com.mwy.entity.Book", 11, "mwy");
		System.out.println(EhcacheUtil.get("com.mwy.entity.Book", 11));
	}
}

结果(存到默认的临时文件路径)

⑤、将结果指定在硬盘上存储对象的路径 

代码

package com.mwy.ehcache.test;
import com.mwy.ehcache.util.EhcacheUtil;
public class EhcacheDemo2 {
	public static void main(String[] args) {
		//默认的临时文件路径
		System.out.println(System.getProperty("java.io.tmpdir"));
		EhcacheUtil.put("com.mi.entity.User", 11, "mwy");
		System.out.println(EhcacheUtil.get("com.mi.entity.User", 11));
	}
}

修改ehcache.xml

 
    

得到结果(存储到了指定硬盘)

 2、hibernate使用echcache作为二级缓存

演示一个现象:

同一个session,sql语句只生成一次,这里用到了一级缓存

①、默认一级缓存:session级别的缓存
@Test
	public void test1() {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		
		User user = session.get(User.class, 7);
		System.out.println(user);
		User user2 = session.get(User.class, 7);
		System.out.println(user2);
		User user3 = session.get(User.class, 7);
		System.out.println(user3);
		
		transaction.commit();
		session.close();
	}

结果只会执行一个sql得到三个结果

 原因:当第一个session执行后,获得了结果,第二个执行的时候,会获取上一个session的副本

            因而只会执行一个sql;

 ②、sessionFactory二级缓存

第一步:核心配置文件(hibernate.cfg.xml)

 
      true
     
      true
     
     
      org.hibernate.cache.ehcache.EhCacheRegionFactory

第二步:二级缓存并不是随便用的,内存是有限的(并不是每一个表使用的实体类都要使用二级缓存)

由于要使用User实体类,就要在它的映射文件(User.hbm,xml)中进行配置

要保持一致 

 ehcache.xml中也要保持一致

 使用的Dao(UserDao )

package com.mwy.ehcache.dao;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.mwy.entity.User;
import com.mwy.util.SessionFactoryUtil;
public class UserDao {
	public User get(User user) {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		User u = session.get(User.class, user.getId());
		transaction.commit();
		session.close();
		return u;
	}
}

测试

	@Test
	public void test2() {
		UserDao userDao  = new UserDao();
		User u = new User();
		u.setId(7);
		User user = userDao.get(u);
		System.out.println(user);
		User user2 = userDao.get(u);
		System.out.println(user2);
		User user3 = userDao.get(u);
		System.out.println(user3);
		
	}

得到结果:

3、hibernate多条记录缓存 ①、hibernate二级缓存不会同时缓存多条数据
public static void main(String[] args) {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		
		Query query = session.createQuery("from User");
		List list = query.list();
		System.out.println(list);
		List list2 = query.list();
		System.out.println(list2);
		List list3 = query.list();
		System.out.println(list3);
		
		transaction.commit();
		session.close();
	}

得到结果:(运行了3次sql语句)

 

 ②、这么设计的原因

 例如:查询多条数据时,每个查询都有一个结果,如果数据量庞大,假设有1亿条,那么sessionFactory内存会被撑爆;

所以默认把缓存机制关掉,查询多条数据时自动在数据库中查询;

内存是给某一条数据或单条数据使用;

如果要缓存多条数据也是可以的,通过手动代码去控制;

query.setCacheable(true);

public static void main(String[] args) {
		Session session = SessionFactoryUtil.getSession();
		Transaction transaction = session.beginTransaction();
		Query query = session.createQuery("from User");

		query.setCacheable(true);

		List list = query.list();
		System.out.println(list);
		List list2 = query.list();
		System.out.println(list2);
		List list3 = query.list();
		System.out.println(list3);
		transaction.commit();
		session.close();
	}

得到结果:

今天到这就结束了~~~~

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/337261.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号