方法一:
注解类中定义参数名称:
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DBChange {
String projectId() default "";
String environmentType() default "";
/**
*传递参数的对象类型
*/
Class<?> parameter() default Object.class;
/**
* 默认不校验参数
* @return
*/
boolean require() default false;
}
切面类中解析参数:
@Aspect
@Component
@Log4j
public class DBChangeAop {
//切面链接处
@Pointcut("@annotation(com.ggdo.manager.util.DBChange)")
public void cutMethod(){}
@Before(value = "cutMethod() && @annotation(dbChange)")
public void doBeforeCut(JoinPoint joinPoint,DBChange dbChange) throws Exception{
log.info("Before增强");
//自定义工具类解析注接类传入参数
String projectId = (String)DBChangeResolver.newInstance().resolver(joinPoint,dbChange.projectId());
String environmentType = (String)DBChangeResolver.newInstance().resolver(joinPoint,dbChange.environmentType());
log.info("projectId:"+projectId);
log.info("environmentType:"+environmentType);
if (projectId == null || "".equals(projectId) ){
throw new CommonException("projectId不能为空!");
}
}
@After(value = "cutMethod()")
public void doAfterCut(JoinPoint joinPoint){
log.info("After增强");
}
}
自定义工具类,对注解传入的参数进行解析
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import java.lang.reflect.Method;
public class DBChangeResolver {
private static DBChangeResolver resolver ;
public static DBChangeResolver newInstance(){
if (resolver == null) {
return resolver = new DBChangeResolver();
}else{
return resolver;
}
}
/**
* 解析注解上的值
* @param joinPoint
* @param str 需要解析的字符串
* @return
*/
public Object resolver(JoinPoint joinPoint, String str) {
if (str == null) return null ;
Object value = null;
if (str.matches("#\\{\\D*\\}")) {// 如果name匹配上了#{},则把内容当作变量
String newStr = str.replaceAll("#\\{", "").replaceAll("\\}", "");
if (newStr.contains(".")) { // 复杂类型
try {
value = complexResolver(joinPoint, newStr);
} catch (Exception e) {
e.printStackTrace();
}
} else {
value = simpleResolver(joinPoint, newStr);
}
} else { //非变量
value = str;
}
return value;
}
private Object complexResolver(JoinPoint joinPoint, String str) throws Exception {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
String[] names = methodSignature.getParameterNames();
Object[] args = joinPoint.getArgs();
String[] strs = str.split("\\.");
for (int i = 0; i < names.length; i++) {
if (strs[0].equals(names[i])) {
Object obj = args[i];
Method dmethod = obj.getClass().getDeclaredMethod(getMethodName(strs[1]), null);
Object value = dmethod.invoke(args[i]);
return getValue(value, 1, strs);
}
}
return null;
}
private Object getValue(Object obj, int index, String[] strs) {
try {
if (obj != null && index < strs.length - 1) {
Method method = obj.getClass().getDeclaredMethod(getMethodName(strs[index + 1]), null);
obj = method.invoke(obj);
getValue(obj, index + 1, strs);
}
return obj;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
private String getMethodName(String name) {
return "get" + name.replaceFirst(name.substring(0, 1), name.substring(0, 1).toUpperCase());
}
private Object simpleResolver(JoinPoint joinPoint, String str) {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
String[] names = methodSignature.getParameterNames();
Object[] args = joinPoint.getArgs();
for (int i = 0; i < names.length; i++) {
if (str.equals(names[i])) {
return args[i];
}
}
return null;
}
}
方法添加注解时设置传参:
@PostMapping("/change")
@DBChange(projectId = "#{resultInfo.projectId}",environmentType = "#{resultInfo.environment}" ,require = true)
public ResponseObj changeDb(@RequestBody EdcReleaseLogDto resultInfo){
log.info("测试");
}
此方法存在问题:如果方法的接收参数的EdcReleaseLogDto中不包含AOP注解需要的参数,但EdcReleaseLogDto的父类DTO中有AOP注解需要的参数,此时AOP不能拿到该参数。
方法二:
考虑到方法一中问题,直接从请求参数中获取AOP注解需要的参数。此方法支持从请求头获取参数或者从请求方法中获取参数,从请求方法中获取参数时,要求入参接收对象本身或者父类有AOP注解需要的对应参数。
@Before(value = "cutMethod()")
public void doBeforeCut(JoinPoint joinPoint) {
log.info("请求开始 : ==========================");
// 接收到请求,记录请求内容
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
log.info("解析请求头参数 : ============开始==========");
Enumeration<String> headerNames = request.getHeaderNames();
EDCBaseRequestBody body = new EDCBaseRequestBody();
while (headerNames.hasMoreElements()) {
String headName = headerNames.nextElement();
// log.info("headName->" + headName);
if ("projectId".equals(headName) || "projectid".equals(headName)) {
String header = request.getHeader(headName);
body.setProjectId(Integer.parseInt(header));
log.info("headName->" + headName + ";header:" + header);
}
if ("environment".equals(headName)) {
String header = request.getHeader(headName);
body.setEnvironment(header);
log.info("headName->" + headName + ";header:" + header);
}
}
if (!(StringUtils.isEmpty(body.getEnvironment())) && body.getProjectId() != null) {
return body;
}
log.info("解析请求参数 : =================开始==================");
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
// 只记录post方法 传json格式的数据
if ("POST".equals(request.getMethod())) {
LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
String[] paramNames = u.getParameterNames(method);
//方法 1 请求的方法参数值 JSON 格式 null不显示
if (joinPoint.getArgs().length > 0) {
Object[] args = joinPoint.getArgs();
for (int i = 0; i < args.length; i++) {
//请求参数类型判断过滤,防止JSON转换报错
if (args[i] instanceof HttpServletRequest || args[i] instanceof HttpServletResponse || args[i] instanceof MultipartFile) {
continue;
}
String jsonstr = JSON.toJSONString(args[i]);
Map<String, Object> map = JSONObject.parseObject(jsonstr);
if (map.containsKey("projectId")) {
Integer projectId = ((map.get("projectId")).getClass().equals(String.class)) ? Integer.parseInt((String) map.get("projectId")) : (Integer) map.get("projectId");
body.setProjectId(projectId);
}
if (map.containsKey("environment")) {
body.setEnvironment((String) map.get("environment"));
}
log.info("请求参数名称 :" + paramNames[i] + ", 内容 :" + JSON.toJSONString(args[i]));
}
return body;
}
}
if ("GET".equals(request.getMethod())) {
throw new CommonException("GET请求参数解析异常");
}
throw new CommonException("请求参数异常");
}