Interception de méthode (AOP)


L'AOP du framework YMP est basé sur l'interception implémentée par le MethodInterceptor de CGLIB. Il est configuré à travers les annotations suivantes :

  • @Before : utilisé pour définir le pré-intercepteur d'une classe ou d'une méthode, et déclarer le pré-intercepteur. -intercepteur sur la classe Sera appliqué à toutes les méthodes de la classe ;

  • @After : utilisé pour définir le post-intercepteur d'une classe ou d'une méthode. Le post-intercepteur déclaré sur la classe sera appliqué à toutes les méthodes de. la classe ;

  • @Clean : utilisé pour nettoyer tous les intercepteurs spécifiés sur la classe, les intercepteurs nettoyés ne seront pas exécutés

  • @ContextParam : utilisé pour définir les paramètres de contexte, principalement utilisé pour transmettre des paramètres à l'intercepteur ; Configuration ;

  • @Ignored : La déclaration d'une méthode ignorera toutes les configurations de l'intercepteur ;

Description :

La déclaration des méthodes annotées @Ignored, des méthodes non publiques, des méthodes de classe Object et des méthodes surchargées de classe Object ne sera pas gérée par l'intercepteur.

Exemple 1 : 

    // 创建自定义拦截器
    public class DemoInterceptor implements IInterceptor {
        public Object intercept(InterceptContext context) throws Exception {
            // 判断当前拦截器执行方向
            switch (context.getDirection()) {
                // 前置
                case BEFORE:
                    System.out.println("before intercept...");
                    // 获取拦截器参数
                    String _param = context.getContextParams().get("param");
                    if (StringUtils.isNotBlank(_param)) {
                        System.out.println(_param);
                    }
                    break;
                // 后置
                case AFTER:
                    System.out.println("after intercept...");
            }
            return null;
        }
    }

    @Bean
    public class TestDemo {

        @Before(DemoInterceptor.class)
        public String beforeTest() {
            return "前置拦截测试";
        }

        @After(DemoInterceptor.class)
        public String afterTest() {
            return "后置拦截测试";
        }

        @Before(DemoInterceptor.class)
        @After(DemoInterceptor.class)
        @ContextParam({
                @ParamItem(key = "param", value = "helloworld")
            })
        public String allTest() {
            return "拦截器参数传递";
        }

        public static void main(String[] args) throws Exception {
            YMP.get().init();
            try {
                TestDemo _demo = YMP.get().getBean(TestDemo.class);
                _demo.beforeTest();
                _demo.afterTest();
                _demo.allTest();
            } finally {
                YMP.get().destroy();
            }
        }
    }

Exemple 2 : 

    @Bean
    @Before(DemoInterceptor.class)
    @ContextParam({
            @ParamItem(key = "param", value = "helloworld")
        })
    public class TestDemo {

        public String beforeTest() {
            return "默认前置拦截测试";
        }

        @After(DemoInterceptor.class)
        public String afterTest() {
            return "后置拦截测试";
        }

        @Clean
        public String cleanTest() {
            return "清理拦截器测试";
        }

        public static void main(String[] args) throws Exception {
            YMP.get().init();
            try {
                TestDemo _demo = YMP.get().getBean(TestDemo.class);
                _demo.beforeTest();
                _demo.afterTest();
                _demo.cleanTest();
            } finally {
                YMP.get().destroy();
            }
        }
    }

Remarque : @ContextParamL'attribut value de l'annotation permet d'obtenir la valeur de xxx à partir des paramètres globaux du framework via le format de $xxx