朋友被阿里面试官灵魂拷问,跑来求救
2020-03-11 16:01:37来源:博客园 阅读 ()
朋友被阿里面试官灵魂拷问,跑来求救
本人免费整理了Java高级资料,涵盖了Java、Redis、MongoDB、MySQL、Zookeeper、Spring Cloud、Dubbo高并发分布式等教程,一共30G,需要自己领取。
传送门:https://mp.weixin.qq.com/s/osB-BOl6W-ZLTSttTkqMPQ
最近有个朋友去阿里面试,被面试官来了个灵魂拷问:
- 注解是干什么的?
- 一个注解可以使用多次么?如何使用?
- @Inherited是做什么的?
- @Target中的`TYPE_PARAMETER和TYPE_USER`用在什么地方?
- 泛型中如何使用注解?
- 注解定义可以实现继承么?
- spring中对注解有哪些增强?@Aliasfor注解是干什么的?
第1个他回答上来了,后面的几个直接懵了,然后就没有然后了。
之后跑来问我,然后我让他看本文,准备下次去吊打面试官。
本文内容
带你玩转java注解,解决上面的所有问题。
什么是注解?
代码中注释大家都熟悉吧,注释是给开发者看的,可以提升代码的可读性和可维护性,但是对于java编译器和虚拟机来说是没有意义的,编译之后的字节码文件中是没有注释信息的;而注解和注释有点类似,唯一的区别就是注释是给人看的,而注释是给编译器和虚拟机看的,编译器和虚拟机在运行的过程中可以获取注解信息,然后可以根据这些注解的信息做各种想做的事情。比如:大家对@Override应该比较熟悉,就是一个注解,加在方法上,标注当前方法重写了父类的方法,当编译器编译代码的时候,会对@Override标注的方法进行验证,验证其父类中是否也有同样签名的方法,否则报错,通过这个注解是不是增强了代码的安全性。
总的来说:注解是对代码的一种增强,可以在代码编译或者程序运行期间获取注解的信息,然后根据这些信息做各种牛逼的事情。
注解如何使用?
3个步骤:
- 定义注解
- 使用注解
- 获取注解信息做各种牛逼的事情
定义注解
关于注解的定义,先来几个问题:
- 如何为注解定义参数?
- 注解可以用在哪里?
- 注解会被保留到什么时候?
定义注解语法
jdk中注解相关的类和接口都定义在java.lang.annotation包中。
注解的定义和我们常见的类、接口类似,只是注解使用@interface来定义,如下定义一个名称为MyAnnotation的注解:
public @interface MyAnnotation {
}
注解中定义参数
注解有没有参数都可以,定义参数如下:
public @interface 注解名称{
[public] 参数类型 参数名称1() [default 参数默认值];
[public] 参数类型 参数名称2() [default 参数默认值];
[public] 参数类型 参数名称n() [default 参数默认值];
}
注解中可以定义多个参数,参数的定义有以下特点:
- 访问修饰符必须为public,不写默认为public
- 该元素的类型只能是基本数据类型、String、Class、枚举类型、注解类型(体现了注解的嵌套效果)以及上述类型的一位数组
- 该元素的名称一般定义为名词,如果注解中只有一个元素,请把名字起为value(后面使用会带来便利操作)
- 参数名称后面的()不是定义方法参数的地方,也不能在括号中定义任何参数,仅仅只是一个特殊的语法
- default代表默认值,值必须和第2点定义的类型一致
- 如果没有默认值,代表后续使用注解时必须给该类型元素赋值
指定注解的使用范围:@Target
使用@Target注解定义注解的使用范围,如下:
@Target(value = {ElementType.TYPE,ElementType.METHOD})
public @interface MyAnnotation {
}
上面指定了MyAnnotation注解可以用在类、接口、注解类型、枚举类型以及方法上面,自定义注解上也可以不使用@Target注解,如果不使用,表示自定义注解可以用在任何地方。
看一下@Target源码:
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
ElementType[] value();
}
有一个参数value,是ElementType类型的一个数组,再来看一下ElementType,是个枚举,源码如下:
package java.lang.annotation;
/*注解的使用范围*/
public enum ElementType {
/*类、接口、枚举、注解上面*/
TYPE,
/*字段上*/
FIELD,
/*方法上*/
METHOD,
/*方法的参数上*/
PARAMETER,
/*构造函数上*/
CONSTRUCTOR,
/*本地变量上*/
LOCAL_VARIABLE,
/*注解上*/
ANNOTATION_TYPE,
/*包上*/
PACKAGE,
/*类型参数上*/
TYPE_PARAMETER,
/*类型名称上*/
TYPE_USE
}
指定注解的保留策略:@Retention
我们先来看一下java程序的3个过程
- 源码阶段
- 源码被编译为字节码之后变成class文件
- 字节码被虚拟机加载然后运行
那么自定义注解会保留在上面哪个阶段呢?可以通过@Retention注解来指定,如:
@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnotation {
}
上面指定了MyAnnotation只存在于源码阶段,后面的2个阶段都会丢失。
来看一下@Retention
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
RetentionPolicy value();
}
有一个value参数,类型为RetentionPolicy枚举,如下:
public enum RetentionPolicy {
/*注解只保留在源码中,编译为字节码之后就丢失了,也就是class文件中就不存在了*/
SOURCE,
/*注解只保留在源码和字节码中,运行阶段会丢失*/
CLASS,
/*源码、字节码、运行期间都存在*/
RUNTIME
}
使用注解
语法
将注解加载使用的目标上面,如下:
@注解名称(参数1=值1,参数2=值2,参数n=值n)
目标对象
直接来案例说明。
无参注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Ann1 { //@1
}
@Ann1 //@2
public class UseAnnotation1 {
}
@1:Ann1为无参注解
@2:类上使用@Ann1注解,没有参数
一个参数的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Ann2 { //@1
String name();
}
@Ann2(name = "我是路人甲java") //@2
public class UseAnnotation2 {
}
一个参数为value的注解,可以省略参数名称
只有一个参数,名称为value的时候,使用时参数名称可以省略
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Ann3 {
String value();//@1
}
@Ann3("我是路人甲java") //@2
public class UseAnnotation3 {
}
@1:注解之后一个参数,名称为value
@2:使用注解,参数名称value省略了
数组类型参数
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Ann4 {
String[] name();//@1
}
@Ann4(name = {"我是路人甲java", "欢迎和我一起学spring"}) //@2
public class UseAnnotation4 {
@Ann4(name = "如果只有一个值,{}可以省略") //@3
public class T1 {
}
}
@1:name的类型是一个String类型的数组
@2:name有多个值的时候,需要使用{}包含起来
@3:如果name只有一个值,{}可以省略
为参数指定默认值
通过default为参数指定默认值,用的时候如果没有设置值,则取默认值,没有指定默认值的参数,使用的时候必须为参数设置值,如下:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Ann5 {
String[] name() default {"路人甲java", "spring系列"};//@1
int[] score() default 1; //@2
int age() default 30; //@3
String address(); //@4
}
@Ann5(age = 32,address = "上海") //@5
public class UseAnnotation5 {
}
@1:数组类型通过{}指定默认值
@2:数组类型参数,默认值只有一个省略了{}符号
@3:默认值为30
@4:未指定默认值
@5:age=32对默认值进行了覆盖,并且为address指定了值
综合案例
@Target(value = {
ElementType.TYPE,
ElementType.METHOD,
ElementType.FIELD,
ElementType.PARAMETER,
ElementType.CONSTRUCTOR,
ElementType.LOCAL_VARIABLE
})
@Retention(RetentionPolicy.RUNTIME)
@interface Ann6 {
String value();
ElementType elementType();
}
@Ann6(value = "我用在类上", elementType = ElementType.TYPE)
public class UseAnnotation6 {
@Ann6(value = "我用在字段上", elementType = ElementType.FIELD)
private String a;
@Ann6(value = "我用在构造方法上", elementType = ElementType.CONSTRUCTOR)
public UseAnnotation6(@Ann6(value = "我用在方法参数上", elementType = ElementType.PARAMETER) String a) {
this.a = a;
}
@Ann6(value = "我用在了普通方法上面", elementType = ElementType.METHOD)
public void m1() {
@Ann6(value = "我用在了本地变量上", elementType = ElementType.LOCAL_VARIABLE) String a;
}
}
上面演示了自定义注解在在类、字段、构造器、方法参数、方法、本地变量上的使用,@Ann6注解有个elementType参数,我想通过这个参数的值来告诉大家对应@Target中的那个值来限制使用目标的,大家注意一下上面每个elementType的值。
@Target(ElementType.TYPE_PARAMETER)
这个是1.8加上的,用来标注类型参数,类型参数一般在类后面声明或者方法上声明,这块需要先了解一下泛型泛型,有点难度,会让很多人懵逼,那是因为你没有看这篇文章!不然理解起来比较吃力,来个案例感受一下:
@Target(value = {
ElementType.TYPE_PARAMETER
})
@Retention(RetentionPolicy.RUNTIME)
@interface Ann7 {
String value();
}
public class UseAnnotation7<@Ann7("T0是在类上声明的一个泛型类型变量") T0, @Ann7("T1是在类上声明的一个泛型类型变量") T1> {
public <@Ann7("T2是在方法上声明的泛型类型变量") T2> void m1() {
}
public static void main(String[] args) throws NoSuchMethodException {
for (TypeVariable typeVariable : UseAnnotation7.class.getTypeParameters()) {
print(typeVariable);
}
for (TypeVariable typeVariable : UseAnnotation7.class.getDeclaredMethod("m1").getTypeParameters()) {
print(typeVariable);
}
}
private static void print(TypeVariable typeVariable) {
System.out.println("类型变量名称:" + typeVariable.getName());
Arrays.stream(typeVariable.getAnnotations()).forEach(System.out::println);
}
}
类和方法上面可以声明泛型类型的变量,上面有3个泛型类型变量,我们运行一下看看效果:
类型变量名称:T0
@com.javacode2018.lesson001.demo18.Ann7(value=T0是在类上声明的一个泛型类型变量)
类型变量名称:T1
@com.javacode2018.lesson001.demo18.Ann7(value=T1是在类上声明的一个泛型类型变量)
类型变量名称:T2
@com.javacode2018.lesson001.demo18.Ann7(value=T2是在方法上声明的泛型类型变量)
@Target(ElementType.TYPE_USE)
这个是1.8加上的,能用在任何类型名称上,来个案例感受一下:
@Target({ElementType.TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
@interface Ann10 {
String value();
}
@Ann10("用在了类上")
public class UserAnnotation10<@Ann10("用在了类变量类型V1上") V1, @Ann10("用在了类变量类型V2上") V2> {
private Map<@Ann10("用在了泛型类型上") String, Integer> map;
public <@Ann10("用在了参数上") T> String m1(String name) {
return null;
}
}
类后面的V1、V2都是类型名称,Map后面的尖括号也是类型名称,m1方法前面也定义了一个类型变量,名称为T
注解信息的获取
为了运行时能准确获取到注解的相关信息,Java在java.lang.reflect 反射包下新增了AnnotatedElement接口,它主要用于表示目前正在虚拟机中运行的程序中已使用注解的元素,通过该接口提供的方法可以利用反射技术地读取注解的信息,看一下UML图:
- Package:用来表示包的信息
- Class:用来表示类的信息
- Constructor:用来表示构造方法信息
- Field:用来表示类中属性信息
- Method:用来表示方法信息
- Parameter:用来表示方法参数信息
- TypeVariable:用来表示类型变量信息,如:类上定义的泛型类型变量,方法上面定义的泛型类型变量
AnnotatedElement常用方法
案例
要解析的列如下
package com.javacode2018.lesson001.demo18;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.Map;
@Target({ElementType.PACKAGE,
ElementType.TYPE,
ElementType.FIELD,
ElementType.CONSTRUCTOR,
ElementType.METHOD,
ElementType.PARAMETER,
ElementType.TYPE_PARAMETER,
ElementType.TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
@interface Ann11 {
String value();
}
@Target({ElementType.PACKAGE,
ElementType.TYPE,
ElementType.FIELD,
ElementType.CONSTRUCTOR,
ElementType.METHOD,
ElementType.PARAMETER,
ElementType.TYPE_PARAMETER,
ElementType.TYPE_USE})
@Retention(RetentionPolicy.RUNTIME)
@interface Ann11_0 {
int value();
}
@Ann11("用在了类上")
@Ann11_0(0)
public class UseAnnotation11<@Ann11("用在了类变量类型V1上") @Ann11_0(1) V1, @Ann11("用在了类变量类型V2上") @Ann11_0(2) V2> {
@Ann11("用在了字段上")
@Ann11_0(3)
private String name;
private Map<@Ann11("用在了泛型类型上,String") @Ann11_0(4) String, @Ann11("用在了泛型类型上,Integer") @Ann11_0(5) Integer> map;
@Ann11("用在了构造方法上")
@Ann11_0(6)
public UseAnnotation11() {
this.name = name;
}
@Ann11("用在了返回值上")
@Ann11_0(7)
public String m1(@Ann11("用在了参数上") @Ann11_0(8) String name) {
return null;
}
}
解析类上的注解
解析这部分
@Ann11("用在了类上")
代码
@Test
public void m1() {
for (Annotation annotation : UserAnnotation10.class.getAnnotations()) {
System.out.println(annotation);
}
}
运行输出
@com.javacode2018.lesson001.demo18.Ann11(value=用在了类上)
@com.javacode2018.lesson001.demo18.Ann11_0(value=0)
解析类上的类型变量
解析类名后面的尖括号的部分,即下面的部分:
UseAnnotation11<@Ann11("用在了类变量类型V1上") @Ann11_0(1) V1, @Ann11("用在了类变量类型V2上") @Ann11_0(2) V2>
用例代码
@Test
public void m2() {
TypeVariable<Class<UserAnnotation10>>[] typeParameters = UserAnnotation10.class.getTypeParameters();
for (TypeVariable<Class<UserAnnotation10>> typeParameter : typeParameters) {
System.out.println(typeParameter.getName() + "变量类型注解信息:");
Annotation[] annotations = typeParameter.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
}
}
运行输出
V1变量类型注解信息:
@com.javacode2018.lesson001.demo18.Ann11(value=用在了类变量类型V1上)
@com.javacode2018.lesson001.demo18.Ann11_0(value=1)
V2变量类型注解信息:
@com.javacode2018.lesson001.demo18.Ann11(value=用在了类变量类型V2上)
@com.javacode2018.lesson001.demo18.Ann11_0(value=2)
解析字段name上的注解
用例代码
@Test
public void m3() throws NoSuchFieldException {
Field nameField = UserAnnotation10.class.getDeclaredField("name");
for (Annotation annotation : nameField.getAnnotations()) {
System.out.println(annotation);
}
}
运行输出
@com.javacode2018.lesson001.demo18.Ann11(value=用在了字段上)
@com.javacode2018.lesson001.demo18.Ann11_0(value=3)
解析泛型字段map上的注解
用例代码
@Test
public void m4() throws NoSuchFieldException, ClassNotFoundException {
Field field = UseAnnotation11.class.getDeclaredField("map");
Type genericType = field.getGenericType();
Type[] actualTypeArguments = ((ParameterizedType) genericType).getActualTypeArguments();
AnnotatedType annotatedType = field.getAnnotatedType();
AnnotatedType[] annotatedActualTypeArguments = ((AnnotatedParameterizedType) annotatedType).getAnnotatedActualTypeArguments();
int i = 0;
for (AnnotatedType actualTypeArgument : annotatedActualTypeArguments) {
Type actualTypeArgument1 = actualTypeArguments[i++];
System.out.println(actualTypeArgument1.getTypeName() + "类型上的注解如下:");
for (Annotation annotation : actualTypeArgument.getAnnotations()) {
System.out.println(annotation);
}
}
}
运行输出
java.lang.String类型上的注解如下:
@com.javacode2018.lesson001.demo18.Ann11(value=用在了泛型类型上,String)
@com.javacode2018.lesson001.demo18.Ann11_0(value=4)
java.lang.Integer类型上的注解如下:
@com.javacode2018.lesson001.demo18.Ann11(value=用在了泛型类型上,Integer)
@com.javacode2018.lesson001.demo18.Ann11_0(value=5)
解析构造函数上的注解
用例代码
@Test
public void m5() {
Constructor<?> constructor = UseAnnotation11.class.getConstructors()[0];
for (Annotation annotation : constructor.getAnnotations()) {
System.out.println(annotation);
}
}
运行输出
@com.javacode2018.lesson001.demo18.Ann11(value=用在了构造方法上)
@com.javacode2018.lesson001.demo18.Ann11_0(value=6)
解析m1方法上的注解
用例代码
@Test
public void m6() throws NoSuchMethodException {
Method method = UseAnnotation11.class.getMethod("m1", String.class);
for (Annotation annotation : method.getAnnotations()) {
System.out.println(annotation);
}
}
运行输出
@com.javacode2018.lesson001.demo18.Ann11(value=用在了返回值上)
@com.javacode2018.lesson001.demo18.Ann11_0(value=7)
解析m1方法参数注解
用例代码
@Test
public void m7() throws NoSuchMethodException {
Method method = UseAnnotation11.class.getMethod("m1", String.class);
for (Parameter parameter : method.getParameters()) {
System.out.println(String.format("参数%s上的注解如下:", parameter.getName()));
for (Annotation annotation : parameter.getAnnotations()) {
System.out.println(annotation);
}
}
}
运行输出
参数arg0上的注解如下:
@com.javacode2018.lesson001.demo18.Ann11(value=用在了参数上)
@com.javacode2018.lesson001.demo18.Ann11_0(value=8)
上面参数名称为arg0,如果想让参数名称和源码中真实名称一致,操作如下:
如果你编译这个class的时候没有添加参数–parameters,运行的时候你会得到这个结果:
Parameter: arg0
编译的时候添加了–parameters参数的话,运行结果会不一样:
Parameter: args
对于有经验的Maven使用者,–parameters参数可以添加到maven-compiler-plugin的配置部分:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<compilerArgument>-parameters</compilerArgument>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
@Inherit:实现类之间的注解继承
用法
来看一下这个注解的源码
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}
我们通过@Target元注解的属性值可以看出,这个@Inherited 是专门修饰注解的。
作用:让子类可以继承父类中被@Inherited修饰的注解,注意是继承父类中的,如果接口中的注解也使用@Inherited修饰了,那么接口的实现类是无法继承这个注解的
案例
package com.javacode2018.lesson001.demo18;
import java.lang.annotation.*;
public class InheritAnnotationTest {
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface A1{ //@1
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface A2{ //@2
}
@A1 //@3
interface I1{}
@A2 //@4
static class C1{}
static class C2 extends C1 implements I1{} //@5
public static void main(String[] args) {
for (Annotation annotation : C2.class.getAnnotations()) { //@6
System.out.println(annotation);
}
}
}
@1:定义了一个注解A1,上面使用了@Inherited,表示这个具有继承功能
@2:定义了一个注解A2,上面使用了@Inherited,表示这个具有继承功能
@3:定义接口I1,上面使用了@A1注解
@4:定义了一个C1类,使用了A2注解
@5:C2继承了C1并且实现了I1接口
@6:获取C2上以及从父类继承过来的所有注解,然后输出
运行输出:
@com.javacode2018.lesson001.demo18.InheritAnnotationTest$A2()
从输出中可以看出类可以继承父类上被@Inherited修饰的注解,而不能继承接口上被@Inherited修饰的注解,这个一定要注意
@Repeatable重复使用注解
来看一段代码:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Ann12{}
@Ann12
@Ann12
public class UseAnnotation12 {
}
上面代码会报错,原因是:UseAnnotation12上面重复使用了@Ann12注解,默认情况下@Ann12注解是不允许重复使用的。
像上面这样,如果我们想重复使用注解的时候,需要用到@Repeatable注解
使用步骤
先定义容器注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.FIELD})
@interface Ann12s {
Ann12[] value(); //@1
}
容器注解中必须有个value类型的参数,参数类型为子注解类型的数组。
为注解指定容器
要让一个注解可以重复使用,需要在注解上加上@Repeatable注解,@Repeatable中value的值为容器注解,如下代码中的@2
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.FIELD})
@Repeatable(Ann12s.class)//@2
@interface Ann12 {
String name();
}
使用注解
重复使用相同的注解有2种方式,如下面代码
- 重复使用注解,如下面的类上重复使用@Ann12注解
- 通过容器注解来使用更多个注解,如下面的字段v1上使用@Ann12s容器注解
@Ann12(name = "路人甲Java")
@Ann12(name = "Spring系列")
public class UseAnnotation12 {
@Ann12s(
{@Ann12(name = "Java高并发系列,见公众号"),
@Ann12(name = "mysql高手系列,见公众号")}
)
private String v1;
}
获取注解信息
com.javacode2018.lesson001.demo18.UseAnnotation12
@Test
public void test1() throws NoSuchFieldException {
Annotation[] annotations = UseAnnotation12.class.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
System.out.println("-------------");
Field v1 = UseAnnotation12.class.getDeclaredField("v1");
Annotation[] declaredAnnotations = v1.getDeclaredAnnotations();
for (Annotation declaredAnnotation : declaredAnnotations) {
System.out.println(declaredAnnotation);
}
}
运行输出:
@com.javacode2018.lesson001.demo18.Ann12s(value=[@com.javacode2018.lesson001.demo18.Ann12(name=路人甲Java), @com.javacode2018.lesson001.demo18.Ann12(name=Spring系列)])
-------------
@com.javacode2018.lesson001.demo18.Ann12s(value=[@com.javacode2018.lesson001.demo18.Ann12(name=Java高并发系列,见公众号), @com.javacode2018.lesson001.demo18.Ann12(name=mysql高手系列,见公众号)])
上面就是java中注解的功能,下面我们来介绍spring对于注解方面的支持。
先来看一个问题
代码如下:
package com.javacode2018.lesson001.demo18;
import org.junit.Test;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.core.annotation.AnnotationUtils;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface A1 {
String value() default "a";//@0
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@A1
@interface B1 { //@1
String value() default "b";//@2
}
@B1("路人甲Java") //@3
public class UseAnnotation13 {
@Test
public void test1() {
//AnnotatedElementUtils是spring提供的一个查找注解的工具类
System.out.println(AnnotatedElementUtils.getMergedAnnotation(UseAnnotation13.class, B1.class));
System.out.println(AnnotatedElementUtils.getMergedAnnotation(UseAnnotation13.class, A1.class));
}
}
@0:A1注解value参数值默认为a
@1:B1注解上使用到了@A1注解
@2:B1注解value参数值默认为b
@2:UseAnnotation13上面使用了@B1注解,value参数的值为:路人甲java
test1方法中使用到了spring中的一个类AnnotatedElementUtils,通过这个工具类可以很方便的获取注解的各种信息,方法中的2行代码用于获取UseAnnotation13类上B1注解和A1注解的信息。
运行test1方法输出:
@com.javacode2018.lesson001.demo18.B1(value=路人甲Java)
@com.javacode2018.lesson001.demo18.A1(value=a)
上面用法很简单,没什么问题。
此时有个问题:此时如果想在UseAnnotation13上给B1上的A1注解设置值是没有办法的,注解定义无法继承导致的,如果注解定义上面能够继承,那用起来会爽很多,spring通过@Aliasfor方法解决了这个问题。
Spring @AliasFor:对注解进行增强
直接上案例,然后解释代码。
案例1:通过@AliasFor解决刚才难题
package com.javacode2018.lesson001.demo18;
import org.junit.Test;
import org.springframework.core.annotation.AliasFor;
import org.springframework.core.annotation.AnnotatedElementUtils;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface A14 {
String value() default "a";//@0
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@A14 //@6
@interface B14 { //@1
String value() default "b";//@2
@AliasFor(annotation = A14.class, value = "value") //@5
String a14Value();
}
@B14(value = "路人甲Java",a14Value = "通过B14给A14的value参数赋值") //@3
public class UseAnnotation14 {
@Test
public void test1() {
//AnnotatedElementUtils是spring提供的一个查找注解的工具类
System.out.println(AnnotatedElementUtils.getMergedAnnotation(UseAnnotation14.class, B14.class));
System.out.println(AnnotatedElementUtils.getMergedAnnotation(UseAnnotation14.class, A14.class));
}
}
运行输出:
@com.javacode2018.lesson001.demo18.B14(a14Value=通过B14给A14的value参数赋值, value=路人甲Java)
@com.javacode2018.lesson001.demo18.A14(value=通过B14给A14的value参数赋值)
注意上面diam的@3只使用了B14注解,大家认真看一下,上面输出汇总可以看出A14的value值和B14的a14Value参数值一样,说明通过B14给A14设置值成功了。
重点在于代码@5,这个地方使用到了@AliasFor注解:
@AliasFor(annotation = A14.class, value = "value")
这个相当于给某个注解指定别名,即将B1注解中a14Value参数作为A14中value参数的别名,当给B1的a14Value设置值的时候,就相当于给A14的value设置值,有个前提是@AliasFor注解的annotation参数指定的注解需要加载当前注解上面,如:@6
案例2:同一个注解中使用@AliasFor
package com.javacode2018.lesson001.demo18;
import org.junit.Test;
import org.springframework.core.annotation.AliasFor;
import org.springframework.core.annotation.AnnotatedElementUtils;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@interface A15 {
@AliasFor("v2")//@1
String v1() default "";
@AliasFor("v1")//@2
String v2() default "";
}
@A15(v1 = "我是v1") //@3
public class UseAnnotation15 {
@A15(v2 = "我是v2") //@4
private String name;
@Test
public void test1() throws NoSuchFieldException {
//AnnotatedElementUtils是spring提供的一个查找注解的工具类
System.out.println(AnnotatedElementUtils.getMergedAnnotation(UseAnnotation15.class, A15.class));
System.out.println(AnnotatedElementUtils.getMergedAnnotation(UseAnnotation15.class.getDeclaredField("name"), A15.class));
}
}
注意上面代码,A15注解中(@1和@2)的2个参数都设置了@AliasFor,@AliasFor如果不指定annotation参数的值,那么annotation默认值就是当前注解,所以上面2个属性互为别名,当给v1设置值的时候也相当于给v2设置值,当给v2设置值的时候也相当于给v1设置值。
运行输出
@com.javacode2018.lesson001.demo18.A15(v1=我是v1, v2=我是v1)
@com.javacode2018.lesson001.demo18.A15(v1=我是v2, v2=我是v2)
从输出中可以看出v1和v2的值始终是相等的,上面如果同时给v1和v2设置值的时候运行代码会报错。
我们回头来看看@AliasFor的源码:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface AliasFor {
@AliasFor("attribute")
String value() default "";
@AliasFor("value")
String attribute() default "";
Class<? extends Annotation> annotation() default Annotation.class;
}
AliasFor注解中value和attribute互为别名,随便设置一个,同时会给另外一个设置相同的值。
案例2:@AliasFor中不指定value和attribute
当@AliasFor中不指定value或者attribute的时候,自动将@AliasFor修饰的参数作为value和attribute的值,如下@AliasFor注解的value参数值为name
package com.javacode2018.lesson001.demo18;
import org.junit.Test;
import org.springframework.core.annotation.AliasFor;
import org.springframework.core.annotation.AnnotatedElementUtils;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface A16 {
String name() default "a";//@0
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@A16
@interface B16 { //@1
@AliasFor(annotation = A16.class) //@5
String name() default "b";//@2
}
@B16(name="我是v1") //@3
public class UseAnnotation16 {
@Test
public void test1() throws NoSuchFieldException {
//AnnotatedElementUtils是spring提供的一个查找注解的工具类
System.out.println(AnnotatedElementUtils.getMergedAnnotation(UseAnnotation16.class, A16.class));
System.out.println(AnnotatedElementUtils.getMergedAnnotation(UseAnnotation16.class, B16.class));
}
}
运行输出:
@com.javacode2018.lesson001.demo18.A16(name=我是v1)
@com.javacode2018.lesson001.demo18.B16(name=我是v1)
总结
到目前为止文章开头的问题,想必各位都可以回答上来了,文章内容比较多,大家最好去敲一遍,加深理解。
欢迎留言!
原文链接:https://www.cnblogs.com/yunxi520/p/12462570.html
如有疑问请与原作者联系
标签:
版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有
- 2020年深圳中国平安各部门Java中级面试真题合集(附答案) 2020-06-11
- JVM常见面试题解析 2020-06-11
- 作为一个面试官,我想问问你Redis分布式锁怎么搞? 2020-06-10
- 阿里巴巴26个屌炸天的开源项目,你知道几个? 2020-06-09
- 送你一份年薪百万的抖音Java岗内部面试题 2020-06-09
IDC资讯: 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营: 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程: Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术: Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧: 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作: FrontPages Dreamweaver Javascript css photoshop fireworks Flash