知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# Spring 高频面试题集(45 题) 覆盖 Spring Core、Spring MVC、Spring Boot、Spring Cloud 核心考点。 ## 目录 - [第 1 章 · Spring Core 基础(8 题)](#第-1-章--spring-core-基础) - [第 2 章 · IoC 与 Bean(10 题)](#第-2-章--ioc-与-bean) - [第 3 章 · AOP(6 题)](#第-3-章--aop) - [第 4 章 · 事务(6 题)](#第-4-章--事务) - [第 5 章 · Spring MVC(5 题)](#第-5-章--spring-mvc) - [第 6 章 · Spring Boot(5 题)](#第-6-章--spring-boot) - [第 7 章 · Spring Cloud(5 题)](#第-7-章--spring-cloud) ## 高频 Top 10 1. Spring IoC 和 DI?(1) 2. Bean 生命周期?(11) 3. 循环依赖怎么解决?三级缓存?(12-13) 4. AOP 原理?JDK 代理 vs CGLIB?(19-20) 5. @Transactional 失效的场景?(27) 6. Spring Boot 自动配置原理?(36) 7. Bean 作用域?(14) 8. Bean 线程安全?(15) 9. Spring MVC 请求流程?(31) 10. Spring 用到的设计模式?(8) --- # 第 1 章 · Spring Core 基础 ## 1. Spring IoC 和 DI 是什么? **IoC(Inversion of Control)控制反转**:对象的创建和依赖不再由代码控制,交给 Spring 容器管理。 **DI(Dependency Injection)依赖注入**:IoC 的具体实现手段,容器把依赖"注入"到对象里。 ```java // 传统方式 UserService service = new UserService(); service.setDao(new UserDao()); // IoC + DI @Service public class UserService { @Autowired private UserDao dao; // Spring 自动注入 } ``` **好处**:解耦、可测试性强、配置集中。 ## 2. Spring 核心容器的接口? ``` BeanFactory(基础容器,延迟加载) ↑ ApplicationContext(企业级容器,启动时加载) ├── ClassPathXmlApplicationContext ├── AnnotationConfigApplicationContext └── WebApplicationContext ``` **BeanFactory vs ApplicationContext**: - BeanFactory:懒加载,按需创建 Bean - ApplicationContext:启动时预加载(单例),功能更强(国际化、事件、AOP) ## 3. Spring 常用注解? **IoC**: - `@Component`、`@Service`、`@Repository`、`@Controller`:声明 Bean - `@Autowired`、`@Resource`、`@Inject`:注入 - `@Configuration`、`@Bean`:Java 配置类 - `@ComponentScan`:扫描路径 - `@Primary`、`@Qualifier`:多实现类选择 **AOP**: - `@Aspect`、`@Pointcut`、`@Before`、`@After`、`@Around` **MVC**: - `@Controller`、`@RestController` - `@RequestMapping`、`@GetMapping`、`@PostMapping` - `@RequestParam`、`@PathVariable`、`@RequestBody` - `@ResponseBody`、`@ControllerAdvice`、`@ExceptionHandler` **事务**: - `@Transactional` ## 4. @Autowired 和 @Resource 的区别? | 对比 | @Autowired | @Resource | |------|-----------|-----------| | 来源 | Spring | JSR-250(Java) | | 注入方式 | byType(默认) | byName(默认) | | 是否支持 required | 支持(`required=false`) | 不支持 | | 用途 | 字段、构造器、setter | 字段、setter | **byType 多个实现时**: - `@Autowired` + `@Qualifier("name")` - `@Resource(name = "xxx")` **推荐**: - Spring 项目用 `@Autowired` - 通用 Java 用 `@Resource` ## 5. 构造器注入 vs Setter 注入 vs 字段注入? ```java // 字段注入(最常见,但官方不推荐) @Autowired private UserDao dao; // 构造器注入(推荐) private final UserDao dao; public UserService(UserDao dao) { this.dao = dao; } // Spring 4.3+ 单构造器可省略 @Autowired // Setter 注入 @Autowired public void setDao(UserDao dao) { this.dao = dao; } ``` **构造器注入的好处**: 1. **不可变**:字段可以用 `final` 2. **循环依赖显式**:循环依赖在启动时直接报错,不藏着 3. **便于单元测试**:直接 new 对象传参数 4. **空指针友好**:依赖初始化就保证 **字段注入的问题**: - 不能 final - 测试麻烦(需要反射或 `ReflectionTestUtils`) - 隐藏依赖 ## 6. Spring 用到哪些设计模式? - **单例模式**:Bean 默认 singleton - **工厂模式**:BeanFactory、ApplicationContext - **代理模式**:AOP - **模板方法**:`JdbcTemplate`、`RestTemplate` - **观察者模式**:`ApplicationEvent` 事件机制 - **策略模式**:`Resource` 不同实现(`ClassPathResource`、`FileSystemResource`) - **责任链**:Interceptor - **适配器**:`HandlerAdapter` - **装饰器**:`BeanWrapper` ## 7. Spring 如何解耦? **核心机制**: - **IoC 容器** 管理 Bean 生命周期 - **DI** 把依赖注入到对象里 - **AOP** 把横切关注点分离(日志、事务、安全) 结果:组件间通过接口协作,实现可以替换,便于测试和维护。 ## 8. BeanFactory 和 FactoryBean 的区别? **BeanFactory**:Spring 容器的顶层接口,管理 Bean **FactoryBean**:一种特殊的 Bean,用来**创建复杂对象** ```java public class MyFactoryBean implements FactoryBean<Something> { @Override public Something getObject() { return new Something(); } // 自定义创建逻辑 @Override public Class<?> getObjectType() { return Something.class; } @Override public boolean isSingleton() { return true; } } // 使用 @Autowired Something s; // 拿到 FactoryBean.getObject() 的结果 @Autowired MyFactoryBean factoryBean; // 加 & 前缀拿到 FactoryBean 本身(context.getBean("&myFactoryBean")) ``` **常见用途**:MyBatis 的 `SqlSessionFactoryBean`、Feign 的 `FeignClientFactoryBean`。 --- # 第 2 章 · IoC 与 Bean ## 9. Spring 容器启动的流程? ``` 1. 加载配置(XML / 注解 / Java Config) 2. 扫描包,找到所有候选 Bean → 生成 BeanDefinition 3. BeanDefinition 注册到容器 4. 调用 BeanFactoryPostProcessor 修改 BeanDefinition(比如 @Value 占位符替换) 5. 实例化 Bean:反射 newInstance 6. 填充属性:@Autowired 注入 7. 调用 Aware 接口(BeanNameAware、ApplicationContextAware) 8. 调用 BeanPostProcessor.postProcessBeforeInitialization 9. 调用 init 方法(@PostConstruct / InitializingBean / init-method) 10. 调用 BeanPostProcessor.postProcessAfterInitialization(AOP 代理在这里) 11. Bean 完成初始化,对外提供 12. 容器关闭时调用 destroy(@PreDestroy / DisposableBean / destroy-method) ``` ## 10. BeanDefinition 是什么? Bean 的**元信息描述**(蓝图),不是实际的 Bean。 包含: - class(类名) - scope(单例 / 原型) - 依赖关系 - init / destroy 方法 - 懒加载标志 - ... 容器先解析所有 BeanDefinition,再根据它创建 Bean。 ## 11. Spring Bean 的生命周期? 简化版: ``` 实例化(newInstance) ↓ 属性注入(Populate) ↓ Aware 接口回调(BeanNameAware / BeanFactoryAware / ApplicationContextAware) ↓ BeanPostProcessor.before ↓ 初始化方法(@PostConstruct → InitializingBean.afterPropertiesSet → init-method) ↓ BeanPostProcessor.after(AOP 代理创建) ↓ 使用 ↓ 销毁(@PreDestroy → DisposableBean.destroy → destroy-method) ``` ## 12. Spring 循环依赖怎么解决? **循环依赖**:A 依赖 B,B 依赖 A。 Spring 用**三级缓存**解决**单例 setter/字段注入**的循环依赖。 **三级缓存**: ```java Map<String, Object> singletonObjects; // 一级:完整的 Bean Map<String, Object> earlySingletonObjects; // 二级:半成品 Bean(已实例化,未填充属性) Map<String, ObjectFactory<?>> singletonFactories; // 三级:Bean 工厂(能拿到提前暴露的引用) ``` **解决流程**(A → B → A): ``` 1. 创建 A:实例化后放三级缓存(以 ObjectFactory 形式) 2. A 填充属性,发现需要 B → 去创建 B 3. 创建 B:实例化后放三级缓存 4. B 填充属性,发现需要 A → 从缓存找 - 一级没有(A 还没完成) - 二级没有 - 三级有 → 从 ObjectFactory 拿到 A 的早期引用,放二级 - 注入给 B 5. B 完成初始化,放一级 6. A 继续填充属性(拿到了完整的 B),完成初始化,放一级 ``` ## 13. 为什么需要三级缓存不是二级? **一级不够**:拿不到"半成品"的引用。 **二级和三级的区别**: - 二级是"原始的早期引用" - 三级是"ObjectFactory",可以在获取早期引用时做 AOP 代理 **为什么要三级**:如果 A 有 AOP,B 注入的应该是**代理对象**而不是原始对象。三级的 ObjectFactory 会判断是否需要 AOP,返回合适的引用。 **二级缓存的作用**:避免同一 Bean 多次调用 ObjectFactory(性能优化)。 **无法解决的场景**: - **构造器注入**的循环依赖(对象还没创建就需要依赖) - **prototype 作用域**(不走缓存) - `@Async` 等非 AOP 切面可能失败 ## 14. Bean 的作用域? | 作用域 | 说明 | |--------|------| | `singleton`(默认) | 容器内单例 | | `prototype` | 每次获取都新建 | | `request` | Web 请求范围 | | `session` | Web 会话范围 | | `application` | Web 应用范围 | | `websocket` | WebSocket 范围 | ## 15. Spring 的 Bean 是线程安全的吗? **默认不是**。 - Spring 只管理 Bean 的创建和生命周期,**不处理线程安全** - 单例 Bean 如果有**成员变量**就有线程安全问题 **怎么办**: 1. 无状态(不要有可变成员变量) 2. 有状态的用 `prototype` 作用域 3. 或者用 `ThreadLocal` 保存线程私有数据 4. 或者用同步锁(效率低,不推荐) **Controller/Service/Dao 为什么没事**:因为它们都是无状态的,只有方法,没有成员变量。 ## 16. @Autowired 按什么顺序注入? 1. 按类型(byType) 2. 如果有多个候选 Bean: - 先看 `@Primary` - 再看 `@Qualifier` - 最后按名字匹配(字段名 / 方法参数名) 3. 都不行 → 抛 `NoUniqueBeanDefinitionException` ## 17. @Lazy 有什么用? **延迟初始化**:Bean 第一次使用时才创建,而不是启动时。 ```java @Lazy @Component public class SlowBean { } ``` **用途**: - 启动慢的 Bean - 解决某些循环依赖(@Lazy 注入 + 代理) ## 18. Spring 事件机制怎么用? **发布事件**: ```java @Component public class OrderService { @Autowired private ApplicationEventPublisher publisher; public void createOrder() { // ... publisher.publishEvent(new OrderCreatedEvent(this, order)); } } ``` **监听事件**: ```java @Component public class EmailListener { @EventListener public void handle(OrderCreatedEvent event) { // 发邮件 } @Async // 配合 @EnableAsync 异步执行 @EventListener public void handleAsync(OrderCreatedEvent event) { ... } } ``` **用途**:模块解耦,不需要直接依赖。 --- # 第 3 章 · AOP ## 19. AOP 是什么?用来做什么? **AOP(Aspect Oriented Programming)面向切面编程**:把横切关注点(日志、事务、权限、缓存)从业务代码里抽离,集中管理。 **核心概念**: - **切面(Aspect)**:横切关注点的模块化(比如"事务管理") - **连接点(JoinPoint)**:可以被拦截的点(方法调用) - **切点(Pointcut)**:匹配哪些连接点 - **通知(Advice)**:切面在连接点执行的代码 - `@Before`、`@After`、`@AfterReturning`、`@AfterThrowing`、`@Around` - **织入(Weaving)**:把切面应用到目标对象的过程 ## 20. AOP 实现原理?JDK 代理 vs CGLIB? **两种动态代理**: **1. JDK 动态代理**: - **要求目标类实现接口** - 生成实现同一接口的代理类 - `Proxy.newProxyInstance()` **2. CGLIB 代理**: - **继承目标类**生成子类作为代理 - 不要求接口 - **不能代理 final 类 / final 方法** **Spring AOP 的选择**(Spring Boot 2.0+ 默认 CGLIB): - 目标类有接口 → JDK 动态代理 - 目标类没接口 → CGLIB - 强制 CGLIB:`@EnableAspectJAutoProxy(proxyTargetClass = true)` **性能**: - JDK:创建快,调用略慢 - CGLIB:创建慢(要生成字节码),调用快 - 现代 JDK 基本打平 ## 21. Spring AOP 和 AspectJ 的区别? | 对比 | Spring AOP | AspectJ | |------|-----------|---------| | 织入时机 | 运行时 | 编译期 / 类加载期 | | 实现 | 动态代理 | 字节码增强 | | 能力 | 只能拦截 Spring Bean 的公共方法 | 可以拦截任意对象、任意方法(含私有) | | 性能 | 略慢(代理调用) | 快(直接修改字节码) | | 复杂度 | 低 | 高 | **Spring AOP 够用**,大部分业务场景。AspectJ 更强但集成复杂。 ## 22. AOP 失效的场景? **自调用问题**:同一类内部调用不会走代理 ```java @Service public class UserService { public void a() { b(); // ❌ 不走代理,b 上的事务/切面失效 } @Transactional public void b() { ... } } ``` **解决**: 1. 把 b() 抽到另一个 Bean 2. 注入自己:`@Autowired UserService self; self.b();` 3. `((UserService) AopContext.currentProxy()).b();`(需要 `@EnableAspectJAutoProxy(exposeProxy=true)`) **其他失效场景**: - 访问 `private` 方法(JDK 代理看不到) - `final` 方法(CGLIB 无法覆盖) - 静态方法(代理拦截不了) ## 23. @Before、@After、@Around 的区别? ```java @Before("pointcut()") public void before() { ... } // 方法执行前 @After("pointcut()") public void after() { ... } // 方法执行后(无论成功失败) @AfterReturning("pointcut()") public void afterReturning() { ... } // 正常返回后 @AfterThrowing("pointcut()") public void afterThrowing() { ... } // 抛异常后 @Around("pointcut()") public Object around(ProceedingJoinPoint pjp) throws Throwable { // 前置逻辑 Object result = pjp.proceed(); // 调目标方法 // 后置逻辑 return result; } ``` **@Around 最强大**,能控制是否执行原方法、修改参数和返回值。 **执行顺序**(正常情况): ``` @Around (前) @Before 目标方法 @Around (后) @After @AfterReturning ``` ## 24. 切点表达式? ```java // 匹配 UserService 所有方法 @Pointcut("execution(* com.x.service.UserService.*(..))") // 匹配 service 包下所有类的所有方法 @Pointcut("execution(* com.x.service..*.*(..))") // 匹配特定注解 @Pointcut("@annotation(com.x.MyAnno)") @Pointcut("@within(com.x.MyClassAnno)") // 组合 @Pointcut("execution(* *..service..*.*(..)) && @annotation(tx)") public void txPointcut(Transactional tx) { } ``` ## 25. 多个切面执行顺序? **@Order 控制优先级**(数值越小越先执行): ```java @Aspect @Order(1) public class LogAspect { } @Aspect @Order(2) public class TxAspect { } ``` **执行顺序**(洋葱模型): ``` Log(before) → Tx(before) → 方法 → Tx(after) → Log(after) ``` --- # 第 4 章 · 事务 ## 26. Spring 事务的传播行为? `@Transactional(propagation = ...)` 7 种: | 传播行为 | 说明 | |---------|------| | `REQUIRED`(默认) | 有就加入,没有就新建 | | `SUPPORTS` | 有就加入,没有就非事务 | | `MANDATORY` | 必须有事务,没有抛异常 | | `REQUIRES_NEW` | 每次都新建(挂起外层事务) | | `NOT_SUPPORTED` | 非事务运行(挂起外层) | | `NEVER` | 不能有事务,有则抛异常 | | `NESTED` | 嵌套事务(savepoint) | **REQUIRED vs REQUIRES_NEW vs NESTED**: - REQUIRED:共用事务,异常都回滚 - REQUIRES_NEW:内外独立事务,互不影响 - NESTED:savepoint,内部失败只回滚到 savepoint,外部决定整体 ## 27. @Transactional 失效的场景? **经典失效场景**: 1. **自调用**(同类方法互调,不走代理) 2. **public 方法才生效**:private / protected 默认不生效 3. **事务方法捕获了异常没抛出**:没异常事务不回滚 4. **抛的是 checked 异常**:默认只回滚 RuntimeException 和 Error - 要回滚:`@Transactional(rollbackFor = Exception.class)` 5. **数据库引擎不支持**:MyISAM 无事务 6. **Bean 没被 Spring 管理**:new 出来的没事务 7. **多线程**:事务绑在当前线程,子线程不共享 8. **`@Async` 异步执行**:新线程,事务失效 9. **数据源没事务管理器**:配置缺失 ## 28. 事务回滚的默认规则? - **运行时异常(RuntimeException 及其子类)**:**自动回滚** - **Error**:自动回滚 - **Checked 异常**(IOException、SQLException 等):**不回滚** **改默认**: ```java @Transactional(rollbackFor = Exception.class) // 所有异常都回滚 @Transactional(noRollbackFor = CustomException.class) // 指定不回滚 ``` **经验**:生产用 `rollbackFor = Exception.class`,明确控制。 ## 29. 事务隔离级别? `@Transactional(isolation = ...)`: - `DEFAULT`:用数据库默认(MySQL 是 RR) - `READ_UNCOMMITTED` - `READ_COMMITTED` - `REPEATABLE_READ` - `SERIALIZABLE` 和数据库的隔离级别一致(见 MySQL 面试题)。 ## 30. 编程式事务和声明式事务? **声明式**(推荐): ```java @Transactional public void method() { ... } ``` **编程式**: ```java @Autowired TransactionTemplate txTemplate; public void method() { txTemplate.execute(status -> { try { // 业务 return result; } catch (Exception e) { status.setRollbackOnly(); throw e; } }); } ``` **使用场景**: - 声明式:绝大多数 - 编程式:需要细粒度控制(部分代码事务,部分不要) ## 31. 大事务的危害?怎么避免? **危害**: - 锁时间长,降低并发 - undo log 大 - 主从延迟 - 回滚慢 - 死锁概率增加 **避免**: 1. **事务尽量短**,不在事务里做耗时操作(调用远程 API、发 MQ) 2. **把事务外的代码放出来** 3. **批量操作分批** 4. **只读查询不要包在事务里** 5. **用编程式事务精准控制** --- # 第 5 章 · Spring MVC ## 32. Spring MVC 请求处理流程? ``` 1. 请求 → DispatcherServlet(前端控制器) 2. HandlerMapping 根据 URL 找到对应的 Controller 3. HandlerAdapter 适配调用 Controller 方法 4. Controller 处理业务,返回 ModelAndView 5. ViewResolver 解析 View 6. View 渲染(或 @ResponseBody 直接写响应) 7. 返回响应 ``` ``` Client → DispatcherServlet ↓ HandlerMapping (找 Handler) ↓ HandlerAdapter (调用) ↓ Controller ↓ ViewResolver → View ↓ Response ``` ## 33. @RequestMapping 参数绑定? - `@RequestParam`:URL 参数或表单参数 - `@PathVariable`:URL 路径变量 - `@RequestBody`:JSON → Java 对象(反序列化) - `@RequestHeader`:请求头 - `@CookieValue`:Cookie - `@ModelAttribute`:表单对象绑定 ```java @GetMapping("/user/{id}") public User get(@PathVariable Long id, @RequestParam(required = false) String name, @RequestHeader("Authorization") String token) { ... } @PostMapping("/user") public User create(@RequestBody User user) { ... } ``` ## 34. @Controller 和 @RestController 的区别? - `@Controller`:默认方法返回**视图名**(JSP / Thymeleaf) - `@RestController` = `@Controller` + `@ResponseBody`:方法返回值直接作为**响应体**(通常是 JSON) 前后端分离下基本都用 `@RestController`。 ## 35. 全局异常处理? ```java @RestControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(BusinessException.class) public Result handle(BusinessException e) { return Result.fail(e.getCode(), e.getMessage()); } @ExceptionHandler(Exception.class) public Result handleOther(Exception e) { log.error("", e); return Result.fail(500, "系统错误"); } } ``` 统一返回格式,避免异常栈信息暴露给前端。 ## 36. 拦截器(Interceptor)和过滤器(Filter)的区别? | 对比 | Filter | Interceptor | |------|--------|-------------| | 规范 | Servlet | Spring | | 作用链 | 所有请求 | 只拦截 DispatcherServlet 处理的请求 | | 调用时机 | 早(Servlet 之前) | 晚(Controller 前后) | | 能获取 Spring Bean | 需要特殊处理 | 天然可用 | | 用途 | 编码、跨域、登录 | 权限、日志、统计 | **执行顺序**: ``` Filter → Servlet → Interceptor.preHandle → Controller → Interceptor.postHandle → View → Interceptor.afterCompletion → Filter 后处理 ``` --- # 第 6 章 · Spring Boot ## 37. Spring Boot 自动配置原理? **核心机制**:`@SpringBootApplication` 组合注解 ```java @SpringBootApplication = @SpringBootConfiguration // 配置类 + @ComponentScan // 扫描包 + @EnableAutoConfiguration // 自动配置 ``` **@EnableAutoConfiguration 原理**: 1. 通过 `@Import(AutoConfigurationImportSelector.class)` 导入选择器 2. 选择器读取 `META-INF/spring.factories`(JDK 17 / Boot 3 用 `META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports`) 3. 找到所有的 `*AutoConfiguration` 类 4. 根据 `@ConditionalOnXxx` 条件决定是否生效 **示例**:`DataSourceAutoConfiguration` ```java @Configuration @ConditionalOnClass(DataSource.class) // 存在 DataSource 类 @ConditionalOnProperty("spring.datasource") // 配置了数据源 public class DataSourceAutoConfiguration { ... } ``` ## 38. Spring Boot Starter 是什么? **Starter**:一组**依赖 + 自动配置**的打包,开箱即用。 ``` spring-boot-starter-web → 引入 MVC、Tomcat、Jackson 等 spring-boot-starter-data-jpa → 引入 Hibernate、JPA ``` **自定义 Starter**: 1. 创建 `xxx-spring-boot-starter` 模块 2. 写 `XxxAutoConfiguration` 3. `META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports` 里注册 ## 39. Spring Boot 内嵌容器? 默认 **Tomcat**,也支持 Jetty、Undertow。 **原理**:`EmbeddedServletContainerFactory` 启动容器 **切换**: ```xml <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> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-undertow</artifactId> </dependency> ``` ## 40. application.yml 和 application.properties 的加载顺序? **优先级(从高到低)**: 1. 命令行参数 2. `application-{profile}.properties/yml`(激活的 profile) 3. `application.properties/yml` 4. 代码里 `@PropertySource` 5. 默认值 **profile 切换**:`--spring.profiles.active=prod` ## 41. Spring Boot Actuator 是什么? **运维监控端点**,提供健康检查、指标、配置查看等能力。 ``` /actuator/health # 健康检查 /actuator/info # 应用信息 /actuator/metrics # 指标 /actuator/env # 环境变量 /actuator/beans # Bean 列表 /actuator/mappings # 路由映射 /actuator/loggers # 日志级别(支持动态修改) /actuator/heapdump # 堆 dump /actuator/threaddump # 线程 dump ``` **安全**:生产要加认证、用独立端口、只暴露必要端点。 --- # 第 7 章 · Spring Cloud ## 42. Spring Cloud 核心组件? **第一代**(Netflix,Spring Cloud 2020 后停维): - Eureka(注册中心) - Ribbon(客户端负载均衡) - Feign(声明式 HTTP 客户端) - Hystrix(熔断降级) - Zuul(网关) - Config(配置中心) **第二代**(Alibaba,主流): - Nacos(注册中心 + 配置中心) - Sentinel(限流熔断) - Seata(分布式事务) - Dubbo(RPC) - OpenFeign(继续用) - Spring Cloud Gateway(网关) ## 43. 服务注册发现怎么工作? ``` 1. 服务启动 → 向注册中心(Nacos/Eureka)注册(IP、端口、实例 ID) 2. 注册中心维护服务列表 3. 消费者定期从注册中心拉取服务列表(缓存本地) 4. 消费者发起调用时,从列表选一个实例(负载均衡) 5. 服务下线 / 心跳丢失 → 注册中心移除 ``` **心跳机制**: - 服务定期(比如 5 秒)给注册中心发心跳 - 注册中心超过一定时间(比如 15 秒)没收到 → 标记下线 ## 44. 负载均衡策略? **客户端 LB**(Ribbon / LoadBalancer): - 轮询(RoundRobin) - 随机 - 加权轮询 - 最少并发 - 响应时间加权 - 可用区感知 **服务端 LB**(Nginx、网关): - Nginx 的 LB 策略 **选择**: - 微服务内部调用用客户端 LB(减少一跳) - 外部入口用服务端 LB ## 45. 熔断降级 限流区别? - **熔断**:依赖故障时快速失败,避免雪崩(Hystrix、Sentinel) - 失败率超过阈值 → 熔断器开启 → 后续请求直接失败 - 一段时间后 → 半开 → 尝试恢复 - **降级**:主功能不可用时返回兜底方案(默认值、缓存、简化流程) - **限流**:保护自己,控制访问速率 - 令牌桶、漏桶、滑动窗口、固定窗口 **关系**:限流是预防,熔断是故障时快速止损,降级是兜底返回。三者一起用。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入