50、Windows 与 WSL 2 及 Ubuntu 的安装配置与 Java 原生编译微服务指南

最新推荐文章于 2025-10-02 09:33:18 发布

脸先着地天使

最新推荐文章于 2025-10-02 09:33:18 发布

阅读量30

点赞数

CC 4.0 BY-SA版权

分类专栏： Spring Boot 3与微服务架构实战文章标签： Windows WSL 2 Ubuntu

本文链接：https://blog.youkuaiyun.com/jwt8token/article/details/150363330

Spring Boot 3与微服务架构实战专栏收录该内容

53 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

Windows 与 WSL 2 及 Ubuntu 的安装配置与 Java 原生编译微服务指南

1. Windows 环境下 Docker Desktop 的安装配置

在 Windows 系统上安装并配置 Docker Desktop，可按以下步骤操作：
1. 从 https://hub.docker.com/editions/community/docker-ce-desktop-windows/ 下载并安装 Docker Desktop for Windows。
2. 安装过程中若提示启用 WSL 2，选择“是”。
3. 安装完成后，从开始菜单启动 Docker Desktop。
4. 从 Docker 菜单中选择“Settings”，在设置窗口中选择“General”选项卡：
- 确保选中“Use the WSL 2 based engine”复选框。
- 若想避免每次重启电脑后手动启动 Docker Desktop，建议选中“Start Docker Desktop when you log in”复选框。
5. 点击“Apply & Restart”按钮完成配置。

2. Visual Studio Code 及其 Remote WSL 扩展的安装

为简化在 Linux 服务器中编辑源代码的操作，推荐使用 Visual Studio Code 及其 Remote WSL 扩展。安装和配置步骤如下：
1. 从 https://code.visualstudio.com 下载并安装 Visual Studio Code。安装时，在“Select Additional Tasks”中选择“Add to PATH”选项，这样就能在 Linux 服务器中使用 code 命令在 Visual Studio Code 中打开文件夹。
2. 安装完成后，从开始菜单启动 Visual Studio Code。
3. 使用 https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl 安装 Remote WSL 扩展。

3. WSL 2 中 Linux 服务器工具的安装

接下来，在 WSL 2 的 Linux 服务器中安装所需工具。从开始菜单启动 Windows Terminal，并打开 Linux 服务器的终端。Ubuntu 中已预装 git 和 curl 工具，其余工具可使用 apt install 、 sdk install 或 curl 与 install 组合的方式进行安装。

3.1 使用 apt install 安装工具

使用以下命令安装 jq 、 zip 、 unzip 和 siege ：

sudo apt update
sudo apt install -y jq
sudo apt install -y zip
sudo apt install -y unzip
sudo apt install -y siege

安装 Helm，运行以下命令：

curl -s https://baltocdn.com/helm/signing.asc | \
gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg > /dev/null 
sudo apt-get install apt-transport-https --yes 
echo "deb [arch=$(dpkg --print-architecture) \
  signed-by=/usr/share/keyrings/helm.gpg] \
  https://baltocdn.com/helm/stable/debian/ all main" | \
  sudo tee /etc/apt/sources.list.d/helm-stable-debian.list
sudo apt-get update
sudo apt install -y helm

3.2 使用 SDKman 安装 Java 和 Spring Boot CLI

使用 SDKman（ https://sdkman.io ）安装 Java 和 Spring Boot CLI，按以下步骤操作：

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

验证 SDKman 是否正确安装：

sdk version

安装 Java：

sdk install java 17.0.6-tem

安装 Spring Boot CLI：

sdk install springboot 3.0.4

3.3 使用 curl 和 install 安装其余工具

使用 curl 下载可执行文件，再用 install 命令将文件复制到文件系统的正确位置，并确保所有者和访问权限配置正确。安装特定版本的 kubectl 、 minikube 和 istioctl ，可运行以下命令：

# 安装 kubectl
curl -LO "https://dl.k8s.io/release/v1.26.1/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
rm kubectl

# 安装 minikube
curl -LO https://storage.googleapis.com/minikube/releases/v1.29.0/minikube-linux-amd64
sudo install -o root -g root -m 0755 minikube-linux-amd64 /usr/local/bin/minikube
rm minikube-linux-amd64

# 安装 istioctl
curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.17.0 TARGET_ARCH=x86_64 sh -
sudo install -o root -g root -m 0755 istio-1.17.0/bin/istioctl /usr/local/bin/istioctl
rm -r istio-1.17.0

4. 工具安装验证

运行以下命令验证工具是否正确安装：

git version && \
docker version -f json | jq -r .Client.Version && \
java -version 2>&1 | grep "openjdk version" && \
curl --version | grep "curl" | sed 's/(.*//' && \
jq --version && \
spring --version && \
siege --version 2>&1 | grep SIEGE && \
helm version --short && \
kubectl version --client -o json | \
  jq -r .clientVersion.gitVersion && \
minikube version | grep "minikube" && \
istioctl version --remote=false

5. 源代码的获取与访问

源代码可从 https://github.com/PacktPublishing/Microservices-with-Spring-Boot-and-Spring-Cloud-Third-Edition 获取。为能在 WSL 2 的 Linux 服务器中运行相关命令，需将源代码下载到一个文件夹，并设置环境变量 $BOOK_HOME 指向该文件夹。示例命令如下：

export BOOK_HOME=~/Microservices-with-Spring-Boot-and-Spring-Cloud-Third-Edition
git clone https://github.com/PacktPublishing/Microservices-with-Spring-Boot-and-Spring-Cloud-Third-Edition.git $BOOK_HOME

要验证从 Visual Studio Code 访问下载到 WSL 2 中 Linux 服务器的源代码，可运行以下命令：

cd $BOOK_HOME
code .

在 Visual Studio Code 中，可通过“Terminal → New Terminal”菜单选项打开终端，运行 bash 命令。

6. 代码结构

每个章节包含多个 Java 项目，每个微服务和 Spring Cloud 服务对应一个项目，还有几个供其他项目使用的库项目。以第 14 章为例，项目结构如下：

├── api
├── microservices
│   ├── product-composite-service
│   ├── product-service
│   ├── recommendation-service
│   └── review-service
├── spring-cloud
│   ├── authorization-server
│   ├── config-server
│   ├── eureka-server
│   └── gateway
└── util

所有项目使用 Gradle 构建，文件结构遵循 Gradle 标准约定：

├── build.gradle
├── settings.gradle
└── src
    ├── main
    │   ├── java
    │   └── resources
    └── test
        ├── java
        └── resources

7. Java 原生编译微服务概述

将微服务中的 Java 源代码编译成二进制可执行文件（即 Native Images），能显著缩短启动时间并减少内存消耗。下面将介绍何时适合进行 Java 源代码的原生编译，以及 GraalVM 项目和 Spring AOT 引擎。

8. 何时进行 Java 源代码的原生编译

Java 以“一次构建，随处运行”的特性提供了出色的跨平台支持。但在微服务时代，对微服务的快速升级、灵活伸缩以及零伸缩的需求，使得快速启动成为更关键的要求。同时，容器技术的使用降低了应用本身跨平台支持的重要性。因此，将 Java 源代码在构建时编译成目标平台的二进制格式（即 AOT 编译）变得尤为重要。

9. GraalVM 项目介绍

Oracle 多年来致力于开发高性能 Java VM 及相关工具，即 GraalVM 项目（ https://www.graalvm.org ）。GraalVM 的 VM 是多语言的，支持多种语言。我们关注的是其 Native Image 编译器，它可将 Java 字节码编译成特定操作系统和硬件平台的 Native Image。Native Image 无需 Java VM 即可运行，包含二进制编译的应用类和依赖类，还包括 Substrate VM 运行时系统。

为构建 Native Image，原生编译器基于封闭世界假设进行静态代码分析，这意味着运行时可调用的所有字节码在构建时必须可达。GraalVM Native Image 编译器存在一些限制，如反射和动态代理的使用，且编译时间较长。不过，GraalVM 项目提供了配置选项，可提供可达性元数据来克服这些限制。

10. Spring AOT 引擎介绍

Spring 团队也在支持 Spring 应用的原生编译。Spring Framework 6 和 Spring Boot 3 增加了对构建 Native Images 的官方支持，使用 GraalVM 的 Native Image 编译器进行实际编译。Spring 的 AOT 引擎在构建时分析 Spring Boot 应用，生成 GraalVM Native Image 编译器所需的初始化源代码和可达性元数据。

创建 Spring Boot 应用的 Native Image 过程如下：
1. 应用源代码由 Java 编译器编译成字节码。
2. Spring 的 AOT 引擎在封闭世界假设下分析代码，生成 AOT 源代码和可达性元数据。
3. AOT 生成的代码使用 Java 编译器编译成字节码。
4. 应用的字节码、可达性元数据和 AOT 引擎生成的字节码被发送到 GraalVM 的 Native Image 编译器，创建 Native Image。

构建 Native Image 有两种方式：
- 创建当前操作系统的 Native Image：使用 Gradle 的 nativeImage 任务。
- 创建作为 Docker 镜像的 Native Image。

以下是创建 Native Image 的流程 mermaid 图：

graph LR
    A[应用源代码] --> B(Java 编译器编译成字节码)
    B --> C(Spring AOT 引擎分析生成 AOT 代码和元数据)
    C --> D(Java 编译器编译 AOT 代码成字节码)
    D --> E(应用字节码、元数据和 AOT 字节码)
    E --> F(GraalVM Native Image 编译器创建 Native Image)

综上所述，通过上述步骤和工具，我们可以在 Windows 环境下配置开发环境，获取并访问源代码，同时了解 Java 原生编译微服务的相关知识和工具。

Windows 与 WSL 2 及 Ubuntu 的安装配置与 Java 原生编译微服务指南

11. 处理原生编译问题

在进行 Java 源代码的原生编译时，会遇到一些问题，主要源于 GraalVM Native Image 编译器的限制，如反射和动态代理的使用。为解决这些问题，可利用 GraalVM 项目提供的配置选项，提供可达性元数据。以下是几种创建所需可达性元数据的方法：
- 手动配置 ：根据项目中反射和动态代理的使用情况，手动编写配置文件，描述这些动态特性的使用。
- 自动工具 ：使用 GraalVM 提供的工具，在运行时自动收集可达性信息，生成元数据。

12. 测试和编译 Native Images

在编译 Native Images 之前，需要进行充分的测试，确保代码在原生编译后能正常运行。以下是测试和编译的步骤：
1. 单元测试 ：使用 JUnit 等测试框架编写单元测试，确保每个模块的功能正常。
2. 集成测试 ：使用 Docker Compose 或 Kubernetes 进行集成测试，验证微服务之间的交互。
3. 编译 Native Images ：使用 Gradle 的 nativeImage 任务或创建 Docker 镜像的方式编译 Native Images。

以下是使用 Gradle 编译 Native Image 的示例：

./gradlew nativeImage

13. 使用 Docker Compose 进行测试

Docker Compose 是一个用于定义和运行多容器 Docker 应用的工具。使用 Docker Compose 可以方便地测试 Native Images。以下是使用 Docker Compose 进行测试的步骤：
1. 编写 Docker Compose 文件 ：定义微服务的容器化配置，包括镜像、端口映射、环境变量等。

version: '3'
services:
  service1:
    image: my-native-image-1
    ports:
      - "8080:8080"
  service2:
    image: my-native-image-2
    ports:
      - "8081:8081"

启动 Docker Compose ：使用以下命令启动 Docker Compose：

docker-compose up -d

进行测试 ：使用 curl 等工具对微服务进行测试，验证其功能。

14. 使用 Kubernetes 进行测试

Kubernetes 是一个用于自动化部署、扩展和管理容器化应用的开源平台。使用 Kubernetes 可以更复杂地测试 Native Images。以下是使用 Kubernetes 进行测试的步骤：
1. 编写 Kubernetes 配置文件 ：定义微服务的部署、服务等资源。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-native-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-native-service
  template:
    metadata:
      labels:
        app: my-native-service
    spec:
      containers:
      - name: my-native-container
        image: my-native-image
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: my-native-service
spec:
  selector:
    app: my-native-service
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

部署到 Kubernetes ：使用以下命令将配置文件部署到 Kubernetes：

kubectl apply -f my-native-service.yaml

进行测试 ：使用 kubectl 命令或浏览器访问服务的外部 IP 地址进行测试。

15. 总结

通过前面的介绍，我们了解了在 Windows 环境下，借助 WSL 2 和 Ubuntu 进行开发环境的搭建，包括 Docker Desktop、Visual Studio Code 及其扩展、各种开发工具的安装与配置，还掌握了源代码的获取、访问以及代码结构。同时，深入学习了 Java 原生编译微服务的相关知识，如何时进行原生编译、GraalVM 项目和 Spring AOT 引擎的使用，以及处理原生编译问题、测试和编译 Native Images 的方法，还介绍了使用 Docker Compose 和 Kubernetes 进行测试的步骤。

以下是整个流程的表格总结：
| 步骤 | 内容 |
| ---- | ---- |
| 1 | 在 Windows 安装 Docker Desktop 并配置 WSL 2 |
| 2 | 安装 Visual Studio Code 及其 Remote WSL 扩展 |
| 3 | 在 WSL 2 的 Linux 服务器安装工具 |
| 4 | 验证工具安装 |
| 5 | 获取并访问源代码 |
| 6 | 了解代码结构 |
| 7 | 学习 Java 原生编译微服务知识 |
| 8 | 处理原生编译问题 |
| 9 | 测试和编译 Native Images |
| 10 | 使用 Docker Compose 测试 |
| 11 | 使用 Kubernetes 测试 |

通过这些步骤和方法，我们可以构建高效、快速启动的 Java 微服务应用，满足现代软件开发的需求。

以下是整个过程的 mermaid 流程图：

graph LR
    A[Windows 环境] --> B(安装 Docker Desktop 和配置 WSL 2)
    B --> C(安装 Visual Studio Code 及扩展)
    C --> D(在 WSL 2 安装工具)
    D --> E(验证工具安装)
    E --> F(获取并访问源代码)
    F --> G(了解代码结构)
    G --> H(学习 Java 原生编译知识)
    H --> I(处理编译问题)
    I --> J(测试和编译 Native Images)
    J --> K(使用 Docker Compose 测试)
    J --> L(使用 Kubernetes 测试)

总之，掌握这些技术和方法，能够帮助开发者更好地应对现代微服务开发的挑战，提高开发效率和应用性能。