java静态代理和动态代理

使用代理模式目的是控制访问



也就是说A类和B类有相同的接口，B类组合了A类，调用B类中的方法，在方法体内部调用了A类的方法，只不过在此基础上添加了一些逻辑。这一种是java的静态代理，代理类和被代理类都已经确定了。

java静态代理实例代码：

public interfece Moveable{
public void move();
}
//被代理类
public class Car implements Moveable{
public void move()
{
system.out.println("汽车行驶中");

}
}
//代理类
public  class Car2 implements Moveable{
private Moveable m;
public void setM(Moveable m){
this.m=m;
}
public void move()
{
m.move();
}
}

还有一种是动态代理，也就是代理类和被代理类都不确定。但是你要编写调用处理器，调用代理类的方法，也就是调用处理器的invoke()方法。（需要代理类和调用处理器关联）invoke()方法的逻辑用户自定义。调用处理器具有通用性。动态代理你可以自己使用反射实现，也可用使用java已经封装好的API

动态代理java API：

package oom;

public interface Moveable {
public void move();
}

package oom;

public class Car implements Moveable {

@Override
public void move() {
System.out.println("汽车行驶中......");

}

}

package oom;

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

/**
* 实现了InvocationHandler接口，这是一个调用处理器
*/
public class CarInvocationHandler implements InvocationHandler {
private  Moveable  moveable;

public CarInvocationHandler(Moveable moveable) {
super();
this.moveable = moveable;
}

public CarInvocationHandler() {
super();
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(System.currentTimeMillis());//扩展的逻辑

// 这一步使用了反射，method具有不确定性。
//如果把成员变量moveable的类型改成Object,那么任何对象的方法调用前后都会打印输出时间戳
method.invoke(moveable, args);

System.out.println(System.currentTimeMillis());
return "";
}

}

package oom;

import java.lang.reflect.Proxy;

public class Test {

public static void main(String[] args) {
CarInvocationHandler handler = new CarInvocationHandler(new Car());

//Car.class.getClassLoader()等使用了反射，所以说反射是动态代理的基石。代理对象这时才与
//调用处理器关联，调用动态代理的方法会转掉处理器的invoke()方法
Moveable car = (Moveable) Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(),
handler);
//调用接口中第一的方法
car.move();

}

}

为什么java代理要实现相同的接口呢？

动态代理都运用在哪些场景呢？

代理模式产生的目的就是控制访问，所有需要控制访问地方都可以使用动态代理，比如权限管理和AOP。

AOP的拦截功能是由java中的动态代理来实现的。说白了，就是在目标类的基础上增加切面逻辑，生成增强类（该切面逻辑或者在目标类函数执行之前，或者目标类函数执行之后，或者在目标类函数抛出异常时候执行。