在Web应用中，浏览器请求一个URL，服务器就把生成的html网页发送给浏览器，而浏览器和服务器之间的传输协议是HTTP,那么接下来我们看下如何用JAVA来实现一个简单的HTTP服务器。
具体代码实现
import java.nio.charset.StandardCharsets;
import java.io.*;
import java.util.*;
import java.NET.*;
/**
* HTTP 服务
*/
public class HttpServer {
public static void mAIn(String[] args) throws IOException {
// 监听指定端口
ServerSocket ss = new ServerSocket(9901);
System.out.println("server is running...");
for (;;) {
Socket sock = ss.accept();
System.out.println("connected from " + sock.getRemoteSocketAddress());
// 开启线程处理接收到的socket数据
Thread t = new Handler(sock);
t.start();
}
}
}
/**
* 执行类
*/
class Handler extends Thread {
Socket sock;
public Handler(Socket sock) {
this.sock = sock;
}
public void run() {
try (InputStream input = this.sock.getInputStream()) {
try (OutputStream output = this.sock.getOutputStream()) {
handle(input, output);
}
} catch (Exception e) {
try {
this.sock.close();
} catch (IOException ioe) {
}
System.out.println("client disconnected.");
}
}
/**
* 具体执行方法
* 处理http输入数据，转换输出
* @param input
* @param output
* @throws IOException
*/
private void handle(InputStream input, OutputStream output) throws IOException {
System.out.println("Process new http request...");
BufferedReader reader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(output, StandardCharsets.UTF_8));
// 读取HTTP请求:
boolean requestOk = false;
String first = reader.readLine();
if (first.startsWith("GET / HTTP/1.")) {
requestOk = true;
}
for (;;) {
String header = reader.readLine();
if (header.isEmpty()) { // 读取到空行时, HTTP Header读取完毕
break;
}
System.out.println(header);
}
System.out.println(requestOk ? "Response OK" : "Response Error");
if (!requestOk) {
// 发送错误响应:
writer.write("HTTP/1.0 404 Not Found-lzfrn");
writer.write("Content-Length: 0rn");
writer.write("rn");
writer.flush();
} else {
// 发送成功响应:
String data = "<html><body><h1 style="color:red">Hello, LZF!</h1></body></html>";
int length = data.getBytes(StandardCharsets.UTF_8).length;
writer.write("HTTP/1.0 200 OKrn");
writer.write("Connection: closern");
writer.write("Content-Type: text/htmlrn");
writer.write("Content-Length: " + length + "rn");
writer.write("rn"); // 空行标识Header和Body的分隔
writer.write(data);
writer.flush();
}
}
}
复制代码
我们用 javac HttpServer.java 命令将java文件编译成可执行类，然后运行命令 java HttpServer
可以看到 server 已经正常启动，我们在网页上输入 127.0.0.1:9901, 可以看到已经能够正常返回了，是不是很简单呀。
从上面我们可以看到编写HTTP服务器其实是非常简单的，只需要先编写基于多线程的TCP服务，然后在一个TCP连接中读取HTTP请求，发送HTTP响应就可以了。
但是，要编写一个完善的HTTP服务器，还要考虑更多东西例如：
我们一直都在强调不要重复造轮子，Java发展了这么久处理TCP连接，解析HTTP协议这些底层工作早已有了现成的API。JavaEE提供的Servlet API，我们可以使用Servlet API编写自己的Servlet来处理HTTP请求，
接下来我们看一个简单的例子
import java.nio.charset.StandardCharsets;
import java.io.*;
import java.util.*;
import java.net.*;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// WebServlet注解表示这是一个Servlet，并映射到地址/:
@WebServlet(urlPatterns = "/")
public class HelloServlet extends HttpServlet {
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// 设置响应类型:
resp.setContentType("text/html");
// 获取输出流:
PrintWriter pw = resp.getWriter();
String name = req.getParameter("name");
// 写入响应:
if (null == name) {
pw.write("<h1>Hello, world!</h1>");
} else {
pw.write("<h1>Hello, " + name + "!</h1>");
}
// 最后不要忘记flush强制输出:
pw.flush();
}
}
其中 Servlet API是一个jar包，我们需要通过Maven来引入它，才能正常编译。编写pom.xml文件如下
<project xmlns="http://maven.Apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.lzf.learnjava</groupId>
<artifactId>web-servlet-hello1</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<java.version>8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.0</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<finalName>hello</finalName>
</build>
</project>
具体代码结构目录如下
Mavean 打包出来的是war包， 需要运行的话得先启动Web服务器，而Web服务我们最常用的就是Tomcat。首先我们到官网下载Tomcat服务器，解压后
Tomcat目录：
bin：存放启动和关闭tomcat脚本 conf：存放不同的配置文件（server.xml和web.xml) doc：存放Tomcat文档 lib：存放Tomcat运行需要的库文件（JARS） logs：存放Tomcat执行时的LOG文件 webApps：Tomcat的主要Web发布目录（包括应用程序示例） work：存放jsp编译后产生的class文件
把hello.war复制到Tomcat的webapps目录下，Tomcat 默认监听的8080的端口，可以通过修改 conf/server.xml -> Connector 里的 port 属性来改变监听端口。然后切换到bin目录，执行startup.sh或startup.bat启动Tomcat服务器
网页上输入
http://localhost:9903/hello/?name=Qc ，成功访问！
接下来我们来分析Tomcat 是如何处理一个HTTP请求的过程
首先我们先了解Tomcat 的体系架构
参考上面的图解释下：
1.Server组件
即服务器，每个tomcat程序启动后，就是一个server。
2、Service组件
一个Server可以包含多个Service，Service这是一种抽象的服务，它把连接器和处理引擎结合在一起。
3、Connector组件：
一个Service可以有多个Connector，Connector组件用于处理连接和并发。一般说来常见于server.xml
中的连接器类型通常有4种：
1) HTTP连接器 2) SSL连接器 3) AJP 1.3连接器 4) proxy连接器
4、Engine组件：
Engine是Servlet处理器的一个实例，即servlet引擎，其defaultHost属性是用来来为其定义一个接收所
有发往非明确定义虚拟主机的请求的host组件。如前面示例中定义的：
<Engine name=”Catalina” defaultHost=”localhost”>
5、Host组件：
位于Engine容器中，用于接收请求并进行相应处理的主机或虚拟主机.
<!-- 自定义host , 类似 Nginx 反向代理功能 /> -->
<Host name="aaatc.test" appBase="webapps2">
</Host>
<!--如果一个主机有两个或两个以上的主机名，额外的名称均可以以别名的形式进行定义： -->
<Host name="localhost" appBase="webapp" unpackWARs="true">
<Alias>bbbtc.test</Alias>
</Host>
6、Context组件：
Context在某些意义上类似于apache中的路径别名，一个Context定义用于标识tomcat实例中的一个Web应用程序
了解了架构之后我们看请求过程
1、用户打开浏览器输入地址，请求被发送到本机端口9903，被在那里监听的Coyote HTTP/1.1 Connector获得。
2、Connector把该请求交给它所在的Service的Engine来处理，并等待Engine的回应。
3、Engine获得请求localhost:9903/hello/?name=Qc，匹配所有的虚拟主机Host。
4、Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）名为localhost的Host获得请求/hello/?name=Qc，匹配它所拥有的所有的Context。 Host匹配到路径为/hello 的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）。
5、在它的mapping table中寻找出对应的Servlet 处理数据。
6、构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet（）或doPost（）.执行业务逻辑、数据存储等程序。
7、Context把执行完之后的HttpServletResponse对象返回给Host。
8、Host把HttpServletResponse对象返回给Engine。
9、Engine把HttpServletResponse对象返回Connector。
10、Connector把HttpServletResponse对象返回给浏览器。
以上就是 Tomcat 处理一个HTTP请求的完整流程。
Tomcat 实际上也是一个Java程序，我们可以把 Tomcat 以 Jar 包的方式引入，然后自己编写一个main()方法，先启动Tomcat，然后让它加载我们的webapp就行。我们常用的 SpringBoot 框架采用的就是这样的方式。
首先我们需要先建一个项目 web-servlet-hello-tomcat, 编写pom.xml文件
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.lzf.learnjava</groupId>
<artifactId>web-servlet-hello-tomcat</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<java.version>8</java.version>
<tomcat.version>9.0.58</tomcat.version>
</properties>
<dependencies>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
<version>${tomcat.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<version>${tomcat.version}</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<finalName>hello</finalName>
</build>
</project>
然后，我们编写一个main()方法，启动Tomcat服务器
package com.lzf.learnjava.servlet;
import org.apache.catalina.Context;
import org.apache.catalina.WebResourceRoot;
import org.apache.catalina.startup.Tomcat;
import org.apache.catalina.webresources.DirResourceSet;
import org.apache.catalina.webresources.StandardRoot;
import java.io.File;
/**
* @author liuzufa
*/
public class Main {
public static void main(String[] args) throws Exception {
// 启动Tomcat:
Tomcat tomcat = new Tomcat();
tomcat.setPort(Integer.getInteger("port", 9904));
tomcat.getConnector();
// 创建webapp:
Context ctx = tomcat.addWebapp("", new File("src/main/webapp").getAbsolutePath());
WebResourceRoot resources = new StandardRoot(ctx);
resources.addPreResources(
new DirResourceSet(resources, "/WEB-INF/classes", new File("target/classes").getAbsolutePath(), "/"));
ctx.setResources(resources);
tomcat.start();
tomcat.getServer().await();
}
}
除去前面的手动输出HTML的方法，我们还可以使用JSP。JSP是Java Server Pages的缩写，它的文件必须放到/src/main/webapp下，文件名必须以.jsp结尾，整个文件与HTML并无太大区别，但需要插入变量，或者动态输出的地方，使用特殊指令<% ... %>。
JSP和Servlet有什么区别？其实它们没有任何区别，因为JSP在执行前首先被编译成一个Servlet。在Tomcat的临时目录下，可以找到一个hello_jsp.java的源文件，这个文件就是Tomcat把JSP自动转换成的Servlet源码。
1、学会使用java编写一个简单http服务
2、解释了Tomcat处理一次HTTP请求的完整流程
3、将Tomcat以jar 的方式引入项目中，学会了简单的JSP开发。
作者：xiao6zi470
链接：
https://juejin.cn/post/7067917428319223845
京公网安备 11010802035086号