动态代理+读写锁实现线程安全的HashMap缓存工具类

private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public void readLock() {
    try {
        readWriteLock.readLock().lock();
    } catch (Exception e) {
        throw new CacheRuntimeException(e);
    }
}

public void releaseRead(){
    readWriteLock.readLock().unlock();
}

public void writeLock() {
    try {
        readWriteLock.writeLock().lock();
    } catch (Exception e) {
        throw new CacheRuntimeException(e);
    }
}

public void releaseWrite(){
    readWriteLock.writeLock().unlock();
}

private HashBiMap<Integer,String> idAndNameBiMap;

public void init() {
    idAndNameBiMap= HashBiMap.create();
    System.out.println("idAndNameBiMap init");
}

public Integer getIdByName(String name){
    System.out.println("getIdByName");
    return idAndNameBiMap.inverse().get(name);
}

public String getNameById(Integer id){
    System.out.println("getNameById");
    return idAndNameBiMap.get(id);
}

public void putIdAndName(Integer id,String name){
    System.out.println("putIdAndName");
    idAndNameBiMap.put(id, name);
}

public synchronized AbstractCacheImpl getTarget() {
    if (targetCrated) {
        return target;
    }
    if (ClassUtils.isAssignable(this.cacheImpl, AbstractCacheImpl.class)) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.cacheImpl);
        enhancer.setCallback(this);
        target = (AbstractCacheImpl) enhancer.create();
        target.setCallbackId(getProxyName());
        if (MapUtil.isNotEmpty(cacheProperties)) {
            BeanUtil.fillBeanWithMap(cacheProperties, target, false);
        }
    } else {
        throw new CacheRuntimeException(
                "cacheImpl isn't a subclass of AbstractCacheImpl" + this);
    }
    initCache();
    targetCrated = true;
    return target;
}

@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    try {
        AbstractCacheImpl cache = (AbstractCacheImpl) o;
        Object retFromSuper = null;
        if (ignoreMethods.contains(method.getName())) {
            retFromSuper = methodProxy.invokeSuper(cache, objects);
        } else if (writeMethod.contains(method.getName())) {
            System.out.println("writeLock:"+method.getName());
            cache.writeLock();
            try {
                retFromSuper = methodProxy.invokeSuper(cache, objects);
            } finally {
                cache.releaseWrite();
                System.out.println("releaseWrite");
            }
        } else if (readMethod.contains(method.getName())) {
            System.out.println("readLock:"+method.getName());
            cache.readLock();
            try {
                retFromSuper = methodProxy.invokeSuper(cache, objects);
            } finally {
                cache.releaseRead();
                System.out.println("releaseRead");
            }
        } else {
            retFromSuper = methodProxy.invokeSuper(cache, objects);
        }
        return retFromSuper;
    } catch (Exception e) {
        throw new RuntimeException(e).fillInStackTrace();
    }
}

@Configuration
public class UserCacheConfigration {

@Bean("userCacheBean")
public CacheProxy userCacheBean() {
    return CacheProxy.builder()
            .proxyName("userCache")
            // 缓存子类的初始化方法
            .initMethod("init")
            // 缓存子类
            .cacheImpl(UserCache.class)
            //  需要上读锁的方法
            .readMethod(Sets.newHashSet("getNameById"))
            // 需要上写锁的方法
            .writeMethod(Sets.newHashSet("putIdAndName"))
            .build();
}
}

@Test
public void testUserCache(){
    UserCache target = (UserCache) cacheProxy.getTarget();
    target.putIdAndName(1,"张三");
    target.putIdAndName(2,"李四");
    System.out.println(target.getIdByName("张三"));
    System.out.println(target.getNameById(2));
}