监控Redis操作

目的：监控Redis操作的执行时间、执行命令、执行参数和执行结果

监控操作时间基本逻辑

//开始统计
 //do something
//结束统计

RedisTemplate核心执行方法

public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline){
        //逻辑代码
}

所有的方法调用最终都会执行到这个方法上

而这个方法会获取到与Redis的连接对象，将这个对象传到回调函数中，在回调函数中调用Redis。

所以可以在这个方法的执行前后增加埋点操作，统计redis执行时间

如继承RedisTemplate类，重写execute方法，就可以在redis操作执行前后统计执行时间

 @Override
public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline){
        //开始统计
        super.execute(action,exposeConnection,pipeline);
        //结束统计
        //统计结果
}

但是excute方法的参数只有一个回调函数和两个判断条件，具体在回调函数调用的是redis的哪个操作，是set还是delete等都无法知道，无法针对性的统计每个具体方法的执行时间，无法获取到相关的执行参数，比如具体执行了哪个方法、执行的参数是哪些等。

所以阅读execute方法的执行逻辑，发现RedisTemplate在执行回调函数的前后，给子类留了功能扩展的方法，很明显是为了能够在操作执行前后能够执行相关的扩展功能的操作，关键代码如下

public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) {
        //从工厂中获取连接    

        this.preProcessConnection(conn, existingConnection);   //执行回调函数方法前
        Object result = action.doInRedis(connToExpose); //执行回调函数方法
        this.postProcessResult(result, connToUse, existingConnection); //执行回调函数方法后

        //释放连接        
}

protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
        return connection;
}

protected <T> T postProcessResult(T result, RedisConnection conn, boolean existingConnection) {
        return result;
}

可以看到preProcessConnection和postProcessResult这两个方法，在RedisTemplate中都是留空的，并且方法类型都是protected，而且执行的顺序分别是在action.doInRedis(）这个回调函数前后，所以很明显是为了留给子类继承，来进行功能扩展。所以，我们可以继承这两个方法，在这两个方法中对Redis执行时间进行埋点统计。

protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
        //开始统计
        return connection;
}

protected <T> T postProcessResult(T result, RedisConnection conn, boolean existingConnection) {
        //结束统计
        //记录执行结果
        return result;
}

但是这种方法同样会出现上一种方法的问题，无法获取到执行的具体方法、参数。因此，继续单步至回调函数中，查看回调函数的执行过程能否有机会进行埋点。对常用的redisTemplate.opsForValue().get()方法进行跟踪

public ValueOperations<K, V> opsForValue() {
    if(this.valueOps == null) {
        this.valueOps = new DefaultValueOperations(this);
    }
    return this.valueOps;
}

public V get(final Object key) {
    return this.execute(new ValueDeserializingRedisCallback(this, key) {
         protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
             return connection.get(rawKey);
         }
     }, true);
}

abstract class ValueDeserializingRedisCallback implements RedisCallback<V> {
    private Object key;
    public ValueDeserializingRedisCallback(Object key) {
        this.key = key;
    }
    public final V doInRedis(RedisConnection connection) {
        byte[] result = this.inRedis(AbstractOperations.this.rawKey(this.key), connection);
        return AbstractOperations.this.deserializeValue(result);
    }

    protected abstract byte[] inRedis(byte[] var1, RedisConnection var2);
}

可以看到，这个方法最终的确是调用了redisTemplate的exeute方法，并且是在回调函数中调用RedisConnection的get方法来获取redis的数据。所以我们需要对connection.set(rawKey, rawValue)这个方法进行拦截，就可以知道执行的参数、执行的结果，更进一步的思考，如果知道调用的是RedisConnection哪个方法，就可以知道在redis中，执行的是那一个redis命令。

//开始统计
//获取参数
return connection.get(rawKey); //获取命令
//结束统计
//获取结果

查看RedisConnection的代码，发现它是一个接口，继承RedisCommands，而RedisCommands继承了各种与Redis相关的命令接口。因此，知道知道在调用RedisConnection的时候，调用的是哪一个接口，就可以知道执行的是redis的哪一个命令。并且，由于我们不可能修改RediTemplate的源码，来在每一个操作的地方进行埋点，所以我们就可以从RedisConnection这个对象进行处理，在RedisConnection的方法执行前后，进行拦截，于是可以考虑用动态代理的方式，拦截RedisConnection对象的方法，在执行方法的前后进行埋点统计工作。于是我们可以继承RedisTemplate的preProcessConnection函数，对RedisConnection进行动态代理并返回代理后的RedisConnection对象，这样实际执行的时候，doInRedis这个回调函数中执行的RedisConnection就是我们动态代理后的对象。

@Override
protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
    //对Connection对象进行动态代理
    Class[] interfacesForClass = ClassUtils.getAllInterfacesForClass(connection.getClass(), this.getClass().getClassLoader());
        connection = (RedisConnection)         
    Proxy.newProxyInstance(connection.getClass().getClassLoader(),interfacesForClass,new MyRedisConnection(connection,this)) ;
    return super.preProcessConnection(connection, existingConnection);
}

private class MyRedisConnection implements InvocationHandler{
        private final RedisConnection target ;
        protected CatRedisConnection(RedisConnection target){
            this.target = target ;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //开始统计
            result = method.invoke(this.target,args) ;
            //结束统计
            //获取redis命令、参数、结果
            return result;
        }
    }

这样就实现了对Redis操作的埋点，能够统计每一个Redis操作的执行时间、执行命令、执行参数和执行结果。