SpringMVC利用AOP实现自定义注解记录日志

最新推荐文章于 2022-04-15 17:18:24 发布
最新推荐文章于 2022-04-15 17:18:24 发布
阅读量555 收藏
点赞数
分类专栏： spring+strut2+hibernate+ibatis+jpa 文章标签： java 测试 runtime
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011660647/article/details/84823004
版权

 

对应的中文：

任意公共方法的执行： 
execution(public * *(..)) 
任何一个以“set”开始的方法的执行： 
execution(* set*(..)) 
AccountService 接口的任意方法的执行： 
execution(* com.xyz.service.AccountService.*(..)) 
定义在service包里的任意方法的执行： 
execution(* com.xyz.service.*.*(..)) 
定义在service包或者子包里的任意方法的执行： 
execution(* com.xyz.service..*.*(..)) 
在service包里的任意连接点（在Spring AOP中只是方法执行） ： 
within(com.xyz.service.*) 
在service包或者子包里的任意连接点（在Spring AOP中只是方法执行） ： 
within(com.xyz.service..*) 
实现了 AccountService 接口的代理对象的任意连接点（在Spring AOP中只是方法执行） ： 
this(com.xyz.service.AccountService) 
'this'在binding form中用的更多：- 请常见以下讨论通知的章节中关于如何使得代理对象可以在通知体内访问到的部分。 
实现了 AccountService 接口的目标对象的任意连接点（在Spring AOP中只是方法执行） ： 
target(com.xyz.service.AccountService) 
'target'在binding form中用的更多：- 请常见以下讨论通知的章节中关于如何使得目标对象可以在通知体内访问到的部分。 
任何一个只接受一个参数，且在运行时传入的参数实现了 Serializable 接口的连接点 （在Spring AOP中只是方法执行） 
args(java.io.Serializable) 
'args'在binding form中用的更多：- 请常见以下讨论通知的章节中关于如何使得方法参数可以在通知体内访问到的部分。 请注意在例子中给出的切入点不同于 execution(* *(java.io.Serializable))： args只有在动态运行时候传入参数是可序列化的（Serializable）才匹配，而execution 在传入参数的签名声明的类型实现了 Serializable 接口时候匹配。 
有一个 @Transactional 注解的目标对象中的任意连接点（在Spring AOP中只是方法执行） 
@target(org.springframework.transaction.annotation.Transactional) 
'@target' 也可以在binding form中使用：请常见以下讨论通知的章节中关于如何使得annotation对象可以在通知体内访问到的部分。 
任何一个目标对象声明的类型有一个 @Transactional 注解的连接点（在Spring AOP中只是方法执行） 
@within(org.springframework.transaction.annotation.Transactional) 
'@within'也可以在binding form中使用：- 请常见以下讨论通知的章节中关于如何使得annotation对象可以在通知体内访问到的部分。 
任何一个执行的方法有一个 @Transactional annotation的连接点（在Spring AOP中只是方法执行） 
@annotation(org.springframework.transaction.annotation.Transactional) 
'@annotation' 也可以在binding form中使用：- 请常见以下讨论通知的章节中关于如何使得annotation对象可以在通知体内访问到的部分。 
任何一个接受一个参数，并且传入的参数在运行时的类型实现了 @Classified annotation的连接点（在Spring AOP中只是方法执行） 
@args(com.xyz.security.Classified)

第一，注解：

  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/ 

唐国龙3
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMVC AOP和自定义注解实现日志管理
寻梦友的博客
08-08 1216
今天主要介绍“ AOP切面+自定义注解” 实现 日志管理功能。 很多应用场景中，对敏感、保密性高的表进行增删改查操作，或涉及金钱操作时，往往需要增加日志管理收集功能。在不修改原有功能方法基础上，可以使用“AOP切面+自定义注解”实现无感知的日志收集功能。【本人自己的见解，具体应用到什么场景，自己把控！！！】
SpringMVC：切面AOP
最新发布
一些平时在开发过程中遇到的常见问题，分享给大家
07-23 2144
目前在实际AOP实用场景主要处理重复且频繁的操作，比如登录加密验证，接口调用日志处理，异常处理等方面。那我们今天就来看看切面AOP
SpringMVC使用AOP
vincent_duan的专栏
05-27 295
撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>> ...
Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2
08-22
Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2
Spring AOP+自定义注解实现日志记录
chengbinbbs的专栏
07-02 752
利用spring aop+自定义注解，来实现日志的记录，把日志记录从业务中解放出来，你只需专注于你的业务代码实现，保持业务代码的干净。自定义日志注解，释放你的双手。 日志类注解ClassLogger： import java.lang.annotation.*; @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME)...
自定义注解实现AOP日志记录
weixin_43539126的博客
04-01 1104
1.引入jar包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 2.创建自定义注解 @Target(ElementType.METHOD) @Retention(Retenti
springMVC自定义注解,用AOP来实现日志记录的方法
08-28
SpringMVC自定义注解与AOP实现日志记录的方法 在本文中，我们将探讨如何使用SpringMVC自定义注解与AOP（Aspect-Oriented Programming）来实现日志记录的方法。该方法可以在项目中记录业务操作的日志，并提取关键...
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
08-18
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
spring MVC AOP注解方式如何拦截controller 例子
12-22
有人问 Sping AOP用AspectJ注解的方式拦截不到SpringMVC的controller方法？ 我这里提供了一种解决方法，仅供参考
spring mvc 中 实现自定义注解 拦截需要的方法
03-31
网上很多人想使用注解拦截spring mvc action中的一个方法,实现方法很多,一般是通过在拦截器中分析url路径来实现, 使用自定义注解的方式来标注要拦截的 action 中的某个方法, 没有很好的解决方法, 如果通过借助spring mvc中的方法可以轻松实现要拦截 action 中 具体的某个方法. 不多说了,看代码,里面写的很详细
基于注解配置和使用spring AOP(spring mvc框架)
07-19
基于注解配置和使用spring AOP(spring mvc框架)
Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源
12-25
本项目“Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源”正是针对这一需求提供的一种解决方案。下面将详细介绍这个项目中的关键技术点和实现原理。 首先，Spring框架是Java企业级应用开发的核心...
spring aop配置
flyinglzd2013的专栏
09-18 1103
1、我理解的Spring AOP  AOP其实就是划分出来了一个切面，然后在这个切面里面进行了一些增强,最后产生一个增加了新功能的代理对象，注意，是代理对象，这是Spring AOP实现的基础。这个对象只不过比原始对象（Bean）多了一些功能而已，比如Bean预处理，Bean后处理，异常处理等。  2、简单的Demo理解Spring AOP  首先定义一个AOP代理工厂AOPProx
使用springMVC AOP实现日记记录
黎鉴洪的博客
05-02 9796
1 . 配置springmvc驱动，以及包扫描，还有AOP配置，如下： 2 . 引入相关jar包 3 . 目录树 4 . 编写日记记录类 LogInterceptor.java package org.lee.Interceptor; import java.lang.reflect.Method;
springMVC的Aop
qq_48569009的博客
04-15 1950
Aop是面向切面编程：是通过预编译方式和运行器动态代理实现程序功能的统一维护技术。Aop是oop的延续，是spring框架中的重要内容，是函数编程的一种衍生泛型，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑部分之间的耦合度降低提高程序的可重用行，提高开发的效率。 Aop的作用是： 在程序运行期间，在不修改源码的情况下对方法进行功能性增强。 优势：减少重复代码，提高开发效率，并且便于维护。 Aop的底层实现： Aop的底层是使用Spring提供的动态代理技术实现的，在...
SpringMVC自定义注解：AOP实现业务操作日志
本文将介绍如何在Spring MVC项目中创建一个自定义注解，利用AOP进行日志记录，以便满足客户对于业务操作日志的需求。 首先，我们需要理解需求背景。在项目接近尾声时，客户要求记录所有的业务操作日志，并包含关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值