`

Spring AOP annotation 简单实例

 
阅读更多

最后输出(可以看出各种通知的时间):

 

我是前置通知。
我是环绕--进。
aa 已成功保存
我是后置通知。
我是最终通知。
我是环绕--出。

 

app.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:p="http://www.springframework.org/schema/p"
	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-3.0.xsd
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.0.xsd
">

	<aop:aspectj-autoproxy />
	<context:component-scan base-package="com.mhm.spring"/>
	
</beans>

 

MyAOP.Java

package com.mhm.spring.mng.impl;

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
@Aspect
public class MyAOP {

	//声明切入点
        //注意,impl下面的类必须实现了mng中的接口,不然不能实现代理,但如果还是要使用代理
        //那么,在项目中加入cglib,它会根据二进制来实现代理
	@Pointcut("execution(* com.mhm.spring.mng.impl..*.*(..))")
	public void anyMethod(){};
	
	//前置通知
	@Before("anyMethod()")
	public void dobefore() {
		System.out.println("我是前置通知。");
	}
	
	//后置通知
	@AfterReturning("anyMethod()")
	public void doafterReturning() {
		System.out.println("我是后置通知。");
	}
	
	//最终置通知
	@After("anyMethod()")
	public void doafter() {
		System.out.println("我是最终通知。");
	}
	
	//异常通知
	@AfterThrowing("anyMethod()")
	public void doexception() {
		System.out.println("我是异常通知。");
	}
	
	//环绕通知
	@Around("anyMethod()")
	public Object doprocess(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("我是环绕--进。");
		Object o = pjp.proceed();
		System.out.println("我是环绕--出。");
		return o;
	}
	
}

 

PersonMng.java

package com.mhm.spring.mng;

public interface PersonMng {
	public void save(String name);
	public String get(int id);
	public void delete(String id);
}

 

PersonMngImpl:

package com.mhm.spring.mng.impl;

import org.springframework.stereotype.Service;

@Service
public class PersonMngImpl implements PersonMng {

	@Override
	public void delete(String id) {
		System.out.println(id + " 已成功删除。");
	}

	@Override
	public String get(int id) {
		return "返回ID为 " + id + " 的人";
	}

	@Override
	public void save(String name) {
		//throw new RuntimeException("我是运行时异常。");
		System.out.println(name + " 已成功保存");
	}

}

 

测试:package com.mhm.spring.mng.impl;

import org.junit.AfterClass;

public class PersonMngImplTest {

	
	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		
	}

	@Test
	public void save() {
		try{
			ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
			PersonMng personMng = (PersonMng)context.getBean("personMngImpl");
			personMng.save("aa");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}

}

 

//下面是稍微复杂点的MyAOP

package com.mhm.spring.mng.impl;

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
@Aspect
public class MyAOP {

	//声明切入点
	@Pointcut("execution(* com.mhm.spring.mng.impl..*.*(..))")
	public void anyMethod(){};
	
	//前置通知
	//拦截参数为String类型的方法
	@Before("anyMethod() && args(name)")
	public void dobefore(String name) {
		System.out.println("我是前置通知。" + name);
	}
	
	//后置通知
	//拦截 返回类型为String 的方法
	@AfterReturning(pointcut="anyMethod()", returning="result")
	public void doafterReturning(String result) {
		System.out.println("result: " + result);
		System.out.println("我是后置通知。" );
	}
	
	//最终置通知
	@After("anyMethod()")
	public void doafter() {
		System.out.println("我是最终通知。");
	}
	
	//异常通知
	@AfterThrowing(pointcut="anyMethod()", throwing="ex")
	public void doexception(Exception ex) {
		System.out.println("我是异常通知: " + ex);
	}
	
	//环绕通知
	@Around("anyMethod()")
	public Object doprocess(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("我是环绕--进。");
		Object o = pjp.proceed();
		System.out.println("我是环绕--出。");
		return o;
	}
	
}
 

 

 

 

 

分享到:
评论

相关推荐

    简单spring aop 例子

    现在,我们来看如何创建一个简单的Spring AOP例子: 1. **定义切面(Aspect)**:切面是包含通知(Advice)和切入点(Pointcut)的类。通知定义了要执行的逻辑,切入点定义了何时执行。例如,我们可以创建一个名为`...

    spring aop实例annotation方法实现

    本实例将详细探讨如何通过注解(Annotation)来实现Spring AOP的方法拦截。 一、Spring AOP基础 Spring AOP是Spring框架的一部分,它提供了一种在运行时织入横切关注点(如日志、事务管理等)到目标对象的能力。AOP...

    spring aop权限小实例

    本实例将深入探讨如何在Spring AOP中实现权限控制,以提高代码的可读性和可维护性。 首先,我们要理解AOP的基本概念。AOP允许程序员定义“切面”,这些切面封装了特定的关注点,比如权限检查。然后,这些切面可以在...

    spring aop 附带测试实例

    在提供的压缩包文件"springAOP"中,可能包含了以下内容: - **切面类(Aspect Class)**:包含切点和通知的Java类,可能使用了`@Aspect`注解。 - **目标类(Target Class)**:被AOP代理的对象,通常包含业务逻辑。...

    spring aop xml 实例

    Spring AOP的XML配置实例展示了如何将横切关注点(如日志、事务等)与业务逻辑解耦,提高了代码的可复用性和可维护性。这种编程模式在大型项目中尤其有用,因为它使得系统的结构更加清晰,每个组件都专注于自己的...

    Spring AOP简单demo

    **Spring AOP 简介** Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架的一个重要模块,它扩展了传统的面向对象编程,允许开发者定义“横切关注点”(cross-cutting concerns),如日志、事务...

    spring AOP实例代码(带详细的讲解)

    Spring AOP通过两种主要实现方式提供切面功能:代理模式(Proxy)和基于注解的切面(Annotation-based AOP)。代理模式下,Spring创建一个目标对象的代理,当调用目标方法时,代理会在前后添加额外的行为。而注解...

    SpringAOP结合ehCache实现简单缓存实例

    本文将深入探讨如何结合Spring AOP与EhCache实现一个简单的缓存实例,以便优化Java应用的运行效率。 首先,让我们了解Spring AOP。Spring AOP是Spring框架的一部分,它允许我们在不修改业务代码的情况下,通过定义...

    spring aop 注解例子

    本例子就是一个使用 Spring AOP 注解实现的项目,旨在展示如何在简单的环境中应用这一特性。 1. **AOP 基础概念** - **切面(Aspect)**: 包含一组相关功能的模块,这些功能在多个对象中都可能被用到,比如日志、...

    spring aop的demo

    在`springAop1`这个压缩包中,可能包含了一个简单的应用示例,展示了如何定义一个切面类,以及如何在该类中定义通知方法。例如,我们可能会看到一个名为`LoggingAspect`的类,其中包含了`@Before`注解的方法,用于在...

    spring 2.0使用AOP实例(基于Annotation的配置方式)

    这篇博客文章将探讨如何在Spring 2.0中使用AOP实例,特别是通过注解来实现。 首先,我们需要了解AOP的基本概念。AOP的核心是切面(Aspect),它封装了横切关注点,即那些跨越多个对象的行为或责任。在Spring中,切...

    SpringAOP.zip

    Spring AOP,全称为Aspect Oriented Programming,是Spring框架中的一个重要模块,主要负责处理系统中的...文件"5.SpringAOP_01"和"6.SpringAOP_02"很可能是课程的分阶段内容,涵盖了从基础概念到进阶实践的详细讲解。

    Spring AOP + AspectJ annotation example

    在IT行业中,Spring框架是Java企业级应用开发的首选,而Spring AOP(面向切面编程)则是其重要组成部分,它允许我们分离关注点,尤其是跨切面的系统级服务,如日志、事务管理等。AspectJ是Spring AOP支持的一种强大...

    spring aop API示例

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种强大的方式来实现代码的横切关注点,如日志记录、事务管理、性能监控等。在这个"spring aop API示例"中,我们将深入探讨如何利用Spring AOP的四...

    spring aop 实现权限的简单示例

    在本示例中,我们将深入探讨如何利用Spring AOP实现简单的权限验证。 首先,AOP的核心概念是切面(Aspect),它封装了横切关注点,比如日志、事务管理、权限验证等。在Spring AOP中,切面通过通知(Advice)来定义...

    基于xml的SpringAOP实例

    Spring AOP,全称Aspect-Oriented Programming(面向切面编程),是Spring框架的重要组成部分,主要用来处理系统中的横切关注点,如日志、事务管理等。在基于XML的配置方式下,Spring AOP提供了直观且灵活的声明式...

    Spring AOP 1.0示例

    Spring AOP 1.0是Spring框架早期的一个版本,它引入了面向切面编程(Aspect Oriented Programming,AOP)的概念,使得开发者可以方便地实现横切关注点,如日志记录、事务管理、性能监控等,从而提高代码的可读性和可...

    理解Spring AOP实现与思想 案例代码

    Spring AOP(面向切面编程)是Spring框架中的一个重要特性,它允许开发者在不修改源代码的情况下,通过插入额外的代码(称为切面)来增强应用程序的功能。这主要通过代理模式实现,使得我们可以集中处理系统中横切...

    Spring_02_入门篇_AOP_简单实例

    本教程将深入探讨Spring中的核心概念之一——面向切面编程(Aspect-Oriented Programming,简称AOP),并提供基于注解和XML配置的两种实现方式的简单实例。 **一、什么是AOP** 面向切面编程(AOP)是一种编程范式...

    spring-aop.jar

    在Spring中,切面可以通过`@Aspect`注解的类来表示,如`org.springframework.aop.aspectj.annotation.AnnotationAspectAdapter`。 3. **通知(Advice)**:通知是切面中定义的行为,包括前置通知、后置通知、异常...

Global site tag (gtag.js) - Google Analytics