spring boot基础

spring boot

spring boot 是一个轻量级框架

spring如何简化Java开发：

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

核心：约定大于配置

spring boot主要优点

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

Hello，world

环境配置：

  • Java环境
  • Maven
  • springBoot

项目结构：

  1. 程序的主启动类
  2. 一个application.properties配置文件
  3. 一个测试类
  4. 一个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接口：

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

  2. 在包中新建一个HelloController类

    @RestController
public class HelloController {

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

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

将项目打成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 ：自动配置导入选择器，那么它会导入哪些组件的选择器呢？我们点击去这个类看源码：

  1. 这个类中有一个这样的方法
// 获得候选的配置
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;
}

  1. 这个方法又调用了 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());
}

  2. 我们继续点击查看 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);
        }
    }
}

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

spring.factories

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

总结：

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

SpringApplication

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

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

SpringApplication.run分析

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

SpringApplication

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

  1. 推断这个项目是普通项目还是web项目
  2. 查找并加载所有可用初始化器，设置到initializers属性中
  3. 找出所有的应用程序监听器设置到listeners属性中
  4. 推断并设置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语法要求严格

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

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

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

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可以给我们的实体类直接注入匹配值

注入配置文件

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

  2. 编写一个实体类 Dog；

    package com.kuang.springboot.pojo;

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

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

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

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

    @SpringBootTest
class DemoApplicationTests {

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

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

}

成功输出

  1. 编写一个复杂一点的实体类：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()方法  
}

  1. 使用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

  2. 刚才已经把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;
}

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

    @SpringBootTest
class DemoApplicationTests {

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

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

}

  4. 注入成功

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/fkxiaozhou/p/13889155.html