JDK的代理模式

jdk的代理模式

1.代理模式的定义:

为其他对象提供一种代理一控制对这个对象的访问,代理对对象起到中介作用,用于去掉部分功能服务或者是增加一些额外的服务

2.静态代理:

代理和被代理之间的关系是确定的,他们都是实现相同的接口或者是继承相同的抽象类;

 

创建接口

public interface Moveable {

void move();

}

创建车实现Moveable方法

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 {

@Override

public void move() {

long starttime = System.currentTimeMillis();

System.out.println("汽车开始行驶....");

super.move();

long endtime = System.currentTimeMillis();

System.out.println("汽车结束行驶.... 汽车行驶时间："

+ (endtime - starttime) + "毫秒！");

}

}

② 聚合的方式:

创建Car3__以聚合的方式实现静态代理:

public class Car3 implements Moveable {

public Car3(Car car) {

super();

this.car = car;

}

private Car car;

@Override

public void move() {

long starttime = System.currentTimeMillis();

System.out.println("汽车开始行驶....");

car.move();

long endtime = System.currentTimeMillis();

System.out.println("汽车结束行驶.... 汽车行驶时间："

+ (endtime - starttime) + "毫秒！");

}

}

两者之间都可以实现静态代理,但是相比之下,使用聚合的方式更好:

比如: 上面的例子只是增加了时间记录那么需要创建一个Car2,那么如果在增加一个记录行驶日志呢?那么就要再创建一个Car4,再增加一个权限呢?那么就需要再创建一个Car5来继承Car4,.........这样的话没增加一个功能就需要创建一个实例.但是使用聚合的方式就不会这样了

同样创建一个move接口:

public interface Moveable {

void move();

}

再创建一个实例Car实现Moveable接口

public class Car implements Moveable {

@Override

public void move() {

//实现开车

try {

Thread.sleep(new Random().nextInt(1000));

System.out.println("汽车行驶中....");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

创建时间代理_用于记录时间

public class CarTimeProxy implements Moveable {

public CarTimeProxy(Moveable m) {

super();

this.m = m;

}

private Moveable m;

@Override

public void move() {

long starttime = System.currentTimeMillis();

System.out.println("汽车开始行驶....");

m.move();

long endtime = System.currentTimeMillis();

System.out.println("汽车结束行驶.... 汽车行驶时间："

+ (endtime - starttime) + "毫秒！");

}

}

创建日志代理_用于记录日志

public class CarLogProxy implements Moveable {

public CarLogProxy(Moveable m) {

super();

this.m = m;

}

private Moveable m;

@Override

public void move() {

System.out.println("日志开始....");

m.move();

System.out.println("日志结束....");

}

}

创建测试类

public static void main(String[] args) {

Car car = new Car();

CarLogProxy clp = new CarLogProxy(car);

CarTimeProxy ctp = new CarTimeProxy(clp);

clp.move();//此时是先执行日志,再执行记录行驶时间

ctp.move();//此时是先执行记录行驶时间,再执行记录日志

}

这样可以看出聚合相比于继承要灵活了很多

但是,像权限,日志,时间这种公共的代理,后面如果再创建了一个其他对象,如飞机,火车,自行车呢?那是不是就要创建不同的实例呢?然后这种情况下就需要用到动态代理了

3.动态代理

动态代理的原理图如下所示:

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[] interf aces,

InvocationHandler h): 返回代理类的一个实例，返回后的代理类可以当作被

代理类使用(可使用被代理类的在接口中声明过的方法)

示例:

创建时间处理的handler

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;

/*

* 参数：

* 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;

}

}

JDK动态代理测试:

/**

* JDK动态代理测试类

*/

public static void main(String[] args) {

Car car = new Car();

InvocationHandler h = new TimeHandler(car);

Clas s<?> cls = car.getClass();

/**

* loader 类加载器

* interfaces 实现接口

* h InvocationHandler

*/

Moveable m = (Moveable)Proxy.newProxyInstance(cls.getClassLoader(),

cls.getInterfaces(), h);

m.move();

}

总结:

动态代理实现步骤

1.创建一个实现接口InvocationHandler的类，它

必须实现i nvoke方法

2.创建被代理的类以及接口

3.调用Proxy的静态方法，创建一个代理类

newProxyInstance(ClassLoader loader,Class[]

interfaces,InvocationHandler h)

4.通过代理调用方法

动态代理实现思路

实现功能: 通过Proxy的newProxyInstance返回代理对象

1、声明一段源码(动态产生代理)

2、编译源码(JDK Compiler API),产生新的类(代理类)

3、将这个类load到内存当中，产生一个新的对象(代理对象)

4、return 代理对象