既然有了HTTP，为什么还要HTTPS？

keytool -genkeypair -alias test -keyalg RSA -keysize 2048 -validity 365 -storetype PKCS12 -keystore test.p12 -storepass password

What is your first and last name?
  [Unknown]:  Your Name
What is the name of your organizational unit?
  [Unknown]:  Your Organizational Unit
What is the name of your organization?
  [Unknown]:  Your Organization
What is the name of your City or Locality?
  [Unknown]:  Your City
What is the name of your State or Province?
  [Unknown]:  Your State
What is the two-letter country code for this unit?
  [Unknown]:  US
Is CN=Your Name, OU=Your Organizational Unit, O=Your Organization, L=Your City, ST=Your State, C=US correct?
  [no]:  yes

keytool -genkeypair -alias test -keyalg RSA -keysize 2048 -validity 365 -keystore test.p12 -storetype PKCS12 -storepass password -dname "CN=Your Name, OU=Your Organizational Unit, O=Your Organization, L=Your City, ST=Your State, C=CN"

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpsConfigurator;
import com.sun.net.httpserver.HttpsServer;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.security.KeyStore;

public class LocalHttpsServer {
    public static void main(String[] args) throws Exception {
        // 加载密钥库
        char[] passphrase = "password".toCharArray();
        KeyStore ks = KeyStore.getInstance("PKCS12");
        ks.load(new FileInputStream("C:\\Program Files\\Java\\jdk1.8.0_60\\bin\\test.p12"), passphrase);

        // 初始化密钥管理器工厂
        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(ks, passphrase);

        // 初始化信任管理器工厂
        TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
        tmf.init(ks);

        // 初始化 SSL 上下文
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);

        // 创建 HTTPS 服务器
        HttpsServer httpsServer = HttpsServer.create(new InetSocketAddress(8443), 0);
        httpsServer.setHttpsConfigurator(new HttpsConfigurator(sslContext));

        // 创建处理器
        httpsServer.createContext("/api", new HttpHandler() {
            @Override
            public void handle(HttpExchange exchange) {
                try {
                    if ("POST".equals(exchange.getRequestMethod()) && "application/json".equals(exchange.getRequestHeaders().getFirst("Content-Type"))) {
                        InputStream is = exchange.getRequestBody();
                        StringBuilder jsonString = new StringBuilder();
                        int i;
                        while ((i = is.read()) != -1) {
                            jsonString.append((char) i);
                        }

                        System.out.println("Received JSON: " + jsonString.toString());

                        String response = "{\"message\":\"Received\"}";
                        exchange.getResponseHeaders().set("Content-Type", "application/json");
                        exchange.sendResponseHeaders(200, response.getBytes().length);
                        OutputStream os = exchange.getResponseBody();
                        os.write(response.getBytes());
                        os.close();
                    } else {
                        exchange.sendResponseHeaders(405, -1); // Method Not Allowed
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 启动服务器
        httpsServer.setExecutor(null);
        httpsServer.start();
        System.out.println("HTTPS server started at https://localhost:8443/api");
    }
}

import javax.net.ssl.*;
import java.io.OutputStream;
import java.io.InputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.cert.X509Certificate;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

public class HttpsPostJsonClient {
    public static void main(String[] args) {
        String httpsURL = "https://localhost:8443/api";
        String jsonInputString = "{\"param1\":\"value1\",\"param2\":\"value2\"}";

        try {
            // 信任所有证书
            TrustManager[] trustAllCerts = new TrustManager[]{
                    new X509TrustManager() {
                        public X509Certificate[] getAcceptedIssuers() { return null; }
                        public void checkClientTrusted(X509Certificate[] certs, String authType) { }
                        public void checkServerTrusted(X509Certificate[] certs, String authType) { }
                    }
            };

            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, new java.security.SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
            HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
                public boolean verify(String hostname, javax.net.ssl.SSLSession sslSession) {
                    return true;
                }
            });

            // 创建 URL 对象
            URL url = new URL(httpsURL);
            HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();

            // 设置请求方法为 POST
            connection.setRequestMethod("POST");

            // 允许写入和读取数据
            connection.setDoOutput(true);
            connection.setDoInput(true);

            // 设置请求头
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestProperty("Accept", "application/json");

            // 发送 POST 数据
            try (OutputStream os = connection.getOutputStream()) {
                byte[] input = jsonInputString.getBytes("UTF-8");
                os.write(input, 0, input.length);
            }

            // 读取响应
            try (InputStream is = connection.getInputStream();
                 BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"))) {
                StringBuilder response = new StringBuilder();
                String responseLine;
                while ((responseLine = br.readLine()) != null) {
                    response.append(responseLine.trim());
                }
                System.out.println("Response: " + response.toString());
            }

        } catch (Exception e) {
            System.out.println("exceptinotallow===: " + e);
        }
    }
}