一:你应该明白的知识

1.对于AOP这种编程思想,很多框架都进行了实现。Spring就是其中之一,可以完成面向切面编程。然而,AspectJ也实现了AOP的功能,且实现方式更为简捷,使用更加方便,而且还支持注解式开发。所以,Spring又将AspectJ对于AOP的实现也引入到了自己的框架中。在Spring中使用AOP开发时,一般使用AspectJ的实现方式。

2.Spring的经典AOP配置方案
  01.使用的是Aspectj第三方框架,实现了AOP思想
  02.注解配置的AOP
  03.纯POJO <aop:config>

3..切入点表达式
execution(【modifiers-pattern?】 访问修饰符
ret-type-pattern 返回值类型
【declaring-type-pattern?】 全限定性类名
name-pattern(param-pattern) 方法名(参数名)
【throws-pattern?】) 抛出异常类型

切入点表达式要匹配的对象就是目标方法的方法名。所以,execution表达式中明显就是方法的签名。注意:表达式中加[]的部分表示可省略部分,各部分间用空格分开。在其中可以使用以下符号:
符号       意义
*      0至多个任意字符
..     用在方法参数中,表示任意多个参数

用在包名后,表示当前包及其子包路径
+    用在类名后,表示当前类及其子类
       用在接口后,表示当前接口及其实现类
案例:
execution(public * *(..)) 指定切入点为:任意公共方法
execution(* set*(..)) 指定切入点为:任何一个以"set"开始的方法

二.使用的是Aspectj第三方框架注解配置的AOP增强

源码介绍:

1.ISomeService.java

  1. package entity;
  2. //业务接口
  3. public interface ISomeService {
  4. //1.1 执行事务
  5. public void doTransaction();
  6. //1.2 书写日志
  7. public String doLog();
  8. }

2.SomeServiceImpl.java

  1. package entity;
  2. //接口的实现类
  3. public class SomeServiceImpl implements ISomeService {
  4. //实现接口中的方法
  5. @Override
  6. public void doTransaction() {
  7. System.out.println("----开启事务----");
  8. }
  9.  
  10. @Override
  11. public String doLog() {
  12. //int i=5/0;//制造一个错误,用于测试异常增强
  13. System.out.println("---书写日志-----");
  14. return "abc";
  15. }
  16.  
  17. }

3.MyAspect.java(使用的是Aspectj第三方框架注解配置的AOP增强)

  1. package aop;
  2. //aspectj注解实现aop增强
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.AfterReturning;
  6. import org.aspectj.lang.annotation.AfterThrowing;
  7. import org.aspectj.lang.annotation.Around;
  8. import org.aspectj.lang.annotation.Aspect;
  9. import org.aspectj.lang.annotation.Before;
  10.  
  11. //该类为切面
  12. @Aspect
  13. public class MyAspect {
  14.  
  15. // 前置通知
  16. @Before(value = "execution(public * *..ISomeService.doLog(..))")
  17. public void myBefore() {
  18. System.out.println("这是前置增强");
  19. }
  20.  
  21. // 后置通知
  22. @AfterReturning(value = "execution(public * *..ISomeService.doLog(..))")
  23. public void myAfterReturning() {
  24. System.out.println("这是后置增强");
  25. }
  26.  
  27. // 环绕增强
  28. @Around(value = "execution(public * *..ISomeService.doLog(..))")
  29. public void myAround(ProceedingJoinPoint pjp) throws Throwable {
  30. System.out.println("这是环绕前置增强");
  31.  
  32. pjp.proceed();
  33.  
  34. System.out.println("这是环绕后置增强");
  35. }
  36.  
  37. // 异常增强
  38. @AfterThrowing(value = "execution(public * *..ISomeService.doLog(..))")
  39. public void myAfterThrowing() {
  40. System.out.println("这是异常增强");
  41. }
  42.  
  43. // 最终增强
  44. @After(value = "execution(public * *..ISomeService.doLog(..))")
  45. public void myAfter() {
  46. System.out.println("这是最终增强");
  47. }
  48. }

4.applicationContext.xml(Spring的配置文件)

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:aop="http://www.springframework.org/schema/aop"
  6. xsi:schemaLocation="
  7. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  8. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
  9. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
  10.  
  11. <!-- 目标对象 -->
  12. <bean id="someService" class="entity.SomeServiceImpl"></bean>
  13.  
  14. <!-- 切面: -->
  15. <bean id="myAspect" class="aop.MyAspect"></bean>
  16.  
  17. <!-- 自动代理 -->
  18. <aop:aspectj-autoproxy/>
  19. </beans>

5.MyTest.java

  1. package test;
  2. //测试类
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5.  
  6. import entity.ISomeService;
  7.  
  8. public class MyTest {
  9. public static void main(String[] args) {
  10. ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  11. ISomeService biz=(ISomeService)ctx.getBean("someService");
  12. biz.doLog();
  13. biz.doTransaction();
  14. System.out.println("success!");
  15. }
  16.  
  17. }

6.log4j.properties(日志配置文件)

  1. ### direct log messages to stdout ###
  2. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  3. log4j.appender.stdout.Target=System.out
  4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
  6.  
  7. ### direct messages to file mylog.log ###
  8. log4j.appender.file=org.apache.log4j.FileAppender
  9. log4j.appender.file.File=c\:mylog.log
  10. log4j.appender.file.layout=org.apache.log4j.PatternLayout
  11. log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
  12.  
  13. ### set log levels - for more verbose logging change 'info' to 'debug' ###
  14.  
  15. log4j.rootLogger=info, stdout

7.当然,同志们别忘了引入jar包啊!

8.其测试结果展示:

三:使用的是Aspectj第三方框架 纯POJO 基于Schema配置 (<aop:config>)

源码介绍:

1.MyAspect.java

  1. package aop;
  2.  
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5.  
  6. public class MyAspect {
  7. // 前置通知
  8. public void myBefore() {
  9. System.out.println("这是前置增强");
  10. }
  11.  
  12. public void before(JoinPoint jp) {
  13. System.out.println("前置通知方法before() jp = " + jp);
  14. }
  15.  
  16. // 后置通知
  17. public void myAfterReturning() {
  18. System.out.println("这是后置增强");
  19. }
  20.  
  21. // 带参数
  22. public void afterReturing(String result) {
  23. System.out.println("后置通知方法 result = " + result);
  24. }
  25.  
  26. // 环绕通知
  27. public Object around(ProceedingJoinPoint pjp) throws Throwable {
  28. System.out.println("环绕通知方法,目标方法执行之前");
  29. // 执行目标方法
  30. Object result = pjp.proceed();
  31. System.out.println("环绕通知方法,目标方法执行之后");
  32. return ((String) result).toUpperCase();
  33. }
  34.  
  35. // 异常通知
  36. public void afterThrowing() {
  37. System.out.println("异常通知方法");
  38. }
  39.  
  40. public void afterThrowing(Exception ex) {
  41. System.out.println("异常通知方法 ex = " + ex.getMessage());
  42. }
  43.  
  44. // 最终通知
  45. public void after() {
  46. System.out.println("最终通知方法");
  47. }
  48. }

2.applicationContext.xml(Spring的配置文件)

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4. xmlns:aop="http://www.springframework.org/schema/aop"
  5. xsi:schemaLocation="
  6. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  7. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
  8. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
  9. <!-- 目标对象 -->
  10. <bean id="someService" class="entity.SomeServiceImpl"></bean>
  11.  
  12. <!-- 切面: -->
  13. <bean id="myAspect" class="aop.MyAspect"></bean>
  14.  
  15. <aop:config>
  16. <!--expression:切入点表达式 -->
  17. <aop:pointcut expression="execution(public * *..ISomeService.doLog(..))"
  18. id="beforePointcut" />
  19. <aop:aspect ref="myAspect"><!-- ref:指定切面 -->
  20. <!-- method:指定切面类中的方法; pointcut-ref:指定定义的切点 -->
  21. <!-- 前置增强 -->
  22. <aop:before method="myBefore" pointcut-ref="beforePointcut" />
  23. <!-- 前置增强 带参 -->
  24. <aop:before method="before(org.aspectj.lang.JoinPoint)"
  25. pointcut-ref="beforePointcut" />
  26. <!-- 后置增强 -->
  27. <aop:after-returning method="myAfterReturning"
  28. pointcut-ref="beforePointcut" />
  29. <!-- 后置增强 带参 -->
  30. <aop:after-returning method="afterReturing(java.lang.String)"
  31. pointcut-ref="beforePointcut" returning="result" />
  32. <!-- 环绕增强 -->
  33. <aop:around method="around" pointcut-ref="beforePointcut" />
  34. <!-- 异常增强 -->
  35. <aop:after-throwing method="afterThrowing"
  36. pointcut-ref="beforePointcut" />
  37. <!-- 异常增强 带参 -->
  38. <aop:after-throwing method="afterThrowing(java.lang.Exception)"
  39. pointcut-ref="beforePointcut" throwing="ex" />
  40. <!-- 最终增强 -->
  41. <aop:after method="after" pointcut-ref="beforePointcut" />
  42. </aop:aspect>
  43. </aop:config>
  44. </beans>

其中,其他的类和文件和上面的例子中完全相同。这里则不做介绍。

3.其测试结果展示:

AspectJ对AOP的实现的更多相关文章

  1. Spring @AspectJ 实现AOP 入门例子(转)

    AOP的作用这里就不再作说明了,下面开始讲解一个很简单的入门级例子. 引用一个猴子偷桃,守护者守护果园抓住猴子的小情节. 1.猴子偷桃类(普通类): package com.samter.common ...

  2. Spring框架(6)---AspectJ实现AOP

    AspectJ实现AOP 上一篇文章Spring框架(4)---AOP讲解铺垫,讲了一些基础AOP理解性的东西,那么这篇文章真正开始讲解AOP 通过AspectJ实现AOP要比普通的实现Aop要方便的 ...

  3. 使用java5的注解和Sping/AspectJ的AOP 来实现Memcached的缓存

    使用java5的注解和Sping/AspectJ的AOP 来实现Memcached的缓存 今天要介绍的是Simple-Spring-Memcached,它封装了对MemCached的调用,使MemCa ...

  4. 8 -- 深入使用Spring -- 4...2 使用AspectJ实现AOP

    8.4.2 使用AspectJ实现AOP AspectJ是一个基于Java语言的AOP框架.Spring 4.0 的AOP对AspectJ很好的集成. AspectJ是Java 语言的一个AOP实现, ...

  5. spring3: schema的aop与Aspectj的aop的区别

    schema的aop如下: 接口: package chapter6.service; public interface IHelloAroundService { public void sayAr ...

  6. Spring整合AspectJ的AOP

    学而时习之,不亦说乎!                              --<论语> 看这一篇之前最好先看前面关于AOP的两篇. http://www.cnblogs.com/z ...

  7. 利用基于@AspectJ的AOP实现权限控制

    一. AOP与@AspectJ AOP 是 Aspect Oriented Programming 的缩写,意思是面向方面的编程.我们在系统开发中可以提取出很多共性的东西作为一个 Aspect,可以理 ...

  8. (转)Spring使用AspectJ进行AOP的开发:注解方式

    http://blog.csdn.net/yerenyuan_pku/article/details/69790950 Spring使用AspectJ进行AOP的开发:注解方式 之前我已讲过Sprin ...

  9. Spring 基于 AspectJ 的 AOP 开发

    Spring 基于 AspectJ 的 AOP 开发 在 Spring 的 aop 代理方式中, AspectJ 才是主流. 1. AspectJ 简介 AspectJ 是一个基于 java 语言的 ...

随机推荐

  1. 发现一个百度的密码。。。记最近一段时间的php感想

    请看图. 突然想看一下百度的cookie. 最近百度一年真是多攒多难,我一直挺百度啊.百度文化就是程序员文化,但是收到中国其他文化的侵蚀,不得不变, 任何人重构系统,都会有大概百分三十左右的性能提升. ...

  2. iOS--------坐标系统(UIView的frame、bounds跟center属性)

    1.概要翻开ios官方开发文档,赫然发现上面对这三个属性的解释如下: frame:描述当前视图在其父视图中的位置和大小. bounds:描述当前视图在其自身坐标系统中的位置和大小. center:描述 ...

  3. Hadoop学习笔记【分布式文件系统学习笔记】

    分布式文件系统介绍 分布式文件系统:Hadoop Distributed File System,简称HDFS. 一.HDFS简介 Hadoop分布式文件系统(HDFS)被设计成适合运行在通用硬件(c ...

  4. KnockoutJS 3.X API 第四章(14) 绑定语法细节

    data-bind绑定语法 Knockout的声明性绑定系统提供了一种简洁而强大的方法来将数据链接到UI. 绑定到简单的数据属性或使用单个绑定通常是容易和明显的. 对于更复杂的绑定,它有助于更好地了解 ...

  5. Windows Server 2012部署Enterprise Solution 5.4

    最近一个客户升级系统,改用Windows Server 2012作为服务器操作系统.升级之后性能未见明显的改善,在不改变代码的基础上,考虑到C/S架构的能力,增加内存或是处理器的处理能力似乎可以解决一 ...

  6. C# 集合类 :(Array、 Arraylist、List、Hashtable、Dictionary、Stack、Queue)

    我们用的比较多的非泛型集合类主要有 ArrayList类 和 HashTable类.我们经常用HashTable 来存储将要写入到数据库或者返回的信息,在这之间要不断的进行类型的转化,增加了系统装箱和 ...

  7. hibernate(七)组件映射与多对一映射

    一.组件映射 用注解配置组件映射: Husband为我们映射的类,wife是这个类的一部分(属性不能与husband中属性重名,不要写Entity注解,不要有主键) Husband类:(在getWif ...

  8. java中线程存活和线程执行的问题!

    /* 下面的程序会出现下面的情况,当Thread-0, Thread-1, Thread-2都被wait的时候,可能会同时苏醒 Thread-0 put Thread-1 put Thread-2 p ...

  9. List和Dictionary泛型类查找效率浅析

    List和Dictionary泛型类查找效率存在巨大差异,前段时间亲历了一次.事情的背景是开发一个匹配程序,将书籍(BookID)推荐给网友(UserID),生成今日推荐数据时,有条规则是同一书籍七日 ...

  10. MemCache在win7上的可视化配置以及Nodejs/Net应用

    惯例科普:MemCache是一套分布式的高速缓存系统,由LiveJournal的Brad Fitzpatrick开发,但目前被许多网站使用以提升网站的访问速度,尤其对于一些大型的.需要频繁访问数据库的 ...