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

最新推荐文章于 2024-02-21 10:59:38 发布
最新推荐文章于 2024-02-21 10:59:38 发布
阅读量475 收藏 1
点赞数
分类专栏： Spring springMVC

第一，注解：

  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依赖：

< 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配置，基本无内容

<!-- 配置扫描路径 -->
     < 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配置

<!-- 最重要！！！如果放在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配置

<? 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

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

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

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

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

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;
     }
     
}

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

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

weixin_39214481
关注
专栏目录
SpringMVC AOP和自定义注解实现日志管理
寻梦友的博客
08-08 1275
今天主要介绍“ AOP切面+自定义注解” 实现 日志管理功能。 很多应用场景中，对敏感、保密性高的表进行增删改查操作，或涉及金钱操作时，往往需要增加日志管理收集功能。在不修改原有功能方法基础上，可以使用“AOP切面+自定义注解”实现无感知的日志收集功能。【本人自己的见解，具体应用到什么场景，自己把控！！！】
Spring MVC 中的 AOP（动态代理）-个人总结
最新发布
2401_85797177的博客
08-21 1016
Spring中的两种动态代理：JDK动态代理和CGLIB动态代理的区别。
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
08-18
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
SpringMVC中基于AOP的自定义注解记录日志
一杯咖啡。的博客
06-04 399
最近发现以前用的非注解式的记录操作日志非常麻烦，于是寻思用注解+AOP的方式来改造service层的日志记录 首先定义自定义操作日志注解@Target(ElementType.METHOD)//作用于方法上 @Retention(RetentionPolicy.RUNTIME) public @interface SystemLog { /** * 模块名称 如：用户管理
springMVC自定义注解,用AOP来实现日志记录的方法
08-28
SpringMVC自定义注解与AOP实现日志记录的方法 在本文中，我们将探讨如何使用SpringMVC自定义注解与AOP（Aspect-Oriented Programming）来实现日志记录的方法。该方法可以在项目中记录业务操作的日志，并提取关键...
Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源
12-25
本项目“Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源”正是针对这一需求提供的一种解决方案。下面将详细介绍这个项目中的关键技术点和实现原理。 首先，Spring框架是Java企业级应用开发的核心...
Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2
08-22
Spring MVC AOP通过注解方式拦截Controller等实现日志管理demo版本2
基于注解配置和使用spring AOP(spring mvc框架)
07-19
基于注解配置和使用spring AOP(spring mvc框架)
spring MVC AOP注解方式如何拦截controller 例子
12-22
有人问 Sping AOP用AspectJ注解的方式拦截不到SpringMVC的controller方法？ 我这里提供了一种解决方法，仅供参考
spring aop日志拦截
04-28
spring mvc利用aop日志实现对controller层的拦截
SpringMVC 基于注解的自定义AOP实现日志记录
木帆雨竹
12-09 225
SpringMVC如何实现aop
datouniao1的博客
08-15 602
aop面向切面的编程AspectOriented Programming 我想创建一个类来监听controller ，当controller执行方法的时候将入参和输出参数打印出来 package com.wdg.controller; import java.text.SimpleDateFormat; import java.util.Date; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoin..
springboot项目创建笔记16 之《@SpringBootApplication注解解析》
csj50的专栏
09-14 520
一、注解的使用 1、使用非常简单，加在自定义的类上面，右键 - Run As - Java Application启动 @SpringBootApplication public class MybootApplication { public static void main(String[] args) { SpringApplication.run(MybootApplication.class, args); } } 二、注解的组成 1、@SpringBootApplication
SpringMVC日志管理（自定义异常及自定义注解）
07-25 219
近期为了规范公司老旧项目的日志，主要也是为了便于日后错误排查以及加强对业务系统的监控，准备对原有的日志输出进行简单的改造。 解决思路 1、通过自定义异常来将可能出现的问题分为两大类，业务类及系统类。同时，所有异常向上抛出至controller层，集中处理。 2、通过自定义注解Log在所有的业务处理方法（control）上标注方法的用途及所属模块，用于监控所有业务的运行情况。 3、...
SpringMVC项目添加日志功能（AOP实现）最简单版
cqdddgs的博客
02-21 546
最近项目新增一个功能，需要把用户的操作都记录到数据库，于是在实现功能之后在这里分享 大家请根据自己的需求增减字段，然后将你的dao service serviceImpl controller创建好 4.编写配置文件 5.编写切面 实现效果：
SpringMVC自定义注解：AOP实现业务操作日志
本文将介绍如何在Spring MVC项目中创建一个自定义注解，利用AOP进行日志记录，以便满足客户对于业务操作日志的需求。 首先，我们需要理解需求背景。在项目接近尾声时，客户要求记录所有的业务操作日志，并包含关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值