代码比较
复制代码
package cn.how2j.test;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;
import java.lang.annotation.Documented;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
import org.junit.Test;
import cn.hutool.cache.Cache;
import cn.hutool.cache.CacheUtil;
import cn.hutool.cache.file.LFUFileCache;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
public class TestCache {
@Test
@Comment("缓存工具")
public void test0(){
p4("hutool的缓存，在处理缓存满了或者到期的时候，有如下几种策略：");
p3("FIFOCache","first in first out , 先入先出，一旦缓存满了，先放进去的，先被清空");
p3("LFUCache","least frequently used, 一旦缓存满了，用得最少的，先被清空 (命中低的数据被清空)");
p3("LRUCache","least recently used, 一旦缓存满了，最久没用的，先被清空 (旧数据被清空)");
p3("TimedCache","一旦时间到了，被清空 (考虑时效性)");
p3("WeakCache","一旦内存满了，要垃圾回收了，优先被清空 (内存占用重要性)");
p3("FileCach","把文件对象作为缓存，减少IO访问频率");
//LFUCache
//LRUCache least recently used
//TimedCache
//WeakCache
//FileCach
}
@Test
@Comment("FIFO 示例")
public void test1(){
p4("初始化缓存大小是 2");
p4("接着向里面挨个放入1，2，3，导致缓存变满");
Cache cache= CacheUtil.newFIFOCache(2);
cache.put("key1",1 );
cache.put("key2",2 );
cache.put("key3",3 );
p3("遍历缓存中的数据",CollectionUtil.join(cache, ","));
p4("如预料一般，最早放入的最先被清空");
}
@Test
@Comment("LFUCache 示例")
public void test2(){
p4("初始化缓存大小是 2");
p4("接着向里面挨个放入1，2，3，导致缓存变满");
Cache cache= CacheUtil.newLFUCache(2);
cache.put("key1",1 );
cache.put("key2",2 );
p4("中途故意使用一次 key1");
cache.get("key1");
cache.put("key3",3 );
p3("遍历缓存中的数据",CollectionUtil.join(cache, ","));
p4("如预料一般，使用频率最低的 2 的被清空");
}
@Test
@Comment("LFUCache 示例")
public void test3(){
p4("初始化缓存大小是 2");
p4("接着向里面挨个放入1，2，3，导致缓存变满");
Cache cache= CacheUtil.newLRUCache(2);
cache.put("key1",1 );
cache.put("key2",2 );
p4("中途故意使用一次 key1");
cache.get("key1");
cache.put("key3",3 );
p3("遍历缓存中的数据",CollectionUtil.join(cache, ","));
p4("如预料一般，最久没有被使用的 2 的被清空");
}
@Test
@Comment("TimedCache 示例")
public void test4(){
p4("初始化缓存大小是 2");
p4("接着向里面挨个放入1，2， 分别放设置存放时间为1秒和5秒");
Cache cache= CacheUtil.newTimedCache(Integer.MAX_VALUE);
cache.put("key1",1, 1000 );
cache.put("key2",2,5000 );
p4("休息3秒");
ThreadUtil.sleep(3000);
p3("遍历缓存中的数据",CollectionUtil.join(cache, ","));
p4("如预料一般， 经过3秒后，1被清空了，2还在");
}
@Test
@Comment("WeakCache 示例")
public void test5(){
p4("WeekCache表示当垃圾回收发生的时候，不会阻挡回收器把它回收走。");
p4("请注意看描述：\"不会阻挡\", 就是说，垃圾回收真正要对它下手了，是可以下手的。");
p4("但是垃圾回收发生的时候，不一定会回收所有垃圾和 week引用。");
p4("正因为如此，不易观察到现象，而且不稳定，所以就不做演示了，免得误导");
}
@Test
@Comment("FileCache 示例")
public void test6(){
p4("FileCache 也分 LFU, LRU 等，只是调用方式有所区别，并没有被放到 CacheUtil里，找了好一会儿才找到。。。，");
//参数1：容量，能容纳的byte数
//参数2：最大文件大小，byte数，决定能缓存至少多少文件，大于这个值不被缓存直接读取
//参数3：超时。毫秒
long capacity = 1024*1024*500; //最多500m, 太大了，内存吃不消，缓存就没法实施了
long maxFileSize = 1024*1024*10; //最大10m, 文件小于这个就缓存，太大了也不缓存
long timeout = 1000*60*60*24; //缓存一天，超过这个就自动从缓存里移除了
LFUFileCache cache = new LFUFileCache(1024*1024*500, 500, 2000);
//使用办法：
//byte[] bytes = cache.getFileBytes("e:/project/hutool/img/logo.png");
}
private String preComment = null;
private void c(String msg) {
System.out.printf("\t备注：%s%n", msg);
}
private void p1(String type1, Object value1, String type2, Object value2) {
p(type1, value1, type2, value2, "format1");
}
private void p2(String type1, Object value1, String type2, Object value2) {
p(type1, value1, type2, value2, "format2");
}
private void p3(String type1, Object value1) {
p(type1, value1, "", "", "format3");
}
private void p4(Object value) {
p(null, value, "", "", "format4");
}
private void p(String type1, Object value1, String type2, Object value2, String format) {
try {
throw new Exception();
} catch (Exception e) {
String methodName = getTestMethodName(e.getStackTrace());
Method m = ReflectUtil.getMethod(this.getClass(), methodName);
Comment annotation = m.getAnnotation(Comment.class);
if (null != annotation) {
String comment = annotation.value();
if (!comment.equals(preComment)) {
System.out.printf("%n%s 例子： %n%n", comment);
preComment = comment;
}
}
}
int padLength = 12;
type1 = StrUtil.padEnd(type1, padLength, Convert.toSBC(" ").charAt(0));
type2 = StrUtil.padEnd(type2, padLength, Convert.toSBC(" ").charAt(0));
if ("format1".equals(format)) {
System.out.printf("\t%s的:\t\"%s\" %n\t被转换为----->%n\t%s的 :\t\"%s\" %n%n", type1, value1, type2, value2);
}
if ("format2".equals(format)) {
System.out.printf("\t基于 %s:\t\"%s\" %n\t获取 %s:\t\"%s\"%n%n", type1, value1, type2, value2);
}
if ("format3".equals(format)) {
System.out.printf("\t%s:\t\"%s\" %n\t%n", type1, value1);
}
if ("format4".equals(format)) {
System.out.printf("\t%s%n%n", value1);
}
}
private String getTestMethodName(StackTraceElement[] stackTrace) {
for (StackTraceElement se : stackTrace) {
String methodName = se.getMethodName();
if (methodName.startsWith("test"))
return methodName;
}
return null;
}
@Target({ METHOD, TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Comment {
String value();
}
}
package cn.how2j.test;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;
import java.lang.annotation.Documented;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
import org.junit.Test;
import cn.hutool.cache.Cache;
import cn.hutool.cache.CacheUtil;
import cn.hutool.cache.file.LFUFileCache;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
public class TestCache {
@Test
@Comment("缓存工具")
public void test0(){
p4("hutool的缓存，在处理缓存满了或者到期的时候，有如下几种策略：");
p3("FIFOCache","first in first out , 先入先出，一旦缓存满了，先放进去的，先被清空");
p3("LFUCache","least frequently used, 一旦缓存满了，用得最少的，先被清空 (命中低的数据被清空)");
p3("LRUCache","least recently used, 一旦缓存满了，最久没用的，先被清空 (旧数据被清空)");
p3("TimedCache","一旦时间到了，被清空 (考虑时效性)");
p3("WeakCache","一旦内存满了，要垃圾回收了，优先被清空 (内存占用重要性)");
p3("FileCach","把文件对象作为缓存，减少IO访问频率");
//LFUCache
//LRUCache least recently used
//TimedCache
//WeakCache
//FileCach
}
@Test
@Comment("FIFO 示例")
public void test1(){
p4("初始化缓存大小是 2");
p4("接着向里面挨个放入1，2，3，导致缓存变满");
Cache cache= CacheUtil.newFIFOCache(2);
cache.put("key1",1 );
cache.put("key2",2 );
cache.put("key3",3 );
p3("遍历缓存中的数据",CollectionUtil.join(cache, ","));
p4("如预料一般，最早放入的最先被清空");
}
@Test
@Comment("LFUCache 示例")
public void test2(){
p4("初始化缓存大小是 2");
p4("接着向里面挨个放入1，2，3，导致缓存变满");
Cache cache= CacheUtil.newLFUCache(2);
cache.put("key1",1 );
cache.put("key2",2 );
p4("中途故意使用一次 key1");
cache.get("key1");
cache.put("key3",3 );
p3("遍历缓存中的数据",CollectionUtil.join(cache, ","));
p4("如预料一般，使用频率最低的 2 的被清空");
}
@Test
@Comment("LFUCache 示例")
public void test3(){
p4("初始化缓存大小是 2");
p4("接着向里面挨个放入1，2，3，导致缓存变满");
Cache cache= CacheUtil.newLRUCache(2);
cache.put("key1",1 );
cache.put("key2",2 );
p4("中途故意使用一次 key1");
cache.get("key1");
cache.put("key3",3 );
p3("遍历缓存中的数据",CollectionUtil.join(cache, ","));
p4("如预料一般，最久没有被使用的 2 的被清空");
}
@Test
@Comment("TimedCache 示例")
public void test4(){
p4("初始化缓存大小是 2");
p4("接着向里面挨个放入1，2， 分别放设置存放时间为1秒和5秒");
Cache cache= CacheUtil.newTimedCache(Integer.MAX_VALUE);
cache.put("key1",1, 1000 );
cache.put("key2",2,5000 );
p4("休息3秒");
ThreadUtil.sleep(3000);
p3("遍历缓存中的数据",CollectionUtil.join(cache, ","));
p4("如预料一般， 经过3秒后，1被清空了，2还在");
}
@Test
@Comment("WeakCache 示例")
public void test5(){
p4("WeekCache表示当垃圾回收发生的时候，不会阻挡回收器把它回收走。");
p4("请注意看描述：\"不会阻挡\", 就是说，垃圾回收真正要对它下手了，是可以下手的。");
p4("但是垃圾回收发生的时候，不一定会回收所有垃圾和 week引用。");
p4("正因为如此，不易观察到现象，而且不稳定，所以就不做演示了，免得误导");
}
@Test
@Comment("FileCache 示例")
public void test6(){
p4("FileCache 也分 LFU, LRU 等，只是调用方式有所区别，并没有被放到 CacheUtil里，找了好一会儿才找到。。。，");
//参数1：容量，能容纳的byte数
//参数2：最大文件大小，byte数，决定能缓存至少多少文件，大于这个值不被缓存直接读取
//参数3：超时。毫秒
long capacity = 1024*1024*500; //最多500m, 太大了，内存吃不消，缓存就没法实施了
long maxFileSize = 1024*1024*10; //最大10m, 文件小于这个就缓存，太大了也不缓存
long timeout = 1000*60*60*24; //缓存一天，超过这个就自动从缓存里移除了
LFUFileCache cache = new LFUFileCache(1024*1024*500, 500, 2000);
//使用办法：
//byte[] bytes = cache.getFileBytes("e:/project/hutool/img/logo.png");
}
private String preComment = null;
private void c(String msg) {
System.out.printf("\t备注：%s%n", msg);
}
private void p1(String type1, Object value1, String type2, Object value2) {
p(type1, value1, type2, value2, "format1");
}
private void p2(String type1, Object value1, String type2, Object value2) {
p(type1, value1, type2, value2, "format2");
}
private void p3(String type1, Object value1) {
p(type1, value1, "", "", "format3");
}
private void p4(Object value) {
p(null, value, "", "", "format4");
}
private void p(String type1, Object value1, String type2, Object value2, String format) {
try {
throw new Exception();
} catch (Exception e) {
String methodName = getTestMethodName(e.getStackTrace());
Method m = ReflectUtil.getMethod(this.getClass(), methodName);
Comment annotation = m.getAnnotation(Comment.class);
if (null != annotation) {
String comment = annotation.value();
if (!comment.equals(preComment)) {
System.out.printf("%n%s 例子： %n%n", comment);
preComment = comment;
}
}
}
int padLength = 12;
type1 = StrUtil.padEnd(type1, padLength, Convert.toSBC(" ").charAt(0));
type2 = StrUtil.padEnd(type2, padLength, Convert.toSBC(" ").charAt(0));
if ("format1".equals(format)) {
System.out.printf("\t%s的:\t\"%s\" %n\t被转换为----->%n\t%s的 :\t\"%s\" %n%n", type1, value1, type2, value2);
}
if ("format2".equals(format)) {
System.out.printf("\t基于 %s:\t\"%s\" %n\t获取 %s:\t\"%s\"%n%n", type1, value1, type2, value2);
}
if ("format3".equals(format)) {
System.out.printf("\t%s:\t\"%s\" %n\t%n", type1, value1);
}
if ("format4".equals(format)) {
System.out.printf("\t%s%n%n", value1);
}
}
private String getTestMethodName(StackTraceElement[] stackTrace) {
for (StackTraceElement se : stackTrace) {
String methodName = se.getMethodName();
if (methodName.startsWith("test"))
return methodName;
}
return null;
}
@Target({ METHOD, TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Comment {
String value();
}
}
433
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
