登录 注册

SpringBoot 整合 Docker 和 MongoDB 笔记

本贴最后更新于 1675 天前，其中的信息可能已经事过景迁

前言

一开始我只是想学一下 Docker，在了解了 Docker 的基础知识后，发现 Docker 安装软件很方便，于是就通过 Docker 安装了 MongoDB，顺带着把 MongoDB 也学习了，最后想着，既然 Docker 和 MongoDB 都学习了，为什么不顺带着将 MongoDB 和 SpringBoot 整合一下，再通过 Docker 部署呢？于是乎就有了这篇笔记，记录一下学习的过程。

Docker 学习

Docker 的学习主要参考 Docker 官网 和 菜鸟教程-Docker 教程

Docker 的安装以及 一些基础的知识，包括 镜像 和 容器 等概念，看一下 Docker 官网就可以 。需要熟练使用 镜像 和 容器 的操作指令，包括拉取（删除、打包. 镜像，运行（停止、删除）容器等。这些指令和 git 和 Linux 的指令很像的，很容易掌握。总结如下：

镜像操作指令

以 Docker 官网提供的 hello-world 镜像为例

1. 查找镜像

指令： docker search hello-world

imagesearch.png

2. 拉取镜像

指令： docker pull hello-world

imagepull.png

3. 列出所有镜像

指令： docker image ls 或者 docker images

imagelist.png

4. 删除镜像

指令： docker rmi hello-world

容器操作指令

容器的操作，就结合安装 MongoDB 来一起学习，Docker 安装软件就是将该软件对应的 Docker 镜像拉取下来，然后运行成为一个容器的过程。常用的开发软件都有对应的 Docker 镜像的，我们可以在 DockerHub 这个网站去找我们需要的软件镜像。比如我们搜索 mongodb，如下图所示：

mongodbiamge.png

第一个就是我们要找的镜像，我们点进去，右侧就是我们拉取镜像的指令。

mongofbdownload.png

1. 拉取 MongoDB 镜像

指令： docker pull mongo

2. 运行容器

指令： docker run -itd --name mongo -p 27017:27017 mongo --auth

参数说明：

  • -i : 交互式操作
  • -t : 终端
  • -d : 后台运行
  • --name : mongo 指定容器的名字
  • -p : 指定端口号
  • --auth : 指的是 MongoDB 数据库运行后，需要密码才能访问容器服务

其实使用 Docker 安装 MongoDB 这两步就完成了。

3. 查看容器信息

指令： docker ps -a

这个指令会列出容器 ID、镜像、创建时间、状态、端口号、名称等信息，比较重要的就是 CONTAINER ID(容器 ID)，NAMES(容器名称) 这两个，我们可以通过它们来管理镜像

dockerpsa.png

4. 停止容器

指令：docker stop [容器ID] 或者 [容器名称]

5. 启动容器

指令： docker start [容器ID] 或者 [容器名称]

6. 重启容器

指令： docker start [容器ID] 或者 [容器名称]

7. 删除容器

指令： docker rm -f [容器ID] 或者 [容器名称]

MongoDB 学习

在前面我们已经通过 Dokcer 安装了 MongoDB，现在我们通过 docker exec -it mongo mongo 指令进入 MongoDB 容器

mogo1.png

初次进入，我们需要创建一个超级用户，执行下面的两个命令：

# 1. 切换到admin数据库

 use admin

# 2. 创建超级用户admin

db.createUser({
	user: 'admin',
	pwd: '123456',
	roles: [{
		role: 'userAdminAnyDatabase',
		db: 'admin'
	}, "readWriteAnyDatabase"]
});
​

然后我们切换到 test 数据库，创建一个 test 用户，我们所有的学习都基于这个 test 数据库来进行，与上面类似，执行下面两个指令：

# 1. 切换到test，说明一下，use指令切换数据库时，如果数据库不存在，会自动创建的

use test

# 2. 创建一个对test数据库具有读写权限的用户test

db.createUser({
	user: "test",
	pwd: passwordPrompt(), // or cleartext password
	roles: [{
		role: "readWrite",
		db: "test"
	}]
})
执行完这条语句后，会提示我们输入该用户的密码，输入完成，用户就创建成功了。
​

关于 MongoDB 其他知识，参考 MongoDB 官网

创建 SpringBoot 项目，整合 MongoDB 和 Docker

我们通过 SpringBoot 项目来整合 MongoDB 和 Docker,然后通过 Swagger 来测试

1. MongoDB 和 Swagger 依赖配置
<!--   mongodb     -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <!--   web     -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--   lombok     -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- swagger -->
        <dependency>
            <groupId>com.spring4all</groupId>
            <artifactId>swagger-spring-boot-starter</artifactId>
            <version>1.7.0.RELEASE</version>
        </dependency>
        <!--   启动类加上@EnableSwagger2Doc注解后,如果不加validation这个依赖,启动会失败,目前原因不明     -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
​
2. Docker 插件配置
<properties>
        <java.version>1.8</java.version>
	<!-- dcoker 插件版本 -->
        <docker.maven.plugin.version>1.2.2</docker.maven.plugin.version>
        <docker.image.prefix>springboot</docker.image.prefix>
    </properties>
​
<!--     docker 配置       -->
        <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>${docker.maven.plugin.version}</version>
            <configuration>
                <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
		<!--  指定Dockfile文件所在位置  -->
                <dockerDirectory>src/main/docker</dockerDirectory>
                <resources>
                    <resource>
                        <targetPath>/</targetPath>
                        <directory>${project.build.directory}</directory>
                        <include>${project.build.finalName}.jar</include>
                    </resource>
                </resources>
            </configuration>
        </plugin>
​
3. MongoDB 连接配置
spring:
  data:
    mongodb:
      database: test
      host: 127.0.0.1
      port: 27017
      username: test
      password: test
​
4. 代码

实体类

@Data
public class Book {
    private Integer id;
    private String name;
    private String author;
    private String description;
}
​

操作 MongoDB 数据库主要通过注入 MongoTemplate 来实现

@Service
public class BookService {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     *  保存
     *
     * @param book
     */
    public void save(Book book) {
        mongoTemplate.save(book);
    }


    /**
     *  根据ID查询
     *
     * @param id
     * @return
     */
    public Book findById(Integer id) {
       return mongoTemplate.findOne(Query.query(Criteria.where("id").is(id)), Book.class);
    }

    /**
     *  根据名字查询
     *
     * @param name
     * @return
     */
    public Book findByName(String name) {
       return mongoTemplate.findOne(Query.query(Criteria.where("name").is(name)), Book.class);
    }

    /**
     *  查询所有
     *
     * @return
     */
    public List<Book> findAll() {
        return mongoTemplate.findAll(Book.class);
    }

    /**
     *  更新
     *
     * @param book
     */
    public void update(Book book) {
        Query query = Query.query(Criteria.where("id").is(book.getId()));
        Update update = Update.update("name", book.getName()).set("author", book.getAuthor())
                .set("description", book.getDescription());
        mongoTemplate.updateFirst(query, update, Book.class);
    }


    /**
     *  删除
     *
     * @param id
     */
    public void delete(Integer id) {
        mongoTemplate.remove(Query.query(Criteria.where("id").is(id)), Book.class);
    }


}
​

控制层

@RestController
@RequestMapping("/book")
@Api(value = "书籍管理", tags = "book")
public class BookController {

    @Autowired
    private BookService bookService;

    @PostMapping("/save")
    @ApiOperation(value = "保存")
    public void save(@RequestBody Book book) {
        this.bookService.save(book);
    }

    @GetMapping("/getById/{id}")
    @ApiOperation(value = "根据ID查询")
    public Book getById(@PathVariable Integer id) {
        return bookService.findById(id);
    }

    @GetMapping("/getByName/{name}")
    @ApiOperation(value = "根据名称查询")
    public Book getByName(@PathVariable String name) {
        return bookService.findByName(name);
    }


    @GetMapping("/getAll")
    @ApiOperation(value = "查询所有")
    public List<Book> getAll() {
        return bookService.findAll();
    }


    @PutMapping("/update")
    @ApiOperation(value = "更新")
    public void update(@RequestBody Book book) {
        bookService.update(book);
    }

    @DeleteMapping("/delete{id}")
    @ApiOperation(value = "删除")
    public void delete(@PathVariable Integer id) {
        bookService.delete(id);
    }
}
​
5. 编写 Dockfile 文件

打包之前需要先编写一个 Dcokerfile 文件，这个文件我放在 /src/main/docker/目录下，Dockerfile 的具体配置，可以看看这个 Docker Dockerfile

FROM openjdk:8-jdk-alpine
VOLUME /tmp
ADD springboot-mongodb-docker-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
​
6. 将项目打包为 Docker 镜像

进入项目所在目录，执行 mvn package docker:build 命令，如果没有报错，就说明打包成功，此时执行 docker images 指令查看镜像，第一个就是我们打包的镜像

spingbootdockerimage.png

7. 启动镜像

指令：docker run -d --net=host -p 8080:8080 --name springboot-mongodb-docker springboot/springboot-mongodb-docker:latest

参数说明：

  • -d : 后台运行
  • --net=host: 使用 host 模式启动容器，此时容器和宿主机共用一个 Network Namespace，这样我们的容器才可以访问其他运行着的软件，比如 MongoDB
  • -p : 指定端口号
  • --name: 指定我们容器的名字

如果我们想查看项目的日志，可以通过指令 docker logs springboot-mongodb-docker > logs.txt 来将日志写到 logs.txt 文件中

8. 通过 Swagger 测试

在浏览器输入 http://localhost:8080/swagger-ui.html#/

测试保存接口

booksave2.png

测试查询接口

bookfind.png

进入数据库查看

mogofind.png

至此，我们就成功了 😄

总结

通过 Docker 安装软件，是非常便利的，只需要学会 docker pull 和 docker run 两个指令就可以了。同时，docker 和 SpringBoot 的整合，使我们部署维护项目也变得很简单。

完整代码 springboot-mongodb-docker

  • Docker

    Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的操作系统上。容器完全使用沙箱机制，几乎没有性能开销，可以很容易地在机器和数据中心中运行。

    495 引用 • 931 回帖
  • Spring

    Spring 是一个开源框架，是于 2003 年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson 在其著作《Expert One-On-One J2EE Development and Design》中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 JavaEE 应用程序开发提供集成的框架。

    949 引用 • 1460 回帖
  • MongoDB

    MongoDB（来自于英文单词“Humongous”，中文含义为“庞大”）是一个基于分布式文件存储的数据库，由 C++ 语言编写。旨在为应用提供可扩展的高性能数据存储解决方案。MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。它支持的数据结构非常松散，是类似 JSON 的 BSON 格式，因此可以存储比较复杂的数据类型。

    91 引用 • 59 回帖
文山 位置
423 17 138 34 16 11 2 204

相关帖子

回帖
SpringBoot 整合 Docker 和 MongoDB 笔记

欢迎来到这里！

我们正在构建一个小众社区，大家在这里相互信任，以平等 • 自由 • 奔放的价值观进行分享交流。最终，希望大家能够找到与自己志同道合的伙伴，共同成长。

注册 关于
请输入回帖内容 ...
marshalby2
Java 开发者 文山
回帖
25
 帖子
14
 积分
13246