（九）代理模式

Spring的两大核心是 IOC、 AOP，之前所记的几乎都是IOC部分，从此篇开始进入 AOP部分，想弄清楚AOP，必须先弄清楚代理模式。

静态代理

角色分析：

• 抽象角色：一般使用接口或抽象类来实现
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，一般会添加一些附属操作
• 客户：访问代理对象的人

一个简单的例子：租房

1. 接口抽象角色：

package com.xiao.demo1;

//租房
public interface Rent {

    public void rent();
}

2. 真实角色

package com.xiao.demo1;

//房东
public class Host implements Rent{


    public void rent() {
        System.out.println("房东要出租房子");
    }
}

3. 代理角色

package com.xiao.demo1;

//代理
public class proxy implements Rent {

    private Host host;

    public proxy() {
    }

    public proxy(Host host) {
        this.host = host;
    }


    public void rent() {
        seeHouse();
        host.rent();
        hetong();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }

    //签合同
    public void hetong(){
        System.out.println("与中介签租赁合同");
    }
}

4. 客户角色访问代理角色

package com.xiao.demo1;

public class Client {
    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
        //代理角色，会添加一些附属操作，比如看房、签合同
        proxy proxy = new proxy(host);
        proxy.rent();
    }
}

代理模式的好处：

1. 可以使真实角色的操作更加存粹，不用关注一些公共的业务。
2. 公共事务交给了代理，实现了业务的分工。
3. 公共业务发生拓展时，方便集中管理。

缺点：

1. 一个角色就会产生一个代理角色，代码量会翻倍，开销效率变低。（后面的动态代理会解决）

栗子2：

1. 接口抽象角色

package com.xiao.demo2;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

2. 真实角色

package com.xiao.demo2;

public class UserServicelmpl implements UserService{

    public void add() {
        System.out.println("增加用户");
    }

    public void delete() {
        System.out.println("删除用户");
    }

    public void update() {
        System.out.println("查询用户");
    }

    public void select() {
        System.out.println("查询用户");
    }
}

3. 代理角色

package com.xiao.demo2;

public class UserServiceProxy implements UserService {

    private UserServicelmpl userService;

    public void setUserService(UserServicelmpl userService) {
        this.userService = userService;
    }

    public void add() {
        log("add");
        userService.add();
    }

    public void delete() {
        log("delete");
        userService.delete();
    }

    public void update() {
        log("update");
        userService.update();
    }

    public void select() {
        log("select");
        userService.select();
    }

    //日志方法
    public void log(String msg){
        System.out.println("使用了"+msg+"方法");
    }
}

4. 客户端

package com.xiao.demo2;

public class Client {
    public static void main(String[] args) {
        UserServicelmpl userServicelmpl = new UserServicelmpl();

        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userServicelmpl);
        proxy.delete();
    }

}

在没有代理角色之前，若想实现对应的方法，可能需要修改几个类中的代码，如果量多的情况下，工作量将非常繁杂；在添加了代理角色后，只需在代理角色中调用对象的抽象方法即可，无须改动原有的代码。

动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分两大类：基于接口的动态代理，基于类的动态代理。基于接口—JDK动态代理；基于类—cglib；java字节码实现：javassist.

该文中所述的都是基于接口–JDK动态代理实现。在实现之前，需要了解两个类：

1. Proxy：代理，生成动态代理实例(具体可查看JDK官方文档)

2. InvocationHandler：调用处理程序，并返回结果
   例子：

package com.xiao.demo3;

//房东
public class Host implements Rent {


    public void rent() {
        System.out.println("房东要出租房子");
    }
}

package com.xiao.demo3;

//租房
public interface Rent {

    public void rent();
}

package com.xiao.demo3;

//声明：这里的代码是个模板，需要使用时，只需要修改rent即可
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//这个类用于自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

// 可参考官方代码:
//    Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
//            new Class<?>[] { Foo.class },
//            handler);

    //被代理的接口，即真实对象
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //参照上面的官方代码
    //生成得到代理对象newProxyInstance，
    //第一个参数：加载类在哪个位置；第二个参数：表示要代理的是哪一个接口；第三个参数：代表它自己的ProxyInvocationHandler
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),
                this);
    }

    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //执行的方法。动态代理的本质就是使用反射机制
        //由invoke执行
        Object result = method.invoke(rent, args);
        return result;
    }


}

package com.xiao.demo3;

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();

        //代理角色，目前还没有，只有一个处理程序ProxyInvocationHandler，需要由处理程序去生成一个代理类
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象
        pih.setRent(host);      //设置要代理的对象

        Rent proxy = (Rent) pih.getProxy();     //这里的proxy是动态生成的，我们并没有写

        proxy.rent();

    }
}

动态代理的好处：

1. 可以使真实角色的操作更加存粹，不用关注一些公共的业务。
2. 公共事务交给了代理，实现了业务的分工。
3. 公共业务发生拓展时，方便集中管理。
4. 一个动态代理类代理的时一个接口，一般就是对应的一类业务
5. 一个动态代理类可以代理多个类，只要是实现了同一个接口接口。比如上例中，就实现了UserService接口。