Spring相关问题整理

目录

1.Spring Boot与以前的Spring有什么区别？

2.Spring Boot启动加载过程是什么样的？

先进行总的分析汇总

具体详细如下：

一、基本代码启动

二、初始化SpringApplication

1.初始化SpringApplication的initialize方法

2.调用deduceWebEnvironment来判断当前的应用是否是web应用，并设置到webEnvironment属性中。

3.找出所有的应用程序初始化器 getSpringFactoriesInstances + setInitializers

补充：获取初始化器

4.找出所有的应用程序事件监听器  getSpringFactoriesInstances + setListeners

补充：获取监听器

5.调用deduceMainApplicationClass方法找出main类

三、运行SpringApplication

1.SpringApplicationRunListeners类

2.SpringApplicationRunListener类：监听SpringApplication的run方法执行

补充：获取SpringApplicationRunListeners

四、run方法详细

1.配置并准备环境

2.创建Spring容器上下文

3.配置Spring容器上下文

4.Spring容器创建之后回调方法postProcessApplicationContext

5.初始化器开始工作

6.Spring容器创建完成之后会调用afterRefresh方法

3.Spring的IOC/AOP的实现（必考）

4.动态代理的实现方式（必考）是否使用过GCLB，和JDK的区别是什么？

知识背景：JDK和CGLIB动态代理总结

补充问题：

何时使用JDK还是CGLiB？

如何强制使用CGLIB实现AOP？

JDK动态代理和CGLIB字节码生成的区别？

CGlib比JDK快？

Spring在选择用JDK还是CGLiB的依据：

5.Spring如何解决循环依赖（三级缓存）（必考）

循环依赖的产生和解决的前提

Spring使用了三级缓存解决了循环依赖的问题

6.Spring的@Transactional如何实现的（必考）

7.Spring的事务传播级别

补充：隔离级别

8.BeanFactory和ApplicationContext的联系和区别

9.Spring的后置处理器

10.Spring Cloud Zuul网关的调优策略有哪些？怎么实现其高可用？Zuul和Gataway，你们项目中是怎么选择的？项目中对Zuul网关层的要求是什么样的？

11.Spring Cloud Eureka和Nacos对比？怎么做选择？Eureka中高可用是怎么做的？进行的调优有哪些？原理是什么？

12.Spring Cloud 中常用的注解有哪些？怎么用的？

13.Spring Cloud中的组件有哪些？具体说说？微服务架构中用到的关键技术有哪些？

14.Spring Cloud Config配置架构是什么样的？可视化怎么做的？设计的业务有哪些？

参考书籍、文献和资料

---

备注：针对基本问题做一些基本的总结，不是详细解答！

1.Spring Boot与以前的Spring有什么区别？

具体可以见博客：https://blog.csdn.net/xiaofeng10330111/article/details/87271456

Spring开发WEB应用程序过程广泛采用的固定开发模式：通常包括使用Maven、Gradle等工具搭建工程、web.xml定义Spring的DispatcherServlet、完成启动Spring MVC的配置文件、编写响应HTTP请求的Controller以及服务部署到Tomcat Web服务器等步骤。但是，基于传统Spring框架进行开发的开发过程中，逐渐暴露出一些问题，典型的就是过于复杂和繁重的配置工作。

Spring Boot优化了开发过程，采用约定优于配置思想的自动化配置、启动依赖项目自动管理、简化部署并提供监控等功能，是开发过程变得简单。其核心优势体现在编码、配置、部署、监控等多个方面：

• 编码方面：只需要在maven中添加依赖并实现一个方法就可以提供微服务架构所推荐的RESTful风格接口。
• 配置方面：简单化--->1>把Spring中基于XML的功能配置方式转换为Java Config；2>把基于*.properties/*.xml文件部署环境配置转换成语言更为强大的*.yml；3>对常见的各种功能组件均提供了各种默认的starter依赖以简化Maven的配置。
• 部署方面：相较于传统模式下的war包，Spring Boot的部署既包含了业务代码和各种第三方类库，同时也内嵌了HTTP容器。新的部署方式包结构支持java-jar standalone.jar方式的一键启动，不需要预部署应用服务器，通过默认内嵌Tomcat降低对运行环境的基本要求。
• 监控方面：基于spring-boot-actuator组件，可以通过RESTful接口以及HATEOAS表现方式获取JVM性能指标、线程工作状态等运行信息。

2.Spring Boot启动加载过程是什么样的？

先进行总的分析汇总

Spring Boot通常有一个名为*Application的入口类，在入口类里有一个main方法，这个main方法其实就是一个标准的java应用的入口方法。在main方法中使用SpringApplication.run方法启动SpringBoot应用项目。

其中@SpringBootApplication是Spring Boot的核心注解，主要组合了@Configuration、@EnableAutoConfiguration、@ComponentScan。（如果不使用@SpringBootApplication注解,则可以使用在入口类上直接使用@Configuration、@EnableAutoConfiguration、@ComponentScan也能达到相同效果。）

其中几个注解的作用大致说一下:

• @Configuration:是做类似于spring xml 工作的注解，标注在类上，类似与以前的**.xml配置文件。
• @EnableAutoConfiguration:spring boot自动配置时需要的注解，会让Spring Boot根据类路径中的jar包依赖为当前项目进行自动配置。同时,它也是一个组合注解。
• 在@EnableAutoConfiguration中用了@Import注解导入EnableAutoConfigurationImportSelector类,而EnableAutoConfigurationImportSelector就是自动配置关键。（SpringBoot的自动配置:SpringBoot的一大特色就是自动配置，例如，添加了spring-boot-starter-web依赖，会自动添加Tomcat和SpringMVC的依赖，SpringBoot会对Tomcat和SpringMVC进行自动配置。又例如:添加了spring-boot-starter-data-jpa依赖,SpringBoot会自动进行JPA相关的配置。）
• @ComponentScan:告诉Spring 哪个packages 的用注解标识的类，会被spring自动扫描并且装入bean容器。SpringBoot会自动扫描@SpringBootApplication所在类的同级包以及下级包的Bean(如果为JPA项目还可以扫描标注@Entity的实体类)，所以建议入口类放置在最外层包下。

spring-boot启动过程:

在这个静态方法中，创建并构造了SpringApplication对象，并调用该对象的run方法。

构造SpringApplication对象:主要是对一些属性附上初始值，关键在与SpringApplication对象的initialize方法。

• 调用deduceWebEnvironment来判断当前的应用是否是web应用，并设置到webEnvironment属性中。
• 找出所有的应用程序初始化器，调用getSpringFactoriesInstances从spring.factories文件中找出key为ApplicationContextInitializer的类并实例化，然后调用setInitializers方法设置到SpringApplication的initializers属性中。
• 找出所有的应用程序事件监听器，调用getSpringFactoriesInstances从spring.factories文件中找出key为ApplicationListener的类并实例化，然后调用setListeners方法设置到SpringApplication的listeners属性中。
• 调用deduceMainApplicationClass方法找出main类

初始化SpringApplication完成之后，调用run方法运行，run方法执行完成之后，Spring容器也已经初始化完成，各种监听器和初始化器也做了相应的工作。

• 具体运行SpringApplication，重点由SpringApplicationRunListeners和SpringApplicationRunListener类实现
• SpringApplicationRunListeners内部持有SpringApplicationRunListener集合和1个Log日志类。用于SpringApplicationRunListener监听器的批量执行。
• SpringApplicationRunListener类：监听SpringApplication的run方法执行。
• run具体的实现包括：配置并准备环境--->创建Spring容器上下文--->配置Spring容器上下文--->Spring容器创建之后回调方法postProcessApplicationContext--->初始化器开始工作--->Spring容器创建完成之后会调用afterRefresh方法

具体详细如下：

一、基本代码启动

启动代码很简单，直接如下便可以完成：

@SpringBootApplication
public class SpringBootDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemoApplication.class, args);
    }
}

SpringApplication.run方法实际执行的方法如下：

public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
    return new SpringApplication(sources).run(args);
}

二、初始化SpringApplication

1.初始化SpringApplication的initialize方法

SpringApplication的构造函数中调用了initialize方法来初始化SpringApplication：

private void initialize(Object[] sources) {
    if (sources != null && sources.length > 0) {
        this.sources.addAll(Arrays.asList(sources));
    }
    this.webEnvironment = deduceWebEnvironment();
    setInitializers((Collection) getSpringFactoriesInstances(
            ApplicationContextInitializer.class));
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = deduceMainApplicationClass();
}

2.调用deduceWebEnvironment来判断当前的应用是否是web应用，并设置到webEnvironment属性中。

deduceWebEnvironment方法通过获取

javax.servlet.Servlet
org.springframework.web.context.ConfigurableWebApplicationContext

这两个类来判断，如果能获得这两个类则说明是web应用，否则不是。

3.找出所有的应用程序初始化器 getSpringFactoriesInstances + setInitializers

调用getSpringFactoriesInstances从spring.factories文件中找出key为ApplicationContextInitializer的类并实例化，然后调用setInitializers方法设置到SpringApplication的initializers属性中。这个过程就是找出所有的应用程序初始化器。

当前的初始化器有如下几个:

DelegatingApplicationContextInitializer
ContextIdApplicationContextInitializer
ConfigurationWarningsApplicationContextInitializer
ServerPortInfoApplicationContextInitializer
SharedMetadataReaderFactoryContextInitializer
AutoConfigurationReportLoggingInitializer

补充：获取初始化器

初始化器的获取由SpringApplication.getSpringFactoriesInstances方法完成：

• 读取ApplicationContextInitializer的实现类
• 实例化ApplicationContextInitializer的实现类

private  Collection getSpringFactoriesInstances(Class type,
        Class[] parameterTypes, Object... args) {
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    // Use names and ensure unique to protect against duplicates
    // 读取ApplicationContextInitializer的实现类
    Set names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    // 实例化ApplicationContextInitializer的实现类
    List instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

SpringFactoriesLoader.loadFactoryNames方法获取ApplicationContextInitializer接口实现的类：

• 获取接口类的名称
• 获取FACTORIES_RESOURCE_LOCATION(META-INF/spring.factories)的多个位置
• 从META-INF/spring.factories文件中加载配置
• 从配置中读取ApplicationContextInitializer的实现类

public static List loadFactoryNames(Class factoryClass, ClassLoader classLoader) {
    // 获取接口类的名称
    String factoryClassName = factoryClass.getName();
    try {
        // 获取FACTORIES_RESOURCE_LOCATION(META-INF/spring.factories)的多个位置
        Enumeration urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        List result = new ArrayList();
        /**
         * urls有
         * spring-boot/META-INF/spring.factories
         * spring-beans/META-INF/spring.factories
         * spring-boot-autoconfigure/META-INF/spring.factories
         * 
         */
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            // 从META-INF/spring.factories文件中加载配置
            Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
            // 从配置中读取ApplicationContextInitializer的实现类
            String factoryClassNames = properties.getProperty(factoryClassName);
            result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
        }
        return result;
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() +
                "] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
}

4.找出所有的应用程序事件监听器  getSpringFactoriesInstances + setListeners

调用getSpringFactoriesInstances从spring.factories文件中找出key为ApplicationListener的类并实例化，然后调用setListeners方法设置到SpringApplication的listeners属性中。这个过程就是找出所有的应用程序事件监听器。

当前的事件监听器有如下几个：

ConfigFileApplicationListener
AnsiOutputApplicationListener
LoggingApplicationListener
ClasspathLoggingApplicationListener
BackgroundPreinitializer
DelegatingApplicationListener
ParentContextCloserApplicationListener
ClearCachesApplicationListener
FileEncodingApplicationListener
LiquibaseServiceLocatorApplicationListener

补充：获取监听器

获取监听器的方法与获取初始化器的方法一致：

唯一的区别在于获取org.springframework.context.ApplicationListener接口的实现类

5.调用deduceMainApplicationClass方法找出main类

就是这里的SpringBootDemoApplication类

三、运行SpringApplication

重点：SpringApplicationRunListeners和SpringApplicationRunListener类

1.SpringApplicationRunListeners类

SpringApplicationRunListeners内部持有SpringApplicationRunListener集合和1个Log日志类。用于SpringApplicationRunListener监听器的批量执行。

2.SpringApplicationRunListener类：监听SpringApplication的run方法执行

SpringApplicationRunListener用于监听SpringApplication的run方法的执行，它定义了5个步骤：

• starting：run方法执行的时候立马执行，对应的事件类型是ApplicationStartedEvent
• environmentPrepared：ApplicationContext创建之前并且环境信息准备好的时候调用，对应的事件类型是ApplicationEnvironmentPreparedEvent
• contextPrepared：ApplicationContext创建好并且在source加载之前调用一次，没有具体的对应事件
• contextLoaded：ApplicationContext创建并加载之后并在refresh之前调用，对应的事件类型是ApplicationPreparedEvent
• finished：run方法结束之前调用，对应事件的类型是ApplicationReadyEvent或ApplicationFailedEvent

SpringApplicationRunListener目前只有一个实现类EventPublishingRunListener，它把监听的过程封装成了SpringApplicationEvent事件并让内部属性ApplicationEventMulticaster接口的实现类SimpleApplicationEventMulticaster广播出去，广播出去的事件对象会被SpringApplication中的listeners属性进行处理。

所以说SpringApplicationRunListener和ApplicationListener之间的关系是通过ApplicationEventMulticaster广播出去的SpringApplicationEvent所联系起来的。

补充：获取SpringApplicationRunListeners

首先看getRunListeners方法：

private SpringApplicationRunListeners getRunListeners(String[] args) {
    Class[] types = new Class[] { SpringApplication.class, String[].class };
    return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(
            SpringApplicationRunListener.class, types, this, args));
}

可以看到通过调用构造函数来实例化SpringApplicationRunListeners，传入的参数有logger以及调用getSpringFactoriesInstance获得的SpringApplicationRunListener集合。

再看getSpringFactoriesInstance方法，它和获取初始化器的方法一样：

获取的接口类型是org.springframework.boot.SpringApplicationRunListener。

获取到的实现类为org.springframework.boot.context.event.EventPublishRunListener。

四、run方法详细

初始化SpringApplication完成之后，调用run方法运行，run方法执行完成之后，Spring容器也已经初始化完成，各种监听器和初始化器也做了相应的工作。

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();    // 构造一个任务执行观察者
    stopWatch.start();    // 开始执行，记录开始时间
    ConfigurableApplicationContext context = null;
    FailureAnalyzers analyzers = null;
    configureHeadlessProperty();
    // 获取SpringApplicationRunListeners，内部只有一个EventPublishingRunListener
    SpringApplicationRunListeners listeners = getRunListeners(args);
    // 封装成SpringApplicationEvent事件然后广播出去给SpringApplication中的listeners所监听
    // 这里接受ApplicationStartedEvent事件的listener会执行相应的操作
    listeners.starting();
    try {
        // 构造一个应用程序参数持有类
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 准备并配置环境
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        // 打印banner图形
        Banner printedBanner = printBanner(environment);
        // 创建Spring容器
        context = createApplicationContext();
        analyzers = new FailureAnalyzers(context);
        // 配置Spring容器
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        // 容器上下文刷新，详见Spring的启动分析
        refreshContext(context);
        
        // 容器创建完成之后调用afterRefresh方法
        afterRefresh(context, applicationArguments);
        // 调用监听器，广播Spring启动结束的事件
        listeners.finished(context, null);
        // 停止任务执行观察者
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
        }
        return context;
    }
    catch (Throwable ex) {
        handleRunFailure(context, listeners, analyzers, ex);
        throw new IllegalStateException(ex);
    }
}

具体步骤如：

1.配置并准备环境

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
    // 创建应用程序的环境信息。如果是web程序，创建StandardServletEnvironment；否则，创建StandardEnvironment
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    // 配置环境信息。比如profile，命令行参数
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    // 广播出ApplicationEnvironmentPreparedEvent事件给相应的监听器执行
    listeners.environmentPrepared(environment);
    // 环境信息的校对
    if (!this.webEnvironment) {
        environment = new EnvironmentConverter(getClassLoader())
                .convertToStandardEnvironmentIfNecessary(environment);
    }
    return environment;
}

2.创建Spring容器上下文

protected ConfigurableApplicationContext createApplicationContext() {
    Class contextClass = this.applicationContextClass;
    if (contextClass == null) {
        try {
            // 判断是否是web应用，
            // 如果是则创建AnnotationConfigEmbeddedWebApplicationContext，否则创建AnnotationConfigApplicationContext
            contextClass = Class.forName(this.webEnvironment
                    ? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
        }
        catch (ClassNotFoundException ex) {
            throw new IllegalStateException(
                    "Unable create a default ApplicationContext, "
                            + "please specify an ApplicationContextClass",
                    ex);
        }
    }
    return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
}

3.配置Spring容器上下文

private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    // 设置Spring容器上下文的环境信息
    context.setEnvironment(environment);
    // Spring容器创建之后做一些额外的事
    postProcessApplicationContext(context);
    // SpringApplication的初始化器开始工作
    applyInitializers(context);
    // 遍历调用SpringApplicationRunListener的contextPrepared方法。目前只是将这个事件广播器注册到Spring容器中
    listeners.contextPrepared(context);
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }

    // 把应用程序参数持有类注册到Spring容器中，并且是一个单例
    context.getBeanFactory().registerSingleton("springApplicationArguments",
            applicationArguments);
    if (printedBanner != null) {
        context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
    }

    // 加载sources，sources是main方法所在的类
    Set