使用 Docker 环境和Java Spring Boot 实现最小 API：MySQL。

的意思是什么？

我将在 Windows 11 上使用 Linux 进行云开发。

您可以在这里查看文章的列表。

实现

在本地环境的Ubuntu中的Docker环境中，启动了一个由Dockerfile构建的Java Spring Boot Web服务的自定义容器和MySQL数据库容器。

以JAR文件格式作为容器启动应用程序。

运行环境

REST API 服务容器

数据库容器

技術主題

什么是Spring Boot？

研发环境

Windows 11 Home 22H2 を使用しています。

创建 REST API 的规范

启动数据库容器

您可以在这篇文章中了解到如何创建一个适用于ToDo应用的RDBMS数据库，并将其作为Docker容器启动的步骤。

确认数据库容器已启动。

$ docker ps
CONTAINER ID   IMAGE        COMMAND                   CREATED        STATUS       PORTS                                                  NAMES
63a3acec271c   mysql-base   "docker-entrypoint.s…"   20 hours ago   Up 3 hours   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   mysql-todo

实现REST API的步骤是什么？

创建项目

创建项目文件夹。
＊将~/tmp/restapi-spring-boot指定为项目文件夹。

$ mkdir -p ~/tmp/restapi-spring-boot
$ cd ~/tmp/restapi-spring-boot

创建Model类

我要创建一个名为Todo的实体类。

$ mkdir -p src/main/java/com/example/model
$ vim src/main/java/com/example/springboot/model/Todo.java

文件的内容 de

package com.example.springboot.model;

import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;

import lombok.Data;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;

// ToDo エンティティを表すクラス
@Data
@Entity @Table(name="todos")
public class Todo {
    // RDBMS 本来の int 型のキー：API 入出力の JSON にはマッピングしない
    @JsonIgnore
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Id @Column(name="id", unique=true) Long _rdbms_id;

    // string 型の ID を定義：RDBMS 側にはマッピングしない
    @Transient String id;
    public String getId() { return Long.toString(_rdbms_id); }
    public void setId(String id) { _rdbms_id = Long.parseLong(id); }

    @JsonProperty("content")
    @Column(name="content") String content;

    @JsonProperty("created_date")
    @Column(name="created_date") 
    @Temporal(TemporalType.TIMESTAMP) Date createdDate;

    @JsonProperty("completed_date")
    @Column(name="completed_date") 
    @Temporal(TemporalType.TIMESTAMP) Date completedDate;
}

创建一个TodoRepository仓库接口。

$ mkdir -p src/main/java/com/example/model
$ vim src/main/java/com/example/springboot/model/TodoRepository.java

文件的内容 de

package com.example.springboot.model;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;

// ToDo エンティティに対する Repository インタフェース
public interface TodoRepository extends JpaRepository<Todo, Long> {
    List<Todo> findByCompletedDateIsNotNull();
}

创建 Application 类和 Controller 类

创建一个Application类。

$ vim src/main/java/com/example/springboot/Application.java

文件的内容

package com.example.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.scheduling.annotation.EnableAsync;

@EntityScan("com.example.springboot.*")
@EnableJpaRepositories("com.example.springboot.*")
@SpringBootApplication
@EnableAsync
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

创建一个名为TodoController的类。

$ vim src/main/java/com/example/springboot/TodoController.java

文件的内容

package com.example.springboot;

import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;

import org.springframework.scheduling.annotation.Async;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.example.springboot.model.Todo;
import com.example.springboot.model.TodoRepository;

@CrossOrigin( // CORS 設定：適切に修正してください。
    origins = "*", 
    methods = { RequestMethod.GET, RequestMethod.POST, RequestMethod.PUT, RequestMethod.DELETE }
)
@RestController
@RequestMapping("/todos")
public class TodoController {

    private final TodoRepository _todoRepository;

    public TodoController(TodoRepository todoRepository) {
        _todoRepository = todoRepository;
    }

    // すべての ToDo アイテムを取得します。
    @GetMapping
    @Async public CompletableFuture<List<Todo>> getAllTodos() {
        List<Todo> todos = _todoRepository.findAll();
        return CompletableFuture.completedFuture(todos);
    }

    // 完了した ToDo アイテムを取得します。
    @GetMapping("/complete")
    @Async public CompletableFuture<List<Todo>> getCompleteTodos() {
        List<Todo> todos = _todoRepository.findByCompletedDateIsNotNull();
        return CompletableFuture.completedFuture(todos);
    }

    // ID で ToDo アイテムを取得します。
    @GetMapping("/{id}")
    @Async public CompletableFuture<Optional<Todo>> getTodo(@PathVariable String id) {
        Optional<Todo> todo = _todoRepository.findById(Long.parseLong(id));
        return CompletableFuture.completedFuture(todo);
    }

    // 新しい ToDo アイテムを追加します。
    @PostMapping
    @Async public CompletableFuture<Todo> createTodo(@RequestBody Todo todo) {
        todo.setCreatedDate(new Date());
        return CompletableFuture.completedFuture(_todoRepository.save(todo));
    }

    // 既存の ToDo アイテムを更新します。
    @PutMapping("/{id}")
    @Async public CompletableFuture<Todo> updateTodo(@PathVariable String id, @RequestBody Todo todo) {
        Optional<Todo> exist = _todoRepository.findById(Long.parseLong(id));
        if (exist.isPresent()) {
            Todo target = exist.get();
            target.setContent(todo.getContent());
            target.setCompletedDate(todo.getCompletedDate());
            return CompletableFuture.completedFuture(_todoRepository.save(target));
        }
        return CompletableFuture.completedFuture(null);
    }

    // ID で ToDo アイテムを削除します。
    @DeleteMapping("/{id}")
    @Async public CompletableFuture<Void> deleteTodo(@PathVariable String id) {
        _todoRepository.deleteById(Long.parseLong(id));
        return CompletableFuture.completedFuture(null);
    }
}

添加Spring Boot的配置文件

创建application.properties文件。

$ mkdir -p src/main/resources
$ vim src/main/resources/application.properties

文件的内容

spring.datasource.url=jdbc:mysql://${DB_HOST}:${DB_PORT}/${DB_NAME}?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
spring.datasource.username=${DB_USER}
spring.datasource.password=${DB_PASSWORD}
spring.jpa.show-sql=false

创建 pom.xml

创建pom.xml文件。

$ vim pom.xml

文件的内容 de

<?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.7.15</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>restapi-spring-boot</artifactId>
    <version>1.0</version>
    <name>restapi-spring-boot</name>
    <properties>
        <java.version>17</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>javax.persistence-api</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <build>
        <finalName>app</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

启动应用

创建环境变量。

export DB_HOST=localhost
export DB_PORT=3306
export DB_NAME=db_todo
export DB_USER=root
export DB_PASSWORD=password

打开应用程序。
※ 停止应用程序时，请按下 ctrl + C。

$ mvn spring-boot:run \
    -Dspring-boot.run.arguments="--server.port=5000"

应用程序的操作确认

在终端上使用curl命令进行确认

获取：/todos终点的操作确认

获取所有的待办事项。

$ curl -s http://localhost:5000/todos | jq '.'

回应

[
// 省略
  {
    "id": "3",
    "content": "運動する",
    "created_date": "2023-08-23T05:15:08.000+00:00",
    "completed_date": "2023-08-23T05:15:08.000+00:00"
  },
  {
    "id": "4",
    "content": "本を読む",
    "created_date": "2023-08-23T05:15:08.000+00:00",
    "completed_date": null
  },
  {
    "id": "5",
    "content": "請求書を支払う",
    "created_date": "2023-08-23T05:15:08.000+00:00",
    "completed_date": null
  },
// 省略

确认 /todos/complete 终端点的操作

获取已完成的待办事项。

$ curl -s http://localhost:5000/todos/complete | jq '.'

响应

[
  {
    "id": "1",
    "content": "食材を買う",
    "created_date": "2023-08-23T05:15:08.000+00:00",
    "completed_date": "2023-08-23T05:15:08.000+00:00"
  },
  {
    "id": "2",
    "content": "報告書を仕上げる",
    "created_date": "2023-08-23T05:15:08.000+00:00",
    "completed_date": "2023-08-23T05:15:08.000+00:00"
  },
  {
    "id": "3",
    "content": "運動する",
    "created_date": "2023-08-23T05:15:08.000+00:00",
    "completed_date": "2023-08-23T05:15:08.000+00:00"
  }
]

请求：/todos/{id}端点的操作确认

使用ID获取待办事项项。

$ curl -s http://localhost:5000/todos/8 | jq '.'

回复/响应

{
  "id": "8",
  "content": "コードを書く",
  "created_date": "2023-08-25T03:12:38.000+00:00",
  "completed_date": null
}

发帖：/todos 确认端点的操作

添加新的待办事项。

$ curl -s -X POST http://localhost:5000/todos \
    -H 'Content-Type: application/json; charset=utf-8' \
    -d \
'{
    "content": "昼寝をする"
}' | jq '.'

回应

{
  "id": "9",
  "content": "昼寝をする",
  "created_date": "2023-08-31T10:47:09.657+00:00",
  "completed_date": null
}

在中国的本土化的环境下，将以下内容进行释义：
对于 /todos/{id} 这个端点，需要进行操作确认。

更新现有的待办事项。

$ curl -s -X PUT http://localhost:5000/todos/9 \
    -H 'Content-Type: application/json; charset=utf-8' \
    -d \
'{
    "content": "窓を開ける"
}' | jq '.'

回應

None (※なし)

删除：/todos/{id} 终端点的操作验证。

使用ID来删除待办事项。

$ curl -s -X DELETE http://localhost:5000/todos/9 | jq '.'

回应

None (※なし)

创建容器镜像

创建 Dockerfile。

$ vim Dockerfile

文件的内容 de

# build the app.
FROM openjdk:17-jdk-slim as build-env

# set the working dir.
WORKDIR /app

# install build tools and libraries.
RUN apt-get update && apt-get install -y maven

# copy source code to the working dir.
COPY . .

# build the app.
RUN mvn clean package

# set up the container.
FROM debian:12-slim

# set the working dir.
WORKDIR /app

# install the openjdk-17-jre-headless and clean up unnecessary files.
RUN apt-get update && \
    apt-get install -y --no-install-recommends openjdk-17-jre-headless && \
    apt-get autoremove -y && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

# set environment variables.
ENV JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64/jre
ENV PATH=$PATH:$JAVA_HOME/bin

# copy the built app from the build-env.
COPY --from=build-env /app/target/*.jar app.jar

# expose the port.
EXPOSE 8080

# command to run the app using java.
ENTRYPOINT ["java","-jar","app.jar"]

启动Docker守护进程。

$ sudo service docker start
 * Starting Docker: docker    [ OK ]

构建容器映像。

$ docker build \
    --no-cache \
    --tag api-todo-spring-boot:latest .

我会检查容器镜像。

$ docker images | grep api-todo-spring-boot
api-todo-spring-boot    latest    01ee6f4a47ac    9 seconds ago    340MB

启动容器

在本地启动容器。
※ 停止容器时，请按下 Ctrl + C。

$ docker run --rm \
    --publish 5000:8080 \
    --name api-local \
    --net net-todo \
    --env DB_HOST=mysql-todo \
    --env DB_PORT=3306 \
    --env DB_NAME=db_todo \
    --env DB_USER=root \
    --env DB_PASSWORD=password \
    api-todo-spring-boot

容器操作验证

我們將從另一個終端機使用curl命令來進行確認。
* 通過ID檢索待辦事項項目。

$ curl -s http://localhost:5000/todos/8 | jq '.'

回应

{
  "id": "8",
  "content": "コードを書く",
  "created_date": "2023-08-25T03:12:38.000+00:00",
  "completed_date": null
}

我来检查一下集装箱的状态。

$ docker ps
CONTAINER ID   IMAGE                  COMMAND                   CREATED          STATUS          PORTS                                                  NAMES
3534c2e3a94f   api-todo-spring-boot   "java -jar app.jar"       35 seconds ago   Up 34 seconds   0.0.0.0:5000->8080/tcp, :::5000->8080/tcp              api-local
63a3acec271c   mysql-base             "docker-entrypoint.s…"   8 days ago       Up 51 minutes   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   mysql-todo

连接到容器

从另一个终端连接到容器。

$ docker exec -it api-local /bin/bash

在连接到容器后，请确认目录。
※ 当退出容器时，请按下ctrl + D。

# pwd
/app
# ls -lah
total 40M
drwxr-xr-x 1 root root 4.0K Aug 31 11:23 .
drwxr-xr-x 1 root root 4.0K Aug 31 11:29 ..
-rw-r--r-- 1 root root  40M Aug 31 11:23 app.jar

使用top命令查看当前情况。

# apt update
# apt install procps
# top
top - 11:31:27 up  4:05,  0 user,  load average: 0.21, 0.17, 0.14
Tasks:   3 total,   1 running,   2 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.8 us,  0.3 sy,  0.0 ni, 98.8 id,  0.0 wa,  0.0 hi,  0.1 si,  0.0 st
MiB Mem :   7897.1 total,   1299.0 free,   3898.0 used,   2996.1 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   3999.1 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
    1 root      20   0 6945900 345012  23520 S   0.0   4.3   0:15.19 java
   59 root      20   0    4188   3332   2820 S   0.0   0.0   0:00.02 bash
  249 root      20   0    8560   4548   2664 R   0.0   0.1   0:00.00 top

让我们来显示容器的信息。

# cat /etc/*-release
PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
NAME="Debian GNU/Linux"
VERSION_ID="12"
VERSION="12 (bookworm)"
VERSION_CODENAME=bookworm
ID=debian
HOME_URL="https://www.debian.org/"
SUPPORT_URL="https://www.debian.org/support"
BUG_REPORT_URL="https://bugs.debian.org/"

附赠：Swagger 装备

添加库

将 springdoc-openapi 库添加到 pom.xml 中。

$ vim pom.xml

文件的内容

<!-- 省略 -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
+   <dependency>
+       <groupId>org.springdoc</groupId>
+       <artifactId>springdoc-openapi-ui</artifactId>
+       <version>1.7.0</version>
+   </dependency>
    <dependency>
        <groupId>javax.persistence</groupId>
        <artifactId>javax.persistence-api</artifactId>
        <version>2.2</version>
    </dependency>
<!-- 省略 -->

查看Swagger

在Web浏览器中确认Swagger的URL。

http://localhost:5000/swagger-ui/index.html

总结

在 WSL Ubuntu Docker 环境中，我成功实现了一个最小的Java Spring Boot API。

你觉得怎样？在WSL Ubuntu上，你可以轻松地启动Java Spring Boot Web应用程序。请务必试一试。我们还会继续介绍Spring的开发环境等，敬请期待。

推荐内容