Java Review - 关于代理的二三事儿

企业开发 2023-08-18 17:35:43 阅读次数: 0

文章目录

在这里插入图片描述

Pre

Java-JDK动态代理

Java-CGLib动态代理

概述

代理模式是一种结构型设计模式，其目的是为其他对象提供一种代理以控制对这个对象的访问。

在 Java 中，代理模式有两种形式：

  • 静态代理
  • 动态代理

在代理模式中，代理类和目标类之间有一个抽象接口，代理类实现了这个接口，而目标类则实现了具体的业务逻辑。通过代理类调用目标类，可以实现对目标类的访问控制、权限检查、审计等功能。

代理模式在 Java 中应用广泛，例如可以使用代理模式来实现对网络请求的缓存、访问控制、限流等功能。

静态代理

在这里插入图片描述

概述

静态代理是一种在编译时生成代理类的方式。在静态代理中，代理类和委托类的关系在运行前就确定了。静态代理模式的实现需要手动编写代理类，并使用代理类来调用目标类。

静态代理是指在编译时就已经确定了代理类和被代理类的关系，代理类和被代理类都要实现同一个接口或者继承同一个父类。在静态代理中，代理类负责调用被代理类的方法，并在方法调用前后进行一些额外的处理。

静态代理的优点是简单易懂，容易实现，缺点是需要为每个被代理类编写一个代理类，如果被代理类过多，会导致代码冗长和维护困难。

Code

在这里插入图片描述

package com.artisan.proxy.static_proxy;

/**
 * @author artisan
 */
public interface Subject {
    
    

    void bussiness();
}


package com.artisan.proxy.static_proxy;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class RealSubject implements Subject {
    
    

    @Override
    public void bussiness() {
    
    
        System.out.println("RealSubject bussiness  Logic ");
    }
}
    

package com.artisan.proxy.static_proxy;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 * @desc: 代理类也需要实现同一个接口, 并持有真正的业务对象
 */
public class ProxySubject implements Subject {
    
    

    /**
     * 持有真正的对象
     */
    private RealSubject realSubject;


    /**
     * 传入要代理的对象, 通过构造函数实例化代理对象
     *
     * @param realSubject
     */
    public ProxySubject(RealSubject realSubject) {
    
    
        this.realSubject = realSubject;
    }

    @Override
    public void bussiness() {
    
    
        // 代理前的业务逻辑
        System.out.println("ProxySubject before request");

        // 真正的业务处理逻辑
        realSubject.bussiness();

        // 代理后业务逻辑
        System.out.println("ProxySubject after request");
    }
}
    

package com.artisan.proxy.static_proxy;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class StaticProxyDemo {
    
    

    public static void main(String[] args) {
    
    
        // 真正的处理对象
        RealSubject realSubject = new RealSubject();
        // 传入真正的处理对象，初始化代理对象
        ProxySubject proxySubject = new ProxySubject(realSubject);
        // 通过代理类调用实现了同一个接口或者继承了同一个父类的方法，以便织入代理逻辑，且不影响原来的方法的逻辑
        proxySubject.bussiness();
    }
}

在这里插入图片描述

动态代理

概述

动态代理是一种在运行时生成代理类的方式。在动态代理中，代理类和委托类的关系是在运行时确定的。动态代理模式的实现可以使用 Java 提供的 Proxy 类和 InvocationHandler 接口来实现 或者 CGLib动态代理。

实现方式一 - JDK代理或接口代理

在这里插入图片描述

概述

动态代理是指在运行时动态生成代理类，不需要为每个被代理类编写一个代理类。在动态代理中，代理类实现了InvocationHandler接口，通过反射机制调用被代理类的方法，并在方法调用前后进行一些额外的处理。

动态代理的优点是可以动态生成代理类，不需要为每个被代理类编写一个代理类，缺点是实现较为复杂。

Java动态代理是一种在运行时创建代理类的机制，它允许在不提前知道代理类的具体类型的情况下，动态地创建一个代理对象来代替原始类。相比于静态代理，动态代理更加灵活，可以代理任意的接口类型，不需要为每个被代理的类编写专门的代理类，而是通过Java的反射机制在运行时动态生成代理类。

动态代理主要使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现。动态代理又被称为JDK代理或接口代理。

Code

在这里插入图片描述

package com.artisan.proxy.dynamic_jdk_proxy;

/**
 * @author artisan
 */
public interface Subject {
    
    

    void request();


    String handle(String inParams);
}



package com.artisan.proxy.dynamic_jdk_proxy;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class RealSubject implements Subject {
    
    
    @Override
    public void request() {
    
    
        System.out.println("real subject execute request");
    }

    @Override
    public String handle(String inParams) {
    
    
        System.out.println("real subject execute handle, 入参： " + inParams);
        return inParams;
    }
}
    
    

package com.artisan.proxy.dynamic_jdk_proxy;

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

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class DynamicProxy implements InvocationHandler {
    
    

    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    
        System.out.println("DynamicProxy before request");

        Object result = method.invoke(target, args);

        System.out.println("DynamicProxy after request");
        return result;
    }
}

 package com.artisan.proxy.dynamic_jdk_proxy;

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

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class DynamicJdkProxyDemo {
    
    

    public static void main(String[] args) {
    
    

        // 创建真实（返回值请使用接口来接收）
        Subject subject = new RealSubject();

        // 创建动态代理类
        InvocationHandler invocationHandler = new DynamicProxy(subject);

        // 一切都是面向接口  方式一
        Subject subjectProxy = (Subject) Proxy.newProxyInstance(
                Subject.class.getClassLoader(),
                new Class[]{
    
    Subject.class},
                invocationHandler);

        // 通过动态代理进行request方法调用
        subjectProxy.request();

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

        String handle = subjectProxy.handle("1-testInParams");
        System.out.println(handle);

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

        // 一切都是面向接口  方式二
        Subject o = (Subject) Proxy.newProxyInstance(
                subject.getClass().getClassLoader(),
                subject.getClass().getInterfaces(),
                invocationHandler);

        // 通过动态代理进行request方法调用
        o.request();
        System.out.println("------------------------------");

        String handle1 = o.handle("2-testInParams");
        System.out.println(handle1);
    }
}

在这里插入图片描述

通过动态代理，我们在执行类的方法前后成功添加了额外的处理（xxxx），同时客户端代码无需关心具体的日志记录逻辑，实现了解耦。动态代理在很多场景下非常有用，例如AOP（面向切面编程）等

实现方式二 - CGLib 子类代理 (Code Generation Library)

概述

CGLIB（Code Generation Library）是一个开源的第三方库，用于在Java运行时生成字节码并创建代理类。与Java标准库中的动态代理（基于接口）不同，CGLIB代理可以代理普通类，即使它们没有实现任何接口。CGLIB使用ASM库来生成字节码，并通过继承的方式创建代理类，因此也被称为子类代理。CGLIB广泛用于各种框架和库中，如Spring AOP

cglib代理是一种基于字节码技术的代理方式，它可以在运行时动态生成被代理类的子类，并覆盖其中的方法来实现代理。在cglib代理中，被代理类不需要实现任何接口或者继承任何父类。

cglib代理的优点是不需要为每个被代理类编写一个接口或者父类，可以对任意类进行代理，缺点是由于它是基于字节码技术实现的，所以生成的子类可能会比较庞大。

pom依赖

     <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

Code

在这里插入图片描述

 package com.artisan.proxy.dynamic_cglib_proxy;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 * @desc: 普通类
 */
public class NormalClass {
    
    

    public String logic() {
    
    
        System.out.println("Normal class execute Logic");
        return "OK";
    }

    public int minus(int a, int b) {
    
    
        System.out.println("Normal class execute minus");
        return a - b;
    }
}
    
    

 package com.artisan.proxy.dynamic_cglib_proxy;

/**
 * @author artisan
 */
public interface Subject {
    
    

    void request();


    String handle(String inParams);
}


package com.artisan.proxy.dynamic_cglib_proxy;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 * @desc: 接口类
 */
public class RealSubject implements Subject {
    
    
    @Override
    public void request() {
    
    
        System.out.println("real subject execute request");
    }

    @Override
    public String handle(String inParams) {
    
    
        System.out.println("real subject execute handle, 入参： " + inParams);
        return inParams;
    }
}
    
    

package com.artisan.proxy.dynamic_cglib_proxy;


import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 * @desc: Cglib动态代理回调类, 需要实现MethodInterceptor接口
 */
public class CglibProxy implements MethodInterceptor {
    
    

    /**
     *
     */
    private Object target;

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

    /**
     * 创建代理类
     *
     * @return
     */
    public Object createProxy() {
    
    
        // 创建Enhancer对象,用于生成动态代理
        Enhancer enhancer = new Enhancer();

        // 设置需要创建代理的类
        enhancer.setSuperclass(target.getClass());

        // 设置回调对象,处理代理方法调用
        enhancer.setCallback(this);

        // 生成代理类
        return enhancer.create();
    }

    /**
     * 拦截代理类方法调用
     *
     * @param o           代理类实例
     * @param method      代理类方法
     * @param args        方法参数
     * @param methodProxy 方法代理,用于调用父类方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    
    

        // 前置处理
        System.out.println("CglibProxy before request");

        // 调用父类方法
        Object result = methodProxy.invokeSuper(o, args);

        // 后置处理
        System.out.println("CglibProxy after request");

        return result;
    }
}
    

package com.artisan.proxy.dynamic_cglib_proxy;


/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class DynamicCglibProxyDemo {
    
    

    public static void main(String[] args) {
    
    
        testNormalClass();
        System.out.println("==============================");
        testInterface();
    }

    /**
     * 代理普通类
     */
    public static void testNormalClass() {
    
    
        // 真实类
        NormalClass normalClass = new NormalClass();
        // 构建代理类
        CglibProxy cglibProxy = new CglibProxy(normalClass);
        // 创建代理类
        NormalClass proxy = (NormalClass) cglibProxy.createProxy();

        // 通过代理类执行方法调用无参方法
        proxy.logic();
        System.out.println("---------------------------");

        // 调用代理对象的方法,传入参数
        int result = proxy.minus(5, 2);
        System.out.println(result);
    }

    /**
     * 代理接口
     */
    public static void testInterface() {
    
    
        // 真实类
        Subject subject = new RealSubject();
        //  构建代理类
        CglibProxy cglibProxy = new CglibProxy(subject);
        // 创建代理类
        Subject subjectProxy = (Subject) cglibProxy.createProxy();

        // 通过代理类执行方法调用无参方法
        subjectProxy.request();
        System.out.println("---------------------------");

        // 调用代理对象的方法,传入参数
        String result = subjectProxy.handle("testInparmas");
        System.out.println(result);
    }
}

在这里插入图片描述
通过CGLIB代理，我们成功在方法执行前后添加了额外的处理（xx），实现了解耦。CGLIB代理在不需要接口的情况下也能很好地完成代理任务，但由于它是通过继承的方式生成代理类，可能会影响某些场景，比如无法代理final方法。

在这里插入图片描述

猜你喜欢

转载自blog.csdn.net/yangshangwei/article/details/132231128
今日推荐
NetBSD 禁止提交由 AI 生成的代码
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
周排行
女程序员是这样被恶搞的
B/S 和 C/S 的优缺点
vector一直申请会怎样？
座头鲸识别比赛(Humpback Whale Identification)总结
Linux高性能服务器编程——I/O复用 select
Mysql连接数据库（当包使用）
通过URI获取的文件路径为null的解决方法
1022-Primes on Interval(素数筛选+二分查找) ZCMU
Python出现： TypeError: expected string or buffer
bzoj2434: [Noi2011]阿狸的打字机 ac自动机+树状数组
每日归档
更多
2024-05-18(4)
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022