什么是代理模式

代理设计模式是一种结构型设计模式，它允许你控制对一个对象的访问。该模式通过在客户端和目标对象之间创建一个代理来实现这一目的。代理可以提供额外的功能，例如安全性、缓存、日志记录等。代理可以在运行时动态地添加或删除功能，从而使系统更加灵活。

代理模式通常包括以下几个角色：

抽象角色：定义了代理接口，并提供了一些基本的方法。
委托角色：实现了抽象角色中定义的方法，并提供了与目标对象相同的接口。
目标角色：被代理的对象，也就是需要被保护或者控制访问的对象。

代理模式可以分为静态代理和动态代理两种类型。静态代理是在编译时生成代理类，而动态代理是在运行时动态生成代理类。

应用场景

远程方法调用(Remote Method Invocation,RMI):在分布式系统中，客户端可以通过代理对象来调用远程对象的方法。
动态代理：动态代理可以在运行时生成代理对象，从而实现更灵活的代码重用和扩展。
缓存：代理可以用于缓存数据，以提高性能并减少对数据库或其他存储系统的访问。
安全控制：代理可以用于实现安全控制，例如，一个代理服务器可以检查客户端的身份验证信息，以确保只有授权的用户才能访问受保护的资源。
日志记录：代理可以用于记录系统的行为，例如，代理服务器可以记录所有被代理对象的方法调用。
对象池：代理可以用于管理对象池，例如，代理服务器可以维护一组对象的池，并在需要时从池中获取对象而不是每次都创建新的对象。
延迟加载：代理可以用于延迟加载资源，例如，当需要使用某个资源时才加载它，而不是在程序启动时就加载。
命令注入：代理可以用于注入命令，例如，在一个系统中，客户端可以通过代理对象来执行特定的命令。
智能指针：智能指针是一种基于代理模式实现的指针类型，它可以自动管理内存并避免内存泄漏。
装饰器模式：装饰器模式也可以通过代理来实现，例如，一个装饰器可以包装一个对象并添加额外的功能。
买火车票不一定到火车站买，也可以去代售点。
银行卡和支票都是真实钱的代理对象。

静态代理

静态代理是一种在代码编写期进行代理类和被代理类的关联的代理方式。

具体实现是创建一个代理类，通常需要实现与被代理类相同的接口或继承被代理类。

房东接口类：Landlord1Service，注意，静态代理实现它的真实对象只能有一个，多个的话，代理对象不能确定哪个对象需要被代理，会导致报错，JDK动态代理没这个问题。

代码结构

代码

房东接口

/**
 * 房东
 */
public interface Landlord1Service {
    /**
     * 出租
     *
     * @param money 金额
     */
    void rent(Integer money);
}

租客

import org.springframework.stereotype.Component;

/**
 * 租客
 */
@Component
public class TenantImpl implements Landlord1Service {

    @Override
    public void rent(Integer money) {
        System.out.println("租下" + money + "元一个月的房子");
    }
}

中介

中介这个时候就相当于代理

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 中介
 *
 * @author Created by njy on 2023/5/30
 */
@Component
public class ProxyImpl implements Landlord1Service {

    /**
     * 房东有很多套房子，不想亲自出马了，于是找来了中介
     */
    @Autowired
    private Landlord1Service target;

    /**
     * 优点就是在不改变原来的实现类的情况下对方法实现了增强
     * 缺点是如果原来的接口新增了方法，那么这里也要对应实现新的方法
     *
     * @param money 金额
     */
    @Override
    public void rent(Integer money) {
        System.out.println("[静态代理]交中介费");
        target.rent(money);
        System.out.println("[静态代理]中介负责维修管理");
    }
}

测试

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class TestProxy {

    /**
     * 租客
     */
    @Autowired
    private TenantImpl tenant;

    /**
     * 中介-代理
     */
    @Autowired
    private ProxyImpl proxy;

    //1.静态代理
    @Test
    void TestStatic() {
        tenant.rent(1000);
        System.out.println();
        proxy.rent(2000);
    }
}

静态代理应用场景

适用场景：

当代理对象只有一个时，可以使用静态代理
当被代理的类的接口比较稳定时，可以使用静态代理
当需要为多个被代理的类提供代理时，会导致代理类过多，不方便管理和维护，所以不建议使用静态代理。

JDK动态代理

JDK动态代理是一种比较常见的代理方式，它是在程序运行时动态生成代理类，也就是说我们在编写代码时并不知道具体代理的是什么类，而是在程序运行时动态生成。

代码结构

代码

房东接口

/**
 * 房东
 */
public interface Landlord2Service {

    /**
     * 出租
     */
    void rent(Integer money);
}

租客1

import org.springframework.stereotype.Component;

/**
 * 租客1
 */
@Component
public class Teant1Impl implements Landlord2Service {
    @Override
    public void rent(Integer money) {
        System.out.println("tenant1租下" + money + "元一个月的房子");
    }
}

租客2

import org.springframework.stereotype.Component;

/**
 * 租客2
 */
@Component
public class Tenant2Impl implements Landlord2Service {
    @Override
    public void rent(Integer money) {
        System.out.println("tenant2租下" + money + "元一个月的房子");
    }
}

中介

中介—动态代理类

import java.lang.reflect.Proxy;

/**
 * JDK动态代理：就是把代理抽象了一下
 */
public class JDKProxy {

    private Object target;

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

    /**
     * 给目标对象生成代理对象
     *
     * @return 代理生成的对象
     */
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                //这里是要实现jdk代理InvocationHandler的接口，lambda表达式
                (proxy, method, args) -> {
                    //执行对象方法
                    System.out.println("[JDK动态代理]交中介费");
                    method.invoke(target, args);
                    System.out.println("[JDK动态代理]中介负责维修管理");
                    return null;
                });
    }
}

测试

import com.xiaofei.proxy.jdkProxy.JDKProxy;
import com.xiaofei.proxy.jdkProxy.Landlord2Service;
import com.xiaofei.proxy.jdkProxy.Teant1Impl;
import com.xiaofei.proxy.jdkProxy.Tenant2Impl;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * JDK动态代理测试
 */
@SpringBootTest
public class JDKProxyTest {
    @Autowired
    private Teant1Impl teant1;
    @Autowired
    private Tenant2Impl tenant2;

    //2.JDK动态代理
    @Test
    void TestJDK() {
        Landlord2Service proxyInstance1 = (Landlord2Service) new JDKProxy(teant1).getProxyInstance();
        proxyInstance1.rent(2500);

        System.out.println();
        Landlord2Service proxyInstance2 = (Landlord2Service) new JDKProxy(tenant2).getProxyInstance();
        proxyInstance2.rent(2500);
    }
}

JDK动态代理应用场景

对象必须实现一个或多个接口
代理类的代理方法不需要额外的逻辑

Cglib代理

CGLIB代理是在运行时动态生成代理类的方式，它使用的库是cglib，和JDK代理相比，它不是动态的生成一个实现了接口的代理类，而是直接在内存中构建一个被代理类的子类，并重写父类的方法来进行代理。

代码结构

代码

房东

import org.springframework.stereotype.Component;

/**
 * 房东
 */
@Component
public class Landlord3Service {
    /**
     * 出租房屋
     *
     * @param money
     * @return
     */
    public void rent(Integer money) {
        System.out.println("租下" + money + "元一个月的房子");
    }
}

Cglib代理

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * JDKProxy：cglib子类代理工厂
 * 1.代理的类不能为final
 * 2.目标对象的方法如果为final/static，那么就不会被拦截，也不会执行目标对象的业务方法
 */
public class CglibProxy implements MethodInterceptor {

    /**
     * 目标对象
     */
    private final Object target;

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

    public Object getProxyInstance() {
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类（代理对象）
        return en.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("[Cglib代理]交中介费");
        method.invoke(target, objects);
        System.out.println("[Cglib代理]中介负责维修管理");
        return null;
    }
}

测试

import com.xiaofei.proxy.cglib.CglibProxy;
import com.xiaofei.proxy.cglib.Landlord3Service;
import lombok.RequiredArgsConstructor;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * CglibProxy测试
 */
@SpringBootTest
@RequiredArgsConstructor
public class CglibProxyTest {
    @Autowired
    private Landlord3Service landlord3Service;

    /**
     * Cglib代理
     */
    @Test
    void TestCglib() {
        Landlord3Service proxyInstance = (Landlord3Service) new CglibProxy(landlord3Service).getProxyInstance();
        proxyInstance.rent(3000);
    }
}