两篇文章总结Springboot的基础知识---------加深印象------快速回顾--------上（篇）

文章目录

• 前言
• 一、SpringBoot是什么？
• 二、微服务
• 三、手动创建一个SpringBoot项目
• 四、探究springboot
• 五、配置文件
• 六、批量映射配置文件属性到实体类
• 七、测试
• 八、配置文件处理器
• 九、单个映射配置文件中属性
• 十、获取自定义配置文件中得属性
• 十一、注入自定义bean对象到容器中
• 写在最后

---

前言

       *的自律就是享受孤独，利用周末的时间，把这两天老师讲过的Springboot的基础知识总结一下。
       老惯例了，一方面加深自己的印象，另一方面充实自己内心深处的灵魂。因为我知道无论岁月如何变迁，变得只是人的思想与外貌。岁月是永远挥之不去的宿命。而那种宿命本叫无能为力。

---

一、SpringBoot是什么？

1.1简介

1. 官方解释：Spring Boot makes it easy to create stand-alone， Springboot 可以简单并且快速的创建一个独立的应用。这句话怎么理解，说白了就是能够创建一个与服务器通讯的一个项目，减去了手动加入Tomcat的复杂步骤。
2. SpringBoot是spring的一站式解决方案，不是Spring的升级。
3. SpringBoot与SpringMVC有啥区别？说白了SpringMVC是Spring的一个模块，SpringBoot是Spring的一个整合。整体与个别的区别。

1.2框架的优点

• 能够快速创建独立运行的Spring项目以及与主流框架集成。
• 使用嵌入式的Servlet容器，应用无需打成WAR包。
• starters自动依赖与版本控制。这里的依赖是指在pom.xml文件下导入依赖时候，场景启动器会自动导入相关依赖。
• 大量的自动配置，简化开发，也可修改默认值。
• 无需配置XML，无代码生成，开箱即用。同样，这里的意思也是里面的jar包Tomcat还有一些配置都默认配好了，可以直接写代码拿来用的。
• 准生产环境的运行时应用监控。
• 与云计算的天然集成。

二、微服务

1. Martin Fowler 2014年提出的微服务思想。
2. 微服务：架构风格。最典型的就是官网上的Springboot和SpringCloud微服务。
   
   

打包也简单，运营也简单。
3. 单体应用：All IN ONE。
4. 微服务：将每一个功能模块最终都可以被单独替换和独立升级的单元，之间通过http进行互通。

三、手动创建一个SpringBoot项目

参考之前鄙人发表过的一篇详细的博客：
手把手操作如何使用Idea开发工具手动创建第一个Springboot项目-（全网最详细的的操作步骤）–依赖jar包无法导入问题汇总–收藏篇

---

四、探究springboot

4.1-pom

1. Pom.xml 文件，中有依赖：

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

它是继承了一个父项目的，父项目的核心代码：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.1.18.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
  </parent>

2. 这哥们才是真正管理Springboot里面的所有的依赖的。
3. 他了可以指定Springboot的版本号，还可以管理导入的依赖，可以忽略版本。当没有写版面号报错时，说明版本控制器没有规定此jar版本号，需要手动规定是哪个版本。
4. 比如

如果idea与Spirngboot检测不到相应的版本号，那么程序就会报错，并且也不会自动加载相关依赖。

4.2启动器

来看一段代码：

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

代码中的spring-boot-starter表示springboot给封装的一些场景启动器，只要导入对应的场景启动器，就会自动导入一些项目的相关依赖，前提是你要勾选。

4.3主程序启动类

同样，上一段代码：

@SpringBootApplication  //定义这是一个Springboot主程序启动类
public class MainApplication {
    public static void main(String[] args) {
        //spring应用启动起来
        SpringApplication.run(MainApplication.class,args);
    }
}

@SringBootApplication是一个组合注解

1. 咱们可以按住Ctrl 键点击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) })

可以看到一堆组合注解在这里。

2. 其中的 **@SpringBootConfiguration**说明此类是一个Springboot配置类。
3. 其中的 **@Configuration**表明这是一个Spring配置类。
4. **@EnableAutoConfigueation**意思是开启自动配置
5. **@AutoConfigurationPackage**表示将我们主程序启动类所在包以及子包下所有的组件都都注入到容器中。
6. **@Import(AutoConfigurationPackages.Registrar.class)**表示将相关的组件导入我们的spring容器中，导入的内容有AutoConfigurationPackages.Registrar.class确定。
7. @Import(AutoConfigurationImportSelector.class)表示将获取到的所有的组件以全类名方法返回；将这些组件添加到容器中。给我们容器中导入非常多的自动配置，并且自动配置会自动配置相应的相应的环境，免去我们自己写xml配置。
8. 从META-INF/spring.factories目录下获取对应的自动配置类搭配starter实现自动导入和配置。

五、配置文件

1. SpringBoot 使用一个全局的配置文件。固定名称有两种：
   1).application.properties
   2.)application.yml

2. 这两个哥们的作用：对springboot的一些自动配置进行定制化，按照自己本身的需求进行设置。

3. YAML（英文全称YAML Ain’t Markup Language）
   1).YAML A Markup Language —— yaml是一个标记语言
   2.）YAML isn’t Markup Language yaml不是一个标记语言

4.优点：以数据为中心，比json、xml等更适合做配置文件。

举个栗子：XML标记语言：

<server>
      <port>8081</port>
</server>

然而yaml/yml

server:
  port: 8081
  servlet:
    context-path: /dev

5. yaml语法：k:(空格)v 表示一对键值对。
   层级：
   1.以空格缩进来制定层级关系的。多少空格无所谓，不能使用tab。
   2.只要左对齐就是同一级。

6.yaml值的写法：
1.普通的字符，数值，boolean，或者日期等等。
2.k: v 字符可以不加单引号或者双引号。

比如说

server:
  port: 8081
  servlet:
    context-path: /dev
person:
  name: 张三${random.uuid}
  age: ${random.int(10,20)}
  birth: 2020/11/06
  dog:
    name: ${person.name}的狗
    id: ${random.long(1,10)}
  cat: {name: '${person.name}的猫',id: 2}
  pet:
  - mimi
  - gou
  -  ${person.nme:李四}的zhu
  pets: [cat,dog,pig]
  user-name: zhangsan

spring:
  profiles:
    active: test

person与server就是同一级的，name与age也是同一级的。

7.字符：单引号： ’张三 \n 李四‘ 不会对\n 进行转义，输出：张三 \n 李四。
          双引号： “张三 \n 李四” 会对\n转义 ，\n表示原本自身的意思，输出：张三，李四。

8.对象（属性），map（key-vlaue）

k: 
 v1: 1
 v2: 2
 v3: 3

行类写法：

k: {v1: 1,v2: 2,v3: 3}

集合和数组：

k:
 - v1
 - v2
 - v3

行类写法：

k: [v1,v2,v3]

9. properties:

1.基本语法：
k = v

层级（以点来控制层级，一个’’.“就是一级）：

k.c1.c2 = v2

2.值的写法：

普通字符： k= v

map/对象： k.k1 = v1

 k.k2 = v2

集合/数组： k.list = v1,v2,v3

比如说：

people.age=13
people.name=王五
people.birth=2020/11/06
people.dog.name = 王五的狗
people.dog.id = 1
people.pet= dog,cat,mimi
people.user-name=wangwu

(5)推荐使用yml，两者对比，yaml更能体现层级关系。

六、批量映射配置文件属性到实体类

6.1.如果application.properties 配置文件有中文乱码,则在
File encodings，下配置一下即可。

6.2-如果我们包下新建四个类，分别给类书写属性。

在pom.xml下配置lombok
则在Person类下可以直接映射实体类。

Structure下相应的属性也线束出来了。

Person类下的代码；

/*
将配置文件中所有属性都一一映射过来，注意：javaBean的属性名与配置名要一样
（1）@ConfigurationProperties本类中所有属性都是与配置文件相关
（2）prefix = "person" 配置文件中哪个下面的所有属性
（3）@Component将所在类加入容器中，@ConfigurationProperties只有在容器才生效
 */
@Component
@ConfigurationProperties(prefix = "person")
@Data
public class Person {
    private String name;
    private Integer age;
    private Date birth;
    private Dog dog;
    private Cat cat;
    private List pet;
    private List pets;
    private String userName;
}

七、测试

分两步。

1. 首先要测试的话，加入所依赖的包，pom.xml文件下添加依赖：

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

注意：这个依赖必须是要添加到< dependencies>< /dependencies>里面的。

2.新建一个测试类，比如咱们新建一个测试类，类名叫MainApplicationTest，然后第一步声明Springboot测试类，再加上@RunWith 使用Spring来运行，紧接着声明一个测试方法@Test，最后自动注入指定容器中的组件。
示例代码：

@SpringBootTest //（1）这是一个Springboot的测试类
@RunWith(SpringRunner.class)//（2）使用Spring来运行
public class MainApplicationTest {
    @Resource //(4) 自动注入指定容器中的组件
    private Person person;

    /*
    （3）声明一个测试方法
     */
    @Test
    public void testPerson(){
        System.out.println(person);
    }
}

八、配置文件处理器

作用：在配置文件写对应类的时候有提示。
注意：每加一个属性就得重启一下。

依赖代码：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

九、单个映射配置文件中属性

/*
将配置文件中属性单个映射过来
@Value
（1）指定注入配置某一个属性  @Value("${people.name}")
（2）支持Spel 可以获取计算后得值  @Value("#{11*2}")
（3）支持指定默认值 @Value("xywang")
 */
@Component
@Data
public class People {
    @Value("${people.name}")
    private String name2;
    @Value("#{11*2}")
    private Integer age;
    @Value("xywang")
    private String userName;
}

对比@Value与@ConfigurationProperties

	@Value	ConfigurationProperties
功能	单个	批量映射
spel	支持	不支持
复杂对象映射	不支持	支持
JSR303 数据校验	不支持	支持
是否支持松散语法	不支持	支持

JSR303 数据校验：

1.在类上加注解@Validated ，开启映射校验

2.要校验得属性上对应得校验规则注解

@Validated
public class Person {
    @Email
    private String name;
    private Integer age;
    private Date birth;
    private Dog dog;
    private Cat cat;
    private List pet;
    private List pets;
    private String userName;
}

十、获取自定义配置文件中得属性

@PropertySource(value = {"classpath:person.properties"})加载指定配置文件，value可以赋值为数组 classpath:代表是项目中得resources文件下
注意：@ConfigurationProperties(prefix = "person") 默认获取全局配置文件中得属性。

/*
将配置文件中所有属性都一一映射过来
（1）@ConfigurationProperties本类中所有属性都是与配置文件相关
（2）prefix = "person" 配置文件中哪个下面的所有属性
（3）@Component将所在类加入容器中

注意：@ConfigurationProperties(prefix = "person") 默认获取全局配置文件中得属性
 */
@Component
@ConfigurationProperties(prefix = "person")
@Data
@Validated
@PropertySource(value = {"classpath:person.properties"})
public class Person {
    //@Email
    private String name;
    private Integer age;
    private Date birth;
    private Dog dog;
    private Cat cat;
    private List pet;
    private List pets;
    private String userName;
}

十一、注入自定义bean对象到容器中

第一步、编写bean.xml，可以在Resources下新建

<?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 class="com.neusoft.TestService" id="testService"></bean>
</beans>

第二步：在主配置类上加上@ImportResource(locations = {"classpath:beans.xml"})

加载指定的配置文件，locations可以赋值为数组 classpath:代表是项目中得resources文件下。

@SpringBootApplication  //表明这是一个主程序启动类
@ImportResource(locations = {"classpath:beans.xml"})
//加载指定的配置文件，`locations`可以赋值为数组  classpath:代表是项目中得resources文件下。
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class,args);
    }
}

现在SpringBoot将所有的配置文件都转化为配置类在项目中创建一个config文件夹，在这个文件夹中写我们的配置类。

@Configuration  //（1）表明这个一个spring配置文件
public class BeanConfig {

    @Bean //（3）指明将此方法的返回值注入到容器中
    /*
    （2）方法名就是对应bean.xml中的id属性
     */
    public TestService testService(){
        return new TestService();
    }
}

之后我们测试，在测试类中进行。

//（1）注入ioc容器
@Resource
private ApplicationContext ioc;
/*
 （2）声明一个测试方法
 */
 @Test
 public void testPerson(){
     System.out.println(ioc.containsBean("testService"));
 }

运行测试类可以看到：

可以看到返回值为ture，说明注入成功。

写在最后

以上就是对Springboot的基础知识的简要概述，打字不易，如果能帮到你的话，记得点个赞再走噢。

这个世界并不在乎你的自尊，只在乎你做出来的成绩，然后再去强调你的感受。——比尔·盖茨