Java8: @Repeatable注解原理和使用技巧

最新推荐文章于 2024-05-06 18:26:10 发布
最新推荐文章于 2024-05-06 18:26:10 发布
阅读量1k 收藏 4
点赞数 5
分类专栏： 琦彦の百宝箱 回归JAVA 文章标签： java 注解 Repeatable 重复
原文链接：https://www.zyc.red/Java/Annotation/Repeatable%E6%B3%A8%E8%A7%A3/
版权

目录

前言

Spring 中 @PropertySources 与 @PropertySource区别是?

@PropertySources

@PropertySource

应用场景

原理

问题来了

推荐方式

前言

@Repeatable是java8为了解决同一个注解, 不能重复在同一类/方法/属性上使用的问题。

也就是说该注解可以重复的注解某个元素。

 

 

Spring 中 @PropertySources 与 @PropertySource区别是?

@PropertySources

/*
 * Copyright 2002-2014 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.context.annotation;

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

/**
 * Container annotation that aggregates several {@link PropertySource} annotations.
 *
 * <p>Can be used natively, declaring several nested {@link PropertySource} annotations.
 * Can also be used in conjunction with Java 8's support for <em>repeatable annotations</em>,
 * where {@link PropertySource} can simply be declared several times on the same
 * {@linkplain ElementType#TYPE type}, implicitly generating this container annotation.
 *
 * @author Phillip Webb
 * @since 4.0
 * @see PropertySource
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PropertySources {

	PropertySource[] value();

}

@PropertySource

package org.springframework.context.annotation;

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

import org.springframework.core.io.support.PropertySourceFactory;

/**
 * Annotation providing a convenient and declarative mechanism for adding a
 * {@link org.springframework.core.env.PropertySource PropertySource} to Spring's
 * {@link org.springframework.core.env.Environment Environment}. To be used in
 * conjunction with @{@link Configuration} classes.
 *
 * <h3>Example usage</h3>
 *
 * <p>Given a file {@code app.properties} containing the key/value pair
 * {@code testbean.name=myTestBean}, the following {@code @Configuration} class
 * uses {@code @PropertySource} to contribute {@code app.properties} to the
 * {@code Environment}'s set of {@code PropertySources}.
 *
 * <pre class="code">
 * &#064;Configuration
 * &#064;PropertySource("classpath:/com/myco/app.properties")
 * public class AppConfig {
 *
 *     &#064;Autowired
 *     Environment env;
 *
 *     &#064;Bean
 *     public TestBean testBean() {
 *         TestBean testBean = new TestBean();
 *         testBean.setName(env.getProperty("testbean.name"));
 *         return testBean;
 *     }
 * }</pre>
 *
 * <p>Notice that the {@code Environment} object is
 * {@link org.springframework.beans.factory.annotation.Autowired @Autowired} into the
 * configuration class and then used when populating the {@code TestBean} object. Given
 * the configuration above, a call to {@code testBean.getName()} will return "myTestBean".
 *
 * <h3>Resolving <code>${...}</code> placeholders in {@code <bean>} and {@code @Value} annotations</h3>
 *
 * <p>In order to resolve ${...} placeholders in {@code <bean>} definitions or {@code @Value}
 * annotations using properties from a {@code PropertySource}, you must ensure that an
 * appropriate <em>embedded value resolver</em> is registered in the {@code BeanFactory}
 * used by the {@code ApplicationContext}. This happens automatically when using
 * {@code <context:property-placeholder>} in XML. When using {@code @Configuration} classes
 * this can be achieved by explicitly registering a {@code PropertySourcesPlaceholderConfigurer}
 * via a {@code static} {@code @Bean} method. Note, however, that explicit registration
 * of a {@code PropertySourcesPlaceholderConfigurer} via a {@code static} {@code @Bean}
 * method is typically only required if you need to customize configuration such as the
 * placeholder syntax, etc. See the "Working with externalized values" section of
 * {@link Configuration @Configuration}'s javadocs and "a note on
 * BeanFactoryPostProcessor-returning {@code @Bean} methods" of {@link Bean @Bean}'s
 * javadocs for details and examples.
 *
 * <h3>Resolving ${...} placeholders within {@code @PropertySource} resource locations</h3>
 *
 * <p>Any ${...} placeholders present in a {@code @PropertySource} {@linkplain #value()
 * resource location} will be resolved against the set of property sources already
 * registered against the environment. For example:
 *
 * <pre class="code">
 * &#064;Configuration
 * &#064;PropertySource("classpath:/com/${my.placeholder:default/path}/app.properties")
 * public class AppConfig {
 *
 *     &#064;Autowired
 *     Environment env;
 *
 *     &#064;Bean
 *     public TestBean testBean() {
 *         TestBean testBean = new TestBean();
 *         testBean.setName(env.getProperty("testbean.name"));
 *         return testBean;
 *     }
 * }</pre>
 *
 * <p>Assuming that "my.placeholder" is present in one of the property sources already
 * registered, e.g. system properties or environment variables, the placeholder will
 * be resolved to the corresponding value. If not, then "default/path" will be used as a
 * default. Expressing a default value (delimited by colon ":") is optional.  If no
 * default is specified and a property cannot be resolved, an {@code
 * IllegalArgumentException} will be thrown.
 *
 * <h3>A note on property overriding with @PropertySource</h3>
 *
 * <p>In cases where a given property key exists in more than one {@code .properties}
 * file, the last {@code @PropertySource} annotation processed will 'win' and override.
 *
 * <p>For example, given two properties files {@code a.properties} and
 * {@code b.properties}, consider the following two configuration classes
 * that reference them with {@code @PropertySource} annotations:
 *
 * <pre class="code">
 * &#064;Configuration
 * &#064;PropertySource("classpath:/com/myco/a.properties")
 * public class ConfigA { }
 *
 * &#064;Configuration
 * &#064;PropertySource("classpath:/com/myco/b.properties")
 * public class ConfigB { }
 * </pre>
 *
 * <p>The override ordering depends on the order in which these classes are registered
 * with the application context.
 *
 * <pre class="code">
 * AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
 * ctx.register(ConfigA.class);
 * ctx.register(ConfigB.class);
 * ctx.refresh();
 * </pre>
 *
 * <p>In the scenario above, the properties in {@code b.properties} will override any
 * duplicates that exist in {@code a.properties}, because {@code ConfigB} was registered
 * last.
 *
 * <p>In certain situations, it may not be possible or practical to tightly control
 * property source ordering when using {@code @PropertySource} annotations. For example,
 * if the {@code @Configuration} classes above were registered via component-scanning,
 * the ordering is difficult to predict. In such cases - and if overriding is important -
 * it is recommended that the user fall back to using the programmatic PropertySource API.
 * See {@link org.springframework.core.env.ConfigurableEnvironment ConfigurableEnvironment}
 * and {@link org.springframework.core.env.MutablePropertySources MutablePropertySources}
 * javadocs for details.
 *
 * <p><b>NOTE: This annotation is repeatable according to Java 8 conventions.</b>
 * However, all such {@code @PropertySource} annotations need to be declared at the same
 * level: either directly on the configuration class or as meta-annotations within the
 * same custom annotation. Mixing of direct annotations and meta-annotations is not
 * recommended since direct annotations will effectively override meta-annotations.
 *
 * @author Chris Beams
 * @author Juergen Hoeller
 * @author Phillip Webb
 * @author Sam Brannen
 * @since 3.1
 * @see PropertySources
 * @see Configuration
 * @see org.springframework.core.env.PropertySource
 * @see org.springframework.core.env.ConfigurableEnvironment#getPropertySources()
 * @see org.springframework.core.env.MutablePropertySources
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(PropertySources.class)
public @interface PropertySource {

	/**
	 * Indicate the name of this property source. If omitted, the {@link #factory()}
	 * will generate a name based on the underlying resource (in the case of
	 * {@link org.springframework.core.io.support.DefaultPropertySourceFactory}:
	 * derived from the resource description through a corresponding name-less
	 * {@link org.springframework.core.io.support.ResourcePropertySource} constructor).
	 * @see org.springframework.core.env.PropertySource#getName()
	 * @see org.springframework.core.io.Resource#getDescription()
	 */
	String name() default "";

	/**
	 * Indicate the resource location(s) of the properties file to be loaded.
	 * <p>Both traditional and XML-based properties file formats are supported
	 * &mdash; for example, {@code "classpath:/com/myco/app.properties"}
	 * or {@code "file:/path/to/file.xml"}.
	 * <p>Resource location wildcards (e.g. *&#42;/*.properties) are not permitted;
	 * each location must evaluate to exactly one {@code .properties} resource.
	 * <p>${...} placeholders will be resolved against any/all property sources already
	 * registered with the {@code Environment}. See {@linkplain PropertySource above}
	 * for examples.
	 * <p>Each location will be added to the enclosing {@code Environment} as its own
	 * property source, and in the order declared.
	 */
	String[] value();

	/**
	 * Indicate if failure to find the a {@link #value() property resource} should be
	 * ignored.
	 * <p>{@code true} is appropriate if the properties file is completely optional.
	 * Default is {@code false}.
	 * @since 4.0
	 */
	boolean ignoreResourceNotFound() default false;

	/**
	 * A specific character encoding for the given resources, e.g. "UTF-8".
	 * @since 4.3
	 */
	String encoding() default "";

	/**
	 * Specify a custom {@link PropertySourceFactory}, if any.
	 * <p>By default, a default factory for standard resource files will be used.
	 * @since 4.3
	 * @see org.springframework.core.io.support.DefaultPropertySourceFactory
	 * @see org.springframework.core.io.support.ResourcePropertySource
	 */
	Class<? extends PropertySourceFactory> factory() default PropertySourceFactory.class;

}

下面, 我们先从应用场景说起

应用场景

举一个比较贴近开发的例子，在spring/springboot我们引入资源文件可以使用注解@PropertySource

@PropertySource("classpath:sso.properties")
public class Application {
}

那要引入多个资源文件怎么办，没事，我把PropertySource中的value设置成String[]数组就行了

public @interface PropertySource {
      ...
      String[] value();
}

那么就能这么用

@PropertySource({"classpath:sso.properties","classpath:dubbo.properties","classpath:systemInfo.properties"})
public class Application {
}

就spring引入配置文件来讲，肯定是没事问题的。但是如果注解中2个值存在依赖关系，那么这样就不行了。比如下面这个

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
//@Repeatable(Validates.class)
public @interface Validate {

    /**
     * 业务类型
     * @return
     */
    String bizCode();

    /**
     * 订单类型
     * @return
     */
    int orderType();

}

我玩策略模式的时候喜欢用注解和spring结合做自动策略路由

上面的@validate注解，bizcode和orderType是一对一的关系，我希望可以添加如下的注解

@Validate(bizCode = "fruit",orderType = 1)
@Validate(bizCode = "fruit",orderType = 2)
@Validate(bizCode = "vegetable",orderType = 2)
public class BizLogic2 {
}

很抱歉在java8之前，这种方式不行，不过你可以这么做，新建一个如下的注解

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

    Validate[] value();

}

注意这个聚合注解默认约束value来存储子注解

然后对应代码修改如下

@Validates(value = {
        @Validate(bizCode = "fruit",orderType = 1),
        @Validate(bizCode = "fruit",orderType = 2),
        @Validate(bizCode = "vegetable",orderType = 2)
})
public class BizLogic2 {
}

在java8的@Repeatable出来之后，我们在不改动@Validates的情况下，对@Validate进行修改，增加@Repeatable(Validates.class)

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Repeatable(Validates.class)
public @interface Validate {

    /**
     * 业务类型
     * @return
     */
    String bizCode();

    /**
     * 订单类型
     * @return
     */
    int orderType();

}

那么就可以在类上使用多个@Validate注解了。

回过头来看下@PropertySource和@PropertySources也是如此

package org.springframework.context.annotation;

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

/**
 * Container annotation that aggregates several {@link PropertySource} annotations.
 *
 * <p>Can be used natively, declaring several nested {@link PropertySource} annotations.
 * Can also be used in conjunction with Java 8's support for <em>repeatable annotations</em>,
 * where {@link PropertySource} can simply be declared several times on the same
 * {@linkplain ElementType#TYPE type}, implicitly generating this container annotation.
 *
 * @author Phillip Webb
 * @since 4.0
 * @see PropertySource
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PropertySources {

	PropertySource[] value();

}

从上面的注释中可以看到，spring在4.0支持了java8这个特性

原理


/**
 * The annotation type {@code java.lang.annotation.Repeatable} is
 * used to indicate that the annotation type whose declaration it
 * (meta-)annotates is <em>repeatable</em>. The value of
 * {@code @Repeatable} indicates the <em>containing annotation
 * type</em> for the repeatable annotation type.
 *
 * @since 1.8
 * @jls 9.6 Annotation Types
 * @jls 9.7 Annotations
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Repeatable {
    /**
     * Indicates the <em>containing annotation type</em> for the
     * repeatable annotation type.
     * @return the containing annotation type
     */
    Class<? extends Annotation> value();
}

那么@Repeatable的原理是啥？

语法糖而已！

首先我们需要定一个容器注解来包含这个能够重复的注解，并且这个容器注解的必须拥有一个返回需要重复注解数组的value方法。

咋一看好像有点绕，其实Repeatable的原理和我们原先的实现方式是一样的，原先我们是在另一个注解的value方法显示的另一个返回注解数组，而使用Repeatable之后，我们则可以直接在元素上重复使用某个注解。

我们反编译下面代码

@Validates(value = {
        @Validate(bizCode = "fruit",orderType = 1),
        @Validate(bizCode = "fruit",orderType = 2),
        @Validate(bizCode = "vegetable",orderType = 2)
})
public class BizLogic2 {
}

和

@Validate(bizCode = "fruit", orderType = 1)
@Validate(bizCode = "fruit", orderType = 2)
@Validate(bizCode = "vegetable", orderType = 2)
public class BizLogic2 {
}

 发现反编译变成了

@Validates({@Validate(
    bizCode = "fruit",
    orderType = 1
), @Validate(
    bizCode = "fruit",
    orderType = 2
), @Validate(
    bizCode = "vegetable",
    orderType = 2
)})
public class BizLogic2 {
    public BizLogic2() {
    }
}

语法糖无疑了。

问题来了

那么再反编译下面代码试试

@Validate(bizCode = "fruit", orderType = 1)
public class BizLogic2 {
}

生成

@Validate(
    bizCode = "fruit",
    orderType = 1
)
public class BizLogic2 {
    public BizLogic2() {
    }
}

那这样就存在问题了，我以为加了@Repeatable之后@Validate都会生成被语法糖@Validates包裹。没想到它居然这么智能，只有一个@Validate注解的时候居然不转换。

其中有一些需要注意的细节，可重复注解最终是以另一个注解的value值的数组形式存在于class中的，所以此时通过反射的getDeclaredAnnotation方法获取可重复注解时，获取到的是容器注解。

同时如果元素上的可重复注解只有一个时，最终的class中重复注解并不会被存放到容器注解，而是以直接的形式存放在元素上，此时通过反射的getDeclaredAnnotation方法是能获取到该注解的，所以当我们使用反射获取可重复注解时需要额外的关注这些细节。

所以使用多个@Validate的时候就会留坑，你需要兼容1个或多个的场景。

推荐方式

直接使用@Validates读取注解代码如下

Validates validates = AnnotationUtils.getAnnotation(BizLogic2.class,Validates.class);
        Arrays.stream(validates.value()).forEach(a->{
            System.out.println(a.bizCode());
        });

带兼容的逻辑如下

Validate validate = AnnotationUtils.getAnnotation(BizLogic.class,Validate.class);
        if(Objects.nonNull(validate)){
            System.out.println(validate.bizCode());
        }
        Validates validates = AnnotationUtils.getAnnotation(BizLogic2.class,Validates.class);
        Arrays.stream(validates.value()).forEach(a->{
            System.out.println(a.bizCode());
        });

如果你是自己写业务的，我觉得第一种方式更加方便。
但是如果你是开发中间件的，那么必须兼容。

还有一点需要注意，我的@Validate是被@Component元注解，当多个@Validate语法糖转换成@Validates之后，由于@Validates上没@Component，导致我的bean加载不到spring容器中去

参考链接: 

https://docs.oracle.com/javase/tutorial/java/annotations/repeating.html

琦彦
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java内功修炼系列：注解（Annotation）
12-21
目录 一 注解的定义 二 如何自定义注解 三 元注解 3.1 @Retention 3.2 @Target 3.3 @Documented 3.4 @Inherited 3.5 @Repeatable 四 Java 预置的注解 4.1 @Deprecated 4.2 @Override 4.3 @SuppressWarnings 4.4 @SafeVarargs 4.5 @FunctionalInterface 五 注解的属性 5.1 属性的定义 5.2 注解的提取 六 注解的使用场景 七 注解实战之简易测试框架 补充1 ：元数据 参考文章： 一 注解的定义 Java 注解是从 Java5 开
主流大厂最新Java注解面试问题[译]
开发猫
10-21 2790
  大厂最新Java注解面试问题 1.简介 自Java 5以来，注释已经出现，而现在，它们是无处不在的编程结构，可以丰富代码。 在本文中，我们将回顾一些关于注释的问题; 通常会在技术面谈时询问，并在适当情况下; 我们将实施示例以更好地理解他们的答案。 2.问题 Q1。什么是注释？他们的典型用例是什么？ 注释是绑定到程序源代码元素的元数据，对它们运行的​​代码的操作没有影响。 他...
玩转java(Android)注解
chuanao8829的博客
05-08 129
玩转java(Android)注解 1. java标准(原生)注解概览 Java API 中，在java.lang、java.lang.annotation和javax.anotation包中定义了原生注解，分为三类： 编译注解 资源注解 元注解 1.1 编译相关注解 注解 释义 ...
深入理解Java注解类型
相忘于江湖
11-22 637
Java注解在实际应用中很广泛，目前很多主流的框架也采用了注解来提高效率，其实注解可以理解为Java代码中的一个标记，也可以理解为一个对象，它有自己的属性和值，只是没有相关方法的实现而已。下面先通过一个例子来看一下什么是注解 public class Test { //添加自定义注解 @FunAnno(name="我是方法a") public void fun_a()...
java笔记注解
m0_73469063的博客
11-26 241
​ 2、根节点：必须只能有一个根节点 ​ 3、标签：标签必须有结束且区分大小写，标签必须顺序嵌套 ​ 4、属性：必须引号引起值 ​ 5、空格会被保留，HTML空格最多保留一个 ​ 6、命名规则：命名必须见名知意 a)名字可包含字母、数字以及其他的字符 b)名字不能以数字或者标点符号开始 c)名字不能以字符“xml”（或者XML、Xml）开始 ​ 7、名字不能包含空格 ​ 8、 不应在 XML 元素名称中使用 ":" ，这是由于它用于命名空间（namespaces）的保留字。以下是一些XML的显着特征。
java中@Repeatable的理解
热门推荐
weixin_42245133的博客
08-16 1万+
@Repeatable是jdk8中新增的注解，使用如Spring中的@ComponentScan注解。在没有@Repeatable注解的的注解中，在同一个地方使用相同的注解会报错，有了此元注解注解的注解，就可以在同一个地方使用相同的注解。其官方文档如下 The annotation type {@code java.lang.annotation.Repeatable} is used to ...
@Repeatable
weixin_41812346的博客
05-14 873
在使用 @Repeatable 注解时，我们需要同时提供一个容器注解（container annotation）来封装可重复注解的多个实例。使用反射获取 MyClass 的所有注解信息，然后找到其中标记了 @Roles 注解的那个注解，从而获取包含了所有角色信息的 Role 数组。@Repeatable 是 JDK 1.8 中新增的一种注解，它主要作用是允许同一个程序元素多次使用相同的注解。通过使用 @Repeatable 注解，我们可以在一个程序元素上多次使用相同的注解。
元注解@Repeatable的使用
qq_31075041的博客
06-23 3983
被元注解@Repeatable修饰的注解，可以在同一个地方使用多次。这是JAVA8加入的新特性，在此之前注解在同一个地方只能使用一次（实际上有解决方案，但可读性不好）。 @Repeatable的使用有以下几个要点： 在需要重复使用的注解上修饰@Repeatable @Repeatable中的参数为被修饰注解的容器的类对象（class对象） 容器包含一个value方法，返回一个被修饰注解的数组 这样就完成了一个可重复使用的注解的定义，然后在对应类、方法、属性上多次使用该注.
java：@Repeatable注解使用
a232884c的博客
05-17 2309
java：@Repeatable注解使用 1 前言 java8新增了注解@Repeatable，在hibernate-validator的源码注解如@MAX、@NotNull等中，有@Repeatable注解的使用，源码示例如下： /* * Jakarta Bean Validation API * * License: Apache License, Version 2.0 * See the license.txt file in the root directory or <http:/
java8源码-Annotation_demo:Annotation_demo
06-04
java8添加的，可重复的，表该注解可以多次使用 注解元解释 @Target 通过@Target进行添加到注解中，说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Ann
解读MySQL事务的隔离级别和日志登记模式选择技巧
03-04
MySQL的四种事务隔离级别：Read-uncommitted、Read-committed、Repeatable-read、Seriailizable，相信大家都清楚各自异同，不清楚的朋友可以查看另外一篇技术文章：MySQL_InnoDB之事务与锁详解。但是对于第二类、第...
repeatable-workflows-docker-ipython:如何使用 Docker 和 IPython Notebooks 实现可重复的工作流
06-20
使用 Docker 和 IPython 创建可重复的工作流
java-数据库系统原理.docx
03-11
事务并发访问引起的问题及使用哪种事务隔离级别避免： java-数据库系统原理全文共3页，当前为第2页。 并发访问问题 事务隔离级别 丢失修改 MySQL 所有事务隔离级别在数据库层面上均可避免 脏读 READ-COMMITTED 事务...
链表刷题集
yajunjiao的专栏
04-30 816
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Linux下网络编程-简易Epll服务器和客户端
最新发布
weixin_45256307的博客
05-06 108
Linux下网络编程-简易Epll服务器和客户端
《设计一款蓝牙热敏打印机》
唐顺才的博客
05-06 68
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
一篇文章，系统性聊聊Java注解
架构风清扬
05-06 479
一篇文章，系统性聊聊Java注解
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1168
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
@Repeatable 是干嘛的
10-14
@Repeatable 是 Java 8 中新增的注解，用于标识某个注解可以重复使用。在 Java 8 之前，一个元素只能使用一次某个注解，如果需要使用多个相同的注解，则需要将这些注解放在一个容器中，然后将容器作为元素的注解。而...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值