您现在的位置是：首页 >技术杂谈 >SpringBoot 框架网站首页技术杂谈

SpringBoot 框架

红尘不染 2024-07-04 11:17:55
简介SpringBoot 框架

SpringBoot 框架

SpringBoot 简介

SpringBoot 的设计目的是用来简化 Spring 应用的初始搭建以及开发过程。
以 SpringMVC 开发为例。

  1. 需要在pom.xml中导入坐标。
  2. 配置 web类。
  3. 配置 SpringMVC配置类。
  4. 编写Controller类。

其中前三步都是在进行配置，SpringBoot 就是对这三步进行简化。

SpringBoot 开发步骤

1.创建新模块，选择Spring初始化，并配置模块相关基础信息
请添加图片描述
选择 Spring Initializr 来快速构建 SpringBoot 工程。而在 Module SDK 这一项选择我们安装的 JDK 版本。
请添加图片描述
请添加图片描述
2.选择当前模块需要使用的技术集，由于我们需要开发一个 web 程序，使用到了 SpringMVC 技术，所以按照下图红框进行勾选。
请添加图片描述

直接点击 Finish 完成 SpringBoot 工程的构建请添加图片描述
3.开发控制器类

@RestController
@RequestMapping("/books")
public class BookController {
	@GetMapping("/{id}")
	public String getById(@PathVariable Integer id){
		System.out.println("id ==> "+id);
		return "hello , spring boot!";
	}
}

4.运行自动生成的Application类，运行 SpringBoot 工程不需要使用本地的 Tomcat 和 插件，只运行项目 com.itheima 包下的 Application 类，我们就可以在控制台看出如下信息。
5.运行后，访问对应请求路径即可请求到对应的Controller。

注意：
1.在创建好的工程中不需要创建配置类
2.创建好的项目会自动生成其他的一些文件，而这些文件目前对我们来说没有任何作用，所以可以将这些文件删除。
可以删除的目录和文件如下：.mvn，.gitignore，HELP.md，mvnw，mvnw.cmd

通过上面的入门案例我们可以看到使用 SpringBoot 进行开发，使整个开发变得很简单。其原因在于生成的 Application 类和 pom.xml，通过Application 进行自动装配。pom.xml 通过起步依赖，加载技术所需要的所有依赖。

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

<?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.5.0</version>
	</parent>
	<groupId>com.itheima</groupId>
	<artifactId>springboot_01_quickstart</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<!--JDK 的版本-->
	<properties>
		<java.version>8</java.version>
	</properties>
	<dependencies>
		<!--该依赖就是我们在创建 SpringBoot 工程勾选的那个 Spring Web 产生的-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!--这个是单元测试的依赖，我们现在没有进行单元测试，所以这个依赖现在可以没有-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<!--这个插件是在打包时需要的，而这里暂时还没有用到-->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

Spring 开发配置和SpringBoot开发配置对比：
请添加图片描述

  • 坐标
    Spring 程序中的坐标需要自己编写，而且坐标非常多
    SpringBoot 程序中的坐标是我们在创建工程时进行勾选自动生成的
  • web3.0配置类
    Spring 程序需要自己编写这个配置类。这个配置类大家之前编写过，肯定感觉很复杂
    SpringBoot 程序不需要我们自己书写
  • 配置类
    Spring/SpringMVC 程序的配置类需要自己书写。而 SpringBoot 程序则不需要书写。

SpringBoot工程快速启动

将 SpringBoot 工程打成 jar 包，该 jar 包运行不依赖于 Tomcat 和 Idea 这些工具也可以正常运行。
在构建 SpringBoot 工程时已经在 pom.xml 中配置了如下插件：

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

所以只需要使用 Maven 的 package 指令打包就会在 target 目录下生成对应的 Jar 包。
注意：该插件必须配置，不然打好的 jar 包也是有问题的。

进入 jar 包所在位置，在 命令提示符 中输入如下命令

jar -jar springboot_01_quickstart-0.0.1-SNAPSHOT.jar

就可以正常启动Springboot 工程了。
请添加图片描述

SpringBoot概述

SpringBoot 主要作用是简化 Spring 的搭建过程和开发过程。
原始 Spring 环境搭建和开发存在以下问题：

  • 配置繁琐
  • 依赖设置繁琐

SpringBoot 程序优点恰巧就是针对 Spring 的缺点

  • 自动配置。这个是用来解决 Spring 程序配置繁琐的问题
  • 起步依赖。这个是用来解决 Spring 程序依赖设置繁琐的问题
  • 辅助功能（内置服务器,…）。我们在启动 SpringBoot 程序时既没有使用本地的 tomcat 也没有使用 tomcat 插件，而是使用 SpringBoot 内置的服务器。

起步依赖

在创建的SpringBoot 的 Maven 工程的的 pom.xml 配置文件中自动生成了很多包含 starter 的依赖。
在这里插入图片描述
这些依赖就是起步依赖。
从上面的文件中可以看到指定了一个父工程，我们进入到父工程，发现父工程中又指定了一个父工程，如下图所示
在这里插入图片描述
该父工程中可以看到配置内容结构如下图所示
在这里插入图片描述
上图中的 properties 标签中定义了各个技术软件依赖的版本，避免了我们在使用不同软件技术时考虑版本的兼容问题。
dependencyManagement 标签是进行依赖版本锁定，但是并没有导入对应的依赖；如果我们工程需要那个依赖只需要引入依赖的 groupid 和 artifactId 不需要定义 version 。
build 标签中也对插件的版本进行了锁定，如下图
在这里插入图片描述
在创建的工程中的 pom.xml 中配置了如下依赖
在这里插入图片描述
进入到该依赖，查看 pom.xml 的依赖会发现它引入了如下的依赖
在这里插入图片描述
里面的引入了 spring-web 和 spring-webmvc 的依赖，这就是为什么工程中没有依赖这两个包还能正常使用springMVC 中的注解的原因。
而依赖 spring-boot-starter-tomcat ，从名字基本能确认内部依赖了 tomcat ，所以工程才能正常启动。
结论：以后需要使用技术，只需要引入该技术对应的起步依赖即可

小结

  • starter
    SpringBoot 中常见项目名称，定义了当前项目使用的所有项目坐标，以达到减少依赖配置的目的。
  • parent
    所有 SpringBoot 项目要继承的项目，定义了若干个坐标版本号（依赖管理，而非依赖），以达到减少依赖冲突的目的。

在实际开发中，使用任意坐标时，仅书写GAV中的groupid和artifactId，version 由SpringBoot提供。

自动装配

创建的每一个 SpringBoot 程序时都包含一个类似于下面的类，我们将这个类称作引导类。

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

SpringBoot 在创建项目时，采用jar的打包方式
SpringBoot 的引导类是项目的入口，运行 main 方法就可以启动项目
自动装配原理：SpringBoot 自动装配原理

切换web服务器

现在启动工程使用的是 tomcat 服务器，将 tomcat服务器切换为 jetty 服务器。步骤如下：
使用 exclusion 标签，将tomcat 起步依赖排除。

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

然后添加 jetty 的起步依赖。

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

通过切换服务器，不难发现在使用 SpringBoot 换技术时只需要导入该技术的起步依赖即可。

配置文件

配置文件格式

配置文件格式， SpringBoot 提供了多种配置文件的格式。
application.properties，application.yml，application.yaml。
SpringBoot 程序的配置文件名必须是 application ，只是后缀名不同而已。配合文件必须放在 resources 目录下。

示例，修改服务器的启动端口号
application.properties

server.port=80

application.yml
注意： 在 : 后，数据前一定要加空格。

server:
	port: 81

application.yaml
注意： 在 : 后，数据前一定要加空格。

server:
	port: 82

如果使用多种配置文件格式，三种配置文件的优先级：application.properties > application.yml > application.yaml

注意事项：

  • SpringBoot 核心配置文件名为 application
  • SpringBoot 内置属性过多，且所有属性集中在一起修改，在使用时，通过提示键+关键字修改属性

yaml格式

YAML（YAML Ain’t Markup Language），一种数据序列化格式。这种格式的配置文件在近些年已经占有主导地位，这种配置文件和前期使用的配置文件(xml配置，properties配置文件格式)是有一些优势的，我们先看之前使用的配置文件。

xml配置格式

<enterprise>
	<name>itcast</name>
	<age>16</age>
	<tel>4006184000</tel>
</enterprise>

properties 配置格式

enterprise.name=itcast
enterprise.age=16
enterprise.tel=4006184000

yaml 配置文件格式

enterprise:
	name: itcast
	age: 16
	tel: 4006184000

yaml 配置文件优点：

  • 容易阅读，yaml 类型的配置文件比 xml 类型的配置文件更容易阅读，结构更加清晰
  • 容易与脚本语言交互
  • 以数据为核心，重数据轻格式，yaml 更注重数据，而 xml 更注重格式

YAML 文件扩展名：yml (主流)，yaml。这两种后缀名都可以，通常使用 yml。

YAML 语法规则：

  • 大小写敏感
  • 属性层级关系使用多行描述，每行结尾使用冒号结束
  • 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键），空格的个数并不重要，只要保证同层级的左侧对齐即可。
  • 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）
  • #表示注释

yaml配置文件数据读取

在 resources 下创建一个名为 application.yml 的配置文件，里面配置了不同的数据，内容如下

lesson: SpringBoot

server:
	port: 80

enterprise:
	name: itcast
	age: 16
	tel: 4006184000
	subject:
		- Java
		- 前端
		- 大数据

@Value注解读取配置文件

使用 @Value(“表达式”) 注解可以从配置文件中读取数据，注解中用于读取属性名引用方式是： ${一级属性名.二级属性名……}。
在 BookController 中使用 @Value 注解读取配合文件数据，如下

@RestController
@RequestMapping("/books")
public class BookController {
	@Value("${lesson}")
	private String lesson;
	@Value("${server.port}")
	private Integer port;
	@Value("${enterprise.subject[0]}")
	private String subject_00;
	@GetMapping("/{id}")
	public String getById(@PathVariable Integer id){
		System.out.println(lesson);
		System.out.println(port);
		System.out.println(subject_00);
		return "hello , spring boot!";
	}
}

Environment对象

SpringBoot 还可以使用 @Autowired 注解注入 Environment 对象的方式读取数据。这种方式 SpringBoot 会将配置文件中所有的数据封装到 Environment 对象中，如果需要使用哪个数据只需要通过调用 Environment 对象的 getProperty(String name) 方法获取。

@RestController
@RequestMapping("/books")
public class BookController {
	@Autowired
	private Environment env;
	@GetMapping("/{id}")
	public String getById(@PathVariable Integer id){
		System.out.println(env.getProperty("lesson"));
		System.out.println(env.getProperty("enterprise.name"));
		System.out.println(env.getProperty("enterprise.subject[0]"));
		return "hello , spring boot!";
	}
}

注意：这种方式，框架内容大量数据，而在开发中我们很少使用。

自定义对象

SpringBoot 还提供了将配置文件中的数据封装到我们自定义的实体类对象中的方式。
Enterprise 实体类内容如下：
使用 @ConfigurationProperties 注解表示加载配置文件，在该注解中也可以使用 prefix 属性指定只加载指定前缀的数据，在类上添加 @Component 注解，将 bean 交给 Spring 管理。

@Component
@ConfigurationProperties(prefix = "enterprise")
public class Enterprise {
	private String name;
	private int age;
	private String tel;
	private String[] subject;
	public String getName() {
		return name;
	} 
	public void setName(String name) {
		this.name = name;
	} 
	public int getAge() {
		return age;
	} 
	public void setAge(int age) {
		this.age = age;
	} 
	public String getTel() {
		return tel;
	} 
	public void setTel(String tel) {
		this.tel = tel;
	} 
	public String[] getSubject() {
		return subject;
	} 
	public void setSubject(String[] subject) {
		this.subject = subject;
	} 
	@Override
	public String toString() {
		return "Enterprise{" +
				"name='" + name + ''' +
				", age=" + age +
				", tel='" + tel + ''' +
				", subject=" + Arrays.toString(subject) +
				'}';
	}
}

BookController 内容如下：
在 BookController 中进行注入bean，读取配置文件数据。

@RestController
@RequestMapping("/books")
public class BookController {
	@Autowired
	private Enterprise enterprise;
	@GetMapping("/{id}")
	public String getById(@PathVariable Integer id){
		System.out.println(enterprise.getName());
		System.out.println(enterprise.getAge());
		System.out.println(enterprise.getSubject());
		System.out.println(enterprise.getTel());
		System.out.println(enterprise.getSubject()[0]);
		return "hello , spring boot!";
	}
}

多环境配置

在实际的开发中，对于开发环境、测试环境、生产环境的配置肯定都不相同，比如开发阶段会在自己的电脑上安装 mysql，连接自己电脑上的 mysql 即可，但是项目开发完毕后要上线就需要该配置，将环境的配置改为线上环境的。
来回的修改配置会很麻烦，而 SpringBoot 给开发者提供了多环境的快捷配置，需要切换环境时只需要改一个配置即可。
yaml文件实现多环境配置
为每个环境创建一个配置文件，命名必须为 application-环境标识.yml
开发环境，application-dev.yml

#设置开发环境配置 
server: 
  port: 8080 #设置 Tomcat 内嵌端口号 
  servlet: 
    context-path: /dev #设置上下文根

生产环境，application-product.yml

#设置生产环境配置 
server: 
  port: 80 
  servlet: 
    context-path: /product

测试环境，application-test.yml

#设置测试环境配置 
server: 
  port: 9090 
  servlet: 
    context-path: /test

在总配置文件 application.yml进行环境的激活

#springboot 总配置文件 

#激活开发环境 
#spring: 
#  config: 
#    active:  
#      on-profile: dev

#激活测试环境 
#spring: 
#  config: 
#    active:
#      on-profile: test 

#激活生产环境 
spring:
  config:
    activate:
      on-profile: product

命令行启动参数设置
使用 SpringBoot 开发的程序打成 jar 包，通过 java -jar xxx.jar 的方式启动服务的。通过设置启动参数来进行环境配置。
SpringBoot 提供了在运行 jar 时设置开启指定的环境的方式，如下：

java –jar xxx.jar –-spring.profiles.active=test

还可以在启动时，指定端口号

java –jar xxx.jar –-server.port=88

当然也可以同时设置多个配置，比如即指定启用哪个环境配置，又临时指定端口，如下

java –jar springboot.jar –-server.port=88 –-spring.profiles.active=test

命令行设置的配置参数要高于配置文件中的配置。

配置文件分类
SpringBoot 定义了配置文件不同的放置的位置；而放在不同位置的优先级时不同的。
SpringBoot 中4级配置文件放置位置

  • 1级：classpath：application.yml
  • 2级：classpath：config/application.yml
  • 3级：file ：application.yml
  • 4级：file ：config/application.yml

说明：级别越高优先级越高

在 resources 下创建一个名为 config 的目录，在该目录中创建 application.yml 配置文件，而在该配置文件中将端口号设置为 81 ，内容如下：

server:
  port: 81

而在 resources 下创建的 application.yml 配置文件中并将端口号设置为 80 ，内容如下

server:
  port: 80

运行启动引导类，可以在控制台看到启动的应用端口号为81。在config 目录下的配置文件要高于 resources目录下的。

将SpringBoot工厂打为 jar包。然后在jar所在的目录中新建一个配置文件，内容如下：

server:
  port: 82

然后再jar所在的目录下，创建config目录，在config目录下创建一个配置文件，内容如下：

server:
  port: 83

在命令行使用以下命令运行程序：

java -jar springboot_config_file.jar

然后发现程序的端口号为83。
file：config 下的配置文件优先于类路径下的配置文件。

SpringBoot 整合

整合junit
创建SpringBoot工程：
在这里插入图片描述
工程创建完成后，会默认创建出一个测试类。可以直接使用。

@SpringBootTest
class Springboot07TestApplicationTests {
	@Autowired
	private BookService bookService;
	@Test
	public void save() {
		bookService.save();
	}
}

注意：这里的引导类所在包必须是测试类所在包及其子包。
如：引导类所在包是 com.itheima，测试类所在包是 com.itheima
如果不满足这个要求的话，就需要在使用 @SpringBootTest 注解时，使用 classes 属性指定引导类的字节码对象。
如：@SpringBootTest(classes = Springboot07TestApplication.class)

整合mybatis
在pom文件中加入下面的依赖。

<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>2.2.0</version>
</dependency>
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<scope>runtime</scope>
</dependency>
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.16</version>
</dependency>

在项目中创建实体类：

public class Book {
	private Integer id;
	private String name;
	private String type;
	private String description;
	//setter and getter
	//toString
}

在项目中创建 mapper接口，使用@Mapper注解，spring将为接口创建代理对象。也可以在引导类上使用@MapperScan(“com.itheima.dao”)注解，对整个包进行扫描。

@Mapper
public interface BookDao {
	@Select("select * from tbl_book where id = #{id}")
	public Book getById(Integer id);
}

在配置文件中配置数据源和连接池。

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource

在测试类中进行测试

@SpringBootTest
class Springboot08MybatisApplicationTests {
	@Autowired
	private BookDao bookDao;
	@Test
	void testGetById() {
		Book book = bookDao.getById(1);
		System.out.println(book);
	}
}
风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

站长推荐