面向切面編程
1.傳統切面開發
通過Spring AOP我們可以很便捷的進行面向切面編程，比如統一日志處理、權限處理等等，常見開發范式如下：
package com.xxx.service;
import lombok.extern.slf4j.Slf4j;
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.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@EnableAspectJAutoProxy
@Aspect
@Slf4j
public class DemoAspectConfig {
@Pointcut(value = "execution(* com.xxx.service.controller..*(..))")
public void pointcut() {
}
@Around("pointcut()")
public Object advice(ProceedingJoinPoint pjp) {
try {
// do something...
Object result = pjp.proceed();
return result;
} catch (Throwable throwable) {
// do something...
return null;
} finally {
// do something
}
}
}
2.動態切面的AOP
傳統的AOP開發，切點表達式是直接硬編碼的，也可以應對大多數的業務場景，但是很明顯，是缺少靈活性的。如果切點要想做到可擴展，那么就需要借助所謂的動態AOP，即支持切點的可配置。下面的code通過SpringBoot的自動配置機制，實現切點的動態可配置。原理如下：
通過JAVA config，借助ImportAware, BeanFactoryAware在容器啟動過程中獲取項目中通過注解EnableAlarmNotify(可以用在主類或Java Config的類上, 詳見下文)指定的需要告警的包，構造出最終的告警切面的切點表達式, 達到靈活擴展的目的
動態切面配置類
DynamicAspectAutoConfiguration：
package com.xxx.service;
import lombok.extern.slf4j.Slf4j;
import org.aopalliance.aop.Advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.Apache.commons.lang.StringUtils;
import org.springframework.aop.Advisor;
import org.springframework.aop.Pointcut;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportAware;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.type.AnnotationMetadata;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.stream.Collectors;
/**
* 通過Java config，借助ImportAware, BeanFactoryAware在容器啟動過程中獲取項目中
* 通過注解EnableAlarmNotify(可以用在主類或Java Config的類上)指定的需要告警的包，
* 構造出最終的告警切面的切點表達式,
* 達到靈活擴展的目的
*/
@Configuration
@EnableAlarmNotify
@Slf4j
public class DynamicAspectAutoConfiguration implements ImportAware, BeanFactoryAware {
private BeanFactory beanFactory;
/**
* 切點表達式
*/
private String expressionPointCut = "(@within(org.springframework.web.bind.annotation.RestController) " +
"|| @within(org.springframework.stereotype.Controller))";
/**
* 通過Import 獲取注解元數據
*/
@Override
public void setImportMetadata(AnnotationMetadata importMetadata) {
AnnotationAttributes attributes = AnnotationAttributes.fromMap(importMetadata.getAnnotationAttributes(EnableAlarmNotify.class.getName()));
if (attributes != null) {
String[] basePackages = attributes.getStringArray("basePackages");
if (basePackages != null && basePackages.length > 0) {
String givenPackage = Arrays.stream(basePackages)
.filter(StringUtils::isNotBlank)
.map(basePackage -> "within(" + getPackageName(basePackage) + "..*)")
.collect(Collectors.joining(" || ", "(", ")"));
//設置最終的切點表達式
this.expressionPointCut = this.expressionPointCut + " && " + givenPackage;
log.info("告警通知的切點表達式為: {}", this.expressionPointCut);
}
}
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
//通過接口注入beanFactory容器
this.beanFactory = beanFactory;
}
private String getPackageName(String basePackage) {
if (StringUtils.isEmpty(basePackage)) {
return basePackage;
}
while (basePackage.endsWith(".")) {
basePackage = basePackage.substring(0, basePackage.length() - 1);
}
return basePackage;
}
@Bean("alarmNotifyPointcut")
@ConditionalOnClass(Pointcut.class)
public Pointcut alarmNotifyPointcut() {
AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
pointcut.setExpression(expressionPointCut);
pointcut.setBeanFactory(beanFactory);
return pointcut;
}
@Bean("alarmNotifyAdvice")
@ConditionalOnClass(Advice.class)
public MethodInterceptor alarmNotifyAdvice() {
return invocation -> {
final Method method = invocation.getMethod();
NotSendAlarmNotify notSendAlarmNotify = Util.getDefaultIfNull(AnnotationUtils.findAnnotation(method, NotSendAlarmNotify.class),
AnnotationUtils.findAnnotation(method.getDeclaringClass(), NotSendAlarmNotify.class));
if (notSendAlarmNotify != null) {
//指定不告警 直接執行目標方法
return invocation.proceed();
}
String className = method.getDeclaringClass().getName();
String methodName = method.getName();
Object[] args = invocation.getArguments();
if (args != null && args.length > 0) {
// 保留原始請求參數
args = Arrays.copyOf(args, args.length);
}
try {
Object result = invocation.proceed();
//可以自定義相關處理邏輯
return result;
} catch (Throwable throwable) {
//發送告警通知
SendAlarmNotifyUtil.sendAlarm(className, methodName, args);
throw throwable;
}
};
}
@Bean("alarmNotifyAdvisor")
@ConditionalOnClass(Advisor.class)
public DefaultBeanFactoryPointcutAdvisor alarmNotifyAdvisor() {
DefaultBeanFactoryPointcutAdvisor advisor = new DefaultBeanFactoryPointcutAdvisor();
advisor.setPointcut(alarmNotifyPointcut());
advisor.setAdvice(alarmNotifyAdvice());
advisor.setBeanFactory(beanFactory);
return advisor;
}
static final class Util {
public static <T> T getDefaultIfNull(T object, T defaultValue) {
return object != null ? object : defaultValue;
}
}
}
注解EnableAlarmNotify：
package com.xxx.service;
import org.springframework.context.annotation.Import;
import java.lang.annotation.*;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(DynamicAspectAutoConfiguration.class)
public @interface EnableAlarmNotify {
String[] basePackages() default {"com.xxx"};
}
注解NotSendAlarmNotify
package com.xxx.service;
import java.lang.annotation.*;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface NotSendAlarmNotify {
}
說明：動態AOP(支持切點可配置)最好抽取到公共服務上，這樣公司內部的其他服務就可以直接通過二方包引用，使用非常方便。以上內容希望對你有所幫助~~
