springboot aop

加入springboot-aop的依赖

<dependency> 
  <groupId>org.springframework.boot</groupId> 
  <artifactId>spring-boot-starter-aop</artifactId> 
</dependency> 

代码：在网关自定义了一个过滤器 现在在该过滤器做切面点 每次执行该过滤器的apply方法时执行切面方法

//自定义过滤器 要在yml文件里配置自定义过滤器的过滤器名称MyCustomFilter （MyCustomFilter-GatewayFilterFactory）
// （GatewayFilterFactory是默认名称，前面的就是自定义过滤器的名称）
//  filters:
//    - MyCustomFilter=condition1,condition2,condition3,condition4
@Order(1)
@Component
public class MyCustomGatewayFilterFactory
        extends AbstractGatewayFilterFactory<MyCustomGatewayFilterFactory.Config> {

    public MyCustomGatewayFilterFactory() {
        super(Config.class);
    }


    @Override
    public GatewayFilter apply(Config config) {
        return ((exchange, chain) -> {
            System.out.println("进入自定义过滤器");
            ServerHttpRequest request = exchange.getRequest();
            ServerHttpResponse response = exchange.getResponse();
            String key = config.getParam();
            System.out.println(key);
            return chain.filter(exchange);
        });
    }

    /**
     *  如果是自定义config 则需要重写该方法返回list集合 以便routdefine通过反射传回参数
     *  ShortcutConfiguratble 这个类获取配置
     *  RouteDefinitionRouteLocator.getFilters 获得所有过滤器 然后按顺序执行
     * @return
     */
    @Override
    public List<String> shortcutFieldOrder() {
        List<String> list = new ArrayList<>();
        list.add("param");
        list.add("param2");
        list.add("param3");
        list.add("param4");
        return list;
    }

    /**
     * 你再路由配置那里给过滤器设置了多少参数那么就创建多少个参数变量来接收值
     * 我在过滤器那里设置了四个参数 因此这里也设置四个
     *       routes:
     *         - id: nacos-custom1-service
     *           #lb是负载均衡 lb://注册的服务名
     *           uri: lb://nacos-custom1-service
     *           predicates: #路由断言 路由断言path中的第一个词不能和服务名相同 相同会被去除掉
     *             - Path=/custom1Service/** #第一个前缀就是你要发布出去的服务API名称 可以自定义 通过过滤器删掉就行
     *           filters:
     *             - StripPrefix=1
     *             - MyCustom=key1,key2,key3,value4 #自定义局部过滤器 类名：MyCustomFilterGatewayFilterFactory
     */
    static public class Config {
        private String param;
        private String param2;
        private String param3;
        private String param4;

        public String getParam2() {
            return param2;
        }

        public void setParam2(String param2) {
            this.param2 = param2;
        }

        public String getParam3() {
            return param3;
        }

        public void setParam3(String param3) {
            this.param3 = param3;
        }

        public String getParam4() {
            return param4;
        }

        public void setParam4(String param4) {
            this.param4 = param4;
        }

        public String getParam() {
            return param;
        }

        public void setParam(String param) {
            this.param = param;
        }
    }


}

切面代码：

@Aspect
@Component
public class mycustomInterceptor {

    /**
     * 定义一个切面点
     * 方法执行順序 先执行around方法
     * 在执行point.proceed();之前去执行before通知方法，然后执行point.proceed()方法，
     * 然后再执行afterreturn通知方法
     * execution( * com.zg.filter..*(..))参数说明
     *            切面点的方法返回值 （*指所有）
     *              包名
     *                           ..代表该包以及该包下的所有子包
     *                             *表示匹配所有方法
     *                              （..）两个..表示所有参数
     *  例如精准指定一个类的一个方法作为切面点
     *  execution(* com.zg.filter.MyCustomGatewayFilterFactory.apply(..)) 这个切面点就是
     *  com.zg.filter包下的MyCustomGatewayFilterFactory类的apply方法
     * )
     */
//    @Pointcut("execution( * com.zg.filter..*(..))")
    @Pointcut("execution( * com.zg.filter.MyCustomGatewayFilterFactory.apply(..))")
    public void pointCut(){}



    /**
     * 在切面点执行一个环绕方法
     */
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint point) {
        System.out.println("进入切面点的环绕方法");
        MethodSignature method = (MethodSignature)point.getSignature();
        System.out.println("method:" + method.getName());
        Class cl = point.getClass();
        System.out.println("class:" + cl.getName());
        Object[] objects = point.getArgs();
        for (Object ob : objects) {
            System.out.println("参数："+ob);
        }
        try {
            Object result = point.proceed();
            System.out.println("执行切面点监控的方法");
            return result;
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return true;
    };

    @Before("pointCut()")
    public void before(JoinPoint point) {
        System.out.println("进入切面点的before方法");
        MethodSignature method = (MethodSignature)point.getSignature();
        System.out.println("method:" + method.getName());
        Class cl = point.getClass();
        System.out.println("class:" + cl.getName());
        Object[] objects = point.getArgs();
        for (Object ob : objects) {
            System.out.println("参数："+ob);
        }

    }

    @AfterReturning("pointCut()")
    public void after(JoinPoint point) {
        System.out.println("进入切面点的after方法");
        MethodSignature method = (MethodSignature)point.getSignature();
        System.out.println("method:" + method.getName());
        Class cl = point.getClass();
        System.out.println("class:" + cl.getName());
        Object[] objects = point.getArgs();
        for (Object ob : objects) {
            System.out.println("参数："+ob);
        }

    }
}

可参考：拦截器https://www.cnblogs.com/dw3306/p/9779431.html

https://www.jb51.net/program/320972wdq.htm

https://www.jb51.net/program/320997n63.htm

https://www.jb51.net/program/320905ak0.htm

https://www.jb51.net/program/32095909f.htm