springboot拦截器实现日志登录和操作记录

原创 已于 2024-11-11 13:23:33 修改 · 539 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #后端 #java

于 2024-11-11 11:29:26 首次发布

文章目录

登录日志



/**
 * @Date: 2023/8/20 13:24
 */
public class LoginlogThread implements Runnable {
    private Loginlog loginlog;

    public LoginlogThread(Loginlog loginlog) {
        this.loginlog = loginlog;
    }

    @Override
    public void run() {
        LoginlogService loginlogService = Spring.getBean(LoginlogService.class);
        loginlogService.save(this.loginlog);
    }
}


import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

/**

 * @Date: 2023/8/20 12:32
 */
@Component
@Configuration
@Slf4j
public class LoginlogInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //不记录日志
        if (!(request instanceof BodyReaderHttpServletRequestWrapper)) {
            return true;
        }

        Map<String, Object> requestParm = new HashMap<>();
        BodyReaderHttpServletRequestWrapper requestWrapper = (BodyReaderHttpServletRequestWrapper) request;
        //ip地址
        String ipAddress = IPUtil.getIPAddress(requestWrapper);
        requestParm.put("ipAddress", ipAddress);
        String bodyString = requestWrapper.getBodyString();
        //转map
        Map<String, Object> map = JSON.parseObject(bodyString, new TypeReference<Map<String, Object>>() {
        });
        //获得用户名
        String username = MapUtil.getMapValue(map, "username", "");
        requestParm.put("username", username);
        request.setAttribute("loginLog", requestParm);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        Object loginlog = request.getAttribute("loginLog");
        if (null == loginlog) {
            return;
        }
        Map<String, Object> requestParm = (Map<String, Object>) loginlog;
        //获取响应结果
        Object body = request.getAttribute("body");
        if (null == body || !(body instanceof RespBody)) {
            return;
        }
        RespBody<Object> result = (RespBody<Object>) body;
        if (null == ex || HttpStatus.SUCCESS.getStatus() != response.getStatus()) {
            Loginlog info = new Loginlog();
            String username = MapUtil.getMapValue(requestParm, "username", "");
            String ipAddress = MapUtil.getMapValue(requestParm, "ipAddress", "");
            info.setIpAddress(ipAddress);
            info.setUsername(username);
            info.setLoginResult(result.getCode());
            info.setHttpStatus(response.getStatus());
            LoginlogThreadPool.getDataThread().submit(new LoginlogThread(info));
            //释放资源
            request.removeAttribute("loginLog");
        }
    }
}


操作日志

import com.alibaba.fastjson.JSON;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

/**
 * 操作日志拦截器
 *
 * @Date: 2023/8/14 9:37
 */
@Component
@Configuration
@Slf4j
public class OperationLogInterceptor implements HandlerInterceptor {

    @Autowired
    private PersonalUserService personalUserService;

    @Autowired
    private LogConfig logConfig;

    @Autowired
    private SecurityConfig securityConfig;

    //不拦截的请求
    private static String[] AllowAccessURI = null;

    private boolean isAllowAccessURI(String requestURI) {
        //判断参数是否合法
        if (StringUtil.isNullOrEmpty(requestURI)) {
            return false;
        }
        if (StringUtil.isNullOrEmpty(securityConfig.getAllowAccessURI())) {
            //log.warn("allow access uri not configured");
            return false;
        }
        if (null == AllowAccessURI) {
            AllowAccessURI = securityConfig.getAllowAccessURI().split(",");
        }
        //判断是否在“允许访问”的列表中
        for (int i = 0; i < AllowAccessURI.length; i++) {
            String allowURI = AllowAccessURI[i];
            if (requestURI.contains(allowURI)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean preHandle(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull Object handler) throws Exception {
        //如果是不开启，则直接退出
        if (logConfig.getOperationLogEnable() == EnableEnum.UNABLE.getCode()) {
            return true;
        }
        //不记录日志
        if (!(request instanceof BodyReaderHttpServletRequestWrapper)) {
            return true;
        }

        Map<String, Object> requestParm = new HashMap<>();
        BodyReaderHttpServletRequestWrapper requestWrapper = (BodyReaderHttpServletRequestWrapper) request;
        //请求URI地址
        String requestURI = requestWrapper.getRequestURI();
        //允许通过的则不记录日志
        if (isAllowAccessURI(requestURI)) {
            return true;
        }
        requestParm.put("requestURI", requestURI);

        //请求类型
        String method = requestWrapper.getMethod();
        requestParm.put("method", method);

        //ip地址
        String ipAddress = IPUtil.getIPAddress(requestWrapper);
        requestParm.put("ipAddress", ipAddress);

        //参数内容
        String parameter = "";
        Map<String, String[]> parameterMap = requestWrapper.getParameterMap();
        if (null == parameterMap || parameterMap.isEmpty()) {
            parameter = requestWrapper.getBodyString();
        } else {
            parameter = JSON.toJSONString(parameterMap);
        }
        requestParm.put("parameter", parameter);

        //字符集
        String characterEncoding = requestWrapper.getCharacterEncoding();
        requestParm.put("characterEncoding", characterEncoding);

        if (null == handler) {
            log.error("handler is null"); //静态资源
            return true;
        }

        //handler的处理
        if (!(handler instanceof HandlerMethod)) {
            log.info("static resource"); //静态资源
            request.setAttribute("startTime", System.currentTimeMillis());
            return true;
        }
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Class<?> clazz = handlerMethod.getBeanType();

        //获得类上@RequestMapping注解
        //类路径
        String classMappingURL = "";
        RequestMapping classRequestMappingAnnotation = clazz.getAnnotation(RequestMapping.class);
        if (null != classRequestMappingAnnotation) {
            String[] classMappingURLArray = classRequestMappingAnnotation.value();
            if (null != classMappingURLArray && classMappingURLArray.length > 0) {
                classMappingURL = classMappingURLArray[0];
            }
        }

        //获得swager上的@Api注解
        String apiName = "";
        Api apiAnnotation = clazz.getAnnotation(Api.class);
        if (null != apiAnnotation) {
            String[] tags = apiAnnotation.tags();
            if (null != tags && tags.length > 0) {
                apiName = tags[0];
            }
        }
        requestParm.put("apiName", apiName);

        //获得swager上的@ApiOperation注解
        String operationName = "";
        ApiOperation apiOperationAnnotation = handlerMethod.getMethodAnnotation(ApiOperation.class);
        if (null != apiOperationAnnotation) {
            operationName = apiOperationAnnotation.value();
        }
        requestParm.put("operationName", operationName);

        //获得方法上@RequestMapping注解
        String methodMappingURL = "";
        //获得方法上的注解
        RequestMapping methodRequestMapping = handlerMethod.getMethodAnnotation(RequestMapping.class);
        if (null != methodRequestMapping) {
            String[] methodRequestMappingArray = methodRequestMapping.value();
            if (null == methodRequestMappingArray || methodRequestMappingArray.length <= 0) {
                log.error("methodRequestMappingArray is null");
                return true;
            }
            methodMappingURL = methodRequestMappingArray[0];
        } else {
            if (RequestMethod.POST.name().equalsIgnoreCase(method)) {
                PostMapping postMapping = handlerMethod.getMethodAnnotation(PostMapping.class);
                if (null == postMapping) {
                    log.error("postMapping is null");
                    return true;
                }
                methodMappingURL = postMapping.value()[0];
            } else if (RequestMethod.PUT.name().equalsIgnoreCase(method)) {
                PutMapping putMapping = handlerMethod.getMethodAnnotation(PutMapping.class);
                if (null == putMapping) {
                    log.error("putMapping is null");
                    return true;
                }
                methodMappingURL = putMapping.value()[0];
            } else if (RequestMethod.GET.name().equalsIgnoreCase(method)) {
                GetMapping getMapping = handlerMethod.getMethodAnnotation(GetMapping.class);
                if (null == getMapping) {
                    log.error("getMapping is null");
                    return true;
                }
                methodMappingURL = getMapping.value()[0];
            } else if (RequestMethod.DELETE.name().equalsIgnoreCase(method)) {
                DeleteMapping deleteMapping = handlerMethod.getMethodAnnotation(DeleteMapping.class);
                if (null == deleteMapping) {
                    log.error("deleteMapping is null");
                    return true;
                }
                methodMappingURL = deleteMapping.value()[0];
            } else {
                log.error("Request method type not supported");
                return true;
            }
        }
        String rule = String.format("/%s/%s/%s", logConfig.getAppName(), classMappingURL, methodMappingURL).replace("//", "/");
        requestParm.put("rule", rule);

        //定义一个匹配器
        PathMatcher matcher = new AntPathMatcher();
        boolean match = matcher.match(rule, requestURI);
        if (!match) {
            return true;
        }

        //获得登录的用户信息，如未登录，则匿名访问
        Object userID = request.getAttribute("userID");
        if (null == userID) {
            log.error("no login");
            return true;
        }

        PersonalUser currentLoginUser = personalUserService.getCurrentLoginUser(request);
        if (null == currentLoginUser) {
            return true;
        }
        //创建id
        String id = SnowFlakeUtil.getInstance().nextStringId();

        //id
        request.setAttribute("id", id);

        //requestParm缓存
        requestParm.put("currentLoginUser", currentLoginUser);
        requestParm.put("id", id);
        request.setAttribute("requestParm", requestParm);

        //记录起始时间
        request.setAttribute("startTime", System.currentTimeMillis());
        //添加日志
        return true;
    }

    @Override
    public void postHandle(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull Object handler, ModelAndView modelAndView) throws Exception {
    }

    @Override
    public void afterCompletion(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, Object handler, Exception ex) throws Exception {
        String id = (String) request.getAttribute("id");
        //如果取不到id则直接返回
        if (StringUtil.isNullOrEmpty(id)) {
            return;
        }
        Long startTime = (Long) request.getAttribute("startTime");
        Long endTime = System.currentTimeMillis();
        Long costTime = endTime - startTime;
        Object body = request.getAttribute("body");
        if (null == body || !(body instanceof RespBody)) {
            return;
        }
        RespBody<Object> result = (RespBody<Object>) body;
        Map<String, Object> requestParm = (Map<String, Object>) request.getAttribute("requestParm");
        Map<String, Object> map = new HashMap<>();
        map.put("costTime", costTime);
        map.put("httpStatus", response.getStatus());
        map.put("result", result);
        map.putAll(requestParm);
        //记录日志并释放资源
        if (null == ex || HttpStatus.SUCCESS.getStatus() != response.getStatus()) {
            //更新日志，开启线程处理
            OperationLogThreadPool.getDataThread().submit(new OperationLogDataThread(map));
            request.removeAttribute("startTime");
            request.removeAttribute("id");
            request.removeAttribute("requestParm");
        }
    }
}

操作日志



import com.alibaba.fastjson.JSON;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

/**
 * 操作日志拦截器
 *
 * @Date: 2023/8/14 9:37
 */
@Component
@Configuration
@Slf4j
public class OperationLogInterceptor implements HandlerInterceptor {

    @Autowired
    private PersonalUserService personalUserService;

    @Autowired
    private LogConfig logConfig;

    @Autowired
    private SecurityConfig securityConfig;

    //不拦截的请求
    private static String[] AllowAccessURI = null;

    private boolean isAllowAccessURI(String requestURI) {
        //判断参数是否合法
        if (StringUtil.isNullOrEmpty(requestURI)) {
            return false;
        }
        if (StringUtil.isNullOrEmpty(securityConfig.getAllowAccessURI())) {
            //log.warn("allow access uri not configured");
            return false;
        }
        if (null == AllowAccessURI) {
            AllowAccessURI = securityConfig.getAllowAccessURI().split(",");
        }
        //判断是否在“允许访问”的列表中
        for (int i = 0; i < AllowAccessURI.length; i++) {
            String allowURI = AllowAccessURI[i];
            if (requestURI.contains(allowURI)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean preHandle(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull Object handler) throws Exception {
        //如果是不开启，则直接退出
        if (logConfig.getOperationLogEnable() == EnableEnum.UNABLE.getCode()) {
            return true;
        }
        //不记录日志
        if (!(request instanceof BodyReaderHttpServletRequestWrapper)) {
            return true;
        }

        Map<String, Object> requestParm = new HashMap<>();
        BodyReaderHttpServletRequestWrapper requestWrapper = (BodyReaderHttpServletRequestWrapper) request;
        //请求URI地址
        String requestURI = requestWrapper.getRequestURI();
        //允许通过的则不记录日志
        if (isAllowAccessURI(requestURI)) {
            return true;
        }
        requestParm.put("requestURI", requestURI);

        //请求类型
        String method = requestWrapper.getMethod();
        requestParm.put("method", method);

        //ip地址
        String ipAddress = IPUtil.getIPAddress(requestWrapper);
        requestParm.put("ipAddress", ipAddress);

        //参数内容
        String parameter = "";
        Map<String, String[]> parameterMap = requestWrapper.getParameterMap();
        if (null == parameterMap || parameterMap.isEmpty()) {
            parameter = requestWrapper.getBodyString();
        } else {
            parameter = JSON.toJSONString(parameterMap);
        }
        requestParm.put("parameter", parameter);

        //字符集
        String characterEncoding = requestWrapper.getCharacterEncoding();
        requestParm.put("characterEncoding", characterEncoding);

        if (null == handler) {
            log.error("handler is null"); //静态资源
            return true;
        }

        //handler的处理
        if (!(handler instanceof HandlerMethod)) {
            log.info("static resource"); //静态资源
            request.setAttribute("startTime", System.currentTimeMillis());
            return true;
        }
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Class<?> clazz = handlerMethod.getBeanType();

        //获得类上@RequestMapping注解
        //类路径
        String classMappingURL = "";
        RequestMapping classRequestMappingAnnotation = clazz.getAnnotation(RequestMapping.class);
        if (null != classRequestMappingAnnotation) {
            String[] classMappingURLArray = classRequestMappingAnnotation.value();
            if (null != classMappingURLArray && classMappingURLArray.length > 0) {
                classMappingURL = classMappingURLArray[0];
            }
        }

        //获得swager上的@Api注解
        String apiName = "";
        Api apiAnnotation = clazz.getAnnotation(Api.class);
        if (null != apiAnnotation) {
            String[] tags = apiAnnotation.tags();
            if (null != tags && tags.length > 0) {
                apiName = tags[0];
            }
        }
        requestParm.put("apiName", apiName);

        //获得swager上的@ApiOperation注解
        String operationName = "";
        ApiOperation apiOperationAnnotation = handlerMethod.getMethodAnnotation(ApiOperation.class);
        if (null != apiOperationAnnotation) {
            operationName = apiOperationAnnotation.value();
        }
        requestParm.put("operationName", operationName);

        //获得方法上@RequestMapping注解
        String methodMappingURL = "";
        //获得方法上的注解
        RequestMapping methodRequestMapping = handlerMethod.getMethodAnnotation(RequestMapping.class);
        if (null != methodRequestMapping) {
            String[] methodRequestMappingArray = methodRequestMapping.value();
            if (null == methodRequestMappingArray || methodRequestMappingArray.length <= 0) {
                log.error("methodRequestMappingArray is null");
                return true;
            }
            methodMappingURL = methodRequestMappingArray[0];
        } else {
            if (RequestMethod.POST.name().equalsIgnoreCase(method)) {
                PostMapping postMapping = handlerMethod.getMethodAnnotation(PostMapping.class);
                if (null == postMapping) {
                    log.error("postMapping is null");
                    return true;
                }
                methodMappingURL = postMapping.value()[0];
            } else if (RequestMethod.PUT.name().equalsIgnoreCase(method)) {
                PutMapping putMapping = handlerMethod.getMethodAnnotation(PutMapping.class);
                if (null == putMapping) {
                    log.error("putMapping is null");
                    return true;
                }
                methodMappingURL = putMapping.value()[0];
            } else if (RequestMethod.GET.name().equalsIgnoreCase(method)) {
                GetMapping getMapping = handlerMethod.getMethodAnnotation(GetMapping.class);
                if (null == getMapping) {
                    log.error("getMapping is null");
                    return true;
                }
                methodMappingURL = getMapping.value()[0];
            } else if (RequestMethod.DELETE.name().equalsIgnoreCase(method)) {
                DeleteMapping deleteMapping = handlerMethod.getMethodAnnotation(DeleteMapping.class);
                if (null == deleteMapping) {
                    log.error("deleteMapping is null");
                    return true;
                }
                methodMappingURL = deleteMapping.value()[0];
            } else {
                log.error("Request method type not supported");
                return true;
            }
        }
        String rule = String.format("/%s/%s/%s", logConfig.getAppName(), classMappingURL, methodMappingURL).replace("//", "/");
        requestParm.put("rule", rule);

        //定义一个匹配器
        PathMatcher matcher = new AntPathMatcher();
        boolean match = matcher.match(rule, requestURI);
        if (!match) {
            return true;
        }

        //获得登录的用户信息，如未登录，则匿名访问
        Object userID = request.getAttribute("userID");
        if (null == userID) {
            log.error("no login");
            return true;
        }

        PersonalUser currentLoginUser = personalUserService.getCurrentLoginUser(request);
        if (null == currentLoginUser) {
            return true;
        }
        //创建id
        String id = SnowFlakeUtil.getInstance().nextStringId();

        //id
        request.setAttribute("id", id);

        //requestParm缓存
        requestParm.put("currentLoginUser", currentLoginUser);
        requestParm.put("id", id);
        request.setAttribute("requestParm", requestParm);

        //记录起始时间
        request.setAttribute("startTime", System.currentTimeMillis());
        //添加日志
        return true;
    }

    @Override
    public void postHandle(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull Object handler, ModelAndView modelAndView) throws Exception {
    }

    @Override
    public void afterCompletion(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, Object handler, Exception ex) throws Exception {
        String id = (String) request.getAttribute("id");
        //如果取不到id则直接返回
        if (StringUtil.isNullOrEmpty(id)) {
            return;
        }
        Long startTime = (Long) request.getAttribute("startTime");
        Long endTime = System.currentTimeMillis();
        Long costTime = endTime - startTime;
        Object body = request.getAttribute("body");
        if (null == body || !(body instanceof RespBody)) {
            return;
        }
        RespBody<Object> result = (RespBody<Object>) body;
        Map<String, Object> requestParm = (Map<String, Object>) request.getAttribute("requestParm");
        Map<String, Object> map = new HashMap<>();
        map.put("costTime", costTime);
        map.put("httpStatus", response.getStatus());
        map.put("result", result);
        map.putAll(requestParm);
        //记录日志并释放资源
        if (null == ex || HttpStatus.SUCCESS.getStatus() != response.getStatus()) {
            //更新日志，开启线程处理
            OperationLogThreadPool.getDataThread().submit(new OperationLogDataThread(map));
            request.removeAttribute("startTime");
            request.removeAttribute("id");
            request.removeAttribute("requestParm");
        }
    }
}

package com.maxvision.systemlog.core;

import com.maxvision.common.communication.RespBody;
import com.maxvision.common.enums.EnableEnum;
import com.maxvision.common.util.*;
import com.maxvision.common.util.Error;
import com.maxvision.rbac.entity.ent.PersonalUser;
import com.maxvision.systemlog.entity.ent.Operationlog;
import com.maxvision.systemlog.entity.ent.Operationlogconfig;
import com.maxvision.systemlog.service.service.OperationLogConfigService;
import com.maxvision.systemlog.service.service.OperationlogService;
import lombok.extern.slf4j.Slf4j;

import java.util.Map;

/**

  • 操作日志处理线程

*/
@Slf4j
public class OperationLogDataThread implements Runnable {
private Map<String, Object> map;

public OperationLogDataThread(Map<String, Object> map) {
    this.map = map;
}

@Override
public void run() {
    if (null == map) {
        log.error(Error.MISSING_PARAMETER + "");
        return;
    }
    //日志记录id
    String id = MapUtil.getMapValue(map, "id", "");
    //接口耗时
    long costTime = MapUtil.getMapValueLong(map, "costTime", 0L);
    //httpStatus
    int httpStatus = MapUtil.getMapValue(map, "httpStatus", 0);
    //rule
    String rule = MapUtil.getMapValue(map, "rule", "");
    //ipAddress
    String ipAddress = MapUtil.getMapValue(map, "ipAddress", "");
    //parameter
    String parameter = MapUtil.getMapValue(map, "parameter", "");
    //characterEncoding
    String characterEncoding = MapUtil.getMapValue(map, "characterEncoding", "");
    //requestURI
    String requestURI = MapUtil.getMapValue(map, "requestURI", "");
    //apiName
    String apiName = MapUtil.getMapValue(map, "apiName", "");
    //operationName
    String operationName = MapUtil.getMapValue(map, "operationName", "");
    //method
    String method = MapUtil.getMapValue(map, "method", "");
    //返回结果
    int code = Error.SUCCESS;
    if (map.containsKey("result")) {
        Object result = map.get("result");
        if (result instanceof RespBody) {
            RespBody<Object> respBody = (RespBody<Object>) result;
            code = respBody.getCode();
        }
    }
    //用户
    String operationUserId = "";
    String operationUserName = "";
    if (map.containsKey("currentLoginUser")) {
        Object result = map.get("currentLoginUser");
        if (result instanceof PersonalUser) {
            PersonalUser respBody = (PersonalUser) result;
            operationUserId = respBody.getId();
            operationUserName = respBody.getUsername();
        }
    }

    //操作日志配置接口
    OperationLogConfigService operationLogConfigService = Spring.getBean(OperationLogConfigService.class);

    //操作日志接口
    OperationlogService operationlogService = Spring.getBean(OperationlogService.class);

    synchronized (OperationLogDataThread.class) {
        //将map转成对应的实体
        Operationlogconfig config = new Operationlogconfig();
        config.setId(MD5Util.md5Encode(rule));
        //判断是否存在
        Operationlogconfig dbConfig = operationLogConfigService.queryById(config.getId());
        if (dbConfig == null) {
            //添加
            config.setMenuName(apiName);
            config.setOperationName(operationName);
            config.setCount(1L);
            config.setEnable(EnableEnum.UNABLE.getCode());
            config.setRule(rule);
            //添加
            operationLogConfigService.add(config);
        } else {
            //修改数据表中的数据
            Long count = dbConfig.getCount();
            if (count >= Long.MAX_VALUE) {
                count = 0L;
            }
            dbConfig.setCount(count + 1);
            if (StringUtil.isNullOrEmpty(dbConfig.getMenuName())) {
                dbConfig.setMenuName(apiName);
            }
            if (StringUtil.isNullOrEmpty(dbConfig.getOperationName())) {
                dbConfig.setOperationName(operationName);
            }
            operationLogConfigService.update(dbConfig);
        }

        //查询配置
        Operationlogconfig operationlogconfig = operationLogConfigService.queryById(config.getId());
        if (null == operationlogconfig) {
            log.error("config is null");
            return;
        }

        //不记日志
        if (operationlogconfig.getEnable() != EnableEnum.ENABLE.getCode()) {
            //log.warn("Do not record  operationlog");
            return;
        }
        Operationlog info = new Operationlog();
        info.setId(id);
        info.setCode(code);
        info.setHttpStatus(httpStatus);
        info.setParameter(parameter);
        info.setCharacterEncoding(characterEncoding);
        info.setOperationLogConfigId(operationlogconfig.getId());
        info.setRequestURI(requestURI);
        info.setCostTime(costTime);
        info.setIpAddress(ipAddress);
        info.setMethod(method);
        info.setOperationUserId(operationUserId);
        info.setOperationUserName(operationUserName);
        operationlogService.add(info);
    }

}

}
2.1 Vite + Vue 3 + TS 项目脚手架深度配置
嗨，欢迎来到我的 优快云 博客小天地！一名深耕多年的技术发烧友。在这里，我将把日常工作中积累的宝贵经验，从复杂架构设计的精妙之处，到代码优化的实战技巧，毫无保留地分享给大家。
03-10 5895
2.1 Vite + Vue 3 + TS 项目脚手架深度配置
vite + vue3 + setup + pinia + ts 项目实战
qq_46416934的博客
03-09 1572
介绍 一个使用 vite + vue3 + pinia + ant-design-vue + typescript 完整技术路线开发的项目，秒级开发更新启动、新的vue3 composition api 结合 setup纵享丝滑般的开发体验、全新的 pinia状态管理器和优秀的设计体验（1k的size）、antd无障碍过渡使用UI组件库 ant-design-vue、安全高效的 typescript类型支持、代码规范验证、多级别的权限管理~ 前言 前两天接到了一个需求，就是把原来的一个项目的主要功能模块和用
创建vue3+ts项目
qq_48783694的博客
03-12 6183
在开发项目的时候，经常会用到svg矢量图，使用svg矢量图之后，页面上加载的不再是图片资源，很大的提升了页面性能，svg文件比img小很多，在项目中机会不占资源。安装依赖：https://www.npmjs.com/package/vite-plugin-mock。官网地址：https://element-plus.gitee.io/zh-CN/API接口统一管理：创建src/api/use/index.ts以及type.ts。官网：https://stylelint.bootcss.com/
【搭建】Vue3项目（pnpm）
weixin_61901395的博客
02-29 1158
【搭建】Vue3项目（pnpm）
创建vue3+pinia项目规范化流程
weixin_45837076的博客
11-18 389
husky 是一个 git hooks 工具 ( git的钩子工具，可以在特定时机执行特定的命令 )，在代码提交成功前进行校验。创建vue应用命令：npm init vue@latest （npm创建命令）Vue3：脚手架create-vue，底层构建工具基于vite，3.cd 进刚刚创建的目录中，安装依赖：pnpm i。1.创建：pnpm create vue。以下流程使用pnpm包管理器，速度快。(1)在Settings中添加配置。4.启动：pnpm dev。关于pinia的使用。
【Vue3+Ts project】pnpm 安装 和 使用
m0_64494670的博客
04-29 890
pnpm 使用方法
手把手教你轻松使用pnpm建立Vue3项目（包含配置）
2301_80841939的博客
12-16 6672
我们为什么要使用 pnpm？ 速度快：pnpm的安装速度通常比npm和yarn快，尤其是在大型项目中。 节省空间：通过智能地共享依赖项，pnpm可以在多个项目中节省大量磁盘空间。 兼容性好：pnpm遵循npm和yarn的大部分约定，因此你可以很容易地在它们之间切换。 安全性：pnpm提供了内置的安全措施，比如防止在node_modules中执行不受信任的代码。
从零开始搭建Vue3+Vite+TS+Router+Pinia脚手架
BDawn的专栏
11-04 1163
从零开始搭建Vue3+Vite+TS+Router+Pinia脚手架
0-1搭建vue3.0+vite+ts+less脚手架4——配置 ESLint、 Prettier、StyleLint、Husky、 LintStaged
chuangtxj123的博客
09-08 2215
这样就配置完毕啦，当我们使用 git commit -m “xxx” 时，lint-staged 会自动执行帮我们进行代码质量与风格的修复。配置完成之后我们对代码风格的配置只会使用prettier的配置，相当于将eslint中冲突的规则覆盖掉了。运行之后就会出现.husky文件夹，之后我们就可以配置在GItHook中执行的操作啦😀。我们还可以配置忽略文件，让 StyleLint 不对这些文件进行校验。我们还可以配置忽略文件，让 ESLint 不对这些文件进行校验。然后配置一个初始化 Hysky 的命令。
vue3+Vite+TS项目，配置ESlint和Prettier
热门推荐
iblackboy的博客
03-25 1万+
是一个用于检测 ECMAScript/JavaScript 代码中的潜在问题和错误的工具，旨在使代码更一致并避免错误。它可以帮助开发者检测代码中的潜在问题，提高代码质量。一个“有态度”的代码格式化工具支持大量编程语言已集成到大多数编辑器中几乎不需要设置参数为什么使用Prettier?按保存键时，代码就被格式化了代码评审时无须争论代码样式节省时间和精力ESLint配置文件（需求不同，会有一些差异）env: {},extends: [],env: {},},},
一、pnpm创建vite+vue3.0+ts项目
qq_23135259的博客
04-25 1218
3、设置一个项目名称，回车后，出现，选择项目框架，这里选择创建vue项目，（按上下键选择，按回车键选中）5、成功，cd apply：目录定义到apply目录下，apply是第三步设置的项目名，会生成个文件夹。pnpm run serve ：运行项目。pnpm install :项目初始化。4、这里选择typescript。1、cmd打开命令窗口。
创建vue3项目
m0_68705108的博客
05-12 4451
随着前端技术的快速发展，Vue.js 作为一款流行的 JavaScript 框架，不断推陈出新。Vue 3 作为其最新版本，带来了诸多性能提升和新的特性。本文将详细介绍如何使用 Vue CLI（命令行界面）来创建一个完整的 Vue 3 项目。
vite+vue3+ts 手把手教你创建一个vue3项目
attengtiong的博客
12-21 8624
Vue3+Vite3+TS前端工程化实践
vue3：2、使用新一代Vue脚手架create-vue以及pnpm包管理器，创建项目
qq_37899792的博客
09-07 839
即官方的项目脚手架工具，提供了搭建基于且 TypeScript 就绪的 Vue 项目的选项。前言（2）：pnpm包管理器的进化路径: npm => yarn => pnpmpnpm 代表 performant（高性能的npm），同 npm 和 Yarn，都属于Javascript 包管理安装工具，它较 npm 和在性能上得到很大提升，被称为。
教你如何创建一个vite+ts+vue3的脚手架(傻瓜式教程）
m0_63500235的博客
03-26 1328
vite项目的搭建 安装命令 npm create vite@latest 回车选择 vue 回车选择 vue-ts 创建成功 cd 到根文件夹(vite-project)里面 创建vuex 在src里面新建 store文件夹创建 index.ts 文件 import { createStore } from "vuex"; export default createStore<any>({ state: {}, // 数据源存放地 getters: {...
基于Vue3+TS的Monorepo前端项目架构设计与实现
岩家兴的博客
02-20 1171
写在前面 你好，我是前端程序员鼓励师岩家兴！去年在另一个项目https://juejin.cn/post/7121736546000044046中，我向读者朋友们介绍了结合npm包管理工具yarn作vue3项目的monorepo架构设计。今天，在这个风和日丽阳光明媚的钱塘江畔，我心情很好，我打算再写一篇她的姊妹篇------基于Vue3+TS的Monorepo前端项目架构设计与实现(pnpm版本...
详解从零搭建企业级 vue3 + vite2+ ts4 框架全过程
趣谈前端
09-08 1575
大厂技术坚持周更精选好文本文不仅仅是搭建个脚手架这么简单，还会带你了解每一步、甚至每一个配置项的作用，和每个配置的知识点涉及到的知识点：Vue3、Vite、TypeScript、ESlint、Stylelint、Vue-router、Axios、Pinia本文项目初始化时间为2022/2/19，运行初始化命令获得的 vite 最新版本为 2.8.0整个搭建过程体系因为我想把每个点都写得详细...
创建vue3（npm create vue@latest）
zzz2306的博客
09-04 2039
4.然后就可以关闭终端窗口了！这时会看到桌面已经有了创建的文件夹。3.创建并配置选项（项目名称自取）5.文件夹，右键vs code打开。1.桌面右键选择终端打开，输入。node的多版本管理中，其实是node版本不对。nvm use 版本号。查看多个node版本。
vue3 运行npm create vue@latest 和 npm init vue@latest 执行速度慢的问题
ljh574649119的专栏
02-07 2606
npm create vue@latest、和 npm init vue@latest 不管是电脑cmd上还是vscode终端上都是卡住不动！
Vue3 + ts + pinia + elementplus + axios
最新发布
03-15
引用2中提到了使用Vite2+Vue3+TS+Pinia+ElementPlus搭建项目，所以这里需要指导用户运行创建命令，比如`npm create vite@latest`，然后选择模板。 接下来是依赖安装。需要列出所有需要的依赖项，包括vue-router、...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

思静鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值