Spring入门（9）-AOP初探

时间：2023-03-09 01:42:39
Spring入门（9）-AOP初探

Spring入门（9）-AOP初探

0. 目录

  1. 什么是面向切面编程
  2. AOP常见术语
  3. AOP实例
  4. 参考资料

1. 什么是面向切面编程

Aspect Oriented Programming(AOP)，即面向切面编程。AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。最常见的就是日志记录。举个例子，我们现在提供一个服务查询学生信息服务，但是我们希望记录有谁进行了这个查询。如果按照传统的OOP的实现的话，那我们实现了一个查询学生信息的服务接口(StudentInfoService)和其实现类（StudentInfoServiceImpl.java），同时为了要进行记录的话，那我们在实现类(StudentInfoServiceImpl.java)中要添加其实现记录的过程。这样的话，假如我们要实现的服务有多个呢？那就要在每个实现的类都添加这些记录过程。这样做的话就会有点繁琐，而且每个实现类都与记录服务日志的行为紧耦合，违反了面向对象的规则。那么怎样才能把记录服务的行为与业务处理过程中分离出来呢？看起来好像就是查询学生的服务自己在进行，但却是背后日志记录对这些行为进行记录，并且查询学生的服务不知道存在这些记录过程，这就是我们要讨论AOP的目的所在。AOP的编程，好像就是把我们在某个方面的功能提出来与一批对象进行隔离，这样与一批对象之间降低了耦合性，可以就某个功能进行编程。

Spring入门（9）-AOP初探

AOP不是Spring特有的，比如AspectJ也是AOP的实现。

2. AOP常见术语

1.通知(Advice):

通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。

Spring切面可以应用5种类型的通知。

  • Before：在方法调用前调用通知
  • After：在方法调用后调用通知
  • After-returning：在方法成功执行之后调用通知
  • After-throwing：方法抛出异常后调用通知
  • Around：在方法调用之前和调用之后执行自定义行为

2.连接点(Joinpoint):

程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。

3.切入点(Pointcut)

通知定义了切面要发生的“故事”和时间，那么切入点就定义了“故事”发生的地点，例如某个类或方法的名称，Spring中允许我们方便的用正则表达式来指定。

4.切面(Aspect)

通知和切入点共同组成了切面：时间、地点和要发生的“故事”

5.引入(Introduction)

引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能）

6.目标(Target)

即被通知的对象，如果没有AOP,那么它的逻辑将要交叉别的事务逻辑，有了AOP之后它可以只关注自己要做的事（AOP让他做爱做的事）

7.代理(proxy)

应用通知的对象，详细内容参见设计模式里面的代理模式

8.织入(Weaving)

把切面应用到目标对象来创建新的代理对象的过程，织入一般发生在如下几个时机:

(1)编译时：当一个类文件被编译时进行织入，这需要特殊的编译器才可以做的到，例如AspectJ的织入编译器

(2)类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码

(3)运行时：切面在运行的某个时刻被织入,SpringAOP就是以这种方式织入切面的，原理应该是使用了JDK的动态代理技术

3. AOP实例

1. 先看接口定义

package com.chzhao.spring.aoptest;

public interface IBaseBusiness {

    /**

     * 用作代理的切入点方法

     *

     * @param obj

     * @return

     */

    public String delete(String obj);

    /**

     * 这方法不被切面切

     *

     * @param obj

     * @return

     */

    public String add(String obj);

    /**

     * 这方法切不切呢？可以设置

     *

     * @param obj

     * @return

     */

    public String modify(String obj);

}

2. 接口实现

package com.chzhao.spring.aoptest;

public class BaseBusiness implements IBaseBusiness{

	/**

     * 切入点

     */

    public String delete(String obj) {

        System.out.println("==========调用切入点：" + obj + "说：你敢删除我！===========\n");

        return obj + "：瞄～";

    }

    public String add(String obj) {

        System.out.println("================这个方法不能被切。。。============== \n");

        return obj + "：瞄～ 嘿嘿！";

    }

    public String modify(String obj) {

        System.out.println("=================这个也设置加入切吧====================\n");

        return obj + "：瞄改瞄啊！";

    }

}

3. 定义切点

package com.chzhao.spring.aoptest;

import java.lang.reflect.Method;

import org.springframework.aop.support.NameMatchMethodPointcut;

/**

 * 定义一个切点，指定对应方法匹配。来供切面来针对方法进行处理<br>

 *

 * 继承NameMatchMethodPointcut类，来用方法名匹配

 *

 */

public class Pointcut extends NameMatchMethodPointcut {

	private static final long serialVersionUID = 3990456017285944475L;

	@SuppressWarnings("rawtypes")

	@Override

	public boolean matches(Method method, Class targetClass) {

		// 设置单个方法匹配

		this.setMappedName("delete");

		// 设置多个方法匹配

		String[] methods = { "delete", "modify" };

		// 也可以用“ * ” 来做匹配符号

		// this.setMappedName("get*");

		this.setMappedNames(methods);

		return super.matches(method, targetClass);

	}

}

4. Before

package com.chzhao.spring.aoptest;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class BaseBeforeAdvice implements MethodBeforeAdvice {

	public void before(Method method, Object[] args, Object target)

			throws Throwable {

		System.out.println("===========进入beforeAdvice()============ \n");

		System.out.print("准备在" + target + "对象上用");

		System.out.print(method + "方法进行对 '");

		System.out.print(args[0] + "'进行删除！\n\n");

		System.out.println("要进入切入点方法了 \n");

	}

}

5. AfterReturn

package com.chzhao.spring.aoptest;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

public class BaseAfterReturnAdvice implements AfterReturningAdvice {

	/**

	 * returnValue ：切入点执行完方法的返回值，但不能修改 <br>

	 * method ：切入点方法 <br>

	 * args ：切入点方法的参数数组 <br>

	 * target ：目标对象

	 */

	public void afterReturning(Object returnValue, Method method,

			Object[] args, Object target) throws Throwable {

		System.out.println("==========进入afterReturning()=========== \n");

		System.out.println("切入点方法执行完了 \n");

		System.out.print(args[0] + "在");

		System.out.print(target + "对象上被");

		System.out.print(method + "方法删除了");

		System.out.print("只留下：" + returnValue + "\n\n");

	}

}

6. AfterThrow

package com.chzhao.spring.aoptest;

import java.lang.reflect.Method;

import org.springframework.aop.ThrowsAdvice;

public class BaseAfterThrowsAdvice implements ThrowsAdvice {

	/**

	 * 通知方法，需要按照这种格式书写

	 *

	 * @param method

	 *            可选：切入的方法

	 * @param args

	 *            可选：切入的方法的参数

	 * @param target

	 *            可选：目标对象

	 * @param throwable

	 *            必填 : 异常子类，出现这个异常类的子类，则会进入这个通知。

	 */

	public void afterThrowing(Method method, Object[] args, Object target,

			Throwable throwable) {

		System.out.println("删除出错啦");

	}

}

7. Around

package com.chzhao.spring.aoptest;

import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInvocation;

import org.springframework.cglib.proxy.MethodInterceptor;

import org.springframework.cglib.proxy.MethodProxy;

public class BaseAroundAdvice implements MethodInterceptor {

	public Object invoke(MethodInvocation invocation) throws Throwable {

		System.out.println("===========进入around环绕方法！=========== \n");

		// 调用目标方法之前执行的动作

		System.out.println("调用方法之前: 执行！\n");

		// 调用方法的参数

		Object[] args = invocation.getArguments();

		// 调用的方法

		Method method = invocation.getMethod();

		// 获取目标对象

		Object target = invocation.getThis();

		// 执行完方法的返回值：调用proceed()方法，就会触发切入点方法执行

		Object returnValue = invocation.proceed();

		System.out.println("===========结束进入around环绕方法！=========== \n");

		System.out.println("输出：" + args[0] + ";" + method + ";" + target + ";"

				+ returnValue + "\n");

		System.out.println("调用方法结束：之后执行！\n");

		return returnValue;

	}

	public Object intercept(Object arg0, Method arg1, Object[] arg2,

			MethodProxy arg3) throws Throwable {

		return null;

	}

}

8. 主方法

package com.chzhao.spring.aoptest;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopMain {

	public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext("aop.xml");

        IBaseBusiness business = (IBaseBusiness ) context.getBean("businessProxy");

        business.delete("猫");

    }

}

9. 最重要的配置文件

<?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: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-3.0.xsd

	http://www.springframework.org/schema/context

	http://www.springframework.org/schema/context/spring-context-3.0.xsd

	http://www.springframework.org/schema/aop

	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"

	default-autowire="byName">

	<!-- ==============================利用spring自己的aop配置================================ -->

	<!-- 声明一个业务类 -->

	<bean id="baseBusiness" class="com.chzhao.spring.aoptest.BaseBusiness" />

	<!-- 声明通知类 -->

	<bean id="baseBefore" class="com.chzhao.spring.aoptest.BaseBeforeAdvice" />

	<bean id="baseAfterReturn" class="com.chzhao.spring.aoptest.BaseAfterReturnAdvice" />

	<bean id="baseAfterThrows" class="com.chzhao.spring.aoptest.BaseAfterThrowsAdvice" />

	<bean id="baseAround" class="com.chzhao.spring.aoptest.BaseAroundAdvice" />

	<!-- 指定切点匹配类 -->

	<bean id="pointcut" class="com.chzhao.spring.aoptest.Pointcut" />

	<!-- 包装通知，指定切点 -->

	<bean id="matchBeforeAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">

		<property name="pointcut">

			<ref bean="pointcut" />

		</property>

		<property name="advice">

			<ref bean="baseBefore" />

		</property>

	</bean>

	<!-- 使用ProxyFactoryBean 产生代理对象 -->

	<bean id="businessProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

		<!-- 代理对象所实现的接口 ，如果有接口可以这样设置 -->

		<property name="proxyInterfaces">

			<value>com.chzhao.spring.aoptest.IBaseBusiness</value>

		</property>

		<!-- 设置目标对象 -->

		<property name="target">

			<ref local="baseBusiness" />

		</property>

		<!-- 代理对象所使用的拦截器 -->

		<property name="interceptorNames">

			<list>

				<value>matchBeforeAdvisor</value>

				<value>baseAfterReturn</value>

			</list>

		</property>

	</bean>

</beans>

4. 参考资料

Spring In Action 第三版

aop的常见术语以及aop中常见通知的实现的总结

Spring AOP 学习例子

相关文章