代理模式（三）

静态代理：聚合+继承
聚合 ：在一个类中调用另一个对象，把参数传进来，执行器业务逻辑
聚合比继承更适合代理模式
实现功能特价，增加日志处理，增加权限管理、在move方法外层添加方法实现运行时间处理功能、实体对
像方法move
如果用继承方式实现功能叠加，代理类将无限叠加下去。

package proxy;
public interface Moveable {
public void move();
}
package proxy;
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();
}
}
}
package proxy;
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( “日志结束”);
}
}
package proxy;
public class CarTimeProxy implements Moveable{
private Moveable m;
public CarTimeProxy(Moveable m){
super();
this. m = m;
}
@Override
public void move() {
long starttime =System. currentTimeMillis();
System. out.println( “汽车开始行使” );
m.move();
long endtime = System. currentTimeMillis();
System. out.println( “汽车结束行驶..汽车行驶时间:” +(endtime -starttime ));
}
}
package proxy;
public class Client {
public static void main(String[] args) {
/*Car car = new Car();
car.move();*/
//使用继承的方式
/*Moveable car = new Car2();
car.move();*/

        //使用聚合方式实现
        /*Car car = new Car();
        Moveable n = new CarTimeProxy(car);
       n.move();*/    
       Car car = new Car();
       CarTimeProxy ctp = new CarTimeProxy( car);
       CarLogProxy  clp = new CarLogProxy( ctp);
        clp.move();
 }    

}
JDK动态代理
Java 动态代理类位于java.lang.reflect报下，一般主要涉及到以下两个类：
(1)Interface InvocationHandler:该接口中仅定义了一个方法
public object invoke(Object obj,Method method,Object[] args)
在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，args为该方法的参数数 组 。这个抽象方法在代理类中动态实现。
（2）Proxy:该类纪委动态代理类
static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h):返回代理类的一个实例，返回后的大力类可以当做代理类使用（可使用被代理类的在接口中声明过的方法）
代理模式-动态代理
所谓Dynamic Proxy是这样一种class;
它是在运行时生成的class
该class需要实现一组interface
使用动态代理类时，必须实现InvocationHandler接口
package JdkProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class TimeHandler implements InvocationHandler{
public TimeHandler(Object target) {
super();
this.target = target;
}
private Object target;
/*
* (non-Javadoc)
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
* 参数：
* proxy:被代理对象
* method:被代理对象的方法
* args：方法的参数
* 返回值： Object 方法的返回值
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
long starttime =System.currentTimeMillis();
System.out.println(“汽车开始行使”);
method.invoke(target);
long endtime = System.currentTimeMillis();
System.out.println(“汽车结束行驶..汽车行驶时间:”+(endtime-starttime));
return null;
}
}

package JdkProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import proxy.Car;
import proxy.Moveable;
public class Test {
/**
* JDK动态代理测试类
* @param args
*/
public static void main(String[] args) {
Car car = new Car();
InvocationHandler h = new TimeHandler(car);
Class