一、静态代理
代理和被代理对象在代理之前是确定的，他们都实现相同的接口或者继承相同的抽象类。UML模型如下：
6632620276117148876.jpg
下面分别通过继承和聚合的方式实现静态代理。
二、继承方式实现静态代理
1、创建一个接口
public interface Moveable {
void move();
}
2、创建一个Car类
import java.util.Random;
public class Car implements Moveable {
@Override
public void move() {
long startTime=System.currentTimeMillis();
System.out.println("汽车开始行驶。。。");
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶中。。。");
} catch(InterruptedException e) {
e.printStackTrace();
}
long endTime=System.currentTimeMillis();
System.out.println("汽车结束行驶。。。行驶时间 " + (endTime - startTime) + " 秒");
}
}
3、通过继承的代理方式来实现记录汽车行驶时间，新建Car2类，继承Car类。此时注释掉Car类中的行驶起止时间。
import java.util.Random;
public class Car implements Moveable {
@Override
public void move() {
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶中。。。");
} catch(InterruptedException e) {
e.printStackTrace();
}
}
}
Car2类如下定义：
public class Car2 extends Car {
public Car2() {
super();
}
@Override
public void move() {
long startTime=System.currentTimeMillis();
System.out.println("汽车开始行驶。。。");
super.move();
long endTime=System.currentTimeMillis();
System.out.println("汽车结束行驶。。。行驶时间 " + (endTime - startTime) + " 秒");
}
}
测试类：
public class ProxyTest {
public static void main(String[] args) {
Moveable moveable=new Car2();
moveable.move();
}
}
输出结果：
汽车开始行驶。。。
汽车行驶中。。。
汽车结束行驶。。。行驶时间 968 秒
三、聚合方式实现静态代理
聚合概念：一个类中会调用另一个对象。
1、创建一个Car3类，实现Moveable接口。
public class Car3 implements Moveable {
private Car car;
public Car3(Car car) {
super();
this.car=car;
}
@Override
public void move() {
long startTime=System.currentTimeMillis();
System.out.println("汽车开始行驶。。。");
car.move();
long endTime=System.currentTimeMillis();
System.out.println("汽车结束行驶。。。行驶时间 " + (endTime - startTime) + " 秒");
}
}
2、测试类：
public class ProxyTest {
public static void main(String[] args) {
Car car=new Car();
Moveable moveable=new Car3(car);
moveable.move();
}
}
3、输出结果：
汽车开始行驶。。。
汽车行驶中。。。
汽车结束行驶。。。行驶时间 10 秒
四、继承方式实现代理的优缺点
如果要叠加业务，比如说要加权限的处理，加日志的处理。则需定义新的子类，继承Car2或者Car3，在move方法进行权限或日志的处理。根据叠加业务及处理顺序不同，分别要创建不同的子类，这样子类会无限膨胀下去，不好管理。但是聚合可以避免这个问题。
五、聚合的优势体现
需求：叠加对日志的处理及日志的处理
1、新建日志代理类，实现Moveable接口：
public class CarLogProxy implements Moveable {
private Moveable m;
public CarLogProxy(Moveable m) {
super();
this.m=m;
}
@Override
public void move() {
System.out.println("日志开始。。。");
m.move();
System.out.println("日志结束。。。");
}
}
2、新建时间代理类，实现Moveable接口：
public class CarTimeProxy implements Moveable {
private Moveable m;
public CarTimeProxy(Moveable m) {
super();
this.m=m;
}
@Override
public void move() {
System.out.println("汽车开始行驶。。。");
m.move();
System.out.println("汽车结束行驶。。。");
}
}
3、Car类
import java.util.Random;
public class Car implements Moveable {
@Override
public void move() {
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶中。。。");
} catch(InterruptedException e) {
e.printStackTrace();
}
}
}
4、测试类：
public class Test {
public static void main(String[] args) {
Car car=new Car();
CarLogProxy carLogProxy=new CarLogProxy(car);
CarTimeProxy carTimeProxy=new CarTimeProxy(carLogProxy);
carTimeProxy.move();
}
}
5、输出结果：
汽车开始行驶。。。
日志开始。。。
汽车行驶中。。。
日志结束。。。
汽车结束行驶。。。
6、改变代理顺序进行测试：
public class Test {
public static void main(String[] args) {
Car car=new Car();
CarTimeProxy carTimeProxy=new CarTimeProxy(car);
CarLogProxy carLogProxy=new CarLogProxy(carTimeProxy);
carLogProxy.move();
}
}
7、返回结果：
日志开始。。。
汽车开始行驶。。。
汽车行驶中。。。
汽车结束行驶。。。
日志结束。。。
很显然，聚合实现代理方式比继承代理方式更为灵活，代理之间可以互相组合，互相传递。
但是又问题来了，如果要实现火车，自行车对时间的代理呢，则又需要创建火车的时间代理类，自行车的时间代理类。火车的日志代理类，自行车的日志代理类，代理类仍然会膨胀下去。可以通过动态代理来解决这个问题。
