springMVC学习(sringAOP)

最新推荐文章于 2021-10-25 02:31:20 发布

mockingbirds

最新推荐文章于 2021-10-25 02:31:20 发布

阅读量1.7k

点赞数

分类专栏： spring springMVC学习文章标签： spring AOP

本文链接：https://blog.csdn.net/mockingbirds/article/details/45440683

版权

spring 同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

springMVC学习

9 篇文章 5 订阅

订阅专栏

什么是AOP编程，先来看看官方给的概念：面向切面编程（AOP）通过提供另外一种思考程序结构的途经来弥补面向对象编程（OOP）的不足。在OOP中模块化的关键单元是类（classes），而在AOP中模块化的单元则是切面。切面能对关注点进行模块化，例如横切多个类型和对象的事务管理。（在AOP术语中通常称作横切（crosscutting）关注点。）

首先我们从一些概念和术语开始学习：

切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中，切面可以使用基于模式）或者基于@Aspect注解的方式来实现。
连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。
通知（Advice）：在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知（通知的类型将在后面部分进行讨论）。许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。
切入点（Pointcut）：匹配连接点的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。
引入（Introduction）：用来给一个类型声明额外的方法或属性（也被称为连接类型声明（inter-type declaration））。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用引入来使一个bean实现IsModified接口，以便简化缓存机制。
目标对象（Target Object）：被一个或者多个切面所通知的对象。也被称做被通知（advised）对象。既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。
AOP代理（AOP Proxy）：AOP框架创建的对象，用来实现切面契约（例如通知方法执行等等）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
织入（Weaving）：把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

通知类型：

前置通知（Before advice）：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
后置通知（After returning advice）：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
异常通知（After throwing advice）：在方法抛出异常退出时执行的通知。
最终通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
环绕通知（Around Advice）：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。

环绕通知是最常用的通知类型。和AspectJ一样，Spring提供所有类型的通知，我们推荐你使用尽可能简单的通知类型来实现需要的功能。例如，如果你只是需要一个方法的返回值来更新缓存，最好使用后置通知而不是环绕通知，尽管环绕通知也能完成同样的事情。用最合适的通知类型可以使得编程模型变得简单，并且能够避免很多潜在的错误。比如，你不需要在JoinPoint上调用用于环绕通知的proceed()方法，就不会有调用的问题。

这里的概念和术语不是很好的理解，其实aop编程，把程序运行期间看成了一条横线，我很可以利用aop编程来在这条横线任意一个地方插入一个插入一个方法而不影响原本的代码，使得我们的代码更加容易维护。通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

下面我们看一个案例，在该栗子中，我们通过AOP来实现用户注册功能，在注册成功之前和之后运行特定方法，就是我们上边提到的前置通知，和后置通知。

首先我们写一个接口，用来定义用户注册的方法：

package com.test.biz;
public interface UserBiz {
	public void doRegister(String userName,String password);
}

接下来写一个用户注册的实现类：

package com.test.biz.impl;

import com.test.biz.UserBiz;

public class UserBizImpl implements UserBiz {

	@Override
	public void doRegister(String userName, String password) {
		System.out.println("=====doRegister开始执行=====");
		System.out.println(userName+"注册成功!");
		System.out.println("=====doRegister执行执行结束=====");
	}
}

现在，我们的用户注册的方法都已经实现了，接下来就是开始编写我们的前置通知，和后置通知了。
前置通知：需要实现MethodBeforeAdvice接口，并重写before(Method method, Object[] args, Object target)方法。

后置通知：需要实现AfterReturningAdvice接口，并重写afterReturning(Object returnValue, Method method, Object[] args,Object target)方法。

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

import org.springframework.aop.MethodBeforeAdvice;

public class LogAdvice implements MethodBeforeAdvice {

	@Override
	public void before(Method method, Object[] args, Object target)
			throws Throwable {
	System.out.println("[系统日志]"+method.getName()+",时间:"+new Date()+",参数:"+Arrays.toString(args));
	}
}

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

import org.springframework.aop.AfterReturningAdvice;

public class MyAdvice implements AfterReturningAdvice {

	@Override
	public void afterReturning(Object returnValue, Method method, Object[] args,
			Object target) throws Throwable {
		System.out.println("后置通知:"+method.getName()+"\t"+Arrays.toString(args));
	}
}

到现在为止，我们的前置通知和后置通知都已经写好了，记下来就是配置我们的spring容器了，在src下新建一个applicationContext.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
	<bean id="userBizTarget" class="com.test.biz.impl.UserBizImpl"></bean>
	<bean id="logAdivce" class="com.test.advice.LogAdvice"></bean>
	<bean id="myAdvice" class="com.test.advice.MyAdvice"></bean>
	<bean id="bizProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="interceptorNames">
			<list>
				<value>logAdivce</value>
				<value>myAdvice</value>
			</list>
		</property>
	</bean>
	<bean id="userBiz" parent="bizProxy">
		<!-- 被代理目标所实现的接口 -->
		<property name="proxyInterfaces">
			<value>com.test.biz.UserBiz</value>
		</property>
		<!-- 被代理目标 -->
		<property name="target"  ref="userBizTarget"></property>
	</bean>
	
</beans>

可以看到org.springframework.aop.framework.ProxyFactoryBean是spring为我们提供的一个用于代理的类，里边有一个参数interceptorNames和proxyInterfaces。

interceptorNames：表示需要spring拦截执行的方法，对于该栗子，就是在doRegister()方法之前和之后执行的方法。

proxyInterfaces 是被代理类所实现的接口。

接下来，我编写一个测试类来测试是否"前置通知"和"后置通知"是在doRegister()方法前后运行的。如下：

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserBiz userBiz = (UserBiz)ac.getBean("userBiz");
userBiz.doRegister("张三", "123");

此时运行改程序输出如下结果：

[系统日志]doRegister,时间:Sat May 02 17:03:11 CST 2015,参数:[张三, 123]
=====doRegister开始执行=====
张三注册成功!
=====doRegister执行执行结束=====
后置通知:doRegister [张三, 123]

根据输出结果，我们可以发现"前置通知"和"后置通知"确实是在doRegister()方法前后运行的。这其实就是spring中AOP的简单实现，就是在程序运行期间动态为其增加新的方法，而不修改原有的代码。

注意需要引入commons-logging.jar，log4j-1.2.15.jar，spring.jar这三个jar文件。

大家有没有想过，现在我是一个UserBizImpl需要被代理，因此该类需要被配置对应的代理，那么如果我有很多歌类都需要相同的代理呢？？这样写下去觉得是要发疯的，下面我利用第二种方法，完全配置到applicationContext.xml方法中来实现。利用切面的来改善上面的程序，同样是在用户注册之前和之后运行"前置通知"和"后置通知"

此时我们的MyAdvice就是一个普通的类，再也不用实现什么接口了。

package com.test.aop;

public class MyAdvice {
	public void before(){
		System.out.println("前置通知....");
	}
	public void afterReturning(){
		System.out.println("后置通知....");
	}
	public void afterThrowing(){
		System.out.println("异常通知....");
	} 
	public void afterFinally(){
		System.out.println("最终通知....");
	} 
	public void around(){
		System.out.println("环绕通知...");
	}
}

UserBiz.java接口和UserBizImpl实现类和之前的都一样，这里我就不贴出来了，接下来就是编写我们的applicationContext.xml了，在applicationContext.xml中配置AOP需要引入aop的命名空间，如下：

xmlns:aop="http://www.springframework.org/schema/aop"

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

<?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:aop="http://www.springframework.org/schema/aop"
		xsi:schemaLocation="
			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
			
	<bean id="userBiz" class="com.test.biz.impl.UserBizImpl"></bean>		
	<!-- 通知 -->
	<bean id="myAdvice" class="com.test.aop.MyAdvice"></bean>
	<aop:config>
		<!-- ref="通知bean的id" -->
	  <aop:aspect id="myAspect" ref="myAdvice">
  			<!-- 定义一个切入点 -->
		    <aop:pointcut id="bizMethods" 
		          expression="execution(* com.test.biz.*.*(..))"/>
		    <!-- 前置通知 pointcut-ref="切入点bean的id"  method="通知中的方法名"-->      
		    <aop:before pointcut-ref="bizMethods" method="before"/>
		    <!-- 后置通知 -->
		    <aop:after-returning method="afterReturning" pointcut-ref="bizMethods"/>
	  </aop:aspect>
	</aop:config>
</beans>

可以看到这是我并没有给UserBizImpl设置代理，而是这样做的：

1.将通知类声明到spring容器中来让spring容器来管理。

2.通过这样的配置来实现aop编程：
<aop:config>

<aop:aspect id="myAspect" ref="myAdvice">

<aop:pointcut id="bizMethods"
expression="execution(* com.test.biz.*.*(..))"/>

<aop:before pointcut-ref="bizMethods" method="before"/>

<aop:after-returning method="afterReturning" pointcut-ref="bizMethods"/>
</aop:aspect>
</aop:config>
这里ref引用的就是我第一步声明的通知类，然后定义一个切入点：

expression="execution(* com.test.biz.*.*(..))

该切入点代表：com.test.biz包以及子包下任意方法名，任意返回值，任意参数的方法

第一个"*"表示返回值

第二个"*"表示类名

第三个"*"表示方法名

第四个“..”表示0个或多个参数

最后就是利用aop中为我们提供改好的

<aop:before pointcut-ref="bizMethods" method="before"/>和

<aop:after-returning method="afterReturning" pointcut-ref="bizMethods"/>

定义前置通知和后置通知的对应的方法，可以看到我们前置通知和后置通知通过ref引用了上一步定义的切入点，而method的值就是对应的方法名。也就是切入点中 ref="myAdvice"的通知类中的方法。

下面我编写一个测试类，来测试这些通知是否生效：

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserBiz userBiz = (UserBiz)ac.getBean("userBiz");
userBiz.doRegister("aa","aa");

此时打印如下：

前置通知....
=====doRegister开始执行=====
aa注册成功!
=====doRegister执行执行结束=====
后置通知....
注意需要引入aspectjrt.jar，aspectjweaver.jar，commons-logging.jar，log4j-1.2.15.jar，spring.jar这些jar包。
根据log可以看出，通知正常运行。好了今天的springAOP就到这里了，希望大家喜欢。

源码下载

mockingbirds

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
springMVC学习(sringAOP)

什么是AOP编程，先来看看官方给的概念：面向切面编程（AOP）通过提供另外一种思考程序结构的途经来弥补面向对象编程（OOP）的不足。在OOP中模块化的关键单元是类（classes），而在AOP中模块化的单元则是切面。切面能对关注点进行模块化，例如横切多个类型和对象的事务管理。（在AOP术语中通常称作横切（crosscutting）关注点。）首先我们从一些概念和术语开始学习：
复制链接

扫一扫