在 Java 开发过程中，我们经常需要将本地构建的 JAR 包部署到私有 Maven 仓库中，以便团队成员使用。
然而，手动部署过程繁琐且容易出错：
为了解决这些痛点，我开发了一个自动化的批处理脚本，能够智能解析 JAR 包信息并自动部署到多个 Maven 仓库。
该脚本主要实现以下功能：
@echo offchcp 65001 >nul 2>&1setlocal enabledelayedexpansion技术解析：
chcp 65001：将控制台编码页设置为 UTF-8，解决中文乱码问题>nul 2>&1：隐藏编码设置的输出信息，保持界面整洁setlocal enabledelayedexpansion：启用延迟变量扩展，支持在循环中动态修改变量if "%~1"=="" ( echo 用法: %~nx0 ^<JAR文件路径^> echo 示例: %~nx0 C:\path\to\your.jar exit /b 1)set "filepath=%~1"if not exist "%filepath%" ( echo 错误: 文件不存在: %filepath% exit /b 1)if /i not "%~x1"==".jar" ( echo 错误: 文件必须是JAR格式 exit /b 1)技术要点：
%~nx0：获取脚本文件名（不含路径）%~1：获取第一个参数，%~x1：获取第一个参数的文件扩展名/i：不区分大小写的比较exit /b 1：以错误码 1 退出，但不关闭父窗口powershell -NoProfile -ExecutionPolicy Bypass -Command ^ "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; " ^ "Add-Type -AssemblyName System.IO.Compression.FileSystem; " ^ "$zip = [System.IO.Compression.ZipFile]::OpenRead('%filepath%'); " ^ "$pomEntry = $zip.Entries | Where-Object { $_.FullName -match 'META-INF/maven/.*/pom.properties$' } | Select-Object -First 1; " ^ "if ($pomEntry) { " ^ "$stream = $pomEntry.Open(); " ^ "$reader = New-Object System.IO.StreamReader($stream); " ^ "$content = $reader.ReadToEnd(); " ^ "$reader.Close(); " ^ "$stream.Close(); " ^ "$content | Out-File -FilePath '%tempDir%\pom.properties' -Encoding UTF8; " ^ "Write-Host 'SUCCESS: pom.properties found' -ForegroundColor Green; " ^ "} else { " ^ "Write-Host 'WARNING: pom.properties not found' -ForegroundColor Yellow; " ^ "} " ^ "$zip.Dispose();"技术亮点：
-NoProfile：跳过 PowerShell 配置文件，加快启动速度-ExecutionPolicy Bypass：绕过执行策略限制^：批处理中的行继续符，用于多行命令System.IO.Compression.ZipFile：.NET 的 ZIP 文件操作类META-INF/maven/.*/pom.properties$$zip.Dispose()：正确释放 ZIP 文件资源（而不是 Close()）set "groupId="set "artifactId="set "version="if exist "%tempDir%\pom.properties" ( for /f "usebackq tokens=1,2 delims==" %%a in ("%tempDir%\pom.properties") do ( if "%%a"=="groupId" set "groupId=%%b" if "%%a"=="artifactId" set "artifactId=%%b" if "%%a"=="version" set "version=%%b" ))解析机制：
usebackq：允许使用引号括起文件名tokens=1,2：分割每行为两个 tokendelims==：使用等号作为分隔符%%a 和 %%b：循环变量，分别代表键和值set "tempUploadDir=%TEMP%\maven_upload_%RANDOM%"mkdir "%tempUploadDir%"set "tempJarPath=%tempUploadDir%\%artifactId%-%version%.jar"copy "%filepath%" "%tempJarPath%" >nul技术原理：
.m2/repository 目录部署文件到远程仓库%RANDOM%：生成随机数，确保临时目录名唯一artifactId-version.jarset "pomFilePath=%filepath:.jar=.pom%"set "pomFileExists=false"if exist "%pomFilePath%" ( echo 找到对应的POM文件: %pomFilePath% set "pomFileExists=true" set "tempPomPath=%tempUploadDir%\%artifactId%-%version%.pom" copy "%pomFilePath%" "!tempPomPath!" >nul) else ( echo 未找到对应的POM文件: %pomFilePath% echo 将仅上传JAR文件)实现逻辑：
%filepath:.jar=.pom%：字符串替换，将.jar 替换为.pom!tempPomPath! 而不是 %tempPomPath%if "%pomFileExists%"=="true" ( set "deployCmd1=mvn deploy:deploy-file -Dmaven.test.skip=true -DgroupId=%groupId% -DartifactId=%artifactId% -Dversion=%version% -Dpackaging=jar -Dfile="!tempJarPath!" -DpomFile="!tempPomPath!" -Durl=http://repo1.example.com/repository/maven-releases -DrepositoryId=maven-public") else ( set "deployCmd1=mvn deploy:deploy-file -Dmaven.test.skip=true -DgroupId=%groupId% -DartifactId=%artifactId% -Dversion=%version% -Dpackaging=jar -Dfile="!tempJarPath!" -Durl=http://repo1.example.com/repository/maven-releases -DrepositoryId=maven-public")参数说明：
-Dmaven.test.skip=true：跳过测试阶段，加快部署速度-DgroupId/-DartifactId/-Dversion：Maven 坐标信息-Dpackaging=jar：指定打包类型-Dfile：要部署的文件路径-DpomFile：可选，POM 文件路径（仅在存在时添加）-Durl：目标仓库 URL-DrepositoryId：仓库 ID，需要在 Maven settings.xml 中配置认证信息start "Maven Deploy 1" !deployCmd1!timeout /t 1 /nobreak >nulstart "Maven Deploy 2" !deployCmd2!timeout /t 3 /nobreak >nulrmdir /s /q "%tempUploadDir%"设计考虑：
start：在新窗口中执行命令，实现并发部署timeout：等待命令启动后再清理资源/nobreak：防止用户按键中断等待/s /q：静默递归删除临时目录echo.echo 解析结果:echo GroupId: %groupId%echo ArtifactId: %artifactId%echo Version: %version%echo 文件路径: %filepath%echo.set /p "confirm=是否继续上传到Maven仓库? (y/N): "if /i not "%confirm%"=="y" ( echo 取消上传 exit /b 0)PowerShell 部分使用了颜色输出：
-ForegroundColor Green）-ForegroundColor Yellow）| 参数 | 作用 | 示例值 |
|---|---|---|
chcp 65001 | 设置 UTF-8 编码 | 解决中文乱码 |
enabledelayedexpansion | 启用延迟变量扩展 | 支持动态变量修改 |
-NoProfile | 跳过 PowerShell 配置文件 | 提升启动速度 |
-ExecutionPolicy Bypass | 绕过执行策略 | 确保脚本能够执行 |
%RANDOM% | 生成随机数 | 创建唯一临时目录 |
-Dmaven.test.skip=true | 跳过测试 | 加快部署速度 |
-DrepositoryId | 仓库标识 | 关联 settings.xml 认证 |
upload-jar.cmd "C:\path\to\test-api-1.1.3.jar"输出示例：
正在解析JAR文件: C:\path\to\test-api-1.1.3.jarSUCCESS: pom.properties found找到对应的POM文件: C:\path\to\test-api-1.1.3.pom已复制POM文件到临时目录解析结果: GroupId: com.example ArtifactId: test-api Version: 1.1.3 文件路径: C:\path\to\test-api-1.1.3.jar是否继续上传到Maven仓库? (y/N): y开始上传到Maven仓库...已复制JAR文件到临时目录上传到仓库1: http://repo1.example.com/repository/maven-releases上传到仓库2: http://repo2.example.com/repository/maven-releases清理临时文件...上传命令已启动，请查看弹出的命令行窗口获取上传结果。这个自动化部署脚本通过巧妙结合批处理、PowerShell 等技术，完美解决了 Maven JAR 包部署过程中的各种痛点。它不仅提升了开发效率，还减少了人为错误，是 DevOps 自动化的一个优秀实践案例。
关键技术收获：
通过这个项目，我们可以看到，即使是看似简单的自动化任务，也蕴含着丰富的技术细节和设计思考。好的工具不仅要解决问题，更要让使用者感到愉悦。
]]>本文将详细介绍如何在前端收集用户操作数据，并通过后端 API 安全地发送到 Kafka 消息队列中，实现实时数据流处理。
很多开发者可能会问：既然要发送数据到 Kafka，为什么不在前端直接连接 Kafka 呢？
这主要有以下几个重要原因：
前端应用 → 后端API → Kafka集群 → 数据处理服务这种架构的优势：
首先创建一个专门的工具类来处理用户行为数据的收集和发送：
// src/utils/userDataCollector.jsimport axios from 'axios';/** * 用户数据收集工具类 * 通过后端API发送用户行为数据到消息队列 */class UserDataCollector { constructor() { // 前端通过API调用，无需消息队列配置 } /** * 通用的数据发送方法 * @param {string} topic - 数据主题 * @param {Object|string} data - 要发送的数据 * @param {string} key - 数据标识（可选） */ async sendData(topic, data, key = null) { try { const dataString = typeof data === 'string' ? data : JSON.stringify(data); const response = await this.sendViaAPI({ topic: topic, message: dataString, key: key }); if (process.env.NODE_ENV === 'development') { console.log(`数据已发送到主题[${topic}]:`, data); } return response; } catch (error) { console.error(`发送数据到主题[${topic}]失败:`, error); // 发送失败不影响主要业务流程 return null; } } /** * 发送用户操作数据 * @param {Object} actionInfo - 操作信息对象 * @param {string} actionInfo.actionId - 操作ID * @param {string} actionInfo.module - 模块名称 * @param {string} actionInfo.userId - 用户ID * @param {number} actionInfo.timestamp - 时间戳 * @param {string} topic - 自定义主题（可选） */ async sendUserAction(actionInfo, topic = 'user-behavior') { const message = { actionId: actionInfo.actionId, module: actionInfo.module, userId: actionInfo.userId, timestamp: actionInfo.timestamp, eventType: 'user_action', source: 'web_frontend', sessionId: this.getSessionId(), userAgent: navigator.userAgent }; return await this.sendData(topic, message, actionInfo.userId); } /** * 通过后端API发送数据 */ async sendViaAPI(payload) { try { return await axios.post(`/api/datasync/${payload.topic}`, payload.message, { headers: { 'Content-Type': 'application/json' } }); } catch (error) { if (process.env.NODE_ENV === 'development') { console.warn(`数据发送接口暂不可用，主题: ${payload.topic}, 数据:`, payload.message); } return null; } } /** * 获取会话ID */ getSessionId() { let sessionId = sessionStorage.getItem('sessionId'); if (!sessionId) { sessionId = 'session_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9); sessionStorage.setItem('sessionId', sessionId); } return sessionId; } /** * 批量发送数据 */ async sendBatchData(topic, dataList, keyExtractor = null) { const promises = dataList.map((data, index) => { const key = keyExtractor ? keyExtractor(data, index) : null; return this.sendData(topic, data, key); }); return await Promise.allSettled(promises); }}// 导出单例实例let instance = null;export function getUserDataCollector() { if (!instance) { instance = new UserDataCollector(); } return instance;}export default { getUserDataCollector};// src/App.vue<template> <div id="app"> <!-- 应用内容 --> </div></template><script>import { getUserDataCollector } from '@/utils/userDataCollector';export default { name: 'App', async created() { // 应用启动时发送用户访问数据 await this.sendUserVisitInfo(); }, methods: { async sendUserVisitInfo() { const collector = getUserDataCollector(); // 从路由获取页面信息 const pageInfo = this.$route.query.page || 'dashboard'; const moduleInfo = this.$route.query.module || 'main'; // 从状态管理获取用户信息 const userInfo = this.$store.state.user || {}; // 构建用户访问数据 const visitData = { actionId: pageInfo, module: moduleInfo, userId: userInfo.id || 'anonymous', timestamp: Date.now() }; try { await collector.sendUserAction(visitData, 'page-visit-log'); console.log('用户访问信息已记录'); } catch (error) { console.error('发送用户访问信息失败:', error); } } }};</script>// src/router/index.jsimport { getUserDataCollector } from '@/utils/userDataCollector';const router = new VueRouter({ routes: [ // 路由配置 ]});// 路由守卫中收集页面访问数据router.afterEach(async (to, from) => { const collector = getUserDataCollector(); const navigationData = { actionId: to.name || to.path, module: to.meta?.module || 'unknown', userId: store.state.user?.id || 'anonymous', timestamp: Date.now(), fromPage: from.name || from.path, toPage: to.name || to.path }; await collector.sendUserAction(navigationData, 'navigation-log');});export default router;package com.example.api.controller;import com.example.system.bean.ResponseBean;import com.example.service.MessageProducer;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.web.bind.annotation.*;import java.util.UUID;@Slf4j@RestController@RequiredArgsConstructorpublic class DataSyncController { private final MessageProducer messageProducer; @PostMapping("/api/datasync/{topicName}") public ResponseBean syncData(@PathVariable String topicName, @RequestBody String dataJson) { log.info("接收数据同步请求 - 主题:{}, 数据:{}", topicName, dataJson); try { // 数据验证 if (!isValidTopic(topicName)) { return ResponseBean.error("无效的数据主题"); } if (!isValidJson(dataJson)) { return ResponseBean.error("数据格式错误"); } // 发送到消息队列 String messageKey = UUID.randomUUID().toString(); messageProducer.send(topicName, messageKey, dataJson); // 记录统计信息 recordMetrics(topicName, true); return ResponseBean.success(); } catch (Exception e) { log.error("数据同步失败 - 主题:{}, 错误:{}", topicName, e.getMessage(), e); recordMetrics(topicName, false); return ResponseBean.error("数据同步失败"); } } private boolean isValidTopic(String topicName) { // 验证主题名称是否在允许列表中 return topicName.matches("^[a-zA-Z0-9\\-_]+$") && topicName.length() <= 50; } private boolean isValidJson(String json) { // 验证JSON格式 try { // 可以使用Jackson或其他JSON库进行验证 return json != null && !json.trim().isEmpty(); } catch (Exception e) { return false; } } private void recordMetrics(String topicName, boolean success) { // 记录监控指标 // 例如：成功/失败次数、响应时间等 }}package com.example.service;import lombok.extern.slf4j.Slf4j;import org.springframework.stereotype.Service;@Slf4j@Servicepublic class MessageProducer { // 注入Kafka生产者或其他消息队列客户端 public void send(String topic, String key, String message) { try { // 发送到消息队列的具体实现 // kafkaTemplate.send(topic, key, message); log.info("消息已发送 - 主题:{}, 键:{}", topic, key); } catch (Exception e) { log.error("发送消息失败 - 主题:{}, 错误:{}", topic, e.getMessage(), e); throw e; } }}// 前端错误处理class UserDataCollector { async sendData(topic, data, key = null) { try { return await this.sendViaAPI({topic, message: JSON.stringify(data), key}); } catch (error) { // 静默失败，不影响用户体验 this.handleError(error, topic, data); return null; } } handleError(error, topic, data) { // 本地存储失败的数据，后续重试 const failedData = { topic, data, timestamp: Date.now(), error: error.message }; const failures = JSON.parse(localStorage.getItem('failed_data') || '[]'); failures.push(failedData); localStorage.setItem('failed_data', JSON.stringify(failures)); // 定期重试逻辑 this.scheduleRetry(); }}// 批量发送和防抖class UserDataCollector { constructor() { this.buffer = []; this.batchSize = 10; this.flushInterval = 5000; // 5秒 // 定期刷新缓冲区 setInterval(() => this.flush(), this.flushInterval); } async sendData(topic, data, key = null) { // 添加到缓冲区 this.buffer.push({topic, data, key}); // 达到批次大小时立即发送 if (this.buffer.length >= this.batchSize) { await this.flush(); } } async flush() { if (this.buffer.length === 0) return; const batch = this.buffer.splice(0); try { await this.sendBatch(batch); } catch (error) { // 批次发送失败，重新加入缓冲区 this.buffer.unshift(...batch); } }}// 敏感数据处理class UserDataCollector { sanitizeData(data) { const sanitized = {...data}; // 移除敏感字段 delete sanitized.password; delete sanitized.token; // 脱敏处理 if (sanitized.email) { sanitized.email = this.maskEmail(sanitized.email); } if (sanitized.phone) { sanitized.phone = this.maskPhone(sanitized.phone); } return sanitized; } maskEmail(email) { const [name, domain] = email.split('@'); const maskedName = name.charAt(0) + '***' + name.slice(-1); return `${maskedName}@${domain}`; }}// 添加性能监控class UserDataCollector { async sendViaAPI(payload) { const startTime = performance.now(); try { const response = await axios.post(`/api/datasync/${payload.topic}`, payload.message); // 记录成功指标 this.recordMetric('api_call_success', performance.now() - startTime, payload.topic); return response; } catch (error) { // 记录失败指标 this.recordMetric('api_call_failure', performance.now() - startTime, payload.topic); throw error; } } recordMetric(type, duration, topic) { // 发送到监控系统 if (window.performance && window.performance.mark) { window.performance.mark(`${type}_${topic}_${Date.now()}`); } }}@PostMapping("/api/datasync/{topicName}")public ResponseBean syncData(@PathVariable String topicName, @RequestBody String dataJson) { long startTime = System.currentTimeMillis(); try { // 业务逻辑 messageProducer.send(topicName, UUID.randomUUID().toString(), dataJson); // 记录成功指标 recordMetrics("sync_success", System.currentTimeMillis() - startTime, topicName); return ResponseBean.success(); } catch (Exception e) { // 记录失败指标 recordMetrics("sync_failure", System.currentTimeMillis() - startTime, topicName); throw e; }}通过前后端协作的方式收集用户行为数据有以下优势：
这种架构模式在实际项目中得到了广泛应用，能够有效支撑大规模用户行为数据的收集和处理需求。
]]>在现代微服务架构中，服务间的网络调用是不可避免的。然而，网络的不稳定性和外部服务的不可靠性可能导致级联故障，最终影响整个系统的可用性。
为了解决这一问题，熔断器模式（Circuit Breaker Pattern）应运而生，它能够在检测到故障时快速失败，防止故障传播，并提供服务降级的能力。
本文将详细介绍如何实现一个通用的熔断器工具类，并展示其在实际项目中的应用。
熔断器模式的灵感来源于电路中的断路器。当电路中的电流过大时，断路器会自动切断电路，保护电器设备不受损害。
在软件系统中，熔断器同样起到保护作用：
Supplier<T> 接口，支持任意类型的调用封装private static class CircuitBreakerState { private volatile boolean open = false; // 熔断器是否打开 private final AtomicLong startTime = new AtomicLong(0); // 熔断开始时间 private final AtomicLong timeoutCount = new AtomicLong(0); // 超时次数计数 private volatile boolean alertSent = false; // 是否已发送报警 private final String serviceName; // 服务名称 public CircuitBreakerState(String serviceName) { this.serviceName = serviceName; }}这个内部类封装了每个服务的熔断状态，使用 volatile 关键字确保状态变更的可见性，AtomicLong 保证计数的原子性。
public static class CircuitBreakerConfig { private final int timeoutThresholdMs; // 超时阈值（毫秒） private final long circuitBreakerDurationMs; // 熔断持续时间（毫秒） private final int failureThreshold; // 失败次数阈值 public static CircuitBreakerConfig defaultConfig() { return new CircuitBreakerConfig(30000, 10 * 60 * 1000, 1); }}配置类采用不可变设计，提供默认配置的同时支持自定义参数。
public static String executeWithCircuitBreaker(String serviceName, Supplier<String> httpSupplier, CircuitBreakerConfig config) { CircuitBreakerState state = circuitBreakerStates.computeIfAbsent(serviceName, CircuitBreakerState::new); // 检查熔断状态 if (isCircuitBreakerOpen(state, config)) { log.warn("Circuit breaker is open for service: {}", serviceName); return null; } long startTime = System.currentTimeMillis(); try { String result = httpSupplier.get(); long duration = System.currentTimeMillis() - startTime; // 成功调用后的处理逻辑 if (duration > config.timeoutThresholdMs) { handleTimeout(state, serviceName, duration, config); } else { resetCircuitBreaker(state); } return result; } catch (Exception e) { long duration = System.currentTimeMillis() - startTime; if (duration > config.timeoutThresholdMs) { handleTimeout(state, serviceName, duration, config); } throw e; }}private static boolean isCircuitBreakerOpen(CircuitBreakerState state, CircuitBreakerConfig config) { if (!state.open) { return false; } long currentTime = System.currentTimeMillis(); long elapsedTime = currentTime - state.startTime.get(); // 检查是否到达自动恢复时间 if (elapsedTime >= config.circuitBreakerDurationMs) { log.info("Circuit breaker timeout period elapsed for service: {}", state.serviceName); resetCircuitBreaker(state); return false; } return true;}private static void handleTimeout(CircuitBreakerState state, String serviceName, long duration, CircuitBreakerConfig config) { long timeouts = state.timeoutCount.incrementAndGet(); log.warn("HTTP request timeout for service: {}, duration: {}ms, timeout count: {}", serviceName, duration, timeouts); if (timeouts >= config.failureThreshold) { triggerCircuitBreaker(state, serviceName); }}private static void triggerCircuitBreaker(CircuitBreakerState state, String serviceName) { state.open = true; state.startTime.set(System.currentTimeMillis()); log.error("Circuit breaker OPENED for service: {}", serviceName); if (!state.alertSent) { state.alertSent = true; sendAlert(serviceName, state.timeoutCount.get()); }}最简单的使用方式，采用默认配置（30 秒超时，10 分钟熔断，1 次失败即触发）：
String result = CircuitBreakerUtils.executeWithCircuitBreaker( "user-service", // 服务标识 () -> HttpClientUtils.httpPost("http://user-service/api/user", userJson));if (result == null) { // 熔断器打开，执行降级逻辑 return getDefaultUserInfo();}根据不同服务的特性，可以自定义熔断参数：
// AI推理服务通常需要更长的处理时间CircuitBreakerConfig aiConfig = new CircuitBreakerConfig( 60000, // 60秒超时阈值 15 * 60 * 1000, // 15分钟熔断时间 3 // 失败3次后熔断);String aiResult = CircuitBreakerUtils.executeWithCircuitBreaker( "ai-inference-service", () -> HttpClientUtils.httpPost("http://ai-service/infer", inputData), aiConfig);将现有的 HTTP 调用代码进行简单改造：
// 改造前String response = HttpClientUtils.httpPost(url, jsonRequest);// 改造后String response = CircuitBreakerUtils.executeWithCircuitBreaker( "external-api", () -> HttpClientUtils.httpPost(url, jsonRequest));在批量调用场景下，每个服务都可以独立熔断：
public void processBatch(List<String> urls) { for (int i = 0; i < urls.size(); i++) { final String url = urls.get(i); final String serviceName = "batch-service-" + i; String result = CircuitBreakerUtils.executeWithCircuitBreaker( serviceName, () -> HttpClientUtils.httpGet(url) ); if (result != null) { processSingleResult(result); } else { log.warn("Service {} is circuit-broken, skipping", serviceName); } }}// 检查特定服务的熔断状态boolean isOpen = CircuitBreakerUtils.isCircuitBreakerOpen("user-service");// 打印所有服务的熔断状态CircuitBreakerUtils.printCircuitBreakerStatus();// 手动重置熔断器（例如在服务修复后）CircuitBreakerUtils.resetCircuitBreaker("user-service");当熔断器被触发时，系统会自动发送报警信息：
【熔断器告警】服务接口超时熔断服务名称: user-service超时次数: 3熔断时间: 10分钟触发时间: 2026-01-08 17:30:15private static List<ForbiddenURL> processBatch(List<String> urls) { String requestJson = buildRequestJson(urls); String responseJson = CircuitBreakerUtils.executeWithCircuitBreaker( "url-data-query", () -> HttpClientUtils.httpPost(URL_DATA_QUERY, requestJson) ); if (StringUtils.isBlank(responseJson)) { log.warn("URL query service unavailable, returning empty result"); return new ArrayList<>(); } return parseResponse(responseJson);}public String queryDatabase(String sql) { return CircuitBreakerUtils.executeWithCircuitBreaker( "database-proxy", () -> { // 可能的慢查询 return httpClient.post("/database/query", sql); }, new CircuitBreakerConfig(45000, 5 * 60 * 1000, 2) // 45秒超时，5分钟熔断 );}public PaymentResult processPayment(PaymentRequest request) { String result = CircuitBreakerUtils.executeWithCircuitBreaker( "payment-gateway", () -> paymentGateway.charge(request) ); if (result == null) { // 支付网关不可用，记录订单并稍后重试 return PaymentResult.pending("Payment gateway temporarily unavailable"); } return parsePaymentResult(result);}每个服务只维护一个 CircuitBreakerState 对象，内存占用极小。使用 ConcurrentHashMap 进行状态管理，在服务数量不多的情况下，性能开销可以忽略不计。
volatile 确保状态变更的可见性AtomicLong 进行无锁的原子操作ConcurrentHashMap 提供线程安全的服务映射// 对于高频调用，可以预先创建配置对象private static final CircuitBreakerConfig HIGH_FREQ_CONFIG = new CircuitBreakerConfig(5000, 2 * 60 * 1000, 2);// 避免在循环中重复创建配置public void batchProcess(List<Request> requests) { for (Request req : requests) { CircuitBreakerUtils.executeWithCircuitBreaker( "batch-service", () -> processRequest(req), HIGH_FREQ_CONFIG // 复用配置对象 ); }}// 可以扩展支持基于错误率的熔断public enum CircuitBreakerStrategy { TIMEOUT_BASED, // 基于超时 ERROR_RATE_BASED, // 基于错误率 RESPONSE_TIME_BASED // 基于响应时间}// 集成Micrometer进行度量private static void recordMetrics(String serviceName, long duration, boolean success) { Timer.Sample sample = Timer.start(meterRegistry); sample.stop(Timer.builder("http.request") .tag("service", serviceName) .tag("success", String.valueOf(success)) .register(meterRegistry));}// 支持CompletableFuturepublic static <T> CompletableFuture<T> executeAsync(String serviceName, Supplier<CompletableFuture<T>> asyncSupplier) { // 异步熔断器实现}// 推荐的服务命名方式"user-service" // 简单服务"payment-gateway-alipay" // 区分不同的支付网关"database-read-replica" // 区分读写数据库public UserInfo getUserInfo(String userId) { String result = CircuitBreakerUtils.executeWithCircuitBreaker( "user-service", () -> userServiceClient.getUser(userId) ); if (result == null) { // 多级降级策略 // 1. 尝试从缓存获取 UserInfo cached = cacheService.getUser(userId); if (cached != null) return cached; // 2. 返回默认用户信息 return UserInfo.defaultUser(); } return parseUserInfo(result);}本文介绍的熔断器工具类具有以下优势：
通过合理使用熔断器模式，可以显著提高微服务架构的稳定性和可用性。在实际应用中，建议结合业务特点选择合适的配置参数，并制定完善的降级策略，以确保在外部服务不可用时，系统仍能提供基本的服务能力。
熔断器只是微服务容错的手段之一，在实际项目中，还应该配合重试机制、超时控制、限流器等措施，构建完整的容错体系。
]]>特别是当需要根据另一张表中相关字段的值来更新数据时，使用 SQL 的关联更新（JOIN）功能可以大大简化这一过程。
下面，我们将探讨如何使用 SQL 语句进行表的关联更新。
假设我们有两张表：
这两张表都有一个共同的字段 model_id，我们希望根据表 A 中的 model_name 更新表 B 中的 model_name。
以下是一个 SQL 语句示例，展示如何通过关联来更新表 B 的 model_name 字段：
UPDATE table_b AS bJOIN table_a AS aON b.model_id = a.model_idSET b.model_name = a.model_nameWHERE b.model_id IS NOT NULL; -- 可选条件，确保 model_id 不为空UPDATE 来指定需要更新的表（在本例中为 table_b）。JOIN 语句将表 A 和表 B 关联起来，基于共同的字段 model_id。SET 指定需要更新的字段，将表 B 的 model_name 更新为表 A 的 model_name。model_id 不为空的记录。在执行更新操作之前，建议采取以下步骤：
备份数据: 确保在进行大规模更新之前备份重要数据，以防止数据丢失。
验证更新: 在更新之前，可以通过一个 SELECT 查询来验证将要更新的数据。例如：
SELECT b.model_id, b.model_name, a.model_nameFROM table_b AS bJOIN table_a AS aON b.model_id = a.model_id;这将帮助您查看即将被更新的记录，以确保更新操作的准确性。
通过 SQL 的关联更新功能，我们可以高效地根据另一张表的字段值更新数据。
这种方法在处理大量数据时尤其有效，可以节省时间并减少手动更新的错误。
希望本指南能帮助您更好地理解 SQL 关联更新的使用。
]]>Python 提供了一个便捷的方法来实现这一点，但随着 Python 2 和 Python 3 的语法差异，实现方式略有不同。
本文将介绍如何在 Python 2 和 Python 3 中创建一个简单的 HTTP 服务器。
在 Python 2 中，我们可以使用 SimpleHTTPServer 模块来创建一个基本的 HTTP 服务器。以下是实现方法：
python -m SimpleHTTPServer 9000这个命令会在当前目录启动一个 HTTP 服务器，监听 9000 端口。
Python 3 对模块进行了重组，SimpleHTTPServer 被整合到了 http.server 模块中。使用以下命令：
python -m http.server 9000这个命令同样会在当前目录启动一个 HTTP 服务器，监听 9000 端口。
为了方便使用，我们可以创建一个脚本，它能够自动检测 Python 版本并使用相应的方法启动服务器：
#!/usr/bin/env pythonimport sysdef start_server(port=9000): try: if sys.version_info[0] < 3: # Python 2 import SimpleHTTPServer import SocketServer Handler = SimpleHTTPServer.SimpleHTTPRequestHandler httpd = SocketServer.TCPServer(("", port), Handler) print("Serving on port %s (Python 2)" % port) httpd.serve_forever() else: # Python 3 import http.server import socketserver Handler = http.server.SimpleHTTPRequestHandler with socketserver.TCPServer(("", port), Handler) as httpd: print("Serving on port %s (Python 3)" % port) httpd.serve_forever() except KeyboardInterrupt: print("\nServer stopped.")if __name__ == "__main__": start_server()将此脚本保存为 simple_server.py，然后可以通过以下方式运行：
python simple_server.py这个脚本会自动检测 Python 版本并使用适当的方法启动服务器，默认端口为 9000。
通过这种方法，无论您使用的是 Python 2 还是 Python 3，都可以快速启动一个简单的 HTTP 服务器，方便进行开发测试或文件共享。
希望这个教程对您有所帮助！如果您有任何疑问，欢迎在评论区留言。
]]>Spring Boot 提供了多种方法来实现流式输出，使得服务器可以逐步向客户端发送数据，而不是等待整个响应准备就绪。
本文将介绍 5 种在 Spring Boot 中实现流式输出的方法，从传统的 Server-Sent Events (SSE) 到更现代的响应式编程方法。
五种流式输出方法的主要优缺点：
| 方法 | 优点 | 缺点 |
|---|---|---|
| SseEmitter | ・支持 SSE，适合实时数据流・客户端易处理事件流・长连接，减少网络开销 | ・仅支持文本数据・部分旧浏览器可能不支持 SSE |
| ResponseBodyEmitter | ・支持二进制数据流・灵活性高，可发送不同类型数据 | ・客户端需自行处理数据流・可能需额外客户端逻辑解析数据 |
| DeferredResult | ・支持异步处理・可一次性返回所有数据 | ・不支持实时流式传输・可能占用较多服务器内存 |
| Flux | ・支持响应式编程・非阻塞式，效率高・支持背压・易于处理错误和异常 | ・需要响应式编程知识・可能增加系统复杂性 |
| AsyncContext | ・直接操作底层 Servlet API，控制力强・可处理大量并发请求 | ・代码复杂度较高・错误处理相对困难・不如高级抽象易用 |
Server-Sent Events (SSE) 是一种允许服务器向客户端推送数据的技术。Spring 框架提供了 SseEmitter 类来简化 SSE 的实现。
@PostMapping(value = "/chatStream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)public SseEmitter chatStream(@RequestBody @Validated GetAiAuditRequest dto, HttpServletResponse response) { SseEmitter emitter = new SseEmitter(-1L); // 设置无超时 response.setContentType("text/event-stream"); response.setCharacterEncoding("UTF-8"); CompletableFuture.runAsync(() -> { try { TestClass.invoke(dto.getPrompt(), chunk -> { try { emitter.send(chunk); } catch (Exception e) { log.error("Error sending SSE event", e); } }); } catch (Exception e) { emitter.completeWithError(e); } finally { emitter.complete(); } }, asyncExecutor); return emitter;}这种方法使用 SseEmitter 来发送事件流，适合需要实时更新的场景。
有时候，我们可能需要使用不同的内容类型，但仍然希望保持类似 SSE 的行为。这时可以使用 ResponseBodyEmitter。
@PostMapping(value = "/chatStream2", produces = MediaType.APPLICATION_OCTET_STREAM_VALUE)public ResponseBodyEmitter chatStream2(@RequestBody @Validated GetAiAuditRequest dto, HttpServletResponse response) { ResponseBodyEmitter emitter = new ResponseBodyEmitter(-1L); response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE); response.setCharacterEncoding("UTF-8"); CompletableFuture.runAsync(() -> { try { TestClass.invoke(dto.getPrompt(), chunk -> { try { String sseFormattedData = "data:" + chunk + "\n\n"; emitter.send(sseFormattedData.getBytes(StandardCharsets.UTF_8), MediaType.APPLICATION_OCTET_STREAM); } catch (Exception e) { log.error("Error sending chunk", e); } }); } catch (Exception e) { emitter.completeWithError(e); } finally { emitter.complete(); } }, asyncExecutor); return emitter;}这种方法允许我们使用自定义的内容类型，同时保持类似 SSE 的数据格式。
Spring WebFlux 提供了响应式编程的支持，我们可以使用 Flux 和 ServerSentEvent 来实现流式输出。
@PostMapping(value = "/chatStream3", produces = MediaType.TEXT_EVENT_STREAM_VALUE)public Flux<ServerSentEvent<String>> chatStream3(@RequestBody @Validated GetAiAuditRequest dto) { return Flux.<ServerSentEvent<String>>create(sink -> { TestClass.invoke(dto.getPrompt(), chunk -> { sink.next(ServerSentEvent.<String>builder() .data(chunk) .build()); }); sink.complete(); }).subscribeOn(Schedulers.fromExecutor(asyncExecutor)) .onErrorResume(e -> { log.error("Error in chatStream3", e); return Flux.just(ServerSentEvent.<String>builder() .data("Error: " + e.getMessage()) .build()); });}这种方法利用了响应式编程的特性，提供了更好的背压处理和资源管理。
有时我们可能不需要完整的 SSE 格式，只需要直接输出数据流。这时可以使用 Flux 直接输出数据。
@PostMapping(value = "/chatStream4", produces = MediaType.TEXT_EVENT_STREAM_VALUE)public Flux<Object> chatStream4(@RequestBody @Validated GetAiAuditRequest dto) { return Flux.create(sink -> { TestClass.invoke(dto.getPrompt(), chunk -> { sink.next(chunk); sink.next("\n"); // 添加换行符以确保立即刷新 }); sink.complete(); }).subscribeOn(Schedulers.fromExecutor(asyncExecutor)) .onErrorResume(e -> { log.error("Error in chatStream4", e); return Flux.just("Error: " + e.getMessage(), "\n"); });}这种方法更加灵活，允许我们自定义输出格式。
最后，我们可以使用传统的 Servlet API 来实现流式输出，这种方法提供了最大的灵活性。
@PostMapping(value = "/chatStream5", produces = MediaType.TEXT_EVENT_STREAM_VALUE)public void chatStream5(@RequestBody @Validated GetAiAuditRequest dto, HttpServletRequest request, HttpServletResponse response) throws IOException { AsyncContext asyncContext = request.startAsync(); asyncContext.setTimeout(0); // 无超时 response.setContentType("text/event-stream"); response.setCharacterEncoding("UTF-8"); asyncExecutor.execute(() -> { try { PrintWriter writer = response.getWriter(); TestClass.invoke(dto.getPrompt(), chunk -> { try { writer.write("data:" + chunk + "\n\n"); writer.flush(); } catch (Exception e) { log.error("Error writing chunk", e); } }); } catch (Exception e) { log.error("Error in chat stream", e); } finally { asyncContext.complete(); } });}这种方法使用 AsyncContext 和 PrintWriter 直接写入响应，提供了最大的控制权。
curl -X POST \ -H "Accept: text/event-stream" \ -H "Cache-Control: no-cache" \ -H "Connection: keep-alive" \ -H "Content-Type: application/json" \ -d '{"prompt":"What is public in Java?"}' \ --no-buffer \ http://127.0.0.1/view/data/chatStream | \sed 's/^data://; s/#￥#/\n/g' | tr -d '\n'curl -X POST \ -H "Accept: application/octet-stream" \ -H "Content-Type: application/json" \ -d '{"prompt":"What is public in Java?"}' \ --no-buffer \ http://127.0.0.1/view/data/chatStream2 | \sed 's/^data://; s/#￥#/\n/g' | tr -d '\n'import java.io.BufferedReader;import java.io.InputStreamReader;import java.io.OutputStream;import java.net.HttpURLConnection;import java.net.URL;import java.nio.charset.StandardCharsets;public class SseClientControllerTest { private static final String URL_STRING = "http://127.0.0.1:18083/view/data/chatStream2"; public static void main(String[] args) { try { long startTime = System.currentTimeMillis(); System.out.println((System.currentTimeMillis()-startTime)+"----"+"步骤1: 准备连接SSE端点"); String jsonBody = "{\"prompt\":\"What is public in Java?\"}"; byte[] postData = jsonBody.getBytes(StandardCharsets.UTF_8); URL url = new URL(URL_STRING); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setRequestMethod("POST"); // 如果服务器支持 POST 方式的 SSE if(URL_STRING.endsWith("chatStream2")){ conn.setRequestProperty("Accept", "application/octet-stream"); } else { conn.setRequestProperty("Accept", "text/event-stream"); conn.setRequestProperty("Cache-Control", "no-cache"); conn.setRequestProperty("Connection", "keep-alive"); } conn.setReadTimeout(0); // 无限读取超时 conn.setRequestMethod("POST"); conn.setRequestProperty("Content-Type", "application/json"); conn.setRequestProperty("Content-Length", String.valueOf(postData.length)); conn.setDoOutput(true); System.out.println((System.currentTimeMillis()-startTime)+"----"+"步骤2: 发送POST请求到SSE端点"); try (OutputStream os = conn.getOutputStream()) { os.write(postData); } System.out.println((System.currentTimeMillis()-startTime)+"----"+"步骤3: 收到响应，状态码: " + conn.getResponseCode()); if (conn.getResponseCode() != HttpURLConnection.HTTP_OK) { throw new RuntimeException("HTTP error! status: " + conn.getResponseCode()); } System.out.println((System.currentTimeMillis()-startTime)+"----"+"步骤4: 开始读取SSE流"); try (BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()))) { String line; while ((line = reader.readLine()) != null) { if (!line.isEmpty()) { System.out.print(line.replace("data:","").replace("#￥#","\n")); } } } System.out.println((System.currentTimeMillis()-startTime)+"----"+"步骤6: SSE流结束"); } catch (Exception e) { System.err.println("发生错误: " + e.getMessage()); e.printStackTrace(); } }}这五种方法展示了 Spring Boot 中实现流式输出的不同方式，从传统的 SSE 到现代的响应式编程。选择哪种方法取决于你的具体需求，如性能要求、兼容性考虑、以及与现有代码的集成等因素。无论选择哪种方法，流式输出都能显著提升实时数据处理和长时间运行任务的用户体验。
在实际应用中，记得要考虑错误处理、资源管理和性能优化。同时，客户端的实现也需要相应地调整以正确处理这些流式数据。
希望这篇文章能帮助你在 Spring Boot 项目中实现高效的流式输出！
]]>行为特征：
适用场景： 只需要一个可用的内网 IP，对具体是哪个网段不敏感
/** * 获取本地内网IP地址 * @return 本地内网IP地址 */public static String getLocalIntranetIp() { try { Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces(); while (networkInterfaces.hasMoreElements()) { NetworkInterface networkInterface = networkInterfaces.nextElement(); // 跳过回环接口和非激活接口 if (networkInterface.isLoopback() || !networkInterface.isUp()) { continue; } Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses(); while (inetAddresses.hasMoreElements()) { InetAddress inetAddress = inetAddresses.nextElement(); // 只处理IPv4地址且非回环地址 if (inetAddress instanceof Inet4Address && !inetAddress.isLoopbackAddress()) { String ip = inetAddress.getHostAddress(); // 判断是否为内网IP if (isInnerIP(ip)) { return ip; } } } } } catch (Exception e) { log.error("获取本地内网IP失败", e); } return "127.0.0.1";}行为特征：
适用场景： 需要了解完整网络环境，或让用户选择特定网卡
/** * 获取所有本地内网IP地址 * @return 本地内网IP地址列表 */public static List<String> getAllLocalIntranetIps() { List<String> ipList = new ArrayList<>(); try { Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces(); while (networkInterfaces.hasMoreElements()) { NetworkInterface networkInterface = networkInterfaces.nextElement(); // 跳过回环接口和非激活接口 if (networkInterface.isLoopback() || !networkInterface.isUp()) { continue; } Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses(); while (inetAddresses.hasMoreElements()) { InetAddress inetAddress = inetAddresses.nextElement(); // 只处理IPv4地址且非回环地址 if (inetAddress instanceof Inet4Address && !inetAddress.isLoopbackAddress()) { String ip = inetAddress.getHostAddress(); // 判断是否为内网IP if (isInnerIP(ip)) { ipList.add(ip); } } } } } catch (Exception e) { log.error("获取所有本地内网IP失败", e); } return ipList;}行为特征：
适用场景： 需要一个 "最佳" 的本地 IP，用于服务绑定、日志记录等
/** * 获取首选的本地内网IP（优先级：192.168.x.x > 10.x.x.x > 172.16-31.x.x） * @return 首选的本地内网IP地址 */public static String getPreferredLocalIntranetIp() { List<String> ipList = getAllLocalIntranetIps(); if (ipList.isEmpty()) { return "127.0.0.1"; } // 优先返回192.168网段的IP for (String ip : ipList) { if (ip.startsWith("192.168.")) { return ip; } } // 其次返回10网段的IP for (String ip : ipList) { if (ip.startsWith("10.")) { return ip; } } // 最后返回172.16-31网段的IP for (String ip : ipList) { if (ip.startsWith("172.")) { String[] parts = ip.split("\\."); if (parts.length >= 2) { int secondOctet = Integer.parseInt(parts[1]); if (secondOctet >= 16 && secondOctet <= 31) { return ip; } } } } // 如果都没有，返回第一个 return ipList.get(0);}/** * 获取本地主机名 * @return 本地主机名 */public static String getLocalHostName() { try { return InetAddress.getLocalHost().getHostName(); } catch (UnknownHostException e) { log.error("获取本地主机名失败", e); return "unknown"; }}/** * 获取本地IP和主机名信息 * @return 格式为 "IP(hostname)" 的字符串 */public static String getLocalIpWithHostName() { String ip = getPreferredLocalIntranetIp(); String hostname = getLocalHostName(); return ip + "(" + hostname + ")";}在文件顶部添加这些导入：
import java.net.NetworkInterface;import java.net.Inet4Address;import java.util.Enumeration;import java.util.ArrayList;public static void main(String[] args) { // 获取单个内网IP String localIp = getLocalIntranetIp(); log.info("本地内网IP: {}", localIp); // 获取所有内网IP List<String> allIps = getAllLocalIntranetIps(); log.info("所有本地内网IP: {}", allIps); // 获取首选内网IP String preferredIp = getPreferredLocalIntranetIp(); log.info("首选内网IP: {}", preferredIp); // 获取主机名 String hostname = getLocalHostName(); log.info("本地主机名: {}", hostname); // 获取IP和主机名 String ipWithHostname = getLocalIpWithHostName(); log.info("IP和主机名: {}", ipWithHostname);}这些方法会自动过滤掉回环地址和非内网地址，返回真正的本地内网 IP 地址。getPreferredLocalIntranetIp() 方法按照常用网段的优先级返回最合适的 IP 地址。
第一个内网IP: 192.168.1.100所有内网IP: [192.168.1.100]首选内网IP: 192.168.1.100结果: 三个方法返回相同第一个内网IP: 172.17.0.1 (Docker网桥)所有内网IP: [172.17.0.1, 10.0.2.15, 192.168.1.100]首选内网IP: 192.168.1.100 (优先选择192.168网段)结果: 首选方法返回更合适的IP第一个内网IP: 10.0.1.50 (第一个网卡)所有内网IP: [10.0.1.50, 192.168.100.10, 172.20.0.5]首选内网IP: 192.168.100.10 (优先192.168网段)结果: 首选方法选择了业务网段| 方法 | 适用场景 | 优点 | 缺点 |
|---|---|---|---|
getLocalIntranetIp() | 简单应用，只需一个 IP | 快速、简单 | 可能返回虚拟网络 IP |
getAllLocalIntranetIps() | 网络诊断、用户选择 | 信息完整 | 需要额外处理逻辑 |
getPreferredLocalIntranetIp() | 服务绑定、配置生成 | 智能选择 | 逻辑相对复杂 |
建议： 大多数情况下使用 getPreferredLocalIntranetIp()，它能提供最合适的结果。
PUT your_index/_mapping{ "properties": { "sendTime": { "type": "text", "fields": { "keyword": { "type": "keyword", "ignore_above": 256 } } } }}POST your_index/_update_by_query?refresh=true{ "query": { "match_all": {} }}PUT _index_template/your_template{ "index_patterns": ["your_index_pattern*"], "template": { "mappings": { "properties": { "sendTime": { "type": "text", "fields": { "keyword": { "type": "keyword", "ignore_above": 256 } } } } } }}新的数据会自动应用新 mapping，旧数据保持不变。
更新后验证是否生效：
GET your_index/_mapping/field/sendTime应该看到：
{ "your_index": { "mappings": { "sendTime": { "full_name": "sendTime", "mapping": { "sendTime": { "type": "text", "fields": { "keyword": { "type": "keyword", "ignore_above": 256 } } } } } } }}// 更新mapping后，可以这样排序SortBuilder sortBuilder;try { sortBuilder = SortBuilders.fieldSort("sendTime.keyword").order(SortOrder.DESC);} catch (Exception e) { // 兜底方案 sortBuilder = SortBuilders.fieldSort("_id").order(SortOrder.ASC); log.warn("sendTime.keyword字段不可用，使用_id排序");}_update_by_query 才能生效最安全的方案：先在测试环境验证，确认无问题后再在生产环境执行。
]]>您可以根据实际的 WebSocket 服务器地址进行修改。
<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>WebSocket Test</title> <style> body { font-family: Arial, sans-serif; margin: 20px; } #messages { border: 1px solid #ccc; padding: 10px; width: 300px; height: 200px; overflow-y: scroll; margin-bottom: 10px; } </style></head><body><h2>WebSocket Test Client</h2><div id="messages"></div><input type="text" id="messageInput" placeholder="Enter your message..." /><button id="sendButton">Send</button><script> const serverUrl = 'wss://your_websocket_server_address'; // 替换为您的 WebSocket 服务器地址 const websocket = new WebSocket(serverUrl); const messagesDiv = document.getElementById('messages'); const messageInput = document.getElementById('messageInput'); const sendButton = document.getElementById('sendButton'); websocket.onopen = function(event) { messagesDiv.innerHTML += '<div>Connected to WebSocket server.</div>'; }; websocket.onmessage = function(event) { messagesDiv.innerHTML += '<div>Received: ' + event.data + '</div>'; messagesDiv.scrollTop = messagesDiv.scrollHeight; // 滚动到最新消息 }; websocket.onerror = function(event) { messagesDiv.innerHTML += '<div style="color: red;">Error: ' + event.message + '</div>'; }; websocket.onclose = function(event) { messagesDiv.innerHTML += '<div>Disconnected from WebSocket server.</div>'; }; sendButton.onclick = function() { const message = messageInput.value; if (message) { websocket.send(message); messagesDiv.innerHTML += '<div>Sent: ' + message + '</div>'; messageInput.value = ''; // 清空输入框 } };</script></body></html>替换 WebSocket 服务器地址：
const serverUrl = 'wss://your_websocket_server_address'; 这一行，并将 your_websocket_server_address 替换为您实际的 WebSocket 服务器地址。打开 HTML 文件：
.html 文件中，保存后用浏览器打开。测试 WebSocket：
wss://，请确保您的服务器支持安全的 WebSocket 连接。在 Linux 中，您可以使用 sed 命令来替换文件中的文本。具体来说，如果您想将 monitor-chart.vue 文件中的所有 mychart 替换为 myChart，可以使用以下命令：
sed -i 's/mychart/myChart/g' monitor-chart.vuesed 是一个流编辑器，用于处理文本。-i 选项表示在文件中直接进行修改。s/mychart/myChart/g 是 sed 的替换命令：s 表示替换。mychart 是要被替换的文本。myChart 是替换后的文本。g 表示全局替换，即替换文件中所有出现的 mychart。在执行该命令之前，可以先备份原文件：
cp monitor-chart.vue monitor-chart.vue.bak如果您希望在确认每个替换时手动检查，可以去掉 g，改为：
sed -i 's/mychart/myChart/g' monitor-chart.vue如果您的 mychart 可能在不同的大小写环境中出现，您可能需要使用不区分大小写的选项：
sed -i 's/mychart/myChart/Ig' monitor-chart.vue请根据您的需求选择适合的命令。
]]>同步：$ tar c test-file|nc -q 10 -lp 8899接受：$ nc -w 10 192.168.0.1 8899|tar x这两个命令行使用 tar 和 nc（netcat）工具在网络上进行文件的传输。
以下是对每个命令的详细解析：
$ tar c test-file | nc -q 10 -lp 8899tar c test-file：
tar 是一个用于打包和压缩文件的工具。c 表示创建一个新的 tar 归档。test-file 是要被打包的文件或目录（可以是单个文件，也可以是多个文件或目录，具体取决于实际情况）。| （管道符）：
tar 命令的输出传递给下一个命令。nc -q 10 -lp 8899：
nc（netcat）是一个网络工具，用于读写网络连接。-q 10 表示在发送完数据后，等待 10 秒，然后关闭连接。-l 表示以监听模式运行。-p 8899 指定监听的端口为 8899。这个命令的作用是将 test-file 打包后通过 TCP 协议在本地端口 8899 发送。此命令会一直监听该端口，直到接收到连接并发送完数据。
$ nc -w 10 192.168.0.1 8899 | tar xnc -w 10 192.168.0.1 8899：
nc 用来创建网络连接。-w 10 表示在连接关闭后等待 10 秒。192.168.0.1 是发送请求的目标 IP 地址。8899 是目标端口。| tar x：
tar x 用于解压缩和解包 tar 归档文件。x 表示提取文件。这个命令的作用是连接到 192.168.0.1 的 8899 端口，接收从该端口发送过来的数据流（即 test-file 的 tar 归档），并将其解压到当前目录。
这两个命令组合的作用是通过网络将一个文件（test-file）从一台机器发送到另一台机器。第一台机器使用 tar 打包文件并通过 nc 发送，第二台机器使用 nc 接收数据并通过 tar 解压缩。此操作在文件传输和备份等场景中非常有用。
确保在你的项目中添加了 Spring Retry 依赖：
<dependency> <groupId>org.springframework.retry</groupId> <artifactId>spring-retry</artifactId></dependency>在你的 Spring 配置类中启用重试功能：
import org.springframework.context.annotation.Configuration;import org.springframework.retry.annotation.EnableRetry;@Configuration@EnableRetrypublic class RetryConfig {}为了在触发 JSONException 时暂停两分钟后重新请求，我们可以使用重试机制。以下是修改后的代码：
import org.springframework.retry.annotation.Backoff;import org.springframework.retry.annotation.Retryable;public class FeatureOperate { @Retryable(value = {JSONException.class}, maxAttempts = 2, backoff = @Backoff(delay = 120000)) private boolean insert(params……) { String res = null; try { res = HttpClient4Utils.httpPost(operateUrl, headerMap, paramJson.toJSONString(), Consts.UTF_8); JSONObject jsonObject = JSONObject.parseObject(res); } catch (JSONException e) { log.error("[res]{} [Message]{} [paramJson]{}", res, e.getMessage(), paramJson, e); throw e; // 重新抛出异常，触发重试 } catch (Exception e) { log.error("[res]{} [Message]{} [paramJson]{}", res, e.getMessage(), paramJson, e); } return false; }}主要修改如下：
添加了 @Retryable 注解到方法上：
value = {JSONException.class}: 指定要重试的异常类型。maxAttempts = 2: 设置最大尝试次数为 2（初始尝试 + 1 次重试）。backoff = @Backoff(delay = 120000): 设置重试延迟为 120000 毫秒（2 分钟）。在 catch JSONException 的块中，我们重新抛出异常，以触发重试机制。
这样，当发生 JSONException 时，方法将等待 2 分钟后重新尝试。如果第二次尝试仍然失败，则方法将返回 false。
请注意，这种方法会增加方法的执行时间。如果这是一个对时间敏感的操作，你可能需要考虑其他的错误处理策略。
]]>我们需要在 @RequestBody 的同时，优化参数解析方法，使其能够动态地从请求中读取其他的额外参数，而不需要预先定义固定的字段。
以下是一个改进的方案：
import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface ProcessRequestParams {}RequestBodyWrapper 类来包装原始的请求体：public class RequestBodyWrapper { private final Map<String, Object> body; public RequestBodyWrapper(Map<String, Object> body) { this.body = body; } public Map<String, Object> getBody() { return body; }}import org.springframework.core.Ordered;import org.springframework.core.annotation.Order;import org.springframework.stereotype.Component;import org.springframework.web.filter.OncePerRequestFilter;import org.springframework.web.util.ContentCachingRequestWrapper;import javax.servlet.FilterChain;import javax.servlet.ServletException;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.IOException;@Component@Order(Ordered.HIGHEST_PRECEDENCE)public class ContentCachingFilter extends OncePerRequestFilter { @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { ContentCachingRequestWrapper wrappedRequest = new ContentCachingRequestWrapper(request); filterChain.doFilter(wrappedRequest, response); }}HandlerMethodArgumentResolver：import com.fasterxml.jackson.databind.ObjectMapper;import com.netease.mdas.system.bean.RequestBodyWrapper;import org.springframework.core.MethodParameter;import org.springframework.util.StreamUtils;import org.springframework.web.bind.support.WebDataBinderFactory;import org.springframework.web.context.request.NativeWebRequest;import org.springframework.web.method.support.HandlerMethodArgumentResolver;import org.springframework.web.method.support.ModelAndViewContainer;import org.springframework.web.util.ContentCachingRequestWrapper;import org.springframework.web.util.WebUtils;import javax.servlet.http.HttpServletRequest;import java.io.IOException;import java.nio.charset.StandardCharsets;import java.util.Map;public class RequestBodyWrapperArgumentResolver implements HandlerMethodArgumentResolver { private final ObjectMapper objectMapper; public RequestBodyWrapperArgumentResolver(ObjectMapper objectMapper) { this.objectMapper = objectMapper; } @Override public boolean supportsParameter(MethodParameter parameter) { return parameter.getParameterType().equals(RequestBodyWrapper.class); } @Override public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception { HttpServletRequest nativeRequest = (HttpServletRequest) webRequest.getNativeRequest(); String body = getRequestBody(nativeRequest); if (body != null && !body.isEmpty()) { Map<String, Object> map = objectMapper.readValue(body, Map.class); return new RequestBodyWrapper(map); } return new RequestBodyWrapper(null); } private String getRequestBody(HttpServletRequest request) throws IOException { ContentCachingRequestWrapper wrapper = WebUtils.getNativeRequest(request, ContentCachingRequestWrapper.class); if (wrapper != null) { byte[] buf = wrapper.getContentAsByteArray(); if (buf.length > 0) { return new String(buf, StandardCharsets.UTF_8); } } // 如果不是 ContentCachingRequestWrapper，则直接读取输入流 return StreamUtils.copyToString(request.getInputStream(), StandardCharsets.UTF_8); }}ArgumentResolver：@Configurationpublic class WebMvcConfig implements WebMvcConfigurer { @Autowired private ObjectMapper objectMapper; @Override public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) { resolvers.add(new RequestBodyWrapperArgumentResolver(objectMapper)); }}SearchController：@ApiOperation(value = "邮件列表", notes = "邮件列表,根据条件名模糊查询")@PostMapping("/findList")@ProcessRequestParamspublic ResponseBean findList(@RequestHeader(value = "systemproduct") String orgId, @RequestBody FeedbackSearchVO dto, RequestBodyWrapper wrapper) { // ... 其他代码保持不变 ... dto.setOtherInfoQuery(initOtherInfoQuery(wrapper.getBody())); // ... 其他代码保持不变 ...}initOtherInfoQuery 方法：public static Map<String, List<JSONObject>> initOtherInfoQuery(Map<String, Object> requestBody) { Map<String, List<JSONObject>> otherInfoQuery = new HashMap<>(); for (Map.Entry<String, Object> entry : requestBody.entrySet()) { String key = entry.getKey(); Object value = entry.getValue(); if (value instanceof List) { List<JSONObject> jsonList = new ArrayList<>(); for (Object item : (List<?>) value) { jsonList.add(new JSONObject(item)); } otherInfoQuery.put(key, jsonList); } else { List<JSONObject> jsonList = new ArrayList<>(); jsonList.add(new JSONObject(value)); otherInfoQuery.put(key, jsonList); } } return otherInfoQuery;}这种方法的优点是：
@RequestBody 的正常工作。这个解决方案应该能够处理动态的参数，而不需要在代码中硬编码这些参数名。
]]>查找包含 "aaa" 的文件
grep -rl "aaa" /path/to/directory汇总出现的字符次数：
grep -ro "aaa" /path/to/directory | wc -l将找到的文件名和出现次数汇总在一起：
for file in $(grep -rl "mail" /home/dir/test); do count=$(grep -o "mail" "$file" | wc -l); echo "$file: $count"; done作为在网易近十年的 “老网易”，很乐意做你的求职伙伴！
社招 / 实习均可内推，全程护航助你避开海笔筛选，直连 HR 团队效率拉满！
北京、广州、杭州、上海、成都 等。
网易游戏、网易云音乐、网易有道、网易邮箱、Lofter 等都可以！
包括但不限于 技术、产品、运营、项目管理、市场渠道、销售、内容、电商、教育、职能支持、游戏策划、游戏程序、游戏艺术、游戏测试、人工智能、用户体验及设计、高管、企业服务 等等，总有一款适合你～～
1️⃣ 登录 网易社会招聘官网 :hr.163.com，挑选心仪岗位
2️⃣ 邮箱发我岗位信息（截图 or 链接 or 岗位名称），地址：hellojue#foxmail.com, #替换成 @
3️⃣ 我回复你独属内推邀请海报
4️⃣ 你扫码填信息，并按邮件指引补全简历即完成内推！（简历直达 HR）
✅ 免部分岗位海笔筛选
✅ 直推业务团队，流程加速
✅ 全程跟进进度，可私聊查询状态
✅ 隐私保护（简历仅 HR 可见，零泄露风险）
如果与其他问题，可以随时沟通～～
]]>一个用于启动异步处理的接口，另一个用于查询处理状态和结果的接口。实现异步处理和轮询查询的功能。
@GetMapping("/accountCheck")public ResponseBean accountCheck(@RequestHeader(value = "teamId") String teamId) { List<Account> AccountList = AccountService.findAll(teamId); List<AccountEdit> accountEdits = new LinkedList<>(); for (Account account : AccountList) { AccountEdit accountEdit = AccountService.edit(account.getId()); ResponseBean checkRes = AccountCheckUtils.checkAccount(accountEdit); if (checkRes.isError()) { accountEdit.setAuthParams(checkRes.getMsg()); accountEdits.add(accountEdit); } } String info = "校验完成，共" + accountEdits.size() + "个账号，其中有" + accountEdits.size() + "个账号校验失败！"; return ResponseBean.success(info, accountEdits);}我们可以将这个过程分为两个部分：一个用于启动异步处理的接口，另一个用于查询处理状态和结果的接口。这样可以实现异步处理和轮询查询的功能。以下是优化后的代码：
@Autowiredprivate AccountService AccountService;@Autowired@Qualifier("applicationTaskExecutor")private AsyncTaskExecutor asyncTaskExecutor;private final ConcurrentMap<String, AccountCheckTask> taskMap = new ConcurrentHashMap<>();@GetMapping("/startAccountCheck")public ResponseBean startAccountCheck(@RequestHeader(value = "teamId") String teamId) { String taskId = ActiveInfo.userName()+teamId; List<Account> AccountList = AccountService.findAll(teamId); AccountCheckTask task = new AccountCheckTask(AccountList.size()); taskMap.put(taskId, task); CompletableFuture.runAsync(() -> processAccounts(AccountList, task), asyncTaskExecutor) .thenRun(() -> task.setCompleted(true)); Map<String, Object> response = new HashMap<>(); response.put("taskId", taskId); response.put("totalAccounts", AccountList.size()); return ResponseBean.successMap("",response);}@GetMapping("/getAccountCheckResult")public ResponseBean getAccountCheckResult(@RequestHeader(value = "teamId") String teamId) { String taskId = ActiveInfo.userName()+teamId; AccountCheckTask task = taskMap.get(taskId); if (task == null) { return ResponseBean.error("Task not found"); } Map<String, Object> result = new HashMap<>(); result.put("totalAccounts", task.getTotalAccounts()); result.put("processedAccounts", task.getProcessedAccounts()); result.put("remainingAccounts", task.getRemainingAccounts()); result.put("completed", task.isCompleted()); String statusInfo = "进行中"; if (task.isCompleted()) { statusInfo = "已完成"; } List<AccountEdit> failedAccounts = task.getFailedAccounts(); String info = String.format("账号校验%s（共 %d 个账号）：已检测 %d 个账号，其中有 %d 个账号校验失败！",statusInfo, task.getTotalAccounts(), task.getProcessedAccounts().get(), failedAccounts.size()); result.put("info", info); result.put("failedAccounts", failedAccounts); return ResponseBean.successMap(info,result);}private void processAccounts(List<Account> accounts, AccountCheckTask task) { accounts.stream() .map(account -> AccountService.edit(account.getId())) .forEach(accountEdit -> { try { ResponseBean checkRes = AccountCheckUtils.checkAccount(accountEdit); if (checkRes.isError()) { accountEdit.setAuthParams(checkRes.getMsg()); task.addFailedAccount(accountEdit); } } catch (Exception e) { log.error("Error checking account: " + accountEdit.getId(), e); accountEdit.setAuthParams("检查过程中发生错误: " + e.getMessage()); task.addFailedAccount(accountEdit); } finally { task.incrementProcessedAccounts(); } });}其中
@Datapublic class AccountCheckTask { private final int totalAccounts; private final AtomicInteger processedAccounts = new AtomicInteger(0); private final List<AccountEdit> failedAccounts = new CopyOnWriteArrayList<>(); private volatile boolean completed = false; public AccountCheckTask(int totalAccounts) { this.totalAccounts = totalAccounts; } public void incrementProcessedAccounts() { processedAccounts.incrementAndGet(); } public int getRemainingAccounts() { return totalAccounts - processedAccounts.get(); } public void addFailedAccount(AccountEdit account) { failedAccounts.add(account); }}const [checkStatus, setCheckStatus] = useState(false);const [accountList, setAccountList] = useState([]);const [checkInfo, setCheckInfo] = useState('');const startAccountList = async () => { const { data } = await axios .get('/AccountCheck/startAccountCheck'); let intervalId = null; const fetchData = async () => { const { data } = await axios .get('/AccountCheck/getAccountCheckResult'); setAccountList(data.map.failedAccounts.map(convertToListBean)); setCheckInfo(data.map.info) if(data.map.completed){ setCheckStatus(false) clearInterval(intervalId); } else { setCheckStatus(true) } }; fetchData();// 立即执行一次 // 然后设置定时器 intervalId = setInterval(fetchData, 5000); return () => { if (intervalId) { clearInterval(intervalId); } };};***************************APPLICATION FAILED TO START***************************Description:Field asyncTaskExecutor in xxx...Controller required a single bean, but 2 were found:- applicationTaskExecutor: defined by method 'applicationTaskExecutor' in class path resource [org/springframework/boot/autoconfigure/task/TaskExecutionAutoConfiguration.class]- taskScheduler: defined by method 'taskScheduler' in class path resource [org/springframework/boot/autoconfigure/task/TaskSchedulingAutoConfiguration.class]这个错误表明 Spring 容器中存在多个 AsyncTaskExecutor 的 bean 定义，导致注入冲突。解决这个问题有几种方法：
使用 @Qualifier 注解指定要注入的具体 bean：
在你的 AccountCheckController 类中，将：
@Autowiredprivate AsyncTaskExecutor asyncTaskExecutor;改为：
@Autowired@Qualifier("applicationTaskExecutor")private AsyncTaskExecutor asyncTaskExecutor;在你的配置类中明确定义一个 AsyncTaskExecutor bean：
@Configurationpublic class AsyncConfig { @Bean public AsyncTaskExecutor asyncTaskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(5); executor.setMaxPoolSize(10); executor.setQueueCapacity(25); executor.setThreadNamePrefix("MyAsync-"); executor.initialize(); return executor; }}然后在控制器中使用 @Qualifier 注入这个 bean：
@Autowired@Qualifier("asyncTaskExecutor")private AsyncTaskExecutor asyncTaskExecutor;如果你不需要自定义 AsyncTaskExecutor，可以在 application.properties 或 application.yml 中禁用自动配置：
spring.task.execution.pool.enabled=falsespring.task.scheduling.pool.enabled=false使用 @Primary 注解标记首选的 bean：
在你的配置类中：
@Configurationpublic class AsyncConfig { @Bean @Primary public AsyncTaskExecutor asyncTaskExecutor() { // ... 配置和返回 AsyncTaskExecutor }}如果你确实需要多个 AsyncTaskExecutor，可以考虑使用不同的名称：
@Configurationpublic class AsyncConfig { @Bean public AsyncTaskExecutor myAsyncTaskExecutor() { // ... 配置和返回 AsyncTaskExecutor }}然后在控制器中：
@Autowired@Qualifier("myAsyncTaskExecutor")private AsyncTaskExecutor asyncTaskExecutor;选择最适合你的项目结构和需求的方法。
通常，使用 @Qualifier 或定义一个明确的 bean 是最直接的解决方案。
如果你的项目中确实需要多个 AsyncTaskExecutor，确保它们有不同的名称，并在注入时使用 @Qualifier 指定正确的 bean。
]]>这段代码实现了一个拼音分词和缩写提取的功能。
代码主要部分：
它使用 Trie 结构来高效地匹配最长的有效拼音，从而实现准确的拼音分词。
class TrieNode: def __init__(self): self.children = {} self.is_end = False self.full = ''def insert(root, word, full): node = root for char in word: if char not in node.children: node.children[char] = TrieNode() node = node.children[char] node.is_end = True node.full = fulldef search_longest(root, word): node = root last_match = None for i, char in enumerate(word): if char not in node.children: break node = node.children[char] if node.is_end: last_match = (i, node.full) return last_matchdef extract_initials_and_full(text, trie): result = [] i = 0 while i < len(text): match = search_longest(trie, text[i:]) if match: end, full = match result.append(full) i += end + 1 else: result.append(text[i]) i += 1 return resultdef get_initials(result): return ''.join(item[0] for item in result)initials = ['b', 'p', 'm', 'f', 'd', 't', 'n', 'l', 'g', 'k', 'h', 'j', 'q', 'x', 'zh', 'ch', 'sh', 'r', 'z', 'c', 's', 'y', 'w']finals = [ '', 'a', 'o', 'e', 'i', 'u', 'v', 'ai', 'ei', 'ui', 'ao', 'ou', 'iu', 'ie', 've', 'er', 'an', 'en', 'in', 'un', 'vn', 'ang', 'eng', 'ing', 'ong', 'ia', 'iao', 'ian', 'iang', 'iong', 'ua', 'uo', 'uai', 'uan', 'uang', 'ue', 'van', 've', 'ueng', 'ong', 'iong']valid_pinyin = [ (initial + final, initial[0], initial + final) for initial in initials for final in finals]special_cases = ['a', 'o', 'e', 'i', 'u', 'v', 'ai', 'ei', 'ui', 'ao', 'ou', 'an', 'en', 'er', 'ang', 'eng']valid_pinyin.extend((case, case[0], case) for case in special_cases)pinyin_trie = TrieNode()for pinyin, initial, full in valid_pinyin: insert(pinyin_trie, pinyin, full)test_cases = ["zhongguorenmin", "beijingdaxue", "aiwozhonghua", "qiaoersi", "changsha", "liangjiang", "fangyt"]for case in test_cases: result = extract_initials_and_full(case, pinyin_trie) initials = get_initials(result) print(f"Input: {case}") print(f"Full result: {result}") print(f"Initials: {initials}") print()Input: zhongguorenminFull result: ['zhong', 'guo', 'ren', 'min']Initials: zgrmInput: beijingdaxueFull result: ['bei', 'jing', 'da', 'xue']Initials: bjdxInput: aiwozhonghuaFull result: ['ai', 'wo', 'zhong', 'hua']Initials: awzhInput: qiaoersiFull result: ['qiao', 'er', 'si']Initials: qesInput: changshaFull result: ['chang', 'sha']Initials: csInput: liangjiangFull result: ['liang', 'jiang']Initials: ljInput: fangytFull result: ['fang', 'y', 't']Initials: fyt当一棵二叉树的前序序列和中序序列分别是 ABCDEF 和 BADCEF 时，其后序序列必是？
| A | A | |||||
|---|---|---|---|---|---|---|
| B | B | |||||
| C | C | |||||
| D | D | |||||
| E | E | |||||
| F | F | |||||
| B | A | D | C | E | F |
二叉树的结果为：
在每个节点的后侧画个节点，依次遍历二叉树，即可得到其后序遍历结果：
则其后续遍历是：BDFECA
二叉树：[A,B,C,null,null,D,E,null,null,null,F]
绘制树：https://blog.schwarzeni.com/works/leetcode-binarytree-edit/
]]>axios.request({ url: url, method: "post", responseType: "blob", params: this.queryMap})在使用 Axios 进行 HTTP 请求时，如果 params 包含数组类型的变量，默认情况下，Axios 会将数组参数转换成类似 param[]=value1¶m[]=value2 的形式。
然而，这种默认行为可能与服务器的预期格式不匹配，导致异常。
如果你希望数组参数以其他格式传递，可以使用 paramsSerializer 来自定义序列化过程。
下面是一个示例，展示如何使用 qs 库将数组参数序列化为所需的格式。
qs 库进行自定义序列化首先，确保你已经安装了 qs 库：
npm install qs然后，你可以在 Axios 请求中使用 qs.stringify 方法来自定义参数序列化：
import axios from 'axios';import qs from 'qs';axios.request({ url: url, method: 'post', responseType: 'blob', params: this.queryMap, paramsSerializer: params => { return qs.stringify(params, { arrayFormat: 'repeat' }); }});在 qs.stringify 方法中，arrayFormat 有多种选项，你可以根据需要选择适合你的选项：
- 'indices' (默认): param[0]=value0¶m[1]=value1
- 'brackets': param[]=value0¶m[]=value1
- 'repeat': param=value0¶m=value1
- 'comma': param=value0,value1
例如：
paramsSerializer: params => { return qs.stringify(params, { arrayFormat: 'brackets' });}如果你不想引入额外的库，可以手动实现参数序列化：
function customParamsSerializer(params) { const queryString = Object.keys(params).map(key => { const value = params[key]; if (Array.isArray(value)) { return value.map(val => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join('&'); } else { return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`; } }).join('&'); return queryString;}axios.request({ url: url, method: 'post', responseType: 'blob', params: this.queryMap, paramsSerializer: customParamsSerializer});qs 库import axios from 'axios';import qs from 'qs';axios.request({ url: url, method: 'post', responseType: 'blob', params: this.queryMap, paramsSerializer: params => { return qs.stringify(params, { arrayFormat: 'repeat' }); }});function customParamsSerializer(params) { const queryString = Object.keys(params).map(key => { const value = params[key]; if (Array.isArray(value)) { return value.map(val => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join('&'); } else { return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`; } }).join('&'); return queryString;}axios.request({ url: url, method: 'post', responseType: 'blob', params: this.queryMap, paramsSerializer: customParamsSerializer});通过自定义 paramsSerializer，你可以确保数组类型的请求变量以正确的格式发送，从而避免出现异常。
MySQL 根据账号汇总创建时间最大的的记录：
SELECTws.*FROMaccount_state wsINNER JOIN (SELECTaccount_id,MAX(create_time) AS max_create_timeFROMaccount_stateGROUP BYaccount_id) max_ws ON ws.account_id = max_ws.account_id AND ws.create_time = max_ws.max_create_time