1。首先基于注解配置的AOP使用：（在学习Spring的AOP之前建意先去学习一下Java的JDK动态代理和CGLIB的代理技术，AOP是基于代理实现的，JDK的动态代理需要目标对象实现一个接口，若没有实现接口则可以使用CGLIB，它的代理对象是继承目标对象。）
目标对象的接口如下：
Java代码
1.public interface PersonService {
2.
3. public abstract void save(String name);
4.
5. public abstract String getPersonName(String personId);
6.
7. public abstract void deletePerson(Integer id);
8.}
目标对象(PersonServiceImple)：
Java代码
1.public class PersonServiceImple implements PersonService {
2.
3. public void save(String name) {
4. System.out.println("aop.annotation.service.imple.PersonServiceImple的save()方法");
5. // throw new RuntimeException("手动引用的一个异常信息");
6. }
7.
8. public String getPersonName(String personId) {
9.// throw new RuntimeException("手动抛出的异常信息....");
10. return "http://zmx.iteye.com";
11.
12. }
13.
14. public void deletePerson(Integer id){
15. throw new RuntimeException("手动抛出的异常信息....");
16. }
17.}
使用Spring的注解配置一个Spring的切面
Java代码
1.import org.aspectj.lang.ProceedingJoinPoint;
2.import org.aspectj.lang.annotation.After;
3.import org.aspectj.lang.annotation.AfterReturning;
4.import org.aspectj.lang.annotation.AfterThrowing;
5.import org.aspectj.lang.annotation.Around;
6.import org.aspectj.lang.annotation.Aspect;
7.import org.aspectj.lang.annotation.Before;
8.import org.aspectj.lang.annotation.Pointcut;
9.
10.//@Aspect用来标示一个类为切面
11.@Aspect
12.public class MyInterceptor {
13. // @Pointcut用来设置一个切入点。aop.annotation.service..包（子包）内的所有类，所有方法，任何参数
14. @Pointcut("execution(* aop.annotation.service.imple..*.*(..))")
15. private void anyMethod() {
16.
17. }
18.
19. // 使用@Before(切入点)用来表示目标方法执行前执行的操作（前置通知）
20. // @Before("anyMethod()")
21. @Before("anyMethod() && args(nameArg)")
22. // 使用这个方法可以获取参数。即：在原来的切入点条件上加了另一个条件即：拦截方法的参数有一个并且是String类型
23. public void doBefore(String nameArg) {
24. System.out.println("前置通知...拦截方法执行参数：" + nameArg);
25. }
26.
27. // 使用@AfterReturning(切入点)用来表示目标方法执行完执行的操作（后置通知）
28. // @AfterReturning("anyMethod()")
29. @AfterReturning(pointcut = "anyMethod()", returning = "returnArg")
30. // 使用这个方法可以获取返回结果。即：在原来的切入点条件上加了另一个条件即：拦截方法的返回值类型是String类型
31. public void doAfterReturning(String returnArg) {
32. System.out.println("后置通知...拦截方法返回结查：" + returnArg);
33. }
34.
35. // 使用@After(切入点)用来表示目标方法执行无论是否出现异常都执行的操作（最终通知）
36. @After("anyMethod()")
37. public void doFinally() {
38. System.out.println("最终通知...");
39. }
40.
41. // 使用@AfterThrowing(切入点)用来表示目标方法执行出现异常时执行的操作（例外通知）
42. // @AfterThrowing("anyMethod()")
43. @AfterThrowing(pointcut = "anyMethod()", throwing = "ex")
44. public void doException(Exception ex) {
45. System.out.println("例外通知...取获异常信息：" + ex);
46. }
47.
48.
49. // 使用@Around(切入点)用来表示整个通知（环绕通知：该方法必须接受一个org.aspectj.lang.ProceedingJoinPoint类型的参数）
50. @Around("anyMethod()")
51. public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
52. System.out.println("环绕通知之前...");
53. Object result = pjp.proceed();
54. System.out.println("环绕通知之后...");
55. return result;
56. }
57.
58.}
在Spring的配置XML中打开对象上述注解的功能和向Spring容器中注册该目标对象
Xml代码
1.<beans xmlns="http://www.springframework.org/schema/beans"
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xmlns:aop="http://www.springframework.org/schema/aop"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans
5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
6. http://www.springframework.org/schema/aop
7. http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
8. <!-- 基于注解方式的声明切面 -->
9. <aop:aspectj-autoproxy />
10.
11. <bean id="personService"
12. class="aop.annotation.service.imple.PersonServiceImple">
13. </bean>
14. <bean id="myInterceptor" class="aop.annotation.aspect.MyInterceptor"></bean>
15.
16.</beans>
测试：
Java代码
1.public static void main(String[] args) {
2. ApplicationContext ctx = new ClassPathXmlApplicationContext("beansAOP.xml");
3. PersonService personService = (PersonService) ctx.getBean("personService");
4. //personService.save("小张");//执行参数
5. personService.getPersonName("mengya");//返回结果
6. //personService.deletePerson(123);
7. }
2。首先基于XML配置的AOP使用：
目标对象接口：
Java代码
1.public interface PersonService {
2.
3. public abstract void save(String name);
4.
5. public abstract String getPersonName(String personId);
6.
7. public void deletePerson(Integer id);
8.}
目标对象：
Java代码
1.public class PersonServiceImple implements PersonService {
2.
3. public void save(String name) {
4. System.out
5. .println("aop.xml.service.imple.PersonServiceImple的save()方法");
6. // throw new RuntimeException("手动引用的一个异常信息");
7. }
8. public String getPersonName(String personId) {
9.// throw new RuntimeException("手动抛出的异常信息....");
10. return "http://zmx.iteye.com";
11.
12. }
13. public void deletePerson(Integer id){
14. throw new RuntimeException("手动抛出的异常信息....");
15. }
16.}
Spring的切面对象：
Java代码
1.public class MyInterceptor {
2.
3. public void doBefore() {
4. System.out.println("前置通知...");
5. }
6.
7. public void doAfterReturning(String returnArg) {
8. System.out.println("后置通知...拦截方法返回结查：" + returnArg);
9. }
10.
11. public void doFinally() {
12. System.out.println("最终通知...");
13. }
14.
15. public void doException(Exception ex) {
16. System.out.println("例外通知...取获异常信息：" + ex);
17. }
18.
19. public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
20. System.out.println("环绕通知之前...");
21. Object[] args = pjp.getArgs();
22. for (int i = 0; i < args.length; i++) {
23. System.out.println(args);
24. }
25. Object result = pjp.proceed();
26. System.out.println("环绕通知之后...");
27. return result;
28. }
29.
30.}
在XML配置上述内容：
Xml代码
1.<beans xmlns="http://www.springframework.org/schema/beans"
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xmlns:aop="http://www.springframework.org/schema/aop"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans
5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
6. http://www.springframework.org/schema/aop
7. http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
8.
9. <bean id="personService"
10. class="aop.xml.service.imple.PersonServiceImple">
11. </bean>
12.
13. <bean id="myInterceptor" class="aop.xml.aspect.MyInterceptor"></bean>
14.
15. <!-- AOP配置 -->
16. <aop:config>
17. <!-- 切面 -->
18. <aop:aspect id="myAspect" ref="myInterceptor">
19. <aop:pointcut id="myAnyMethod"
20. expression="execution(* aop.xml.service.imple.*.*(..))" />
21. <aop:before pointcut-ref="myAnyMethod" method="doBefore"/>
22. <aop:after-returning method="doAfterReturning" pointcut-ref="myAnyMethod" returning="returnArg"/>
23. <aop:after-throwing method="doException" pointcut-ref="myAnyMethod" throwing="ex"/>
24. <aop:after method="doFinally" pointcut-ref="myAnyMethod"/>
25. <aop:around method="doAround" pointcut-ref="myAnyMethod"/>
26. </aop:aspect>
27. </aop:config>
28.
29.</beans>
测试：
Java代码
1.public static void main(String[] args) {
2. ApplicationContext ctx = new ClassPathXmlApplicationContext(
3. "beansAOP2.xml");
4. PersonService personService = (PersonService) ctx.getBean("personService");
5.// personService.save("AOP");
6. personService.getPersonName("123");
7.
8. }
分享到：
相关推荐
在基于XML的配置方式下，Spring AOP提供了直观且灵活的声明式方法来实现这些关注点的分离，使得业务逻辑代码更为简洁。 在Spring AOP中，我们首先需要定义一个切面（Aspect），它包含了若干个通知（Advice）。通知...
下面将详细介绍Spring AOP的注解方式和XML配置方式。 ### 注解方式 #### 1. 定义切面（Aspect） 在Spring AOP中，切面是包含多个通知（advisors）的类。使用`@Aspect`注解标记切面类，例如： ```java @Aspect ...
Spring AOP，即Spring的面向切面编程，是Spring框架中的一个重要组成部分，它提供了一种在不修改原有代码的情况下，对程序...虽然现在更多地使用注解式配置，但理解XML配置方式对于全面掌握Spring AOP仍然至关重要。
然而，随着Spring的发展，基于注解的AOP配置逐渐成为主流，因为它的简洁性和可读性更强。但这并不意味着XML配置方式失去了价值，尤其是在需要更细粒度控制或者与旧项目集成时，XML配置依然有着其独特的优势。 总的...
在使用Spring AOP时，我们可以通过XML配置或注解的方式来定义切面。例如，可以使用`@Aspect`注解定义一个切面类，`@Before`、`@After`等注解来声明通知，`@Pointcut`定义切点表达式。 在实际开发中，Spring AOP广泛...
Spring AOP有两种实现方式：基于代理的AOP（JDK动态代理和CGLIB代理）和基于注解的AOP。 - **JDK动态代理**：当目标类实现了接口时，Spring会使用JDK的Proxy类创建一个代理对象，该代理对象会在调用接口方法时插入...
本篇文章将深入探讨如何在Spring MVC中配置和使用基于注解的AOP。 一、Spring AOP基础知识 1. **切面（Aspect）**：切面是关注点的模块化，例如日志、事务管理等。在Spring AOP中，切面可以是Java类或@Aspect注解...
在Spring框架中，AOP的实现有两种主要方式：一种是基于XML配置，另一种是基于注解。本篇将主要讨论如何通过注解方式来实现AOP编程。 首先，我们需要了解Spring中的核心注解。`@Aspect`是定义一个切面的注解，通常会...
实验主题涉及Spring AOP（面向切面编程）的两种实现方式——基于XML配置和基于注解的编程，用于模拟银行账户的存钱和取钱操作。AOP的主要目的是分离关注点，将业务逻辑与横切关注点（如日志、事务管理等）解耦。 一...
本教程将探讨如何在Spring中结合AspectJ实现AOP，包括基于XML配置和基于注解的方式。 **一、AOP基本概念** AOP的核心概念有切面（Aspect）、连接点（Join Point）、通知（Advice）、切点（Pointcut）和引入...
压缩包中的`SpringAOPTest`可能包含了一个Spring AOP的示例，包括了注解和XML配置的两种方式。通过分析这个测试案例，你可以了解如何在实际项目中实现AOP。例如，它可能包含了一个带有切面逻辑的切面类，使用了`@...
在Java开发领域，Spring框架是不可或缺的一部分，尤其在企业级应用中广泛使用。Spring AOP（面向切面编程）提供了一种优雅的方式来处理系统中的横切关注点，如日志、事务管理等。本篇文章将深入探讨如何在Spring中...
Spring支持两种AOP的实现方式：Spring AspectJ注解风格和Spring XML配置风格。使用AspectJ注解风格是最常见的，它允许开发者直接在方法上使用注解来定义切面。 Spring AOP中有五种不同类型的的通知（Advice）： 1....
Spring AOP主要通过两种方式实现：XML配置和注解。本实例主要探讨的是使用XML配置的方式来实现AOP。XML配置虽然相比注解方式略显繁琐，但它提供了更大的灵活性，尤其是在需要对多个类或方法应用相同通知（Advice）时...
**Spring AOP 管理XML版详解** 在Spring框架中，面向切面编程（Aspect Oriented Programming，简称AOP）是一种重要的设计模式，它扩展了传统的面向对象编程（OOP），使得我们可以将关注点分离，特别是那些横切关注...
在Spring XML配置中，我们可以使用`<aop:config>`元素来定义切点表达式，然后使用`<aop:aspect>`元素来声明切面，并将通知方法与切点关联起来。此外，还可以使用注解驱动的配置，通过`@EnableAspectJAutoProxy`注解...
通过以上步骤，我们就成功地使用XML配置完成了Spring AOP的开发。这种方式虽然相对繁琐，但它清晰地展示了AOP的各个组成部分，有利于理解和学习。然而，在实际开发中，更常见的是使用注解驱动的AOP，因为其更简洁且...
Spring AOP就是基于这些接口进行设计的，因此这个库是Spring AOP和其他AOP实现之间协作的基础。 在实际使用中，我们需要在项目的类路径下包含这些Jar包，并在Spring配置文件中启用AOP支持。例如，可以通过以下XML...
在Spring框架中，AOP通过代理实现，可以使用XML配置或注解进行配置。本篇文章主要聚焦于Spring AOP的XML配置通知。 **一、AOP概念解析** 1. **切面（Aspect）**：一个关注点的模块化，例如事务管理就是一个切面。...