上一章：[Spring+SpringMVC+Mybatis]框架学习笔记（三）：Spring实现JDBC
下一章：[Spring+SpringMVC+Mybatis]框架学习笔记（五）：SpringAOP_顾问

第4章 Spring实现AOP

4.1 AOP的概念

AOP: Aspect Oriented Programming 面向切面编程

AOP的实现可以把业务逻辑和系统级的服务进行隔离，使业务逻辑跟各个系统级服务的耦合度降低，提高系统的重用性和开发效率。

业务逻辑：某个类的某个方法本身要实现的功能。

系统级的服务：系统的日志、事务、权限验证

举例：六七十年代，村支书要通知一个事情，原来要一家一家逐个告诉他们；有了广播（AOP）以后，只需要用广播，大家就知道了。

4.2 AOP的实现

AOP底层实现的原理：动态代理

动态代理有两种方式：

• jdk动态代理（只能代理实现了接口的类）
• cglib动态代理（都可以） ----> 字节码生成器

4.3 AOP的一些专业术语

• 切面（Aspect）：交叉在各个业务逻辑中的系统服务，例如：安全验证、事务处理、日志记录等
• 织入（weaving）：将切面代码插入到目标对象的某个方法的过程，相当于jdk动态代理中的InvacationHandler接口方法的内容。
• 连接点（JointPoint）：理论上可以被切面织入的所有方法，例如addStudent(),delStudent()...通常所有方法都可以被称为连接点。
• 切入点（PointCut）: 实际上被切面织入的方法。
• 目标对象（target）：就是切入点所属的类，如：StudentService类
• 通知（Advice）：就是切面的实现，切面织入的目标对象，方法，时间点（方式执行前、后、前后、异常）以及内容。
• 顾问（Advisor）：就是通知的封装和延伸。可以将通知以更复杂的方式织入到某些方法中。

把前5个术语串联起来：

将切面织入到目标对象的连接点方法中，使连接点成为切入点。

4.4 Spring实现AOP的步骤

1）搭建SpringAOP开发环境需要引入的jar包；
aopalliance-1.0.jar
spring-aop-4.2.1.RELEASE.jar

2）实现通知

• 前置通知 implements org.springframework.aop.MethodBeforeAdvice
• 后置通知 implements org.springframework.aop.AfterReturningAdvice
• 环绕通知 implements org.aopalliance.intercept.MethodInterceptor
• 异常通知 implements org.springframework.aop.ThrowsAdvice

3）注册目标类

4）注册通知

5）注册代理生产器，并注入目标类和通知

ps：通知的注意点：

• 代理生产器配置时，目标类接口可以省略；
• 后置通知是在目标方法执行之后才执行，它可以得到目标方法的返回值，但是不能改变它；
• 环绕通知有在目标方法执行之前的代码，也有在目标方法执行之后的代码；可以得到目标方法的返回值，且可以改变它。

4.5 Spring实现AOP实例

4.5.1 目标类接口

package com.steven.spring.sysmgr.service;

import java.util.List;

import com.steven.spring.sysmgr.entity.Student;

public interface IStudentService {

public boolean addStudent(Student student);

public boolean delStudent(Integer studentId);

public boolean updateStudent(Student student);

public List<Student> getStudentList();
}

4.5.2 目标类

package com.steven.spring.sysmgr.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.steven.spring.sysmgr.entity.Student;
import com.steven.spring.sysmgr.service.IStudentService;

public class StudentService implements IStudentService{

@Override
public boolean addStudent(Student student) {
System.out.println("执行增加功能");
return true;
}

@Override
public boolean delStudent(Integer studentId) {
//模拟异常，在异常通知中使用
int i = 1 / 0;

System.out.println("执行删除功能");
return true;
}

@Override
public boolean updateStudent(Student student) {
System.out.println("执行修改功能");
return true;
}

@Override
public List<Student> getStudentList() {
System.out.println("执行增加功能");
return new ArrayList<Student>();
}

}

4.5.3 实现通知

a) 前置通知

package com.steven.spring.sysmgr.advice;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

/**
* 前置通知
* @author chenyang
*
*/
public class MyBeforeAdvice implements MethodBeforeAdvice {

@Override
public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
// TODO Auto-generated method stub
System.out.println("这是前置通知，应该在方法执行之前打印出来");
}

}

b) 后置通知

package com.steven.spring.sysmgr.advice;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

/**
* 后置通知
* @author chenyang
*
*/
public class MyAfterAdvice implements AfterReturningAdvice {
//该方法中的代码就是要织入到目标类方法的切面代码
@Override
public void afterReturning(Object returnValue, Method paraMethod,
Object[] paramArrayOfObject, Object target) throws Throwable {
System.out.println("方法执行的结果：" + returnValue);
System.out.println("这是后置通知，应该在方法执行之后打印出来");

}

}

c) 环绕通知

package com.steven.spring.sysmgr.advice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
* 环绕通知
* @author chenyang
*
*/
public class MyAroundAdvice implements MethodInterceptor {
// 环绕通知可以改变方法的返回值
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("这是环绕通知的前面执行部分");
Object result = invocation.proceed();
System.out.println("方法的执行结果是：" + result);
System.out.println("这是环绕通知的后面执行部分");
result = false;
return result;
}

}

d) 异常通知

package com.steven.spring.sysmgr.advice;

import org.springframework.aop.ThrowsAdvice;

/**
* 异常通知
* @author chenyang
*
*/
public class MyThrowingAdvice implements ThrowsAdvice {
public void afterThrowing(Exception e){
System.out.println("发生的异常：" + e);
}

}

4.5.4 配置文件：注册目标类、通知、代理生成器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!-- 注册目标类，并描述依赖关系 -->
<bean id="studentService" class="com.steven.spring.sysmgr.service.impl.StudentService"></bean>

<!-- 注册前置通知 -->
<bean id="beforeAdvice" class="com.steven.spring.sysmgr.advice.MyBeforeAdvice"></bean>

<!-- 注册后置通知 -->
<bean id="afterAdvice" class="com.steven.spring.sysmgr.advice.MyAfterAdvice"></bean>

<!-- 注册环绕通知 -->
<bean id="aroundAdvice" class="com.steven.spring.sysmgr.advice.MyAroundAdvice"></bean>

<!-- 注册异常通知 -->
<bean id="throwingAdvice" class="com.steven.spring.sysmgr.advice.MyThrowingAdvice"></bean>

<!-- 注册前置通知的代理生成器，注入目标类接口、目标类、通知 -->
<bean id="myBeforeProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="studentService"/>
<property name="interfaces" value="com.steven.spring.sysmgr.service.IStudentService"/>
<property name="interceptorNames" value="beforeAdvice"/>
</bean>

<!-- 注册后置通知的代理生成器，注入目标类、通知 -->
<bean id="myAfterProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="studentService"/>
<!-- 这里省略了目标类接口的实现类，因为系统能自己找到 -->
<property name="interceptorNames" value="afterAdvice"/>
</bean>

<!-- 注册环绕通知的代理生成器，注入目标类、通知 -->
<bean id="myAroundProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="studentService"/>
<property name="interceptorNames" value="aroundAdvice"/>
</bean>

<!-- 注册异常通知的代理生成器，注入目标类、通知 -->
<bean id="myThrowingProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="studentService"/>
<property name="interceptorNames" value="throwingAdvice"/>
</bean>

</beans>

ps:

教你什么时候用value，什么时候用ref？

ref是引用（指针），value是布尔、string等得值。

用ref还是value，需要看源码中这个name是什么类型。 全选name的引号中的值，alt + / , 若弹出的类的参数是对象，就用ref；若不是，就用value。

4.5.5 测试

package com.steven.spring.sysmgr.test;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.steven.spring.sysmgr.entity.Student;
import com.steven.spring.sysmgr.service.IStudentService;

/**
* 测试各种通知
* @author chenyang
*
*/
public class AdviceTest {
private ApplicationContext ac = null;

@Before
public void init(){
ac = new ClassPathXmlApplicationContext("applicationContext.xml");
}

//测试前置通知，预期目标：将前置通知打印的内容出现在目标方法内容的前面
@Test
public void testBeforeAdvice(){
IStudentService studentService = (IStudentService) ac.getBean("myBeforeProxy");
studentService.addStudent(new Student());
}

//测试后置通知
@Test
public void testAfterAdvice(){
IStudentService studentService = (IStudentService) ac.getBean("myAfterProxy");
studentService.addStudent(new Student());
}

//测试环绕通知
@Test
public void testAroundAdvice(){
IStudentService studentService = (IStudentService) ac.getBean("myAroundProxy");
studentService.addStudent(new Student());
}

//测试异常通知
@Test
public void testThrowingAdvice(){
IStudentService studentService = (IStudentService) ac.getBean("myThrowingProxy");
studentService.delStudent(1);
}
}

上一章：[Spring+SpringMVC+Mybatis]框架学习笔记（三）：Spring实现JDBC
下一章：[Spring+SpringMVC+Mybatis]框架学习笔记（五）：SpringAOP_顾问