【Spring】AOP - 面向切面

最新推荐文章于 2024-09-16 18:08:54 发布
最新推荐文章于 2024-09-16 18:08:54 发布
阅读量1.5w 收藏 25
点赞数 9
分类专栏： Java.Spring 文章标签： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/robinjwong/article/details/25568481
版权

面向切面 - AOP

切面实现了横切关注点（跨越多个应用对象的逻辑）的模块化：


术语

通知（Advice）

在AOP术语中，切面的工作被成为通知。通知定义了切面是什么以及何时使用。

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

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

连接点（Joinpoint）

连接点是在应用执行过程中能够插入切面的一个点。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。

切点（Pointcut）

切点的定义会匹配通知所要织入的一个或多个连接点。通常使用明确的类和方法名称来指定这些切点，或是利用正则表达式定义匹配的类和方法名称模式来指定这些切点。

切点用于准确定位应该在什么地方应用切面的通知。

切面（Aspect）

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

引入（Introduction）

引入允许我们向现有的类添加新方法或属性，通过通知类，从而可以在无需修改现有的类的情况下，让它们具有新的行为和状态。

参见<aop:declare-parents>元素的使用，引入新的接口行为。

织入（Weaving）

织入是将切面应用到目标对象来创建新的代理对象的过程，切面在指定的连接点被织入到目标对象中（注入前置、后置通知等）。

在目标对象的生命周期里有多个点可以进行织入：

  • 编译期—— 切面在目标类编译期被织入，这种方式需要特殊的编译器，如AspectJ；
  • 类加载期—— 切面在目标类家在到JVM时被织入，这种方式需要特殊的类加载器（ClassLoader）；
  • 运行期—— 切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。Spring AOP就是以这种方式织入切面的；

Spring对AOP的支持

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

  • 基于代理的经典AOP;
  • @AspectJ注解驱动的切面；
  • 纯POJO切面；
  • 注入式AspectJ切面；

Spring通知是Java编写 —— Spring所创建的通知都是用标准的Java类编写的；

Spring在运行期通知对象 —— Spring运行时才创建代理对象，所以我们不需要特殊的编译器来织入Spring AOP的切面；

Spring只支持方法连接点 —— Spring基于动态代理，所以Spring只支持方法连接点，不支持构造器和字段连接点；


SpringAOP 之 定义切点

Spring AOP中，需要使用AspectJ的切点表达式语言来定义切点。

Spring AOP支持的AspectJ切点指示符

Spring仅支持AspectJ切点指示器的一个子集：

AspectJ指示器描述
execution用于匹配方法执行的连接点
within用于匹配指定类型内的方法执行
this用于匹配当前AOP代理对象类型的执行方法，注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配
target用于匹配当前目标对象类型的执行方法，注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配
args用于匹配当前执行的方法传入的参数为指定类型的执行方法
@within用于匹配持有指定注解类型内的方法
@target用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解
@args用于匹配当前执行的方法传入的参数持有指定注解的执行
@annotation用于匹配当前执行方法持有指定注解的方法
beanSpring AOP扩展的，用于匹配特定名称的Bean对象的执行方法
reference pointcut表示引用其他命名切入点

在Spring中尝试使用其他AspectJ指示器时，将会抛出IllegalArgumentException异常。


http://sishuok.com/forum/posts/list/281.html

SpringAOP 之 基于POJO切面

在XML中声明切面

Spring提供了声明式切面的选择。

Spring的AOP配置元素简化了基于POJO切面的声明：

AOP配置元素功能
<aop:advisor>定义一个AOP通知器
<aop:after>定义一个AOP后置通知（不考虑被通知的方法是否执行成功）
<aop:after-returning>定义一个AOP返回后通知
<aop:after-throwing>定义一个AOP抛出后通知
<aop:around>定义一个AOP环绕通知
<aop:aspect>定义一个切面
<aop:before>定义一个AOP前置通知
<aop:config>顶层的AOP元素。大多数<aop:*>元素必须包含在<aop:config>里
<aop:pointcut>定义一个切点
<aop:declare-parents>为被通知的对象引入额外的接口，并透明地实现

















声明前置和后置通知

XML Bean配置文件：

<?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">
	
	<!-- Root Context: defines shared resources visible to all other web components -->
	<bean id="advised" class="com.springtest.AdvisedObj" />
    <bean id="advising" class="com.springtest.AdvisingObj" />

	<aop:config>
        <aop:aspect ref="advising">
        	
            <aop:pointcut id="performance" expression="execution(* com.springtest.AdvisedObj.perform(..))" />
            
            <aop:before pointcut-ref="performance" method="beforeExecute" />
            <aop:after  pointcut-ref="performance" method="afterExecute" />     
              
        </aop:aspect>
	</aop:config>

</beans>

Java Code: 

package com.springtest;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.springtest.AdvisedObj;
import com.springtest.AdvisingObj;

public class SpringCoreTest{
	
	public static void main(String[] args){
		ApplicationContext ctx = 
				new FileSystemXmlApplicationContext("//Users/... .../beans_config.xml");
		
		AdvisedObj advisedObj = (AdvisedObj)ctx.getBean("advised");
		advisedObj.perform();
	}
}



package com.springtest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AdvisedObj {
	private static final Logger logger = LoggerFactory.getLogger(AdvisedObj.class);
	
	public void perform(){
		logger.info("AdvisedObj perform().");
	}
}


package com.springtest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AdvisingObj {
	private static final Logger logger = LoggerFactory.getLogger(AdvisingObj.class);
	
	public void beforeExecute(){
		logger.info("AdvisingObj beforeExcecute().");
	}
	
	public void afterExecute(){
		logger.info("AdvisingObj afterExecute().");
	}
}

执行结果： 

00:52:24.350 [main] INFO  com.springtest.AdvisingObj - AdvisingObj beforeExcecute().
00:52:24.367 [main] INFO  com.springtest.AdvisedObj - AdvisedObj perform().
00:52:24.367 [main] INFO  com.springtest.AdvisingObj - AdvisingObj afterExecute().

关于Spring AOP配置元素，大多数的AOP配置元素必须在<aop:config>元素的上下文内使用。

在所有的通知元素中，pointcut属性定义了通知所应用的切点。pointcut属性的值是使用AspectJ切点表达式语法所定义的切点。

<aop:pointcut>元素所定义的切点可以被同一个<aop:aspect>元素内的所有通知元素所引用。如果想让定义的切点能够在多个切面使用，可以把<aop:pointcut>元素放在<aop:config>元素的作用域内。


声明环绕通知

使用<aop:round>元素。使用环绕通知，可以完成之前前置通知和后置通知所实现的相同功能，但是只需要在一个方法中实现。

参考下面新的通知方法，它使用了ProceedingJoinPoint作为方法的参数。这个对象能让我们在通知里调用被通知方法。通知方法可以完成任何它所需要做的事情，如果希望把控制转给被通知的方法时，可以调用ProceedingJoinPoint的proceed方法。

必须调用proceed方法，如果忘记，通知将会阻止被通知的方法的调用。还可以在通知里多次调用被通知的方法。

示例：

<?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">
	
	<!-- Root Context: defines shared resources visible to all other web components -->
	<bean id="advised" class="com.springtest.AdvisedObj" />
    <bean id="advising" class="com.springtest.AdvisingObj" />

	<aop:config>
        <aop:aspect ref="advising">
        	
            <aop:pointcut id="performance" expression="execution(* com.springtest.AdvisedObj.perform(..))" />
            <!--  
            <aop:before pointcut-ref="performance" method="beforeExecute" />
            <aop:after  pointcut-ref="performance" method="afterExecute" />  
            -->   
            <aop:around  pointcut-ref="performance" method="roundExecute" />
              
        </aop:aspect>
	</aop:config>

</beans>

package com.springtest;

import org.aspectj.lang.ProceedingJoinPoint;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AdvisingObj {
	private static final Logger logger = LoggerFactory.getLogger(AdvisingObj.class);
	
	public void beforeExecute(){
		logger.info("AdvisingObj beforeExcecute().");
	}
	
	public void afterExecute(){
		logger.info("AdvisingObj afterExecute().");
	}
	
	public void roundExecute(ProceedingJoinPoint joinpoint){
		try{
			logger.info("AdvisingObj before roundExecute().");
		    joinpoint.proceed();
		    logger.info("AdvisingObj after roundExecute().");
		}catch(Throwable t){
			
		}
	}
}

结果： 

01:36:00.808 [main] INFO  com.springtest.AdvisingObj - AdvisingObj before roundExecute().
01:36:00.825 [main] INFO  com.springtest.AdvisedObj - AdvisedObj perform().
01:36:00.825 [main] INFO  com.springtest.AdvisingObj - AdvisingObj after roundExecute().

为通知传递参数

有时候通知并不仅仅是对方法进行简单包装，还需要校验传递给方法的参数值，这时候为通知传递参数就非常有用了。

通过配置实现将被通知方法的参数传递给通知，如下指定String参数，然后在args参数中标识了将parameter作为参数。

示例：

<?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">
	
	<!-- Root Context: defines shared resources visible to all other web components -->
	<bean id="advised" class="com.springtest.AdvisedObj" />
    <bean id="advising" class="com.springtest.AdvisingObj" />

	<aop:config>
        <aop:aspect ref="advising">
        	
            <aop:pointcut id="performance" expression="execution(* com.springtest.AdvisedObj.perform(String)) and args(parameter)" />
            <!--  
            <aop:before pointcut-ref="performance" method="beforeExecute" />
            <aop:after  pointcut-ref="performance" method="afterExecute" />  
             
            <aop:around  pointcut-ref="performance" method="roundExecute" />
            -->
            
            <aop:before pointcut-ref="performance" method="parameterExecute" arg-names="parameter" />
              
        </aop:aspect>
	</aop:config>

</beans>

package com.springtest;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.springtest.AdvisedObj;
import com.springtest.AdvisingObj;

public class SpringCoreTest{
	
	public static void main(String[] args){
		ApplicationContext ctx = 
				new FileSystemXmlApplicationContext("//Users/... .../beans_config.xml");
		
		AdvisedObj advisedObj = (AdvisedObj)ctx.getBean("advised");
		advisedObj.perform("TestParameter");
	}
}


package com.springtest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AdvisedObj {
	private static final Logger logger = LoggerFactory.getLogger(AdvisedObj.class);
	
	public void perform(String parameter){
		logger.info("AdvisedObj perform(), parameter is {}.", parameter);
	}
}


package com.springtest;

import org.aspectj.lang.ProceedingJoinPoint;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AdvisingObj {
	private static final Logger logger = LoggerFactory.getLogger(AdvisingObj.class);
	
	public void beforeExecute(){
		logger.info("AdvisingObj beforeExcecute().");
	}
	
	public void afterExecute(){
		logger.info("AdvisingObj afterExecute().");
	}
	
	public void roundExecute(ProceedingJoinPoint joinpoint){
		try{
			logger.info("AdvisingObj before roundExecute().");
		    joinpoint.proceed();
		    logger.info("AdvisingObj after roundExecute().");
		}catch(Throwable t){
			
		}
	}
	
	public void parameterExecute(String parameter){
		logger.info("AdvisingObj parameterExecute(), parameter is {}.",parameter);
	}
}

通过切面引入新的功能

利用被称为引入的AOP概念，切面也可以为Spring Bean添加新方法。

利用<aop:declare-parents>元素：

示例：

添加一个新的接口及实现类：

package com.springtest;

public interface ExtendedInterface {
    void extendedExecute();
}


package com.springtest;

import com.springtest.ExtendedInterface;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExtendedObj implements ExtendedInterface{
	private static final Logger logger = LoggerFactory.getLogger(ExtendedObj.class);
	
	public void extendedExecute(){
		logger.info("ExtendedObj extendedExecute().");
	}
}

在AOP配置中，<aop:declare-parents>声明了此切面锁通知的Bean在它的对象结构中拥有新的父类型，那些Bean会实现此接口。 

<?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">
	
	<!-- Root Context: defines shared resources visible to all other web components -->
	<bean id="advised" class="com.springtest.AdvisedObj" />
    <bean id="advising" class="com.springtest.AdvisingObj" />
    <bean id="extended" class="com.springtest.ExtendedObj" />
    
	<aop:config>
        <aop:aspect ref="advising">
        	<!-- 
            <aop:pointcut id="performance" expression="execution(* com.springtest.AdvisedObj.perform(String)) and args(parameter)" />
              
            <aop:before pointcut-ref="performance" method="beforeExecute" />
            <aop:after  pointcut-ref="performance" method="afterExecute" />  
            <aop:around  pointcut-ref="performance" method="roundExecute" />
            <aop:before pointcut-ref="performance" method="parameterExecute" arg-names="parameter" />
            -->
            
            <aop:declare-parents 
                types-matching="com.springtest.AdvisedObj+" 
                implement-interface="com.springtest.ExtendedInterface"
                delegate-ref="extended" /> 
        </aop:aspect>
	</aop:config>

</beans>

package com.springtest;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.springtest.AdvisedObj;
import com.springtest.AdvisingObj;
import com.springtest.ExtendedInterface;;

public class SpringCoreTest{
	
	public static void main(String[] args){
		ApplicationContext ctx = 
				new FileSystemXmlApplicationContext("//Users/wongrobin/all/projects/java/javaweb/ssh/SpringCoreTest/beans_config.xml");
		
		//AdvisedObj advisedObj = (AdvisedObj)ctx.getBean("advised");
		//advisedObj.perform("TestParameter");

		ExtendedInterface advisedObj = (ExtendedInterface)ctx.getBean("advised");
	    advisedObj.extendedExecute();
	}
}


SpringAOP 之 @AspectJ注解切面

使用注解来创建切面是AspectJ5所引入的关键特性。AspectJ面向注解的模型可以非常简单地通过少量注解把任意类转换为切面（不需要使用Java语言扩展）。这种新特性通常称为@AspectJ。

示例：

<?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">
	
    <aop:aspectj-autoproxy />
    
	<!-- Root Context: defines shared resources visible to all other web components -->
	<bean id="advised" class="com.springtest.AspectJAnnotationAdvisedObj" />
    <bean id="advising" class="com.springtest.AspectJAnnotationAdvisingObj" />

</beans>


<aop:aspectj-autoproxy  />将在Spring上下文中创建一个AnnotationAwareAspectJAutoProxyCreator类， 它会自动代理一些Bean，这些Bean的方法需要与使用@Aspect注解的Bean所定义的切点相匹配， 因此，被代理的目标对象类和使用@Aspect注解的类都应该定义成Bean，否则无法找到它们（定义Bean：advised和advising）。 


package com.springtest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AspectJAnnotationAdvisedObj{
private static final Logger logger = LoggerFactory.getLogger(AspectJAnnotationAdvisedObj.class);
	
	public void perform(){
		logger.info("AspectJAnnotationAdvisedObj perform().");
	}
}


package com.springtest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;

@Aspect
public class AspectJAnnotationAdvisingObj {
	private static final Logger logger = LoggerFactory.getLogger(AspectJAnnotationAdvisingObj.class);
	
    @Pointcut("execution(* com.springtest.AspectJAnnotationAdvisedObj.perform(..))")
	public void performance() {
		
	}
	
    @Before("performance()")
	public void beforeExecute(){
		logger.info("AspectJAnnotationAdvisingObj beforeExcecute().");
	}
	
    @AfterReturning("performance()")
	public void afterExecute(){
		logger.info("AspectJAnnotationAdvisingObj afterExecute().");
	}
}


@Pointcut注解用于定义一个可以在@AspectJ切面内可重用的切点。@Pointcut注解的值是一个AspectJ切点表达式，这里表示该切点必须匹配perform方法。切点的名称来源于注解所应用的方法名称。因此，该切点的民称为performance()。performance()方法的实际内容并不重要，在这里它事实上是空的，其实该方法本身只是一个标识，供@Pointcut注解依附。

@Before注解标识是前置通知方法，@AfterReturning注解标识是后置通知方法。

performance()切点的名称作为参数的值赋给了所有的通知注解，以这种方式来标识每一个通知方法应该应用在哪里。


package com.springtest;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.springtest.AspectJAnnotationAdvisedObj;
import com.springtest.AspectJAnnotationAdvisingObj;

public class AspectJAnnotationTest {

	public static void main(String[] args){
		ApplicationContext ctx = 
				new FileSystemXmlApplicationContext("//Users/wongrobin/all/projects/java/javaweb/ssh/SpringCoreTest/annotationaspectj_config.xml");
		
		AspectJAnnotationAdvisedObj advisedObj = (AspectJAnnotationAdvisedObj)ctx.getBean("advised");
		advisedObj.perform(); 
	}
}

<aop:aspectj-autoproxy>仅仅使用@AspectJ注解作为指引来创建基于代理的切面，但本质上它仍然是一个Spring风格的切面。

注解环绕通知

使用@Around注解可以创建环绕通知；被环绕通知的方法必须接受一个ProceedingJoinPoint对象作为方法入参，并在对象上调用proceed()方法。

示例：

package com.springtest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;

@Aspect
public class AspectJAnnotationAdvisingObj {
	private static final Logger logger = LoggerFactory.getLogger(AspectJAnnotationAdvisingObj.class);
	
    @Pointcut("execution(* com.springtest.AspectJAnnotationAdvisedObj.perform(..))")
	public void performance() {
		
	}
	/*
    @Before("performance()")
	public void beforeExecute(){
		logger.info("AspectJAnnotationAdvisingObj beforeExcecute().");
	}
	
    @AfterReturning("performance()")
	public void afterExecute(){
		logger.info("AspectJAnnotationAdvisingObj afterExecute().");
	}
    */
    @Around("performance()")
    public void roundExecute(ProceedingJoinPoint joinpoint){
		try{
			logger.info("AspectJAnnotationAdvisingObj before roundExecute().");
		    joinpoint.proceed();
		    logger.info("AspectJAnnotationAdvisingObj after roundExecute().");
		}catch(Throwable t){
			
		}
	}
}

执行结果： 

02:44:04.540 [main] INFO  c.s.AspectJAnnotationAdvisingObj - AspectJAnnotationAdvisingObj before roundExecute().
02:44:04.562 [main] INFO  c.s.AspectJAnnotationAdvisedObj - AspectJAnnotationAdvisedObj perform().
02:44:04.562 [main] INFO  c.s.AspectJAnnotationAdvisingObj - AspectJAnnotationAdvisingObj after roundExecute().

传递参数给所标注的通知

使用@AspectJ注解为通知传递参数，与Spring基于XML的切面声明没有太大区别。

示例：

package com.springtest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AspectJAnnotationAdvisedObj{
private static final Logger logger = LoggerFactory.getLogger(AspectJAnnotationAdvisedObj.class);
	
	public void perform(String parameter){
		logger.info("AspectJAnnotationAdvisedObj perform(), parameter is {}.", parameter);
	}
}


package com.springtest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;

@Aspect
public class AspectJAnnotationAdvisingObj {
	private static final Logger logger = LoggerFactory.getLogger(AspectJAnnotationAdvisingObj.class);
	
    @Pointcut("execution(* com.springtest.AspectJAnnotationAdvisedObj.perform(String)) && args(parameter)")
	public void performance(String parameter) {
		
	}
	
    @Before("performance(parameter)")
	public void beforeExecute(String parameter){
		logger.info("AspectJAnnotationAdvisingObj beforeExcecute(), parameter is {}.", parameter);
	}
	
    @AfterReturning("performance(parameter)")
	public void afterExecute(String parameter){
		logger.info("AspectJAnnotationAdvisingObj afterExecute(), parameter is {}.", parameter);
	}

    /*
    @Around("performance()")
    public void roundExecute(ProceedingJoinPoint joinpoint){
		try{
			logger.info("AspectJAnnotationAdvisingObj before roundExecute().");
		    joinpoint.proceed();
		    logger.info("AspectJAnnotationAdvisingObj after roundExecute().");
		}catch(Throwable t){
			
		}
	}
	*/
}


package com.springtest;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.springtest.AspectJAnnotationAdvisedObj;
import com.springtest.AspectJAnnotationAdvisingObj;

public class AspectJAnnotationTest {

	public static void main(String[] args){
		ApplicationContext ctx = 
				new FileSystemXmlApplicationContext("//Users/wongrobin/all/projects/java/javaweb/ssh/SpringCoreTest/annotationaspectj_config.xml");
		
		AspectJAnnotationAdvisedObj advisedObj = (AspectJAnnotationAdvisedObj)ctx.getBean("advised");
		advisedObj.perform("Parameter1"); 
	}
}

执行结果： 

03:03:19.837 [main] INFO  c.s.AspectJAnnotationAdvisingObj - AspectJAnnotationAdvisingObj beforeExcecute(), parameter is Parameter1.
03:03:19.856 [main] INFO  c.s.AspectJAnnotationAdvisedObj - AspectJAnnotationAdvisedObj perform(), parameter is Parameter1.
03:03:19.856 [main] INFO  c.s.AspectJAnnotationAdvisingObj - AspectJAnnotationAdvisingObj afterExecute(), parameter is Parameter1.

标注引入

使用基于注解的AOP为已有的Bean引入接口。等价于<aop:declare-parents>的注解是@AspectJ的@DeclareParents。

示例：使用上一节的ExtendInterface和ExtendedObj：

package com.springtest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.DeclareParents;

@Aspect
public class AspectJAnnotationAdvisingObj {
	private static final Logger logger = LoggerFactory.getLogger(AspectJAnnotationAdvisingObj.class);
	
	@DeclareParents(
			value="com.springtest.AspectJAnnotationAdvisedObj+",
			defaultImpl=ExtendedObj.class)
	public static ExtendedInterface extended;
	 /*
    @Pointcut("execution(* com.springtest.AspectJAnnotationAdvisedObj.perform(String)) && args(parameter)")
	public void performance(String parameter) {
		
	}
	
    @Before("performance(parameter)")
	public void beforeExecute(String parameter){
		logger.info("AspectJAnnotationAdvisingObj beforeExcecute(), parameter is {}.", parameter);
	}
	
    @AfterReturning("performance(parameter)")
	public void afterExecute(String parameter){
		logger.info("AspectJAnnotationAdvisingObj afterExecute(), parameter is {}.", parameter);
	}

   
    @Around("performance()")
    public void roundExecute(ProceedingJoinPoint joinpoint){
		try{
			logger.info("AspectJAnnotationAdvisingObj before roundExecute().");
		    joinpoint.proceed();
		    logger.info("AspectJAnnotationAdvisingObj after roundExecute().");
		}catch(Throwable t){
			
		}
	}
	*/
}


package com.springtest;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.springtest.AspectJAnnotationAdvisedObj;
import com.springtest.AspectJAnnotationAdvisingObj;
import com.springtest.ExtendedInterface;;

public class AspectJAnnotationTest {

	public static void main(String[] args){
		ApplicationContext ctx = 
				new FileSystemXmlApplicationContext("//Users/wongrobin/all/projects/java/javaweb/ssh/SpringCoreTest/annotationaspectj_config.xml");
		/*
		AspectJAnnotationAdvisedObj advisedObj = (AspectJAnnotationAdvisedObj)ctx.getBean("advised");
		advisedObj.perform("Parameter1"); 
		*/
		ExtendedInterface advisedObj = (ExtendedInterface)ctx.getBean("advised");
		advisedObj.extendedExecute(); 
	}
}

执行结果： 

03:16:30.784 [main] INFO  com.springtest.ExtendedObj - ExtendedObj extendedExecute().

@DeclareParents注解由3部分组成：

  • value属性等同于<aop:delcare-parents>的types-matching属性。它标识应该被引入指定接口的Bean类型。
  • defaultImpl属性等同于<aop:declare-parents>的default-impl属性。它标识该类提供了所引入接口的实现。
  • 由@DeclaeParents注解所标注的static属性指定了将被引入的接口。

（该注解类AspectJAnnotationAdvisingObj需要声明为Spring应用上下文中的一个Bean。）


SpringAOP 之  注入AspectJ切面

AspectJ提供了Spring AOP所不能支持的许多类型的切点。




王晓斌
关注
专栏目录
使用Spring进行面向切面编程
02-09 1万+
Chapter 6. 使用Spring进行面向切面编程（AOP） 6.1. 简介 面向切面编程（AOP）通过提供另外一种思考程序结构的途经来弥补面向对象编程（OOP）的不足。在OOP中模块化的关键单元是类（classes），而在AOP中模块化的单元则是切面。切面能对关注点进行模块化，例如横切多个类型和对象的事务管理。（在AOP术语中通常称作横切（crosscutti
Spring AOP(面向切面编程)
Fong灵
11-03 748
Spring AOP(面向切面编程)
Spring AOP——Spring 中面向切面编程
杜海的博客
09-14 219
一、AOP——另一种编程思想 1.1 什么是 AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。 从《Spring实战（第4版）》图书中扒了一张图： 从该图可以很形象地看出，所谓切面，相当于应用对象间的横切点，我们可以将其单独抽象为单独的模块。 1.2 为什么需要 AOP 想象下面的场景，开发中在多个模块间有某段
Spring高手之路23——AOP触发机制与代理逻辑的执行
最新发布
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
09-16 9984
本篇文章深入解析了Spring AOP代理的触发机制和执行流程，从源码角度详细讲解了Bean如何被AOP代理，包括代理对象的创建、配置与执行逻辑，帮助读者全面掌握Spring AOP的核心技术。
Spring的面向切面
weixin_33755847的博客
10-22 113
Spring的面向切面 　　在应用开发中，有很多类似日志、安全和事务管理的功能。这些功能都有一个共同点，那就是很多个对象都需要这些功能。复用这些通用的功能的最简单的方法就是继承或者委托。但是当应用规模达到一定程度时，使用继承或委托将会使应用的结构非常复杂。 　　面向切面便是解决上面问题的最佳办法。我们把这些通用的功能（横切关注点）放在专门的类中（这种类又叫切面），然后在程序运行后通过动态代理，...
Spring切入点表达式常用写法
lisj0731的专栏
03-31 355
Spring切入点表达式常用写法(2009-07-09 17:03:50)转载标签： it 分类： spring 自从使用AspectJ风格切面配置，使得Spring的切面配置大大简化，但是AspectJ是另外一个开源项目，其规则表达式的语法也稍稍有些怪异。 下面给出一些常见示例的写法： 比如，下面是一个对Service包上所有方法的切面配置 ...
AOP面向切面
qq_44872907的博客
03-30 405
什么是Aop？ Aop的全称是面向切面编程，本质上，不通过改源码的方式，添加新的功能，如登陆时的权限判断。 1.面向切面编程，利用的是aop可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分质检的耦合度降低，提高程序的可用性，同事提高了开发的效率。 2.通俗描述，不通过修改源代码的方式，在主干功能里面添加新功能。 3.使用登陆例子说明aop。 ...
16.2 Spring框架-AOP面向切面编程
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
spring-aop-jar
12-14
在IT领域，Spring框架是一个广泛使用的Java应用框架，它提供了许多功能，包括依赖注入、面向切面编程（AOP）等。"spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨...
spring-aop面向切面系统日志案例
07-17
这个“spring-aop面向切面系统日志案例”是一个实践教程，旨在教你如何利用Spring AOP实现系统的日志记录。 首先，理解Spring AOP的基本概念至关重要。AOP是一种编程范式，它允许程序员定义“切面”，这些切面可以...
spring-AOP面向切面编程所需jar包.zip
06-22
该压缩包包含--学习笔记(05):轻松搞定Spring全家桶(初识篇)-面向切片编程AOP：--系列博客中新需要的三个jar包。包括spring-aspects-5.2.7.RELEASE.jar和spring-aop-5.2.7.RELEASE.jar和...
Aop面向切面
weixin_47600732的博客
06-27 2459
Aop面向切面 1.AOP在spring中的作用 ​ 1.横切关注点：跨越应用程序多个模块的方法或者功能，即使与我们的业务逻辑 无关但是我们需要关注的部分就是横切关注点，例如日志，安全。缓存，事务等等； ​ 2.切面（ASPECT）：横切关注点，被模块化的特殊对象，也就是一个类； ​ 3.通知(ADVICE)：切面必须要完成的工作，也就是类中的一个方法； ​ 4.目标(TARGET)：被通知的对象； ​ 5.代理(Proxy):向目标对象应用通知之后创建对象； ​ 6.切入点(PointCut)
AOP（面向切面编程）
m0_58487321的博客
04-21 2197
AOP（面向切面编程）注解
AOP(面向切面编程)
m0_65431718的博客
05-09 6566
对aop的理解
Spring AOP：面向切面编程详解与实战
CH03-AOP面向切面编程 本章节深入探讨了面向切面编程(AOP)这一强大的软件设计模式，它是软件开发中的一种热点技术，特别在Spring框架中占有重要地位。AOP旨在通过预先编译或运行时动态代理，实现对程序功能的集中...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值