上一章：[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);

		}

}