定义

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是中介。
代理模式的分类：

静态代理
动态代理

7.代理模式 - 图1
UML类图
7.代理模式 - 图2

代理模式是SpringAOP的底层 [SpringAOP和SpringMVC]
7.代理模式 - 图3

优缺点

优点：

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

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

适用场景
根据需要创建开销很大的对象时，只有用到才创建（虚代理）
控制对原始对象的访问，比如过滤器（保护代理）
在访问对象时附加一些操作，比如对象没有引用时释放资源（智能指引）
为一个对象在不同的地址空间提供局部代理（远程代理）

代理模式实现方法

1.静态代理
静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者继承相同的父类。

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

接口（抽象角色）

public interface Rent {
    public void rent();
}

真实角色

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

代理角色

//代理（中介），实现了业务的分工、扩展、管理
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("中介带你看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
    //签合同
    public void hetong(){
        System.out.println("签合同");
    }
}

客户端访问代理角色

public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理,中介帮房东租房子,但是 代理一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        //不用面对房东,直接找中介租房即可
        proxy.rent();
    }

需求来了，现在我们需要增加一个日志功能，怎么实现？？

思路1 ：在实现类上增加代码【麻烦！】
思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了！
2.动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的
动态代理分为两大类 : 基于接口的动态代理, 基于类的动态代理
- 基于接口-JDK动态代理
- 基于类: cglib
- java字节码实现 : javassist

需要了解的两个类: Proxy: 代理, InvocationHandler: 调用处理程序

InvocationHandler**(调用处理程序)

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

代码实现

抽象角色和真实角色和之前的一样！

//抽象角色：租房
public interface Rent {
   public void rent();
}
---------------------------------------------
//真实角色: 房东，房东要出租房子
public class Host implements Rent{
   public void rent() {
       System.out.println("房屋出租");
  }
}

ProxyInvocationHandler 即代理角色

public class ProxyInvocationHandler implements InvocationHandler {
   private Rent rent;
   public void setRent(Rent rent) {
       this.rent = rent;
  }
   //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
   public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(),
               rent.getClass().getInterfaces(),this);
  }
   // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
   // 处理代理实例上的方法调用并返回结果
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throwsThrowable {
       seeHouse();
       //核心：本质利用反射实现！
       Object result = method.invoke(rent, args);
       fare();
       return result;
  }
   //看房
   public void seeHouse(){
       System.out.println("带房客看房");
  }
   //收中介费
   public void fare(){
       System.out.println("收中介费");
  }
}

Client 租客租房

//租客
public class Client {
   public static void main(String[] args) {
       //真实角色
       Host host = new Host();
       //代理实例的调用处理程序
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       pih.setRent(host); //将真实角色放置进去！
       Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
       proxy.rent();
  }
}

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

动态代理再理解

我们来使用动态代理实现代理我们后面写的UserService！
我们也可以编写一个通用的动态代理实现的类！所有的代理对象设置为Object即可！

//抽象角色：增删改查业务
public interface UserService {
   void add();
   void delete();
   void update();
   void query();
}
---------------------------------------------------
//真实对象，完成增删改查操作的人
public class UserServiceImpl implements UserService {
}

ProxyInvocationHandler. java 即代理角色

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);
  }
   // proxy : 代理类
   // method : 代理类的调用处理程序的方法对象.
   public Object invoke(Object proxy, Method method, Object[] args) throwsThrowable {
       log(method.getName());
       //动态代理的本质,就是使用反射机制实现
       Object result = method.invoke(target, args);
       return result;
  }
   public void log(String methodName){
       System.out.println("执行了"+methodName+"方法");
  }
}

测试

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.add();
    }
}

动态代理的好处

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

7.代理模式

定义

优缺点

优点：

缺点：

适用场景

代理模式实现方法

1.静态代理

2.动态代理

代码实现

动态代理再理解

动态代理的好处