Java学习笔记3——注解与反射

所有框架的底层：Mybatis、SpringBoot

1. 注解

Annotation是从JDK5.0开始引入的新技术。Annotation不是程序本身，可以对程序作出解释，可以被其他程序（如编译器）读取。Annotation的格式以“public @注释名”在代码中存在，还可以添加一些参数值，例如@SuppressWarnings(value=“unchecked”)。Annotation可以附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息，可以通过反射机制编程实现对这些元数据的访问。

内置注解：

• @Override：定义在java.lang.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。
• @Deprecated：定义在java.lang.Deprecated中，此注释可以用于修辞方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为很危险或有更好选择。
• @SuppressWarnings：定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息，但需要添加参数才能使用，参数已经定义好了：
  • @SuppressWarnings(“all”)
  • @SuppressWarnings(“unchecked”)
  • @SuppressWarnings(value={“unchecked”,“deprecation”})
  • ……

**元注解：**注解其他注解meta-annotation

• @Target：用于描述注解的使用范围
• @Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE<CLASS<RUNTIME）
• @Document：说明该注解将被包含在Javadoc中
• @Inherited：说明子类可以继承分类中的该注解

注意：
其中的每一个方法实际上是声明了一个配置参数，方法的名称就是参数的名称，返回值的类型就是参数的类型（class、string、enum），可以通过default来声明参数的默认值，如果只有一个参数成员，一般参数名为value。注解元素必须要有值，定义注解元素时，经常使用空字符串，0作为默认值。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
public class Test{
	@MyAnnotation(name="a")//如果没有默认值必须赋值，否则报错
	public void test(){
	}
}
//一个类只能有一个public？
@Target(value={ElementType.METHOD,ElementType.TYPE})
@Retention(value=RetentionPolicy.RUNTIME)
@interface MyAnnotation{
	//注解参数：参数类型 参数名()//不是方法
	String name() default "";
	int id() default -1;//如果默认值为-1，代表不存在
}

2. 反射

静态	动态语言
静态语言与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活。	动态语言是一类在运行时可以改变其结构的语言：例如新的函数、对象、代码可以被引进，已有的函数可以被删除或是其他结构上的变化，即运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python等。

Reflection反射机制允许程序在执行期借助API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。如判断任意对象所属的类；构造任意一个类的对象；判断任意类所具有的成员变量和方法；获取泛型信息；调用任意对象的成员变量和方法；处理注解；动态代理。
主要API：java.lang.Class；java.lang.reflect.Method；java.lang.reflect.Field；java.lang.reflect.Constructor
优点：实现动态创建对象和编译；
缺点：对性能有影响，这类操作总是慢于直接执行相同的操作。

public class Test{
	public static void main(String[] args){
		Class c = Class.forName("com.reflect.User");
		System.out.println(c);
		//一个类在内存中只有一个class对象，一个类被加载后，整个类的结构都会被封装在Class对象中。用hashcode判断
}
class User{
	private String name;
	private int id;
	private int age;
	public User(){
	}
	public User(String name,int id,int age){
		this.name = name;
		this.id = id;
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}
	public int getId(){
		return id;
	}
	public void setId(int id){
		this.id = id;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age = age;
	}
	@Override
	public String toString(){
		return "user("+name+id+age;
	}
}

方法名	功能说明
static ClassforName(String name)	返回指定类名name的Class对象
Object newInstance()	调用缺省构造函数，返回Class对象的一个实例
getName()	返回此Class对象所表示的实体（类、接口、数组类或void）的名称
Class getSuperClass()	返回当前Class对象的父类的Class对象
Class[] getinterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Constructor[] getConstructors()	返回一个包含某些Constructor对象的数组
Method getMethod(String name,Class…T)	返回一个Method对象，此对象的形参类型为paramType
Field[] getDeclaredFields()	返回Field对象的一个数组

//测试class类的创建方式有哪些
public class Test{
	public static void main(String[] args) throws ClassNotFoundException {
		Person person = new Student();
		System.out.println("这个人是："+person.name);
		//方式一：通过对象获得
		class c1 = person.getClass();
		//方式二：forname获得
		Class c2 = class.forname("com.reflection.student");//抛出异常
		//方式三：通过类名.class获得
		Class c3 = Student.class;
		//方式四：基本内置类型的包装类都有一个Type属性
		Class c4 = Integer.TYPE;
		//获得父类类型
		Class c5 = c1.getSuperclass();
	}
}
class Person{
	public String name;
	public Person(){
	}
	public Person(String name){
		this.name = name;
	}
	@Override
	public String toString(){
		return "Person{"+"name="+name+"}";
	}
}
class Student extends Person{
	public Student(){
		this.name = "学生";
	}
}

有哪些类型可以有class对象？

• class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
• interface：接口
• []：数组——只要元素类型和维度一样，就是同一个class
• enum：枚举
• annotation：注解
• primitive type：基本数据类型
• void

3. 类的加载过程

什么时候会发生类初始化？

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

4. 类加载器的作用

• 类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
• 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
• 类加载器是用来

JVM规范定义了如下类型的类的加载器：

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

//获取系统类的加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
//获取系统类加载器的父类加载器——>拓展类加载器
ClassLoader parent = systemClassLoader.getParent();
//获取扩展类加载器的父类加载器——>根加载器（C/C++）
ClassLoader parent1 = parent.getParent(); //null
//如何获得系统类加载器可以加载的路径
System.out.println(System.getProperty("java.class.path"));
//双亲委派机制，多重检测是否写了重复包，

5. 获取类的运行时结构

c1.getFields()//只能找到public属性
c1.getDeclaredFields()//找到全部的属性
c1.getMethods();//获得本类及父类全部的public方法
c1.getDeclaredMethods();//获取本类的所有方法
c1.getConstructors();//public方法
c1.getDeclaredConstructors();//全部方法

6. 动态创建对象执行方法

创建类的对象：调用Class对象的newInstance()方法：

• 类必须有一个无参数的构造器；
• 类的构造器的访问权限需要足够；
• 难道没有无参的构造器就不能创建对象？需在操作时明确调用类中的构造器，并将参数传递进去，才可以实例化操作，步骤如下：
  1）通过Class类的getDeclaredConstructor(Class … paramterTypes)取得本类的指定形参类型的构造器；
  2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数；
  3）通过Constructor实例化对象。

public class Test {
	public static void main(String[] args) {
		Class c1 = Class.forName("com.reflection.User");//获得class对象
		User user = (User)c1.newInstance();//构造一个对象，本质是调用了无参构造器
		System.out.println(user);
		//通过构造器创建对象
		Constructor constructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
		User user1 = (User)constructor.newInstance("zr",001,18);
		System.out.println(user1);
		//通过反射调用方法
		User user2 = (User)c1.newInstance();
		Method setName = c1.getDeclaredMethod("setName",String.class);
		setName.invoke(user2,"za");//invoke:激活（对象，方法的值）
		System.out.println(user3.getName());
		//通过反射操作属性：不能直接操作私有属性，须关闭安全检查
		User user3 = (User)c1.newInstance();
		Field name = c1.getDeclaredField("name");
		name.setAccessible(true);//权限——关闭安全检查
		name.set(user4,"za2");
		System.out.println(user4.getName());
	}
}

性能分析

• 设置时间点
• 10亿次

关闭检查后可以提高反射方式的性能。

7. 反射操作泛型

Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
为了通过反射操作这些类型，Java新增了ParameterizedType、GenericArrayType、TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。

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

public class Test {
	//参数泛型
	public void test(Map<String,User> map, List<User> list) {
		System.out.println("test1");
	}
	//返回值泛型
	public Map<String,User> test2() {
		System.out.println("test2");
		return null;
	}
	public static void main(String[] args) throws NoSuchMethodException {
		Method method = Test.class.getMethod("test",Map.class,List.class);
		Type[] genericParameterTypes = method.getGenericParameterTypes();
		for (Type genericParameterType : genericParameterTypes) {
			System.out.println("#"+genericParameterType);
			if (genericParameterType instanceof ParameterizedType){
				Type[] actualTypeArguments = ((ParameterizedType) genericParameterType().getActualTypeArguments();
				for (Type actualTypeArgument : actualTypeArguments) {
					System.out.println( actualTypeArgument);
				}
			}
		}
	}	
}

8. 反射操作注解

ORM，Object relationship mapping，对象关系映射
类和表结构对应
属性和字段对应
对象和记录对应
——利用注解和反射完成类和表结构的映射关系

public class Test{
	public static void main(String[] args) {
		Class c1 = Class.forName("com.reflection.student");
		Annotation[] annotations = c1.getAnnotations();
		for (Annotation annotation : annotations) {
			System.out.println(annotation);
		}
		//获得注解的value的值
		Table table = (Table)c1.getAnnotation(Table.class);
		String value = Table.value();
		System.out.println(value);
		//获得类指定的注解
		Field f = c1.getDeclaredField("name");
		Value annotation = f.getAnnotation(Value.class);
		System.out.println(annotation.ColumnName());
	}
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
	String value();
}
@Target(ElementType.Field)
@Retention(value=RetentionPolicy.RUNTIME)
@interface Value{
	String ColumnName();
	String type();
	int length();
}

@Table("db_student")
class Student{
	@Value(ColumnName="db_name",type="varchar",length=3)
	private String name;
	//……
}