源码分析系列教程（01） - Spring核心总结（AOP篇）

public interface IUserDao {
  void save();
}
public class UserDao implements IUserDao {
  public void save() {
    System.out.println("已经保存数据...");
  }
}
//代理类
public class UserDaoProxy implements IUserDao {
  private IUserDao target;
  public UserDaoProxy(IUserDao iuserDao) {
    this.target = iuserDao;
  }
  public void save() {
    System.out.println("开启事物...");
    target.save();
    System.out.println("关闭事物...");
  }
}

1. 通过实现InvocationHandler接口创建自己的调用处理器 
   IvocationHandler handler = new InvocationHandlerImpl(…); 
2. 通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类
   Class clazz = Proxy.getProxyClass(classLoader,new Class[]{…}); 
3. 通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
   Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class}); 
4. 通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入
   Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));

// 每次生成动态代理类对象时,实现了InvocationHandler接口的调用处理器对象 
public class InvocationHandlerImpl implements InvocationHandler {
  private Object target;// 这其实业务实现类对象，用来调用具体的业务方法
  // 通过构造函数传入目标对象
  public InvocationHandlerImpl(Object target) {
    this.target = target;
  }
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Object result = null;
    System.out.println("调用开始处理");
    result = method.invoke(target, args);
    System.out.println("调用结束处理");
    return result;
  }
  public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException,
      IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    // 被代理对象
    IUserDao userDao = new UserDao();
    InvocationHandlerImpl invocationHandlerImpl = new InvocationHandlerImpl(userDao);
    ClassLoader loader = userDao.getClass().getClassLoader();
    Class<?>[] interfaces = userDao.getClass().getInterfaces();
    // 主要装载器、一组接口及调用处理动态代理实例
    IUserDao newProxyInstance = (IUserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
    newProxyInstance.save();
  }
}

public class CglibProxy implements MethodInterceptor {
  private Object targetObject;
  // 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理
  public Object getInstance(Object target) {
    // 设置需要创建子类的类
    this.targetObject = target;
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(target.getClass());
    enhancer.setCallback(this);
    return enhancer.create();
  }
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
    System.out.println("开启事务");
    Object result = proxy.invoke(targetObject, args);
    System.out.println("关闭事务");
    // 返回代理对象
    return result;
  }
  public static void main(String[] args) {
    CglibProxy cglibProxy = new CglibProxy();
    UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDao());
    userDao.save();
  }
}

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>  开启事务注解权限
@Aspect             指定一个类为切面类   
@Pointcut("execution(* com.ylw.service.UserService.add(..))")  指定切入点表达式
@Before("pointCut_()")        前置通知: 目标方法之前执行
@After("pointCut_()")       后置通知:目标方法之后执行（始终执行）
@AfterReturning("pointCut_()")     返回后通知: 执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()")     异常通知:  出现异常时候执行
@Around("pointCut_()")        环绕通知: 环绕目标方法执行

@Component
@Aspect
public class AopLog {
  // 前置通知
  @Before("execution(* com.ylw.service.UserService.add(..))")
  public void begin() {
    System.out.println("前置通知");
  }
  //
  // 后置通知
  @After("execution(* com.ylw.service.UserService.add(..))")
  public void commit() {
    System.out.println("后置通知");
  }
  // 运行通知
  @AfterReturning("execution(* com.ylw.service.UserService.add(..))")
  public void returning() {
    System.out.println("运行通知");
  }
  // 异常通知
  @AfterThrowing("execution(* com.ylw.service.UserService.add(..))")
  public void afterThrowing() {
    System.out.println("异常通知");
  }
  // 环绕通知
  @Around("execution(* com.ylw.service.UserService.add(..))")
  public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("环绕通知开始");
    proceedingJoinPoint.proceed();
    System.out.println("环绕通知结束");
  }
}

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
  <!-- dao 实例 -->
  <bean id="userService" class="com.ylw.service.UserService"></bean>
  <!-- 切面类 -->
  <bean id="aop" class="com.ylw.aop2.AopLog2"></bean>
  <!-- Aop配置 -->
  <aop:config>
    <!-- 定义一个切入点表达式： 拦截哪些方法 -->
    <aop:pointcut expression="execution(* com.ylw.service.UserService.*(..))"
      id="pt" />
    <!-- 切面 -->
    <aop:aspect ref="aop">
      <!-- 环绕通知 -->
      <aop:around method="around" pointcut-ref="pt" />
      <!-- 前置通知： 在目标方法调用前执行 -->
      <aop:before method="begin" pointcut-ref="pt" />
      <!-- 后置通知： -->
      <aop:after method="after" pointcut-ref="pt" />
      <!-- 返回后通知 -->
      <aop:after-returning method="afterReturning"
        pointcut-ref="pt" />
      <!-- 异常通知 -->
      <aop:after-throwing method="afterThrowing"
        pointcut-ref="pt" />
    </aop:aspect>
  </aop:config>
</beans>

public class AopLog2 {
  // 前置通知
  public void begin() {
    System.out.println("前置通知");
  }
  //
  // 后置通知
  public void commit() {
    System.out.println("后置通知");
  }
  // 运行通知
  public void returning() {
    System.out.println("运行通知");
  }
  // 异常通知
  public void afterThrowing() {
    System.out.println("异常通知");
  }
  // 环绕通知
  public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("环绕通知开始");
    proceedingJoinPoint.proceed();
    System.out.println("环绕通知结束");
  }
}

Jdbc代码：
Conn.setAutoCommite(false);  // 设置手动控制事务
Hibernate代码：
Session.beginTransaction();    // 开启一个事务

Jdbc技术：DataSourceTransactionManager
Hibernate技术：HibernateTransactionManager