1 SpringBoot介绍
理解: 传统框架在使用时,特别的繁琐 Spring/SpringMVC/Mybatis在使用时需要大量的配置文件. 使用SpringBoot可以简化传统框架的配置文件. 以注解的方式简化开发过程. SpringBoot可以理解为框架的框架(框架的工具API).
优势: “开箱即用” 拿来就用 简化配置的过程.
什么是 Spring Boot
Spring Boot 其实就是 Spring，学过 Spring 的同学一定都知道，即使是一个很简单的程序，Spring 都需要大量的配置。而 Spring Boot 将我们从配置文件中解放了出来，Spring Boot 提供了大量的默认配置，我们只需要少数的配置甚至不配置，就可以建立起来一个 Spring Boot 应用，简直就是 Java 程序员的福音。
在之前学习 Spring 的时候，总是需要经过繁杂的配置才能正常使用。例如配置 Spring MVC，我们需要配置前端控制器、过滤器、还有视图解析器等相关内容。在这个过程中，我们似乎总要配置几个 Bean，而 Spring Boot 可以根据帮我们自动配置这些组件。Spring Boot 设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot 致力于在蓬勃发展的快速应用开发领域成为领导者。
上图为 Spring Boot 架构图，可以帮助同学们初步了解 Spring Boot 架构。
本节教程采用 Spring Boot 2.0.4，该版本采用 Spring 5.0.8 构建，要求 JDK 至少 1.8 版本，并且 Servlet 容器要求 3.1 版本以上，也就是 tomcat8.5+，Jetty 9.4+，Undertow 1.4+，或者其他 3.1 版本以上的 Servlet 容器。
2018 年 3 月 1 号 Spring Boot 2 正式发布，这是 Spring Boot 1.0 发布 4 年之后的一次非常重要的版本更新，有很多新功能和特性值得开发者们注意。
- 基于 Java 8，支持 Java 9
- 支持 Quartz 调度程序
- 大大简化了安全自动配置
- 支持嵌入式 Netty
- Tomcat, Undertow 和 Jetty 均已支持 HTTP/2
- 全新的执行器架构，支持 Spring MVC, WebFlux 和 Jersey
- 使用 Spring WebFlux/WebFlux.fn 提供响应式 Web 编程支持
- 为各种组件的响应式编程提供了自动化配置，如：Reactive Spring Data、Reactive Spring Security 等
- 用于响应式 Spring Data Cassandra, MongoDB, Couchbase 和 Redis 的自动化配置和启动器 POM
- 引入对 Kotlin 1.2.x 的支持，并提供了一个
runApplication函数，让你通过惯用的 Kotlin 来运行 Spring Boot 应用程序。
首先是 JDK 版本的升级，Spring Boot 2.0 要求 JDK8 作为最低版本，许多现有的 API 已更新，以利用 Java 8 的特性，同时也，支持 JDK 9，但是不再支持 Java 6 和 7。
同时，Spring Boot 2.0 基于 Spring Framework 5 构建，本次更新中也对部分其依赖的第三方组件进行了升级，主要有以下几个：
- Jetty 9.4
- Tomcat 8.5
- Flyway 5
- Hibernate 5.2
- Gradle 3.4
- Thymeleaf 3.0
这里只介绍了与本次课程有关的一些内容，想要了解更多 Spring Boot 2.0 新特性的同学可以查看其官方发布内容：
Spring Boot 的优点
- 继承了 Spring 的优点
Spring Boot 框架来自于 Spring 大家族，因此 Spring 所有具备的功能和 Spring 框架的优点以及带给开发人员的便利， Spring Boot 框架同样能够提供并且做了大量的封装和优化，使得 Spring Boot 相交于 Spring 框架更容易上手和学习；简单来说，相对于 Spring 来说，完成同样的功能和效果，用户需要操作和编码的工作更少了。
- 可以快速创建独立运行的 Spring 项目，简化开发
Spring Boot 简化了基于 Spring 的应用开发，通过少量的代码就能快速构建一个个独立的、产品级别的 Spring 应用。
官方的 Spring Initializr 方案是一个创建新的 Spring Boot 项目不错的选择，并根据自身业务需求选择和加载可能使用到的依赖，使用官方的初始化方案创建 Spring Boot 项目能够确保你获得经过测试和验证的依赖项，这些依赖项适用于自动配置，能够大大简化项目创建流程，同时，IDEA 和 STS 编辑器也支持这种直接初始化 Spring Boot 项目的方式，一分钟之内就可以完成一个项目的初始化工作，是不是被惊艳到了？
- 习惯优于配置
Spring Boot 遵循习惯优于配置的原则，使用 Spring Boot 我们只需要很少的配置甚至零配置即可完成项目开发，因为大多数大使用 Spring Boot 默认配置即可。
- starters 自动依赖与版本控制
Spring Boot 通过一些 starter 的定义减少开发人员在依赖管理上所花费的时间，在整合各项功能的时候不需要去自行搜索和查找所需依赖并且在 Maven 的 pom 文件中进行定义。 starter 可以简单的理解为“场景启动器”，在不同的场景和功能中引入不同的 starter， 如果需要开发 web 项目，在 pom 文件中导入 spring-boot-starter-web ， web 项目开发中所需的依赖都已经维护在 spring-boot-starter-web 中，无需再去导入 servlet 、springmvc 等所需要的 jar 包，项目中如果需要使用 jdbc，在 pom 文件中导入 spring-boot-starter-web 即可，还有其他企业开发中的各种场景，Spring Boot 都已经准备好了，如果没有对应的 starter 也可以自行定义。starter 节选如下：
能够如此方便的进行依赖管理是因为 Spring Boot 在场景启动器的设计中提供了 starter POM，这些 pom 文件的存在导致使用 Spring Boot 开发项目可以非常方便的进行包管理，所需依赖以及依赖 jar 包的关系和版本都由 starter 自行维护，很大程度上减少了自己维护依赖版本所造成的 jar 包冲突或者依赖的版本冲突。
- 对主流框架无配置集成 使用场景全覆盖
Spring Boot 集成的技术栈丰富，各互联网公司使用的技术框架大多可以无配置集成，其他的也可以通过自定义 Spring Boot-starter 进行快速集成，这也代表着 Spring Boot 的应用场景非常广泛，包括常见的 Web 应用、SOA 及目前十分火热的微服务等。在 Web 应用中，Spring Boot 提供了 spring-boot-starter-web 来为 Web 开发予以支持，spring-boot-starter-web 为我们提供了嵌入的 Tomcat 以及 SpringMVC 的依赖， 可以快速构建 MVC 模式的 Web 工程；在 SOA 及微服务中，用 Spring Boot 可以包装每个服务， Spring Cloud 即是一套基于 Spring Boot 实现分布式系统的工具，适用于构建微服务；Spring Boot 提供了 spring-boot-starter-websocket 可以快速实现消息推送，也可以整合流行的 RPC 框架，提供 RPC 服务接口，只要简单地加入对应的 starter 组件即可。
-
使用 Spring Initializr 可以在几秒钟就配置好一个 Spring Boot 应用。
-
对大量的框架都可以无缝集成，基本不需要配置或者很少的配置就可以运行。
-
简化的安全性。
-
丰富的 SQL 和 NoSQL 支持。
-
嵌入式 Servlet 容器的支持。如：Tomcat，Jetty 和 Undertow。
内嵌 Servlet 容器，Spring Boot 直接嵌入 Tomcat 、 Jetty 或者 Undertow 作为 Servlet 容器 ，降低了对环境的要求，在开发和部署时都无需安装 Tomcat 或者 Jetty 等 Web 容器，调试方便，开发完成后可以将项目打包为 Jar 包，并使用命令行直接启动项目，减去部署环节打包并发布到 Servlet 容器中的过程。
使用嵌入式的 Servlet 容器使得开发调试环节和部署环节的工作量有所减少，同时开发者也可以通过 Spring Boot 配置文件修改内置 Servlet 容器的配置，简单又灵活。
-
提高开发、生产效率，如热部署等功能。
-
提供监控功能，如跟踪，指标和健康状况。
-
创建独立的 Spring 应用程序
-
直接嵌入 Tomcat，Jetty 或 Undertow（无需部署 WAR 文件）
-
提供启动器配置依赖项，以简化构建配置
自动进行 Spring 框架的配置，节省程序员大量的时间和精力，能够让程序员专注在业务逻辑代码的编写上，由于自动配置，大量原先需要在 Spring 配置文件中配置项不用去做，但是 Spring Boot 也有自己的配置方式，简洁灵活。
-
尽可能自动配置 Spring 和第三方库
开发环境搭建
- JDK8的安装和配置
- IDEA编辑器的安装和配置
- Maven的安装和配置
- MySql8的安装和使用
2 IDEA环境配置
2.1 准备项目目录
程序员操守: 1.路径中不要出现中文/空格/特殊字符.
2.中文对C语言的程序有致命的影响.
- 目录:
- IDEA软件打开
2.2 IDEA环境配置
具体配置查看PPT文档
2.3 关于Maven环境说明
组件:
- 远程仓库 官方维护了几乎所有的项目的jar包.(版权问题oracle数据)
- 私服镜像 在国内仓库. 阿里云镜像服务器.
- 本地仓库 用户在自己本地维护的jar包文件.
settings文件说明:
- 配置本地仓库路径
- 配置私服镜像
<mirror>
<id>aliyun</id>
<name>aliyun for maven</name>
<mirrorOf>*</mirrorOf>
<url>https://maven.aliyun.com/repository/public</url>
</mirror>
IDEA整合Maven
2.4 创建项目不能识别问题
如图: 创建项目之后,不能被maven项目标识.
-
解决方案
2.5 关于Server URL地址说明
课上使用默认配置 jar包版本下载2.5.3
路径: https://start.spring.io/
https://start.springboot.io/
https://start.aliyun.com/
3 SpringBoot入门demo创建
3.1 项目创建
3.2 项目版本
3.3 关于项目报错说明
如果项目中出现parent标签报错/插件报错说明:
1.parent标签报错
- maven插件报错
4. 关于maven 重要说明
4.1 jar包依赖传递性说明
例子: 假设: A.jar 依赖 B.jar , B.jar 依赖于 C.jar
说明: 在项目中 添加了web的jar包,则可以依赖其他的jar包,为项目提供支持.
4.1.1 知识点1 jar包下载不完整解决方案:
如果pom.xml文件jar包文件报错. 检查本地仓库中的jar包文件是否完整.如果下载不完整. 则手动删除文件.之后重写下载.
4.1.2 知识点2: jar包传递性的原理.
说明: 当maven依赖jar包文件时,首先根据坐标查找本地仓库的路径,之后添加jar包文件. 之后再次加载该文件目录的xxx.pom文件.读取其中的依赖项,进行再次依赖.以此类推.
4.2 jar包下载安全性说明(扩展)
说明: maven数据传输 通过sha1的数字摘要 包装数据的完整性
4.2.1 知识讲解:
SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。
4.2.2 知识扩展:
问题1: 如果数据相同,采用相同的hash函数 问: 值是否相同? 答案:必然相同!!!!
问题2: 常见hash编码 是多少位16进制数?? 答案: 8位16进制数
问题3: 8位16进制数,取值区间多少? 答案: 2^32
00000000-FFFFFFFF
问题4: 1kb的数据和1gb数据 hash谁快? 答案: 一样快
问题5: 数据相同则hash码相同,hash码相同数据一定相同? 不正确. **hash碰撞!**
降低碰撞概率, 增大hash长度.
1234567
(2^4)^8=2^32
4.2.3 数据传递有效性
5.SpringBoot高级用法
5.1 pom.xml文件说明
<?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>
<!--项目的坐标
1.标识当前的项目
2.坐标的位置就是jar包文件的位置
3.通过坐标可以被其它项目引用
-->
<groupId>com.example</groupId>
<artifactId>springboot_demo1</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springboot_demo1</name>
<description>springboot_demo1</description>
<!--2.指定pom.xml中的配置信息-->
<properties>
<java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!--指定springboot的版本-->
<spring-boot.version>2.3.7.RELEASE</spring-boot.version>
</properties>
<!--3.当前项目依赖的其它jar包文件 -->
<dependencies>
<!--3.1 添加依赖信息,其中版本号是默认的无序手写-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!--版本号 <version></version>-->
</dependency>
<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>
<!--4.依赖的管理器
历史: 早期项目使用时,需要自己手动的添加依赖jar包文件.可能导致jar包文件不兼容/冲突
直接导致项目启动出问题. 该问题是开发中的常见诟病.
SpringBoot优势:
SpringBoot将市面上常见的jar包都进行了兼容.并且在内部进行了测试.并且
使用其它第三方框架的时候,只需要简单的配置.可以使用其功能. (开箱即用)
-->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.3.7.RELEASE</version>
<configuration>
<mainClass>com.jt.SpringbootDemo1Application</mainClass>
</configuration>
<executions>
<execution>
<id>repackage</id>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
5.1.1 parent标签作用
<!--
继承特点: 将父级内容进行引用.(简化)
SpringBoot理解: SpringBoot是框架的框架
问题: jar包冲突问题严重,之后需要有人统一管理
A.jar ~~~~ 5.1.jar
B.jar ~~~~ 4.8.jar
SpringBoot项目: 官网将大部分框架在内部进行了整合.
并且制定了,统一的版本依赖信息.
parent标签的作用: 定义当前SpringBoot所有依赖的版本号
-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.3</version>
<relativePath/>
</parent>
5.1.2 dependency标签作用
<!--按需导入
历史说明: 2010 原来SSM 需要手动的编辑大量的的配置文件
思想: SpringBoot使用体现了"开箱即用"的思想
-->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<!--Springboot的启动器 在内部已经将整合的配置写好,实现拿来就用-->
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
5.1.3 build标签作用
<!--build标签
springboot项目在打包部署发布时,需要依赖maven工具API
如果不添加该插件,则直接影响项目发布
-->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.5.3</version>
</plugin>
</plugins>
</build>
5.1.4 Maven指令
1.clean 删除编译后的目录 target .java 文件源码 .jar包(xxx.class文
件)
- 用法: 1.当可能出现编译问题时 使用clean. 2.项目打包前使用
2.install 项目发布 将xxx.class文件 打包成为 xxx.jar
-jar包位置: 1.target目录下 2.本地仓库中.
target目录下:
本地仓库目录下:
5.1.5 java项目发布命令
-
进入jar包的根目录
-
前提 必须配置JDK
说明: 通过 java -version 检查JDK是否配置正常.
如果提示java不是内部命令 则环境变量配置一定有问题.
环境变量配置:
2. 项目发布
命令: java -jar xxx.jar
5.1.6 项目关闭问题
如果项目发布成功之后,需要关闭. 则直接关闭dos命令窗口即可.
如果依然不能正常关闭.则杀死进程/或者重启计算机.
右键结束进程项即可
5.1.7 关于dos命令窗口锁定问题
说明: 当通过dos命令 启动tomcat服务器时,可能由于误操作.锁定当前dos窗口
解决方案: 万能取消指令 ctrl + c
6. SpringBoot高级用法
6.1 @Value注解
6.1.1 需求说明
有时需要动态的获取数据,不能直接写死在代码中, 如何处理???
6.1.2 编辑YML文件—YML文件和XML文件不同时存在
#语法说明
## 语法1: 数据结构 key-value结构
## 语法2: 写法 key:(空格)value
## 语法3: yml文件 默认字符集是UTF-8编码 中文不乱码
## 语法4: yml文件 有层级效果 注意缩进
server:
port: 8080
# SpringBoot启动时 默认加载yml文件
msg:
hello: "今天下雨,记得带伞~~"
6.1.3 编辑HelloController
@RestController //将该类交给Spring管理
public class HelloController {
/**
* 规则:
* 1. 当Spring容器启动时,会加载YML配置文件.
* 会将内部的key-value结构 加载到spring维护的内存空间中
* 2. @Value功能,从spring容器中根据key 动态赋值
* 3. springel表达式 简称:spel
*
* 使用场景:
* 如果代码中需要给成员变量赋值时,一般采用动态赋值的方式.
*/
@Value("${msg.hello}")
private String msg;
@RequestMapping("/hello")
public String hello(){
return msg;
}
}
6.1.4 页面效果展现
6.2 属性赋值
6.2.1 @Value为属性赋值
YML配置信息
# SpringBoot启动时 默认加载yml文件
msg:
hello: "今天下雨,记得带伞~~"
动态赋值:
6.3 properties文件为属性赋值
6.3.1 业务说明
业务有时会需要动态赋值,如果将大量的业务数据写到yml文件中 导致代码混乱.最好的方式应该指定properties文件 为业务赋值.
6.3.2 编辑properties文件
#语法:
#数据结构: key=value
#注意事项: 不要添加""号 本身就是字符串.
#字符集编码: 写法采用utf-8,程序读取时采用ISO-8859-1
pro.msg=配置信息
6.3.3 动态为属性赋值
package com.jt.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController //将该类交给Spring管理
//spring负责加载指定的配置文件
//如果注解中只有一个属性名称为value 则可以省略不写
@PropertySource(value="classpath:/msg.properties",encoding = "utf-8")
public class HelloController {
/**
* 规则:
* 1. 当Spring容器启动时,会加载YML配置文件.
* 会将内部的key-value结构 加载到spring维护的内存空间中
* 2. @Value功能,从spring容器中根据key 动态赋值
* 3. springel表达式 简称:spel
*
* 使用场景:
* 如果代码中需要给成员变量赋值时,一般采用动态赋值的方式.
*/
@Value("${msg.hello}")
private String msg;
@Value("${pro.msg}")
private String proMsg;
@RequestMapping("/hello")
public String hello(){
return msg+"||"+proMsg;
}
}
6.4环境切换
要求: 不管是几个环境,要求配置项都必须相同,值可以不同
语法:
1.使用—实现YML配置文件的分割
2.定义环境名称
3.定义默认环境名称
#指定默认的环境
spring:
profiles:
active: test
---
#关于YML配置文件说明
# 1.数据结构 key=value
# 2.数据类型 默认都是字符串 如果需要类型转化,则框架已经在内部完成
# 3.yml写法: 1.key: (空格)value 2.有层级结构 编辑时注意
# 4.字符集编码: 默认程序加载时都是UTF-8
#定义环境名称
spring:
config:
activate:
on-profile: dev
server:
port: 8080
#项目发布的路径
servlet:
# /缺省值 localhost:8080/jt/xxxx请求路径
context-path: /
#2.为属性赋值 hello代表前缀 key=hello.msg
hello:
msg: "我喜欢开发"
#环境分割线
---
spring:
config:
activate:
on-profile: test
server:
port: 8090
#项目发布的路径
servlet:
# /缺省值 localhost:8080/jt/xxxx请求路径
context-path: /
#2.为属性赋值 hello代表前缀 key=hello.msg
hello:
msg: "我喜欢测试"
6.5热部署
6.5.1 添加依赖
<!--支持热部署 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
6.5.2 配置IDEA环境
快捷键: ctrl + shift +alt + / 或者 ctrl + alt + a
勾选属性即可实现热部署
6.6 Lombok插件安装
6.6.1 插件安装
6.6.2 添加jar包
<!--引入插件lombok 自动的set/get/构造方法插件 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
6.6.3 lombok作用
动态生成常见 get/set/toString等方法
//标准写法
//知识点: 为什么需要添加无参构造???
// 利用反射机制实例化对象时,默认调用无参构造
@Data //get/set/toString/equals/hashcode
@NoArgsConstructor //无参构造
@AllArgsConstructor//全参构造
@Accessors(chain = true)
public class User implements Serializable {
private Integer id;
private String name;
//链式加载的底层原理 返回User对象
/* public User setId(Integer id){
this.id = id;
return this; //代表当前对象!!!!!
}
public User setName(String name){
this.name = name;
return this;
}*/
}
6.6.4 lombok知识点
问题: lombok使用需要提前安装lombok插件!!, 如果项目发布在Linux系统中.问: 系统是否需要提前安装插件?
答案: 不要 因为lombok插件在编译期有效!!!
xxx.java文件编译为xxx.class文件.
知识衍生: 写的是java源码, 运行的是编译后的.class
6.7 SpringBoot测试类用法
6.7.1 业务说明
说明:有时由于业务需要,需要进行单元测试, 单元测试中的对象可能会依赖Spring容器.
需求: 需要Spring容器管理一个User对象. id=101 name=“好好学习”
分析: 难点: 定制化属性内容!!! 具体业务功能. 利用配置类实现!!!
6.7.2 编辑配置类
//作用: 将自己需要的对象交给Spring容器管理
@Configuration //标识这是一个配置类
public class UserConfig {
/**
* 知识点:1.Spring内部维护一个Map集合
* 2. Map集合 key/value 分别是谁???
* 3.IOC管理的对象的方式 1.@Controller等注解 2.@bean
*
* 1.注解组合: @Configuration + @Bean
* 2.什么是bean: 被spring管理的对象就是bean
* 3.@Bean注解的作用
* 将方法的返回值对象交给Spring管理
* 4.Spring如何管理对象?
* 数据结构: Map集合 Map<K,V>
* key: 对象的ID
* value: 实例化之后的对象
* demo1: Spring如何管理对象
* key: 方法的名称
* value: 方法的返回值 Map<user,new User()>
*
* demo2:
* @Controller
* HelloController{}
* key: helloController 首字母小写
* value: spring通过反射创建的HelloController对象
* @return
*/
@Bean
public User user(){
return new User(101,"好好学习");
}
}
6.7.3 Spring对象注入原理
1.根据对象类型进行注入
6.7.4 编辑测试类
package com.jt.test;
import com.jt.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
/**
* 原理说明:
* 1.当测试类执行时,会根据SpringBoot的配置,动态启动Spring容器.
* 2.当spring容器启动时,会加载所有的注解和配置类,最终将所有的对象
* 交给Spring容器管理 Map集合
* 3.@SpringBootTest 通过这个注解,可以动态的从spring容器中
* 获取对象
*
*/
@SpringBootTest
public class TestSpring {
/**
* 注入方式:
* 1. 根据类型注入 (默认规则)
* 2. 根据名称注入 @Autowired
* @Qualifier("user")
*/
@Autowired
//@Qualifier(value="user")
private User user;
@Test
public void testUser(){
System.out.println(user.toString());
}
}
7. SpringBoot使用注意事项
7.1 关于Build标签说明
如果没有build标签则项目打包之后不能正常执行.报错如下
7.2 关于主启动类说明
说明: 主启动类运行,真正起作用的是注解@SpringBootApplication
@SpringBootApplication
public class SpringbootDemo1Application {
public static void main(String[] args) {
SpringApplication.run(SpringbootDemo1Application.class, args);
}
}
启动并运行项目
找到SpringBoot 工程中由@SpringBootApplication注解描述的类为然后启动运行，其启动过程如下：
在启动过程中底层做了哪些事情，大致描述如下：
第一：基于配置加载类(通过ClassLoader将指定位置的类通过线程调用IO从磁盘读取到内存)。
第二：对类进行分析(创建字节码对象-Class类型,通过反射获取器配置信息)。
第三：对于指定配置(例如由spring特定注解描述)的对象存储其配置信息(借助BeanDefinition对象存储)。
第四：基于BeanDefinition对象中class的配置构建类的实例(Bean对象),并进行bean对象的管理(可能会存储到bean池)。
7.2.1 关于元注解的说明
@Target(ElementType.TYPE) //注解对谁有效
@Retention(RetentionPolicy.RUNTIME) //注解的声明周期,在运行期有效
@Documented //文档支持,生成源码时 是否动态生成注释文档
@Inherited //是否可以被继承
@SpringBootConfiguration //springboot的配置类
@EnableAutoConfiguration //启动自动化的配置,加载pom.xml文件中的启动项
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), //包扫描路径,默认条件下是主启动类的包路径. 所以以后写代码在主启动类的同包及子包中编辑.
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
7.2.2 @ComponentScan说明
说明: 当springBoot启动时,会实例化很多的对象,但是需要排除特定的类型
原因: SpringBoot内部兼容了很多的第三方框架,但是其中个别加入之后会影响整个代码流程,所以通过这样的方式将个别的类排除在外.
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
7.2.3 @SpringBootConfiguration注解说明
关键词: 配置文件/配置类 作用:整合第三方框架(配置)
@Configuration: 该注解一般标识类文件,告知springBoot程序 这个类是用来整合第三方框架/配置的.
说明2: @SpringBootConfiguration修饰主启动类,说明主启动类也是一个配置类.
说明3: SpringBoot主启动类会扫描用户自己的配置类,并且实例化对象.
7.2.4 @EnableAutoConfiguration注解说明
说明: 自动化的配置如图所示:
@AutoConfigurationPackage说明
该注解表示自动配置的包扫描的路径.
工作原理: 该注解会动态的获取主启动类当前的包路径.之后开启包扫描的机制.
知识点: 以后写代码都应该在主启动类的同包及子包中.
@Import(AutoConfigurationImportSelector.class)
知识回顾: SpringBoot使用体现了"开箱即用"的思想,用户引入jar包之后 可以直接使用(少量配置).
思考: dependencies代表程序的依赖项,(将其他的包加载到自己的项目中), 只是加载不负责执行.
流程说明(重点!!!)
当SpringBoot主启动项执行时,内部会加载@Import(AutoConfigurationImportSelector.class),
该注解的作用就是根据依赖信息,根据SpringBoot内部的配置信息,依次加载执行.
当匹配了用户添加的启动器之后,程序负责实例化框架(执行jar包中的内容).
如果匹配不到,则继续向下执行.最终SpringBoot程序加载成功.
7.2.5 主启动类注解结构图
7.2.6 关于依赖考题
问题: 用户暂时不需要数据库的配置. 问:能否先行添加数据源的启动项?? (不添加任何注解!!!)
答案: 不可以,因为启动项执行需要完整配置,数据源信息并未添加.导致报错.
总结: SpringBoot项目中的依赖包尤其启动项,添加时慎重. 如果需要添加启动器,则必须保证配置完整.否则程序启动必然失败!!!.
7.3 关于YML文件的说明
# 数据结构 key-value
# 语法结构 key:(空格)value
# 注意层级缩进
# 默认字符集: utf-8编码格式 支持中文
server:
port: 8080
本文由 liyunfei 创作，采用 知识共享署名4.0
国际许可协议进行许可
本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名
最后编辑时间为: Oct 4,2022