代理解析（静态代理、动态代理jdk和动态代理cglib）

最新推荐文章于 2024-09-15 12:54:30 发布
原创 最新推荐文章于 2024-09-15 12:54:30 发布 · 219 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了代理模式的概念及其在软件开发中的应用。从静态代理到动态代理（包括JDK动态代理和CGLIB动态代理），通过具体示例展示了如何实现代理模式，以及其背后的原理和技术细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、代理介绍：
开始接触代理是在设计模式动态代理中了解的，大概是这样的：张三喜欢一个女孩，但是她不敢表白怎么办，很简单，他找李四帮他去表白。这里李四就是代理对象，代替张三干活，可以看下面的画面：
在这里插入图片描述
慢慢积累之后，发现很多经典的框架背后都使用了代理的模式，例如Spring的AOP实现原理便是动态代理;常用的ORM模型中mybatis框架实现原理也是动态代理；事务的实现原理反射+动态代理；dubbo的实现中也有动态代理…很多很多，我们可以得出的结论是熟悉代理以及熟悉动态代理的重要性。代理模式是：通过代理控制对目标对象的访问，下面是代理类图：
在这里插入图片描述
二、代理分类
代理分为：静态代理和动态代理；
动态代理分类：jdk动态代理和cglib动态代理。

  **1.静态代理介绍**
         静态代理是有实实在在的代理类存在，并且和目标类实现相同的接口。它的特点是效率高，因为所有的类都是已经编写完		       					                    成的，客户端只需要取得代理对象并且执行即可，同时他可以实现对目标对象中指定的方法进行增强。它的优缺点：

优点：效率高；
缺点：
与目标类实现相同的接口代码冗余；
如果接口发生改变，代理类中的方法也要修改；
代理类服务于一种类型的对象，如果要服务多类型的对象，那么势必要为每种类型的对象都生成代理类。

2.动态代理介绍
动态代理能用很少的代码对一个类的所有方法实现一样的增强效果，但是不能增强其中的某一个方法。与静态代理的硬编
码方式相比，动态代理支持运行时动态生成代理对象这种方式
优点：
在编码时代理逻辑与业务逻辑互相独立；
各不影响，减少侵入，降低耦合。

   **jdk和cglib两种动态代理方式对比：**
*jdk
    目标类和代理类实现了共同的接口；
	    拦截器必须实现InvocationHandler接口，而这个接口中invoke方法体的内容就是代理对象方体的内容；
         当客户端用代理对象调用方法的时候，invoke方法执行。
  *cglib
目标类是代理类的父类；
拦截器必须实现MethodInterceptor接口，而接口中的intercept方法就是代理类的方法体；
使用字节码增强机制创建代理对象的。

三、代理实现过程（coding…）
1.静态代理：
日志:
package com.test.spring.proxy_02proxy;
public class Logger {
public void logger(){
System.out.println(“logging”);
}
}

安全性：
package com.test.spring.proxy_02proxy;
public class Security {
public void security(){
System.out.println(“security…”);
}
}

权限：
package com.test.spring.proxy_02proxy;
public class Privilege {
private String access;
public String getAccess() {
return access;
}
public void setAccess(String access) {
this.access = access;
}
}

接口：
package com.test.spring.proxy_02proxy;
public interface SalaryManager {
public void showSalary();
}

目标类（接口的实现类）:
package com.test.spring.proxy_02proxy;
public class SalaryManagerImpl implements SalaryManager{
@Override
public void showSalary() {
System.out.println(“正在查看工资：涨了20W人民币”);
}
}

代理类：
package com.test.spring.proxy_02proxy;
/**

  • 1.导入日志、安全性框架和权限

  • 2.目标对象

  • 3.在代理对象的方法中调用上面的方法

  • */
    public class SalaryManagerProxy implements SalaryManager {
    private Logger logger;
    private Security security;
    private Privilege privilege;
    private SalaryManager targetSalaryManager;

    //利用构造函数赋值
    public SalaryManagerProxy(Logger logger,Security security,Privilege privilege,SalaryManager targetSalaryManager){
    this.logger = logger;
    this.security = security;
    this.privilege = privilege;
    this.targetSalaryManager = targetSalaryManager;
    }

    @Override
    public void showSalary() {
    this.logger.logger();
    this.security.security();
    if(“admin”.equals(this.privilege.getAccess())){
    this.targetSalaryManager.showSalary();
    }else{
    System.out.println(“你没有权限查看！”);
    }
    }
    }

客户端测试类：
package com.test.spring.proxy_02proxy;
import org.junit.Test;
public class SalaryProxyTest {
@Test
public void test(){
Logger logger = new Logger();
Privilege privilege = new Privilege();
privilege.setAccess(“admin”);

	Security security = new Security();
	SalaryManager targetSalaryManager = new SalaryManagerImpl();
	SalaryManagerProxy  salaryManagerProxy = new SalaryManagerProxy(logger, 
                                                                                     security, privilege,  targetSalaryManager);
	salaryManagerProxy.showSalary();
}

}

2.动态代理：
2.1jdk动态代理
Person实例：
package com.test.spring.proxy_04jdkproxydao;
public class Person {
private Long pid;
private String pname;
public Long getPid() {
return pid;
}
public void setPid(Long pid) {
this.pid = pid;
}
public String getPname() {
return pname;
}
public void setPname(String pname) {
this.pname = pname;
}
}

接口：
package com.test.spring.proxy_04jdkproxydao;
public interface PersonDao {
public void insertPerson();
public void updatePerson();
public void deletePerson();
}

目标类：(接口的实现类)
package com.test.spring.proxy_04jdkproxydao;
public class PersonDaoImpl implements PersonDao{
@Override
public void insertPerson() {
System.out.println(“insert Person!”);
}
@Override
public void updatePerson() {
System.out.println(“update Person!”);
}
@Override
public void deletePerson() {
System.out.println(“delete Person!”);
}
}

事务：(开启事务，提交事务)
package com.test.spring.proxy_04jdkproxydao;
public class Transaction {
public void beginTransaction(){
System.out.println(“Begin transaction!”);
}
public void commitTransaction(){
System.out.println(“Commit transaction!”);
}
}

拦截器：
package com.test.spring.proxy_04jdkproxydao;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class PersonInterceptor implements InvocationHandler{
private Transaction transaction;
private Object target;
public PersonInterceptor(Transaction transaction,Object target){
this.transaction = transaction;
this.target = target;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
		throws Throwable {
	Object obj;
	String methodName = method.getName();
	if("insertPerson".equals(methodName) || "updatePerson".equals(methodName) || 		"deletePerson".equals(methodName)){
		this.transaction.beginTransaction();//开启事务
		obj = method.invoke(target, args);	
		this.transaction.commitTransaction();//提交事务
	}else{
		obj = method.invoke(target, args);
	}		
	return obj;
}

}

客户端测试类：
package com.test.spring.proxy_04jdkproxydao;
import java.lang.reflect.Proxy;
import org.junit.Test;
/**

  • 代理对象的方法：
  • *就是拦截器中invoke方法体的内容
  • *代理对象的方法把目标方法和切面（可以是日志、安全性的检查、权限、事务）就整合在一起了
  • *代理对象的是有jdk的类库生成的
  • */
    public class ProxyDaoTest {
    @Test
    public void test(){
    Transaction transaction = new Transaction();
    PersonDao targerPersonDao = new PersonDaoImpl();
    PersonInterceptor interceptor = new PersonInterceptor(transaction,targerPersonDao);
    //代理对象Proxy，调用的方法是newProxyInstance(loader, interfaces, h)
    PersonDao proxy = (PersonDao) Proxy.newProxyInstance(targerPersonDao.getClass().getClassLoader(),
    targerPersonDao.getClass().getInterfaces(), interceptor);
    proxy.insertPerson();
    }

小总结1：
基于jdk的动态代理需要有实现的接口；
动态代理的核心：是创建了处理器 InvocationHandler实例。在调用目标对象时，会调用代理对象，代理对象中请求目标对象，invoke方法便是调用目标对象的方法生成代理对象的过程，同时增强工作也是在invoke方法中进行的。

2.2cglic动态代理
Person实例：
package com.test.spring.proxy_04jdkproxydao;
public class Person {
private Long pid;
private String pname;
public Long getPid() {
return pid;
}
public void setPid(Long pid) {
this.pid = pid;
}
public String getPname() {
return pname;
}
public void setPname(String pname) {
this.pname = pname;
}
}

目标类:
package com.test.spring.proxy_04jdkproxydao;
public class PersonDaoImpl{
public void insertPerson() {
System.out.println(“insert Person!”);
}
public void updatePerson() {
System.out.println(“update Person!”);
}
public void deletePerson() {
System.out.println(“delete Person!”);
}
}

事务：(开启事务，提交事务)
package com.test.spring.proxy_04jdkproxydao;
public class Transaction {
public void beginTransaction(){
System.out.println(“Begin transaction!”);
}
public void commitTransaction(){
System.out.println(“Commit transaction!”);
}
}

拦截器：
package com.test.spring.proxy_05cglibproxy;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class PersonInterceptor implements MethodInterceptor{
private Transaction transaction;
private Object target;
public PersonInterceptor(Transaction transaction,Object target){
this.transaction = transaction;
this.target = target;
}

//创建代理
public Object createProxy(){	
	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(this.target.getClass());//设置目标类为代理类的父类
	enhancer.setCallback(this);//设置拦截器为回调函数
	return enhancer.create();
}	

@Override
public Object intercept(Object arg0, Method method, Object[] arg2, 
		MethodProxy arg3) throws Throwable {
	Object obj;
	
	String methodName = method.getName();
	if("insertPerson".equals(methodName) || "updatePerson".equals(methodName) || "deletePerson".equals(methodName)){
		this.transaction.beginTransaction();//开启事务
		obj = method.invoke(target, arg2);
		this.transaction.commitTransaction();//提交事务
	}else{
		obj = method.invoke(target, arg2);
	}
		
	return obj;

}
}

客户端测试：
package com.test.spring.proxy_05cglibproxy;
import org.junit.Test;
public class ProxyDaoTest {
@Test
public void test(){
Transaction transaction = new Transaction();
PersonDaoImpl targerPersonDao = new PersonDaoImpl();

	PersonInterceptor interceptor = new PersonInterceptor(transaction,targerPersonDao);
	PersonDaoImpl proxy = (PersonDaoImpl) interceptor.createProxy();
	proxy.updatePerson();		
}

}

小总结2：
基于cglib的动态代理是没有实现接口的，它是以目标类作为代理类的父类
cglib动态代理的关键是基于enhancer.setCallback方法，和其中的MethodInterceptor() 方法
在MethodInterceptor实例中重写intercept方法中调用invoke方法设置代理对象，最后通过enhancer.create()创建代理对象。

【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
浅谈Spring中JDK动态代理和CGLIB动态代理
CharlesYooSky的博客
10-21 1853
浅谈Spring中JDK动态代理和CGLIB动态代理
JDK动态代理和CGLIB动态代理有什么区别？
最新发布
水w的博客
09-15 7092
JDK动态代理和CGLIB动态代理有什么区别？
Spring的两种代理JDK和CGLIB的区别浅谈
热门推荐
钟渊博客
08-04 5万+
我的店铺 一、原理区别： java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。 而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。 1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP...
设计模式-代理模式
面对未来，乘风破浪
11-13 398
一、 代理模式 代理模式： 为其他对象提供一种代理以控制对这个对象的方法 代码示例： 1. Subject abstract class Subject { public abstract void Request(){}; } 2. RealSubject public class RealSubject extends Subject{ pub
动态代理：JDK动态代理和CGLIB代理的区别
08-29 177
动态代理：JDK动态代理和CGLIB代理的区别 代理模式：代理类和被代理类实现共同的接口（或继承），代理类中存有指向被代理类的索引，实际执行时通过调用代理类的方法、实际执行的是被代理类的方法。 而AOP，是通过动态代理实现的。 一、简单来...
代理模式解析
m0_56202970的博客
04-05 158
代理模式 使用一个代理对象代替真实对象，以此在不修改原对象的前提下扩展该对象的功能。 例如我们需要在每个方法执行的前后都加上输出语句表明该方法执行与结束，这时就能使用代理模式扩展原方法的功能 具体实现： 静态代理 创建代理对象实现与目标对象实现的相同接口，创建目标对象，调用目标对象方法，在此基础上扩展 之所以实现相同接口，是为了尽可能保证代理对象的内部结构和目标对象一致，这样我们对代理对象的操作最终都可以转移到目标对象身上，代理对象只需专注于增强代码的编写。 //接口 public interface Su
JDK动态代理和CGLIB动态代理
努力努力再努力的小笼包
05-30 8535
在SpringAOP中基于动态代理实现功能的增强，也就是动态的生成代理类，在代理类中织入增强的逻辑然后调用目标对象的方法。动态代理中用的比较多的两种：JDK动态代理、CGLIB动态代理。 JDK动态代理 使用JDK的java.lang.reflect.Proxy类的newProxyInstance方法实现的代理。 用一个测试接口看下具体实现： public interface JdkProxyDemoService { void queryTrs(); } @Service public
深入解析Java动态代理技术：静态、JDK与CGLib
动态代理主要有三种实现方式：静态代理、基于JDK的动态代理和基于CGLIB的动态代理。本文将详细介绍这三种动态代理的实现原理和特点。 ### 静态代理 静态代理是指在编译时就已经确定要代理的对象，并且在编译完成后...
JDK动态代理和Cglib动态代理（包含代码和讲解）
m0_46741750的博客
01-20 1073
文章目录1.JDK动态代理代码代码结构：总结2.Cglib动态代理代码3.总结 1.JDK动态代理 首先，我们需要明白的就是在jdk动态代理当中，需要明白的就是，为什么会有这样一个代理，那是因为当需要代理的方法越来越多的时候，这个时候就会增大麻烦量，于是就引出了JDK的动态代理。 代码 首先是书写对应的接口，以及你需要完成的任务对应的实现类 subject.interface package com.example.qhb.Jdk; public interface Subject { void
浅谈JDK动态代理与CGLIB代理去区别
03-01
NULL 博文链接：https://jummy.iteye.com/blog/255628
Spring中JDK的动态代理和CGLIB代理的区别
weixin_33721427的博客
01-03 152
一，应用范围 1，如果目标对象实现了接口，在默认情况下会采用JDK的动态代理实现AOP 2，如果目标对象实现了接口，也可以强制使用CGLIB生成代理实现AOP 3，如果目标对象没有实现接口，必须引入CGLIB，Spring会在JDK的动态代理和CGLIB代理之间进行切换。 二，强制使用CGLIB代理 ...
动态代理解析
chengqu9972的博客
08-01 183
一、什么是代理模式 代理模式的定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。 代理模式的分类：代理模式分为静态代理和动态代理 二、静态代理 以简单的事务处理为例 interface public in...
代理详解
weixin_34407348的博客
04-20 119
本文纯属个人观点，如有错处，敬请指正，不胜感激。 我们不管是在项目中，还是在面试过程中，总是免不了被问及循环引用的话题，这还是要归于ios的内存管理机制——引用计数。而循环引用常常发生的情景其中之一就是代理和block。这里重点说说代理。 一、代理解决什么问题 场景： 有一个婴儿，他要吃饭才能维持生存，但是，...
jdk动态代理和cglb动态代理
一个菜鸡的博客
06-14 986
动态代理和静态代理都是代理模式的实现方式，其主要区别在于代理类生成的时机和方式。静态代理是在编译时就确定了代理类的代码，在程序运行前就已经存在了代理类的class文件。代理类与委托类的关系在编译时就已经确定，因此被称为静态代理。在静态代理中，代理类需要实现与委托类相同的接口或者继承委托类的父类，以便能够对委托类进行代理操作。动态代理是在程序运行时生成代理类的代码，代理类通过反射机制动态生成。动态代理不需要像静态代理一样实现与委托类相同的接口或继承委托类的父类，它可以实现任意接口。
jdk的动态代理和CGLIB的区别
lixiaoyi01的博客
02-02 2091
jdk的动态代理和CGLIB的区别 先说一下我对代理的理解： 我们租房或者买房的时候，我们只关注房子多大，多少钱，还有一些其他需求，但是这个过程有时候需要你自己 去找资源，要商量价格，要自己拟定合同的内容，我们上班哪有那么多时间去管这些事呢，因此中介油然而生， 中介帮你完成我们与自己需求不关注的点，这就跟代理类是一个意思。 jdk代理是基于接口实现类来说的，如果你
jdk动态代理与CGLIB动态代理的实现与区别
cpown的博客
06-29 384
上篇文章我们写了静态代理设计模式之代理模式【1】静态代理 今天说一下java的动态代理。 一、为什么要使用动态代理 其实动态代理是弥补了静态代理的短板，静态代理需要给每一个被代理对象写一个代理类，这就需要编写大量冗余代码，而动态代理，只需要编写一个代理类，就可以代理多个不同的对象，大大减少重复代码，前提是他们实现了同一个接口。 请记住，代理的主要目的是控制对目标对象的访问，而不是增强目标对象的功能。访问控制包括同步，身份验证，远程访问（RPC），懒惰实例化（Hibernate，Mybatis），AOP（事务
jdk动态代理与cglib动态代理有什么区别
iteye_19426的博客
03-25 212
<!--StartFragment-->AOP 使用的设计模式就是代理模式，是对IOC设计的补充。为了扩展性，往往会加上反射，动态生成字节码，生成代理类。 这里往往还会使用到DI，把代理的实现类通过依赖注入的方式，传给代理工厂。 关于生成动态代理类的方式有两种：JDK和CGLIB。 CGLIB，是一个开源工具。spring 和hibernate已经广泛使用。 关于AOP的概念解释网...
深入理解JDK与CGlib动态代理源码解析
在这个知识分享中，我们将深入探讨JDK动态代理和CGlib动态代理的实现原理及其源代码，同时也会涉及相关的面向切面编程（AOP）概念。 ### JDK动态代理的实现原理 #### 核心组件 1. **Proxy类**：JDK的Proxy类是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值