自己实现一个简单的支持并发的Web服务器

小鱼儿 2022-08-21 04:56 260阅读 0赞

前面我们自己实现了一个线程池，现在我们基于前面编写的线程池(http://blog.csdn.net/canot/article/details/50904001)编写一个支持并发访问的Web服务器来处理一些简单的HTTP请求/响应。

  1. public class SimpleHttpServer {
  3.     //定义处理HttpRequest的线程池 
  4.     static ThreadPool<HttpRequestHandler> threadPool = new DefaultThreadPool<HttpRequestHandler>();
  5.     static ServerSocket serverSocket;
  6.     //该Web服务器的路径
  7.     static String basePath;
  8.     //默认的端口号
  9.     static int port = 8080;
  10.   //启动服务器
  11.     public static void start() throws IOException {
  12.         serverSocket = new ServerSocket(port);
  13.         Socket client = null;
  14.         //获取客户端的连接
  15.         while ((client = serverSocket.accept()) != null) {
  16.             //生成一个job放入线程池执行
  17.             threadPool.execute(new HttpRequestHandler(client));
  18.         }
  19.         serverSocket.close();
  20.     }
  22.     static class HttpRequestHandler implements Runnable {
  24.         private Socket client;
  26.         public HttpRequestHandler(Socket client) {
  27.             this.client = client;
  28.         }
  30.         public void run() {
  31.             byte[] buff = new byte[1024];
  32.             BufferedReader br = null;
  33.             PrintWriter pw = null;
  34.             File directory = new File("");
  35.             String basePath = directory.getAbsolutePath();
  36.             int length = 0;
  37.             try {
  38.                 //读取客户端发送的请求数据
  39.                 br = new BufferedReader(new InputStreamReader(client.getInputStream()));
  40.                 //获取请求行的第一行再解析出要请求的资源
  41.                 String header = br.readLine();
  42.                 String filePath = header.split(" ")[1];
  43.                 //判断请求的资源的为html
  44.                 if(filePath.endsWith("html")){
  45.                 pw = new PrintWriter(client.getOutputStream());
  46.                 //构造HTTP响应头信息
  47.                 pw.println("HTTP/1.1 200 Ok");
  48.                 pw.println("Server: wangxiServer");
  49.                 pw.println("Content-Type: text/html;charset=UTF-8");
  50.                 pw.println("");
  51.                 //通过io流读取访问的资源，然后输出给客户端
  52.                 InputStream is = new FileInputStream(new File(basePath,filePath));
  53.                 while((length=is.read(buff))>0){
  54.                     pw.println(new String(buff,0,length));
  55.                 }
  56.                 pw.flush();
  57.                 //判断请求的资源的为jpg
  58.                 }else if(filePath.endsWith("jpg")){
  59.                     //获取要访问的图片流，把流的数据全部存在ByteArrayOutputStream中
  60.                     ByteArrayOutputStream bos = new ByteArrayOutputStream();
  61.                     InputStream is = new FileInputStream(new File(basePath,filePath));
  62.                     while((length=is.read(buff))>0){
  63.                         bos.write(buff, 0, length);
  64.                     }
  65.                     byte[] image  = bos.toByteArray();
  66.                     //构造HTTP响应头,输出给客户端
  67.                     pw = new PrintWriter(client.getOutputStream());
  68.                     pw.println("HTTP/1.1 200 Ok");
  69.                     pw.println("Server: wangxiServer");
  70.                     pw.println("Content-Type: image/jpeg");
  71.                     pw.println("Content-Length:"+image.length);
  72.                     pw.println("");
  73.                     //输出图片流
  74.                     client.getOutputStream().write(image, 0, image.length);
  75.                 }else{
  76.                     pw.println("HTTP/1.1 200 Ok");
  77.                     pw.println("Server: wangxiServer");
  78.                     pw.println("Content-Type: text/html;charset=UTF-8");
  79.                     pw.println("");
  80.                     pw.println("404 No Found");
  81.                     pw.flush();
  82.                 }
  83.             } catch (IOException e) {
  84.                 // TODO Auto-generated catch block
  85.                 e.printStackTrace();
  86.             }
  88.         }
  90.     }
  91. }

启动该服务器:

  1. public class TestMyService {
  3.     public static void main(String[] args) {
  4.         try {
  5.             SimpleHttpServer.start();
  6.         } catch (IOException e) {
  7.             // TODO Auto-generated catch block
  8.             e.printStackTrace();
  9.         }
  10.     }
  11. }

SimpleHttpServer在建立起与客户端的连接之后，并不会直接处理客户端的请求，而是把其封装成HttpRequestHandler并交给线程池处理。在线程池中则由Worker处理客户端请求的同时，SimpleHttpServer能够继续完成后续客户端连接的建立，并不会阻塞后续客户端的请求。

在该项目的根目录下建立a.html,并放置图片1.jpg:

  1. <html>
  2. <head>
  3.     <title></title>
  4. </head>
  5. <body>
  6.    <img src="http://localhost:8080/1.jpg"></img>
  7. </body>
  8. </html>

在浏览器中输入http://localhost:8080/a.html可以看到图片正常显示，则完成了处理html和jpg的HTTP请求。

发表评论

表情：
评论列表 （有 0 条评论，260人围观）

还没有评论，来说两句吧...

相关阅读

    相关 一个简单web服务器的java实现

    一个简单的web服务器在不考虑其性能及健壮性的情况下，通常只需实现的功能包括服务器的启动，它用于监听某一个端口，接收客户端发来的请求，并将响应结果返回给客户端。本文将介绍一个简

    Dear 丶Dear 丶/ 0 赞/ 509 阅读