这三个Java HTTP客户端库都可以用来发送HTTP请求并处理响应。以下是各自的简单比较和示例代码：

1. WebClient (Java 11及以上):

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
 
public class WebClientExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://example.com"))
                .build();
 
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

2. HttpClient (Apache HttpComponents):

import org.apache.hc.client5.httpclient.HttpClientBuilder;
import org.apache.hc.core5.http.HttpEntity;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.HttpResponse;
 
public class HttpClientExample {
    public static void main(String[] args) throws Exception {
        HttpClientBuilder builder = HttpClientBuilder.create();
        CloseableHttpClient client = builder.build();
 
        HttpGet request = new HttpGet("http://example.com");
        HttpResponse response = client.execute(request);
        HttpEntity entity = response.getEntity();
 
        System.out.println(response.getStatusLine().getStatusCode());
        System.out.println(EntityUtils.toString(entity));
    }
}

3. OkHttp (Square):

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
 
public class OkHttpExample {
    public static void main(String[] args) throws Exception {
        OkHttpClient client = new OkHttpClient();
 
        Request request = new Request.Builder()
                .url("http://example.com")
                .build();
 
        Response response = client.newCall(request).execute();
        System.out.println(response.code());
        System.out.println(response.body().string());
    }
}

这些示例都是同步执行的，如果需要异步执行，可以使用各自库提供的异步API。

# 使用Fedora 36作为基础镜像
FROM balenalib/genericx86-64-ext-fedora:36-build
 
# 安装OpenJDK 17
ENV JAVA_VERSION 17
ENV JAVA_HOME /usr/lib/jvm/java-${JAVA_VERSION}-openjdk
RUN dnf config-manager --set-enabled powertools && \
    dnf -y install java-${JAVA_VERSION}-openjdk && \
    dnf clean all && \
    rm -rf /var/cache/dnf/*
 
# 验证安装的Java版本
RUN java -version
 
# 安装Maven
ENV MAVEN_VERSION 3.8.6
ENV MAVEN_HOME /usr/share/maven
ENV PATH ${M2_HOME}/bin:${PATH}
RUN curl -fsSL https://apache.osuosl.org/maven/maven-3/${MAVEN_VERSION}/binaries/apache-maven-${MAVEN_VERSION}-bin.tar.gz | \
    tar -xz -C /usr/share && \
    ln -s /usr/share/apache-maven-${MAVEN_VERSION} ${M2_HOME}
 
# 设置Maven的配置文件
COPY settings.xml ${M2_HOME}/conf/settings.xml
 
# 验证Maven版本
RUN mvn -version
 
# 设置工作目录
WORKDIR /app
 
# 指定容器启动时执行的命令
CMD ["mvn"]

这个Dockerfile演示了如何构建一个包含OpenJDK 17和Maven的基础镜像。它首先从Fedora 36的官方镜像开始构建，然后安装OpenJDK 17，清理缓存，并验证Java版本。接着，它下载并安装了Maven，并使用了一个settings.xml配置文件，最后验证了Maven版本，并设置了工作目录和容器启动时执行的命令。

报错解释：

java.sql.SQLSyntaxErrorException: Unknown database 异常表示尝试连接到数据库时出现语法错误，具体是因为指定的数据库名称未知或不存在。

解决方法：

1. 检查数据库名称：确保你在连接字符串中指定的数据库名称是正确的。
2. 检查数据库服务器：确保数据库服务器正在运行，并且网络连接没有问题。
3. 权限问题：确认你的数据库用户有权访问指定的数据库。
4. 大小写敏感：有些数据库管理系统对数据库名称大小写敏感，确保大小写正确。
5. 路由问题：如果使用了数据库路由或连接池，确保配置正确，并且路由到正确的数据库服务器。

示例代码检查点：

String dbURL = "jdbc:mysql://localhost:3306/yourDatabase"; // 检查数据库名称是否正确
String user = "username"; // 检查用户名是否正确
String pass = "password"; // 检查密码是否正确
 
try {
    Connection con = DriverManager.getConnection(dbURL, user, pass);
    // 你的代码...
} catch (SQLException e) {
    e.printStackTrace();
}

确保在尝试连接之前，替换 yourDatabase、username 和 password 为正确的数据库名称、用户和密码。

要使用Java通过高德API获取两地之间的距离（公里），你需要做以下几步：

1. 获取高德API的Key。
2. 使用高德的地理编码服务获取两地的经纬度。
3. 使用高德的路径规划服务计算两地距离。

以下是一个简单的Java代码示例，展示了如何实现这些步骤：

import okhttp3.*;
import java.io.IOException;
 
public class GaoDeApiExample {
    private static final String GAODE_API_KEY = "你的高德API Key";
    private static final String DISTANCE_API = "https://restapi.amap.com/v3/distance?key=%s&origins=%s&destination=%s&type=1";
 
    public static void main(String[] args) throws IOException {
        String from = "北京天安门"; // 起点地名
        String to = "上海浦东国际机场"; // 终点地名
 
        String distanceUrl = String.format(DISTANCE_API, GAODE_API_KEY, from, to);
 
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url(distanceUrl)
                .build();
 
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }
 
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    String result = response.body().string();
                    System.out.println("距离（公里）: " + result);
                }
            }
        });
    }
}

请确保你已经替换了你的高德API Key为你从高德官网获取的API Key，并且你的API Key有调用路径规划服务的权限。

注意：上述代码使用了OkHttp库来发送HTTP请求，你需要在你的项目中添加这个依赖。

<!-- 在pom.xml中添加OkHttp依赖 -->
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.9.1</version>
</dependency>

这个示例代码是一个简化的版本，仅用于说明如何调用高德API获取两地距离。在实际应用中，你可能需要处理异常情况、错误处理、并发请求等问题。

在Java后端对接Stripe进行自定义金额支付，你需要使用Stripe的Java库，并确保已经配置了API密钥。以下是一个简化的代码示例，展示了如何实现自定义金额支付：

1. 首先，确保你已经添加了Stripe的Java库依赖到你的项目中。如果使用Maven，可以在pom.xml中添加如下依赖：

<dependency>
    <groupId>com.stripe</groupId>
    <artifactId>stripe-java</artifactId>
    <version>20.73.0</version> <!-- 使用最新的库版本 -->
</dependency>

2. 接下来，在你的Java后端代码中，创建一个方法来处理支付：

import com.stripe.Stripe;
import com.stripe.exception.StripeException;
import com.stripe.model.PaymentIntent;
import com.stripe.param.PaymentIntentCreateParams;
 
public class StripePaymentService {
 
    // 使用你的Stripe API密钥初始化Stripe
    public StripePaymentService(String secretKey) {
        Stripe.apiKey = secretKey;
    }
 
    public String createPaymentIntent(long amount, String currency, String paymentMethodId) throws StripeException {
        PaymentIntentCreateParams params = PaymentIntentCreateParams.builder()
                .setAmount(amount) // 金额，单位为最小货币单位，例如美元为美分
                .setCurrency(currency) // 货币类型，例如"usd"
                .setPaymentMethod(paymentMethodId) // 客户的支付方式
                .build();
 
        PaymentIntent paymentIntent = PaymentIntent.create(params);
 
        // 返回客户端所需的支付意图客户端密钥
        return paymentIntent.getClientSecret();
    }
}

3. 在你的支付请求处理中，调用这个服务来创建一个新的PaymentIntent并获取客户端密钥：

public class PaymentController {
 
    private final StripePaymentService stripePaymentService;
 
    public PaymentController(StripePaymentService stripePaymentService) {
        this.stripePaymentService = stripePaymentService;
    }
 
    @PostMapping("/create-payment-intent")
    public ResponseEntity<Map<String, Object>> createPaymentIntent(@RequestParam long amount, @RequestParam String currency, @RequestParam String paymentMethodId) throws StripeException {
        Map<String, Object> response = new HashMap<>();
        response.put("clientSecret", stripePaymentService.createPaymentIntent(amount, currency, paymentMethodId));
        return ResponseEntity.ok(response);
    }
}

确保你的Stripe API密钥（Stripe.apiKey）是配置正确的，并且在创建StripePaymentService实例时传入。

这个代码示例展示了如何在后端创建一个PaymentIntent并返回客户端密钥，这是客户端可以用来通过Stripe.js完成支付的。客户端代码需要使用返回的客户端密钥来完成支付流程。

import org.springframework.retry.annotation.Retryable;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
 
public class RetryService {
 
    @Retryable(
      value = {Exception.class}, 
      maxAttempts = 5, 
      backoff = @Backoff(delay = 2000)
    )
    public void retryOperation(String message) {
        // 假设这是一个可能失败的操作
        System.out.println("Operation is running, message: " + message);
        throw new RuntimeException("Operation failed");
    }
 
    @Recover
    public void recover(Exception e, String message) {
        // 当重试失败后执行的方法
        System.out.println("Recovered from exception: " + e + ", message: " + message);
    }
}

这个简单的例子展示了如何使用Spring Retry来实现方法的重试。retryOperation方法可能会抛出异常，导致重试。在重试失败后，recover方法会被调用。这个例子中，我们指定了最大重试次数为5，并且在每次重试之间使用了2秒的延迟。

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.util.Base64;
 
public class AESUtil {
 
    // AES密钥算法
    private static final String KEY_ALGORITHM = "AES";
 
    // 加密/解密算法/工作模式/填充方式
    private static final String CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";
 
    // 生成密钥
    public static String generateAESKey() throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_ALGORITHM);
        keyGenerator.init(128, new SecureRandom()); // 192 and 256 bits may not be available
        SecretKey secretKey = keyGenerator.generateKey();
        return Base64.getEncoder().encodeToString(secretKey.getEncoded());
    }
 
    // AES加密
    public static String encryptAES(String data, String key) throws Exception {
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        SecretKeySpec secretKeySpec = new SecretKeySpec(Base64.getDecoder().decode(key), KEY_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
        byte[] encrypted = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encrypted);
    }
 
    // AES解密
    public static String decryptAES(String data, String key) throws Exception {
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        SecretKeySpec secretKeySpec = new SecretKeySpec(Base64.getDecoder().decode(key), KEY_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
        byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(data));
        return new String(decrypted);
    }
 
    public static void main(String[] args) {
        try {
            String key = generateAESKey();
            String originalText = "Hello World!";
            String encryptedText = encryptAES(originalText, key);
            String decryptedText = decryptAES(encryptedText, key);
 
            System.out.println("Original Text : " + originalText);
            System.out.println("Encrypted Text : " + encryptedText);
            System.out.println("Decrypted Text : " + decryptedText);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这段代码提供了AES加密和解密的基本操作，包括密钥的生成、加密和解密。在main方法中，我们生成了一个密钥，用这个密钥对字符串"Hello Wo

在Java中，BigDecimal类用于精确的十进制数值操作。当需要比较两个BigDecimal对象的大小时，可以使用compareTo方法。

compareTo方法会返回一个整数值，该值指示其两个参数相比的数值顺序。返回值有三种情况：

1. 如果这个BigDecimal等于参数BigDecimal，则返回0。
2. 如果这个BigDecimal小于参数BigDecimal，则返回-1。
3. 如果这个BigDecimal大于参数BigDecimal，则返回1。

以下是使用compareTo方法比较BigDecimal大小的示例代码：

import java.math.BigDecimal;
 
public class BigDecimalComparison {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("10.0");
        BigDecimal b = new BigDecimal("5.0");
 
        // 比较两个BigDecimal的大小
        int result = a.compareTo(b);
 
        if (result > 0) {
            System.out.println("a 大于 b");
        } else if (result < 0) {
            System.out.println("a 小于 b");
        } else {
            System.out.println("a 等于 b");
        }
    }
}

在这个例子中，a大于b，因此输出将会是a 大于 b。

报错信息 "OCI runtime create failed: runc create failed" 通常表示 Docker 容器启动失败，与 OCI (Open Container Initiative) 运行时标准有关。

解决方法：

1. 检查 Docker 容器配置：确保 Dockerfile 和容器启动命令没有错误。
2. 检查挂载卷：如果在 Docker 命令中使用了 -v 或 --mount 选项挂载了宿主机的目录，确保目录路径正确，并且对于需要写入的目录，宿主机目录具有适当的权限。
3. 检查宿主机目录权限：确保 Docker 进程有权访问挂载的目录。
4. 检查 Docker 版本：确保你的 Docker 版本与 runc 兼容。
5. 查看日志：使用 docker logs 容器ID或名称 查看容器日志，以获取更多错误信息。

如果报错信息中包含 "java.nio" 相关错误，这通常表示 Java 应用程序在 Docker 容器内运行时遇到了问题。

解决方法：

1. 检查 Java 应用程序的日志：查看详细的错误信息，确定是否是 Java 应用程序代码问题。
2. 检查 Java 版本：确保容器内安装了正确版本的 Java，并且与应用程序兼容。
3. 检查环境变量：确保如 JAVA_HOME 环境变量正确设置，并指向正确的 Java 安装路径。
4. 检查文件权限：如果是文件权限问题，确保容器内的 Java 应用程序有足够权限访问相关文件。

在解决问题时，可以逐一排查上述可能性，并根据具体错误信息采取相应的解决措施。

报错信息不完整，但根据提供的部分信息，可以推测是在尝试编译Java项目时遇到了无法访问org.springframework.boot.SpringApplication类的问题。这通常是因为以下原因之一：

1. Spring Boot相关的jar包没有正确添加到项目的依赖中。
2. 项目的类路径（Classpath）没有正确设置，导致编译器找不到Spring Boot的类文件。

解决方法：

1. 确认项目的pom.xml（如果是Maven项目）或build.gradle（如果是Gradle项目）文件中是否已经包含了Spring Boot的起步依赖。对于Maven项目，你应该包含类似以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>你的Spring Boot版本</version>
</dependency>

对于Gradle项目，添加：

implementation 'org.springframework.boot:spring-boot-starter:你的Spring Boot版本'

2. 如果依赖已经存在，尝试执行Maven的mvn clean install或Gradle的gradle clean build来重新构建项目，以确保所有依赖都被正确下载和添加到项目中。
3. 确认IDE的类路径设置是否正确，以及是否包含了所需的Spring Boot相关jar包。
4. 如果你是在IDE（如IntelliJ IDEA或Eclipse）中开发，尝试重新导入项目或刷新Maven或Gradle依赖。
5. 如果以上步骤都不能解决问题，尝试清理IDE缓存并重启。

请根据你的开发环境和项目配置进行相应的操作。