java代理模式

榴月~

已于 2024-07-20 16:36:14 修改

阅读量404

点赞数 5

分类专栏： Java 文章标签： java 代理模式

于 2024-07-20 16:21:14 首次发布

本文链接：https://blog.csdn.net/qq_34358193/article/details/140573129

版权

Java 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

1、代理模式

在Java语言中，常见的代理控制方式主要有静态代理和动态代理两种。每种代理方式都有其特定的应用场景和优缺点。

1. 静态代理

定义：静态代理是在编译期间就确定代理类的方式，代理类和被代理类在编译时就已经确定。静态代理需要针对每个被代理类编写一个代理类，这会增加代码量，但实现起来相对简单。

特点：

代理类需要手动编写，实现与被代理类相同的接口。
代理类与被代理类之间的关系在编译时就已经确定，无法在运行时动态改变。
可以在不修改被代理类代码的情况下，通过代理类添加额外的处理逻辑。

应用场景：当需要在原有的业务逻辑前后增加一些额外操作时，可以使用静态代理。例如，日志记录、性能监控等。

优缺点：

优点：实现简单，不侵入原代码。
缺点：代理类繁多，不易扩展和维护；当接口增加方法时，代理类和被代理类都需要修改，违反了开闭原则（软件实体应对扩展开放，对修改关闭）。

在Java语言中，常见的几种代理的控制方式

远程代理控制访问远程对象，为一个位于不同的机器的JVM上的对象提供一个本地的代理对象。
虚拟代理，根据实际需要创建开销很大的对象。如果需要创建一个消耗资源较大的对象，那么可以先创建一个消耗相对较小的对象表示这个较大的对象，大对象只在需要时才会被真正的创建。
保护代理：给予权限控制对资源的访问。保护代理用于对象应该有不同的访问权限的时候。

优点：

职责清晰：
权限控制，代理对象在客户端和目标对象之间起到中介的作用，这样实现了客户对象与目标对象的解耦合，可保护目标对象，可扩展。

2. 动态代理

动态代理是在运行时动态生成代理类的方式，相比静态代理更加灵活。Java中动态代理主要有两种实现方式：基于接口的JDK动态代理和基于类的CGLIB动态代理。

JDK动态代理：

特点：被代理类必须实现一个或多个接口，代理类由JDK在运行时动态生成，无需手动编写。
实现：通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口实现。
应用场景：适用于被代理类实现了接口的情况。

CGLIB动态代理：

特点：CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。与JDK动态代理不同，CGLIB代理不需要被代理类实现接口。
实现：通过继承被代理类来创建代理对象，因此被代理类不能为final类。
应用场景：适用于被代理类没有实现接口的情况。

优缺点：

优点：动态代理无需手动编写代理类，减少了代码量；更加灵活，可以在运行时动态改变代理逻辑。
缺点：动态代理相比静态代理有一定的性能损耗，因为需要动态生成代理类和调用反射机制；JDK动态代理要求被代理类必须实现接口，限制了其使用范围；CGLIB代理需要被代理类不是final类，且需要引入额外的依赖。

综上所述，Java语言中常见的代理控制方式包括静态代理和动态代理（JDK动态代理和CGLIB动态代理）。在选择使用哪种代理方式时，需要根据具体的应用场景和需求进行权衡和选择。

1.1 静态代理

Java静态代理模式是一种设计模式，其中代理类的代码在编译时就已经确定，并且代理类会显式地实现与目标对象相同的接口。在静态代理中，代理对象持有目标对象的引用，并在客户端和目标对象之间起到中介的作用。

静态代理模式的关键组成：

接口（Interface）：定义代理类和目标类需要实现的方法。
目标类（Target Class）：实现接口并定义实际执行的方法。
代理类（Proxy Class）：也实现相同的接口，并持有一个目标类的引用。代理类在调用目标类的方法之前或之后可以执行额外的操作。

静态代理模式的优点：

可以在不修改目标类代码的情况下，为目标类的方法调用添加额外的处理逻辑。
代理类可以在客户端和目标类之间起到中介的作用，实现功能的解耦。

静态代理模式的缺点：

代理类需要手动编写，对于每个目标类都需要创建一个对应的代理类，增加了代码的维护成本。
如果接口发生变化，代理类和目标类都需要修改，不够灵活。

示例代码：

// 定义接口
public interface Subject {
    void request();
}

// 目标类
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("执行真实对象的request()");
    }
}

// 代理类
public class ProxySubject implements Subject {
    private Subject subject;

    public ProxySubject(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void request() {
        System.out.println("调用request()之前的处理");
        subject.request();  // 调用目标对象的方法
        System.out.println("调用request()之后的处理");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        Subject proxy = new ProxySubject(realSubject);
        proxy.request();  // 通过代理对象调用目标对象的方法
    }
}

在这个例子中，ProxySubject是代理类，它实现了Subject接口，并持有一个RealSubject的引用。在request()方法中，代理类在调用目标类的方法之前和之后添加了额外的处理逻辑。客户端代码通过代理对象来调用目标对象的方法，从而实现了静态代理模式。

1.2 动态代理

动态代理是一种常用的设计模式，它允许开发者在运行时动态地创建代理类。这些代理类可以在不修改原始类代码的情况下，为原始类的方法调用提供额外的处理逻辑，如权限控制、事务处理、日志记录等。

在Java中，动态代理主要有两种方式实现：

Java原生动态代理：
- 使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。
- 只能代理实现了接口的类。
- 通过Proxy.newProxyInstance()方法动态创建代理对象。
CGLIB动态代理：
- 使用CGLIB库，这是一个开源的代码生成库。
- 可以代理没有实现接口的类。
- 通过继承被代理类并覆盖其方法来实现代理。

动态代理的优点

灵活性：可以在运行时动态地创建代理对象，无需在编译时静态地确定代理关系。
解耦：代理对象和被代理对象之间的耦合度降低，便于维护和扩展。
增强功能：可以在不修改原始类代码的情况下，为原始类的方法调用添加额外的处理逻辑。

动态代理的应用场景

AOP（面向切面编程）：在方法调用前后插入额外的处理逻辑，如日志记录、事务管理等。
RPC（远程过程调用）：在客户端和服务端之间进行通信时，使用动态代理来封装网络通信的细节。
测试：在单元测试中，使用动态代理来模拟对象的行为，以便进行隔离测试。

示例代码（Java原生动态代理）

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

public class DynamicProxyExample {
    public static void main(String[] args) {
        // 创建原始对象
        MyInterface original = new MyClass();

        // 创建代理对象
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                MyInterface.class.getClassLoader(),
                new Class[]{MyInterface.class},
                new MyInvocationHandler(original)
        );

        // 通过代理对象调用方法
        proxy.doSomething();
    }

    interface MyInterface {
        void doSomething();
    }

    static class MyClass implements MyInterface {
        @Override
        public void doSomething() {
            System.out.println("Doing something...");
        }
    }

    static class MyInvocationHandler implements InvocationHandler {
        private final Object target;

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

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Before method call");
            Object result = method.invoke(target, args);
            System.out.println("After method call");
            return result;
        }
    }
}

在这个例子中，我们创建了一个MyInterface的代理对象，并在代理对象的方法调用前后添加了额外的打印语句。

1.3 CGLIB

CGLIB（Code Generation Library）是一个强大的、高性能的代码生成库，广泛用于Java的动态代理和AOP（面向切面编程）。与Java原生的动态代理机制相比，CGLIB提供了更为丰富和灵活的功能，尤其是在处理没有实现接口的类时。Java原生动态代理只能代理实现了接口的类，而CGLIB则没有这个限制。

CGLIB的核心功能：

动态类生成：可以在运行时动态生成类的字节码，并加载到JVM中。
方法拦截：可以在运行时拦截所有对目标对象方法的调用，并在调用前后添加自定义逻辑。
继承代理：可以创建一个被代理类的子类，并在子类中覆盖父类的方法，从而实现代理功能。
固定点切入：允许在特定方法调用前后插入自定义代码，这是AOP的基础。

使用CGLIB进行动态代理的基本步骤：

定义MethodInterceptor：创建一个实现了MethodInterceptor接口的类，在这个类中定义在代理方法调用前后要执行的逻辑。
创建代理实例：使用Enhancer类来创建代理对象。你需要设置被代理类的Class对象，以及一个MethodInterceptor实例。
调用代理对象的方法：通过代理对象调用方法时，会自动执行你在MethodInterceptor中定义的逻辑。

示例代码：

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 CGLIBDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(SampleClass.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println("Before method call");
                Object result = proxy.invokeSuper(obj, args);
                System.out.println("After method call");
                return result;
            }
        });

        SampleClass proxy = (SampleClass) enhancer.create();
        proxy.test();
    }

    public static class SampleClass {
        public void test() {
            System.out.println("Hello CGLIB!");
        }
    }
}