`

spring aop注解

 
阅读更多

在软件开发中,分布于应用多出的功能被称为和横切关注点. 通常,这些横切关注点从概念上是与应用的业务逻辑相分离的(但是往往直接嵌入到应用的业务逻辑中).将这些横切关注点与业务逻辑相分离正是面向切面编成(AOP)所要解决的 

要了解什么是AOP,首先应该了解AOP相关术语,只有完全理解这些,才能更好的掌握AOP 

描述切面的常用术语有 通知(advice), 切点(pointcut), 连接点(join point).

通知(advice)

切面有目标-他必须要完成的工作,成为通知.通知定义了切面是什么以及何时使用. 

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

  • Before                在方法被调用之前调用通知
  • After                  在方法完成之后调用通知,无论方法执行是否成功
  • After-returning    在方法成功执行之后调用通知
  • After-throwing     在方法抛出异常后调用通知
  • Around                通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为

连接点(join point) 

连接点是在应用执行过程中能够插入切面的一个点.这个点可以是调用方法时,抛出异常时,甚至修改一个字段时.切面代码可以利用这些点插入到应用的正常流程之中,并添加新的行为 

切点(pointcut) 

切点的定义会匹配通知所要织入的一个或多个连接点 

切面(Aspect) 

切面是通知和切点的结合,通知和切点共同定义了关于切面的全部内容-它是什么,在何时和何处完成其功能 

Spring提供了4种各具特色的AOP支持 

  • 基于代理的经典AOP
  • @AspectJ注解驱动的切面
  • 纯POJO切面
  • 注入式AspectJ切面(适合Spring各个版本)

以下介绍如何使用注解,在Spring使用AOP

1. XML方式配置

在xml里引入:

<?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"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

 <context:component-scan base-package="com.spring.aop"></context:component-scan> 
<bean id="studentService" class="com.spring.aop.service.impl.StudentServiceImpl" ></bean>
<bean id="studentServiceAspect" class="com.spring.aop.advice.StudentServiceAspect"></bean>

<aop:config>
 <aop:aspect id="studentServiceAspect" ref="studentServiceAspect">
 	<aop:pointcut expression="execution(* com.spring.aop.service.*.*(..))" id="business"/>
 	<aop:before method="doBefore" pointcut-ref="business"/>
 	<aop:after method="doAfter" pointcut-ref="business" />
 	<aop:around method="doAround" pointcut-ref="business"/>
 	<aop:after-returning method="doAfterReturning" pointcut-ref="business"/>
 	<aop:after-throwing method="doAfterThrow" pointcut-ref="business" throwing="ex"/>
 </aop:aspect>
</aop:config>
</beans>

aop类:

public class StudentServiceAspect {

	//前置通知
	public void doBefore(JoinPoint jp){
		System.out.println("doBefore beginning...");
		System.out.println("类名:"+jp.getTarget().getClass());
		System.out.println("方法名:"+jp.getSignature().getName());
		System.out.println(Arrays.asList(jp.getArgs()));
		System.out.println("doBefore end.");
	}

	//后置通知
	public void doAfter(JoinPoint jp){
		System.out.println("doAfter beginning...");
		System.out.println("类名:"+jp.getTarget().getClass());
		System.out.println("方法名:"+jp.getSignature().getName());
		System.out.println("参数:"+Arrays.asList(jp.getArgs()));
		System.out.println("doAfter end.");
	}
	

	//环绕通知相当于doBefore 和 doAfter的结合
	public Object doAround(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("doAround beginning...");
		Object retVal = pjp.proceed();
		System.out.println(retVal);
		System.out.println("doAfter Proceed...");

		return retVal;	
	}
	

	public void doAfterReturning(JoinPoint jp){
		System.out.println("返回通知");
	}
	
	public void doAfterThrow(JoinPoint jp,Throwable ex){
		System.out.println("出错异常:"+ ex.getMessage());
	}
	
}

 

2. 注解的方式

xml中加入:

 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

 aop类加上注解:

import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component("studentServiceAspect")
@Aspect
public class StudentServiceAspect {
	
	@Pointcut("execution(* com.spring.aop.service.*.*(..))")
	public void pointcut(){}

	@Before(value = "pointcut()")
	//前置通知
	public void doBefore(JoinPoint jp){
		System.out.println("doBefore beginning...");
		System.out.println("类名:"+jp.getTarget().getClass());
		System.out.println("方法名:"+jp.getSignature().getName());
		System.out.println(Arrays.asList(jp.getArgs()));
		System.out.println("doBefore end.");
	}
	
	@After("pointcut()")
	//后置通知
	public void doAfter(JoinPoint jp){
		System.out.println("doAfter beginning...");
		System.out.println("类名:"+jp.getTarget().getClass());
		System.out.println("方法名:"+jp.getSignature().getName());
		System.out.println("参数:"+Arrays.asList(jp.getArgs()));
		System.out.println("doAfter end.");
	}
	
	@Around("pointcut()")
	//环绕通知相当于doBefore 和 doAfter的结合
	public Object doAround(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("doAround beginning...");
		Object retVal = pjp.proceed();
		System.out.println(retVal);
		System.out.println("doAfter Proceed...");

		return retVal;	
	}
	
	@AfterReturning("pointcut()")
	public void doAfterReturning(JoinPoint jp){
		System.out.println("返回通知");
	}
	
	@AfterThrowing(value="pointcut()",throwing="ex")
	public void doAfterThrow(JoinPoint jp,Throwable ex){
		System.out.println("出错异常:"+ ex.getMessage());
	}
	
}

就是这么简单,一个简单的POJO加上一个@Aspect ,定义一个或者多个切点(pointcut).N个通知方法(advice). 

 

切点配合通知便是切面,切面便是AOP(在什么位置,什么时候,做什么)

 

 

分享到:
评论

相关推荐

    spring AOP注解的应用1

    在Spring框架中,AOP(面向切面编程)是一...Spring AOP注解的应用使得切面编程更加简单直观,大大简化了对横切关注点的管理。在实际开发中,结合Spring提供的其他特性,如事务管理,可以构建出高效、健壮的后端系统。

    spring aop注解版

    总结起来,Spring AOP注解版通过简单易懂的注解,使得面向切面编程变得更加直观和方便。它降低了横切关注点与业务逻辑之间的耦合度,提高了代码的可维护性和复用性。通过合理利用这些注解,开发者可以轻松地实现日志...

    基于注解实现SpringAop

    基于注解实现SpringAop基于注解实现SpringAop基于注解实现SpringAop

    spring aop 注解例子

    **Spring AOP 注解例子详解** 在 Spring 框架中,面向切面编程(Aspect Oriented Programming,AOP)是一种强大的设计模式,它允许我们分离关注点,将业务逻辑与系统服务(如日志、事务管理等)解耦。在 Spring AOP...

    spring aop 自定义注解保存操作日志到mysql数据库 源码

    2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 (需要知道原理的请看spring aop源码,此处不做赘述) 3、可在现有源码上快速进行功能扩展 4、spring boot,mybatis,druid,spring aop的使用

    spring aop注解方式、xml方式示例

    下面将详细介绍Spring AOP的注解方式和XML配置方式。 ### 注解方式 #### 1. 定义切面(Aspect) 在Spring AOP中,切面是包含多个通知(advisors)的类。使用`@Aspect`注解标记切面类,例如: ```java @Aspect ...

    SpringAOP注解特棒例子

    在这个"SpringAOP注解方式"的示例中,我们将深入探讨如何使用注解来实现Spring AOP的功能。 首先,Spring AOP通过两种主要的方式来定义切面:XML配置和注解。本示例主要关注注解方式,因为它提供了更简洁、更直观的...

    spring aop jar 包

    在使用Spring AOP时,我们可以通过XML配置或注解的方式来定义切面。例如,可以使用`@Aspect`注解定义一个切面类,`@Before`、`@After`等注解来声明通知,`@Pointcut`定义切点表达式。 在实际开发中,Spring AOP广泛...

    spring aop注解所需要的三个jar包,aspectjrt.jar,aspectjweaver.jar,aopalliance.jar

    本篇文章将深入探讨Spring AOP注解所依赖的三个核心JAR包:aspectjrt.jar、aspectjweaver.jar以及aopalliance.jar,并阐述它们在AOP框架中的作用。 首先,`aspectjrt.jar`是AspectJ运行时库,它是AspectJ编译器和织...

    Spring AOP 注解方式

    在Spring AOP中,我们可以利用注解来实现切面,使得代码更加简洁、易读。本篇文章将深入探讨如何使用注解方式在Spring AOP中实现内部方法的拦截。 首先,理解AOP的基本概念至关重要。AOP的核心是切面(Aspect),它...

    使用Spring的注解方式实现AOP的细节

    本篇文章将深入探讨如何通过Spring的注解方式实现AOP的细节。 首先,我们需要了解AOP的基本概念。AOP的核心是切面(Aspect),它封装了跨越多个对象的行为或责任。切点(Pointcut)定义了哪些方法会被通知(Advice...

    Spring AOP 16道面试题及答案.docx

    Spring支持两种AOP的实现方式:Spring AspectJ注解风格和Spring XML配置风格。使用AspectJ注解风格是最常见的,它允许开发者直接在方法上使用注解来定义切面。 Spring AOP中有五种不同类型的的通知(Advice): 1....

    Spring AOP 注解使用

    **Spring AOP 注解使用详解** 在Java世界中,Spring框架以其强大的功能和灵活性而备受推崇,其中AOP(Aspect-Oriented ...通过理解上述概念和实践案例,你将能够更有效地利用Spring AOP注解来优化和组织你的代码。

    Spring AOP完整例子

    Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许开发者在不修改源代码的情况下,通过插入切面来增强或改变程序的行为。在本教程中,我们将深入探讨Spring AOP的不同使用方法,包括定义切点、通知类型...

    用注解的方式进行SpringAOP开发

    本篇我们将深入探讨如何使用注解的方式来实现Spring AOP开发。 ### 一、注解基础 在Spring AOP中,主要使用以下几种注解: 1. `@Aspect`:定义一个切面类,切面是AOP的核心,包含通知(advisors)和切点...

    spring aop依赖jar包

    现在,我们回到主题——"springaop依赖的jar包"。在Spring 2.5.6版本中,使用Spring AOP通常需要以下核心jar包: - `spring-aop.jar`:这是Spring AOP的核心库,包含了AOP相关的类和接口。 - `spring-beans.jar`:...

    Spring Aop四个依赖的Jar包

    Spring AOP,全称Aspect-Oriented Programming(面向切面编程),是Spring框架的一个重要模块,它通过提供声明式的方式来实现面向切面编程,从而简化了应用程序的开发和维护。在Spring AOP中,我们无需深入到每个...

    死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理(csdn)————程序.pdf

    Spring AOP 是一种面向切面编程的技术,它允许我们在不修改源代码的情况下,对应用程序的特定部分(如方法调用)进行增强。在 Spring 中,AOP 的实现主要依赖于代理模式,有两种代理方式:JDK 动态代理和 CGLIB 动态...

    SpringAOP的注解配置

    在Spring AOP中,我们可以通过注解配置来实现切面编程,从而简化代码并提高可维护性。 首先,我们需要了解Spring AOP中的核心概念: 1. **切面(Aspect)**:切面是关注点的模块化,它包含了横切关注点(如日志)和...

    Spring AOP面向方面编程原理:AOP概念

    Spring AOP支持多种方式来定义切入点,包括但不限于方法名、类名、注解等。 5. **引入(Introduction)**:允许向被通知对象添加新的接口实现或者新的方法。例如,可以使用引入让任何对象实现`IsModified`接口,...

Global site tag (gtag.js) - Google Analytics