guava-retrying 加入自定义注解，用aop方式使用
由于网络环境不太稳定，一些接口方法需要加入重试。正好看到Google's Guava library 项目https://github.com/rholder/guava-retrying，里面功能比较完善。但是官方没有提供注解方式使用，频繁使用会有点麻烦。所以查阅相关资料后编写了支持注解使用的方法
定义注解类
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* des: guava retrying 注解使用
* doc: https://github.com/rholder/guava-retrying
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Retry {
//指定异常时重试 由于pjp.proceed();需要try catch 异常，会有问题暂时没找到解决方法，先注释
// Class[] exceptionClass() default {};
//出现Exception时重试
boolean retryIfException() default false;
//程序出现RuntimeException异常时重试
boolean retryIfRuntimeException() default false;
//重试次数
int attemptNumber() default 3;
//重试间隔 ms
long waitStrategySleepTime() default 1000;
//持续时间; 期间
long duration() default 0;
//返回值为指定字符串时重试
String returnResult() default "willRertyString";
//返回值为false时重试（默认关闭） 不支持同时设置指定返回字符串重试
boolean closeReturnFalseRetry() default true;
}
AOP类
package net.capitalonline.retry.retryaspect;
import com.github.rholder.retry.RetryerBuilder;
import com.github.rholder.retry.StopStrategies;
import com.github.rholder.retry.WaitStrategies;
import com.google.common.base.Predicates;
import net.capitalonline.retry.Retry;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
/**
* des: guava retrying 注解使用
* doc: https://github.com/rholder/guava-retrying
*/
@Aspect
@Component
public class RetryAspect {
@Pointcut("@annotation(net.capitalonline.retry.Retry)")
public void MethodCallConstraintPointcut(){
}
@Around(value = "@annotation(net.capitalonline.retry.Retry)")
public Object monitorAround(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("enter retry aspect");
Method method;
if (pjp.getSignature() instanceof MethodSignature) { //判断注解是否method 上
MethodSignature signature = (MethodSignature) pjp.getSignature();
method = signature.getMethod();
} else {
return null;
}
Retry annotation = method.getDeclaredAnnotation(Retry.class);
//重试时间，重试次数
if (annotation.duration() <= 0 && annotation.attemptNumber() <= 1) {
return pjp.proceed();
}
//不能设置开启returnFalse重试 和指定返回值重试
if(!annotation.closeReturnFalseRetry() && !annotation.returnResult().equals("willRertyString")){
return pjp.proceed();
}
RetryerBuilder builder = RetryerBuilder.newBuilder();
//重试次数
if (annotation.attemptNumber() > 0) {
builder.withStopStrategy(StopStrategies.stopAfterAttempt(annotation.attemptNumber()));
}
//退出策略
if (annotation.duration() > 0) {
builder.withStopStrategy(StopStrategies.stopAfterDelay(annotation.duration(), TimeUnit.MILLISECONDS));
}
//重试间间隔等待策略
if (annotation.waitStrategySleepTime() > 0) {
builder.withWaitStrategy(WaitStrategies.fixedWait(annotation.waitStrategySleepTime(), TimeUnit.MILLISECONDS));
}
// //停止重试的策略
// if (annotation.exceptionClass().length > 0) {
// for (Class retryThrowable : annotation.exceptionClass()) {
// if (retryThrowable != null && Throwable.class.isAssignableFrom(retryThrowable)) {
// builder.retryIfExceptionOfType(retryThrowable);
// }
// }
// }
//RuntimeException时重试
if (annotation.retryIfRuntimeException()){
builder.retryIfRuntimeException();
}
if (annotation.retryIfException()){
builder.retryIfException();
}
if (!annotation.returnResult().equals("willRertyString")){
builder.retryIfResult(Predicates.equalTo(annotation.returnResult()));
}
if (!annotation.closeReturnFalseRetry()){
builder.retryIfResult(Predicates.equalTo(annotation.closeReturnFalseRetry()));
}
return builder.build().call(() -> {
try {
System.out.println("aspect exec method "+ method.getName());
return pjp.proceed();
} catch (Throwable throwable) {
if (throwable instanceof Exception) {
throw (Exception) throwable;
} else {
throw new Exception(throwable);
}
}
});
// Callable<Object> callable=new Callable<Object>() {
// @Override
// public Object call() throws Exception {
// try {
// return pjp.proceed();
// }catch (Throwable e){
// e.printStackTrace();
// System.out.println("测试");
// return null;
// }
// }
// };
// try {
// return builder.build().call(callable);
// }catch (Exception e){
// System.out.println("重试");
// return "error";
// }
}
}
application.yaml 配置中加入
aop:
proxy-target-class: true
使用实例
import org.springframework.stereotype.Component;
import java.lang.reflect.UndeclaredThrowableException;
import java.text.SimpleDateFormat;
import java.util.Date;
@Component
public class TestA {
int x=0;
@Retry(retryIfException = true, waitStrategySleepTime = 1200)
public void test() throws RemoteException{
try {
SimpleDateFormat sdf = new SimpleDateFormat();// 格式化时间
sdf.applyPattern("yyyy-MM-dd HH:mm:ss a");// a为am/pm的标记
Date date = new Date();// 获取当前时间
System.out.println("现在时间：" + sdf.format(date)); // 输出已经格式化的现在时间（24小时制）
int a=1/x;
System.out.println("1231");
} catch (Exception e) {
System.out.println("nonono");
throw new RemoteException("12321");
}
}
}
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
@WebAppConfiguration
@ContextConfiguration(classes = Application.class)
public class Tmpmytest {
@Autowired
TestA testA;
@Test
public void tmptest() {
try {
testA.test();
} catch (Exception e) {
System.out.println("ada");
}
}
}
