【JavaSE】反射

り澄忆秋、

已于 2022-06-10 18:10:29 修改

阅读量314

点赞数 1

分类专栏： JavaSE 文章标签： java

于 2022-06-06 16:20:01 首次发布

本文链接：https://blog.csdn.net/t_158327/article/details/125114403

版权

JavaSE 专栏收录该内容

24 篇文章 3 订阅

订阅专栏

本文深入探讨了Java反射的概念，包括如何通过Class类获取运行时类的实例，利用反射创建对象，访问和修改属性，调用方法。此外，还介绍了ClassLoader的工作原理以及如何加载配置文件。文章进一步阐述了反射在动态代理中的应用，展示了静态和动态代理的区别。

摘要由CSDN通过智能技术生成

文章目录

1.Java反射概述

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

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

● Java反射机制提供的功能：

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

● 反射相关的主要API：

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

public class person {

    private String name;
    public int age;

    public 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;
    }

    public void show(){
        System.out.println("你好！我是人!");
    }

    private String show_123(String str){
        System.out.println(str+"show_123");
        return "ooo";
    }

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

public class test{

    public static void main(String[] args) throws Exception {
        Class clazz = person.class;
        // 1.通过反射创建对象
        Constructor constructor = clazz.getConstructor(String.class, int.class);
        Object ab = constructor.newInstance("ab",12);
        person p = (person)ab;
        System.out.println(p);
        System.out.println("-----------");

        // 2.通过反射，调用对象指定的属性、方法
        Field age = clazz.getDeclaredField("age");
        age.set(p,10);
        System.out.println(p);
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);
        System.out.println("-----------");

        // 3.通过反射获得私有结构：构造器、属性、方法
        Constructor constructor1 = clazz.getDeclaredConstructor(String.class);
        constructor1.setAccessible(true);
        person p1 = (person)constructor1.newInstance("cd");
        System.out.println(p1);
        System.out.println("-----------");
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1,"adef");
        System.out.println(p1);
        System.out.println("-----------");
        Method show_123 = clazz.getDeclaredMethod("show_123",String.class);
        show_123.setAccessible(true);
        Object wefwef = show_123.invoke(p1, "wefwef");
        System.out.println(wefwef);
    }
}

2.理解Class类并获取Class实例*

类的加载过程:

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

获取Class实例的4种方式:

常用: Class clazz = Class.forName(String name);

public class test_02 {

    public static void main(String[] args) throws ClassNotFoundException {
        /* 1: 调用运行时类的属性(.class) */
        Class clazz1 = person.class;
        System.out.println(clazz1);

        /* 2: 调用运行时类的对象 */
        person p = new person();
        Class clazz2 = p.getClass();
        System.out.println(clazz2);

        /* 3: 调用Class的静态方法 */ (常用)
        Class clazz3 =  Class.forName("person"); // 全类名(com.main.person)
        System.out.println(clazz3);

        System.out.println(clazz1 == clazz2); // true,
        // 通过不同的方式获取同一个运行时类(加载到内存中的运行时类，会缓存一定的时间，在此时间内，我们可以通过不同的方式来获取)

        /* 4: 使用类的加载器(ClassLoader) */
        ClassLoader classLoader = test_02.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("person");
        System.out.println(clazz4);

    }
}

Class的实例的种类:

public class Main{
	public static void main(String[] args){
		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;
	}
}

3.类的加载与ClassLoader的理解

类的加载:
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化：
1.类的加载(Load):
将类的Class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成。

2.类的链接(Link):
将类的二进制数据合到JRE中

3.类的初始化(Initialize):
JVM负责对类进行初始化

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

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

3.1 使用ClassLoader加载配置文件*

public class Main{
	public static void main(String[] args){
		
		Properties pros = new Properties();

		// 此时的文件默认在当前的 mnodule下。
		// 读取配置文件的方式一：
		FileInputstream fis = new FileInputstream("jdbc.properties");
		FileInputstream fis = new FileInputstream("src\\jdbc1.properties")j
		pros.Load(fis);
		
		// 读取配置文件的方式二：使用 CLassLoader
		// 配置文件默认识别为：当前 nodule的 src下
		ClassLoader classLoader = ClassLoaderTest.class.getclassLoader();
		Inputstream is = classLoader.getResourceAsStream("jdbc1.properties");
		pros.load(is);
	}
}

4.创建运行时类的对象*

public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        Class clazz = person.class;
        /*
            newInstance(): 调用此方法，创建对应运行时类的对象，内部调用了此运行时类的空参构造器
            1.运行时类需提供空参构造器
            2.空参构造器访问权限得够
         */
        person p = (person)clazz.newInstance();
        
	    Constructor constructor1 = clazz.getDeclaredConstructor(String.class);
        constructor1.setAccessible(true);
        person p1 = (person)constructor1.newInstance("cd");
        System.out.println(p1);
    }

5.获取运行时类的完整结构

public class test_01 {

    public static void v(){
        Class clazz = person.class;

        /* 获取属性结构 */
        // 获取当前类及其父类中public权限的属性
        Field[] fields = clazz.getFields();
        for(Field field:fields){
            System.out.println(field);
        }
        System.out.println("-------");
        // 获取当前类中所有声明的属性(所有权限，不包含父类)
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field field:declaredFields){
            System.out.println(field);
        }
        System.out.println("--------");
        // 获取属性中的结构：权限修饰符、返回值类型、方法名、修饰的注释等
        Field[] fields1 = clazz.getFields();
        for(Field field:fields1){
            System.out.println(field.getModifiers());
            System.out.println(field.getType());
            System.out.println(field.getName());
        }
    }

    public static void v1(){
       Class clazz =  person.class;

        /* 获取方法结构 */
        // 获取当前类及其父类中public权限的方法
        Method[] methods = clazz.getMethods();
        for(Method method:methods){
            System.out.println(method);
        }
        System.out.println("-------");
        // 获取当前类中所有声明的方法(所有权限，不包含父类)
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method method:declaredMethods){
            System.out.println(method);
        }

    }

    public static void v3(){
        Class clazz = person.class;

        // 获取方法中的结构：权限修饰符、返回值类型、方法名、修饰的注释等
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method method:declaredMethods){
            // 1.获取方法声明的注释
            Annotation[] annotations = method.getAnnotations();
            for(Annotation annotation:annotations){
                System.out.println(annotation);
            }
            // 2.权限修饰符
            System.out.println(Modifier.toString(method.getModifiers()) + "\t");
            // 3.返回值类型
            System.out.println(method.getReturnType().getName() + "\t");
            // 4.方法名
            System.out.println(method.getName());
            // 5.形参列表
            System.out.println("(");
            Class[] parameterTypes = method.getParameterTypes();
            if(!(parameterTypes==null || parameterTypes.length==0)){
                for(int i=0;i<parameterTypes.length;i++){
                    System.out.println(parameterTypes[i].getName() + "args_" + i);
                }
            }
            System.out.println(")");
        }
    }

    public static void main(String[] args) {
        v3();
    }
}

6.调用运行时类的指定结构*

6.1 调用属性

public class test {

    // 调用属性
    public static void v() throws Exception {
        Class clazz = person.class;

        // 该方法要求属性为public，因此不太常用
        Field id = clazz.getField("id");
        person p = (person)clazz.newInstance();
        // get: 获取那个对象的值
        int p_id = (int)id.get(p);
        System.out.println(p_id);
        // set：设置那个对象的值
        id.set(p,123);
        System.out.println(p.id);
        System.out.println("-----------");
    }

    public static void v1() throws Exception {
        Class clazz = person.class;

        /* 获取指定变量名的属性 */
        // public以下的权限get、set都需要设置: field.setAccessible(true); // 可访问
        person p = (person)clazz.newInstance();
        Field name = clazz.getDeclaredField("name");

        name.setAccessible(true);
        name.set(p,"qwe");
        System.out.println(name.get(p));
    }

    public static void main(String[] args) throws Exception {
        v1();
    }
}

6.2 调用方法

public class test {

    public static void v() throws Exception{
        Class clazz = person.class;

        /* 获取指定的某个方法 */
        // 指明方法名和参数 // 方法若为public权限以下，也需要设置: method.setAccessible(ture); 可访问
        person p = (person)clazz.newInstance();
        Method show = clazz.getDeclaredMethod("show", String.class);
        show.setAccessible(true);
        show.invoke(p,"wefwefwef");
        System.out.println("-------");
        Method uu = clazz.getDeclaredMethod("uu", String.class);
        uu.setAccessible(true);
        String invoke = (String)uu.invoke(p, "123");
        System.out.println(invoke);

        // 静态方法的调用(静态属性同)
        Method ss = clazz.getDeclaredMethod("ss");
        ss.setAccessible(true);
        Obiject returnValue = ss.invoke(person.class);
        System.out.println(returnValue); // void: null
    }

    public static void main(String[] args) throws Exception{
        v();
    }
}

6.3 调用构造器

public class test{

    public static void v() throws Exception{
        /* 获取指定的某个构造器 */
        // 指定构造器中的形参列表
        Class clazz = person.class;
        Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        // 创建对象：指定参数值
        person p = (person)declaredConstructor.newInstance("abc", 123);
        System.out.println(p);
    }

    public static void main(String[] args) throws Exception{
        v();

    }
}

7.反射的应用：动态代理*

● 代理设计模式的原理：
使用一个代理将对象包装起来，笨后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
● 之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。

● 动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

● 动态代理使用场合：
调试
远程方法调用

● 动态代理相比于静态代理的优点：
抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

7.1 静态代理

代理类和被代理类在编译期间，就确定下来了

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 staticProxyTest {

    public static void main(String[] args) {
        // 创建被代理的对象
        NikeClothFactory nike = new NikeClothFactory();
        // 创建代理类的对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
        
        proxyClothFactory.produceCloth();
    }

}

7.2 动态代理

interface Human{

    String getBelief();
    void eat(String food);
}

// 被代理类
class SuperMan implements Human{

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

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

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

    // 此方法创建一个代理类的对象(根据被代理类的对象动态的创建代理类对象)
    public static Object getProxyInstance(Object obj){ // obj:被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        // 通过 Proxy.newProxyInstance和InvocationHandler动态创建了被代理类的 "代理类"，
        // 此时代理类和被代理类拥有同一套接口的方法，调用该代理类的方法的同时会调用被代理类中的同名的方法，
        // 返回值也即为被代理类方法中的返回值
        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时，就会自动的调用如下的方法
    // 将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 此时该方法为代理类调用的方法。在此方法中，调用了被代理类的method方法。obj:被代理类的对象
        System.out.println("代理类经过一些初始操作~");

        Object invoke = method.invoke(obj, args);
        // 上述方法返回值为该方法返回值


        return invoke;
    }
}


public class ProxyTest {

    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        Human proxyInstance = (Human)ProxyFactory.getProxyInstance(superMan);
        // 通过代理类方法会自动调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief+"\n");
        proxyInstance.eat("虾~");

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

        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory proxyInstance1 = (ClothFactory)ProxyFactory.getProxyInstance(nikeClothFactory);
        proxyInstance1.produceCloth();
    }
}

り澄忆秋、

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
【JavaSE】反射

Reflection(反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法加载完类之后，在堆内存的方法区中就产生了一个cass类型的对象（一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。......
复制链接

扫一扫