Spring AOP基础之代理模式.静态代理和动态代理

代理模式

一、代理模式介绍
代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。

一.静态代理
上图角色分析：
?抽象角色：一般会使用接口或者抽象类来解决
?真实角色：被代理的角色实现抽象方法
?代理角色：代理真实角色，代理真实角色,也实现抽象方法，一般会做一些附属操作。

代理模式的优点：
?可以使真实角色的操作更加纯粹！不用关注一些公共的业务。
?公共业务交给代理角色，实现了业务的分工
?公共业务扩展的时候，方便集中管理。
静态代理的缺点：
?一个真实角色就会产生一个代理角色，代码量翻倍，开发效率变低。

参考代码如下：

//1.抽象角色
public interface IRent {
    //租房接口的方法;
    public void rent();
}
/*2.房东：中式英语；*/
public class HouseOwner implements IRent{
    public void rent() {
        System.out.println("房东直租房屋，一室一厅一卫，一个月300$");
    }
}
/*3.传说中中介，非链家莫属了*/
public class Proxy implements IRent{
    //1.目标对象,代理房东的房子
    HouseOwner target;
    //2.构造方法
    public Proxy(HouseOwner target) {
        this.target = target;
    }
    //3.实现的代理方法
    public void rent() {
        before();
        target.rent();
        after();
    }
    //代理增强的附加功能;
    public void before(){
        System.out.println("收取看房费100元");
    }
    public void after(){
        System.out.println("合适进行收费");
    }
}
public class ClientTest {
    @Test
    public void test(){
        //3.1房东直租
        HouseOwner owner=new HouseOwner();
        //3.2 中介代理对象的创建，来了
        Proxy proxy=new Proxy(owner);
        //3.3 客户看房子;
        proxy.rent();
    }
}

效果：

作业扩充：
代理增加日志功能
1.?创建一个抽象接口，对用户业务进行抽象：实现一个日志输出功能，以记录业务代码的调用情况。
实现思路有两种，如下：
?思路1：在业务实现类每个方法中增加相应操作（该思路是传统方法，缺点很多）。
?思路2：使用代理，在不改变原有业务的情况下，实现此日志记录功能！

体现一个重要的思想：在不改变原有代码的情况下，实现对原有功能的增强。AOP的核心思想。
二.动态代理
动态代理和静态代理的角色是一样的，动态代理的代理类是动态生成的，不是像静态代理那样是直接写死的。动态代理可以分为两大类：一类是基于接口动态代理 , 一类是基于类的动态代理。

基于接口的动态代理，如JDK动态代理
基于类的动态代理，如cglib
JDK的动态代理需要了解两个类：

核心 : InvocationHandler （调用处理程序） 和 Proxy （代理）
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。
Object invoke(Object proxy, 方法 method, Object[] args)

.
static Object newProxyInstance(ClassLoader loader, //指定当前目标对象使用类加载器
Class[] interfaces, //目标对象实现的接口的类型
InvocationHandler h //事件处理器
)

案例说明：
订单模块进行操作，增加日志功能。
JDK动态代理是代理工厂，不再需要实现多个接口了，注意这里面变化比较大。

package com.yh.jdk;
//1.抽象接口
public interface OrderService {
    void addOrder();
    void updateOrder();
    void selectOders();
}
package com.yh.jdk;
/*2.目标对象*/
public class OrderDaoImpl implements OrderService{
    public void addOrder() {
        System.out.println("增加订单业务");
    }

    public void updateOrder() {
        System.out.println("更新订单业务");
    }

    public void selectOders() {
        System.out.println("查询日志信息");
    }
}
package com.yh.jdk;

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

/*3.定义一个动态代理的，工厂，又来了。呵呵，好处大大滴
* static Object newProxyInstance(ClassLoader loader, 类[] interfaces, InvocationHandler h)
返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。
*           loader - 类加载器来定义代理类
            interfaces - 代理类实现的接口列表
            InvocationHandler h - 调度方法调用的调用处理函数
* */
public class JDKProxyFactory {
    //3.1要代理的目标对象;
    Object target;
    //3.2构造方法;
    public JDKProxyFactory(Object target) {
        this.target = target;
    }
    //3.3 注意这里是重要的，合并实现的方法.
    public Object getInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),//获取目标对象的类加载器;
                target.getClass().getInterfaces(),//获取目标对象的接口
                new InvocationHandler() {   //事件处理器，拦截方法，处理.
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //注意看这里有个参数是method,还有印象吗？
                        System.out.println("******开始记录日志 **********");
                        Object invoke = method.invoke(target, args);
                        if(method.getName().equals("selectOders"))
                            System.out.println("******结束记录日志 **********");
                        return invoke;
                    }
                }
        );
    }
}
```package com.yh.jdk;

import org.junit.Test;

public class TestJdkClient {
    @Test
    public void test03(){
        OrderService target=new OrderDaoImpl();
        System.out.println(target.getClass());
        //注意动态代理的灵活性;获取实例方法.
        OrderService jdkProxyFactory = (OrderService) new JDKProxyFactory(target).getInstance();
        //代理类执行;
        jdkProxyFactory.addOrder();
    }
}