SpringBoot使用LogAspect的切面日志

已于 2022-08-19 17:39:49 修改
阅读量1.4k 收藏 5
点赞数 1
分类专栏： Java 文章标签： spring boot java
于 2022-08-08 16:38:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tanqingfu1/article/details/126230286
版权

目录

1、引入依赖

2、切面方法

3、Log类

 4、LogAspect类

5、SysLog实体类

6、服务类和服务实现类

7、实际调用

1、引入依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <scope>test</scope>
</dependency>
<dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
</dependencies>

2、切面方法

切面方法说明如下：

@Aspect 作用是把当前类标识为一个切面供容器读取
@Pointcut (切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式
@Before 标识一个前置增强方法，相当于BeforeAdvice的功能
@AfterReturning 后置增强，相当于AfterReturningAdvice，方法退出时执行
@AfterThrowing 异常抛出增强，相当于ThrowsAdvice
@After final增强，不管是抛出异常或者正常退出都会执行
@Around 环绕增强，相当于MethodInterceptor

3、Log类

package com.shucha.deveiface.biz.aspect;

import java.lang.annotation.*;

/**
 * @author tqf
 * @Description 自定义拦截日志
 * @Version 1.0
 * @since 2022-08-08 15:28
 */
@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {

    /**
     * 操作描述  查询、新增、修改、删除等
     * @return
     */
    String menu() default "";

    /**
     * 接口名称 不需要填写  可以通过request.getRequestURL().toString(); 获取
     * @return
     */
    String operation() default "";

    /**
     * 是否记录请求参数数据, 默认true: 记录; false:不记录
     *
     * @return
     */
    boolean isData() default true;
}

 4、LogAspect类

package com.shucha.deveiface.biz.aspect;



import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.sdy.common.model.Response;
import com.sdy.mvc.controller.BaseController;
import com.sdy.mvc.utils.HttpUtil;
import com.shucha.deveiface.biz.model.SysLog;
import com.shucha.deveiface.biz.service.SysLogService;
import feign.Request;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ArrayUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
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.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * @author tqf
 * @Description 日志切面类
 * @Version 1.0
 * @since 2022-08-08 15:28
 */
@Aspect
@Component
@Slf4j
@Order(1)
public class LogAspect {

    @Autowired
    private SysLogService sysLogService;

    private final ThreadLocal<Long> startTime = new ThreadLocal<>();

    // 配置织入点
    @Pointcut("@annotation(Log)")
    public void logPointCut() {
    }

    @Before("logPointCut()")
    private void before() {
        startTime.set( System.currentTimeMillis());
    }

    /**
     * 处理完请求后执行
     * @param joinPoint
     * @param res
     * @throws Exception
     */
    @AfterReturning(returning = "res", pointcut = "logPointCut()")
    public void afterReturning(JoinPoint joinPoint, Response res) throws Exception {
        long nowTime = System.currentTimeMillis();
        HttpServletRequest request = getRequest();
        handleLog(joinPoint, null, res, nowTime, request);
    }

    /**
     * 拦截异常操作
     * @param joinPoint 切点
     * @param e         异常
     */
    @AfterThrowing(value = "logPointCut()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e) throws Exception {
        // 从上下文中获取reqeust
        ServletRequestAttributes servletRequestAttributes =
                (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
        // HttpServletRequest request = getRequest();
        HttpServletRequest request = servletRequestAttributes.getRequest();
        handleLog(joinPoint, e, null, System.currentTimeMillis(), request);
    }

    protected void handleLog(final JoinPoint joinPoint, final Exception e, Response jsonResult, Long nowTime, HttpServletRequest request) throws Exception {
        Log controllerLog = getAnnotationLog(joinPoint);
        ProceedingJoinPoint point = (ProceedingJoinPoint)joinPoint;
        if (controllerLog == null) {
            return;
        }
        // 数据库日志
        SysLog sysLog = new SysLog();
        // 接口地址
        String requestUrl = request.getRequestURL().toString();
        // 请求的IP地址
        String ip = HttpUtil.getIpAddr(request);
        sysLog.setIp(ip);
        // 获取操作内容
        String content = controllerLog.menu();

        // 获取请求参数
        String requestData = "";
        if(controllerLog.isData()){
            requestData = getRequestParams(point,request);
        }
        if (jsonResult == null) {
            content = content + "--出现服务异常!";
        }
        if (jsonResult != null && !jsonResult.getSuccess()) {
            content = content + "--执行失败!";
        }
        sysLog.setContent(content)
            .setType(content)
            .setCreateTime(new Date())
            .setRequestUrl(requestUrl)
            .setRequestData(requestData);
        // 保存数据库
        sysLogService.save(sysLog);
    }

    /**
     * 是否存在注解，如果存在就获取
     */
    private Log getAnnotationLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        if (method != null) {
            return method.getAnnotation(Log.class);
        }
        return null;
    }

    private HttpServletRequest getRequest() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        return attributes.getRequest();
    }

    /**
     * 获取请求参数 json格式返回
     * @param request
     * @return
     */
    private String getParameterName(HttpServletRequest request){
        // 增加查询日志  获取所有查询的参数名称和值 json格式存储
        Map map = new HashMap();
        Enumeration paramNames = request.getParameterNames();
        while (paramNames.hasMoreElements()) {
            String paramName = (String) paramNames.nextElement();
            String[] paramValues = request.getParameterValues(paramName);
            if (paramValues.length == 1) {
                String paramValue = paramValues[0];
                if (paramValue.length() != 0) {
                    map.put(paramName, paramValue);
                }
            }
        }
        return JSON.toJSONString(map);
    }

    /**
     * 获取请求参数
     * @param request
     * @return
     */
    public String getRequestParams(ProceedingJoinPoint point, HttpServletRequest request) {
        MethodSignature methodSignature = (MethodSignature)point.getSignature();
        Method method = methodSignature.getMethod();
        String queryString = null;
        String requestMethod = request.getMethod();
        if (requestMethod.equals(Request.HttpMethod.POST.name())) {
            //参数值
            Object[] args = ArrayUtils.toArray(point.getArgs());
            queryString = JSON.toJSONString(args[0], SerializerFeature.WriteMapNullValue);
        }
        else {
            // 增加查询日志  获取所有查询的参数名称和值 json格式存储
            Map map = new HashMap();
            Enumeration paramNames = request.getParameterNames();
            while (paramNames.hasMoreElements()) {
                String paramName = (String) paramNames.nextElement();
                String[] paramValues = request.getParameterValues(paramName);
                if (paramValues.length == 1) {
                    String paramValue = paramValues[0];
                    if (paramValue.length() != 0) {
                        map.put(paramName, paramValue);
                    }
                }
            }
            queryString = JSON.toJSONString(map);
        }
        return queryString;
    }

}

5、SysLog实体类

package com.shucha.deveiface.biz.model;

import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.sdy.common.model.BaseModel;
import com.sdy.common.utils.DateUtil;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.util.Date;

/**
 * <p>
 * 用户操作日志
 * </p>
 *
 * @author tqf
 * @since 2022-08-08 15:25
 */
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
public class SysLog extends BaseModel {
    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @ApiModelProperty(value = "主键")
    @TableId
    private Long id;

    /**
     * 操作用户id
     */
    @ApiModelProperty(value = "操作用户id")
    private Long userId;

    @ApiModelProperty(value = "请求参数")
    private String requestData;

    @ApiModelProperty(value = "请求接口地址")
    private String requestUrl;

    /**
     * IP地址
     */
    @ApiModelProperty(value = "IP地址")
    private String ip;

    /**
     * 操作内容
     */
    @ApiModelProperty(value = "操作内容")
    private String content;

    /**
     * 操作类型
     */
    @ApiModelProperty(value = "操作类型")
    private String type;

    /**
     * 创建时间
     */
    @ApiModelProperty(value = "创建时间")
    @JsonFormat(pattern = DateUtil.DATETIME_FORMAT)
    private Date createTime;

}

创建表和插入数据

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for sys_log
-- ----------------------------
DROP TABLE IF EXISTS `sys_log`;
CREATE TABLE `sys_log`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_id` int(11) NULL DEFAULT NULL COMMENT '操作用户id',
  `ip` varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT 'IP地址',
  `content` varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '操作内容',
  `request_url` varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '请求接口地址',
  `request_data` longtext CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL COMMENT '请求参数',
  `type` varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '操作类型\r\n0：登陆\r\n1：新增用户\r\n2：开户\r\n3：用户基本信息编辑\r\n4：用户资源编辑\r\n5：新增角色\r\n6编辑角色\r\n7:角色权限编辑\r\n8：角色关联用户编辑\r\n9：新增菜单\r\n10：菜单编辑\r\n11：日志查询',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `idx_user_id`(`user_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_unicode_ci COMMENT = '操作日志信息' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_log
-- ----------------------------
INSERT INTO `sys_log` VALUES (1, NULL, '192.168.0.111', '查询数据', 'http://192.168.0.111:50041/test/getData', '{}', '查询数据', '2022-08-08 17:21:51');
INSERT INTO `sys_log` VALUES (2, NULL, '192.168.0.111', '新增数据发发发', NULL, NULL, NULL, NULL);
INSERT INTO `sys_log` VALUES (3, NULL, '192.168.0.111', '新增数据', 'http://192.168.0.111:50041/test/saveData', '{\"content\":\"新增数据发发发\",\"createTime\":null,\"id\":2,\"ip\":\"192.168.0.111\",\"requestData\":null,\"requestUrl\":null,\"type\":null,\"userId\":null}', '新增数据', '2022-08-08 17:22:12');

SET FOREIGN_KEY_CHECKS = 1;

6、服务类和服务实现类

package com.shucha.deveiface.biz.service;

import com.sdy.mvc.service.BaseService;
import com.shucha.deveiface.biz.model.SysLog;

/**
 * <p>
 * 用户操作日志 服务类
 * </p>
 *
 * @author cgj
 * @since 2021-07-13
 */
public interface SysLogService extends BaseService<SysLog> {

}

package com.shucha.deveiface.biz.service.impl;

import com.sdy.mvc.service.impl.BaseServiceImpl;
import com.shucha.deveiface.biz.mapper.SysLogMapper;
import com.shucha.deveiface.biz.model.SysLog;
import com.shucha.deveiface.biz.service.SysLogService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * <p>
 * 用户操作日志 服务实现类
 * </p>
 *
 * @author cgj
 * @since 2021-07-13
 */
@Slf4j
@Service
public class SysLogServiceImpl extends BaseServiceImpl<SysLog> implements SysLogService {
    @Autowired
    private SysLogMapper sysLogMapper;
}

7、实际调用

package com.shucha.deveiface.web.controller;

import com.sdy.common.model.Response;
import com.shucha.deveiface.biz.aspect.Log;
import com.shucha.deveiface.biz.model.SysLog;
import com.shucha.deveiface.biz.service.SysLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author tqf
 * @Description
 * @Version 1.0
 * @since 2022-08-08 15:23
 */
@RestController
@RequestMapping("/test")
public class TestController {

    @Autowired
    private SysLogService logService;

    @Log(menu = "查询数据")
    @GetMapping("/getData")
    public Response test(){
        return Response.success("请求成功");
    }

    @Log(menu = "新增数据")
    @PostMapping("/saveData")
    public Response saveData(@RequestBody SysLog sysLog){
        logService.save(sysLog);
        return Response.success();
    }
}
码奴生来只知道前进~
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Boot - aop 切面对请求进行日志记录
学无止境
06-14 423
** * < p > * 测试 Controller * < / p > * / @Slf4j @RestController public class TestController {/ ** * 测试方法 http : // localhost : 8080 / test * * @param who 测试参数 * @ return {
springboot利用线程池异步记录日志（二）
缔曦的博客
09-01 848
缘由 在业务逻辑中记录日志，繁琐且耦合度高，利用aop结合注解形式，更便捷 步骤 1.自定义【日志记录】注释 2.自定义日志记录实体类 3.利用aop，拦截被注释的方法，整理日志数据，插入数据库 ps：原理很简单，跟着代码读一遍就ok了 /** * 自定义日志记录注释 * / @Target({ ElementType.PARAMETER, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) @Documented public @inter
springboot使用LogAspect的切面日志
yanwendonge的博客
04-26 2567
1.首先定义个切面标签源 public enum Source { main("10", "微信"), platform("20", "支付宝"), driverApp("25", "app"), shipperApplet("70", "小程序"), private String code; private String name; pri...
使用AOP切面实现日志记录功能
最新发布
心态的博客
10-26 3438
说到AOP大家都可以想到他是面向切面的编程，它通过将横切关注点（例如日志记录、事务管理、权限控制等）从主要业务逻辑中分离出来，以模块化的方式进行管理。在AOP中，通过定义切面（Aspect）来捕获和处理横切关注点，然后将其应用于特定的目标对象或方法。官方的解释有点抽象，我们举个例子说明：假设我们需要在多个方法中添加日志记录功能。传统的方式是在每个方法中都添加日志代码，但这样会导致代码重复，并且当我们需要修改日志记录逻辑时，需要逐个修改所有方法。
logAspect
qianhuan_的博客
07-14 356
package oa.aop; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import oa.log.biz.RecordBiz; import oa.log.po.Record; import oa.system.ctrl.LoginCtrl; import oa.utils.JacksonJson; import org..
用AOP统一记录日志（详细笔记入门）
加辣椒了吗?的博客
04-28 889
文章目录笔记：用AOP统一记录日志（小白入门）一、引入架包打开pom.xml文件，引入aspectj架包代码如下：二、编写配置类新建配置类LogAspect .java，代码如下三、运行成功总结 笔记：用AOP统一记录日志（小白入门） 就三步 一、引入架包 打开pom.xml文件，引入aspectj架包 代码如下： <dependency> <groupId>org.aspectj</groupId> <artifactId>aspect
SpringBoot日志处理之Logback
空夜's Blog
12-09 2217
日志处理是一个正式项目必备的功能，日志要能够根据时间、类型等要素，根据指定格式来保存指定的日志，方便我们观察程序运行情况、定位程序bug。 SpringBoot中推荐使用Logback日志框架。 本节示例项目在https://github.com/laolunsi/spring-boot-examples slf4j：一个针对各类Java日志框架的统一facade抽象。 java常见日志框架...
SpringBoot：使用Logback打点日志
q736317048的博客
01-28 441
1.日志不仅用于排查问题，查看应用运行情况 2.更可以用于统计，虽然统计可以通过数据库进行统计，但存在风险，如果用日志，并且建议一个日志系统用于分析 为了日后产品大数据分析以及运营人员分析数据 3.写日志，可以加缓存buffer，也可以进行异步 下面这段xml文件放在resources目录下 <?xml version="1.0" encoding="UTF-8" ?> <configuration> <!--日志布局 时间格式 日记级别 方法 线程-->
springboot配置aop切面日志打印过程解析
08-25
Spring Boot 配置 AOP 切面日志打印过程解析 本文主要介绍了 Spring Boot 配置 AOP 切面日志打印过程解析，...通过本文，读者可以了解 AOP 的基本概念和应用场景，并学会使用 Spring Boot 配置 AOP 切面日志打印功能。
解决springboot的aop切面不起作用问题(失效的排查)
08-19
SpringBoot中的AOP（Aspect-Oriented Programming）切面是指在业务逻辑中添加的额外功能，以实现日志记录、安全检查、事务管理等功能。但是，在实际开发中，我们可能会遇到AOP切面不起作用的问题。下面我们将介绍...
springboot切面添加日志功能实例详解
08-25
本文将深入讲解如何利用Spring AOP（面向切面编程）来实现自定义的日志功能。 首先，我们需要创建一个新的Spring Boot项目。通过Spring Initializr或手动配置pom.xml文件，引入所需的依赖，确保Spring Web和Spring ...
SpringBoot整合aop面向切面编程过程解析
08-24
SpringBoot整合AOP面向切面编程过程解析 AOP（Aspect Oriented Programming），即面向切面编程，是一种编程技术，通过预编译方式和运行期动态代理实现程序功能的统一维护。AOP是Spring框架中的一个重要内容，它通过...
springboot如何使用AOP做访问请求日志
08-25
2. 切面类配置：创建一个 LogAspect 类，使用 @Component 和 @Aspect 注解来标识该类是一个切面类。 ```java @Component @Aspect public class LogAspect { // ... } ``` 3. 切入点表达式：在 LogAspect 类中，...
自定义Log切面日志
weixin_44991038的博客
12-30 684
springBoot自定义log切面日志工具、自定义注解、
利用AOP做一个完善的日志LogAspect切入以SpringBoot为框架基础
牧风人的博客
11-13 1069
利用AOP做一个完善的日志LogAspect切入以SpringBoot为框架基础 日常的记录日志，不会还有人还在每个方法都重复书写log.info log....，还有些更初级的sout 哈哈哈，我们要学会用Spring中的利器，那就是AOP思想，替我们把这些重复的工作做了。AOP思想其实我们接触得很多了，像日志记录，权限控制，事务管理啊，基本都用过，里面运用的核心就是AOP。具体AOP详细的介绍和使用我这里就不赘述了，网上有很多资料。 今天我想学做个比较细致些的日志记录方式 以SpringBo.
logaspcet（日志切面）打印传入参数和对应值
zhoupan2008的专栏
11-14 408
【代码】logaspcet（日志切面）打印传入参数和对应值。
Spring AOP面向切面详解，记录操作日志
一只程序猿
03-07 1946
最近又用到AOP记录操作日志，虽然很多年以前就已经用过了。但是那时候多数是百度的来的，并没有去深入研究。说白了，只是实现了功能，可能睡一觉又忘了。 AOP（Aspect-OrientedProgramming)面向切面，切开封装的对象内部，并将那些影响了多个类并且与具体业务无关的公共行为封装成一个独立的模块（称为切面）。更重要的是它又能巧妙将这些切面复原，不留痕迹的融入核心业务逻辑中。这样，...
【SpringBoot应用篇】【AOP+注解】SpringBoot使用Aspect AOP注解实现日志管理（增强版）
输入技术、输出想法
12-28 1397
需求: 需要保存的日志内容在方法的参数中，并且方法参数的类型对象不一样，且对象的属性名称不一样。解决思路:1、添加类型转换器Convert接口,需要转换的类型继承Convert接口2、@Log注解中添加Convert接口类型的Class属性3、在切面环绕通知中进行处理。
Java验证时间格式是否正确方法类
热门推荐
tanqingfu1的博客
09-16 2万+
在很多场景中我们需要验证时间日期的是否属于正确的格式，验证时间是否符合常规的。 1、验证 yyyy-MM-dd HH:mm:dd 格式的日期 String date = "2020-01-25 12:36:45"; System.out.println("date "+isLegalDate(date.length(),date,"yyyy-MM-dd HH:mm:ss")); 2、验证 yyyy-MM-dd 格式的日期 String yearMonthday = "2020-01-0..
springboot LogAspect
08-16
Spring Boot中的LogAspect是一个切面（Aspect），用于在应用中处理日志记录的方面。它基于Spring AOP（面向切面编程）框架，通过定义切点和通知来实现日志记录功能。 在Spring Boot中使用LogAspect，需要按照以下步骤进行操作： 1. 创建一个切面类，可以命名为LogAspect或者其他合适的名称。 2. 在切面类中使用@Aspect注解进行标记，表示该类是一个切面。 3. 定义一个切点，用于确定日志记录的位置。可以使用@Pointcut注解指定切点表达式，例如execution(* com.example.*.*(..))。 4. 编写通知方法，用于在切点位置执行特定的逻辑。通常使用@Before、@After、@AfterReturning或@AfterThrowing等注解来标记通知方法。 5. 在通知方法中使用日志框架（如log4j、logback或者slf4j）来记录日志信息。 通过以上步骤，我们可以在应用中实现针对特定方法或类的日志记录功能。例如，在@Before通知方法中，我们可以使用日志框架输出方法执行前的日志信息；在@AfterReturning通知方法中，我们可以记录方法执行后的返回值等。 需要注意的是，要使用LogAspect，我们还需要在Spring Boot应用中引入相应的依赖（如spring-boot-starter-aop），并且确保AOP功能已经启用。 这就是关于Spring Boot中LogAspect的基本介绍。如果你有更具体的问题，可以继续提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码奴生来只知道前进~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值