正文

java 自定义注解

Java注解又称Java标注，是Java语言5.0版本开始支持加入源代码的特殊语法元数据。为我们在代码中添加信息提供了一种形式化的方法，使我们可以在稍后某个时刻非常方便的使用这些数据。
Java语言中的类、方法、变量、参数和包等都可以被标注。和Javadoc不同，Java标注可以通过反射获取注解内容。在编译器生成类文件时，注解可以被嵌入到字节码中。Java虚拟机可以保留注解内容，在运行时可以获取到注解内容

内置注解

Java 定义了一套注解，共有 7 个，3 个在 java.lang 中，剩下 4 个在 java.lang.annotation 中。
1、作用在代码的注解是

1
2
3

@Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
@Deprecated - 标记过时方法。如果使用该方法，会报编译警告。
@SuppressWarnings - 指示编译器去忽略注解中声明的警告。

2、作用在其他注解的注解(或者说元注解)是:

@Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。
@Documented - 标记这些注解是否包含在用户文档中。
@Target - 标记这个注解应该是哪种 Java 成员。
@Inherited - 标记这个注解是继承于哪个注解类(默认 注解并没有继承于任何子类)

3、从 Java 7 开始，额外添加了 3 个注解:

1
2
3

@SafeVarargs - Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
@FunctionalInterface - Java 8 开始支持，标识一个匿名函数或函数式接口。
@Repeatable - Java 8 开始支持，标识某注解可以在同一个声明上使用多次。

元注解

1、@Retention
@Retention annotation指定标记注释的存储方式：

1
2
3

RetentionPolicy.SOURCE - 标记的注释仅保留在源级别中，并由编译器忽略。
RetentionPolicy.CLASS - 标记的注释在编译时由编译器保留，但Java虚拟机（JVM）会忽略。
RetentionPolicy.RUNTIME - 标记的注释由JVM保留，因此运行时环境可以使用它。

2、@Documented
@Documented 注释表明，无论何时使用指定的注释，都应使用Javadoc工具记录这些元素。（默认情况下，注释不包含在Javadoc中。）有关更多信息，请参阅 Javadoc工具页面。
3、@Target
@Target 注释标记另一个注释，以限制可以应用注释的Java元素类型。目标注释指定以下元素类型之一作为其值

ElementType.TYPE 可以应用于类的任何元素。
ElementType.FIELD 可以应用于字段或属性。
ElementType.METHOD 可以应用于方法级注释。
ElementType.PARAMETER 可以应用于方法的参数。
ElementType.CONSTRUCTOR 可以应用于构造函数。
ElementType.LOCAL_VARIABLE 可以应用于局部变量。
ElementType.ANNOTATION_TYPE 可以应用于注释类型。
ElementType.PACKAGE 可以应用于包声明。
ElementType.TYPE_PARAMETER
ElementType.TYPE_USE

4、@Inherited
@Inherited 注释表明注释类型可以从超类继承。当用户查询注释类型并且该类没有此类型的注释时，将查询类的超类以获取注释类型（默认情况下不是这样）。此注释仅适用于类声明。
5、@Repeatable
Repeatable Java SE 8中引入的，@Repeatable注释表明标记的注释可以多次应用于相同的声明或类型使用(即可以重复在同一个类、方法、属性等上使用)。

自定义注解

现在有一个场景,比如有一些线程类需要放在线程池中运行,如果有多个消费者,那么这段代码就会复制几遍,我们可以利用自定义注解,在需要放入线程池中运行的类上注解,扫描这个注解,循环调用这段代码

1
2
3

ExecutorService PROGRAM_THREAD_POOL = Executors.newFixedThreadPool(10);
List<ProgramConsumer> programEventsList = IntStream.range(0, 10).mapToObj(i -> new ProgramConsumer(EventType.PROGRAM)).collect(Collectors.toList());
programEventsList.forEach(PROGRAM_THREAD_POOL::submit);0

添加自定义注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface StartConsumer {

    String value() default "null";
    EventType type();
}

注意这里 type 并没有添加默认值,所以这个注解在使用的时候一定要注入这个值,另外一个 value 表示从配置文件中获取的该线程的启动个数

@Slf4j
@StartConsumer(type = EventType.PROGRAM,value = "programNumberThreads")
public class ProgramConsumer extends Consumer {

    public ProgramConsumer(EventType eventType) {
        super(eventType);
    }

    @Override
    protected boolean staticize(EpgPublishEventDetail obj) {
        log.info("program staticize start");
        return true;
    }
}

扫描注解类,这里利用的是 reflections 工具类,适合没有交给 spring 管理得类
引入依赖

<dependency>
    <groupId>org.reflections</groupId>
    <artifactId>reflections</artifactId>
    <version>0.9.11</version>
</dependency>

实例

@Component
@Slf4j
@Order(1)
public class ConsumerStart implements ApplicationRunner {

    @Autowired
    private Environment env;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("event consumer start");
        Reflections reflections = new Reflections("com.utstar.emc.executor.consumer");
        Set<Class<?>> set = reflections.getTypesAnnotatedWith(StartConsumer.class);
        List<ConsumerInit> consumerInitList = new ArrayList<>();
        for (Class<?> c : set) {
            final StartConsumer annotation = c.getAnnotation(StartConsumer.class);
            Constructor constructor = c.getConstructor(EventType.class);
            String threadsProperty = annotation.value();
            String threads = env.getProperty(threadsProperty);
            //默认为10
            int threadsInt = 10;
            if (StringUtils.isNotBlank(threads)) {
                try {
                    threadsInt = Integer.parseInt(threads);
                } catch (Exception e) {
                    log.error("[{}] property is error,is not number", threadsProperty);
                }
            }
            ExecutorService THREAD_POOL = Executors.newFixedThreadPool(threadsInt);
            List<Consumer> consumers = IntStream.range(0, threadsInt).mapToObj(i -> {
                try {
                    return (Consumer) constructor.newInstance(annotation.type());
                } catch (Exception e) {
                    e.printStackTrace();
                    return null;
                }
            }).collect(Collectors.toList());
            ConsumerInit consumerInit = new ConsumerInit(annotation.type().name(), consumers, THREAD_POOL);
            consumerInitList.add(consumerInit);
        }
        for (ConsumerInit consumerInit : consumerInitList) {
            log.info("type [{}] event consumer start,has [{}] threads", consumerInit.type,consumerInit.consumer.size());
            consumerInit.consumer.forEach(consumerInit.executorService::submit);
            log.info("type [{}] event consumer end,has [{}] threads", consumerInit.type,consumerInit.consumer.size());
        }
    }

    static final class ConsumerInit {
        private final String type;
        private final List<Consumer> consumer;
        private final ExecutorService executorService;

        public ConsumerInit(String type, List<Consumer> consumer, ExecutorService executorService) {
            this.type = type;
            this.consumer = consumer;
            this.executorService = executorService;
        }
    }
}

如果是springboot环境,可以利用 ApplicationContext 拿到,当然前提是你的这个类是交给 spring 管理的,这里有一个应用:

1	Map<String,Object> beans = event.getApplicationContext().getBeansWithAnnotation(OnsConsumer.class);

springboot+Aop+自定义注解实现日志记录

参考资料

https://blog.csdn.net/yuruixin_china/article/details/88827401 springboot扫描自定义类注解、方法注解
https://blog.csdn.net/u010928589/article/details/90293703 自定义spring boot-starter,实现自动配置,自定义注解扫描注入(类似dubbo-starter)