RMICache组件设计(remote method cache)

    ​    ​一个复杂的系统，可能外部一个web请求，调用到服务端之后，会变成多个请求，可能是再次请求外部，也可能是请求外部的DB，这时候就面临一个问题，就是一个请求，如何不被重复发送，例如根据userId在数据库查询用户信息，这个操作，可能会由于新人改代码，明明线程内已经请求过一次了，还会再继续请求，这个时候就多了一次网络开销。

    ​    ​这种问题如何避免呢？也可能有答案，就是通过review代码的形式，之前已经获取的用户信息中，放在一个变量中，把这个变量不断的传递下去，先从这个变量中获取数据，如果变量中没有，则从远端（例如数据库端）获取这个数据，但是这样有个问题，就是这个变量会冗余的作为方法体的参数，看起来有点不爽。

    ​    ​所以，基于此，我觉得可以尝试用ThreadLocal来缓存一个线程中以及调用过的方法的返回结果。这样的话，非常复杂的系统，再也不用反复review代码去看有哪些调用是被重复搞的，也不用再通过上下文去传递变量了。

    ​    ​设计图如下：

    ​    ​

上代码（目前还是一个初级版本  https://github.com/iamzhongyong/RMICache ）：

package  rmicache;

import  java.util.HashMap;
import  java.util.Map;

/**
 * 缓存信息的持有
 *
 */
public  class  RMICacheHolder {

    private  RMICacheHolder() {}

    private  static  RMICacheHolder rmiCacheHolder =  new  RMICacheHolder();

    /** 缓存的实体对象, map结构，一个线程体内，可能缓存多个方法的对象 */
    private  ThreadLocal<Map<String /*方法的签名信息*/,Object/*线程缓存的对象*/>> cacheEntry = new ThreadLocal<Map<String,Object>>(){
        @Override
        protected Map<String, Object> initialValue() {
            return new HashMap<String,Object>();
        }
    };

    /**构造单例*/
    public static RMICacheHolder newInstance(){
        return rmiCacheHolder;
    }

    /**根据方法签名，获取缓存对象，如果没有，则通过callback的形式来放入到缓存中*/
    public Object getEntry(String methedSign,RMICacheCallback callback){
        Map<String,Object> cacheObject = RMICacheHolder.newInstance().cacheEntry.get();
        Object cacheValue = cacheObject.get(methedSign);
        if(null == cacheValue){
            cacheValue = callback.RMIGet();
            cacheObject.put(methedSign, cacheValue);
        }
        return cacheValue;
    }

    /**根据方法的签名，获取方法的缓存对象*/
    public Object getEntry(String methodSign){
        Map<String,Object> cacheObject = RMICacheHolder.newInstance().cacheEntry.get();
        return cacheObject.get(methodSign);
    }

    /**缓存之中，放入数据*/
    public void putEntry(String methodSign,Object obj){
        Map<String,Object> cacheObject = RMICacheHolder.newInstance().cacheEntry.get();
        cacheObject.put(methodSign, obj);
    }

    /**清理线程缓存中的数据，由于现在大多数都是基于线程池的使用，所以这不清理操作必须存在*/
    public  void  clearThreadLocal(){
        RMICacheHolder.newInstance().cacheEntry.set( new  HashMap<String,Object>());
    }

}

 

下面一个是一个callback的接口定义：

package  rmicache;

public  interface  RMICacheCallback {
    /**
     * 远程获取这个结果
     * @return
     */
    public  Object RMIGet();

}

 

结合一个例子使用：

package  test;

import  rmicache.RMICacheCallback;
import  rmicache.RMICacheHolder;

/**
 * 辅助进行测试的方法
 *
 */
public  class  BizService {

    /**
     * 假设这个数据的获取非常消耗时间，在一个线程处理过程中，由于逻辑复杂，不能保证这个方法被人调用多次
     * 如果系统对于高并发和响应时间有很高的要求，那么多一个耗时的调用，是非常致命的。
     */
    public  UserDO getUserDOByID(Long userId){
        try  {
            Thread.sleep( 1000 );
        }  catch  (InterruptedException e) {
        }
        UserDO user =  new  UserDO();

        user.setName( "iamzhongyong_" +Thread.currentThread().getName());
        user.setAge( 18 );
        return  user;
    }
    /**
     * 远程的包装类
     */
    public  UserDO getUserDOByIdWraper( final  Long userId){
        return  (UserDO) RMICacheHolder.newInstance().getEntry( "getUserDOByID" ,  new  RMICacheCallback() {
            public  Object RMIGet() {
                return  getUserDOByID(userId);
            }
        });
    }

}

 

测试类：

直接调用远程，方法调用三次，耗时： 3004
三次包装类调用，方法调用三次,有缓存，耗时： 1010
线程数据清理，调用一次包装类，耗时： 1000
异步方法调用三次,一次远程，一次缓存，耗时： 2001
异步方法调用三次，全部是远程，耗时： 3001
线程缓存清理后,异步方法调用三次,一次远程，一次缓存，耗时： 2000

​