java通过反射获取加了某个注解的所有的类

Posted 2023-03-19

一、前言

有时候我们会碰到这样的情况：

有n个场景，每个场景都有自己的逻辑，即n个处理逻辑，

这时候我们就需要通过某个参数的值代表这n个场景，然后去加载每个场景不同的bean对象，即不同的类，这些类中都有一个同名的方法，但是里面的逻辑不同，类似策略模式、工厂模式等

假设这样的场景，银行卡分几种类型，比如普通会员，黄金会员，黑卡会员......

普通会员、黄金会员和黑卡的权限不一样，消费能力不一样等等内容，这里我们就以消费的能力举例，普通会员只能转账5万元，黄金只能转账20万元，黑卡100万元，

我们有3各类，分别是Putong.class，Huangjin.class，Heika.class，这三个类里面有一个同样的方法，名字叫：checkPermissions()方法，三个类上都加了一个自定义注解@MemberTypeDefinition

二、代码demo参考

1、自定义注解

package com.zygxsq.test;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解
 *
 **/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MemberTypeDefinition 
    /**
     * 数据源默认执行方法
     */
    public static final String DEFAULT_DAO_METHOD_NAME = "checkPermissions";

    /**
     * 数据源执行的方法名称, 默认为getData, 该方法必须只有一个参数@link BaseDataSpec, 返回结果必须是@link BaseResult, 可见性必须是public
     *
     * @return 方法名称
     */
    String value() default DEFAULT_DAO_METHOD_NAME;

2、基础model类

Putong.class

package com.zygxsq.test;

import org.springframework.stereotype.Component;

/**
 * 普通会员处理逻辑
 *
 **/
@MemberTypeDefinition
@Slf4j
@Component
public class Putong 


    public BaseResult checkPermissions(BaseDataSpec baseDataSpec) 
        // 省略中间的一些处理逻辑
        // ......
        // 省略中间的一些处理逻辑

        // 最后封装返回结果
        BaseResult baseResult = new BaseResult();
        baseResult.setResponse("我是普通会员");
        return baseResult;
    

Huangjin.class

package com.zygxsq.test;

import org.springframework.stereotype.Component;

/**
 * 黄金会员处理逻辑
 *
 **/
@MemberTypeDefinition
@Slf4j
@Component
public class Huangjin 

    public BaseResult checkPermissions(BaseDataSpec baseDataSpec) 
        // 省略中间的一些处理逻辑
        // ......
        // 省略中间的一些处理逻辑

        // 最后封装返回结果
        BaseResult baseResult = new BaseResult();
        baseResult.setResponse("我是黄金会员");
        return baseResult;
    

Heika.class

package com.zygxsq.test;

import org.springframework.stereotype.Component;

/**
 * 黑卡会员处理逻辑
 *
 **/
@MemberTypeDefinition
@Slf4j
@Component
public class Heika 


    public BaseResult checkPermissions(BaseDataSpec baseDataSpec) 
        // 省略中间的一些处理逻辑
        // ......
        // 省略中间的一些处理逻辑

        // 最后封装返回结果
        BaseResult baseResult = new BaseResult();
        baseResult.setResponse("我是黑卡会员");
        return baseResult;
    

3、入参和返回参数对象

入参对象

package com.zygxsq.test;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

import java.io.Serializable;
import java.util.List;

/**
 * 入参数据对象
 *
 **/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class BaseDataSpec implements Serializable 

    /**
     * serialVersionUID
     */
    private static final long serialVersionUID = -5669150877852962345L;

    /**
     * id
     */
    private String id;

    /**
     * 名字
     */
    private String name;

返回结果对象

package com.zygxsq.test;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * 返回结果对象
 *
 **/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class BaseResult implements Serializable 
    /**
     * serialVersionUID
     */
    private static final long serialVersionUID = 7510262928468530569L;

    private String response;

4、反射核心代码

那如何通过反射进行加载呢，BaseDataAnnotationApplication.class

package com.zygxsq.test;

import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Map;

/**
 * 启动加载
 *
 **/
@Slf4j
@Component
public class BaseDataAnnotationApplication implements ApplicationContextAware, InitializingBean 
    private ApplicationContext applicationContext;
    /**
     * <className,V>
     */
    private final Map<String, Object> loadMap = Maps.newConcurrentMap();
    /**
     * 特殊人群表缓存 <id,1> ,获取 SpecialPeople.class里面所有的表名
     */
    public static Map<String,Object> dmTablesMap = Maps.newConcurrentMap();

    @Override
    public void afterPropertiesSet() throws Exception 
        // 获取加了 MemberTypeDefinition 注解的源表bean
        loadSourceDefinition();
        // 获取SpecialPeople.class里面所有的表名
        loadSpecialMap();
    

    private void loadSourceDefinition() throws Exception
        Map<String, Object> beans = applicationContext.getBeansWithAnnotation(MemberTypeDefinition.class);
        for (final Object serviceObject : beans.values()) 

            final Class<? extends Object> calcuteClass = serviceObject.getClass();
            MemberTypeDefinition annotation = calcuteClass.getAnnotation(MemberTypeDefinition.class);
            if (null == annotation) 
                log.error("类：  注解缺失", calcuteClass);
                continue;
            

            loadMap.put(calcuteClass.getName(), serviceObject);
        
    

    /**
     * 获取SpecialPeople.class里面所有的表名
     * @throws Exception
     */
    private void loadSpecialMap() throws Exception 
        dmTablesMap = Maps.newConcurrentMap();
        Field[] declaredFields = SpecialPeople.class.getDeclaredFields();
        for (Field declaredField : declaredFields) 
            Class<?> type = declaredField.getType();
            String typeName = declaredField.getGenericType().getTypeName();
            Class<?> aClass = Class.forName(typeName);
            if (type == People.class) 
                People people = (People) declaredField.get(aClass);
                String id = people.getId().trim();
                dmTablesMap.put(id, "1");
            
        
    

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException 
        this.applicationContext = applicationContext;
    

    public <T> BaseResult buildData(Class<T> clazz, BaseDataSpec baseDataSpec) throws Exception
        // 获取执行方法名, 默认为getData
        String methodName;
        MemberTypeDefinition annotation = clazz.getAnnotation(MemberTypeDefinition.class);
        if (annotation == null || StringUtils.isBlank(annotation.value())) 
            methodName = MemberTypeDefinition.DEFAULT_DAO_METHOD_NAME;
         else 
            methodName = annotation.value();
        
        Method method;
        Object bean = loadMap.get(clazz.getName());
        BaseResult result = null;
        try 
            method = bean.getClass().getMethod(methodName, BaseDataSpec.class);
            result = (BaseResult) method.invoke(bean, baseDataSpec);
         catch (NoSuchMethodException e) 
            throw new Exception(clazz.getName()+"未找到执行方法："+methodName);
         catch (Exception e2) 
            throw new Exception(clazz.getName()+"未找到执行方法："+methodName);
        
        return result;
    

    public <T> BaseResult buildData(Class<?> sourceClass) 
        return null;
    

通过上面的application，就可以加对象加载到缓存里了，然后我们直接调用即可

5、测试接口

package com.zygxsq.test;

import com.zygxsq.test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/users")
public class TestController 
    @Autowired
    private BaseDataAnnotationApplication baseDataAnnotationApplication;

    @RequestMapping("/getUserType")
    public String getUserType() 
        // ...
        // 省略查询表等逻辑
        // ...
        Class<test.Putong> putongClass = Putong.class;
        BaseDataSpec baseDataSpec = BaseDataSpec.builder()
                .id("888888")
                .build();
        BaseResult baseResult = baseDataAnnotationApplication.buildData(putongClass,baseDataSpec);
        String response = baseResult.getResponse();
        System.out.println(response);
        return response;
    

6、代码结构

所有代码结构，大致是这样，具体的一些代码可以放在不同的package下面，我这里仅仅是让大家可以直观的看到有这些类

Java的自定义注解及通过反射获取注解

一、注解基本知识

　　1、元注解：@Retention @Target @Document @Inherited

　　2、Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口。

　　3、参数成员只能用public或默认(default)这两个访问权修饰

　　4、参数成员只能用基本类型byte，short，char，int，long，float，double，boolean八种基本数据类型和String、Enum、Class、annotations等数据类型，以及这一些类型的数组。

　　5、要获取类、方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation对象,除此之外没有别的获取注解对象的方法

　　6、注解也可以没有定义成员, 不过这样注解就没啥用了，只起到标识作用

 

自定义注解类时, 可以指定目标 (类、方法、字段, 构造函数等) , 注解的生命周期(运行时,class文件或者源码中有效), 是否将注解包含在javadoc中及是否允许子类继承父类中的注解, 具体如下：

　　1、@Target 表示该注解目标,可能的 ElemenetType 参数包括：

　　　　ElemenetType.CONSTRUCTOR 构造器声明
　　　　ElemenetType.FIELD 域声明(包括 enum 实例)
　　　　ElemenetType.LOCAL_VARIABLE 局部变量声明
　　　　ElemenetType.METHOD 方法声明
　　　　ElemenetType.PACKAGE 包声明
　　　　ElemenetType.PARAMETER 参数声明
　　　　ElemenetType.TYPE 类，接口(包括注解类型)或enum声明

　　2、@Retention 表示该注解的生命周期,可选的 RetentionPolicy 参数包括

　　　　RetentionPolicy.SOURCE 注解将被编译器丢弃
　　　　RetentionPolicy.CLASS 注解在class文件中可用，但会被JVM丢弃
　　　　RetentionPolicy.RUNTIME JVM将在运行期也保留注释，因此可以通过反射机制读取注解的信息

　　3、@Documented 指示将此注解包含在 javadoc 中

　　4、@Inherited 指示允许子类继承父类中的注解

二、在java中的使用

　　2.1、定义注解

package annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

public class MyAnnotation {
    /**
     * 注解类
     * 
     * @author suguoliang
     *
     */
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyClassAnnotation {
        String uri();

        String desc();
    }

    /**
     * 构造方法注解
     * 
     * @author suguoliang
     *
     */
    @Target(ElementType.CONSTRUCTOR)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyConstructorAnnotation {
        String uri();

        String desc();
    }

    /**
     * 方法注解
     * 
     * @author suguoliang
     *
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyMethodAnnotation {
        String uri();

        String desc();
    }

    /**
     * 字段注解
     * 
     * @author suguoliang
     *
     */
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyFieldAnnotation {
        String uri();

        String desc();
    }

    /**
     * 可以同时应用到类和方法上
     * 
     * @author 尐蘇
     *
     */
    @Target({ ElementType.TYPE, ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyClassAndMethodAnnotation {
        // 定义枚举
        public enum EnumType {
            util, entity, service, model
        }

        // 设置默认值
        public EnumType classType() default EnumType.util;

        // 数组
        int[] arr() default { 3, 7, 5 };

        String color() default "blue";
    }
}

　　2.2基本测试

package annotation;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import annotation.MyAnnotation.MyClassAndMethodAnnotation;
import annotation.MyAnnotation.MyClassAndMethodAnnotation.EnumType;
import annotation.MyAnnotation.MyClassAnnotation;
import annotation.MyAnnotation.MyConstructorAnnotation;
import annotation.MyAnnotation.MyFieldAnnotation;
import annotation.MyAnnotation.MyMethodAnnotation;

@MyClassAnnotation(desc = "The Class", uri = "com.sgl.annotation")
@MyClassAndMethodAnnotation(classType = EnumType.util)
public class TestAnnotation {
    @MyFieldAnnotation(desc = "The Class Field", uri = "com.sgl.annotation#id")
    private String id;

    @MyConstructorAnnotation(desc = "The Class Constructor", uri = "com.sgl.annotation#constructor")
    public TestAnnotation() {
    }

    public String getId() {
        return id;
    }

    @MyMethodAnnotation(desc = "The Class Method", uri = "com.sgl.annotation#setId")
    public void setId(String id) {
        this.id = id;
    }

    @MyMethodAnnotation(desc = "The Class Method sayHello", uri = "com.sgl.annotation#sayHello")
    public void sayHello(String name) {
        if (name == null || name.equals("")) {
            System.out.println("hello world!");
        } else {
            System.out.println(name + "\t:say hello world");
        }
    }

    public static void main(String[] args) throws Exception {
        Class<TestAnnotation> clazz = TestAnnotation.class;
        // 获取类注解
        MyClassAnnotation myClassAnnotation = clazz.getAnnotation(MyClassAnnotation.class);
        System.out.println(myClassAnnotation.desc() + "+" + myClassAnnotation.uri());

        // 获得构造方法注解
        Constructor<TestAnnotation> constructors = clazz.getConstructor(new Class[] {});// 先获得构造方法对象
        MyConstructorAnnotation myConstructorAnnotation = constructors.getAnnotation(MyConstructorAnnotation.class);// 拿到构造方法上面的注解实例
        System.out.println(myConstructorAnnotation.desc() + "+" + myConstructorAnnotation.uri());

        // 获得方法注解
        Method method = clazz.getMethod("setId", new Class[] { String.class });// 获得方法对象
        MyMethodAnnotation myMethodAnnotation = method.getAnnotation(MyMethodAnnotation.class);
        System.out.println(myMethodAnnotation.desc() + "+" + myMethodAnnotation.uri());

        // 获得字段注解
        Field field = clazz.getDeclaredField("id");// 暴力获取private修饰的成员变量
        MyFieldAnnotation myFieldAnnotation = field.getAnnotation(MyFieldAnnotation.class);
        System.out.println(myFieldAnnotation.desc() + "+" + myFieldAnnotation.uri());
    }
}

　　2.3通过反射解析

package annotation;

import java.lang.reflect.Method;
import java.util.Arrays;

import annotation.MyAnnotation.MyClassAndMethodAnnotation;
import annotation.MyAnnotation.MyClassAndMethodAnnotation.EnumType;
import annotation.MyAnnotation.MyClassAnnotation;
import annotation.MyAnnotation.MyMethodAnnotation;

public class ParseAnnotation {
    /**
     * 解析方法注解
     * 
     * @param clazz
     */
    public static <T> void parseMethod(Class<T> clazz) {
        try {
            T obj = clazz.newInstance();
            for (Method method : clazz.getDeclaredMethods()) {
                MyMethodAnnotation methodAnnotation = method.getAnnotation(MyMethodAnnotation.class);
                if (methodAnnotation != null) {
                    // 通过反射调用带有此注解的方法
                    method.invoke(obj, methodAnnotation.uri());
                }
                MyClassAndMethodAnnotation myClassAndMethodAnnotation = method
                        .getAnnotation(MyClassAndMethodAnnotation.class);
                if (myClassAndMethodAnnotation != null) {
                    if (EnumType.util.equals(myClassAndMethodAnnotation.classType())) {
                        System.out.println("this is a util method");
                    } else {
                        System.out.println("this is a other method");
                    }
                    System.out.println(Arrays.toString(myClassAndMethodAnnotation.arr()));// 打印数组
                    System.out.println(myClassAndMethodAnnotation.color());// 输出颜色
                }
                System.out.println("\t\t-----------------------");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static <T> void parseType(Class<T> clazz) {
        try {
            MyClassAndMethodAnnotation myClassAndMethodAnnotation = clazz
                    .getAnnotation(MyClassAndMethodAnnotation.class);
            if (myClassAndMethodAnnotation != null) {
                if (EnumType.util.equals(myClassAndMethodAnnotation.classType())) {
                    System.out.println("this is a util class");
                } else {
                    System.out.println("this is a other class");
                }
            }
            MyClassAnnotation myClassAnnotation = clazz.getAnnotation(MyClassAnnotation.class);
            if (myClassAnnotation != null) {
                System.err.println(" class info: " + myClassAnnotation.uri());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        parseMethod(TestAnnotation.class);
        parseType(TestAnnotation.class);
    }
}