前言: 
在上一篇中: [Spring框架]Spring AOP基础入门总结一. 中 我们已经知道了一个Spring AOP程序是如何开发的, 在这里呢我们将基于AspectJ来进行AOP 的总结和学习.

一, AspectJ的概述:

AspectJ是一个面向切面的框架,它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。

Spring为了简化自身的AOP的开发,将AspectJ拿过来作为Spring自身一个AOP的开发.

二, Spring AspectJ开发实例

2.1 开发所需jar包

2.2 AspectJ 注解开发规范

2.2.1 @AspectJ提供不同的通知类型

@Before 前置通知,相当于BeforeAdvice
  在执行目标方法之前完成一个操作,获得到切入点信息.

@AfterReturning 后置通知,相当于AfterReturningAdvice

 在目标方法执行之后完成一个操作,获得方法的返回值.

 @AfterReturning(value="execution(* cn.augmentum.aspectj.demo1.CustomerService+.update(..))",returning="result")
public void afterReturing(Object result){
System.out.println("后置通知============"+result);
}

@Around 环绕通知,相当于MethodInterceptor

 在目标方法执行的前和执行后完成一个操作,阻止目标方法执行.

 @Around(value="execution(* cn.augmentum.aspectj.demo1.CustomerService+.delete(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("环绕前通知==========");
Object obj = joinPoint.proceed();
System.out.println("环绕后通知==========");
return obj;
}


@AfterThrowing抛出通知,相当于ThrowAdvice

 在目标方法出现异常的时候,完成一个操作.获得异常信息.

 @AfterThrowing(value="execution(* cn.itcast.aspectj.demo1.CustomerService+.find(..))",throwing="e")
public void afterThrowing(Throwable e){
System.out.println("异常抛出通知========="+e.getMessage());
}

@After 最终final通知,不管是否异常,该通知都会执行

 在目标方法任何情况下都会执行的操作.相当于finally中的代码.

 @After(value="execution(* cn.itcast.aspectj.demo1.CustomerService+.find(..))")
public void after(){
System.out.println("最终通知===========");
}


2.2.2 通过配置启用@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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 开启AspectJ自动代理-->
<aop:aspectj-autoproxy />
</beans>

2.2.3 在通知中通过value属性定义切点

通过execution函数,可以定义切点的方法切入
语法:
  execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
例如
  匹配所有类public方法 execution(public * *(..))
  匹配指定包下所有类方法 execution(* cn.itcast.dao.*(..)) 不包含子包
  execution(* cn.itcast.dao..*(..)) ..*表示包、子孙包下所有类
  匹配指定类所有方法 execution(* cn.itcast.service.UserService.*(..))
  匹配实现特定接口所有类方法 execution(* cn.itcast.dao.GenericDAO+.*(..))
  匹配所有save开头的方法 execution(* save*(..))

2.2.4 AspectJ的切入点:

 统一管理切入点的表达式.
@Pointcut(value="execution(* cn.itcast.aspectj.demo1.CustomerService+.find(..))")
private void myPointcut1(){} //这个类没有实际用途, 只是为了@Pointcut 注解


2.2.6 Aspect和Advisor的区别:

Advisor :传统的切面.传统切面一般都是由一个切入点和一个通知的组合.
Aspect :真正意义上的切面.由多个切入点和多个通知的组合.

2.3 Spring AspctJ 基于注解模式的开发
CustomerService.java:

 public interface CustomerService {

     public void save();
public Integer update();
public void delete();
public void find();
}

CustomerServiceImpl.java:

 public class CustomerServiceImpl implements CustomerService {

     @Override
public void save() {
System.out.println("保存客户...");
} @Override
public Integer update() {
System.out.println("修改客户...");
return 100;
} @Override
public void delete() {
System.out.println("删除客户...");
} @Override
public void find() {
System.out.println("查询客户...");
int d = 1 / 0;
} }

MyAspectAnno.java:

 /**
* 自定义切面类:
*
*/
@Aspect
public class MyAspectAnno { @Before(value="execution(* cn.augmentum.aspectj.demo1.CustomerService+.save(..))")
public void before(JoinPoint joinPoint){
System.out.println("前置通知============"+joinPoint);
} @AfterReturning(value="execution(* cn.augmentum.aspectj.demo1.CustomerService+.update(..))",returning="result")
public void afterReturing(Object result){
System.out.println("后置通知============"+result);
} @Around(value="execution(* cn.augmentum.aspectj.demo1.CustomerService+.delete(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("环绕前通知==========");
Object obj = joinPoint.proceed();
System.out.println("环绕后通知==========");
return obj;
} @AfterThrowing(value="MyAspectAnno.myPointcut1()",throwing="e")
public void afterThrowing(Throwable e){
System.out.println("异常抛出通知========="+e.getMessage());
} @After(value="MyAspectAnno.myPointcut1()")
public void after(){
System.out.println("最终通知===========");
} @Pointcut(value="execution(* cn.augmentum.aspectj.demo1.CustomerService+.find(..))")
private void myPointcut1(){}
}

SpringDemo.java 测试类:

 @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo1 { @Resource(name = "customerService")
private CustomerService customerService; @Test
public void demo1() {
customerService.save();
customerService.update();
customerService.delete();
customerService.find();
}
}

applicationContext.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.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 使用注解完成AOP的开发 -->
<aop:aspectj-autoproxy/> <!-- 目标对象 -->
<bean id="customerService" class="cn.augmentum.aspectj.demo1.CustomerServiceImpl"/> <!-- 配置切面 -->
<bean id="myAspectAnno" class="cn.augmentum.aspectj.demo1.MyAspectAnno"/>
</beans>

2.4 Spring AspctJ 基于xml模式的开发

OrderService.java:

 public class OrderService {
public void save(){
System.out.println("保存订单...");
}
public Integer update(){
System.out.println("修改订单...");
return 200;
}
public void delete(){
System.out.println("删除订单...");
}
public void find(){
System.out.println("查询订单...");
//int d = 1/ 0;
}
}

MyAspectXml.java:

 public class MyAspectXml {

     public void before(){
System.out.println("前置通知===========");
} public void afterReturing(Object result){
System.out.println("后置通知==========="+result);
} public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("环绕前通知==========");
Object obj = joinPoint.proceed();
System.out.println("环绕后通知==========");
return obj;
} public void afterThrowing(Throwable e){
System.out.println("异常抛出通知========"+e.getMessage());
} public void after(){
System.out.println("最终通知==========");
}
}

SpringDemo.java 测试类:

 @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo2 { @Resource(name="orderService")
private OrderService orderService; @Test
public void demo1(){
orderService.save();
orderService.update();
orderService.delete();
orderService.find();
}
}

applicationContext.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.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 配置目标类 -->
<bean id="orderService" class="cn.augmentum.aspectj.demo2.OrderService"></bean> <!-- 配置切面 -->
<bean id="myAspectXml" class="cn.augmentum.aspectj.demo2.MyAspectXml"></bean> <!-- AOP的配置 -->
<aop:config>
<aop:pointcut expression="execution(* cn.augmentum.aspectj.demo2.OrderService.save(..))" id="pointcut1"/>
<aop:pointcut expression="execution(* cn.augmentum.aspectj.demo2.OrderService.update(..))" id="pointcut2"/>
<aop:pointcut expression="execution(* cn.augmentum.aspectj.demo2.OrderService.delete(..))" id="pointcut3"/>
<aop:pointcut expression="execution(* cn.augmentum.aspectj.demo2.OrderService.find(..))" id="pointcut4"/>
<aop:aspect ref="myAspectXml">
<aop:before method="before" pointcut-ref="pointcut1"/>
<aop:after-returning method="afterReturing" pointcut-ref="pointcut2" returning="result"/>
<aop:around method="around" pointcut-ref="pointcut3"/>
<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="e"/>
<aop:after method="after" pointcut-ref="pointcut4"/>
</aop:aspect>
</aop:config>
</beans>

OK. 到了这里Spring 基于AOP的开发也总结完了, 学习之路漫漫, 谨以此记录成长的过程!

[Spring框架]Spring AOP基础入门总结二:Spring基于AspectJ的AOP的开发.的更多相关文章

  1. [Spring框架]Spring AOP基础入门总结一.

    前言:前面已经有两篇文章讲了Spring IOC/DI 以及 使用xml和注解两种方法开发的案例, 下面就来梳理一下Spring的另一核心AOP. 一, 什么是AOP 在软件业,AOP为Aspect ...

  2. Spring 基于 AspectJ 的 AOP 开发

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

  3. PHP基础入门(二)【PHP函数基础】

    PHP基础入门(二)--函数基础 了解 PHP基础入门详解(一) 后,给大家分享一下PHP的函数基础. 这部分主要讲的就是: 函数的声明与使用.PHP中变量的作用域.静态变量.函数的参数传递.变量函数 ...

  4. Oracle数据库基础入门《二》Oracle内存结构

    Oracle数据库基础入门<二>Oracle内存结构 Oracle 的内存由系统全局区(System Global Area,简称 SGA)和程序全局区(Program Global Ar ...

  5. MyBatis基础入门《二十》动态SQL(foreach)

    MyBatis基础入门<二十>动态SQL(foreach) 1. 迭代一个集合,通常用于in条件 2. 属性 > item > index > collection : ...

  6. MyBatis基础入门《二》Select查询

    MyBatis基础入门<二>Select查询 使用MySQL数据库,创建表: SET NAMES utf8mb4; ; -- ---------------------------- -- ...

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

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

  8. Spring基础入门(二)

    一.AOP 1.AOP概念 aop:面向切面编程,扩展功能不修改源代码实现. AOP采取横向抽取机制,取代了传统纵向继承体系重复性代码. 2.AOP原理 (1)第一种情况,有接口情况,使用动态代理创建 ...

  9. 深入学习Spring框架(一)- 入门

    1.Spring是什么? Spring是一个JavaEE轻量级的一站式开发框架. JavaEE: 就是用于开发B/S的程序.(企业级) 轻量级:使用最少代码启动框架,然后根据你的需求选择,选择你喜欢的 ...

随机推荐

  1. BZOJ 2229 最小割

    题目链接:http://61.187.179.132/JudgeOnline/problem.php?id=2229 题意:给定一个带权无向图.若干询问,每个询问回答有多少点对(s,t)满足s和t的最 ...

  2. vi编辑器的常见使用技巧

    光标移动 在普通模式下, 1.按 h 向左移动光标 按 h + 数字n 可以向右移动 n个字符   比如 h + 5  就是向左移动5个字符 2.按j向下移动光标 3.按k向上移动光标 4.按 l 向 ...

  3. 【UVA10829】 L-Gap Substrings (后缀数组)

    Description If a string is in the form UVU, where U is not empty, and V has exactly L characters, we ...

  4. 3D游戏开发之在UE4中创建非玩家角色(NPC)

    接着上节我们继续学习,现在我们来创建一些NPC(non-playable characters,非玩家角色).在这个游戏中,当我们靠近NPC时,它们会做出相应的反应. 一 创建C++类 1) 在UE编 ...

  5. HDU2579

    Dating with girls(2) Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Oth ...

  6. Node.js 虚拟机

    稳定性: 3 - 稳定 可以通过以下方法访问该模块: var vm = require('vm'); JavaScript 可以立即编译立即执行,也可以编译,保存,之后再运行. vm.runInThi ...

  7. 为啥程序会有bug?

    如果这是第二次看到我的文章,欢迎右侧扫码订阅我哟~ 

  8. php--include 、require

    一.include .require 定义:包含并运行指定文件 问题:查询了这两个语言结构的资料,有人说,什么require  先执行,什么include后执行. 思考:我觉得官方文档已经解释的很清楚 ...

  9. python文件读写,以后就用with open语句

    读写文件是最常见的IO操作.Python内置了读写文件的函数,用法和C是兼容的. 读写文件前,我们先必须了解一下,在磁盘上读写文件的功能都是由操作系统提供的,现代操作系统不允许普通的程序直接操作磁盘, ...

  10. 照片管家iOS-实现本地相册、视频、安全保护、社交分享源码下载Demo

    <照片管家> APP功能: 1.本地照片批量导入与编辑 2.本地视频存储与播放 3.手势密码.数字密码.TouchID安全保护 4.QQ.微信.微博.空间社交分享 5.其他细节功能. 运用 ...