一、案例分析
1、引出问题
回到Spring之初控制事务繁琐的问题。 回到Spring之初控制事务繁琐的问题.
考虑一个应用场景∶需要对系统中的某些业务方法做事务管理，拿简单的save和update操作举例。没有加上事务控制的代码如下。
加上事务代码，如下：
上述问题︰在我们的业务层中每一个业务方法都得处理事务(繁琐的try-catch)。
在设计上存在两个很严重问题︰ 上述问题:在我们的业务层中每一个业务方法都得处理事务(繁琐的尝试-捕捉)。在设计上存在两个很严重问题：
① 责任不分离.业务方法只需要关心如何完成该业务功能,不需要去关系事务管理/日志管理/权限管理等等。
② 代码结构重复.在开发中不要重复代码,重复就意味着维护成本增大。
2、房屋租赁的启示
通过中介，房东就可以免去一系列繁琐的东西，只管收租就好了
二、静态代理
1、代理实现
代理模式︰客户端直接使用的都是代理对象，不知道真实对象是谁，此时代理对象可以在客户端和真实对象之间起到中介的作用。
1、代理对象完全包含真实对象，客户端使用的都是代理对象的方法，和真实对象没有直接关系;
2、代理模式的职责︰把不是真实对象该做的事情从真实对象上撇开——职责清晰;
静态代理∶在程序运行前就已经存在代理类的字节码文件，代理对象和真实对象的关系在运行前就确定了。
EmployeeServiceProxy 代码：
//静态代理类
public class EmployeeServiceProxy implements IEmployeeService {
private IEmployeeService target;//真实对象/委托对象
private TransactionManager txManager;//事务管理器
public void setTarget(IEmployeeService target) {
this.target = target;
}
public void setTxManager(TransactionManager txManager) {
this.txManager = txManager;
}
public void save(Employee emp) {
txManager.begin();
try {
target.save(emp);
txManager.commit();
} catch (Exception e) {
e.printStackTrace();
txManager.rollback();
}
}
}XML如下
<bean id="employeeDAO" class="cn.wolfcode.dao.impl.EmployeeDAOImpl" />
<bean id="transactionManager" class="cn.wolfcode.tx.TransactionManager" />
<!-- 代理对象 -->
<bean id="employeeServiceProxy" class="cn.wolfcode.proxy.EmployeeServiceProxy">
<property name="txManager" ref="transactionManager" />
<property name="target">
<bean class="cn.wolfcode.service.EmployeeServiceImpl">
<property name="dao" ref="employeeDAO" />
</bean>
</property>
</bean>调用
@Test
void testSave() throws Exception {
System.out.println(service.getClass());//查看对象的真实类型
service.save(new Employee());
}2、问题分析
静态代理∶在程序运行前就已经存在代理类的字节码文件，代理对象和真实对象的关系在运行前就确定了。
优点︰
① 业务类只需要关注业务逻辑本身，保证了业务类的重用性。
② 把真实对象隐藏起来了,保护真实对象
缺点︰
① 代理对象的某个接口只服务于某一种类型的对象，也就是说每一个真实对象都得创建一个代理对象。
② 如果需要代理的方法很多，则要为每一种方法都进行代理处理。
③ 如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。
三、动态代理
代理模式︰客户端直接使用的都是代理对象，不知道真实对象是谁，此时代理对象可以在客户端和真实对象之间起到中介的作用。
1、代理对象完全包含真实对象，客户端使用的都是代理对象的方法，和真实对象没有直接关系;
2、代理模式的职责:把不是真实对象该做的事情从真实对象上撇开——职责清晰;
静态代理∶在程序运行前就已经存在代理类的字节码文件，代理对象和真实对象的关系在运行前就确定了。
动态代理∶动态代理类是在程序运行期间由JVM通过反射等机制动态的生成的，所以不存在代理类的字节码文件，代理对象和真实对象的关系是在程序运行时期才确定的。
如何实现动态代理∶
1)︰针对有接口∶使用JDK动态代理
2)∶针对无接口∶使用CGLIB或Javassist组件
1、字节码动态加载
Java运行原理和字节码加载过程:
如何动态的加载一份字节码︰
由于JVM通过字节码的二进制信息加载类的，如果我们在运行期系统中，遵循Java编译系统组织.class文件的格式和结构，生成相应的二进制数据，然后再把这个二进制数据加载转换成对应的类,如此，就完成了在代码中动态创建一个类的能力了。
2、JDK动态代理
JDK动态代理API分析:(必须要求真实对象是有接口)
1） java.lang.reflect.Proxy类:Java动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。
主要方法∶
public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler handler)
方法职责∶为指定类加载器、一组接口及调用处理器生成动态代理类实例
loader：类加载器，一般传递真实对象的类加载器
interfaces：代理类需要实现的接口
hanlder：代理对象如何做增强
2）java.lang.reflect.InvocationHandler接口:
public Object invoke(Object proxy, Method method, Object[] args)方法职责︰负责集中处理动态代理类上的所有方法调用参数:
proxy :生成的代理对象
method :当前调用的真实方法对象
args:当前调用方法的实参返回:真实方法的返回结果
jdk动态代理操作步骤∶
①实现InvocationHandler接口，创建自己增强代码的处理器。
②给Proxy类提供ClassLoader对象和代理接口类型数组，创建动态代理对象。
③在处理器中实现增强操作。
Java代码：
//事务的增强操作
public class TransactionManagerAdvice implements java.lang.reflect.InvocationHandler {
private Object target;//真实对象(对谁做增强)
private TransactionManager txManager;//事务管理器(模拟)
public void setTxManager(TransactionManager txManager) {
this.txManager = txManager;
}
public void setTarget(Object target) {
this.target = target;
}
//创建一个代理对象
public <T> T getProxyObject() {
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), //类加载器,一般跟上真实对象的类加载器
target.getClass().getInterfaces(), //真实对象所实现的接口(JDK动态代理必须要求真实对象有接口)
this);//如何做事务增强的对象
}
//如何为真实对象的方法做增强的具体操作
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getName().startsWith("get") || method.getName().startsWith("list")) {
return method.invoke(target, args);//放行
}
Object ret = null;
txManager.begin();
try {
//---------------------------------------------------------------
ret = method.invoke(target, args);//调用真实对象的方法
//---------------------------------------------------------------
txManager.commit();
} catch (Exception e) {
e.printStackTrace();
txManager.rollback();
}
return ret;
}
}3、JDK动态代理原理
通过DynamicProxyClassGenerator生成动态代理的字节码，再通过反编译工具查看。
生成动态代理字节码。
public class DynamicProxyClassGenerator {
public static void main(String[] args) throws Exception {
generateClassFile(EmployeeServiceImpl.class, "EmployeeServiceProxy");
}
//生成代理类的字节码文件-->Java反编译工具-->Java文件
public static void generateClassFile(Class targetClass, String proxyName) throws Exception {
//根据类信息和提供的代理类名称，生成字节码
byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, targetClass.getInterfaces());
String path = targetClass.getResource(".").getPath();
System.out.println(path);
FileOutputStream out = null;
//保留到硬盘中
out = new FileOutputStream(path + proxyName + ".class");
out.write(classFile);
out.close();
}
}生成后代码（整理过）
public final class EmployeeServiceProxy extends Proxy implements IEmployeeService {
private static Method method_equals;
private static Method method_toString;
private static Method method_hashCode;
private static Method method_update;
private static Method method_save;
public EmployeeServiceProxy(InvocationHandler paramInvocationHandler) {
super(paramInvocationHandler);
}
static {
try {
method_equals = Class.forName("java.lang.Object").getMethod("equals",new Class[] { Class.forName("java.lang.Object") });
method_toString = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
method_hashCode = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
method_update = Class.forName("cn.wolfcode.service.IEmployeeService").getMethod("update",new Class[] { Class.forName("cn.wolfcode.domain.Employee") });
method_save = Class.forName("cn.wolfcode.service.IEmployeeService").getMethod("save",new Class[] { Class.forName("cn.wolfcode.domain.Employee") });
} catch (Exception e) {
}
}
public final boolean equals(Object paramObject) {
try {
return ((Boolean) this.h.invoke(this, method_equals, new Object[] { paramObject })).booleanValue();
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String toString() {
try {
return (String) this.h.invoke(this, method_toString, null);
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int hashCode() {
try {
return ((Integer) this.h.invoke(this, method_hashCode, null)).intValue();
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final void save(Employee paramEmployee) {
try {
this.h.invoke(this, method_save, new Object[] { paramEmployee });
return;
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
public final void update(Employee paramEmployee) {
try {
this.h.invoke(this, method_update, new Object[] { paramEmployee });
return;
} catch (Error | RuntimeException localError) {
throw localError;
} catch (Throwable localThrowable) {
throw new UndeclaredThrowableException(localThrowable);
}
}
}原理一图胜千言
观察: save方法，发现底层其实依然在执行InvocationHandler中的invoke方法。
注意：在增强的方法里面调用toString会导致死循环（原理看生成的代理类源码）
4、CGLIB动态代理
使用JDK的动态代理，只能针对于目标对象存在接口的情况，如果目标对象没有接口，此时可以考虑使用CGLIB 的动态代理方式。
Java 代码︰
//事务的增强操作-CGLIB
public class TransactionManagerAdvice implements org.springframework.cglib.proxy.InvocationHandler {
private Object target;//真实对象(对谁做增强)
private TransactionManager txManager;//事务管理器(模拟)
public void setTxManager(TransactionManager txManager) {
this.txManager = txManager;
}
public void setTarget(Object target) {
this.target = target;
}
//创建一个代理对象
public <T> T getProxyObject() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());//将继承于哪一个类,去做增强
enhancer.setCallback(this);//设置增强的对象
return (T) enhancer.create();//创建代理对象
}
//如何为真实对象的方法做增强的具体操作
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object ret = null;
txManager.begin();
try {
//---------------------------------------------------------------
ret = method.invoke(target, args);//调用真实对象的方法
//---------------------------------------------------------------
txManager.commit();
} catch (Exception e) {
e.printStackTrace();
txManager.rollback();
}
return ret;
}
}4、CGLIB动态代理原理
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"C:/test");
CGLIB生成的动态代理字节码文件，阅读比较复杂，不容易读，我们见到看一下，下面是经过优化处理的代码。
观察∶可以看出CGLIB是通过生成代理类，然后继承于目标类，再对目标类中可以继承的方法做覆盖，并在该方法中做功能增强的，因为多态的关系，实则调用的是子类中的方法。
四、动态代理总结
1、JDK动态代理总结︰
① JAVA动态代理是使用java.lang.reflect包中的Proxy类与InvocationHandler接口这两个来完成的。
② 要使用JDK动态代理，委托必须要定义接口。
③ JDK动态代理将会拦截所有pubic的方法（因为只能调用接口中定义的方法），这样即使在接口中增加了新的方法，不用修改代码也会被拦截。
④ 动态代理的最小单位是类(所有类中的方法都会被处理)，如果只想拦截一部分方法，可以在invoke方法中对要执行的方法名进行判断。
2、CGLIB代理总结∶
① CGLIB可以生成委托类的子类，并重写父类非final修饰符的方法。
② 要求类不能是final的，要拦截的方法要是非final、非static、非private的。
③ 动态代理的最小单位是类(所有类中的方法都会被处理);
备注：如果想深入彻底理解底层代码，可以在评论区发获取动态代理原理解刨资料哦
255
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
