用Java Socket手撸了一个HTTP服务器

最新推荐文章于 2024-05-17 16:27:50 发布
最新推荐文章于 2024-05-17 16:27:50 发布
阅读量1.1k 收藏 21
点赞数 30
分类专栏： java 文章标签： java http 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zch981964/article/details/136591754
版权

作为一个 Java 后端，提供 HTTP 服务可以说是基本技能之一了，但是你真的了解 HTTP 协议么？你知道知道如何手撸一个 HTTP 服务器么？Tomcat 的底层是怎么支持 HTTP 服务的呢？大名鼎鼎的 Servlet 又是什么东西呢，该怎么使用呢？

在初学 Java 时，Socket 编程是逃不掉的一章；虽然在实际业务项目中，使用这个的可能性基本为 0， 但并不意味着不用学。本篇将主要介绍如何使用 Socket 来实现一个简单的 HTTP 服务器，提供常见的 get/post 请求支持，并在此过程中了解下 HTTP 协议。

I. HTTP 服务器从 0 到 1

既然我们的目标是借助 Socket 来搭建 HTTP 服务器，那么我们首先需要确认两点，一是如何使用 Socket；另一个则是 HTTP 协议如何解析数据；下面分别进行说明。

1. Socket 编程基础

我们这里主要是利用 ServerSocket 来绑定端口，提供 TCP 服务，基本使用姿势也比较简单，一般套路如下

  • 创建 ServerSocket 对象，绑定监听端口
  • 通过 accept() 方法监听客户端请求
  • 连接建立后，通过输入流读取客户端发送的请求信息
  • 通过输出流向客户端发送响应信息
  • 关闭相关资源
    对应的伪代码如下:
ServerSocket serverSocket = new ServerSocket(port, ip)
serverSocket.accept();
// 接收请求数据
socket.getInputStream();

// 返回数据给请求方
out = socket.getOutputStream()
out.print(xxx)
out.flush();;

// 关闭连接
socket.close()

具体的代码，我们前面的章节详细地讲过了，第一次来的小伙伴可以戳链接去学习一下。

2. HTTP 协议

ServerSocket 走的是 TCP 协议，HTTP 协议本身是在 TCP 协议之上的一层。

TCP 是一种面向连接的、可靠的、基于字节流的传输层协议。TCP 在两个网络节点之间提供了一条可靠的通信信道，确保数据在传输过程中不会丢失、重复或乱序。TCP 使用握手过程建立连接，通过确认和重传机制确保数据可靠传输，并使用流量控制和拥塞控制算法来优化网络性能。

HTTP 是一个用于在 Web 浏览器和 Web 服务器之间传输超文本、图像、视频和其他媒体资源的应用层协议。HTTP 使用请求-响应模型，即客户端（通常是 Web 浏览器）发送请求给服务器，服务器处理请求并返回响应。HTTP 协议定义了一组方法（如 GET、POST、PUT、DELETE 等），用于指定请求的类型和目的。此外，HTTP 协议还定义了一组状态代码（如 200、404、500 等），用于表示响应的结果。

HTTP 协议依赖于 TCP 协议来传输数据。当 Web 浏览器向 Web 服务器发送 HTTP 请求时，它首先使用 TCP 协议与服务器建立连接。一旦连接建立，HTTP 请求消息会被封装在 TCP 数据包中，然后通过 TCP 信道发送给服务器。服务器收到 TCP 数据包后，解包提取 HTTP 请求消息，处理请求并生成 HTTP 响应消息。最后，HTTP 响应消息被封装在 TCP 数据包中，并通过相同的 TCP 信道发送回客户端。客户端收到 TCP 数据包后，解包提取 HTTP 响应消息并显示给用户。
在这里插入图片描述
这幅图展示了客户端（Web 浏览器）与服务器（Web 服务器）之间的 HTTP 请求和响应，它们通过可靠的、面向连接的 TCP 连接进行数据传输。

好，再说回 HTTP 服务器这件事，最需要关注的无非两点：

请求消息

HTTP 请求消息由请求行（Request Line）、请求头（Request Headers）、空行（Empty Line）、请求体（Request Body，可选）几个部分组成。

①、请求行又包含三个部分，HTTP 方法（例如 GET, POST, PUT, DELETE 等）、请求的目标 URL（通常是相对 URL，但也可以是绝对 URL）、HTTP 版本（例如 HTTP/1.1 或 HTTP/2），这些部分用空格分隔，例如：

GET /index.html HTTP/1.1

②、请求头是一系列以键值对表示的元数据，用于描述请求的附加信息。每个请求头占一行，键和值之间用冒号（:）分隔。请求头包含诸如 Host、User-Agent、Content-Type、Content-Length、Accept 等信息。例如：

Host: www.tobebetterjavaer.com
User-Agent: Mozilla/5.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

③、请求头和请求体之间有一个空行，表示请求头的结束。
④、对于某些 HTTP 方法（例如 POST、PUT 等），还可以在请求消息中包含请求体。请求体用于传输要发送给服务器的数据。请求体的格式和内容取决于 Content-Type 请求头的值。

例如，当提交 HTML 表单时，请求体可能如下所示：

username=恒二哥&password=123456

将这些部分放在一起，就构成了一个完整的 HTTP 请求消息：

POST /login HTTP/1.1
Host: Host: www.tobebetterjavaer.com
User-Agent: Mozilla/5.0
Content-Type: application/x-www-form-urlencoded
Content-Length: 29
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
username=恒二哥&password=123456

在这里插入图片描述

响应消息

一个典型的 HTTP 响应消息由三部分组成：状态行（Status Line）、响应头（Response Headers）、响应体（Response Body）。
在这里插入图片描述

上面两张图，可以让你对 HTTP 请求和响应有个直观映象，接下来开始抓重点。
不管是请求消息还是响应消息，都可以划分为三部分，这就为我们后面的处理简化了很多工作。

  • 第一行：状态行
  • 第二行到第一个空行：header（请求头/相应头）
  • 剩下所有：正文

3. HTTP 服务器设计

接下来进入正题，基于 Socket 创建一个 HTTP 服务器，使用 Socket 基本没啥太大的问题，我们需要额外关注以下两点：

  • 对请求数据进行解析
  • 封装返回结果

a. 请求数据解析

注意📢，这些代码放在 HttpMessageParser 类中，随后会给出完整的代码。

@Data
public static class Request {
    /**
     * 请求方法 GET/POST/PUT/DELETE/OPTION...
     */
    private String method;
    /**
     * 请求的uri
     */
    private String uri;
    /**
     * HTTP版本
     */
    private String version;

    /**
     * 请求头
     */
    private Map<String, String> headers;

    /**
     * 请求参数相关
     */
    private String message;
}

根据前面的 HTTP 协议介绍，解析过程如下，我们先看请求行的解析过程。

请求行，包含三个基本要素：请求方法 + URI + HTTP 版本，用空格进行分割，所以解析代码如下

/**
 * 根据标准的HTTP协议，解析请求行
 *
 * @param reader
 * @param request
 */
private static void decodeRequestLine(BufferedReader reader, Request request) throws IOException {
    String[] strs = StringUtils.split(reader.readLine(), " ");
    assert strs.length == 3;
    request.setMethod(strs[0]);
    request.setUri(strs[1]);
    request.setVersion(strs[2]);
}

**请求头的解析，**从第二行，到第一个空白行之间的所有数据，都是请求头；请求头的格式也比较清晰，形如 key:value, 具体实现如下：

最后就是正文的解析了，这一块需要注意一点，正文可能为空，也可能有数据；有数据时，我们要如何把所有的数据都取出来呢？

先看具体实现如下：

/**
 * 根据标注HTTP协议，解析正文
 *
 * @param reader    输入流读取器，用于读取请求中的数据
 * @param request   Request 对象，表示 HTTP 请求
 * @throws IOException 当发生 I/O 错误时抛出
 */
private static void decodeRequestMessage(BufferedReader reader, Request request) throws IOException {
    // 从请求头中获取 Content-Length，如果没有，则默认为 0
    int contentLen = Integer.parseInt(request.getHeaders().getOrDefault("Content-Length", "0"));

    // 如果 Content-Length 为 0，表示没有请求正文，直接返回。
    // 例如 GET 和 OPTIONS 请求通常不包含请求正文
    if (contentLen == 0) {
        return;
    }

    // 根据 Content-Length 创建一个字符数组来存储请求正文
    char[] message = new char[contentLen];

    // 使用 BufferedReader 读取请求正文
    reader.read(message);

    // 将字符数组转换为字符串，并将其设置为 Request 对象的 message
    request.setMessage(new String(message));
}

注意上面我的使用姿势，首先是根据请求头中的Content-Type的值，来获得正文的数据大小，因此我们获取的方式是创建一个这么大的char[] 数组来读取流中所有数据，如果我们的数组比实际的小，则读不完；如果大，则数组中会有一些空的数据；

最后将上面的几个解析封装一下，完成 request 解析：

/**
 * HTTP 请求可以分为三部分：
 * 1. 请求行：包括请求方法、URI 和 HTTP 协议版本
 * 2. 请求头：从第二行开始，直到一个空行为止
 * 3. 消息正文：紧跟在空行后的所有内容，长度由请求头中的 Content-Length 决定
 *
 * 本方法将 InputStream 中的 HTTP 请求数据解析为一个 Request 对象
 *
 * @param reqStream  包含 HTTP 请求数据的输入流
 * @return           一个表示 HTTP 请求的 Request 对象
 * @throws IOException 当发生 I/O 错误时抛出
 */
public static Request parse2request(InputStream reqStream) throws IOException {
    // 使用 BufferedReader 和 InputStreamReader 读取输入流中的数据
    BufferedReader httpReader = new BufferedReader(new InputStreamReader(reqStream, "UTF-8"));

    // 创建一个新的 Request 对象
    Request httpRequest = new Request();

    // 解析请求行并设置到 Request 对象中
    decodeRequestLine(httpReader, httpRequest);

    // 解析请求头并设置到 Request 对象中
    decodeRequestHeader(httpReader, httpRequest);

    // 解析消息正文并设置到 Request 对象中
    decodeRequestMessage(httpReader, httpRequest);

    // 返回解析后的 Request 对象
    return httpRequest;
}

接下来，是请求结果的封装，给一个简单的进行演示：

/**
    * Response 类表示一个 HTTP 响应，包括版本、状态码、状态信息、响应头和响应正文。
    */
@Data
public static class Response {
    private String version;
    private int code;
    private String status;
    private Map<String, String> headers;
    private String message;
}

/**
    * 根据给定的 Request 对象和响应字符串构建一个 HTTP 响应。
    *
    * @param request   用于构建响应的 Request 对象
    * @param response  响应字符串
    * @return          一个表示 HTTP 响应的字符串
    */
public static String buildResponse(Request request, String response) {
    // 创建一个新的 Response 对象，并设置版本、状态码和状态信息
    Response httpResponse = new Response();
    httpResponse.setCode(200);
    httpResponse.setStatus("ok");
    httpResponse.setVersion(request.getVersion());

    // 设置响应头
    Map<String, String> headers = new HashMap<>();
    headers.put("Content-Type", "application/json");
    headers.put("Content-Length", String.valueOf(response.getBytes().length));
    httpResponse.setHeaders(headers);

    // 设置响应正文
    httpResponse.setMessage(response);

    // 构建响应字符串
    StringBuilder builder = new StringBuilder();
    buildResponseLine(httpResponse, builder);
    buildResponseHeaders(httpResponse, builder);
    buildResponseMessage(httpResponse, builder);
    return builder.toString();
}

/**
    * 构建响应行，包括版本、状态码和状态信息。
    *
    * @param response      用于构建响应行的 Response 对象
    * @param stringBuilder 用于拼接响应字符串的 StringBuilder 对象
    */
private static void buildResponseLine(Response response, StringBuilder stringBuilder) {
    stringBuilder.append(response.getVersion()).append(" ").append(response.getCode()).append(" ")
            .append(response.getStatus()).append("\n");
}

/**
    * 构建响应头。
    *
    * @param response      用于构建响应头的 Response 对象
    * @param stringBuilder 用于拼接响应字符串的 StringBuilder 对象
    */
private static void buildResponseHeaders(Response response, StringBuilder stringBuilder) {
    for (Map.Entry<String, String> entry : response.getHeaders().entrySet()) {
        stringBuilder.append(entry.getKey()).append(":").append(entry.getValue()).append("\n");
    }
    stringBuilder.append("\n");
}

/**
    * 构建响应正文。
    *
    * @param response      用于构建响应正文的 Response 对象
    * @param stringBuilder 用于拼接响应字符串的 StringBuilder 对象
    */
private static void buildResponseMessage(Response response, StringBuilder stringBuilder) {
    stringBuilder.append(response.getMessage());
}

b. 请求任务 HttpTask

每个请求，单独分配一个任务来干这个事情，就是为了支持并发，对于 ServerSocket 而言，接收到了一个请求，那就创建一个 HttpTask 任务来实现 HTTP 通信。

那么这个 httptask 干啥呢？

  • 从请求中捞数据
  • 响应请求
  • 封装结果并返回
/**
 * HttpTask 类实现了 Runnable 接口，用于处理一个 HTTP 请求。
 * 当在一个线程中执行时，该任务将处理一个 Socket 连接上的 HTTP 请求，
 * 并发送响应消息。
 */
public class HttpTask implements Runnable {
    // 用于处理 HTTP 请求的 Socket
    private Socket socket;

    /**
     * 构造一个新的 HttpTask，用于处理指定的 Socket 连接。
     *
     * @param socket  用于处理 HTTP 请求的 Socket
     */
    public HttpTask(Socket socket) {
        this.socket = socket;
    }

    /**
     * 实现 Runnable 接口的 run 方法，用于处理 HTTP 请求并发送响应消息。
     */
    @Override
    public void run() {
        // 检查 socket 是否为 null，如果为 null 则抛出异常
        if (socket == null) {
            throw new IllegalArgumentException("socket can't be null.");
        }

        try {
            // 获取 Socket 的输出流，并创建一个 PrintWriter 对象
            OutputStream outputStream = socket.getOutputStream();
            PrintWriter out = new PrintWriter(outputStream);

            // 从 Socket 的输入流中解析 HTTP 请求
            HttpMessageParser.Request httpRequest = HttpMessageParser.parse2request(socket.getInputStream());

            try {
                // 根据请求结果进行响应，省略返回
                String result = null;
                
                // 根据请求和结果构建 HTTP 响应
                String httpRes = HttpMessageParser.buildResponse(httpRequest, result);

                // 将 HTTP 响应发送到客户端
                out.print(httpRes);
            } catch (Exception e) {
                // 如果发生异常，构建一个包含异常信息的 HTTP 响应
                String httpRes = HttpMessageParser.buildResponse(httpRequest, e.toString());
                out.print(httpRes);
            }

            // 刷新输出流，确保响应消息被发送
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭 Socket 连接
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

c. HTTP 服务搭建

前面的基本上把该干的事情都干了，剩下的就简单了，创建ServerSocket，绑定端口接收请求，我们在线程池中跑这个 HTTP 服务

public class BasicHttpServer {
    // 创建一个单线程执行器，用于启动 HTTP 服务器
    private static ExecutorService bootstrapExecutor = Executors.newSingleThreadExecutor();
    // 创建一个线程池，用于处理来自客户端的 HTTP 请求
    private static ExecutorService taskExecutor;
    // 设置服务器监听的端口号
    private static int PORT = 8999;

    // 启动 HTTP 服务器的方法
    static void startHttpServer() {
        // 获取处理器可用核心数，用于设置线程池大小
        int nThreads = Runtime.getRuntime().availableProcessors();
        // 初始化线程池，设置线程池大小，队列大小和丢弃策略
        taskExecutor =
                new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(100),
                        new ThreadPoolExecutor.DiscardPolicy());

        // 循环尝试启动服务器，如果启动失败，则等待10秒后重试
        while (true) {
            try {
                ServerSocket serverSocket = new ServerSocket(PORT);
                bootstrapExecutor.submit(new ServerThread(serverSocket));
                break;
            } catch (Exception e) {
                try {
                    // 重试，等待 10 秒
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                }
            }
        }

        // 关闭启动执行器
        bootstrapExecutor.shutdown();
    }

    // HTTP 服务器主要任务类
    private static class ServerThread implements Runnable {
        // 保存传递给构造函数的 ServerSocket 实例
        private ServerSocket serverSocket;

        // 构造函数
        public ServerThread(ServerSocket s) throws IOException {
            this.serverSocket = s;
        }

        // 任务主体方法
        @Override
        public void run() {
            while (true) {
                try {
                    // 等待客户端连接
                    Socket socket = this.serverSocket.accept();
                    // 创建一个 HttpTask 实例，将 Socket 实例作为参数传递
                    HttpTask eventTask = new HttpTask(socket);
                    // 将 HttpTask 提交给 taskExecutor 执行
                    taskExecutor.submit(eventTask);
                } catch (Exception e) {
                    e.printStackTrace();
                    try {
                        // 如果发生异常，等待 1 秒后继续尝试
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                    }
                }
            }
        }
    }
}

这段代码是一个简单的 HTTP 服务器实现。以下是关于这个 HTTP 服务器的主要组件和功能的详细解释：

1、bootstrapExecutor：一个单线程的 ExecutorService，用于执行 HTTP 服务器的启动任务。

2、taskExecutor：一个线程池，用于处理来自客户端的 HTTP 请求。线程池的大小等于处理器可用核心数，队列大小为100，使用 DiscardPolicy 丢弃策略。

3、PORT：服务器侦听的端口号，默认为 8999。

4、startHttpServer() 方法：

  • a.创建一个线程池 taskExecutor 用于处理 HTTP 请求。
  • b.在一个循环中，尝试创建一个 ServerSocket 实例并绑定到指定端口。如果失败，则等待 10 秒后重试。
  • c.当成功创建 ServerSocket 实例后，将其作为参数提交给 bootstrapExecutor 执行 ServerThread 任务。
  • d.关闭 bootstrapExecutor。
    5、ServerThread 类实现了 Runnable 接口，它是 HTTP 服务器的主要任务：
  • a.serverSocket 成员变量：保存传递给构造函数的 ServerSocket 实例。
  • b.run() 方法：
  • 在一个无限循环中，调用 serverSocket.accept() 方法等待客户端的连接。
  • 当接受到一个新的客户端连接时，创建一个 HttpTask 实例，将 Socket 实例作为参数传递。
  • 将 HttpTask 提交给 taskExecutor 执行。

这个 HTTP 服务器的主要逻辑是：使用一个线程来监听客户端连接，当有新的客户端连接时，创建一个 HttpTask 来处理客户端的 HTTP 请求，并将这个任务提交给线程池 taskExecutor 执行。这样可以实现多个客户端请求的并发处理。

到这里，一个基于 Socket 实现的 HTTP 服务器基本上就搭建完了，接下来就可以进行测试了

4. 测试

做这个服务器，主要是基于项目 quick-fix 产生的，这个项目主要是为了解决应用内部服务访问与数据订正，我们在这个项目的基础上进行测试。

一个完整的 post 请求如下
在这里插入图片描述
接下来我们看下打印出返回头的情况

在这里插入图片描述

恒二哥
关注
  • 30
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用Java最简单的交换协议HttpExchange 构建HttpServer服务器,解析ResponseBody实现上传文件...
dieyao5524的博客
10-20 1254
HBServer.java package Test; import java.io.IOException; import java.net.InetSocketAddress; import java.util.concurrent.Executors; import com.sun.net.httpserver.HttpServer; import Te...
Java网络编程——创建非阻塞的HTTP服务器
布道师小羊的博客
12-07 993
Http简介、创建非阻塞的HTPP服务器
Java 网络编程-Socket编程（一、简易客户端-服务器）
最新发布
jiaoyaqiang的博客
05-17 767
很显然，客户端调用Socket构造器，创建了Socket，并且连接了服务器（服务器已经运行的情况下）。上面是服务器读取客户端发送的消息的代码，一行一行的读取消息，并且只有当客户端发送“quit”给服务器时，才表示此客户端要退出，并且在这个过程中其他客户端是不能与服务器进行连接的，因为服务器一直在while里面读取此客户端发送的数据，不过，这只是一个体验版，以后会一步一步进行升级的，毕竟学习也是一步一步学出来的。向服务器发送消息，并且接收服务器的回复，也是一行一行的读取。大家也自己进行测试，应该是没问题的。
java socket 发送http请求webservice.
03-17
NULL 博文链接：https://genius.iteye.com/blog/451378
java socket发送http请求
qq5132834的专栏
06-16 3167
public static void main(String[ ] args) throws UnknownHostException, IOException           {             String host = "127.0.0.1";             int port = 8080;             Socket socket = new S
java socket发送http
kingj126的专栏
02-28 206
含义 ENCTYPE="multipart/form-data" 说明：  通过 http 协议上传文件 rfc1867协议概述，jsp 应用举例，客户端发送内容构造  1、 概述在最初的 http 协议中，没有上传文件方面的功能。 rfc1867 (http://www.ietf.org/rfc/rfc1867.txt) 为 http 协议添加了这个功能。客户端的浏览器，如 Mic...
JAVA使用Socket编写HTTP服务器
Code Of Life
07-08 213
HTTP服务器核心就是Socket短连接 先简单说概念： 1、socket就是TCP/IP实现的套接字，就是应用层调用下层服务的接口。 2、短连接指的是连接建立后，双方进行数据交互（通常是一个数据包，也可以是多个），交互完毕后立即关闭连接的TCP/IP实现方式就是常说的短连接，最常见的短连接例子就是HTTP协议。 3、长连接则指的是双方交互完毕后，不关闭连接，而让连接一直空闲着等...
java socket实现http请求
qq_39561611的博客
10-30 400
1
Java使用NioSocket手动实现HTTP服务器
08-30
Java使用NioSocket手动实现HTTP服务器是使用Java语言通过NioSocket实现的一个简单的HTTP服务器。NioSocket是Java的New I/O（Non-blocking I/O）API，提供了非阻塞式的I/O操作，可以提高服务器的性能和可扩展性。 在...
java Socket实现简单模拟HTTP服务器
08-30
3. 模拟 HTTP 服务器：使用 Java Socket 可以模拟简单的 HTTP 服务器，来处理客户端的请求和响应。服务器可以监听客户端的请求，解析请求头，返回响应体。 4. HTTP 请求头解析：HTTP 请求头包含了请求的方法、URL、...
java使用socket实现一个多线程web服务器的方法
08-26
在Java编程中，使用Socket实现一个多线程Web服务器是一个常见的任务，这有助于处理并发的客户端连接，提升服务器的响应速度。下面将详细解释这个过程，包括服务器类、请求类和响应类的设计与实现。 首先，服务器类...
java搭建一个Socket服务器响应多用户访问
08-31
以上代码展示了如何使用Java的Socket API创建一个简单的多用户服务器。每个客户端连接都会由一个单独的线程处理，从而实现了并发处理。在实际应用中，可能还需要考虑异常处理、资源管理以及更复杂的消息解析和业务...
在 Java 上实现的 Socket.IO 服务器 实时java框架
10-25
该项目是Socket.IO服务器的开源 Java 实现。基于Netty服务器框架。 根据 Apache License 2.0 获得许可。 支持1.x - 4.x版本的Socket.IO 客户端 支持 xhr 轮询传输 支持websocket传输 支持命名空间和房间 支持ack...
java socket发http请求_java socket发送http请求
weixin_33554506的博客
02-12 576
public static void main(String[ ] args) throws UnknownHostException, IOException{String host = "127.0.0.1";int port = 8080;Socket socket = new Socket(host, port);BufferedWriter out = new BufferedWrite...
java socket 实现http_java socket 实现http请求
weixin_35964164的博客
02-15 1989
java中发送Http请求的方法很多，可以使用开源框架如httpclient，URLConnection的相关函数和Socket api来发送。相对于前两种，直接使用Socket发送http请求可以说是最底层的方式，其他方式或多或少的对该方式进行了封装，如下。Socket socket = new Socket("localhost", 8080);OutputStream os = socket...
java socket发送http_Java Socket发送与接收HTTP消息简单实现
weixin_35225039的博客
02-12 606
在上次Java Socket现实简单的HTTP服务我们实现了简单的HTTP服务，它可以用来模拟HTTP服务，用它可以截获HTTP请求的原始码流，让我们很清楚的了解到我们向服务发的HTTP消息的结构，对HTTP请求消息有个清晰的认识。这一节我想写了一个客户的程序，就是用来模拟浏览器，用来向服务器发送HTTP请求，最得要的是可以用它来显示服务器发回来的HTTP响应消息的一般结构。下面是代码实现：imp...
Java socket非阻塞发送http请求
u010905359的博客
08-19 294
一旦连接完成，我们将SocketChannel切换到写模式并发送HTTP请求，然后将SocketChannel切换到读模式并读取服务器的响应。然后，我们可以根据需要处理响应数据。以下是使用非阻塞SocketChannel的方式与服务器通信，并使用Selector来处理多个通道的事件。在连接建立后，我们将SocketChannel注册到Selector上，并监听OP_CONNECT事件。
面向Socket编程，实现Java客户端向服务器发送http请求
ITJingYing2050的博客
09-22 1076
文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 作为一个合格的程序员，不能不懂网络编程，说到网络编程，Socket编程作为网络通信的底层API，对我们了解那些网络框架的原理，大有助益。 一、pandas是什么？ 二、使用步骤 总结 ...
http隧道服务器java实现
05-23
HTTP隧道服务器是一种代理服务器，它允许通过HTTP隧道进行加密和解密的数据传输。Java语言可以用来实现HTTP隧道服务器。 以下是一些实现HTTP隧道服务器的Java库和框架： 1. Apache HttpComponents：这是一个开源的Java库，提供了HTTP客户端和服务器的实现。它支持HTTP隧道服务器的实现，并提供了完整的SSL/TLS支持。 2. Netty：这是一个异步事件驱动的网络应用程序框架，它可以用来实现高性能的HTTP隧道服务器。Netty提供了多种协议的编解码和处理器，可以轻松地实现HTTP隧道服务器。 3. Jetty：这是一个开源的Servlet容器和HTTP服务器，它可以用来实现HTTP隧道服务器。Jetty提供了完整的HTTP/1.1协议支持，并支持SSL/TLS加密。 4. Spring Boot：这是一个开源的Java框架，用于快速构建可部署的应用程序。Spring Boot提供了内置的Tomcat服务器，并支持HTTP隧道服务器的实现。 以上是一些Java库和框架，可以用来实现HTTP隧道服务器。您可以根据自己的需求和技能选择适合自己的实现方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

恒二哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值