注解和反射

一、注解

1）什么是注解

• Annotation（JDK5.0开始引入的新技术）
  • 不是程序本身，但可以对程序作出解释
  • 可以被其他程序（如编译器）读取
  • 可以附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问
• 例：@SuppressWarnings(value={“unchecked”,“deorecation”})

2）内置注解

• @Override：定义在java.lang.Override中，只能修饰方法，重写
• @Deprecated：定义在java.lang.Deprecated中，能修饰方法、属性、类，表示不鼓励程序员使用这样的元素
• @SuppressWarnings(“all”)：定义在java.lang.SupressWarnings中，用来抑制编译时的警告信息，需要添加一个参数才能正确使用，这些参数都是已经定义好的，有all、unchecked、deprecation等

3）元注解

• meta-annotation的作用

  • 注解其他注解被用来提供对其他annotation类型作说明
  • 这些类型和它们所支持的类在java.lang.annotation包中可以找到

• 4个标准的meta-annotation类型

  • @Target：用来描述注解的使用范围
  • @Retention：表示需要在什么级别保存该注释信息（SOURSE<CLASS<RUNTIME）
  • @Document：说明该注解将被包含在javadoc中
  • @Inherited：说明子类可以继承父类中的该注解

4）自定义注解

• 使用@Interface自定义注解，自动继承了java.lang.annotation.Annotation接口
• 其中的每一个方法实际上是声明了一个配置参数，方法名就是参数名（如果只有一个参数成员，一般参数名为value，显式赋值时value可以省略，且只有value可以省略），返回值类型就是参数类型（只能是基本类型、Class、String、Enum）
• 可以通过default声明参数的默认值（经常使用空字符串、0作为默认值，如果默认值为-1，表示不存在），如果没有默认值，则不显式赋值会报错

// 自定义注解举例
@Target(value = ElementType.METHOD)
public @Interface MyAnnotation {
	String name();
}

// 自定义注解举例
@Target(value = {ElementType.METHOD, ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
@Document
@Inherited
public @Interface MyAnnotation {
	String name() default "";
	int id() default 0;
}

// 自定义注解的使用
@MyAnnotation(name = "lll", id = 111)
public void test(){
System.out.println("");
}

二、反射

1）反射概述

• 编程语言分类

  • 动态语言：在运行时可以改变其结构的语言，如Object-C、C#、JavaScript、PHP、Python等

    // 如JavaScript
    function f() {
    	var x = "var a=3;var b=5;alert(a+b)";
    	eval(x); // 执行上述代码，并返回值给x
    }
    

  • 静态语言：运行时结构不可变的语言，如Java、C、C++

  • “准动态语言”：Java可以利用反射机制获得类似动态语言的特性

• Java Relection

  • Reflection（反射）机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并直接操作任意对象的内部属性及方法。

    // 正常方式：引入需要的“包类”名称 -> 通过new实例化 -> 取得实例化对象
    // 反射方式：实例化对象 -> getClass()方法 -> 得到完整的“包类”名称
    

  • 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（Class对象只能由系统建立，一个类只有一个Class对象，一个Class对象对应的是一个加载到JVM中的class文件），一个类被加载后，类的整个结构都会被封装在Class对象中，通过Class可以完整地得到一个类中的所有被加载的结构。

    // 返回值类型是Class类（描述类的类），其他类都可以看做是Class类的对象，Class类是Java反射的源头
    Class c = Class.forName("java.lang.String");
    

  • 反射相关的主要API

    • java.lang.Class：代表一个类
    • java.lang.reflect.Method：代表类的方法
    • java.lang.reflect.Field：代表类的成员变量
    • java.lang.reflect.Constructor：代表类的构造器
    • …

2）Class类、Class对象

• 获取Class类的实例（Class对象）

  • 已知具体类，通过其class属性获取Class对象，该方法最为安全可靠，程序性能最高：Class clazz = Person.class;
  • 已知某个类的实例，通过调用其getClass()方法获取Class对象：Class clazz = person.getClass();
  • 已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException：Class clazz = Class.forName(“demo01.Student”);
  • 内置基本数据类型的包装类可以直接用TYPE获取：Integer.TYPE
  • 使用ClassLoader

• 哪些类型可以有Class对象

  • class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类，如Object.class, Class.class
  • interface：接口，如Comparable.class
  • []：数组，如int [] [].class（只要数组类型与维度相同，就是一个Class，不管长度相同与否）
  • enum：枚举，如ElementType.class
  • annotation：注解@interface，如Override.class
  • primitive type：基本数据类型，如Integer.class
  • void：如void.class

3）类加载过程

• 类的加载（Load）：类加载器将类的class文件字节码内容读入内存，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口

  （标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间，不过JVM垃圾回收机制可以回收这些Class对象）

  （双亲委派机制：自己定义的一个类要加载时，会从用户类加载器到扩展类加载器到跟加载器依次往上找，如果已经存在相同的类，则会用已有的类，自己定义的类无效）

  // 获取系统类加载器
  ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); // sun.misc.Launcher$AppClassLoader@18b
  4aac2
  // 获取系统类加载器的父类加载器：扩展类加载器
  systemClassLoader parent = systemClassLoader.getParent(); // sun.misc.Launcher$ExtClassLoader@4554617c
  // 获取扩展类加载器的父类加载器：根加载器
  systemClassLoader parent1 = parent.getParent(); // null
  // 获取自定义类的加载器：系统类加载器
  ClassLoader classLoader= Class.forName("com.kuang.reflection.Test07").getClassLoader(); // sun.misc.Launcher$AppClassLoader@18b
  4aac2
  // 获取内置类的加载器：根加载器
  classLoader= Class.forName("java.lang.Object").getClassLoader(); // null
  // 获取系统类加载器可以加载的路径
  System.getProperty("java.class.path"); // 非常多
  

  • 引导类加载器：C++编写的，JVM自带的类加载器，负责Java平台核心库，用来装载核心类库（在rt.jar包中）（该加载器无法直接获取）
  • 扩展类加载器：负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库
  • 系统类加载器：负责java -classpath或-D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器
  • 自定义类加载器：可以自己定义类加载器

• 类的链接（Link）：将Java类的二进制代码合并到JVM的运行状态（JRE）之中

  • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题
  • 准备：正式为类变量（static类型的变量）分配内存并设置类变量默认初始化值
  • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）

• 类的初始化（Initialize）：JVM对类进行初始化，执行类构造器<clinit>()方法（编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句，合并执行）

  （虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步）

  • 类的主动引用一定会发生类的初始化
    • 当虚拟机启动时，先初始化main方法所在的类
    • new一个类的对象
    • 调用类的静态成员（除了final常量）和静态方法，会发生类的加载
    • 使用java.lang.reflect包的方法对类进行反射调用
    • 当初始化一个类时，如果其父类还没有进行初始化，则需要先触发其父类的初始化
  • 类的被动引用不会发生类的初始化
    • 当访问一个静态域时，只有真正声明这个域的类才会被初始化，如通过子类引用父类的静态变量，不会导致子类初始化
    • 通过数组定义类引用，不会触发此类的初始化，如Son[] array = new Son[5]
    • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

4）动态获取运行时类的完整结构

• Class类的常用方法

  • 返回当前Class对象父类的Class对象：Class getSuperClass()

  • 获取Class对象的接口：Class[] getInterface()

  • 获取Class对象的类加载器：ClassLoader getClassLoader()

  • 获取此Class对象所表示的实体（类、接口、数组或void）的包名+类名、类名：String getName()、String getSimpleName()

  • 获得Class对象的public属性、全部属性、指定属性：Field[] getFields()、Field[] getDeclaredFields()、Field getDeclaredField(String fieldName)

  • 获得Class对象的本类及其父类的全部public方法、本类的全部方法、指定方法（没有形参则paramType传null）：Method[] getMethods()、Method[] getDeclaredMethods()、Method getMethod(String methodName, Class … paramType)

  • 获取Class对象的public构造器、所有构造器、指定构造器：Constructor[] getConstructors()、Constructor[] getDeclaredConstructors()、Constructor getDeclaredConstructor(Class … paramType)

5）动态创建运行时类的对象

• 调用Class对象的缺省构造函数，返回Class对象的一个实例：User user = (user)clazz.newInstance()
  • 类必须有一个无参数的构造器
  • 类的构造器的访问权限需要足够
• 利用有参构造器创建对象
  • 通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类指定形参类型的构造器：Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class, int.class)
  • 对于私有构造器，先关闭安全检测：constructor .setAccessible(true);
  • 通过Constructor实例化对象：User user = (user)constructor.newInstance(“秦疆”, 001, 18)

6）动态操作运行时类的对象

• 通过反射调用普通方法
  • 获取Class类实例：Class clazz = User.class;
  • 创建运行时类的对象：User user3 = (User)clazz.newInstance();
  • 通过反射获取一个方法：Method setName = clazz.getDeclaredMethod(“setName”, String.class); // 没有形参则传null
  • 对于私有方法，先关闭安全检测：setName.setAccessible(true);
  • 调用（激活）这个方法：setName.invoke(user3, “狂神3”);
• 各种方式调用方法性能对比分析
  • 普通方式执行10亿次：9ms
  • 反射方式执行10亿次：5699ms
  • 反射方式关闭安全检测执行10亿次：1959ms
• 通过反射操作属性
  • 获取Class类实例：Class clazz = User.class;
  • 创建运行时类的对象：User user4 = (User)clazz.newInstance();
  • 通过反射获取一个属性：Field name = clazz.getDeclaredField(“name”);
  • 对于私有属性，先关闭安全检测：name.setAccessible(true);
  • 设置属性值：name.set(user4, “狂神4”);

7）获取泛型信息

• Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去前置类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除

• 为了通过反射操作这些类型，Java新增了几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型

  • ParameterizedType：表示一种参数化类型，比如Collection<String>
  • GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
  • TypeVariable：是各种类型变量的公共父接口
  • WildcardType：代表一种通配符类型表达式

• 获取方法中泛型参数

  public class Test00 {
  	// 方法01
  	public void test01(Map<String,User> map, List<User> list){
  		System.out.println("test01");
  	}
  	// 方法02
  	public Map<String,User> test02(){
  		System.out.println("test02");
  	}
  
  	public static void main(String[] args) throws NoSuchMethodException {
  		// 获取方法01的泛型参数
  		Method method = Test00.class.getMethod("test01", Map.class, List.class);
  		Type[] genericParameterTypes = method.getGenericParameterTypes();
  		for (Type genericParameterType : genericParameterTypes) {
  			if (genericParameterType instanceof ParameterizedType) {
  				Type[] acturalTypeArguments = 			((ParameterizedType)genericParameterType).getActuralTypeArguments();
  				for (Type acturalTypeArgument : acturalTypeArguments){
  					System.out.println(acturalTypeArgument);
  				}
  			}
  		}
  		// 获取方法02的泛型参数
  		Method method1 = Test00.class.getMethod("test02", null);
  		Type[] genericReturnTypes = method.getGenericReturnTypes();
  		for (Type genericReturnType : genericReturnTypes) {
  			if (genericReturnType instanceof ParameterizedType) {
  				Type[] acturalTypeArguments = 			((ParameterizedType)genericReturnType).getActuralTypeArguments();
  				for (Type acturalTypeArgument : acturalTypeArguments){
  					System.out.println(acturalTypeArgument);
  				}
  			}
  		}
  	}
  
  }
  

8）获取注解信息

• ORM：Object relationship Mapping，对象映射关系

• 利用注解和反射可以完成类和表结构的映射关系

  // 类名的注解
  @Target(ElementType.Type)
  @Retention(RetentionPolicy.RUNTIME)
  @interface Tablekuang{
  	String value();
  }
  // 属性的注解
  @Target(ElementType.Field)
  @Retention(RetentionPolicy.RUNTIME)
  @interface Fieldkuang{
  	String columnName();
  	String type();
  	int length();
  }
  // 类（对应数据库中一张表）
  @Tablekuang("db_student")
  class Student{
  
  	@Fieldkuang(columnName = "db_id", type = "int", length = 10)
  	private int id;
  	@Fieldkuang(columnName = "db_age", type = "int", length = 10)
  	private int age;
  	@Fieldkuang(columnName = "db_name", type = "varchar", length = 3)
  	private String name;
  
  	...
  }
  // 反射操作注解
  public class Test {
  	Class clazz = Class.forName("com.kuang.reflection.Student");
  	// 通过反射获取注解
  	Annotation[] annotations = clazz.getAnnotions();
  	for (Annotation annotation : annotations){
  		System.out.println(annotation);
  	}
  	// 获取注解的value值
  	Tablekuang tablekuang = (Tablekuang)clazz.getAnnotation(Tablekuang.class);
  	String value = tablekuang.value();
  	// 获得指定类指定的注解
  	Field f = clazz.getDeclaredField("name");
  	Fieldkuang annotation = f.getAnnotation(Fieldkuang.class);	
     	System.out.println(annotation.columnName()+" "+annotation.type()+" "+annotation.length());	
  }