1、代理模式

为什么要学习代理模式？

因为这就是springAOP的底层！【springAOP和springMVC】

代理模式的分类：

• 静态代理
• 动态代理

1.1、静态代理

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
• 客户：访问代理对象的人！

代码步骤：

• 1.接口 ——Rent

  //出租房子
  public interface Rent {
      void rent();
  }
  

• 2.真实角色——Host

  //房东
  public class Host implements Rent {
      @Override
      public void rent() {
          //打印
          System.out.println("房东有房子出租！");
      }
  }
  

• 3.代理角色——Proxy

  //中介
  public class Proxy implements Rent {
      private Host host;
  
      public Proxy() {
      }
  
      public Proxy(Host host) {
          this.host = host;
      }
  
      @Override
      public void rent() {
          host.rent();
          seeHouse();
          hetong();
          fare();
      }
  
      public void seeHouse() {
          //打印
          System.out.println("See House 看房子");
      }
  
      public void hetong(){
          //打印
          System.out.println("签约租凭合同");
      }
      public void fare(){
          //打印
          System.out.println("收取中介费用!");
      }
  }
  

• 4.客户端访问代理角色——Client

  public class Client {
      //这是一个main方法，是程序的入口：
      public static void main(String[] args) {
          //房东出租房子给中介代理
          Host host = new Host();
          //代理。帮助房东出租房子，会有一些附属的操作
          Proxy proxy = new Proxy(host);
          //
          proxy.rent();
      }
  }
  

小结

代理模式的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
• 公共也就就交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理！

缺点：

一个真实角色就会产生一个代理角色；代码量会翻倍开发效率会变低

1.2、加深理解

UserService

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

UserServiceImpl——真实对象

//真实对象
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }
}

UserServiceProxy——代理

public class UserServiceProxy implements UserService{

    private UserServiceImpl userService;

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

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

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

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

    @Override
    public void query() {
        log("query");
        userService.query();
    }

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

加粗样式Client

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);
        proxy.add();
    }
}

1.3、动态代理

动态代理和静态代理角色一样

动态代理的代理类是动态生成的，不是我们直接写好的！

动态代理分为两大类：基于接口的动态代理，基于类的动态代理

• 基于接口-JDK 动态代理【我们在这里使用】
• 基于：cglib
• java字节码实现：javasist

需要了解两个类：

• Proxy：代理，
• InvocationHandler：调用处理程序，是由代理实例的调用处理程序实现的接口。

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)                    
    //返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。  

/**
所需三个参数参数 
loader - 类加载器来定义代理类 ，需要一个
interfaces - 代理类实现的接口列表 
h - 调度方法调用的调用处理函数 

newProxyInstance，方法有三个参数：
loader: 用哪个类加载器去加载代理对象
interfaces/：动态代理类需要实现的接口
h：动态代理方法在执行时，会调用h里面的invoke方法去执行
*/
    
/**
* ClassLoader loader 类加载器，用于加载代理对象的字节码
* Class<?>[] interfaces 字节码数组，用于让代理对象和被代理对象有相同的方法
* InvocationHandler h 处理方法，用于方法增强
*/

Object invoke(Object proxy, 方法 method, Object[] args) //处理代理实例上的方法调用并返回结果。  
    
/**
* Object proxy 被代理的类
* Method method 被代理类的方法
* Object[] args 方法参数
*/

ProxyInvocationHandler

//自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Rent rent;

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

    //生成代理类
    public Object getProxy() {

        //第一个参数：目标对象类的加载器，第二个参数：目标对象相同的接口字节码对象数组，第三个参数：InvocationHandler对象
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
    }

    //调用代理对象的任何方法，实质执行的都是invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //动态代理的本质，就是使用反射机制实现的
        Object invoke = method.invoke(rent, args);//目标方法
        hetong();
        fare();
        return invoke;
    }

    public void seeHouse() {
        //打印
        System.out.println("See House 看房子");
    }

    public void hetong() {
        //打印
        System.out.println("签约租凭合同");
    }

    public void fare() {
        //打印
        System.out.println("收取中介费用!");
    }

}

Client

public class Client {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理角色。
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用处理角色来处理我们调用的接口对象
        pih.setRent(host);
        Rent proxy =(Rent) pih.getProxy();
        proxy.rent();
    }
}

真正动态

public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object target;

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

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

    //处理代理实例，返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target,args);
        return result;
    }

    public void log(String msg){
        System.out.println("执行了"+msg+"方法");

    }

}

import com.blue.demo02.UserService;
import com.blue.demo02.UserServiceImpl;

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

        //代理角色：现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService);

        //通过调用程序处理角色 来处理我们要调用的接口对象
        UserService proxy = (UserService) pih.getProxy();

        proxy.delete();

    }
}

动态代理的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务!
• 公共也就就交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理！
• 一个动态代理类代理的是一个接口，一般就是对应的一类业务!
• 一个动态代理类可以代理多个类，只要是实现了同一个接口即可!