SpringBoot入门学习之基础篇(一)搭建和SpringBoot构成结构

​

入门案例

Spring和SpringBoot对比

一、原有Spring优缺点分析

1.Spring的优点分析
Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的EnterpriseJavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。

2.Spring的缺点分析
虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。
所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。
除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

二、SpringBoot的概述

1.SpringBoot解决上述Spring的缺点
SpringBoot对上述Spring的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。
2.SpringBoot的特点
为基于Spring的开发提供更快的入门体验开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式。

三、SpringBoot的核心功能

1起步依赖
起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
2自动配置
Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。

类/配置文件	Spring	SpringBoot
pom文件坐标	手工添加	勾选添加
web3.0配置类	手工添加	无
Spring/SpringMVC配置类	手工添加	无
控制器	手工添加	手工制作

SpringBoot可以通过idea、官网和手工快速搭建

idea搭建位置

官网搭建

https://start.spring.io/

国内地址；

https://start.springboot.io

阿里版本

https://start.aliyun.com/

也可以在idea中把地址给换一下

总结

SpringBoot程序需要基于jdk8进行制作

SpringBoot可以通过勾选选择技术

运行Application程序入口来进行运行

在idea中屏蔽不展示的文件

SpringBoot简介

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。

1.Spring的优点分析
Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的EnterpriseJavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。

2.Spring的缺点分析
虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。
所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。
除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

入门案列解析

parent

对于parent通俗的讲，SpringBoot使用的相关jar包所依赖的版本号都在parent中定义，当让也并非仅限于如此。

基本功能
当我们创建SpringBoot项目时，可以继承自一个spring-boot-starter-parent,也可以不继承自他。我们先来看看parent的基本功能有哪些？

1、定义了java编译版本为1.8

2、使用UTF-8的格式

3、继承自spring-boot-dependencies，这里面定义了依赖的版本，正式因为这里面定义 了依赖的版本，所以我们在写依赖时才不用写版本号

4、执行打包操作的配置

5、自动化资源过滤

6、自动化的插件配置

7、针对application.properties和application.yml的资源过滤，包括profile定义的不同环境的配置文件，例如application-dev(pro).properies和application-dev(pro).yml

如图:

我们可以看到，他继承自 spring-boot-dependencies，另外还可以看到jdk版本，编码格式，过滤信息等。下面我们再来看看spring-boot-dependencies中的定义

这里我们可以看到真对版本的定义和dependencyManagement节点，这下明白SpringBoot项目中部分依赖不需要写版本号了吧。

不用parent

在我们日常开发中并非所有的公司都需要这个parent，有的时候公司会自己定义parent，我们的SpringBoot项目要继承公司自己定义的parent，这个时候我们改如何办呢？

一个简单的办法就是我们自己定义一个dependencyManagement节点，然后在里面自己定义好版本，在接下来的引用依赖时就不用写版本号了。

例如:

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-dependencies</artifactId>
			<version>2.1.4.RELEASE</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>

这样写过之后，依赖的版本号是解决了，但是关于打包的插件，jdk版本，编码格式等这些配置，在没有parent的时候这些都需要自己区配置
总结:

1.开发SpringBoot程序要继承个spring-boot-starter-parent

2.spring-boot-starter-parent中定义若干个依赖管理

3.继承parent模块可以避免多个依赖使用相同技术时出现的版本冲突

4.继承parent的形式也可以采用引入依赖的形式实现效果

starter

用过springboot的同学都知道，相比于spring在配置pom文件时候的各种复杂依赖关系，springboot整合了很多的第三方依赖使用起来相当的方便。

在使用的过程中，我们经常能在pom文件中看到很多springboot的starter依赖，starter中简单来讲就是引入了一些相关依赖和一些初始化的配置。

例如我们最常见的

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

当然，除此以外，还有很多的类似依赖，比如下面截图的这些官方的starter依赖。

仔细观察，不难发现spring-boot-starter-***的形式，其实这是springboot的官方命名规则。

非官方的命名方式就是***-spring-boot starter的形式(如下mybatis框架的依赖)，当然这些都是约定俗成的，不是强制性的，你说我就想自定义一个spring-boot-starter-***形式的，你开心就好，完全可以，做好被骂的觉悟就行了。

自定义starter

实战
创建一个父maven项目:springboot_custome_starter
新建一个maven工程， 父工程，pom类型 ， src 目录 和 IDEA自动创建的.md文件，删除掉

pom 如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <packaging>pom</packaging>
    <groupId>com.artisan.customstarter</groupId>
    <artifactId>starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>starter</name>
    <description>SpringBoot自定义starter</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <!--提供source-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <configuration>
                    <attach>true</attach>
                </configuration>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

创建 两个Module: artisan-spring-boot-starter 和 artisan-spring-boot-starter-autoconfigurer

同样的方式创建

artisan-spring-boot-starter (空的jar文件，仅仅提供辅助性依赖管理)
pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>starter</artifactId>
        <groupId>com.artisan.customstarter</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <description>
        启动器（starter）是一个空的jar文件，
        仅仅提供辅助性依赖管理，
        这些依赖需要自动装配或其他类库。
    </description>



    <artifactId>artisan-spring-boot-starter</artifactId>

    <dependencies>
        <!--引入autoconfigure-->
        <dependency>
            <groupId>com.artisan.customstarter</groupId>
            <artifactId>artisan-spring-boot-starter-autoconfigurer</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <!--如果当前starter 还需要其他的类库就在这里引用-->
    </dependencies>


</project>

如果使用spring Initializr创建的需要删除 启动类、resources下的文件，test文件。

artisan-spring-boot-starter-autoconfigurer
pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>starter</artifactId>
        <groupId>com.artisan.customstarter</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>artisan-spring-boot-starter-autoconfigurer</artifactId>


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


    </dependencies>

</project>

关于自动提示的jar ,引入spring-boot-configuration-processor之后， 编译之后就会在META-INF文件夹下面生成一个spring-configuration-metadata.json的文件。

内容如下

【工程结构】

CustomProperties

import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @author 大佬发的精美代码感谢大佬们
 * @version 1.0
 * @description:  属性配置文件
 * @date 2021/5/22 18:56
 * @mark: show me the code , change the world
 */

@ConfigurationProperties("artisan.custom")
public class CustomProperties {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
    

IndexController

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 大佬发的精美代码感谢大佬们
 * @version 1.0
 * @description: TODO
 * @date 2021/5/22 18:58
 * @mark: show me the code , change the world
 */

@RestController
public class IndexController {

    private CustomProperties customProperties;

    public IndexController(CustomProperties customProperties) {
        this.customProperties = customProperties;
    }

    @RequestMapping("/")
    public String index() {
        return customProperties.getName();
    }

}
    

CustomAutoConfiguration 自动配置类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 大佬发的精美代码感谢大佬们
 * @version 1.0
 * @description: 模拟给web应用自动添加一个首页
 * @date 2021/5/22 18:55
 * @mark: show me the code , change the world
 */


@Configuration
@ConditionalOnProperty(value = "artisan.custom.name")
@EnableConfigurationProperties(CustomProperties.class)
public class CustomAutoConfiguration {


    @Autowired
    CustomProperties cus;

    @Bean
    public IndexController indexController() {
        return new IndexController(cus);
    }


}
    

spring.factories
在 resources 下创建文件夹 META-INF 并在 META-INF 下创建文件 spring.factories ，内容如下：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.artisan.CustomAutoConfiguration

打包发布
到这儿，我们的配置自定义的starter就写完了 ，我们artisan-spring-boot-starter 和 artisan-spring-boot-starter-autoconfigurer 安装成本地jar包。

引用自定义starter测试
新建个spring boot 项目 ，引用刚才的starter

访问 http://localhost:8080/

咦 ，别忘了你自定义的属性

重启后，重新访问

因为我们开启了debug=true .找找我们自动装配的类看看

starter和parent的对比

starter
SpringBoot在常见的项目名称定义了当前项目使用的所有依赖坐标，已达到减少依赖配置的目的
parent
所有SpringBoot项目要继承的项目定义了若干坐标版本号以达到减少依赖冲突的目的。
spring-boot-starter-parent各版本存在着诸多坐标版本不同

总结

开发SpringBoot需要导入坐标通常导入对应的starter
每一个starter根据功能不同，通常包含多个依赖坐标
使用starter可以实现快速配置的效果，达到简化配置的目的

启动方式

@SpringBootApplication
public class DemoApplication {

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

}

SpringBoot的引导类是Boot工程的执行入口，运行main方法就可以启动项目
SpringBoot工程运行初始化Spring容器，扫描引导类所在的包加载bean

总结

SpringBoot工程提供引导类来启动程序
SpringBoot工程运行后创建并初始化Spring容器

辅助功能

使用Maven依赖管理变得更起步依赖项

      <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!--web起步依赖环境中,排除Tomcat起步依赖-->
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--添加jettu起步依赖版本由Springboot中的starter控制-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>

jetty比tomcat更轻量级、可扩展性更强

内部服务器
tomcat(默认) apache出品，粉丝多、应用面广、负载了若干较重的组件
jetty 更轻量级，负载性能远不及tomcat
undertow undertow，负载性能勉强跑赢tomcat

总结

内嵌Tomcat服务器是springboot辅助功能之一
内嵌tomcat工作原理是将Tomcat服务器作为对象运行，并将该对象交给Spring容器进行管理
变更内嵌服务器思想是去除现有的服务器，添加全新的服务器

​