EHCache简单使用

最新推荐文章于 2021-11-14 13:05:45 发布
最新推荐文章于 2021-11-14 13:05:45 发布
阅读量575 收藏
点赞数
分类专栏： 开发技巧 文章标签： echcache
说明：本文转自 http://oaklet.iteye.com/blog/309037
按照原文创建一个java project，运行main方法会出现：
java.lang.NoClassDefFoundError: com/test/InsertDate
Caused by: java.lang.ClassNotFoundException: com.test.InsertDate
 at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
 at java.security.AccessController.doPrivileged(Native Method)
 at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
 at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
 at java.lang.ClassLoader.loadClass(ClassLoader.java:248)
Exception in thread "main"
建议创建web 工程，引入strutrs、spring、hibernate相关的包。
 
 
原文正文如下：
关于缓存的话题，在坛子里已经有很多讨论，简单的来说，如果一个应用中80% 的时间内都在访问20% 的数据，那么，这时候就应该使用缓存了。
测试环境：
MySQL 5.0.22，
jdk1.6.0_07，
ehcache-1.6.0-beta2，
mysql-connector-java-3.1.14

测试表：
Sql代码 
  1. CREATE TABLE TEST
  2. (
  3. TEST_ID BIGINT,
  4. TEST_NAME VARCHAR(50),
  5. TEST_TIME TIMESTAMP,
  6. TEST_VALUE DECIMAL(10, 3)
  7. ); 
CREATE TABLE TEST
(
TEST_ID BIGINT,
TEST_NAME VARCHAR(50),
TEST_TIME TIMESTAMP,
TEST_VALUE DECIMAL(10, 3)
);

支持类：
Java代码 
  1. public class Util {
  3. public static Random rand = new Random();
  4. public static String atoz = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  6. public static String genString(int length) {
  7. StringBuilder re = new StringBuilder(length);
  8. re.append(atoz.charAt(rand.nextInt(52)));
  9. for (int i = 0; i < length; i++) {
  10. re.append(atoz.charAt(rand.nextInt(62)));
  11. }
  12. return re.toString();
  13. }
  15. public static double genDouble() {
  16. double d1 = 5120 * rand.nextDouble();
  17. double d2 = 1024000 * rand.nextDouble();
  18. return d1 + d2;
  19. }
  20. } 
public class Util {

    public static Random rand = new Random();
    public static String atoz = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

    public static String genString(int length) {
        StringBuilder re = new StringBuilder(length);
        re.append(atoz.charAt(rand.nextInt(52)));
        for (int i = 0; i < length; i++) {
            re.append(atoz.charAt(rand.nextInt(62)));
        }
        return re.toString();
    }

    public static double genDouble() {
        double d1 = 5120 * rand.nextDouble();
        double d2 = 1024000 * rand.nextDouble();
        return d1 + d2;
    }
}

插入测试数据：
Java代码 
  1. public static void traditionalInsert(int total) throws Exception {
  2. Thread.sleep(3000);
  3. Timestamp current = new Timestamp(System.currentTimeMillis());
  4. String currentStr = dateFormat.format(current);
  5. System.out.println(currentStr);
  6. Connection conn = DriverManager.getConnection(dbURL, user, pass);
  7. try {
  8. long begin = System.currentTimeMillis();
  9. conn.setAutoCommit(false);
  10. String sql = "INSERT INTO TEST (TEST_ID,TEST_NAME,TEST_TIME,TEST_VALUE) VALUES (?, ?, ?, ?)";
  11. PreparedStatement ps = conn.prepareStatement(sql);
  12. for (int i = 1; i <= total; i++) {
  13. ps.setLong(1, i);
  14. ps.setString(2, Util.genString(33));
  15. ps.setTimestamp(3, current);
  16. ps.setBigDecimal(4, new BigDecimal(Util.genDouble()));
  17. ps.addBatch();
  18. if ((i % 500) == 0) {
  19. ps.executeBatch();
  20. }
  21. }
  22. ps.executeBatch();
  23. conn.commit();
  24. long end = System.currentTimeMillis();
  25. System.out.printf("Count:%d Time:%d\n", total, (end - begin));
  26. } catch (Exception ex) {
  27. ex.printStackTrace();
  28. conn.rollback();
  29. } finally {
  30. conn.close();
  31. }
  32. } 
public static void traditionalInsert(int total) throws Exception {
        Thread.sleep(3000);
        Timestamp current = new Timestamp(System.currentTimeMillis());
        String currentStr = dateFormat.format(current);
        System.out.println(currentStr);
        Connection conn = DriverManager.getConnection(dbURL, user, pass);
        try {
            long begin = System.currentTimeMillis();
            conn.setAutoCommit(false);
            String sql = "INSERT INTO TEST (TEST_ID,TEST_NAME,TEST_TIME,TEST_VALUE) VALUES (?, ?, ?, ?)";
            PreparedStatement ps = conn.prepareStatement(sql);
            for (int i = 1; i <= total; i++) {
                ps.setLong(1, i);
                ps.setString(2, Util.genString(33));
                ps.setTimestamp(3, current);
                ps.setBigDecimal(4, new BigDecimal(Util.genDouble()));
                ps.addBatch();
                if ((i % 500) == 0) {
                    ps.executeBatch();
                }
            }
            ps.executeBatch();
            conn.commit();
            long end = System.currentTimeMillis();
            System.out.printf("Count:%d Time:%d\n", total, (end - begin));
        } catch (Exception ex) {
            ex.printStackTrace();
            conn.rollback();
        } finally {
            conn.close();
        }
    }

使用的javaBean：
Java代码 
  1. public class TEST implements Serializable {
  2. private static final long serialVersionUID = 1L;
  3. public Long TEST_ID;
  4. public String TEST_NAME;
  5. public Timestamp TEST_TIME;
  6. public BigDecimal TEST_VALUE;
  7. @Override
  8. public String toString() {
  9. return String.format("ID:%s,,,NAME:%s", TEST_ID, TEST_NAME);
  10. }
  11. } 
public class TEST implements Serializable {
	private static final long serialVersionUID = 1L;
	public Long TEST_ID;
	public String TEST_NAME;
	public Timestamp TEST_TIME;
	public BigDecimal TEST_VALUE;
	@Override
	public String toString() {
		return String.format("ID:%s,,,NAME:%s", TEST_ID, TEST_NAME);
	}
}

先试一下缓存到字典中：
Java代码 
  1. public static HashMap<Long, TEST> simpleCache() throws Exception {
  2. HashMap<Long, TEST> cacheid = new HashMap<Long, TEST>();
  3. Class.forName(dbDriver);
  4. Connection conn = DriverManager.getConnection(dbURL, user, pass);
  5. try {
  6. long begin = System.currentTimeMillis();
  7. Statement s = conn.createStatement();
  8. String sql = "SELECT TEST_ID,TEST_NAME,TEST_TIME,TEST_VALUE FROM TEST";
  9. ResultSet querySet = s.executeQuery(sql);
  10. for (int i = 1; querySet.next(); i++) {
  11. TEST curr = new TEST();
  12. curr.TEST_ID = querySet.getLong(1);
  13. curr.TEST_NAME = querySet.getString(2);
  14. curr.TEST_TIME = querySet.getTimestamp(3);
  15. curr.TEST_VALUE = querySet.getBigDecimal(4);
  16. cacheid.put(curr.TEST_ID, curr);
  17. }
  18. long end = System.currentTimeMillis();
  19. System.out.printf("Time:%d\n", (end - begin));
  20. } catch (Exception ex) {
  21. ex.printStackTrace();
  22. } finally {
  23. conn.close();
  24. }
  25. return cacheid;
  26. } 
public static HashMap<Long, TEST> simpleCache() throws Exception {
        HashMap<Long, TEST> cacheid = new HashMap<Long, TEST>();
        Class.forName(dbDriver);
        Connection conn = DriverManager.getConnection(dbURL, user, pass);
        try {
            long begin = System.currentTimeMillis();
            Statement s = conn.createStatement();
            String sql = "SELECT TEST_ID,TEST_NAME,TEST_TIME,TEST_VALUE FROM TEST";
            ResultSet querySet = s.executeQuery(sql);
            for (int i = 1; querySet.next(); i++) {
                TEST curr = new TEST();
                curr.TEST_ID = querySet.getLong(1);
                curr.TEST_NAME = querySet.getString(2);
                curr.TEST_TIME = querySet.getTimestamp(3);
                curr.TEST_VALUE = querySet.getBigDecimal(4);
                cacheid.put(curr.TEST_ID, curr);
            }
            long end = System.currentTimeMillis();
            System.out.printf("Time:%d\n", (end - begin));
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            conn.close();
        }
        return cacheid;
    }

缓存到字典中，写法比较简单，使用方便，缺点就是缓存数据量比较少，一般缓存10W就有可能把jvm的缓存给占完了。用ehcache就可以解决缓存数据太少的问题。

一个简单的配置：
Xml代码 
  1. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:noNamespaceSchemaLocation="ehcache.xsd">
  3. <diskStore path="java.io.tmpdir"/>
  4. <defaultCache
  5. maxElementsInMemory="10000"
  6. maxElementsOnDisk="0"
  7. eternal="true"
  8. overflowToDisk="true"
  9. diskPersistent="false"
  10. timeToIdleSeconds="0"
  11. timeToLiveSeconds="0"
  12. diskSpoolBufferSizeMB="50"
  13. diskExpiryThreadIntervalSeconds="120"
  14. memoryStoreEvictionPolicy="LFU"
  15. />
  16. <cache name="demoCache"
  17. maxElementsInMemory="100"
  18. maxElementsOnDisk="0"
  19. eternal="false"
  20. overflowToDisk="false"
  21. diskPersistent="false"
  22. timeToIdleSeconds="119"
  23. timeToLiveSeconds="119"
  24. diskSpoolBufferSizeMB="50"
  25. diskExpiryThreadIntervalSeconds="120"
  26. memoryStoreEvictionPolicy="FIFO"
  27. />
  28. </ehcache>

Cache配置中的几个属性：

name：Cache的名称，必须是唯一的(ehcache会把这个cache放到HashMap里)。
maxElementsInMemory：内存中保持的对象数量。
maxElementsOnDisk：DiskStore中保持的对象数量，默认值为0，表示不限制。
eternal：是否是永恒数据，如果是，则它的超时设置会被忽略。
overflowToDisk：如果内存中数据数量超过maxElementsInMemory限制，是否要缓存到磁盘上。
timeToIdleSeconds：对象空闲时间，指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值0，表示一直可以访问。
timeToLiveSeconds：对象存活时间，指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值0，表示一直可以访问。
diskPersistent：是否在磁盘上持久化。指重启jvm后，数据是否有效。默认为false。
diskExpiryThreadIntervalSeconds：对象检测线程运行时间间隔。标识对象状态的线程多长时间运行一次。
diskSpoolBufferSizeMB：DiskStore使用的磁盘大小，默认值30MB。每个cache使用各自的DiskStore。
memoryStoreEvictionPolicy：如果内存中数据超过内存限制，向磁盘缓存时的策略。默认值LRU，可选FIFO、LFU。

获取配置中的demoCache：
Java代码 
  1. CacheManager manager = CacheManager.create("ehcache.xml");
  2. Cache demo = manager.getCache("demoCache"); 
CacheManager manager = CacheManager.create("ehcache.xml");
Cache demo = manager.getCache("demoCache");

往cache中加入数据：
Java代码 
  1. public static void ehcache() throws Exception {
  2. CacheManager manager = CacheManager.create("ehcache.xml");
  3. manager.addCache("TEST_ID.TEST");
  4. Cache cid = manager.getCache("TEST_ID.TEST");
  5. Class.forName(dbDriver);
  6. Connection conn = DriverManager.getConnection(dbURL, user, pass);
  7. try {
  8. long begin = System.currentTimeMillis();
  9. Statement s = conn.createStatement();
  10. String sql = "SELECT TEST_ID,TEST_NAME,TEST_TIME,TEST_VALUE FROM TEST";
  11. ResultSet querySet = s.executeQuery(sql);
  12. for (int i = 1; querySet.next(); i++) {
  13. TEST curr = new TEST();
  14. curr.TEST_ID = querySet.getLong(1);
  15. curr.TEST_NAME = querySet.getString(2);
  16. curr.TEST_TIME = querySet.getTimestamp(3);
  17. curr.TEST_VALUE = querySet.getBigDecimal(4);
  18. cid.put(new Element(curr.TEST_ID, curr));
  19. }
  20. long end = System.currentTimeMillis();
  21. System.out.printf("Time:%d\n", (end - begin));
  22. } catch (Exception ex) {
  23. ex.printStackTrace();
  24. } finally {
  25. conn.close();
  26. }
  27. } 
public static void ehcache() throws Exception {
        CacheManager manager = CacheManager.create("ehcache.xml");
        manager.addCache("TEST_ID.TEST");
        Cache cid = manager.getCache("TEST_ID.TEST");
        Class.forName(dbDriver);
        Connection conn = DriverManager.getConnection(dbURL, user, pass);
        try {
            long begin = System.currentTimeMillis();
            Statement s = conn.createStatement();
            String sql = "SELECT TEST_ID,TEST_NAME,TEST_TIME,TEST_VALUE FROM TEST";
            ResultSet querySet = s.executeQuery(sql);
            for (int i = 1; querySet.next(); i++) {
                TEST curr = new TEST();
                curr.TEST_ID = querySet.getLong(1);
                curr.TEST_NAME = querySet.getString(2);
                curr.TEST_TIME = querySet.getTimestamp(3);
                curr.TEST_VALUE = querySet.getBigDecimal(4);
                cid.put(new Element(curr.TEST_ID, curr));
            }
            long end = System.currentTimeMillis();
            System.out.printf("Time:%d\n", (end - begin));
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            conn.close();
        }
    }

这里在CacheManager中直接加入了一个叫TEST_ID.TEST的cache。因为只给了一个名字，所以系统会把defaultCache的设置给它clone一份。
使用方法，像字典一样使用就行：
Java代码 
  1. Cache cid = manager.getCache("TEST_ID.TEST");
  2. Element e5120 = cid.get(new Long(5120));
  3. System.out.println(e5120.getValue()); 
Cache cid = manager.getCache("TEST_ID.TEST");
Element e5120 = cid.get(new Long(5120));
System.out.println(e5120.getValue());


ehcache中数据是以java对象的形式存在的，使用了java的序列化保存到磁盘，所以保存的对象要实现Serializable接口。ehcache还可以支持分布式缓存。
andy_713
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ehcache三个小demo
04-05
三个ehcache的小demo，两个web程序，一个纯java，java项目是采用注解和xml配置，是后台缓存。一个web项目是注解配置，后台缓存；另一个是拦截器配置，前天缓存
SpringBoot中使用Ehcache的详细教程
08-18
- **快速和简单**：EhCache设计简洁，易于集成和使用。 - **多种缓存策略**：支持LRU（Least Recently Used）、LFU（Least Frequently Used）等缓存淘汰策略。 - **内存和磁盘存储**：当内存达到预设上限时，数据会...
简单的使用ehcache
weixin_33978044的博客
11-11 112
之前一直感觉缓存是高上大的东西，没有心思去研究。做了之后发现，简单的使用还是很容易的。这里记录ehcache在jfinal中的简单使用。 1.ehcahe简介 EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。 看到官网上已经3.0了。 2.作用 我把它当做一个可以存储数据和读...
ehcache简单使用
weixin_30486037的博客
05-04 113
项目中需要实现一个功能，定时查询FTP服务器某个目录下的文件，并及时下载至本机，同时不能消耗太多系统资源。 最后实现是使用ehcache，将文件路径和文件大小缓存，如果前后两次无变化，则忽略。如果同一路径大小有变化，则下载此文件。 当然，由于缓存的不可靠近，如果数据库可以支持，可以将数据写入表中，对数值进行标记。这样更加可靠。 以下是ehcache的简单应用。 1、下载ehcac...
EHCache的使用
08-08
### EHCache的使用详解 #### 一、EHCache概述与特点 EHCache 是一款非常流行的开源缓存组件，由 SourceForge 提供支持。作为一个纯 Java 实现的高性能缓存库，EHCache 在处理高并发场景下表现优异。其主要特点包括...
Ehcache集群使用
04-08
**Ehcache 集群使用详解** Ehcache 是一款高效、易用且功能丰富的内存缓存系统，常用于提升 Java 应用程序的性能和响应速度。它支持本地缓存、分布式缓存以及集群配置，使得多台服务器之间可以共享缓存数据，从而...
cache/ehcache缓存使用
10-23
以下是一个简单的示例，展示了如何在Java代码中使用Ehcache： ```java import net.sf.ehcache.CacheManager; import net.sf.ehcache.Element; public class JDBCEhcache { public static void main(String[] ...
ehCache 使用例子
10-21
在Java领域，缓存是优化系统性能的重要手段之一，而ehCache因其简单易用和强大的功能，成为了许多开发者的首选。 在ehCache的使用中，我们通常会遇到以下关键知识点： 1. **配置**：ehCache的配置文件通常是`...
ehCache
huanghm88的专栏
02-21 936
1、最近在做一个贷款项目是城市分站的 分为贷款前台和贷款机构后台，这个两个平台的二级域名不一样，一个前台是cityname.xx.com,cityname是会地区的不同而变化的，如在 北京就是bj.xx.com,机构后台是loan.xx.com,在机构登录的时候 ，如果把登录信息放在session，会有一个问题，就是当切换到前台的时候，由于域名改变了，此时session就会改变，之前session
EHCache的简单使用
u012111199的博客
06-13 130
一、创建ehcache配制文件，放到classes目录下 &lt;?xml version="1.0" encoding="UTF-8"?&gt;&lt;!-- &lt;ehcache xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xsi:noNamespaceSchemaLocation=”ehcache.xsd”updateChe...
ehcache的简单使用
jie_kong的专栏
02-15 653
因项目需要缓存来所以学习encache。
简单的使用Ehcache
左岸
05-06 164
缓存清除策略，官方文档给出的有   LRU - least recently used（最近最少使用） LFU - least frequently used（最不经常使用） FIFO - first in first out, the oldest element by creation time（清除最早缓存的数据，不关心是否经常使用） 1实体要序列化 public cla...
Ehcache 的简单使用
特别享受思考问题的过程
11-14 1736
文章目录Ehcache 的简单使用背景使用版本配置配置项编程式配置XML 配置自定义监听器验证示例代码改进代码备注完整示例代码官方文档 Ehcache 的简单使用 背景 当一个JavaEE-Java Enterprise Edition应用想要对热数据(经常被访问，很少被修改的数据)进行缓存时，在遥远的年代，还没有Redis，开发者们想到的是直接利用JDK中的集合进行缓存。随之而来的问题是，JVM内存毕竟有限，如果热数据太多，过期策略、驱逐策略这些都需要开发者手动编写。那么Ehcache是主要解决这类问题的
Ehcache的简单使用
在水一方的博客
07-28 423
1.使用场景： 高频次访问 数据时效性要求不高 数据获取比较难（经过一定的计算）2.使用的意义： 提高反馈速度 节省计算资源（当然，这个一般比较次要）上例子1.类路径下添加ehcache.xml配置文件 2.添加缓存管理器（采用注解的方式） 3.在被应用的方法上使用@Cacheable即可，当然Ehcache的注解比较多这里不做过多
Ehcache简单使用
代码的艺术
03-23 1096
一个ehcache的简单工具类， 测试环境 jdk1.6 Ehcahce ehcache-2.8.3 package com.utils; import java.net.URL; import com.Person; import net.sf.ehcache.Cache; import net.sf.ehcache.CacheManager; impor
热数据本地缓存 - ehcache
Zoey~~
12-12 628
什么是ehCache EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。 一、具体描述 Ehcache是一个用Java实现的使用简单，高速，实现线程安全的缓存管理类库，ehcache提供了用内存，磁盘文件存储，以及分布式存储方式等多种灵活的cache管理方案。同时ehcache作为开放源代码项目，采用限制比较宽松的Apa...
Ehcache深度解析：API使用与缓存管理
这是最简单的初始化方式，Ehcache会在类路径下查找默认的配置文件。 - **方法二**：通过指定配置文件路径来创建CacheManager。这种方法允许自定义配置，例如`src/config/ehcache.xml`。 - **方法三**：通过URL加载...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值