代理

引题：假如我们想计算一个方法的运行时间，在不动源代码的情况下都是用代理类来代替源码完成业务。具体方法有下面两种。

源码：

package com.liuzhihong.inter;
/**
 * @ClassName Moveable
 * @Description
 * @Author 刘志红
 * @Date 2019/4/3
 **/
public interface Moveable {
    void move();
}

package com.liuzhihong.waitproxy;
import com.liuzhihong.inter.Moveable;
/**
 * @ClassName Person
 * @Description
 * @Author 刘志红
 * @Date 2019/4/3
 **/
public class Person implements Moveable {
    @Override
    public void move() {
        System.out.println("Person.move");
        try {
            Thread.sleep((int) (Math.random() * 10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

1：继承方式

package com.liuzhihong.ext;
import com.liuzhihong.waitproxy.Person;

import java.time.Duration;
import java.time.Instant;
/**
 * @ClassName PersonExtend
 * @Description
 * @Author 刘志红
 * @Date 2019/4/3
 **/
public class PersonExtend extends Person {
    @Override
    public void move() {
        Instant start = Instant.now();
        super.move();
        Instant end = Instant.now();
        System.out.println("运行时间"+ Duration.between(start,end).toMillis());
    }
}

2：聚合方式

package com.liuzhihong.polymerization;
import com.liuzhihong.inter.Moveable;
import com.liuzhihong.waitproxy.Person;

import java.time.Duration;
import java.time.Instant;
/**
 * @ClassName PersonPol
 * @Description
 * @Author 刘志红
 * @Date 2019/4/3
 **/
public class PersonPol implements Moveable {
    private  Person person;
    public PersonPol(Person person) {
        this.person = person;
    }
    @Override
    public void move() {
        Instant start = Instant.now();
        person.move();
        Instant end = Instant.now();
        System.out.println("Program RunningTime:"+ Duration.between(start, end).toMillis());
    }
}

测试代码

package com.liuzhihong.test;
import com.liuzhihong.ext.PersonExtend;
import com.liuzhihong.polymerization.PersonPol;
import com.liuzhihong.waitproxy.Person;
import org.junit.Test;
/**
 * @ClassName Test
 * @Description
 * @Author 刘志红
 * @Date 2019/4/3
 **/
public class TestProxy {
    @Test
    public void testEXC(){
        new PersonExtend().move();
    }

    @Test
    public void testPlo(){
        new PersonPol(new Person()).move();
    }
}

总结：从上面的例子我们可以看出，使用集成和聚合都能够实现代理。

引出问题:继承和聚合哪种好呢？实际业务中不光有计算时间，还可能有打印日志等（会有很多代理）。拿继承来说，每一种我们都需要写一个继承类。如果混用呢？拿计算时间和日志来说，先时间后日志。我们需要先写时间继承类，再在时间继承类的基础上写日志继承类。如果业务反一下的话，又得重写这两个继承类。这还是只有计算时间和打印日志，如果需要其他很多种代理呢？这样显然这样很笨重。使用聚合可以解决这种问题，具体如下：

修改计算时间的聚合代理方式，并且添加时间日志代理，代码如下：

package com.liuzhihong.polymerization;
import com.liuzhihong.inter.Moveable;
import com.liuzhihong.waitproxy.Person;

import java.time.Duration;
import java.time.Instant;
/**
 * @ClassName PersonPol
 * @Description
 * @Author 刘志红
 * @Date 2019/4/3
 **/
public class TimeProxy implements Moveable {
    private Moveable moveable;
    public TimeProxy(Moveable moveable) {
        this.moveable = moveable;
    }
    @Override
    public void move() {
        Instant start = Instant.now();
        moveable.move();
        Instant end = Instant.now();
        System.out.println("Program RunningTime:" + Duration.between(start, end).toMillis());
    }
}

package com.liuzhihong.polymerization;
import com.liuzhihong.inter.Moveable;
/**
 * @ClassName LogProxy
 * @Description
 * @Author 刘志红
 * @Date 2019/4/3
 **/
public class LogProxy implements Moveable {
    private Moveable moveable;
    public LogProxy(Moveable moveable) {
        this.moveable = moveable;
    }
    @Override
    public void move() {
        System.out.println("method begin...");
        moveable.move();
        System.out.println("method end!!!");
    }
}

我们只需要上面两个代理类就可以完成上面所说的所有业务。这是因为代理本身也实现了接口；测试如下

package com.liuzhihong.test;
import com.liuzhihong.polymerization.LogProxy;
import com.liuzhihong.polymerization.TimeProxy;
import com.liuzhihong.waitproxy.Person;
import org.junit.Test;
/**
 * @ClassName Test
 * @Description
 * @Author 刘志红
 * @Date 2019/4/3
 **/
public class TestProxy {
    /**
     * 计算时间
     */
    @Test
    public void testTime() {
        new TimeProxy(new Person()).move();
    }
    /**
     * 加日志
     */
    @Test
    public void testLog() {
        new LogProxy(new Person()).move();
    }
    /**
     * 日志包计算时间
     */
    @Test
    public void testTimeLog() {
        new LogProxy(new TimeProxy(new Person())).move();
    }
    /**
     * 计算时间包日志
     */
    @Test
    public void testLogTime() {
        new TimeProxy(new LogProxy(new Person())).move();
    }
}

总结：代理方式选择了用聚合而不用继承。

引出问题：