反射注解_2_注解-CSDN博客

本文链接：https://blog.csdn.net/CXY_1274511216/article/details/132385881

1：注解

1、什么是注解

对于很多初次接触的开发者来说应该都有这个疑问？Annontation是Java5开始引入的新特征，中文名称叫注解。

它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定的工具或框架使用。

Annontation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。

Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。包含在 java.lang.annotation 包中

2、注解的作用

1、生成文档。这是最常见的，也是java 最早提供的注解。常用的有@param @return 等 2、跟踪代码依赖性，实现替代配置文件功能。比如Spring的注入，未来java开发，将大量注解配置，具有很大用处; 3、在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出

对Java中类、方法、成员变量做标记，然后进行特殊处理，至于到底做何种处理由业务需求来决定。
例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行。

2.1、注解概述、作用、

Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。
Java 语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注。

3、注解的原理

注解本质是一个继承了Annotation的特殊接口，其具体实现类是Java运行时生成的动态代理类。而我们通过反射获取注解时，返回的是Java运行时生成的动态代理对象$Proxy1。通过代理对象调用自定义注解（接口）的方法，会最终调用AnnotationInvocationHandler的invoke方法。该方法会从memberValues这个Map中索引出对应的值。而memberValues的来源是Java常量池

　这个运行时生成的动态代理对象是可以导出到文件的，方法有两种

在代码中加入System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
在运行时加入jvm 参数 -Dsun.misc.ProxyGenerator.saveGeneratedFiles=true

2：注解的分类

2.1自定义注解

自定义注解类编写的一些规则:

1. Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
2. 参数成员只能用public或默认(default)这两个访问权修饰
3. 参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和String、Enum、Class、annotations等数据类型,以及这一些类型的数组.
4. 要获取类方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation对象,因为你除此之外没有别的获取注解对象的方法
5. 注解也可以没有定义成员, 不过这样注解就没啥用了

例子如下：

先创建第一个注解：

package cn.sz.gl.test07;

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;

@Target(ElementType.FIELD)//可以用来修饰对象，属性
@Retention(RetentionPolicy.RUNTIME)//什么时候都不丢弃
@Documented//用于生成javadoc文档
public @interface FruitName {

	String value() default "";
}

再创建一个注解：

package cn.sz.gl.test07;

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;

@Target(ElementType.FIELD)//可以用来修饰对象，属性
@Retention(RetentionPolicy.RUNTIME)//什么时候都不丢弃
@Documented//用于生成javadoc文档
public @interface FruitColor {
	
	public enum Color{RED,GREEN,BLUE};
	Color fc() default Color.GREEN;
}

创建一个工具类用来处理注解：

package cn.sz.gl.test07;

import java.lang.reflect.Field;

public class AnnotationUtil {

	public static Object findInfo(Class clazz) throws IllegalArgumentException, IllegalAccessException, InstantiationException{
		Object obj = class.newInstance();
		Field fs [] = class.getDeclaredFields();
		
		for (int i = 0; i < fs.length; i++) {
			//判断该属性上是否有FruitName类型的注解
			if(fs[i].isAnnotationPresent(FruitName.class)){
				FruitName fn = fs[i].getAnnotation(FruitName.class);
				//为属性赋值
				fs[i].setAccessible(true);
				fs[i].set(obj, fn.value());
			}
			if(fs[i].isAnnotationPresent(FruitColor.class)){
				FruitColor fc = fs[i].getAnnotation(FruitColor.class);
				fs[i].setAccessible(true);
				fs[i].set(obj, fc.fc().toString());
			}
		}
		return obj;
	}
}

然后创建一个类，在类中应用自定义的注解：

package cn.sz.gl.test07;

import cn.sz.gl.test07.FruitColor.Color;

public class Apple {

	@FruitName("MyApple")
	private String applename;
	@FruitColor(fc=Color.RED)
	private String color;

	public String getApplename() {
		return applename;
	}

	public void setApplename(String applename) {
		this.applename = applename;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}
}

最后在main方法中测试：

package cn.sz.gl.test07;

public class Test {

	public static void main(String[] args) {
		
		try {
			Apple apple = (Apple) AnnotationUtil.findInfo(Apple.class);
			
			System.out.println(apple.getApplename());
			System.out.println(apple.getColor());
			
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

2.2 元注解

元注解：就是注解注解的注解。

2.2.1元注解有两个：

@Target: 约束自定义注解只能在哪些地方使用，
@Retention：申明注解的生命周期

@Target中可使用的值定义在ElementType枚举类中，常用值如下

TYPE，类，接口
FIELD, 成员变量
METHOD, 成员方法
PARAMETER, 方法参数
CONSTRUCTOR, 构造器
LOCAL_VARIABLE, 局部变量

@Retention中可使用的值定义在RetentionPolicy枚举类中，常用值如下

SOURCE：注解只作用在源码阶段，生成的字节码文件中不存在
CLASS：注解作用在源码阶段，字节码文件阶段，运行阶段不存在，默认值.
RUNTIME：注解作用在源码阶段，字节码文件阶段，运行阶段（开发常用）

2.3 内置注解

Java中有三种内置注解，这些注解用来为编译器提供指令,它们是:

@Deprecated

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

可以用来标记类，方法，属性;

@Override

用来修饰对父类进行重写的方法。如果一个并非重写父类的方法使用这个注解，编译器将提示错误。

实际上在子类中重写父类或接口的方法，@Overide并不是必须的。但是还是建议使用这个注解，在某些情况下，假设你修改了父类的方法的名字，那么之前重写的子类方法将不再属于重写，如果没有@Overide，你将不会察觉到这个子类的方法。有了这个注解修饰，编译器则会提示你这些信息

@SuppressWarnings

用来抑制编译器生成警告信息

可以修饰的元素为类，方法，方法参数，属性，局部变量

当我们一个方法调用了弃用的方法或者进行不安全的类型转换，编译器会生成警告。我们可以为这个方法增加@SuppressWarnings注解，来抑制编译器生成警告。

注意：使用@SuppressWarnings注解，采用就近原则，比如一个方法出现警告，我们尽量使用@SuppressWarnings注解这个方法，而不是注解方法所在的类。虽然两个都能抑制编译器生成警告，但是范围越小越好，因为范围大了，不利于我们发现该类下其他方法的警告信息

//告诉编译器忽略 unchecked 警告信息，如使用List，ArrayList等未进行参数化产生的警告信息。
@SuppressWarnings(“unchecked”)

//如果编译器出现这样的警告信息：The serializable class WmailCalendar does not declare a     //static final serialVersionUID field of type long，使用这个注释将警告信息去掉。
@SuppressWarnings(“serial”)

//如果使用了使用@Deprecated注释的方法，编译器将出现警告信息。使用这个注释将警告信息去掉。
@SuppressWarnings(“deprecation”)

//rawtypes是说传参时也要传递带泛型的参数 
@SuppressWarnings(“rawtypes”) 

//抑制所有类型的警告：
@SuppressWarnings(“all”)

3：注解的应用

3.1解析注解的技巧

注解在哪个成分上，我们就先拿哪个成分对象。
比如注解作用成员方法，则要获得该成员方法对应的Method对象，再来拿上面的注解
比如注解作用在类上，则要该类的Class对象，再来拿上面的注解
比如注解作用在成员变量上，则要获得该成员变量对应的Field对象，再来拿上面的注解

3.2应用举例

创建GoodBook注解类

package annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//          类                  方法
@Target({ElementType.TYPE,ElementType.METHOD,ElementType.CONSTRUCTOR})//表示该注解只能放到类型上  类
@Retention(RetentionPolicy.RUNTIME)
public @interface GoodBook {

    String name() ;
    String [] authors();
    double price();
}

创建测试类

package annotation;

import java.lang.reflect.Method;
import java.util.Arrays;

@GoodBook(name="水浒传",authors = {"施耐庵","高启强"},price = 99)
public class AnnotationDemo3 {

    @GoodBook(name="西游记",authors = {"吴承恩"},price = 50)
    public void show(){

    }

    @GoodBook(name="水浒传",authors = {"施耐庵"},price = 99)
    public AnnotationDemo3(){

    }
}
//注解的解析
class AnnotationDemo3Test{

    public static void main(String[] args) throws Exception {

//        fun1();
        fun2();
        }

    private static void fun2() throws Exception {
//        获取show方法上面的注解，将注解上面的属性值打印到控制台
//        获取类的字节码文件
        Class<AnnotationDemo3> c = AnnotationDemo3.class;
//        获取show方法Method
        Method show = c.getDeclaredMethod("show");
//        判断是否有指定的注解
        boolean f = show.isAnnotationPresent(GoodBook.class);
        if (f){
//            获取指定注解
            GoodBook book = show.getAnnotation(GoodBook.class);
            System.out.println(book.name());
            System.out.println(book.price());
        }

    }

    private static void fun1() {
        //获取到AnnotationDemo3类上面有个GoodBook注解的name属性值
//        获取到类的字节码文件
        Class<AnnotationDemo3> c = AnnotationDemo3.class;
//        判定指定目标上 是否有指定的注解
        boolean f = c.isAnnotationPresent(GoodBook.class);
        if (f){
//            获取类上面的注解
            GoodBook goodBook = c.getAnnotation(GoodBook.class);
            System.out.println(goodBook.name());
            String [] authors = goodBook.authors();
            System.out.println(Arrays.toString(authors));
    }


}
}