本文通过JDK动态代理实现Spring切面的增删改查操作中的日志记录和数据库事务管理，展示了如何在方法执行前后添加自定义逻辑。
引子
JDK动态代理是最简单的一种动态代理。
但简单必然是有弊端的，就是所要代理的类必须要实现接口！！！就是没有实现接口的类不能创建 JDK 动态代理！
我们知道：写代码最重要是实践，先要有一个观感，然后再研究原理，不然不接地气。而平常最常见的代理模式就是 spring 的切面，这里我们通过 JDK 动态代理的方式实现两个切面逻辑：打印日志、数据库事务。
实战
实现普通的增删改查
为了演示切面逻辑，首先要写一段常见的业务逻辑：用户的增删改查（接口及其实现类）。然后我们要对这个增删改查的每个方法实现切面逻辑：及在方法执行前打印日志和开启事务，再方法执行完成后提交事务然后打印日志。
public interface UserService {
void add(String name);
void delete(Long id);
void update(Long id, String name);
String query(Long id);
}
public class UserServiceImpl implements UserService {
@Override
public void add(String name) {
System.out.println("新增用户：" + name);
}
@Override
public void delete(Long id) {
System.out.println("删除用户：" + id);
}
@Override
public void update(Long id, String name) {
System.out.println("修改id=" + id + "的用户名为：" + name);
}
@Override
public String query(Long id) {
return "查询id=" + id + "的用户名";
}
}
实现数据库事务切面
首先我们实现在每一个方法被调用时开启事务、在方法结束时提交事务：实现一个实现InvocationHandler的处理类。
在这个类中我们保存了原始的被代理对象originObj，在invoke(Object proxy, Method method, Object[] args)方法中，通过反射调用了originObj对应的方法（怎么调用的，谁调用的下面原理部分解释）。再调用originObj的方法的前后写入我们要实现的增强逻辑（即事务处理逻辑，这里简化了使用文字描述一下）
public class TransactionHandler implements InvocationHandler {
private final Object originObj;
public TransactionHandler(Object originObj) {
this.originObj = originObj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("事务开始");
Object result = method.invoke(originObj, args);
System.out.println("事务结束，提交并关闭事务！");
return result;
}
}
然后创建一个工厂类，方便创建代理对象（不写也行，但是要对同一个对象对多重代理时就会比较麻烦，到处写会很乱，下面会说到）：
public class AOPHelper {
public static <T> T create(T obj){
ClassLoader classLoader = obj.getClass().getClassLoader();
Class<?>[] interfaces = obj.getClass().getInterfaces();
return (T) Proxy.newProxyInstance(classLoader,
interfaces, new TransactionHandler(obj));
}
}
小小的测试一下
最后是开始使用（测试）
UserService origin = new UserServiceImpl();
UserService proxyInstance = AOPHelper.create(origin);
proxyInstance.add("小红");
输出为：
事务开始
保存用户：小红
事务结束，提交并关闭事务！
我们看到，在调用方法的开头和结尾都分别调用了我们的事务逻辑！
实现日志切面
实现了数据库事务切面后，再实现日志切面就非常简单了！
public class LogHandler implements InvocationHandler {
private final Object originObj;
public LogHandler(Object originObj) {
this.originObj = originObj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用前打印日志");
Object result = method.invoke(originObj, args);
System.out.println("调用后打印日志");
return result;
}
}
然后修改一下 AOPHelper工厂类：
public static <T> T create(T obj){
ClassLoader classLoader = obj.getClass().getClassLoader();
Class<?>[] interfaces = obj.getClass().getInterfaces();
Object transactionProxyObj = Proxy.newProxyInstance(classLoader,
interfaces, new TransactionHandler(obj));
return (T) Proxy.newProxyInstance(classLoader, interfaces, new LogHandler(transactionProxyObj));
}
这里看到，我们只不过是在创建完数据库事务代理对象后，再包裹一层日志的逻辑而已！
测试的代码不需要改，这就是工厂类的好处，封装了创建过程！直接看输出：
调用前打印日志
事务开始
保存用户：小红
事务结束，提交并关闭事务！
调用后打印日志
原理
talk is cheap! show me the code!
最好理解 java 动态代理的方式是直接看生成的代理对象代码，先复制过来：
public final class $Proxy0 extends Proxy implements UserService {
private static Method m1;
private static Method m6;
private static Method m2;
private static Method m3;
private static Method m4;
private static Method m5;
private static Method m0;
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m6 = Class.forName("com.proxy.UserService").getMethod("query", Class.forName("java.lang.Long"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.proxy.UserService").getMethod("add", Class.forName("java.lang.String"));
m4 = Class.forName("com.proxy.UserService").getMethod("update", Class.forName("java.lang.Long"), Class.forName("java.lang.String"));
m5 = Class.forName("com.proxy.UserService").getMethod("delete", Class.forName("java.lang.Long"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final String query(Long var1) throws {
try {
return (String)super.h.invoke(this, m6, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void add(String var1) throws {
try {
super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void update(Long var1, String var2) throws {
try {
super.h.invoke(this, m4, new Object[]{var1, var2});
} catch (RuntimeException | Error var4) {
throw var4;
} catch (Throwable var5) {
throw new UndeclaredThrowableException(var5);
}
}
public final void delete(Long var1) throws {
try {
super.h.invoke(this, m5, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
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);
}
}
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 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);
}
}
}
看完懂了吗？逻辑非常简单，其实就是在运行时通过动态生成字节码，创建一个UserService 的子类，然后在每个方法里调用你写的 InvocationHandler 方法！
ok，是不是很有感觉，会用 JDK 动态代理了吧！！！
扫一扫
282
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
