Spring Aop

Spring Aop:面向切面编程

Spring Aop是Spring框架的一个核心技术点,那么使用Aop有什么好处呢?如下图

从图中可以看到,在以往我们处理业务逻辑的时候总是会去执行一些非业务性的代码,这样会使我们编写的代码业务逻辑非常混乱,

那么有了Aop之后,我们可以将业务逻辑中的非去,单独业务性代码(比如事务处理)移除出开设为一个模块(这是第一个好处,重复代码被移除出去独立为一个模块,减少代码的冗余),这样业务逻辑中就只剩下业务性的代码,使业务逻辑变得更加清晰(这是第二个好处)

有人就会问,如果我这个业务逻辑必须提交事务,而提交事务的代码又被移除了,那么如何提交事务?

这里就可以提出面向切面编程的思想了,什么是面向切面编程?简单理解就是我移除后的代码独立为一个模块,那么在我业务逻辑需要的时候,我们可以根据切点将代码切入到要用的地方,比如我们一般执行完业务逻辑要进行事务提交,那么我可以将提交事务的代码切入到该业务逻辑之后执行(第三个好处,因为代码独立,降低与业务逻辑的耦合,方便我们维护)

基础术语:

连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出.

目标(Target)：被通知(被代理)的对象
注1：完成具体的业务逻辑

通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)
注2：完成切面编程

代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),
             例子：外科医生+护士
注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的

切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。
                 (也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)
    
适配器(Advisor)：适配器=通知(Advice)+切入点(Pointcut)

如何实现AOP
目标对象只负责业务逻辑代码
通知对象负责AOP代码，这二个对象都没有AOP的功能，只有代理对象才有

通知:

前置通知:

package com.study.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.MethodBeforeAdvice;

public class MyMethodBeforeAdvice implements MethodBeforeAdvice {

	public void before(Method method, Object[] args, Object target) throws Throwable {
		// TODO Auto-generated method stub
		String targetName = target.getClass().getName();
		String methodName = method.getName();
		String params = Arrays.toString(args);
		String msg = \"{系统日志}:正在调用->\"+targetName+\".\"+methodName+\",携带的参数:\"+params;
		System.out.println(msg);
	}

}

后置通知:

package com.study.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.AfterReturningAdvice;

public class MyAfterReturningAdvice implements AfterReturningAdvice {

	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		// TODO Auto-generated method stub
		String targetName = target.getClass().getName();
		String methodName = method.getName();
		String params = Arrays.toString(args);
		String msg = \"{返利通知,返利三元}:正在调用->\"+targetName+\".\"+methodName+\",携带的参数:\"+params+\",方法返回值:\"+returnValue;
		System.out.println(msg);
	}

}

环绕通知:

package com.study.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.aopalliance.intercept.MethodInvocation;

public class MethodInterceptor implements org.aopalliance.intercept.MethodInterceptor {

	public Object invoke(MethodInvocation invocation) throws Throwable {
		Object target = invocation.getThis();
		Method method = invocation.getMethod();
		Object[] args = invocation.getArguments();
		
		String targetName = invocation.getClass().getName();
		String methodName = method.getName();
		String params = Arrays.toString(args);
		
		String msg1 = \"{环绕通知}:正在调用->\"+targetName+\".\"+methodName+\",携带的参数:\"+params;
		System.out.println(msg1);
		Object returnValue = invocation.proceed();
		String msg2 = \"方法返回值:\"+returnValue;
		System.out.println(msg2);
		return returnValue;
	}

}

异常通知：

先声明异常:

package com.study.exception;

public class PriceException extends RuntimeException {

	public PriceException() {
		super();
	}

	public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
	}

	public PriceException(String message, Throwable cause) {
		super(message, cause);
	}

	public PriceException(String message) {
		super(message);
	}

	public PriceException(Throwable cause) {
		super(cause);
	}
	
}

package com.study.advice;

import org.springframework.aop.ThrowsAdvice;

import com.study.exception.PriceException;

public class MyThrowsAdvice implements ThrowsAdvice {
	public void afterThrowing( PriceException ex ) {
		System.out.println(\"价格输出有误,购买失败,请重新输入\");
	}
}

过滤通知:

<bean class=\"org.springframework.aop.support.RegexpMethodPointcutAdvisor\" id=\"myRegexpMethodPointcutAdvisor\">
	<!-- <property name=\"pattern\" value=\".*buy\"></property> -->
	<property name=\"advice\" ref=\"myAfterReturningAdvice\"></property>
	<!-- .*buy:[.*]任意字符0-n个,以buy结尾的方法 -->
	<property name=\"patterns\">
		<list>
			<value>.*buy</value>
		</list>
	</property>
</bean>

配置:

<!-- 目标对象 -->
<bean class=\"com.study.biz.impl.BookBizImpl\" id=\"bookBizImpl\"></bean>

<!-- 前置通知 -->
<bean class=\"com.study.advice.MyMethodBeforeAdvice\" id=\"myMethodBeforeAdvice\"></bean>
<bean class=\"com.study.advice.MyAfterReturningAdvice\" id=\"myAfterReturningAdvice\"></bean>
<bean class=\"com.study.advice.MethodInterceptor\" id=\"myMethodInterceptor\"></bean>
<bean class=\"com.study.advice.MyThrowsAdvice\" id=\"myThrowsAdvice\"></bean>
<bean class=\"org.springframework.aop.support.RegexpMethodPointcutAdvisor\" id=\"myRegexpMethodPointcutAdvisor\">
	<!-- <property name=\"pattern\" value=\".*buy\"></property> -->
	<property name=\"advice\" ref=\"myAfterReturningAdvice\"></property>
	<!-- .*buy:[.*]任意字符0-n个,以buy结尾的方法 -->
	<property name=\"patterns\">
		<list>
			<value>.*buy</value>
		</list>
	</property>
</bean>

<!-- 生成代理 -->
<bean class=\"org.springframework.aop.framework.ProxyFactoryBean\" id=\"proxyFactoryBean\">
	<property name=\"target\" ref=\"bookBizImpl\"></property>
	<property name=\"proxyInterfaces\" value=\"com.study.biz.BookBiz\"></property>
	<property name=\"interceptorNames\">
		<list>
			<value>myMethodBeforeAdvice</value>
			<!-- <value>myAfterReturningAdvice</value> -->
			<value>myRegexpMethodPointcutAdvisor</value>
			<value>myMethodInterceptor</value>
			<value>myThrowsAdvice</value>
		</list>
	</property>
</bean>