Spring-AOP入门

Spring-AOP入门

入门概述

    在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

    将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

    从最开始的面向机器编程到面向过程编程到面向对象对象编程直至现在的面向切面编程可以看出，随着计算机软件的不断发展，其越来越符合人的思维习惯，同样的代码量所能实现的功能也越来越多。而AOP则是在不增业务逻辑的代码上，增加新功能。而AOP一般用于框架开发。在实际项目中，使用AOP也是一个趋势。

 

AOP初步原理图

PS：通过上图，可以看出，AOP(面向切面编程)就是在某一服务执行时，插入特定功能代码。而且这一特定功能代码，可以同时对应于多个服务。

 

AOP详细原理及案例

AOP详细原理图

案例：AOP开发步骤

1、定义接口

package com.pc.aop;
/**
 * 
 * @author Switch
 * @function 测试服务接口
 * @description
 *
 */
public interface TestServiceInter {
	public void printOk();
}

package com.pc.aop;
/**
 * 
 * @author Switch
 * @function 测试服务接口2
 * @description
 *
 */
public interface TestServiceInter2 {
	public void printOk2();
}

2、编写对象(被代理对象=目标对象)

package com.pc.aop;
/**
 * 
 * @author Switch
 * @function 测试服务1
 * @description
 *
 */
public class Test1Service implements TestServiceInter,TestServiceInter2{
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public void printOk() {
		System.out.println(name + " Print Ok");
	}
	@Override
	public void printOk2() {
		System.out.println(name + " Print Ok2");
	}
}

3、编写通知(有前置通知、后置通知、环绕通知、异常通知、引入通知五种)

package com.pc.aop;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
/**
 * 
 * @author Switch
 * @function 我的前置通知类
 * @description
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
	@Override
	/**
	 * 在一个给定的方法前被回调
	 * method:被调用方法名字
	 * args:给method传递的参数
	 * target:目标对象
	 */
	public void before(Method method, Object[] args, Object target)
			throws Throwable {
		System.out.println("记录日志..." + method.getName());
	}
}

4、配置beans.xml(Spring配置文件)

<?xml version="1.0" encoding="utf-8"?>
<beans 
	xmlns="http://www.springframework.org/schema/beans"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xmlns:context="http://www.springframework.org/schema/context"
 	xmlns:tx="http://www.springframework.org/schema/tx"
 	xsi:schemaLocation="
 		http://www.springframework.org/schema/beans 
 		http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    	http://www.springframework.org/schema/context 
    	http://www.springframework.org/schema/context/spring-context-2.5.xsd
    	http://www.springframework.org/schema/tx 
    	http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
	<!-- 在容器文件中配置bean(service/dao/domain/action/数据源) -->
</beans>

4.1、配置被代理对象(目标对象)

	<!-- 配置被代理的对象 -->
	<bean id="test1Service" class="com.pc.aop.Test1Service">

4.2、配置通知

	<!-- 配置前置通知 -->
	<bean id="myMethodBeforeAdvice" class="com.pc.aop.MyMethodBeforeAdvice" />

4.3、配置代理对象，是ProxyFactoryBean的对象实例

    <!-- 配置代理对象 -->
	<!-- 猜测底层实现使用代理模式，在某一接口被调用的方法上下文插入语句或方法。推测是另外有一个方法，调用这些东西 -->
	<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
	</bean>

4.3.1、配置代理接口集

        <!-- 配置代理接口集 -->
		<property name="proxyInterfaces">
			<list>
				<value>com.pc.aop.TestServiceInter</value>
				<value>com.pc.aop.TestServiceInter2</value>
			</list>
		</property>

4.3.2、织入通知

		<!-- 把通知织入到代理对象 -->
		<property name="interceptorNames">
			<list>
				<!-- 相当于把myMethodBeforeAdvice前置通知和代理对象关联，也可以把通知看做是拦截器 -->
				<value>myMethodBeforeAdvice</value>
			</list>
		</property>

4.3.3、配置被代理对象

        <!-- 配置被代理对象，可以指定 -->
	<property name="target" ref="test1Service"/>

4.4、完整Spring配置文件

<?xml version="1.0" encoding="utf-8"?>
<beans 
	xmlns="http://www.springframework.org/schema/beans"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xmlns:context="http://www.springframework.org/schema/context"
 	xmlns:tx="http://www.springframework.org/schema/tx"
 	xsi:schemaLocation="
 		http://www.springframework.org/schema/beans 
 		http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    	http://www.springframework.org/schema/context 
    	http://www.springframework.org/schema/context/spring-context-2.5.xsd
    	http://www.springframework.org/schema/tx 
    	http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
	<!-- 在容器文件中配置bean(service/dao/domain/action/数据源) -->
	<!-- 配置被代理的对象 -->
	<bean id="test1Service" class="com.pc.aop.Test1Service">
		<property name="name" value="张三" />
	</bean>
	
	<!-- 配置前置通知 -->
	<bean id="myMethodBeforeAdvice" class="com.pc.aop.MyMethodBeforeAdvice" />
		
	<!-- 配置代理对象 -->
	<!-- 猜测底层实现使用代理模式，在某一接口被调用的方法上下文插入语句或方法。推测是另外有一个方法，调用这些东西 -->
	<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 配置代理接口集 -->
		<property name="proxyInterfaces">
			<list>
				<value>com.pc.aop.TestServiceInter</value>
				<value>com.pc.aop.TestServiceInter2</value>
			</list>
		</property>
		<!-- 把通知织入到代理对象 -->
		<property name="interceptorNames">
			<list>
				<!-- 相当于把myMethodBeforeAdvice前置通知和代理对象关联，也可以把通知看做是拦截器 -->
				<value>myMethodBeforeAdvice</value>
			</list>
		</property>
		<!-- 配置被代理对象，可以指定 -->
		<property name="target" ref="test1Service"/>
	</bean>
</beans>

AOP术语

1、切面(aspect)：要实现的交叉功能，是系统模块化的一个切面或领域。如日志记录。

2、连接点：应用程序执行过程中插入切面的地点，可以是方法调用，异常抛出，或者要修改的字段。

3、通知：切面的实际实现，它通知系统新的行为。如在日志通知包含了实现日志功能的代码，如向日志文件写日志。通知在连接点插入到应用系统中。

4、切入点：定义了通知应该应用在哪些连接点，通知可以应用到AOP框架支持的任何连接点。

5、引入：为类添加新方法和属性。

6、目标对象：被通知的对象。既可以是自己编写的类也可以是第三方类。

7、代理：将通知应用到目标对象后创建的对象，应用系统的其他部分不用为了支持代理对象而改变。

8、织入：将切面应用到目标对象从而创建一个新代理对象的过程。织入发生在目标对象生命周期的多个点上：

    编译期：切面在目标对象编译时织入。这需要一个特殊的编译器。

    类装载期：切面在目标对象被载入JVM时织入。这需要一个特殊的类载入器。

    运行期：切面在应用系统运行时织入。不需要特殊的编译器。

PS：spring只支持方法连接点，不提供属性接入点，spring的观点是属性拦截破坏了封装。面向对象的概念是对象自己处理工作，其他对象只能通过方法调用的得到的结果。

 

Spring的两种代理方式

1、若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。该类让spring动态产生一个新类，它实现了所需的接口，织入了通知，并且代理对目标对象的所有请求。

2、若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。使用该方式时需要注意:

    1、对接口创建代理优于对类创建代理，因为会产生更加松耦合的系统。对类代理是让遗留系统或无法实现接口的第三方类库同样可以得到通知，这种方式应该是备用方案。

    2、标记为final的方法不能够被通知。spring是为目标类产生子类。任何需要被通知的方法都被复写，将通知织入。final方法是不允许重写的。

PS：也就是说通过代理对象去实现AOP时，获得的ProxyFactoryBean的类型，在目标对象实现接口时，使用的是JDK的动态代理技术。如果目标对象没有实现接口，则使用CGLIB技术。

 

 

通知

通知类型	接口	描述
Around	org.aopalliance.intercept.MethodInterceptor	拦截对目标方法调用
Before	org.springframework.aop.MethodBeforeAdvice	在目标方法调用前调用
After	org.springframework.aop.AfterReturningAdvice	在目标方法调用后调用
Throws	org.springframework.aop.ThrowsAdvice	当目标方法抛出异常时调用

 

1、前置通知

package com.pc.aop;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
/**
 * 
 * @author Switch
 * @function 我的前置通知类
 * @description
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
	@Override
	/**
	 * 在一个给定的方法前被回调
	 * method:被调用方法名字
	 * args:给method传递的参数
	 * target:目标对象
	 */
	public void before(Method method, Object[] args, Object target)
			throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("记录日志..." + method.getName());
	}
}

2、后置通知

package com.pc.aop;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
/**
 * 
 * @author Switch
 * @function 我的后置通知类
 * @description
 *
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {
	@Override
	/**
	 * 在被调用方法返回后被回调
	 * returnValue 返回值
	 * method 被调用方法
	 * args 被调用方法参数列表
	 * target 目标对象
	 */
	public void afterReturning(Object returnValue, Method method,
			Object[] args, Object target) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("关闭资源..." + method.getName());
	}
}

3、环绕通知

package com.pc.aop;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
 * 
 * @author Switch
 * @function 我的环绕通知
 * @description
 *
 */
public class MyMethodInterceptor implements MethodInterceptor {
	@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("调用方法前...");
		Object object = arg0.proceed();
		System.out.println("调用方法后...");
		return object;
	}
}

4、异常通知

package com.pc.aop;
import java.lang.reflect.Method;
import org.springframework.aop.ThrowsAdvice;
/**
 * 
 * @author Switch
 * @function 我的异常通知
 * @description
 * 
 */
public class MyThrowsAdvice implements ThrowsAdvice {
	public void afterThrowing(Method method, Object[] objects, Object target,
			Exception exception) {
		System.out.println("异常..." + exception.getMessage());
	}
}

配置文件

	<!-- 配置前置通知 -->
	<bean id="myMethodBeforeAdvice" class="com.pc.aop.MyMethodBeforeAdvice" />
	<!-- 配置后置通知 -->
	<bean id="myAfterReturningAdvice" class="com.pc.aop.MyAfterReturningAdvice" />
	<!-- 配置环绕通知 -->
	<bean id="myMethodInterceptor" class="com.pc.aop.MyMethodInterceptor"/>
	<!-- 配置异常通知 -->
	<bean id="myThrowsAdvice" class="com.pc.aop.MyThrowsAdvice" />
	
    <!-- 配置代理对象 -->
	<!-- 猜测底层实现使用代理模式，在某一接口被调用的方法上下文插入语句或方法。推测是另外有一个方法，调用这些东西 -->
	<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 把通知织入到代理对象 -->
		<property name="interceptorNames">
			<list>
				<!-- 相当于把myMethodBeforeAdvice前置通知和代理对象关联，也可以把通知看做是拦截器 -->
				<value>myMethodBeforeAdvice</value>
				<!-- 相当于把myAfterReturningAdvice后置通知和代理对象关联 -->
				<value>myAfterReturningAdvice</value>
				<!-- 相当于把myMethodInterceptor环绕通知和代理对象关联 -->
				<value>myMethodInterceptor</value>
				<!-- 相当于把myThrowsAdvice异常通知和代理对象关联 -->
				<value>myThrowsAdvice</value>
			</list>
		</property>
	</bean>
</beans>

定义切入点

    切入点是一个动态的概念，当通知织入连接点时，该连接点就变成了切入点。切入点主要用于将通知切入到满足一定规则的某一特定类的特定方法。

案例：

	<!-- 定义通知切入点 -->
	<!-- 这里是定义前置通知的切入点 -->
	<bean id="myMethodBeforeAdviceFilter" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
		<property name="advice" ref="myMethodBeforeAdvice" />
		<property name="mappedNames">
			<list>
				<!-- <value>printOK</value> -->
				<!-- 支持正则表达式 -->
				<value>print*</value>
			</list>
		</property>
	</bean>

	<!-- 配置代理对象 -->
	<!-- 猜测底层实现使用代理模式，在某一接口被调用的方法上下文插入语句或方法。推测是另外有一个方法，调用这些东西 -->
	<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 把通知织入到代理对象 -->
		<property name="interceptorNames">
			<list>
				<!-- 前置通知配置了引入通知，故使用引入通知指定哪些方法生效 -->
				<value>myMethodBeforeAdviceFilter</value>
			</list>
		</property>
	</bean>

正则表达式切入点

符号	描述	示例	匹配	不匹配
.	匹配任何单个字符	setFoo.	setFooB	setFoo setFooBar
+	匹配一个字符一次或多次	setFoo+	setFooBar,setFooB	setFoo
*	匹配一个字符0次或多次	setFoo*	setFoo,setFooB,setFooBar