设计模式简单理解之代理设计模式

代理模式，从字面上理解就是我负责核心工作，你作为代理负责我非核心的工作。类Proxy作为代理，第一阶段代码如下：

class Proxy {
    private Myduty myduty;

    public Proxy(Myduty myduty) {
        this.myduty = myduty;
    }


    public void doSth() {
        openRefrigeratorDoor();
        putInElephant();
        closeRefrigeratorDoor();
    }


    public void openRefrigeratorDoor() {
        System.out.println("打开冰箱门");
    }

    public void putInElephant() {
        //核心业务，应该由我来放
        myduty.putInElephant();
    }

    public void closeRefrigeratorDoor() {
        System.out.println("关上冰箱门");
    }

}

class Myduty {
    //我来处理核心的工作
    public void putInElephant() {
        System.out.println("把大象放进冰箱");
    }
}

上面代码简单解析，既然我来作核心工作的话，那么代理类必须是要持有我的类对象的，然后通过代理类就可以完成所以的工作啦。但是上面代码不具有通用型，加入我想让另外的人来处理核心工作怎么办呢，那么我们引入接口，通过多态解决问题。完整代码如下：

interface Duty {
    void putInElephant();
}

class Proxy {
    private Duty duty;

    public Proxy(Duty myduty) {
        this.duty = myduty;
    }


    public void doSth() {
        openRefrigeratorDoor();
        putInElephant();
        closeRefrigeratorDoor();
    }


    public void openRefrigeratorDoor() {
        System.out.println("打开冰箱门");
    }

    public void putInElephant() {
        //核心业务，应该由我来放
        duty.putInElephant();
    }

    public void closeRefrigeratorDoor() {
        System.out.println("关上冰箱门");
    }

}

class Myduty implements Duty{

    //我来处理核心的工作
    @Override
    public void putInElephant() {
        System.out.println("My把大象放进冰箱");
    }
}

测试类：

public class ProxyPattern {
    public static void main(String[] strings) {
        new Proxy(new Myduty()).doSth();
    }

}

//结果：
//打开冰箱门
//My把大象放进冰箱
//关上冰箱门

代理模式的是让你专心投入到你的核心工作，而不去操心其他的繁杂事情，Java里面线程类的设计就利用到了代理设计模式：

@Override
    public void run() {
        if (target != null) {
            target.run();//调用Runnable子类的run方法
        }
    }

public class ProxyPattern {
    public static void main(String[] strings) {
        new Proxy(new Myduty()).doSth();
        new Thread(new TestTH()).start();//两者异曲同工之妙！
    }
    static class TestTH implements Runnable {
        @Override
        public void run() {
            System.out.println("核心业务类");
        }
    }


}

我们都知道Thread类是Runnable的子类，但是当我们使用线程处理程序时，我们一般只关注如何重写子类中的run()方法，run()方法也是我们的核心业务，而Thread则是我们多线程业务的代理类。Callable同理：

public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;//子类对象c
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();//静态代理模式
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

我们重写的Callable的子类中的call()方法即为我们的核心业务。真的佩服那些类库的设计人员，每个细节都充满着程序设计的智慧，值得我们细细品味和学习。若是有什么不对的地方还请大家指出，这些主要是帮组下新手理解，毕竟我也只是个菜鸟，谢谢大家！