Java 从零开始手撸一个 HTTP 服务器

最新推荐文章于 2024-06-04 05:20:45 发布
最新推荐文章于 2024-06-04 05:20:45 发布
阅读量1.9k 收藏 11
点赞数 8
分类专栏： Java 个人杂记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rizero/article/details/111410244
版权

先想想需要达到怎样的要求：

本来这是一个很小的课程设计作业，老师也是要求能达到简单的socket应答就行了。但是我还是觉得有必要自己手撸一个HTTP服务器，毕竟这样更炫酷。

在开始写之前，我们先想想应该达到一个怎样的效果，我自己罗列了一下：

  1. 能在浏览器访问网页，比如：http://localhost:8000/index.html，这样子能解析自己预先准备的index.html：
  2. 能读取文本信息：比如：http://localhost:8000/17.xml，这样子能直接读取文本显示。
  3. 能处理请求异常：比如：http://localhost:8000/we.html，我们不支持这个地址，就会弹出File not found
  4. 持续接受用户的请求（无论正确/错误）

根据我自己对于HTTP服务器的理解，设计出HTTP服务器的生命周期如下：

  • Step1-read：读取socket数据流
  • Step2-parser：解析数据流，分析报头，得到客户给予服务器的命令语义
  • Step3-process：处理客户给的命令语义，返回处理结果
  • Step4-response：把处理结果打包，增加报头
  • Step5-write：写入socket数据流

以上的五步，我们完全可以把他作为一个线程独立出来，我希望：每一次客户向服务器发起请求的时候，我们就独立开辟一条线程去处理客户的需求，说白了，用子线程去独立执行以上的过程。

开始撸码

你应该遵循一下函数设计的规范：

我个人的编码规范，对于一个有返回对象的函数，应该需要设计如下：

    public Object functionExample(Object params){
        Object object1 = null;
        Obejct object2 = null;
        try{
            object1 = new Object();
            object2 = new Object();
            //Do something
            return object1;//Here is the return
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                //Close object1
                //CLose object2
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        return null;
    }

部分代码如果想偷懒偶尔不写close，我们也可以用这个

@SuppressWarnings("resource") // Warnings iggnore

先写服务器的主线程框架：

package csdn_fake_server;

import java.io.*;
import java.util.logging.Logger;
import java.net.*;


public class Server extends Thread{
    int watchPort = 8000;
    Logger log = Logger.getLogger("SERVER-LOG-JT");//Open log

    public Server(){};
    /**
     * Server
     * @param port: The server listen port
     */
    public Server(int port) {
        watchPort = port;
    }

    //Class httpServer{} 这里将会实现我们上面提到的子线程

    @Override
    public void run() {
        super.run();
        try {
            @SuppressWarnings("resource") // Warnings iggnore
            ServerSocket serverSocket = new ServerSocket(watchPort);
            while (true) { // Waitting for clients
                Socket socket = serverSocket.accept();// Thread Join here
                //Child Thread here
                new httpServer(socket).start();// If connected, start a new server thread
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }
}

以上是我写出来一个自己脑海里服务器的线程框架，该类里面你应该要配备一个测试的函数main(String[] args)。

我们在启动服务器线程之后，我们将利用ServerSocket 的accept()通过线程拥塞来监听端口的信息，因此，我们一旦收到服务器的套接字信息之后，就可以开启我们的子线程去处理客户的需求了。

接着写服务器子线程框架实现

    class httpServer extends Thread {

        Socket currentSocket = null; //Client Socket
        InputStream inputStream = null;//Use for get header
        OutputStream outputStream = null;//Use for response

        final static int sucessStatus = 200;//HTTP response header status code
        final static int noResourceStatus = 404;//HTTP response header status code

        int resultStatus = 404; //Our response code
        long responseLength = 20; //@Attention!!! Error info length, Important

        public httpServer(Socket socket) {
            try {
                currentSocket = socket; //Get socket bridge
                inputStream = socket.getInputStream(); // Get inputstream
                outputStream = socket.getOutputStream(); // Get outputstream
            } catch (Exception e) {
                log.info("Connection aborted");
            }
        }

        // Read=>parser=>process=>response=>write
        @Override
        public void run() {
            try {
                String rawString = read(); // Get raw header
                String serverCommand = parser(rawString); // Parser the raw header
                String resultString = process(serverCommand); // Process command
                String rawResultString = response(resultString); // Pack the result
                write(rawResultString);// Write in responsed stream
                currentSocket.close();// CLose the client socket
                //End thread
            } catch (Exception e) {
                log.info("Failed connection");
                e.printStackTrace();
            }
        }

        private String read(){//Step 1
            try{
	            //Read Interface
                return null;
            }catch(Exception e){
                log.info("Read faild");
                e.printStackTrace();
            }
            return null;
        }

        /**
         * 
         * @param rawString: raw String from read()
         * @return server command from client
         */
        private String parser(String rawString) { //Step 2
            try{
            	//Parser Interface
                return null;
            }catch(Exception e){
                log.info("Parser faild");
                e.printStackTrace();
            }
            return null;
        }
        
        /**
         * 
         * @param commandString: command string from parser
         * @return
         */
        private String process(String commandString) { //Step 3   
            try{
            	//Process Interface
                return null;
            }catch(Exception e){
                log.info("Process failed");
                e.printStackTrace();
            }finally{
                try{
                    //Close IO
                }catch(Exception e){
                    log.info("Bad IO");
                    e.printStackTrace();
                }
            }
			return null;
        }
        
        private String response(String resultString) { // Step 4
            try{
	            // response Interface
                return null;
            }catch(Exception e){
                log.info("response failed");
                e.printStackTrace();
            }
            return null;
        }

        private void write(String rawResultString) { //Step 5
            try{
            	//Write Interface
                return;
            }catch(Exception e){
                log.info("write faild");
                e.printStackTrace();
            }
        }
    }

好了，至此，我们的子线程的框架机搭建好了，具体的五个函数还没有实现。

  • read
  • parser
  • process
  • response
  • write

我们来好好思考一下每一步需要完成些什么工作。

第一步：读取原始的报文数据

private String read();//Step 1

读取报文之前，我们应该需要知道Http的报文格式，我们尝试打开现在的代码，然后试一下在浏览器向我们这个还没完成的服务器发送请求：http://localhost:8000/

在这里插入图片描述
如果我们在浏览器发出的请求一般都是GET请求了，对报文数据是在下一步，我们不关心客户给我们发来的数据是什么，我们在这个步骤值考虑把我们的数据流读入进服务器就是了。

因为HTTP的报文数据以“\r\n”作为分割，我们可以选择读取完所有的报文之后，再处理，也可以我们简单地读取第一行就行了，我们可以选择用BufferedReader的IO工具来处理，因为以行作为单位这样的话就更加方便了。

我们写出我们的read接口：

        private String read(){//Step 1
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            try{
                String infoRead = bufferedReader.readLine(); // We only get the line1 as: GET /index.html HTTP/1.1
                log.info(infoRead);
                return infoRead;
            }catch(Exception e){
                log.info("Read faild");
                e.printStackTrace();
            }
            return null;
        }

我这里偷懒没有Close IO，为了控制博文的长度，还是希望以后能加上。

第二步：解析报文

因为我们在上一步读取数据的时候偷懒只读一行了，因此，我们处理解析的时候也是一笔带过就是了，用空格分开GET /index.html HTTP/1.1

        /**
         * @param rawString: raw String from read()
         * @return server command from client
         */
        private String parser(String rawString) { //Step 2
            try{
                String[] split = rawString.split(" ");
                if (split.length != 3) { //@example as: GET /index.html HTTP/1.1
                    throw new NullPointerException();
                }
                return split[1]; // Get path
            }catch(Exception e){
                log.info("Parser faild");
                e.printStackTrace();
            }
            return null;
        }

第三步：处理客户语义

通过上面的解析报文，我们已经知道了客户需要请求一个地址了。因此，我们根据可以给出的地址来从后台读取文件：

		/**
         * @param commandString: command string from parser
         * @return
         */
        private String process(String commandString) { //Step 3  
            FileReader fileReader = null;
            BufferedReader bufferedReader = null;   
            try{
                log.info(commandString);//Show request in server panel
                if(commandString.equals("/")){ //Default get resource
                    commandString = "index.html";
                }
                File file = new File("src/simple_webserver_lab/template/"+commandString);
                fileReader = new FileReader(file);
                bufferedReader = new BufferedReader(fileReader);
                StringBuffer stringBuffer = new StringBuffer();
                String line;
                while((line = bufferedReader.readLine())!=null){
                    stringBuffer.append(line+"\r\n");
                }
                resultStatus = 200; //Success
                responseLength = file.length(); // This is must be added for HTPP Header
                String result = stringBuffer.toString();
                return result;
            }catch(Exception e){
                resultStatus = 404;
                log.info("Process failed");
                e.printStackTrace();
            }finally{
                try{
                    bufferedReader.close();
                    fileReader.close();
                }catch(Exception e){
                    resultStatus = 404;
                    log.info("Bad IO");
                    e.printStackTrace();
                }
            }
            return null;
        }

第四步：（巨坑）响应客户返回数据包

HTTP报头的content length是一个大坑

  • 需要两次的\r\n
  • 长度必须匹配！！！！

看这里：

<h1>File not found...</h1>

为毛后面写这些点，就是为了填补上不够数的字节，如果你差一个字节，都会不出来结果的，浏览器会报错的。

我们给出的数据只能比要求的content length要长！

我在前面定义了一个全局的响应长度：

        long responseLength = 20; //@Attention!!! Error info length, Important

像上面如果你返回：<h1>Error</h1>就会空白，因为你的数据不满足http报文的数据长度，因此我们会丢弃掉这个分组的数据了。

还有就是：HTTP/1.1 之间不要空格，否则 Firefox 系列的浏览器检查会出错哦。

响应部分的代码：

        /**
         * @param resultString
         * @return raw response result
         */
        private String response(String resultString) { // Step 4
            try{
                StringBuffer responseInfo = new StringBuffer();
                switch(resultStatus){
                    case sucessStatus:{
                        responseInfo.append("HTTP/1.1 200 ok \r\n");
                        responseInfo.append("Content-Type:text/html \r\n");
                        responseInfo.append("Content-Length:"+Long.toString(responseLength)+" \r\n\r\n");
                        responseInfo.append(resultString);
                        break;
                    }
                    case noResourceStatus:{
                        responseInfo.append("HTTP/1.1 "+Integer.toString(noResourceStatus)+" file Not Found \r\n");
                        responseInfo.append("Content-Type:text/html \r\n");
                        responseInfo.append("Content-Length:"+Long.toString(responseLength)+" \r\n\r\n");
                        responseInfo.append("<h1>File not found...</h1>");
                        break;
                    }default:{
                        break;
                    }
                }
                return responseInfo.toString();
            }catch(Exception e){
                log.info("response failed");
                e.printStackTrace();
            }
            return null;
        }

第五步：写入Socket的数据流

这个就没啥好说的了

        /***
         * @param rawResultString
         */

        private void write(String rawResultString) { //Step 5
            try{
                outputStream.write(rawResultString.getBytes());
                outputStream.flush();
                outputStream.close();
                return;
            }catch(Exception e){
                log.info("write faild");
                e.printStackTrace();
            }
        }

测试结果：

启动服务器：

    public static void main(String[] args) {
        Server server = new Server();
        server.start(); //服务器的主线程启动
    }

前提你要有一个index.html在你的指定目录。

假如我们访问根和指定访问index.html，都会显示：
在这里插入图片描述

在这里插入图片描述
后台打印：
在这里插入图片描述
假如，我们访问目录下的文本文件：17.xml，将会显示文本内容：
在这里插入图片描述
终端：
在这里插入图片描述
假如我们访问一个不存在的路径：
在这里插入图片描述
后台打印：
在这里插入图片描述
至此，我们撸完了一个简易的 Http 服务器了。

完整代码：

项目文件夹：
在这里插入图片描述
Server.java


package simple_webserver_lab;

import java.io.*;
import java.util.logging.Logger;
import java.net.*;

/**
 * @author:JintuZheng
 * @version: 1.0.00
 */

public class Server extends Thread {  


    int watchPort = 8000;
    Logger log = Logger.getLogger("SERVER-LOG-JT");

    public Server(){};
    /**
     * Server
     * @param port: The server listen port
     */
    public Server(int port) {
        watchPort = port;
    }

    /**
     * @apiNote: The child httpServer
     */
    class httpServer extends Thread {

        Socket currentSocket = null; //Client Socket
        InputStream inputStream = null;//Use for get header
        OutputStream outputStream = null;//Use for response

        final static int sucessStatus = 200;//HTTP response header status code
        final static int noResourceStatus = 404;//HTTP response header status code

        int resultStatus = 404; //Our response code
        long responseLength = 20; //@Attention!!! Error info length, Important

        public httpServer(Socket socket) {
            try {
                currentSocket = socket; //Get socket bridge
                //log.info(socket.getInetAddress().toString()); //Show ip address
                inputStream = socket.getInputStream(); // Get inputstream
                outputStream = socket.getOutputStream(); // Get outputstream
            } catch (Exception e) {
                log.info("Connection aborted");
            }
        }

        // Read=>parser=>process=>response=>write
        @Override
        public void run() {
            try {
                String rawString = read(); // Get raw header
                String serverCommand = parser(rawString); // Parser the raw header
                String resultString = process(serverCommand); // Process command
                String rawResultString = response(resultString); // Pack the result
                write(rawResultString);// Write in responsed stream
                currentSocket.close();// CLose the client socket
                //End thread
            } catch (Exception e) {
                log.info("Failed connection");
                e.printStackTrace();
            }
        }

        private String read(){//Step 1
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            try{
                String infoRead = bufferedReader.readLine(); // We only get the line1 as: GET /index.html HTTP/1.1
                log.info(infoRead);
                return infoRead;
            }catch(Exception e){
                log.info("Read faild");
                e.printStackTrace();
            }
            return null;
        }

        /**
         * 
         * @param rawString: raw String from read()
         * @return server command from client
         */
        private String parser(String rawString) { //Step 2
            try{
                String[] split = rawString.split(" ");
                if (split.length != 3) { //@example as: GET /index.html HTTP/1.1
                    return null;
                }
                return split[1]; // Get path
            }catch(Exception e){
                log.info("Parser faild");
                e.printStackTrace();
            }
            return null;
        }
        
        /**
         * 
         * @param commandString: command string from parser
         * @return
         */
        private String process(String commandString) { //Step 3  
            FileReader fileReader = null;
            BufferedReader bufferedReader = null;   
            try{
                log.info(commandString);//Show request in server panel
                if(commandString.equals("/")){ //Default get resource
                    commandString = "index.html";
                }
                File file = new File("src/simple_webserver_lab/template/"+commandString);
                fileReader = new FileReader(file);
                bufferedReader = new BufferedReader(fileReader);
                StringBuffer stringBuffer = new StringBuffer();
                String line;
                while((line = bufferedReader.readLine())!=null){
                    stringBuffer.append(line+"\r\n");
                }
                resultStatus = 200;
                responseLength = file.length(); // This is must be added for HTPP Header
                String result = stringBuffer.toString();
                return result;
            }catch(Exception e){
                resultStatus = 404;
                log.info("Process failed");
                e.printStackTrace();
            }finally{
                try{
                    bufferedReader.close();
                    fileReader.close();
                }catch(Exception e){
                    resultStatus = 404;
                    log.info("Bad IO");
                    e.printStackTrace();
                }
            }
            return null;
        }
        
        /**
         * 
         * @param resultString
         * @return raw response result
         */
        private String response(String resultString) { // Step 4
            try{
                StringBuffer responseInfo = new StringBuffer();
                switch(resultStatus){
                    case sucessStatus:{
                        responseInfo.append("HTTP/1.1 200 ok \r\n");
                        responseInfo.append("Content-Type:text/html \r\n");
                        responseInfo.append("Content-Length:"+Long.toString(responseLength)+" \r\n\r\n");
                        responseInfo.append(resultString);
                        break;
                    }
                    case noResourceStatus:{
                        responseInfo.append("HTTP/1.1 "+Integer.toString(noResourceStatus)+" file Not Found \r\n");
                        responseInfo.append("Content-Type:text/html \r\n");
                        responseInfo.append("Content-Length:"+Long.toString(responseLength)+" \r\n\r\n");
                        responseInfo.append("<h1>File not found...</h1>");
                        break;
                    }default:{
                        break;
                    }
                }
                return responseInfo.toString();
            }catch(Exception e){
                log.info("response failed");
                e.printStackTrace();
            }
            return null;
        }
        /***
         * 
         * @param rawResultString
         */

        private void write(String rawResultString) { //Step 5
            try{
                outputStream.write(rawResultString.getBytes());
                outputStream.flush();
                outputStream.close();
                return;
            }catch(Exception e){
                log.info("write faild");
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        super.run();
        try {
            @SuppressWarnings("resource") // Warnings iggnore
            ServerSocket serverSocket = new ServerSocket(watchPort);
            while (true) { // Waitting for clients
                Socket socket = serverSocket.accept();// Thread Join here
                new httpServer(socket).start();// If connected, start a new server thread
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }
}
JintuZheng
关注
专栏目录
在Java中实现一个简单的HTTP服务器
Programming Talk
06-21 234
HTTP服务器的基本功能是接收客户端的HTTP请求，处理请求并返回HTTP响应。监听网络端口，接受客户端连接。解析HTTP请求。处理请求，根据请求内容生成响应。发送HTTP响应给客户端。管理连接的生命周期，包括处理并发连接。本文详细介绍了如何使用Java编写一个简单的HTTP服务器，并演示了如何扩展其功能。通过本文的学习，我们可以掌握基本的HTTP服务器实现原理，并能够在实际项目中应用这些知识。一个简单的HTTP服务器虽然功能有限，但理解其工作原理对掌握Web开发基础非常有帮助。
Java构建简单的http服务器
小哥哥，你来啦！互相关注一波，互粉！
08-09 265
Java代码如下 package test; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; import java.util.Date; public clas...
使用Java Socket手撸一个http服务器
weixin_34006468的博客
12-30 305
原文连接：使用Java Socket手撸一个http服务器 作为一个java后端，提供http服务可以说是基本技能之一了，但是你真的了解http协议么？你知道知道如何手撸一个http服务器么？tomcat的底层是怎么支持http服务的呢？大名鼎鼎的Servlet又是什么东西呢，该怎么使用呢？ 在初学java时，socket编程是逃不掉的一章；虽然在实际业务项目中，使用这个的可能性基本为0，本篇...
快速搭建一个自己的服务器详解（java环境）
热门推荐
GuoZebin的博客
07-19 17万+
一. 服务器的购买 1. 我选择的是阿里云的服务器，学生价9.5元一个月，百度直接搜索阿里云，然后点击右上角登录，推荐大家用支付宝扫码登录，方便快捷。阿里云官网的东西比较多，登录后我找了很久也没有找到学生服务器在哪里卖，最后在咨询里找到了这个网址，https://promotion.aliyun.com/ntms/campus2017.html，购买的时候需要进行学生认证，按照他的要求一步步...
搭建JavaWeb服务器
weixin_30604651的博客
05-20 187
JDK安装可以参考http://www.cnblogs.com/a2211009/p/4265225.html Tomcat安装可参考 1.由于服务器配置比较低综合考虑，选择ubuntu系统进行搭建 2. 登陆阿里云服务器： 方法一：使用xshell软件登陆服务器 主机填写ip地址 端口号选择22 连接登陆服务器 方法二：使用阿里云管理终端 ssh ...
java httpServer
Iori202的专栏
12-15 152
import java.io.IOException;import java.net.InetSocketAddress; import com.sun.net.httpserver.HttpExchange;import com.sun.net.httpserver.HttpHandler;import com.sun.net.httpserver.HttpServer; /** * * ...
java socket http服务器_使用Java Socket手撸一个http服务器
weixin_42316952的博客
02-12 941
作为一个java后端，提供http服务可以说是基本技能之一了，但是你真的了解http协议么？你知道知道如何手撸一个http服务器么？tomcat的底层是怎么支持http服务的呢？大名鼎鼎的Servlet又是什么东西呢，该怎么使用呢？在初学java时，socket编程是逃不掉的一章；虽然在实际业务项目中，使用这个的可能性基本为0，本篇博文将主要介绍如何使用socket来实现一个简单的http服务器功...
从零开始一个http服务器(一)【实战系列，持续更新】
zpznba的博客
04-08 730
一个简单的socket server 写一个helloworld 复习c语言的socket API 一个简单的socket server 用telent测试 从helloworld 开始 先来回顾下c语言的，c语言的helloword程序如下 // main.c #include<stdio.h> int main() { printf("hello worl...
从0开始带你手撸一套SpringBoot+Vue后台管理系统
06-28
在本项目中，我们将一起构建一个基于Spring Boot和Vue.js的后台管理系统，这是一次从零开始的学习旅程，旨在帮助开发者全面理解这两种技术的结合应用。Spring Boot是Java领域广泛使用的微服务框架，而Vue.js则是一种...
手把手教你从零开始开发上线一个生产级别的 Java 小说系统
最新发布
qq_33856597的博客
06-04 1018
PDManer 元数建模，是一款多操作系统开源免费的桌面版关系数据库模型建模工具，基于 ES6 + React + Electron + Java 构建，相对于 PowerDesigner，他具备界面简洁美观，操作简单，上手容易等特点。支持 Windows, Mac, Linux 等操作系统，也能够支持国产操作系统，能够支持的数据库如下：MySQL, PostgreSQL, Oracle, SQLServer等常见数据库支持达梦，GuassDB 等国产数据库。
android 打开url 下载apk,Android 从零开始撸一个应用内更新Demo
weixin_31784241的博客
05-27 1615
原标题：Android 从零开始撸一个应用内更新Demo对于Android app来说，应用内更新几乎成了一个标配的功能了。原理其实不难，今天我们就从零开始撸一个自己的应用内更新的demo出来。先看看最终实现的效果： Picture上图的效果，稍微将功能拆分一下，可以总结为以下几点。1.检查更新；2.最新apk下载；3.apk下载成功后应用内跳转安装；1.检查更新为了检验检查更新的效果，我们需要一...
java HttpServer构建http服务器
08-09
NULL 博文链接：https://fxzcollege6.iteye.com/blog/2190825
java轻量级httpserver
03-29
NULL 博文链接：https://jj871231.iteye.com/blog/1290265
JAVA版HttpServer实现
05-23
本程序利用JAVA语言实现了HttpServer服务器，及时响应客户端的请求浏览，很好很强大！
耗时两周手撸了一个 RPC 轮子，是驴子是马拉出来遛遛
华科硕士，大厂打工中。编程问题咨询，请私我
01-11 3459
手撸 RPC 轮子系列文章目录： 「从零开始造 RPC 轮子系列」01 我为什么要去造一个轮子？ 「从零开始造 RPC 轮子系列」02 演示轮子，是驴是马拉出来遛遛] （TODO）「从零开始造 RPC 轮子系列」03 完事具备，只差一个环境搭建 （TODO）「从零开始造 RPC 轮子系列」04 手绘 4 张图带你入门 RPC 服务框架 （TODO）「从零开始造 RPC 轮子系列」05 用通俗的语言介绍 RPC 框架的架构原理 正文开始 大家好，我是雷小帅，最近我手写了一个mini版dubbo RPC框
从零开始设计一个轻量级分布式 RPC 框架
小牛肉的博客
12-19 1816
本项目基于 Spring + Netty + Zookeeper + Protostuff 从零开始设计实现一个轻量级的分布式 RPC 框架，内含详细设计思路以及开发教程，通过造轮子的方式来学习，深入理解 RPC 框架的底层原理。相比简历上一律的 xxxx 系统，造轮子很显然更能赢得面试官的青睐
Java-httpserver
u011183517的专栏
06-06 1211
java httpserver
Java HTTP Server
xianzhan 的博客
11-25 674
Java HTTP ServerHTTP Server HTTP Server 如何用 Java 写一个超简单的 HTTP 服务器? try (ServerSocket ss = new ServerSocket(8000)) { for (; ; ) { Socket s = ss.accept(); InputStream is = s.getInput...
用Java 构建您自己的HTTP 服务器（仅限 GET 方法）
allway2的博客
09-13 964
整个互联网使用频率最高的协议之一* * 在 OSI 模型中，第 7 层 每次访问网站时，您的 Web 浏览器都会使用HTTP协议与 Web服务器通信并获取页面内容。此外，当您实现后端应用程序并且必须与其他后端应用程序通信时 - 80%（或更多）的情况下您将使用HTTP. 长话短说——当你想成为一名优秀的软件开发人员时，你必须了解HTTP协议的工作原理。我认为，连接HTTP服务器是一种很好的理解方式。 Web 浏览器向 Web服务器发送什么？ 好问题。当然，您可以使用“开发人员工具”...
Java编程入门指南：从零开始学习
接着，教程详细阐述了如何安装SUN公司的SDK，以及一个完整的Java程序从编写到运行的基本步骤，让初学者能够快速建立起实际操作的经验。 第二章深入到语言语法的基础，讲解了标识符和关键字的规则，以及Java中的基本...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值