`

一个简单的Web服务器（Web服务器如何工作）

 
阅读更多

一个简单的Web服务器（Web服务器如何工作）

分类： JavaWeb 2013-10-20 17:13 34人阅读 评论(0) 收藏 举报
JavaWeb服务器通信

 

HTTP允许Web服务器和浏览器通过Internet发送并接收数据，是一种基于“请求——响应”的协议。HTTP使用的是可靠的TCP连接，TCP协议默认使用TCP 80端口。在HTTP中，总是由客户端通过建立连接并发送HTTP请求来初始化一个事务的。Web服务器端并不负责联系客户端或建立一个到客户端的回调连接。HTTP协议是无状态的协议。 套接字是网络连接的端点。套接字使应用程序可以从网络中读取数据，可以向网络中写入数据。不同计算机上的两个应用程序可以通过连接发送或接收字节流，一次达到相互通信的目的。要创建一个套接字，需要指明其主机名和端口号，如下：

 

 

[java] view plaincopyprint?
  1. new Socket("www.baidu.com", 80); 
new Socket("www.baidu.com", 80);
一旦创建了Socket的实例，就可以使用该实例发送或接收字节流。要发送字节流，需要调用Socket类的getOutputStream()方法获取一个java.io.OutputStream对象。要发送文本到远程应用程序，通常需要使用返回的OutputStream对象创建一个java.io.PrintWriter对象。若想要从连接的另一端接收字节流，需要调用Socket类的getInputStream()方法，该方法会返回一个java.io.InputStream对象。

 

如果要想实现一个服务器应用程序，需要使用服务器套接字的实现（java.net.ServerSocket）。ServerSocket类和Socket类不同，服务器套接字要等待来自客户端的连接请求，当服务器套接字收到了连接请求以后，他会创建一个Socket实例来处理与客户端的通信。要创建一个服务器套接字，需要指定其主机名和监听的端口号。服务器套接字还有一个重要属性是backlog，表示在服务器在拒绝接受传入的请求之前，传入的连接请求的最大队列长度。ServerSocket类的实例化方式之一如下：

 

[java] view plaincopyprint?
  1. new ServerSocket(8080, 1, InetAddress.getByName("127.0.0.1")); 
new ServerSocket(8080, 1, InetAddress.getByName("127.0.0.1"));
创建了ServletSocket实例后，可以使其等待传入的连接请求，该链接请求会通过服务器套接字侦听的端口上绑定地址传入。这些工作可以通过调用ServerSocket类的accept方法完成。只有当接收到连接请求时，该方法才会返回，返回值是一个Socket实例。

 

 

Web服务器应用程序实例如下：

1.Request类：

 

[java] view plaincopyprint?
  1. package com.demo.tomcat;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  6. publicclass Request {
  7. /**
  8. * 从Socket中读取数据的缓冲区大小
  9. */
  10. privatestaticfinalint SOCKET_BUFFER_SIZE = 1024;
  11. /**
  12. * 输入流（通过与客户端通信Socket中获取）
  13. */
  14. private InputStream input;
  15. /**
  16. * Http请求的URI
  17. */
  18. private String uri;
  20. /**
  21. * Constructor
  22. * @param input 输入流
  23. */
  24. public Request(InputStream input){
  25. this.input = input;
  26. }
  27. /**
  28. * 解析Http请求的原始数据（例如,GET请求index.html的请求行为:"GET /index.html HTTP/1.1）
  29. */
  30. publicvoid parse(){
  31. //读取Socket中的数据
  32. StringBuffer sb = new StringBuffer(SOCKET_BUFFER_SIZE);
  33. int i;
  34. byte[] buf = newbyte[SOCKET_BUFFER_SIZE];
  35. try {
  36. i = input.read(buf);
  37. for(int j = 0; j < i; j++){
  38. sb.append((char) buf[j]);
  39. }
  40. } catch (IOException e) {
  41. e.printStackTrace();
  42. }
  43. //解析URI
  44. if(sb.length() > 0){
  45. uri = parseURI(sb.toString());
  46. }
  47. }
  49. /**
  50. * 获取请求的URI
  51. * @param requestStr
  52. * @return
  53. */
  54. private String parseURI(String requestStr){
  55. if(requestStr == null || requestStr.length() <= 0){
  56. returnnull;
  57. }
  58. int index1,index2;
  59. index1 = requestStr.indexOf(' ');
  60. if(index1 != -1){
  61. index2 = requestStr.indexOf(' ', index1 + 1);
  62. if(index2 > index1){
  63. //截取字符串并返回
  64. return requestStr.substring(index1 + 1, index2);
  65. }
  66. }
  67. returnnull;
  68. }
  70. public String getUri() {
  71. return uri;
  72. }
  73. } 
package com.demo.tomcat;

import java.io.IOException;
import java.io.InputStream;

public class Request {
    /**
     * 从Socket中读取数据的缓冲区大小
     */
    private static final int SOCKET_BUFFER_SIZE = 1024;
    /**
     * 输入流（通过与客户端通信Socket中获取）
     */
    private InputStream input;
    /**
     * Http请求的URI
     */
    private String uri;

    /**
     * Constructor
     * @param input 输入流
     */
    public Request(InputStream input){
        this.input = input;
    }
    /**
     * 解析Http请求的原始数据（例如,GET请求index.html的请求行为:"GET /index.html HTTP/1.1）
     */
    public void parse(){
        //读取Socket中的数据
        StringBuffer sb = new StringBuffer(SOCKET_BUFFER_SIZE);
        int i;
        byte[] buf = new byte[SOCKET_BUFFER_SIZE];
        try {
            i = input.read(buf);
            for(int j = 0; j < i; j++){
                sb.append((char) buf[j]);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //解析URI
        if(sb.length() > 0){
            uri = parseURI(sb.toString());
        }
    }

    /**
     * 获取请求的URI
     * @param requestStr
     * @return
     */
    private String parseURI(String requestStr){
        if(requestStr == null || requestStr.length() <= 0){
            return null;
        }
        int index1,index2;
        index1 = requestStr.indexOf(' ');
        if(index1 != -1){
            index2 = requestStr.indexOf(' ', index1 + 1);
            if(index2 > index1){
                //截取字符串并返回
                return requestStr.substring(index1 + 1, index2);
            }
        }
        return null;
    }

    public String getUri() {
        return uri;
    }
}

 

2.Response类：

 

[java] view plaincopyprint?
  1. package com.demo.tomcat;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  9. publicclass Response {
  10. /**
  11. * 读取数据缓冲区大小
  12. */
  13. privatestaticfinalint BUFFER_SIZE = 1024;
  14. /**
  15. * 请求
  16. */
  17. private Request request;
  18. /**
  19. * 输出流
  20. */
  21. private OutputStream output;
  23. /**
  24. * Constructor
  25. * @param output 输出流
  26. */
  27. public Response(OutputStream output){
  28. this.output = output;
  29. }
  31. publicvoid setRequest(Request request){
  32. this.request = request;
  33. }
  35. /**
  36. * 发送一个静态资源到浏览器
  37. * @throws Exception
  38. */
  39. publicvoid sendStaticResource() throws Exception {
  40. //读取静态资源
  41. byte[] bytes = newbyte[BUFFER_SIZE];
  42. FileInputStream fis = null;
  43. try {
  44. File file = new File(HttpServer.WEB_ROOT, request.getUri());
  45. if(file.exists()){//文件存在
  46. fis = new FileInputStream(file);
  47. //读取静态资源到缓冲区
  48. int ch = fis.read(bytes, 0, BUFFER_SIZE);
  49. while( ch != -1){
  50. output.write(bytes, 0, ch);
  51. ch = fis.read(bytes, 0, BUFFER_SIZE);
  52. }
  53. } else {
  54. String errorMessage = "HTTP/1.1 404 File Not Found\r\n" +
  55. "Content-Type: text/html\r\n" +
  56. "Content-Length: 23\r\n" +
  57. "\r\n" +
  58. "<h1>File Not Found</h1>";
  59. //发送错误信息
  60. output.write(errorMessage.getBytes());
  61. }
  62. } catch (IOException e) {
  63. e.printStackTrace();
  64. } finally {
  65. fis.close();
  66. }
  68. }
  69. } 
package com.demo.tomcat;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;


public class Response {
    /**
     * 读取数据缓冲区大小
     */
    private static final int BUFFER_SIZE = 1024;
    /**
     * 请求
     */
    private Request request;
    /**
     * 输出流
     */
    private OutputStream output;

    /**
     * Constructor
     * @param output 输出流
     */
    public Response(OutputStream output){
        this.output = output;
    }

    public void setRequest(Request request){
        this.request = request;
    }

    /**
     * 发送一个静态资源到浏览器
     * @throws Exception
     */
    public void sendStaticResource() throws Exception {
        //读取静态资源
        byte[] bytes = new byte[BUFFER_SIZE];
        FileInputStream fis = null;
        try {
            File file = new File(HttpServer.WEB_ROOT, request.getUri());
            if(file.exists()){//文件存在
                fis = new FileInputStream(file);
                //读取静态资源到缓冲区
                int ch = fis.read(bytes, 0, BUFFER_SIZE);
                while( ch != -1){
                    output.write(bytes, 0, ch);
                    ch = fis.read(bytes, 0, BUFFER_SIZE);
                }
            } else {
                String errorMessage = "HTTP/1.1 404 File Not Found\r\n" +
                        "Content-Type: text/html\r\n" +
                        "Content-Length: 23\r\n" +
                        "\r\n" +
                        "<h1>File Not Found</h1>";
                //发送错误信息
                output.write(errorMessage.getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            fis.close();
        }

    }
}

 

3.HttpServer类：

 

[java] view plaincopyprint?
  1. package com.demo.tomcat;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.OutputStream;
  7. import java.net.InetAddress;
  8. import java.net.ServerSocket;
  9. import java.net.Socket;
  12. publicclass HttpServer {
  13. /**
  14. * 访问的根路径
  15. */
  16. publicstaticfinal String WEB_ROOT = System.getProperty("user.dir") + File.separator + "webroot";
  17. /**
  18. * 关闭服务请求命令
  19. */
  20. publicstaticfinal String SHUTDOWN_COMMAND = "/SHUTDOWN";
  21. /**
  22. * 是否关闭服务
  23. */
  24. private Boolean shutdown = false;
  26. publicstaticvoid main(String[] args){
  27. HttpServer httpServer = new HttpServer();
  28. httpServer.await();
  29. }
  31. /**
  32. * 从accept方法返回的Socket中获取InputStream对象和OutputStream对象
  33. */
  34. publicvoid await(){
  35. //创建ServerSocket对象
  36. ServerSocket serverSocket = null;
  37. //监听端口
  38. int port = 8080;
  39. try {
  40. //实例化ServerSocket对象
  41. serverSocket = new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
  42. } catch (IOException e) {
  43. e.printStackTrace();
  44. System.exit(1);
  45. }
  46. while(!shutdown){
  47. Socket socket = null;
  48. InputStream input = null;
  49. OutputStream output = null;
  51. try {
  52. socket = serverSocket.accept();
  53. input = socket.getInputStream();
  54. output = socket.getOutputStream();
  55. //创建并解析request
  56. Request request = new Request(input);
  57. request.parse();
  58. //创建response，发送静态资源给浏览器
  59. Response response = new Response(output);
  60. response.setRequest(request);
  61. response.sendStaticResource();
  62. //关闭socket
  63. socket.close();
  64. //是否关闭服务
  65. shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
  66. } catch (Exception e) {
  67. e.printStackTrace();
  68. }
  69. }
  70. }
  71. } 
package com.demo.tomcat;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;


public class HttpServer {
    /**
     * 访问的根路径
     */
    public static final String WEB_ROOT = System.getProperty("user.dir") + File.separator + "webroot";
    /**
     * 关闭服务请求命令
     */
    public static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
    /**
     * 是否关闭服务
     */
    private Boolean shutdown = false;

    public static void main(String[] args){
        HttpServer httpServer = new HttpServer();
        httpServer.await();
    }

    /**
     * 从accept方法返回的Socket中获取InputStream对象和OutputStream对象
     */
    public void await(){
        //创建ServerSocket对象
        ServerSocket serverSocket = null;
        //监听端口
        int port = 8080;
        try {
            //实例化ServerSocket对象
            serverSocket = new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
        while(!shutdown){
            Socket socket = null;
            InputStream input = null;
            OutputStream output = null;

            try {
                socket = serverSocket.accept();
                input = socket.getInputStream();
                output = socket.getOutputStream();
                //创建并解析request
                Request request = new Request(input);
                request.parse();
                //创建response，发送静态资源给浏览器
                Response response = new Response(output);
                response.setRequest(request);
                response.sendStaticResource();
                //关闭socket
                socket.close();
                //是否关闭服务
                shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

 

注意：需要在项目所在的路径下添加一个名为"webroot"的文件夹，该文件夹下放置你要访问你的文件（如test.txt），输入相应的URI（如http://lcoalhost:8080/test.txt），即可访问到该资源文件。

参考：深入剖析Tomcat第一章

分享到：
| 小记wsdl2java
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    简单Web服务器设计与实现.doc

    课程设计的内容包括熟悉WWW服务器和WEB服务器的工作原理、熟悉套接字编程的相关知识、完成一个简单的WEB服务器的设计与实现、运行该服务器，并编写一个简单的HTML文件完成测试。 课程设计要求包括按要求编写课程...

    易语言简易WEB服务器源码.rar

    【标题】"易语言简易WEB服务器源码.rar" 指的是一款基于易语言开发的简单Web服务器的源代码资源。易语言是中国本土设计的一种编程语言，它以其独特的汉字编程方式，降低了编程的门槛，使得非计算机专业人员也能快速...

    易语言简易WEB服务器

    易语言简易WEB服务器是一款基于易语言开发的简单网络服务器软件，主要目标是为初学者提供一个学习和理解HTTP协议、网络编程以及服务器构建基础的平台。这个源码可以帮助开发者了解如何处理HTTP请求，如何响应客户端...

    VB6.0编写的简易WEB服务器

    VB6.0编写的简易WEB服务器是一个非常适合初学者入门网络编程的项目。VB6.0（Visual Basic 6.0）是微软推出的一种可视化编程工具，以其易学易用的特性，深受程序员喜爱。在这个项目中，我们将探讨如何利用VB6.0构建一...

    简单搭建WEB服务器 简单搭建WEB服务器 简单搭建WEB服务器

    本文将详细介绍如何简单搭建一个WEB服务器，包括基础概念、所需工具及步骤，旨在帮助初学者快速入门。 一、Web服务器的基础概念 1. HTTP：HTTP是互联网上应用最为广泛的一种网络协议，用于从万维网服务器传输超文本...

    简易个人WEB服务器

    【简易个人WEB服务器】 在数字化时代，个人网页和网站已经成为表达自我、分享信息的重要平台。...总的来说，“简易个人WEB服务器”为非专业人士提供了一个便捷的Web服务解决方案，使得互联网的使用更加亲民和有趣。

    Web服务器的工作原理

    Web服务器的工作原理 Web服务器的工作原理 Web服务器的工作原理 Web服务器的工作原理 Web服务器的工作原理 Web服务器的工作原理 Web服务器的工作原理 Web服务器的工作原理 Web服务器的工作原理 Web服务器的工作原理 ...

    WEB服务器、应用程序服务器、HTTP服务器区别

    IIS、Apache、Tomcat、Weblogic、WebSphere 都是不同的服务器， Apache 是纯粹的 Web 服务器，Tomcat 是一个 Servlet 和 JSP 容器，可以作为轻量级应用服务器，IIS 是一个兼具应用服务器功能的 Web 服务器，Weblogic...

    简易WEB服务器（C++）

    【简易WEB服务器（C++）】是一个编程项目，旨在通过C++语言实现一个基础的互联网服务器，能够响应用户的HTTP请求并提供文件服务。这个项目主要关注网络编程和HTTP协议的理解，是学习网络通信和服务器开发的初级实践...

    简易静态Web服务器

    【简易静态Web服务器】是一个适合Java初学者的项目，它实现了最基本的Web服务器功能，只用于加载HTML文件。这个Web服务器的核心在于三个Java类：HttpServer、Request和Response，每个类都扮演着Web服务中关键角色。 ...

    超级简单的web服务器

    本篇文章将深入探讨一个被称为"超级简单的Web服务器"的概念，特别是针对那些希望快速分享本地文件而无需复杂配置的用户。 "超级简单的Web服务器"通常指的是那些轻量级、易于使用且快速部署的Web服务解决方案。它们...

    简易web服务器实现

    本篇文章将深入探讨如何实现一个简单的Web服务器，并基于给出的标题"简易web服务器实现"以及描述中的信息，我们将重点讲解Web服务器的基本概念、工作原理以及实现步骤。 一、Web服务器基本概念 Web服务器是一种运行...

    微型web服务器-单文件

    标题中的"微型web服务器-单文件"指出，这个软件仅由一个文件组成，这意味着它可能是一个高度精简的实现，无需复杂的安装过程，只需执行即可开始服务。 描述中提到，该服务器适用于“一般的web服务”，这可能意味着...

    简单的web服务器

    这个“简单的web服务器”项目旨在通过Java实现一个基础版的Web服务器，类似于流行的Tomcat服务器，它能够处理静态资源的请求。 【描述】：此项目的核心目标是提供一个基础的环境，使开发者能够快速地测试和部署静态...

    一个支持servlet的web服务器.rar

    这个压缩包“一个支持servlet的web服务器.rar”很可能包含了实现这一功能的源代码、配置文件或者是一个预编译好的服务器软件，允许开发者在本地环境中运行和测试Servlet应用。下面我们将深入探讨Servlet以及如何在...

    简易Web服务器.rar

    简易Web服务器.rar

    基于QT的轻量级web服务器

    【基于QT的轻量级web服务器】是一种在Linux环境下运行的、使用QT库开发的简易Web服务器。QT是一个跨平台的C++图形用户界面应用程序开发框架，它为开发者提供了丰富的API，使得构建桌面和移动应用变得更为便捷。在这...

    守望简单web服务器

    总的来说，【守望简单Web服务器】为个人和小团队提供了一个快速上手的Web服务解决方案，方便进行网站开发和测试。用户在使用过程中应遵循安全最佳实践，并结合其他资源进行学习，提升自己的Web技术能力。

    简单JAVA WEB服务器

    本项目“简单JAVA WEB服务器”旨在提供一个基础的平台，帮助学习者理解Java Web服务器的工作原理，特别是静态网页服务和JSP（Java Server Pages）的执行，以及Cookie的解析。 1. **多线程技术**：Java Web服务器...

    c#简单web服务器开发实例

    在本文中，我们将深入探讨如何使用C#语言开发一个简单的Web服务器，主要基于`HttpListener`组件。`HttpListener`是.NET Framework提供的一种基础网络通信类，它允许我们监听HTTP请求，并对这些请求做出响应。 首先...

Magicbox
Global site tag (gtag.js) - Google Analytics