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

这篇具有很好参考价值的文章主要介绍了Java Review - 关于代理的二三事儿。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Java Review - 关于代理的二三事儿,【Java - Java Base】,java,代理模式


Pre

Java-JDK动态代理

Java-CGLib动态代理


概述

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

在 Java 中,代理模式有两种形式:

  • 静态代理
  • 动态代理

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

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


静态代理

Java Review - 关于代理的二三事儿,【Java - Java Base】,java,代理模式

概述

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

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

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


Code

Java Review - 关于代理的二三事儿,【Java - Java Base】,java,代理模式

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 Review - 关于代理的二三事儿,【Java - Java Base】,java,代理模式


动态代理

概述

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


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

Java Review - 关于代理的二三事儿,【Java - Java Base】,java,代理模式

概述

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

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

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

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

Code

Java Review - 关于代理的二三事儿,【Java - Java Base】,java,代理模式

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);
    }
}
    
    

Java Review - 关于代理的二三事儿,【Java - Java Base】,java,代理模式

通过动态代理,我们在执行类的方法前后成功添加了额外的处理(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

Java Review - 关于代理的二三事儿,【Java - Java Base】,java,代理模式

 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);
    }
}
    

Java Review - 关于代理的二三事儿,【Java - Java Base】,java,代理模式
通过CGLIB代理,我们成功在方法执行前后添加了额外的处理(xx),实现了解耦。CGLIB代理在不需要接口的情况下也能很好地完成代理任务,但由于它是通过继承的方式生成代理类,可能会影响某些场景,比如无法代理final方法

Java Review - 关于代理的二三事儿,【Java - Java Base】,java,代理模式文章来源地址https://www.toymoban.com/news/detail-647846.html

到了这里,关于Java Review - 关于代理的二三事儿的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

原文地址:https://blog.csdn.net/yangshangwei/article/details/132231128

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包