定义
- 为其他对象提供一种代理, 以控制对这个对象的访问
- 代理对象在客户端和目标对象之间起到中介作用
- 数据结构型设计模式
代理的几种形式
- 静态代理
- 动态代理
- Spring AOP
适用场景
- 保护目标对象
- 增强目标对象
静态代理
显式声明被代理对象
原始代码
interface Movable {
void move();
}
public class Tank implements Movable {
@Override
public void move() {
System.out.println("Tank moving claclacla...");
try {
Thread.sleep(new Random().nextInt(1000)); // 模拟坦克移动了一段儿时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
问题1: 我想记录坦克的移动时间
一般的做法是直接改move方法
public class Tank implements Movable {
@Override
public void move() {
long start = System.currentTimeMillis();
System.out.println("Tank moving claclacla...");
try {
Thread.sleep(new Random().nextInt(10000)); // 模拟坦克移动了一段儿时间
} catch (InterruptedException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println(end - start);
}
public static void main(String[] args) {
new Tank().move();
}
}
interface Movable {
void move();
}
问题2: 如果无法改变方法源码呢? benchmark
像下面这样用继承?
public class Tank implements Movable {
@Override
public void move() {
System.out.println("Tank moving claclacla...");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new Tank2().move();
}
}
class Tank2 extends Tank {
@Override
public void move() {
long start = System.currentTimeMillis();
super.move();
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
interface Movable {
void move();
}
这样的话, 耦合度太高, 假如我又需要记录权限, 也需要记录日志, 再记录时间, 就要不断的继承
这样的方式肯定是不好的
我们终于开始引入Proxy类了
加一个TankTimeProxy, TankLogProxy, 在main方法调用中, 有点像装饰者模式, 实现了代理的各种组合
没错, 设计模式到最后就是各种模式相互混杂而成, 是对多态的各种灵活巧妙地使用
public class Tank implements Movable {
@Override
public void move() {
System.out.println("Tank moving claclacla...");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new TankTimeProxy().move();
}
}
class TankTimeProxy implements Movable {
Tank tank;
@Override
public void move() {
long start = System.currentTimeMillis();
tank.move();
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
class TankLogProxy implements Movable {
Tank tank;
@Override
public void move() {
System.out.println("start moving...");
tank.move();
System.out.println("stopped!");
}
}
interface Movable {
void move();
}
问题: 被代理的对象只能是Tank吗?
把Tank改成Movable就可以了, 如下:
public class Tank implements Movable {
@Override
public void move() {
System.out.println("Tank moving claclacla...");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new TankLogProxy( new TankTimeProxy( new Tank() ) ).move();
}
}
class TankTimeProxy implements Movable {
Movable m;
public TankTimeProxy(Movable m) {
this.m = m;
}
@Override
public void move() {
long start = System.currentTimeMillis();
m.move();
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
class TankLogProxy implements Movable {
Movable m;
public TankLogProxy(Movable m) {
this.m = m;
}
@Override
public void move() {
System.out.println("start moving...");
m.move();
long end = System.currentTimeMillis();
System.out.println("stopped!");
}
}
interface Movable {
void move();
}
至此, 发展到这一步, 一个真正的静态代理就产生了
Tank和Proxy都去实现Movable, 这样ProxyA和ProxyB之间就可以互相嵌套
静态代理的缺点
- Tank必须实现Movable, 否则就没法调用move方法
- 不能代理任意类型的Object子类, 因为Object里没有任何的业务方法 ( 给你一个Movable, 你知道去调用move(), 给你一个Object呢, 里面啥都没有, 代理个啥? 没法指定, 没法写死 )
问题: 如果想让LogProxy可以代理任意类型的Object呢?
毕竟日志记录,时间计算是很多方法都需要的东西,这时该怎么做呢?
难道把Movable改成Object吗? 那move方法怎么办, Object类里, 可没有move方法
本质上来讲, 我们在做这样一件事: 分离代理行为和被代理对象
动态代理
动态代理的Proxy类, 不是自己手写的, 而是动态生成的, 你看不见他的代码
JDK动态代理的实现原理
- 拿到被代理类的引用, 并且获取他的所有的接口(反射获取)
- JDK Proxy类重新生成一个新的类, 实现了被代理类所有接口的方法
- 动态生成Java代码, 把增强逻辑加入到新生成代码中
- 编译生成新的Java代码的class文件
- 加载并重新运行新的class, 得到类就是全新类
public class Tank implements Movable {
@Override
public void move() {
System.out.println("Tank moving claclacla...");
try {
Thread.sleep(new Random().nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Tank tank = new Tank();
//reflection 通过二进制字节码分析类的属性和方法
Movable m = (Movable) Proxy.newProxyInstance(Tank.class.getClassLoader(),
new Class[]{Movable.class}, //tank.class.getInterfaces()
new LogHander(tank)
);
m.move();
}
}
class LogHander implements InvocationHandler {
Object obj;
public LogHander(Tank tank) {
this.obj = tank;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("method " + method.getName() + " start..");
Object o = method.invoke(obj, args);
System.out.println("method " + method.getName() + " end!");
return o;
}
}
interface Movable {
void move();
}
运行结果:
method move start..
Tank moving claclacla...
method move end!
终于, Proxy类里的类型不再是Movable了, 变成了Object , 可以代理任意类型的对象了
只是, 这个对象还是得实现interface, 并且在调用newProxyInstance方法时, 作为参数传进去
问题: InvocationHandler里的invoke方法, 是在哪里被调用的呢
public Object invoke(Object proxy, Method method, Object[] args)
答案是: 上面这个方法, 是在JDK生成的动态代理类里调用的
我们可以加入下面这句话
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
// 或者
System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles","true");
public class Tank implements Movable {
@Override
public void move() {
System.out.println("Tank moving claclacla...");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Tank tank = new Tank();
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
Movable m = (Movable) Proxy.newProxyInstance(Tank.class.getClassLoader(),
new Class[]{Movable.class}, //tank.class.getInterfaces()
new TimeProxy(tank)
);
m.move();
}
}
class TimeProxy implements InvocationHandler {
Object obj;
public TimeProxy(Movable m) {
this.obj = m;
}
// 这里的Object proxy是那个生成的代理对象
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//Arrays.stream(proxy.getClass().getMethods()).map(Method::getName).forEach(System.out::println);
System.out.println("method start..");
Object o = method.invoke(this.obj, args);
System.out.println("method stop..");
return o;
}
}
interface Movable {
void move();
}
运行上面的代码之后, 会在proxy/v10目录下, 生成$Proxy0.class文件
点进去, 可以看到如下的代码
package proxy.v10;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
final class $Proxy0 extends Proxy implements Movable { // 自动帮我们实现了Movable接口
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
// 构造器, 接收了一个实现InvocationHandler的那个类TimeProxy的实例
// 下面有个super.h, 引用的就是这个传进来的var1对象
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
// object的equals方法, 可以忽略
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
// 自动帮我们实现了Proxy中的move方法
public final void move() throws {
try {
// super.h就是实现了InvocationHandler的那个类TimeProxy的实例
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
// object的toString方法, 可以忽略
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
// object的hashCode方法, 可以忽略
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("proxy.v10.Movable").getMethod("move");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
Proxy.newProxyInstance中生成$Proxy0的核心代码是
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);
JDK动态代理的时序图
- 用了asm之后 , java才能被称之为"动态语言"
- 所谓动态语言, 就是在执行过程中, 动态的修改代码
- 反射只能获取代码, 不能修改原先代码的逻辑
- asm能直接操纵二进制
JDK动态代理相比静态代理的优点
被代理对象可以是Object的子类, 而不是某个接口 ( 比如Movable )
JDK动态代理的缺点
被代理对象必须实现接口
Java自带的Instrument
Instrument比asm还要强大, 直接操纵二进制码, 但是需要你理解每一个0和1是什么意思, 而asm是提供了可读的方法, 间接的帮助你实现操纵二进制码
由于专业性太强, 可以不必关注
其实说实话, asm虽然比instrument简单, 但也知道下就行了
CGLib ( Code Generation Library )
优点
被代理对象不需要实现接口, 见下面这行代码
enhancer.setSuperclass(Tank.class); // 在这里设置的是被代理类
完整的代码:
public class Main {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Tank.class); // 在这里设置的是被代理类
enhancer.setCallback(new TimeMethodInterceptor());
Tank tank = (Tank) enhancer.create();
tank.move();
}
}
class TimeMethodInterceptor implements MethodInterceptor {
// Object o 就是CGLib生成的动态代理类的一个实例
// Object o 在debug时看到的对象是cglib.Tank$$EnhancerByCGLIB$$18e13221@458ad742
// Method method 是 public void cglib.Tank.move()
// MethodProxy是cglib的一个类: net.sf.cglib.proxy.MethodProxy
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println(o.getClass().getSuperclass().getName());
System.out.println("before");
Object result = null;
result = methodProxy.invokeSuper(o, objects);
System.out.println("after");
return result;
}
}
class Tank {
public void move() {
System.out.println("Tank moving claclacla...");
try {
Thread.sleep(new Random().nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
CGLib底层用的也是asm ( JDK动态代理, Spring用的也都是asm )
但是用CGLib的时候, 被代理对象的类, 不能被final修饰
但是asm可以, asm可以在二进制文件中, 把final修饰符给去掉
CGLib动态代理容易踩的坑
- 无法代理final修饰的方法
CGLib和JDK动态代理对比
- JDK动态代理是实现了被代理对象的接口, CGLib是继承了被代理对象
- JDK和CGLib都是在运行期生成字节码, JDK是直接写Class字节码, CGLib使用ASM框架写Class字节码, CGLib代理实现更复杂, 生成代理类比JDK效率低(只是生成慢, 执行效率还是高的)
- JDK调用代理方法, 是通过反射机制调用, CGLib是通过FastClass机制直接调用方法, CGLib执行效率更高
Spring AOP
app_auto.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
<aop:aspectj-autoproxy/>
<bean id="tank" class="com.mashibing.dp.spring.v2.Tank"/>
<bean id="timeProxy" class="com.mashibing.dp.spring.v2.TimeProxy"/>
</beans>
Tank.java
public class Tank {
public void move() {
System.out.println("Tank moving claclacla...");
try {
Thread.sleep(new Random().nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
TankProxy.java
@Aspect
public class TimeProxy {
@Before("execution (void com.mashibing.dp.spring.v2.Tank.move())")
public void before() {
System.out.println("method start.." + System.currentTimeMillis());
}
@After("execution (void com.mashibing.dp.spring.v2.Tank.move())")
public void after() {
System.out.println("method stop.." + System.currentTimeMillis());
}
}
Main.java
public class Main {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("app_auto.xml");
Tank t = (Tank)context.getBean("tank");
t.move();
}
}
SpringAOP中的代理选择原则
- 当Bean有实现接口时, Spring就会用JDK动态代理
- 当Bean没有实现接口时, Spring选择CGLib
- Spring可以通过配置强制使用CGLib, 只需在Spring的配置文件中加入如下代码<aop:aspectj-autoproxy proxy-target-class=“true” />
代理模式的优点
- 代理模式能将代理对象与真实被调用的目标对象分离
- 一定程度上降低了系统的耦合程度, 易于扩展
- 代理可以起到保护目标对象的作用
- 增强目标对象的职责
代理模式的缺点
- 代理模式会造成系统设计中类的数目增加
- 在客户端和目标对象之间增加了一个代理对象, 会造成请求处理速度变慢
- 增加了系统的复杂度