springboot2基础入门：

spring与springboot ：

总体来说，Spring 是一个 Java 开发框架，提供依赖注入、AOP、事务、MVC、数据访问等基础能力。 Spring Boot 是基于 Spring 的快速开发框架，用来简化 Spring 项目的配置、启动和部署。

spring能做什么：

spring其实是一整个生态圈，有各种各样的解决方案，下面只列出几个主要的。

Microservices：微服务

一个大的系统可以分成很多小模块，比如一个电商系统可以拆成：
用户服务
订单服务
支付服务
商品服务
库存服务

这些小的模块就叫做微服务。

而 Spring Boot 就是用来快速写一个服务，Spring Cloud 则用来管理一堆服务。

Reactive：响应式编程

Reactive 指的是 异步、非阻塞 的应用模型。

传统 Web 请求大概是：一个请求占用一个线程，等数据库/网络返回

响应式模式是：请求不会一直阻塞线程，适合高并发、实时流式场景

比如实时聊天、推送系统、流式数据处理，就可能用到 Reactive。

Cloud：云原生 / 云平台

云环境就是把应用运行在“云服务器/云平台”上的环境，Cloud 表示 Spring 可以很好地运行在云环境里，比如：

Docker Kubernetes AWS Azure Google Cloud 阿里云 腾讯云

它关注的是：

配置管理 服务发现 负载均衡 日志监控 弹性伸缩 容器化部署

Web apps：Web 应用

Spring 可以开发：
网站
后台管理系统
REST API
前后端分离接口
传统 MVC 项目

Event Driven：事件驱动

Event Driven 指的是系统之间通过“事件”通信。

如：
用户下单 -> 发送订单创建事件
库存服务 -> 扣减库存
积分服务 -> 增加积分
通知服务 -> 发送短信

这些服务不一定直接互相调用，而是通过消息队列传递事件。

ps：消息是“发生了一件事”。消息队列是一个中间件，用来存放和传递消息。
用户点击下单
订单服务创建订单
系统产生一个事件：OrderCreatedEvent（订单已创建）
这个事件被发送到消息队列
库存服务、积分服务、通知服务去消息队列里消费这个事件

Batch：批处理

Batch 指的是定时或离线处理大量数据。

如：
每天凌晨统计订单
批量生成报表
批量导入 Excel
定时清理过期数据
银行对账
日志分析

适合处理“很多条数据，一批一批执行”的任务。

Serverless：无服务器应用

即有请求时才运行服务，请求来了才执行，没请求时几乎不占资源。

springboot能做什么：

springboot其实是一个高层框架，是基于spring框架的整合配置。即建立在 Spring 之上，把大量配置、依赖整合、服务器启动这些繁琐工作自动处理掉。会根据你引入的依赖，自动判断要配置什么。快速创建生产级别spring应用。

即：

整合 Spring 技术栈的一站式框架
简化 Spring 技术栈的快速开发脚手架

优点：

创建独立的 Spring 应用  
    Spring Boot 可以直接创建一个“独立应用”，也就是项目自己就能启动，不需要你手动部署到外部服务器。

内嵌 Tomcat、Jetty 或 Undertow，不需要部署 WAR 文件 
    
提供 starter 依赖，简化构建配置 
    把常用依赖打包成套餐，减少你自己找 jar、配版本的麻烦。

自动配置 Spring 和第三方库 
    Spring Boot 会根据你引入的依赖，自动猜测你想做什么，然后帮你配置好。 

提供生产级别功能，比如指标、健康检查、外部化配置 

不生成代码，也不强制要求 XML 配置
    Spring Boot 不强制你写 XML，大部分场景用注解和配置文件就能完成。

缺点：

迭代快，需一直关注
封装深，原理复杂，不易精通

Hello World

使用maven构建项目后在pom中加入：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>

然后maven重构项目，再在pom中添加系统依赖：

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

然后编写启动类，名字任意，但一定要加@SpringBootApplication注解，宣称这是一个SpringBoot应用，位置建议放在最外层根包下。然后是主方法固定启动写法

package com.inex;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

然后在包含启动类的包下面新建controller包，新建一个controller类：

package com.inex.controller;

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

//@ResponseBody
//@Controller
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello,world";
    }
}

@ResponseBody注解：下面的类，方法直接返回数据给浏览器/前端

@RequestMapping注解：接收 HTTP 请求

@RestController注解：上面两个的集合

@Controller注解：表示这个类是 Spring MVC 的控制器，即专门负责接收浏览器/前端请求，并决定返回什么结果的类。是 Web 后端的入口之一。

可以改服务的配置，固定在main->resources下的application.properties

比如：

server.port=8888

具体可改哪些配置可参考官方文档。

为简化部署，可以加入以下依赖然后直接打成jar包：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

maven面板里执行package后新生成的整个target目录都是打包后的结果。在该目录下可直接运行环境。

依赖管理机制：

所有springboot项目都有一个父项目依赖：

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>

一般用来做依赖管理，子项目只要继承了父项目那就能直接继承父项目的依赖

而starter的父项目则是：

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

再跟进可以看到巨量依赖（：

  <properties>
    <activemq.version>5.15.13</activemq.version>
    <antlr2.version>2.7.7</antlr2.version>
    <appengine-sdk.version>1.9.82</appengine-sdk.version>
    <artemis.version>2.12.0</artemis.version>
    <aspectj.version>1.9.6</aspectj.version>
    <assertj.version>3.16.1</assertj.version>
    <atomikos.version>4.0.6</atomikos.version>
    <awaitility.version>4.0.3</awaitility.version>
    <bitronix.version>2.1.4</bitronix.version>
    <build-helper-maven-plugin.version>3.1.0</build-helper-maven-plugin.version>
    <byte-buddy.version>1.10.14</byte-buddy.version>
    <caffeine.version>2.8.5</caffeine.version>
    <cassandra-driver.version>4.6.1</cassandra-driver.version>
    <classmate.version>1.5.1</classmate.version>
    <commons-codec.version>1.14</commons-codec.version>
    <commons-dbcp2.version>2.7.0</commons-dbcp2.version>
    <commons-lang3.version>3.10</commons-lang3.version>
    <commons-pool.version>1.6</commons-pool.version>
    <commons-pool2.version>2.8.1</commons-pool2.version>
    <couchbase-client.version>3.0.8</couchbase-client.version>
    <db2-jdbc.version>11.5.4.0</db2-jdbc.version>
    <dependency-management-plugin.version>1.0.10.RELEASE</dependency-management-plugin.version>
    <derby.version>10.14.2.0</derby.version>
    <dropwizard-metrics.version>4.1.12.1</dropwizard-metrics.version>
    <ehcache.version>2.10.6</ehcache.version>
    <ehcache3.version>3.8.1</ehcache3.version> 
    ...

几乎声明了所有开发常用的jar的版本号

我们想添加任意驱动时可以直接在这里面Ctrl+F搜索然后复制到pom的dependencies里

不用写版本号，因为spring-boot-dependencies里面已经配好。这称为自动版本仲裁机制。如果想自己修改版本号可以先看spring-boot-dependencies里写好的key，再自己去maven仓库找合适的版本配置。用<properties>标签写入，比如mysql：

    <properties>
            <mysql.version>8.0.33</mysql.version>
    </properties>

然后刷新

starter场景启动器：

1、我们见到很多 spring-boot-starter-*：* 就是某种场景
2、只要引入 starter，这个场景的所有常规需要的依赖我们都自动引入
3、SpringBoot 所有支持的场景：
https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
4、见到的 *-spring-boot-starter一般是第三方为我们提供的简化开发的场景启动器。 
5、所有场景启动器最底层的依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.3.4.RELEASE</version>
    <scope>compile</scope>
</dependency>

自动配置特性：

IOC容器：Spring 管理 Bean 对象的容器，它帮我们创建对象、保存对象、装配对象

Bean对象： Spring 帮你创建、保存、管理的对象

下面的代码会启动 Spring Boot 项目，并把 IOC 容器里的所有组件名字打印出来。就是看 Spring Boot 自动给我们装配了哪些组件，也能验证哪些类已经被

Spring 管理了。

package com.inex;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class MainApplication {
    public static void main (String[] args){
        // 1、返回我们的IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        // 2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

引入 starter 后，Spring Boot 会根据项目里的依赖和配置，自动创建常用组件，并给它们设置默认值。

Spring Boot 默认会扫描 主程序类所在包及其子包。

如果你把类放到外面，又想它扫描到，可以手动指定扫描路径：

@SpringBootApplication(scanBasePackages = "com.atguigu")
public class MainApplication {
}

或者：

@ComponentScan("com.atguigu")

ps：@SpringBootApplication 等同于：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

Spring Boot 内部有很多专门接收配置的类。比如文件上传配置对应的类大概是：

MultipartProperties

配置文件里这些内容：

spring.servlet.multipart.enabled=true
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=100MB

会自动绑定到 MultipartProperties 对象上，最后会变成 Java 对象里的一个属性值

各种配置拥有默认值，配置文件的值最终会绑定每个类上，这个类会在容器中创建对象

Spring Boot 不是把所有自动配置类都开启，而是 按导入的依赖开启。SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面。Spring

Boot 自动配置的核心依赖是 spring-boot-autoconfigure 。里面有很多自动配置类，比如：

WebMvcAutoConfiguration
DispatcherServletAutoConfiguration
ServletWebServerFactoryAutoConfiguration
DataSourceAutoConfiguration
MultipartAutoConfiguration
JacksonAutoConfiguration

这些类会根据项目里的依赖和配置文件，决定要不要生效。

比如：

• 有 SpringMVC 依赖，WebMvcAutoConfiguration 生效
• 有 Jackson 依赖，JacksonAutoConfiguration 生效
• 有数据库连接池依赖，DataSourceAutoConfiguration 生效

starter 是“依赖集合”，auto-configuration 是“自动配置逻辑”。

比如：

spring-boot-starter-web

它引入：

• SpringMVC
• Tomcat
• Jackson
• Spring Boot 基础依赖

然后 Spring Boot 看到这些依赖，就会触发对应的自动配置。

流程：

引入 starter
    ↓
starter 引入一堆依赖
    ↓
Spring Boot 检测到这些依赖
    ↓
对应的自动配置类生效
    ↓
自动创建组件并设置默认值