Java设计模式之代理模式

Java设计模式之代理模式

java咖啡.jpg

代理模式

• 静态代理
• 动态代理

为什么需要代理

通过代理，我们能够不用知道委托人是谁，而执行者能够接到任务并完成。在完成任务的同时，我们可以对代理的任务进行拓展，比如增加日志、事务、时间消耗计算等，一句话，能够在不修改委托人原始任务的情况下，对委托人的任务进行拓展，并且执行者不需要知道委托人是谁，仅仅知道委托任务即可。

一、静态代理

类图.png

public interface IAction {
    public void say();
}

public class RealAction implements IAction {
    @Override
    public void say() {
        System.out.println("i am realAction!!");
    }
}

public class StaticProxy implements IAction {

    private RealAction mRealAction;

    public StaticProxy() {
        if (mRealAction == null){
            mRealAction = new RealAction();
        }
    }

    @Override
    public void say() {
        System.out.println("i am proxy start -------");
        mRealAction.say();
        System.out.println("i am proxy end -------");
    }
}

调用

IAction staticSubject = new StaticProxy();
staticSubject.say();

结果

静态代理输出结果.png

二、动态代理

类图.png

类IAction、RealAction 同上

public class DynamicProxy implements InvocationHandler {

    private Object mTarget;

    public DynamicProxy(Object target) {
        mTarget = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("------start time-----");
        Object resultObject = method.invoke(mTarget , args);
        System.out.println("------end time-----");
        return resultObject;
    }
}

步骤

一个典型的动态代理创建对象过程可分为以下四个步骤：
1、通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(...);
2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类
Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});
3、通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4、通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入
Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。
生成的ProxySubject继承Proxy类实现Subject接口，实现的Subject的方法实际调用处理器的invoke方法，而invoke方法利用反射调用的是被代理对象的的方法（Object result=method.invoke(proxied,args)）

调用

IAction subject = null;
RealAction rSubject = new RealAction();
DynamicProxy proxy = new DynamicProxy(rSubject);
subject = (IAction) Proxy.newProxyInstance(getClassLoader(), rSubject.getClass().getInterfaces(), proxy);
subject.say();

结果

动态代理输出结果.png

总结

• 静态代理
  • 优点：
    1、直观感受，静态代理是实实在在的存在的，我们自己写的。
    2、在编译期加入，提前就指定好了谁调用谁，效率高。
  • 缺点：
    1、静态代理很麻烦，需要大量的代理类
    当我们有多个目标对象需要代理时，我就需要建立多个代理类，改变原有的代码，改的多了就很有可能出问题，必须要重新测试。
    2、重复的代码会出现在各个角落里，违背了一个原则：“ 重复不是好味道 ”
    我们应该杜绝一次次的重复。
    3、在编译期加入，系统的灵活性差
• 动态代理

  • 优点：
    1、一个动态代理类更加简单了，可以解决创建多个静态代理的麻烦，避免不断的重复多余的代码
    2、调用目标代码时，会在方法“运行时”动态的加入，决定你是什么类型，才调谁，灵活

  • 缺点：
    1、系统灵活了，但是相比而言，效率降低了，比静态代理慢一点
    2、动态代理比静态代理在代码的可读性上差了一点，不太容易理解
    3、JDK动态代理只能对实现了接口的类进行代理