一、案例分析

 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的。

③ 动态代理的最小单位是类(所有类中的方法都会被处理);
 

备注：如果想深入彻底理解底层代码，可以在评论区发获取动态代理原理解刨资料哦