aop详解

最新推荐文章于 2023-09-15 22:16:58 发布
最新推荐文章于 2023-09-15 22:16:58 发布
阅读量220 收藏
点赞数
分类专栏： aop 文章标签： aop

本文抛砖引玉，并没有详细的介绍更全面的内容，通过一个例子让初次使用的人能够快速入门，简单的介绍一下。

第一，注解：

  1. @Before – 目标方法执行前执行

  2. @After – 目标方法执行后执行

  3. @AfterReturning – 目标方法返回后执行，如果发生异常不执行

  4. @AfterThrowing – 异常时执行

  5. @Around – 在执行上面其他操作的同时也执行这个方法

第二，SpringMVC如果要使用AOP注解，必须将

1
< aop:aspectj-autoproxy  proxy-target-class = "true" />

放在spring-servlet.xml(配置MVC的XML)中


第三，execution表达式请参考Spring官网http://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html


代码下载：http://pan.baidu.com/s/1gdeopW3

项目截图


首先是Maven依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
< properties >
         < springframework >4.0.5.RELEASE</ springframework >
         < aspectj >1.8.5</ aspectj >
         < servlet >3.1.0</ servlet >
     </ properties >
     < dependencies >
         <!-- servlet -->
         < dependency >
             < groupId >javax.servlet</ groupId >
             < artifactId >javax.servlet-api</ artifactId >
             < version >${servlet}</ version >
             < scope >compile</ scope >
         </ dependency >
         <!-- Spring web mvc -->
         < dependency >
             < groupId >org.springframework</ groupId >
             < artifactId >spring-webmvc</ artifactId >
             < version >${springframework}</ version >
         </ dependency >
         <!-- Spring AOP -->
         < dependency >
             < groupId >org.springframework</ groupId >
             < artifactId >spring-aop</ artifactId >
             < version >${springframework}</ version >
         </ dependency >
         < dependency >
             < groupId >org.aspectj</ groupId >
             < artifactId >aspectjrt</ artifactId >
             < version >${aspectj}</ version >
         </ dependency >
         < dependency >
             < groupId >org.aspectj</ groupId >
             < artifactId >aspectjweaver</ artifactId >
             < version >${aspectj}</ version >
         </ dependency >
     </ dependencies >

spring-context.xml配置，基本无内容

1
2
3
4
<!-- 配置扫描路径 -->
     < context:component-scan  base-package = "org.xdemo.example.springaop" >
         < context:exclude-filter  type = "annotation"  expression = "org.springframework.stereotype.Controller"  />
     </ context:component-scan >

spring-mvc.xml配置

1
2
3
4
5
6
7
8
9
<!-- 最重要:::如果放在spring-context.xml中，这里的aop设置将不会生效 -->
     < aop:aspectj-autoproxy  proxy-target-class = "true" />
     <!-- 启用MVC注解 -->
     < mvc:annotation-driven  />
 
     <!-- 指定Sping组件扫描的基本包路径 -->
     < context:component-scan  base-package = "org.xdemo.example.springaop" >
         < context:include-filter  type = "annotation"  expression = "org.springframework.stereotype.Controller" />
     </ context:component-scan >

Web.xml配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<? xml  version = "1.0"  encoding = "UTF-8" ?>
< web-app  xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"  xmlns = "http://java.sun.com/xml/ns/javaee"  xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  version = "3.0" >
     < display-name >Archetype Created Web Application</ display-name >
     <!-- WebAppRootKey -->
     < context-param >
         < param-name >webAppRootKey</ param-name >
         < param-value >org.xdemo.example.springaop</ param-value >
     </ context-param >
 
     <!-- Spring Context -->
     < context-param >
         < param-name >contextConfigLocation</ param-name >
         < param-value >classpath:spring-context.xml</ param-value >
     </ context-param >
     < listener >
         < listener-class >org.springframework.web.context.ContextLoaderListener</ listener-class >
     </ listener >
 
     <!-- SpringMVC -->
     < servlet >
         < servlet-name >SpringMVC</ servlet-name >
         < servlet-class >org.springframework.web.servlet.DispatcherServlet</ servlet-class >
         < init-param >
             < param-name >contextConfigLocation</ param-name >
             < param-value >classpath:spring-mvc.xml</ param-value >
         </ init-param >
         < load-on-startup >1</ load-on-startup >
     </ servlet >
     < servlet-mapping >
         < servlet-name >SpringMVC</ servlet-name >
         < url-pattern >/</ url-pattern >
     </ servlet-mapping >
 
</ web-app >

注解Log

1
2
3
4
5
6
7
8
9
10
11
12
package  org.xdemo.example.springaop.annotation;
 
import  java.lang.annotation.ElementType;
import  java.lang.annotation.Retention;
import  java.lang.annotation.RetentionPolicy;
import  java.lang.annotation.Target;
 
@Retention (RetentionPolicy.RUNTIME)
@Target ({ ElementType.METHOD })
public  @interface  Log {
     String name()  default  "" ;
}

日志AOP，写法一LogAop_1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
package  org.xdemo.example.springaop.aop;
 
import  java.lang.reflect.Method;
import  java.util.UUID;
 
import  org.aspectj.lang.JoinPoint;
import  org.aspectj.lang.ProceedingJoinPoint;
import  org.aspectj.lang.annotation.After;
import  org.aspectj.lang.annotation.Around;
import  org.aspectj.lang.annotation.Aspect;
import  org.aspectj.lang.annotation.Before;
import  org.aspectj.lang.reflect.MethodSignature;
import  org.springframework.stereotype.Component;
import  org.xdemo.example.springaop.annotation.Log;
 
@Aspect
@Component
public  class  LogAop_1 {
 
     ThreadLocal<Long> time= new  ThreadLocal<Long>();
     ThreadLocal<String> tag= new  ThreadLocal<String>();
     
     /**
      * 在所有标注@Log的地方切入
      * @param joinPoint
      */
     @Before ( "@annotation(org.xdemo.example.springaop.annotation.Log)" )
     public  void  beforeExec(JoinPoint joinPoint){
         
         time.set(System.currentTimeMillis());
         tag.set(UUID.randomUUID().toString());
         
         info(joinPoint);
         
         MethodSignature ms=(MethodSignature) joinPoint.getSignature();
         Method method=ms.getMethod();
         System.out.println(method.getAnnotation(Log. class ).name()+ "标记" +tag.get());
     }
     
     @After ( "@annotation(org.xdemo.example.springaop.annotation.Log)" )
     public  void  afterExec(JoinPoint joinPoint){
         MethodSignature ms=(MethodSignature) joinPoint.getSignature();
         Method method=ms.getMethod();
         System.out.println( "标记为" +tag.get()+ "的方法" +method.getName()+ "运行消耗" +(System.currentTimeMillis()-time.get())+ "ms" );
     }
     
     @Around ( "@annotation(org.xdemo.example.springaop.annotation.Log)" )
     public  void  aroundExec(ProceedingJoinPoint pjp)  throws  Throwable{
         System.out.println( "我是Around，来打酱油的" );
         pjp.proceed();
     }
     
     private  void  info(JoinPoint joinPoint){
         System.out.println( "--------------------------------------------------" );
         System.out.println( "King:\t" +joinPoint.getKind());
         System.out.println( "Target:\t" +joinPoint.getTarget().toString());
         Object[] os=joinPoint.getArgs();
         System.out.println( "Args:" );
         for ( int  i= 0 ;i<os.length;i++){
             System.out.println( "\t==>参数[" +i+ "]:\t" +os[i].toString());
         }
         System.out.println( "Signature:\t" +joinPoint.getSignature());
         System.out.println( "SourceLocation:\t" +joinPoint.getSourceLocation());
         System.out.println( "StaticPart:\t" +joinPoint.getStaticPart());
         System.out.println( "--------------------------------------------------" );
     }
     
     
}

日志AOP，写法二LogAop_2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
package  org.xdemo.example.springaop.aop;
 
import  java.lang.reflect.Method;
import  java.util.UUID;
 
import  org.aspectj.lang.JoinPoint;
import  org.aspectj.lang.ProceedingJoinPoint;
import  org.aspectj.lang.annotation.After;
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.aspectj.lang.reflect.MethodSignature;
import  org.springframework.stereotype.Component;
import  org.xdemo.example.springaop.annotation.Log;
 
@Aspect
@Component
public  class  LogAop_2 {
 
     ThreadLocal<Long> time= new  ThreadLocal<Long>();
     ThreadLocal<String> tag= new  ThreadLocal<String>();
     
     @Pointcut ( "@annotation(org.xdemo.example.springaop.annotation.Log)" )
     public  void  log(){
         System.out.println( "我是一个切入点" );
     }
     
     /**
      * 在所有标注@Log的地方切入
      * @param joinPoint
      */
     @Before ( "log()" )
     public  void  beforeExec(JoinPoint joinPoint){
         
         time.set(System.currentTimeMillis());
         tag.set(UUID.randomUUID().toString());
         
         info(joinPoint);
         
         MethodSignature ms=(MethodSignature) joinPoint.getSignature();
         Method method=ms.getMethod();
         System.out.println(method.getAnnotation(Log. class ).name()+ "标记" +tag.get());
     }
     
     @After ( "log()" )
     public  void  afterExec(JoinPoint joinPoint){
         MethodSignature ms=(MethodSignature) joinPoint.getSignature();
         Method method=ms.getMethod();
         System.out.println( "标记为" +tag.get()+ "的方法" +method.getName()+ "运行消耗" +(System.currentTimeMillis()-time.get())+ "ms" );
     }
     
     @Around ( "log()" )
     public  void  aroundExec(ProceedingJoinPoint pjp)  throws  Throwable{
         System.out.println( "我是Around，来打酱油的" );
         pjp.proceed();
     }
     
     private  void  info(JoinPoint joinPoint){
         System.out.println( "--------------------------------------------------" );
         System.out.println( "King:\t" +joinPoint.getKind());
         System.out.println( "Target:\t" +joinPoint.getTarget().toString());
         Object[] os=joinPoint.getArgs();
         System.out.println( "Args:" );
         for ( int  i= 0 ;i<os.length;i++){
             System.out.println( "\t==>参数[" +i+ "]:\t" +os[i].toString());
         }
         System.out.println( "Signature:\t" +joinPoint.getSignature());
         System.out.println( "SourceLocation:\t" +joinPoint.getSourceLocation());
         System.out.println( "StaticPart:\t" +joinPoint.getStaticPart());
         System.out.println( "--------------------------------------------------" );
     }
     
}

用到的一个用户类User

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package  org.xdemo.example.springaop.bean;
 
public  class  User {
 
     private  String name;
 
     public  String getName() {
         return  name;
     }
 
     public  void  setName(String name) {
         this .name = name;
     }
 
}

一个测试的Controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package  org.xdemo.example.springaop.controller;
 
import  javax.annotation.Resource;
 
import  org.springframework.stereotype.Controller;
import  org.springframework.web.bind.annotation.RequestMapping;
import  org.springframework.web.bind.annotation.ResponseBody;
import  org.xdemo.example.springaop.annotation.Log;
import  org.xdemo.example.springaop.bean.User;
import  org.xdemo.example.springaop.service.IUserService;
 
 
@Controller
@RequestMapping ( "/aop" )
public  class  SpringController {
     
     @Resource  IUserService userService;
     
     @Log (name= "您访问了aop1方法" )
     @ResponseBody
     @RequestMapping (value= "aop1" )
     public  String aop1(){
         return  "AOP" ;
     }
     
     @Log (name= "您访问了aop2方法" )
     @ResponseBody
     @RequestMapping (value= "aop2" )
     public  String aop2(String string)  throws  InterruptedException{
         Thread.sleep(1000L);
         User user= new  User();
         user.setName(string);
         userService.save(user);
         return  string;
     }
     
}

一个测试的接口实现类（接口类略）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package  org.xdemo.example.springaop.service;
 
import  org.springframework.stereotype.Service;
import  org.xdemo.example.springaop.annotation.Log;
import  org.xdemo.example.springaop.bean.User;
 
@Service
public  class  UserServiceImpl  implements  IUserService {
 
     @Log (name =  "您访问了保存用户信息" )
     public  void  save(User user) {
         System.out.println(user.getName());
     }
 
}

在地址栏输入地址测试：http://localhost:8080/springaop/aop/aop2?string=sxxxxx

结果如下：


转载请注明来源：http://www.xdemo.org/springmvc-aop-annotation/ 

吉叔说Java
关注
专栏目录
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
08-18
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
SpringMVC利用AOP实现自定义注解记录日志
10-14
SpringMVC利用AOP实现自定义注解记录日志
Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2
08-22
Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2
SpringMVC AOP 注解模式 全局管理访问日志
第二庄
06-12 1140
SpringMVC AOP 注解模式 全局管理访问日志 ​ 注：此处不详细讲解aop的使用方式，只记录一个使用过的例子并配上一点说明 我们需要开启自动注入，让spring自动实现织入 &lt;aop:aspectj-autoproxy /&gt; @annotation注解 对于切面来说，我们一般会定义一个切点Pointcut，这里不讲这个。想说的是，我们定义Advice的时候， ...
java Spring AOP详解及简单实例
08-30
Java Spring AOP详解及简单实例 一、什么是AOP AOP（Aspect Oriented Programming）是面向切面编程，它不同于OOP（Object Oriented Programming）面向对象编程。AOP是将程序的运行看成一个流程切面，其中可以在切...
Spring AOP详解
08-07
**Spring AOP详解** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架中的一个重要组成部分，它提供了一种在程序运行期间通过代理方式实现横切关注点（如日志、事务管理等）的技术。相较于...
spring-springMVC开发文档和AOP详解
11-24
最后，《Spring3_AOP详解》深入剖析了Spring的AOP特性。AOP是面向切面编程的缩写，它允许我们在不改变原有代码结构的情况下，插入额外的功能，如日志、事务管理和性能监控等。通过代理机制，AOP可以在运行时将“切面...
JavaScript实现AOP详解(面向切面编程,装饰者模式)
01-19
什么是AOP？ AOP(面向切面编程)的主要作用是把一些跟核心业务逻辑模块无关的功能抽离出来，这些跟业务逻辑无关的功能通常包括日志统计、安全控制、异常处理等。把这些功能抽离出来之后， 再通过“动态织入”的方式...
spring MVC AOP注解方式如何拦截controller 例子
12-22
有人问 Sping AOP用AspectJ注解的方式拦截不到SpringMVC的controller方法？ 我这里提供了一种解决方法，仅供参考
springmvc中使用log4j及aop记录日志的例子
12-27
使用springmvc，利用aop aspectj log4j 实现进入函数，退出函数的日志的记录
基于注解配置和使用spring AOP(spring mvc框架)
07-19
基于注解配置和使用spring AOP(spring mvc框架)
SpringMVC - 基于注解的AOP开发、注解配置AOP详解
qq_39123467的博客
04-25 1262
SpringMVC - 基于注解的AOP开发、注解配置AOP详解
SpringMVC使用AOP
vincent_duan的专栏
05-27 305
撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>> ...
【SpringMVC】自定义注解与AOP结合使用
最新发布
让优秀成为一种习惯！
09-15 1952
注解（Annotation）是Java语言的一种元数据（metadata）机制，它提供了一种在代码中添加额外信息的方式。注解可以用于标记代码的特定元素，如类、方法、字段、参数等，以便在编译时、运行时或者通过工具进行处理。注解相关类都包含在包中。自定义注解是开发者根据自己的需求创建的注解。通过自定义注解，开发者可以为代码添加特定的元数据信息，并定义相应的处理逻辑。
SpringMVC中使用AOP
用文章记录成长
10-17 3464
1.定义一个AOP： package org.yang.aop; import java.io.IOException; import javax.servlet.http.HttpServletResponse; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.As
Java JDK 实现AOP详解
"Java JDK 实现AOP" Java JDK实现AOP主要涉及到的是利用Java的反射API和动态代理机制来实现面向切面编程的概念。面向切面编程（AOP）是一种编程范式，旨在提高代码的模块化和可维护性，通过将关注点分离，使得代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值