AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring Boot + vue-element 开发个人博客项目实战教程（十八、操作日志功能实现）1

2023-07-18 157
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： Spring Boot + vue-element 开发个人博客项目实战教程（十八、操作日志功能实现）1

⭐ 作者简介：码上言



⭐ 代表教程：Spring Boot + vue-element 开发个人博客项目实战教程



⭐专栏内容：零基础学Java、个人博客系统

项目部署视频

https://www.bilibili.com/video/BV1sg4y1A7Kv/?vd_source=dc7bf298d3c608d281c16239b3f5167b

文章目录

一、前言

我们后端的功能差不多写的可以了，我看了下还差了个操作日志和登录日志，我们今天就将这个实现一下，然后后端就基本上完成了，再完成前端的页面我们的项目就完成了，可能大家注意到了我把项目的标题都改了，没有了移动端，我考虑到现在我们就先做前后台功能，后期我们再进行用户端的开发，等我更新完基础的知识。

二、操作日志开发

我们开始开发操作日志功能，首先我们要思考，我们操作日志是干嘛的？怎么能获取到操作日志？我们怎么知道谁操作的什么功能？接下来我们一点点的开发。由于时间比较长了 ，一开始建立的数据有点改变，大家把下面的sql重新再Navicat里的查询里再运行一遍，更新下操作日志的数据。

DROP TABLE IF EXISTS `person_operation_log`;
CREATE TABLE `person_operation_log` (
  `id`                    INT             NOT NULL PRIMARY KEY AUTO_INCREMENT     COMMENT '主键',
  `operation_ip`          VARCHAR(128)        NULL DEFAULT 0                      COMMENT '主机地址',
  `opera_location`        VARCHAR(255)        NULL DEFAULT ''                     COMMENT '操作地点',
  `methods`               TEXT                NULL                                COMMENT '方法名',
  `args`                TEXT                NULL                                COMMENT '请求参数',
  `operation_name`        VARCHAR(50)     NOT NULL DEFAULT ''                     COMMENT '操作人',
  `operation_type`      VARCHAR(50)     NOT NULL DEFAULT ''                     COMMENT '操作类型',
  `return_value`        TEXT                NULL                                COMMENT '返回参数',
  `create_time`           DATETIME            NULL DEFAULT CURRENT_TIMESTAMP      COMMENT '创建时间'
) ENGINE = InnoDB
  CHARACTER SET = utf8mb4
  COLLATE = utf8mb4_bin
  ROW_FORMAT = Dynamic
  COMMENT '操作日志表';

更新完表之后，我们接下来写操作日志的添加功能，这儿大家看到这里可以停止往下看了，自己去写一下操作日志的添加，我们写了那么多次了，要自己尝试，我们教程都快结束了再不会写就说不过去了。

1、新建实体类

在entity包中新建一个OperationLog.java类

package com.blog.personalblog.entity;
import lombok.Data;
import java.time.LocalDateTime;
/**
 * @author: SuperMan
 * @create: 2022-04-02
 **/
@Data
public class OperationLog {
    /**
     * 主键id
     */
    private Integer id;
    /**
     * ip地址
     */
    private String operationIp;
    /**
     * ip来源
     */
    private String operaLocation;
    /**
     * 操作方法名
     */
    private String methods;
    /**
     * 请求参数
     */
    private String args;
    /**
     * 操作人
     */
    private String operationName;
    /**
     * 操作类型
     */
    private String operationType;
    /**
     * 返回结果
     */
    private String returnValue;
    /**
     * 创建时间
     */
    private LocalDateTime createTime;
}

2、新建OperationLogService.java

新建一个业务类接口，然后写一个添加和查询的接口，操作日志只能展示，不能删除和修改。

package com.blog.personalblog.service;
import com.blog.personalblog.config.page.PageRequest;
import com.blog.personalblog.entity.OperationLog;
import java.util.List;
/**
 * @author: SuperMan
 * @create: 2022-04-02
 **/
public interface OperationLogService {
    /**
     * 保存操作日志
     *
     * @param operationLog
     * @return
     */
    void saveOperationLog(OperationLog operationLog);
    /**
     * 操作日志列表（分页）
     *
     * @param pageRequest
     * @return
     */
    List<OperationLog> getOperationLogPage(PageRequest pageRequest);
}

3、新建OperationLogServiceImpl.java

新建一个业务的实现类，实现那两个接口。

package com.blog.personalblog.service.Impl;
import com.blog.personalblog.config.page.PageRequest;
import com.blog.personalblog.entity.OperationLog;
import com.blog.personalblog.mapper.OperationLogMapper;
import com.blog.personalblog.service.OperationLogService;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
/**
 * @author: SuperMan
 * @create: 2022-04-02
 **/
@Service
public class OperationLogServiceImpl implements OperationLogService {
    @Resource
    OperationLogMapper operationLogMapper;
    @Override
    public void saveOperationLog(OperationLog operationLog) {
        operationLogMapper.createOperationLog(operationLog);
    }
    @Override
    public List<OperationLog> getOperationLogPage(PageRequest pageRequest) {
        int pageNum = pageRequest.getPageNum();
        int pageSize = pageRequest.getPageSize();
        PageHelper.startPage(pageNum,pageSize);
        List<OperationLog> operationLogList = operationLogMapper.getOperationLogPage();
        return operationLogList;
    }
}

然后我们写dao层的接口。

4、新建OperationLogMapper.java

这个也不用多说了，新写两个添加和查找的接口。

package com.blog.personalblog.mapper;
import com.blog.personalblog.entity.OperationLog;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
 * @author: SuperMan
 * @create: 2022-04-02
 **/
@Repository
public interface OperationLogMapper {
    /**
     * 创建操作日志
     * @param operationLog
     * @return
     */
    int createOperationLog(OperationLog operationLog);
    /**
     * 分类列表（分页）
     * @return
     */
    List<OperationLog> getOperationLogPage();
}

5、新建OperationLogMapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.blog.personalblog.mapper.OperationLogMapper">
    <resultMap id="BaseResultMap" type="com.blog.personalblog.entity.OperationLog">
        <result column="id" jdbcType="INTEGER" property="id"/>
        <result column="operation_ip" jdbcType="VARCHAR" property="operationIp"/>
        <result column="opera_location" jdbcType="VARCHAR" property="operaLocation"/>
        <result column="methods" jdbcType="VARCHAR" property="methods"/>
        <result column="args" jdbcType="VARCHAR" property="args"/>
        <result column="operation_name" jdbcType="VARCHAR" property="operationName"/>
        <result column="operation_type" jdbcType="VARCHAR" property="operationType"/>
        <result column="return_value" jdbcType="VARCHAR" property="returnValue"/>
        <result column="create_time" jdbcType="VARCHAR" property="createTime"/>
    </resultMap>
    <insert id="createOperationLog" parameterType="com.blog.personalblog.entity.OperationLog" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO person_operation_log (operation_ip, opera_location, methods, args, operation_name, operation_type, return_value)
        VALUES(#{operationIp}, #{operaLocation}, #{methods}, #{args}, #{operationName}, #{operationType}, #{returnValue})
    </insert>
    <select id="getOperationLogPage" resultMap="BaseResultMap">
        select * from person_operation_log
    </select>
</mapper>

上边写了那么多，基本上把操作日志的功能写完了，我们现在有了存储操作日志的数据了，也能查出来了，现在是要考虑如何把操作日志的数据获取。

接下来我们要放大招，手写注解，以前都是我们使用别人的注解，现在我们要自己写注解。

三、开发注解

我们使用AOP切面的方式来实现日志记录功能。但是什么是AOP呢？在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方

式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个

热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑

的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高

了开发的效率。


我们先看一下AOP包含的概念


1.Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

2.Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。

3.Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。

4.Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

5.Target（目标对象）：织入 Advice 的目标对象.。

6.Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

1、OperationType.java

接下来我们要编写注解了，首先创建一个annotation包和handler包，主要放AOP切点类和自定义注解类，我们在annotation包中先创建一个OperationType.java枚举类。这个类主要是放注解使用的枚举类型。

package com.blog.personalblog.annotation;
import lombok.Getter;
/**
 * 操作类型
 *
 * @author: SuperMan
 * @create: 2022-04-02
 **/
@Getter
public enum OperationType {
    /**
     * 默认系统
     */
    SYSTEM("SYSTEM"),
    /**
     * 登录
     */
    LOGIN("LOGIN"),
    /**
     * 添加
     */
    INSERT("INSERT"),
    /**
     * 删除
     */
    DELETE("DELETE"),
    /**
     * 查询
     */
    SELECT("SELECT"),
    /**
     * 更新
     */
    UPDATE("UPDATE");
    private String value;
    OperationType(String s) {
        this.value = s;
    }
}

2、OperationLogSys.java

接下来我们自定义注解，OperationLogSys这个就是我们定义的注解名@OperationLogSys，然后下面两个接口就是我们使用注解后边带的参数，接下来我们再讲解一下。

package com.blog.personalblog.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 操作日志注解
 *
 * @author: SuperMan
 * @create: 2022-04-02
 **/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface OperationLogSys {
    /**
     * 日志描述
     */
    String desc() default "";
    /**
     * 日志操作类型
     */
    OperationType operationType() default OperationType.SYSTEM;
}

@Target

作用：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）

取值(ElementType)有：

a. CONSTRUCTOR：用于描述构造器

b. FIELD：用于描述域

c. LOCAL_VARIABLE：用于描述局部变量

d. METHOD：用于描述方法

e. PACKAGE：用于描述包

f. PARAMETER：用于描述参数

g. TYPE：用于描述类、接口(包括注解类型) 或enum声明。

@Retention

作用是定义被它所注解的注解保留多久，一共有三种策略：

a. source：注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃；被编译器忽略。

b. class：注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期。

c. runtime：注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在。


首先要明确生命周期长度 SOURCE < CLASS < RUNTIME ，所以前者能作用的地方后者一定也能作用。一般如果需要在运行时去动态获取注解信息，那只能用 RUNTIME 注解；如果要在编译时进行一些预处理操作，比如生成一些辅助代码（如 ButterKnife），就用 CLASS注解；如果只是做一些检查性的操作，比如 @Override 和 @SuppressWarnings，则可选用 SOURCE 注解。

  • @Documented
    用来标注生成javadoc的时候是否会被记录。

3、OptLogAspect.java

接下来是我们最主要的类，可以使用自定义注解或针对包名实现AOP增强。

在handler包中新建OptLogAspect.java
1、Pointcut(切入点)： JoinPoint的集合，是程序中需要注入Advice的位置的集合，指明Advice要在什么样的条件下才能被触发，在程序中主要体现为书写切入点表达式。

    /**
     * 日志 切面 自定义注解  切到任意方法
     */
    @Pointcut("@annotation(com.blog.personalblog.annotation.OperationLogSys)")
    public void optLog() {
    }

2、标识一个前置增强方法，相当于BeforeAdvice的功能。

 @Before("optLog()")
 public void doBefore(JoinPoint joinPoint) {
     log.info("进入方法前执行...");
 }

3、接下来我们就开始获取到注解的操作数据。具体的下面代码都有注释，这里我只说JoinPoint类和@AfterReturning注解。
JoinPoint常用的方法：

  • Object[] getArgs：返回目标方法的参数
  • Signature getSignature：返回目标方法的签名
  • Object getTarget：返回被织入增强处理的目标对象
  • Object getThis：返回AOP框架为目标对象生成的代理对象

    @AfterReturning    注解可指定如下两个常用属性：
  • pointcut/value:这两个属性的作用是一样的，它们都属于指定切入点对应的切入表达式。一样既可以是已有的切入点，也可直接定义切入点表达式。当指定了pointcut属性值后，value属性值将会被覆盖。
  • returning:该属性指定一个形参名，用于表示Advice方法中可定义与此同名的形参，该形参可用于访问目标方法的返回值。除此之外，在Advice方法中定义该形参（代表目标方法的返回值）时指定的类型，会限制目标方法必须返回指定类型的值或没有返回值。
    @Async
    @Transactional(rollbackFor = Exception.class)
    @AfterReturning(value = "optLog()", returning = "result")
    public void doAfterReturning(JoinPoint joinPoint, Object result) throws Throwable {
        // 获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) Objects.requireNonNull(requestAttributes).resolveReference(RequestAttributes.REFERENCE_REQUEST);
        // 从切面织入点处通过反射机制获取织入点处的方法
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        OperationLogSys annotation = signature.getMethod().getAnnotation(OperationLogSys.class);
        // 获取切入点所在的方法
        Method method = signature.getMethod();
        OperationLog operationLog = new OperationLog();
        if (annotation != null) {
            //操作类型
            String operationType = annotation.operationType().getValue();
            operationLog.setOperationType(operationType);
            //IP地址
            String ipAddr = IpUtil.getIpAddr(request);
            operationLog.setOperationIp(ipAddr);
            //IP来源
            operationLog.setOperaLocation(IpUtil.getIpInfo(ipAddr));
            //操作人
            String userName = request.getRemoteUser();
            operationLog.setOperationName(userName);
            //操作方法名
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = method.getName();
            methodName = className + "." + methodName;
            operationLog.setMethods(methodName);
            //参数
            operationLog.setArgs(JSON.toJSONString(joinPoint.getArgs()));
            //返回结果
            operationLog.setReturnValue(JSON.toJSONString(result));
            operationLogService.saveOperationLog(operationLog);
        }
    }

补充一个IpUtil工具类：

package com.blog.personalblog.util;
import com.alibaba.fastjson.JSON;
import com.github.pagehelper.util.StringUtil;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.URL;
import java.net.UnknownHostException;
import java.util.List;
import java.util.Map;
/**
 * 获取ip工具
 *
 * @author: SuperMan
 * @create: 2022-01-26
 **/
public class IpUtil {
    /**
     * 获取ip地址
     * @param request
     * @return
     */
    public static String getIpAddr(HttpServletRequest request) {
        if (request == null) {
            return "";
        }
        //String ip = request.getHeader("x-forwarded-for");
        Subject subject = SecurityUtils.getSubject();
        String ip = subject.getSession().getHost();
        if (StringUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Forwarded-For");
        }
        if (StringUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (StringUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (StringUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (StringUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (StringUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        if (StringUtil.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
            if ("127.0.0.1".equals(ip)) {
                InetAddress inet = null;
                try {
                    inet = InetAddress.getLocalHost();
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                }
                ip = inet.getHostAddress();
            }
        }
        if (ip != null && ip.length() > 15) {
            if (ip.indexOf(",") > 0) {
                ip = ip.substring(0, ip.indexOf(","));
            }
        }
        return ip;
    }
    /**
     * 通过IP获取地址
     *
     * @param ip
     * @return
     */
    public static String getIpInfo(String ip) {
        if ("127.0.0.1".equals(ip)) {
            ip = "127.0.0.1";
        }
        String info = null;
        try {
            URL url = new URL("http://opendata.baidu.com/api.php?query=" + ip + "&co=&resource_id=6006&oe=utf8");
            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openConnection().getInputStream(), "utf-8"));
            StringBuffer result = new StringBuffer();
            while ((info = reader.readLine()) != null) {
                result.append(info);
            }
            reader.close();
            Map map = JSON.parseObject(result.toString(), Map.class);
            List<Map<String, String>> data = (List) map.get("data");
            return data.get(0).get("location");
        } catch (Exception e) {
            return "";
        }
    }
}

以下是全部的代码：

package com.blog.personalblog.handler;
import com.alibaba.fastjson.JSON;
import com.blog.personalblog.annotation.OperationLogSys;
import com.blog.personalblog.entity.OperationLog;
import com.blog.personalblog.service.OperationLogService;
import com.blog.personalblog.util.IpUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
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.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Objects;
/**
 * 操作日志切面
 *
 * @author: SuperMan
 * @create: 2022-04-02
 **/
@Slf4j
@Aspect
@Component
public class OptLogAspect {
    @Resource
    private OperationLogService operationLogService;
    /**
     * 日志 切面 自定义注解  切到任意方法
     */
    @Pointcut("@annotation(com.blog.personalblog.annotation.OperationLogSys)")
    public void optLog() {
    }
    @Before("optLog()")
    public void doBefore(JoinPoint joinPoint) {
        log.info("进入方法前执行...");
    }
    @Async
    @Transactional(rollbackFor = Exception.class)
    @AfterReturning(value = "optLog()", returning = "result")
    public void doAfterReturning(JoinPoint joinPoint, Object result) throws Throwable {
        // 获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) Objects.requireNonNull(requestAttributes).resolveReference(RequestAttributes.REFERENCE_REQUEST);
        // 从切面织入点处通过反射机制获取织入点处的方法
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        OperationLogSys annotation = signature.getMethod().getAnnotation(OperationLogSys.class);
        // 获取切入点所在的方法
        Method method = signature.getMethod();
        OperationLog operationLog = new OperationLog();
        if (annotation != null) {
            //操作类型
            String operationType = annotation.operationType().getValue();
            operationLog.setOperationType(operationType);
            //IP地址
            String ipAddr = IpUtil.getIpAddr(request);
            operationLog.setOperationIp(ipAddr);
            //IP来源
            operationLog.setOperaLocation(IpUtil.getIpInfo(ipAddr));
            //操作人
            String userName = request.getRemoteUser();
            operationLog.setOperationName(userName);
            //操作方法名
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = method.getName();
            methodName = className + "." + methodName;
            operationLog.setMethods(methodName);
            //参数
            operationLog.setArgs(JSON.toJSONString(joinPoint.getArgs()));
            //返回结果
            operationLog.setReturnValue(JSON.toJSONString(result));
            operationLogService.saveOperationLog(operationLog);
        }
    }
}
文章标签：
日志服务
Java
前端开发
SQL
Spring
Maven
数据格式
存储
XML
编译器
关键词：
Spring Boot功能
Spring功能
Spring开发
开发日志服务
Spring boot vue
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
码上言
目录
相关文章
喜欢猪猪
|
4天前
|
消息中间件 缓存 Java
手写模拟Spring Boot启动过程功能
【11月更文挑战第19天】Spring Boot自推出以来，因其简化了Spring应用的初始搭建和开发过程，迅速成为Java企业级应用开发的首选框架之一。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理，并通过Java代码手写模拟Spring Boot的启动过程，帮助读者深入理解其工作机制。
喜欢猪猪
21 3
喜欢猪猪
|
4天前
|
Java 开发者 微服务
手写模拟Spring Boot自动配置功能
【11月更文挑战第19天】随着微服务架构的兴起，Spring Boot作为一种快速开发框架，因其简化了Spring应用的初始搭建和开发过程，受到了广大开发者的青睐。自动配置作为Spring Boot的核心特性之一，大大减少了手动配置的工作量，提高了开发效率。
喜欢猪猪
19 0
众所周知
|
17天前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用。
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用。首先，创建并配置 Spring Boot 项目，实现后端 API；然后，使用 Ant Design Pro Vue 创建前端项目，配置动态路由和菜单。通过具体案例，展示了如何快速搭建高效、易维护的项目框架。
众所周知
95 62
lqj_本人
|
9天前
|
监控 开发者
鸿蒙5.0版开发：使用HiLog打印日志（ArkTS）
在HarmonyOS 5.0中，HiLog是系统提供的日志系统，支持DEBUG、INFO、WARN、ERROR、FATAL五种日志级别。本文介绍如何在ArkTS中使用HiLog打印日志，并提供示例代码。通过合理使用HiLog，开发者可以更好地调试和监控应用。
lqj_本人
47 16
刘大猫.
|
14天前
|
前端开发 Java easyexcel
SpringBoot操作Excel实现单文件上传、多文件上传、下载、读取内容等功能
SpringBoot操作Excel实现单文件上传、多文件上传、下载、读取内容等功能
刘大猫.
54 8
东方睿赢
|
15天前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个前后端分离的应用框架，实现动态路由和菜单功能
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个前后端分离的应用框架，实现动态路由和菜单功能。首先，确保开发环境已安装必要的工具，然后创建并配置 Spring Boot 项目，包括添加依赖和配置 Spring Security。接着，创建后端 API 和前端项目，配置动态路由和菜单。最后，运行项目并分享实践心得，帮助开发者提高开发效率和应用的可维护性。
东方睿赢
34 2
刘大猫.
|
19天前
|
JSON Java API
springboot集成ElasticSearch使用completion实现补全功能
springboot集成ElasticSearch使用completion实现补全功能
刘大猫.
23 1
程序员皮皮林
|
23天前
|
存储 Java 数据管理
强大！用 @Audited 注解增强 Spring Boot 应用，打造健壮的数据审计功能
本文深入介绍了如何在Spring Boot应用中使用`@Audited`注解和`spring-data-envers`实现数据审计功能，涵盖从添加依赖、配置实体类到查询审计数据的具体步骤，助力开发人员构建更加透明、合规的应用系统。
程序员皮皮林
59 0
蓝染-惣右介
|
11天前
|
XML 安全 Java
【日志框架整合】Slf4j、Log4j、Log4j2、Logback配置模板
本文介绍了Java日志框架的基本概念和使用方法，重点讨论了SLF4J、Log4j、Logback和Log4j2之间的关系及其性能对比。SLF4J作为一个日志抽象层，允许开发者使用统一的日志接口，而Log4j、Logback和Log4j2则是具体的日志实现框架。Log4j2在性能上优于Logback，推荐在新项目中使用。文章还详细说明了如何在Spring Boot项目中配置Log4j2和Logback，以及如何使用Lombok简化日志记录。最后，提供了一些日志配置的最佳实践，包括滚动日志、统一日志格式和提高日志性能的方法。
蓝染-惣右介
116 30
【日志框架整合】Slf4j、Log4j、Log4j2、Logback配置模板
最好zzz
|
1月前
|
XML JSON Java
Logback 与 log4j2 性能对比：谁才是日志框架的性能王者？
【10月更文挑战第5天】在Java开发中，日志框架是不可或缺的工具，它们帮助我们记录系统运行时的信息、警告和错误，对于开发人员来说至关重要。在众多日志框架中，Logback和log4j2以其卓越的性能和丰富的功能脱颖而出，成为开发者们的首选。本文将深入探讨Logback与log4j2在性能方面的对比，通过详细的分析和实例，帮助大家理解两者之间的性能差异，以便在实际项目中做出更明智的选择。
最好zzz
216 3

热门文章

最新文章

  • 1
    SQLServer数据库日志清理 清除sqlserver2005日志 - sk
  • 2
    MapReduce对交易日志进行排序的Demo(MR的二次排序)
  • 3
    Windows登录类型及安全日志解析
  • 4
    rman RMAN-06059: expected archived log not found
  • 5
    Enterprise Library 2.0 Hands On Lab 翻译（4）：日志应用程序块（一）
  • 6
    python 合并当天tomcat异常日志
  • 7
    最详细的Log4j使用教程
  • 8
    innodb重做日志缓冲
  • 9
    MySQL的innodb_flush_log_at_trx_commit配置值的设定
  • 10
    让log4j的DailyRollingFileAppender自动删除过期文件
  • 1
    Spring Boot框架在java领域的优势
    76
  • 2
    Spring Boot 2.x 嵌入式 Servlet 容器
    62
  • 3
    springboot定制嵌入式的servlet
    44
  • 4
    基于SpringBoot+Vue+uniapp的公园管理系统的详细设计和实现(源码+lw+部署文档+讲解等)
    74
  • 5
    基于SpringBoot+Vue的志愿服务管理系统设计和实现(源码+LW+部署讲解)
    73
  • 6
    基于SpringBoot+Vue+uniapp的武汉市公交路线查询系统的详细设计和实现(源码+lw+部署文档+讲解等)
    112
  • 7
    基于SpringBoot+Vue+uniapp的旅游攻略系统的详细设计和实现(源码+lw+部署文档+讲解等)
    113
  • 8
    基于SpringBoot+Vue+uniapp的房屋租赁App的详细设计和实现(源码+lw+部署文档+讲解等)
    127
  • 9
    基于SpringBoot+Vue个人博客系统设计和实现(源码+LW+部署讲解)
    86
  • 10
    基于SpringBoot+Vue+uniapp的成人教育APP的详细设计和实现(源码+lw+部署文档+讲解等)
    86

    • 相关课程

    更多
  • 日志服务 SLS 可观测数据分析平台介绍
  • 微服务+全栈在线教育实战项目演练（SpringCloud Alibaba+SpringBoot）
  • SpringBoot实战教程
  • SpringBoot快速掌握 - 核心技术
  • SpringBoot快速掌握 - 高级应用
  • Springboot项目云开发快速迁移

    • 相关电子书

    更多
  • PostgresChina2018_赖思超_PostgreSQL10_hash索引的WAL日志修改版final
  • Kubernetes下日志实时采集、存储与计算实践
  • 日志数据采集与分析对接

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
  • 搭建Java Web开发环境
  • 通过日志服务实现云资源OSS的安全审计
  • 如何将OSS数据导入至SLS中进行分析
  • 日志服务之使用Nginx模式采集日志
  • WEB网页编程实战
    • 下一篇
    阿里云OSS设置跨域访问