Spring深入学习（7）AOP导学：基于接口的动态代理

关于代理

代理是一种常用的设计模式，其目的就是为了给其他对象提供一个代理以控制对某个对象的访问。代理负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行的后续处理。
为了保持行为的一致性，代理类和委托类通常会实现相同的接口。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好的隐藏和保护委托类对象。
下面就通过一个简单的例子，帮助理解基于接口的代理类。

生产者与消费者与代理

创建一个生产者的接口

package com.tianqicode.proxy;

public interface IProducer {

    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money);

    /**
     * 售后
     * @param money
     */
    public void afterService(float money);

}

实现这个接口

package com.tianqicode.proxy;

/**
 *一个生产者
 */
public class Producer implements IProducer{

    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money) {
        System.out.println("销售产品,并拿到钱：" + money);
    }

    /**
     * 售后
     * @param money
     */
    public void afterService(float money) {
        System.out.println("提供售后,并拿到钱：" + money);
    }
}

在模拟一个消费者通过代理调用销售产品方法之前，先了解一下如何写一个代理类

• 动态代理：
  特点： 字节码随用随创建，随用随加载（内部匿名类）
  作用： 不修改源码的基础上对方法增强
  分类：
  • 基于接口的动态代理：
    涉及的类：Proxy
    提供者：JDK官方
  • 如何创建代理对象：
    使用Proxy类中的newProxyInstance方法
  • 创建代理对象的要求：
    委托类至少实现一个接口，否则不能使用
  • newProxyInstance方法的参数：
    ClassLoader：类加载器；它是用于加载代理对象字节码的。和委托类对象使用相同的类加载器。（固定写法）。
    class[ ]：字节码数组；它是用于让代理对象和委托类对象有相同的方法。（固定写法）
    InvocationHandler:调用处理器；用于提供增强的代码，它是让我们写如何代理。我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类。接口中只定义了一个invoke方法，在这个方法中使用动态调用方法的形式，对被调用的方法进行加强。
    此接口的实现类一般是谁用谁写。

package com.tianqicode.proxy;

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

/**
 * 模拟一个消费者
 */

public class Client {

    public static void main(String[] args) {

        final Producer producer = new Producer();

        IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 作用：执行委托对象的任何接口方法都会经过这个方法
                     * @param proxy  代理对象的引用
                     * @param method 当前执行的方法
                     * @param args   当前执行方法所需的参数
                     * @return       和委托对象方法有相同的返回值
                     * @throws Throwable
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //提供增强的代码
                        Object returnValue = null;

                        //1、获取方法执行的参数
                        Float money =(Float) args[0];
                        //2、判断当前方法是不是销售
                        if ("saleProduct".equals(method.getName())) {

                            //用来动态调用方法
                            returnValue = method.invoke(producer,money*0.8f);
                        }

                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(10000f);
    }
}

这样就实现了对销售方法的动态代理，并未对销售方法进行改动，就实现了对销售方法的增强。
我们同样可以利用这个思想去优化之前的项目，让它变得更加简洁。