设计模式(22)-----代理设计模式-----静态代理

1 package com.DesignPatterns.al.Dynamic1;
2 
3 public interface Moveable {
4     public void move();
5 }

package com.DesignPatterns.al.Dynamic1;

import java.util.Random;

public class Tank implements Moveable {

    @Override
    public void move() {
        
        System.out.println("坦克在移动");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }
}

package com.DesignPatterns.al.Dynamic1;

/**
 * 用继承计算tank中move的运行时间
 * 
 * @author qingruihappy
 * @data 2018年10月31日 下午11:19:43
 * @说明:
 */
public class Tank1 extends Tank {

    @Override
    public void move() {
        long startTime = System.currentTimeMillis();
        super.move();
        long endTime = System.currentTimeMillis();
        System.out.println("tank总共花费时间是" + (endTime - startTime));
    }

}

 1 package com.DesignPatterns.al.Dynamic1;
 2 /**
 3  * 用继承实现静态代理
 4  * @author qingruihappy
 5  * @data   2018年11月1日 上午1:05:36
 6  * @说明:
 7  */
 8 public class Test {
 9     public static void main(String[] args) {
10         Moveable m=new Tank1();
11         m.move();
12     }
13 
14 }

package com.DesignPatterns.al.Dynamic2;

public interface Moveable {
    public void move();
}

package com.DesignPatterns.al.Dynamic2;

import java.util.Random;

public class Tank implements Moveable {

    @Override
    public void move() {
        
        System.out.println("坦克在移动");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }
}

package com.DesignPatterns.al.Dynamic2;

/**
 * 聚合实现： 聚合：在一个类中有另一个类的实现，站在代理的角度来说就是当前类是代理类，里面的另一个类就是目标类，调用代理类的时候就是调用目标类的方法。
 * Tank2中有Tank的类，操作的就是Tank相关的方法。
 * 
 * @author qingruihappy
 * @data 2018年10月31日 下午11:26:45
 * @说明:
 */
public class Tank2 implements Moveable {
    Tank t;

    public Tank2(Tank t) {
        super();
        this.t = t;
    }

    @Override
    public void move() {
        long startTime = System.currentTimeMillis();
        t.move();
        long endTime = System.currentTimeMillis();
        System.out.println("tank总共花费时间是" + (endTime - startTime));
    }

}

package com.DesignPatterns.al.Dynamic2;

public class Test {
    public static void main(String[] args) {
        Moveable m=new Tank2(new Tank());
        m.move();
    }

}

package com.DesignPatterns.al.Dynamic3;

public interface Moveable {
    public void move();
}

package com.DesignPatterns.al.Dynamic3;

import java.util.Random;

public class Tank implements Moveable {

    @Override
    public void move() {
        
        System.out.println("坦克在移动");
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }
}

package com.DesignPatterns.al.Dynamic3;

/**
 * 现在我们来说一下为什么用实现（聚合），不用继承。
 * 最概要的说法就是实现解耦，因为设计模式的要义是面向抽象编程而不是实现编程
 * 设计模式还有一个要义就是：少用继承，多用组合。
 * 下面我们举例来说明。
 * 
 * @author qingruihappy
 * @data 2018年10月31日 下午11:26:45
 * @说明:
 */
public class TankLog implements Moveable {
    Moveable t;

    public TankLog(Moveable t) {
        super();
        this.t = t;
    }

    @Override
    public void move() {
        System.out.println("tank开始打印日志");
        t.move();
        System.out.println("tank开始打印结束");
    }

}

package com.DesignPatterns.al.Dynamic3;

/**
 * 现在我们来说一下为什么用实现（聚合），不用继承。
 * 最概要的说法就是实现解耦，因为设计模式的要义是面向抽象编程而不是实现编程
 * 设计模式还有一个要义就是：少用继承，多用组合。
 * 下面我们举例来说明。
 * 
 * @author qingruihappy
 * @data 2018年10月31日 下午11:26:45
 * @说明:
 */
public class TankTime implements Moveable {
    Moveable t;

    public TankTime(Moveable t) {
        super();
        this.t = t;
    }

    @Override
    public void move() {
        System.out.println("tank开始打印开始时间");
        long startTime = System.currentTimeMillis();
        t.move();
        long endTime = System.currentTimeMillis();
        System.out.println("tank开始打印结束时间");
        System.out.println("tank总共花费时间是" + (endTime - startTime));
    }

}

package com.DesignPatterns.al.Dynamic3;
/**
 * 现在假如我们有一个打印日志的代理，一个打印时间的代理（甚至还有事物的代理，还比如说我检查当前的人有没有运行我这个方法的权限等等）。
 * 假如我们用继承的话会怎么办呢，我们就的让打印日志的代理继承目标，再让打印时间的代理继承时间的类，让事物的代理继承代理时间的类，让运行权限的代理继承事物的代理......
 *。还有就是假如现在我们换了顺序了，先出打印日志的代理，然后在用时间的代理继承时间的代理，那么又会多出来两个代理类，想想都是一件恐怖的事情，类太多了。
 *
 * 但是我们用接口（聚合呢，我们来看这个例子。）
 * 聚合有点类似于装饰着设计模式：在这里我们要注意这几模式其实更看重的是使用场景，而不是具体细节的用法。
 * 其实设计模式多多少少都想多态，但是我们注意设计模式更看重的是语义上的而不是语法上的。
 * 
 * 
 * 现在静态的代理已经将完了，但是我们来看这个代理有什么缺陷，首先代理类和目标类必须继承相同的接口（虽然是缺点但是可以接受）
 * 但是还有一个就是，假如现在有其它的类加car也需要实现打印时间的代理，那我们怎么做的，你说好说，在写一个car的代理呗。
 * 那假如现在有自行车，火车，货车，电瓶车，小推车，等等100多个都要求实现时间的代理，是不是需要些100多个类呢。
 * 
 * 下面就引出了动态代理。
 * @author qingruihappy
 * @data   2018年11月1日 上午12:39:35
 * @说明:
 */
public class Test {
    public static void main(String[] args) {
    /*    TankTime m=new TankTime(new Tank());
        TankLog n=new TankLog(m);
        n.move();*/
        
        TankLog m=new TankLog(new Tank());
        TankTime n=new TankTime(m);
        n.move();
    }

}

tank开始打印日志
tank开始打印开始时间
坦克在移动
tank开始打印结束时间
tank总共花费时间是636
tank开始打印结束

tank开始打印开始时间
tank开始打印日志
坦克在移动
tank开始打印结束
tank开始打印结束时间
tank总共花费时间是270