简介

母ISSUE：https://github.com/peteryuanpan/notebook/issues/28
视频地址：https://www.bilibili.com/video/BV1Ct411g78e
从头到尾记录一遍，把SpringBoot基础打一打
部署一个简单的服务出来，再定下一步

总结

P2：SpringBoot的背景。是Spring团队于2014年基于Spring4.0开发的框架，底层是Spring技术栈，特点是非常简洁，开发效率高，只需要简单的配置即可部署服务，还有，使用嵌入式的Servlet容器，starters自动依赖与版本控制，准生产环境的运用时应用监控等等优势，但不要止步于SpringBoot，后续需要对Spring框架有更深入的了解
P5： 1）介绍了如何实现一个最简单的SpringBoot之Get localhost:8080//hello接口，返回"HelloWorld"字符串，几个步骤：一，intelliJIDEA中创建maven工程；二，pom.xml中导入maven依赖；三，编写Application类，用于启动SpringBoot；四，编写Controller类，用于定义接口。然后run即可启动服务了 2）介绍了maven install成.jar文件的方法，需要在pom.xml中导入build.plugins.pulgin，注意也需要导入parent，否则会报错
P6：SpringBoot 将所有的功能场景都抽取出来了，作为一个个的starters（启动器），只需要在项目里面引入这些starter相关场景的所有依赖，要用什么功能就导入什么场景的starter。1.5.9版本的starters列表可以于 https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#using-boot-starter 查看
P7：初步介绍了SpringBoot自动配置原理，在@SpringBootConfiguration源码中，含有@SpringBootConfiguration、@EnableAutoConfiguration，在@EnableAutoConfiguration源码中，含有@AutoConfigurationPackage、@Import({EnableAutoConfigurationImportSelector.class})，其中前者将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里的所有组件扫描到Spring容器中，后者从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中
P8：介绍了如何使用Spring Initializer（Spring Assistant）快速创建项目，其中https://start.spring.io/ 网页版也可以自动生成demo.zip，介绍了@RestController注解，介绍了java/resources下自动生成的文件/文件夹的作用，其中application.properties用于修改默认配置，比如填写server.port=8081，则可修改默认端口号

后续

P3：微服务的具体原理是什么？martin fowler于2014年发表了关于微服务的博客（参考 https://martinfowler.com/microservices/ ），形象生动的介绍了微服务的理念，从此后微服务面世，这篇文章有译文吗？原文也看一下吧
P4：http://www.gulixueyuan.com/ ，谷粒学院 - JAVA培训营，这里有不少东西，淘一下？
P7：芋芋的文章也有自动配置相关的，也看一遍？http://www.iocoder.cn/Spring-Boot/autoconfigure/?vip

P1

SQL与NoSQL的区别
Elasticsearch

P2

SpringBoot HelloWorld
SpringBoot 是 Spring团队于2014年基于Spring4.0开发的框架
https://spring.io/projects
SpringBoot 特点是简洁，开发效率高，底层是Spring技术栈

SpringBoot优点

快速创建独立运行的Spring项目以及与主流框架集成
使用嵌入式的Servlet容器，应用无需打成WAR包
starters自动依赖与版本控制
大量的自动配置，简化开发，也可以修改默认值
无需配置XML，无代码生成，开箱即用
准生产环境的运用时应用监控
与云计算天然集成

SpringBoot缺点

入门容易，精通难，需要对Spring框架有更深入的了解

P3

martin fowler于2014年发表了关于微服务的博客（参考 https://martinfowler.com/microservices/ ），形象生动的介绍了微服务的理念，从此后微服务面世
微服务是一种架构风格，其中一个应用应该是一组小型服务，小型服务之间通过HTTP协议进行互通
微服务先前的业务模式即单体应用，Browser - Apache - Tomcat（WAR..）- MySQL Database，优势是简单，缺点是牵一发而动全身
一个单体应用程序把它所有的功能放在一个单一进程中，一个微服务架构把每个功能元素放入一个可独立替换和独立升级的软件单元
微服务模式图有点像宇宙星体图
YourApp ~ SpringBoot - SpringCloud - SpringCloudDataFlow，SpringBoot快速构建出一个的应用，SpringCloud将多个应用进行网状互联互调，SpringClouDataFlow进行分布式流式计算批处理

P4

http://www.gulixueyuan.com/ ，谷粒学院 - JAVA培训营
环境要求：jdk1.8、Maven 3.3+、IntelliJIDEA2017+、SpringBoot1.5.9.RELEASE

P5

编写SpringBoot HelloWorld
浏览器发送请求hello请求，服务器接收请求并处理，响应Hello World字符串
IntelliJIDEA，project，创建maven工程，JDK1.8
spring-boot-01-helloworld

导入maven依赖

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>1.5.9.RELEASE</version>
</dependency>

编写代码 HelloWorldMainApplication.java
```
package com.example;
```

import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

@SpringBootApplication来标注一个主程序类，说明这是一个SpringBoot应用 */ @SpringBootApplication public class HelloWorldMainApplication {

public static void main(String[] args) { // 启动Spring应用 SpringApplication.run(HelloWorldMainApplication.class, args); }

}

HelloController.java
```java
package com.example.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    @ResponseBody
    @RequestMapping("/hello")
    public String hello() {
        return "Hello World!";
    }

}

访问http://localhost:8080/hello 即可获得 Hello World!
进入 https://spring.io/projects/spring-boot 点击Learn，找到最新版本，点击Reference Doc. https://docs.spring.io/spring-boot/docs/2.3.1.RELEASE/reference/html/ ，点击Getting Started，搜索Creating an Executable Jar https://docs.spring.io/spring-boot/docs/2.3.1.RELEASE/reference/html/getting-started.html#getting-started-first-application-executable-jar TODO：上面这小段要读一下

将文档中的插件导入到pom.xml中

<build>
<plugins>
    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
</plugins>
</build>

在intelliJIDEA中，找到maven project，spring-boot-01-helloworld，Lifecycle，点击package，build完成后，project中多出了target，spring-boot01-helloworld-1.0-SNAPSHOT.jar
命令行执行时报了错误 C:\Users\Admin\Desktop\plan\2020\SSM-CRUD\spring-boot-01-helloworld\target>java -jar spring-boot-01-helloworld-1.0-SNAPSHOT.jar spring-boot-01-helloworld-1.0-SNAPSHOT.jar中没有主清单属性参考解决办法 https://my.oschina.net/u/3523885/blog/1557350 https://blog.csdn.net/chengyuqiang/article/details/88122777 原因是打包出.jar中，META-INF文件夹下MANIFEST.MF文件缺少定义jar接口类，即缺少Main-Class 将.jar解压后，看到META-INF\MAINFEST.MF内容如下
```
Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Built-By: Admin
Created-By: Apache Maven 3.6.1
Build-Jdk: 1.8.0_231
```
预期是有这么一行，但是没有
```
Main-Class: com.example.HelloWorldMainApplication
```
尝试了从project structure中添加META-INF/MAINFEST.MF到resources下，再到maven project中运行clean、package，但依然没用 如何让.jar的MANIFEST.MF文件内容拥有Main-Class？

在第二次尝试的时候找到了问题所在原因是之前在编写pom.xml时做了偷懒

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>

上面这一段没有写进去，导致maven install时，最终.jar中MANIFEST.MF文件内容不符合预期添加了上面这段到pom.xml后，重新maven clean，maven install，即可在cmd下运行 java -jar spring-boot-01-helloworld-1.0-SNAPSHOT.jar了，并且还发现上面两个网上的解决方案，实则没有需要

TODO：为何如上设置后访问http://222.65.254.216:8080/hello 无法打开？ 其中222.65.254.216是本机IP 猜测应该是防火墙的问题

P6

pom.xml，按住ctrl，用鼠标左键点击具体的artifactId，可以跳转到artifactId的pom.xml中，在Maven Projects中也能查看依赖树状关系

spring-boot-starter是场景启动器，帮导入了web模块相关的依赖其具体dependencies如下

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator</artifactId>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
    </dependency>
</dependencies>

进入 https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/ ，搜索starters，找到13.5. Starters，点击进入到 #using-boot-starter，可以看到相关依赖比如 spring-boot-starter-activemq、spring-boot-starter-aop、spring-boot-starter-data-jpa、spring-boot-starter-data-redis、spring-boot-starter-mail等等

spring boot 将所有的功能场景都抽取出来了，作为一个个的starters（启动器），只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来，要用什么功能就导入什么场景的starter

P7

@SpringBootApplication注解，标注在某个类上，说明该类是SpringBoot的主配置类，SpringBoot应该运行该类的Main方法来启动应用

同样的，按住ctrl，点击@SpringBootApplication，可以进入具体的SpringBootApplication.class中，查看源码可以看到@SpringBootApplication是一个组合注解，内容如下

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)

其中@SpringBootConfiguration，表示一个SpringBoot的配置类，再点进去，可以看到源码如下

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

其中@Configuration，表示一个Spring的配置类，关联配置文件（这一块知识与Spring原理有关，可深入了解下），配置类也是容器中的一个组件：@Component

还有@EnableAutoConfiguration，表示让SpringBoot对该类开启自动配置功能代码如下

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({EnableAutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

Class<?>[] exclude() default {};

String[] excludeName() default {};
}

其中有@AutoConfigurationPackage，表示自动配置包

其中有如@Import(AutoConfigurationPackages.Registrar.class)形式注解，该具体类，将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里的所有组件扫描到Spring容器中

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    Registrar() {
    }

    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
    }

    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
    }
}

启动HelloWorld程序，对new AutoConfigurationPackages.PackageImport(metadata)).getPackageName()这一行打个断点，用Evaluate Expression计算一下，包名是叫做com.example，也就是主包

还有注解@Import({EnableAutoConfigurationImportSelector.class})，import(x)的意思是给容器导入组件x，EnableAutoConfigurationImportSelector看源码，再找到AutoConfigurationImportSelector源码，可看到selectImports方法，即是告诉容器具体需要导入哪些组件

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    } else {
        try {
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            configurations = this.removeDuplicates(configurations);
            configurations = this.sort(configurations, autoConfigurationMetadata);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return (String[])configurations.toArray(new String[configurations.size()]);
        } catch (IOException var6) {
            throw new IllegalStateException(var6);
        }
    }
}

断点查看List configurations即可知道，会给容器中导入非常多的自动配置类（xxxAutoConfiguration），起作用是：给容器中导入并配置该场景所需要的组件。
上面代码中还有getCandidateConfigurations方法，进入后看到SpringFactoriesLoader.loadFactoryNames，再进入看到classLoader.getResources("META-INF/spring.factories") 总结下即是，SpringBoot在启动的时候，从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效了，然后可进行自动配置工作了。

TODO

P7初步讲了SpringBoot自动配置的原理，挺重要的，可以结合其他资料再看一遍
芋芋的文章也有自动配置相关的，也看一遍？http://www.iocoder.cn/Spring-Boot/autoconfigure/?vip
上面@AutoConfigurationPackage与@Import({EnableAutoConfigurationImportSelector.class})作用和区别分别是什么？答：前者将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里的所有组件扫描到Spring容器中，后者从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中区别：前者管辖的是主程序代码package下的所有组件，后者管辖的是spring工程相关的内置组件

P8

使用Spring Initializer快速创建SpringBoot项目
IDEA9里面，File - New project - Spring Assistant（要安装一下插件，网上搜），选择1.8，Default https://start.spring.io ，next
groupid: com.example；artifactid：spring-boot-01-helloworld-quick，next
界面中可以选择需要使用的模块，即对应上面所提的starter 不妨选择spring-web，点击next
再点击next，即可生成项目了
查看pom.xml如下，与之前生成的类似

其中这个dependency是单元测试类

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
...
</dependency>

发现主类主函数是自动帮忙生成了的
再编写一个RestController
```
package com.example.demo.controller;
```

import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController;

/ @ResponseBody // 这个类的所有方法返回的数据值直接写给浏览器（如果是对象转为json数据） @Controller / @RestController // 内置包含了上面2个注解 public class HelloController {

@RequestMapping("/hello")
public String hello() {
    return "hello world quick!";
}

}


- run起来，访问http://localhost:8080/hello ，可以得到结果
![image](https://user-images.githubusercontent.com/10209135/88123495-8f538000-cbfd-11ea-93ba-acc4f500272f.png)
- 看java/resources文件夹中，自动创建好了static文件夹、teamplates文件夹、application.properties
- static文件夹用于保存所有静态资源（js、css、teamplate）
- templates文件夹用于保存所有模板页面，SpringBoot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面，但可以使用模板引擎，比如freemarker、thymeleaf
**TODO：这里记一下，不太明白模板引擎具体含义，视频中说后续会再详细说**
- application.properties可以修改SpringBoot默认的应用配置文件，比如填写**server.port=8081**，则会修改端口号，此时需要访问http://localhost:8081/hello ，而非 http://localhost:8080/hello
**TODO：配置文件中参数有哪些，该怎么写？视频中说后续会再详细说**

peteryuanpan / notebook

尚硅谷 SpringBoot 视频教程全集（P1 ~ P8） #23

简介

总结

后续

P1

P2

P3

P4

P5

P6

P7

P8