【Java】——自定义注解对参数进行校验、spring扫描自定义注解

矫情吗；* 2022-05-20 03:13 271阅读 0赞

# 前提 #

上篇博客中详细介绍自定义注解的使用，本文主要是对自定义注解的进一步深入。会使用CGLIb进行动态代理来完成对方法参数是否为空的判断，以及再spring中如何扫描自定义注解

# 自定义注解对方法参数为空校验 #

# 为什么要用动态代理？ #

因为Java的反射拿不到参数的相关信息，对方法参数进行校验，肯定是要在方法执行前进行校验，所以就需要动态代理来完成。对真实的对象进行代理，让代理对象执行参数校验这一部分的操作。

## 1、自定义注解 ##

@Target({ElementType.FIELD,ElementType.METHOD,ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation {
        String msg() default "参数不能为空";
    }

## 2、代理类以及校验方法 ##

import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    import java.lang.reflect.Parameter;
    
    public class HelloServiceCgLib implements MethodInterceptor {
        private Class target;
    
        public Object getInstance(Class target) {
            this.target = target;
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(this.target);
            enhancer.setCallback(this);
            return enhancer.create();
        }
    
        @Override
        public Object intercept(Object object, Method method, Object[] objects, MethodProxy proxy) throws Throwable {
            System.out.println("我是CGLIB的动态代理");
            System.out.println("我准备执行了");
            if (!check(method,objects)) {
                System.out.println("我没能成功执行");
                return false;
            }
                Object returnObj = proxy.invokeSuper(object, objects);
                System.out.println("我已经正确执行过了");
                return returnObj;
        }
    
        /**
         * 对参数校验的方法
         * @param method 目标方法
         * @param objects 相关参数值
         * @return
         */
        public  boolean check(Method method,Object[] objects)  {
            Parameter[] parameters = method.getParameters();
            for (int i = 0; i <parameters.length; i++) {
               Parameter parameter = parameters[i];
                if (parameter.isAnnotationPresent(MyAnnotation.class)) {
                    MyAnnotation annotation = parameter.getAnnotation(MyAnnotation.class);
                    if (objects==null ||objects[i]==null) {
                        System.out.println(parameter.getName()+annotation.msg());
                        return false;
                    }
                }
            }
            return true;
        }
    }

## 3、真实类 ##

public class Hello {
        public void sayHello(@MyAnnotation String name,@MyAnnotation String start) {
            System.out.println("hello "+name);
            System.out.println(start);
        }
    }

## 4、调用过程 ##

public class AnnotationTest {
        public static void main(String[] args) {
                    HelloServiceCgLib helloServiceCgLib = new HelloServiceCgLib();
            Hello proxy = (Hello) helloServiceCgLib.getInstance(Hello.class);
            proxy.sayHello("world",null);
        }

## 5、执行结果 ##

![70][]

对第二个参数进行拦截，判断为空，阻止方法的非正常执行。

# spring扫描自定义注解 #

在使用Spring的时候需要自定义annotation来满足项目需求。

在Bean初始化的过程都会调用BeanPostProcessor接口即Spring中的后置处理器，这个接口是Spring IOC容器给我们提供扩展接口，方便在Spring容器中完成bean实例化，配置以及其他初始化方法前后添加一些自己处理的逻辑。

在bean创建好之后都会调用后置处理器的postProcessAfterInitialization方法，所以可以利用自定义这个方法，达到让spring扫描自定义注解的目的。

## 1、自定义注解 ##

@Target({ElementType.FIELD,ElementType.METHOD,ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyListener {
        String value() default "spring";
    }

## 2、配置spring扫描 ##

@Component
    public class MyListenerProcessor implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            Method[] methods = ReflectionUtils.getAllDeclaredMethods(bean.getClass());
            if (methods != null) {
                for (Method method : methods) {
                    MyListener myListener = AnnotationUtils.findAnnotation(method, MyListener.class);
                    // process
                    if (myListener != null) {
                        System.out.println(method.getName());
                        System.out.println(myListener.value());
                    }
    
                }
            }
            return bean;
        }
    }

## 3、配置要扫描的方法 ##

@Service
    public class MyService {
    
        @MyListener
        public void onMessage() {
            System.out.println("我被调用了");
        }
    }

## 4、初始化，判断spring是否正确扫描注解 ##

public class Main {
        public static void main(String[] args) {
            AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
            MyService bean = ac.getBean(MyService.class);}
        }

## 5、注解被spring扫描到了 ##

![70 1][]

# 总结 #

通过对自定义注解的使用可以很好加深对动态代理这些概念的认识，对spring框架的理解同样可以更进一步。

[70]: /images/20220520/cd7c85c0146e4af28f67208e42947b90.png
[70 1]: /images/20220520/d9378a72eb5644ffa148639c91701b4e.png