使用spring通过aop获取方法参数和参数值

使用spring通过aop获取方法参数和参数值

目录spring通过aop获取方法参数和参数值自定义注解切面aop切面 注解、参数获取1、定义需要切面的注解2、在需要进行切面的方法标注注解3、定义切面

spring通过aop获取方法参数和参数值

自定义注解

package com.xiaolc.aspect;

import java.lang.annotation.*;

/**

* @author lc

* @date 2019/9/10

*/

@Documented

@Target({ElementType.TYPE, ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

public @interface LiCheng {

}

切面

package com.xLuDeTVziaolc.aspect;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.core.DefaultParameterNameDiscoverer;

import org.springframework.core.ParameterNameDiscoverer;

import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.Map;

/**

* 获取方法上的注解值

*/

@Component

@Aspect

public class AuditAnnotationAspect {

@Around("@annotation(liCheng))")

private static Map getFieldsName(ProceedingJoinPoint joinPoint,LiCheng liCheng) throws ClassNotFoundException, NoSuchMethodException {

String classType = joinPoint.getTarget().getClass().getName();

String methodName = joinPoint.getSignature().getName();

// 参数值

Object[] args = joinPoint.getArgs();

Class>[] classes = new Class[args.length];

for (int k = 0; k < args.length; k++) {

if (!args[k].getClass().isPrimitive()) {

// 获取的是封装类型而不是基础类型

String result = args[k].getClass().getName();

Class s = map.get(result);

classes[k] = s == null ? args[k].getClass() : s;

}

}

ParameterNameDiscoverer pnd = new DefaultParameterNameDiscoverer();

// 获取指定的方法，第二个参数可以不传，但是为了防止有重载的现象，还是需要传入参数的类型

Method method = Class.forName(classType).getMethod(methodName, classes);

// 参数名

String[] parameterNames = pnd.getParameterNames(method);

// 通过map封装参数和参数值

HashMap paramMap = new HashMap();

for (int i = 0; i < parameterNames.length; i++) {

paramMap.put(parameterNames[i], args[i]);

System.out.println("参数名："+parameterNames[i]+"\n参数值"+args[i]);

}

return paramMap;

}

private static HashMap map = new HashMap() {

{

put("java.lang.Integer", int.class);

put("java.lang.Double", double.class);

put("java.lang.Float", float.class);

put("java.lang.Long", Long.class);

put("java.lang.Short", short.class);

put("java.lang.Boolean", boolean.class);

put("java.lang.Char", char.class);

}

};

}

aop切面 注解、参数获取

在工作中会经常使用aop，这里将aop使用基本方法，获取在切点中使用的获取参数、注解做一个样例。

1、定义需要切面的注解

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface AnnDemo {

String value();

boolean isAop() default true;

}

2、在需要进行切面的方法标注注解

@RestController

@RequestMapping("/order")

public class OrderController {

@Autowired

private OrderService orderService;

@RequestMapping("/all")

@AnnDemo(value = "all",isAop = false)

public List findAll() {

List list = orderService.getOrderList();

return list;

}

@RequestMapping("/page")

@AnnDemo(value = "page")

public List findPage(@RequestParam("username") String username) {

List listPage = orderService.getOrdersListPage();

return listPage;

}

}

3、定义切面

在切面中获取切点注解，方法，参数的获取

@Aspect

@Component

public class AspectDemo {

@Pointcut(value = "execution(* com.yin.freemakeradd.controller..*(..))")

public void excetionMethod() {}

@Pointcut(value = "execution(* com.yin.freemakeradd.controller..*(..)) && @annotation(AnnDemo)")

public void excetionNote() { }

@Before("excetionMethod()")

public void testBefore(JoinPoint joinPoint) {

System.out.println("----------------------------前置通知---");

Object[] args = joinPoint.getArgs();

for (Object arg : args) {

System.out.println(arg);

}

}

@Around(value = "execution(* com.yin.freemakeradd.controller..*(..)) && @annotation(AnnDemo)")

public Object testBeforeNote(ProceedingJoinPoint joinPoint) throws Throwable {

//用的最多通知的签名

Signature signature = joinPoint.getSignature();

MethodSignature msg=(MethodSignature) signature;

Object target = joinPoint.getTarget();

//获取注解标注的方法

Method method = target.getClass().getMethod(msg.getName(), msg.getParameterTypes());

//通过方法获取注解

AnnDemo annotation = method.getAnnotation(AnnDemo.class);

Object proceed;

//获取参数

Object[] args = joinPoint.getArgs();

System.out.println(annotation.value());

System.out.println(annotation.isAop());

for (Object arg : args) {

System.out.println(arg);

}

if (Objects.isNull(annotation) || !annotation.isAop()) {

System.out.println("无需处理");

proceed = joinPoint.proceed();

}else {

System.out.println("进入aop判断");

proceed = joinPoint.proceed();

if(proceed instanceof List){

List proceedLst = (List) proceed;

if(!CollectionUtils.isEmpty(proceedLst)){

TbOrder tbOrder = new TbOrder();

tbOrder.setPaymentType("fffffffffffffffffff");

ArrayList tbOrderLst = new ArrayList<>();

tbOrderLst.add(tbOrder);

return tbOrderLst;

}

}

System.out.println(proceed);

}

return proceed;

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。