动态代理(JDK Proxy)

代理模式

代理模式是23种设计模式的一种,他是指一个对象A通过持有另一个对象B,可以具有B同样的行为的模式. 为了对外开放协议,B往往实现了一个接口,A也会去实现接口. 但是B是“真正”实现类,A则比较“虚”,他借用了B的方法去实现接口的方法. A虽然是“伪军”,但它可以增强B,在调用B的方法前后都做些其他的事情. Spring AOP就是使用了动态代理完成了代码的动态“织入”.

使用代理好处还不止这些,一个工程如果依赖另一个工程给的接口,但是另一个工程的接口不稳定,经常变更协议,就可以使用一个代理,接口变更时,只需要修改代理,不需要一一修改业务代码. 从这个意义上说,所有调外界的接口,我们都可以这么做,不让外界的代码对我们的代码有侵入,这叫防御式编程. 代理其他的应用可能还有很多.

上述例子中,类A写死持有B,就是B的静态代理. 如果A代理的对象是不确定的,就是动态代理. 动态代理目前有两种常见的实现,jdk动态代理和cglib动态代理.

JDK动态代理

jdk动态代理是jre提供给我们的类库,可以直接使用,不依赖第三方. 先看下jdk动态代理的使用代码,再理解原理.
以一个Deme

• 需求:
• 1. 要对单借口 进行订单号长度校验 不能小于十位 但是不能有代码入侵性
• 2. 接口返回下单成功 发送短信
     代码:

1. 接口

package proxy.jdk;

/**
 * @Description: <br/>
 * 订单服务
 * <p>
 * <br/>
 * @Author: Qz1997
 * @create 2021/5/1 10:47
 */
public interface OrderService {
    /**
     * 下单
     *
     * @param orderNo 订单号
     * @return 结果
     */
    String preOrder(String orderNo);
}

2. 实现类

package proxy.jdk;

/**
 * @Description: <br/>
 * 订单服务
 * <p>
 * <br/>
 * @Author: Qz1997
 * @create 2021/5/1 10:51
 */
public class OrderServiceImpl implements OrderService {
    /**
     * 下单
     *
     * @param orderNo 订单号
     * @return 结果
     */
    @Override
    public String preOrder(String orderNo) {
        System.out.println("orderNo = " + orderNo);
        return "下单成功";
    }
}

3. 生成代理工厂

package proxy.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.lang.reflect.Proxy;
import java.util.Objects;

/**
 * @Description: <br/>
 * 生成代理对象的工厂
 * <p>
 * <br/>
 * @Author: Qz1997
 * @create 2021/5/1 11:43
 */
public class MyProxyFactory<T> implements InvocationHandler {
    /**
     * 目标类，也就是被代理对象
     */
    private T target;

    /**
     * 代理执行方法
     *
     * @param proxy  是被代理的对象
     * @param method 执行的方法
     * @param args   方法执行的参数
     * @return 代理结果
     * @throws Throwable 异常
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /*
         * JDK 动态代理基于接口的
         * Proxy 类
         * InvocationHandler 的函数式接口
         *
         * Proxy#newProxyInstance 方法有三个参数
         * 1. 类加载器
         * 2. 需要代理的对象
         * 3. InvocationHandler 的函数式接口 代理的方法
         *
         */
        // 参数1: 是被代理的对象
        // 参数2: 执行的方法
        // 参数3: 方法执行的参数

        // --------------分割线------------
        // 判断方法参数 如果是null || 参数格式 <= 0
        if (Objects.isNull(args) || args.length <= 0) {
            // 注意: 如果只有借口没有实现类  如: MyBatis的Mapper 这里执行的方法对象就是代理对象了 (Object proxy)
            return method.invoke(target, args);
        }
        /// // 判断这个方法上是否包含某个注解
        // if (method.isAnnotationPresent(Async.class)) {
        //     // ....进行一顿增强
        //     // return method.invoke(proxy, arg);
        // }
        Parameter[] parameters = method.getParameters();
        Parameter parameter = parameters[0];
        Class<?> type = parameter.getType();
        // 类型为String
        if (type == String.class) {
            String orderNo = (String) args[0];
            if (Objects.nonNull(orderNo) && orderNo.length() < 10) {
                throw new RuntimeException("订单号错误");
            }
        }
        String result = (String) method.invoke(target, args);
        if (Objects.equals(result, "下单成功")) {
            System.out.println("发动订单短信");
        }
        return result;
    }

    public void setTarget(T target) {
        this.target = target;
    }


    /**
     * 生成代理类
     *
     * @return 代理对象
     */
    @SuppressWarnings("all")
    public T creatProxyedObj() {
        return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }
}

4. 使用

package proxy.jdk;

/**
 * @Description: <br/>
 * 需求:
 * 1. 要对单借口 进行订单号长度校验 不能小于十位   但是不能有代码入侵性
 * 2. 接口返回`下单成功` 发送短信
 * <p>
 * <br/>
 * @Author: Qz1997
 * @create 2021/5/1 10:40
 */
public class JdkProxy {
    public static void main(String[] args) {
        // 创建一个原对象
        OrderService orderService = new OrderServiceImpl();
        // 代理的工厂
        MyProxyFactory<OrderService> objectMyProxy = new MyProxyFactory<>();
        // 设置原对象
        objectMyProxy.setTarget(orderService);
        // 生成代理对象
        orderService = objectMyProxy.creatProxyedObj();
        // 执行的就是代理方法
        String result = orderService.preOrder("123234234234");
        System.out.println("s = " + result);
    }
}

执行结果