文档章节

(一)spring aop的两种配置方式。

o
 osc_wws45aot
发布于 2019/08/20 15:41
字数 2190
阅读 17
收藏 0

精选30+云产品,助力企业轻松上云!>>>

  sring aop的方式有两种:(1)xml文件配置方式(2)注解的方式实现,我们可以先通过一个demo认识spring aop的实现,然后再对其进行详细的解释。

一、基于注解的springAop配置。

   环境准备阶段:

   (1)pom.xml:

 1 <dependencies>
 2         <!-- 引入Spring-AOP等相关Jar -->
 3         <dependency>
 4             <groupId>org.springframework</groupId>
 5             <artifactId>spring-core</artifactId>
 6             <version>3.0.6.RELEASE</version>
 7         </dependency>
 8         <dependency>
 9             <groupId>org.springframework</groupId>
10             <artifactId>spring-context</artifactId>
11             <version>3.0.6.RELEASE</version>
12         </dependency>
13         <dependency>
14             <groupId>org.springframework</groupId>
15             <artifactId>spring-aop</artifactId>
16             <version>3.0.6.RELEASE</version>
17         </dependency>
18         <dependency>
19             <groupId>org.springframework</groupId>
20             <artifactId>spring-orm</artifactId>
21             <version>3.0.6.RELEASE</version>
22         </dependency>
23         <dependency>
24             <groupId>org.aspectj</groupId>
25             <artifactId>aspectjrt</artifactId>
26             <version>1.6.1</version>
27         </dependency>
28         <dependency>
29             <groupId>aspectj</groupId>
30             <artifactId>aspectjweaver</artifactId>
31             <version>1.5.3</version>
32         </dependency>
33         <dependency>
34             <groupId>cglib</groupId>
35             <artifactId>cglib</artifactId>
36             <version>2.1_2</version>
37         </dependency>
38 
39         <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
40         <dependency>
41             <groupId>com.mchange</groupId>
42             <artifactId>c3p0</artifactId>
43             <version>0.9.5.2</version>
44         </dependency>
45         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
46         <dependency>
47             <groupId>mysql</groupId>
48             <artifactId>mysql-connector-java</artifactId>
49             <version>5.1.37</version>
50         </dependency>
51 
52         <!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
53         <dependency>
54             <groupId>dom4j</groupId>
55             <artifactId>dom4j</artifactId>
56             <version>1.6.1</version>
57         </dependency>
58         <!-- https://mvnrepository.com/artifact/commons-lang/commons-lang -->
59         <dependency>
60             <groupId>commons-lang</groupId>
61             <artifactId>commons-lang</artifactId>
62             <version>2.6</version>
63         </dependency>
64     </dependencies>

 (2)定义接口:

 1 package cn.spring.aop.dao;
 2 
 3 /**
 4  * @author Simple
 5  * @date 10:01 2019/8/20
 6  * @description
 7  */
 8 public interface UserService {
 9     public void save();
10 }

 (3)接口实现类:

 1 package cn.spring.aop.dao;
 2 
 3 import org.springframework.stereotype.Service;
 4 
 5 /**
 6  * @author Simple
 7  * @date 9:57 2019/8/20
 8  * @description
 9  */
10 @Service
11 public class UserServiceImpl implements UserService {
12 
13     @Override
14     public void save() {
15         System.out.println("保存成功.....");
16     }
17 }

 (4)Aop类: 

 1 package cn.spring.aop;
 2 
 3 import org.aspectj.lang.ProceedingJoinPoint;
 4 import org.aspectj.lang.annotation.*;
 5 import org.springframework.stereotype.Component;
 6 
 7 /**
 8  * @author Simple
 9  * @date 10:06 2019/8/20
10  * @description
11  */
12 @Component
13 @Aspect
14 public class AopAspect {
15     /**
16      * 前置通知
17      */
18     @Before("execution(* cn.spring.aop.dao.UserService.save(..))")
19     public void before(){
20         System.out.println("前置通知....");
21     }
22 
23     /**
24      * 后置通知
25      * returnVal,切点方法执行后的返回值
26      */
27     @AfterReturning(value="execution(* cn.spring.aop.dao.UserService.save(..))",returning = "returnVal")
28     public void AfterReturning(Object returnVal){
29         System.out.println("后置通知...."+returnVal);
30     }
31 
32 
33     /**
34      * 环绕通知
35      * @param joinPoint 可用于执行切点的类
36      * @return
37      * @throws Throwable
38      */
39     @Around("execution(* cn.spring.aop.dao.UserService.save(..))")
40     public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
41         System.out.println("环绕通知前....");
42         Object obj= (Object) joinPoint.proceed();
43         System.out.println("环绕通知后....");
44         return obj;
45     }
46 
47     /**
48      * 抛出通知
49      * @param e
50      */
51     @AfterThrowing(value="execution(* cn.spring.aop.dao.UserService.save(..))",throwing = "e")
52     public void afterThrowable(Throwable e){
53         System.out.println("出现异常:msg="+e.getMessage());
54     }
55 
56     /**
57      * 无论什么情况下都会执行的方法
58      */
59     @After(value="execution(* cn.spring.aop.dao.UserService.save(..))")
60     public void after(){
61         System.out.println("最终通知....");
62     }
63 }

 (5)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        xmlns:context="http://www.springframework.org/schema/context"
 5        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 6         http://www.springframework.org/schema/aop
 7         http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 8     <!-- 开启注解扫描 -->
 9       <context:component-scan base-package="cn.spring.aop"></context:component-scan>
10     <!-- 启动@aspectj的自动代理支持-->
11       <aop:aspectj-autoproxy />
12 </beans>

 (6)测试类:

 1 package cn.spring.aop;
 2 
 3 import cn.spring.aop.dao.UserService;
 4 import cn.spring.aop.dao.UserServiceImpl;
 5 import org.springframework.context.ApplicationContext;
 6 import org.springframework.context.support.ClassPathXmlApplicationContext;
 7 
 8 /**
 9  * @author Simple
10  * @date 10:13 2019/8/20
11  * @description
12  */
13 public class TestDemo {
14     public static void main(String[] args) {
15         ApplicationContext ac =new ClassPathXmlApplicationContext("spring.xml");
16         UserService userService = (UserService) ac.getBean("userServiceImpl");
17         userService.save();
18     }
19 }

 (7)运行结果:

二、配置详解

(1)spring.xml中注解的作用

1.spring--<aop:aspectj-autoproxy></aop:aspectj-autoproxy> 

   这个是 开启事物注解权限,引入了三个jar包  aspectjweaver.jar aspectjrt.jar aspectj.jar  aopalliance.jar。

   2.Spring -- <context:component-scan>

   在xml配置了这个标签后,spring可以自动去扫描base-pack下面或者子包下面的java文件,如果扫描到有@Component @Controller@Service等这些注解的类,则把这些类注册为bean。

(2)Aop类中的注解

         在aop类中,编写了5种注解类型的通知函数:

   @Before 前置通知

   @AfterReturning 后置通知

   @Around 环绕通知

   @AfterThrowing 异常通知

   @After 最终通知

   @pointcut 定义切点匹配表达式

(3)切点表达式

  1. execution

   由于Spring切面粒度最小是达到方法级别,而execution表达式可以用于明确指定方法返回类型,类名,方法名和参数名等与方法相关的部件,并且在Spring中,大部分需要使用AOP的业务场景也只需要达到方法级别即可,因而execution表达式的使用是最为广泛的。如下是execution表达式的语法:

 execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

 这里问号表示当前项可以有也可以没有,其中各项的语义如下:
  • modifiers-pattern方法的可见性,如public,protected;
  • ret-type-pattern:方法的返回值类型,如int,void等;
  • declaring-type-pattern:方法所在类的全路径名,如com.spring.Aspect;
  • name-pattern:方法名类型,如buisinessService();
  • param-pattern:方法的参数类型,如java.lang.String;
  • throws-pattern:方法抛出的异常类型,如java.lang.Exception;

       如下是一个使用execution表达式的例子:

  execution(public * com.spring.service.BusinessObject.businessService(java.lang.String,..))

      上述切点表达式将会匹配使用public修饰,返回值为任意类型,并且是com.spring.BusinessObject类中名称为businessService的方法,方法可以有多个参数,但是第一个参数必须是java.lang.String类型的方法。         

   通配符的类型,主要有两种:

  • *通配符,该通配符主要用于匹配单个单词,或者是以某个词为前缀或后缀的单词。

           如下示例表示返回值为任意类型,在com.spring.service.BusinessObject类中,并且参数个数为零的方法:execution(* com.spring.service.BusinessObject.*())

  • ..通配符,该通配符表示0个或多个项,主要用于declaring-type-pattern和param-pattern中,如果用于declaring-type-pattern中,则表示匹配当前包及其子包,如果用于param-pattern中,则表示匹配0个或多个参数。

如下示例表示匹配返回值为任意类型,并且是com.spring.service包及其子包下的任意类的名称为businessService的方法,而且该方法不能有任何参数:execution(* com.spring.service..*.businessService())

这里需要说明的是,包路径service..*.businessService()中的..应该理解为延续前面的service路径,表示到service路径为止,或者继续延续service路径,从而包括其子包路径;后面的*.businessService(),这里的*表示匹配一个单词,因为是在方法名前,因而表示匹配任意的类。

 如下示例是使用..表示任意个数的参数的示例,需要注意,表示参数的时候可以在括号中事先指定某些类型的参数,而其余的参数则由..进行匹配:

execution(* com.spring.service.BusinessObject.businessService(java.lang.String,..))

三、基于xml的SpringAop配置

  xml配置主要是将注解转换为xml这里我们在上述的情况下做下修改,主要修改两个地方:1,spring.xml,2 aop类

1.springaop.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        xmlns:context="http://www.springframework.org/schema/context"
 5        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 6         http://www.springframework.org/schema/aop
 7         http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 8     <!--基于配置需要我们手动进行配置-->
 9     <!-- dao 实例 -->
10     <bean id="userService" class="cn.spring.aop.dao.UserServiceImpl"></bean>
11     <!-- 切面类 -->
12     <bean id="aop" class="cn.spring.aop.AopAspect2"></bean>
13     <!-- Aop配置 -->
14     <aop:config>
15         <!-- 定义一个切入点表达式: 拦截哪些方法 -->
16         <aop:pointcut expression="execution(* cn.spring.aop.dao.UserService.*(..))"  id="pt"/>
17         <!-- 切面 -->
18         <aop:aspect ref="aop">
19             <!-- 环绕通知 -->
20             <aop:around method="around" pointcut-ref="pt"/>
21             <!-- 前置通知: 在目标方法调用前执行 -->
22             <aop:before method="before" pointcut-ref="pt"/>
23             <!-- 后置通知: -->
24             <aop:after method="after" pointcut-ref="pt"/>
25             <!-- 返回后通知 -->
26             <aop:after-returning method="afterReturning" pointcut-ref="pt" />
27             <!-- 异常通知 -->
28             <aop:after-throwing method="after" pointcut-ref="pt"/>
29         </aop:aspect>
30     </aop:config>
31 </beans>

 2.aop类  AopAspect2

 1 package cn.spring.aop;
 2 
 3 import org.aspectj.lang.ProceedingJoinPoint;
 4 import org.aspectj.lang.annotation.*;
 5 import org.springframework.stereotype.Component;
 6 
 7 /**
 8  * @author Simple
 9  * @date 10:06 2019/8/20
10  * @description
11  */
12 @Component
13 @Aspect
14 public class AopAspect2 {
15     /**
16      * 前置通知
17      */
18     public void before(){
19         System.out.println("前置通知....");
20     }
21 
22     /**
23      * 后置通知
24      * returnVal,切点方法执行后的返回值
25      */
26     public void afterReturning(){
27         System.out.println("后置通知....");
28     }
29 
30 
31     /**
32      * 环绕通知
33      * @param joinPoint 可用于执行切点的类
34      * @return
35      * @throws Throwable
36      */
37     public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
38         System.out.println("环绕通知前....");
39         Object obj= (Object) joinPoint.proceed();
40         System.out.println("环绕通知后....");
41         return obj;
42     }
43 
44     /**
45      * 抛出通知
46      * @param e
47      */
48     public void afterThrowable(Throwable e){
49         System.out.println("出现异常:msg="+e.getMessage());
50     }
51 
52     /**
53      * 无论什么情况下都会执行的方法
54      */
55     public void after(){
56         System.out.println("最终通知....");
57     }
58 }

 3.测试方法

 1 package cn.spring.aop;
 2 
 3 import cn.spring.aop.dao.UserService;
 4 import cn.spring.aop.dao.UserServiceImpl;
 5 import org.springframework.context.ApplicationContext;
 6 import org.springframework.context.support.ClassPathXmlApplicationContext;
 7 
 8 /**
 9  * @author Simple
10  * @date 10:13 2019/8/20
11  * @description
12  */
13 public class TestDemo {
14     public static void main(String[] args) {
15         ApplicationContext ac =new ClassPathXmlApplicationContext("springaop.xml");
16         UserService userService = (UserService) ac.getBean("userService");
17         userService.save();
18     }
19 }

 4.运行结果

     现在在开发中主要是使用注解进行开发,方便快捷,但是更多的是配置和注解一块使用,springaop在配置方面很多都是这种注解加配置,原因主要是方便管理维护。我们这里主要讲的是两种方式的使用和切点表达式。

 

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
Spring框架总结篇

文章目录 一、Spring框架介绍 二、IoC控制反转 三、AOP面向切面编程 四、配置文件与Bean 五、Spring集成JdbcTemplate 六、事务控制 一、Spring框架介绍 Spring Framework即,提供了从表现层到...

osc_ibuoui1c
05/01
8
0
Spring框架总结篇

文章目录 一、Spring框架介绍 二、IoC控制反转 三、AOP面向切面编程 四、配置文件与Bean 五、Spring集成JdbcTemplate 六、事务控制 一、Spring框架介绍 Spring Framework即,提供了从表现层到...

Hudie.
04/30
0
0
Spring入门详细教程(三)

前言 本篇紧接着spring入门详细教程(二),建议阅读本篇前,先阅读第一篇和第二篇。链接如下: Spring入门详细教程(一) https://www.cnblogs.com/jichi/p/10165538.html Spring入门详细教...

osc_tjdfnjyo
2018/12/26
5
0
Spring MVC 事务配置

Spring MVC事务配置 要了解事务配置的所有方法,请看一下 《Spring事务配置的5种方法》 本文介绍两种配置方法: 一、 XML,使用tx标签配置拦截器实现事务 一、 Annotation方式 以下所使用环境...

明舞
2014/08/16
50
0
spring aop

一.spring aop是什么?   spring aop 面向切面编程。业务逻辑层在处理业务之前和之后都要进行一些参数的校验,异常处理,日志记录等代码,有非常多非核心的业务逻辑在里面,这些业务逻辑不...

osc_13a0punx
2019/05/21
0
0

没有更多内容

加载失败,请刷新页面

加载更多

实战梯子游戏多年技巧心得回米必看

梯子游戏技巧交流回雪威【X3364FF】梯子游戏最起码是要学会找出它的规律,简单点我们要从低倍入手,这个有充足的考虑时间。 梯子游戏大概的走势可以分为长龙路、单跳路、对子路、房厅路。长龙...

风清杨啊
38分钟前
19
0
09VulKan——图像视图 采样器 组合图像取样器

整体思想: 使用一个纹理贴图到应用程序的流程: 注意: 在交换链和帧缓冲区中,图像不是直接访问,而是通过图像视图。这里借助图像视图来访问纹理图像 顶点着色器 #version 450#extensi...

黑白双键
39分钟前
11
0
等待收录

静态网站 https://dinghaobaojie.com/

张宏亮
52分钟前
18
0
UEditor富文本编辑

听很多人说百度推出的UEditor框架很实用,但是自己从来没有实践过,这一次有项目中用到,所以记录一下。(感觉一个东西会的人不难,没有做过掌握不到诀窍,就不太好弄) 主要可以分为三步: ...

axj_cfc
58分钟前
28
0
分布式事务

分布式事务处理机制共有四种: 两阶段提交 TCC事务(事务补偿) 本地消息表(异步确保), MQ事务消息。 两阶段提交: 与数据库XA事务一样,两阶段提交使用XA协议。 两阶段提交这种方案属于牺...

九分石人
今天
21
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部