1. 代理模式

代理模式一般指的是一个类代表另一个类的功能。这种类型的设计模式属于结构型模式，通过创建具有现有对象的对象，以便向外界提供功能接口。

这里来举例说明：
歌星A，擅长唱歌；某晚会邀请A去唱歌，但是实际上不会直接联系A，而是联系A的经纪人B，经纪人经过合同谈判等步骤，最终A去晚会上进行了唱歌。
首先定义个接口Star里面定义了唱歌方法如下：

1
2
3
4
5
6
7
8
public interface Star{

   // 唱歌
   void sing();
   
   // 跳舞
   void dance();
}

然后声明实现类歌星A：

1
2
3
4
5
6
7
8
9
10
11
12
public class RapStar implements Star{

   @Override
   public void sing() {
      System.out.println("RapStar开始freestyle！");
   }
   
   @Override
   public void dance() {
      System.out.println("RapStar开始地板动作！");
   }
}

然后我们会定义一个经纪人类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Broker implements Star{
 
   private RapStar rapStar;
 
   public Broker(RapStar rapStar){
      this.rapStar = rapStar;
   }
 
   @Override
   public void sing() {
      System.out.println("价钱谈好了，经纪人抽取提成......");
      rapStar.sing();
   }

   @Override
   public void sing() {
      System.out.println("价钱谈崩了，经纪人表示不跳舞");
      // rapStar.dance();
   }
}

然后实际的调用就会是这样：

1
2
3
4
5
6
7
8
9
10
public class Party {
   
   public static void main(String[] args) {
   	  RapStar rapStar = new RapStar();
   	  System.out.println("今晚邀请了明星A");
      Star star = new Broker(rapStar);
      star.sing();
      star.dance();  
   }
}

最终输出就会是：

1
2
3
4
今晚邀请了明星A
价钱谈好了，经纪人抽取提成......
RapStar开始freestyle！
价钱谈崩了，经纪人表示不跳舞

这样就达到了，在RapStar不变的情况下，进行方法的增强。

2. 静态代理

静态代理就是在编译时就指定的代理，比如上述的例子中，指定了Broker代理RapStar，但是当现在来了一个演员明星ActorStar的时候，也需要Broker去代理，这时就不支持了，需要进行代码的修改。

3. 动态代理

为了解决静态代理的问题，让程序动态的根据要进行代理的类自动生成代理类，这个就是动态代理。
常用的动态代理有两种：JDK动态代理、cglib动态代理。

3.1 JDK动态代理

JDK动态代理的实现方式如下：

1
2
3
4
5
6
Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() {
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           return method.invoke(obj, args);
     }
});

通过查看参数以及查看源码，可以知道：
使用JDK动态代理的类，必须实现某个接口（第二个参数需要传入实现的接口），最终底层会生成一个和当前需要代理的类实现了相同接口的类，实现了代理功能（类似上面的例子）。

3.2 cglib动态代理

cglib动态代理的实现如下：

1
2
3
4
5
6
Enhancer.create(obj.getClass(), new MethodInterceptor() {
     @Override
     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        return method.invoke(obj, objects);
     }
 });

通过查看参数以及查看源码，可以知道：
使用cglib动态代理的类，不需要实现接口（可实现可不实现，不关注），它只有两个参数，最终底层是根据当前需要代理类，派生出一个子类，通过子类的方式实现了方法的代理增强。

两个动态代理都是通过里面的invoke/intercept方法，进行方法的代理增强。