spring boot基础

spring boot

spring boot 是一个轻量级框架

spring如何简化Java开发：

基于pojo的轻量级和最小侵入性编程，所有东西都是bean
通过IOC，依赖注入（DI）和面向接口实现松耦合
基于切面（AOP）和惯例进行声明式编程
通过切面和模板减少样式代码，Redis Template,xxxTemplate

核心：约定大于配置

spring boot主要优点

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

Hello，world

环境配置：

Java环境
Maven
springBoot

项目结构：

程序的主启动类
一个application.properties配置文件
一个测试类
一个pom.xml

pom.xml分析：

<!-- 父依赖 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
    <relativePath/>
</parent>

<dependencies>
    <!-- web场景启动器 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- springboot单元测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <!-- 剔除依赖 -->
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- 打包插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

编写一个HTTP接口：

在主程序的同级目录下，新建一个controller包，必须是同级目录

在包中新建一个HelloController类

@RestController
public class HelloController {

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

编写完毕后，从主程序启动项目，浏览器发起请求，查看页面

将项目打成jar包

点击maven的package

如果打包发生错误，可以配置打包时运行测试用例

<!--
    在工作中,很多情况下我们打包是不想执行测试用例的
    可能是测试用例不完事,或是测试用例会影响数据库数据
    跳过测试用例执
    -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <!--跳过项目运行测试用例-->
        <skipTests>true</skipTests>
    </configuration>
</plugin>

打包成功，会在target目录下生成一个jar包。

spring boot 原理

pom.xml

父依赖

主要依赖一个父项目，主要是管理项目的资源过滤及插件

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

点进去，发现还有一个父依赖

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

这是真正管理spring boot应用里所有依赖版本的地方，SpringBoot的版本控制中心；

以后导入依赖是默认不需要写版本的，但如果导入的包没有在依赖里进行管理就需要手动配置版本了。

启动器 spring-boot-starter

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

springboot-boot-starter-xxx:就是spring-boot的场景启动器

spring-boot-starter-web:帮我们导入web模块正常运行所依赖的组件

SpringBoot将所有的功能场景都抽取出来，做成一个个的starter （启动器），只需要在项目中引入这些starter即可，所有相关的依赖都会导入进来，我们要用什么功能就导入什么样的场景启动器即可；我们未来也可以自己自定义 starter；

主启动类

默认的主启动类：

//@SpringBootApplication 来标注一个主程序类
//说明这是一个Spring Boot应用
@SpringBootApplication
public class SpringbootApplication {

   public static void main(String[] args) {
     //以为是启动了一个方法，没想到启动了一个服务
      SpringApplication.run(SpringbootApplication.class, args);
   }

}

对启动类的注解进行分析：

@SpringBootApplication

作用：标注在某个类上说明这个类是spring boot的主配置类，spring Boot就应该运行这个类的main方法来启动spring boot应用。

进入这个类,可以看到上面的很多其他注解

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    // ......
}

@ComponentScan

这个注解十分重要，对应xml配置中的元素

作用：自动扫描并加载符合条件的组件或者bean，将这个bean加载到IOC容器中

@SpringBootConfiguration

作用：这是一个spring boot的配置类，标注在某个类上，表明这是一个spring boot的配置类；继续进入这个注解：

// 点进去得到下面的 @Component
@Configuration
public @interface SpringBootConfiguration {}

@Component
public @interface Configuration {}

这里的@Configuration，说明这是一个配置类，配置类就是对应spring的xml配置文件；

@Component，启动类也是spring的一个组件，负责启动应用。

@EnableAutoConfiguration

@EnableAutoConfiguration：开启自动配置功能

以前需要自己配置的东西，现在spring boot可以自动帮我们配置

@EnableAutoConfiguration告诉spring boot开启自动配置功能，这样自动配置才能够生效

@AutoConfigurationPackage ：自动配置包

@Import({Registrar.class})
public @interface AutoConfigurationPackage {
}

@import ：Spring底层注解@import ，给容器中导入一个组件

Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器；

@Import({AutoConfigurationImportSelector.class}) ：给容器导入组件；

AutoConfigurationImportSelector ：自动配置导入选择器，那么它会导入哪些组件的选择器呢？我们点击去这个类看源码：

这个类中有一个这样的方法

// 获得候选的配置
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    //这里的getSpringFactoriesLoaderFactoryClass（）方法
    //返回的就是我们最开始看的启动自动导入配置文件的注解类；EnableAutoConfiguration
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;
}

这个方法又调用了 SpringFactoriesLoader 类的静态方法！我们进入SpringFactoriesLoader类loadFactoryNames() 方法

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
    String factoryClassName = factoryClass.getName();
    //这里它又调用了 loadSpringFactories 方法
    return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

我们继续点击查看 loadSpringFactories 方法

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    //获得classLoader ， 我们返回可以看到这里得到的就是EnableAutoConfiguration标注的类本身
    MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        try {
            //去获取一个资源 "META-INF/spring.factories"
            Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            LinkedMultiValueMap result = new LinkedMultiValueMap();

            //将读取到的资源遍历，封装成为一个Properties
            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();

                while(var6.hasNext()) {
                    Entry<?, ?> entry = (Entry)var6.next();
                    String factoryClassName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String factoryName = var9[var11];
                        result.add(factoryClassName, factoryName.trim());
                    }
                }
            }

            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

发现一个多次出现的文件：spring.factories，全局搜索它

spring.factories

我们根据源头打开spring.factories ，看到了很多自动配置的文件；这就是自动配置根源所在！

总结：

SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
将这些值作为自动配置类导入容器，自动配置类就生效，帮我们进行自动配置工作；
整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；
它会给容器中导入非常多的自动配置类（xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件，并配置好这些组件；
有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；

SpringApplication

一开始以为是运行了一个main方法，但是这是开启了一个服务

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

SpringApplication.run分析

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

SpringApplication

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

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

查看构造器：

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    // ......
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    this.setInitializers(this.getSpringFactoriesInstances();
    this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = this.deduceMainApplicationClass();
}

yaml配置注入

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

application.properties
- 语法结构：key = value
application.yml
- 语法结构：key:空格 value

配置文件的作用：修改spring boot自动配置的默认值，因为springBoot在底层都已经自动配置好了

yaml语言以数据为中心，而不是以标记语言为重点

yaml语法要求严格

空格不能省略
以缩进来控制层级关系，左边对齐的是同一个层级
属性和值的大小写都十分敏感

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

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

k： v

注意：

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

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

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

对象、Map（键值对）

#对象、Map格式
k: 
    v1:
    v2:

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

student:
    name: qinjiang
    age: 3

行内写法

student: {name: qinjiang,age: 3}

数组（ List、set ）

用 - 值表示数组中的一个元素,比如:

pets:
 - cat
 - dog
 - pig

行内写法

pets: [cat,dog,pig]

修改SpringBoot的默认端口号

server:
  port: 8082

yaml可以给我们的实体类直接注入匹配值

注入配置文件

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

编写一个实体类 Dog；

package com.kuang.springboot.pojo;

@Component  //注册bean到容器中
public class Dog {
    private String name;
    private Integer age;
    
    //有参无参构造、get、set方法、toString()方法  
}

以前给bean注入属性值，使用@Value

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

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

@SpringBootTest
class DemoApplicationTests {

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

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

}

成功输出

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

@Component //注册bean到容器中
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
    
    //有参无参构造、get、set方法、toString()方法  
}

使用yaml配置的方式进行注入，大家写的时候注意区别和优势，我们编写一个yaml配置！

person:
  name: qinjiang
  age: 3
  happy: false
  birth: 2000/01/01
  maps: {k1: v1,k2: v2}
  lists:
   - code
   - girl
   - music
  dog:
    name: 旺财
    age: 1

刚才已经把person这个对象的所有值都写好了，我们现在来注入到我们的类中

/*
@ConfigurationProperties作用：
将配置文件中配置的每一个属性的值，映射到这个组件中；
告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
参数 prefix = “person” : 将配置文件中的person下面的所有属性一一对应
*/
@Component //注册bean
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
}

确认以上配置都OK之后，我们去测试类中测试一下

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    Person person; //将person自动注入进来

    @Test
    public void contextLoads() {
        System.out.println(person); //打印person信息
    }

}

注入成功

相关阅读:
.Net中的加密解密
 C#集合类
 .NetFramework 1: I/O & Stream
系列4：文件操作以及读写文件
 PetShop之表示层设计：PetShop之表示层设计（转）
const和static readonly 区别
 ASP.NET经典源代码下载地址及数据库配置方法
 一个知名出版商的挫折——解读 Wrox 的历史、现在与未来（转载）
《C++编程——数据结构与程序设计方法》程序范例：影碟店（源代码）
ASP.NET 英语词典
原文地址：https://www.cnblogs.com/fkxiaozhou/p/13889155.html

spring boot基础

spring boot

Hello，world

spring boot 原理

pom.xml

主启动类

@SpringBootApplication

@ComponentScan

@SpringBootConfiguration

@EnableAutoConfiguration

@Import({AutoConfigurationImportSelector.class}) ：给容器导入组件 ；

spring.factories

SpringApplication

yaml配置注入

@Import({AutoConfigurationImportSelector.class}) ：给容器导入组件；