SpringBoot学习笔记

Posted 想成为大师啊

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringBoot学习笔记相关的知识，希望对你有一定的参考价值。

微服务阶段

  • JavaSE：面向对象
  • mysql + JDBC：持久化存储
  • html + css +javascript + Jquery + 框架：视图，框架
  • JavaWeb：开始独立开发MVC三层架构的网站（原始）
  • SSM：框架（简化了我们的开发流程，配置也开始较为复杂）
  • war：Tomcat运行
  • Spring再简化：SpringBoot - Jar（内嵌Tomcat）- 微服务架构

    SpringCloud：

Spring

Spring是一个开源框架，2003年兴起的一个轻量级的Java开发框架。Spring是为了解决企业级应用开发的复杂性而创建的，简化开发

为了降低Java开发的复杂性，Spring采用了以下4种关键策略：

  • 1、基于POJO的轻量级和最小侵入性编程
  • 2、通过IOC，依赖注入（DI）和面向接口实现松耦合；
  • 3、基于切面（AOP）和惯例进行声明式编程
  • 4、通过切面和模板减少样式代码

核心思想：约定大于配置！！！

（程序猿）程序 = 数据结构 + 算法（集合框架）

（码农）程序 = 面向对象 + 框架

微服务架构

微服务是一种架构风格，它要求我们在开发一个应用的时候，这个应用必须构建一系列小服务的组合；可以通过http方式进行互通。要说微服务架构，先得说说过去我们的单体应用架构

单体应用架构：

  • 所谓单体应用架构（all in one）是指，我们将一个应用的中的所有应用服务都封装在一个应用中。
  • 无论是ERP、CRM或是其他什么系统，你都把数据库访问，web访问，等等各个功能放到一个war包内
  • 这样做的好处是：易于开发和测试；也十分方便部署；当需要扩展时，只需要将war复制多份，然后放到多个服务器上，再做个负载均衡就可以了。
  • 单体应用框架的缺点是：哪怕我要修改一个非常小的地方，我都需要停掉整个服务、重新打包、部署这个应用war包。特别是对于一个大型应用，我们不可能把所有内容放在一个应用里面，我们如何维护、如何分工合作都是问题

微服务架构：

  • all in one的架构方式，我们把所有的功能单元放在一个应用里面。然后我们把整个应用部署到服务器上。如果负载能力不行，我们将整个应用进行水平复制，进行扩展，然后在负载均衡。
  • 所谓微服务架构，就是打破之前all in one的架构方式，把每个功能元素独立出来。把独立出来的功能元素的动态组合，需要的功能元素才去拿来组合，需要多一些时可以整合多个功能元素。所以微服务架构是对功能元素进行复制，而没有对整个应用复制
  • 这样做的好处：
    • 1、节省了调用资源
    • 2、每个功能元素的服务都是一个可替换的、可独立升级的软件代码

高内聚，低耦合！！！

如何构建微服务

一个大型系统的微服务架构，就像一个复杂交织的神经网络，每一个神经元就是一个功能元素，它们各自完成自己的功能，然后通过http相互请求调用。比如一个电商系统，查缓存、连数据库、浏览页面、结账、支付等服务都是一个个独立的功能服务，都被微化了，它们作为一个个微服务共同构建一个庞大的系统。如果修改其中的一个功能，只需要更新升级其中一个功能服务单元即可。

但是这种庞大的系统架构给部署和运维带来很大的难度。于是，Spring为我们带来了构建大型分布式微服务的全套、全程产品：

  • 构建一个个功能独立的微服务应用单元，可以使用SpringBoot，可以帮我们快速构建一个应用；
  • 大型分布式网络服务的调用，这部分由Spring Cloud来实现，实现分布式；
  • 在分布式中间，进行流式数据计算、批处理，我们有Spring Cloud Data Flow。
  • Spring为我们想清楚了整个从开始构建应用到大型分布式应用全流程方案。

第一个SpringBoot程序

官方：提供一个快速生成的网站，IDEA集成了这个网站

  • 可以在官网直接下载后，导入idea开发（官网在哪）
  • 可以直接使用idea创建一个SpringBoot项目（一般开发直接在IDEA中创建）

官网网址：https://spring.io/projects/spring-boot

进入官网后，点击Spring Initializr


在官网配置好项目后，就可以点击下面的 GENERATE CTRL + 回车
。然后会得到一个项目压缩包，解压后，就可以导入到 idea 中。

如果是在idea工具里面进行配置的话，一定要注意，下载来源不要默认，而要加上阿里云镜像！！！！


后面的过程就和官网配置页面设置一样，选好后，就可以进入到项目中编写了。

package com.blb.demo.controller;

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

@Controller
@RequestMapping("/hello")
public class HelloController 

    @GetMapping("/hello")
    @ResponseBody
    public String hello()
        return "hello,world";

当我们写好第一个接口后，就可以在本地上跑一下了

成功！！！

细节讲解：

  • @RequestMapping()：注解映射请求路径
  • @GetMapping和@PostMapping

    • 从命名约定我们可以看到每个注释都是为了处理各自的传入请求方法类型，即@GetMapping用于处理请求方法的GET类型，@PostMapping用于处理请求方法的POST类型等。

    • 如果我们想使用传统的@RequestMapping注释实现URL处理程序，那么它应该是这样的：

      @RequestMapping(value = "/get/id", method = RequestMethod.GET)

    • 新方法可以简化为：

      @GetMapping("/get/id")

@responseBody注解的作用是：

  • 将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。
  • 注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据

原理初探

自动配置：

  • pom.xml
    • spring-boot-dependencies：核心依赖在父工程中
    • 我们在写或者引入一些SpringBoot依赖的时候，不需要指定版本，就因为有这些版本仓库

启动器：

<dependency>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
  • 启动器就是SpringBoot的启动场景
  • 比如spring-boot-starter-web，他就会帮我们自动导入web环境所有的依赖！
  • SpringBoot会将所有的功能场景，都变成一个个的启动器
  • 我们要使用什么功能，就只需要找到对应的启动器就可以了 starter

主程序：

package com.blb.demo;

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

// @SpringBootApplication : 标注这个类是一个SpringBoot的应用（启动类下的所有资源被导入）
@SpringBootApplication
public class DemoApplication 

    public static void main(String[] args) 
    	// 将SpringBoot应用启动
        SpringApplication.run(DemoApplication.class, args);
  • 注解
    • @SpringBootConfiguration：SpringBoot的配置
      • @Configuration：Spring配置类
      • @Component：说明这也是一个Spring的组件
    • @EnableAutoConfiguration：自动配置
      • @AutoConfigurationPackage：自动配置包
        • @Import(AutoConfigurationPackages.Registrar.class)：自动配置 包注册
      • @Import(AutoConfigurationImportSelector.class)：自动导入选择
      • 获取所有的配置：
        • List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

获取候选的配置：

  • 方法getCandidateConfigurations()返回了自动配置类的信息列表，而它通过调用SpringFactoriesLoader.loadFactoryNames()来扫描加载含有META-INF/spring.factories文件的jar包，该文件记录了具有哪些自动配置类
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) 
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
		Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
				+ "are using a custom packaging, make sure that file is correct.");
		return configurations;

META-INF/spring.factories：自动配置的核心文件

所有资源加载到配置类中！

Properties properties = PropertiesLoaderUtils.loadProperties(resource);

结论：SpringBoot所有自动配置都是在启动的时候扫描并加载（spring.factories所有的自动配置类都在这里面，但是不一定生效，要判断条件是否成立，只要导入了对应的start，就有对应的启动器了，有了启动器，我们自动装配就会生效，然后就配置成功！）

  • 1、SpringBoot在启动的时候，从类路径下 /META-INF/spring.factories获取指定的值；
  • 2、将这些自动配置的类导入容器，自动配置就会生效，帮我进行自动配置
  • 3、以前我们需要自动配置的东西，现在SpringBoot帮我们做了！
  • 4、整个JavaEE，解决方案和自动配置的东西都在spring-boot-autoconfigure-2.2.0.RELEASE.jar这个包下
  • 5、它会把所有需要导入的组件，以类名的方式返回，这些组件就会被添加到容器；
  • 6、容器中也会存在非常多的xxxAutoConfiguration@Bean的文件，就是这些类给容器中导入了这个场景需要的所有组件；并自动配置。@Configuration，JavaConfig！
  • 7、有了自动配置类，免去了我们手动编写配置文件的工作了！

SpringApplication.run（主程序类）分析：分析该方法主要分为两部分

  • 1、SpringApplication的实例化
    • new SpringApplication(主程序类)
      • 判断是否web应用
      • 加载并保存所有ApplicationContextInitializer(META-INF/spring.factories)
      • 加载并保存所有ApplicationListener
      • 获取到主程序类
  • 2、run方法的执行
    • run()
      • 回调所有的SpringApplicationRunListener(META-INF/spring.factories)的starting
      • 获取ApplicationArguments
      • 准备环境和所有监听器(SpringApplicationRunListener)的environmentPrepared
      • 打印banner信息
      • 创建ioc容器对象
        • AnnotationConfigEmbeddedWebApplicationContext(Web环境容器)
        • AnnotationConfigApplicationContext(普通环境容器)

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

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

查看构造器：

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) 
		// 设置一些默认参数
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = new HashSet();
        this.isCustomEnvironment = false;
        this.lazyInitialization = false;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");

		// 保存主配置类到一个Set集合primarySources中
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        
        // 获取当前的应用类型，判断是不是Web应用 
        this.webApplicationType = WebApplicationType.deduceFromClasspath();

		// 从类路径下找到META-INF/spring.factories配置的所有ApplicationContextInitializer;然后保存起来        
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));

		// 从类路径下找到META‐INF/spring.ApplicationListener；然后保存起来,原理同上
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        // 从多个配置类中找到有main方法的主配置类。在调run方法的时候是可以传递多个配置类的
        this.mainApplicationClass = this.deduceMainApplicationClass();
        // 执行完毕，SpringApplication对象就创建出来了，返回到1处，调用SpringApplication对象的run方法，到3

SpringBoot：配置文件及自动配置原理

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

  • application.properties
    • 语法结构：key = value
  • application.yaml
    • 语法结构：key: 空格 value

配置文件的作用：修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了；

YAML

YAML是"YAML Ain’t a Markup Language"（YAML不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种标记语言），但为了强调这种语言以数据做为中心，而不是以标记语言为重点，而用反向缩略语重命名。（取自百度百科）

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

  • yaml配置：

    server:
	port: 8080

// 普通的key-value
name: huake

// 对象
student:
	name: huake
	age: 3

// 行内写法
studednt: name: huake, age: 3

// 数组
pets:
  - cat
  - dog
  - pig

pets: [cat, dog, pig]

  • xml配置：

    <server>
	<port>8080</port>
</server>

  • properties只能写键值对

    name=huake

student.name = huake
student.age = 3

YAML语法

基本语法：

k:(空格) v

以此来表示一对键值对（空格不能省略）；以空格的缩进来控制层级关系，只要是左边对齐的一列数据都是同一个层级的。

注意：属性和值的大小写都是十分敏感的。例如：

server:
	port: 8080
	path: /hello

值的写法：字面量: 普通的值 [数字, 布尔值, 字符串]

k: v

字面量直接写在后面就可以，字符串默认不用加上双引号或者单引号；"" 双引号，不会转义字符串里面的特殊字符，特殊字符会作为本身想表示的意思；

比如：name: "kuang \\n shen"

输出：

kuang
shen

yaml可以直接给实体类赋值：

  • 首先介绍一下原生的赋值方式：
    • 先创建一个类
    • @component是spring中的一个注解，它的作用就是实现bean的注入（注册bean）
    • @Value是一个赋值注解
    • @Autowired是用在JavaBean中的注解，通过byType形式，用来给指定的字段或方法注入所需的外部资源
    • 经过测试，我们拿到了实例化后的值；
  • 接下来就是通过yaml文件来进行赋值：

    • 同样先创建好我们的类

    • 在yaml文件进行对应类型赋值

    • 最后进行测试，发现数据都得到了

    • 打印结果

      Personname='huake', 
age=3,
happy=true,
birth=Fri Jan 07 00:00:00 CST 2022,
maps=k1=v1, k2=v2,
lists=[code, music, girl],
dog=Dogname='旺财', age=3

@ConfigurationProperties作用：

  • 将配置文件中配置的每一个属性值，映射到这个组件中；
  • 告诉SpringBoot将本类中的所有属性和配置文件中国相关的配置进行绑定
  • 参数 prefix = “person” （将配置文件中的person下面的所有属性一一对应）
  • 只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能

上面采用的方法都是最简单的方式，开发中最常用的；那我们来唠叨一下其他的实现方式，道理都是相通的，写还是那样写；配置文件除了yaml还有我们之前常用的properties，但properties配置文件在写中文的时候，会有乱码，我们需要去IDEA中设置编码格式为UTF-8；

@ConfigurationProperties@Value
功能批量注入配置文件中的属性一个个指定
松散绑定（松散语法）支持不支持
SpEL不支持支持
JSR303数据校验支持不支持
复杂类型封装支持不支持
  • cp只需要写一次即可，value则需要每个字段都添加
  • 松散绑定：比如我的yaml中写的last-name，这个和lastName是一样的，- 后面跟着的字母默认是大写的。这就是松散绑定
  • JSR303数据校验：这个就是我们可以在字段是增加一层过滤器验证，可以保证数据的合法性
  • 复杂类型封装，yaml中可以封装对象，使用@Value就不支持

结论：

  • 配置yaml和配置properties都可以获取到值，强烈推荐yaml
  • 如果我们在某个业务中，只需要获取配置文件中的某个值，可以使用 @Value
  • 如果说，我们专门编写了一个JavaBean来和配置文件进行映射，就直接使用 @ConfigurationProperties，不要犹豫！！！

JSR303数据校验（了解即可）：

SpringBoot中可以用@validated来校验数据，如果数据异常则会统一抛出异常，方便异常中心统一处理。

  • 我们这里来写个注解让我们的name只能支持Email格式


  • 空检查

    • @Null 验证对象是否为null
    • @NotNull 验证对象是否不为null, 无法查检长度为0的字符串
    • @NotBlank 检查约束字符串是不是Null还有被Trim的长度是否大于0,只对字符串,且会去掉前后空格.
    • @NotEmpty 检查约束元素是否为NULL或者是EMPTY.

  • Booelan检查

    • @AssertTrue 验证 Boolean 对象是否为 true
    • @AssertFalse 验证 Boolean 对象是否为 false

  • 长度检查

    • @Size(min=, max=) 验证对象（Array,Collection,Map,String）长度是否在给定的范围之内
    • @Length(min=, max=) Validates that the annotated string is between
      min and max included.

  • 日期检查

    • @Past 验证 Date 和 Calendar 对象是否在当前时间之前
    • @Future 验证 Date 和 Calendar 对象是否在当前时间之后
    • @Pattern 验证 String 对象是否符合正则表达式的规则（正则表达式）

  • 数值检查，建议使用在Stirng,Integer类型，不建议使用在int类型上，因为表单值为“”时无法转换为int，但可以转换为Stirng为"",Integer为null

    • @Min 验证 Number 和 String 对象是否大等于指定的值
    • @Max 验证 Number 和 String 对象是否小等于指定的值
    • @DecimalMax 被标注的值必须不大于约束中指定的最大值.
      这个约束的参数是一个通过BigDecimal定义的最大值的字符串表示.小数存在精度
    • @DecimalMin 被标注的值必须不小于约束中指定的最小值.
      这个约束的参数是一个通过BigDecimal定义的最小值的字符串表示.小数存在精度
    • @Digits 验证 Number 和 String 的构成是否合法
    • @Digits(integer=,fraction=)
      验证字符串是否是符合指定格式的数字，interger指定整数精度，fraction指定小数精度。
    • @Range(min=, max=) Checks whether the annotated value lies between
      (inclusive) the specified minimum and maximum.
    • @Range(min=10000,max=50000,message=“range.bean.wage”) private
      BigDecimal wage;
    • @Valid 递归的对关联对象进行校验,
      如果关联对象是个集合或者数组,那么对其中的元素进行递归校验,如果是一个map,则对其中的值部分进行校验.(是否进行递归验证)
    • @CreditCardNumber信用卡验证
    • @Email 验证是否是邮件地址，如果为null,不进行验证，算通过验证。
    • @ScriptAssert(lang= ,script=, alias=)
    • @URL(protocol=,host=, port=,regexp=, flags=)

多环境切换

profile是Spring对不同环境提供不同配置功能的支持，可以通过激活不同的环境版本，实现快速切换环境

  • 方式一：多配置文件
    • 我们在主配置文件编写的时候，文件名可以是 application-profile.properties/yml，用来指定多个环境版本；
    • 例如：
      • application-test.properties 代表测试环境配置
      • application-dev.properties代表开发环境配置
    • 但是SpringBoot并不会直接启动这些配置文件，它默认使用application.properties主配置文件
    • 我们需要通过一个配置来选择需要激活的环境：
      // 比如在配置文件中指定dev环境，我们可以通过设置不同的端口号进行测试;
// 我们启动SpringBoot，就可以看到已经切换到dev下的配置了
spring.profiles.active=dev


      我们可以配置多个端口（测试端口，开发端口等等），在我们主配置文件中指定哪一个配置文件作为项目启动的端口即可spring.profiles.active=配置文件名
  • 方式二：yaml的多文档块（默认为8081端口）

    • 和properties配置文件一样，但是使用yml去实现不需要创建多个配置文件，更加方便了

      也是通过spring.profiles.active进行配置

    • 注意：如果yml和properties同时都配置了端口，并且没有激活其他环境，默认会使用properties配置文件的！

配置文件加载位置

SpringBoot启动会扫描以下位置的application.properties或者application.yml文件作为SpringBoot的默认配置文件

  • 优先级1：项目路径下的config文件夹配置文件
  • 优先级2：项目路径下配置文件
  • 优先级3：资源路径下的config文件夹配置文件
  • 优先级4：资源路径下配置文件

优先级由高到低，高优先级的配置会覆盖低优先级的配置；

SpringBoot会从这四个位置全部加载主配置文件，互补配置；我们在最低级的配置文件中设置一个项目访问路径的配置来测试互补问题

// 配置项目的访问路径
server.servlet.context-path=/huake

扩展：指定位置加载配置文件

  • 我们还可以通过spring.config.location来改变默认的配置文件位置
  • 项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置
  • 这种情况，一般是后期运维做的多，相同配置，外部指定的配置文件优先级最高
java -jar spring-boot-config.jar --spring.config.location=F://application.properties

外部加载配置文件的方式十分多，我们选择最常用的即可，在开发的资源文件中进行配置

自动配置原理再理解

  • 表示这是一个配置类

    @Configuration(proxyBeanMethods = false)

  • 自动配置属性：HttpProperties

    @EnableConfigurationProperties(HttpProperties.class)

  • Spring的底层注解：根据不同的条件，来判断当前配置或者类是否生效

    @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)

  • 在配置文件中能配置的东西，都存在一个固有的规律：xxxProperties、xxxAutoConfiguration

  • xxxAutoConfiguration有默认值（而这些默认值的改变是通过xxxProperties和配置文件的绑定），所以我们可以使用自定义的配置了

# Initializers
org.springframework.context.ApplicationContextInitializer=\\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

# Application Listeners
org.springframework.context.ApplicationListener=\\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

# Auto Configuration Import Listeners
org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener

# Auto Configuration Import Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoC
以上是关于SpringBoot学习笔记的主要内容，如果未能解决你的问题，请参考以下文章
 

 Elasticsearch学习笔记-04.2删除文档


 SpringBoot学习笔记：Json数据的处理


 8周期性任务findbreak和continue 学习笔记


 makefile学习笔记


 超适合初学者的SpringBoot入门学习笔记，收藏起来慢慢看！


 学习笔记（第三周）