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

最新推荐文章于 2022-08-31 17:40:59 发布
最新推荐文章于 2022-08-31 17:40:59 发布
阅读量477 收藏 1
点赞数 1
分类专栏： JAVA

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

第一，注解：

  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
<!-- 最重要:::如果放在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
<? 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
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
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
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
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
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
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/ 

小城风带香
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
08-18
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2
08-22
Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2
SpringMVC AOP 注解模式 全局管理访问日志
第二庄
06-12 1112
SpringMVC AOP 注解模式 全局管理访问日志 ​ 注：此处不详细讲解aop的使用方式，只记录一个使用过的例子并配上一点说明 我们需要开启自动注入，让spring自动实现织入 &lt;aop:aspectj-autoproxy /&gt; @annotation注解 对于切面来说，我们一般会定义一个切点Pointcut，这里不讲这个。想说的是，我们定义Advice的时候， ...
springMVC自定义注解,用AOP来实现日志记录的方法
08-28
SpringMVC自定义注解与AOP实现日志记录的方法 在本文中，我们将探讨如何使用SpringMVC自定义注解与AOP（Aspect-Oriented Programming）来实现日志记录的方法。该方法可以在项目中记录业务操作的日志，并提取关键...
Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源
12-25
本项目“Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源”正是针对这一需求提供的一种解决方案。下面将详细介绍这个项目中的关键技术点和实现原理。 首先，Spring框架是Java企业级应用开发的核心...
springMVC AOP拦截拦截Controller等实现日志管理
07-19
在这个场景中，我们将讨论如何利用AOP来实现Controller的日志管理，以捕获并记录应用程序中的异常。 首先，我们需要了解Spring AOP的基础概念。AOP允许我们定义“切面”，这些切面是关注点的模块化，如日志记录。切...
SpringMVC - 基于注解的AOP开发、注解配置AOP详解
qq_39123467的博客
04-25 1234
SpringMVC - 基于注解的AOP开发、注解配置AOP详解
spring MVC AOP注解方式如何拦截controller 例子
12-22
有人问 Sping AOP用AspectJ注解的方式拦截不到SpringMVC的controller方法？ 我这里提供了一种解决方法，仅供参考
springmvc中使用log4j及aop记录日志的例子
12-27
使用springmvc，利用aop aspectj log4j 实现进入函数，退出函数的日志的记录
菜鸟之路——Spring MVC（十四）Spring AOP
sjjsh2的博客
11-15 3123
AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向切面编程。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。   我们现在做的一些非业务，如：日志、事务、安全等都会写在业务代码中(
spring AOP + 自定义注解 实现
夜尽天明xyz的博客
08-08 1216
1.首先在spring mvc 的配置文件中确定扫描包 <context:component-scan base-package=“com.sun.controller,com.sun.annotation” /> 2.其次配置aop aspectj 自动注解识别 <aop:aspectj-autoproxy proxy-target-class=“true”/> 3.自定义注解类 package com.sun.annotation; import java.lang.annota
Aop概念详解
蝉之洞
03-23 2906
AOP详解
AOP的使用（详细讲解）
热门推荐
酷小亚
08-31 1万+
一、AOP基本概念 二、AOP底层原理 三、AOP的JDK动态代理 四、AOP术语 五、AOP操作（准备） 六、AOP操作（AspectJ注解）【重点】 七、AOP操作（AspectJ配置文件）
springMVC自定义注解，用AOP来实现日志记录
Mr_Alex
11-04 9017
需求背景最近的一个项目，在项目基本完工的阶段，客户提出要将所有业务操作的日志记录到数据库中，并且要提取一些业务的关键信息(比如交易单号)体现在日志中。为了保证工期，在查阅了资料以后，决定用AOP+自定义注解的方式来完成这个需求。准备工作自定义注解需要依赖的jar包有 aspectjrt-XXX.jar ,aspectjweaver-XXX.jar，XXX代表版本号。
智慧旅游大数据建设方案.docx
最新发布
08-11
智慧旅游大数据建设方案.docx
SpringMVC4框架技术详解
- **拦截器（Interceptor）**：用于在请求处理前后执行自定义逻辑，如权限验证、日志记录等。 6. **注解驱动开发** 自Spring3.0开始，SpringMVC支持注解驱动开发，使得配置更简洁，开发者可以直接在Controller类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值