SpringBoot

什么是SpringBoot？

SpringBoot是一个快速开发的框架，能过快速整合第三方框架，他是如何快速整合的呢？其实它根据的基本原理是Maven依赖关系，Maven的集成，完全采用注解化，简化XML配置，内嵌HTTP服务器（Tomcat，jetty），默认嵌入Tomcat，最终以Java应用程序进行执行。

SpringBoot原理：Maven依赖关系，Maven的继承，完全采用注解化，Spring3.0以后采用注解方式启动SpringMVC。

为什么要用SpringBoot？

以往的项目整合起来是比较繁琐复杂的，而且存在jar包冲突的问题，这时候SpringBoot应运而生了，SpringBoot也就是用来做这个的。

SpringBoot启动方式？

Springboot启动方式主要有三种。

1. 运行带有main方法类
   这种比较简单，直接在idea或者eclipse中执行项目中的启动类。
2. 通过命令行 java -jar 的方式
   将项目打包成jar包，用Java命令直接启动。
3. 通过spring-boot-plugin的方式
   如果需要正常使用该maven插件，需要我们在maven项目中增加以下插件配置:

org.springframework.boot
spring-boot-maven-plugin

准备工作做好之后，我们需要进入项目的根目录，执行
mvn spring-boot:run

SpringBoot与SpringMVC 区别？

springboot是约定大于配置，可以简化spring的配置流程；
springmvc是基于servlet的mvc框架，个人感觉少了model中的映射。
以前web应用要使用到tomat服务器启动，而springboot内置服务器容器，通过@SpringBootApplication中注解类中main函数启动即可。

怎么理解springboot的约定大于配置

百度意思：约定优于配置（convention over configuration），也称作按约定编程，是一种软件设计范式，旨在减少软件开发人员需做决定的数量，获得简单的好处，而又不失灵活性。

在SpringBoot中，约定大于配置可以从以下两个方面来理解：

• 开发人员仅需规定应用中不符合约定的部分
• 在没有规定配置的地方，采用默认配置，以力求最简配置为核心思想

总的来说，上面两条都遵循了推荐默认配置的思想。当存在特殊需求的时候，自定义配置即可。这样可以大大的减少配置工作，这就是所谓的“约定”。

SpringBoot与SpringCloud 区别？

Spring Boot是一种快速开发技术实现，约定大于配置；Spring Cloud提供了微服务系统中一站式的解决方案，每个微服务方案都以Spring Boot为基础。

SpringBoot中用哪些注解？

1. @SpringBootApplication：包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中@ComponentScan让spring Boot扫描到Configuration类并把它加入到程序上下文。
2. @Configuration 等同于spring的XML配置文件；使用Java代码可以检查类型安全。
3. @EnableAutoConfiguration 开启自动配置。
4. @ComponentScan 组件扫描，可自动发现和装配一些Bean。
5. @Component可配合CommandLineRunner使用，在程序启动后执行一些基础任务。
6. @RestController注解是@Controller和@ResponseBody的合集,表示这是个控制器bean,并且是将函数的返回值直接填入HTTP响应体中,是REST风格的控制器。
7. @Autowired自动导入。
8. @PathVariable获取参数。
9. @JsonBackReference解决嵌套外链问题。
10. @RepositoryRestResourcepublic配合spring-boot-starter-data-rest使用。

@EnableAutoConfiguration作用？

一是收集所有spring.factories中EnableAutoConfiguration相关bean的类，初始化为一个相关的bean；
二是将得到的类注册到spring容器中，启动自动化配置。

@SpringBootApplication原理？

springboot底层实现自动配置的步骤：

1. springboot应用启动
2. @SpringBootApplication起作用
3. @EnableAutoConfiguration 自动配置
4. @AutoConfigurationPackage：这个组合注解主要是@Import(AutoConfigurationPackages.Registrar.class)，它通过将Registrar类导入到容器中，而Registrar类作用是扫描主配置类同级目录以及子包，并将相应的组件导入到springboot创建管理的容器中
5. @Import(AutoConfigurationImportSelector.class)：它通过将AutoConfigurationImportSelector类导入到容器中，AutoConfigurationImportSelector类作用是通过selectImports方法实现将配置类信息交给SpringFactory加载器进行一系列的容器创建过程。

SpringBoot热部署使用什么？

使用spring提供的devtools

热部署原理是什么？

原理就是重启项目,但比手动重启快多了,其深层原理是使用了两个ClassLoder,一个ClassLoader加载哪些不会改变的类(第三方jar包),另一个ClassLoader加载会更改的类.称之为restart ClassLoader,这样在有代码更改的时候,原来的restart Classloader被丢弃,重新创建一个restart ClassLoader,由于需要加载的类相比较少,所以实现了较快的重启时间(5秒以内)

热部署原理与热加载区别是什么？

部署方式
热部署在服务器运行时重新部署项目
热加载在运行时重新加载class

实现原理
热部署直接重新加载整个应用
热加载在运行时重新加载class

使用场景
热部署更多的是在生产环境使用
热加载则更多的实在开发环境使用

热加载几乎没有
安全性，直接修改Java虚拟机中的字节码文件，难以监控和控制
热加载有个通俗的名字就是开发者模式

你们项目中异常是如何处理？

SpringBoot的项目已经对有一定的异常处理了，但是对于我们开发者而言可能就不太合适了，因此我们需要对这些异常进行统一的捕获并处理。SpringBoot中有一个@ControllerAdvice的注解，使用该注解表示开启了全局异常的捕获，我们只需在自定义一个方法使用@ExceptionHandler注解然后定义捕获异常的类型即可对这些捕获的异常进行统一的处理。

SpringBoot如何实现异步执行？

1、在application启动类中，加上@EnableAsync注解，Spring Boot 会自动扫描异步任务。
2、创建AsyncTask 异步任务类，加上@Component 注解，然后在需要异步执行的方法前面加上@Async注解，这样Spring Boot容器扫描到相关异步方法之后，调用时就会将这些方法异步执行。
3、最后调用任务类里面的方法

SpringBoot多数据源拆分的思路？

在一个项目中多数据源如何划分：1.分包名（业务） 2.注解方式

SpringBoot多数据源事务如何管理？

这里需要使用jta-atomikos进行事务管理。

SpringBoot如何实现打包？

springboot的打包方式有很多种。有打成war的，有打成jar的，也有直接提交到github，通过jekins进行打包部署的。

SpringBoot性能如何优化？

1. Tomcat覆盖默认配置

server:
  tomcat:
    max-connections: 2000
    accept-count: 100
    threads:
      max: 800
      min-spare: 100
  max-http-header-size: 131072

2. 优化线程池配置

@EnableAsync
@Configuration
public class AsyncConfig {
    public static final int CPUNMU = Runtime.getRuntime().availableProcessors();

    @Bean(name = "taskExecutor")
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(CPUNMU);
        executor.setMaxPoolSize(CPUNMU * 25);
        executor.setQueueCapacity(5000);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("Async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        return executor;
    }
}  

3. 增加数据库连接池

 @Primary
    @Bean(name = "dataSource")
    public DataSource dsDataSource(Environment environment) throws IOException {
       try{
        SQLServerDataSource ds = new SQLServerDataSource();
        HikariDataSource ds2 = new HikariDataSource();
        ds2.setDataSource(ds);
        ds2.setMaximumPoolSize(100);
        ds2.setConnectionTimeout(1800000);
        ds2.setPoolName("DataSource-");
        ds2.setMinimumIdle(20);
    } catch (Exception e) {
        logger.error("Config error: {}", e.getMessage());
    }

    return ds2; 
    }

4. 增加缓存(SpringBoot Cache)

// Constant info cache
private static Map constantCache = new ConcurrentHashMap<>(1024 * 5);
// token cache
private static Map tokenCache = new ConcurrentHashMap<>(1024 * 5);

5. 优化索引
6. 增加Pod数量
7. 增加Ingress数量
8. 升级数据库的DTU
9. 第三方API采用多线程调用

创建
completedFuture    
supplyAsync        无参有返回值
runAsync        无参无返回值

whenComplete                

thenApply    有参有返回值
thenAccept     有参无返回值
thenRun        无参无返回值

Scheduled job 增加@Async指定线程池，避免获取不到线程等等
@Async("xxxThreadPool")

ExecutorService pool = new ThreadPoolExecutor(0, 4,
        20L, TimeUnit.SECONDS,
        new SynchronousQueue<>(), new ThreadPoolExecutor.CallerRunsPolicy());
long start = System.currentTimeMillis();
List list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    final int t = i;
    System.out.println("---" + t);
    list.add(CompletableFuture.supplyAsync(() -> {
        System.out.println("A- " + t + " - " + Thread.currentThread().getName());
        try {
            Thread.sleep(3 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "A- " + t;
    }, pool));
}

CompletableFuture all = CompletableFuture.allOf(list.toArray(new CompletableFuture[list.size()]));
try {
    all.get();
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}
boolean done = all.isDone();
System.out.println("all done = " + done + " use:" + (System.currentTimeMillis() - start));
System.out.println(LocalDateTime.now());

11. blob文件上传下载采用多线程
12. 异步日志

SpringBoot2.0新特性？

1、基于 Java 8，支持 Java 9
也就是说Spring Boot2.0的最低版本要求为JDK8，据了解国内大部分的互联网公司系统都还跑在JDK1.6/7上，因此想要升级到Spring Boot2.0的同学们注意啦，同时支持了Java9，也仅仅是支持而已。
2、响应式编程
使用 Spring WebFlux/WebFlux.fn提供响应式 Web 编程支持， Webflux 是一个全新的非堵塞的函数式 Reactive Web 框架，可以用来构建异步的、非堵塞的、事件驱动的服务，在伸缩性方面表现非常好，此功能来源于Spring5.0。
Spring Boot2.0也提供对响应式编程的自动化配置，如：Reactive Spring Data、Reactive Spring Security 等
3、HTTP/2支持
在Tomcat, Undertow 和 Jetty 中均已支持 HTTP/2
4、对Kotlin支持
引入对 Kotlin 1.2.x 的支持，并提供了一个 runApplication 函数，让你通过惯用的 Kotlin 来运行 Spring Boot 应用程序。
5、全新的执行器架构
全新的执行器架构，支持 Spring MVC, WebFlux 和 Jersey
6、支持 Quartz
Spring Boot1.0并没有提供对 Quartz 的支持，之前出现了各种集成方案，Spring Boot2.0给出了最简单的集成方式。
7、Security
大大的简化了安全自动配置
8、Metrics
Metrics 方面，Spring Boot 2引入了Micrometer，来统一metrics的规范，使得开发人员更好的理解和使用metrics的模块，而不需要关心对接的具体存储是什么。
9、监控方面
Spring Boot 2 增强了对 Micrometer 的集成。RabbitMQ、JVM 线程和垃圾收集指标会自动进行 instrument 监控，异步控制器(controller)也会自动添加到监控里。通过集成，还可以对 InfluxDB 服务器进行监控。
10、数据方面
db方面，默认引入了HikariCP，替代了之前的tomcat-pool作为底层的数据库连接池， 对比于tomcat-pool， HikariCP拥有更好的性能，总而言之就是提高了db的访问速度
JOOQ的支持
Redis方面， 默认引入了Lettuce, 替代了之前的jedis作为底层的redis链接方式
MongoDBHibernate优化
11、Thymeleaf 3
Spring Boot 2支持了Thymeleaf 3，Thymeleaf 3相对于Thymeleaf 2性能提升可不是一点点，因为2.0的性能确实不咋地，同时也使用了新的页面解析系统。
12、OAuth 2.0
同时也加入了 对于OAuth 2.0的支持， 使得开发人员更加友好的使用spring-security来完成权限模块的开发
13、依赖组件的更新
Jetty 9.4
Tomcat 8.5
Flyway 5
Hibernate 5.2
Gradle 3.4
Thymeleaf 3.0

SpringBoot执行流程？

（1）创建 Spring Application 实例，调用 run 方法，同时将启动入口类作 为参数传递进去，由此开始了 Spring Boot 内部相关核心组件以及配置的启动和加载；

（2）通过 Spring Factories Loader 加载 META-INF/spring.factories 文 件，获取并创建 SpringApplicationRunListener 对象；

（3）然后由 SpringApplicationRunListener 来发出 starting 消息；

（4）创建参数，并配置当前 SpringBoot 应用需要使用的 Environment 实 例；

（5）完成之后，依然由 SpringApplicationRunListener 来发出 environmentPrepared 消息；

（6）创建 Spring 的应用上下文实例：ApplicationContext，初始化该实例 并设置应用环境配置实例：Environment，同时加载相关的配置项；

（7）由 SpringApplicationRunListener 发出 contextPrepared 消息，告 知 SpringBoot 应用当前使用的 ApplicationContext 已准备完毕；

（8）将各种 Bean 组件装载入 Spring 的 IO 容器/应用上下文： ApplicationContext 中，继续由 SpringApplicationRunListener 来发出 contextLoaded 消息，告知 SpringBoot 应用当前使用的 ApplicationContext 已准备完毕；

（9）重新刷新 Refresh Spring 的应用上下文实例：ApplicationContext， 完成 IOC 容器可用的最后一步；

（10）由 SpringApplicationRunListener 发出 started 消息，完成最终的 程序的启动；

（11）由 SpringApplicationRunListener 发出 running 消息，告知程序已成功运行起来了。

SpringBoot底层实现原理？

1. maven
   子父依赖关系，快速整合第三方框架

2. 无配置文件
   省略了web.xml，spring.xml，springmvc.xml.mybatis.xml。
   spring3.0以上提供注解，springboot通过java语言编写springmvc配置初始化，包括访问路径，视图解析器，也初始化非springmvc配置文件

3. 内置tomcat
   通过java语言创建tomcat，读取class文件到内存，由tomcat执行

SpringBoot装配Bean的原理？

就是Spring装配bean的原理，springboot就是在spring框架的基础上进行封装的。