Java动态代理机制详解(JDK动态代理与CGLIB动态代理区别)

最新推荐文章于 2024-08-05 07:30:00 发布
最新推荐文章于 2024-08-05 07:30:00 发布
阅读量938 收藏 1
点赞数
分类专栏： Spring学习笔记 文章标签： JDK动态代理 CGLIB代理 SpringAOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RobertoHuang/article/details/71437046
版权

代理是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理。在讲述动态代理前,我们先通过一个例子了解一下什么是静态代理,这里以事务控制为例。

1.静态代理

1.1 pom.xml文件配置

<properties>
    <!-- Spring -->
    <spring.version>4.1.3.RELEASE</spring.version>
</properties>
<dependencies>
    <!-- Spring Begin -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- Spring End -->
</dependencies>

1.2 业务接口代码

public interface UserService {
    /**
     * 
     * 功能描述: <br>
     * 〈保存用户〉
     *
     * @since [1.0.0](可选)
     */
    public void saveUser();

    /**
     * 
     * 功能描述: <br>
     * 〈更新用户〉
     *
     * @since [1.0.0](可选)
     */
    public void updateUser();
}

1.3 业务实现类代码

@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser() {
        System.out.println("userService saveUser()...");
    }

    @Override
    public void updateUser() {
        System.out.println("userService updateUser()...");
    }
}

1.4 事务管理类代码

@Service("transactionManager")
public class TransactionManager {
    public void beginTransaction() {
        System.out.println("开启事务....");
    }

    public void commint() {
        System.out.println("提交事务....");
    }

    public void rollback() {
        System.out.println("回滚事务....");
    }
}

1.5 代理类代码

@Service("userServiceProxy")
public class UserServiceProxy implements UserService {
    @Resource(name = "userService")
    private UserService userService;

    @Resource(name = "transactionManager")
    private TransactionManager transactionManager;

    @Override
    public void saveUser() {
        try {
            transactionManager.beginTransaction();
            userService.saveUser();
            transactionManager.commint();
        } catch (Exception e) {
            transactionManager.rollback();
        }
    }

    @Override
    public void updateUser() {
        try {
            transactionManager.beginTransaction();
            userService.updateUser();
            transactionManager.commint();
        } catch (Exception e) {
            transactionManager.rollback();
        }
    }
}

1.6 测试类代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:applicationContext.xml" })
public class ProxyTest {
    @Resource(name = "userServiceProxy")
    private UserService userService;

    @Test
    public void testStaticProxy() {
        userService.saveUser();
    }
}

1.7 测试结果

开启事务....
userService saveUser()...
提交事务....

从上面的代码,可以看出静态代理给我们带来的一系列问题,如在代理对象中包含了真实对象的引用,如果我们需要为不同的业务进行代理,就需要为每个业务都创建一个代理对象,甚是麻烦,所以引出了动态代理。

2.JDK动态代理

2.1 业务类接口

public interface UserService {
    /**
     * 
     * 功能描述: <br>
     * 〈保存用户〉
     *
     * @since [1.0.0](可选)
     */
    public void saveUser();

    /**
     * 
     * 功能描述: <br>
     * 〈更新用户〉
     *
     * @since [1.0.0](可选)
     */
    public void updateUser();
}

2.2 业务实现类

@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser() {
        System.out.println("userService saveUser()...");
    }

    @Override
    public void updateUser() {
        System.out.println("userService updateUser()...");
    }
}

2.3 事务管理类代码

@Service("transactionManager")
public class TransactionManager {
    public void beginTransaction() {
        System.out.println("开启事务....");
    }

    public void commint() {
        System.out.println("提交事务....");
    }

    public void rollback() {
        System.out.println("回滚事务....");
    }
}

2.4 代理类代码

@Service("transactionManagerProxy")
public class TransactionManagerProxy implements InvocationHandler {
    private Object target;

    @Resource(name = "transactionManager")
    private TransactionManager transactionManager;

    public Object createProxyObject(Object object) {
        this.target = object;
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        transactionManager.beginTransaction();
        Object object = null;
        try {
            object = method.invoke(target, args);
            transactionManager.commint();
        } catch (Exception e) {
            transactionManager.rollback();
        }
        return object;
    }
}

2.5 测试类代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:applicationContext.xml" })
public class ProxyTest {
    @Resource(name = "transactionManagerProxy")
    private TransactionManagerProxy transactionManagerProxy ;

    @Test
    public void testStaticProxy() {
        UserService userService = (UserService) transactionManagerProxy.createProxyObject(new UserServiceImpl());
        userService.saveUser();
    }
}

2.6 测试结果

开启事务....
userService saveUser()...
提交事务....

但是,JDK的动态代理依靠接口实现,如果有些类并没有实现接口,则不能使用JDK代理,这就要使用cglib动态代理了。

3.CGLIB动态代理

3.1 业务接口类

public interface UserService {
    /**
     * 
     * 功能描述: <br>
     * 〈保存用户〉
     *
     * @since [1.0.0](可选)
     */
    public void saveUser();

    /**
     * 
     * 功能描述: <br>
     * 〈更新用户〉
     *
     * @since [1.0.0](可选)
     */
    public void updateUser();
}

3.2 业务实现类

@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser() {
        System.out.println("userService saveUser()...");
    }

    @Override
    public void updateUser() {
        System.out.println("userService updateUser()...");
    }
}

3.3 事务管理类

@Service("transactionManager")
public class TransactionManager {
    public void beginTransaction() {
        System.out.println("开启事务....");
    }

    public void commint() {
        System.out.println("提交事务....");
    }

    public void rollback() {
        System.out.println("回滚事务....");
    }
}

3.4 事务代理类

public class TransactionManagerProxy implements org.springframework.cglib.proxy.InvocationHandler {
    private Object target;
    private TransactionManager transactionManager;

    public TransactionManagerProxy(Object target, TransactionManager transactionManager) {
        this.target = target;
        this.transactionManager = transactionManager;
    }

    // 创建代理对象
    public Object getProxyInstance() {
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(this.getClass().getClassLoader());
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        transactionManager.beginTransaction();
        Object object = null;
        try {
            object = method.invoke(target, args);
            transactionManager.commint();
        } catch (Exception e) {
            transactionManager.rollback();
        }
        return object;
    }
}

3.5 测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:applicationContext.xml" })
public class ProxyTest {
    @Resource(name = "transactionManager")
    private TransactionManager transactionManager;

    @Test
    public void testStaticProxy() {
        UserServiceImpl userServiceImpl = (UserServiceImpl) new TransactionManagerProxy(new UserServiceImpl(), transactionManager).getProxyInstance();
        userServiceImpl.saveUser();
    }
}

3.6 测试结果

开启事务....
userService saveUser()...
提交事务....

1.CGLIB可以生成目标类的子类,并重写父类非final修饰符的方法。
2.要求类不能是final的,要拦截的方法要是非final,非static,非private的
3.动态代理的最小单位是类(所有类中的方法都会被处理)

注:若目标对象实现了若干接口,Spring就会使用JDK动态代理,若目标对象没有实现任何接口,Spring就使用CGLIB库生成目标对象的子类。

RobertoHuang
关注
专栏目录
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
深入理解动态代理：JDK动态代理与CGLIB动态代理
qq_40254606的博客
06-28 1466
动态代理是一种在运行时创建代理对象的技术，通过代理对象来控制对原对象的访问，能够在不修改原对象的情况下添加额外的功能。JDK动态代理：基于Java反射机制，只能代理实现了接口的类。CGLIB动态代理：基于字节码生成技术，可以代理没有实现接口的类。// 抽象主题接口动态代理在Java中提供了一种灵活而强大的机制，能够在运行时为目标对象添加额外的功能。JDK动态代理和CGLIB动态代理各有优势和适用场景，开发者可以根据具体需求选择合适的代理机制。希望这篇文章对你理解动态代理有所帮助。
java动态代理机制
03-28
NULL 博文链接：https://xueyue.iteye.com/blog/1202897
Java动态代理机制详解（JDK 和CGLIB，Javassist，ASM）
weixin_34130269的博客
10-27 119
class文件简介及加载 　　Java编译器编译好Java文件之后，产生.class 文件在磁盘中。这种class文件是二进制文件，内容是只有JVM虚拟机能够识别的机器码。JVM虚拟机读取字节码文件，取出二进制数据，加载到内存中，解析.class 文件内的信息，生成对应的 Class对象: class字节码文件是根据JVM虚拟机规范中规定的字节码组织规则生成的、具体class文件是怎样组织...
JDK动态代理与CGLib动态代理
最新发布
weixin_74261199的博客
08-05 2439
动态代理（Dynamic Proxy）是在程序运行时给目标对象创建代理对象，代理对象可以对方法进行增强、控制等。在生成代理对象的过程中，目标对象不变，代理对象中方法对目标对象方法进行增强。代理对象执行目标方法时会被拦截，转而调用写好的代理方法。JDK代理、CGLib代理。
详解Java动态代理机制
Walker_YAM
05-07 709
之前介绍的反射和注解都是Java中的动态特性，还有即将介绍的动态代理也是Java中的一个动态特性。这些动态特性使得我们的程序很灵活。动态代理是面向AOP编程的基础。通过动态代理，我们可以在运行时动态创建一个类，实现某些接口中的方法，目前为止该特性已被广泛应用于各种框架和类库中，例如：Spring，Hibernate，MyBatis等。理解动态代理是理解框架底层的基础。      主要内容如下： 理
JDK动态代理和cglib动态代理
akunshouyoudou的博客
11-03 160
转载：https://www.jianshu.com/p/1712ef4f2717 回顾一下JDK动态代理和cglib动态代理，转自我的BLOG： http://zeusjava.com/2015/10/13/jdk-dynamic-agent-and-cglib/ 闲言少叙，先来说一下什么是代理模式，我们去一个新的地方总是要先找地方住，但是我们人生地不熟的掌握的资源不多，这时候一般会找...
【推荐】JDK和CGLIB动态代理区别
大树叶 技术专栏
03-13 356
一 JDK和CGLIB动态代理原理 1、JDK动态代理 利用拦截器(拦截器必须实现InvocationHanlder)加上反射机制生成一个实现代理接口的匿名类， 在调用具体方法前调用InvokeHandler来处理。 2、CGLiB动态代理 利用ASM开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。 3、何时使用JDK还是CGLiB？ 1）如果...
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
Java 动态代理详解（学习资料）
06-17
JDK 动态代理JDK 提供了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来支持动态代理。Proxy 类用于创建一个代理对象，而 InvocationHandler 接口则定义了代理对象的方法调用处理逻辑。...
java 动态代理机制
简乐君
06-19 446
JAVA动态代理业务接口：package jianlejun; public interface IShopping { public void buyMac(); public int buyMedicine(int num); }业务实现类:package jianlejun; public class Shopping implements IShopping { @Override...
Java动态代理机制
xiaoweids的博客
06-03 316
retrofit是一个解耦性非常高的网络请求框架，最近在研究的时候发现了动态代理这个非常强大且实用的技术，这篇文章将作为retrofit的前置知识，让大家认识：动态代理有哪些应用场景,什么是动态代理，怎样使用，它的局限性在什么地方？ #动态代理的应用场景1. AOP—面向切面编程，程序解耦 简言之当你想要对一些类的内部的一些方法，在执行前和执行后做一些共同的的操作，而在方法中执行个性化操作的时候--用动态代理。在业务量庞大的时候能够降低代码量，增强可维护性。2. 想要自定义第三放类库中的某些方法 我引用了一
Java 动态代理机制
我的成长之路
01-14 221
代理模式 动态代理是指在程序运行中根据代码动态生成代理，主要有代理类和委托类 特征：代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。 动态代理类 必须实现 InvocationHandler 接口 Invo...
聊聊Java中的动态代理机制
无远弗届
06-03 1497
代理模式涉及一个代表或代理对象，该对象与真实对象具有相同的接口。代理对象在不直接暴露真实对象的情况下，控制对真实对象的访问。动态代理的实现依赖于Java的反射机制。反射是一种在运行时检查或修改程序行为的能力。通过反射，我们可以在运行时获取类的信息、创建对象、调用方法、访问字段等。动态代理的第一步是定义一个或多个接口。这些接口将由真实对象和代理对象实现。接口定义了代理对象可以调用的方法。
JDK动态代理与Cglib动态代理
Jitwxs
03-09 602
AOP(Aspect Oriented Programming)，即面向切面编程，最主要的思想就是纵向重复，横向抽取。要想实现AOP，其底层实现是使用了动态代理技术，在Spring中，动态代理技术分为传统的JDK动态代理和Cglib动态代理。这两种代理机制区别是： JDK动态代理：针对实现了接口的类进行代理 Cglib动态代理：针对没有实现接口的类进行代理，底层是字节码增强技术，生成当前类的子...
Java动态代理详解：JDK与Cglib实现
Java动态代理（JDK和Cglib）为开发者提供了强大的功能，可以在运行时扩展对象的行为，而无需修改源代码。无论是接口代理还是类代理，都能有效地提高代码的复用性和灵活性，是Java开发中的重要工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值