静态代理和jdk，cglib动态代理到Spring Aop的代理模式

已于 2023-05-13 20:18:03 修改
阅读量215 收藏
点赞数 5
文章标签： 代理模式 java spring
于 2023-01-06 00:56:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64897221/article/details/128572458
版权

静态代理和jdk，cglib动态代理到Spring Aop的动态代理

什么是代理模式(Peoxy)

定义：

​ 由于某些原因需要给某对象提供一个代理以控制对该对象的访问。因为访问对象不适合或者不能直接应用目标对象，代理对象就可以作为访问对象和目标对象之间的中介。

角色：

  • 主体(Subject) 定义了使Proxy和Real Subject角色之间具有一致性的接口。
  • 真实主体(Real Subject) 实现Subject角色接口，是代理对象所代表的真实对象。
  • 代理(Proxy) 提供与Real Subject 相同方法，内部引用Real Subject角色。

优点：

  • 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
  • 代理对象可以扩展目标对象的功能；
  • 代理模式能将客户端与目标对象分离，在一定程度商降低了系统的耦合度

普通代理：

​ 通过代理对象来访问角色，不能直接访问真实角色；真实角色的初始化放在代理中。

强制代理：

​ 真实角色初始化后，不能直接使用，必须获取代理类，用代理类调用对应的方法。强制代理通常通过增加getProxy()方法实现获取方法，在真实类增加私有方法判断是否通过代理类调用。

静态代理和动态代理

静态代理

静态代理：代理类是自己手动实现的，自己创建的一个Java类代表代理类

案例

案例分析

1.创建一个Game接口，里面有一款名叫LOL的游戏

//定义游戏接口
public interface Game {
    /**
     * 接口定义一个方法，标识有LOL这个游戏
     */
    void LOL();
}

2.创建一个游戏启动器，实现Game接口，要玩游戏

//定义一个启动类，即目标类，实现接口。
public class Player implements Game{

    /**
     * 私有化无参构造，不能直接获取目标对象，起到保护作用
     */
    private Player() {
    }

    @Override
    public void LOL() {
        System.out.println("玩lol");
    }

    /**
     * 构造getProxy()方法实现获取目标类
     * @return 返回游戏厂家代理类
     */
    public static GameFactory getProxy(){
        Player player = new Player();
        return new GameFactory(player);
    }
}

3.创建一个游戏厂商代理类，实现Game接口。游戏厂家代理这个游戏，玩家需要通过代理厂家来玩游戏

//定义一个游戏代理类，即代理类
public class GameFactory implements Game{

    private Player player;

    /**
     * 带参构造，传入目标对象
     * @param player
     */
    public GameFactory(Player player) {
        this.player = player;
    }

    @Override
    public void LOL() {
        //代理商代理的游戏开始
        System.out.println("游戏开始前，选英雄");
        player.LOL();
        //游戏结束
        System.out.println("游戏结束了，胜利");
    }
}

4.创建游戏客户端，玩家玩游戏

public class PlayGame {
    public static void main(String[] args) {
        //通过getProxy方法获得方法
        GameFactory gameFactory = Player.getProxy();
        gameFactory.LOL();
    }
}

5.结果：

游戏开始前，选英雄
玩lol
游戏结束了，胜利

静态代理优缺点：

优点：

  1. 实现简单
  2. 容易理解

缺点：当项目中，目标类的代理很多，或者接口功能需要增强，修改，有以下缺点

  1. 当目标类增加了，代理类可能也需要成倍增加
  2. 当接口中功能增加，修改，会影响众多实现类，厂家类，代理类都需要进行修改

动态代理

使用jdk的反射机制，在程序执行中，创建代理对象。不需要创建类文件，代理目标是活动的，可设置的。

  1. 动态代理是指代理类对象在程序运行时由JVM根据反射机制动态生成的。动态代理不需要定义代理类的，java源文件。
  2. 动态代理其实就是jdk运行期间，动态创建class字节码并加载到JVM。
  3. 动态代理的实现方式常用的有两种：使用JDK代理，与通过CGLlB动态代理。
JDK动态代理

JDK动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口，核心是InvocationHandler接口和Proxy类。

JDK动态代理具体实现原理：

  • 通过实现InvocationHandler接口创建自己的调用处理器,重写invke()方法实现功能增强
  • 通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理
  • 通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型
  • 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入
案例

案例分析

还是以同样的案例

//定义游戏接口
public interface Game {
    /**
     * 接口定义一个方法，标识有LOL这个游戏
     */
    void LOL();
}

//定义一个游戏启动类，即目标类，实现接口。
public class Player implements Game {
    @Override
    public void LOL() {
        System.out.println("目标类Play中，执行玩的方法");
        System.out.println("玩lol");
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//实现InvocationHandler，完成代理类要完成的功能(1.调用目标方法，2.功能增强)
public class GameProxy implements InvocationHandler {
    //这里用Object类，因为传入的target可以是任何类的
    private Object target = null;

    //动态代理，目标对象是活动的，不是固定的，需要传进来
    public GameProxy(Object target) {
        //赋值
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /**
         * Object proxy: jdk创建的代理对象，无需赋值
         * Method method: 目标类中的方法
         * Object[] args: 目标类中的方法参数
         */
        System.out.println("游戏开始前，请选择英雄========="+method.getName());
        Object o = method.invoke(target, args);
        System.out.println("游戏失败，多练练狗头吧========"+method.getName());
        return o;
    }
}

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

//游戏测试类
public class PlayGameTest {
    public static void main(String[] args) {
        //创建代理对象 ，使用Proxy
        //1.创建目标对象
        Game game = new Player();
        //2.创建InvocationHandler对象
        InvocationHandler invocationHandler = new GameProxy(game);
        //3.创建代理对象
        Game proxy  = (Game) Proxy.newProxyInstance(game.getClass().getClassLoader(),
                game.getClass().getInterfaces(),
                invocationHandler);
        //通过代理执行方法
        proxy.LOL();
    }
}

结果：

游戏开始前，请选择英雄=LOL
目标类Play中，执行玩的方法
玩lol
游戏失败，多练练狗头吧LOL

CGLIB动态代理
  • CGBLIB 利用ASM开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
  • CGLib动态代理是通过字节码底层继承要代理类来实现，因此如果被代理类被final关键字所修饰，会失败。
  • 使用 JDK 的 Proxy 实现代理，要求目标类与代理类实现相同的接口。若目标类不存在接口，则无法使用该方式实现。但对于无接口的类，要为其创建动态代理，就要使用 CGLIB 来实现。
案例

案例分析

相同的案例，用CGLIB代理，就不用创建接口类。

public class Player02 {
    public void play(String name){
        System.out.println("我是玩家，我要玩"+name);
    }
}

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 CglibProxy implements MethodInterceptor {

    private Object target;

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        /**
         * Object o : 代理对象本身
         * Method method : 被代理对象的方法
         * Object[] objects : 函数调用的参数
         * MethodProxy methodProxy : 方法的代理
         */
        System.out.println("CGLIB动态代理，游戏开始！");
        Object invoke = method.invoke(target, objects);
        System.out.println("CGLIB动态代理,游戏结束");
        return invoke;
    }

    public Object getCglibProxy(Object objectTarget){
        this.target = objectTarget;
        Enhancer enhancer = new Enhancer();
        //设置父类，因为CGLIB是针对指定类生成一个子类，所以需要指定父类
        enhancer.setSuperclass(objectTarget.getClass());
        enhancer.setCallback(this);//设置回调

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

public class CglibTest {
    public static void main(String[] args) {
        //实例化对象
        CglibProxy cglibProxy = new CglibProxy();
        //获取代理对象
        Player02 player = (Player02) cglibProxy.getCglibProxy(new Player02());
        player.play("CF");
    }
}

注意：在使用CGLIB动态代理，需要导入CGLIB的jar包

Spring Aop中两种动态代理的实现方式

Spring中JDK动态代理

案例分析

1.创捷UserService接口

public interface UserService {
    //新增用户
    void addUser(String userName,String passWord);
    //删除用户
    String delUser(String userName);
}

2.创建UserService接口实现类UserServiceImpl

import com.XiaoWu.JDK.UserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String userName, String passWord) {
        System.out.println("调用新增用户方法");
        System.out.println("传入参数为userName:"+userName+",passWord:"+passWord);
    }

    @Override
    public String delUser(String userName) {
        System.out.println("调用了删除方法");
        return "删除成功"+userName;
    }
}

3.代理对象，对目标的方法进行增强

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

//@Aspect:作用是把当前类标识为一个切面供容器读取
@Aspect
@Component
public class UserServiceAspect {
    //前置增强
    //execution(访问权限 包名.类名。方法名(..));args:传入的参数
    @Before("execution(* com.XiaoWu.JDK.UserService.addUser(..)) && args(userName,passWord)")
    public void before(String userName,String passWord){
        System.out.println("JDK加强后的方法-----before，传入值userName:"+userName+",passWord:"+passWord);
    }
    //后置增强,带返回值
    @AfterReturning(value = "execution(* com.XiaoWu.JDK.UserService.delUser(..)) && args(userName)",argNames = "userName,rs",returning = "rs")
    public String afterReturning(String userName,String rs){
        System.out.println("JDK加强后的方法----AfterReturning，传入值userName:"+userName);
        return rs;
    }
}

4.注解类

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

@Configuration
@ComponentScan(basePackages = "com.XiaoWu.JDK")
@EnableAspectJAutoProxy
public class AopConfig {
}

5.测试类

import com.XiaoWu.JDK.config.AopConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AopConfig.class);
        UserService bean = applicationContext.getBean(UserService.class);
        bean.addUser("张三","123");
        System.out.println("============");
        String lisi = bean.delUser("李四");
        System.out.println(lisi);
        System.out.println(bean.getClass().getSuperclass());
    }
}

6.结果

JDK加强后的方法-----before，传入值userName:张三,passWord:123
调用新增用户方法
传入参数为userName:张三,passWord:123

============

调用了删除方法
JDK加强后的方法----AfterReturning，传入值userName:李四
删除成功李四

class java.lang.reflect.Proxy

Spring中CGLIB动态代理

案例分析

1.创建Student对象

import org.springframework.stereotype.Component;

@Component
public class Student {
    public void hello(){
        System.out.println("hello,student!!!");
    }
}

2.创建Student代理类，对目标方法进行增强

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class StudentAspect {
    @Around("execution(* com.XiaoWu.CGLib.Student.hello(..))")
    public void around(ProceedingJoinPoint joinPoint){
        System.out.println("CGLib环绕增强前");
        try {
            joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("CGLib环绕增强后");
    }
}

3.注解类

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

@Component
@ComponentScan(basePackages = "com.XiaoWu.CGLib")
@EnableAspectJAutoProxy
public class Config {
}

4测试类

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        Student bean = context.getBean(Student.class);
        bean.hello();
        System.out.println(bean.getClass().getSuperclass());
    }
}

5.结果

CGLib环绕增强前
hello,student!!!
CGLib环绕增强后
class com.XiaoWu.CGLib.Student

JDK和CGLIB的原理区别，以及优缺点

  • java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
  • 而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP

2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

4、使用JDK动态代理的父类是class java.lang.reflect.Proxy，使用CGLIB动态代理的父类是代理类所继承的目标类，如上就是class com.XiaoWu.CGLib.Student

5.使用JDK动态代理是自带的，不需要导入jar包，使用CGLIB动态代理需要导入相应的jar包

6.从执行效率上看，CGLIB动态代理效率较高。

本人还只是一名大三的学生，这是我在学习过程中通过查资料学习总结出来的。欢迎各位大佬们的指点！若涉及侵权，请联系我

小吴干饭三大缸
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
场景应用：为什么SpringBoot使用cglib作为默认动态代理 ？AOP使用jdk动态代理会有什么问题 ？
流楚丶格念的博客
10-07 6202
现在，让我们看看为什么Spring Boot默认选择CGLIB作为动态代理方式以及AOP中使用JDK动态代理可能会引发问题。这些示例帮助解释了为什么Spring Boot选择CGLIB作为默认动态代理方式，并强调了AOP使用JDK动态代理可能引发的一些问题。让我们首先考虑性能。当涉及到Spring Boot的默认动态代理选择和AOP使用JDK动态代理可能引发的问题时，让我们通过具体的代码示例来更好地理解这些概念。如果目标类没有实现接口，或者需要代理非接口类的方法，那么JDK动态代理就无法胜任。
代理模式之静态代理，JDK动态代理和cglib动态代理
烟雨星空的博客
12-27 1197
代理模式，顾名思义，就是通过代理去完成某些功能。比如，你需要购买火车票，不想跑那么远到火车站售票窗口买，可以去附近的火车票代售点买，或者到携程等第三方网站买。这个时候，我们就把火车站叫做目标对象或者委托对象，也可以叫被代理对象，而火车票代售点和携程就叫做代理对象。 一、静态代理 静态代理是最简单的代理模式。需要定义一个接口，然后委托类和代理类分别实现这个接口 //待实现的接口 public int...
Java通过注解实现简单SpringIOC及cglib动态代理
weixin_45357745的博客
03-01 612
简单实现spring ioc
Spring源码解析（四）-Spring使用cglib创建代理对象
weixin_42346558的博客
11-18 704
Spring源码解析 办公设备租赁，深圳惠源. 文章目录Spring源码解析一、ProxyFactorySpring通过ProxyFactory创建代理对象，可以看Spring源码解析（三）从以上可以看出一般情况下使用jdk代理，除非设置了proxyTargetClass为true或者没有实现接口，所有我们主要看下proxyTargetClass在那个位置设置获取注解属性proxyTargetClass为true的时候执行AopConfigUtils.forceAutoProxyCreatorToUseCl
spring（八）————spring如何使用Cglib对@Configuration进行代理的
qq_35599414的博客
02-28 745
refresh--》finishBeanFactoryInitialization中使用代理对象回调了scan_d方法和scan_e方法，由于这两个方法加了@Bean注解，所以会被BeanMethodInterceptor.intercept();但是由于此时scan_e方法还没执行完，ThreadLocal里面还是scan_e方法，那么scan_d执行增强方法的时候去匹配ThreadLocal里面的方法就为f，此时进入resolveBeanReference方法。这篇文章我们会继续进行说明。
Java两种动态代理JDK动态代理和CGLIB动态代理
热门推荐
学而不思则罔，思而不学则殆。
08-07 14万+
目录 代理模式 JDK动态代理 cglib动态代理 测试 代理模式 代理模式是23种设计模式的一种，他是指一个对象A通过持有另一个对象B，可以具有B同样的行为的模式。为了对外开放协议，B往往实现了一个接口，A也会去实现接口。但是B是“真正”实现类，A则比较“虚”，他借用了B的方法去实现接口的方法。A虽然是“伪军”，但它可以增强B，在调用B的方法前后都做些其他的事情。Spring AOP...
代理模式（静态代理、jdk动态代理、CGLib动态代理）
m0_54355172的博客
05-02 1456
本文主要通过案例和流程图讲解三种代理模式，并分析他们各自的特点与相互之间的联系。
JDK动态代理和CGLIB动态代理
努力努力再努力的小笼包
05-30 7966
在SpringAOP中基于动态代理实现功能的增强，也就是动态的生成代理类，在代理类中织入增强的逻辑然后调用目标对象的方法。动态代理中用的比较多的两种：JDK动态代理、CGLIB动态代理。 JDK动态代理 使用JDK的java.lang.reflect.Proxy类的newProxyInstance方法实现的代理。 用一个测试接口看下具体实现： public interface JdkProxyDemoService { void queryTrs(); } @Service public
Java Spring-AOP动态代理-JDK和CGlib实现
涂涂写写的笔记
11-18 1344
代理增强的方法和Bean本身的方法当作一个切面，是对面向对象编程OOP的升华。OOP是纵向对一个事物的抽象，一个对象包括静态的属性信息，包括动态的方法信息等。而AOP是横向的对不同事物的抽象，属性与属性、方法与方法、对象与对象都可以组成一个切面，而用这种思维去设计编程的方式叫做。思想，我们会new一个筷子对象，new一个手机对象，然后先调用 chopsticks.pickUp() ，再调用 phone.user()。编码是为了解决生活中的问题，譬如现在我想用筷子吃饭的时候看手机，那么首先会有两个对象。
静态代理、JDK与Cglib动态代理简单实现
一恍过去
04-30 1万+
静态代理、JDK与Cglib动态代理简单实现
Spring框架+SpringAOP动态代理
03-22
SpringAOP动态代理 Spring AOP 使用的动态代理主要有两种方式：JDK 动态代理和 CGLIB 代理。 JDK 动态代理：用于代理实现了接口的类。Spring 会使用 java.lang.reflect.Proxy 类来创建代理对象。 CGLIB 代理：用于...
Spring框架中JDK动态代理和cglib动态代理
11-06
Spring框架的AOP中重要的一个知识点，动态代理，springAOP框架会根绝实际情况选择使用jdk的动态代理还是cglib的动态代理
动态代理，JDK实现动态代理，springAOP初学理解动态代理。代码实现
12-20
第一种是JDK提供的基于接口的动态代理，要求被代理的类必须至少实现一个接口。 2. 第二种是第三方cglib提供的基于子类的动态代理，。至少要继承一个类。 我们这里 来讲解，动态代理，以及第一种实现动态代理的方式 ...
Spring-AOP-JDK动态代理
05-12
Spring-AOP-利用java中的动态代理和Spring的拦截器做到AOP
Spring AOP与动态代理
12-22
AOP（Aspect-Oriented Programming：面向切面编程）能够将那些与业务无关，却为业务模块所共同调用的逻辑或...Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理。JDK动态代理通过反射来接收被代理的
【设计模式深度剖析】【1】【结构型】【代理模式】| 玩游戏打怪、升级为例加深理解
最新发布
浣花御劍
05-20 748
玩游戏打怪、升级为例深入理解代理模式
kubernetes集群svc的代理模式-iptables修改为ipvs
weixin_39941298的博客
05-14 883
我们都知道，k8s集群的外部网络分发，借助kube-proxy组件来完成；我们为什么要将代理模式修改为ipvs而不继续使用iptables呐？1，iptables底层使用四表五链完成网络代理，效率比较低，而ipvs是采用了iphash的方式实现代理的，效率比较高，因此才会采用ipvs作为生产环境中的网络代理；2，iptables不太适合【读】，可读性太低，很乱；通过一层一层的路由查询，我们就知道了目标地址的终点ip是什么；
背包问题(01背包和无限背包)
weixin_38184628的博客
05-18 698
假设有一个背包，体积是 V，另外有 n 个物品，物品的体积分别是 v1, v2, ... vn，每个物品的价值是 w1, w1, ... wn。求怎么将物品放到背包里，才能使背包中物品的价值最大？背包问题是一个典型的动态规划问题。动态规划问题中经常包含一个最字，比如最大价值?最短路径?动态规划问题的求解思路包括以下几点：（1）只看眼前利益动态规划，关键字是动态，也就是说结果是在变化的。在计算过程中，只看眼前利益，只要当前这种情况满足要求，那么这就是中间的一个结果。下边的代码是找数组的最大值。
代码随想录训练营Day31:动态规划3：0-1背包
mooc666quq的博客
05-14 824
打卡第31天：动态规划解决01背包问题：分割等和子集、最后一块石头的重量、目标和、一和零。
Spring Aop中的JDK动态代理和CGLIB动态代理有什么区别
06-10
在 Spring AOP 中，JDK 动态代理和 CGLIB 动态代理都可以用来实现切面的功能，它们的主要区别在于： 1. JDK 动态代理只能代理实现了接口的类，而 CGLIB 动态代理可以代理没有实现接口的类。这是因为 JDK 动态代理是基于接口来实现的，而 CGLIB 动态代理则是通过生成被代理类的子类来实现的。 2. JDK 动态代理相对于 CGLIB 动态代理来说，生成代理对象的速度更快，执行效率也更高。这是因为 JDK 动态代理是使用 Java 自带的反射机制来实现的，而 CGLIB 动态代理则是使用 ASM 字节码操作框架来生成字节码的。 3. JDK 动态代理适用于对单个对象的代理，而 CGLIB 动态代理适用于对类的代理。这是因为 JDK 动态代理生成的代理对象是实现了接口的单个对象，而 CGLIB 动态代理生成的代理对象是被代理类的子类。 需要注意的是，当被代理的类没有实现接口时，Spring AOP 默认会使用 CGLIB 动态代理来生成代理对象，如果被代理的类实现了接口，则可以通过配置来选择使用 JDK 动态代理或 CGLIB 动态代理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值