Spring事务Transactional和动态代理（一）-JDK代理实现
骑着龙的羊 人气:0
系列文章索引：
1. [Spring事务Transactional和动态代理（一）-JDK代理实现](http://www.itrensheng.com/archives/spring_transaction_jdk_proxy)
2. [Spring事务Transactional和动态代理（二）-cglib动态代理](Spring事务Transactional和动态代理（一）-JDK代理实现)
3. [Spring事务Transactional和动态代理（三）-事务失效的场景](http://www.itrensheng.com/archives/spring_transactional_uneffect)
### 什么是代理
理设计模式提供了对目标对象的间接访问方式，能力模式能够解耦合并且便于扩展目标的功能。
在现实生活这，我们消费者如果要去购买一杯牛奶的时候，并不是直接去找牛奶厂商购买，而是在便利店或者超市购买（零售商）；超市进货的时候也通常不是直接找牛奶厂商，而是找市级代理（渠道经销商），市级代理再找省级代理（代理商），省级代理从牛奶生产商（厂商）提货。
如下图，虽然通过层层代理，一杯牛奶的价格会有增加，但是用户省却了时间（用户不能跑到内蒙去买牛奶）。
### 静态代理
静态代理的实现比较简单，代理类通过实现与目标对象相同的接口，并在类中维护一个代理对象。通过构造器塞入目标对象，赋值给代理对象，进而执行代理对象实现的接口方法
```java
public interface Person {
void eat();
}
public class Child implements Person {
@Override
public void eat() {
System.out.println("A Child eats something");
}
}
public class StaticProxyDemo {
public static void main(String[] args) {
Person person = new Child();
person.eat();
}
}
```
代理类如下：
```java
public class PersonProxy {
private Person person;
public PersonProxy(Person person){
this.person = person;
}
private void beforeExecute(){
System.out.println("before");
}
public void execute(){
beforeExecute();
person.eat();
afterExecute();
}
private void afterExecute(){
System.out.println("after");
}
public static void main(String[] args) {
PersonProxy personProxy = new PersonProxy(new Child());
personProxy.execute();
}
}
```
#### 静态代理的优点：
这样可以通过PersonProxy来操作目标对象Person，且在不修改Person对象的条件下能够对目标对象进行beforeExecute()和afterExecute()的拦截操作，这样就达到了解耦合和扩展目标对象的功能。
#### 静态代理的缺点：
因为代理对象，需要实现与目标对象一样的接口，会导致代理类十分繁多，不易维护，同时一旦接口增加方法，则目标对象和代理类都需要维护。
### 动态代理的实现
JDK的动态代理是基于java.lang.reflect.Proxy实现的InvocationHandler接口
增加Proxy对象，需要实现InvocationHandler，可以看到DynamicPersonProxy类并没有实现Person接口或者继承Person接口的子类,DynamicPersonProxy类是完全与Person松耦合
```java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynamicPersonProxy implements InvocationHandler {
private Object target;
public DynamicPersonProxy(Object target){
this.target = target;
}
public T getProxy(){
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
private void beforeInvoke(){
System.out.println("before");
}
private void afterInvoke(){
System.out.println("after");
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
beforeInvoke();
Object result = method.invoke(target,args);
afterInvoke();
return result;
}
}
```
测试类如下：
```java
public class DynamicProxyTest{
public static void main(String[] args) {
// System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
Person person = new Child();
DynamicPersonProxy dynamicPersonProxy = new DynamicPersonProxy(person);
Person proxyPerson = (Person) dynamicPersonProxy.getProxy();
proxyPerson.eat();
}
}
//输出如下：
before
A Child eats something
after
```
#### 动态代理的优点：
代理对象无需实现接口，接口增加方法也就无需再修改代理对象
#### 动态代理的缺点：
目标对象一定要实现接口，**否则无法使用JDK动态代理**
### 动态代理的原理
动态代理的核心流程是：
1. 为接口创建代理类的字节码文件
2. 使用ClassLoader将字节码文件加载到JVM
3. 创建代理类实例对象
4. 执行对象的目标方法
#### JDK Proxy源码分析
下面从源码的角度来看一下动态代理的实现原理
核心方法Proxy.newProxyInstance源码如下：
```java
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
//InvocationHandler不能为空
Objects.requireNonNull(h);
//clone接口
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//首先从缓存查找是否有代理类，没有就生成一个
Class<?> cl = getProxyClass0(loader, intfs);
/*
* 通过InvocationHandler调用目标类的构造函数
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
//constructorParams是指指定代理类的构造函数类型
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
//如果构造函数不是public修饰，修改
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
```
其中查找Proxy类的源码如下：
```java
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
//长度检查
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//调用了下面的WeakCache.get(K key, P parameter)方法，loader作为key，interfaces作为parameter参数
//定义如下：proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory())
return proxyClassCache.get(loader, interfaces);
}
//首先当前key（也就是上面的ClassLoader）已经加载存在，就直接从缓存中返回
//如果不存在，就会通过ProxyClassFactory来创建代理对象
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
expungeStaleEntries();
//根据key的hash值和一个ReferenceQueue来构造
Object cacheKey = CacheKey.valueOf(key, refQueue);
// 从map中取出cacheKey的值
ConcurrentMap> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
ConcurrentMap> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
Supplier supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) {
if (supplier != null) {
// supplier可能是Factory或者CacheValue
V value = supplier.get();
if (value != null) {
return value;
}
}
// 缓存中没有supplier，同时supplier中没有
// 懒加载的方式创建一个Factory
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// 安装 Factory
supplier = factory;
}
} else {
if (valuesMap.replace(subKey, supplier, factory)) {
supplier = factory;
} else {
supplier = valuesMap.get(subKey);
}
}
}
}
```
再看一下上面提到的ProxyClassFactory是一个 工厂方法，是一个静态final类，实现了BiFunction接口，其中只有一个apply方法
```java
//类定义
private static final class ProxyClassFactory
implements BiFunction[], Class<?>>{
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
/*
* 校验当前类加载器ClassLoader解析到的名称和定义的名称是否相同
*/
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
/*
* 校验是否是接口类型，这也就是为什么JDK动态代理只能基于接口
*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
/*
* 防重
*/
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
// 代理对象的目录
String proxyPkg = null;
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
.....
/*
* 生成指定Proxy代理对象的字节码
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
//调用的native方法
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
* 生成的代理类有bug
*/
throw new IllegalArgumentException(e.toString());
}
}
}
```
#### Proxy代理字节码生成分析
去掉DynamicProxyTest类中的注释
```java
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
```
这样就可以看到JDK生成的class文件。所生成的$Proxy0特性如下：
1. 继承了Proxy，实现了目标接口Person。因为Java不允许多重继承，这就限制了：使用JDK代理不能是普通类或者抽象类，只能是接口类型
2. 只有一个InvocationHandler参数的构造函数，所以代理类必须继承InvocationHandler接口
3. 生成了同名的eat()方法，且调用了InvocationHandler的invoke方法
4. 使用静态代码块初始化Object类的equals，toString和hashCode方法，还有Person接口的eat方法
如上示例反编译所生成的class文件内容如下：
```java
package com.sun.proxy;
import com.randy.dynamicproxy.jdk.interfaces.Person;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements Person {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
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);
}
}
public final void eat() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
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);
}
}
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("com.randy.dynamicproxy.jdk.interfaces.Person").getMethod("eat");
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());
}
}
}
```
加载全部内容