SpringAOP&&定时任务简单实现接口访问入表和定时任务接口重试

# SpringAOP&&定时任务简单实现接口访问入表和定时任务接口重试 #

• Spring aop

• Spring 定时任务

• 代理模式深化

---

1.表设计

2.Aop主要代码

@Aspect
@Component
public class AopUtils implements Ordered {
//当前
private static final Logger logger = LoggerFactory.getLogger(AopUtils.class);
public static String
AOPLOG_NO_RETREN_VALUE = "NONE RETURN";
@Value("${接口地址.url}")
private String url;
@Autowired
private RequestInfoDao requestInfoDao;
/**
*
API 接口日志访问记录
* 环绕通知实现
* @param jp
* @return
*/
@Around("execution(* com.*.*.modules.*.service.CommonService.*(..))")
public Object logApiMethod(ProceedingJoinPoint jp) throws Throwable {
RequestAttributes ra = RequestContextHolder.getRequestAttributes();
ServletRequestAttributes sra = (ServletRequestAttributes) ra;
Object rvt = null;
RequestInfo requestInfo = new RequestInfo();
//配合后面的定时任务重试接口机制
if(sra == null) {
try {
rvt = jp.proceed(jp.getArgs());
String params = "";
List<Object> filterArgs = Lists.newArrayList();
try {
if(jp.getArgs()!=null) {
Arrays.stream(jp.getArgs()).forEach(arg -> {
if (!(arg instanceof HttpServletRequest || arg instanceof HttpServletResponse)) {
filterArgs.add(arg);
}
});
}
params = (filterArgs.size()==0)? "":JsonMapper.toJsonString(filterArgs);
}catch (Exception e) {
params = filterArgs+"";
}
String returnValue = "";
try {
returnValue = rvt==null ? "": JsonMapper.toJsonString(rvt);
}catch (Exception e) {
returnValue = "返回值过长不显示";
}
requestInfo.setParam(params);
requestInfo.setReturnValue(returnValue);
requestInfo.setUpdateDate(new Date());
User user = new User("接口重试");
requestInfo.setUpdateBy(user);
requestInfo.setResult(true);
requestInfo.setErrorResson(null);
requestInfoDao.updateByParams(info);
return rvt;
} catch (Throwable var6) {
requestInfo.setResult(false);
requestInfo.setErrorResson("线上接口访问异常："+var6.getMessage());
logger.error("线上接口访问异常：", var6);
}
}
HttpServletRequest request = sra.getRequest();
requestInfo.setResult(true);
try {
rvt = jp.proceed(jp.getArgs());
} catch (Throwable var6) {
requestInfo.setResult(false);
requestInfo.setErrorResson("线上接口访问异常："+var6.getMessage());
logger.error("线上接口访问异常：", var6);
}
String methodName = jp.getSignature().getName();
//参数写成一个集合数组，接口重试的时候需要转换
String params = "";
List<Object> filterArgs = Lists.newArrayList();
try {
if(jp.getArgs()!=null) {
Arrays.stream(jp.getArgs()).forEach(arg -> {
if (!(arg instanceof HttpServletRequest || arg instanceof HttpServletResponse)) {
filterArgs.add(arg);
}
});
}
params = (filterArgs.size()==0)? "":JsonMapper.toJsonString(filterArgs);
}catch (Exception e) {
params = filterArgs+"";
}
String returnValue = "";
if(isShowReturnValue(methodName)) {
try {
returnValue = rvt==null ? "": JsonMapper.toJsonString(rvt);
}catch (Exception e) {
returnValue = "返回值过长不显示";
}
}else {
returnValue = "不显示返回值";
}
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String requestURI = httpServletRequest.getRequestURI();
String beanName = jp.getThis().getClass().getSimpleName();
int num = beanName.indexOf("$$");
beanName = beanName.substring(0, 1).toLowerCase() + beanName.substring( 1, num);
requestInfo.setId(IdGen.uuid());
requestInfo.setBeanName(beanName);
requestInfo.setMethod(methodName);
requestInfo.setParam(params);
requestInfo.setRequestUrl(url+requestURI);
requestInfo.setReturnValue(returnValue);
requestInfo.setCreateDate(new Date());
requestInfo.setUpdateDate(new Date());
//接口是否可重复
Method aopMethod = ((MethodSignature)jp.getSignature()).getMethod();
Method m = jp.getTarget().getClass().getDeclaredMethod(methodName, aopMethod.getParameterTypes());
InterfaceRepeatFlag interfaceRepeatFlag = m.getAnnotation(InterfaceRepeatFlag.class);
if (interfaceRepeatFlag == null){
requestInfo.setRepeatFlag(false);
}else {
requestInfo.setRepeatFlag(interfaceRepeatFlag.value());
}
User user = new User();
user.setId("接口调用");
requestInfo.setCreateBy(user);
requestInfo.setUpdateBy(user);
if(requestInfoDao != null) {
requestInfoDao.insert(requestInfo);
}
return rvt;
}
private boolean isShowReturnValue(String methodName) {
List<String> debugRoles = Arrays.asList(AOPLOG_NO_RETREN_VALUE.split(","));
for(String debugRole : debugRoles) {
if(!StringUtils.isBlank(methodName)
&& methodName.indexOf(debugRole) == 0){
return false;
}
}
return true;
}
@Override
public int getOrder() {
return 1001;
}
}

3.定时任务配置

<bean name="schedulerFactory"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<!-- 定义数据源 ,数据源里面需要Quzrtz集群所需要的表 -->
<property name="dataSource">
<ref bean="dataSource" />
</property>
<!-- 指定spring容器的key，如果不设定在job中的jobmap中是获取不到spring容器的 -->
<property name="applicationContextSchedulerContextKey" value="applicationContextKey" />
<!-- 指定spring的配置相关信息 -->
<property name="configLocation" value="classpath:quartz.properties" />
<!-- 指定触发器，可以指定多个 -->
<property name="triggers">
<list>
<ref bean="interfaceJobTrigger"/>
</list>
</property>
</bean>
<!-- 定义任务 -->
<bean id="interfaceJob" class="com.*.*.modules.quzrtz.service.interfaceJob"/>
<bean id="interfaceJobDetail" class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass">
<!-- 上面的任务的代理类(自己实现) -->
<value>com.*.*.modules.quzrtz.scheduler.InterfaceJobSchedule</value>
</property>
<property name="description">
<value>定时任务接口重试</value>
</property>
<property name="jobDataAsMap">
<map>
<!--实际的任务BeanName,填上EventMonitorService的BeanName -->
<entry key="targetObject" value="interfaceJob" />
<!-- 执行Bean中的哪个方法 -->
<entry key="targetMethod" value="repeatInterface" />
</map>
</property>
</bean>
<bean id="interfaceJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail">
<!-- 任务代理Bean name -->
<ref bean="interfaceJobDetail" />
</property>
<property name="description">
<!-- 任务代理Bean name -->
<value>定时任务接口重试</value>
</property>
<property name="cronExpression">
<!-- 配置表达式,这里表示每1分钟执行一次 -->
<value>0 0/1 * * * ?</value>
</property>
</bean>

4.定时任务

@Transactional(readOnly = false)
public void repeatInterface() {
RequestInfo requestInfo = new RequestInfo();
requestInfo.setRepeatFlag(true);
requestInfo.setResult(false);
List<RequestInfo> requestInfoList = requestInfoDao.findAllList(requestInfo);
for (RequestInfo requestInfo : requestInfoList){
String paramStr = requestInfo.getParam();
String beanStr = requestInfo.getBeanName();
String methodStr = requestInfo.getMethod();
try {
Object obj = SpringContextHolder.getBean(beanStr);
Method m = null;
Method[] methods = obj.getClass().getMethods();
if (methods != null && methods.length > 0) {
for (Method method : methods) {
if (method.getName().equals(methodStr)) {
m = method;
break;
}
}
}
Class paramCls = m.getParameterTypes()[0];
List<Object> params =
JSONArray.parseArray(paramStr);
MethodUtils.invokeExactMethod(obj, methodStr, JSON.parseObject(JSONObject.toJSONString(params.get(0)), paramCls));
}catch (Exception e){
e.printStackTrace();
logger.error("接口重试：失败，失败原因："+e.getMessage());
continue;
}
logger.info("接口重试成功：类名"+beanStr+";方法："+methodStr+";参数："+paramStr+";结束重试");
}
}

5.定时任务调度器-定时任务代理

public class InterfaceJobSchedule extends QuartzJobBean {
private Logger logger = LoggerFactory.getLogger(InterfaceJobSchedule.class);
private String targetObject;
private String targetMethod;
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
try {
Object otargetObject = SpringContextHolder.getBean(targetObject);
Method m = null;
Method[] methods = otargetObject.getClass().getMethods();
if (methods != null && methods.length > 0) {
for (Method method : methods) {
if (method.getName().equals(targetMethod)) {
m = method;
break;
}
}
m.invoke(otargetObject, new Object[]{});
}
} catch (Exception e) {
logger.error("InterfaceJobSchedule Exception:", e);
}
}
/**
* @param targetObject the targetObject to set
*/
public void setTargetObject(String targetObject) {
this.targetObject = targetObject;
}
/**
* @param targetMethod the targetMethod to set
*/
public void setTargetMethod(String targetMethod) {
this.targetMethod = targetMethod;
}
}

6.接口重试注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InterfaceRepeatFlag {
public boolean value() default true;
}

7.学习总结

Spring AOP核心是代理模式，可见代理模式的拓展性有多强，有业务的代码才会有收获，试一试，收获颇多