代理模式简述

目录

一、主要角色

二、类型划分

三、静态代理

示例

缺点

四、动态代理

JDK动态代理

示例

 缺点

CGLib动态代理

导入依赖

示例

五、Spring AOP

        代理模式是一种结构型设计模式，通过代理对象控制对目标对象的访问，可在不改变目标对象情况下增强其功能，隐藏实现细节。

一、主要角色

• Subject（业务接口类）：可以是抽象类或接口
• RealSubject（业务实现类）：具体的业务执行，即被代理的对象
• Proxy（代理类）：RealSubject的代理

二、类型划分

根据代理的创建时期，可分为静态代理和动态代理

• 静态代理：由程序员创建或工具自动生成代理类源代码并编译，程序运行前代理类的字节码文件已经存在；
• 动态代理：在程序运行时运用反射机制动态创建而成

为方便下面的讲解，我们先提前创建业务接口类和业务实现类

//业务接口类
public interface HouseSubject {
    void rentHouse();
}

//业务实现类（被代理类）
public class RealHouseSubject implements HouseSubject {
    @Override
    public void rentHouse() {
        System.out.println("我是房东，我出租房子");
    }
}

三、静态代理

示例

//代理类
public class HouseProxy implements HouseSubject{
    //中介出售房子前要先有房东的授权
    private HouseSubject houseSubject;

    public HouseProxy(HouseSubject houseSubject) {
        this.houseSubject = houseSubject;
    }

    @Override
    public void rentHouse() {
        System.out.println("我是中介，我开始代理房东出租房子");
        houseSubject.rentHouse();
        System.out.println("我是中介，代理结束");
    }
}

使用代理类执行

public class Main {
    public static void main(String[] args) {
        //创建代理对象
        HouseSubject subject=new HouseProxy(new RealHouseSubject());
        subject.rentHouse();
    }
}

缺点

• 为每个被代理类编写代理类，代码冗余，随着业务的发展，类数量膨胀，项目管理难度增大
• 被代理类接口变化时，所有相关代理类都需修改，易出错，可维护性差
• 只能服务特定被代理类，难以应对新类和多变的额外逻辑需求，缺乏灵活性

四、动态代理

JDK动态代理

示例

自定义JDKInvocationHandler 并重写invoke()，在invoke()中会调用目标方法，并自定义一些处理逻辑

import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

//实现 InvocationHandler接口可以被代理对象的方法进行功能增强
@Slf4j
public class JDKInvocationHandler implements InvocationHandler {

    //目标类
    private Object target;

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

    /**
     * 调用目标方法，并对方法进行增强
     * @param proxy 代理对象
     * @param method 代理对象需要实现的方法
     * @param args method方法所对应的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("JDK动态代理开始");
        //调用目标函数
        Object result=method.invoke(target,args);
        log.info("JDK动态代理结束");
        return null;
    }
}

创建代理对象，执行逻辑 

import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        RealHouseSubject target=new RealHouseSubject();

        //通过被代理类、被代理类实现的接口、方法调用处理器来创建一个代理类
        /**
         *  ClassLoader loader 类加载器，用于加载代理对象
         *  Class<?>[] interfaces 被代理类实现的一些接口（jdk只能代理实现了接口的类）
         *  java.lang.reflect.InvocationHandler h 实现了InvocationHandler接口的对象
         */
        HouseSubject proxy=(HouseSubject) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            new Class[]{HouseSubject.class},
            new JDKInvocationHandler(target)
        );
        //使用代理类
        proxy.rentHouse();
    }
}

 缺点

只能代理实现了接口的类，不能代理普通类

CGLib动态代理

导入依赖

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

示例

import lombok.extern.slf4j.Slf4j;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

@Slf4j
public class CGLibMethodInterceptor implements MethodInterceptor {
    private Object target;
    public CGLibMethodInterceptor(Object target) {
        this.target = target;
    }

    /**
     *
     * @param o 被代理的对象
     * @param method 目标方法
     * @param objects 方法入参
     * @param methodProxy 用于调用原始方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //代理增强内容
        System.out.println("CGLib代理开始");
        //通过反射调用被代理的方法
        Object retVal=methodProxy.invoke(target,objects);
        System.out.println("CGLib代理结束");
        return retVal;
    }
}

import net.sf.cglib.proxy.Enhancer;

public class Main {
    public static void main(String[] args) {
        HouseSubject target=new RealHouseSubject();
        HouseSubject proxy= (HouseSubject)Enhancer.create(target.getClass(),new CGLibMethodInterceptor(target));
        proxy.rentHouse();
    }
}

五、Spring AOP

Spring AOP是基于动态代理实现的，动态代理有JDK和CGLIB两种方式，运行时使用哪种方式与项目配置和代理的对象有关。

proxy-target-class="false"情况下，若代理对象实现接口，默认使用JDK动态代理；若未实现接口，则会用CGLIB动态代理。当然，即便对象实现接口，也能通过xml配置proxy-target-class="true"或在配置类上使用注解@EnableAspectJAutoProxy(proxyTargetClass = true) 强制使用CGLIB动态代理。

Spring Boot 2.X开始默认使用CGLIB代理，也就是proxy-target-class="true"。

二者各有优劣，需依项目实际情况抉择。JDK动态代理优势在于基于Java原生支持，无需额外依赖，性能较好，适用于对性能要求高且目标对象有接口的场景；但是只能代理实现了接口的对象。

CGLIB动态代理优势在于能代理无接口的普通类，功能更强大、灵活性更高；但是需额外注入依赖，且通过继承创建代理，若类被final修饰则无法代理，生成代理对象的性能开销相对较大。