在这篇文章中，我们将带领您了解使用docker创建MySQL容器，并在springboot中使用的全貌，同时，我们还将为您介绍有关0018SpringBoot连接docker中的mysql并使用dru

在这篇文章中，我们将带领您了解使用 docker 创建 MySQL 容器，并在 springboot 中使用的全貌，同时，我们还将为您介绍有关0018SpringBoot 连接 docker 中的 mysql 并使用 druid 数据源、0018SpringBoot连接docker中的mysql并使用druid数据源、docker compose 部署 springboot+mysql、docker springboot 集成 redis、mysql 应用部署的知识，以帮助您更好地理解这个主题。

• 使用 docker 创建 MySQL 容器，并在 springboot 中使用
• 0018SpringBoot 连接 docker 中的 mysql 并使用 druid 数据源
• 0018SpringBoot连接docker中的mysql并使用druid数据源
• docker compose 部署 springboot+mysql
• docker springboot 集成 redis、mysql 应用部署

使用 docker 创建 MySQL 容器，并在 springboot 中使用

最近在看网上找了个 springboot 的项目试试，在项目中需要的 MySQL 版本是 5.7，但是本机的 MySQL 只有 5.5。因此想着在我的服务器上跑一个 MySQL:5.7 的容器解决这一问题，但是在实际操作过程中出现了一些问题，在这做下记录。

一、MySQL:5.7 容器的创建

1. 拉取镜像

1 docker pull mysql:5.7

2. 查看镜像

1 docker images

3. 创建与启动容器

1 docker run -di --name=mysql5.7 -p 33306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

4. 查看启动的容器

1 docker ps

5. 查看容器 (包括关闭的容器)

1 docker ps -a

二、出现的问题

1. 创建完容器后，以守护式方式创建完容器后发现 MySQL 容器几秒钟后自己关闭了。

在网上查后发现可能是虚拟内存不够。使用 free 后发现 swap 虚拟内存为 0，应该是虚拟内存未启用。

启用 swap:

1 dd if=/dev/zero of=/swapfile bs=1M count=1024
2 
3 mkswap /swapfile
4 
5 swapon /swapfile

再次 free 发现 swap 有数值了

 再次启动容器后发现容器不会自己关闭了，那么问题解决了。

2. 在 springboot 中连接 MySQL 容器报错

 在网上搜索解决办法大部分都说是权限的问题，但是添加权限后还是没用。

后来想到可能是配置文件的问题，因为我将服务器的 33306 端口映射到了 MySQL 的 3306 端口，而在配置文件中没有填写 MySQL 端口的信息，那么用的应该是 MySQL 默认的 3306 端口。

在配置文件中加入 33306 端口配置信息，springboot 可以正常使用了。

0018SpringBoot 连接 docker 中的 mysql 并使用 druid 数据源

由于 druid 数据源自带监控功能，所以引用 druid 数据源

1、centos7 中安装并启动 docker

2、docker 安装并启动 mysql

3、pom.xml 中引入 druid 依赖

4、application.yml 中配置数据库连接及 druid 数据源信息

5、编写 DruidConfig 配置文件，绑定 4 中所配置的数据源信息

6、编写 HelloController 用于访问

7、登录 druid 管理控制台

8、访问 HelloController 中的 hello 方法，并在 druid 控制台中查看

具体实现如下：

1、centos7 中安装并启动 docker

yum install docker

systemctl start docker

2、docker 安装并启动 mysql

拉取：

docker pull mysql

启动：

docker run --name mysql01 -e MYSQL_ROOT_PASSWORD=root@123 -d mysql:latest

查看容器：

docker ps -a

停止容器：

docker stop 容器 id

启动容器：

docker start 容器 id

删除容器：

docker rm 容器 id

3、pom.xml 中引入 druid 依赖

<?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.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.myself</groupId>
    <artifactId>springboot-05-data-jdbc</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-05-data-jdbc</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <!--必须将此段注释调用才能使用@Runwith注解-->
            <!--<exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>-->
        </dependency>
        <!--用于热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--引入druid数据源-->
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.8</version>
        </dependency>
    </dependencies>

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

</project>

4、application.yml 中配置数据库连接及 druid 数据源信息

spring:
  datasource:
    username: root
    password: root@123
    url: jdbc:mysql://192.168.225.118:3306/jdbc?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，''wall''用于防火墙
    #filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
  #    schema:
  #      - classpath:department.sql

5、编写 DruidConfig 配置类，绑定 4 中所配置的数据源信息

package com.myself.springboot05datajdbc.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DruidConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid(){
        return  new DruidDataSource();
    }

    //配置Druid的监控
    //1、配置一个管理后台的Servlet
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        Map<String,String> initParams = new HashMap<>();

        initParams.put("loginUsername","admin");
        initParams.put("loginPassword","123456");
        initParams.put("allow","");//默认就是允许所有访问
        initParams.put("deny","192.168.15.21");

        bean.setInitParameters(initParams);
        return bean;
    }


    //2、配置一个web监控的filter
    @Bean
    public FilterRegistrationBean webStatFilter(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());

        Map<String,String> initParams = new HashMap<>();
        initParams.put("exclusions","*.js,*.css,/druid/*");

        bean.setInitParameters(initParams);

        bean.setUrlPatterns(Arrays.asList("/*"));

        return  bean;
    }
}

6、编写 HelloController 用于访问

package com.myself.springboot05datajdbc.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;

@RestController
public class HelloController {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @GetMapping("/hello")
    public Map<String, Object> hello(){
        List<Map<String, Object>> lists = jdbcTemplate.queryForList("select * from department");
        return lists.get(0);
    }
}

7、登录 druid 管理控制台

 　　用户名密码为在步骤 5 的代码中写的

8、访问 HelloController 中的 hello 方法，并在 druid 控制台中查看

特别注意：在步骤 4 中配置数据源时，有可能连接不上远程的 docker 中的 mysql 数据库，需要以下步骤赋权才可以：

安装的 mysql 默认其他机器是没有权限访问的，需要赋权

1、  docker ps 查看 mysql 的容器 id

2、docker exec -it xxx sh 进入容器终端

3、mysql –u root –p

4、通过 navicat 远程连接不上，出现这个原因是 mysql8 之前的版本中加密规则是 mysql_native_password, 而在 mysql8 之后，加密规则是 caching_sha2_password.

解决问题方法有两种，一种是升级 navicat 驱动，一种是把 mysql 用户登录密码加密规则还原成 mysql_native_password.

这里采用第二种方式 ：

修改加密规则:

5、 ALTER USER ''root''@''%'' IDENTIFIED WITH mysql_native_password BY ''123'';

  其中：root 为用户名，% 为允许所有机器访问，123 为新设置的密码

6、 FLUSH PRIVILEGES;

如有理解不到之处，望指正！

0018SpringBoot连接docker中的mysql并使用druid数据源

由于druid数据源自带监控功能，所以引用druid数据源

1、centos7中安装并启动docker

2、docker安装并启动MysqL

3、pom.xml中引入druid依赖

4、application.yml中配置数据库连接及druid数据源信息

5、编写DruidConfig配置文件，绑定4中所配置的数据源信息

6、编写HelloController用于访问

7、登录druid管理控制台

8、访问HelloController中的hello方法，并在druid控制台中查看

具体实现如下：

1、centos7中安装并启动docker

yum install docker

systemctl start docker

2、docker安装并启动MysqL

拉取：

docker pull MysqL

启动：

docker run --name MysqL01 -e MysqL_ROOT_PASSWORD=root@123 -d MysqL:latest

查看容器：

docker ps -a

停止容器：

docker stop 容器id

启动容器：

docker start 容器id

删除容器：

docker rm 容器id

3、pom.xml中引入druid依赖

<?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.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.myself</groupId>
    <artifactId>springboot-05-data-jdbc</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-05-data-jdbc</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>MysqL</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <!--必须将此段注释调用才能使用@Runwith注解-->
            <!--<exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>-->
        </dependency>
        <!--用于热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--引入druid数据源-->
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.8</version>
        </dependency>
    </dependencies>

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

</project>

4、application.yml中配置数据库连接及druid数据源信息

spring:
  datasource:
    username: root
    password: root@123
    url: jdbc:MysqL://127.0.0.1:3306/jdbc?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=UTC
    driver-class-name: com.MysqL.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenevictionRunsMillis: 60000
    minevictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    #filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useglobalDataSourceStat: true
    connectionProperties: druid.stat.mergesql=true;druid.stat.slowsqlMillis=500
  #    schema:
  #      - classpath:department.sql

5、编写DruidConfig配置类，绑定4中所配置的数据源信息

package com.myself.springboot05datajdbc.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DruidConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid(){
        return  new DruidDataSource();
    }

    //配置Druid的监控
    //1、配置一个管理后台的Servlet
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        Map<String,String> initParams = new HashMap<>();

        initParams.put("loginUsername","admin");
        initParams.put("loginPassword","123456");
        initParams.put("allow","");//默认就是允许所有访问
        initParams.put("deny","192.168.15.21");

        bean.setinitParameters(initParams);
        return bean;
    }


    //2、配置一个web监控的filter
    @Bean
    public FilterRegistrationBean webStatFilter(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());

        Map<String,String> initParams = new HashMap<>();
        initParams.put("exclusions","*.js,*.css,/druid/*");

        bean.setinitParameters(initParams);

        bean.setUrlPatterns(Arrays.asList("/*"));

        return  bean;
    }
}

6、编写HelloController用于访问

package com.myself.springboot05datajdbc.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;

@RestController
public class HelloController {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @GetMapping("/hello")
    public Map<String, Object> hello(){
        List<Map<String, Object>> lists = jdbcTemplate.queryForList("select * from department");
        return lists.get(0);
    }
}

7、登录druid管理控制台

 　　用户名密码为在步骤5的代码中写的

8、访问HelloController中的hello方法，并在druid控制台中查看

特别注意：在步骤4中配置数据源时，ip地址一定要是MysqL容器的ip地址，而不能是docker所在虚拟机的地址，查看容器所在ip方法如下：

1、  docker ps 查看MysqL的容器id

2、  docker exec -it xxx sh 进入容器终端

3、  cat /etc/hosts 显示ip所在的配置文件

如有理解不到之处，望指正！

docker compose 部署 springboot+mysql

【直播预告】程序员逆袭 CEO 分几步？

1、宿主机为安装了 ubuntu22.04 系统的虚拟机。docker 和 docker-compose 的安装过程略过。

2、先看下项目结构：

项目为普通的 springboot 项目，只有一个测试接口，功能是从数据库表里查询数据。

Dockerfile 和 docker-compose.yml 文件在项目根目录下。

3、打 jar 包

mvn clean install

生成的 jar 包在 target 目录下，名为 demo-0.0.1-SNAPSHOT.jar。

4、编写 Dockerfile 文件，直接贴出文件内容：

FROM openjdk:11

ADD target/demo-0.0.1-SNAPSHOT.jar /myapp.jar
ADD src/main/resources/application.yml /application.yml

ENTRYPOINT ["java","-jar","/myapp.jar"]

From 就是从哪个镜像开始构建，这里使用 openjdk:11, openjdk 是镜像名称，11 是版本号。

ADD target/demo-0.0.1-SNAPSHOT.jar/myapp.jar， 是把 target 目录下的 jar 包，复制到容器的根目录下，并重命名为 myapp.jar。

ADD src/main/resources/application.yml/application.yml，是把项目的配置文件，复制到容器根目录下。

ENTRYPOINT ["java","-jar","/myapp.jar"]， ENTRYPOINT 是容器启动后执行的命令，这里是执行 jar 包，启动项目。

5、编写 docker-compose.yml

version: ''3''
services:
  mysql:
    image: mysql:8.0.26    # mysql镜像，版本为8.0.26
    container_name: mysql  # 容器名称，不是必须配置
    restart: always  # restart配置为always
    volumes:
      - dbdata:/var/lib/mysql  # 挂载目录，防止容器被停止并删除后，数据丢失
    environment:
      MYSQL_DATABASE: demo    # 创建一个空的数据库 
      MYSQL_ROOT_USER: root   # root角色用户 
      MYSQL_ROOT_PASSWORD: 123456  # root用户密码
      MYSQL_ROOT_HOST: ''%''  # 允许远程连接
      TZ: Asia/Shanghai  # 设置时区
  app:
    build: .
    container_name: app
    restart: always
    ports:
      - 8082:8082
    depends_on:
      - mysql
volumes:
  dbdata:

versrion 是 docker-compose 的版本；

services 表示服务列表，这里有两个服务，一个 mysql, 一个 app；

mysql 服务添加了挂载目录，格式为 - 宿主机目录：容器目录，宿主机目录可以写绝对路径，相对路径以及本例中的这种写法，直接写 dbdata，则这个目录位置在 docker 默认的工作目录下。

通过 sudo docker ps，可以看到 mysql 容器的 id。然后通过 sudo docker inspect mysql 容器 id，可以看到 mysql 容器的详情，注意其中的 Mounts 项：

mysql 服务没有配置端口映射，使用的是默认的 3306。

6、application.yml 中修改数据库连接信息。

用户名和密码以及数据库名称，用第 5 步中 mysql 服务的配置信息。需要注意的是这里的主机，用的是 mysql, 也就是 docker-compose.yml 文件中，mysql 服务的服务名。

初次启动时，数据库是空的，需要登录进去，建表。

sudo docker exec -it mysql 容器 id /bin/bash

进入容器后，执行：

    mysql -uroot -p

输入密码，进入 msyql 命令行，然后

use 数据库名称；

切换到指定数据库，执行建表命令。最后执行 quit 命令退出 mysql, 执行 exit 退出容器。

看到网上有许多无法连接数据库的问题，基本都是卡在这里。

然后有许多文章给出解决方案，基本丢失配置自定义的 network, 或者设置 network_mode，我本人都试过了，没有解决问题。按照上述配置，就可以了。

docker-compose 启动，会自动创建一个网络，一个 docker-compose 内的多个服务，共享这个网络，多个服务间通过域名或者说服务名，就可以访问。

如果这里启动的 mysql 服务，还需要被别的服务器访问，那就需要配置具体的 ip 地址。

以上。

docker springboot 集成 redis、mysql 应用部署

• 使用 docker 安装 redis

查找镜像：docker search redis

拉取 redis 镜像：docker pull redis

查找本地的镜像：docker images redis

1. 默认无密码执行命令

在redis的基础上run一个容器：docker run -d -p 6379:6379 [imageid]  执行成功，返回容器id

2. 密码版

docker run -d --name redis -p 6379:6379 redis --requirepass 123456
参数解释：-d是在后端执行，-p 6379:6379 指定端口，前面一个是宿主机暴露端口，后面一个是容器端口

3. redis 客户端连接命令：docker exec -it 0b63b7eacc29 redis-cli

• mysql 的安装步骤同上，在容器创建的时候，脚本修改：

docker run -p 3306:3306 --name mysql -v /root/docker/mysql/conf:/etc/mysql/conf.d 
-v /root/docker/mysql/logs:/logs -v /root/docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7

• 最后启动打包发布应用   

Dockerfile

# 基础镜像使用Java
FROM java:8
# 作者
MAINTAINER Bruce Shaw
# VOLUME 指定了临时文件目录为/tmp。
# 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp
VOLUME /tmp
RUN mkdir /pm/
# 拷贝当前下面的所有lib到docker下面temp
ARG JAR_FILE=/target/*.jar
ADD ${JAR_FILE} /pm/
# 容器入口点，在指定容器启动程序及参数
ENTRYPOINT ["java", "-cp", "/pm/*", "com.you.PmWebApplication"]
# 指定容器需要映射到主机的端口
EXPOSE 8010

创建镜像

docker build -f Dockerfile .

启动项目

docker run -d -p 8010:8010 -p 8085:8085 --link mysql:mysql --link redis:redis [imageId] --name pm

-d 后台启动  -p 指定端口 可以多个成组 --link 连接宿主的 mysql 和容器内部的 mysql；redis 同理 --name pm 指定容器名称

docker 查看日志

docker logs [containId] -f

-f 参数 可以查看实时的日志

关于使用 docker 创建 MySQL 容器，并在 springboot 中使用的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于0018SpringBoot 连接 docker 中的 mysql 并使用 druid 数据源、0018SpringBoot连接docker中的mysql并使用druid数据源、docker compose 部署 springboot+mysql、docker springboot 集成 redis、mysql 应用部署等相关知识的信息别忘了在本站进行查找喔。