SpringBoot

SpringBoot 快速入门(保姆级详细教程) SpringBoot快速入门,保姆级别超详细,解决IDEA创建SpringBoot项目一直转圈圈。 阅读详情

SpringBoot

今日目标:

  • 掌握基于SpringBoot框架的程序开发步骤
  • 熟练使用SpringBoot配置信息修改服务器配置
  • 基于SpringBoot的完成SSM整合项目开发

1,SpringBoot简介

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

使用了 Spring 框架后已经简化了我们的开发。而 SpringBoot 又是对 Spring 开发进行简化的,可想而知 SpringBoot 使用的简单及广泛性。既然 SpringBoot 是用来简化 Spring 开发的,那我们就先回顾一下,以 SpringMVC 开发为例:

  1. 创建工程,并在 pom.xml 配置文件中配置所依赖的坐标
    在这里插入图片描述

  2. 编写 web3.0 的配置类

    作为 web 程序,web3.0 的配置类不能缺少,而这个配置类还是比较麻烦的,代码如下
    在这里插入图片描述

  3. 编写 SpringMVC 的配置类
    在这里插入图片描述

​ 做到这只是将工程的架子搭起来。要想被外界访问,最起码还需要提供一个 Controller 类,在该类中提供一个方法。

  1. 编写 Controller 类
    在这里插入图片描述

从上面的 SpringMVC 程序开发可以看到,前三步都是在搭建环境,而且这三步基本都是固定的。SpringBoot 就是对这三步进行简化了。接下来我们通过一个入门案例来体现 SpingBoot 简化 Spring 开发。

1.1 SpringBoot快速入门

1.1.1 开发步骤

SpringBoot 开发起来特别简单,分为如下几步:

  • 创建新模块,选择Spring初始化,并配置模块相关基础信息
  • 选择当前模块需要使用的技术集
  • 开发控制器类
  • 运行自动生成的Application类

知道了 SpringBoot 的开发步骤后,接下来我们进行具体的操作

1.1.1.1 创建新模块
  • 点击 + 选择 New Module 创建新模块
    在这里插入图片描述

  • 选择 Spring Initializr ,用来创建 SpringBoot 工程

    以前我们选择的是 Maven ,今天选择 Spring Initializr 来快速构建 SpringBoot 工程。而在 Module SDK 这一项选择我们安装的 JDK 版本。
    在这里插入图片描述

  • 对 SpringBoot 工程进行相关的设置

    我们使用这种方式构建的 SpringBoot 工程其实也是 Maven 工程,而该方式只是一种快速构建的方式而已。
    在这里插入图片描述

    注意:打包方式这里需要设置为 Jar

  • 选中 Web,然后勾选 Spring Web

    由于我们需要开发一个 web 程序,使用到了 SpringMVC 技术,所以按照下图红框进行勾选
    在这里插入图片描述

  • 下图界面不需要任何修改,直接点击 Finish 完成 SpringBoot 工程的构建
    在这里插入图片描述

经过以上步骤后就创建了如下结构的模块,它会帮我们自动生成一个 Application 类,而该类一会再启动服务器时会用到
在这里插入图片描述

注意:

  1. 在创建好的工程中不需要创建配置类

  2. 创建好的项目会自动生成其他的一些文件,而这些文件目前对我们来说没有任何作用,所以可以将这些文件删除。

    可以删除的目录和文件如下:

    • .mvn
    • .gitignore
    • HELP.md
    • mvnw
    • mvnw.cmd
1.1.1.2 创建 Controller

在 com.itheima.controller 包下创建 BookController ,代码如下:

@RestController
@RequestMapping("/books")
public class BookController {

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id ==> "+id);
        return "hello , spring boot!";
    }
}
1.1.1.3 启动服务器

运行 SpringBoot 工程不需要使用本地的 Tomcat 和 插件,只运行项目 com.itheima 包下的 Application 类,我们就可以在控制台看出如下信息
在这里插入图片描述

1.1.1.4 进行测试

使用 Postman 工具来测试我们的程序
在这里插入图片描述

通过上面的入门案例我们可以看到使用 SpringBoot 进行开发,使整个开发变得很简单,那它是如何做到的呢?

要研究这个问题,我们需要看看 Application 类和 pom.xml 都书写了什么。先看看 Applicaion 类,该类内容如下:

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

这个类中的东西很简单,就在类上添加了一个 @SpringBootApplication 注解,而在主方法中就一行代码。我们在启动服务器时就是执行的该类中的主方法。

再看看 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>
    
    <!--指定了一个父工程,父工程中的东西在该工程中可以继承过来使用-->
    <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 Web 依赖实现的。具体的我们后面在聊。

1.1.2 对比

做完 SpringBoot 的入门案例后,接下来对比一下 Spring 程序和 SpringBoot 程序。如下图
在这里插入图片描述

  • 坐标

    Spring 程序中的坐标需要自己编写,而且坐标非常多

    SpringBoot 程序中的坐标是我们在创建工程时进行勾选自动生成的

  • web3.0配置类

    Spring 程序需要自己编写这个配置类。这个配置类大家之前编写过,肯定感觉很复杂

    SpringBoot 程序不需要我们自己书写

  • 配置类

    Spring/SpringMVC 程序的配置类需要自己书写。而 SpringBoot 程序则不需要书写。

注意:基于Idea的 Spring Initializr 快速构建 SpringBoot 工程时需要联网。

1.1.3 官网构建工程

在入门案例中之所以能快速构建 SpringBoot 工程,是因为 Idea 使用了官网提供了快速构建 SpringBoot 工程的组件实现的。那如何在官网进行工程构建呢?通过如下步骤构建

1.1.3.1 进入SpringBoot官网

官网地址如下:

https://spring.io/projects/spring-boot

进入到 SpringBoot 官网后拖到最下方就可以看到如下内容
在这里插入图片描述

然后点击 Spring Initializr 超链接就会跳转到如下页面
在这里插入图片描述

这个页面内容是不是感觉很眼熟的,这和我们使用 Idea 快速构建 SpringBoot 工程的界面基本相同。在上面页面输入对应的信息

1.1.3.2 选择依赖

选择 Spring Web 可以点击上图右上角的 ADD DEPENDENCIES... CTRL + B 按钮,就会出现如下界面
在这里插入图片描述

1.1.3.3 生成工程

以上步骤完成后就可以生成 SpringBoot 工程了。在页面的最下方点击 GENERATE CTRL + 回车 按钮生成工程并下载到本地,如下图所示
在这里插入图片描述

打开下载好的压缩包可以看到工程结构和使用 Idea 生成的一模一样,如下图
在这里插入图片描述

而打开 pom.xml 文件,里面也包含了父工程和 Spring Web 的依赖。

通过上面官网的操作,我们知道 Idea 中快速构建 SpringBoot 工程其实就是使用的官网的快速构建组件,那以后即使没有 Idea 也可以使用官网的方式构建 SpringBoot 工程。

1.1.4 SpringBoot工程快速启动
1.1.4.1 问题导入

在这里插入图片描述

以后我们和前端开发人员协同开发,而前端开发人员需要测试前端程序就需要后端开启服务器,这就受制于后端开发人员。为了摆脱这个受制,前端开发人员尝试着在自己电脑上安装 Tomcat 和 Idea ,在自己电脑上启动后端程序,这显然不现实。

我们后端可以将 SpringBoot 工程打成 jar 包,该 jar 包运行不依赖于 Tomcat 和 Idea 这些工具也可以正常运行,只是这个 jar 包在运行过程中连接和我们自己程序相同的 Mysql 数据库即可。这样就可以解决这个问题,如下图
在这里插入图片描述

那现在问题是如何打包呢?

1.1.4.2 打包

由于我们在构建 SpringBoot 工程时已经在 pom.xml 中配置了如下插件

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

所以我们只需要使用 Maven 的 package 指令打包就会在 target 目录下生成对应的 Jar 包。

注意:该插件必须配置,不然打好的 jar 包也是有问题的。

1.1.4.3 启动

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

jar -jar springboot_01_quickstart-0.0.1-SNAPSHOT.jar

执行上述命令就可以看到 SpringBoot 运行的日志信息
在这里插入图片描述

1.2 SpringBoot概述

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

大家已经感受了 SpringBoot 程序,回过头看看 SpringBoot 主要作用是什么,就是简化 Spring 的搭建过程和开发过程。

原始 Spring 环境搭建和开发存在以下问题:

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

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

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

接下来我们来说一下 SpringBoot 的起步依赖

1.2.1 起步依赖

我们使用 Spring Initializr 方式创建的 Maven 工程的的 pom.xml 配置文件中自动生成了很多包含 starter 的依赖,如下图
在这里插入图片描述

这些依赖就是启动依赖,接下来我们探究一下他是如何实现的。

1.2.1.1 探索父工程

从上面的文件中可以看到指定了一个父工程,我们进入到父工程,发现父工程中又指定了一个父工程,如下图所示
在这里插入图片描述

再进入到该父工程中,在该工程中我们可以看到配置内容结构如下图所示
在这里插入图片描述

上图中的 properties 标签中定义了各个技术软件依赖的版本,避免了我们在使用不同软件技术时考虑版本的兼容问题。在 properties 中我们找 servlet 和 mysql 的版本如下图
在这里插入图片描述

dependencyManagement 标签是进行依赖版本锁定,但是并没有导入对应的依赖;如果我们工程需要那个依赖只需要引入依赖的 groupid 和 artifactId 不需要定义 version。

而 build 标签中也对插件的版本进行了锁定,如下图
在这里插入图片描述

看完了父工程中 pom.xml 的配置后不难理解我们工程的的依赖为什么都没有配置 version。

1.2.1.2 探索依赖

在我们创建的工程中的 pom.xml 中配置了如下依赖
在这里插入图片描述

进入到该依赖,查看 pom.xml 的依赖会发现它引入了如下的依赖
在这里插入图片描述

里面的引入了 spring-web 和 spring-webmvc 的依赖,这就是为什么我们的工程中没有依赖这两个包还能正常使用 springMVC 中的注解的原因。

而依赖 spring-boot-starter-tomcat ,从名字基本能确认内部依赖了 tomcat,所以我们的工程才能正常启动。

结论:以后需要使用技术,只需要引入该技术对应的起步依赖即可

1.2.1.3 小结

starter

  • SpringBoot 中常见项目名称,定义了当前项目使用的所有项目坐标,以达到减少依赖配置的目的

parent

  • 所有 SpringBoot 项目要继承的项目,定义了若干个坐标版本号(依赖管理,而非依赖),以达到减少依赖冲突的目的

  • spring-boot-starter-parent(2.5.0)与 spring-boot-starter-parent(2.4.6)共计57处坐标版本不同

实际开发

  • 使用任意坐标时,仅书写GAV中的G和A,V由SpringBoot提供

    G:groupid

    A:artifactId

    V:version

  • 如发生坐标错误,再指定version(要小心版本冲突)

1.2.2 程序启动

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

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

注意:

  • SpringBoot 在创建项目时,采用jar的打包方式

  • SpringBoot 的引导类是项目的入口,运行 main 方法就可以启动项目

    因为我们在 pom.xml 中配置了 spring-boot-starter-web 依赖,而该依赖通过前面的学习知道它依赖 tomcat ,所以运行 main 方法就可以使用 tomcat 启动咱们的工程。

1.2.3 切换web服务器

现在我们启动工程使用的是 tomcat 服务器,那能不能不使用 tomcat 而使用 jetty 服务器,jetty 在我们 maven 高级时讲 maven 私服使用的服务器。而要切换 web 服务器就需要将默认的 tomcat 服务器给排除掉,怎么排除呢?使用 exclusion 标签

<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>

现在我们运行引导类可以吗?运行一下试试,打印的日志信息如下
在这里插入图片描述

程序直接停止了,为什么呢?那是因为排除了 tomcat 服务器,程序中就没有服务器了。所以此时不光要排除 tomcat 服务器,还要引入 jetty 服务器。在 pom.xml 中因为 jetty 的起步依赖

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

接下来再次运行引导类,在日志信息中就可以看到使用的是 jetty 服务器
在这里插入图片描述

小结:

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

2,配置文件

2.1 配置文件格式

我们现在启动服务器默认的端口号是 8080,访问路径可以书写为

http://localhost:8080/books/1

在线上环境我们还是希望将端口号改为 80,这样在访问的时候就可以不写端口号了,如下

http://localhost/books/1

而 SpringBoot 程序如何修改呢?SpringBoot 提供了多种属性配置方式

  • application.properties

    server.port=80
    
  • application.yml

    server:
    	port: 81
    
  • application.yaml

    server:
    	port: 82
    

注意:SpringBoot 程序的配置文件名必须是 application ,只是后缀名不同而已。

2.1.1 环境准备

创建一个新工程 springboot_02_base_config 用来演示不同的配置文件,工程环境和入门案例一模一样,结构如下:
在这里插入图片描述
在该工程中的 com.itheima.controller 包下创建一个名为 BookController 的控制器。内容如下:

@RestController
@RequestMapping("/books")
public class BookController {

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id ==> "+id);
        return "hello , spring boot!";
    }
}
2.1.2 不同配置文件演示
  • application.properties配置文件

现在需要进行配置,配合文件必须放在 resources 目录下,而该目录下有一个名为 application.properties 的配置文件,我们就可以在该配置文件中修改端口号,在该配置文件中书写 port ,Idea 就会提示,如下
在这里插入图片描述

application.properties 配置文件内容如下:

server.port=80

启动服务,会在控制台打印出日志信息,从日志信息中可以看到绑定的端口号已经修改了
在这里插入图片描述

  • application.yml配置文件

删除 application.properties 配置文件中的内容。在 resources 下创建一个名为 application.yml 的配置文件,在该文件中书写端口号的配置项,格式如下:

server:
	port: 81

注意: 在:后,数据前一定要加空格。

而在 yml 配置文件中也是有提示功能的,我们也可以在该文件中书写 port ,然后 idea 就会提示并书写成上面的格式
在这里插入图片描述

启动服务,可以在控制台看到绑定的端口号是 81
在这里插入图片描述

  • application.yaml配置文件

删除 application.yml 配置文件和 application.properties 配置文件内容,然后在 resources 下创建名为 application.yaml 的配置文件,配置内容和后缀名为 yml 的配置文件中的内容相同,只是使用了不同的后缀名而已

application.yaml 配置文件内容如下:

server:
	port: 83

启动服务,在控制台可以看到绑定的端口号
在这里插入图片描述

注意:在配合文件中如果没有提示,可以使用一下方式解决

  • 点击 File 选中 Project Structure
    在这里插入图片描述

  • 弹出如下窗口,按图中标记红框进行选择
    在这里插入图片描述

  • 通过上述操作,会弹出如下窗口
    在这里插入图片描述

  • 点击上图的 + 号,弹出选择该模块的配置文件
    在这里插入图片描述

  • 通过上述几步后,就可以看到如下界面。properties 类型的配合文件有一个,ymal 类型的配置文件有两个
    在这里插入图片描述

2.1.3 三种配合文件的优先级

在三种配合文件中分别配置不同的端口号,启动服务查看绑定的端口号。用这种方式就可以看到哪个配置文件的优先级更高一些

application.properties 文件内容如下:

server.port=80

application.yml 文件内容如下:

server:
	port: 81

application.yaml 文件内容如下:

server:
	port: 82

启动服务,在控制台可以看到使用的端口号是 80。说明 application.properties 的优先级最高

注释掉 application.properties 配置文件内容。再次启动服务,在控制台可以看到使用的端口号是 81,说明 application.yml 配置文件为第二优先级。

从上述的验证结果可以确定三种配置文件的优先级是:

application.properties > application.yml > application.yaml

注意:

  • SpringBoot 核心配置文件名为 application

  • SpringBoot 内置属性过多,且所有属性集中在一起修改,在使用时,通过提示键+关键字修改属性

    例如要设置日志的级别时,可以在配置文件中书写 logging,就会提示出来。配置内容如下

    logging:
      level:
        root: info
    

2.2 yaml格式

上面讲了三种不同类型的配置文件,而 properties 类型的配合文件之前我们学习过,接下来我们重点学习 yaml 类型的配置文件。

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

最开始我们使用的是 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 类型的配置文件比 xml 类型的配置文件更容易阅读,结构更加清晰

  • 容易与脚本语言交互

  • 以数据为核心,重数据轻格式

    yaml 更注重数据,而 xml 更注重格式

YAML 文件扩展名:

  • .yml (主流)
  • .yaml

上面两种后缀名都可以,以后使用更多的还是 yml 的。

2.2.1 语法规则
  • 大小写敏感

  • 属性层级关系使用多行描述,每行结尾使用冒号结束

  • 使用缩进表示层级关系,同层级左侧对齐,只允许使用空格(不允许使用Tab键)

    空格的个数并不重要,只要保证同层级的左侧对齐即可。

  • 属性值前面添加空格(属性名与属性值之间使用冒号+空格作为分隔)

  • # 表示注释

核心规则:数据前面要加空格与冒号隔开

数组数据在数据书写位置的下方使用减号作为数据开始符号,每行书写一个数据,减号与数据间空格分隔,例如

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

2.3 yaml配置文件数据读取

2.3.1 环境准备

新创建一个名为 springboot_03_read_data 的 SpringBoot 工程,目录结构如下
在这里插入图片描述

在 com.itheima.controller 包写创建名为 BookController 的控制器,内容如下

@RestController
@RequestMapping("/books")
public class BookController {

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

在 com.itheima.domain 包下创建一个名为 Enterprise 的实体类等会用来封装数据,内容如下

public class Enterprise {
    private String name;
    private int age;
    private String tel;
    private String[] subject;
    
    //setter and getter
    
    //toString
}

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

lesson: SpringBoot

server:
  port: 80

enterprise:
  name: itcast
  age: 16
  tel: 4006184000
  subject:
    - Java
    - 前端
    - 大数据
2.3.2 读取配置数据
2.3.2.1 使用 @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!";
    }
}
2.3.2.2 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!";
    }
}

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

2.3.2.3 自定义对象

SpringBoot 还提供了将配置文件中的数据封装到我们自定义的实体类对象中的方式。具体操作如下:

  • 将实体类 bean 的创建交给 Spring 管理。

    在类上添加 @Component 注解

  • 使用 @ConfigurationProperties 注解表示加载配置文件

    在该注解中也可以使用 prefix 属性指定只加载指定前缀的数据

  • 在 BookController 中进行注入

具体代码如下:

Enterprise 实体类内容如下:

@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 内容如下:

@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!";
    }
}

注意:

使用第三种方式,在实体类上有如下警告提示
在这里插入图片描述

这个警告提示解决是在 pom.xml 中添加如下依赖即可

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

2.4 多环境配置

以后在工作中,对于开发环境、测试环境、生产环境的配置肯定都不相同,比如我们开发阶段会在自己的电脑上安装 mysql ,连接自己电脑上的 mysql 即可,但是项目开发完毕后要上线就需要该配置,将环境的配置改为线上环境的。
在这里插入图片描述

来回的修改配置会很麻烦,而 SpringBoot 给开发者提供了多环境的快捷配置,需要切换环境时只需要改一个配置即可。不同类型的配置文件多环境开发的配置都不相同,接下来对不同类型的配置文件进行说明

2.4.1 yaml文件

在 application.yml 中使用 --- 来分割不同的配置,内容如下

#开发
spring:
  profiles: dev #给开发环境起的名字
server:
  port: 80
---
#生产
spring:
  profiles: pro #给生产环境起的名字
server:
  port: 81
---
#测试
spring:
  profiles: test #给测试环境起的名字
server:
  port: 82
---

上面配置中 spring.profiles 是用来给不同的配置起名字的。而如何告知 SpringBoot 使用哪段配置呢?可以使用如下配置来启用都一段配置

#设置启用的环境
spring:
  profiles:
    active: dev  #表示使用的是开发环境的配置

综上所述,application.yml 配置文件内容如下

#设置启用的环境
spring:
  profiles:
    active: dev

---
#开发
spring:
  profiles: dev
server:
  port: 80
---
#生产
spring:
  profiles: pro
server:
  port: 81
---
#测试
spring:
  profiles: test
server:
  port: 82
---

注意:

在上面配置中给不同配置起名字的 spring.profiles 配置项已经过时。最新用来起名字的配置项是

#开发
spring:
  config:
    activate:
      on-profile: dev
2.4.2 properties文件

properties 类型的配置文件配置多环境需要定义不同的配置文件

  • application-dev.properties 是开发环境的配置文件。我们在该文件中配置端口号为 80

    server.port=80
    
  • application-test.properties 是测试环境的配置文件。我们在该文件中配置端口号为 81

    server.port=81
    
  • application-pro.properties 是生产环境的配置文件。我们在该文件中配置端口号为 82

    server.port=82
    

SpringBoot 只会默认加载名为 application.properties 的配置文件,所以需要在 application.properties 配置文件中设置启用哪个配置文件,配置如下:

spring.profiles.active=pro
2.4.3 命令行启动参数设置

使用 SpringBoot 开发的程序以后都是打成 jar 包,通过 java -jar xxx.jar 的方式启动服务的。那么就存在一个问题,如何切换环境呢?因为配置文件打到的jar包中了。

我们知道 jar 包其实就是一个压缩包,可以解压缩,然后修改配置,最后再打成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 官网已经进行了说明,参见 :

https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config

进入上面网站后会看到如下页面
在这里插入图片描述

如果使用了多种方式配合同一个配置项,优先级高的生效。

2.5 配置文件分类

在这里插入图片描述

有这样的场景,我们开发完毕后需要测试人员进行测试,由于测试环境和开发环境的很多配置都不相同,所以测试人员在运行我们的工程时需要临时修改很多配置,如下

java –jar springboot.jar –-spring.profiles.active=test --server.port=85 --server.servlet.context-path=/heima --server.tomcat.connection-timeout=-1 …… …… …… …… ……

针对这种情况,SpringBoot 定义了配置文件不同的放置的位置;而放在不同位置的优先级时不同的。

SpringBoot 中4级配置文件放置位置:

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

==说明:==级别越高优先级越高

2.5.1 代码演示

在这里我们只演示不同级别配置文件放置位置的优先级。

2.5.1.1 环境准备

创建一个名为 springboot_06_config_file 的 SpringBoot 工程,目录结构如下
在这里插入图片描述

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

server:
  port: 81

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

server:
  port: 80
2.5.1.2 验证1级和2级的优先级

运行启动引导类,可以在控制台看到如下日志信息
在这里插入图片描述

通过这个结果可以得出类路径下的 config 下的配置文件优先于类路径下的配置文件。

2.5.1.3 验证2级和4级的优先级

要验证4级,按照以下步骤完成

  • 将工程打成 jar 包

    点击工程的 package 来打 jar 包
    在这里插入图片描述

  • 在硬盘上找到 jar 包所在位置
    在这里插入图片描述

  • 在 jar 包所在位置创建 config 文件夹,在该文件夹下创建 application.yml 配置文件,而在该配合文件中将端口号设置为 82

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

    java -jar springboot_06_config_file-0.0.1-SNAPSHOT.jar
    

    运行后日志信息如下
    在这里插入图片描述

    通过这个结果可以得出file: config 下的配置文件优先于类路径下的配置文件。

注意:

SpringBoot 2.5.0版本存在一个bug,我们在使用这个版本时,需要在 jar 所在位置的 config 目录下创建一个任意名称的文件夹

3,SpringBoot整合junit

回顾 Spring 整合 junit

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class UserServiceTest {
    
    @Autowired
    private BookService bookService;
    
    @Test
    public void testSave(){
        bookService.save();
    }
}

使用 @RunWith 注解指定运行器,使用 @ContextConfiguration 注解来指定配置类或者配置文件。而 SpringBoot 整合 junit 特别简单,分为以下三步完成

  • 在测试类上添加 SpringBootTest 注解
  • 使用 @Autowired 注入要测试的资源
  • 定义测试方法进行测试

3.1 环境准备

创建一个名为 springboot_07_test 的 SpringBoot 工程,工程目录结构如下
在这里插入图片描述

在 com.itheima.service 下创建 BookService 接口,内容如下

public interface BookService {
    public void save();
}

在 com.itheima.service.impl 包写创建一个 BookServiceImpl 类,使其实现 BookService 接口,内容如下

@Service
public class BookServiceImpl implements BookService {
    @Override
    public void save() {
        System.out.println("book service is running ...");
    }
}

3.2 编写测试类

在 test/java 下创建 com.itheima 包,在该包下创建测试类,将 BookService 注入到该测试类中

@SpringBootTest
class Springboot07TestApplicationTests {

    @Autowired
    private BookService bookService;

    @Test
    public void save() {
        bookService.save();
    }
}

==注意:==这里的引导类所在包必须是测试类所在包及其子包。

例如:

  • 引导类所在包是 com.itheima
  • 测试类所在包是 com.itheima

如果不满足这个要求的话,就需要在使用 @SpringBootTest 注解时,使用 classes 属性指定引导类的字节码对象。如 @SpringBootTest(classes = Springboot07TestApplication.class)

4,SpringBoot整合mybatis

4.1 回顾Spring整合Mybatis

Spring 整合 Mybatis 需要定义很多配置类

  • SpringConfig 配置类

    • 导入 JdbcConfig 配置类

    • 导入 MybatisConfig 配置类

      @Configuration
      @ComponentScan("com.itheima")
      @PropertySource("classpath:jdbc.properties")
      @Import({JdbcConfig.class,MyBatisConfig.class})
      public class SpringConfig {
      }
      
      
  • JdbcConfig 配置类

  • 定义数据源(加载properties配置项:driver、url、username、password)

    public class JdbcConfig {
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String userName;
        @Value("${jdbc.password}")
        private String password;
    
        @Bean
        public DataSource getDataSource(){
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName(driver);
            ds.setUrl(url);
            ds.setUsername(userName);
            ds.setPassword(password);
            return ds;
        }
    }
    
  • MybatisConfig 配置类

    • 定义 SqlSessionFactoryBean

    • 定义映射配置

      @Bean
      public MapperScannerConfigurer getMapperScannerConfigurer(){
          MapperScannerConfigurer msc = new MapperScannerConfigurer();
          msc.setBasePackage("com.itheima.dao");
          return msc;
      }
      
      @Bean
      public SqlSessionFactoryBean getSqlSessionFactoryBean(DataSource dataSource){
          SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
          ssfb.setTypeAliasesPackage("com.itheima.domain");
          ssfb.setDataSource(dataSource);
          return ssfb;
      }
      
      

4.2 SpringBoot整合mybatis

4.2.1 创建模块
  • 创建新模块,选择 Spring Initializr,并配置模块相关基础信息
    在这里插入图片描述
  • 选择当前模块需要使用的技术集(MyBatis、MySQL)
    在这里插入图片描述
4.2.2 定义实体类

在 com.itheima.domain 包下定义实体类 Book,内容如下

public class Book {
    private Integer id;
    private String name;
    private String type;
    private String description;
    
    //setter and  getter
    
    //toString
}
4.2.3 定义dao接口

在 com.itheima.dao 包下定义 BookDao 接口,内容如下

public interface BookDao {
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
}
4.2.4 定义测试类

在 test/java 下定义包 com.itheima ,在该包下测试类,内容如下

@SpringBootTest
class Springboot08MybatisApplicationTests {

	@Autowired
	private BookDao bookDao;

	@Test
	void testGetById() {
		Book book = bookDao.getById(1);
		System.out.println(book);
	}
}
4.2.5 编写配置

我们代码中并没有指定连接哪儿个数据库,用户名是什么,密码是什么。所以这部分需要在 SpringBoot 的配置文件中进行配合。

在 application.yml 配置文件中配置如下内容

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db
    username: root
    password: root
4.2.6 测试

运行测试方法,我们会看到如下错误信息
在这里插入图片描述

错误信息显示在 Spring 容器中没有 BookDao 类型的 bean。为什么会出现这种情况呢?

原因是 Mybatis 会扫描接口并创建接口的代码对象交给 Spring 管理,但是现在并没有告诉 Mybatis 哪个是 dao 接口。而我们要解决这个问题需要在BookDao 接口上使用 @Mapper ,BookDao 接口改进为

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

注意:

SpringBoot 版本低于2.4.3(不含),Mysql驱动版本大于8.0时,需要在url连接串中配置时区 jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC,或在MySQL数据库端配置时区解决此问题

4.2.7 使用Druid数据源

现在我们并没有指定数据源,SpringBoot 有默认的数据源,我们也可以指定使用 Druid 数据源,按照以下步骤实现

  • 导入 Druid 依赖

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.16</version>
    </dependency>
    
  • 在 application.yml 配置文件配置

    可以通过 spring.datasource.type 来配置使用什么数据源。配置文件内容可以改进为

    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
    

5,案例

SpringBoot 到这就已经学习完毕,接下来我们将学习 SSM 时做的三大框架整合的案例用 SpringBoot 来实现一下。我们完成这个案例基本是将之前做的拷贝过来,修改成 SpringBoot 的即可,主要从以下几部分完成

  1. pom.xml

    配置起步依赖,必要的资源坐标(druid)

  2. application.yml

    设置数据源、端口等

  3. 配置类

    全部删除

  4. dao

    设置@Mapper

  5. 测试类

  6. 页面

    放置在resources目录下的static目录中

5.1 创建工程

创建 SpringBoot 工程,在创建工程时需要勾选 web、mysql、mybatis,工程目录结构如下
在这里插入图片描述

由于我们工程中使用到了 Druid ,所以需要导入 Druid 的坐标

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

5.2 代码拷贝

将 springmvc_11_page 工程中的 java 代码及测试代码连同包拷贝到 springboot_09_ssm 工程,按照下图进行拷贝
在这里插入图片描述

需要修改的内容如下:

  • Springmvc_11_page 中 config 包下的是配置类,而 SpringBoot 工程不需要这些配置类,所以这些可以直接删除

  • dao 包下的接口上在拷贝到 springboot_09-ssm 工程中需要在接口中添加 @Mapper 注解

  • BookServiceTest 测试需要改成 SpringBoot 整合 junit 的

    @SpringBootTest
    public class BookServiceTest {
    
        @Autowired
        private BookService bookService;
    
        @Test
        public void testGetById(){
            Book book = bookService.getById(2);
            System.out.println(book);
        }
    
        @Test
        public void testGetAll(){
            List<Book> all = bookService.getAll();
            System.out.println(all);
        }
    }
    

5.3 配置文件

在 application.yml 配置文件中需要配置如下内容

  • 服务的端口号
  • 连接数据库的信息
  • 数据源
server:
  port: 80

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

5.4 静态资源

在 SpringBoot 程序中是没有 webapp 目录的,那么在 SpringBoot 程序中静态资源需要放在什么位置呢?

静态资源需要放在 resources 下的 static 下,如下图所示
在这里插入图片描述

Spring Boot 完整教程 - 从入门到精通(全面版) Spring Boot 是由 Pivotal 团队提供的基于 Spring 框架的全新框架,其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。Spring Boot 核心理念:约定优于配置开箱即用微服务友好// 自动配置类@Bean// 配置属性类private String prefix = "默认前缀";// 服务类myservice:prefix: "自定义前缀"// 1. 配置属性类@Data// 2. 服务类。 阅读详情

相关推荐

黑马程序员SpringBoot基础学习【持续更新】

入门案例中没有引入spring-webmvc等依赖包,没有配置Tomcat服务器,为什么能正常启动没有配置端口号,为什么是8080端口?程序启动找到自动化配置包下的SpringBoot先加载所有的自动配置类xxxAutoConfiguration每个自动配置类安装条件进行生效生效的配置类就会给容器中装配很多组件只要容器中有这些组件,相当于这些功能就实现了定制化配置用户直接自己@Bean替换底层组件用户去看这个组件是获取的配置文件什么值就去修改引入场景依赖。

IN year 2771

spring boot复习整理

SpringBoot 1,SpringBoot简介SpringBoot 是由 Pivotal 团队提供的全新框架,其设计目的是用来简化 Spring 应用的初始搭建以及开发过程。使用了 Spring 框架后已经简化了我们的开发。而 SpringBoot 又是对 Spring 开发进行简化的,可想而知 SpringBoot 使用的简单及广泛性。既然 SpringBoot 是用来简化 Spring 开发的,那我们就先回顾一下,以 SpringMVC 开发为例: 1. 创建工程,并在 pom.xml 配置文件中配

m0_48816017的博客 790

springboot集成redis主-从模式+哨兵机制

springboot集成redis主-从模式 一、环境准备 (硬件资源:Linux+redis-5.0.3+springboot project) 需redis 3.0以上安装包,这里面以redis-5.0.3为示例。 下面讲解在一台linux上模拟1主、2从、3哨兵的主从模式(实际应用中应需3台服务器,其中一台放1主和1哨兵,另外两台放1从1哨兵)。 redis安装这里不做介绍,解压tar...

u012105362的博客 9656

SpringBoot基础

SpringBoot基础 学习目标: 能够理解Spring的优缺点 能够理解SpringBoot的特点 能够理解SpringBoot的核心功能 能够搭建SpringBoot的环境 能够完成application.properties配置文件的配置 能够完成application.yml配置文件的配置 能够使用SpringBoot集成Mybatis 能够使用SpringBoot集成Junit 能够...

vampire_Violet的博客 3005

springboot 断点上传、续传、秒传实现

群里面都是三言两语言的,也不完整,问题也说不清楚,也没有视频,教程之类的资料,不敢用,客户那边对这块还是有要求的。我们主要是做政府项目,客户也都是政府单位的,对用户体验要求比较高,要让他们感觉用的方便,对稳定性要求比较高,基本上一年365天都不希望你出问题,对安全性要求也比较高,涉密了,信创国产化,不能连外网的,都是内网。用的是HTML5也好,控件也罢,这些都无所谓。网上搜到的SpringBoot的代码不多,完整的不多,能用的也不多,基本上大部分的文章只是提供了少量的代码,讲一下思路,或者实现方案。

aryasei的专栏 1413

国民技术N32G45X低功耗问题之更改全局变量和栈在RAM中的地址

最近项目中用的MCU是国民技术的N32G45X,MCU的资源很丰富,RAM也很大,配套的库和例程也比较全,用起来还是不错的,但是在调试低功耗的时候还是费了不少劲。 首先由于项目低功耗需要,只能选择停机模式2(STOP2)。根据数据手册的描述,在此模式下外部低速时钟开启, RTC运行, R-SRAM保持,所有I/O状态保持,独立看门狗处于关闭状态,25℃的条件下电流为10个微安。 用的这款MCU的RAM是144KB,分为SRAM(128KB)和R-SRAM( Retention SRAM – 16KB),如果

狂想家 2488

全网最强SpringBoot教程 | 万字长文爆肝SpringBoot

本文介绍了SpringBoot框架的基本概念和快速开发步骤。SpringBoot旨在简化Spring应用的初始搭建和开发流程,相比传统SpringMVC开发更加便捷。 主要内容包括: SpringBoot简介:对比传统Spring开发,展示其简化配置的优势 快速入门开发步骤: 通过Spring Initializr创建项目 选择所需技术依赖(如Spring Web) 开发Controller类 运行自动生成的Application主类 项目结构说明:自动生成的配置类和简化后的pom.xml文件 测试验证:使

qq_45832461的博客 3653

NoC架构深度解析:从拓扑结构到流量控制的全面指南

本文深入解析了片上网络(NoC)架构,从总线架构的瓶颈出发,阐述了NoC作为芯片内部“交通网”的核心优势。文章详细探讨了主流拓扑结构(如Mesh、Torus、Ring)的选型权衡,并系统介绍了数据包格式、路由算法、路由器流水线、流量控制机制以及网络接口(NI)设计,为理解现代多核SoC的通信基石提供了全面指南。

gg901的博客 1042

SpringBoot与MybatisPlus SpringBoot

仅为个人学习使用。

,,,,,,, 7323

双内核架构 Xenomai 4 安装教程

双内核 Xenomai 4 安装指南

^_^ 4472

华为OD-C卷D卷-音乐小说内容重复识别[200分][Python/C++/Java]两种解法实现(并查集+动态规划)

如果不相似,返回不相似的内容。输入:两条语句,给出是否相似,对于相似的语句,返回True和相似的字符对;给出相似对"(****)",""时,"异世邪君(人气玄幻作家)" 和 "异世邪君" 认为是相似,此时相似符号范围 *** 即可。例如,如果"顿号"和"逗号"是相似的,"逗号"和"分号"是相似的,则"顿号"和"逗号"是相似的。初始化:给出两个字符串,一些相似字符对,如顿号和逗号相似,的和de相似,猪和潴,给出两个字符串的相似判断结果。不相似的内容,需要给出不相似的字符串,多处不相似的字符串用空格分隔。

算法算法算法!!! 2001

SpringBoot——SpringBoot启动原理

本博文将介绍SpringBoot启动原理,帮助大家更好的理解相关springboot的原理。更好在面试中回答面试问题。

庄小焱 8730

【实战项目开发技术分享】机器人安全通过狭窄区域的方案

在机器人的应用领域中,有时会遇到需要机器人通过狭窄区域的情况。无论是室内还是室外,机器人需要具备适应性和灵活性,以便在狭窄的空间中进行安全、高效的导航。本文将提供一些如何让机器人通过狭窄区域的实现方案和思路,希望帮助读者可以根据实际的开发需要进行适当调整和扩展。

xiewf的博客 2万+

SpringBoot 作业

基于SpringBoot的CRUD增删改查操作

2301_76731971的博客 568

openbmc 支持mctp over pcie(二)

本文介绍了在OpenBMC系统中实现MCTP over PCIe的社区方案,主要针对AMD CPU和Intel CPU平台。方案基于社区开发的mctpd应用层和内核驱动,通过修改设备树(dts)配置内存区域,并编译Linux内核模块。验证时可通过查看/proc/net/protocols确认MCTP协议支持,使用ip addr命令检查mctppci0网络接口状态。相关代码和文档参考了AspeedTech和CodeConstruct的GitHub仓库。该方案为BMC作为MCTP端点提供了标准化实现方法。

wit_yuan的专栏 379

工艺边与定位孔设计经验规则总结

工艺边是在SMT焊接时,为了PCB和导轨接触预留的PCB边。工艺边和PCB的接触部分一般需要开槽,或者使用邮票孔,以方便后期去除工艺边。

fydar的博客 1989

SpringBoot6/springBoot集成Elasticsearch:打造高效搜索引擎应用

SpringBoot6/springBoot集成Elasticsearch项目是一个专为新手和开发者设计的实用Demo,它展示了如何在SpringBoot应用中快速集成Elasticsearch搜索引擎,实现高效的数据检索功能。通过这个项目,你可以轻松掌握SpringBoot与Elasticsearch的整合技巧,为你的应用添加强大的搜索能力。 ## 🚀 为什么选择Elasticsearch?

gitblog_00549的博客 855

飞牛fnNAS搭建私有云音乐库

本文介绍了在飞牛NAS上部署Navidrome音乐服务器的完整流程。首先创建音乐存储目录并安装Navidrome应用,然后配置管理员账号、语言设置和音乐路径。接着详细说明使用"音乐标签"软件刮削音乐元数据的方法,包括获取软件、导入音乐文件和自动匹配标签。针对远程访问需求,推荐使用ZeroTier实现内网穿透,并给出注册、创建网络及设备加入的具体步骤。最后介绍移动端使用"音流"APP连接Navidrome服务器的配置方法,实现手机端音乐播放。通过这套方案,用户可以搭建专

dgnankai的专栏 1831

SpringBoot6/springBoot集成WebSocket:实时通讯应用开发教程

SpringBoot6/springBoot是一个包含丰富SpringBoot知识点的Demo项目,每个子项目都聚焦于一个特定技能点,非常适合新手学习和开发者复习。本文将详细介绍如何在该项目中集成WebSocket,搭建实时通讯应用,让你快速掌握这一实用技术。 ## 什么是WebSocket?为什么选择它? WebSocket是一种在单个TCP连接上进行全双工通信的协议,能让客户端和服务器之间

gitblog_00711的博客 837

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

SpringBoot - Jackson详解

JSON 是目前主流的前后端数据传输方式。在 Spring Boot 项目中,只要添加了 WEB依赖(spring-boot-starter-web),就可以很方便地实现 JSON 转换。WEB 依赖默认加入了 jackson-databind 作为 JSON 处理器,我们不需要要添加额外的 JSON 处理器就可以返回一段 JSON。

记录并分享 949

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

如何快速上手SpringBoot6/springBoot:新手必备的环境搭建与第一个Demo教程

SpringBoot6/springBoot是一个包含丰富SpringBoot系列Demo代码的项目,每个子项目都对应SpringBoot的一个知识点或技能点,且都有相应的博客介绍,代码开箱即用,非常适合新手学习或老司机复习。通过本教程,你将快速掌握SpringBoot6/springBoot的环境搭建方法,并成功运行第一个Demo,开启你的SpringBoot学习之旅。 ## 📋 环境准备:

gitblog_01094的博客 523

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

SpringBoot整合Sentinel【详解】

springboot整合sentinel【详解】

qq_27480007的博客 1522

springboot整合mybatis(一)入门

mybatis

xiatianit的博客 3029

【springboot整合mybatis】分页

pageHelper 分页

xiatianit的博客 492

SpringBoot实战之路

1、为什么用到SpringBoot? 传统项目:整合SSH或者SSM,考虑配置文件,jar包冲突等问题 打包方式:打war包放到Tomcat webapp目录下进行执行 2、什么是SpringBoot? 快速开发框架,快速整合第三方常用框架。(Maven依赖关系,Maven继承方式实现) 完全采用注解化简化xml配置。内嵌Http服务器(Tomcat、Jetty)最终以java应用程序执...

秋实先生的博客 370

[ SpringBoot ]

Spring虽然有很多优点, 但是Spring框架的1. 配置麻烦,而且很多都是模版化的配置(固定的)2. 需要添加很多依赖, 例如web层依赖jackson组件,需要我们自己添加, 版本也可能不匹配基于以上两点,spring官方推出了SpringBoot .

yang20060116的博客 845
上一篇: SpringMVC_day02
下一篇: MyBatisPlus
InLoadwetrust
博客等级 码龄6年 11粉丝 84原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

InLoadwetrust

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值