Java代理模式详解

最新推荐文章于 2024-03-13 00:17:43 发布
最新推荐文章于 2024-03-13 00:17:43 发布
阅读量945 收藏 5
点赞数 5
分类专栏： 设计模式 文章标签： java 代理模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43559187/article/details/124288312
版权

导学

文章目录

一、代理模式(Proxy pattern)

AOP的原理是动态代理

动态代理解决了方法之间的紧耦合，在方法调用方法中间可动态进行附加操作

IOC解决了类与类之间的紧耦合！

image-20220420080044098

1. 核心角色与应用场景

核心角色：

  • 抽象对象
    • 定义代理角色和真实角色的公共对外方法
  • 真实角色
    • 实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用
    • 关注真正的业务逻辑！
  • 代理角色
    • 实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以添加自己的操作。
    • 将统一的流程控制放到代理角色中处理！

应用场景：

  • 安全代理：屏蔽对真实角色的直接访问。
  • 远程代理：通过代理类远程方法调用(RMI)
  • 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
    • 比如要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。

2. 代理模式介绍

  • 代理设计模式的原理：

    使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

  • 代理模式的作用就是在不修改原对象的基础上增强该对象的方法。比如官方购买苹果手机不赠送充电头，此时京东平台作为苹果的代理商，可以在代理销售苹果手机时赠送充电头。

    image-20220420071500776

  • 代理模式分为静态代理和动态代理。静态代理会生成一个代理类，动态代理不会生成代理类，直接生成代理对象。

    • 动态代理：客户通过代理类来调用其他对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
    • 静态代理：特征是代理类和目标对象的类都是在编译期间确定下来的，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。

  • 动态代理使用场合：

    • 调试
    • 远程方法调用

  • 动态代理相比静态代理的优点：

    抽象角色中(接口)声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

二、静态代理

代理类和被代理类实现同一个接口，在代理类中对方法进行扩展

代理类和被代理类在编译期间就确定下来了

interface ClothFactory{
    void produceCloth();
}

//代理类
class ProxyClothFactory implements ClothFactory{
    private ClothFactory clothFactory;//用被代理类对象进行实例化

    public ProxyClothFactory(ClothFactory clothFactory) {
        this.clothFactory = clothFactory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");

        clothFactory.produceCloth();

        System.out.println("代理工厂做一些后续的收尾工作");
    }
}

//被代理类
class NikeClothFactory implements ClothFactory{
    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类的对象
        ClothFactory nike = new NikeClothFactory();
        //创建代理类的对象
        ClothFactory proxy = new ProxyClothFactory(nike);
        //通过代理类的对象调用方法
        proxy.produceCloth();
    }
}

三、jdk动态代理一

在代理模式中，代理类和被代理类都要实现同一个接口

使用到了一个类Proxy和一个接口InvocationHandler

  1. 创建被代理类，实现接口，编写方法
  2. 要实现动态代理，创建一个类ProxyFactory，用于创建代理类对象
    1. 在ProxyFactory中提供一个静态方法，参数为被代理类对象，用于获取代理类对象
    2. 通过Java反射包下的Proxy的newProxyInstance方法获取代理类对象
    3. newProxyInstance方法的参数为被代理类对象的类加载器，被代理类对象实现的接口，以及一个handler(主要用于调用被代理类的同名方法)
  3. 创建一个类实现InvocationHandler，重写invoke方法，参数有proxy，method，args
    1. 在invoke方法中通过method.invoke()来调用被代理类的方法，invoke方法中需要传入被代理类对象，和被代理类对象方法所需的参数args，返回值即为被代理类方法返回值
    2. 被代理类obj通过bind()从ProxyFactory中传入
package com.sxt.proxyTest;

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

interface Human{
    String getBelief();

    void eat(String food);
}

//被代理类
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "I believe I can fly";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}

/*
实现动态代理，解决的问题：
问题一：根据加载到内存中的被代理类，动态的创建一个代理类及其对象
问题二：当通过代理类的对象调用方法时，如何去调用被代理类的同名方法
 */
class ProxyFactory{
    //调用此方法，返回一个代理类的对象——解决问题一
    public static Object getProxyInstance(Object obj){//obj：被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}

class MyInvocationHandler implements InvocationHandler{

    private Object obj;//需要使用被代理类的对象进行赋值

    public void bind(Object obj){
        this.obj=obj;
    }

    //当我们通过代理类的对象，调用方法a时，就会自动调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //method：即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj：被代理类的对象
        Object returnValue = method.invoke(obj, args);
        //上述方法的返回值作为当前类中的invoke方法的返回值
        return returnValue;
    }
}

public class DynamicProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("麻辣烫");

        System.out.println("--------------------------");

        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory proxyInstance1 = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
        proxyInstance1.produceCloth();
    }
}

测试：

public class DynamicProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("麻辣烫");

        System.out.println("--------------------------");

        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory proxyInstance1 = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
        proxyInstance1.produceCloth();
    }
}

四、jdk动态代理二

image-20220420071733323

JDK动态代理是针对接口进行代理，所以我们要写被代理的接口和该接口的实现类。

//接口
public interface Apple {
    String sell(double price);//卖产品

    void repair();//维修
}

//被代理接口的实现类
public class AppleImpl implements Apple {
    @Override
    public String sell(double price) {
        System.out.println("产品卖了"+price+"元");
        return "iphone13";
    }

    @Override
    public void repair() {
        System.out.println("苹果售后维修");
    }
}

//代理方式类，定义被代理方法的增强方式
//该类实现InvocationHandler接口，重写invoke方法，定义方法的增强方式
public class ShoppingProxy implements InvocationHandler {
    private Apple apple;//传入被代理对象

    public ShoppingProxy(Apple apple) {
        this.apple = apple;
    }

    /**
     * 定义原方法的增强方式
     * @param proxy 被代理对象
     * @param method 被代理对象调用的方法
     * @param args 被代理对象调用方法时传入的参数
     * @return  方法的返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String name = method.getName();//被代理对象执行的方法名
        if("sell".equals(name)){
            double price = (double) args[0] * 0.9;//增强参数
            Object result = method.invoke(apple, price);//执行方法
            return result + "和充电头";//增强返回值
        }else if("repair".equals(name)){
            System.out.println("专属客服为您服务！");//增强方法流程
            return method.invoke(apple,args);
        }else{
            return method.invoke(apple,args);   //什么都不增强
        }
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        //被代理对象
        Apple apple = new AppleImpl();
        //代理方式对象
        ShoppingProxy shoppingProxy = new ShoppingProxy(apple);
        //生成代理对象
        Apple appleJD = (Apple) Proxy.newProxyInstance(
                apple.getClass().getClassLoader(),//代理类的加载器
                apple.getClass().getInterfaces(),//被代理接口
                shoppingProxy //代理方式对象
        );
        //执行增强后的方法
        String sell = appleJD.sell(6000);
        System.out.println(sell);

        appleJD.repair();
    }
}

五、cglib动态代理

image-20220420072620717

CGLib动态代理简化了JDK动态代理的写法，JDK是针对接口代理，而CGLib是针对类代理。

  1. 需要先引入cglib依赖
  2. 代理方式类，需要实现MehtodInterceptor接口，重写intercept方法，并且通过该类的构造器将被代理对象传入
    1. 重写的intercept方法中，参数为被代理对象，被代理对象调用的方法，参数列表，底层生成的代理类的应用
    2. 通过参数method调用invoke方法来调用被代理对象的方法
  3. 在测试类中创建被代理对象，代理方式类对象，通过Enhancer.create方法创建代理对象，将被代理对象和代理方式类对象传入
<dependencies>
    <!--cglib动态代理-->
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>3.3.0</version>
    </dependency>
</dependencies>

//被代理类
public class Apple {
    public String sell(double price) {
        System.out.println("产品卖了"+price+"元");
        return "iphone13";
    }

    public void repair() {
        System.out.println("苹果售后维修");
    }
}

//代理方式类，实现MethodInterceptor接口，重写intercept方法
public class ShoppingProxy implements MethodInterceptor {
    private Apple apple;//被代理对象

    public ShoppingProxy(Apple apple){
        this.apple = apple;
    }

    /**
     * 定义原方法的增强方式
     * @param o 被代理对象
     * @param method 被代理对象调用的方法
     * @param objects 被代理对象调用方法时传入的参数
     * @param methodProxy 底层生成的代理类的应用
     * @return 方法的返回值
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        String name = method.getName();
        if("sell".equals(name)){
            double price = (double)objects[0]*0.8;
            Object result = method.invoke(apple, price);
            return result+"和数据线";
        }else if("repair".equals(name)){
            System.out.println("专属客服为您服务！");
            return method.invoke(apple,objects);
        }else{
            return method.invoke(apple,objects);
        }
    }
}

测试：

//测试类
public class Test {
    public static void main(String[] args) {
        //被代理对象
        Apple apple = new Apple();
        //代理方式
        ShoppingProxy shoppingProxy = new ShoppingProxy(apple);
        //生成代理对象
        Apple appleTB = (Apple) Enhancer.create(Apple.class, shoppingProxy);

        //执行增强后的方法
        String sell = appleTB.sell(9000);
        System.out.println(sell);
        appleTB.repair();
    }
}

六、cglib和jdk动态代理的区别

1.Cglib 和 jdk 动态代理的区别？

  1. Jdk动态代理：利用拦截器（必须实现 InvocationHandler ）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理
  2. Cglib动态代理：利用 ASM 框架，对代理对象类生成的 class 文件加载进来，通过修改其字节码生成子类来处理

2. 什么时候用 cglib 什么时候用 JDK 动态代理？

  1. 目标对象生成了接口 默认使用jdk动态代理
  2. 如果目标对象使用了接口，可以强制使用cglib
  3. 如果目标对象没有实现接口，必须采用cglib库，Spring会自动在jdk动态代理和cglib之间转换

3. JDK 动态代理和 cglib 字节码生成的区别？

  1. JDK 动态代理只能对实现了接口的类生成代理，而不能针对类
  2. Cglib 是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，并覆盖其中方法的增强，但是因为采用的是继承，所以该类或方法最好不要设置为 final ，对于 final 类或方法，是无法继承的

4. Cglib 比 JDK 快？

  1. cglib 底层是 ASM 字节码生成框架，但是字节码技术生成代理类，在 JDK1.6 之前比使用 java 反射的效率要高
  2. 在 JDK1.6 之后逐步对 JDK 动态代理进行了优化，在调用次数比较少时效率高于 cglib 代理效率
  3. 只有在大量调用的时候 cglib 的效率高，但是在 JDK8 的时候JDK的效率已高于 cglib
  4. Cglib 不能对声明 final 的方法进行代理，因为 cglib 是动态生成代理对象，final 关键字修饰的类不可变只能被引用不能被修改

5. Spring 如何选择是用 JDK 还是 cglib？

  1. 当 bean 实现接口时，会用 JDK 代理模式
  2. 当 bean 没有实现接口，用 cglib实现
  3. 可以强制使用cglib（在spring配置中加入<aop:aspectj-autoproxy proxyt-target-class="true"/>）

6. Cglib 原理

动态生成一个要代理的子类，子类重写要代理的类的所有不是 final 的方法。在子类中采用方法拦截技术拦截所有的父类方法的调用，顺势织入横切逻辑，它比 Java 反射的 jdk 动态代理要快

Cglib 是一个强大的、高性能的代码生成包，它被广泛应用在许多 AOP 框架中，为他们提供方法的拦截。

懿所思
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 代理模式详解
12-22
代理模式是我们比较常用的设计模式之一。其中新思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信，代理模式一般涉及到的角色有： 　...
详解JAVA设计模式之代理模式
08-19
JAVA 设计模式之代理模式 代理模式是 JAVA 设计模式之一，主要用于为其他对象提供一种代理，以控制对这个对象的访问。代理对象起到中介作用，可去掉功能服务或增加额外的服务。 代理模式的定义：代理模式就是为...
Java 静态代理、Java动态代理、CGLIB动态代理
qiang_zi_的专栏
05-14 554
转载 作者：树修 原文：https://www.jianshu.com/p/1682ed0d0c16 Java 的代理就是客户类不再直接和委托类打交道, 而是通过一个中间层来访问, 这个中间层就是代理。为啥要这样呢, 是因为使用代理有 2 个优势： 可以隐藏委托类的实现 可以实现客户与委托类之间的解耦, 在不修改委托类代码的情况下能够做一些额外的处理 我们举个...
Java 代理模式的基本概念、使用场景、应用示例和实现方法
网络技术联盟站
06-06 2733
代理模式是一种结构型设计模式，它允许我们通过添加一个代理对象来控制对另一个对象的访问。代理对象和实际对象具有相同的接口，使得客户端在不知情的情况下可以使用代理对象进行操作。代理对象在与客户端进行交互时，可以控制对实际对象的访问，以实现一些额外的功能，例如访问计数、延迟加载、权限控制等。在 Java 中，代理模式主要有两种实现方式：静态代理和动态代理。静态代理需要手动编写代理类，通常需要针对每个实际对象编写一个代理类，在系统中管理多个代理类比较麻烦。
Java设计模式-代理模式
m0_62946761的博客
01-06 3054
Java设计模式之一的代理模式，介绍了静态代理模式和动态代理，动态代理介绍了JDK动态代理和Cglib动态代理。
Java 代理模式详解，静态代理与动态代理的区别及优缺点
m0_71777195的博客
06-27 2171
代理模式(Proxy Pattern)是指通过代理对象控制对目标对象的访问，并在不改变目标对象的情况下添加额外的功能或控制访问。代理对象和目标对象实现相同的接口，使得客户端可以通过代理对象间接地访问目标对象。代理模式属于结构型设计模式，它在系统中引入了一个代理对象，该对象代替了客户端直接访问目标对象，从而可以在目标对象的基础上增加一些额外的功能或控制访问。
Java代理的三种方式
qq_36896711的博客
11-28 414
远程代理（Remote Proxy）： 当某个对象位于不同的地址空间，需要通过网络进行远程访问时，可以使用远程代理。远程代理隐藏了对象存在于不同地址空间的事实，使得客户端可以像访问本地对象一样访问远程对象。虚拟代理（Virtual Proxy）： 虚拟代理是一种延迟加载的代理，用于按需创建开销较大的对象。在需要时，虚拟代理才会真正创建目标对象，而在目标对象创建之前，虚拟代理可以提供一些占位信息。保护代理（Protection Proxy）： 保护代理用于控制对目标对象的访问。
java 代理模式详解
05-02
总结一下，Java代理模式的核心在于`Proxy`类和`InvocationHandler`接口，它们共同实现了在运行时动态创建符合特定接口的代理对象。通过代理，我们可以在不修改原始对象代码的情况下，添加额外的功能或者控制对原始...
java代理模式
02-19
java设计模式，代理模式
代理模式详解1.zip
最新发布
05-29
代理模式
Java设计模式——代理设计模式（静态代理和动态代理）
04-15
Java设计模式——代理设计模式（静态代理和动态代理） 各种情况例子源码
【Java学习笔记】代理模式详解
Xcong_Zhu的博客
03-30 672
前面已经提到了，动态代理就是【在内存】中动态生成【字节码代理类】的技术。（虽然不需要开发者书写，但是在内存层面依然存在该代理对象】优点减少了代理类的数量并且解决了代码复用的问题。
java中的代理模式
weixin_39038328的博客
03-13 987
java代理模式的学习：静态代理、JDK动态代理、CGLIB动态代理
java 代理模式（静态代理、动态代理、JDK动态代理、CGLIB动态代理）详解
丨康有为丨的博客
11-09 586
我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。是：扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。1.VPN：当我们访问国外网站的时候，往往需要VPN， 他可以帮助我们去访问一些国内不能访问的网站，也就是说他代理了这个访问过程，把结果返回给了我们。这就是代理模式。2.SpringAOP功能的实现代理模式有静态代理和动态代理两种实现方式。
【设计模式】Java 的三种代理模式
DreamSun的博客
04-19 1616
代理(Proxy)模式是一种结构型设计模式，提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需要修改，可以通过代理的方式来扩展该方法。：真实类，也就是被代理类、委托类。用来真正完成业务服务功能；Proxy：代理类，将自身的请求用 Real Subject 对应的功能来实现，代理类对象并不真正的去实现其业务功能；Subject。
java 中级进阶高级 23种设计模式 详细介绍+代码详解
04-07
java 中级进阶高级 23种设计模式 详细介绍+代码详解，中级java 工程师 进阶高级工程师 要看，用来开发框架 和开发高性能算法使用，视频中介绍了设计模式 适用于所有引用于对象方式开发的技术语言 
Java代理模式及其应用
热门推荐
Rico's Blogs
07-03 1万+
代理根据代理类的产生方式和时机分为静态代理和动态代理两种。代理类不仅可以有效的将具体的实现与调用方进行解耦，通过面向接口进行编码完全将具体的实现隐藏在内部，而且还可以在符合开闭原则的前提下，对目标类进行进一步的增强。典型地，Spring AOP 是对JDK动态代理的经典应用。
java代理模式解析
hb_csu的博客
06-05 898
1、代理模式概述： 代理模式（Proxy Pattern）：给某一个对象提供一个代理，并且由代理对象控制对原对象的引用。《设计模式的艺术》 使用场景： 客户端在使用一个功能时，不希望直接使用其接口，而是希望通过一个代理去完成其功能。类似于现实生活中，人们买、租房时常常会通过中介代理，由中介帮客户相关事项，而且代理常常可以为用户完成一些相关性工作，例如办理手续等。 2、代理模...
java动态代理详解
02-22
Java动态代理是一种在运行时创建代理对象的机制，它允许我们在不修改原始类的情况下，通过代理类来增强原始类的功能。动态代理主要通过反射机制来实现。 Java动态代理主要涉及两个核心类：Proxy和InvocationHandler...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

懿所思

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

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

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

打赏作者

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

抵扣说明：

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

余额充值