Spring Boot笔记

1、什么是SpringBoot 1、简介

就是一个javaweb的开发框架

以前Spring的配置太多，太麻烦，为了提高开发效率，于是开始提倡“约定大于配置”，进而衍生出一些一站式的解决方案。
Spring Boot 基于 Spring 开发，Spirng Boot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。
也就是说，它并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发者体验的工具。
Spring Boot 以约定大于配置的核心思想，默认帮我们进行了很多设置，多数 Spring Boot 应用只需要很少的 Spring 配置。

简单来说就是SpringBoot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了所有的框架。

2、优点

为所有Spring开发者更快的入门
开箱即用，提供各种默认配置来简化项目配置
内嵌式容器简化Web项目
没有冗余代码生成和XML配置的要求

3、微服务架构

微服务是一种架构风格，他要求我们在开发一个应用的时候，这个应用必须建成一系列小服务组合，可以通过http方式进行通信。

所谓微服务加购，就是打破之前all in one的架构方式，把每个功能元素独立出来，把独立出来的功能元素的动态组合，需要的功能元素才去拿来组合，需要多一些可以整合多个功能元素，所以微服务架构是对功能元素进行赋值，而没有对整个应用进行复制，这样做的好处是：

节省了调用资源
每个功能元素的服务都是一个可替换的，可独立升级的软件代码

程序核心：

高内聚（在划分模块时，要把功能关系紧密的放到一个模块中）
低耦合（模块之间的联系越少越好，接口越简单越好）

springboot：快速构建一个个功能独立的微服务应用单元
springcloud：大型分布式网络服务的调用
spring cloud data flow：在分布式中间，进行流式数据计算

2、第一个SpringBoot程序 2.1、项目创建

使用 IDEA 直接创建项目

创建一个新项目
选择spring initalizr ，可以看到默认就是去官网的快速构建工具那里实现
填写项目信息
选择初始化的组件（初学勾选 Web 即可）
填写项目路径
等待项目构建成功

2.2、项目结构分析

程序的主启动类（程序的主入口）
一个 application.properties 配置文件（SpringBoot的核心配置文件）
一个测试类
一个 pom.xml

2.3、HelloWorld项目

引入依赖



    org.springframework.boot
    spring-boot-starter-parent
    2.2.5.RELEASE
    



    
    
        org.springframework.boot
        spring-boot-starter-web
    
    
    
        org.springframework.boot
        spring-boot-starter-test
        test
        
        
            
                org.junit.vintage
                junit-vintage-engine
            
        
    



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

创建主程序

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

@SpringBootApplication
public class MainApplication {

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

编写业务

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

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(){
        return "Hello, Spring Boot 2!";
    }
}

运行&测试

运行MainApplication类
浏览器输入http://localhost:8888/hello，将会输出Hello, Spring Boot 2!。

设置配置
maven工程的resource文件夹中创建application.properties文件。

# 设置端口号
server.port=8888

打包部署
在pom.xml添加


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

在IDEA的Maven插件上点击运行 clean 、package，把helloworld工程项目的打包成jar包，
打包好的jar包被生成在helloworld工程项目的target文件夹内。
用cmd运行java -jar boot-01-helloworld-1.0-SNAPSHOT.jar，既可以运行helloworld工程项目。
将jar包直接在目标服务器执行即可。

2.4、SpringBoot特点 2.4.1、SpringBoot依赖管理特性

父项目做依赖管理

依赖管理 
有一个父项目   

        org.springframework.boot
        spring-boot-starter-parent
        2.3.4.RELEASE


上面项目的父项目如下：
 
    org.springframework.boot
    spring-boot-dependencies
    2.3.4.RELEASE
  

几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制

开发导入starter场景启动器

1、见到很多 spring-boot-starter-* ： *就某种场景
2、只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
3、SpringBoot所有支持的场景
https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
4、见到的  *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。
5、所有场景启动器最底层的依赖


  org.springframework.boot
  spring-boot-starter
  2.3.4.RELEASE
  compile

无需关注版本号，自动版本仲裁

1、引入依赖默认都可以不写版本
2、引入非版本仲裁的jar，要写版本号。

可以修改默认版本号

1、查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
2、在当前项目里面重写配置
    
        5.1.43

2.4.2、自动配置

自动配好Tomcat

引入Tomcat依赖。

配置Tomcat


	org.springframework.boot
	spring-boot-starter-tomcat
	2.3.4.RELEASE
	compile

自动配好SpringMVC

引入SpringMVC全套组件
自动配好SpringMVC常用组件（功能）

自动配好Web常见功能，如：字符编码问题

SpringBoot帮我们配置好了所有web开发的常见场景

public static void main(String[] args) {
    //1、返回我们IOC容器
    ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

    //2、查看容器里面的组件
    String[] names = run.getBeanDefinitionNames();
    for (String name : names) {
        System.out.println(name);
    }
}

默认的包结构

主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
无需以前的包扫描配置

想要改变扫描路径

@SpringBootApplication(scanBasePackages=“com.guo”)
@ComponentScan 指定扫描路径

 @SpringBootApplication
 等同于
 @SpringBootConfiguration
 @EnableAutoConfiguration
 @ComponentScan("com.guo.boot")

2.5、容器功能 2.5.1、组件添加

@Configuration

@Configuration用于定义配置类，可替换xml配置文件，这个时候在类里边不能写bean标签了需要使用@bean注解，被注解的类内部包含有一个或多个被@Bean注解的方法
@bean：给容器中添加组件，以方法名作为组件的id。返回类型为组件类型，返回的值，就是组件在容器中的实例

Full模式(全配置)和Lite模式（轻量级配置）

#############################Configuration使用示例######################################################

@Configuration(proxyBeanMethods = true) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {

    
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}


################################@Configuration测试代码如下########################################
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.atguigu.boot")
public class MainApplication {

    public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        //3、从容器中获取组件

        Pet tom01 = run.getBean("tom", Pet.class);

        Pet tom02 = run.getBean("tom", Pet.class);

        System.out.println("组件："+(tom01 == tom02));


        //4、com.atguigu.boot.config.MyConfig$$EnhancerBySpringCGLIB$$51f1e1ca@1654a892
        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        //如果@Configuration(proxyBeanMethods = true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
        //保持组件单实例
        User user = bean.user01();
        User user1 = bean.user01();
        System.out.println(user == user1);


        User user01 = run.getBean("user01", User.class);
        Pet tom = run.getBean("tom", Pet.class);

        System.out.println("用户的宠物："+(user01.getPet() == tom));

    }
}

@Import

给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
}

@Conditional（条件装配注解）
条件装配：当满足Conditional指定的条件，则进行组件注入

当这个注解配置在类上时，只有这个类内注入了响应名称的组件才会生成相应的实体，
当配置在部分方法时，只有相应的被注入才可以生成实体，否则就不生效

=====================测试条件装配==========================
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
//@ConditionalOnBean(name = "tom")
@ConditionalOnMissingBean(name = "tom")
public class MyConfig {

    

    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom22")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}

public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        boolean tom = run.containsBean("tom");
        System.out.println("容器中Tom组件："+tom);

        boolean user01 = run.containsBean("user01");
        System.out.println("容器中user01组件："+user01);

        boolean tom22 = run.containsBean("tom22");
        System.out.println("容器中tom22组件："+tom22);
    }

2.5.2、原生配置文件引入

@ImportResource

比如，公司使用bean.xml文件生成配置bean，然而你为了省事，想继续复用bean.xml，@ImportResource粉墨登场。

bean.xml：

使用方法：

@ImportResource("classpath:beans.xml")
public class MyConfig {
...
}

测试类：

public static void main(String[] args) {
    //1、返回我们IOC容器
    ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

	boolean haha = run.containsBean("haha");
	boolean hehe = run.containsBean("hehe");
	System.out.println("haha："+haha);//true
	System.out.println("hehe："+hehe);//true
}

2.5.3、配置绑定

如何使用Java读取到properties文件中的内容，并且把它封装到JavaBean中，以供随时使用；

传统方法

public class getProperties {
     public static void main(String[] args) throws FileNotFoundException, IOException {
         Properties pps = new Properties();
         pps.load(new FileInputStream("a.properties"));
         Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
         while(enum1.hasMoreElements()) {
             String strKey = (String) enum1.nextElement();
             String strValue = pps.getProperty(strKey);
             System.out.println(strKey + "=" + strValue);
             //封装到JavaBean。
         }
     }
 }

Spring Boot一种配置配置绑定：
@ConfigurationProperties + @Component
注意想要使用这个注解必须声明组件注解@Component

假设有配置文件application.properties

mycar.brand=BYD
mycar.price=100000

只有在容器中的组件，才会拥有SpringBoot提供的强大功能

@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
...
}

Spring Boot另一种配置配置绑定：
@EnableConfigurationProperties + @ConfigurationProperties

开启Car配置绑定功能
把这个Car这个组件自动注册到容器中

@EnableConfigurationProperties(Car.class)
public class MyConfig {
...
}

@ConfigurationProperties(prefix = "mycar")
public class Car {
...
}

3、自动配置原理初探 1、pom.xml

Spring-boot-dependencies:核心依赖在父工程中
我们在写或者引入springboot依赖的时候，不需要指定版本，因为有这些版本仓库

启动器



  org.springframework.boot
  spring-boot-starter

启动器：说白了就是Springboot的启动场景
比如spring-boot-starter-web，他就会帮我们自动导入web环境所有的依赖
springboot会将所有的功能场景，都变成一个个的启动器
我们要使用什么功能，就值需要找到对应的启动器starter

2、主程序

//标注这个类是一个springboot的应用
@SpringBootApplication
public class SpringbootStudyApplication {
    public static void main(String[] args) {
        //将springboot应用启动
        SpringApplication.run(SpringbootStudyApplication.class, args);
    }
}

分析下@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}
)}
)
public @interface SpringBootApplication {
    ...
}

重点分析

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

1、@SpringBootConfiguration

作用：SpringBoot的配置类，标注在某个类上，表示这是一个SpringBoot的配置类；
@Configuration 说明这是一个配置类，配置类就是对应Spring的xml 配置文件；

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

2、@ComponentScan

指定扫描哪些Spring注解
作用：自动扫描并加载符合条件的组件或者bean ，将这个bean定义加载到IOC容器中

3、@EnableAutoConfiguration

@EnableAutoConfiguration ：开启自动配置功能
以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置；
@EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置才能生效；

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

    Class[] exclude() default {};

    String[] excludeName() default {};
}

重点分析
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)

4、@AutoConfigurationPackage

翻译：自动配置包，指定了默认的包规则

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(Registrar.class)//给容器中导入一个组件

//利用Registrar导入一系列组件
//将指定的一个包下的所有组件导入进来？是主程序所在的包下
public @interface AutoConfigurationPackage {
 
}

@import ：Spring底层注解@import ，给容器中导入一个组件
利用Registrar给容器中导入一系列组件。将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器；

5、@Import({AutoConfigurationImportSelector.class})

给容器导入组件

利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
调用List configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
利用工厂加载 Map loadSpringFactories(@Nullable ClassLoader classLoader);得到所有的组件
从META-INF/spring.factories位置来加载一个文件。
- 默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
- spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

# 文件里面写死了spring-boot一启动就要给容器中加载的所有配置类
# spring-boot-autoconfigure-2.3.4.RELEASE.jar/META-INF/spring.factories
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,
...

虽然我们127个场景的所有自动配置启动的时候默认全部加载，但是xxxxAutoConfiguration按照条件装配规则（@Conditional），最终会按需配置。

6、总结：

springboot所有的自动配置都是在启动的时候扫描并加载，扫描了spring.properties配置文件，所有的自动配置类都在这里面，但是不定生效，因为要判断条件是否成立，只要导入了对应的start，就有对应的启动器，有了启动器我们自动装配就会生效，然后就配置成功

SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration
每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。（xxxxProperties里面读取，xxxProperties和配置文件进行了绑定）
生效的配置类就会给容器中导入非常多的自动配置类@Bean，就是给容器中导入这个场景需要的所有组件，并配置好这些组件 @Configuration；
有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；
只要容器中有这些组件，相当于这些功能就有了
定制化配置
- 用户直接自己@Bean替换底层的组件
- 用户去看这个组件是获取的配置文件什么值就去修改。

xxxxxAutoConfiguration —> 组件 —> xxxxProperties里面拿值 ----> application.properties

7、SpringApplication.run分析

分析该方法主要分两部分，一部分是SpringApplication的实例化，二是run方法的执行；

SpringApplication这个类主要做了以下四件事情：

推断应用的类型是普通的项目还是Web项目
查找并加载所有可用初始化器，设置到initializers属性中
找出所有的应用程序监听器，设置到listeners属性中
推断并设置main方法的定义类，找到运行的主类

8、关于springboot，谈谈你的理解

springboot的自动装配
run()：
- 判断当前项目是普通项目还是web项目
- 推断并设置main方法的定义类，找到运行的主类
- run方法里面有一些监听器，这些监听器是全局存在的，它的作用是获取上下文处理一些bean，所有的bean无论是加载还是生产初始化多存在。

4、Springboot配置文件 1、配置文件

SpringBoot使用一个全局的配置文件，配置文件名称是固定的

application.properties
- 语法结构：key=value
```
server.port=8081
```
application.yaml
- 语法结构：key:空格value
```
server:
  port: 8081
```

2、yaml概述

YAML是 “YAML Ain’t a Markup Language” （YAML不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种标记语言）
这种语言以数据作为中心，而不是以标记语言为重点！

以前的配置文件，大多数都是使用xml来配置；比如一个简单的端口配置，我们来对比下yaml和xml

传统xml配置：

yaml配置：

server：
  prot: 8080

yaml基础语法
说明：语法要求严格！

空格不能省略
以缩进来控制层级关系，只要是左边对齐的一列数据都是同一个层级的。
缩进不允许使用tab，只允许空格
缩进的空格数不重要，只要相同层级的元素左对齐即可
属性和值的大小写都是十分敏感的。
‘#’ 表示注释

字面量：普通的值 [ 数字，布尔值，字符串 ]

字面量直接写在后面就可以，字符串默认不用加上双引号或者单引号；

k: v

注意：

“ ” 双引号，不会转义字符串里面的特殊字符，特殊字符会作为本身想表示的意思；

比如：name: “kuang n shen” 输出：kuang 换行 shen
‘’ 单引号，会转义特殊字符，特殊字符最终会变成和普通字符一样输出

比如：name: ‘kuang n shen’ 输出：kuang n shen

对象、Map（键值对）

#对象、Map格式
key: 
    value1:
    value2:

在下一行来写对象的属性和值得关系，注意缩进；比如：

student:
    name: qinjiang
    age: 3

行内写法

student: {name: qinjiang,age: 3}

数组（ List、set ）
用 - 值表示数组中的一个元素,比如：

pets:
 - cat
 - dog
 - pig

行内写法

pets: [cat,dog,pig]

修改SpringBoot的默认端口号
配置文件中添加，端口号的参数，就可以切换端口；

server:
 port: 8082

3、yaml注入配置文件

yaml文件更强大的地方在于，他可以给我们的实体类直接注入匹配值！

1、原始的给实体对象赋值

在springboot项目中的resources目录下新建一个文件 application.yml

编写一个实体类 User；

@Component  //注册bean到容器中,使得这个类可以被扫描到
public class Dog {
    private String name;
    private Integer age;
    
    //有参无参构造、get、set方法、toString()方法  
}

思考，我们原来是如何给bean注入属性值的！@Value，给User类测试一下：

@Component //注册bean
public class Dog {
    @Value("阿黄")
    private String name;
    @Value("18")
    private Integer age;
}

在SpringBoot的测试类下注入user输出一下

@SpringBootTest
class DemoApplicationTests {

    @Autowired //将狗狗自动注入进来
    Dog dog;

    @Test
    public void contextLoads() {
        System.out.println(dog); //打印看下狗狗对象
    }

}

2、通过yaml文件赋值

我们在编写一个复杂一点的实体类：Person 类

@Component //注册bean到容器中
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map maps;
    private List

Spring Boot笔记

Java相关栏目本月热门文章