`
come_for_dream
  • 浏览: 120758 次
  • 性别: Icon_minigender_1
  • 来自: 长沙
社区版块
存档分类
最新评论

Spring AOP之Advice

阅读更多

Spring AOP之Advice


   前置通知:即代码被执行之前被调用
   后置通知:即代码执行之后进行调用
   环绕通知:即代码执行前后进行调用

这两种方式的实现方式用到了动态代理的思想来完成的,

总结不想说废话:

首先是Spring1.x对Advice的支持:

 

public interface IHello {
	public void sayHello1() ;
	public void sayHello2() ;
	public void sayHello3() ;
	public void sayHello4() ;
}

 然后就是类的实现:

package com.spring.test;

public class Hello implements IHello{

	public void sayHello1() {
		System.out.println("111111111111");
	}

	public void sayHello2() {
		System.out.println("222222222222");
	}

	public void sayHello3() {
		System.out.println("333333333333");
	}

	public void sayHello4() {
		System.out.println("444444444444");
	}
}

 
然后是负责前置通知的类,要实现MethodBeforeAdvice接口:

 

 

 

public class AdviceBeforeHello implements MethodBeforeAdvice {
	@Override
	public void before(Method arg0, Object[] arg1, Object arg2)
			throws Throwable {
		System.out.println("验证用户。。。。");

	}
}

 然后是负责后置通知的类,要实现AfterReturningAdvice接口:

 

 

public class AdviceAfterHello implements AfterReturningAdvice{

	@Override
	public void afterReturning(Object arg0, Method arg1, Object[] arg2,
			Object arg3) throws Throwable {
		System.out.println("方法执行完毕");
		
	}

}

 

 

 

配置项:
<bean id="beforeHello" class="com.spring.advice.AdviceBeforeHello" />
	<bean id="afterHello" class="com.spring.advice.AdviceAfterHello"></bean>
	<bean id="hello" class="com.spring.test.Hello"></bean>
	<!-- 注册代理类 -->
	<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="proxyInterfaces">
			<value>com.spring.test.IHello</value>
		</property>

		<!-- 目标对象,即Hello对象 -->
		<property name="target" ref="hello"></property>
		<!-- 应用的前置通知,拦截器名称 -->
		<property name="interceptorNames">
			<list>
				<value>beforeHello</value>
				<value>afterHello</value>

			</list>
		</property>
	</bean>

 

 

测试方法:

 

	ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
		IHello hello = (IHello) context.getBean("proxy");
		hello.sayHello1();
		hello.sayHello2();
		hello.sayHello3();
		hello.sayHello4();

 

 

结果:

 

下面是环绕通知:

public class AdviceAroundHello implements MethodInterceptor{

	@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {
		Object object=null;
		System.out.println("验证用户");
		try {
			object=arg0.proceed();
		} finally{
			System.out.println("方法执行完毕");
		}
		
		return object;
	}


}

 然后配置beans.xml:

<bean id="aroundHello" class="com.spring.advice.AdviceAroundHello"></bean>
	 
	<bean id="hello" class="com.spring.test.Hello"></bean>
	<!-- 注册代理类 -->
	<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="proxyInterfaces">
			<value>com.spring.test.IHello</value>
		</property>

		<!-- 目标对象,即Hello对象 -->
		<property name="target" ref="hello"></property>
		<!-- 应用的前置通知,拦截器名称 -->
		<property name="interceptorNames">
			<list>
				<value>aroundHello</value>
			</list>
		</property>
	</bean>

 

 以上是Spring1.x对AOP的支持,,Spring2.x除了支持Spring1.x外,还提供了两种实现AOP的方式:

1.基于XML的配置,使用基于Schema的XML配置来完成AOP而且Advice也不用再实现任何其他特定接口。

2.使用JDK5的注释来完成AOP的实现,只需要一个简单的标签就可以完成AOP的整个过程。

 

基于XML Schema的前置通知配置如下:

   编写通知的逻辑代码:

public class AdviceBeforeHello {
	public void beforeHello(){
		System.out.println("验证用户。。。。");

	}
}

 在beans.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"
	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="hello" class="com.spring.test.Hello"></bean>
	<aop:config>
	<!--  -->
		<aop:pointcut id="beforePointCut"
			expression="execution(* com.spring.test.IHello.*(..))" />
		<aop:aspect id="before" ref="beforeAdvice">
			<aop:before method="beforeHello" pointcut-ref="beforePointCut" />
		</aop:aspect>
	</aop:config>


	<bean id="beforeAdvice" class="com.spring.advice.AdviceBeforeHello"></bean>
</beans>

 其他不变。。。。

 

 

2.基于Annotation的前置通知:

切面类:

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AdviceBeforeHello {
	@Before("execution(*  com.spring.test.IHello.*(..))")
	public void beforeHello(){
		System.out.println("验证用户。。。。");

	}
}

 beans.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"
	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">
	<!-- 注册接口实现类 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
	<bean id="hello" class="com.spring.test.Hello"></bean>
	<bean id="beforeAdvice" class="com.spring.advice.AdviceBeforeHello"></bean>
</beans>

 

 基于XML和Annotation的后置通知和前置通知类似。下面是基于XML的环绕通知:

 

import org.aspectj.lang.ProceedingJoinPoint;

public class AdviceAroundHello {

	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
		System.out.println("验证用户");
		//执行连接点的方法
		Object object = joinPoint.proceed();
		System.out.println("方法执行完毕");
		return object;
	}

}

 

 beans.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"
	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="hello" class="com.spring.test.Hello"></bean>
	<aop:config>
		<aop:pointcut id="aroundPointcut"
			expression="execution(*  com.spring.test.IHello.*(..))" />
		<aop:aspect id="around" ref="aroundAdvice">
			<aop:around method="around" pointcut-ref="aroundPointcut" />
		</aop:aspect>
	</aop:config>

	<bean id="aroundAdvice" class="com.spring.advice.AdviceAroundHello"></bean>
</beans>

 

 其他不变。

 

-------------------------------------------------------------------------------------------------------------------------------

基于Annotation的环绕通知:

package com.spring.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class AdviceAroundHello {
	@Around("execution(*  com.spring.test.IHello.*(..))")
	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
		System.out.println("验证用户");
		// 执行连接点的方法
		Object object = joinPoint.proceed();
		System.out.println("方法执行完毕");
		return object;
	}

}

 beans.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"
	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">
	<!-- 注册接口实现类 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
	
	<bean id="hello" class="com.spring.test.Hello"></bean>
	<bean id="aroundAdvice" class="com.spring.advice.AdviceAroundHello"></bean>
</beans>

 

完成!!

 

 

 

 

  • 大小: 51.1 KB
0
0
分享到:
评论

相关推荐

    spring aop jar 包

    在Spring AOP中,切面由通知(Advice)和切点(Pointcut)定义。 2. **通知(Advice)**:通知是在特定连接点(Join Point)执行的代码,例如方法调用前、后或者异常发生时。Spring AOP支持五种类型的通知:前置...

    Spring AOP - Advice

    **Spring AOP - Advice 概述** 在Spring框架中,AOP(Aspect Oriented Programming,面向切面编程)是一种强大的工具,它允许开发者定义“横切关注点”,这些关注点是跨越多个对象和方法的通用行为,如日志、事务...

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

    Spring AOP中有五种不同类型的的通知(Advice): 1. 前置通知(Before Advice):在方法执行前执行,使用`@Before`注解。 2. 返回后通知(After Returning Advice):在方法正常返回后执行,使用`@AfterReturning`...

    简单spring aop 例子

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和声明式的方式来处理系统中的交叉关注点问题,如日志、事务管理、安全性等。本示例将简要介绍如何在Spring应用中实现AOP,通过实际的...

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

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

    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面向方面编程原理:AOP概念

    Spring框架作为Java开发领域的领头羊之一,提供了强大的AOP支持。本文旨在深入探讨Spring AOP的核心概念及其原理。 #### 二、AOP基本概念 AOP是一种编程范式,其目的是提高模块化程度,特别是将那些对很多类都具有...

    Spring AOP实现机制

    Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许程序员在不修改源代码的情况下,通过“切面”来插入额外的业务逻辑,如日志、事务管理等。AOP的引入极大地提高了代码的可复用性和可维护性。 ### 1. ...

    spring AOP依赖三个jar包

    Spring AOP,即Spring的面向切面编程模块,是Spring框架的重要组成部分,它允许开发者在不修改源代码的情况下,对程序进行横切关注点的处理,如日志、事务管理等。实现这一功能,主要依赖于三个核心的jar包:aop...

    spring-aop实例

    通过以上介绍,我们可以看到Spring AOP的强大之处在于它简化了代码的组织和维护,使得横切关注点的实现更加优雅。了解并掌握这些概念,开发者可以有效地利用Spring AOP提升应用程序的可维护性和可扩展性。

    spring-aop-jar

    "spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨Spring AOP、相关jar文件以及它们在实际开发中的作用。 首先,我们来看一下提供的文件: 1. aopalliance.jar:这是一...

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    面向切面编程(AOP)是一种编程范式,旨在将横切关注点(如日志、安全等)与业务逻辑分离,从而提高模块化。...利用Java反射机制和Spring AOP框架,开发者可以方便地实现AOP,从而提升代码的模块化和可维护性。

    小马哥讲 Spring AOP 编程思想 - API 线索图.pdf

    在讨论Spring AOP(面向切面编程)时,首先需要理解几个核心概念。Spring AOP 是Spring框架提供的一个功能模块,它允许开发者将横切关注点(cross-cutting concerns)从业务逻辑中解耦出来,通过在方法调用前后进行...

    spring aop 学习笔记

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和抽象化的方法来处理系统中的交叉关注点,如日志、事务管理、安全性等。本学习笔记将深入探讨Spring AOP的核心概念、工作原理以及实际...

    spring aop spring aop

    Spring AOP,全称Aspect-Oriented Programming(面向切面编程),是Spring框架的重要组成部分,用于实现横切关注点的模块化。它允许开发者定义“切面”,将那些与业务逻辑无关,却为多个对象共有的行为(如日志、...

    spring aop 经典例子(原创)

    在Spring AOP中,切面通常由一个或多个通知(Advice)组成,通知是在特定连接点(Join Point)执行的代码片段。连接点是指程序执行过程中能够插入切面的特定位置,如方法调用、异常抛出等。 在Spring AOP中,有五种...

    springAOP所需jar包

    这些jar包的整合使用使得Spring能够理解并处理切面定义,如定义切点(Pointcut)、通知(Advice)、切面(Aspect)等。切点定义了关注点在何处应用,通知定义了在特定切点上执行的行为,而切面则是切点和通知的组合...

    Spring Aop的简单实现

    Spring AOP,全称Aspect-Oriented Programming(面向切面编程),是Spring框架的重要组成部分,它为应用程序提供了声明式的企业级服务,如日志、事务管理等。在本项目中,我们将探讨如何通过配置文件实现Spring AOP...

Global site tag (gtag.js) - Google Analytics