java 手动写http静态网页服务器

最新推荐文章于 2023-05-02 23:34:05 发布
最新推荐文章于 2023-05-02 23:34:05 发布
阅读量2.2k 收藏 3
点赞数 1
分类专栏： java 文章标签： http服务器 java

本文仅仅是实现一个功能非常有限的http服务器。我仅仅实现了请求一个html和请求一个jpg图片。方式只支持GET。不支持http选项。错误代码仅仅会返回200 400 404.支持xml对服务器的配置。本博客内容仅仅完全处于自身娱乐，高手可直接略过。

实现思想

1用java的sax解析服务器配置文件。确定web服务器的root目录，和web服务器运行的端口号。
2启动一个serverSocket等待链接
3获取一个链接之后把所获得的socket传递给新的httpSolver线程。httpSolver负责解析客户端发来的http请求头。
4如果httpSolver根据服务器请求的文件建立一个HttpMessage类。这个类封装了http请求的消息，包括请求的文件，root目录等等。这个httpMessage传递给GetDisk类
5GetDisk负责从硬盘读取。如果java发现请求的文件不在，那么在返回404.如果请求文件成功那么构造消息头返回200在返回锁请求文件。
6httpSolver关闭socket结束一个回话。

工程文件管理方式

这里写图片描述

xml配置文件

server.xml

?
1
2
3
4
5
6
<code class = "language-xml" hljs= "" ><!--?xml version= 1.0 encoding=UTF- 8 ?-->
 
<server>
     <port> 80 </port>
     <root>d:Root</root>
</server></code>

server.dtd

?
1
2
3
4
5
<code class = "language-xml" hljs= "" ><!--?xml version= 1.0 encoding=UTF- 8 ?-->
 
<!--ELEMENT server (port,root?)-->
<!--ELEMENT port (#PCDATA)-->
<!--ELEMENT root (#PCDATA)--></code>

Main.java

Main.java

?
1
2
3
4
5
6
7
8
9
<code class = "language-java" hljs= "" > package httpServer;
 
public class Main {
     public static void main(String args[])
     {
         ServerClass myServer= new ServerClass();
         myServer.serverStart();
     }
}</code>

ServerClass.java

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
<code class = "language-java" hljs= "" > public class ServerClass {
     private ServerSocket serverSocket;
     private String root;
     private boolean runing;
     private int port;
     public ServerClass()
     {
         runing= false ;
         SAXParserFactory saxpf=SAXParserFactory.newInstance();
         SAXParser saxParser;
 
         try (InputStream in= new FileInputStream(server.xml))
         {
             saxParser=saxpf.newSAXParser();
             saxParser.parse(in, new Handler());        
         }
         catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             System.out.println(server.xml no find);
             e.printStackTrace();
 
         }
         catch (Exception e) {
             // TODO Auto-generated catch block
             System.out.println(parse server.xml error);
             e.printStackTrace();
 
         }
 
     }
 
 
     public void serverStart()
     {
         try {
             serverSocket= new ServerSocket(port);
         } catch (IOException e) {
             // TODO Auto-generated catch block
             System.out.println(ServerSocket cann't establish);
             e.printStackTrace();
         }
         runing= true ;
         System.out.println(System is runing);
         while (runing)
         {
             try {
                 Socket incomingSocket=serverSocket.accept();
 
 
                 new Thread( new requestHandler(incomingSocket,root)).start();
 
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             System.out.println(System deal one request);
         }
         System.out.println(System is down);
     }
 
     public void shutDown()
     {
         runing= false ;
     }
 
     private class Handler extends DefaultHandler
     {
             //单独介绍
     }
}</code>

上面的代码就是调用xml解析工具对服务器的一些基本的内容进行设置。因为我们只对配置文件进行读取操作,所以我们可以简单的使用sax作为简单的解析工具.不用使用dom.之后创建一个serversocket等待链接。
在serverclass里面有一个私有的内部嵌套类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
<code class = "language-java" hljs= "" > private class Handler extends DefaultHandler
     {
         private boolean isPort;
         private boolean isRoot;
         public Handler()
         {
             super ();
             isPort= false ;
             isRoot= false ;
 
         }
 
 
         @Override
         public void characters( char [] ch, int start, int length)
                 throws SAXException {
 
             super .characters(ch, start, length);
             String temp= new String(ch,start,length);
 
             if (isPort)
             {
 
                 port=Integer.parseInt(temp);
                 isPort= false ;
             }
             else if (isRoot)
             {
 
                 root=temp;
                 isRoot= false ;
             }
         }
 
 
         @Override
         public void startElement(String uri, String localName, String qName,
                 Attributes attributes) throws SAXException {
 
             super .startElement(uri, localName, qName, attributes);
             if (qName.equals(port))
             {
                 isPort= true ;
             }
             else if (qName.equals(root))
             {
                 isRoot= true ;
             }
             else if (qName.equals(server))
             {
                 //不操作
             }
             else
             {
                 System.out.println(error xml element);
             }
 
         }
</code>

这个类是用于处理sax解析过程的.因为sax在解析的时候是事件回调的方式.我们要重载DefaultHandler里面的函数.sax在解析的过程中,如果碰到element那么久调用startElement函数,并且把元素等等的名字作为参数传递到里面.当一个element结束的时候调用endElement函数.DefaultHandler里面的各个函数都是空操作.所以我们要进行重载来实现我们想要的操作.私有变量isroot等等是因为在进入元素的时候sax统一调用startElement,碰到里面的值得时候比如 < root > D: oot < / root >在碰到D: oot 的时候会调用characters。但是我们怎么知道D: oot是给root的？就是设置一个isroot变量。表示现在的在处理root元素。把里面的值给root。因为其他的元素比如< port > 80 < / port >碰到80的时候同样会调用characters。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<code class = "language-java" hljs= "" >
  class requestHandler implements Runnable
{
     Socket incomingSocket;
     String root;
     public requestHandler(Socket incomingSocket,String root) {
         this .incomingSocket=incomingSocket;
         this .root=root;
     }
     @Override
     public void run() {
         new httpSolver(incomingSocket,root).serve();
     }
 
 
}</code>

这个主要是为了建立一个线程.用于同时处理很多很多请求.

httpSolver.java

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
<code class = "language-java" hljs= "" > public class httpSolver {
     Socket incomingSocket;
     String root;
     public httpSolver(Socket incomingSocket,String root) {
         this .incomingSocket=incomingSocket;
         this .root=root;
     }
 
     public void serve()
     {
 
         Scanner in= null ;
 
         OutputStream out= null ;
         try {
             in= new Scanner(incomingSocket.getInputStream());
//          out=new PrintWriter(incomingSocket.getOutputStream(),true);
             out=incomingSocket.getOutputStream();
             HttpMessage httpMessage= new HttpMessage();
             httpMessage.root=root;
             while (in.hasNextLine())
             {
                 String input=in.nextLine();
 
                 String splitResult[]= null ;
                 if (input.startsWith(GET)||input.startsWith(get))
                 {
                     splitResult=input.split( new String( ));
 
                     if (!splitResult[ 2 ].equals(HTTP/ 1.1 ))
                     {
                         new badRequest().work(out);
                         incomingSocket.close();
                         break ;
                     }
                     if (splitResult[ 1 ].equals(/))
                     {
                         httpMessage.targetFile=index.html;
                     }
                     else
                     {
                         httpMessage.targetFile=splitResult[ 1 ].substring( 1 ,splitResult[ 1 ].length());
                     }
                 }
                 else
                 {
                     splitResult=input.split( new String(:));
                     switch (splitResult[ 0 ]) {
                     case If-Modified-Since:
                         httpMessage.If_Modified_Since= true ;
                         httpMessage.If_Modified_SinceString=splitResult[ 1 ];
                         break ;
                     case :
                         new GetDisk(httpMessage).work(out);
                         incomingSocket.close();
                         break ;
                     default :
 
                         break ;
 
 
                     }
 
                 }
 
 
             }
 
         }          
         catch (IOException e) {
             // TODO Auto-generated catch block
             System.out.println(socket io exception);
             e.printStackTrace();
         }
         finally
         {
             try
             {
                 if (in!= null )
                 {
                     in.close();
                 }
                 if (out!= null )
                 {
                     out.close();
                 }
 
             }
             catch (Exception e)
             {
                 e.printStackTrace();
             }
         }
 
     }
}
</code>

这里面包括了一主要的读取循环。不断读取客户端发来的信息。通过解析字符串发现客户端请求的是什么。我们把消息封装到一个HttpMessage里面。这样便于消息的传递，可以把客户端传来的信息都放到HttpMessage里面传递给其他的处理类，比如GetDisk用于读入文件。HttpMessage可以理解为C语言里面的结构体

HttpMessage.java

?
1
2
3
4
5
6
7
<code class = "language-java" hljs= "" > //HttpMessage.java
public class HttpMessage {
     public String root;
     public String targetFile;
     public  boolean If_Modified_Since= false ;
     public String If_Modified_SinceString= null ;
}</code>

GetDisk.java

这个类主要处理从磁盘读取文件。并且把应该返回的http头和http内容都拼装起来。其实这里可以使用 原型设计模式 但是我这里只有几个返回形式。所以直接写在了代码里。但这样对代码维护会造成困难。为了便于加快文件的读取速度。读入输出都是使用二进制方式进行。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
<code class = "language-java" hljs= "" > public class GetDisk
{
     private HttpMessage httpMessage;
     private StringBuilder result;
     private Path path;
     public GetDisk(HttpMessage httpMessage)
     {
         result= new StringBuilder();
         this .httpMessage=httpMessage;
 
         path=Paths.get( this .httpMessage.root, this .httpMessage.targetFile);
 
     }
 
     public void work(OutputStream out)
     {
 
         if (!Files.exists(path))
         {
             result.append(HTTP/ 1.1 404 Not Found
Connection: close
);
             result.append(
);
 
             try {
                 out.write(result.toString().getBytes());
                 out.flush();
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             return ;
 
         }
 
 
         byte [] fileContents= null ;
         try {
             fileContents=Files.readAllBytes(path);
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
          if (fileContents!= null )
         {
             result.append(HTTP/ 1.1 200 OK
);
             if (httpMessage.targetFile.endsWith(html))
             {
                 result.append( Content-Type: text/html; charset=utf- 8
);
             }
             else if (httpMessage.targetFile.endsWith(jpg))
             {
                 result.append( Content-Type: image/jpeg
);
             }
             result.append( Keep-Alive: - 1
);
 
 
             result.append(
);
 
             try {
                 out.write(result.toString().getBytes());
                 out.write(fileContents);
                 out.flush();
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
 
         }  
 
 
         return ;
 
     }
}</code>

badRequest.java

主要返回无法解析的指令错误。其实我们可以把每个返回代码的处理过程都实现为一个类。然后这些类都共同的继承一个超类。在超类中实现写好http返回头。然后参数有个个子类给出就是使用模板设计模式。方便代码的管理。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<code class = "language-java" hljs= "" > public class badRequest {
     StringBuilder result;
     public badRequest()
     {
         result= new StringBuilder();
     }
     public void work(OutputStream out)
     {
 
             result.append(HTTP/ 1.1 400 bad request
Connection: close
);
             result.append(
);
 
             try {
                 out.write(result.toString().getBytes());
                 out.flush();
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             return ;
 
 
     }
}</code>
长夜悠悠
关注
专栏目录
Java写一个简单的静态文件的HTTP服务器（基于Socket）
zhaohong_bo的专栏
04-25 2649
** 一、实现思路 ** 1、使用 ServerSocket 监听某一端口，然后等待连接获取 Socket对象。 2、创建一个类 HttpServer 继承 java.lang.Thread 类，重写 run()方法，执行浏览器请求。 3、获得浏览器请求，解析资源文件路径。 4、读取资源文件，响应给浏览器。 ** 二、代码实现 ** 1、ServerSocket 监听端口，获取...
JAVA实现简单的http静态网页服务器
03-20
NULL 博文链接：https://xiaomy.iteye.com/blog/798156
java：静态web服务器（实现http）
03-23
java实现HTTP服务器，从浏览器返回两个int参数，实现加和，并返回结果在浏览器
Java实现简单静态-动态http服务器
Jeffrey_oWang的博客
08-11 1102
编写静态-动态http服务器 用例图： 实现需求： 实现静态-动态服务器的目的是为了更深的理解HTTP协议和Servlet 底层原生的原理。 实现描述： ​ 用户通过浏览器提交一个http 请求到指定的服务器的启动端口，在HttpServer 中，Java通过Socket 封装好得到http的请求流和响应流，通过HttpPrase方法将Http请求流封装成HttpRequest 对象，然后读取指定目录中的html,css,js 文件，转换为文件流，通过响应流封装好的HttpResponse 对象将数据返
纯java写的web服务器
02-17
"纯Java写的web服务器"是指完全使用Java语言实现的Web服务器，它能够处理HTTP请求并返回响应，为用户提供网页服务。这种服务器的核心原理是基于Java的Socket编程，通过创建服务器端套接字监听客户端的连接请求，然后...
Java Web应用开发 03 课堂案例-认知静态网页和动态网页.docx
07-13
在Java Web应用开发中，理解和区分静态网页与动态网页是至关重要的。静态网页和动态网页在性质、功能和实现方式上有着显著的区别。 首先，静态网页是指其内容固定不变的网页，不会根据用户的特定需求或交互行为而...
java动态生成静态网页技术
09-10
然而，在数据经常更新的场景下，手动维护这些静态网页变得既低效又不切实际。因此，采用Java程序动态生成静态网页成为了一种高效且灵活的解决方案。本文将详细介绍如何使用Java实现动态生成静态网页的技术，并通过一...
在java中写出html代码,在java里写html代码
weixin_39830588的博客
07-10 3087
在java里写html代码[2021-02-09 07:31:38]简介:php去除nbsp的方法：首先创建一个PHP代码示例文件；然后通过“preg_replace("/(\s|\&nbsp\;|　|\xc2\xa0)/", " ", strip_tags($val));”方法去除所有nbsp即可。推荐：《PHP视频教jquery输出html代码的方法：1、直接输出标签元素，代码为【...
Java socket实现静态网页服务器（50行代码）
qq_41294444的博客
09-22 1219
客户端： 使用你的浏览器 服务器： 需要自己准备静态html网页，网页放在项目根目录下（写过java的应该都不需要看这句话） package com.wenba1314.socket; import java.io.*; import java.net.ServerSocket; import java.net.Socket; public class ServerToBrowser...
简单的JAVA HTML服务器
10-19
简单的JAVA HTML服务器 实现原理为采用Socket原理、线程池、输入输出流及简单的HTTP协议，麻烦虽小，五脏俱全，只有两个类文件。 使用方法，在DOS窗口下，转到当前HTMLJAR所在目录，打入如下命令： java -Djava.ext.dirs=. httpserver.HttpServer [HTML服务所在路径] [端口] HTML服务所在路径及端口参数是可选的，路径默认路径为当前应用所在路径，默认端口为1234，首页文件可为index.html或 index.html 启动好后，找一个html文件放在当前目录下，重命名为index.html，打开浏览器，输入：http://localhost:1234，即可以返回该页面. JAR编译的JDK版本1.6，至少要JDK1.5以上，因为其中用到JDK自带的线程池，内附源码，用户可以自已将源码再打包。 下载路径为：
java 静态页面开发
11-26
java中有的不需要与后台联动，只需开发静态页面，改资料提供了样板案例，并附有代码，方便调试，只需在原有基础上开发，修改
java web静态网页制作代码
09-30
我的第一个静态网页代码关于软件工程师在线报名的静态网页
Java 编写一个简单的 HTTP 服务器，用于提供静态网页文件
最新发布
m0_74288422的博客
05-02 320
然后，我们进入一个无限循环，在每次迭代中接受一个客户端连接，并读取其请求。我们从请求中提取文件路径，并尝试打开该文件以读取其内容。在上面的代码中，我们定义了一个名为 HTTPServer 的类，它使用 Java 的 Socket API 实现了一个简单的 HTTP 服务器。最后，我们将响应发送回客户端，并关闭连接。在发送响应之前，我们需要将响应内容转换为字节数组，并计算内容长度和响应头部分。要运行此代码，请将其保存在名为 HTTPServer.java 的文件中，并将 www/ 目录中的静态。
java 获取静态页面_Java Jsoup 抓取静态网页
weixin_35879114的博客
02-28 520
一，简介Jsoup：jsoup 是一款Java 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。因为需要我要爬取数据，结果发现单独 jsoup 只能解析静态的html 文件，对于动态的js加载的HTML 无法获取，这就有很大的局限性。但是一般也只是把jsoup 当作一个解析HTML的工...
用原生Java写一个静态资源服务器
weixin_43074462的博客
07-12 639
使用JDK自带的HttpServer实现文件下载功能
简单的Java服务器功能——实现静态页面的访问
wxinyong的博客
11-02 2595
用Java语言实现一个简单的服务器，能够实现静态HTML页面的访问
Netty源码分析-HttpObjectDecoder
大新博客
04-27 1736
/* * Copyright 2012 The Netty Project * * The Netty Project licenses this file to you under the Apache License, * version 2.0 (the "License"); you may not use this file except in compliance *...
java 静态服务器配置_JavaEE开发之SpringMVC中的静态资源映射及服务器推送技术
weixin_30722591的博客
02-16 308
在上篇博客中，我们聊了《SpringMVC的东西，下方我们将会聊到js、css这些静态文件的加载配置，以及服务器推送的两种实现方式。当然我们在服务器推送时，会用到JQuery的东西，所以我们先聊一下如何加载静态资源文件，然后我们再聊如何实现服务器推送。下方给出了两种实现服务器推送的方式，一种是SSE(Server Send Event (服务端推送事件))另一种是基于Servlet异步处理的推送，...
华为云鲲鹏服务器Java微服务部署实战指南
"华为云鲲鹏服务器部署文档是针对中电高科V5.12版本，详述了在华为云鲲鹏服务器上部署Java微服务的环境搭建过程。文档覆盖了CentOS 7.6 64位ARM版本的操作，包括JDK、maven、cmake、gcc、node.js、zookeeper、redis...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值