java.lang.reflect.Proxy的底层原理和语法结构及使用场景，很多都是来自业务模式

于 2024-08-04 10:15:12 发布
阅读量1.1k 收藏 31
点赞数 16
分类专栏： JAVA开发 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhang9880000/article/details/140902481
版权

java.lang.reflect.Proxy 是 Java 提供的一种动态代理机制，可以在运行时创建代理类，为接口生成代理实例。它允许在不修改代码的情况下添加行为或功能，常用于 AOP（面向方面编程）、拦截器、日志、权限控制等场景。以下是对其底层原理、语法结构和使用场景的详细解析。

一、底层原理

1. 动态代理概述

动态代理使用 Java 反射机制和字节码操作，在运行时创建代理类，而不是在编译时。这与静态代理（在编译时生成代理类）不同。

2. 代理类生成

Proxy 类通过 Proxy.newProxyInstance 方法生成代理实例。这个方法需要三个参数：

  • 类加载器 (ClassLoader)。
  • 一组接口（这些接口是代理类要实现的接口）。
  • 一个 InvocationHandler 实例（用于处理方法调用）。

在调用 newProxyInstance 时，Java 会：

  1. 使用指定的类加载器和接口定义生成一个代理类。
  2. 代理类会实现所有指定的接口。
  3. 代理类的所有方法调用都会被重定向到 InvocationHandler 的 invoke 方法。
3. InvocationHandler

InvocationHandler 是一个接口，包含一个方法：

public interface InvocationHandler {
   
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

当代理实例的方法被调用时，invoke 方法会被调用。method 参数表示被调用的方法，args 参数是方法的参数。

二、语法结构

1. 定义接口

首先定义一个接口：

public interface MyInterface {
   
    void doSomething();
}
2. 创建 InvocationHandler

实现 InvocationHandler 接口：

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

public 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: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}
3. 创建代理实例

使用 Proxy.newProxyInstance 创建代理实例：

import java.lang.reflect.Proxy;

public class ProxyDemo {
   
    public static void main(String[] args) {
   
        MyInterface original = new MyInterfaceImpl();
        MyInvocationHandler handler = new MyInvocationHandler(original);

        MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
                MyInterface.class.getClassLoader(),
                new Class[]{
   MyInterface.class},
                handler);

        proxyInstance.doSomething();
    }
}
4. 实现接口的方法

实现接口的具体类：

public class MyInterfaceImpl implements MyInterface {
   
    @Override
    public void doSomething() {
   
        System.out.println("Doing something in the original implementation.");
    }
}

三、使用场景

1. AOP（面向方面编程）

动态代理在 AOP 中非常常用。例如，可以在方法执行前后添加日志、事务管理等。

2. 拦截器

可以在方法调用时进行拦截，添加预处理或后处理逻辑。

3. 远程方法调用

动态代理可以用来处理远程方法调用，将本地方法调用转换为远程调用。

4. 权限控制

在方法调用时检查用户权限，确保只有授权用户才能调用特定方法。

5. 延迟加载

动态代理可以用于延迟加载，当一个方法被调用时才进行实际的资源加载。

四、示例代码

综合上述内容，完整的示例代码如下：

// 定义接口
public interface MyInterface {
   
    void doSomething();
}

// 实现接口的具体类
public class MyInterfaceImpl implements MyInterface {
   
    @Override
    public void doSomething() {
   
        System.out.println("Doing something in the original implementation.");
    }
}

// 创建 InvocationHandler
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public 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: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

// 使用 Proxy 创建代理实例
import java.lang.reflect.Proxy;

public class ProxyDemo {
   
    public static void main(String[] args) {
   
        MyInterface original = new MyInterfaceImpl();
        MyInvocationHandler handler = new MyInvocationHandler(original);

        MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
                MyInterface.class.getClassLoader(),
                new Class[]{
   MyInterface.class},
                handler);

        proxyInstance.doSomething();
    }
}

当然，以下是对 java.lang.reflect.Proxy 更深入的探讨，包括其内部工作机制、性能考虑、与其他代理机制的比较以及更多的高级用法和示例。

一、深入探讨 java.lang.reflect.Proxy

1. 内部工作机制

Proxy.newProxyInstance 方法的内部工作流程如下：

  1. 类加载器和接口验证：验证指定的类加载器和接口，确保接口是有效的。
  2. 生成代理类：生成一个实现了指定接口的代理类。代理类在运行时被动态创建，并缓存以提高性能。
  3. 实例化代理类：使用 InvocationHandler 实例化代理类。
  4. 代理方法调用：每次调用代理实例的方法时，都会调用 InvocationHandler.invoke 方法。
2. 代理类的生成

代理类的生成是通过 sun.misc.ProxyGenerator 类实现的。该类会动态生成字节码，并使用 ClassLoader 加载生成的类。

以下是生成代理类的步骤：

  • 创建类名：创建唯一的代理类名。
  • 实现接口：代理类将实现所有指定的接口。
  • 方法重写：代理类会重写所有接口方法，在方法体内调用 InvocationHandler.invoke 方法。
  • 字节码生成：生成代理类的字节码。
  • 类加载：使用 ClassLoader 加载生成的代理类。

二、性能考虑

动态代理的性能通常比静态代理稍差，因为它涉及到反射调用和动态字节码生成。然而，动态代理提供了更高的灵活性和可扩展性。

性能优化建议：
  1. 减少反射调用：尽量减少代理方法内部的反射调用次数。
  2. 缓存代理实例：如果某个代理实例会被频繁调用，可以考虑缓存该实例以减少创建开销。
  3. 使用 CGLIB：对于性能敏感的场景，可以考虑使用 CGLIB 代理，它基于 ASM 提供更高效的字节码生成。

三、与其他代理机制的比较

1. 静态代理

静态代理在编译时生成代理类，代码量大且不灵活，但性能较好。

  • 优点：性能较好，结构简单。
  • 缺点：需要手动编写代理类，难以维护。
2. CGLIB 动态代理

CGLIB 使用字节码生成库 ASM 来创建代理类，可以代理类而不仅仅是接口。

  • 优点：性能较好，可以代理类。
  • 缺点：需要额外的库，生成的代理类体积较大。
3. JDK 动态代理

JDK 动态代理只支持接口代理，使用反射机制。

  • 优点：无需外部库，使用简单。
  • 缺点：只支持接口代理，性能稍差。

四、高级使用场景和示例

1. AOP（面向方面编程）

AOP 是动态代理的典型应用场景。通过动态代理，可以在方法调用前后添加切面逻辑（如日志记录、事务管理等）。

public class LoggingHandler implements InvocationHandler {
   
    private final Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        System.out.println("Entering method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("Exiting method: " + method.getName());
        return result;
    }
}

使用示例：

MyInterface original = new MyInterfaceImpl();
MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
        MyInterface.class.getClassLoader(),
        new Class[]{
   MyInterface.class},
        new LoggingHandler(original));
proxyInstance.doSomething();
2. 远程方法调用（RMI）

动态代理可以用于远程方法调用，将本地调用转换为远程调用。

public class RemoteInvocationHandler implements InvocationHandler {
   
    private final String host;
    private final int port;

    public RemoteInvocationHandler(String host, int port) {
   
        this.host = host;
        this.port = port;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        // 进行远程调用逻辑
        // 例如，通过网络发送请求到远程服务器
        return null; // 返回远程调用结果
    }
}

使用示例：

MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
        MyInterface.class.getClassLoader(),
        new Class[]{
   MyInterface.class},
        new RemoteInvocationHandler("localhost", 8080));
proxyInstance.doSomething();
3. 延迟加载

使用动态代理实现延迟加载，当方法实际被调用时才进行资源加载。

public class LazyLoadingHandler implements InvocationHandler {
   
    private Object target;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        if (target == null) {
   
            target = new ExpensiveObject(); // 实际的资源加载
        }
        return method.invoke(target, args);
    }
}

使用示例：

MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
        MyInterface.class.getClassLoader(),
        new Class[]{
   MyInterface.class},
        new LazyLoadingHandler());
proxyInstance.doSomething();

五、完整示例代码

以下是一个包含日志记录、远程调用和延迟加载的综合示例：

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

// 定义接口
public interface MyInterface {
   
    void doSomething();
}

// 实现接口的具体类
public class MyInterfaceImpl implements MyInterface {
   
    @Override
    public void doSomething() {
   
        System.out.println("Doing something in the original implementation.");
    }
}

// 日志记录处理器
public class LoggingHandler implements InvocationHandler {
   
    private final Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        System.out.println("Entering method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("Exiting method: " + method.getName());
        return result;
    }
}

// 远程调用处理器
public class RemoteInvocationHandler implements InvocationHandler {
   
    private final String host;
    private final int port;

    public RemoteInvocationHandler(String host, int port) {
   
        this.host = host;
        this.port = port;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        // 模拟远程调用逻辑
        System.out.println
最低0.47元/天 解锁文章
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

九张算数

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值