静态代理模式

在Java中，静态代理指的是代理类的产生发生在源程序编译阶段，在编译之后生成目标程序中包括代理类的class文件。程序运行时，直接装载代理类，生成代理对象。

静态代理有两种实现方式：继承方式和聚合方式

实例：

有一辆坦克，他可以移动，我们想要在记录它移动一次的时间，即执行move()这个方法所用的时间，同时，又想要在它移动或者记录时间之前或之后记录一些日志。

实现方式：

定义移动的接口类

 Moveable.java

package com.fgh.proxy;
public interface Moveable {
	
	void move();
}

第一个实现类Tank.java

package com.fgh.proxy;
import java.util.Random;
public class Tank implements Moveable {
	public void move() {
		System.out.println("Tank moving.......");
		try {
			Thread.sleep(new Random().nextInt(2000));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

一、继承方式

TankExten.java

package com.fgh.proxy;
/**
 * 继承方式实现代理
 * @author fgh
 *
 */
public class TankExten extends Tank {
/**
 * 重写父类的方法
 */
	@Override
	public void move() {
		System.out.println("Tank Starting....");
		super.move();
		System.out.println("Tank Stoping.......");
	}
}

二、聚合方式

TankLogProxy.java

 添加打印日志的逻辑

package com.fgh.proxy;
/**
 * 聚合方式实现代理 添加打印日志的逻辑
 * @author fgh
 *
 */
public class TankLogPrxoxy implements Moveable {
	Moveable m;
	public TankLogPrxoxy(Moveable m) {
		super();
		this.m = m;
	}
	public void move() {
		System.out.println("Tank Start...");
		m.move();
		System.out.println("Tank Stop...");
	}
}

TankTimeProxy.java

计算move(）方法的执行时间

package com.fgh.proxy;
/**
 * 聚合方式 计算move()方法执行时间
 * @author fgh
 *
 */
public class TankTimeProxy implements Moveable {
	Moveable m;
	public TankTimeProxy(Moveable m) {
		super();
		this.m = m;
	}
	public void move() {
		long start = System.currentTimeMillis();
		System.out.println("StartTime:" + start);
		m.move();
		long end = System.currentTimeMillis();
		System.out.println("Execute Time= " + (end - start)+"ms");
	}
}

测试代码：Client.java

package com.fgh.proxy;
/**
 * 静态代理
 * @author fgh
 *
 */
public class Client {
	public static void main(String[] args) {
		 Tank t = new Tank();
		 //move()方法外面套一层打印日志逻辑
		 TankLogPrxoxy tlp = new TankLogPrxoxy(t);
		//接着在外面套一层计算move()方法执行时间的逻辑
		 TankTimeProxy ttp = new TankTimeProxy(tlp);
		 ttp.move();
//		TankExten te = new TankExten();
//		te.move();
	}
}

总结：继承方式容易造成类的堆叠 假如有100个类 那我们要继承100次

聚合方式比较灵活，推荐使用