springCloud微服务系列——链路跟踪第六篇——redis缓存链路跟踪器

向右看齐 2022-05-16 22:58 286阅读 0赞

**目录**

一、简介

二、思路

给redis操作提供定义拦截器的功能

静态代理

动态代理

mybatis的interceptor实现

仿造mybatis的interceptor

类加载

三、示例代码

--------------------

# 一、简介 #

这篇文章总结redis缓存链路跟踪器的实现

# 二、思路 #

redis的客户端本身是没有提供拦截器的。此外，缓存操作一般也不是一个独立的方法，而是嵌入在某业务方法内部，因此也不可能用AOP来拦截。这里的思路是通过动态代理，提供一个代理类，由它来完成redis缓存操作的拦截。

## 给redis操作提供定义拦截器的功能 ##

我们准备通过动态代理来给redis操作提供定义拦截器的功能，类似于mybatis。

我们一步一步来，先看看需要哪些储备知识。

*  ### 静态代理 ###

![70][]

我们可以看到，有3个角色，Action为操作的接口，Operator执行真正的操作逻辑，Proxy引用了Operator的对象，它也实现了Action接口，但是它在doSomething方法中调用Operator对象的该方法，并在调用前后附加自己的逻辑。

public class Proxy implements Action {
        
        private Operator operator;
    
        public Proxy(Operator operator) {
             this.operator = operator;
        }
    
        public void doSomething() {
             preHandle();
             operator.doSomething();
             postHandle();
        }
    
        private void preHandle() {
             System.out.println("前置操作");
        }
    
        private void postHandle() {
             System.out.println("后置操作");
        }
    
    }

调用的时候如下

Proxy proxy = new Proxy(new Operator());
    proxy.doSomething();

静态代理有一个很大的缺点，就是需要新代理一个接口，就必须修改Proxy类，或者新增一个Proxy类。

比如上面的例子中，我需要新代理一个Handle接口，第一种方式，我们的uml图变为如下所示

![70 1][]

很明显Proxy类需要实现Handle接口，并且增加成员变量handler，增加方法doHandle

还有一种方式是新建一个Proxy类

![70 2][]

我们希望不用修改Proxy类的代码，也不新增一个Proxy类。这时候就需要动态代理了。

*  ### 动态代理 ###

动态代理解决了新增一个需要代理的接口，也不用修改Proxy类或者新增一个Proxy类。

![70 3][]

Proxy类通过反射自动得分析出了需要代理的接口，方法，实际实现类，并把这些对象作为p参数传递给了InvocationHandler接口的实现类的invoke方法。

示例代码如下

public class ActionProxy implements InvocationHandler {
    
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          preHandle();
          Object result = method.invoke(target, args);
          postHandle();
          return result;
       }
    
       private void preHandle() {
          System.out.println("前置操作");
       }
    
       private void postHandle() {
          System.out.println("前置操作");
       }
    
    }

Action action = 
     Proxy.newProxyInstance(
        this.getClass().getClassLoader(),
        Action,
        new Operator());
    
    action.doSomething();

这样的话，新增一个需要被代理的接口，只需要在调用的时候修改Proxy.newProxyInstance传递的参数即可，不需要修改Proxy类的代码，或者新增一个Proxy类。

*  ### mybatis的interceptor实现 ###

mybatis的interceptor的实现就是通过动态代理实现的，我们来看看它是怎么实现的吧

1、启动的时候通过解析配置文件，实例化interceptor，并保存下来

![70 4][]

其中紫色代表类，绿色代表方法，蓝色代表方法中的关键代码

XMLConfigBuilder从xml中解析出ingerceptor的类名，并通过反射将其实例化，最后保存到Configuration的interceptorChain成员变量中。

private void pluginElement(XNode parent) throws Exception {
        if (parent != null) {
          for (XNode child : parent.getChildren()) {
            String interceptor = child.getStringAttribute("interceptor");
            Properties properties = child.getChildrenAsProperties();
            Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
            interceptorInstance.setProperties(properties);
            configuration.addInterceptor(interceptorInstance);
          }
        }
      }

2、执行sql操作的时候使用动态代理，代理如下接口，Executor，ParameterHandler，ResultHandler，StatementHandler     ![70 5][]

其中紫色代表类，绿色代表方法，蓝色代表方法中的关键代码

在执行sql操作之前，会调用newExecutor，newParameterHandler，newResultSetHandler，newStatementHandler方法来得到相应的代理对象。

在这几个方法中，调用第一步保存在InterceptorChain中的自定义interceptor的plugin方法，参数target为Executor，ParameterHandle，ResultSetHandler，StatementHandler接口的实现类的对象。

我们在plugin中写的代码为Plugin.warp(target, this)，这个时候，会调用Plugin的warp方法。

在wrap方法中，getSignatureMap方法会解析Signature注解，getAllInterfaces会获得Signature注解中需要被代理的接口，最后通过动态代理返回代理对象为Plugin，

值得注意的是，Plugin是实现了InvocationHandler接口的，而且它在构造的时候保存了target，即Executor，ParameterHandle，ResultSetHandler，StatementHandler接口的实现类的对象。interceptor，作为wrap方法的局部变量传入的。

public Object pluginAll(Object target) {
        for (Interceptor interceptor : interceptors) {
          target = interceptor.plugin(target);
        }
        return target;
    }

@Override
    public Object plugin(Object target) {
    	return Plugin.wrap(target, this);
    }

public static Object wrap(Object target, Interceptor interceptor) {
 Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
 Class<?> type = target.getClass();
 Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
 if (interfaces.length > 0) {
 return Proxy.newProxyInstance(
 type.getClassLoader(),
 interfaces,
 new Plugin(target, interceptor, signatureMap));
 }
 return target;
 }

3、 获得了代理对象，也就是Plugin的实例后，执行sql操作

![70 6][]

其中紫色代表类，绿色代表方法，蓝色代表方法中的关键代码

第二步返回的代理对象为Plugin的实例，Plugin实现了InvocationHandler接口，因此在执行sql操作的时候会执行Plugin的invoke方法。由于Plugin在实例化的时候保存了interceptor的引用，因此在invoke方法中调用interceptor的intercept方法。

*  ### 仿造mybatis的interceptor ###

分析完mybatis的interceptor的实现后，我们完全可以仿造它的实现方式，实现一个针对于redis的interceptor。

1、被代理的接口

我们需要定义一个需要被代理的接口，类似于Mybatis的Executor，ParameterHandle，ResultSetHandler，StatementHandler接口

public interface RedisOperator {
    
    	boolean setBit(String key, int offset, boolean value);
    	
    	boolean getBit(String key, int offset);
    	
    	String set(String key, String data, int expiredSeconds);
    	
    	String get(String key);
    	
    	long del(String key);
    	
    }

2、实际处理操作的类

我们需要真正处理操作的类，类似于Mybatis的Executor，ParameterHandle，ResultSetHandler，StatementHandler接口的实现类

public class JedisRedisOperator implements RedisOperator {
    	
    	private JedisUtil jedisUtil;
    	
    	public JedisRedisOperator(String host, int port, String password) {
    		this.jedisUtil = new JedisUtil(host, port, password);
    	}
    	
    	public JedisRedisOperator(String host, int port, String password, JedisPoolConfig jedisPoolConfig) {
    		this.jedisUtil = new JedisUtil(host, port, password, jedisPoolConfig);
    	}
    	
    	@Override
    	public boolean setBit(String key, int offset, boolean value) {
    		return jedisUtil.setBit(key, offset, value);
    	}
    
    	@Override
    	public boolean getBit(String key, int offset) {
    		return jedisUtil.getBit(key, offset);
    	}
    
    	@Override
    	public String set(String key, String data, int expiredSeconds) {
    		return jedisUtil.set(key, data, expiredSeconds);
    	}
    
    	@Override
    	public String get(String key) {
    		return jedisUtil.get(key);
    	}
    	
    	@Override
    	public long del(String key) {
    		return jedisUtil.del(key);
    	}
    
    	public String getHostPort() {
    		return this.jedisUtil.getHost()+":"+jedisUtil.getPort();
    	}
    	
    }

public class RedisTemplateRedisOperator implements RedisOperator {
 
 	private RedisTemplate<String, String> redisTemplate;
 	
 	public RedisTemplateRedisOperator(RedisTemplate<String, String> redisTemplate) {
 		this.redisTemplate = redisTemplate;
 	}
 	
 	@Override
 	public boolean setBit(String key, int offset, boolean value) {
 		return redisTemplate.opsForValue().setBit(key, offset, value);
 	}
 
 	@Override
 	public boolean getBit(String key, int offset) {
 		return redisTemplate.opsForValue().getBit(key, offset);
 	}
 
 	@Override
 	public String set(String key, String data, int expiredSeconds) {
 		redisTemplate.opsForValue().set(key, data, expiredSeconds, TimeUnit.SECONDS);
 		return null;
 	}
 
 	@Override
 	public String get(String key) {
 		return redisTemplate.opsForValue().get(key);
 	}
 
 	@Override
 	public long del(String key) {
 		redisTemplate.delete(key);
 		return 0;
 	}
 	
 	public String getHostPort() {
 		return redisTemplate.getConnectionFactory().getConnection().getClientName();
 	}
 
 }

3、Interceptor接口，供用户自定义

public interface Interceptor {
    
    	Object intercept(Invocation invocation) throws Throwable;
    
    	Object plugin(Object target);
    	
    }

4、实现了InvocationHandler接口的代理类，该类和第5步的类一致

5、提供生成代理对象功能的类，该类和第4步的类一致

public class Plugin implements InvocationHandler {
 
 	 private final Object target;
 	 private final Interceptor interceptor;
 
 	 private Plugin(Object target, Interceptor interceptor) {
 	 this.target = target;
 	 this.interceptor = interceptor;
 	 }
 	
 	/* (non-Javadoc) 
 	 * Title: invoke 
 	 * Description: 
 	 * @param proxy
 	 * @param method
 	 * @param args
 	 * @return
 	 * @throws Throwable 
 	 * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[]) 
 	 */
 	@Override
 	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 		if(method != null)
 	 return interceptor.intercept(new Invocation(target, method, args));
 	 return method.invoke(target, args);
 	}
 	
 	/**
 	 * 
 	 * Title: wrap 
 	 * Description: 生成代理对象 
 	 * @param target 需要被代理的接口
 	 * @param interceptor 拦截器
 	 * @return
 	 */
 	public static Object wrap(Object target, Interceptor interceptor) {
 	 Class<?> type = target.getClass();
 	 Class<?>[] interfaces = getAllInterfaces(type);
 	 if (interfaces.length > 0) {
 	 return Proxy.newProxyInstance(
 	 type.getClassLoader(),
 	 interfaces,
 	 new Plugin(target, interceptor));
 	 }
 	 return target;
 	 }
 	
 	/**
 	 * 
 	 * Title: getAllInterfaces 
 	 * Description: 获得被代理对象的所有可代理接口 
 	 * @param type
 	 * @return
 	 */
 	private static Class<?>[] getAllInterfaces(Class<?> type) {
 	 Set<Class<?>> interfaces = new HashSet<Class<?>>();
 	 while (type != null) {
 	 for (Class<?> c : type.getInterfaces()) {
 	 	 // 必须实现了RedisOperator接口
 	 	 if(c.getName().equals(RedisOperator.class.getName()))
 	 		 interfaces.add(c);
 	 }
 	 type = type.getSuperclass();
 	 }
 	 return interfaces.toArray(new Class<?>[interfaces.size()]);
 	 }
 
 }

6、代理类的生成时机

Mybatis是在执行sql操作的时候，我们可以在执行redis操作的时候，或者提供一个工具类，在工具类实例化的时候直接保存代理对象。

我这里是定义了一个CacheProssor的工具类，在实例化的时候传入的是RedisOperator的代理对象。同时也提供了一个方便获得代理对象的工具类CacheConfiguration

public class CacheConfiguration {
 
 	public static Interceptor interceptor;
 
 	/**
 	 * 
 	 * Title: wrapRedisOperator 
 	 * Description: 获得RedisOperator的代理类 
 	 * @param redisOperator
 	 * @return
 	 */
 	public static RedisOperator wrapRedisOperator(RedisOperator redisOperator) {
 		if(interceptor == null)
 			return redisOperator;
 		return (RedisOperator) Plugin.wrap(redisOperator, interceptor);
 	}
 	
 }

public class JedisRedisCacheProcessor extends RedisCacheProcessor{
    
    	public JedisRedisCacheProcessor(String key, String host, int port, String password) {
    		super(key, CacheConfiguration.wrapRedisOperator(new JedisRedisOperator(host, port, password)));
    	}
    	
    	public JedisRedisCacheProcessor(String key, JedisPoolConfig jedisPoolConfig, String host, int port, String password) {
    		super(key, CacheConfiguration.wrapRedisOperator(new JedisRedisOperator(host, port, password, jedisPoolConfig)));
    	}
    	
    	public JedisRedisCacheProcessor(String key, String host, int port, String password, ExpiredStrategy expiredStrategy) {
    		super(key, CacheConfiguration.wrapRedisOperator(new JedisRedisOperator(host, port, password)), expiredStrategy);
    	}
    	
    	public JedisRedisCacheProcessor(String key, JedisPoolConfig jedisPoolConfig, String host, int port, String password, ExpiredStrategy expiredStrategy) {
    		super(key, CacheConfiguration.wrapRedisOperator(new JedisRedisOperator(host, port, password, jedisPoolConfig)), expiredStrategy);
    	}
    	
    }

7、通过配置文件实例化用户自定义的interceptor

类似于Mybatis的XMLConfigBuilder，只不过我们是用spring通过yml文件进行配置

@Bean
    @ConditionalOnMissingBean(RedisOperator.class)
    public RedisOperator redisOperator() throws ClassNotFoundException, LinkageError, InstantiationException, IllegalAccessException {
    	String interceptorClassName = cacheProperties.getInterceptor();
    	if(StringUtils.isEmpty(interceptorClassName)) {
    		return new RedisTemplateRedisOperator(redisTemplate);
    	}
    	else {
    		CacheConfiguration.interceptor = (Interceptor) ClassUtils.forName(interceptorClassName, null).newInstance();
    		return CacheConfiguration.wrapRedisOperator(new RedisTemplateRedisOperator(redisTemplate));
    	}
    }

*  ### 类加载 ###

说到这里，还有一个细节没有说， Mybatis的XMLConfigBuilder也好，Spring的ClassUtils工具也好。这时候我们一定要注意双亲委派模型

![70 7][]

顺便来看一下这两个组件的实现方式吧

Mybatis

关键在于获取classLoader

public static Class<?> classForName(String className) throws ClassNotFoundException {
 return classLoaderWrapper.classForName(className);
 }

public Class<?> classForName(String name) throws ClassNotFoundException {
 return classForName(name, getClassLoaders(null));
 }

ClassLoader[] getClassLoaders(ClassLoader classLoader) {
        return new ClassLoader[]{
            classLoader,
            defaultClassLoader,
            Thread.currentThread().getContextClassLoader(),
            getClass().getClassLoader(),
            systemClassLoader};
    }

Class<?> classForName(String name, ClassLoader[] classLoader) throws ClassNotFoundException {
 
 for (ClassLoader cl : classLoader) {
 
 if (null != cl) {
 
 try {
 
 Class<?> c = Class.forName(name, true, cl);
 
 if (null != c) {
 return c;
 }
 
 } catch (ClassNotFoundException e) {
 // we'll ignore this until all classloaders fail to locate the class
 }
 
 }
 
 }
 
 throw new ClassNotFoundException("Cannot find class: " + name);
 
 }

Spring

关键在于获取ClassLoader，另外，spring考虑的非常全面，考虑到了数组，内部类，Cglib动态代理类

@Nullable
    public static ClassLoader getDefaultClassLoader() {
    	ClassLoader cl = null;
    	try {
    		cl = Thread.currentThread().getContextClassLoader();
    	}
    	catch (Throwable ex) {
    		// Cannot access thread context ClassLoader - falling back...
    	}
    	if (cl == null) {
    		// No thread context class loader -> use class loader of this class.
    		cl = ClassUtils.class.getClassLoader();
    		if (cl == null) {
    			// getClassLoader() returning null indicates the bootstrap ClassLoader
    			try {
    				cl = ClassLoader.getSystemClassLoader();
    			}
    			catch (Throwable ex) {
    				// Cannot access system ClassLoader - oh well, maybe the caller can live with null...
    			}
    		}
    	}
    	return cl;
    }

public static Class<?> forName(String name, @Nullable ClassLoader classLoader)
 			throws ClassNotFoundException, LinkageError {
 
 		Assert.notNull(name, "Name must not be null");
 
 		Class<?> clazz = resolvePrimitiveClassName(name);
 		if (clazz == null) {
 			clazz = commonClassCache.get(name);
 		}
 		if (clazz != null) {
 			return clazz;
 		}
 
 		// "java.lang.String[]" style arrays
 		if (name.endsWith(ARRAY_SUFFIX)) {
 			String elementClassName = name.substring(0, name.length() - ARRAY_SUFFIX.length());
 			Class<?> elementClass = forName(elementClassName, classLoader);
 			return Array.newInstance(elementClass, 0).getClass();
 		}
 
 		// "[Ljava.lang.String;" style arrays
 		if (name.startsWith(NON_PRIMITIVE_ARRAY_PREFIX) && name.endsWith(";")) {
 			String elementName = name.substring(NON_PRIMITIVE_ARRAY_PREFIX.length(), name.length() - 1);
 			Class<?> elementClass = forName(elementName, classLoader);
 			return Array.newInstance(elementClass, 0).getClass();
 		}
 
 		// "[[I" or "[[Ljava.lang.String;" style arrays
 		if (name.startsWith(INTERNAL_ARRAY_PREFIX)) {
 			String elementName = name.substring(INTERNAL_ARRAY_PREFIX.length());
 			Class<?> elementClass = forName(elementName, classLoader);
 			return Array.newInstance(elementClass, 0).getClass();
 		}
 
 		ClassLoader clToUse = classLoader;
 		if (clToUse == null) {
 			clToUse = getDefaultClassLoader();
 		}
 		try {
 			return (clToUse != null ? clToUse.loadClass(name) : Class.forName(name));
 		}
 		catch (ClassNotFoundException ex) {
 			int lastDotIndex = name.lastIndexOf(PACKAGE_SEPARATOR);
 			if (lastDotIndex != -1) {
 				String innerClassName =
 						name.substring(0, lastDotIndex) + INNER_CLASS_SEPARATOR + name.substring(lastDotIndex + 1);
 				try {
 					return (clToUse != null ? clToUse.loadClass(innerClassName) : Class.forName(innerClassName));
 				}
 				catch (ClassNotFoundException ex2) {
 					// Swallow - let original exception get through
 				}
 			}
 			throw ex;
 		}
 	}

# 三、示例代码 #

@Slf4j
 public class RedisCacheTracker extends GenericTracker implements Interceptor {
 	
 	public RedisCacheTracker() {
 		super();
 	}
 	
 	public RedisCacheTracker(TraceClient traceClient) {
 		super(traceClient);
 	}
 	
 	/* (non-Javadoc) 
 	 * Title: intercept 
 	 * Description: 
 	 * @param invocation
 	 * @return
 	 * @throws Throwable 
 	 * @see com.luminary.component.cache.plugin.Interceptor#intercept(com.luminary.component.cache.plugin.Invocation) 
 	 */
 	@Override
 	public Object intercept(Invocation invocation) throws Throwable {
 
 		log.info("cache tracker");
 		
 		TraceHolder traceHolder = new TraceHolder();
 		Object result = null;
 		
 		try {
 			
 			Gson gson = new Gson();
 			
 			if(traceClient == null)
 				traceClient = getTraceClient();
 			
 			String serverHost = "";
 			
 			Map<String, Object> params = new HashMap<String, Object>();
 			Object target = invocation.getTarget();
 			if(target instanceof JedisRedisOperator) {
 				JedisRedisOperator jedisRedisOperator = (JedisRedisOperator) target;
 				serverHost = jedisRedisOperator.getHostPort();
 			}
 			else if(target instanceof RedisTemplateRedisOperator) {
 				serverHost = getServerHost();
 			}
 			
 			Method method = invocation.getMethod();
 			Object[] args = invocation.getArgs();
 			if(method.getName().equals("setBit")) {
 				params.put("key", args[0]);
 				params.put("offset", args[1]);
 				params.put("value", args[2]);
 			}
 			else if(method.getName().equals("getBit")) {
 				params.put("key", args[0]);
 				params.put("offset", args[1]);
 			}
 			else if(method.getName().equals("set")) {
 				params.put("key", args[0]);
 				params.put("data", args[1]);
 				params.put("expiredSeconds", args[2]);
 			}
 			else if(method.getName().equals("get")) {
 				params.put("key", args[0]);
 			}
 			else if(method.getName().equals("del")) {
 				params.put("key", args[0]);
 			}
 			
 			traceHolder.setProfile(getProfile());
 		 traceHolder.setRpcType(RpcTypeEnum.CACHE.name());
 			traceHolder.setServiceCategory("redis");
 			traceHolder.setServiceName(invocation.getTarget().getClass().getName());
 			traceHolder.setServiceHost(serverHost);
 			traceHolder.setMethodName(method.getName());
 			traceHolder.setRequestParam(gson.toJson(params));
 			
 			preHandle(traceHolder);
 			result = invocation.proceed();
 			
 			traceHolder.getEntity().setResponseInfo(result == null ? "" : result.toString());
 			postHandle(traceHolder);
 			
 		} catch(Exception e) {
 			log.error(e.getMessage(), e);
 			exceptionHandle(traceHolder, e);
 		} 
 		
 		return result;
 	}
 
 	/* (non-Javadoc) 
 	 * Title: plugin 
 	 * Description: 
 	 * @param target
 	 * @return 
 	 * @see com.luminary.component.cache.plugin.Interceptor#plugin(java.lang.Object) 
 	 */
 	@Override
 	public Object plugin(Object target) {
 		return Plugin.wrap(target, this);
 	}
 	
 	public String getProfile() {
 		log.warn("默认实现方法");
 		return null;
 	}
 	
 	public TraceClient getTraceClient() {
 		log.warn("默认实现方法");
 		return null;
 	}
 	
 	public String getServerHost() {
 		log.warn("默认实现方法");
 		return null;
 	}
 
 }

[https://github.com/wulinfeng2/luminary-component][https_github.com_wulinfeng2_luminary-component]

[70]: /images/20220517/eaa4e7a3fed74ba5a0c2f293404c0109.png
[70 1]: /images/20220517/25e4efacccd742848f17d151e6541ec2.png
[70 2]: /images/20220517/47b3634ad12546febe19f07c5d5b4e78.png
[70 3]: /images/20220517/0ab1f7ddf3914561948b363c4e825e66.png
[70 4]: /images/20220517/6d509ca49f694f16a9dafcce07de9de1.png
[70 5]: /images/20220517/f680879fde79466dbd375769b899b50c.png
[70 6]: /images/20220517/9770cf65aa284780ae91b279401f38cd.png
[70 7]: /images/20220517/143920a4f93b46029d59b7aa6696fdc9.png
[https_github.com_wulinfeng2_luminary-component]: https://github.com/wulinfeng2/luminary-component