java注解

lang

注解

一、认识注解

先看百度百科对java注解的解释：

定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

作用分类：

①编写文档：通过代码里标识的元数据生成文档【生成文档doc文档】

② 代码分析：通过代码里标识的元数据对代码进行分析【使用反射】

③编译检查：通过代码里标识的元数据让编译器能够实现基本的编译检查【Override】

提到的元数据，可以理解为描述数据的数据，看起来很绕，元注解也是描述注解的注解，后面说。

Annotation都是java.lang.annotation.Annotation接口的子接口，注解是一种特殊的接口，从代码格式上来看确实是，是在interface前加了一个@符号，格式为@interface xxx{}

二、JDK内置注解

jdk就存在注解，比如我们用eclipse子类覆盖父类方法时候用快捷间alt+/会自带在方法名称上面贴上一个@Override的标签。

  • @Override

    这个就是在子类覆盖父类的方法时候，经常遇到

  • @Deprecated

    这个元素是用来标记过时的元素，想必大家在日常开发中经常碰到。编译器在编译阶段遇到这个注解时会发出提醒警告，告诉开发者正在调用一个过时的元素比如过时的方法、过时的类、过时的成员变量。 如java.util.Data类中有很多过时的方法

  • @SupressWarings

    抑制警告，有很多人有代码洁癖，看到黄色的警告不爽，用它就可以抑制住。

  • @SafeVarargs

    java7出现的，抑制堆污染警告，有点自欺欺人的感觉。

三、元注解

元注解就是注解的注解，来看一下有哪些元注解

  • @Retention

    Retention英文是保留的意思，在这里可以约束注解的存活周期，代码运行有三个周期，分别为Source(源代码)、Class(字节码)、Runtime(运行时期) 三个时期的值保留在RetentionPolicy这个枚举类中。所以我们可以这样来玩，

    @Retention(RetetionPolicy.常量值)//RESOURCE,CLASS,RUNTIME

  • @Target

    Target是目标的意思，这里约束这个注解在那可以贴（类，方法，构造器，参数等)，位置的常量在ElementType这个枚举类中

    @Target({ElementsType.常亮值})//TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, TYPE表示类，接口，枚举

  • @Documented

    Document文档的意思，也就是使用这个标签到时候会带到API文档中去

  • @Inherited

    Inherited是遗传的意思，顾名思义，这个注解会遗传到子类去

  • @Repeatable 可重复的,Java8的一个新特性

四、自定义注解

1.注解的属性

在注解中定义属性，必须是8 种基本数据类型外加 类、接口、注解及它们的数组。不能是Integer..注解中属性可以有默认值，默认值需要用 default 关键值指定。

如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@interface TestAnnotation{
	int id() default 0;
	String msg() default "hello";
}
@TestAnnotation(id = 3,msg = "aa")
class Test1{
	
}

//当注解中只有一个value属性时候，贴标签的时候可以省略value。
//当注解中没有属性时，括号都可以省略（override注解）
@interface Test1Annotation{
	int[] value();
}
@Test1Annotation({1,2})
class Test2{
	
}

2.用反射操作注解

注解可以在类Class，方法Method，字段Field，构造器Constructor上等，所以在各自的类中都存在获取注解的API

1
2
3
4
boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) 
如果指定类型的注释存在于此元素上，则返回 true，否则返回 false。 
Annotation[] getAnnotations() 返回此元素上存在的所有注释。 
<Annotation>  getAnnotation(Class annotationClass)如果存在该元素的指定类型的注释，则返回这些注释对象，否则返回 null。 获取注解对象

自定义一个注解：

1
2
3
4
5
6
@Target({TYPE, FIELD, METHOD})//注解可以放的目标
@Retention(RetentionPolicy.RUNTIME)//注解保留周期
public @interface AnnotationTest {
	int id();
	String name();
}

测试一下这个自定义的注解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@AnnotationTest(id = 1,name = "na")
class Test{
	public static void main(String[] args) throws Exception {
		//判断Test(类元素)是否应用了这个注解
		boolean hasAnnotation = Test.class.isAnnotationPresent(AnnotationTest.class);
		if(hasAnnotation){
			//获取注解对象
			AnnotationTest t = Test.class.getAnnotation(AnnotationTest.class);
			System.out.println(t.name());
			System.out.println(t.id());
			//获取所有的注解s
			Annotation[] ans = Test.class.getAnnotations();
			for (Annotation an : ans) {
				System.out.println(an);
			}
		}
		System.out.println("============");
		//获取方法中上的注解
		boolean has = Test.class.getMethod("work").isAnnotationPresent(AnnotationTest.class);
		if(has){
			AnnotationTest an = Test.class.getMethod("work").getAnnotation(AnnotationTest.class);
			System.out.println(an.name());
		}
	}
	@AnnotationTest(id = 0,name="hello")
	public void work(){
	}
}

结果为：

1
2
3
4
5
na
1
@annotation.AnnotationTest(id=1, name=na)
============
hello

五、注解的用途

实践：模拟Junit4.x

Junit是做单元测试的，junit4用了注解，用法是在一个公共无参的方法贴上一个@Test标签表示要测试这个方法，但是在测试之前有可能会出现一些初始化操作，在结束后可能需要释放一些资源，需要初始化的方法上面贴上一个@Before，Test之后需要执行的需要贴上@After。

现在我们来自定义注解来模拟一下这些操作，需要在这里提的是，其实注解本身没什么意义，需要人为的设置它完成一些功能。

我们先定义三个注解：

1
2
3
4
5
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAfter {
	
}
1
2
3
4
5
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyBefore {
	
}
1
2
3
4
5
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest {

}

来一个测试这些注解功能的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Employee {
	@MyBefore
	public void init(){
		System.out.println("-------初始化-------");
	}
	@MyAfter
	public void end(){
		System.out.println("-------销毁---------");
	}
	@MyTest
	public void save() {
		System.out.println("保存操作");
	}
	@MyTest
	public void delete() {
		System.out.println("删除操作");
	}
	@MyBefore
	public void ddd(){
		System.out.println("怎么说呢?");
	}
}

好了，接下来我们就得具体去设置这个注解的意义

思路和步骤：

  • 获取Employee类的字节码对象，得到所有的方法

    • 对所有方法进行迭代，将三类注解分别存储，把有@MyBefore注解的存在beforeList,带有@MyAfter存在afterList，带有@MyTest存在testList
      对testList集合迭代，在迭代 过程中先执行beforeList中的方法，在执行afterList中的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class JunitTest {
	public static void main(String[] args) throws Exception {
		//得到Employee中所有的方法
		Method[] mds = Employee.class.getDeclaredMethods();
		//创建Employee的对象,用来执行方法
		Employee e = Employee.class.newInstance();
		//用集合存储三类注解标注的方法
		List<Method> beforeList = new ArrayList<>();
		List<Method> afterList = new ArrayList<>();
		List<Method> testList = new ArrayList<>();
		//对所有的方法进行迭代，分类
		for (Method md : mds) {
			if(md.isAnnotationPresent(MyBefore.class)){
				beforeList.add(md);
			}else if(md.isAnnotationPresent(MyAfter.class)){
				afterList.add(md);
			}else if(md.isAnnotationPresent(MyTest.class)){
				testList.add(md);
			}
		}
		//在对test迭代的过程中，先执行所有被before注解了的方法，然后执行test注解的方法，最后再执行after注解了的方法
		for (Method method : testList) {
			for (Method before : beforeList) {
				before.invoke(e);  //方法都没有参数
			}
			method.invoke(e);
			
			for (Method after : afterList) {
				after.invoke(e);
			}
		}
	}
}

结果：

1
2
3
4
5
6
7
8
-------初始化-------
怎么说呢?
删除操作
-------销毁---------
-------初始化-------
怎么说呢?
保存操作
-------销毁---------

本文标题:java注解

文章作者:Willing

发布时间:2018年11月08日 - 22时10分

最后更新:2018年11月08日 - 22时12分

许可协议: "署名-非商用-相同方式共享 3.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 注解
    1. 1.1. 一、认识注解
    2. 1.2. 二、JDK内置注解
    3. 1.3. 三、元注解
    4. 1.4. 四、自定义注解
      1. 1.4.1. 1.注解的属性
      2. 1.4.2. 2.用反射操作注解
    5. 1.5. 五、注解的用途
      1. 1.5.1. 实践：模拟Junit4.x