【Java】动态代理技术

最新推荐文章于 2024-09-23 17:29:16 发布
最新推荐文章于 2024-09-23 17:29:16 发布
阅读量1.1k 收藏 21
点赞数 17
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013675821/article/details/140713640
版权

Java动态代理是一种强大的技术，用于在运行时动态地创建代理对象，以便在不修改目标类的情况下为其方法提供附加行为或功能。这种技术通常用于日志记录、事务管理、权限控制等场景。在Java中，动态代理主要由java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler这两个类实现。除此之外，我们还可以使用自定义的动态代理工厂来创建代理对象，进一步简化代理的使用过程。

1. Java 动态代理概述

1.1 动态代理与静态代理

  • 静态代理：在编译期确定代理类，即我们需要手动编写代理类。在这种情况下，代理类与目标类需要实现相同的接口。虽然静态代理能够增强方法，但它不够灵活，因为每次新增接口或方法都需要编写新的代理类。

  • 动态代理：在运行时动态创建代理类。Java动态代理主要基于接口进行代理，使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。动态代理通过反射机制实现，不需要手动编写代理类，能够动态地为接口生成代理类。

1.2 Java动态代理的核心类

  • Proxy类：用于创建代理类的工厂类，提供了newProxyInstance方法来生成动态代理对象。

  • InvocationHandler接口：用于定义代理类中方法的调用处理逻辑。它的invoke方法会在代理对象的方法被调用时执行。

1.3 动态代理的优缺点

优点

  • 减少代码重复：无需手动编写每个接口的代理类，避免重复代码。

  • 灵活性高：可以在运行时动态改变代理对象的行为。

  • 解耦性好：将通用逻辑从具体业务中分离出来，提高了代码的可维护性。

缺点

  • 性能开销：由于使用了反射，性能比静态代理稍低。

  • 仅限接口：JDK动态代理只能代理接口，不能代理具体类（可使用CGLIB解决）。

2. 动态代理的实现与使用

接下来，我们将通过一个具体的示例展示如何实现Java动态代理，以及如何使用动态代理工厂来创建代理对象。

2.1 定义接口及其实现类

首先，我们定义一个简单的接口和实现类：

// 定义用户服务接口
public interface UserService {
    void addUser(String name);
    void deleteUser(String name);
}

// 实现接口的具体类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("添加用户: " + name);
    }

    @Override
    public void deleteUser(String name) {
        System.out.println("删除用户: " + name);
    }
}

2.2 创建InvocationHandler实现类

接下来，我们创建一个InvocationHandler实现类，用于定义代理对象的方法调用逻辑：

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

// 动态代理处理器
public class UserServiceInvocationHandler implements InvocationHandler {
    // 目标对象
    private final Object target;

    // 构造器
    public UserServiceInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法调用前的处理逻辑
        System.out.println("执行方法前，记录日志: " + method.getName());

        // 调用目标对象的方法
        Object result = method.invoke(target, args);

        // 方法调用后的处理逻辑
        System.out.println("执行方法后，记录日志: " + method.getName());

        return result;
    }
}

2.3 创建代理对象

通过Proxy类创建代理对象，并调用代理对象的方法：

import java.lang.reflect.Proxy;

public class DynamicProxyExample {
    public static void main(String[] args) {
        // 创建目标对象
        UserService userService = new UserServiceImpl();

        // 创建InvocationHandler
        UserServiceInvocationHandler handler = new UserServiceInvocationHandler(userService);

        // 创建代理对象
        UserService proxyInstance = (UserService) Proxy.newProxyInstance(
            userService.getClass().getClassLoader(),
            userService.getClass().getInterfaces(),
            handler
        );

        // 调用代理对象的方法
        proxyInstance.addUser("Alice");
        proxyInstance.deleteUser("Alice");
    }
}
输出结果
执行方法前，记录日志: addUser
添加用户: Alice
执行方法后，记录日志: addUser
执行方法前，记录日志: deleteUser
删除用户: Alice
执行方法后，记录日志: deleteUser

2.4 使用动态代理工厂

为了简化代理对象的创建，我们可以实现一个动态代理工厂来统一管理代理对象的生成。

2.4.1 创建动态代理工厂
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

// 动态代理工厂类
public class ProxyFactory {

    // 目标对象
    private final Object target;

    // 构造器
    public ProxyFactory(Object target) {
        this.target = target;
    }

    // 创建代理对象
    public Object getProxyInstance() {
        // 获取目标对象的类加载器
        ClassLoader classLoader = target.getClass().getClassLoader();
        
        // 获取目标对象实现的所有接口
        Class<?>[] interfaces = target.getClass().getInterfaces();
        
        // 创建InvocationHandler
        InvocationHandler handler = new UserServiceInvocationHandler(target);

        // 创建并返回代理对象
        return Proxy.newProxyInstance(classLoader, interfaces, handler);
    }
}
2.4.2 使用动态代理工厂创建代理对象
public class DynamicProxyExampleWithFactory {
    public static void main(String[] args) {
        // 创建目标对象
        UserService userService = new UserServiceImpl();

        // 创建代理工厂
        ProxyFactory proxyFactory = new ProxyFactory(userService);

        // 获取代理对象
        UserService proxyInstance = (UserService) proxyFactory.getProxyInstance();

        // 调用代理对象的方法
        proxyInstance.addUser("Bob");
        proxyInstance.deleteUser("Bob");
    }
}
输出结果
执行方法前，记录日志: addUser
添加用户: Bob
执行方法后，记录日志: addUser
执行方法前，记录日志: deleteUser
删除用户: Bob
执行方法后，记录日志: deleteUser

2.5 动态代理与CGLIB

JDK动态代理只能代理接口中的方法，不能直接代理具体类的非接口方法。如果需要代理没有实现接口的类，可以使用CGLIB（Code Generation Library），它是一个强大的高性能代码生成库，允许我们在运行时生成一个类的子类，并覆盖其方法以实现代理。

2.5.1 使用CGLIB实现动态代理

以下示例演示了如何使用CGLIB创建动态代理：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

// 没有实现接口的目标类
public class ProductService {
    public void addProduct(String name) {
        System.out.println("添加产品: " + name);
    }

    public void deleteProduct(String name) {
        System.out.println("删除产品: " + name);
    }
}

// CGLIB动态代理类
public class ProductServiceProxy implements MethodInterceptor {

    // 目标对象
    private final Object target;

    // 构造器
    public ProductServiceProxy(Object target) {
        this.target = target;
    }

    // 创建代理对象
    public Object getProxyInstance() {
        // 创建Enhancer对象
        Enhancer enhancer = new Enhancer();

        // 设置父类
        enhancer.setSuperclass(target.getClass());

        // 设置回调
        enhancer.setCallback(this);

        // 创建代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 方法调用前的处理逻辑
        System.out.println("CGLIB代理执行方法前: " + method.getName());

        // 调用目标对象的方法
        Object result = method.invoke(target, args);

        // 方法调用后的处理逻辑
        System.out.println("CGLIB代理执行方法后: " + method.getName());

        return result;
    }
}

// 使用CGLIB代理
public class CGLIBProxyExample {
    public static void main(String[] args) {
        // 创建目标对象
        ProductService productService = new ProductService();

        // 创建代理对象
        ProductServiceProxy proxy = new ProductServiceProxy(productService);
        ProductService proxyInstance = (ProductService) proxy.getProxyInstance();

        // 调用代理对象的方法
        proxyInstance.addProduct("Phone");
        proxyInstance.deleteProduct("Phone");
    }
}
输出结果
CGLIB代理执行方法前: addProduct
添加产品: Phone
CGLIB代理执行方法后: add

Product
CGLIB代理执行方法前: deleteProduct
删除产品: Phone
CGLIB代理执行方法后: deleteProduct

3. 动态代理的高级应用

3.1 实现缓存

我们可以使用动态代理实现方法的缓存功能，以避免重复计算或数据库查询：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

// 缓存动态代理处理器
public class CachingInvocationHandler implements InvocationHandler {

    private final Object target;
    private final Map<String, Object> cache = new HashMap<>();

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String key = method.getName() + "(" + (args != null ? args[0] : "") + ")";
        
        // 检查缓存
        if (cache.containsKey(key)) {
            System.out.println("从缓存中获取结果: " + key);
            return cache.get(key);
        }
        
        // 调用目标方法
        Object result = method.invoke(target, args);

        // 将结果存入缓存
        cache.put(key, result);
        System.out.println("将结果存入缓存: " + key);

        return result;
    }
}

// 示例使用
public class CacheExample {
    public static void main(String[] args) {
        // 创建目标对象
        UserService userService = new UserServiceImpl();

        // 创建缓存代理处理器
        CachingInvocationHandler cachingHandler = new CachingInvocationHandler(userService);

        // 创建代理对象
        UserService proxyInstance = (UserService) Proxy.newProxyInstance(
            userService.getClass().getClassLoader(),
            userService.getClass().getInterfaces(),
            cachingHandler
        );

        // 调用代理对象的方法
        proxyInstance.addUser("Alice");
        proxyInstance.addUser("Alice"); // 从缓存中获取结果
    }
}

3.2 实现权限控制

使用动态代理实现方法的权限控制：

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

// 权限控制动态代理处理器
public class SecurityInvocationHandler implements InvocationHandler {

    private final Object target;
    private final String userRole;

    public SecurityInvocationHandler(Object target, String userRole) {
        this.target = target;
        this.userRole = userRole;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (!hasAccess(method.getName())) {
            throw new IllegalAccessException("用户无权访问该方法: " + method.getName());
        }

        return method.invoke(target, args);
    }

    private boolean hasAccess(String methodName) {
        // 简单的权限控制逻辑
        if ("admin".equals(userRole) || "readUser".equals(methodName)) {
            return true;
        }
        return false;
    }
}

// 示例使用
public class SecurityExample {
    public static void main(String[] args) {
        // 创建目标对象
        UserService userService = new UserServiceImpl();

        // 创建权限控制代理处理器
        SecurityInvocationHandler securityHandler = new SecurityInvocationHandler(userService, "user");

        // 创建代理对象
        UserService proxyInstance = (UserService) Proxy.newProxyInstance(
            userService.getClass().getClassLoader(),
            userService.getClass().getInterfaces(),
            securityHandler
        );

        // 调用代理对象的方法
        try {
            proxyInstance.addUser("Alice");
        } catch (IllegalAccessException e) {
            System.out.println(e.getMessage());
        }
    }
}

4. Spring框架中的动态代理

Spring框架广泛使用动态代理实现AOP（面向切面编程）功能。在Spring中，动态代理主要用于：

  • 事务管理：在方法调用前后自动开启和关闭事务。
  • 安全检查：在方法调用前进行权限验证。
  • 日志记录：记录方法调用的参数和返回值。
  • 性能监控：监控方法调用的时间消耗。

4.1 在Spring中使用动态代理

Spring支持两种代理机制：

  • JDK动态代理：基于接口的代理。
  • CGLIB代理：基于子类的代理，适用于没有实现接口的类。
4.1.1 Spring的配置方式

使用@EnableAspectJAutoProxy注解启用Spring的AOP支持：

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // Spring配置类
}
4.1.2 定义切面
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.UserService.*(..))")
    public void logBefore() {
        System.out.println("调用方法之前，记录日志");
    }
}
4.1.3 Spring中动态代理的使用示例
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringDynamicProxyExample {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        UserService userService = context.getBean(UserService.class);
        userService.addUser("Charlie");
        userService.deleteUser("Charlie");
    }
}
输出结果
调用方法之前，记录日志
添加用户: Charlie
调用方法之前，记录日志
删除用户: Charlie

4.2 Spring中JDK代理与CGLIB代理的选择

  • JDK动态代理：默认情况下，Spring使用JDK动态代理，如果被代理的对象实现了接口，Spring会自动选择JDK代理。

  • CGLIB代理：如果被代理的对象没有实现接口，Spring会选择使用CGLIB代理。需要注意的是，CGLIB代理需要目标类是非final的，因为CGLIB通过生成子类来实现代理。

4.3 Spring中AOP的实现原理

Spring中的AOP是基于动态代理实现的。当我们在Spring中使用AOP时，Spring会在运行时为目标对象生成一个代理对象，并在代理对象的方法调用前后执行切面的增强逻辑。Spring通过解析配置或注解来确定哪些方法需要被增强，然后使用JDK动态代理或CGLIB代理生成代理对象。

5. 总结

Java动态代理是一种强大的技术，它允许我们在运行时动态地为接口生成代理对象，并通过代理对象控制方法的调用行为。在实际应用中，动态代理常用于日志记录、权限控制、事务管理等场景。动态代理使得我们可以将横切关注点与业务逻辑分离，提高了代码的可维护性和可重用性。

此外，动态代理工厂的使用进一步简化了代理对象的创建过程，使得代理的使用更加方便。在Spring框架中，动态代理被广泛用于实现AOP功能，通过JDK动态代理和CGLIB代理，Spring可以在运行时为Bean生成代理对象，并对方法进行增强。

通过灵活使用动态代理，我们可以编写出更加模块化、可维护的Java应用程序。

cangloe
关注
专栏目录
Java 动态代理 Demo
10-03
Java Jdk 和 Cglib 动态代理 Demo ...2.通过CGLIB基于ASM字节码技术创建动态代理 3.Java 反射原理演示 4.CGLib 依赖如下： <groupId>cglib <artifactId>cglib <version>3.3.0 </dependencies>
Java动态代理是什么？
xj-up的博客
11-28 342
动态代理的类和接口 Proxy:动态代理机制的主类，提供一组静态方法为一组接口动态的生成对象和代理类。 // 方法 1: 该方法用于获取指定代理对象所关联的调用处理器 public static InvocationHandler getInvocationHandler(Object proxy) // 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象 public static Class<?> getProxyClass(ClassLoader loader
JAVA的动态代理详解
biyn9的博客
06-23 1万+
动态代理有什么作用？如何使用动态代理？
Java 之动态代理详解
最新发布
weixin_64178283的博客
09-23 1017
动态代理就像是一位神奇的魔术师，它能悄无声息地在你的代码运行时，为你的对象添加各种功能，而这一切，你不需要修改任何已有的代码！
java动态代理
热门推荐
飞！！！的博客
12-28 5万+
前段时间去学习了一下RPC原理，其中提到了动态代理。特意去学习了一下，为了防止以后忘记，写下这篇博客做个记录，有不对的地方欢迎指正。 java中的常见的动态代理如Spring AOP。关于动态代理首先需要了解代理模式，根据代理类的创建时间又可以分为静态代理和动态代理。 1、代理模式 代理模式是常见的设计模式之一，Java我们通常通过new一个对象然后调用其对应的方法来访问我们需要的服务。代理模式则...
java的动态代理
m0_53077601的博客
10-13 5192
jdk动态代理cglib动态代理jdk动态代理是由java内部的反射机制来实现的，cglib动态代理底层则是借助asm来实现的。反射机制在生成类的过程中比较高效，而asm在生成类之后的相关执行过程中比较高效（可以通过将asm生成的类进行缓存，这样解决asm生成类过程低效问题）。jdk动态代理的应用前提是目标类必须基于统一的接口。因此，jdk动态代理有一定的局限性，cglib这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。
Java 动态代理详解
小旋锋 的博客
12-21 2636
博客原文：http://laijianfeng.org/2018/12/Java-动态代理详解/ 动态代理在Java中有着广泛的应用，比如Spring AOP、Hibernate数据查询、测试框架的后端mock、RPC远程调用、Java注解对象获取、日志、用户鉴权、全局性异常处理、性能监控，甚至事务处理等。 本文主要介绍Java中两种常见的动态代理方式：JDK原生动态代理和CGLIB动态代理。...
【Java学习笔记】 动态代理
Xcong_Zhu的博客
04-05 3002
动态地理（JDK动态代理+CGLIB动态代理）
Java动态代理案例演示代码
01-07
以下是对Java动态代理技术的详细解释。 ### 1. 动态代理的原理 Java动态代理基于JDK的`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口。`Proxy`类用于创建代理类实例，而`...
java动态代理demo
03-15
Java动态代理是Java编程中一个重要的特性，它允许我们在运行时创建代理对象，这些代理对象可以代表并增强原对象的功能。动态代理在很多场景下都非常有用，比如日志记录、性能监控、事务管理等。本示例将带你深入理解...
Java动态代理简单应用
12-22
　Java动态代理比代理的思想更进一步，因为它可以动态地创建代理并动态地处理对代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器(InvocationHandler)上，调用处理器的工作是揭示调用的...
java 动态代理
08-29
Java动态代理是Java编程中一个非常重要的特性，它允许我们在运行时创建代理对象，这些代理对象可以代替原对象执行某些额外的操作，例如日志记录、性能监控、事务管理等。在Java中，动态代理主要通过两个接口来实现：...
Java中的动态代理
qingfengmax的博客
02-23 5108
Java中的动态代理
Java动态代理
峰
03-30 1189
JDK的动态代理是基于反射实现。JDK通过反射，生成一个代理类，这个代理类实现了原来那个类的全部接口，并对接口中定义的所有方法进行了代理。当我们通过代理对象执行原来那个类的方法时，代理类底层会通过反射机制，回调我们实现的InvocationHandler接口的invoke方法。并且这个代理类是Proxy类的子类。这就是JDK动态代理大致的实现方式。优点JDK动态代理是JDK原生的，不需要任何依赖即可使用；通过反射机制生成代理类的速度要比CGLib操作字节码生成代理类的速度更快；缺点。
【Java】万字解读Java的动态代理（JDK原生动态代理、CGLIB动态代理）
✈ 正在努力 の 寒江（StudiousTiger) ✌ 呐 ✈
02-22 5381
动态代理在Java中有着广泛的应用，比如 Spring AOP、RPC 远程调用、Java 注解对象获取、日志、用户鉴权、全局性异常处理、性能监控，甚至事务处理等。JDK原生动态代理和CGLIB 动态代理。
java中动态代理的原理
04-20
Java中动态代理的原理是通过在运行时动态生成一个代理类，代理类实现了被代理类的接口，并使用InvocationHandler来处理被代理方法的调用。当客户端调用代理对象的方法时，实际上是调用了InvocationHandler的invoke方法，而该方法中实现了对被代理方法的调用和增强。因此，动态代理可以在运行时动态地增强被代理对象的功能，比如添加日志、缓存等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值