设计模式之代理模式

马佩
858 阅读7分钟

前言

一月一更哈，我来了～（觉得这个更新速度太慢了，后面会加快更新技术相关方面的博客的哈）

今天在详细的给大家分析一下代理模式～

代理模式的定义：

给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式包含如下角色：

subject：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口;

RealSubject：真实主题角色，是实现抽象主题接口的类;

Proxy:代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象。

代理对象提供与真实对象相同的接口，以便代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。如下图所示：

那么代理又分为静态代理和动态代理，这里写两个小的demo，动态代理采用的就是JDK代理。举个例子就是现在一个班上的学生需要交作业，现在由班长代理交作业，那么班长就是代理，学生就是被代理的对象。

1 静态代理

首先，我们创建一个Person接口。这个接口就是学生（被代理类），和班长（代理类）的公共接口，他们都有交作业的行为。这样，学生交作业就可以让班长来代理执行。

/**
 * Created by Mapei on 2018/11/7
 * 创建person接口
 */
public interface Person {
    //交作业
    void giveTask();
}

Student类实现Person接口，Student可以具体实施交作业这个行为。

/**
 * Created by Mapei on 2018/11/7
 */
public class Student implements Person {
    private String name;
    public Student(String name) {
        this.name = name;
    }

    public void giveTask() {
        System.out.println(name + "交语文作业");
    }
}

StudentsProxy类，这个类也实现了Person接口，但是还另外持有一个学生类对象，那么他可以代理学生类对象执行交作业的行为。

/**
 * Created by Mapei on 2018/11/7
 * 学生代理类，也实现了Person接口，保存一个学生实体，这样就可以代理学生产生行为
 */
public class StudentsProxy implements Person{
    //被代理的学生
    Student stu;

    public StudentsProxy(Person stu) {
        // 只代理学生对象
        if(stu.getClass() == Student.class) {
            this.stu = (Student)stu;
        }
    }

    //代理交作业，调用被代理学生的交作业的行为
    public void giveTask() {
        stu.giveTask();
    }
}

下面测试一下，看代理模式如何使用：

/**
 * Created by Mapei on 2018/11/7
 */
public class StaticProxyTest {
    public static void main(String[] args) {
        //被代理的学生林浅，他的作业上交有代理对象monitor完成
        Person linqian = new Student("林浅");

        //生成代理对象，并将林浅传给代理对象
        Person monitor = new StudentsProxy(linqian);

        //班长代理交作业
        monitor.giveTask();
    }
}

运行结果：

这里并没有直接通过林浅（被代理对象）来执行交作业的行为，而是通过班长（代理对象）来代理执行了。这就是代理模式。代理模式就是在访问实际对象时引入一定程度的间接性，这里的间接性就是指不直接调用实际对象的方法，那么我们在代理过程中就可以加上一些其他用途。比如班长在帮林浅交作业的时候想告诉老师最近林浅的进步很大，就可以轻松的通过代理模式办到。在代理类的交作业之前加入方法即可。这个优点就可以运用在spring中的AOP，我们能在一个切点之前执行一些操作，在一个切点之后执行一些操作，这个切点就是一个个方法。这些方法所在类肯定就是被代理了，在代理过程中切入了一些其他操作。

2 动态代理

动态代理和静态代理的区别是，静态代理的的代理类是我们自己定义好的，在程序运行之前就已经变异完成，但是动态代理的代理类是在程序运行时创建的。相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。比如我们想在每个代理方法之前都加一个处理方法，我们上面的例子中只有一个代理方法，如果还有很多的代理方法，就太麻烦了，我们来看下动态代理是怎么去实现的。

首先还是定义一个Person接口:

/**
 * Created by Mapei on 2018/11/7
 * 创建person接口
 */
public interface Person {
    //交作业
    void giveTask();
}

接下来是创建需要被代理的实际类，也就是学生类：

/**
 * Created by Mapei on 2018/11/7
 */
public class Student implements Person {
    private String name;
    public Student(String name) {
        this.name = name;
    }

    public void giveTask() {
        System.out.println(name + "交语文作业");
    }
}

创建StuInvocationHandler类，实现InvocationHandler接口，这个类中持有一个被代理对象的实例target。InvocationHandler中有一个invoke方法，所有执行代理对象的方法都会被替换成执行invoke方法。

/**
 * Created by Mapei on 2018/11/7
 */
public class StuInvocationHandler<T> implements InvocationHandler {
    //invocationHandler持有的被代理对象
    T target;

    public StuInvocationHandler(T target) {
        this.target = target;
    }

    /**
     * proxy:代表动态代理对象
     * method：代表正在执行的方法
     * args：代表调用目标方法时传入的实参
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理执行" +method.getName() + "方法");
        Object result = method.invoke(target, args);
        return result;
    }
}

那么接下来我们就可以具体的创建代理对象了。

/**
 * Created by Mapei on 2018/11/7
 * 代理类
 */
public class ProxyTest {
    public static void main(String[] args) {

        //创建一个实例对象，这个对象是被代理的对象
        Person linqian = new Student("林浅");

        //创建一个与代理对象相关联的InvocationHandler
        InvocationHandler stuHandler = new StuInvocationHandler<Person>(linqian);

        //创建一个代理对象stuProxy来代理linqian，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
        Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler);

        //代理执行交作业的方法
        stuProxy.giveTask();
    }
}

我们执行代理测试类，首先我们创建了一个需要被代理的学生林浅，将林浅传入stuHandler中，我们在创建代理对象stuProxy时，将stuHandler作为参数，那么所有执行代理对象的方法都会被替换成执行invoke方法，也就是说，最后执行的是StuInvocationHandler中的invoke方法。所以在看到下面的运行结果也就理所当然了。

代理模式的优缺点

讲完代理模式的两种情况以及demo，大家可以根据demo自己模拟一波哈～ 接下来介绍优缺点～

优点：

1）良好的扩展性。修改被代理角色并不影响调用者使用代理，对于调用者，被代理角色是透明的。

2）隔离，降低耦合度。代理角色协调调用者和被代理角色，被代理角色只需实现本身关心的业务，非自己本职的业务通过代理处理和隔离。

缺点

1）增加了代理类，实现需要经过代理，因此请求速度会变慢。

2）实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

代理模式的应用场景

又到了使用场景了，写了一堆不知道什么时候使用，就是没有意义的，是吧？

场景一：安全代理：用来控制真实对象的访问权限的时候，一般用于对象由不同的访问权限的时候

场景二：智能指引：是指当调用真实的对象的时候，代理处理另外一些事。比如，计算真实对象的引用次数，当没有引用的时候可以自动释放；或者在访问一个实际对象前，检查是否已经锁定。这些情况都是通过代码在访问一个对象时附加一些内务处理。

场景三：虚拟代理，是根据需要创建开销很大的对象，通过它来存放实际化很长时间的真实文件，比如我们在页面图片这些就采用了虚拟代理

总结

到这里代理模式就基本上讲完了，在很多的源码中都存在代理模式的应用，比如我上面说明的Aop，代理模式还是很优秀的，大家可以多在源码中探索探索～有问题又有交流哈，求赞，谢谢大家～

avatar
文章
阅读
粉丝