Java注解与反射图解

1、注解

1.1、注解入门

• 注释： 给程序员看。（注解：Annotation）
• 注解： 既可以给程序员看，也可以给程序看。（注解：comment）

1.1.1、什么是注解

1.1.2、元注解

1、 @Target： 描述注解能够作用的位置 （使用频率高）
    ElementType取值：
    TYPE：可以作用于类上
    METHOD：可以作用于方法上
    FIELD：可以作用于成员变量上
2、 @Retention： 描述注解被保留的阶段 （使用频率高）
   @Retention(RetentionPolicy.RUNTIME)：
   当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
3、@Documented：描述注解是否被抽取到API文档中
4、 @Inherited：描述注解是否被子类继承

1.2、自定义注解

1.2.1、概念

1.2.2、自定义注解案例

public class AnnotationTest01 {
    //注解可以显示复制，如果没有默认值，就必须要赋值
    @MyAnnotation( name = "Neil",schools = {"幼儿园A班", "学前班"})
    public void test(){

    }
    
    //只有一个参数的时候可以省略value
    @MyAnnotation1("Neil")
    public void test2(){

    }
}

//定义一个注解
//定义作用域只在方法上
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//表示注解在什么地方还有效（一般是RUNTIME）
// RUNTIME > CLASS > SOURCE
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    //注解的参数：参数类型 + 参数名()
    String name() default "";    //默认值为空
    int age() default 0;
    int id() default -1;  //如果默认值为-1，代表不存在
    String[] schools();
}

@Target(value = {ElementType.METHOD,ElementType.TYPE})
//表示注解在什么地方还有效（一般是RUNTIME）
// RUNTIME > CLASS > SOURCE
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation1{
    String value();  //如果只有一个参数最好用value命名
}

2、反射

2.1、语言分类

1.2、Reflection

1.2.1、基本原理

1.2.2、Java反射机制提供的功能

1.2.3、Java反射的优点和缺点

1.2.4、反射主要相关的API

1.2.5、Class类

1.2.6、获取Class类实例的方式

代码：

public class Test02 {
	public static void main(String[] args) throws ClassNotFoundException {
		Person1 person1 = new Student();
		System.out.println("这个人是: "+person1.name);
	
		//方式一 : 通过对象获得
		Class c1 = person1.getClass();
		System.out.println(c1.hashCode());
		
		//方式二 : forName获得
		Class c2= Class.forName("反射与注解.Student");
		System.out.println(c2.hashCode());
		
		//方式三 : 通过 类名.class 获得
		Class c3 = Student.class;
		System.out.println(c3.hashCode()+"\n");
		
		//获得父类类型
		Class c5 = c1.getSuperclass();
		System.out.println(c5);
	}
}

class Person1{
	public String name;
	
	public Person1() {
	}
	
	public Person1(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Person1 {" + 
				"name='" + name + '\'' +
				'}';
	}	
}

class Student extends Person1{
	public Student() {
		this.name = "学生";
	}
}

class Teacher extends Person1{
	public Teacher() {
		this.name = "老师";
	}
}

1.2.7、哪些类型可以有Class对象

1.2.8、案例

//所有类型的class
public class Test03 {
    public static void main(String[] args) {
        Class c1 = Object.class;       //类
        Class c2 = Comparable.class;   //接口
        Class c3 = String[].class;    //一维数组
        Class c4 = int[][].class;     //二维数组
        Class c5 = Override.class;    //注解
        Class c6 = ElementType.class; //枚举
        Class c7 = Integer.class;     //基本数据类型
        Class c8 = void.class;        //void
        Class c9 = Class.class;       //class

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        //只要 元素类型 与 维度一样 ， 就是同一个Class。
        int[] a = new int[5];
        int[] b = new int[10];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
    
}

结果：

1.3、Java内存分析

1.3.1、Java内存分类

堆：
  存放new的对象和数组
  可以被所有的线程共享，不会存放别的对象引用
栈：
  存放基本变量类型（会包含这个基本类型的具体数值）
  对象的引用（会存放这个引用在堆里面的具体地址，对象本身不在栈中）
方法区（特殊的堆）：
  可以被所有线程共享
  包含了所有的class和static变量

1.3.2、类加载的过程

1.3.3、类的加载与ClassLoader的理解

案例：

public class Test04 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
        /**
         * 1、加载到内存，会产生一个类对应的Class对象(从方法区到堆)
         * 2、链接，链接结束后 m = 0  （从堆到栈）
         * 3、初始化化 （从堆到栈）
         *      <clinit>(){
         *          System.out.println("a类静态代码块初始化");
         *          m = 300;
         *          int m = 100;
         *      }
         *      m = 100
         */
    }
}
class A{
    //首先初始化了静态代码块 m = 300
    //之后初始化了 m = 100
    static {
        System.out.println("a类静态代码块初始化");
        m = 300;
    }
    static int m = 100;
    public A() {
        System.out.println("A类的与参构造初始化");
    }
}

结果：

1.3.4、什么时候发生类的初始化

案例：

//类什么时候会被初始化
public class Test05 {

    static{
        System.out.println("Main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //1、主动引用：new一个对象（会发生类的初始化）
        Son son = new Son();
        
		//2、主动引用：反射 （会发生类的初始化）
        Class c1 = Class.forName("com.reflection.Son");
        
//      不会产生类的引用的方法，因为是子类调用父类的static常量
        //1、在这里父类会被初始化，但是子类不会被初始化
        System.out.println(Son.b);
        
		//2、数组只开辟了空间，也被命名了，但是没有加载任何类，不会发生类的初始化
        Son[] array = new Son[5];
        
		//3、常量，静态变量在链接阶段就被赋值并且调用到了常量池中了，所以调用时不会发生类的初始化
        System.out.println(Son.M);
    }
}

class Father{
    static int b = 2;
    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

1.3.5、类加载器的作用

类加载器包含：

案例：

public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取  系统类  的加载器
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader);

        //获取系统类加载器的父类加载器 --> 扩展类加载器
         ClassLoader parent = classLoader.getParent();
        System.out.println(parent);

        //无法扩展类加载器的父类 --> 引导类加载器

        //测试当前类是哪个加载器加载的（系统类加载器，也就是App加载器）
        ClassLoader classLoader1 = Class.forName("com.reflection.TestReflection07").getClassLoader();
        System.out.println(classLoader1);

        //测试Object类是哪个加载器加载的(引导类加载器)
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);

        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));

        //双亲委派机制
            //自定义一个包java.lang.string --> 先推系统类加载器是否有这个包，再往上推扩展加载器有没有这个包，最后是引导类加载器—
            //如果发现了同样名字的包，就不会使用自定义的包
    }
}

结果：

1.4、反射相关操作

1.4.1、反射获得运行时候类的完整结构

//获得类的信息
public class Test07 {
    public static void main(String[] args) throws Exception {
        //此处在com.reflection下面有一个User类，获取Class
        Class c1 = Class.forName("反射与注解.User");
        
/*
        //也可以用 实例 去获取Class
        User user = new User();
        c1 = user.getClass();
*/
        //1、获取类的名字
        System.out.println("========1========");
        System.out.println(c1.getName());      //获取: 包名 + 类名
        System.out.println(c1.getSimpleName());//获取: 类名 

        //2、获得类的属性
        System.out.println("========2========");
   //   Field[] fields = c1.getFields();  //只能找到public 属性

        Field[] fields = c1.getDeclaredFields();  //可以找到全部的属性(包括private属性)
        for (Field field : fields) {
            System.out.println(field);
        }

        //2.1 获得 User 指定属性
        System.out.println();
        Field name = c1.getDeclaredField("name");  //(因为User中name的属性是private，所以只能用getDeclaredField)
        System.out.println(name);

        //3、获得 User类 的方法
        System.out.println("========3========");
        Method[] methods = c1.getMethods();        //可以获得 本类 和 父类(Object) 的全部方法（不包括private方法）
        for (Method method : methods) {
            System.out.println("正常的 " + method);
        }

        //3.1 获得 User类 的方法所有方法
        methods = c1.getDeclaredMethods();      //获得User(本类)的所有方法(包括私有方法)
        for (Method method : methods) {
            System.out.println("DeclaredMethods " + method);
        }

        //3.2 获取指定方法  (根据参数来获得类)
        System.out.println("========3.2========");
        Method getName = c1.getMethod("getName", null);           //获得无参方法
        Method setName = c1.getMethod("setName", String.class);   //获得有参方法  参数类型String  所以是String.class
        System.out.println(getName);
        System.out.println(setName);

        //4、获得的构造器（
        System.out.println("========4========");
        Constructor[] constructors = c1.getConstructors();   //获得  public类型的构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        System.out.println();
        Constructor[] declaredConstructors = c1.getDeclaredConstructors();  //获得全部的构造器
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        
        //4.1 获取指定构造器   (根据参数来获得类)
        System.out.println("========4.1========");
        Constructor declaredconstructor= c1.getDeclaredConstructor(String.class,int.class,int.class);
        System.out.println("指定构造器: "+declaredconstructor ); 
    }
}

1.4.2、反射创建对象、调用方法、设置属性

小结：

重点是如何去使用：

案例：

//动态创建对象
public class Test08 {
    public static void main(String[] args) throws Exception{
        //获得Class对象
        Class c1 = Class.forName("反射与注解.User");

        //1、构造一个对象
        User user  = (User)c1.newInstance();   //本质上调用无参构造器
        System.out.println(user);

        //2、通过构造器创建对象
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user2  = (User) declaredConstructor.newInstance("疾风剑豪",170,6); //在创建的构造器里加具体的参数
        System.out.println(user2);

        //3、通过反射调用普通方法
        User user3 = (User)c1.getDeclaredConstructor().newInstance();
        //	通过一个 反射 获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user3,"亚索"); //invoke()激活这个方法; (对象,"方法的值(传入的参数)")
        System.out.println(user3.getName());

        //4、通过反射操作属性（不可直接操作私有属性）
        System.out.println("-----QAQ-----");
        User user4 = (User)c1.getDeclaredConstructor().newInstance();
        Field name = c1.getDeclaredField("name");
        //由于权限不够（name属性为private）,所以我们需要设置安全检测。关闭权限检查可以提高程序性能。setAccessible(true);
        name.setAccessible(true);
        name.set(user4,"瑞文");
        System.out.println(user4.getName());
    }
}

结果：

1.4.3、性能对比分析

//分析性能问
public class Test09 {
	
		//普通方法
		public static void test01() {
			User user = new User();
			
			long startTime = System.currentTimeMillis();
			
			for (int i = 0; i < 1000000000; i++) {
				user.getName();
			}
			
			long endTime = System.currentTimeMillis();
			
			System.out.println("普通方式执行10亿次: "+(endTime-startTime)+"ms");
		}
		
		//反射方法调用
		public static void test02() throws Exception {
			User user = new User();
			Class c1 = user.getClass();
			
			Method getName = c1.getDeclaredMethod("getName", null);
			
			long startTime = System.currentTimeMillis();
			
			for (int i = 0; i < 1000000000; i++) {
				getName.invoke(user,null);
			}
			
			long endTime = System.currentTimeMillis();
			
			System.out.println("反射方式执行10亿次: "+(endTime-startTime)+"ms");
		}
		
		
		//反射方式调用  关闭检测
		public static void test03() throws Exception{
			User user = new User();
			Class c1 = user.getClass();
			
			Method getName = c1.getDeclaredMethod("getName", null);
			getName.setAccessible(true);
			
			long startTime = System.currentTimeMillis();
			
			for (int i = 0; i < 1000000000; i++) {
				getName.invoke(user,null);
			}
			
			long endTime = System.currentTimeMillis();
			
			System.out.println("关闭检测执行10亿次: "+(endTime-startTime)+"ms");
		}
		
		public static void main(String[] args) throws Exception {
			test01();
			test02();
			test03();
		}
}

输出结果：

1.4.4、反射操作泛型

案例：

//通过反射获取泛型
public class Test10 {
    public void test01(Map<String,User> map, List<User> list){
        System.out.println("test01");
    }

    public Map<String,User> test02(){
        System.out.println("test02");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = TestReflection10.class.getMethod("test01", Map.class, List.class);
        //获得参数重泛型信息
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println(genericParameterType);
            System.out.println("=============");
            //获得真实的泛型信息
            if(genericParameterType instanceof ParameterizedType){
                for (Type actualTypeArgument : ((ParameterizedType) genericParameterType).getActualTypeArguments()) {
                    System.out.println(actualTypeArgument);
                }

            }
        }
        //获得返回值泛型信息
        System.out.println("--------------------------" );
        Method method2 = TestReflection10.class.getMethod("test02");
        Type genericReturnType = method2.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType){
            for (Type actualTypeArgument : ((ParameterizedType) genericReturnType).getActualTypeArguments()) {
                System.out.println(actualTypeArgument);
            }

        }
    }
}

1.4.5、反射操作注解

案例：

//练习反射操作注解
public class Test11 {
    public static void main(String[] args) throws Exception {
        Class c1 = Class.forName("反射与注解.Student2");
        
        Annotation[] annotations = c1.getAnnotations();
        //通过反射获得注解
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获得注解Value值
        TableZsl tableZsl = (TableZsl)c1.getAnnotation(TableZsl.class);
        System.out.println(tableZsl.value());

        //获得类指定的注解和值
        Field f = c1.getDeclaredField("id");
        FieldZsl annotation = f.getAnnotation(FieldZsl.class);
        System.out.println(annotation.colName());
        System.out.println(annotation.length());
        System.out.println(annotation.type());
    }
}

@TableZsl("db_student2")
class Student2 {
    //通过注解可以操作表
    @FieldZsl(colName = "db_id",type = "int",length = 10)
    private int id;
    @FieldZsl(colName = "db_age",type = "int",length = 10)
    private int age;
    @FieldZsl(colName = "db_name",type = "varchar",length = 10)
    private String name;

    public Student2() {
    }

    public Student2(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", 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;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

//类名的注解
@Target(ElementType.TYPE)     //作用域: 类
@Retention(RetentionPolicy.RUNTIME)   //生命周期
@interface TableZsl{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)   //作用域: 成员变量
@Retention(RetentionPolicy.RUNTIME)
@interface FieldZsl{
    String colName();
    String type();
    int length();
}

输出结果：

终章： 完结撒花~~~