设计模式中有六大原则和二十三设计模式。
其中六大原则分别为：单一职责原则、开闭原则、里氏替换原则、依赖倒置原则、接口隔离原则、迪米特原则。
二十三设计模式：单例模式、Builder 模式、原型模式、工厂方法模式、抽象工厂模式、策略模式、状态模式、责任链模式、解释器模式、命令模式、观察者模式、备忘录模式、迭代器模式、模版方法模式、访问者模式、中介模式、代理模式、组合模式、适配器模式、装饰模式、享元模式、外观模式、桥接模式。
现在我们就介绍下代理模式（Proxy Pattern）。

定义

对其他对象提供一种代理以控制对这个对象的访问。
解释：就是不想把自己暴露给别人，委托他人帮自己实现某些功能。

网上说的增强，在我看来其实就是保留原有的内容，增加自己的逻辑（他也可以重写父类方法实现，不删除super方法）。

使用场景

当无法或不想直接访问某个对象时，或者某个对象不方便访问时，可以通过代理对象，间接访问。想要实现代理，需要委托者和代理者实现相同的接口。最典型的代理模式就是Spring 的AOP(切面)
例如：小明把小刚打了，小刚把小明告了，这时，小刚请了一个律师代理他处理这件事。如果小刚自己处理的话，需要提交申请、进行举证、辩护等诉讼流程。委托律师后，小刚把这些材料委托给律师，律师就可以代替小刚把事情处理了。在处理这些流程时，律师为了诉讼成功，增加了一些自己的东西（这就是我认为的【增强】）。

代理模式实现：

代理模式实现方式：静态代理和动态代理、动态代理又分为jdk代理和Cglib 代理。

静态代理

静态代理就是定义两个实现类A和B，他们都实现了接口C，B类构造器传入A，这时B就可以代替A 做一些事情了。

• UML 图

  
  UML.png

• 示例代码

• 诉讼流程接口（定义业务接口）

package com.example.pattern.proxy.static
import org.slf4j.Logger
import org.slf4j.LoggerFactory

/**
 * 诉讼流程
 */
interface LitigationProcessInterface {
    // 提交诉讼申请
    fun submitLawsuit();
    // 举证
    fun proof();
    // 辩护
    fun defend();

    fun finish(){
        val logger: Logger = LoggerFactory.getLogger(this::class.java)
        logger.info("----- LitigationProcessInterface::finish   结束");
    }
}

• 小刚提供的材料（被代理对象）

package com.example.pattern.proxy.static
import org.slf4j.Logger
import org.slf4j.LoggerFactory
class XiaoGang : LitigationProcessInterface {
    private val logger: Logger = LoggerFactory.getLogger(this::class.java)

    override fun submitLawsuit() {
        logger.info("----- XiaoGang::::::submitLawsuit  小刚提交诉讼申请");
    }

    override fun proof() {
        logger.info("----- XiaoGang::::::proof  小刚举证");
    }

    override fun defend() {
        logger.info("----- XiaoGang::::::defend  小刚辩护");
    }
}

• 律师代理（代理对象）

package com.example.pattern.proxy.static
import org.slf4j.Logger
import org.slf4j.LoggerFactory
/**
 * 律师
 */
class Lawyer(private val xiaoGang: XiaoGang) : LitigationProcessInterface {
    private val logger: Logger = LoggerFactory.getLogger(this::class.java)
    override fun submitLawsuit() {
        logger.info("----- Lawyer::submitLawsuit1  律师代替小刚诉讼申请前")
        // 小刚提交的诉讼申请
        xiaoGang.submitLawsuit()
        logger.info("----- Lawyer::submitLawsuit2  律师代替小刚诉讼申请后")
    }
    override fun proof() {
        logger.info("----- Lawyer::proof1  律师在小刚举证内容前")
        // 小刚提交的举证
        xiaoGang.proof()
        logger.info("----- Lawyer::proof2  律师在小刚举证内容后")
    }
    override fun defend() {
        logger.info("----- Lawyer::defend1  律师在小刚辩护内容前")
        // 小刚的辩护
        xiaoGang.defend();
        logger.info("----- Lawyer::defend2  律师在小刚辩护内容后")
    }
}

• 流程实现（实现）

package com.example.pattern.proxy.static
object Client {
    @JvmStatic fun main(args: Array<String>) {
        val xiaoGang:LitigationProcessInterface = XiaoGang();
        val lawyer = Lawyer(xiaoGang as XiaoGang)
        lawyer.submitLawsuit()
        lawyer.proof()
        lawyer.defend()
        lawyer.finish()
    }
}

• Log 信息：

12:22:58.491 [main] INFO com.example.pattern.proxy.static.Lawyer - ----- Lawyer::submitLawsuit1  律师代替小刚诉讼申请前
12:22:58.496 [main] INFO com.example.pattern.proxy.static.XiaoGang - ----- XiaoGang::::::submitLawsuit  小刚提交诉讼申请
12:22:58.496 [main] INFO com.example.pattern.proxy.static.Lawyer - ----- Lawyer::submitLawsuit2  律师代替小刚诉讼申请后
12:22:58.496 [main] INFO com.example.pattern.proxy.static.Lawyer - ----- Lawyer::proof1  律师在小刚举证内容前
12:22:58.496 [main] INFO com.example.pattern.proxy.static.XiaoGang - ----- XiaoGang::::::proof  小刚举证
12:22:58.496 [main] INFO com.example.pattern.proxy.static.Lawyer - ----- Lawyer::proof2  律师在小刚举证内容后
12:22:58.496 [main] INFO com.example.pattern.proxy.static.Lawyer - ----- Lawyer::defend1  律师在小刚辩护内容前
12:22:58.496 [main] INFO com.example.pattern.proxy.static.XiaoGang - ----- XiaoGang::::::defend  小刚辩护
12:22:58.496 [main] INFO com.example.pattern.proxy.static.Lawyer - ----- Lawyer::defend2  律师在小刚辩护内容后
12:22:58.497 [main] INFO com.example.pattern.proxy.static.Lawyer - ----- LitigationProcessInterface::finish   结束

静态代理虽然效率挺高，但是它是需要和业务结合使用，实现类都需要实现业务的接口才可以实现功能，这也局限了一个代理对象需要实现一次，如果有另一个代理对象，那么还需要实现另一个代理对象，这时使用起来就不是很方便了。那么动态代理就解决了这个问题。

以上是使用接口（interface）方式实现的功能，其实也可以使用 abstract 的方式实现。只不过是implements 改成了extends .

动态代理

上面的静态代理是由程序员或者工具生成的代码进行编译，就是说在运行代码时，编译文件就已经存在了。而动态代理是与之相反的，它是通过反射机制动态生成代理对象。
Java 已经给我们提供了一个便捷的代理接口 InvocationHandler 。只要实现它就可以了。

• 示例代码
• 诉讼流程接口（定义业务接口）

package com.example.pattern.proxy.dynamic;
/**
 * 诉讼流程
 */
public interface LitigationProcessInterface {
    // 提交诉讼申请
    void submitLawsuit();
    // 举证
    void proof();
    // 辩护
    void defend();
    // 结束
    void finish();
}

• 小刚提供的材料（被代理对象）

package com.example.pattern.proxy.dynamic;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 小刚需要提供的内容
 */
public class XiaoGang implements LitigationProcessInterface {
    private Logger logger = LoggerFactory.getLogger( this.getClass());
    public void submitLawsuit() {
        logger.info("----- XiaoGang::::::submitLawsuit  小刚提交诉讼申请");
    }

    public void proof() {
        logger.info("----- XiaoGang::::::proof  小刚举证");
    }

    public void defend() {
        logger.info("----- XiaoGang::::::defend  小刚辩护");
    }

    public void finish() {
        logger.info("----- XiaoGang::::::finish   结束");
    }
}

• 代理对象

package com.example.pattern.proxy.dynamic;

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

/**
 * 代理类
 */
public class DynamicProxy implements InvocationHandler {
    private Object object;
    public DynamicProxy(Object o) {
        this.object = o;
    }

    /**
     * 反射
     *
     * @param proxy  代理实例
     * @param method 方法
     * @param args   方法参数
     * @return 结果
     * @throws Throwable 异常
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(this.object, args);
    }
}

• 实现

package com.example.pattern.proxy.dynamic;

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        LitigationProcessInterface xiaoGang = new XiaoGang();
        DynamicProxy dynamicProxy= new DynamicProxy(xiaoGang);
        //获取被代理对象小刚的 ClassLoader
        ClassLoader xiaoGangClassLoader = xiaoGang.getClass().getClassLoader();
        // 动态构造一个代理律师
        LitigationProcessInterface lawyer = (LitigationProcessInterface) Proxy.newProxyInstance(xiaoGangClassLoader, new Class[]{LitigationProcessInterface.class}, dynamicProxy);
        lawyer.submitLawsuit();
        lawyer.proof();
        lawyer.defend();
        lawyer.finish();
        
    }
}

• Log

13:23:01.047 [main] INFO com.example.pattern.proxy.dynamic.XiaoGang - ----- XiaoGang::::::submitLawsuit  小刚提交诉讼申请
13:23:01.050 [main] INFO com.example.pattern.proxy.dynamic.XiaoGang - ----- XiaoGang::::::proof  小刚举证
13:23:01.050 [main] INFO com.example.pattern.proxy.dynamic.XiaoGang - ----- XiaoGang::::::defend  小刚辩护
13:23:01.050 [main] INFO com.example.pattern.proxy.dynamic.XiaoGang - ----- XiaoGang::::::finish   结束

以上代码和静态代理很像，但是当增加另一个代理对象时，静态代理需要重新实现一个类（LitigationProcessInterface），而动态代理则不需要，只要再实例下代理就可以了。

其实单独定义一个代理对象 DynamicProxy 也是有局限的，它不能够增加额外的东西（也就是所谓的增强），若需要增加额外的东西，需要每个都要重新定义一下，这样和静态代理没有什么区别。

那么我们也可以直接 new 一个 InvocationHandler 对象，这样就可以增加额外的东西了。

package com.example.pattern.proxy.dynamic;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

public class Client {
    public static void main(String[] args) {
        final Logger logger = LoggerFactory.getLogger( Client.class);
        final LitigationProcessInterface xiaoGang = new XiaoGang();
        // 方法二
        InvocationHandler invocationHandler = new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if ("submitLawsuit".equals(method.getName())){
                    logger.info("----- Lawyer::submitLawsuit1  律师代替小刚诉讼申请前");
                    method.invoke(xiaoGang, args);
                    logger.info("----- Lawyer::submitLawsuit2  律师代替小刚诉讼申请后");

                } else if ("proof".equals(method.getName())){
                    logger.info("----- Lawyer::proof1  律师在小刚举证内容前");
                    method.invoke(xiaoGang, args);
                    logger.info("----- Lawyer::proof2  律师在小刚举证内容后");
                } else if ("defend".equals(method.getName())){
                    logger.info("----- Lawyer::defend1  律师在小刚辩护内容前");
                    method.invoke(xiaoGang, args);
                    logger.info("----- Lawyer::defend2  律师在小刚辩护内容后");
                } else if ("finish".equals(method.getName())){
                    logger.info("----- Lawyer::finish1  结束前");
                    method.invoke(xiaoGang, args);
                    logger.info("----- Lawyer::finish2  结束后");
                }
                return null;
            }
        };
        //获取被代理对象小刚的 ClassLoader
        ClassLoader xiaoGangClassLoader = xiaoGang.getClass().getClassLoader();
        // 动态构造一个代理律师
        LitigationProcessInterface lawyer = (LitigationProcessInterface) Proxy.newProxyInstance(xiaoGangClassLoader, new Class[]{LitigationProcessInterface.class}, invocationHandler);
        lawyer.submitLawsuit();
        lawyer.proof();
        lawyer.defend();
        lawyer.finish();
    }
}

• Log

13:50:04.564 [main] INFO com.example.pattern.proxy.dynamic.Client - ----- Lawyer::submitLawsuit1  律师代替小刚诉讼申请前
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.XiaoGang - ----- XiaoGang::::::submitLawsuit  小刚提交诉讼申请
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.Client - ----- Lawyer::submitLawsuit2  律师代替小刚诉讼申请后
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.Client - ----- Lawyer::proof1  律师在小刚举证内容前
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.XiaoGang - ----- XiaoGang::::::proof  小刚举证
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.Client - ----- Lawyer::proof2  律师在小刚举证内容后
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.Client - ----- Lawyer::defend1  律师在小刚辩护内容前
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.XiaoGang - ----- XiaoGang::::::defend  小刚辩护
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.Client - ----- Lawyer::defend2  律师在小刚辩护内容后
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.Client - ----- Lawyer::finish1  结束前
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.XiaoGang - ----- XiaoGang::::::finish   结束
13:50:04.567 [main] INFO com.example.pattern.proxy.dynamic.Client - ----- Lawyer::finish2  结束后

这种Log 是不是和第一种很像了，而它不在需要创建多个代理对象。

Cglib代理

上面两种代理，都是需要实现特定的接口，才能实现代理功能，或者增强功能。而Spring 提供的Cglib 包则简化了实现接口，只要是单独的对象就可以实现代理。

• 定义被代理对象

package com.example.pattern.proxy.enhancer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 小刚需要提供的内容
 */
public class XiaoGang {
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    public void submitLawsuit() {
        logger.info("----- XiaoGang::::::submitLawsuit  小刚提交诉讼申请");
    }

    public void proof() {
        logger.info("----- XiaoGang::::::proof  小刚举证");
    }

    public void defend() {
        logger.info("----- XiaoGang::::::defend  小刚辩护");
    }

    public void finish() {
        logger.info("----- XiaoGang::::::finish   结束");
    }
}

• 代理对象

package com.example.pattern.proxy.enhancer;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class ProxyInterceptor implements MethodInterceptor {
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("----- ProxyFactory:::::: intercept  开始 ");
        //执行目标对象的方法
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("----- ProxyFactory:::::: intercept  结束 ");
        return result;
    }
}

• 实现

package com.example.pattern.proxy.enhancer;

import org.springframework.cglib.proxy.Enhancer;

public class Client {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        //继承被代理类
        enhancer.setSuperclass(XiaoGang.class);
        //设置回调
        enhancer.setCallback(new ProxyInterceptor());
//        enhancer.setCallback(new MethodInterceptor() {
//            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//                // 可以做增强
//                return null;
//            }
//        });
//        enhancer.setCallbackFilter(new CallbackFilter() {
//            public int accept(Method method) {
//                return 0;
//            }
//        });
        //设置代理类对象
        XiaoGang xiaoGang = (XiaoGang) enhancer.create();
        //在调用代理类中方法时会被我们实现的方法拦截器进行拦截
        xiaoGang.submitLawsuit();
        xiaoGang.proof();
        xiaoGang.defend();
        xiaoGang.finish();
    }
}

• LOG

----- ProxyFactory:::::: intercept  开始 
14:22:11.317 [main] INFO com.example.pattern.proxy.enhancer.XiaoGang$$EnhancerByCGLIB$$4d9ceeba - ----- XiaoGang::::::submitLawsuit  小刚提交诉讼申请
----- ProxyFactory:::::: intercept  结束 
----- ProxyFactory:::::: intercept  开始 
14:22:11.320 [main] INFO com.example.pattern.proxy.enhancer.XiaoGang$$EnhancerByCGLIB$$4d9ceeba - ----- XiaoGang::::::proof  小刚举证
----- ProxyFactory:::::: intercept  结束 
----- ProxyFactory:::::: intercept  开始 
14:22:11.320 [main] INFO com.example.pattern.proxy.enhancer.XiaoGang$$EnhancerByCGLIB$$4d9ceeba - ----- XiaoGang::::::defend  小刚辩护
----- ProxyFactory:::::: intercept  结束 
----- ProxyFactory:::::: intercept  开始 
14:22:11.320 [main] INFO com.example.pattern.proxy.enhancer.XiaoGang$$EnhancerByCGLIB$$4d9ceeba - ----- XiaoGang::::::finish   结束
----- ProxyFactory:::::: intercept  结束 

该种代理，比起动态代理更加简单便捷。如果要想扩展方法，则直接new MethodInterceptor 就可以实现，类似于动态代理new InvocationHandler 。

总结

学会使用设计模式，可以让我们的代码写的更加好看漂亮。在我们的编程过程中，很多时候我们写的代码，就使用了设计模式，只不过是不清楚罢了。
经过查看博客和书籍，对代理模式有了初步的了解。如果写的不好，请广大网友指正。
demo地址：https://github.com/wdmxzf/java-example/tree/pattern