本文详细介绍了Spring框架的基础知识、核心模块、常用注解、设计模式以及IOC容器的工作原理。从Spring的起源和特性，到模块构成，包括Core、Context、Web、MVC等，再到各种注解的使用，如@Controller、@RestController、@RequestMapping等。此外，文章深入探讨了Spring的AOP、设计模式，如工厂模式、代理模式、单例模式等，并解释了IOC和DI的概念以及其实现机制。最后，简述了Bean的生命周期和容器启动过程。文章适合准备面试和进阶学习Spring的开发者阅读。
这节我们来搞定另一个面试必问知识点——Spring。
有人说，“Java程序员都是Spring程序员”，老三不太赞成这个观点，但是这也可以看出Spring在Java世界里举足轻重的作用。
基础
1.Spring是什么？特性？有哪些模块？
一句话概括：Spring 是一个轻量级、非入侵式的控制反转 (IoC) 和面向切面 (AOP) 的框架。
2003年，一个音乐家Rod Johnson决定发展一个轻量级的Java开发框架，Spring作为Java战场的龙骑兵渐渐崛起，并淘汰了EJB这个传统的重装骑兵。
Spring重要版本
到了现在，企业级开发的标配基本就是 Spring5 + Spring Boot 2 + JDK 8
Spring有哪些特性呢？
Spring有很多优点：
1、IOC 和 DI 的支持
Spring 的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring 工厂用于生成 Bean，并且管理 Bean 的生命周期，实现高内聚低耦合的设计理念。
2、AOP 编程的支持
Spring 提供了面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等切面功能。
3、声明式事务的支持
支持通过配置就来完成对事务的管理，而不需要通过硬编码的方式，以前重复的一些事务提交、回滚的JDBC代码，都可以不用自己写了。
4、快捷测试的支持
Spring 对 Junit 提供支持，可以通过注解快捷地测试 Spring 程序。
5、快速集成功能
方便集成各种优秀框架，Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz 等）的直接支持。
6、复杂API模板封装
Spring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等）都提供了模板化的封装，这些封装 API 的提供使得应用难度大大降低。
2.Spring有哪些模块呢？
Spring 框架是分模块存在，除了最核心的Spring Core Container是必要模块之外，其他模块都是可选，大约有 20 多个模块。
最主要的七大模块：
-
Spring Core：Spring 核心，它是框架最基础的部分，提供 IOC 和依赖注入 DI 特性。
-
Spring Context：Spring 上下文容器，它是 BeanFactory 功能加强的一个子接口。
-
Spring Web：它提供 Web 应用开发的支持。
-
Spring MVC：它针对 Web 应用中 MVC 思想的实现。
-
Spring DAO：提供对 JDBC 抽象层，简化了 JDBC 编码，同时，编码更具有健壮性。
-
Spring ORM：它支持用于流行的 ORM 框架的整合，比如：Spring + Hibernate、Spring + iBatis、Spring + JDO 的整合等。
-
Spring AOP：即面向切面编程，它提供了与 AOP 联盟兼容的编程实现。
3.Spring有哪些常用注解呢？
Spring有很多模块，甚至广义的SpringBoot、SpringCloud也算是Spring的一部分，我们来分模块，按功能来看一下一些常用的注解：
Web:
-
@Controller：组合注解（组合了@Component注解），应用在MVC层（控制层）。
-
@RestController：该注解为一个组合注解，相当于@Controller和@ResponseBody的组合，注解在类上，意味着，该Controller的所有方法都默认加上了@ResponseBody。
-
@RequestMapping：用于映射Web请求，包括访问路径和参数。如果是Restful风格接口，还可以根据请求类型使用不同的注解：
-
@GetMapping
-
@PostMapping
-
@PutMapping
-
@DeleteMapping
-
-
@ResponseBody：支持将返回值放在response内，而不是一个页面，通常用户返回json数据。
-
@RequestBody：允许request的参数在request体中，而不是在直接连接在地址后面。
-
@PathVariable：用于接收路径参数，比如@RequestMapping(“/hello/{name}”)申明的路径，将注解放在参数中前，即可获取该值，通常作为Restful的接口实现方法。
-
@RestController：该注解为一个组合注解，相当于@Controller和@ResponseBody的组合，注解在类上，意味着，该Controller的所有方法都默认加上了@ResponseBody。
容器:
-
@Component：表示一个带注释的类是一个“组件”，成为Spring管理的Bean。当使用基于注解的配置和类路径扫描时，这些类被视为自动检测的候选对象。同时@Component还是一个元注解。
-
@Service：组合注解（组合了@Component注解），应用在service层（业务逻辑层）。
-
@Repository：组合注解（组合了@Component注解），应用在dao层（数据访问层）。
-
@Autowired：Spring提供的工具（由Spring的依赖注入工具（BeanPostProcessor、BeanFactoryPostProcessor）自动注入）。
-
@Qualifier：该注解通常跟 @Autowired 一起使用，当想对注入的过程做更多的控制，@Qualifier 可帮助配置，比如两个以上相同类型的 Bean 时 Spring 无法抉择，用到此注解
-
@Configuration：声明当前类是一个配置类（相当于一个Spring配置的xml文件）
-
@Value：可用在字段，构造器参数跟方法参数，指定一个默认值，支持 #{} 跟 ${} 两个方式。一般将 SpringbBoot 中的 application.properties 配置的属性值赋值给变量。
-
@Bean：注解在方法上，声明当前方法的返回值为一个Bean。返回的Bean对应的类中可以定义init()方法和destroy()方法，然后在@Bean(initMethod=”init”,destroyMethod=”destroy”)定义，在构造之后执行init，在销毁之前执行destroy。
-
@Scope:定义我们采用什么模式去创建Bean（方法上，得有@Bean） 其设置类型包括：Singleton 、Prototype、Request 、 Session、GlobalSession。
AOP:
-
@Aspect:声明一个切面（类上） 使用@After、@Before、@Around定义建言（advice），可直接将拦截规则（切点）作为参数。
-
@After：在方法执行之后执行（方法上）。 -
@Before：在方法执行之前执行（方法上）。 -
@Around：在方法执行之前与之后执行（方法上）。 -
@PointCut：声明切点 在java配置类中使用@EnableAspectJAutoProxy注解开启Spring对AspectJ代理的支持（类上）。
-
事务：
-
@Transactional：在要开启事务的方法上使用@Transactional注解，即可声明式开启事务。
4.Spring 中应用了哪些设计模式呢？
Spring 框架中广泛使用了不同类型的设计模式，下面我们来看看到底有哪些设计模式?
-
工厂模式 : Spring 容器本质是一个大工厂，使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象。
-
代理模式 : Spring AOP 功能功能就是通过代理模式来实现的，分为动态代理和静态代理。
-
单例模式 : Spring 中的 Bean 默认都是单例的，这样有利于容器对Bean的管理。
-
模板模式 : Spring 中 JdbcTemplate、RestTemplate 等以 Template结尾的对数据库、网络等等进行操作的模板类，就使用到了模板模式。
-
观察者模式: Spring 事件驱动模型就是观察者模式很经典的一个应用。
-
适配器模式 :Spring AOP 的增强或通知 (Advice) 使用到了适配器模式、Spring MVC 中也是用到了适配器模式适配 Controller。
-
策略模式：Spring中有一个Resource接口，它的不同实现类，会根据不同的策略去访问资源。
IOC
5.说一说什么是IOC？什么是DI?
Java 是面向对象的编程语言，一个个实例对象相互合作组成了业务逻辑，原来，我们都是在代码里创建对象和对象的依赖。
所谓的IOC（控制反转）：就是由容器来负责控制对象的生命周期和对象间的关系。以前是我们想要什么，就自己创建什么，现在是我们需要什么，容器就给我们送来什么。
引入IOC之前和引入IOC之后
也就是说，控制对象生命周期的不再是引用它的对象，而是容器。对具体对象，以前是它控制其它对象，现在所有对象都被容器控制，所以这就叫控制反转。
控制反转示意图
DI（依赖注入）：指的是容器在实例化对象的时候把它依赖的类注入给它。有的说法IOC和DI是一回事，有的说法是IOC是思想，DI是IOC的实现。
为什么要使用IOC呢？
最主要的是两个字解耦，硬编码会造成对象间的过度耦合，使用IOC之后，我们可以不用关心对象间的依赖，专心开发应用就行。
6.能简单说一下Spring IOC的实现机制吗？
PS:这道题老三在面试中被问到过，问法是“你有自己实现过简单的Spring吗？”
Spring的IOC本质就是一个大工厂，我们想想一个工厂是怎么运行的呢？
-
生产产品：一个工厂最核心的功能就是生产产品。在Spring里，不用Bean自己来实例化，而是交给Spring，应该怎么实现呢？——答案毫无疑问，反射。
那么这个厂子的生产管理是怎么做的？你应该也知道——工厂模式。
-
库存产品：工厂一般都是有库房的，用来库存产品，毕竟生产的产品不能立马就拉走。Spring我们都知道是一个容器，这个容器里存的就是对象，不能每次来取对象，都得现场来反射创建对象，得把创建出的对象存起来。
-
订单处理：还有最重要的一点，工厂根据什么来提供产品呢？订单。这些订单可能五花八门，有线上签签的、有到工厂签的、还有工厂销售上门签的……最后经过处理，指导工厂的出货。
在Spring里，也有这样的订单，它就是我们bean的定义和依赖关系，可以是xml形式，也可以是我们最熟悉的注解形式。
我们简单地实现一个mini版的Spring IOC：
Bean定义：
Bean通过一个配置文件定义，把它解析成一个类型。
-
beans.properties
偷懒，这里直接用了最方便解析的properties，这里直接用一个<key,value>类型的配置来代表Bean的定义，其中key是beanName，value是class
userDao:cn.fighter3.bean.UserDao -
BeanDefinition.java
bean定义类，配置文件中bean定义对应的实体
public class BeanDefinition { private String beanName; private Class beanClass; //省略getter、setter } -
ResourceLoader.java
资源加载器，用来完成配置文件中配置的加载
-
public class ResourceLoader { public static Map<String, BeanDefinition> getResource() { Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>(16); Properties properties = new Properties(); try { InputStream inputStream = ResourceLoader.class.getResourceAsStream("/beans.properties"); properties.load(inputStream); Iterator<String> it = properties.stringPropertyNames().iterator(); while (it.hasNext()) { String key = it.next(); String className = properties.getProperty(key); BeanDefinition beanDefinition = new BeanDefinition(); beanDefinition.setBeanName(key); Class clazz = Class.forName(className); beanDefinition.setBeanClass(clazz); beanDefinitionMap.put(key, beanDefinition); } inputStream.close(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } return beanDefinitionMap; } } -
BeanRegister.java
对象注册器，这里用于单例bean的缓存，我们大幅简化，默认所有bean都是单例的。可以看到所谓单例注册，也很简单，不过是往HashMap里存对象。
public class BeanRegister { //单例Bean缓存 private Map<String, Object> singletonMap = new HashMap<>(32); /** * 获取单例Bean * * @param beanName bean名称 * @return */ public Object getSingletonBean(String beanName) { return singletonMap.get(beanName); } /** * 注册单例bean * * @param beanName * @param bean */ public void registerSingletonBean(String beanName, Object bean) { if (singletonMap.containsKey(beanName)) { return; } singletonMap.put(beanName, bean); } } -
BeanFactory.java
BeanFactory
-
对象工厂，我们最核心的一个类，在它初始化的时候，创建了bean注册器，完成了资源的加载。
-
获取bean的时候，先从单例缓存中取，如果没有取到，就创建并注册一个bean
-
-
public class BeanFactory { private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>(); private BeanRegister beanRegister; public BeanFactory() { //创建bean注册器 beanRegister = new BeanRegister(); //加载资源 this.beanDefinitionMap = new ResourceLoader().getResource(); } /** * 获取bean * * @param beanName bean名称 * @return */ public Object getBean(String beanName) { //从bean缓存中取 Object bean = beanRegister.getSingletonBean(beanName); if (bean != null) { return bean; } //根据bean定义，创建bean return createBean(beanDefinitionMap.get(beanName)); } /** * 创建Bean * * @param beanDefinition bean定义 * @return */ private Object createBean(BeanDefinition beanDefinition) { try { Object bean = beanDefinition.getBeanClass().newInstance(); //缓存bean beanRegister.registerSingletonBean(beanDefinition.getBeanName(), bean); return bean; } catch (InstantiationException | IllegalAccessException e) { e.printStackTrace(); } return null; } }
-
-
测试
-
UserDao.java
我们的Bean类，很简单
public class UserDao { public void queryUserInfo(){ System.out.println("A good man."); } } -
单元测试
public class ApiTest { @Test public void test_BeanFactory() { //1.创建bean工厂(同时完成了加载资源、创建注册单例bean注册器的操作) BeanFactory beanFactory = new BeanFactory(); //2.第一次获取bean（通过反射创建bean，缓存bean） UserDao userDao1 = (UserDao) beanFactory.getBean("userDao"); userDao1.queryUserInfo(); //3.第二次获取bean（从缓存中获取bean） UserDao userDao2 = (UserDao) beanFactory.getBean("userDao"); userDao2.queryUserInfo(); } } -
运行结果
A good man. A good man. -
-
至此，我们一个乞丐+破船版的Spring就完成了，代码也比较完整，有条件的可以跑一下。
PS:因为时间+篇幅的限制，这个demo比较简陋，没有面向接口、没有解耦、边界检查、异常处理……健壮性、扩展性都有很大的不足，感兴趣可以学习参考[15]。
7.说说BeanFactory和ApplicantContext?
可以这么形容，BeanFactory是Spring的“心脏”，ApplicantContext是完整的“身躯”。
-
BeanFactory（Bean工厂）是Spring框架的基础设施，面向Spring本身。
-
ApplicantContext（应用上下文）建立在BeanFactoty基础上，面向使用Spring框架的开发者。
BeanFactory 接口
BeanFactory是类的通用工厂，可以创建并管理各种类的对象。
Spring为BeanFactory提供了很多种实现，最常用的是XmlBeanFactory，但在Spring 3.2中已被废弃，建议使用XmlBeanDefinitionReader、DefaultListableBeanFactory。
BeanFactory接口位于类结构树的顶端，它最主要的方法就是getBean(String var1)，这个方法从容器中返回特定名称的Bean。
BeanFactory的功能通过其它的接口得到了不断的扩展，比如AbstractAutowireCapableBeanFactory定义了将容器中的Bean按照某种规则（比如按名字匹配、按类型匹配等）进行自动装配的方法。
这里看一个 XMLBeanFactory（已过期） 获取bean 的例子：
public class HelloWorldApp{
public static void main(String[] args) {
BeanFactory factory = new XmlBeanFactory (new ClassPathResource("beans.xml"));
HelloWorld obj = (HelloWorld) factory.getBean("helloWorld");
obj.getMessage();
}
}
ApplicationContext 接口
ApplicationContext由BeanFactory派生而来，提供了更多面向实际应用的功能。可以这么说，使用BeanFactory就是手动档，使用ApplicationContext就是自动档。
ApplicationContext 继承了HierachicalBeanFactory和ListableBeanFactory接口，在此基础上，还通过其他的接口扩展了BeanFactory的功能，包括：
-
Bean instantiation/wiring
-
Bean 的实例化/串联
-
自动的 BeanPostProcessor 注册
-
自动的 BeanFactoryPostProcessor 注册
-
方便的 MessageSource 访问（i18n）
-
ApplicationEvent 的发布与 BeanFactory 懒加载的方式不同，它是预加载，所以，每一个 bean 都在 ApplicationContext 启动之后实例化
这是 ApplicationContext 的使用例子：
public class HelloWorldApp{
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
}
}
ApplicationContext 包含 BeanFactory 的所有特性，通常推荐使用前者。
8.你知道Spring容器启动阶段会干什么吗？
PS：这道题老三面试被问到过
Spring的IOC容器工作的过程，其实可以划分为两个阶段：容器启动阶段和Bean实例化阶段。
其中容器启动阶段主要做的工作是加载和解析配置文件，保存到对应的Bean定义中。
容器启动开始，首先会通过某种途径加载Congiguration MetaData，在大部分情况下，容器需要依赖某些工具类（BeanDefinitionReader）对加载的Congiguration MetaData进行解析和分析，并将分析后的信息组为相应的BeanDefinition。
xml配置信息映射注册过程
最后把这些保存了Bean定义必要信息的BeanDefinition，注册到相应的BeanDefinitionRegistry，这样容器启动就完成了。
9.能说一下Spring Bean生命周期吗？
在Spring中，基本容器BeanFactory和扩展容器ApplicationContext的实例化时机不太一样，BeanFactory采用的是延迟初始化的方式，也就是只有在第一次getBean()的时候，才会实例化Bean；ApplicationContext启动之后会实例化所有的Bean定义。
Spring IOC 中Bean的生命周期大致分为四个阶段：实例化（Instantiation）、属性赋值（Populate）、初始化（Initialization）、销毁（Destruction）。
Bean生命周期四个阶段
我们再来看一个稍微详细一些的过程：
-
实例化：第 1 步，实例化一个 Bean 对象
-
属性赋值：第 2 步，为 Bean 设置相关属性和依赖
-
初始化：初始化的阶段的步骤比较多，5、6步是真正的初始化，第 3、4 步为在初始化前执行，第 7 步在初始化后执行，初始化完成之后，Bean就可以被使用了
-
销毁：第 8~10步，第8步其实也可以算到销毁阶段，但不是真正意义上的销毁，而是先在使用前注册了销毁的相关调用接口，为了后面第9、10步真正销毁 Bean 时再执行相应的方法
简单总结一下，Bean生命周期里初始化的过程相对步骤会多一些，比如前置、后置的处理。
最后通过一个实例来看一下具体的细节：
-
定义一个
PersonBean类，实现DisposableBean,InitializingBean,BeanFactoryAware,BeanNameAware这4个接口，同时还有自定义的init-method和destroy-method。
public class PersonBean implements InitializingBean, BeanFactoryAware, BeanNameAware, DisposableBean {
/**
* 身份证号
*/
private Integer no;
/**
* 姓名
*/
private String name;
public PersonBean() {
System.out.println("1.调用构造方法：我出生了！");
}
public Integer getNo() {
return no;
}
public void setNo(Integer no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
System.out.println("2.设置属性：我的名字叫"+name);
}
@Override
public void setBeanName(String s) {
System.out.println("3.调用BeanNameAware#setBeanName方法:我要上学了，起了个学名");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("4.调用BeanFactoryAware#setBeanFactory方法：选好学校了");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("6.InitializingBean#afterPropertiesSet方法：入学登记");
}
public void init() {
System.out.println("7.自定义init方法：努力上学ing");
}
@Override
public void destroy() throws Exception {
System.out.println("9.DisposableBean#destroy方法：平淡的一生落幕了");
}
public void destroyMethod() {
System.out.println("10.自定义destroy方法:睡了，别想叫醒我");
}
public void work(){
System.out.println("Bean使用中：工作，只有对社会没有用的人才放假。。");
}
}
-
定义一个
MyBeanPostProcessor实现BeanPostProcessor接口。public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("5.BeanPostProcessor.postProcessBeforeInitialization方法：到学校报名啦"); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("8.BeanPostProcessor#postProcessAfterInitialization方法：终于毕业，拿到毕业证啦！"); return bean; } } -
配置文件，指定
init-method和destroy-method属性 -
<?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 name="myBeanPostProcessor" class="cn.fighter3.spring.life.MyBeanPostProcessor" /> <bean name="personBean" class="cn.fighter3.spring.life.PersonBean" init-method="init" destroy-method="destroyMethod"> <property name="idNo" value= "80669865"/> <property name="name" value="张铁钢" /> </bean> </beans> -
测试
-
public class Main { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml"); PersonBean personBean = (PersonBean) context.getBean("personBean"); personBean.work(); ((ClassPathXmlApplicationContext) context).destroy(); } } -
运行结果：
-
1.调用构造方法：我出生了！ 2.设置属性：我的名字叫张铁钢 3.调用BeanNameAware#setBeanName方法:我要上学了，起了个学名 4.调用BeanFactoryAware#setBeanFactory方法：选好学校了 5.BeanPostProcessor#postProcessBeforeInitialization方法：到学校报名啦 6.InitializingBean#afterPropertiesSet方法：入学登记 7.自定义init方法：努力上学ing 8.BeanPostProcessor#postProcessAfterInitialization方法：终于毕业，拿到毕业证啦！ Bean使用中：工作，只有对社会没有用的人才放假。。 9.DisposableBean#destroy方法：平淡的一生落幕了 10.自定义destroy方法:睡了，别想叫醒我关于源码，Bean创建过程可以查看
AbstractBeanFactory#doGetBean方法，在这个方法里可以看到Bean的实例化，赋值、初始化的过程，至于最终的销毁，可以看看ConfigurableApplicationContext#close()。 -
......
33.如何自定义一个SpringBoot Srarter?
知道了自动配置原理，创建一个自定义SpringBoot Starter也很简单。
-
创建一个项目，命名为demo-spring-boot-starter，引入SpringBoot相关依赖
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional> </dependency>2.编写配置文件
这里定义了属性配置的前缀
@ConfigurationProperties(prefix = "hello")
public class HelloProperties {
private String name;
//省略getter、setter
}3.自动装配
创建自动配置类HelloPropertiesConfigure
@Configuration
@EnableConfigurationProperties(HelloProperties.class)
public class HelloPropertiesConfigure {
}4.配置自动类
在/resources/META-INF/spring.factories文件中添加自动配置类路径
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
cn.fighter3.demo.starter.configure.HelloPropertiesConfigure35.对SpringCloud了解多少？
SpringCloud是Spring官方推出的微服务治理框架。
Spring Cloud Netfilx核心组件-来源参考[2]
什么是微服务？
-
2014 年 Martin Fowler 提出的一种新的架构形式。微服务架构是一种架构模式，提倡将单一应用程序划分成一组小的服务，服务之间相互协调，互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务与服务之间采用轻量级的通信机制(如HTTP或Dubbo)互相协作，每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具(如Maven)对其进行构建。
-
微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底地去耦合，每一个微服务提供单个业务功能的服务，一个服务做一件事情，从技术角度看就是一种小而独立的处理过程，类似进程的概念，能够自行单独启动或销毁，拥有自己独立的数据库。
微服务架构主要要解决哪些问题？
-
服务很多，客户端怎么访问，如何提供对外网关?
-
这么多服务，服务之间如何通信? HTTP还是RPC?
-
这么多服务，如何治理? 服务的注册和发现。
-
服务挂了怎么办？熔断机制。
有哪些主流微服务框架？
-
Spring Cloud Netflix
-
Spring Cloud Alibaba
-
SpringBoot + Dubbo + ZooKeeper
SpringCloud有哪些核心组件？
PS:微服务后面有机会再扩展，其实面试一般都是结合项目去问。
243
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
