网络编程（一）——浅析web服务器与浏览器的实现原理_web服务器和浏览器安全设置原理(1)

那顺道就来简单的看一下，所谓的Web服务器(例如知名的Tomcat)与浏览器，基本的实现原理是什么样的呢？

首先可以明确的就是，例如我们所做的通过浏览器输入一个地址，访问一个网页的操作。

实际对应的底层操作简单来说就是：客户端(浏览器)面向于WEB服务器的网络通信。

那么，既然是网络通信。对应于Java当中来说，就自然离不开Socket与IO流。其实这也正是Web服务器与浏览器的基础实现原理。

当然，想要开发一套完善的WEB服务器或浏览器，需要做的工作是很复杂的。但这里，我们想要了解的，只是其原理。

我们知道，将开发的web项目部署到tomcat服务器之后，就可以通过浏览器对服务器上的资源进行访问。

但重要的一点是，存在多种不同厂商开发的不同浏览器。但各个类型的WEB浏览器，都可以正常的访问tomcat服务器上的资源。

对此，我们可以这样理解：我开发了一个WEB服务器，并且能够保证其他人开发的客户端都能够与我的服务器正常通信。

能够实现这样的目的的前提自然就是，你要制定一个规范，并让想要与你开发的服务器正常进行通信的客户端都遵循这个规范来实现。

这个规范，也就是所谓的协议。

所以，正如在网络通信中，数据的传输可以遵循TCP/IP或UDP协议一样。

WEB服务器与WEB浏览器之间，也通过一种双方都熟悉的语言进行通信。

这种协议即是：超文本传输协议，也就是HTTP协议。

不同的是，TCP/IP与UDP议是传输层当中的通信协议，而HTTP协议是应用层当中的协议。

所以，当我们想要使用Java语言实现所谓的WEB通信，自然也应当遵循HTTP协议。

Java中已经为我们提供了这样的一种实现规范，也就是广为人知的：Servlet接口。

而我们开发web项目时,最常用到的HttpServlet类，就是基于此接口实现的具体子类。

该类封装和提供了，针对基于Http协议通信的内容进行访问和操作的常用方法。

说了这么多，我们通过一些小的实例，方便进行更形象的理解。

首先，我们通过一段简单的Servlet代码来看一下，基于HTTP协议进行WEB通信的请求信息：

[java] 
view plain
 copy

1. public class ServletTest extends HttpServlet {
3. public void doGet(HttpServletRequest request, HttpServletResponse response)
4. throws ServletException, IOException {
5. for (Enumeration e = request.getHeaderNames(); e.hasMoreElements()😉 {
6. String header = (String) e.nextElement();
7. if (header != null)
8. System.out.println((new StringBuilder(String.valueOf(header)))
9. .append(“:”).append(request.getHeader(header))
10. .toString());
11. }
13. }
15. public void doPost(HttpServletRequest request, HttpServletResponse response)
16. throws ServletException, IOException {
18. }
20. }

上面的代码中，我们的目的是通过HttpSerlvetRequest当中的方法，

来打印web浏览器基于http协议发起的请求当中，封装的HTTP请求详情。程序输出的结果如下：

一个HTTP协议的请求中，通常主要包含三个部分：

• 方法/统一资源标示符(URI)/协议/版本
• 请求标头
• 实体主体

其中方法也就是所谓的get/post之类的请求方法，统一资源标示符也就是要访问的目标资源的路径，包括协议及协议版本，这些信息被放在请求的第一行。

随后，紧接着的便是请求标头；请求标头通常包含了与客户端环境及请求实体主体相关的有用信息。

最后，在标头与实体主体之间是一个空行。它对于HTTP请求格式是很重要的，空行告诉HTTP服务器，实体主体从这里开始。

前面已经说过了，我们这里想要研究的，是WEB服务器的基本实现原理。

那么我们自然想要自己来实现一下所谓的WEB服务器，我们已经知道了：

所谓的B/S结构，实际上就是客户端与服务器之间基于HTTP协议的网络通信。

那么，肯定是离不开socket与io的，所以我们可以简单的模拟一个最简易功能的山寨浏览器：

[java] 
view plain
 copy

1. public class MyTomcat {
2. public static void main(String[] args) {
3. try {
4. ServerSocket tomcat = new ServerSocket(9090);
5. System.out.println(“服务器启动”);
6. //
7. Socket s = tomcat.accept();
8. //
9. byte[] buf = new byte[1024];
10. InputStream in = s.getInputStream();
11. //
12. int length = in.read(buf);
13. String request = new String(buf,0,length);
14. //
15. System.out.println(request);
17. } catch (IOException e) {
18. // TODO Auto-generated catch block
19. e.printStackTrace();
20. }
21. }
22. }

这次我们在通过对应的URL在浏览器中对我们的山寨服务器进行访问，得到的输出结果是：

通过成果我们看到，我们已经成功的简单山寨了一下tomcat。

不过这里需要注意的是，我们自己山寨的tomcat服务器当中，之所以也成功的输出了Http协议的请求体，是因为：

我们是通过web浏览器进行访问的，如果通过普通的socket进行对serversocket的连接访问，是没有这些请求信息的。

因为我们前面已经说过了，web浏览器与服务器之间的通信必须遵循Http协议。

所以，我们日常生活中使用的web浏览器，会自动的为我们的请求进行基于http协议的包装。

但是，因为我们已经了解了原理，所以我们也可以自己模拟一下浏览器过过瘾：

[java] 
view plain
 copy

1. //山寨浏览器
2. public class MyBrowser {
4. public static void main(String[] args) {
5. try {
6. Socket browser = new Socket(“192.168.1.102”, 9090);
7. PrintWriter pw = new PrintWriter(browser.getOutputStream(),true);
8. // 封装请求第一行
9. pw.println(“GET/ HTTP/1.1”);
10. // 封装请求头
11. pw.println(“User-Agent: Java/1.6.0_13”);
12. pw.println(“Host: 192.168.1.102:9090”);
13. pw
14. .println(“Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2”);
15. pw.println(“Connection: keep-alive”);
16. // 空行
17. pw.println();
18. // 封装实体主体
19. pw.println(“UserName=zhangsan&Age=17”);
20. // 写入完毕
21. browser.shutdownOutput();
24. // 接受服务器返回信息，
25. InputStream in = browser.getInputStream();
26. //
27. int length = 0;
28. StringBuffer request = new StringBuffer();
29. byte[] buf = new byte[1024];
30. //
31. while ((length = in.read(buf)) != -1) {
32. String line = new String(buf, 0, length);
33. request.append(line);
34. }
35. System.out.println(request);
36. //browser.close();
37. } catch (IOException e) {
38. System.out.println(“异常了，操!”);
39. }finally{
41. }
42. }
43. }
45. //修改后的山寨tomcat服务器
46. public class MyTomcat {
47. public static void main(String[] args) {
48. try {
49. ServerSocket tomcat = new ServerSocket(9090);
50. System.out.println(“服务器启动”);
51. //
52. Socket s = tomcat.accept();
53. //
54. byte[] buf = new byte[1024];
55. InputStream in = s.getInputStream();
56. //
58. int length = 0;
59. StringBuffer request = new StringBuffer();
60. while ((length = in.read(buf)) != -1) {
61. String line = new String(buf, 0, length);
62. request.append(line);
63. }
64. //
65. System.out.println(“request:”+request);
67. PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
68. pw.println(“”);
69. pw.println(“”);
70. pw.println(“”);
71. pw.println(“”);
72. pw.println(“”);
73. pw.println(“<p style=“font-weight: bold;color: red;”>welcome to MyTomcat”);
74. pw.println(“”);
75. s.close();
76. tomcat.close();
77. } catch (IOException e) {
78. // TODO Auto-generated catch block
79. e.printStackTrace();
80. }
81. }
82. }

我们先启动服务器，然后运行浏览器模拟网页浏览的过程，首先看到服务器端收到的请求信息：

紧接着，服务器收到请求进行处理后，返回资源给浏览器，于是得到输出信息：

可以看到，我们在山寨浏览器当中得到的返回信息，实际上就是一个HTML文件的源码，

之所以我们的山寨浏览器中，这些信息仅仅是以纯文本形式显示，是因为我们的山寨浏览器不具备解析HTML语言的能力。

所以说，浏览器另外一个重要的功能其实就是：可以对超文本标记语言进行解析。而实际上，这也是浏览器开发的难点和重点。

上面这样的输出结果看上去显然不爽，所以说山寨货毕竟还是坑爹！

我们还是通过正规的WEB浏览器，来试着访问一下我们的山寨服务器，结果发现，效果帅多了：

而顺带一提的是，既然当浏览器向WEB服务器发起访问请求时，会封装有对应的HTTP请求体。

那么，对应的，当WEB服务器处理完浏览器请求，返回数据时，也会有对应的封装，就是所谓的HTTP响应体。

举例来说，假如我们将我们的山寨浏览器的代码进行修改，去连接真正的tomcat服务器：

[java] 
view plain
 copy

一、网安学习成长路线图

网安所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、网安视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

三、精品网安学习书籍

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

四、网络安全源码合集+工具包

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、网络安全面试题

最后就是大家最关心的网络安全面试题板块

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！