@The role of documented

1. @Documented The meaning of

• @Document yes java Document generation , Whether to display the switch of annotation .

2. What's the difference between adding and not adding ？

• Test notes

  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  public @interface RestMapping {
  String[] value() default {};

  String[] path() default {};
  }

• Test class TerminalController

  @RestMapping(“/terminal”)
  public class TerminalController {

• Use command

  // Generate java doc The order of ：
  javadoc -d doc TerminalController.java`
  // -d The destination directory of the output file

a. No effect

b. Plus the effect of

You can see in the public class TerminalController There is a note we wrote on it . This is it. @Documented Usefulness .

3. Digression ： Annotation merge

java Annotations are just a kind of annotation that will not be ignored by the compiler notes . It has no effect on code logic （ Can be used to determine whether there is , Can read content information ）, And the use effect is completely determined by the use of tools .

Annotations are used by many specifications , As a sign or convention , Such as jsr303 Parameter checking .

a. Annotation merge

stay springboot Annotations in play a great role , And these functions only in springboot Useful in , like @AliasFor.

Annotations themselves cannot be inherited by annotations , and springboot You can see a lot of merge annotations in the @RestController = @Controller + @ResponseBody. This is it. @AliasFor Credit . It should be noted that , Leave Spring Can't use .

spring The annotations of are read by the following class , therefore spring Annotations of can be merged （ Yes and only spring annotation ：Spring Annotations）

public interface MergedAnnotations

b. @AliasFor

@AliasFor It has four functions ：

1. Explicit aliases in comments ：
   stay @ContextConfiguration in , value and locations Is an explicit alias for each other .

   public @interface ContextConfiguration {
   @AliasFor(“locations”)
   String[] value() default {};

   @AliasFor(“value”)
   String[] locations() default {};

   // …
   }

2. Explicit aliases of attributes in meta annotations ：
   stay @XmlTestConfig in , xmlFiles yes @ContextConfiguration in locations Explicit alias for . let me put it another way , xmlFiles covers @ContextConfiguration Medium locations attribute .

   @ContextConfiguration
   public @interface XmlTestConfig {

     @AliasFor(annotation = ContextConfiguration.class, attribute = "locations")
     String[] xmlFiles();
   

   }

3. Implicit aliases in comments ：
   stay @MyTestConfig in , value 、 groovyScripts and xmlFiles All are @ContextConfiguration in locations The explicit meta annotation property of the property overrides . therefore , These three attributes are also implicit aliases to each other .

   @ContextConfiguration
   public @interface MyTestConfig {
   @AliasFor(annotation = ContextConfiguration.class, attribute = “locations”)
   String[] value() default {};

   @AliasFor(annotation = ContextConfiguration.class, attribute = “locations”)
   String[] groovyScripts() default {};

   @AliasFor(annotation = ContextConfiguration.class, attribute = “locations”)
   String[] xmlFiles() default {};
   }

4. Pass through implicit aliases in comments ：
   stay @GroovyOrXmlTestConfig in , groovy It's right @MyTestConfig in groovyScripts Explicit overrides of attributes ; and xml It's right @ContextConfiguration Medium locations Explicit overrides of attributes . Besides , groovy and xml Are each other's Transitive implicit aliases , Because they all effectively cover @ContextConfiguration Medium locations attribute .

   @MyTestConfig
   public @interface GroovyOrXmlTestConfig {
   @AliasFor(annotation = MyTestConfig.class, attribute = “groovyScripts”)
   String[] groovy() default {};

   @AliasFor(annotation = ContextConfiguration.class, attribute = “locations”)
   String[] xml() default {};
   }

（ End ）