一、背景
随着业务增长,服务的性能出现瓶颈,作为一个服务端,需要杜绝被下游服务拖垮,造成“雪崩”现象,所以公司自研了熔断器,需要在服务调用的地方加上熔断。
由于历史技术债,获取服务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不在白名单的方法,代理类会扔出异常,当异常数超阈值后,服务熔断,之后请求不会走到目标方法
关闭异常开关后,熔断器内部会重试,当重试成功后,熔断器方向请求,请求链路回复正常
三、总结
使用动态代理减少对业务代码的入侵,提升团队的工作效率