Java需要背的东西|构建系统化知识体系

本文档系统梳理Java开发者必须掌握的核心知识点与高频面试考点,覆盖JVM原理、集合框架、并发编程、Spring生态、设计模式、JDK新特性等关键领域,结合真实代码示例、对比表格、记忆技巧及高频问题解析,助你高效构建知识树,从容应对技术面试与实战挑战。

为什么需要系统化记忆?

Java作为企业级开发的主流语言,其技术生态庞大且演进迅速。仅靠碎片化学习难以应对复杂场景。系统化记忆能建立清晰的知识图谱,提升问题分析与解决能力。例如在JVM调优中,不了解内存模型与GC机制,就无法理解堆外内存泄漏的根源;在Spring事务失效时,若不清楚代理机制与事务传播行为,就难以定位根本原因。

本文采用「核心概念→典型场景→代码验证→易错点警示」的结构化设计,每个模块均包含:
• 必记要点:用简洁语言提炼核心结论
• 原理图解:辅助理解机制本质
• 代码示例:真实可运行的验证案例
• 记忆技巧:谐音/类比/口诀提升记忆效率
• 高频陷阱:结合真实生产问题总结避坑指南

知识体系全景图

知识模块 核心知识点 关联技术 面试权重
JVM 内存模型、GC机制、类加载、调优 性能监控、线上问题排查 ★★★★★
集合框架 List/Map/Set区别、线程安全、源码分析 并发集合、Stream API ★★★★☆
并发编程 线程状态、同步机制、JUC工具、线程池 AQS、CAS、Fork/Join ★★★★★
Spring生态 IOC/AOP、事务、MVC、Boot原理 微服务、Spring Cloud ★★★★★
设计模式 单例、工厂、代理、策略、模板 源码应用、架构设计 ★★★★☆
JDK特性 Lambda、Stream、新日期API、模块化 函数式编程、现代开发 ★★★☆☆

JVM核心知识体系

JVM是Java技术栈的基石,理解其运行机制对性能调优、问题排查至关重要。本模块聚焦内存模型、垃圾回收、类加载三大核心,结合真实案例解析。

内存模型:运行时数据区域

Java虚拟机在执行程序时会将其管理的内存划分为若干数据区域,各区域有特定用途与生命周期:

  • 程序计数器:当前线程所执行的字节码指令地址,线程私有,不会OOM
  • Java虚拟机栈:存储方法帧(栈帧),包含局部变量表、操作数栈等,线程私有
  • 本地方法栈:为Native方法服务,与JVM栈类似
  • Java堆:对象实例存储区,线程共享,是GC主要区域
  • 方法区:存储类信息、常量、静态变量,JDK8后称为元空间(Metaspace)
  • 直接内存:非堆内存,通过DirectByteBuffer操作,受物理内存限制
记忆口诀:
“程序计数器存地址,栈存方法帧私有,堆存对象共享区,方法区存类信息,直接内存是外快”
// 直接内存溢出示例(需JVM参数:-XX:MaxDirectMemorySize=10M) import java.nio.ByteBuffer; public class DirectMemoryOOM { public static void main(String[] args) { ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024); // 分配1MB System.out.println("Direct memory allocated"); } }

当直接内存超过限制时,抛出:java.lang.OutOfMemoryError: Direct buffer memory,常因未调用 Cleaner释放或GC未触发导致。

垃圾回收机制

对象存活判定

  • 引用计数法:简单但无法解决循环引用问题(主流JVM未采用)
  • 可达性分析法:从GC Roots出发,不可达则标记为垃圾

GC Roots包括:

  • 虚拟机栈中引用的对象(本地变量表)
  • 方法区中类静态属性引用的对象
  • 方法区中常量引用的对象
  • 本地方法栈中Native方法引用的对象

垃圾回收算法

算法 原理 优点 缺点
标记-清除 标记→清除 基础算法 产生内存碎片
复制算法 复制到新区域 无碎片,高效 内存浪费(需双倍空间)
标记-整理 标记→移动→整理 无碎片,内存利用率高 整理过程耗时

分代收集理论

现代JVM(如HotSpot)采用分代收集:年轻代(Eden+S0+S1)、老年代、元空间

  • Minor GC:年轻代回收,触发频率高
  • Major GC / Full GC:老年代/元空间回收,耗时长
典型问题:Full GC频繁的排查思路
1. 查看GC日志:使用-Xlog:gc*参数
2. 检查老年代增长速率
3. 分析大对象直接进入老年代(-XX:PretenureSizeThreshold)
4. 检查长期存活对象晋升(-XX:MaxTenuringThreshold)
JDK 1.2

引入软引用(SoftReference)、弱引用(WeakReference)、虚引用(PhantomReference)

JDK 7

字符串常量池从方法区移入Java堆

JDK 8

永久代(PermGen)被元空间(Metaspace)取代,使用本地内存

JDK 11+

引入ZGC与Shenandoah低延迟GC,停顿时间≤10ms

集合框架深度解析

Java集合框架是高频考点,理解其设计思想与实现差异是写出高效代码的基础。本模块聚焦核心容器类的原理、使用场景与陷阱。

List实现类对比

ArrayList与LinkedList是List的两大核心实现,选择不当将导致性能问题:

特性 ArrayList LinkedList Vector
底层结构 动态数组 双向链表 动态数组(线程安全)
随机访问 O(1)(快) O(n)(慢) O(1)
插入/删除 O(n)(需移动) O(1)(链表节点) O(n)
内存占用 低(仅存储元素) 高(需存储前后指针) 高
线程安全 否 否 是(方法同步)
记忆要点:
• ArrayList:适合频繁读取、尾部插入的场景
• LinkedList:适合频繁头/中间插入/删除的场景
• Vector:已过时,推荐用Collections.synchronizedList或CopyOnWriteArrayList
// ArrayList扩容机制演示 ArrayList list = new ArrayList<>(); list.add("A"); // 容量10 // 添加第11个元素时,容量扩展为原1.5倍((oldCapacity * 3) / 2 + 1)

Map实现类深度分析

HashMap是Java最常用的Map实现,其JDK8的优化是面试高频点:

  • 数组+链表+红黑树:当链表长度≥8且数组长度≥64时转红黑树
  • 树化阈值为何是8?:根据泊松分布,哈希冲突达到8的概率极低(0.00000006),避免过度树化
  • 扩容机制:容量必须是2的幂次,确保index = hash & (n-1)等效于hash % n
  • 线程不安全:多线程下可能形成环形链表(JDK8已修复此问题,但仍有数据丢失风险)
经典陷阱:
问题:HashMap允许null键值,但仅允许一个null键
原因:调用put时,null键直接进入数组索引0位置,覆盖旧值
解决方案:使用ConcurrentHashMap或LinkedHashMap(需明确需求)
// HashMap null键处理示例 Map map = new HashMap<>(); map.put(null, "value1"); // 索引0位置 map.put(null, "value2"); // 覆盖旧值 System.out.println(map.get(null)); // 输出"value2"

Set实现类特性

Set是无序不重复集合,底层依赖Map实现:

  • HashSet:基于HashMap,元素作为key存储
  • LinkedHashSet:维护插入顺序(HashMap + 双向链表)
  • TreeSet:基于TreeMap,元素自然排序或自定义比较器
TreeSet排序原理:
• 实现Comparable接口:调用compareTo比较
• 传入Comparator:优先使用比较器
• 两者混用:抛出ClassCastException

线程安全集合

集合类型 实现方式 适用场景 性能特点
Vector 方法级同步 旧版代码兼容 低(锁粒度大)
Collections.synchronizedList 包装类同步 简单场景 中等(需手动迭代加锁)
CopyOnWriteArrayList 写时复制 读多写少(如监听器) 写性能差,读无锁
ConcurrentHashMap 分段锁/CAS 高并发Map操作 高(JDK8优化)
CopyOnWriteArrayList原理:
• 写操作:加锁 → 复制新数组 → 修改 → 替换引用
• 读操作:无锁 → 直接读旧数组(弱一致性)
典型应用:Spring的ApplicationListener注册机制

并发编程核心机制

并发编程是Java的难点与重点,涉及线程管理、同步机制、并发工具等。本模块结合源码分析与实战案例,深入讲解核心原理。

线程生命周期

Java线程有6种状态(Thread.State):

状态 触发条件 转换说明
NEW 线程创建后未启动 调用start()进入RUNNABLE
RUNNABLE 运行中或就绪状态 等待CPU时间片或正在执行
BLOCKED 等待synchronized锁 锁释放后进入RUNNABLE
WAITING 调用wait()/join()/LockSupport.park 需其他线程唤醒(notify/unpark)
TIMED_WAITING 调用sleep()/wait(timeout)等 超时后自动恢复
TERMINATED 线程执行完毕 不可逆状态
面试陷阱:
问题:调用run()方法会启动新线程吗?
答案:不会!run()只是普通方法调用,必须通过start()启动新线程

同步机制对比

synchronized与ReentrantLock是两大核心同步工具,选择依据如下:

特性 synchronized ReentrantLock
获取方式 隐式(字节码monitorenter) 显式(lock/unlock)
可中断 否 是(lockInterruptibly)
超时 否 是(tryLock(timeout))
公平性 非公平 可配置(构造参数)
条件变量 Object.wait/notify Condition(支持多等待队列)
// ReentrantLock条件变量示例 Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); lock.lock(); try { condition.await(); // 等待 condition.signal(); // 唤醒单个线程 } finally { lock.unlock(); }
原理对比:
• synchronized底层通过monitor对象实现
• ReentrantLock依赖AQS(AbstractQueuedSynchronizer),通过CAS与CLH队列管理线程

JUC核心工具类

1. CountDownLatch

倒计时器,用于等待多个线程完成任务:

// 示例:主线程等待3个子线程完成 CountDownLatch latch = new CountDownLatch(3); for (int i = 0; i < 3; i++) { new Thread(() -> { // 业务逻辑 latch.countDown(); // 计数减1 }).start(); } latch.await(); // 阻塞直到计数为0 System.out.println("所有子线程完成");

2. CyclicBarrier

循环屏障,用于多线程等待到达屏障点后一起继续:

CyclicBarrier barrier = new CyclicBarrier(3, () -> { System.out.println("所有线程到达屏障点"); }); for (int i = 0; i < 3; i++) { new Thread(() -> { // 业务逻辑 barrier.await(); // 等待其他线程 }).start(); }

3. Semaphore

信号量,控制并发线程数:

Semaphore semaphore = new Semaphore(2); // 仅允许2个线程同时访问 for (int i = 0; i < 5; i++) { new Thread(() -> { try { semaphore.acquire(); // 获取许可 // 业务逻辑 } finally { semaphore.release(); // 释放许可 } }).start(); }
记忆口诀:
"CountDownLatch倒着数,CyclicBarrier一起走,Semaphore管并发数"
JDK 1.5

引入JUC包,奠定现代并发编程基础

JDK 7

新增Fork/Join框架,支持工作窃取算法

JDK 8

引入CompletableFuture,支持异步编程

JDK 19+

虚拟线程(Virtual Threads)进入预览,提升高并发性能

Spring核心机制

Spring作为Java生态的基石,其IOC/AOP/事务机制是面试必考内容。本模块深入原理,结合源码与实战场景解析。

IOC容器原理

IOC(控制反转)通过依赖注入(DI)实现解耦,核心流程如下:

  1. Resource定位:加载配置文件(XML/注解/Java Config)
  2. BeanDefinition加载:解析配置为BeanDefinition
  3. BeanDefinition注册:注册到BeanDefinitionRegistry
  4. Bean实例化:通过反射创建对象
  5. 依赖注入:填充属性值与依赖
  6. 初始化:执行InitializingBean/自定义init-method
  7. 销毁:执行DisposableBean/自定义destroy-method
// 典型配置方式 @Configuration public class AppConfig { @Bean public UserService userService() { return new UserService(); // 等同于XML的 } }
面试要点:
• Spring如何解决循环依赖?
→ 三级缓存(singletonObjects/earlySingletonObjects/singletonFactories)
• 为什么单例Bean需要构造器注入?
→ 避免循环依赖时依赖注入顺序问题

AOP实现原理

AOP(面向切面编程)通过动态代理实现横切逻辑,核心组件:

  • Joinpoint(连接点):程序执行点(方法调用/异常抛出)
  • Pointcut(切点):定位Joinpoint的表达式
  • Advice(通知):在Joinpoint执行的操作
  • Aspect(切面):Pointcut + Advice的组合
代理方式 实现原理 限制 性能
JDK动态代理 基于接口代理 目标类必须实现接口 高
CGLIB代理 继承目标类生成子类 不能代理final类/方法 中(需字节码生成)
Spring AOP默认策略:
• 实现接口 → JDK动态代理
• 无接口 → CGLIB代理
• 强制CGLIB:配置@EnableAspectJAutoProxy(proxyTargetClass = true)

事务管理机制

事务传播行为

传播行为 说明 典型场景
REQUIRED 有事务则加入,否则新建 默认行为
REQUIRES_NEW always新建事务 独立日志记录
NESTED 嵌套事务(Savepoint) 部分回滚
SUPPORTS 有事务则用,否则非事务 只读操作

事务失效的8大坑

  • 方法非public(Spring AOP仅代理public方法)
  • 自调用问题(this.method()绕过代理)
  • 异常被catch未抛出
  • 事务传播行为配置错误
  • 数据库引擎不支持事务(如MySQL MyISAM)
  • 未启用事务注解(缺少@EnableTransactionManagement)
  • 异常类型不匹配(默认仅RuntimeException回滚)
  • 多数据源未正确配置事务管理器
// 修复自调用问题:注入自身 @Service public class OrderService { @Autowired private OrderService self; public void createOrder() { self.updateStock(); // 通过代理调用 } }
Spring 1.x

基于XML配置,冗长但灵活

Spring 2.x

引入注解支持,简化配置

Spring Boot 1.x

约定大于配置,快速开发

Spring 6 / Boot 3

全面拥抱JDK 17+,移除过时API

设计模式实战应用

设计模式是解决常见问题的经过验证方案。本模块聚焦Java开发高频使用模式,结合Spring源码解析其应用场景。

单例模式

确保一个类仅有一个实例,提供全局访问点:

// 懒汉式(线程安全) public class Singleton { private static volatile Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } } // 静态内部类(推荐) public class Singleton { private Singleton() {} private static class Holder { private static final Singleton INSTANCE = new Singleton(); } public static Singleton getInstance() { return Holder.INSTANCE; } }
Spring单例作用域:
• bean默认scope为singleton
• 实际是容器级别单例,非JVM级别
• 可通过@Scope("prototype")切换多例

工厂模式

定义创建对象的接口,但让子类决定实例化哪个类:

// 简单工厂 public class FruitFactory { public Fruit createFruit(String type) { switch (type) { case "apple": return new Apple(); case "banana": return new Banana(); default: throw new IllegalArgumentException("Unknown type"); } } } // Spring的BeanFactory ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); UserService service = context.getBean("userService", UserService.class);
Spring工厂模式应用:
• BeanFactory:基础工厂接口
• ApplicationContext:高级容器,支持国际化/事件等
• FactoryBean:自定义复杂对象创建逻辑

代理模式

静态代理 vs 动态代理

类型 实现方式 优缺点
静态代理 手写代理类 简单但代码冗余
JDK动态代理 基于接口 需实现接口,反射调用
CGLIB代理 继承目标类 无接口限制,字节码生成
// Spring AOP代理示例 @Aspect public class LoggingAspect { @Before("execution(* com.example.service.*.*(..))") public void logBefore(JoinPoint joinPoint) { System.out.println("调用方法:" + joinPoint.getSignature()); } }
代理模式在Spring中的应用:
• AOP:事务/日志/安全控制
• 远程调用:RMI代理
• 懒加载:Hibernate延迟加载代理

策略模式

定义一系列算法,将每个算法封装起来,并使它们可以互换:

// 策略接口 public interface DiscountStrategy { double calculate(double amount); } // 具体策略 public class VipDiscount implements DiscountStrategy { public double calculate(double amount) { return amount * 0.8; } } public class NormalDiscount implements DiscountStrategy { public double calculate(double amount) { return amount; } } // 上下文 public class DiscountContext { private DiscountStrategy strategy; public void setStrategy(DiscountStrategy strategy) { this.strategy = strategy; } public double executeStrategy(double amount) { return strategy.calculate(amount); } } // 使用 DiscountContext context = new DiscountContext(); context.setStrategy(new VipDiscount()); double price = context.executeStrategy(100); // 80.0
Spring中的策略模式:
• BeanDefinitionReader:不同配置文件解析策略
• HandlerMapping:请求映射策略
• CharsetResolver:字符集解析策略
GOF 23种模式

1994年《设计模式》出版,奠定基础

Spring 1.0

大量使用工厂/代理/模板模式

Java 8+

函数式接口推动策略模式简化

微服务时代

策略模式在配置中心/路由中广泛应用

JDK新特性精要

Java版本快速迭代,掌握新特性可提升开发效率与代码质量。本模块聚焦Java 8-17核心改进,结合实战场景解析。

Lambda表达式与Stream API

函数式编程核心特性,简化集合操作:

// 传统方式 List names = new ArrayList<>(); for (User user : users) { if (user.getAge() > 18) { names.add(user.getName()); } } // Lambda + Stream List names = users.stream() .filter(u -> u.getAge() > 18) .map(User::getName) .collect(Collectors.toList());
操作类型 示例 说明
中间操作 filter/map/sorted 返回Stream,惰性求值
终止操作 collect/forEach/toArray 触发执行,返回非Stream
并行流 parallelStream() 自动分片处理
性能陷阱:
• 小数据集:串行流更快(分片开销)
• 大数据集:并行流优势明显
• 避免在并行流中使用有状态操作(如collect)

新日期时间API

JDK 8前的Date/Calendar存在线程安全问题,新API基于ISO日历系统:

// 获取当前时间 LocalDate today = LocalDate.now(); LocalTime now = LocalTime.now(); LocalDateTime now = LocalDateTime.now(); // 日期计算 LocalDate nextWeek = today.plusWeeks(1); Period period = Period.between(startDate, endDate); // 格式化 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); String formatted = now.format(formatter);
关键优势:
• 线程安全(Immutable)
• API设计更合理(如Duration/Period区分)
• 支持时区(ZonedDateTime)

Optional类

避免NullPointerException的防御性编程工具:

// 传统方式 String value = null; if (value != null) { System.out.println(value.length()); } // Optional方式 Optional optional = Optional.ofNullable(value); optional.ifPresent(v -> System.out.println(v.length())); // 提供默认值 String result = optional.orElse("default"); String result = optional.orElseGet(() -> "default");
最佳实践:
• 不要将Optional用于字段/参数类型
• 避免调用isPresent()后直接get()
• 优先使用orElseGet()而非orElse()
Java 8

Lambda/Stream/新日期API/Optional

Java 9

模块化系统/JShell/私有接口方法

Java 11

HTTP Client API/本地变量类型推断

Java 17

密封类/模式匹配/禁用SHA-1证书

高频问题深度解析

本模块精选10个高频面试问题,结合真实场景提供深度解答,覆盖原理、陷阱与最佳实践。

⚡ Java内存泄漏的典型场景与排查工具

内存泄漏指无用对象长期占用内存,导致OOM。常见场景:

  • 静态集合持有对象引用:如static List持续添加元素
  • 未关闭资源:InputStream/OutputStream未调用close()
  • 监听器未移除:事件监听器注册后未注销
  • ThreadLocal未清理:线程池中ThreadLocal变量未remove()
// 典型泄漏示例 public class MemoryLeakDemo { private static final List list = new ArrayList<>(); public void addData() { list.add(new byte[1024 * 1024]); // 每次添加1MB } } // 修复方案 public void removeData() { list.clear(); // 或移除具体元素 }

排查工具:
• jmap -dump:format=b,file=heap.hprof [pid]:生成堆转储
• jvisualvm:图形化分析内存占用
• Eclipse MAT:深度分析泄漏对象引用链

⚙️ HashMap在JDK8中的红黑树阈值为何是8?

红黑树阈值设定基于统计学与性能平衡:

  • 泊松分布验证:在理想哈希函数下,链表长度≥8的概率为0.00000006
  • 性能对比:
    • 链表长度<8:链表查找O(n),但无树化开销
    • 链表长度≥8:树查找O(log n),但需维护树结构
  • 退化阈值6:当树节点减少至6时退化为链表,避免频繁转换
源码依据:
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
⚡ synchronized与ReentrantLock的底层差异

核心差异:

维度 synchronized ReentrantLock
获取方式 字节码monitorenter指令 AQS的acquire()方法
锁状态 对象头Mark Word AQS的state变量
锁升级 无锁→偏向锁→轻量级锁→重量级锁 仅重量级锁
性能优化 JVM自动优化(如适应性自旋) 需开发者手动优化

性能趋势:
• JDK 6后synchronized性能大幅提升
• 低竞争场景:synchronized更优(JVM优化)
• 高级功能需求:ReentrantLock更灵活

⚙️ Spring事务失效的8大坑及解决方案

常见失效场景与解决方案:

  1. 方法非public → 改为public或配置proxyTargetClass=true
  2. 自调用问题 → 注入自身或提取到新Service
  3. 异常被catch → catch中重新抛出RuntimeException
  4. 事务传播行为错误 → 明确配置propagation
  5. 数据库引擎不支持 → 检查MySQL表引擎(InnoDB)
  6. 未启用事务注解 → 添加@EnableTransactionManagement
  7. 异常类型不匹配 → 配置rollbackFor=Exception.class
  8. 多数据源配置 → 指定transactionManager
// 修复异常类型 @Transactional(rollbackFor = Exception.class) public void updateData() throws Exception { // 业务逻辑 throw new Exception("test"); // 会回滚 }
⚡ 代理模式在Spring AOP中的三种实现方式

实现方式对比:

方式 原理 适用场景
JDK动态代理 基于接口代理 目标类实现接口
CGLIB代理 继承目标类生成子类 目标类无接口
AspectJ织入 编译期/类加载期织入 复杂切面(如字段拦截)

Spring默认策略:
• 实现接口 → JDK代理
• 无接口 → CGLIB代理
• 强制CGLIB:配置@EnableAspectJAutoProxy(proxyTargetClass = true)

⚙️ Java 8的Stream API性能优化技巧

优化要点:

  • 避免中间操作过多:合并filter/map操作
  • 合理使用并行流:
    • 数据量>1000时考虑parallelStream()
    • 避免在并行流中使用有状态操作
  • 提前终止操作:使用findFirst()/findAny()替代collect()
  • 避免装箱/拆箱:使用IntStream/LongStream
// 性能对比示例 // 低效:多次中间操作 list.stream() .filter(x -> x > 10) .map(x -> x * 2) .filter(x -> x < 100) .collect(Collectors.toList()); // 优化:合并filter条件 list.stream() .map(x -> x * 2) .filter(x -> x > 20 && x < 100) .collect(Collectors.toList());
⚡ 线程池参数如何合理配置?

核心参数:

  • corePoolSize:核心线程数
    • CPU密集型:≈CPU核心数
    • IO密集型:≈CPU核心数 * 2
  • maximumPoolSize:最大线程数
    • 参考公式:CPU核心数 * (1 + IO耗时/计算耗时)
  • keepAliveTime:非核心线程存活时间
  • workQueue:任务队列
    • 有界队列:ArrayBlockingQueue(推荐)
    • 无界队列:LinkedBlockingQueue(防OOM)
生产实践:
• 优先使用有界队列+拒绝策略
• 自定义ThreadFactory设置线程名
• 监控线程池状态(ActiveCount/QueueSize)
⚙️ JVM调优的典型指标与工具

关键指标:

指标 正常范围 优化方向
GC频率 Minor GC:秒级 增加年轻代大小
Full GC耗时 ≤100ms 减少老年代对象晋升
内存使用率 70%~80% 调整堆大小/优化对象生命周期

调优工具:
• jstat -gc [pid] 1000:实时监控GC
• jconsole:图形化监控
• GCEasy.io:在线GC日志分析

⚡ 高并发下如何保证Redis与DB一致性?

一致性方案:

  • 缓存双删策略:
    1. 删缓存
    2. 更新DB
    3. 再删缓存(延时双删)
  • 异步更新缓存:基于Binlog监听
  • 分布式锁:更新时加锁防止并发
推荐方案:
• 读操作:缓存→DB(穿透时查DB)
• 写操作:删缓存→更新DB(保证最终一致性)
⚙️ 微服务架构下的服务治理关键点

核心组件:

  • 注册中心:Eureka/Nacos/ZooKeeper
  • 配置中心:Spring Cloud Config/Nacos
  • 服务网关:Spring Cloud Gateway
  • 熔断限流:Sentinel/Hystrix
  • 链路追踪:Sleuth + Zipkin
// Sentinel熔断规则示例 List rules = new ArrayList<>(); DegradeRule rule = new DegradeRule(); rule.setResource("getUserService"); rule.setGrade(RuleConstant.DEGRADE_GRADE_RT); rule.setCount(500); // RT阈值 rule.setTimeWindow(10); // 熔断时长 rules.add(rule); DegradeRuleManager.loadRules(rules);

©2026 Java需要背的东西 - www.xservx.com

蜀ICP备2026035467号-3