1.spring-boot编写一个简单的hello请求

1.创建maven项目

2.导入依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.8.RELEASE</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
<!--整个插件可以将应用打包成一个可运行的jar包-->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
    <!--更改打出的jar包的名称-->
    <finalName>spring-boot</finalName>
</build>

3.编写一个主程序：用于启动springboot应用

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

4.编写相关业务逻辑

控制类代码
@Controller
public class HelloControler {
    @ResponseBody
    @RequestMapping("hello")
    public String helloControl(){
        return "hello world";
    }
}

5.启动服务：直接在HelloWorldAppliaction 类上启动，不需要配置tomcat等

6.浏览器输入http://localhost:8080/hello----->注意：并没有项目名称

页面输出：hello world

7.将springboot项目打包成一个可运行jar

pom文件中增加
<!--整个插件可以将应用打包成一个可运行的jar包-->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

将jar包java -jar执行，也可以直接访问http://localhost:8080/hello，并不需要部署tomcat等，因为其内部自带了tomcat环境

jar包中包含：

helloworld的探究

1.父项目

pom文件：
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
    </parent>
    而spring-boot-starter-parent里也有父项目
    <parent>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-dependencies</artifactId>
          <version>2.1.8.RELEASE</version>
          <relativePath>../../spring-boot-dependencies</relativePath>
    </parent>
    他是真正来管理springboot里面所有的依赖版本，也叫springboot的仲裁中心，以后我们导入的依赖默认不需要写版本号
    (没有在spring-boot-dependencies中管理的依赖自然是需要声明版本号的)

2.启动器

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

spring-boot-starter：spring boot的场景启动器，帮我们导入web模块正常运行的所依赖所有组件


springboot将所有的场景都抽取出来，做成一个个的starter(启动器)，只需要在项目中引入这些starter，就会引入该场景下的所有依赖
使用什么场景，就导入什么场景的启动器

主程序类：

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

@SpringBootApplication标注在某个类上，说明这个类是springboot的主配置类，springboot运行这个类的main方法来启动springboot应用
而@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}
)}
)
public @interface SpringBootApplication {
     。。。   
}

    1.@SpringBootConfiguration:springboot的配置类
        标注在某个类上，表示这是一个springboot配置类；
            @SpringBootConfiguration内部代码如下：
                @Target({ElementType.TYPE})
                @Retention(RetentionPolicy.RUNTIME)
                @Documented
                @Configuration--------->>spring的配置注解：配置类上标这个注解
                public @interface SpringBootConfiguration {
                }
                
                @Configuration的内部代码如下：
                    @Target({ElementType.TYPE})
                    @Retention(RetentionPolicy.RUNTIME)
                    @Documented
                    @Component------------>>发现其是spring的组件
                    public @interface Configuration {
                        @AliasFor(
                            annotation = Component.class
                        )
                        String value() default "";
                    }
    2.@EnableAutoConfiguration开启自动配置功能(springboot内部没有做任何的配置：如包扫描等等)，但是组件已被加载到容器中，可以直接使用
        以前我们需要配置的东西(如包扫描等等)，springboot会帮我们自动配置；@EnableAutoConfiguration告诉springboot开启自动配置功能，这样自动配置才能生效
        @EnableAutoConfiguration内部代码如下：
            @Target({ElementType.TYPE})
            @Retention(RetentionPolicy.RUNTIME)
            @Documented
            @Inherited
            @AutoConfigurationPackage---------->>自动配置包
            @Import({AutoConfigurationImportSelector.class})---->导入哪些组件的选择器！将所有需要导入的组件以全类名的形式返回；这些组件会被添加到容器中
            //会给容器中导入很多的组件(形式如：xxxAutoConfiguration),就是给容器中导入这个场景所需要的所有组件并配置好！
            public @interface EnableAutoConfiguration {
                String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
                Class<?>[] exclude() default {};
                String[] excludeName() default {};
            }
            而@AutoConfigurationPackage的内部代码如下：
                @Target({ElementType.TYPE})
                @Retention(RetentionPolicy.RUNTIME)
                @Documented
                @Inherited
                @Import({Registrar.class})----------->spring的内部注解:是将这个类加载到spring容器中
                public @interface AutoConfigurationPackage {
                }
                Registrar类的内部代码如下：
                    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
                        Registrar() {
                        }
                        //metadata：带@SpringBootApplication的类的元数据：包含了类名和包名等等
                        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
                            //获取出springboot的启动类的包名，并自动扫描其包下和子包下所有的带标签的组件，并加载到容器中
                            AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
                        }
                        public Set<Object> determineImports(AnnotationMetadata metadata) {
                            return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
                        }
                    }

@Import({AutoConfigurationImportSelector.class})详解