---

springboot 日志输出到数据库

 

*********************

logback.xml配置

 

    <appender name="mysql" class="ch.qos.logback.classic.db.DBAppender">
        <connectionSource class="ch.qos.logback.core.db.DataSourceConnectionSource">
            <dataSource class="com.alibaba.druid.pool.DruidDataSource">
                <url>jdbc:mysql://localhost:3306/log?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=GMT%2B8</url>
                <driverClassName>com.mysql.cj.jdbc.Driver</driverClassName>
                <username>root</username>
                <password>123456</password>
            </dataSource>
        </connectionSource>
    </appender>

 

*********************

数据库设置

 

BEGIN;
DROP TABLE IF EXISTS logging_event_property;
DROP TABLE IF EXISTS logging_event_exception;
DROP TABLE IF EXISTS logging_event;
COMMIT;

BEGIN;
CREATE TABLE logging_event 
  (
    timestmp         BIGINT NOT NULL,
    formatted_message  TEXT NOT NULL,
    logger_name       VARCHAR(254) NOT NULL,
    level_string      VARCHAR(254) NOT NULL,
    thread_name       VARCHAR(254),
    reference_flag    SMALLINT,
    arg0              VARCHAR(254),
    arg1              VARCHAR(254),
    arg2              VARCHAR(254),
    arg3              VARCHAR(254),
    caller_filename   VARCHAR(254) NOT NULL,
    caller_class      VARCHAR(254) NOT NULL,
    caller_method     VARCHAR(254) NOT NULL,
    caller_line       CHAR(4) NOT NULL,
    event_id          BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY
  );
COMMIT;


BEGIN;
CREATE TABLE logging_event_property
  (
    event_id       BIGINT NOT NULL,
    mapped_key        VARCHAR(254) NOT NULL,
    mapped_value      TEXT,
    PRIMARY KEY(event_id, mapped_key),
    FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  );
COMMIT;


BEGIN;
CREATE TABLE logging_event_exception
  (
    event_id         BIGINT NOT NULL,
    i                SMALLINT NOT NULL,
    trace_line       VARCHAR(254) NOT NULL,
    PRIMARY KEY(event_id, i),
    FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  );
COMMIT;

 

*********************

数据库插入示例

 

logging_event

           

 

logging_event_exception

                  

 

logging_event_property

                  

 

 

SpringBoot Aop 记录操作日志存入数据库

本文不探讨具体原理，只讲业务实现。我主要是将这个操作分为以下几步:
1.首先我们需要自定义一个操作注解来获取我们拦截的接口的相关信息

2.那么接下来就是这个操作注解放在哪里了

我们需要将该注解放在我们需要拦截的接口上，那这个接口具体属于哪个模块，我们就可以命名moduleName即模块名，option就是这个接口具体是干什么的。注意，所有加上该注解的接口如果被调用那么都会被拦截。
3.接下来我们利用SpringAOP来拦截接口进行日志操作

    */**
     * @author : hao.wu
     * @Description :日志拦截器，切面处理类
     * @Date : Create in 14:32 2019/5/23
     * @Modified By:
     */
    @Aspect
    @Component
    public class LogInterceptor {
        @Autowired
        private CrmOperationLogService crmOperationLogService;
        @Around("@annotation(log)")
        public Object interceptorApplogic(ProceedingJoinPoint pj, OperationLog log) throws Throwable {
        	//这个Pojo是我日志记录的实体类
            OperationLogPojo operationLogPojo = new OperationLogPojo();
           //因为项目的权限控制用的是shiro,所以我这里的可以获取到操作人id,名字这段无关具体操作流程
            Subject subject = SecurityUtils.getSubject();
            UserInfoCommand user = (UserInfoCommand) subject.getSession().getAttribute(ConstantMsg.USER_LOGIN);
            Long userId = user.getId();
            String userName = user.getUserName();
            //获取到被拦截接口上注解的option
            String option = log.option();
            //***继续执行被拦截的接口，记住最后一定要返回这个结果***
            Object proceed = pj.proceed();
            //获取到拦截的接口的方法名
            String methodName = pj.getSignature().getName();
            MethodSignature signature = (MethodSignature) pj.getSignature();
            //被拦截的方法的参数名称数组
            String[] parameterNames = signature.getParameterNames();
            //被拦截的方法的参数值对象数组，这里我们将传入的参数转为json字符串格式便于存入数据库
            Object[] objects = pj.getArgs();
            StringBuilder args = new StringBuilder();
            for (int i = 0; i < objects.length; i++) {
                String s = JSON.toJSONString(objects[i]);
                if (i == objects.length - 1){
                    args.append(s);
                }else {
                    args.append(s).append(",");
                }
            }
            //给日志操作记录类赋值然后存入数据库
            operationLogPojo.setUserId(userId);
            operationLogPojo.setUserName(userName);
            //方法名
            operationLogPojo.setMethodName(methodName);
            //操作名
            operationLogPojo.setOperation(option);
            operationLogPojo.setOperationTime(new Date());
            //被拦截方法的传入的参数值
            operationLogPojo.setArgs(args.toString());
            crmOperationLogService.addOperationLog(operationLogPojo);
            return proceed;
        }
    }**

4.那么最后我们来看一下数据库里的结果吧

第一次写博客，写的不好还请见谅。

SpringAop切面+自定义注解实现日志记录

 

在之前的SpringAop当中，实现了对service层的方法定义了切入点，从而在执行service层的方法的时候会自动加入事务，而这些操作，都是在配置文件当中去实现的；

 

在这篇博文当中，会一不同的方式来实现日志事务的添加，用的式注解的方式，而且切入点和事务都是一起定义在切面类当中的；

 

首先来说明一些概念：

 

SpringAop 底层的原理就是动态代理，

 

但是运行时织入的，也就是在用到目标类或者方法的时候，生成一个代理类，然后将配好的通知织入

 

但就Aop而言的话它本身还有的方式就是，编译时织入，比如说是前置通知，当你编译了以后他就会织入到方法当中，所以你通过反射的方法去看的话会看到相应的生成代码

，还有就是在类加载期间织入的，

但是就性能而言的，SpringAop的这种动态代理的方式，是有着较高的效率的；

Spring提供了四种aop切面的支持

 

   基于代理的经典的pringAop

   纯POJO切面

   @AspectJ注解驱动切面//底层也是Spring的动态代理 只是参考了AspectJ的一些形式

   注入式Aspectj切面

而本此使用的就是@AspectJ注解驱动切面的方式。

 

 

1.要实现自定义注解的切面实现；

首先我们要有一个自定义的注解，下面就是自定义注解的代码，关于自定义注解大家可以自己去了解，下面式创建过程：

 

在创建类的时候选择Annotation这个注解方式，即可；

下面是代码：

我们在OperationLogger这样一个注解类中写如下代码：

@Retention(RetentionPolicy.RUNTIME)//注解会在class中存在，运行时可通过反射获取
@Target(ElementType.METHOD)//目标是方法
public @interface OperationLogger
{

    String modelName() default "";
//首先是被调用的方法的名称，其默认值是“”
    String user();
//接下了一个就是当前使用这个方法的用户是谁
    String option();
//之后就是这个用户所做的是什么操作
}

其实这个类就是一个特殊的接口，只不过这个注解是声明在方法之上的；

 

2.在我们定义好了注解之后我们还需要的就是一个切面类：

我们将切面的名称命名为：SysLogAspect,在这个类当中我们将声明各种通知，以及处理通知的方法，并调用Logservice来实现将记录的日志写入到数据库当中,用到的就是反射的方法：

下面是代码：

首先声明这是一个事务切面
@Aspect
@Component

让其被Spring容器去管理
public class SysLogAspect
{
我们在这和切面当中声明服务层的接口，来实现将我们获取到的日志存入到数据库当中

    @Autowired
    private LoggerService loggerService;

之后声明一个日志的对象
    private static final Logger logger =

Logger.getLogger(SysLogAspect.class);

然后配置切点，切点实在空方法上去配置的，当然这是简便写法，因为这样的话，后面方法上面的切面就直接可以用户这个空的方法名去代替这样就避免了重复去写契入点
    @Pointcut("@annotation(com.qf.annocation.OperationLogger)")
    public void controllerAspect()
    {
        System.out.println("我是一个切入点");
    }
（1）配置通知

    /**
     * 前置通知（Before advice） ：在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。
     * @param joinPoint
     */

前置通知的切入点就直接写的是之前声明切入点的方法
    @Before("controllerAspect()")
    public void doBefore(JoinPoint joinPoint)
    {
        System.out.println("=====SysLogAspect前置通知开始=====");

//调用日志处理类去处理我们的日志
        handleLog(joinPoint, null);
    }

    /**
     * 后通知（After advice） ：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
     * @param joinPoint
     */

同样后置通知的切入点就直接写的是之前声明切入点的方法
    @AfterReturning(pointcut = "controllerAspect()")
    public void doAfter(JoinPoint joinPoint)
    {
        System.out.println("=====SysLogAspect后置通知开始=====");

//调用日志处理类去处理我们的日志
        handleLog(joinPoint, null);
    }

    /**
     * 抛出异常后通知（After throwing advice） ： 在方法抛出异常退出时执行的通知。
     * @param joinPoint
     * @param e
     */

异常通知，我们用value去接收切入点，

这里解释一下当你的参数是一个的时候默认是用value去接收的参数是多个的时候必须做声明，因为是异常通知所需要一个异常注解在上面以便于记录
    @AfterThrowing(value = "controllerAspect()", throwing = "e")
    public void doAfter(JoinPoint joinPoint, Exception e)
    {

        System.out.println("=====SysLogAspect异常通知开始=====")

//调用日志处理类去处理我们的日志，传入异常;
        handleLog(joinPoint, e);
      

    }

    /**
     * 环绕通知（Around advice） ：包围一个连接点的通知，类似Web中Servlet规范中的Filter的doFilter方法。可以在方法的调用前后完成自定义的行为，也可以选择不执行。
     * @param joinPoint
     */

然后是环绕通知对于环绕通知来说，它于其它的不同之处有两点：

1. 参数是ProceedingJoinPoint
2. 使用环绕通知的时候必须去手动执行方法，如果你不去执行方法，当你直接使用的是环绕通知的时候，它会将你日志注解声明之下的方法的返回值屏蔽这样前端是得不到数据的这样会造成一堆的问题，所以要手动去执行proceed方法
3. 
       @Around("controllerAspect()")
       public Object doAround(ProceedingJoinPoint joinPoint)
       {
           Object proceed=null;
           System.out.println("=====SysLogAspect 环绕通知开始=====");

//调用日志处理类去处理我们的日志
        handleLog(joinPoint, null);

        try {
            proceed = joinPoint.proceed();
            return proceed;
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return null;
    }

   /**
     （2）* 日志处理方法
     *
     * @param joinPoint
     * @param e
     */
    private void handleLog(JoinPoint joinPoint, Exception e)
    {
        try
        {

在这里我们首先根据得到的JoinPoint获得注解，具体调用的方法在下面：
            //获得注解，这是在
            OperationLogger logger = giveController(joinPoint);

判断一下返回的是不是空值，防止出现空指针错误
            if (logger == null)
            {
                return;
            }

// 获取目标方法的签名

String signature = joinPoint.getSignature().toString();

//根据的带的签名去截取方法名

String methodName =

在目标方法的签名当中以最后一个点加1开始，以包裹参数的第一个尖括号结尾截取方法名

signature.substring(signature.lastIndexOf(".")+1，  

 

signature.indexOf("("));

当然这个变量并不会在这里用到
            String longTemp = joinPoint.getStaticPart().toLongString();

 

再通过得到调用方法的目标对象，从而获取它的类名
            String classType =

joinPoint.getTarget().getClass().getName();
再通过反射来得到这个类对象
            Class<?> clazz = Class.forName(classType);
得到它内部所有的方法
            Method[] methods = clazz.getDeclaredMethods();
            System.out.println("methodName: " + methodName);
对得到的方法集合进行变脸
            for (Method method : methods)
            {

如果以这个方法上面的注解值日志注解并且方法的名称是之前截取到的方法名
                if (method.isAnnotationPresent(OperationLogger.class)

                        && method.getName().equals(methodName))
                {

这个时候就可以通过这个方法去获取其上面的注解
      我们将获取主借注解的功能封装成一个方法，将之前反射得到的类对象当作参数传递过去
                    String clazzName = clazz.getName();
                    System.out.println("clazzName: " + clazzName + ", methodName: "
                            + methodName);

调用方法，在这里实现的就是对方法的遍历
                    String process = SysLogAspect.process(clazz);

这里就调用我们的服务层去将得到的数据写入数据库
                    loggerService.addLogger(process,methodName);
                }
            }

        } catch (Exception exp)
        {
            logger.error("异常信息:{}", exp);
            exp.printStackTrace();
        }
    }

    /**
     * 获得注解
     * @param joinPoint
     * @return
     * @throws Exception
     */
    private static OperationLogger giveController(JoinPoint joinPoint) throws Exception
    {
      

访问目标方法参数,有三种方法(实际有四种)

1.joinpoint.getargs():获取带参方法的参数

2.joinpoint.getTarget():.获取他们的目标对象信息

3..joinpoint.getSignature():(signature是信号,标识的意思):获取被增强的方法相关信息

Signature signature = joinPoint.getSignature();

//将其强转为MethodSignature 在根据这个去得到具体使用的方法       

 

 

MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();

        if (method != null)
        {

根据方法提供的方法去的到它上面的注解，参数就是我们的自定义注解的类对象

在这里，参数是什么样的注解，你得到的就是相应注解的对象，接收的时候返回值类型也就是相应的类型
            return method.getAnnotation(OperationLogger.class);
        }
        return null;
    }
 

被调用的方法，在这里获得方法上面的注解返回即可，这里由于我们的注解比较的少，所以我们直接返回的就是字符串，如果有多个，可以分装一个对象这里直接返回对像即可
    public static String process(Class clazz) {
        //找方法

        String modelName=null;
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            OperationLogger annotation = method.getAnnotation(OperationLogger.class);//获取指定类型的注解
            //动态代理对象，

            if (annotation != null) {
                //说明有注解
                modelName = annotation.modelName();
                String user = annotation.user();

            }
        }
        return modelName;
    }
}

以上就是我们的日志事务切面，以及对日志的处理都已经准备完毕

 

准备好了注解以及事务切面之后，我们来写一个控制类

再其上面声明我我们自定义的注解

我们以得到数据库列表这个控制器为例

 

之后我们就来编写服务层：

再得到参数之后将其直接插入数据库即可

 

之后我们除了之前与SSM一样的配置意外，我们还应该对我们的注解开启扫描：

 

在Springmvc的配置文件当中加尔u这两个即可；

 

最后我们来测试的结果：

以上就完成了通过springAop的日志事务来将我们用户的一步步操作注入到数据库当中，实现了，数据库存储操所日志的功能

 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_42112846；