使用spring aop 统一捕获异常和写日志的示例demo
之前给大家介绍过Spring AOP的基础知识，需要的朋友点击了解下吧，这边我将给您介绍用spring AOP 实现的异常捕获和日志的小demo，我也会详细解释相关配置。
首先给大家看一下我的工程目录：
大家可以先用eclipse中新建一个maven工程，在工程中pom.xml按下面文件添加依赖：
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.zy</groupId>
<artifactId>AOPException</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>AOPException Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.5.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.0.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.0.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.0.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.5</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.5</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.5</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.6.RELEASE</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>2.18.3</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>AOPException</finalName>
</build>
</project>
添加完依赖后，开始配置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" 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>exception-test-web</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>//这边是加载spring的配置文件
/WEB-INF/config/applicationContext.xml
</param-value>
</context-param>
<context-param>
<param-name>spring.profiles.default</param-name>
<param-value>production</param-value>
</context-param>
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>springServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
//这边是加载spring的配置文件
<param-value>/WEB-INF/config/spring-mvc-config.xml</param-value>
</init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springServlet</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <session-config> <session-timeout>20</session-timeout> </session-config></web-app>
配置完web.xml后，你可开始配置spring配置文件了，也就是applicationContext.xml文件。如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd"
default-lazy-init="true">
<description>Spring公共配置</description>
<!-- 使用annotation 自动注册bean, 并保证@Required、@Autowired的属性被注入 -->
<context:component-scan base-package="com.zy.test">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />//不扫描controller注解类
<context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice" />//不扫描ControllerAdvice注解类
</context:component-scan>
</beans>
然后配置spring-mvc-config.xml文件，如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd ">
<!-- 自动扫描 -->
<context:component-scan base-package="com.zy.test" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />//扫描COntroller注解类
<context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice" />//扫描ControllerAdvice注解类
</context:component-scan>
<mvc:annotation-driven>
<mvc:message-converters register-defaults="true">
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<constructor-arg value="UTF-8" />
<property name="writeAcceptCharset" value="false" />
</bean>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<property name="prettyPrint" value="true" />
</bean>
</mvc:message-converters>
</mvc:annotation-driven>
<!--
<bean class="com.zy.test.config.ExceptionConfig"/>
-->
<!-- 这里的配置可以通过 com.zy.test.config.ExceptionConfig这个注解类来完成 -->
<aop:aspectj-autoproxy proxy-target-class="true" />
<bean class="com.zy.test.aspect.WebExceptionAspect" scope="singleton"/> //配置了单例
</beans>
上面spring容器和spring-mvc容器中扫描的类不一样，是为了区分两个容器的职责，spring-mvc负责controller控制器这块的类。因为我们的异常捕获是从controller类往外抛，所以我们对于aspect类也放在spring-mvc容器中。
下面就开始介绍我们的切面类：
package com.zy.test.aspect;
import java.lang.reflect.Method;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import com.zy.test.annotation.ArchivesLog;
/**
* web 异常切面
* @author user
*
*/
@Aspect
public class WebExceptionAspect {
@Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)")//连接点是@RequestMapping注解的方法
private void webPointcut() {}
@AfterThrowing(pointcut = "webPointcut()", throwing = "e")//切点在webpointCut()
public void handleThrowing(JoinPoint joinPoint, Exception e) {//controller类抛出的异常在这边捕获
String className = joinPoint.getTarget().getClass().getName();
String methodName = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();
//开始打log
System.out.println("异常:" + e.getMessage());
System.out.println("异常所在类：" + className);
System.out.println("异常所在方法：" + methodName);
System.out.println("异常中的参数：");
System.out.println(methodName);
for (int i = 0; i < args.length; i++) {
System.out.println(args[i].toString());
}
}
@Before("execution(* com.zy.test.controller.*.*(..))")
public void beforeProcess(JoinPoint joinPoint) {
String className = joinPoint.getTarget().getClass().getName();
String methodName = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();
//在项目中最好记录当前操作的时间和用户
System.out.println("操作所在类：" + className);
System.out.println("操作所在方法：" + methodName);
System.out.println("操作中的参数：");
for (int i = 0; i < args.length; i++) {
System.out.println(args[i].toString());
}
}
@AfterReturning(value = "execution(* com.zy.test.controller.*.*(..)))", returning = "returnVal")
public void returnProcess(JoinPoint joinPoint, Object returnVal) {
String className = joinPoint.getTarget().getClass().getName();
String methodName = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();
Class targetClass = null;
String operationName = "";
try {
targetClass = Class.forName(className);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Method[] methods = targetClass.getMethods();
for (Method method : methods) {
if (method.getName().equals(methodName)) {
Class[] clazzs = method.getParameterTypes();
if (clazzs != null && clazzs.length == args.length&&
method.getAnnotation(ArchivesLog.class)!=null) {//这块是取出我们注解ArchiveLog中的值,一遍在日志时明确这个操作的名称
operationName = method.getAnnotation(ArchivesLog.class).operationName();
break;
}
}
}
System.out.println("操作名称：" + operationName);
System.out.println("方法正常返回的值：" + returnVal);
}
}
这边我们需要自定义注解：
package com.zy.test.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.RetentionPolicy;
@Target({ElementType.PARAMETER, ElementType.METHOD}) //注解可以用于参数或者方法上
@Retention(RetentionPolicy.RUNTIME) //保留至运行时
@Documented//被javadoc所记录
public @interface ArchivesLog {
/**
* 操作类型
@return
*/
public String operationType() default "";
/**
* 操作名称
@return
*/
public String operationName() default "";
}
然后定义我们的controller类：
package com.zy.test.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.alibaba.fastjson.JSONObject;
import com.zy.test.annotation.ArchivesLog;
import com.zy.test.service.ExceptionService;
@Controller
@RequestMapping("/exception")
public class ExceptionController {
@Autowired
private ExceptionService service;
@RequestMapping(value = "/test/{id}", method = RequestMethod.GET, produces = "application/json;charset=UTF-8" )
@ResponseBody
@ArchivesLog(operationType = "测试", operationName = "测试异常或者测试返回")
public JSONObject test(@PathVariable Integer id) throws Exception {
JSONObject result = new JSONObject();
result.put("zhouyu", "asdasdasdasd");
// try {//去掉注释可以测捕获的异常，不去掉注释可以测日志处理
// service.test();
// } catch (Exception ex) {
// throw new Exception("controller 层 异常");
// }
return result;
}
}
service接口：
package com.zy.test.service;
public interface ExceptionServiceBase {
void test() throws Exception;
}
service实现类：
package com.zy.test.service;
import org.springframework.stereotype.Service;
@Service
public class ExceptionService implements ExceptionServiceBase{
public void test() throws Exception {
boolean flag = true;
if(flag) {
throw new Exception("service 异常");
}
}
}
其中工程中的ExceptionConfig是一个配置类，用于扫描包的。但是如果你是用配置文件的化，这个文件就不用了，这边就不说了。
github上可以拉到新代码：代码在这里
到此这篇关于spring aop 统一捕获异常和写日志的文章就介绍到这了,更多相关spring aop统一异常日志内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
Java Spring AOP之PointCut案例详解
目录 一.PointCut接口 二.ClassFilter接口 三.MethodMatcher接口 总结 一.PointCut接口 /* * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with
-
解决spring AOP中自身方法调用无法应用代理的问题
目录 spring AOP中自身方法调用无法应用代理 如下例 可以使用如下两种方式修改代码以应用事务 (1)在MyServiceImpl中声明一个MyService对象 (2)使用AopContext类 spring aop 内部方法调用事务不生效 方法1: 方法2: spring AOP中自身方法调用无法应用代理 如下例 public class MyServiceImpl implements MyService { public void do(){ //the transaction a
-
Spring AOP 对象内部方法间的嵌套调用方式
目录 Spring AOP 对象内部方法间的嵌套调用 我们先定义一个接口 以及此接口的一个实现类 增加AOP处理 同一对象内的嵌套方法调用AOP失效原因分析 举一个同一对象内的嵌套方法调用拦截失效的例子 原因分析 解决方案 Spring AOP 对象内部方法间的嵌套调用 前两天面试的时候,面试官问了一个问题,大概意思就是一个类有两个成员方法 A 和 B,两者都加了事务处理注解,定义了事务传播级别为 REQUIRE_NEW,问 A 方法内部直接调用 B 方法时能否触发事务处理机制. 答案有点复杂,
-
详解Spring 框架中切入点 pointcut 表达式的常用写法
自从使用 AspectJ 风格切面配置,使得 spring 的切面配置大大简化,但是 AspectJ 是另外一个开源项目,其规则表达式的语法也稍稍有些怪异. 下面给出一些常见示例的写法,例如,下面是一个对 Service 包上所有方法的切面配置: <aop:config> <aop:pointcut id="serviceOperation" expression="execution(* *..service*..*(..))"/> <
-
带你了解如何使用Spring基于ProxyFactoryBean创建AOP代理
目录 1 基础 2 JavaBean属性 3 JDK和CGLIB代理 总结 若使用 Spring IoC 容器(ApplicationContext或BeanFactory)作为你的业务对象(你也应该这么做!),你会想使用 Spring AOP FactoryBean的一种. 工厂 bean 引入了中间层,让它创建不同类型的对象. 在Spring创建 AOP 代理的基本方式是使用 org.springframework.aop.framework.ProxyFactoryBean.这可以完全控制
-
spring 重复注解和aop拦截的实现示例
前言: 1:jdk1.8开始支持重复注解@Repeatable实现 2:aop拦截需要拦截当前注解和@Repeatable指向的包装注解才可以完全拦截到,因为:1.当在在方法上只有一个注解时,aop拦截认为是非包装类型注解.2.当方法上有多个重复注解时,aop拦截认为是包装类型注解. 重复注解实现方式(RequestLimit为原始注解,RequestLimitPack为包装注解): import java.lang.annotation.ElementType; import java.lan
-
使用spring aop 统一捕获异常和写日志的示例demo
之前给大家介绍过Spring AOP的基础知识,需要的朋友点击了解下吧,这边我将给您介绍用spring AOP 实现的异常捕获和日志的小demo,我也会详细解释相关配置. 首先给大家看一下我的工程目录: 大家可以先用eclipse中新建一个maven工程,在工程中pom.xml按下面文件添加依赖: <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XM
-
SpringBoot AOP统一处理Web请求日志的示例代码
SpringBoot AOP统一处理Web请求日志 引入依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 新建过滤器 WebLogAspect.java 使用 @Aspect 注解修饰:说明当前类 是一个切面类. 使用 @Component
-
Spring AOP统一功能处理示例代码
目录 1. 什么是Spring AOP? 2. 为什要用 AOP? 3. Spring AOP 应该怎么学习呢? 3.1AOP组成 3.1.1 切面(Aspect) 3.1.2 连接点(Join Point) 3.1.3 切点(Pointcut) 3.1.4 通知(Advice) 3.2 Spring AOP实现 3.2.1 添加 AOP 框架支持 3.2.2 定义切面和切点. 3.2.3 定义相关通知 3.3 Spring AOP 实现原理 3.3.1 动态代理 3.3.2 JDK和CGLIB
-
spring AOP自定义注解方式实现日志管理的实例讲解
今天继续实现AOP,到这里我个人认为是最灵活,可扩展的方式了,就拿日志管理来说,用Spring AOP 自定义注解形式实现日志管理.废话不多说,直接开始!!! 关于配置我还是的再说一遍. 在applicationContext-mvc.xml中要添加的 <mvc:annotation-driven /> <!-- 激活组件扫描功能,在包com.gcx及其子包下面自动扫描通过注解配置的组件 --> <context:component-scan base-package=&qu
-
使用spring aop统一处理异常和打印日志方式
我们很容易写出的代码 我们很容易写出带有很多try catch 和 logger.warn(),logger.error()的代码,这样一个方法本来的业务逻辑只有5行,有了这些,代码就变成了10行或者更多行,如: public ResultDTO<UserDTO> queryUserByCardId(String cardId) { ResultDTO<UserDTO> result = new ResultDTO<UserDTO>(); StringBuilder l
-
详解Spring Boot中使用AOP统一处理Web请求日志
在spring boot中,简单几步,使用spring AOP实现一个拦截器: 1.引入依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> <dependency> <groupId>org.springframewo
-
Spring AOP实现功能权限校验功能的示例代码
实现功能权限校验的功能有多种方法,其一使用拦截器拦截请求,其二是使用AOP抛异常. 首先用拦截器实现未登录时跳转到登录界面的功能.注意这里没有使用AOP切入,而是用拦截器拦截,因为AOP一般切入的是service层方法,而拦截器是拦截控制器层的请求,它本身也是一个处理器,可以直接中断请求的传递并返回视图,而AOP则不可以. 1.使用拦截器实现未登录时跳转到登录界面的功能 1.1 拦截器SecurityInterceptor package com.jykj.demo.filter; import
-
Spring AOP访问目标方法的参数操作示例
本文实例讲述了Spring AOP访问目标方法的参数操作.分享给大家供大家参考,具体如下: 一 配置 <?xml version="1.0" encoding="GBK"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns
-
Spring AOP中使用args表达式的方法示例
本文实例讲述了Spring AOP中使用args表达式的方法.分享给大家供大家参考,具体如下: 一 配置 <?xml version="1.0" encoding="GBK"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xml
-
Spring AOP中定义切点的实现方法示例
本文实例讲述了Spring AOP中定义切点的实现方法.分享给大家供大家参考,具体如下: 一 配置 <?xml version="1.0" encoding="GBK"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns: