Spring Boot学习笔记一

Spring Boot简介

前言：本章简单介绍Spring boot的使用。

　　（第二天springboot的学习之路：https://www.cnblogs.com/LBJLAKERS/p/12003109.html）　　

• 简化Spring应用开发的一个框架
• 整个Spring技术栈的一个大整合
• J2EE开发的一站式解决方案

Sping Boot 所具备的特征有：

• 可以创建独立的Spring应用程序，并基于其Maven或Gradle插件，可以创建可这性的JARS和WARS
• 内嵌Tomact或Jetty等Servlet容器
• 提供自动配置的starter项目对象模型（POMS）以简化Maven配置
• 尽可能自动配置Spring容器
• 提供准备好的特性，如指标、健康检查和外部化配置
• 绝对没有代码生成，不需要XML配置

开发环境配置

• –jdk1.8：Spring Boot 推荐jdk1.7及以上；java version "1.8.0_112"
• –maven3.x：maven 3.3以上版本；Apache Maven 3.3.9
• –IntelliJIDEA2017：IntelliJ IDEA 2017.3.3 x64、STS
• –SpringBoot 2.0.2.RELEASE：统一环境；
• Maven环境在maven文件的setting.xml 文件中配置一段

  <profile>
  <id>jdk‐1.8</id>
  <activation>
       <activeByDefault>true</activeByDefault>
  <jdk>1.8</jdk>
  </activation>
  <properties>
       <maven.compiler.source>1.8</maven.compiler.source>
       <maven.compiler.target>1.8</maven.compiler.target>
       <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
  </properties>
  </profile>

  创建一个简单的案例，新建maven工程项目，如下图

　　　　

　　　　或者直接在网站上直接生成项目，然后导入到开发工具中（https://start.spring.io）

• 　　导入相应的Spring Boot坐标

     <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.2..RELEASE</version>
     </parent>
  
     <dependencies>
       <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
       <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
         <version>2.2..RELEASE</version>
       </dependency>
     </dependencies>

• 编写一个主程序，启动Spring Boot应用

   /**
   * @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
   */
   @SpringBootApplication
   public class HelloWorldMainApplication {
       public static void main(String[] args) {
       // Spring应用启动起来
       SpringApplication.run(HelloWorldMainApplication.class,args);
       }
   }

• 创建一个Controller类

   @Controller
   public class HelloController {
      @ResponseBody
      @RequestMapping("/hello")
      public String hello(){
         return "Hello World!";
      }
   }

• 启动Spring Boot应用。我们可以从控制台可以看出：Tomcat被初始化端口8080、用8080端口启动。

　　　　

• 　解析注解：
  • @SpringBootApplication:SpringBoot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot的应用。
  • @SpringBootConfiguration:SpringBoot配置类。标注在某个类上，表示这个是Spring Boot的配置类
  • @Configuration：配置类上来标注这个注解。配置类-----配置文件；配置类也是容器中的一个组件，@Component
  • @EnableAutoConfiguration:开启自动配置功能。底层部分代码：

     @AutoConfigurationPackage
     @Import(EnableAutoConfigurationImportSelector.class)
     public @interface EnableAutoConfiguration {

    继续进入

    @AutoConfigurationPackage的注解底层代码

     @Target({ElementType.TYPE})
     @Retention(RetentionPolicy.RUNTIME)
     @Documented
     @Inherited
     @Import({Registrar.class})
     public @interface AutoConfigurationPackage {
     }

    在进入到Registar的底层

     static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
             Registrar() {
             }
    
             public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
                 AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
             }
    
             public Set<Object> determineImports(AnnotationMetadata metadata) {
                 return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
             }
         }

  • @AutoConfigurationPackage：自动配置包

　　　　　　@Import（AutoConfigurationPackage.Registar.class）:Spring的底层注解@Import，给容器中导入一个组件；导入的组件由
　　　　　　AutoConfigurationPackages.Registrar.class；
　　　　　　将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring容器；

• • @Import(EnableAutoConfigurationImportSelector.class)；给容器导入组件。EnableAutoConfigurationImportSelector：导入哪些组件的选择器；

　　　　　　将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中；
　　　　　　会给容器中导入非常多的自动配置类（xxxAutoConfiguration）；就是给容器中导入这个场景需要的所有组件，
　　　　　　并配置好这些组件；

　　　　

　　　　　　有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；

　　　　　　有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；
　　　　　　SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,classLoader)；
　　　　　　Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将
　　　　　　这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作；以前我们需要自己配置的东西，自动配置类都帮我们；
　　　　　　J2EE的整体整合解决方案和自动配置都在spring-boot-autoconfigure-1.5.9.RELEASE.jar；

Spring Boot的热部署

• 使用Spring Initializer快速创建Spring Boot项目.
• Spring Boot的热部署需要导入一个坐标，代码完成更改之后，只需要重启即可，重启的快捷键（Ctrl+F9）

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

Spring Boot的配置文件

• application.properties

• application.yml

　　例如：yaml中的配置文件的方式：

server:
    port: 

　　yaml语法

• k:(空格)v：表示一对键值对（空格必须有）；
• 以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的（如上面的代码所示）

• 属性和值也是大小写敏感；

• 创建一个Person的类

   package zh.stu.springboot.Model;
  
   import org.springframework.boot.context.properties.ConfigurationProperties;
   import org.springframework.stereotype.Component;
  
   import java.util.Date;
   import java.util.List;
   import java.util.Map;
  
   /**
    * @ConfigurationProperties("person")   使用来读取application.yaml文件中的配置，其中里面的参数表示，读取的是以person开头的配置
    *
    * 只有这个组件是容器的组件，才能容器提供的@ConfigurationProperties功能
    */
   @Component
   @ConfigurationProperties(prefix="person")
   public class Person {
       String lastName;
  
       int age;
  
       boolean boss;
  
       Date birth;
  
       Map<String,String> maps;
  
       List<String> list;
  
       dog dog;
  
       @Override
       public String toString() {
           return "Person{" +
                   "lastName='" + lastName + '\'' +
                   ", age=" + age +
                   ", boss=" + boss +
                   ", birth=" + birth +
                   ", maps=" + maps +
                   ", list=" + list +
                   ", dog=" + dog +
                   '}';
       }
  
       public zh.stu.springboot.Model.dog getDog() {
           return dog;
       }
  
       public void setDog(zh.stu.springboot.Model.dog dog) {
           this.dog = dog;
       }
  
       public String getLastName() {
           return lastName;
       }
  
       public void setLastName(String lastName) {
           this.lastName = lastName;
       }
  
       public int getAge() {
           return age;
       }
  
       public void setAge(int age) {
           this.age = age;
       }
  
       public boolean isBoss() {
           return boss;
       }
  
       public void setBoss(boolean boss) {
           this.boss = boss;
       }
  
       public Date getBirth() {
           return birth;
       }
  
       public void setBirth(Date birth) {
           this.birth = birth;
       }
  
       public Map<String, String> getMaps() {
           return maps;
       }
  
       public void setMaps(Map<String, String> maps) {
           this.maps = maps;
       }
  
       public List<String> getList() {
           return list;
       }
  
       public void setList(List<String> list) {
           this.list = list;
       }
  
   }

• 在创建一个dog的类

   package zh.stu.springboot.Model;
  
   public class dog {
  
       private String name;
  
       @Override
       public String toString() {
           return "dog{" +
                   "name='" + name + '\'' +
                   '}';
       }
  
       public String getName() {
           return name;
       }
  
       public void setName(String name) {
           this.name = name;
       }
   }

• 在pom.xml文件中添加一个依赖，这样在配置application.yaml 语法的时候就可以有提示

   <!‐‐导入配置文件处理器，配置文件进行绑定就会有提示‐‐>
   <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring‐boot‐configuration‐processor</artifactId>
        <optional>true</optional>
   </dependency>

• 配置yaml文件，向属性值中加入数据

   person:
     lastName: zhangH
     age:
     boss: false
     birth: //
     maps: {:,:}
     list: [cat,dog]
     dog:
       name: dudu

• 测试数据输出：

   package zh.stu.springboot;
  
   import org.junit.jupiter.api.Test;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.test.context.SpringBootTest;
   import org.springframework.context.ApplicationContext;
   import zh.stu.springboot.Model.Person;
  
   import java.beans.PersistenceDelegate;
  
   @SpringBootTest
   public class yamltest {
  
       @Autowired
       Person person;
  
       @Autowired
       ApplicationContext context;
       @Test
       public void contextload(){
           System.out.println(person);
       }
   }

• 在控制台输出结果

  Person{lastName='zhangH', age=, boss=false, birth=Sun Feb  :: CST , maps={=, =}, list=[cat, dog], dog=dog{name='dudu'}}

@PropertySource    @ImportResource    @Bean

• @PropertySource：将配置文件中配置的每一个属性的值，映射到这个组件中。@ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；

　　　prefix = "person"：配置文件中哪个下面的所有属性进行一一映射。只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
　　　@ConfigurationProperties(prefix = "person")默认从全局配置文件中获取值；
　　　@PropertySource(value = {"classpath:person.properties"})

• @ImportResource:导入spring的配置文件，让配置文件里面的内容生效。因为spring boot里面没有spring的配置文件，如果自己编写spring的配置文件，想让其生效那么就需要使用

　　　@ImportResource这个注解例如：

@ImportResource(locations = {"classpath:beans.xml"})

• 配置类@Configuration------>Spring配置文件　　

  使用@Bean给容器中添加组件

   /**
   * @Configuration：指明当前类是一个配置类；就是来替代之前的Spring配置文件
   *
   * 在配置文件中用<bean><bean/>标签添加组件
   * *
   /
   @Configuration
   public class MyAppConfig {
        //将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名
        @Bean
        public HelloService helloService02(){
            System.out.println("配置类@Bean给容器中添加组件了...");
            return new HelloService();
        }
   }

• Spring Boot配置加载、顺序？

1. properties文件
2. YAML文件
3. 系统环境变量
4. 命令行参数