声明：原创作品，转载请注明出处https://www.jianshu.com/p/e4c1e6b734ad

今天来总结下代理模式，所谓“代理”，顾名思义就是代替你处理某事。当我们无法直接做某事的时候就可以创建一个代理来间接的完成这件事情。

代理模式在我们生活中也随处可见。相信每个人都抢过火车票。买火车票最直接的方式就是去火车站买，但是有的人离火车站比较远，不太方便，一般都选择用抢票软件购买。其中抢票软件就起到了代理的作用。抢票软件和火车站都有同一个功能，就是可以买到火车票。当然了，抢票软件还有一些其他的功能，比如有些抢票软件在你买票时会非常“贴心”的帮你买上保险。。。

接下来，我们来看下如何用代码来实现上述买票的例子。

首先我们需要定义一个接口，里面有一个买票的方法：

public interface Subject {
    void buyTicket();
}

接下来创建一个火车站类，以及代理买票的抢票软件类，因为这两个类都是用来买票的，所以需要实现上面的买票接口：
火车站类：

public class TrainStation implements Subject {
    @Override
    public void buyTicket() {
        System.out.print("成功买到一张票\n");
    }
}

抢票软件类：

public class TicketSoftware implements Subject{
    TrainStation trainStation;
    @Override
    public void buyTicket() {
        if (trainStation == null){
            trainStation = new TrainStation();
        }
        trainStation.buyTicket();
        buyInsurance();
    }

    public void buyInsurance(){
        System.out.print("买了一份保险");
    }
}

可以看到，抢票软件就是我们的代理类，里面的买票方法其实就是调用火车站类中的买票方法，这也符合情理，毕竟我们用的抢票软件都需要通过我们国家铁路系统买的。然后买完票后，抢票软件还给你买个了保险。。。

好了，接下来我们来看下，这个抢票软件是否管用：

TicketSoftware ticketSoftware = new TicketSoftware(); 
ticketSoftware.buyTicket();

输出结果：
----------------------
成功买到一张票
买了一份保险
----------------------

我们的抢票软件起作用了，看来以后就不用再去火车站啦！

动态代理模式

以上就是简单的静态代理模式，所谓静态，就是这个TicketSoftware 代理类是我们事先写好的，而动态代理模式中，代理类是虚拟机在运行时自动创建的。接下来我们来看一下，如何用动态代理来实现上述的例子

和上面一样，我们需要一个接口，里面定义了一个买票方法：

public interface Subject {
    void buyTicket();
}

然后定义一个目标类，即火车站类，真正买票操作是在这个类中完成的：

public class TrainStation implements Subject {
    @Override
    public void buyTicket() {
        System.out.print("成功买到一张票\n");
    }
}

你也发现了，其实这两个类就是上面的，没有做任何修改，接下来我们还需要定义一个代理类，由于这是动态代理模式，这个代理类不需要我们手动编写。注意不需要我们手动编写，并不表示不存在这个代理类，而是由虚拟机自动生成的。那么我们如何获取到这个代理类呢，很简单我们只需要调用Proxy类的newProxyInstance方法，Proxy类是由jdk提供，我们可以直接使用，这个方法需要传入三个参数，第一个参数为目标类的类加载器，所谓类加载器是虚拟机用来加载类的，第二个为目标类所实现的接口数组，第三个参数需要传入一个对象，这个对象所对应的类需要实现jdk提供给我们的InvocationHandler接口，然后复写里面invoke方法，当动态代理类中代理方法被调用时，会执行这个invoke方法。实现InvocationHandler接口完整的类如下：

class MyInvocationHandler implements InvocationHandler {
        // 需要被代理的那个对象
        private Object target;
        // 用于传入目标对象TrainStation 
        public void setTarget(Object target){
            this.target = target;
        }
        // 当我们去调用代理对象的方法时，invoke 方法将会取而代之。
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object result = method.invoke(target,args);//实际上调用了目标对象TrainStation 买火车票的方法
            buyInsurance();//买完票后有买了一份保险
            return result;
        }
        public void buyInsurance(){
            System.out.print("买了一份保险");
        }
    }

这个类还是很简单的，主要的就是他的invoke方法，在这个方法中，我们通过method.invoke(target,args)方法调用了目标对象的方法，在这里也就是火车站对象的买票方法。有关method.invoke是反射的内容稍后会提到。之后我们又调用了买保险的方法。

好了，定义完MyInvocationHandler类，然后实例化MyInvocationHandler对象，并传入一个目标对象：

TrainStation trainStation = new TrainStation();
MyInvocationHandler handler = new MyInvocationHandler();
handler.setTarget(trainStation);

这样第三个参数已经有了，接下来我们就可以获取由虚拟机为我们生成的代理对象了：

Subject proxy = (Subject)Proxy.newProxyInstance(trainStation.getClass().getClassLoader(),trainStation.getClass().getInterfaces(),handler);

这个动态生成的代理对象的类在底层实现了Subject接口，但Proxy.newProxyInstance返回的对象是Object类型，所以我们还需要一次类型转换。

好了有了代理对象，我们就可以像之前的静态代理一样调用代理对象的买票方法：

proxy.buyTicket();//调用代理对象的买票方法

输出结果：
----------------------
成功买到一张票
买了一份保险
----------------------

可以看到我们的动态代理生效了，当我们调用代理类的buyTicket方法，我们之前定义的MyInvocationHandler对象的invoke方法就会执行。你是不是感到很神奇，我们并没有定义代理类，那它究竟是如何工作的呢。别急，接下来我们就一起来看下动态代理的工作原理。

动态代理实现原理

反射

要想理解动态代理的实现原理，我们还得先来理解反射。什么是反射呢？一般我们操作一个对象时，都会先new一个，比如现在有一个Person类：

public class Person {
    public String name;
    private int age;
    public Person(String name){
        System.out.print("有参数实例化\n");
        this.name = name;
    }
    public Person(){
        System.out.print("无参数实例化\n");
    }
    
    private Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void run(){
        System.out.print("跑步");
    }
    public String getName() {
        return name;
    }
}

如上，我们定义了一个Person类，里面定义了几个构造方法，一个有参数一个没有，还有一个私有的带参数的构造方法，另外还有两个方法，一个方法为获取Person的名字，一个是让这个Person跑步，如果我们希望让一个Person跑起来，该怎么做呢，很简单，我们只需要new 一个Person对象，然后调用其run方法就可以了，如下：

Person perosn = new Person("张三");
person.run();

这样就让一个Person跑起来了，但是问题来了，如果在程序运行的时候，我需要操作的不一定是Person，而是一个会变得类，这个类可能是Person也可能是其他类比如叫做Bird或者Dog等等，而我们要操作的方法也不一定是run，也有可能是fly,sleep等等其他方法。那这时怎么办，很显然，我们是无法事先new 一个对象，因为我们根本就不知道程序运行的时候需要操作什么对象，执行什么方法，这时我们就可以用上反射了，反射可以使你在运行时读取类或对象的信息，也可以在运行时创建对象，操作对象的字段属性与方法。

好了理解了什么是反射，接下来，我们来看下如何使用反射。要想使用反射，你需要用到一个类，即Class类。什么是Class类呢？我们知道Java和C语言最大的不同就是，C是面向过程的，而Java是面向对象的。在Java的世界里，一切皆对象，一切都是可描述的，只要你能想到的，不管什么，我们都可以用类来描述，那么问题来了，我们知道类也是客观存在的东西，那么用什么来描述类的，答案就是Class类，即一个描述类的类，这个类的名字为Class。这是一个实际存在的类，路径为JDK的java.lang包中，感兴趣的朋友可以去看下。所谓存在即合理，这个Class类肯定不是Java工程师闲的蛋疼写出来的，而是有用的，拿上面的Person类举个例子，一开始我们通过编码生成了一个Person.java文件，然后通过编译又生成了一个Person.class字节码文件，这个文件就保存了一个Class对象，对象中包含了Person类的所有信息，当我们调用new Person()时，虚拟机就会检查内存中是否加载了Person.class这个字节码文件，如果没有就会加载，此时这个Class对象也会被加载到内存中，当虚拟机实例化Person对象时，虚拟机需要知道一些信息，比如要实例化的类中有什么字段什么方法等等，这些信息都被保存在Class对象中。所以说Class类对于虚拟机来说是个很重要的类。同样在反射中，我们也需要知道Person类的信息，这自然就离不开Class对象。

那么我们如何获取到Class类的对象呢，一共有三种方式，拿上面Person类举例子：
第一种，Class类有一个forName(String className)方法，需要传入一个类的完整类名，返回为该类型的Class对象,如下：

Class clazz = Class.forName("包名.Person");

注意，调用forName时，你需要捕获一个叫做ClassNotFoundException无法找到该类的异常。

第二种，你需要先创建一个Person对象，然后调用Person对象的getClass方法，就可以获取到Class对象：

  Person person = new Person("张三");
  Class clazz = person.getClass();

这种方式不足的地方在于获取Class对象前你还要创建一个Person对象。

第三种，最简单也是最安全的一种方式为直接调用Person.class，如下：

Class clazz = Person.class;

以上简单说明了下获取Class对象的几种方式，我们之前说过Class对象保存了对应类的类信息，包括这个类的构造方法、字段属性，类中的方法等。接下来我们来看下，如何使用Class对象来获取以及操作这些类信息。

构造方法

首先我们来看下构造方法，在反射中要想实例化一个类其实还是调用该类构造方法，只不过不是简单new下就可以了。我们先来看一种简单的实例化方式：

Class<?> clazz = Class.forName("包名.Person");
Person person = (Person) clazz.newInstance();
person.run();

上面的代码很简单，我们先调用Class的forName方法来获取Person类的Class对象，然后直接调用该对象的newInstance方法，这样就获取到了一个Person实例，然后调用他的run方法：

输出结果
====================================
无参数实例化
跑步
====================================

可以看到Person的构造方法成功被调用了，不过需要注意的是clazz.newInstance只适用于无参数构造方法，有参的我们需要通过Class获取Constructor对象来操作，Constructor对象是对构造方法的封装，Class获取Constructor对象的主要方法有以下几种：

我们挨个来看下，

1. getConstructor(Class<?>... parameterTypes)

这个方法返回权限为public的构造方法对象，需要传入参数类型的Class对象，比如我们想要调用Person类中的Person(String name)构造方法可以通过以下方式来实现：

Class<?> clazz = Class.forName("com.modoutech.designpattern.Person");
Constructor<Person> constructor = (Constructor<Person>) clazz.getConstructor(String.class);
Person person1 = constructor.newInstance("张三");
person1.run();

可以看到我们先获取了Person的Class对象，然后调用Class的getConstructor方法，同时传入String.class参数，因为我们要调用的构造方法参数为String类型的，这样就得到了一个Constructor对象，接着我们就可以调用Constructor对象的newInstance方法并传入name参数，来实例化一个Person对象，获取到Perosn对象，就可以调用里面的方法啦。

2. getConstructors()

这个方法会返回所有权限为public的构造方法的Constructor对象数组。

Constructor<Person>[] constructors = (Constructor<Person>[]) clazz.getConstructors();
for (int i = 0; i < constructors.length; i++) {
    System.out.println("构造函数["+i+"]:"+constructors[i].toString() );
}
--------------------------------------------------
输出结果：
构造函数[0]:public com.modoutech.designpattern.Person()
构造函数[1]:public com.modoutech.designpattern.Person(java.lang.String)
--------------------------------------------------

可以看到我们获取了两个Constructor对象，这两个也正是对应了Person中权限为public的构造方法，至于接下来对这两个构造方法调用和上面的方法同理这里就不在赘述了。

3. getDeclaredConstructor(Class<?>... parameterTypes)

这个方法范围要大点，会返回类中申明的任何构造方法对象，包括权限为private的。比如我们想调用Person中私有的Person(String name,int age)构造方法，可以通过如下方式：

Constructor<Person> constructor = (Constructor<Person>) clazz.getDeclaredConstructor(String.class,int.class);
constructor.setAccessible(true);
Person person1 = constructor.newInstance("张三",23);
person1.run();

这里基本和上述步骤相同，不过需要注意的是访问私有的构造方法时，我们需要调用Constructor的setAccessible方法，并设置为true，表示可以访问该私有构造方法。

4. getDeclaredConstructor()

这个方法获取类中已申明的所有构造方法对象数组，包括private的，具体操作方法与上述相同，这里不再赘述。

好了这样我们简单的介绍了用Constructor在反射中实例化对象的几种方式，说完构造方法，接下来我们来看下如何获取以及操作类中的字段属性

字段Field

如果我们要想操作类或对象中的字段，那么就需要用到Field对象。同样这个Field对象也是通过Class获取的，以下是Class获取Field对象的几种方法：

我们来挨个看下：
为了演示方便我们再创建一个Student类，继承自上述的Person类：

public class Student extends Person {
    private String course;
    public int score;

    public String getCourse() {
        return course;
    }

    public void setCourse(String course) {
        this.course = course;
    }
}

1.getDeclaredField(String name)

获取指定名称的(包含private修饰的)字段，不包括从父类中继承的字段。

用这个方法，我们可以在Student类中，获取course和score字段，但是无法获取它父类Person中的字段。拿course举个例子：

Class<?> clazz = Class.forName("com.modoutech.designpattern.Student");
Student student = (Student) clazz.newInstance();
Field courseField = clazz.getDeclaredField("course");
courseField.setAccessible(true);
courseField.set(student,"语文");
System.out.print("course is "+student.getCourse());
-------------------------
输出结果：
无参数实例化
course is 语文
-------------------------

上述，我们先获取了Student的Class对象，并实例化一个Student对象，然后通过Class的getDeclaredField方法，并传入course这个字段名，然后获取一个Field对象，由于course这个字段为private，所以还需要调用他的setAccessible并传入true，来打开它的访问权限，之后就可以调用Field的set方法来设置这个字段的值，这个set方法需两个参数，第一个为需要设置的实例对象，第二个为需要设置的字段值。这样我们就完成了对course这个字段的赋值操作。

2. getDeclaredField()

这个方法用于获取Class对象所表示的类或接口的所有(包含private修饰的)字段,不包括继承的字段：

Field[] fields = clazz.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
    System.out.print(fields[i].getName()+"\n");
}
---------------------------------------------
输出结果：
course
score
---------------------------------------------

以上我们获取了字段数组，并打印了每个字段名，可以看到我们只获取到了Student类中的course和score字段，并没有他父类的字段。

3. getField(String name)

这个方法获取指定名称的public字段，包括父类中的也可以获取到。接下来我们试着获取下Student父类中的name字段：

Class<?> clazz = Class.forName("com.modoutech.designpattern.Student");
Student student = (Student) clazz.newInstance();
Field field = clazz.getField("name");
field.set(student,"张三");
System.out.print("学生名字："+student.getName());

---------------------------------------------------------------------------
输出结果：
无参数实例化
学生名字：张三
--------------------------------------------------------------------------

可以看到我们成功获取了Student父类中的字段，并做了赋值操作。

3. getField()

这个方法时获取所有public字段，包括父类中的：

Field[] fields = clazz.getFields();
for (int i = 0; i < fields.length; i++) {
    System.out.print("字段名："+fields[i].getName()+"\n");
}

---------------------------------------------------------------
输出结果：
字段名：score
字段名：name
---------------------------------------------------------------

可以看到，我们获取到了Student中声明的public字段score，同时还获取到了其父类中public字段name，至于对获取到的字段进行进一步的操作，和上面的一样，就不在赘述了。

在上面，可以看到，我们调用了Field 的set方法来设置字段的值，当然除了set方法外，Field还有其他的一些方法，部分方法如下：

Method（方法）

如果我们想要操作类中的某个方法，我们可以借助Method这个类，这个类是对类或接口中某个方法的描述，我们可以通过调用Class对象的以下方法来获取Method对象：

以上简单的列举了获取Method对象的一些方法，具体获取方式就不演示了，和上面的操作步骤差不多。

接下来，我们来看下如何利用Method对象来调用类中方法。拿上面Person类举个例子，来看下如果通过Method来调用里面的run方法：

Class<?> clazz = Class.forName("com.modoutech.designpattern.Student");
Person person = (Person) clazz.newInstance();
Method method = clazz.getDeclaredMethod("run");
method.invoke(person);

---------------------------------------------
输出结果：
无参数实例化
跑步
---------------------------------------------

可以看到我们成功通过反射来调用了Person中的run方法，当然如果这个方法是private的，那么在调用该方法前需要调用Method的setAccessible方法，并传入true来打开该方法的访问权限。
当然除了上述介绍的一些方法外，Method还提供了其他的一些方法：

以上就是一些常用的方法，这里就不一一展开来讲了，如果想更详细的了解可以查阅官方API。

好了，这样就简单的介绍了下Java反射的一些内容。

源码解析

简单了解了反射知识后，我们来看下动态代理底层实现原理。上面我们知道，动态代理和静态代理的区别主要在于代理类的区别，静态代理的代理类是我们自己手动编码生成的，而动态代理的代理类是由虚拟机帮我们生成的。对于动态代理，我们主要通过调用Proxy的newProxyInstance方法来获取动态代理类：

Subject proxy = (Subject)Proxy.newProxyInstance(trainStation.getClass().getClassLoader(),trainStation.getClass().getInterfaces(),handler);

想必你一定很好奇这个方法是如何创建一个代理类的，我们马上进入到这个newProxyInstance来看一下：

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        if (h == null) {
            throw new NullPointerException();
        }

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, interfaces);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            return newInstance(cons, h);
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
    }

可以看到里面的代码还是比较少的，前面做了下非空判断，然后调用了getProxyClass0方法获取了一个Class对象，难道这个对象就是动态代理类的Class对象吗？先别急我们再往下看看，下面通过刚才获取到的Class对象获取一个Constructor对象，然后把这个Constructor对象和之前传入的InvocationHandler 对象作为参数传入newInstance方法并返回。这样这个方法就结束，我们再进入到newInstance方法看下：

    private static Object newInstance(Constructor<?> cons, InvocationHandler h) {
        try {
            return cons.newInstance(new Object[] {h} );
        } catch (IllegalAccessException | InstantiationException e) {
            throw new InternalError(e.toString());
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString());
            }
        }
    }

可以看到这个方法里的代码就更简单了，就是调用之前传入的Constructor对象的newInstance方法，并把InvocationHandler 作为参数来获取一个实例对象并返回。显然这个对象就是我们想要的动态代理对象。这样我们也就知道了上面调用getProxyClass0方法获取的Class对象就是动态代理的Class对象。那么我们的重点就集中在了这个方法，我们接着就进入到这个方法看下：

       try {
            String proxyPkg = null;     // package to define proxy class in

            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
            for (int i = 0; i < interfaces.length; i++) {
                int flags = interfaces[i].getModifiers();
                if (!Modifier.isPublic(flags)) {
                    String name = interfaces[i].getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // if no non-public proxy interfaces, use the default package.
                proxyPkg = "";
            }

            {
                // Android-changed: Generate the proxy directly instead of calling
                // through to ProxyGenerator.
                List<Method> methods = getMethods(interfaces);
                Collections.sort(methods, ORDER_BY_SIGNATURE_AND_SUBTYPE);
                validateReturnTypes(methods);
                List<Class<?>[]> exceptions = deduplicateAndGetExceptions(methods);

                Method[] methodsArray = methods.toArray(new Method[methods.size()]);
                Class<?>[][] exceptionsArray = exceptions.toArray(new Class<?>[exceptions.size()][]);

                /*
                 * Choose a name for the proxy class to generate.
                 */
                final long num;
                synchronized (nextUniqueNumberLock) {
                    num = nextUniqueNumber++;
                }
                String proxyName = proxyPkg + proxyClassNamePrefix + num;

                proxyClass = generateProxy(proxyName, interfaces, loader, methodsArray,
                        exceptionsArray);
            }
            // add to set of all generated proxy classes, for isProxyClass
            proxyClasses.put(proxyClass, null);

这个方法里面的代码比较多，我截取了重点部分，看上去这里的代码还是很多，不过别担心这些代码其实都在为其中的一条语句做准备：

proxyClass = generateProxy(proxyName, interfaces, loader, methodsArray, exceptionsArray);

这条语句就是创建动态类的语句，其中interfaces和loader是之前传入的，上面的代码其实就是生成类名proxyName，方法数组methodsArray以及异常数组exceptionsArray，这样生成一个类的所有元素就具备了，然后就是调用generateProxy方法来生成动态代理类的Class对象。我们接着在进入这个方法看下，究竟发生了什么：

private static native Class<?> generateProxy(String name, Class<?>[] interfaces,
                                                 ClassLoader loader, Method[] methods,
                                                 Class<?>[][] exceptions);

我们发现这个方法是native的，Java没有给我们提供他的源代码。有的朋友可能还是很好奇，这个方法到底执行了什么，我们知道我们编写好一个类后，然后编译会生成一个.class的字节码文件。这个文件说白了都是一些字节数据，而这个方法就是为我们生成这个数据，当然这些数据不是随意生成的，而是遵守一定规则的。至于这个文件里面具体是怎样的以及具体遵守什么样的规则可以参考《java 虚拟机规范》这个书，里面介绍了class文件的格式等底层知识。对这部分感兴趣的同学可以参考下。

到这里其实有关代理类的动态生成的源码部分已经分析的差不多了，可能有些朋友有些失落，不能完全了解其具体生成的代理类。不过没关系，我们知道了动态代理的使用及运行机制，我们可以试着自己模拟写出一个动态代理类，还是拿上面买火车票来举个例子，首先这个动态代理类中肯定实现了Subject接口并有一个买票的方法，接下来由上面的源码分析我们可以知道这个动态代理类有一个构造方法，他的参数是一个InvocationHandler 对象，很显然当我们调用动态代理的买票方法就会调用InvocationHandler 的invoke方法。模拟的代码如下：

public class MyProxyClass implements Subject{
    private final InvocationHandler mInvocationHandler;

    public MyProxyClass(InvocationHandler invocationHandler){
        this.mInvocationHandler = invocationHandler;
    }

    public void proxyMethod(Method method,Object[] args){
        try {
            mInvocationHandler.invoke(new Object(),method,args);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Override
    public void buyTicket() {
        Method method = null;
        try {
            //这里由于我们定义的买票方法是无参数方法，所以这里getMethod方法就传入方法名，如果有参数则还需传入参数的对应类型
            method = Subject.class.getMethod("buyTicket");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        try {
            mInvocationHandler.invoke(new Object(),method,null);
        } catch (Throwable throwable) {
        }
    }
}

以上就是对动态代理类进行了模拟，虽然不能说是和动态生成的代理类一模一样，但是运行原理是一样的。这样有关动态代理类的分析也就差不多了，不过动态代理有个小小的不足，就是只能代理interface无法代理class，因为每个动态生成的代理类都已经继承了Proxy类，如果再代理class的话，就会出现多继承现象，而Java是不支持多继承的。不过相比动态代理的强大，这点问题还是微不足道的。

好了有关设计模式的代理模式部分到这也就差不多了。

设计模式持续更新中...