当前位置:

首页 > 编程开发 > SpringBoot中构建生产级日志系统的优雅指南

SpringBoot中构建生产级日志系统的优雅指南

基于SpringBoot构建生产级日志系统,需满足级别区分、性能优化、链路追踪、敏感信息脱敏、分类输出、JSON格式及环境差异化等需求。通过添加依赖、配置Logback异步输出、封装日志工具类及递归脱敏工具,实现高效规范的日志管理。

本文目录

    一、需求描述

    在实际开发中,日志系统需要满足哪些需求?下面这些点基本是绕不开的:

    SpringBoot中构建生产级日志系统的优雅指南

    • 区分日志级别:DEBUG/INFO/WARN/ERROR 各司其职,别混为一谈
    • 性能友好:避免日志序列化带来的额外开销,同时支持异步输出
    • 链路追踪:一次请求能全链路追踪,依赖一个 RequestId 就能串起来
    • 敏感信息脱敏:手机号、身份证这类敏感数据得自动打码
    • 日志分类:业务日志、错误日志、慢 SQL 日志最好分开存储,方便排查
    • 输出规范:JSON 格式是标配,便于接入 ELK 做采集和分析
    • 开发/生产环境差异化:开发环境直接输出到控制台,生产环境则落地到文件

    这些需求看似琐碎,但落到工程实践里,就是一套完整的体系。接下来咱们逐步拆解,看看代码怎么落地。

    二、详细步骤与代码实现

    1. 添加依赖

    先把基础依赖加进来。别小看这一步,少了 disruptor,异步日志的性能提升就大打折扣了。

    
    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            com.lmax
            disruptor
            3.4.4
        
        
        
            org.springframework.cloud
            spring-cloud-starter-sleuth
            3.1.5
        
        
        
            org.projectlombok
            lombok
            true
        
    

    2. 配置文件(application.yml)

    配置里除了常规的日志级别和路径,还特意定义了一个自定义的敏感字段列表,方便脱敏时动态扩展。

    # application.yml
    spring:
      application:
        name: demo-service
      # 链路追踪配置
      sleuth:
        web:
          enabled: true
        sampler:
          probability: 1.0  # 生产环境建议0.1
    # 日志配置
    logging:
      # 日志文件路径
      file:
        path: ./logs
        name: ${logging.file.path}/${spring.application.name}.log
      # 日志级别
      level:
        root: INFO
        com.example: DEBUG
        org.springframework.web: INFO
        org.hibernate: WARN
      # 日志格式
      pattern:
        console: "%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(%5p) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n%wEx"
        file: "%d{yyyy-MM-dd HH:mm:ss.SSS} %5p ${PID:- } --- [%t] %-40.40logger{39} : %m%n%wEx"
    # 自定义日志配置
    log:
      # 敏感字段列表
      sensitive-fields:
        - password
        - oldPassword
        - newPassword
        - idCard
        - phone
        - bankCard
        - token
        - secret

    3. Logback配置(logback-spring.xml)

    Logback 的配置是核心。这里我们做了几件事:彩色控制台输出、普通日志文件、错误日志单独文件、业务日志独立文件,并且全部接入了异步输出(AsyncAppender)。注意那个 JSON 日志格式,直接给 ELK 用的。

    
    
        
        
        
        
        
        
        
        
        
        
        
        
            
                ${CONSOLE_LOG_PATTERN}
                UTF-8
            
        
        
        
            0
            1024
            
        
        
        
            ${LOG_PATH}/${APP_NAME}.log
            
                ${LOG_PATH}/${APP_NAME}.%d{yyyy-MM-dd}.log
                30
                10GB
            
            
                ${FILE_LOG_PATTERN}
                UTF-8
            
        
        
        
            ${LOG_PATH}/${APP_NAME}-error.log
            
                ERROR
            
            
                ${LOG_PATH}/${APP_NAME}-error.%d{yyyy-MM-dd}.log
                90
            
            
                ${FILE_LOG_PATTERN}
                UTF-8
            
        
        
        
            ${LOG_PATH}/biz.log
            
                ${LOG_PATH}/biz.%d{yyyy-MM-dd}.log
                30
            
            
                ${FILE_LOG_PATTERN}
            
        
        
        
            2048
            0
            true
            
        
        
            1024
            
        
        
            1024
            
        
        
        
            
        
        
        
            
            
            
        
    

    4. 日志工具类封装

    写一个 LogUtil 工具类,把常见的日志场景封装起来:获取 TraceId、记录业务日志、接口耗时、方法耗时。这样业务代码里只需要一行调用,非常清爽。

    package com.example.log.util;
    
    import lombok.extern.slf4j.Slf4j;
    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 ja vax.servlet.http.HttpServletRequest;
    import ja va.util.UUID;
    
    /**
     * 日志工具类
     */
    @Slf4j
    @Component
    public class LogUtil {
        
        // 业务日志专用Logger
        private static final Logger BIZ_LOGGER = LoggerFactory.getLogger("BIZ_LOGGER");
        
        /**
         * 获取当前请求的TraceId
         */
        public static String getTraceId() {
            try {
                ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
                if (attributes != null) {
                    HttpServletRequest request = attributes.getRequest();
                    String traceId = request.getHeader("X-Trace-Id");
                    if (traceId == null || traceId.isEmpty()) {
                        traceId = UUID.randomUUID().toString().replace("-", "");
                    }
                    return traceId;
                }
            } catch (Exception e) {
                log.warn("获取TraceId失败", e);
            }
            return UUID.randomUUID().toString().replace("-", "");
        }
        
        /**
         * 业务日志(关键操作记录)
         */
        public static void bizLog(String operation, String userId, Object... params) {
            String traceId = getTraceId();
            String message = String.format("[BIZ][%s][%s][%s] params: %s", 
                traceId, operation, userId, params);
            BIZ_LOGGER.info(message);
        }
        
        /**
         * 接口调用日志(简洁版)
         */
        public static void apiLog(String apiName, long costTime, Object request, Object response) {
            if (costTime > 3000) {
                // 慢接口使用WARN级别
                log.warn("[API][{}] cost: {}ms, request: {}, response: {}", 
                    apiName, costTime, request, response);
            } else {
                log.info("[API][{}] cost: {}ms", apiName, costTime);
            }
        }
        
        /**
         * 方法调用日志(带耗时)
         */
        public static void methodLog(String methodName, long startTime) {
            long cost = System.currentTimeMillis() - startTime;
            if (cost > 1000) {
                log.warn("[METHOD][{}] cost: {}ms", methodName, cost);
            } else {
                log.debug("[METHOD][{}] cost: {}ms", methodName, cost);
            }
        }
    }
    

    5. 敏感信息脱敏工具

    脱敏是合规的硬要求。这里实现了一个递归脱敏工具,能处理 Map、List 嵌套,还能自动识别手机号、身份证等字符串格式并打码。

    package com.example.log.util;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import ja vax.annotation.PostConstruct;
    import ja va.util.*;
    import ja va.util.regex.Pattern;
    
    /**
     * 日志脱敏工具
     */
    @Slf4j
    @Component
    public class DesensitizationUtil {
        
        @Value("${log.sensitive-fields:}")
        private List sensitiveFields;
        
        private static final Set SENSITIVE_FIELDS = new HashSet<>(Arrays.asList(
            "password", "oldPassword", "newPassword", "idCard", "phone", 
            "bankCard", "token", "secret", "authorization"
        ));
        
        private static final Pattern PHONE_PATTERN = Pattern.compile("(\\d{3})\\d{4}(\\d{4})");
        private static final Pattern ID_CARD_PATTERN = Pattern.compile("(\\d{4})\\d{10}(\\d{4})");
        private static final Pattern BANK_CARD_PATTERN = Pattern.compile("(\\d{4})\\d{10,12}(\\d{4})");
        
        private ObjectMapper objectMapper;
        
        @PostConstruct
        public void init() {
            this.objectMapper = new ObjectMapper();
            this.objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
            if (sensitiveFields != null) {
                SENSITIVE_FIELDS.addAll(sensitiveFields);
            }
        }
        
        /**
         * 对象脱敏(JSON序列化前处理)
         */
        public String toJsonWithDesensitization(Object obj) {
            try {
                if (obj == null) {
                    return "null";
                }
                Object desensitized = desensitize(obj);
                return objectMapper.writeValueAsString(desensitized);
            } catch (JsonProcessingException e) {
                log.error("JSON序列化失败", e);
                return obj != null ? obj.toString() : "null";
            }
        }
        
        /**
         * 递归脱敏
         */
        @SuppressWarnings("unchecked")
        private Object desensitize(Object obj) {
            if (obj == null) {
                return null;
            }
            
            if (obj instanceof Map) {
                Map map = (Map) obj;
                Map result = new HashMap<>();
                for (Map.Entry entry : map.entrySet()) {
                    String key = entry.getKey();
                    Object value = entry.getValue();
                    
                    if (SENSITIVE_FIELDS.contains(key.toLowerCase())) {
                        result.put(key, "***");
                    } else {
                        result.put(key, desensitize(value));
                    }
                }
                return result;
            }
            
            if (obj instanceof List) {
                List list = (List) obj;
                List result = new ArrayList<>();
                for (Object item : list) {
                    result.add(desensitize(item));
                }
                return result;
            }
            
            // 字符串类型特殊处理
            if (obj instanceof String) {
                String str = (String) obj;
                // 手机号脱敏
                if (str.matches("^1[3-9]\\d{9}$")) {
                    return PHONE_PATTERN.matcher(str).replaceAll("$1****$2");
                }
                // 身份证脱敏
                if (str.matches("^[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[\\dXx]$")) {
                    return ID_CARD_PATTERN.matcher(str).replaceAll("$1**********$2");
                }
            }
            
            return obj;
        }
        
        /**
         * 快速脱敏手机号
         */
        public static String maskPhone(String phone) {
            if (phone == null || phone.length() != 11) {
                return phone;
            }
            return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
        }
        
        /**
         * 快速脱敏身份证
         */
        public static String maskIdCard(String idCard) {
            if (idCard == null || idCard.length() < 18) {
                return idCard;
            }
            return idCard.replaceAll("(\\d{4})\\d{10}(\\d{4})", "$1**********$2");
        }
    }
    
    

    6. 全局日志拦截器(AOP实现)

    AOP 切面是自动记录接口日志的好帮手。这里对所有 Controller 的方法做了环绕通知,自动记录请求参数、响应结果和耗时,所有输出都经过脱敏处理。慢请求还会单独告警。

    package com.example.log.aspect;
    
    import com.example.log.util.DesensitizationUtil;
    import com.example.log.util.LogUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    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 ja vax.servlet.http.HttpServletRequest;
    import ja va.lang.reflect.Method;
    import ja va.util.Arrays;
    import ja va.util.stream.Collectors;
    
    /**
     * Controller层日志切面
     */
    @Slf4j
    @Aspect
    @Component
    public class ControllerLogAspect {
        
        @Autowired
        private DesensitizationUtil desensitizationUtil;
        
        // 定义切点:所有Controller类下的方法
        @Pointcut("execution(* com.example..controller.*.*(..))")
        public void controllerPointcut() {}
        
        @Around("controllerPointcut()")
        public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
            long startTime = System.currentTimeMillis();
            
            // 获取请求信息
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes != null ? attributes.getRequest() : null;
            
            // 获取方法信息
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            String className = joinPoint.getTarget().getClass().getSimpleName();
            String methodName = method.getName();
            
            // 获取参数(脱敏处理)
            Object[] args = joinPoint.getArgs();
            String params = "";
            if (args != null && args.length > 0) {
                params = Arrays.stream(args)
                    .map(arg -> desensitizationUtil.toJsonWithDesensitization(arg))
                    .collect(Collectors.joining(", "));
            }
            
            // 请求信息日志
            if (request != null) {
                log.info("【请求开始】{} {} | 参数: {}", 
                    request.getMethod(), request.getRequestURI(), params);
            } else {
                log.info("【方法调用】{}.{} 参数: {}", className, methodName, params);
            }
            
            Object result = null;
            try {
                result = joinPoint.proceed();
                long costTime = System.currentTimeMillis() - startTime;
                
                // 响应日志(脱敏处理)
                String responseJson = desensitizationUtil.toJsonWithDesensitization(result);
                log.info("【请求结束】{}.{} 耗时: {}ms | 响应: {}", 
                    className, methodName, costTime, responseJson);
                
                // 慢请求告警
                if (costTime > 3000) {
                    log.warn("【慢请求】{}.{} 耗时: {}ms", className, methodName, costTime);
                }
                
                return result;
            } catch (Exception e) {
                long costTime = System.currentTimeMillis() - startTime;
                log.error("【请求异常】{}.{} 耗时: {}ms 异常: {}", 
                    className, methodName, costTime, e.getMessage(), e);
                throw e;
            }
        }
    }
    

    7. MDC链路追踪过滤器

    链路追踪的核心是 MDC。通过一个 Filter 把 traceId 塞进 MDC,然后在日志模板里用 %X{traceId} 就能自动打印出来,这样全链路的日志就串起来了。

    package com.example.log.filter;
    
    import lombok.extern.slf4j.Slf4j;
    import org.slf4j.MDC;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    import ja vax.servlet.*;
    import ja vax.servlet.http.HttpServletRequest;
    import ja va.io.IOException;
    import ja va.util.UUID;
    
    /**
     * MDC过滤器:实现全链路追踪
     */
    @Slf4j
    @Component
    @Order(1)
    public class TraceIdFilter implements Filter {
        
        private static final String TRACE_ID = "traceId";
        
        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                throws IOException, ServletException {
            
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            String traceId = httpRequest.getHeader("X-Trace-Id");
            
            if (traceId == null || traceId.isEmpty()) {
                traceId = UUID.randomUUID().toString().replace("-", "");
            }
            
            try {
                // 将traceId放入MDC,日志模板中可通过%X{traceId}引用
                MDC.put(TRACE_ID, traceId);
                MDC.put("clientIp", getClientIp(httpRequest));
                
                chain.doFilter(request, response);
            } finally {
                // 清理MDC,避免内存泄漏
                MDC.clear();
            }
        }
        
        private String getClientIp(HttpServletRequest request) {
            String ip = request.getHeader("X-Forwarded-For");
            if (ip == null || ip.isEmpty()) {
                ip = request.getRemoteAddr();
            }
            return ip != null ? ip.split(",")[0].trim() : "unknown";
        }
    }
    

    8. 业务中使用示例

    看看实际业务代码里怎么用。一个登录接口,既用了 Lombok 的 @Slf4j 记录常规日志,又调用了 LogUtil.bizLog 记录业务操作,还通过 LogUtil.methodLog 统计了方法耗时。注意,UserUpdateRequest 里的 password 字段会被自动脱敏,无需手动处理。

    package com.example.demo.controller;
    
    import com.example.demo.service.UserService;
    import com.example.log.util.LogUtil;
    import lombok.RequiredArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.bind.annotation.*;
    
    import ja vax.validation.Valid;
    import ja va.util.HashMap;
    import ja va.util.Map;
    
    @Slf4j
    @RestController
    @RequestMapping("/api/user")
    @RequiredArgsConstructor
    public class UserController {
        
        private final UserService userService;
        
        @PostMapping("/login")
        public Map login(@RequestBody @Valid LoginRequest request) {
            // 使用Lombok的@Slf4j
            log.info("用户登录请求: username={}", request.getUsername());
            
            long startTime = System.currentTimeMillis();
            try {
                UserVO user = userService.login(request);
                
                // 记录业务日志
                LogUtil.bizLog("用户登录", user.getId(), "login", request.getUsername());
                
                // 记录方法耗时
                LogUtil.methodLog("login", startTime);
                
                return Map.of("success", true, "data", user);
            } catch (Exception e) {
                log.error("用户登录失败: username={}, error={}", request.getUsername(), e.getMessage(), e);
                throw e;
            }
        }
        
        @PostMapping("/update")
        public Map updateUser(@RequestBody UserUpdateRequest request) {
            // 这里password字段会被自动脱敏
            log.info("更新用户信息: {}", request);
            
            userService.updateUser(request);
            return Map.of("success", true);
        }
    }
    
    // 请求对象示例
    @Data
    class LoginRequest {
        private String username;
        private String password;  // 会被脱敏
    }
    
    @Data
    class UserUpdateRequest {
        private String userId;
        private String phone;
        private String idCard;
        private String password;
    }
    

    9. 异常统一处理中的日志

    全局异常处理里,业务异常只记 WARN 级别,系统异常才记 ERROR 且带堆栈。这样告警阈值才能设得准,不会因为业务异常就炸锅。

    package com.example.demo.handler;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    
    @Slf4j
    @RestControllerAdvice
    public class GlobalExceptionHandler {
        
        @ExceptionHandler(BusinessException.class)
        public Result handleBusinessException(BusinessException e) {
            // 业务异常:记录WARN级别即可
            log.warn("业务异常: code={}, message={}", e.getCode(), e.getMessage());
            return Result.error(e.getCode(), e.getMessage());
        }
        
        @ExceptionHandler(Exception.class)
        public Result handleException(Exception e) {
            // 系统异常:记录ERROR级别,包含堆栈
            log.error("系统异常", e);
            return Result.error(500, "系统繁忙,请稍后重试");
        }
    }
    

    三、总结

    最佳实践总结

    原则说明示例
    级别正确DEBUG调试、INFO业务流程、WARN异常可恢复、ERROR系统错误循环内用DEBUG,关键节点用INFO
    参数占位使用{}占位符,避免字符串拼接log.info("user: {}", user)
    异常记录必须传入异常对象,输出堆栈log.error("错误", e)
    异步输出生产环境必须配置AsyncAppender使用Disruptor提升性能
    链路追踪使用MDC传递traceId全链路可追踪
    敏感脱敏密码、手机号等必须脱敏实现自定义脱敏工具
    日志开关使用isDebugEnabled()避免无效序列化if(log.isDebugEnabled()){...}
    合理采样高频日志需采样1%或千分之一

    性能优化要点

    1. 异步日志:AsyncAppender + Disruptor,QPS提升5-10倍
    2. 条件日志:使用log.isDebugEnabled()避免参数计算
    3. 合理级别:生产环境建议INFO,DEBUG仅开发/测试环境
    4. 避免打印大对象:大List/大JSON需要截断或只打印长度

    监控告警建议

    • ERROR日志数量突增 → 钉钉/企微告警
    • 慢请求日志(>3s) → 性能监控
    • 特定业务日志(登录失败频繁) → 安全告警

    日志规范Checklist

    • 禁止使用System.out.println()
    • 禁止打印密码、token等敏感信息
    • 日志消息清晰,包含关键业务标识(userId、orderId)
    • 异常日志必须包含堆栈信息
    • 关键业务操作必须有业务日志
    • 日志文件配置滚动策略和保留时长(建议30天)
    • 生产环境关闭DEBUG日志

    通过以上方案,可以实现生产级的日志系统,既保证性能又便于问题排查和监控告警。

    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发
    相关文章 更多
    SpringBoot中全局日志记录与请求链路追踪实战教学
    SpringBoot中全局日志记录与请求链路追踪实战教学

    通过MDC与Filter为每个请求生成唯一TraceId,从而实现对请求的全链路追踪,便于快速定位问题;利用AOP自动记录接口入参、出参及耗时,有效减少手动日志,提升开发效率;结合敏感信息脱敏,保障数据安全,全面增强系统可观测性。

    QQ影音怎么加速播放视频课程
    QQ影音怎么加速播放视频课程

    播放时右键选播放速度,或点控制条倍速,1.25 到 1.5 倍看课最舒服;公式代码类内容别超过 1.25 倍。

    企业微信创建企业提示失败怎么办 实名与填写检查
    企业微信创建企业提示失败怎么办 实名与填写检查

    先看提示属于哪类:名称占用就加后缀,实名不一致就重填本人信息,证件不清晰就重拍。统一社会信用代码逐位核对,连续三次失败别改材料重投,直接联系客服人工核。

    Modern Web Guidance 的 legacy-scan 反转建议应该怎样判断?
    Modern Web Guidance 的 legacy-scan 反转建议应该怎样判断?

    说明源码提交对字符串、生成器和数组的识别边界,以及扫描命令与发行包核验限制。

    Codex 0.170.0 正式版的语音与连接更新,适用范围有哪些限制?
    Codex 0.170.0 正式版的语音与连接更新,适用范围有哪些限制?

    0.170.0 的语音更新限于终端通话协商能力的明确新增,同名工具服务器跨环境支持仍标注实验性质;连接部分则修复大请求回退、认证竞态和云端重连等具体问题。这份正式版公告不足以证明所有账户、所有客户端都已具备完整语音功能。

    Hy4 flash 三种权重怎么选,安装和授权要注意哪些条件?
    Hy4 flash 三种权重怎么选,安装和授权要注意哪些条件?

    了解Hy4 flash、FP8与base的适用任务,阅读官方安装及图文代码,并核对资源和MaaS许可条件。

    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化
    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化

    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化。说明已核实的更新范围、类型兼容性和本地版本确认方法。

    OpenAI Java SDK 4.108.0 的两项新增能力适合哪些项目?
    OpenAI Java SDK 4.108.0 的两项新增能力适合哪些项目?

    OpenAI Java SDK 4.108.0 面向 Live MCP 工具接入与 Managed Agents 预算状态处理,说明新增模型、事件含义、正式发布范围和适用限制。

    Free Claude Code 6.19.37 如何兼顾网页搜索与普通工具调用?
    Free Claude Code 6.19.37 如何兼顾网页搜索与普通工具调用?

    Free Claude Code 6.19.37 在自动搜索时保留客户端工具及选择条件,代理执行搜索后仍返回普通调用。说明适用场景、历史信息保留、请求约束与第三方项目的版本边界。

    Google GenAI Go SDK 1.78.0 的 v1beta 配置优先级怎样判断?
    Google GenAI Go SDK 1.78.0 的 v1beta 配置优先级怎样判断?

    Google GenAI Go SDK 1.78.0 将 Gemini Developer API 默认改为 v1,可用 HTTPOptions.APIVersion 或环境变量保留 v1beta,Vertex AI 默认值不变。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。

    为什么要购买正版软件?
    01 官方授权

    授权来源透明,订单与许可信息可随时查询。

    02 即时交付

    付款成功后自动发放激活信息,支持订单追踪。

    03 中文协助

    安装、激活、迁移与续费问题都有专人响应。

    04 长期可用

    提供升级提醒与授权管理,换机时也能轻松迁移。

    网站备案号:苏ICP备2026018738号-1 联系邮箱:bd@zhengruan.com 网站地图

    Copyright ©2018-2026