liu517139239
- 浏览: 5508 次
- 性别:
- 来自: 上海
-
文章分类
最新评论
EHCache简单使用 博客分类： java
转载：http://voyageivi.iteye.com/blog/1484715 感谢分享。
SQLCacheMySQLJVMXML .
关于缓存的话题，在坛子里已经有很多讨论，简单的来说，如果一个应用中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 {
2.
3. public static Random rand = new Random();
4. public static String atoz = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
5.
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. }
14.
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>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="ehcache.xsd">
<diskStore path="java.io.tmpdir"/>
<defaultCache
maxElementsInMemory="10000"
maxElementsOnDisk="0"
eternal="true"
overflowToDisk="true"
diskPersistent="false"
timeToIdleSeconds="0"
timeToLiveSeconds="0"
diskSpoolBufferSizeMB="50"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LFU"
/>
<cache name="demoCache"
maxElementsInMemory="100"
maxElementsOnDisk="0"
eternal="false"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="119"
timeToLiveSeconds="119"
diskSpoolBufferSizeMB="50"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="FIFO"
/>
</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还可以支持分布式缓存。
转载：http://voyageivi.iteye.com/blog/1484715 感谢分享。
SQLCacheMySQLJVMXML .
关于缓存的话题，在坛子里已经有很多讨论，简单的来说，如果一个应用中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 {
2.
3. public static Random rand = new Random();
4. public static String atoz = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
5.
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. }
14.
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>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="ehcache.xsd">
<diskStore path="java.io.tmpdir"/>
<defaultCache
maxElementsInMemory="10000"
maxElementsOnDisk="0"
eternal="true"
overflowToDisk="true"
diskPersistent="false"
timeToIdleSeconds="0"
timeToLiveSeconds="0"
diskSpoolBufferSizeMB="50"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LFU"
/>
<cache name="demoCache"
maxElementsInMemory="100"
maxElementsOnDisk="0"
eternal="false"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="119"
timeToLiveSeconds="119"
diskSpoolBufferSizeMB="50"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="FIFO"
/>
</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还可以支持分布式缓存。
分享到：
发表评论
相关推荐
以下是一个简单的示例，展示了如何在Java代码中使用Ehcache： ```java import net.sf.ehcache.CacheManager; import net.sf.ehcache.Element; public class JDBCEhcache { public static void main(String[] ...
本文将深入探讨Ehcache的简单监控，帮助开发者更好地理解其工作原理和性能状态。 首先，了解Ehcache的核心概念是至关重要的。Ehcache分为三个主要部分：内存缓存、磁盘存储和缓存复制。内存缓存用于存储最近使用的...
2. **简单**：其简洁的API和丰富的文档使ehcache易于集成和使用，即使是对缓存技术不熟悉的开发者也能快速上手。 3. **多种缓存策略**：ehcache支持LRU（Least Recently Used）、LFU（Least Frequently Used）和FIFO...
### Spring与ehcache结合使用详解 #### 一、前言 在现代软件开发中，缓存技术被广泛应用于提高应用程序的性能。其中，Spring框架因其灵活性和强大的功能，在Java领域得到了广泛应用；而ehcache作为一款高性能、...
在Java领域，缓存是优化系统性能的重要手段之一，而ehCache因其简单易用和强大的功能，成为了许多开发者的首选。 在ehCache的使用中，我们通常会遇到以下关键知识点： 1. **配置**：ehCache的配置文件通常是`...
### EHCache的使用详解 #### 一、EHCache概述与特点 EHCache 是一款非常流行的开源缓存组件，由 SourceForge 提供支持。作为一个纯 Java 实现的高性能缓存库，EHCache 在处理高并发场景下表现优异。其主要特点包括...
在这个“springmvc+ehcache简单例子”中，我们将探讨如何将两者结合使用，以实现高效的数据缓存。 首先，让我们了解一下Spring MVC。Spring MVC提供了一个分层架构，允许开发者将业务逻辑、数据访问和用户界面分离...
Spring 3.2引入了对Ehcache的全面支持，通过注解使得集成变得简单且直观。 首先，我们需要添加Ehcache和Spring的相关依赖到项目中。确保你的`pom.xml`或`build.gradle`文件包含了以下依赖： ```xml <!-- Spring ...
Ehcache的设计理念是“快速而简单”，它提供了多种缓存策略和持久化选项，使得开发者能够在不同的应用场景下灵活选择最合适的缓存机制。 #### Ehcache的优点： 1. **高性能与低延迟**：Ehcache采用高效的内存管理...
**Ehcache 集群使用详解** Ehcache 是一款高效、易用且功能丰富的内存缓存系统，常用于提升 Java 应用程序的性能和响应速度。它支持本地缓存、分布式缓存以及集群配置，使得多台服务器之间可以共享缓存数据，从而...
在分布式环境中，Ehcache通过使用JGROUP来实现分布式缓存。JGROUP是一个用于构建可靠集群通信的库，可以提供组成员资格、故障检测、传输协议等多种功能，使得Ehcache能够在多个节点之间共享和同步缓存数据。Ehcache...
9. **API友好**：Ehcache提供了简单易用的API，使得开发者能够轻松地进行缓存操作。 **Ehcache的使用步骤：** 1. **添加依赖**：将提供的Ehcache jar包引入到项目类路径中，如果是Maven或Gradle项目，需要在配置...
在`Ehcache_Hello`这个案例中，开发者可能会创建一个简单的缓存区，并通过API添加、获取和移除缓存项。以下是一个基础的示例代码： ```java CacheManager cacheManager = CacheManager.create(); Cache cache = ...
Ehcache提供了一个简单易用的API，允许开发者轻松地在应用中集成缓存功能，从而减少对数据库的依赖，提高系统性能。 二、缓存原理与优势 缓存的基本原理是将常用但计算或获取成本较高的数据存储在内存中，以便快速...
总的来说，Spring与Ehcache的结合使用，使得开发人员可以方便快捷地在应用中实现高效的缓存管理。通过合理的配置和使用，可以大大提高系统的响应速度，降低数据库的负载，同时还能提供良好的可扩展性和维护性。
为了在Spring中使用ehCache，我们需要添加相应的依赖，并配置Spring AOP以拦截需要缓存的方法。在Spring的配置文件中，我们可以使用`<aop:config>`和`<cache:annotation-driven>`标签来启用AOP和缓存注解支持。然后...
下面是一个简单的Ehcache配置示例： ```java CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder() .withCache("myCache", CacheConfigurationBuilder.newCacheConfigurationBuilder( ...
Ehcache不仅可以作为简单的内存缓存，还可以与其他持久化存储层（如数据库或分布式缓存）配合使用，实现更复杂的缓存策略。 Ehcache的核心概念主要包括以下几个部分： 1. **Cache**：缓存是Ehcache的基本单位，它...
它提供了一个简单易用的API，可以在Java应用程序中快速集成和使用。Ehcache的主要特点包括： 1. 高性能：Ehcache使用内存作为主要存储，访问速度快。 2. 可配置性：可以设置缓存策略，如大小限制、过期时间等。 3. ...