hibernate之二级缓存ehcache的特点及应用查询单个案例

1、为什么需要缓存？

拉高程序的性能。

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

关系型数据库：数据与数据之间存在关系（联系）的数据库 mysql/Oracle、sqlserver
非关系型数据库：数据与数据之间是不存在关系的，key-value
1、基于文件存储的数据库：ehcache
2、基于内存存储的数据库：redis、memcache
3、基于文档存储的数据库：mongodb

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

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

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

①、数据字典

（1）数字字典是什么：一个项目中所有的基础数据；就是项目中所有的下拉框

（2）解决的问题：100个下拉框-->100个表

表设计：

数据源表：数据源标识、数据源描述；

数据项表：数据源标识、数据项键、数据项值；

3. ehcache是什么？

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

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

特点：

①、够快：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）导入相关依赖*

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
4.0.0
hmf
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
       5.1.46

       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

用map集合简易实现缓存原理

package com.hmf.four.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"));
   }
}

结果

演示利用缓存存储数据

导入文件（ehcache.xml）

实体类

package com.hmf.four.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.hmf.four.test;

import com.hmf.four.util.EhcacheUtil;

public class EhcacheDemo2 {
   public static void main(String[] args) {
       System.out.println(System.getProperty("java.io.tmpdir"));
       EhcacheUtil.put("com.javaxl.four.entity.Book", 11, "zhangsan");
       System.out.println(EhcacheUtil.get("com.javaxl.four.entity.Book", 11));
   }
}

同一个session，SQL语句只生成一次（一级缓存）

修改ehcache.xml

overflowToDisk="true" diskPersistent="true" timeToIdleSeconds="0"
timeToLiveSeconds="300" memoryStoreEvictionPolicy="LRU"/>

hibernate使用echcache作为二级缓存 ①、默认一级缓存：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得到三个结果

使用的Dao（UserDao ）

package com.hmf.four.dao;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.hmf.one.entity.User;
import com.hmf.two.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);

   }

测试

hibernate之二级缓存ehcache的特点及应用查询单个案例

Java相关栏目本月热门文章