javaSE基础-反射

反射

Java反射机制概述

Reflection（反射）：是java语言体现动态性的关键，反射机制允许程序在执行期借助于Reflection API取任何类的内部信息，并能直接操作任意对象的内部信息属性及方法。

java类正常加载与反射区别示意图

动态语言 VS 静态语言

Java不是动态语言，但Java有一定的动态性。可以利用反射机制、字节码操作获得类似动态语言的特性，让Java编程更加灵活。

反射应用场景：框架 = 反射 + 注解 + 设计模式

Java反射机制的动态性的体现

@Test
public void test2(){
    for (int i = 0; i < 10; i++) {
        int num = new Random().nextInt(3);
        String classPath="";
        switch(num){
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath="com.bingeone.javaSE.ReflectDemo.Person";
                break;
            case 2:
                classPath="java.lang.Object";
                break;
        }
        Object instance = null;
        try {
            instance = getInstance(classPath);
            System.out.println(instance);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

/**
     * 创建一个指定类的对象
     * classPath:指定类的全类名
     */
public Object getInstance(String classPath) throws Exception {
    Class<?> clazz = Class.forName(classPath);
    Object newInstance = clazz.newInstance();
    return newInstance;
}

注：主要的特点是在运行时动态加载具体某个类的对象

java反射机制提供的功能

• 在运行时判断任意一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时判断任意一个类所具有的成员变量和方法
• 运行时获取泛型信息
• 在运行时调用任意一个对象的成员变量和方法
• 在运行时处理注解
• 生成动态代理

相关的API

java.lang.Calss:反射的源头

java.lang.reflect

理解Class类并获取Class实例

1、类的加载过程

程序经过javac.exe命令之后，会生成一个或多个字节码文件(.class结尾)，接着使用java.exe命令对某个字节码文件进行解析运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，称为运行时类，此运行时类就作为Class的一个实例

2、Class实例就对应一个运行时类

3、加载到内存中的运行时类，会缓存一段时间。在此时间内，我们可以通过不同的方式来获取运行时类

获取Class实例的四种方式

@Test
public void test3() throws ClassNotFoundException {
    //方式一：通过运行时类的属性：（.class）获取
    Class<Person> clazz1 = Person.class;
    System.out.println(clazz1);

    //方式二:运行时类的对象，调用方法getClass()
    Person p1 = new Person();
    Class<? extends Person> clazz2 = p1.getClass();
    System.out.println(clazz2);

    //方式三:调用Class的静态方法：forName(String classPath)
    Class<?> clazz3 = Class.forName("com.bingeone.javaSE.ReflectDemo.Person");
    System.out.println(clazz3);

    //方式四：使用类的加载器：ClassLoader
    ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    Class clazz4 = classLoader.loadClass("com.bingeone.javaSE.ReflectDemo.Person");
    System.out.println(clazz4);

}

创建类的对象的方式

Class类实例可以有哪些结构

@Test
public void test4(){
    Class<Object> c1 = Object.class;
    Class<Comparable> c2 = Comparable.class;
    Class<String[]> c3 = String[].class;
    Class<int[][]> c4 = int[][].class;
    Class<ElementType> c5 = ElementType.class;
    Class<Override> c6 = Override.class;
    Class<Integer> c7 = int.class;
    Class<Void> c8 = void.class;
    Class<Class> c9 = Class.class;

    int[] a = new int[10];
    Class<? extends int[]> c10 = a.getClass();
    int[] b = new int[100];
    Class<? extends int[]> c11 = b.getClass();
    //只要数组的元素类型与维度一样，就是同一个Class
    System.out.println(c10 == c11);//true
}

总结：

• class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
• interface：接口
• []:数组
• enum：枚举
• annotation：注解@interface
• primitive type：基本数据类型
• void

类的加载与ClassLoader的理解

类的加载过程

说明：

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与

链接：将Java类的二进制代码合并到JVM的运行状态之中的过程

• 验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题
• 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
• 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程

初始化：

• 执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的（类构造器是构造类信息的，不是构造该类对象的构造器）
• 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
• 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步

类的加载器作用

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

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

类加载器的分类

引导类加载器：用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取

扩展类加载器：负责jre/lib/ext目录下的jar包或指定目录下jar包装入工作室

系统加载器：负责java -classpath 或 自定义目录下的类与jar包装入工作，是最常用的加载器

Java类编译、运行的执行流程

读取配置文件properites的方式

@Test
public void test2() throws IOException {
    Properties pro = new Properties();
    //方式一：
    //FileInputStream():文件位置默认在module下
    FileInputStream fis = new FileInputStream("jdbc.properties");
    pro.load(fis);

    //方式二：使用ClassLoader
    //加载文件默认位置在当前module的src下
    ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
    pro.load(is);

    String user = pro.getProperty("user");
    String password = pro.getProperty("password");
    System.out.println("user=" + user + ", password=" + password);
}

创建运行时类的对象

NewInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器

创建Class实例的对象

@Test
public void test1() throws InstantiationException, IllegalAccessException {

    Class<Person> clazz = Person.class;
    Person person = clazz.newInstance();
    System.out.println(person);
}

正确创建运行时类的对象的要求：

1、运行时类必须提供空参的构造器

2、空参的构造器的访问权限至少是默认权限，通常为public

Javabean中要求提供一个public的空参构造器的原因

1、便于通过反射，创建一个运行时类对象

2、便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器

获取运行时类的完整结构

通过反射机制，获取对应的运行时类中所有的属性、方法、构造器、父类、接口、父类的泛型、包、注解、异常等

获取属性

@Test
public void test1(){
    Class<Person> clazz = Person.class;
    //getFields():获取当前运行时类及其父类的public的字段
    Field[] fields = clazz.getFields();
    for (Field f : fields) {
        System.out.println(f);
    }

    System.out.println();
    //getDeclaredFields():获取当前运行时类中声明的所有属性。（不包括父类中声明的属性）
    Field[] declaredFields = clazz.getDeclaredFields();
    for (Field df : declaredFields) {
        System.out.println(df);
    }
}

//获取 权限修饰符 数据结构 变量名
@Test
public void test2(){
    Class<Person> clazz = Person.class;
    Field[] declaredFields = clazz.getDeclaredFields();
    System.out.println("权限修饰符" + "\t" + "数据结构" + "\t" + "变量名");
    for (Field df : declaredFields) {
        //权限修饰符
        int modifiers = df.getModifiers();
        System.out.print(Modifier.toString(modifiers) + "\t");

        //数据类型
        Class<?> type = df.getType();
        System.out.print(type + "\t");

        //变量名
        String name = df.getName();
        System.out.print(name);

        System.out.println();
    }
}

获取方法

@Test
public void test1(){
    Class<Person> clazz = Person.class;
    //getMethods():获取当前运行时类及其父类中声明为public权限的方法
    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
        System.out.println(method);
    }

    System.out.println();
    //getDeclaredMethods():获取当前运行时类的所有方法（不包括父类声明的）
    Method[] declaredMethods = clazz.getDeclaredMethods();
    for (Method declaredMethod : declaredMethods) {
        System.out.println(declaredMethod);
    }
}

获取构造器

@Test
public void test1(){
    Class<Person> clazz = Person.class;
    //getConstructors():获取运行时类中声明为public的构造器
    Constructor<?>[] constructors = clazz.getConstructors();
    for (Constructor<?> c : constructors) {
        System.out.println(c);
    }

    System.out.println();
    //getDeclaredConstructors():获取当前运行时类的所有的构造器
    Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
    for (Constructor<?> dc : declaredConstructors) {
        System.out.println(dc);
    }
}

获取运行时类的父类，带泛型的父类

@Test
public void test2(){
    Class<Person> clazz = Person.class;
    //运行时类的父类
    Class<? super Person> superclass = clazz.getSuperclass();
    	  System.out.println(superclass.getName());//com.bingeone.javaSE.ReflectDemo.exer.Creature

    //带泛型的父类
    Type genericSuperclass = clazz.getGenericSuperclass();
    String typeName = genericSuperclass.getTypeName();
    System.out.println(typeName);//com.bingeone.javaSE.ReflectDemo.exer.Creature<java.lang.String>

    //带泛型的父类的泛型
    Type genericSuperclass2 = clazz.getGenericSuperclass();
    ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass2;
    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
    System.out.println(((Class)actualTypeArguments[0]).getName());//java.lang.String
}

获取运行时类实现的接口、父类的接口

@Test
public void test3(){
    Class<Person> clazz = Person.class;
    //获取运行时类实现的接口
    Class<?>[] interfaces = clazz.getInterfaces();
    for (Class<?> i : interfaces) {
        System.out.println(i);
    }

    System.out.println();
    //获取运行时类父类实现的接口
    Class<?>[] interfaces1 = clazz.getSuperclass().getInterfaces();
    for (Class<?> aClass : interfaces1) {
        System.out.println(aClass);
    }
}

获取运行时类所在的包、声明的注解

@Test
public void test4(){
    Class<Person> clazz = Person.class;
    Package pack = clazz.getPackage();
    System.out.println(pack.getName());

    Annotation[] annotations = clazz.getAnnotations();
    for (Annotation ann : annotations){
        System.out.println(ann);
    }
}

调用运行时类的指定结构

实体类-Person.java

click me

public class Person {
    private String name;
    public int age;
	
    Person() {
        System.out.println("person()...");
    }
	
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
	
    private Person(String name) {
        this.name = name;
    }
	
    public String getName() {
        return name;
    }
	
    public void setName(String name) {
        this.name = name;
    }
	
    public int getAge() {
        return age;
    }
	
    public void setAge(int age) {
        this.age = age;
    }
	
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
	
    public void show(){
        System.out.println("Person show...");
    }
	
    private String showNation(String nation){
        System.out.println("People Nation is " + nation);
        return nation;
    }
}

获取运行时类指定的属性

@Test
public void testField2() throws Exception {
    //1、创建运行时类的实例对象
    Class<Person> clazz = Person.class;
    Person p = clazz.newInstance();
    //2、getDeclaredField(String name)：获取运行时类指定变量名的属性
    Field name = clazz.getDeclaredField("name");
    //3、设置当前属性可访问状态
    name.setAccessible(true);
    //设置属性值
    name.set(p,"Tom");
    //4、获取属性值
    String pname = (String) name.get(p);
    System.out.println(pname);
}

获取运行时类指定的方法

@Test
public void testMethod() throws Exception {
    //1、创建运行时类的对象
    Class<Person> clazz = Person.class;
    Person p = clazz.newInstance();
    //2、获取指定的某个方法
    //getDeclaredMethod():参数一：指定获取的方法的名，参数二：指明获取的方法的形参列表的类型
    Method m = clazz.getDeclaredMethod("show", String.class);
    //3、设置该方法可调用
    m.setAccessible(true);
    //4、invoke():方法没有返回值，默认为null；
    String nation = (String) m.invoke(p, "China");//此人的国籍：China
    System.out.println(nation);//China

    System.out.println("********静态方法的调用********");
    Method showDesc = clazz.getDeclaredMethod("showDesc");
    showDesc.setAccessible(true);
    Object returnVal = showDesc.invoke(p);//Person showDesc...
    System.out.println(returnVal);//null
}

获取运行时类指定的构造器

@Test
public void testConstructor() throws Exception{
    Class<Person> clazz = Person.class;
    //private Person(String name)
    //getDeclaredConstructor():参数指明构造器的参数列表类型
    Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class);
    //设置为可调用的
    constructor.setAccessible(true);
    Person p = constructor.newInstance("Jom");
    System.out.println(p);

}

注：反射通常使用无参构造器创建的对象

反射的应用：动态代理

代理设计模式的原理：

使用一个代理将对象包装起来，然后使用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上

静态代理

特点：

• 代理类和被代理类在编译期间就确定下来了，不利于程序的扩展
• 每个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理

//通用接口
interface ClothFactory{
    void produceCloth();
}

//代理类
class ProxyClothFactory implements ClothFactory{

    private ClothFactory factory;

    public ProxyClothFactory(ClothFactory factory){
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("工厂生产之前准备工作");
        factory.produceCloth();
        System.out.println("工厂生产之后的后续工作");
    }
}

//被代理类
class AntaClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Anti工厂生产一批运动服");
    }
}

//测试
public class StaticProxyTest {
    public static void main(String[] args) {
        AntaClothFactory anti = new AntaClothFactory();
        ProxyClothFactory factory = new ProxyClothFactory(anti);
        factory.produceCloth();
    }
}

动态代理

特点：客户通过代理类来调用其他对象的方法，并且是程序运行时根据需要动态创建目标类的代理对象

功能接口

//Human.java
interface Human{
    String getBelief();
    void eat(String food);
}

被代理类

//SuperMan.java
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}

面向切面编程（AOP）

//HumanUtil.java
class HumanUtil{
    public void method1(){
        System.out.println("================通用方法一================");
    }
    public void method2(){
        System.out.println("================通用方法二================");
    }
}

AOP代理方法示意图

动态代理（核心功能类）

/**
 * 实现动态代理，需要解决的问题？
 * 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象
 * 问题二：当通过代理类的对象调用方法时，如何动态的去调用被代理类中同名方法
 */
class ProxyFactory{
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj){//obj:被代理类的对象

        MyInvocationHandler handler = new MyInvocationHandler();

        handler.bind(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }

}

class MyInvocationHandler implements InvocationHandler{
    //需要使用被代理类的对象进行赋值
    private Object obj;

    public void bind(Object obj){
        this.obj= obj;
    }

    //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        HumanUtil humanUtil = new HumanUtil();
        humanUtil.method1();

        //method:即为代理类对象调用的方法，此方法也就作为了代理类对象哦要调用的方法
        //obj:被代理类的对象
        Object returnVal = method.invoke(obj,args);

        humanUtil.method2();
        return returnVal;
    }
}

测试

public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance：代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("牛排");

        System.out.println("*********动态代理体现==代理其他类**********");
        AntaClothFactory antaClothFactory = new AntaClothFactory();
        ClothFactory proxyInstance1 = (ClothFactory) ProxyFactory.getProxyInstance(antaClothFactory);//同一个动态代理类调用不同的被代理对象
        proxyInstance1.produceCloth();
    }
}

//结果
================通用方法一================
================通用方法二================
I believe I can fly!
================通用方法一================
我喜欢吃牛排
================通用方法二================
*********动态代理体现==代理其他类**********
================通用方法一================
Anti工厂生产一批运动服
================通用方法二================

动态代理又分为JDK动态代理 和 CGLib动态代理

	JDK	CGLib
作用	都是用来产生被代理对象的代理对象
实现接口	InvocationHandler	MethodInterceptor
实现原理	通过被代理类实现的接口来创建代理对象	通过构造被代理类的子类来创建代理对象
代理类	可以为实现了接口的类创建代理对象	可以为没被final修饰的类创建代理对象

JDK动态代理调用

//JDK动态代理
public class JDKDynamicProxy implements InvocationHandler {
   private Object obj;// 表示被代理对象
   public JDKDynamicProxy(Object o) {
      this.obj = o;
   }
 
   public Object getProxy() {
      //第一个参数：被代理对象的类的加载器
      //第二个参数：被代理对象实现的所有接口
      return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
   }
 
   public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
      // 代码1
      Object rv = method.invoke(obj, args);
      // 代码2
      return rv;
   }
}

JDKProxy dp2 = newJDKProxy(new House());
//产生的代理对象只能转换成被代理对象实现的接口
Person p = (Person)dp2.getProxy();
p.buy();

CGLib动态代理调用

//CGLib动态代理
public class CGLibDynamicProxy implements MethodInterceptor {
   private Object obj;
   public CGLibDynamicProxy(Object obj){
      this.obj = obj;
   }
  
   public Object getProxy(){
      Enhancer en = new Enhancer();
      en.setSuperclass(obj.getClass());
      en.setCallback(this);
      return en.create();
   }
  
   public Object intercept(Object obl, Method method, Object[] args,
        MethodProxy mp) throws Throwable {
      //代码1
      System.out.println("before");
      Object rv = method.invoke(obj, args);
      System.out.println("after");
      //代码2
      return rv;
   }
}

CGLibDynamicProxy dp = new CGLibDynamicProxy(new User());
//通过CGLib动态代理产生的代理对象可以强转成被代理对象本身
User user = (User)dp.getProxy();
user.print();