import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;

@RestController
@EnableAutoConfiguration
public class HelloWorldApplication {

    @RequestMapping("/")
    String home() {
        return "Hello, Spring Boot!";
    }

    public static void main(String[] args) throws Exception {
        SpringApplication.run(HelloWorldApplication.class, args);
    }

}

package main

import (
    "net/http"
    "net/http/httptrace"
    "time"
)

func main() {
    // 创建一个跟踪结构体
    trace := &httptrace.ClientTrace{
        DNSStart: func(info httptrace.DNSStartInfo) {
            println("DNS解析开始")
        },
        DNSDone: func(info httptrace.DNSDoneInfo) {
            println("DNS解析完成")
        },
        ConnectStart: func(network, addr string) {
            println("连接服务器开始")
        },
        ConnectDone: func(network, addr string, err error) {
            println("连接服务器完成")
        },
        // ... 可以添加更多的跟踪处理函数
    }

    // 使用跟踪
    req, _ := http.NewRequest("GET", "http://example.com", nil)
    client := &http.Client{}
    ctx := httptrace.WithClientTrace(req.Context(), trace)
    req = req.WithContext(ctx)

    start := time.Now()
    client.Do(req)
    elapsed := time.Since(start)

    println("请求耗时:", elapsed)
}

import cn.hutool.http.HttpUtil;
import cn.hutool.core.util.NetUtil;

public class HutoolHttpExample {
    public static void main(String[] args) {
        // 设置全局默认的连接超时时间（单位：毫秒）和读取超时时间
        HttpUtil.setDefaultTimeout(10000);

        // 打印默认超时时间配置
        System.out.println("默认连接超时时间（毫秒）：" + HttpUtil.defaultConnectTimeout);
        System.out.println("默认读取超时时间（毫秒）：" + HttpUtil.defaultReadTimeout);

        // 测试连接是否可用
        String url = "http://www.example.com";
        boolean isAvailable = NetUtil.isUrlAvailable(url);
        System.out.println("连接测试结果：" + isAvailable);
    }
}

# 启用远程调试
spring.datasource.url=jdbc:h2:mem:testdb
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

# 远程调试配置
spring.remote_debug.server.port=5005
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

# Jolokia配置
endpoints.jolokia.enabled=true
endpoints.jolokia.base-path=/jolokia

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password:

---

server:
  port: 5005
  remote-debugging:
    enabled: true

management:
  endpoints:
    web:
      exposure:
        include: "*"
  jolokia:
    enabled: true
    base-path: /jolokia

public class HttpRequest {
    private String[] headers;  // 存储所有的头信息
    private String body;       // 存储请求体

    public HttpRequest(InputStream inputStream) throws IOException {
        // 读取请求行和头信息
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer)) != -1) {
            bos.write(buffer, 0, len);
        }
        String request = bos.toString();

        // 将请求行和头信息按行分割
        String[] temp = request.split("\n");
        headers = new String[temp.length];
        for (int i = 0; i < temp.length; i++) {
            headers[i] = temp[i];
        }

        // 判断是否有请求体
        if (temp.length > 1) {
            String lastHeader = temp[temp.length - 2];
            if (lastHeader.length() == 0) {
                // 存在请求体
                body = temp[temp.length - 1];
            }
        }
    }

    public String getBody() {
        return body;
    }

    public String getHeader(String key) {
        for (String header : headers) {
            if (header.startsWith(key)) {
                return header.split(": ")[1];
            }
        }
        return null;
    }

    public String getMethod() {
        return headers[0].split(" ")[0];
    }

    public String getUrl() {
        return headers[0].split(" ")[1];
    }
}

<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>5.0.0</version>
    <scope>provided</scope>
</dependency>

dependencies {
    providedCompile 'jakarta.servlet:jakarta.servlet-api:5.0.0'
}

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import java.io.File;
import java.io.StringReader;
import org.xml.sax.InputSource;

public class XMLParserExample {
    public static void main(String[] args) {
        try {
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(new File("example.xml"));
            doc.getDocumentElement().normalize();

            System.out.println("Root element :" + doc.getDocumentElement().getNodeName());

            NodeList nList = doc.getElementsByTagName("Student");

            for (int temp = 0; temp < nList.getLength(); temp++) {
                org.w3c.dom.Node node = nList.item(temp);
                System.out.println("\nCurrent Element :" + node.getNodeName());

                if (node.getNodeType() == org.w3c.dom.Node.ELEMENT_NODE) {
                    org.w3c.dom.Element eElement = (org.w3c.dom.Element) node;

                    System.out.println("First Name : " + eElement.getElementsByTagName("First_Name").item(0).getTextContent());
                    System.out.println("Last Name : " + eElement.getElementsByTagName("Last_Name").item(0).getTextContent());
                    System.out.println("Nick Name : " + eElement.getElementsByTagName("Nick_Name").item(0).getTextContent());
                    System.out.println("Marks : " + eElement.getElementsByTagName("Marks").item(0).getTextContent());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

server {
    listen 443 ssl;
    server_name your-domain.com;

    ssl_certificate /path/to/your/certificate.pem;
    ssl_certificate_key /path/to/your/private.key;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers HIGH:!aNULL:!MD5;

    location / {
        proxy_pass http://your_backend_server; # 假设Tomcat监听8080端口
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />