深入理解Java中的反射与动态代理-优快云博客

深入理解Java中的反射与动态代理

大家好，我是微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！
反射的基本概念

在Java中，反射允许程序在运行时检查和操作类、方法、字段等信息。它提供了一种机制，可以在运行时获取类的信息、调用类的方法、操作类的属性，而不需要在编译时确定。

获取Class对象

在Java中，可以通过以下方式获取类的Class对象：

package cn.juwatech.reflection;

public class ReflectionExample {

    public static void main(String[] args) throws ClassNotFoundException {
        // 通过类名获取Class对象
        Class<?> clazz1 = String.class;

        // 通过对象的getClass()方法获取Class对象
        String str = "Hello, Reflection!";
        Class<?> clazz2 = str.getClass();

        // 通过Class.forName()方法获取Class对象
        Class<?> clazz3 = Class.forName("java.lang.String");

        System.out.println(clazz1 == clazz2 && clazz2 == clazz3); // 输出 true
    }
}

上述代码演示了三种获取Class对象的方式：直接通过类名、通过对象的getClass()方法、通过Class.forName()方法。

反射调用方法

利用反射，可以在运行时动态调用类的方法：

package cn.juwatech.reflection;

import java.lang.reflect.Method;

public class ReflectionMethodExample {

    public static void main(String[] args) throws Exception {
        Class<?> clazz = MyClass.class;

        // 获取指定方法并调用
        Method method = clazz.getMethod("sayHello", String.class);
        MyClass obj = new MyClass();
        method.invoke(obj, "Reflection");

        // 调用私有方法
        Method privateMethod = clazz.getDeclaredMethod("privateMethod");
        privateMethod.setAccessible(true); // 设置可访问性为true
        privateMethod.invoke(obj);
    }
}

class MyClass {
    public void sayHello(String name) {
        System.out.println("Hello, " + name + "!");
    }

    private void privateMethod() {
        System.out.println("Private method called");
    }
}

在上述示例中，通过反射获取了MyClass类的方法并进行调用，包括公有方法和私有方法。

动态代理

动态代理允许在运行时创建一个实现一组给定接口的新类。Java中的动态代理主要通过java.lang.reflect.Proxy类实现。

package cn.juwatech.proxy;

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

public class DynamicProxyExample {

    public static void main(String[] args) {
        // 创建一个实现了MyInterface接口的动态代理类
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                MyInterface.class.getClassLoader(),
                new Class[] { MyInterface.class },
                new MyInvocationHandler(new MyClass())
        );

        // 调用代理对象的方法
        proxy.doSomething();
    }
}

interface MyInterface {
    void doSomething();
}

class MyClass implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Original method implementation");
    }
}

class MyInvocationHandler implements InvocationHandler {
    private final Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method invocation");
        Object result = method.invoke(target, args);
        System.out.println("After method invocation");
        return result;
    }
}