6 代理模式

module：spring-08-proxy

为什么要学习代理模式，因为AOP的底层机制就是动态代理！

代理模式：

• 静态代理
• 动态代理

静态代理

静态代理角色分析

• 抽象角色 : 一般使用接口或者抽象类来实现。
• 真实角色 : 被代理的角色。
• 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作。
• 客户 : 使用代理角色来进行一些操作。

代码实现

Rent.java 抽象角色

package com.zzb.demo1;

public interface Rent {

    public void rent();
}

Host.java 真实角色

package com.zzb.demo1;
// 真实角色，房东
public class Host implements Rent{
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

Proxy.java 代理角色

package com.zzb.demo1;
// 代理角色，中介
public class Proxy implements Rent{

    private Host host;

    public Proxy() {
    }

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


    public void rent() {
        seeHouse();
        host.rent();
        paper();
        fare();
    }

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

    // 签合同
    public void paper(){
        System.out.println("中介带你签合同");
    }

    // 收房租
    public void fare(){
        System.out.println("中介收房租");
    }
}

Client.java 客户

package com.zzb.demo1;
//客户类，一般客户都会去找代理！
public class Client {
    public static void main(String[] args) {
        //房东要租房
        Host host = new Host();
        //中介帮助房东
        Proxy proxy = new Proxy(host);
		
        //你去找中介！
        proxy.rent();
    }
}

分析：在上述代码过程中，客户直接接触到的是中介，就如同现实生活中的样子，客户见不到房东，但客户依旧可以通过中介租到房东的房子，这就是所谓的代理模式。程序源自于生活，所以学编程的人，应该更加抽象的看待生活中的事情。

静态代理的优点:

• 可以使得我们的真实角色更加纯粹，不再去关注一些公共的事情；
• 公共的业务由代理来完成，实现了业务的分工 ;
• 公共业务发生扩展时变得更加集中和方便 。

缺点：

• 类增多，多了代理类，工作量变大，开发效率降低

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

静态代理再理解

1、创建一个抽象角色，业务为增删改查

package com.zzb.demo2;

public interface UserService {

    void add();
    void query();
    void update();
    void delete();
}

2、创建一个真实对象，实现抽象接口

package com.zzb.demo2;

public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("add");
    }

    public void query() {
        System.out.println("query");
    }

    public void update() {
        System.out.println("update");
    }

    public void delete() {
        System.out.println("delete");
    }
}

3、现在来了新需求，需要实现一个日志功能：

• 思路1：在原实现类上增加日志功能代码！【麻烦】
• 思路2：使用代理来做，能够在不改变原代码的情况下，实现此功能！

4、设置一个代理类来处理日志功能！代理角色

package com.zzb.demo2;

public class UserServiceProxy implements UserService{

    private UserService userServiceImpl;

    public void setUserServiceImpl(UserService userServiceImpl) {
        this.userServiceImpl = userServiceImpl;
    }

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

    public void query() {
        log("query");
        userServiceImpl.query();
    }

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

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

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

5、测试

@Test
public void test(){
    // 真实业务
    UserServiceImpl userService = new UserServiceImpl();
    // 代理类
    UserServiceProxy proxy = new UserServiceProxy();
    proxy.setUserServiceImpl(userService);

    proxy.add();
}

测试结果：

使用add方法
add

我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想。

纵向开发与横向开发：

动态代理

• 动态代理的角色和静态代理的一样；
• 动态代理的代理类是动态生成的，静态代理的代理类是我们提前写好的；
• 动态代理分为两类 : 一类是基于接口动态代理，一类是基于类的动态代理；
  • 基于接口的动态代理——JDK动态代理；
  • 基于类的动态代理--cglib；
  • 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist；
  • 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！

JDK的动态代理需要了解两个类

核心 : InvocationHandler 调用处理程序 和 Proxy 代理

InvocationHandler接口

Proxy类

代码实现：

1、Rent.java 抽象角色

package com.zzb.demo3;

public interface Rent {
    public void rent();

    public void goOut();
}

2、Host.java 真实角色，房东

package com.zzb.demo3;

public class Host implements Rent{

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

    public void goOut() {
        System.out.println("房东来了，快跑！");
    }
}

3、ProxyInvocationHandler. java 生成代理角色以及方法处理程序

package com.zzb.demo3;

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

public class ProxyInvocationHandler implements InvocationHandler {

    //代理接口
    Object target;

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

    // 生成代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }


    //代理实列的关联调用程序
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        seeHouse();
        Object result = method.invoke(target, args);
        fare();
        return result;
    }

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

    public void fare(){
        System.out.println("中介来收中介费！");
    }
}

4、测试，client

package com.zzb.demo3;

public class Client {

    public static void main(String[] args) {

        Rent host = new Host();
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(host);

        // 生成代理实例
        Rent proxy = (Rent) pih.getProxy();

        // 调用代理实例处理应用程序
        proxy.rent();
        System.out.println("=============================");
        proxy.goOut();
    }
}

测试结果：

中介带你看房子
房东出租房子
中介来收中介费！
=============================
中介带你看房子
房东来了，快跑！
中介来收中介费！

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！

**动态代理的优点

静态代理有的它都有，静态代理没有的，它也有！

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情；
• 公共的业务由代理来完成 . 实现了业务的分工；
• 公共业务发生扩展时变得更加集中和方便；
• 一个动态代理 , 一般代理某一类业务；
• 一个动态代理可以代理多个类，代理的是接口！