Java中的反射

大家好我是Boger

已于 2022-04-16 16:35:52 修改

阅读量510

点赞数

分类专栏： Java学习笔记 # JavaSE学习笔记文章标签： java 开发语言后端

于 2022-02-06 20:27:17 首次发布

本文链接：https://blog.csdn.net/QQ1149646297/article/details/122777722

版权

Java学习笔记同时被 2 个专栏收录

29 篇文章 4 订阅

订阅专栏

JavaSE学习笔记

19 篇文章 0 订阅

订阅专栏

以下为本人观看尚硅谷Java学习视频所做的笔记

Java反射机制概述

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

加载完类之后，在堆内存的方法区中就产生了一个class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为: 反射。
在这里插入图片描述

补充：动态语言 vs 静态语言

动态语言
是一类在运行时可以改变其结构的语言: 例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
主要动态语言: Object-C、C#、JavaScript、PHP、Python、Erlang。
静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。

Java不是动态语言，但Java可以称之为 “准动态语言” 。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

Java反射机制研究及应用

Java反射机制提供的功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理

反射相关的主要API

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

反射示例代码：

import org.junit.Test;

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

class Person {
    private String name;
    public int age;

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

    private Person(String name) {
        this.name = name;
    }

    public void show() {
        System.out.println("我是一个人");
    }

    private String showNation(String nation) {
        System.out.println("我的国籍是：" + nation);
        return nation;
    }

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

public class Sample {
    //反射之前，对于Person类的操作
    @Test
    public void test1() {
        //1.创建Person类的对象
        Person p1 = new Person("Tom", 12);
        //2.通过对象，调用其内部的属性、方法
        p1.age = 10;
        System.out.println(p1.toString());
        p1.show();
        //在Person类外部，不可以通过Person类的对象调用其内部的私有结构
        //比如：name、showNation()以及私有的构造器
    }

    //反射之后，对于Person类的操作
    @Test
    public void test2() throws Exception {
        Class clazz = Person.class;
        
        //1.通过反射，创建Person类的对象
        Constructor cons = clazz.getConstructor(String.class, int.class);
        Object obj = cons.newInstance("Tom", 12);
        Person p = (Person) obj;
        System.out.println(p.toString());
        
        //2.通过反射，调用对象指定的属性、方法
        //调用属性
        Field age = clazz.getDeclaredField("age");
        age.set(p, 10);
        System.out.println(p.toString());
        //调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);
        System.out.println("********************");
        
        //通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
        //调用私有的构造器
        Constructor cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1 = (Person) cons1.newInstance("Jerry");
        System.out.println(p1);
        
        //调用私有的属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1, "HanMeimei");
        System.out.println(p1);
        
        //调用私有的方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        String nation = (String) showNation.invoke(p1, "中国");//相当于String nation = p1.showNation("中国")
        System.out.println(nation);
    }
}

理解Class类并获取Class实例

1、类的加载过程：
程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class文件)。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类就称为Class的一个实例。
换句话说，Class的实例就对应着一个运行时类。

2、加载到内存中的运行时类，会缓存一段时间。在此时间之内，我们可以通过不同的方式来获取此运行时类，且获取到的都是同一个运行时类的实例

3、哪些类型可以有Class对象？
(1) class: 外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
(2) interface: 接口
(3) []: 数组
(4) enum: 枚举
(5) annotation: 注解@interface
(6) primitive type: 基本数据类型
(7) void

Class实例可以是哪些结构的说明：

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

        //以下说明元素类型与维度一样，就是同一个Class实例
        int[] a = new int[10];
        int[] b = new int[10];
        Class c10 = a.getClass();
        Class c11 = b.getClass();
        System.out.println(c10 == c11);//true
    }
}

获取Class的实例的4种方式（前3种方式需要掌握）：
（注意Class类本身带泛型，但下面的代码省略了）

public class Sample {
    @Test
    public void test() throws ClassNotFoundException {
        //方式一：调用运行时类的属性：.class
        Class clazz1 = Person.class;
        System.out.println(clazz1);//class Person

        //方式二：通过运行时类的对象，调用getClass()
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);//class Person

        //方式三：调用Class的静态方法：forName(String classPath)
        Class clazz3 = Class.forName("Person");
        System.out.println(clazz3);//class Person

        //方式四：使用类的加载器：ClassLoader（了解）
        ClassLoader classLoader = Sample.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("Person");
        System.out.println(clazz4);//class Person
        
        //以下输出说明在内存中是同一个运行时类的实例
        System.out.println(clazz1 == clazz2);//true
        System.out.println(clazz1 == clazz3);//true
        System.out.println(clazz1 == clazz4);//true
    }
}

类的加载与ClassLoader的理解

类的加载过程（了解）：
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化
在这里插入图片描述

加载: 将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。
链接: 将Java类的二进制代码合并到JVM的运行状态之中的过程
- 验证: 确保加载的类信息符合JVM规范，例如: 以cafe开头，没有安全方面的问题
- 准备: 正式为类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
- 解析: 虚拟机常量池内的符号引用（常量名）替换为直接引用(地址）的过程。
初始化:
- 执行 类构造器<clinit>() 方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。 （类构造器是构造类信息的，不是构造该类对象的构造器）。
- 当初始化一个类的时候，如果发现其父类还没有进行初始化则需要先触发其父类的初始化。
- 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

类加载器的作用：

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

ClassLoader（了解）：
**类加载器作用是用来把类(class)装载进内存的。**JVM规范定义了如下类型的类的加载器
在这里插入图片描述
了解类的加载器的示例代码：

import org.junit.Test;

public class Sample {
    @Test
    public void test() {
        //对于自定义类，使用系统类加载器进行加载
        ClassLoader classLoader = Sample.class.getClassLoader();
        System.out.println(classLoader);//jdk.internal.loader.ClassLoaders$AppClassLoader@15db9742
        //调用系统类加载器的getParent()：获取扩展类加载器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println(classLoader1);//jdk.internal.loader.ClassLoaders$PlatformClassLoader@3aa9e816
        //调用扩展类加载器的getParent()：无法获取引导类加载器
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类的
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);//null

        ClassLoader classLoader3 = String.class.getClassLoader();
        System.out.println(classLoader3);//null
    }
}

使用ClassLoader加载配置文件的示例代码（这个比较重要）：
文件结构：
在这里插入图片描述
在src目录下的jdbc.properties的内容：

user=Mike
password=abc123

在java目录洗的jdbc.properties的内容：

user=Tom
password=123abc

import org.junit.Test;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class Sample {
    /*
     * Properties：用来读取配置文件
     * */
    @Test
    public void test() throws IOException {
        Properties pros = new Properties();
        //读取配置文件的方式一：
        //此时的文件默认在当前的module下
        FileInputStream fis = new FileInputStream("jdbc.properties");
        pros.load(fis);
        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println("user = " + user + " password = " + password);//user = Tom password = 123abc

        //读取配置文件的方式二：
        //此时的文件默认在当前的module的src下
        ClassLoader classLoader = Sample.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc.properties");
        pros.load(is);

        user = pros.getProperty("user");
        password = pros.getProperty("password");
        System.out.println("user = " + user + " password = " + password);//user = Mike password = abc123
    }
}

创建运行时类的对象

import org.junit.Test;

import java.io.IOException;

class Person {
    private String name;
    private int age;

    public Person() {
    }

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

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

public class Sample {
    @Test
    public void test() throws IOException, IllegalAccessException, InstantiationException {
        Class<Person> clazz = Person.class;
        //newInstance()：调用此方法，创建对应的运行时类的对象，内部调用了运行时类的空参构造器
        //要想此方法正常创建运行时类的对象，要求：
        //1.运行时类必须提供空参构造器
        //2.空参构造器的访问权限得够，通常设置为public
        //在javabean中要求提供一个public的空参构造器，原因：
        //1.便于通过反射，创建运行时类的对象
        //2.便于子类继承此运行时类，默认调用super()时，保证父类有此构造器
        Person obj = clazz.newInstance();
        System.out.println(obj);
    }
}

获取运行时类的完整结构

我们先定义一个具有丰富结构的Person类

文件结构：
在这里插入图片描述
Creature类：

import java.io.Serializable;

public class Creature<T> implements Serializable {
    private char gender;
    public double weight;

    private void breath() {
        System.out.println("生物呼吸");
    }

    public void eat() {
        System.out.println("生物吃东西");
    }
}

MyAnnotation注解：

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}

MyInterface接口：

public interface MyInterface {
    void info();
}

Person类：

@MyAnnotation(value = "hi")
public class Person extends Creature<String> implements Comparable<String>, MyInterface {
    private String name;
    int age;
    public int id;

    public Person() {
    }

    @MyAnnotation(value = "abc")
    private Person(String name) {
        this.name = name;
    }

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @MyAnnotation
    private String show(String nation) {
        System.out.println("我的国籍是：" + nation);
        return nation;
    }

    public String display(String interests, int age) throws NullPointerException, ClassCastException {
        return interests + age;
    }

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

    @Override
    public void info() {
        System.out.println("我是一个人");
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }
}

获取运行时类的属性结构及其内部结构

import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;


public class Sample {
    @Test
    public void test() {
        Class clazz = Person.class;
        //获取属性结构
        //getFields()：获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for (Field f : fields) {
            System.out.println(f);
        }
        //以上代码输出：
        //public int Person.id
        //public double Creature.weight

        //getDeclaredFields：获取当前运行时类声明的所有属性（不包含父类中声明的属性）
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field f : declaredFields) {
            System.out.println(f);
        }
        //以上代码输出：
        //private java.lang.String Person.name
        //int Person.age
        //public int Person.id

        //属性结构：权限修饰符 数据类型 变量名
        for (Field f : declaredFields) {
            //1.权限修饰符
            int modifier = f.getModifiers();
            //2.数据类型
            Class type = f.getType();
            //3.变量名
            String name = f.getName();
            System.out.print("权限修饰符: " + Modifier.toString(modifier) + " 数据类型: " + type.getName() + " 变量名: " + name + "\n");
        }
        //以上代码输出：
        //权限修饰符: private 数据类型: java.lang.String 变量名: name
        //权限修饰符:  数据类型: int 变量名: age
        //权限修饰符: public 数据类型: int 变量名: id
    }
}

获取运行时类的方法结构

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;


public class Sample {
    @Test
    public void test() {
        Class clazz = Person.class;
        //获取方法结构
        //getMethos()：获取当前运行时类及其所有父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for (Method m : methods) {
            System.out.println(m);
        }
        //以上代码的输出：
        //public java.lang.String Person.toString()
        //public int Person.compareTo(java.lang.String)
        //public int Person.compareTo(java.lang.Object)
        //public void Person.info()
        //public java.lang.String Person.display(java.lang.String,int) throws java.lang.NullPointerException,java.lang.ClassCastException
        //public void Creature.eat()
        //public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
        //public final void java.lang.Object.wait() throws java.lang.InterruptedException
        //public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
        //public boolean java.lang.Object.equals(java.lang.Object)
        //public native int java.lang.Object.hashCode()
        //public final native java.lang.Class java.lang.Object.getClass()
        //public final native void java.lang.Object.notify()
        //public final native void java.lang.Object.notifyAll()

        System.out.println();

        //getDeclaredMethods()：获取当前运行时类中声明的所有方法（不包含父类中声明的方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            System.out.println(m);
        }
        //以上代码的输出：
        //public java.lang.String Person.toString()
        //public int Person.compareTo(java.lang.String)
        //public int Person.compareTo(java.lang.Object)
        //public void Person.info()
        //public java.lang.String Person.display(java.lang.String,int) throws java.lang.NullPointerException,java.lang.ClassCastException
        //private java.lang.String Person.show(java.lang.String)

        System.out.println();

        //方法结构：
        //@注解
        //权限修饰符 返回值 方法名(参数类型1 形参1, ...) throws XxxException{}
        for (Method m : declaredMethods) {
            //1.获取方法声明的注解
            Annotation[] annos = m.getAnnotations();
            for (Annotation a : annos) {
                System.out.println(a);
            }
            //2.权限修饰符
            System.out.print(Modifier.toString(m.getModifiers()) + ' ');
            //3.返回值类型
            System.out.print(m.getReturnType().getName() + ' ');
            //4.方法名
            System.out.print(m.getName());
            //5.形参列表
            System.out.print('(');
            Class[] parameterTypes = m.getParameterTypes();
            if (!(parameterTypes == null && parameterTypes.length == 0)) {
                for (int i = 0; i < parameterTypes.length; i++) {
                    if (i == parameterTypes.length - 1)
                        System.out.print(parameterTypes[i].getName() + " args_" + i);
                    else
                        System.out.print(parameterTypes[i].getName() + " args_" + i + ", ");
                }
            }
            System.out.print(')');
            //6.抛出的异常
            Class[] exceptionTypes = m.getExceptionTypes();
            if (exceptionTypes.length > 0) {
                System.out.print(" throws ");
                for (int i = 0; i < exceptionTypes.length; i++) {
                    if (i == exceptionTypes.length - 1)
                        System.out.print(exceptionTypes[i].getName());
                    else
                        System.out.print(exceptionTypes[i].getName() + ", ");
                }
            }
            System.out.print("\n");
        }
        //以上代码的输出：
        //public java.lang.String toString()
        //public int compareTo(java.lang.String args_0)
        //public volatile int compareTo(java.lang.Object args_0)
        //public void info()
        //public java.lang.String display(java.lang.String args_0, int args_1) throws java.lang.NullPointerException, java.lang.ClassCastException
        //@MyAnnotation("hello")
        //private java.lang.String show(java.lang.String args_0)
    }
}

获取运行时类的构造器结构

import org.junit.Test;

import java.lang.reflect.Constructor;


public class Sample {
    @Test
    public void test() {
        Class clazz = Person.class;
        //getConstructors()：获取当前运行时类中声明为public的构造器
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor c : constructors) {
            System.out.println(c);
        }
        //以上代码输出：
        //public Person()

        System.out.println();

        //getDeclaredConstructors：获取当前运行时类中声明的所有构造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor c : declaredConstructors) {
            System.out.println(c);
        }
        //以上代码输出：
        //Person(java.lang.String,int)
        //private Person(java.lang.String)
        //public Person()
    }
}

获取运行时类的父类及父类的泛型

import org.junit.Test;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;


public class Sample {
    @Test
    public void test() {
        Class clazz = Person.class;
        //获取运行时类的父类
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);
        //以上代码输出：
        //class Creature

        //获取运行时类的带泛型的父类
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
        //以上代码输出：
        //Creature<java.lang.String>

        //获取运行时类的带泛型的父类的泛型
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        //获取泛型的类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        for (Type t : actualTypeArguments) {
            System.out.println(t.getTypeName());
        }
        //以上代码的输出：
        //java.lang.String
    }
}

获取运行时类的接口、所在包、注解等

import org.junit.Test;

import java.lang.annotation.Annotation;


public class Sample {
    @Test
    public void test() {
        Class clazz = Person.class;

        //获取运行时类实现的接口
        Class[] interfaces = clazz.getInterfaces();
        for (Class c : interfaces) {
            System.out.println(c);
        }
        //以上代码的输出：
        //interface java.lang.Comparable
        //interface MyInterface

        //获取运行时类的父类实现的接口
        Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for (Class c : interfaces1) {
            System.out.println(c);
        }
        //以上代码的输出：
        //interface java.io.Serializable

        //获取运行时类所在的包
        Package pack = clazz.getPackage();
        System.out.println(pack);

        //获取运行时类声明的注解
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation a : annotations) {
            System.out.println(a);
        }
        //以上代码的输出：
        //@MyAnnotation("hi")
    }
}

调用运行时类的指定结构

调用运行时类中指定的属性

import org.junit.Test;

import java.lang.reflect.Field;

public class Sample {
    @Test
    public void test() throws Exception {
        Class clazz = Person.class;

        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();
        //getField()：获取指定的属性，要求运行时类中属性声明为public（因此通常不采用此方法，因此不需要掌握）
        Field id = clazz.getField("id");
        //设置当前属性的值
        //set()：参数1：指明设置哪个对象的属性，参数2：将此属性值设置为多少
        id.set(p, 1001);
        //获取当前属性的值
        //get()：参数：获取哪个对象的当前属性值
        int pId = (int) id.get(p);
        System.out.println(pId);//1001

        //getDeclaredField()：获取运行时类中指定变量名的属性（需要掌握）
        Field name = clazz.getDeclaredField("name");
        //保证当前属性是可访问的（如果没有这一步且属性不是public，则不能访问）
        name.setAccessible(true);
        //获取、设置指定对象的此属性值
        name.set(p, "Tom");
        System.out.println(name.get(p));
    }
}

调用运行时类中指定的方法

import org.junit.Test;

import java.lang.reflect.Method;

public class Sample {
    @Test
    public void test() throws Exception {
        Class clazz = Person.class;

        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        //1.获取指定的某个方法
        //getDeclaredMethod()：参数1：指明获取的方法的名称 参数2：指明获取的方法的形参列表
        Method show = clazz.getDeclaredMethod("show", String.class);
        //保证当前方法是可访问的
        show.setAccessible(true);
        //invoke()：参数1：方法的调用者 参数2：给方法形参赋值的实参
        //invoke()的返回值是对应类中调用方法的返回值
        Object returnValue = show.invoke(p, "CHN");//相当于 String nation = p.show("CHN");
        System.out.println(returnValue);//输出：CHN

        //以下尝试调用静态方法
        //在Person类中新增一个静态方法，方法声明为：
        //private static void showDesc() {
        //    System.out.println("我是一个可爱的人");
        //}
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        Object returnVal = showDesc.invoke(Person.class);
//        Object returnVal = showDesc.invoke(null);//这个写法也可以
        //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
        System.out.println(returnVal);//输出：null
    }
}

调用运行时类中指定的构造器

import org.junit.Test;

import java.lang.reflect.Constructor;

public class Sample {
    @Test
    public void test() throws Exception {
        Class clazz = Person.class;

        //获取指定的构造器
        //getConstructor()：参数；指明构造器的参数列表
        Constructor constructor = clazz.getDeclaredConstructor(String.class);
        //保证此构造器是可访问的
        constructor.setAccessible(true);
        //调用此构造器创建运行时类的对象
        Person p = (Person) constructor.newInstance("Tom");
        System.out.println(p);//Person{name='Tom', age=0}
    }
}

反射的应用：动态代理

代理设计模式的原理:
使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
动态代理使用场合:
- 调试
- 远程方法调用
**动态代理相比于静态代理的优点: **
抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法

静态代理举例

静态代理特点：
代理类和被代理类在编译期间就确定下来了

//静态代理举例

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 NikeClothFactory implements ClothFactory {
    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}

public class Sample {
    public static void main(String[] args) {
        //创建被代理类的对象
        ClothFactory nike = new NikeClothFactory();
        //创建代理类的对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
        proxyClothFactory.produceCloth();
        //输出：  
        //代理工厂做一些准备工作
        //Nike工厂生产一批运动服
        //代理工厂做一些后续的收尾工作
    }
}

动态代理举例

问题一：如何根据加载到内存中的被代理类，动态地创建一个代理类及其对象
问题二：当通过代理类的对象调用方法时，如何动态地去调用被代理类中的同名方法

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//动态代理举例

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

//被代理类
class SuperMan implements Human {
    @Override
    public String getBelief() {
        return "I believe I can fly! ";
    }

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

interface ClothFactory {
    void produceCloth();
}

//被代理类
class NikeClothFactory implements ClothFactory {
    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}


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 {
        //method:即为代理类对象调用的方法，此方法也作为了被代理类对象要调用的方法
        //obj:被代理类的对象
        Object returnValue = method.invoke(obj, args);
        //上述方法的返回值就作为了当前类中的invoke()的返回值
        return returnValue;
    }
}

public class Sample {
    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("四川麻辣烫");
        //输出：
        //I believe I can fly!
        //我喜欢吃四川麻辣烫

        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
        proxyClothFactory.produceCloth();
        //输出：
        //Nike工厂生产一批运动服
    }
}

AOP (Aspect Orient Programming)（了解）

前面介绍的Proxy和InvocationHandler，很难看出这种动态代理的优势，下面介绍一种更实用的动态代理机制

考虑以下情形：
在这里插入图片描述
改进之后：

代码段1、代码段2、代码段3和深色代码段分离开了，但代码段1、2、3又和一个特定的方法A耦合了！最理想的效果是: 代码块1、2、3既可以执行方法A，又无须在程序中以硬编码的方式直接调用深色代码的方法

理想的：
在这里插入图片描述

大家好我是Boger

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中的反射

以下为本人观看尚硅谷Java学习视频所做的笔记目录Java反射机制概述补充：动态语言 vs 静态语言Java反射机制研究及应用反射相关的主要API理解Class类并获取Class实例类的加载与ClassLoader的理解创建运行时类的对象获取运行时类的完整结构调用运行时类的指定结构反射的应用：动态代理Java反射机制概述Reflection（反射）是被视为动态语言的天键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任何对象的内部属性及方法。加载完类之后
复制链接

扫一扫