类加载+注解

---

类加载器

• 类加载：当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始 化这三个步骤来对类进行初始化。
• 类加载器的作用：负责将.class文件加载到内存中，并为之生成对应的 java.lang.Class 对象。

类加载器工作机制

类加载过程（生命周期）：加载，验证，准备，解析，初始化

• 类的加载
  • 指将class文件读入内存，并为之创建一个 java.lang.Class 对象
  • 任何类被使用时，系统都会为之建立一个 java.lang.Class 对象
  • 简称：将Java二进制代码导入jvm中，生成Class文件
• 类的连接
  • 验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
    • 简称：检查载入Class文件数据的正确性
  • 准备阶段：负责为类的类变量分配内存，并设置默认初始化值
    • 简称：给类的静态变量分配存储空间
  • 解析阶段：将类的二进制数据中的符号引用替换为直接引用
    • 简称：将符号引用转成直接引用
• 类的初始化
  • 假如类还未被加载和连接，则程序先加载并连接该类
  • 假如该类的直接父类还未被初始化，则先初始化其直接父类
  • 假如类中有初始化语句，则系统依次执行这些初始化语句

JVM的类加载机制

• 全盘负责：就是当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载 器负责载入，除非显示使用另外一个类加载器来载入
• 父类委托：就是当一个类加载器负责加载某个Class时，先让父类加载器试图加载该Class，只有在父类加载器 无法加载该类时才尝试从自己的类路径中加载该类
• 缓存机制：保证所有加载过的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜 索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存储到缓存区

反射

• 反射是指对于任何一个Class类，在"运行的时候"都可以直接得到这个类全部成分。
  • 在运行时,可以直接得到这个类的构造器对象：Constructor
  • 在运行时,可以直接得到这个类的成员变量对象：Field
  • 在运行时,可以直接得到这个类的成员方法对象：Method
• 反射的关键：
  反射的第一步都是先得到编译后的Class类对象，然后就可以得到Class的全部成分。

Java获取反射的三种方法

• 使用类的class属性来获取该类对应的Class对像。举例：Student·class会返回Student类对应的Class对像
  类名.class属性
• 调用对象的getClass（）方法，返回该对像所属类对应的Class对像
  该方法是0bject类中的方法，所有的java对象都可以调用该方法
  对象名.getClass()方法
• 使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也新是完整包名的路径
  Class.forName( 全类名 ) 方法

public class Student {
    private int id;
    String name;
    protected boolean sex;
    public float score;
}

public class Get {
    //获取反射机制三种方式
    public static void main(String[] args) throws ClassNotFoundException {
        //调用对象的getClass()方法，返回该对象所属类对应的Class对象
        Student stu = new Student();
        Class classobj1 = stu.getClass();
        System.out.println(classobj1.getName());
        //使用Class类中的静态方法forName(String className)
        //获得字符串所标识的类的class对象
        Class classobj2 = Class.forName("fanshe.Student");
        System.out.println(classobj2.getName());
        //使用类的class属性来获取该类对应的Class对象
        Class classobj3 = Student.class;
        System.out.println(classobj3.getName());
    }
}

反射机制优缺点

• 优点： 运行期类型的判断，动态加载类，提高代码灵活度。
• 缺点： 性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多。

反射机制的应用场景有哪些？

• 反射是框架设计的灵魂。
• 模块化的开发，通过反射去调用对应的字节码；
• 动态代理设计模式也采用了反射机制;
• JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序；
• Spring／Hibernate 等框架也大量使用到了反射机制。
  • xml的配置模式。Spring 通过 XML 配置模式装载 Bean 的过程：
    • 将程序内所有 XML 或 Properties 配置文件加载入内存中;
    • Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息;
    • 使用反射机制，根据这个字符串获得某个类的Class实例;
    • 动态配置实例的属性

反射为何可以给约定了泛型的集合存入其他类型的元素？

• 编译成Class文件进入运行阶段的时候，泛型会自动擦除。
• 反射是作用在运行时的技术，此时已经不存在泛型了。

反射的作用

• 可以在运行时得到一个类的全部成分然后操作。
• 可以破坏封装性。（很突出）
• 也可以破坏泛型的约束性。（很突出）
• 更重要的用途是适合：做Java高级框架
• 基本上主流框架都会基于反射设计一些通用技术功能。

获取构造器

• Constructor getConstructor(Class… parameterTypes)
  根据参数匹配获取某个构造器，只能拿public修饰的构造器
• Constructor getDeclaredConstructor(Class… parameterTypes)
  根据参数匹配获取某个构造器，只要申明就可以定位，不关心权限修饰符
• Constructor[] getConstructors()
  获取所有的构造器，只能拿public修饰的构造器
• Constructor[] getDeclaredConstructors()
  获取所有申明的构造器，只要你写我就能拿到，无所谓权限

package 反射.构造方法;

import org.junit.Test;
import 反射.Student;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo01 {
    // 1. getConstructors:
    // 获取全部的构造器：只能获取public修饰的构造器。
    // Constructor[] getConstructors()
    @Test
    public void getConstructors(){
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.提取类中的全部的构造器对象(这里只能拿public修饰)
        Constructor[] constructors = c.getConstructors();
        // c.遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }


    // 2.getDeclaredConstructors():
    // 获取全部的构造器
    @Test
    public void getDeclaredConstructors(){
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.提取类中的全部的构造器对象
        Constructor[] constructors = c.getDeclaredConstructors();
        // c.遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    // 3.getConstructor(Class... parameterTypes)
    // 获取某个构造器：只能拿public修饰的某个构造器
    @Test
    public void getConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器 只能拿public修饰的某个构造器)
        Constructor cons = c.getConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());
    }


    // 4.getConstructor(Class... parameterTypes)
    // 获取某个构造器
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器)
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());

        // c.定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());

    }

}

创建对象

• Constructor类中用于创建对象的方法
  • T newInstance(Object… initargs) 根据指定的构造方法创建对象
  • public void setAccessible(boolean flag) 设置为true,表示取消访问检查，进行暴力反射

public class ReflectDemo011 {
    // 1.调用构造器得到一个类的对象返回。
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器)
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());

        // 如果遇到了私有的构造器，可以暴力反射
        cons.setAccessible(true); // 权限被打开

        Student s = (Student) cons.newInstance();
        System.out.println(s);

        System.out.println("-------------------");

        // c.定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());

        Student s1 = (Student) cons1.newInstance("哈哈", 10);
        System.out.println(s1);
    }

}

获取方法

• Method getMethod(String name,Class…args);
  根据方法名和参数类型获得对应的方法对象，只能获得public的

• Method getDeclaredMethod(String name,Class…args);
  根据方法名和参数类型获得对应的方法对象，包括private的

• Method[] getMethods();
  获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的

• Method[] getDeclaredMethods();
  获得类中的所有成员方法对象，返回数组,只获得本类申明的方法。

• Method的方法执行：

  • Object invoke(Object obj, Object… args)
  • 参数一：触发的是哪个对象的方法执行。
    参数二： args：调用方法时传递的实际参数

package 反射.成员方法;

import org.junit.Test;



import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectDemo01 {

        /**
         * 1.获得类中的所有成员方法对象
         */
        @Test
        public void getDeclaredMethods(){
            // a.获取类对象
            Class c = Student.class;
            // b.提取全部方法；包括私有的
            Method[] methods = c.getDeclaredMethods();
            // c.遍历全部方法
            for (Method method : methods) {
                System.out.println(method.getName() +" 返回值类型：" + method.getReturnType() + " 参数个数：" + method.getParameterCount());
            }
        }

        /**
         * 2. 获取某个方法对象
         */
        @Test
        public void getDeclardMethod() throws Exception {
            // a.获取类对象
            Class c = Student.class;
            // b.提取单个方法对象
            Method m = c.getDeclaredMethod("method");
            Method m2 = c.getDeclaredMethod("method", String.class);

            // 暴力打开权限了
            m.setAccessible(true);
            m2.setAccessible(true);

            // c.触发方法的执行
            Student d = new Student();
            // 注意：方法如果是没有结果回来的，那么返回的是null.
            Object result = m.invoke(d);
            System.out.println(result);

            Object result2 = m2.invoke(d, "好好学习");
            System.out.println(result2);
        }
    }

获取成员变量

• Field getField(String name);
  根据成员变量名获得对应Field对象，只能获得public修饰
• Field getDeclaredField(String name);
  根据成员变量名获得对应Field对象，只要申明了就可以得到
• Field[] getFields();
  获得所有的成员变量对应的Field对象，只能获得public的
• Field[] getDeclaredFields();
  获得所有的成员变量对应的Field对象，只要申明了就可以得到

获取全部成员变量：getDeclaredFields
获取某个成员变量：getDeclaredField

package 反射.成员变量;

import org.junit.Test;
import 反射.Student;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;



public class ReflectDemo01 {
       /**
         * 1.获取全部的成员变量。
         * Field[] getDeclaredFields();
         *  获得所有的成员变量对应的Field对象，只要申明了就可以得到
         */
        @Test
        public void getDeclaredFields(){
            // a.定位Class对象
            Class c = Student.class;
            // b.定位全部成员变量
            Field[] fields = c.getDeclaredFields();
            // c.遍历一下
            for (Field field : fields) {
                System.out.println(field.getName() + "==>" + field.getType());
            }
        }

        /**
         2.获取某个成员变量对象 Field getDeclaredField(String name);
         */
        @Test
        public void getDeclaredField() throws Exception {
            // a.定位Class对象
            Class c = Student.class;
            // b.根据名称定位某个成员变量
            Field f = c.getDeclaredField("age");
            System.out.println(f.getName() +"===>" + f.getType());
        }

 }

取值和赋值

• void set(Object obj, Object value)：给对象注入某个成员变量数据
• Object get(Object obj):获取对象的成员变量的值。
• void setAccessible(true);暴力反射，设置为可以直接访问私有类型的属性。
• Class getType(); 获取属性的类型，返回Class对象。
• String getName(); 获取属性的名称。

package 反射.成员变量;

import org.junit.Test;
import 反射.Student;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;


public class ReflectDemo02 {
	  @Test
	   public void setField() throws Exception {
	       // a.反射第一步，获取类对象
	       Class c = Student.class;
	
	       // b.提取某个成员变量
	       Field ageF = c.getDeclaredField("age");
	
	       ageF.setAccessible(true); // 暴力打开权限
	
	       // c.赋值
	       Student s = new Student();
	       ageF.set(s , 18);  // s.setAge(18);
	       System.out.println(s);
	
	       // d、取值
	       int age = (int) ageF.get(s);
	       System.out.println(age);
	
	   }
 }

注解

注解的作用

• 对Java中类、方法、成员变量做标记，然后进行特殊处理。
• 例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行

自定义注解

就是自己做一个注解来使用

public @interface 注解名称 {    
public 属性类型 属性名() default 默认值 ;
}

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

• @Target: t约束自定义注解可以标记的范围，约束自定义注解只能在哪些地方使用

  • 可使用的值定义在ElementType枚举类中

• @Retention：申明注解的生命周期

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

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

注解解析

注解的操作中经常需要进行解析，注解的解析就是判断是否存在注解，存在注解就解析出内容。

• Annotation: 注解的顶级接口，注解都是Annotation类型的对象
• AnnotatedElement:该接口定义了与注解解析相关的解析方法