cglib实战代理

一、背景

      随着业务增长，服务的性能出现瓶颈，作为一个服务端，需要杜绝被下游服务拖垮，造成“雪崩”现象，所以公司自研了熔断器，需要在服务调用的地方加上熔断。
      由于历史技术债，获取服务rpc通讯器的方法都有static修饰，如果按需盲加熔断，工作量太大，所以思考权衡后，使用cglib代理一下。

二、实现方式 

1.maven坐标

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

2.代理类

import com.google.common.collect.Sets;
import lombok.AllArgsConstructor;
import lombok.Getter;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;
import java.util.Objects;
import java.util.Set;



@AllArgsConstructor
@Getter
public class BreakerProxy implements MethodInterceptor {


    /**
     * 目标对象
     */
    private Object target;

    /**
     * 父类
     */
    private Class superClass;

    /**
     * 熔断器名称
     */
    private String servantName;

    /**
     * 白名单
     */
    private Set<String> whiteSet = Sets.newHashSet();

    public BreakerProxy(Object target, Class superClass, String servantName) {
        this.target = target;
        this.superClass = superClass;
        this.servantName = servantName;
    }


    /*
     * 用来获取代理对象(创建一个代理对象)
     * */
    public Object getProxy() {
        String superName = superClass.getSimpleName();
        // 利用Apollo做全局熔断开关和各自服务的熔断开关
        if (ConfigCenter.getBoolByKey("breaker_config.disableBreaker", false) ||
                ConfigCenter.getBoolByKey("breaker_config.disableBreaker_" + superName, false)) {
            return target;
        }

       // 从localcache(一个并发map)中获取代理对象
        Object o = ProxyCache.get(superName);
        if (Objects.nonNull(o)) {
            return o;
        }
        synchronized (superClass) {
            o = ProxyCache.get(superName);
            // 双重检验下
            if (Objects.nonNull(o)) {
                return o;
            }
            // 创建代理对象
            Enhancer enhancer = new Enhancer();
            // 我们的代理对象对应的类有可能是final的，所以父类可以通过参数指定下
            // enhancer.setSuperclass(target.getClass());
            enhancer.setSuperclass(superClass);
            enhancer.setCallback(this);
            o = enhancer.create();
            ProxyCache.put(superName, o);
            return o;
        }
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 根据名称获取熔断器
        CallCtrl breaker = BreakerConstants.getBreaker(servantName);
        // 已处于熔断态，且接口不在熔断白名单中
        if (breaker.isDown() && !whiteSet.contains(method.getName())) {
            // 熔断态
            throw new Exception(“breadkr down”);
        }

        try {
            if (ConfigCenter.getBoolByKey("breaker_config.exceptionBreaker_" + superClass.getSimpleName(), false)) {
                // 利用Apollo来调试熔断
                throw new Exception("TEST BREAKER");
            }
            // 执行目标方法
            Object result = methodProxy.invoke(target, objects);
            // 请求成功，成功计数+1
            breaker.recSucc();
            return result;
        } catch (Throwable throwable) {
            // 请求失败，失败计数+1
            breaker.recFail();
            throw throwable;
        }

    }

}

3.应用

public class RpcProxy{
	public static AProxy getAProxy() {
		// 从注册中心获取通讯器对象
        AProxyImpl prx = getCommunicator().stringToProxy("aProxy",AProxyImpl.class);
        // AProxyImpl被final修饰
        return (AProxy) new BreakerProxy(prx, AProxy.class, "aProxy", Sets.newHashSet("add", "update")).getProxy();
    }

    public static BProxy getBProxy() {
		// 从注册中心获取通讯器对象
        BProxyImpl prx = getCommunicator().stringToProxy("bProxy",BProxyImpl.class);
        return (BProxy) new BreakerProxy(prx, BProxy.class, "bProxy", Sets.newHashSet("add", "delete")).getProxy();
    }
}

4.说明

我们发送压测请求，服务的链路处于正常态。

使用Apollo将aProxy的异常开关打开，此时调用AProxy不在白名单的方法，代理类会扔出异常，当异常数超阈值后，服务熔断，之后请求不会走到目标方法

关闭异常开关后，熔断器内部会重试，当重试成功后，熔断器方向请求，请求链路回复正常

三、总结 

使用动态代理减少对业务代码的入侵，提升团队的工作效率