Springboot2 配置AOP日志的方法步骤

Spring boot2 配置AOP前置增强,后置增强,异常增强,环绕增强,最终增强

关于AOP切面相关具体概念不做过多阐述(概念弄懂有利于理解思想),这是配置AOP的各种增强日志,解决日志嵌套在业务代码的麻烦和不科学

先来个Git demo项目压压惊: https://github.com/zhang-xiao-xiang/boot-aop (有的更新了一些)

1pom依赖(这里使用log4j2作为日志框架,因为比log4j或者其他日志框架,它效率更高,功能更加强大)

<!-- 引入log4j2依赖(注意还有排除依赖) -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-log4j2</artifactId>
    </dependency>
    <!-- 排除exclude掉spring-boot的默认log框架配置 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <exclusions>
        <exclusion>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <!-- 加上这个才能辨认到log4j2.yml文件(如果日志要输出到本地或者具体磁盘,需要配置yml) -->
      <groupId>com.fasterxml.jackson.dataformat</groupId>
      <artifactId>jackson-dataformat-yaml</artifactId>
    </dependency>
    <!--AOP的支持依赖-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

2编写切面类

package com.example.nba.aop;//改成你的包名即可

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

/**
 * AopLog
 *
 * @author 10905 2019/1/4
 * @version 1.0
 */
@Aspect
@Component
public class AopLog {
  //使用org.slf4j.Logger,这是Spring实现日志的方法
  private final static Logger logger = LoggerFactory.getLogger(AopLog.class);

  //	切入点注解的表达式:就是需要AOP的地方(一般是业务逻辑层service,当然服务接口调用层controller也行,两者一起打印日志也行
  //	这个类似正则表达式,可以控制日志的精度(包下,类下,方法下)和切面的类型(业务层面,服务接口层面)相当灵活)
    @Pointcut("execution(* com.example.nba.controller.PlayerApi.*(..))")
  // @Pointcut("execution(* com.example.nba.repository.PlayerRep.*(..))")
  //切入点签名的方法,注意返回值必须是void,相当于切入点的无参构造
  public void mypointcut() {
  }

  //	前置增强
  @Before("mypointcut()")
  public void Mybefore(JoinPoint jp) {
    logger.info("*前置增强*调用了【" + jp.getTarget().getClass().getSimpleName() +
        "】的【" + jp.getSignature().getName() + "】的方法,方法入参为【"
        + Arrays.toString(jp.getArgs()) + "】");
    // 接收到请求,记录请求内容(这里同样可以在前置增强配置请求的相关信息)
    ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    HttpServletRequest request = attributes.getRequest();
    logger.info("请求的地址URL : " + request.getRequestURL().toString());
    logger.info("请求的方式HTTP_METHOD : " + request.getMethod());
    logger.info("请求的IP : " + request.getRemoteAddr());
    logger.info("请求的全类名 : " + jp.getSignature().getDeclaringTypeName() + "." + jp.getSignature().getName());
    logger.info("请求的参数(数组形式) : " + Arrays.toString(jp.getArgs()));

  }

  //后置增强
  @AfterReturning(pointcut = "mypointcut()", returning = "result")
  public void MyafterReturing(JoinPoint jp, Object result) {
    logger.info("*后置增强*调用了【" + jp.getTarget().getClass().getSimpleName() +
        "】的【" + jp.getSignature().getName() + "】的方法,方法返回值【" + result + "】");
  }

  //	异常抛出增强
  @AfterThrowing(pointcut = "mypointcut()", throwing = "e")
  public void afterThrowing(JoinPoint jp, RuntimeException e) {
    logger.error("*异常增强*【" + jp.getSignature().getName().getClass().getSimpleName() + "】方法发生异常【" + e + "】");
  }

  //	最终增强
  @After("mypointcut()")
  public void afterLogger(JoinPoint jp) {
    logger.info("*最终增强*【" + jp.getSignature().getName() + "】方法结束执行。");
  }

  //环绕增强
  @Around("mypointcut()")
  public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {
    logger.info("在==>>" + jp.getTarget().getClass().getName() + "类里面使用AOP环绕增强==");
    logger.info("*环绕增强*调用【" + jp.getTarget().getClass().getSimpleName() + "】的【 " + jp.getSignature().getName()
        + "】方法。方法入参【" + Arrays.toString(jp.getArgs()) + "】");
    try {
      Object result = jp.proceed();
      logger.info("*环绕增强*调用 " + jp.getTarget() + "的【 "
          + jp.getSignature().getName() + "】方法。方法返回值【" + result + "】");
      return result;
    } catch (Throwable e) {
      logger.error(jp.getSignature().getName() + " 方法发生异常【" + e + "】");
      throw e;
    } finally {
      logger.info("*环绕增强*执行finally【" + jp.getSignature().getName() + "】方法结束执行<<==。");
    }
  }
}

3测试(数据库代码和业务层等代码就不贴上去了,主要参考AOP的pom依赖和切面类),比如我浏览器请求

http://localhost:8080/player/findAll

控制器显示:

json格式的aop配置(注意文件格式入参需要判断一下(因为excel,PDF,png等格式无法转json)),假如现在的需求是请求和返回参数均以json格式为主,并且记录日志到数据库(排除查询日志的接口,因为查询日志不需要记录到数据库,这里涉及到 AOP排除某个接口或者说是某个切面 ,具体见下)

日志实体(表)

package com.xinzuo.lvyou.pojo;

import java.io.Serializable;
import java.util.Date;

import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 日志记录监控表
 * </p>
 *
 * @author zhangxiaoxiang
 * @since 2019-07-08
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class LogMonitor implements Serializable {

  private static final long serialVersionUID = 1L;

  /**
   * 日志主键ID
   */
  @TableId
  private String logId;

  /**
   * 请求IP地址
   */
  private String requestIp;

  /**
   * 操作接口反馈描述
   */
  private String summarize;
  /**
   * 响应状态吗
   */
  private Integer responseCode;

  /**
   * 请求方式
   */
  private String requestType;

  /**
   * 请求接口
   */
  private String requestApi;

  /**
   * 请求参数
   */
  private String requestPara;

  /**
   * 返回参数
   */
  private String responsePara;

  /**
   * 请求到响应处理时间(毫秒)
   */
  private Integer responseTime;

  /**
   * 创建时间(请求发出的时间)
   */
  private Date createTime;

  /**
   * 日志所属(0移动前端日志,1PC端日志)
   */
  private Integer belongTo;
}

下面是json格式并带有记录到数据库的需求的,假如返回的格式是三段式json,如下

{
  "code": 200,
  "msg": "查询打卡次数成功",
  "data": {
    "photoSave": null,
    "user": null,
    "amount": 27
  }
}

切面类的编写如下

package com.xinzuo.lvyou.aop;

import com.alibaba.fastjson.JSONArray;
import com.gexin.fastjson.JSON;
import com.gexin.fastjson.JSONObject;
import com.xinzuo.lvyou.dao.LogMonitorDao;
import com.xinzuo.lvyou.pojo.LogMonitor;
import com.xinzuo.lvyou.util.KeyUtil;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.Date;

/**
 * AopLog:日志切面类
 *
 * @author zhangxiaoxiang
 * @date: 2019/05/22
 */
@Component
@Aspect
public class AopJsonLog {
  /**
   * 记录日志到数据库
   */
  @Autowired
  private LogMonitorDao logMonitorDao;
  //记录到数据库
  LogMonitor logMonitor = new LogMonitor();
  long start = 0;

  /**
   * 使用org.slf4j.Logger,这是Spring实现日志的方法
   */
  private final static Logger logger = LoggerFactory.getLogger(AopJsonLog.class);

  @Pointcut("execution(* com.xinzuo.lvyou.admin..*(..)) ")
  public void myPointcut() {
  }

  /**
   * 前置增强 单独配置的前端接口切面
   * 日志打印排除在外,查询日志接口就不记录数据库
   * 排除某个方法使用!execution(* com.xinzuo.lvyou.controller.LogMonitorController.*(..))
   *
   * @param jp
   */
  @Before("execution(* com.xinzuo.lvyou.controller..*(..)) && !execution(* com.xinzuo.lvyou.controller.LogMonitorController.*(..))")
  public void MyBefore(JoinPoint jp) {
    logger.info("---------------------------------前端请求接口日志----------------------------------------------");
    // 接收到请求,记录请求内容(这里同样可以在前置增强配置请求的相关信息)
    ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    HttpServletRequest request = attributes.getRequest();
    logger.info("访问的接口:" + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());
    try {
      logger.info("请求入参为:" + new JSONArray(Arrays.asList(jp.getArgs())).toString());
    } catch (Exception e) {
      logger.info("请求入参为:图片,视频,excel,PDF等格式(此时无法转换成JSON格式)");
      //由于知道这里异常的原因是json转换参数异常,所以就不打印了,不捕获,以免控制台难看或者日志难看
      //e.printStackTrace();
    }
    //logger.info("请求的地址URL:      " + request.getRequestURL().toString());
    //logger.info("请求的方式HTTP_METHOD:  " + request.getMethod());
    //logger.info("请求的IP:        " + request.getRemoteAddr());

    start = System.currentTimeMillis();
    logMonitor.setLogId(KeyUtil.genUniqueKey());
    logMonitor.setRequestType(request.getMethod());
    logMonitor.setRequestApi(jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());
    try {
      logMonitor.setRequestPara(new JSONArray(Arrays.asList(jp.getArgs())).toString());
    } catch (Exception e) {
      logMonitor.setRequestPara("请求入参为:图片,视频,excel,PDF等格式(此时无法转换成JSON格式)");
    }
    logMonitor.setRequestIp(request.getRemoteAddr());
    logMonitor.setCreateTime(new Date());

  }

  /**
   * 后置增强
   * 排除某个方法使用!execution(* com.xinzuo.lvyou.controller.LogMonitorController.*(..))
   * 日志打印排除在外,查询日志接口就不记录数据库
   * @param jp
   * @param vo
   */
  @AfterReturning(pointcut = "execution(* com.xinzuo.lvyou.controller..*(..)) && !execution(* com.xinzuo.lvyou.controller.LogMonitorController.*(..))", returning = "vo")
  public void MyafterReturing(JoinPoint jp, Object vo) {

    //logger.info("访问的接口: " + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());
    //入参打印json数组格式
//    try {
//      logger.info("请求入参为:" + new JSONArray(Arrays.asList(jp.getArgs())).toString());
//    } catch (Exception e) {
//      logger.info("请求入参为图片,视频,excel,PDF等格式(此时无法转换成JSON格式)");
//      //由于知道这里异常的原因是json转换参数异常,所以就不打印了,不捕获,以免控制台难看或者日志难看
//      //e.printStackTrace();
//    }
    logger.info("方法返回值:" + JSON.toJSONString(vo));
    logMonitor.setResponsePara(JSON.toJSONString(vo));
    long end = System.currentTimeMillis();
    //解析json
    JSONObject json= null;
    try {
      json = JSON.parseObject(JSON.toJSONString(vo));
      logMonitor.setResponseCode(Integer.valueOf(json.get("code").toString()));
      logMonitor.setSummarize(json.get("msg").toString());
    } catch (Exception e) {
      logMonitor.setSummarize("进行图片,视频,excel,PDF等格式操作(由于这个操作特殊一点,所以后台直接把返回状态码默认为200,以实际为准)");
      logMonitor.setResponseCode(200);
      //e.printStackTrace();
    }

    logMonitor.setBelongTo(0);
    logMonitor.setResponseTime((int) (end - start));
    try {
      logMonitorDao.insert(logMonitor);
    } catch (Exception e) {
      logger.info("AOP系统故障!");
    }
  }

//  /**
//   * 异常抛出增强
//   *
//   * @param jp
//   * @param e
//   */
//  @AfterThrowing(pointcut = "myPointcut()", throwing = "e")
//  public void afterThrowing(JoinPoint jp, RuntimeException e) {
//    logger.error("异常增强:" + jp.getSignature().getName().getClass().getSimpleName() + "方法发生异常【" + e + "】");
//  }

  /**
   * 环绕增强 :测试的时候finally的切面日志注释不打印,因为日志多了反而不好调试,上线时再取消注释
   *
   * @param jp
   * @return
   * @throws Throwable
   */
  @Around("myPointcut()")
  public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {

    logger.info("admin---------------------------------后台请求接口日志----------------------------------------------");
    logger.info("访问的接口:" + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());
    //入参打印json数组格式

    try {
      logger.info("请求入参为:" + new JSONArray(Arrays.asList(jp.getArgs())).toString());
    } catch (Exception e) {
      logger.info("请求入参为:图片,视频,excel,PDF等格式(此时无法转换成JSON格式)");
      //由于知道这里异常的原因是json转换参数异常,所以就不打印了,不捕获,以免控制台难看或者日志难看
      //e.printStackTrace();
    }

    try {
      Object result = jp.proceed();
      logger.info("方法返回值:" + JSON.toJSONString(result));
      return result;
    } catch (Throwable e) {
      logger.info("访问的接口:" + jp.getTarget().getClass().getName() + "." + jp.getSignature().getName());
      logger.info("请求入参为:" + new JSONArray(Arrays.asList(jp.getArgs())).toString());
      logger.error(jp.getSignature().getName() + " 方法发生异常【" + e + "】");
      throw e;
    } finally {
      //logger.info("访问的接口: " + jp.getTarget().getClass().getName() + "."+jp.getSignature().getName());
      //logger.info("请求入参为: "+ new JSONArray(Arrays.asList(jp.getArgs())).toString());
      //logger.info("执行   :" + jp.getSignature().getName() + "方法结束。");
    }
  }
}

————————————下面是spring AOP配置需要的额外依赖—————————————–

<dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.6.12</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.12</version>
    </dependency>
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>2.2</version>
    </dependency>

到此这篇关于Springboot2 配置AOP日志的方法步骤的文章就介绍到这了,更多相关Springboot2 配置AOP日志内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

时间:2020-06-21

详解基于SpringBoot使用AOP技术实现操作日志管理

操作日志对于程序员或管理员而言,可以快速定位到系统中相关的操作,而对于操作日志的管理的实现不能对正常业务实现进行影响,否则即不满足单一原则,也会导致后续代码维护困难,因此我们考虑使用AOP切面技术来实现对日志管理的实现. 文章大致内容: 1.基本概念 2.基本应用 3.日志管理实战 对这几部分理解了,会对AOP的应用应该很轻松. 一.基本概念 项目 描述 Aspect(切面) 跨越多个类的关注点的模块化,切面是通知和切点的结合.通知和切点共同定义了切面的全部内容–它是什么,在何时和何处完成其功

Spring Boot配置AOP打印日志的全过程

前言 在项目开发中,日志系统是必不可少的,用AOP在Web的请求做入参和出参的参数打印,同时对异常进行日志打印,避免重复的手写日志,完整案例见文末源码. 一.Spring AOP AOP(Aspect-Oriented Programming,面向切面编程),它利用一种"横切"的技术,将那些多个类的共同行为封装到一个可重用的模块.便于减少系统的重复代码,降低模块之间的耦合度,并有利于未来的可操作性和可维护性. AOP中有以下概念: Aspect(切面):声明类似于Java中的类声明,在

Spring Boot2集成AOPLog来记录接口访问日志

前言 日志是一个Web项目中必不可少的部分,借助它我们可以做许多事情,比如问题排查.访问统计.监控告警等.一般通过引入slf4j的一些实现框架来做日志功能,如log4j,logback,log4j2,其性能也是依次增强.在springboot中,默认使用的框架是logback. 我们经常需要在方法开头或结尾加日志记录传入参数或返回结果,以此来复现当时的请求情况.但是手动添加日志,不仅繁琐重复,也影响代码的美观简洁.本文引入一个基于AOP实现的日志框架,并通过spring-boot-starter

SpringBoot中使用AOP打印接口日志的方法

前言 AOP 是 Aspect Oriented Program (面向切面)的编程的缩写.他是和面向对象编程相对的一个概念.在面向对象的编程中,我们倾向于采用封装.继承.多态等概念,将一个个的功能在对象中来实现.但是,我们在实际情况中也发现,会有另外一种需求就是一类功能在很多对象的很多方法中都有需要.例如有一些对数据库访问的方法有事务管理的需求,有很多方法中要求打印日志.按照面向对象的方式,那么这些相同的功能要在很多地方来实现或者在很多地方来调用.这就非常繁琐并且和这些和业务不相关的需求耦合太

spring-boot使用AOP统一处理日志

AOP我想大家都很清楚,有时候我们需要处理一些请求日志,或者对某些方法进行一些监控,如果出现例外情况应该进行怎么样的处理,现在,我们从spring-boot中引入AOP. [开发环境:jdk版本号为1.8,spring boot的版本号为1.4.1]{style="background-color:#FF0000"} 首先,我们先引入jar包, POM文件添加如下内容: <!–引用AOP–> <dependency> <groupId>org.s

springboot如何使用AOP做访问请求日志

这篇文章主要介绍了springboot如何使用AOP做访问请求日志,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 springboot中使用AOP做访问请求日志:这次引入springboot的aop和日志 1.pom.xml引入: <!–springBoot的aop,已经集成了spring aop和AspectJ–> <dependency> <groupId>org.springframework.boot<

Springboot接口项目如何使用AOP记录日志

一. 背景 一直想给项目构建一个统一的日志收集系统,先迈出第一步,构建一个日志收集类,用AOP实现无侵入日志收集 二. 环境 1.此随笔内容基于spring boot项目 2.数据库为mysql 5.7.9版本 3.jdk 版本为1.8 三. 说明 此版采用数据库存储,之后考虑使用elasticsearch等工具存储 四. 内容 1.构建日志采集实体类:BaseLogMessage public class BaseLogMessage { private String serverIP; pr

springboot配置aop切面日志打印过程解析

这篇文章主要介绍了springboot配置aop切面日志打印过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.SpringBoot Aop说明 1. Aop AOP(Aspect-Oriented Programming,面向切面编程),它利用一种"横切"的技术,将那些多个类的共同行为封装到一个可重用的模块.便于减少系统的重复代码,降低模块之间的耦合度,并有利于未来的可操作性和可维护性. 2. AOP相关概念: Aspect

python logging日志打印过程解析

Springboot2 配置AOP日志的方法步骤

一. 基础使用 1.1 logging使用场景 日志是什么?这个不用多解释.百分之九十的程序都需要提供日志功能.Python内置的logging模块,为我们提供了现成的高效好用的日志解决方案.但是,不是所有的场景都需要使用logging模块,下面是Python官方推荐的使用方法: 任务场景 最佳工具 普通情况下,在控制台显示输出 print() 报告正常程序操作过程中发生的事件 logging.info()(或者更详细的logging.debug()) 发出有关特定事件的警告 warnings.

Springboot通过aop实现事务控制过程解析

spring的事务控制本质上是通过aop实现的. 在springboot中使用时,可以通过注解@Transactional进行类或者方法级别的事务控制,也可以自己通过spring提供的事务管理器手动控制事务 一. @Transactional注解进行进行类或者方法级别的事务控制 不需要进行特别的设置,按照正常的配置整合spring和mybatis后,在需要进行事务控制的类上或者方法上加上 @Transactional注解,即可对其进行事务控制. 二.手动控制事务 当需要在一个方法的内部进行事务控

SpringBoot多模块项目框架搭建过程解析

这篇文章主要介绍了SpringBoot多模块项目框架搭建过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 创建根项目,New Project 创建一个名为 sms-bomber 的 SpringBoot 新项目,打包为 JAR 的即可,这里只添加 Lombok 与 spring-boot-starter-web 依赖,这两个依赖会传递给所有子模块,删除创建完成的项目中的 .mvn/ src/ mvnw mvnw.cmd 创建启动模块,根目

Python操作Sonqube API获取检测结果并打印过程解析

这篇文章主要介绍了Python操作Sonqube API获取检测结果并打印过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.需求:每次Sonqube检查完毕后,需要登陆才能看到结果无法通过Jenkins发布后直接看到bug 及漏洞数量. 2.demo:发布后,可以将该项目的检测结果简单打印出来显示,后面还可以集成钉钉发送到群里. # -*- coding: UTF-8 -*- import sys reload(sys) sys.se

springboot向elk写日志实现过程

springboot里连接elk里的logstash,然后写指定index索引的日志,而之后使用kibana去查询和分析日志,使用elasticsearch去保存日志. 添加引用 implementation ‘net.logstash.logback:logstash-logback-encoder:5.3′ 添加配置 <?xml version="1.0" encoding="UTF-8"?> <configuration debug=&quo

基于XML配置Spring的自动装配过程解析

一.了解Spring自动装配的方式 采用传统的XML方式配置Bean组件的关键代码如下所示 <bean id="userMapper" class="edu.cn.dao.UserMapperImpl"> <property name="sqlSessionFactory" ref="sqlSessionFactory"/> </bean> <bean id="userSer

SpringBoot实现devtools实现热部署过程解析

1.修改pom.xml文件 <project> <dependencies> <!– 使用devtool热部署插件(推荐) –> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional>

SpringBoot整合aop面向切面编程过程解析

这篇文章主要介绍了SpringBoot整合aop面向切面编程过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是Spring框架中的一个重要内容,它通过对既有程序定义一个切入点,然后在其前后切入不同的执行内容,比如常见的有:打开数据库连接/关闭数据库连接.打开事务/关闭事务.记录日

Spring Boot Logback配置日志过程解析

这篇文章主要介绍了Spring Boot Logback配置日志过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 出于性能等原因,Logback 目前是springboot应用日志的标配: 当然有时候在生产环境中也会考虑和三方中间件采用统一处理方式. 配置时考虑点 支持日志路径,日志level等配置 日志控制配置通过application.yml下发 按天生成日志,当天的日志>50MB回滚 最多保存10天日志 生成的日志中Pattern自

原文 

https://www.zhangshengrong.com/p/rG1V74k6a3/

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Springboot2 配置AOP日志的方法步骤

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址