Java中静态代理和动态代理介绍和使用

登山人在路上

于 2024-07-21 10:53:18 发布

阅读量850

点赞数 20

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_44286009/article/details/140583835

版权

Java基础专栏收录该内容

4 篇文章 0 订阅

订阅专栏

前言

在Java中，代理模式是一种常用的设计模式，用于为其他对象提供一种代理以控制对这个对象的访问。代理模式主要有两种实现方式：静态代理和动态代理。

一、静态代理

静态代理是由程序员手动创建或指定代理类，代理类在程序运行前就已经存在。静态代理通常用于业务层之间的解耦，使得委托类（被代理的类）和代理类之间不存在直接的依赖关系，而是通过共同的接口进行交互。

优点：

可以在不修改真实对象的前提下，增加额外的功能。
灵活性高，可以根据需要创建多个代理类。

缺点：

代理类需要手动编写，增加了代码的复杂性。
如果接口增加方法，所有实现接口的类都需要进行修改。

示例：

假设有一个接口Subject和两个实现类RealSubject（真实对象）和ProxySubject（代理对象）。

Subject接口：

package edu.etime.proxy.demo;

/**
 * @Date 2024/7/21 9:51
 * @Author liukang
 **/
public interface Subject {
    void request();
}

RealSubject（真实对象）：

package edu.etime.proxy.demo;

/**
 * @Date 2024/7/21 9:52
 * @Author liukang
 **/
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("处理请求");
    }
}

ProxySubject（代理对象）：

package edu.etime.proxy.demo;

/**
 * @Date 2024/7/21 9:52
 * @Author liukang
 **/
public class ProxySubject implements Subject {
    private RealSubject realSubject;

    public ProxySubject() {
        this.realSubject = new RealSubject();
    }

    public ProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        preRequest();
        realSubject.request();
        postRequest();
    }

    private void preRequest() {
        System.out.println("请求前的处理");
    }

    private void postRequest() {
        System.out.println("请求后的处理");
    }
}

测试调用：

package edu.etime.proxy.demo;

/**
 * @Date 2024/7/21 9:54
 * @Author liukang
 **/
public class MyTest {
    public static void main(String[] args) {
        // 创建代理对象
        ProxySubject proxySubject = new ProxySubject();
        // 调用代理对象中的request方法
        proxySubject.request();
    }
}

二、动态代理

动态代理是在运行时动态生成代理类。动态代理主要依赖于Java的反射机制。Java提供了两种动态代理的实现方式：基于接口的JDK动态代理和基于类的CGLIB动态代理。

1.JDK动态代理

JDK动态代理：

JDK动态代理是面向接口的代理模式，它要求被代理对象必须实现一个接口。JDK动态代理的核心是InvocationHandler接口和Proxy类。

优点：

动态生成代理类，减少代码量。
代理类实现简单，只需实现InvocationHandler接口。

缺点：

只能代理实现了接口的类。

示例：

Subject接口：

package edu.etime.proxy.demo2;

/**
 * @Date 2024/7/21 9:51
 * @Author liukang
 **/
public interface Subject {
    void request();
}

RealSubject（真实对象）：

package edu.etime.proxy.demo2;

/**
 * @Date 2024/7/21 10:09
 * @Author liukang
 **/
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("处理请求");
    }
}

DynamicProxyHandler（代理对象）：

package edu.etime.proxy.demo2;

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

/**
 * @Date 2024/7/21 10:01
 * @Author liukang
 **/
public class DynamicProxyHandler implements InvocationHandler {
    private Object target;

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

    // 实现InvocationHandler接口重写的方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /*方法参数解释
        * Object proxy：代理的对象
        * Method method：要运行的方法
        * Object[] args：调用方法时传递的参数
        * */
        System.out.println("请求前的处理");
        Object result = method.invoke(target, args);
        System.out.println("请求后的处理");
        return result;
    }

    // 创建代理对象的方法
    public static <T> T getProxyInstance(T target, Class<T> interfaceClass) {
        return (T) Proxy.newProxyInstance(
                interfaceClass.getClassLoader(),// 指定类加载器 此处就使用传入的接口的类加载器，也可以使用其他的
                new Class<?>[]{interfaceClass},// 指定接口，这些接口用于指定生成的代理长什么样子，也就是有哪些方法
                new DynamicProxyHandler(target)// 动态代理对象 DynamicProxyHandler里面重写invoke方法，添加逻辑，用于指定生成的代理对象要干什么事情
        );
    }
}

测试调用:

package edu.etime.proxy.demo2;



/**
 * @Date 2024/7/21 10:06
 * @Author liukang
 **/
public class MyTest {
    public static void main(String[] args) {
        // 使用
        Subject subject = (Subject) DynamicProxyHandler.getProxyInstance(new RealSubject(), Subject.class);
        subject.request();
    }
}

2.CGLIB动态代理

CGLIB（Code Generation Library）是一个强大的、高性能的代码生成库，它可以在运行时扩展Java类和实现接口。CGLIB通过继承被代理类来创建代理对象，因此它不要求被代理类实现接口。

优点：

可以代理没有实现接口的类。

缺点：

性能上比JDK动态代理稍差。
使用复杂度较高。

CGLIB动态代理的关键类：

Enhancer：CGLIB中最常用的类，用于创建代理对象。它允许你设置被代理类、回调接口等。
MethodInterceptor：这是CGLIB中用于拦截方法调用的接口。你需要实现这个接口，并在其intercept方法中编写你的代理逻辑。

CGLIB动态代理的关键步骤：

创建MethodInterceptor实现类：在这个类中，你编写方法拦截逻辑。
使用Enhancer设置被代理类和回调：配置Enhancer实例，指定被代理的类和MethodInterceptor实现类。
创建代理对象：调用Enhancer的create()方法创建代理对象。
通过代理对象调用方法：代理对象会拦截所有调用，并将它们转发到你的MethodInterceptor实现类。

示例：

RealSubject（真实对象）：

package com.etime.proxy;

/**
 * @Date 2024/7/21 10:32
 * @Author liukang
 **/
public class RealSubject {
    public void request() {
        System.out.println("处理请求");
    }
}

CglibProxy（代理对象）：

package com.etime.proxy;

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

import java.lang.reflect.Method;

/**
 * @Date 2024/7/21 10:32
 * @Author liukang
 **/
public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method " + method.getName());
        Object result = proxy.invokeSuper(obj, args); // 调用父类（即被代理类）中的方法
        System.out.println("After method " + method.getName());
        return result;
    }

    public static <T> T getProxyInstance(Class<T> clazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz); // 设置被代理类
        enhancer.setCallback(new CglibProxy()); // 设置回调
        return (T) enhancer.create(); // 创建代理对象
    }
}

测试调用:

package com.etime.proxy;

/**
 * @Date 2024/7/21 10:39
 * @Author liukang
 **/
public class MyTest {
    public static void main(String[] args) {
        RealSubject realSubject = CglibProxy.getProxyInstance(RealSubject.class);
        realSubject.request(); // 这将调用代理对象的request方法，该方法会拦截并增强原始方法
    }
}

注意：cglib动态代理需要导入对应的依赖或者jar包

maven依赖：

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

在这个示例中，RealSubject是一个普通的Java类，没有实现任何接口。我们使用CGLIB的Enhancer类来创建RealSubject的代理对象。CglibProxy类实现了MethodInterceptor接口，并在其intercept方法中编写了代理逻辑。当通过代理对象调用request方法时，intercept方法会被调用，并且我们可以在调用原始方法之前和之后执行额外的逻辑。

注意：由于CGLIB是通过继承来创建代理对象的，因此它不能代理final类，也不能代理final方法，因为final类和方法不能被继承。此外，由于CGLIB依赖于Java的反射机制来生成代理类，因此在性能上可能略逊于JDK动态代理（特别是在处理大量代理对象时）。然而，对于没有实现接口的类，CGLIB是一个很好的选择。