参考

简书 ·蛇发女妖·

简介

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

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

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

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

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对象：

Class clazz = Person.getClass();

以上简单说明了下获取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对象的主要方法有以下几种：

我们挨个来看下，

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对象，就可以调用里面的方法啦。

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的构造方法，至于接下来对这两个构造方法调用和上面的方法同理这里就不在赘述了。

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，表示可以访问该私有构造方法。

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;
    }
}

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这个字段的赋值操作。

getDeclaredFields()

这个方法用于获取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字段，并没有他父类的字段。

• Previous
  GCC编译器
• Next
  G1垃圾回收器