LRUMAP的使用(代替redis)

用到了两个文件

package com.xinrong.adaptor.facade;

import java.math.BigDecimal;
import java.util.Map;

@SuppressWarnings("rawtypes")
public interface CacheFacade {
	public final static int PUT_IF_NOT_CARE = 0;
	public final static int PUT_IF_EQUAL = 1;
	public final static int PUT_IF_GREATER = 2;
	public final static int PUT_IF_EQUAL_OR_GREATER = 3;
	public final static int PUT_IF_LESS = 4;
	public final static int PUT_IF_EQUAL_OR_LESS = 5;

	public Object get(Object key);

	public void put(Object key, Object value);

	public boolean putIfNotExist(Object key, Object value);

	public void remove(Object key);

	public Object getExt(String mapName, Object key);

	public void putExt(String mapName, Object key, Object value, int maxSize);

	public boolean putIfNotExistExt(String mapName, Object key, Object value,
			int maxSize);

	public void removeExt(String mapName, Object key);

	public void putAllExt(String mapName, Map map, int maxSize);

	public BigDecimal add(Object key, BigDecimal value);

	public BigDecimal addExt(String mapName, Object key, BigDecimal value,
			int maxSize);

	public boolean putIf(Object key, Comparable<Object> value, int ifWhat);

	public boolean putIfExt(String mapName, Object key,
			Comparable<Object> value, int ifWhat, int maxSize);
	
	public boolean putIfNotExistBySecond(Object key, Object value,Long second);
}

package com.xinrong.adaptor.facade;

import java.math.BigDecimal;
import java.util.Collections;
import java.util.Map;

import org.apache.commons.collections.map.LRUMap;

public class CacheLocal implements CacheFacade {
	@SuppressWarnings("unchecked")
	private static Map<Object, Object> lruMap = new LRUMap(100000);
	@SuppressWarnings("unchecked")
	private final static Map<String, Map<Object, Object>> mapMap = Collections
			.synchronizedMap(new LRUMap(10000));

	@Override
	public Object get(Object key) {
		synchronized (lruMap) {
			return lruMap.get(key);
		}
	}

	@Override
	public void put(Object key, Object value) {
		synchronized (lruMap) {
			lruMap.put(key, value);
		}
	}

	@Override
	public boolean putIfNotExist(Object key, Object value) {
		synchronized (lruMap) {
			if (lruMap.containsKey(key)) {
				return false;
			} else {
				lruMap.put(key, value);
				return true;
			}
		}
	}

	@Override
	public void remove(Object key) {
		synchronized (lruMap) {
			lruMap.remove(key);
		}

	}

	@Override
	public Object getExt(String mapName, Object key) {
		Map<Object, Object> targetMap;
		if (mapName != null) {
			targetMap = mapMap.get(mapName);
			if (targetMap == null)
				return null;
		} else
			targetMap = lruMap;

		synchronized (targetMap) {
			return targetMap.get(key);
		}
	}

	@Override
	public void putExt(String mapName, Object key, Object value, int maxSize) {
		Map<Object, Object> targetMap;
		if (mapName != null) {
			targetMap = creatSubMapIfNotExist(mapName, maxSize);
		} else
			targetMap = lruMap;
		synchronized (targetMap) {
			targetMap.put(key, value);
		}
	}

	@Override
	public boolean putIfNotExistExt(String mapName, Object key, Object value,
			int maxSize) {
		Map<Object, Object> targetMap;
		if (mapName != null) {
			targetMap = creatSubMapIfNotExist(mapName, maxSize);
		} else
			targetMap = lruMap;
		synchronized (targetMap) {
			if (targetMap.containsKey(key)) {
				return false;
			} else {
				targetMap.put(key, value);
				return true;
			}
		}
	}

	@Override
	public void removeExt(String mapName, Object key) {
		Map<Object, Object> targetMap = mapMap.get(mapName);
		if (targetMap == null)
			return;
		synchronized (targetMap) {
			targetMap.remove(key);
		}
	}

	@Override
	public BigDecimal add(Object key, BigDecimal value) {
		return addExt(null, key, value, 0);
	}

	@Override
	public BigDecimal addExt(String mapName, Object key, BigDecimal value,
			int maxSize) {
		Map<Object, Object> targetMap;
		if (mapName != null) {
			targetMap = creatSubMapIfNotExist(mapName, maxSize);
		} else
			targetMap = lruMap;

		synchronized (targetMap) {
			BigDecimal ret = (BigDecimal) targetMap.get(key);
			if (ret != null) {
				value = value.add(ret);
			}
			targetMap.put(key, value);
		}
		return value;
	}

	@Override
	public boolean putIf(Object key, Comparable<Object> value, int ifWhat) {
		return putIfExt(null, key, value, ifWhat, 0);
	}

	@Override
	public boolean putIfExt(String mapName, Object key,
			Comparable<Object> value, int ifWhat, int maxSize) {
		Map<Object, Object> targetMap;
		if (mapName != null) {
			targetMap = creatSubMapIfNotExist(mapName, maxSize);
		} else
			targetMap = lruMap;
		synchronized (targetMap) {
			Object ret = targetMap.get(key);
			if (ret != null) {
				int cmp = value.compareTo(ret);
				switch (ifWhat) {
				case CacheFacade.PUT_IF_EQUAL:
					if (cmp != 0)
						return false;
					break;
				case CacheFacade.PUT_IF_GREATER:
					if (cmp <= 0)
						return false;
					break;
				case CacheFacade.PUT_IF_EQUAL_OR_GREATER:
					if (cmp < 0)
						return false;
					break;
				case CacheFacade.PUT_IF_LESS:
					if (cmp >= 0)
						return false;
					break;
				case CacheFacade.PUT_IF_EQUAL_OR_LESS:
					if (cmp > 0)
						return false;
					break;
				}
			}
			targetMap.put(key, value);
		}
		return true;
	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public void putAllExt(String mapName, Map map, int maxSize) {
		Map<Object, Object> targetMap = creatSubMapIfNotExist(mapName, maxSize);
		synchronized (targetMap) {
			targetMap.putAll(map);
		}
	}

	@SuppressWarnings("unchecked")
	private Map<Object, Object> creatSubMapIfNotExist(String mapName,
			int maxSize) {
		Map<Object, Object> targetMap = mapMap.get(mapName);
		if (targetMap == null)
			synchronized (mapMap) {
				targetMap = mapMap.get(mapName);
				if (targetMap == null) {
					targetMap = new LRUMap(maxSize);
					mapMap.put(mapName, targetMap);
				}
			}
		return targetMap;
	}
	
	@Override
	public boolean putIfNotExistBySecond(Object key, Object value,Long second) {
		synchronized (lruMap) {
			if (lruMap.containsKey(key)) {
				if(Long.valueOf(value.toString()) - Long.valueOf(lruMap.get(key).toString()) <  second){
					return false;
				}
				
			} 
				lruMap.put(key, value);
				return true;
		}
	}

}

使用

    @Resource
    private CacheLocal cacheLocal;
    
     /**
     * Validate captcha.
     *
     * @param uuid the uuid
     * @param code the code
     */
    public void validateCaptcha(String uuid, String code) {
        if (StringUtils.isEmpty(uuid) || StringUtils.isEmpty(code)) {
            throw new EsException("请输入验证码");
        }

        String verifyKey = Constants.CAPTCHA_CODE_KEY + uuid;
        String captcha = (String) cacheLocal.get(verifyKey);
        if (StringUtils.isEmpty(captcha)) {
            throw new EsException("验证码错误");
        } else {
            if (!captcha.equals(code)) {
                throw new EsException("验证码错误");
            }
        }
        cacheLocal.remove(verifyKey);
    }


	/**
     * 获取验证码
     *
     * @return code
     */
    public AjaxResult getCode() {
        Random random = new Random();
        int type = random.nextInt(2);
        AjaxResult ajax = AjaxResult.success();

        // 保存验证码信息
        String uuid = IdUtils.simpleUUID();
        String verifyKey = Constants.CAPTCHA_CODE_KEY + uuid;

        String capStr = null, code = null;
        BufferedImage image = null;

        // 生成验证码
        if (type == 1) {
            String capText = captchaProducerMath.createText();
            capStr = capText.substring(0, capText.lastIndexOf("@"));
            code = capText.substring(capText.lastIndexOf("@") + 1);
            image = captchaProducerMath.createImage(capStr);
        } else {
            capStr = code = captchaProducer.createText();
            image = captchaProducer.createImage(capStr);
        }

        log.info("uuid=========>" + uuid + " code=========>" + code);
        cacheLocal.put(verifyKey,code);
        // 转换流信息写出
        FastByteArrayOutputStream os = new FastByteArrayOutputStream();
        try {
            ImageIO.write(image, "jpg", os);
        } catch (IOException e) {
            return AjaxResult.error(e.getMessage());
        }

        ajax.put("uuid", uuid);
        ajax.put("img", Base64.encode(os.toByteArray()));
        return ajax;
    }