[TOC] 先写个接口 ~~~ package service; public interface UserService { void save(); void delete(); void update(); void find(); } ~~~ 再写接口的实现类 ~~~ package service; public class UserServiceImpl implements UserService { @Override public void save() { System.out.println("保存用户"); } @Override public void delete() { System.out.println("删除用户"); } @Override public void update() { System.out.println("更新用户"); } @Override public void find() { System.out.println("查找用户"); } } ~~~ aop实现 ~~~ package proxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import service.UserService; import service.UserServiceImpl; public class UserServiceProxyFactory implements InvocationHandler { /** * 代理的目标对象 */ private Object targetObject; public UserServiceProxyFactory(Object targetObject) { super(); // 必须要这个对象,因为method.invoke要用 this.targetObject = targetObject; } /** * 获得代理对象 */ public Object getObjectProxy() { /** * 生成动态代理 * 第一个参数设置代码使用的类装载器，一般采用跟目标类相同的类装载器 * 第二个参数把被代理对象实现的接口给他 * 第三个参数设置回调对象，当代理对象的方法被调用时，会委派给该参数指定对象的invoke方法 */ ClassLoader classLoader = UserServiceProxyFactory.class.getClassLoader(); Class<?>[] interfaces = UserServiceImpl.class.getInterfaces(); return Proxy.newProxyInstance(classLoader, interfaces, this); } /** * 第一个参数,会把当前代理对象传给你 * 第二个参数,当前执行的方法传给你 * 第三个参数,当前方法的参数传给你 */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 前置增强的 System.out.println("打开事务"); // 本来的方法 Object invoke = method.invoke(targetObject, args); // 后置增强 System.out.println("提交事务"); return invoke; } } ~~~ 测试下 ~~~ @Test public void index() { UserService us = new UserServiceImpl(); UserServiceProxyFactory factory = new UserServiceProxyFactory(us); UserService usProxy = (UserService) factory.getObjectProxy(); usProxy.save(); } ~~~