Netty协议开发（HTTP）

谁践踏了优雅 2022-05-03 04:26 277阅读 0赞

HTTP是一个属于应用层的面向对象协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。

HTTP协议的URL

http://host[":"port][abs_path]

http表示通过HTTP协议来定位网络资源；host表示合法的Internet主机域名或者IP地址；port指定一个端口号，为空则使用默认端口80；abs\_path指定请求资源的URI。

## HTTP请求消息（HttpRequest） ##

HTTP请求消息通常有三部分组成：

1.  1.HTTP请求行
2.  2.HTTP消息头
3.  3.HTTP请求正文

请求行以一个方法符开头，以空格分开，后面跟着请求的URI和协议的版本，格式为：Method Request-URI HTTP-Version CRLF

其中Method表示请求方法，Request-URI是一个统一资源标识符，HTTP-Version表示请求的HTTP协议版本，CRLF表示回车和 换行。

请求方法有多种，各方法的作用如下：

<table> 
 <tbody> 
 <tr> 
 <td> GET </td> 
 <td> 请求获取由Request-URI所标识的资源 </td> 
 </tr> 
 <tr> 
 <td> POST </td> 
 <td> 在Request-URI所标识的资源后附加新的数据 </td> 
 </tr> 
 <tr> 
 <td> HEAD </td> 
 <td> 请求获取由Request-URI所标识的资源的响应消息报头 </td> 
 </tr> 
 <tr> 
 <td> OPTIONS </td> 
 <td> 请求查询服务器的性能，或查询与资源相关的选项和需求 </td> 
 </tr> 
 <tr> 
 <td> PUT </td> 
 <td> 请求服务器存储一个资源，并用Request-URI作为其标识 </td> 
 </tr> 
 <tr> 
 <td> DELETE </td> 
 <td> 请求服务器删除由Request-URI所标识的资源 </td> 
 </tr> 
 <tr> 
 <td> TRACE </td> 
 <td> 请求服务器回送收到的请求信息，主要用语测试或诊断 </td> 
 </tr> 
 <tr> 
 <td>CONNECT</td> 
 <td>保留将来使用</td> 
 </tr> 
 </tbody> 
</table>

GET和POST对的主要区别如下：

1.  根据 HTTP 规范,GET 用于信息获取,而且应该是 安全的和幂等的；POST则表示可能改变服务器上的资源的请求。
2.  GET提交请求的数据会附在URL后面，以“？”分割URL和传输数据，多个参数用“&”连接；而POST提交会把提交的数据放置在HTTP消息的包体中，数据不会在地址栏中显示。
3.  传输数据的大小不同，特定游览器对URL长度有限制，POST不是通过URL传值，理论上数据长度不会受限。
4.  安全性。POST的安全性比GET的安全性高。

HTTP的部分请求头列表：

<table> 
 <tbody> 
 <tr> 
 <td> Content-Type </td> 
 <td> 是返回消息中非常重要的内容，表示后面的文档属于什么MIME类型。Content-Type: [type]/[subtype]; parameter。例如最常见的就是text/html，它的意思是说返回的内容是文本类型，这个文本又是HTML格式的。原则上浏览器会根据Content-Type来决定如何显示返回的消息体内容 </td> 
 </tr> 
 <tr> 
 <td> Host </td> 
 <td> 指定请求资源的Intenet主机和端口号，必须表示请求url的原始服务器或网关的位置。HTTP/1.1请求必须包含主机头域，否则系统会以400状态码返回 </td> 
 </tr> 
 <tr> 
 <td> Accept </td> 
 <td> 浏览器可接受的MIME类型 </td> 
 </tr> 
 <tr> 
 <td> Accept-Charset </td> 
 <td> 浏览器可接受的字符集 </td> 
 </tr> 
 <tr> 
 <td> Accept-Encoding </td> 
 <td> 浏览器能够进行解码的数据编码方式，比如gzip。Servlet能够向支持gzip的浏览器返回经gzip编码的HTML页面。许多情形下这可以减少5到10倍的下载时间 </td> 
 </tr> 
 <tr> 
 <td> Accept-Language </td> 
 <td> 浏览器所希望的语言种类，当服务器能够提供一种以上的语言版本时要用到 </td> 
 </tr> 
 <tr> 
 <td> Authorization </td> 
 <td> 授权信息，通常出现在对服务器发送的WWW-Authenticate头的应答中 </td> 
 </tr> 
 <tr> 
 <td> Connection </td> 
 <td> 表示是否需要持久连接。如果Servlet看到这里的值为“Keep- Alive”，或者看到请求使用的是HTTP1.1（HTTP 1.1默认进行持久连接），它就可以利用持久连接的优点，当页面包含多个元素时（例如Applet，图片），显著地减少下载所需要的时间。要实现这一点，Servlet需要在应答中发送一个Content-Length头，最简单的实现方法是：先把内容写入 ByteArrayOutputStream，然后在正式写出内容之前计算它的大小 </td> 
 </tr> 
 <tr> 
 <td> Content-Length </td> 
 <td> 表示请求消息正文的长度 </td> 
 </tr> 
 <tr> 
 <td> Cookie </td> 
 <td> 这是最重要的请求头信息之一 </td> 
 </tr> 
 <tr> 
 <td> From </td> 
 <td> 请求发送者的email地址，由一些特殊的Web客户程序使用，浏览器不会用到它 </td> 
 </tr> 
 <tr> 
 <td> Host </td> 
 <td> 初始URL中的主机和端口 </td> 
 </tr> 
 <tr> 
 <td> If-Modified-Since </td> 
 <td> 只有当所请求的内容在指定的日期之后又经过修改才返回它，否则返回304“Not Modified”应答 </td> 
 </tr> 
 <tr> 
 <td> Pragma </td> 
 <td> 指定“no-cache”值表示服务器必须返回一个刷新后的文档，即使它是代理服务器而且已经有了页面的本地拷贝 </td> 
 </tr> 
 <tr> 
 <td> Referer </td> 
 <td> 包含一个URL，用户从该URL代表的页面出发访问当前请求的页面 </td> 
 </tr> 
 <tr> 
 <td> User-Agent </td> 
 <td> 浏览器类型，如果Servlet返回的内容与浏览器类型有关则该值非常有用 </td> 
 </tr> 
 <tr> 
 <td> UA-Pixels，UA-Color，UA-OS，UA-CPU </td> 
 <td> 由某些版本的IE浏览器所发送的非标准的请求头，表示屏幕大小、颜色深度、操作系统和CPU类型 </td> 
 </tr> 
 </tbody> 
</table>

常见的MIME类型如下：

*      text/html ： HTML格式
 *      text/plain ：纯文本格式      
 *      text/xml ：  XML格式
 *      image/gif ：gif图片格式    
 *      image/jpeg ：jpg图片格式 
 *      image/png：png图片格式

以application开头的媒体格式类型：

*    application/xhtml+xml ：XHTML格式
 *    application/xml     ： XML数据格式
 *    application/atom+xml  ：Atom XML聚合格式    
 *    application/json    ： JSON数据格式
 *    application/pdf       ：pdf格式  
 *    application/msword  ： Word文档格式
 *    application/octet-stream ： 二进制流数据（如常见的文件下载）
 *    application/x-www-form-urlencoded ： <form encType=””>中默认的encType，form表单数据被编码为key/value格式发送到服务器（表单默认的提交数据的格式）

还有一种常见的媒体格式是上传文件之时使用的：

*      multipart/form-data ： 需要在表单中进行文件上传时，就需要使用该格式

## HTTP请求消息（HttpResponse） ##

HTTP响应也是由三个部分组成，分别是：状态行、消息报头、响应正文。

状态行的格式为：HTTP-Version Status-Code Reason-Phrase CRLF，其中HTTP-Version表示服务器HTTP协议的版本，Status-Code表示服务器返回的响应状态吗。

1.  \- 1xx:   指示信息—表示请求已接收，继续处理。
2.  \- 2xx:   成功—表示请求已经被成功接收、理解、接受。
3.  \- 3xx:   重定向—要完成请求必须进行更进一步的操作。
4.  \- 4xx:   客户端错误—请求有语法错误或请求无法实现。
5.  \- 5xx: 服务器端错误—服务器未能实现合法的请求。

HTTP响应状态码和描述信息

<table> 
 <tbody> 
 <tr> 
 <td style="width:198px;">状态码</td> 
 <td style="width:650px;">状态描述</td> 
 </tr> 
 <tr> 
 <td style="width:198px;">200&nbsp;&nbsp;</td> 
 <td style="width:650px;">OK&nbsp;&nbsp;&nbsp;&nbsp;客户端请求成功</td> 
 </tr> 
 <tr> 
 <td style="width:198px;">400&nbsp;&nbsp;</td> 
 <td style="width:650px;">Bad Request&nbsp;&nbsp;&nbsp;由于客户端请求有语法错误，不能被服务器所理解。</td> 
 </tr> 
 <tr> 
 <td style="width:198px;">400&nbsp;&nbsp;</td> 
 <td style="width:650px;">Unauthonzed&nbsp;&nbsp;&nbsp;请求未经授权。这个状态代码必须和WWW-Authenticate报头域一起使用</td> 
 </tr> 
 <tr> 
 <td style="width:198px;">403&nbsp;&nbsp;&nbsp;</td> 
 <td style="width:650px;">Unauthonzed&nbsp;&nbsp;&nbsp;请求未经授权。这个状态代码必须和WWW-Authenticate报头域一起使用</td> 
 </tr> 
 <tr> 
 <td style="width:198px;">404&nbsp;&nbsp;&nbsp;</td> 
 <td style="width:650px;">Not Found&nbsp;&nbsp;&nbsp;请求的资源不存在，例如，输入了错误的URL。</td> 
 </tr> 
 <tr> 
 <td style="width:198px;">500&nbsp;&nbsp;</td> 
 <td style="width:650px;">Internal Server Error&nbsp;服务器发生不可预期的错误，导致无法完成客户端的请求。</td> 
 </tr> 
 <tr> 
 <td style="width:198px;">503&nbsp;&nbsp;</td> 
 <td style="width:650px;">Service Unavailable&nbsp;&nbsp;&nbsp;服务器当前不能够处理客户端的请求，在一段时间之后，服务器可能会恢复正常</td> 
 </tr> 
 </tbody> 
</table>

常用的响应报头：

<table> 
 <tbody> 
 <tr> 
 <td style="width:201px;">名称</td> 
 <td style="width:648px;">作用</td> 
 </tr> 
 <tr> 
 <td style="width:201px;">Location</td> 
 <td style="width:648px;">Location响应报头域用于重定向接受者到一个新的位置。</td> 
 </tr> 
 <tr> 
 <td style="width:201px;">Server</td> 
 <td style="width:648px;">Server响应报头域包含了服务器用来处理请求的软件信息。</td> 
 </tr> 
 <tr> 
 <td style="width:201px;">WWW-Authenticate</td> 
 <td style="width:648px;">WWW-Authenticate响应报头域必须被包含在401(未授权的)响应消息中，这个报头域和前面讲到的Authorization请求报头域是&nbsp;相关的，当客户端收到401响应消息，就要决定是否请求服务器对其进行验证。从这个响应报头域，可以知道服务器端对我们所请求的资源采用的是基本验证机制。</td> 
 </tr> 
 <tr> 
 <td style="width:201px;">Content-Encoding</td> 
 <td style="width:648px;">Content-Encoding实体报头域被使用作媒体类型的修饰符，它的值指示了已经被应用到实体正文的附加内容编码，因而要获得Content- Type报头域中所引用的媒体类型，必须采用相应的解码机制。</td> 
 </tr> 
 <tr> 
 <td style="width:201px;">Content-Language</td> 
 <td style="width:648px;">Content-Language实体报头域描述了资源所用的自然语言。</td> 
 </tr> 
 <tr> 
 <td style="width:201px;">Content-Length</td> 
 <td style="width:648px;">Content-Length实体报头域用于指明正文的长度，以字节方式存储的十进制数字来表示，也就是一个数字字符占一个字节，用其对应的ASCII码存储传输。</td> 
 </tr> 
 <tr> 
 <td style="width:201px;">Content-Type </td> 
 <td style="width:648px;">Content-Type实体报头域用语指明发送给接收者的实体正文的媒体类型。</td> 
 </tr> 
 <tr> 
 <td style="width:201px;">Last-Modified </td> 
 <td style="width:648px;">Last-Modified实体报头域用于指示资源最后的修改日期及时间。</td> 
 </tr> 
 <tr> 
 <td style="width:201px;">Expires </td> 
 <td style="width:648px;">Expires实体报头域给出响应过期的日期和时间。</td> 
 </tr> 
 </tbody> 
</table>

实现一个简单的文件服务器：

package com.netty.http;
 
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.handler.codec.http.HttpObjectAggregator;
 import io.netty.handler.codec.http.HttpRequestDecoder;
 import io.netty.handler.codec.http.HttpResponseEncoder;
 import io.netty.handler.stream.ChunkedWriteHandler;
 
 /**
 * 文件服务器
 */
 public class HttpFileServer {
 // 这里目录要写完整的相对路径，包括main/java
 private static final String DEFAULT_URL = "/";
 
 public void run(final int port, final String url) throws Exception {
 EventLoopGroup bossGroup = new NioEventLoopGroup();
 EventLoopGroup workerGroup = new NioEventLoopGroup();
 try {
 ServerBootstrap b = new ServerBootstrap();
 b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {
 @Override
 protected void initChannel(SocketChannel ch) throws Exception {
 ch.pipeline().addLast("http-decoder", new HttpRequestDecoder());
 ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(65536));
 // 新增HTTP响应编码器，对HTTP响应消息进行编码
 ch.pipeline().addLast("http-encoder", new HttpResponseEncoder());
 // 新增Chunked handler，主要作用是支持异步发送大的码流（例如大文件传输）
 // 但是不占用过多的内存，防止发生java内存溢出错误
 ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
 // HttpFileServerHandler用于文件服务器的业务逻辑处理
 ch.pipeline().addLast("fileServerHandler", new HttpFileServerHandler(url));
 }
 });
 String host = "127.0.0.1";
 ChannelFuture future = b.bind(host, port).sync();
 System.out.println("HTTP文件目录服务器启动，网址是 : http://" + host + ":" + port + url);
 future.channel().closeFuture().sync();
 } finally {
 bossGroup.shutdownGracefully();
 workerGroup.shutdownGracefully();
 }
 }
 
 public static void main(String[] args) throws Exception {
 int port = 8081;
 String url = DEFAULT_URL;
 if (args.length > 1) url = args[1];
 new HttpFileServer().run(port, url);
 }
 }

重点是这块内容：

protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast("http-decoder", new HttpRequestDecoder());
                        ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(65536));
                        // 新增HTTP响应编码器，对HTTP响应消息进行编码
                        ch.pipeline().addLast("http-encoder", new HttpResponseEncoder());
                        // 新增Chunked handler，主要作用是支持异步发送大的码流（例如大文件传输）
                        // 但是不占用过多的内存，防止发生java内存溢出错误
                        ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
                        // HttpFileServerHandler用于文件服务器的业务逻辑处理
                        ch.pipeline().addLast("fileServerHandler", new HttpFileServerHandler(url));
                    }

首先向ChannelPipeline中添加HTTP请求消息解码器，随后添加了HttpObjectAggregator解码器，它将多个消息转换为单一的FullHttpRequest或者FullHttpResponse，原因是HTTP解码器在每个HTTP消息中会生成多个消息对象。然后新增HTTP响应编码器，对HTTP响应消息进行编码，然后新增Chunked handler，它的主要作用是支持异步发送大的码流，但不占用过多内存，防止Java发生内存溢出错误。最后添加HttpFileServerrHandler用于文件服务器的业务逻辑处理。

package com.netty.http;
 
 import static io.netty.handler.codec.http.HttpHeaders.isKeepAlive;
 import static io.netty.handler.codec.http.HttpHeaders.setContentLength;
 import static io.netty.handler.codec.http.HttpHeaders.Names.CONNECTION;
 import static io.netty.handler.codec.http.HttpHeaders.Names.CONTENT_TYPE;
 import static io.netty.handler.codec.http.HttpHeaders.Names.LOCATION;
 import static io.netty.handler.codec.http.HttpMethod.GET;
 import static io.netty.handler.codec.http.HttpResponseStatus.BAD_REQUEST;
 import static io.netty.handler.codec.http.HttpResponseStatus.FORBIDDEN;
 import static io.netty.handler.codec.http.HttpResponseStatus.FOUND;
 import static io.netty.handler.codec.http.HttpResponseStatus.INTERNAL_SERVER_ERROR;
 import static io.netty.handler.codec.http.HttpResponseStatus.METHOD_NOT_ALLOWED;
 import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
 import static io.netty.handler.codec.http.HttpResponseStatus.OK;
 import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelProgressiveFuture;
 import io.netty.channel.ChannelProgressiveFutureListener;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.handler.codec.http.DefaultFullHttpResponse;
 import io.netty.handler.codec.http.DefaultHttpResponse;
 import io.netty.handler.codec.http.FullHttpRequest;
 import io.netty.handler.codec.http.FullHttpResponse;
 import io.netty.handler.codec.http.HttpHeaders;
 import io.netty.handler.codec.http.HttpResponse;
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.LastHttpContent;
 import io.netty.handler.stream.ChunkedFile;
 import io.netty.util.CharsetUtil;
 
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.RandomAccessFile;
 import java.io.UnsupportedEncodingException;
 import java.net.URLDecoder;
 import java.util.regex.Pattern;
 import javax.activation.MimetypesFileTypeMap;
 
 /**
 * 返回的当前服务器下的文件目录
 */
 public class HttpFileServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
 private final String url;
 
 public HttpFileServerHandler(String url) {
 this.url = url;
 }
 
 /**
 * DefaultFullHttpRequest, decodeResult: success)
 * GET /src/main/java/netty/ HTTP/1.1
 * Host: 127.0.0.1:8081
 * Connection: keep-alive
 * Cache-Control: max-age=0
 * User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36
 * Upgrade-Insecure-Requests: 1
 * Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*;q=0.8
 * Accept-Encoding: gzip, deflate, br
 * Accept-Language: zh-CN,zh;q=0.9
 * Content-Length: 0
 * 
 * 
 * DefaultFullHttpRequest, decodeResult: success)
 * GET /favicon.ico HTTP/1.1
 * Host: 127.0.0.1:8081
 * Connection: keep-alive
 * Pragma: no-cache
 * Cache-Control: no-cache
 * User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.96 Safari/537.36
 * Accept: image/webp,image/*,*;q=0.8
 * Referer: http://127.0.0.1:8081/src/main/java/netty/
 * Accept-Encoding: gzip, deflate, sdch, br
 * Accept-Language: zh-CN,zh;q=0.8
 * Content-Length: 0
 * 
 * 这里发现，每次刷新，或者点击都会有两个请求，很郁闷？
 * 浏览器每次发起请求，都会同时请求一次favicon.ico（本次不讨论浏览器缓存了favicon.ico）
 */
 @Override
 public void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
 // 过滤掉浏览器每次发起请求，都会同时请求一次favicon.ico
 if (request.getUri().equals("/favicon.ico")) {
 return;
 }
 System.out.println("服务器接受消息" + request);
 // 首先对HTTP请求小弟的解码结果进行判断，如果解码失败，直接构造HTTP 400错误返回。
 if (!request.getDecoderResult().isSuccess()) {
 sendError(ctx, BAD_REQUEST);
 return;
 }
 // 请求方法：如果不是从浏览器或者表单设置为get请求，构造http 405错误返回
 if (request.getMethod() != GET) {
 sendError(ctx, METHOD_NOT_ALLOWED);
 return;
 }
 // 对请求的的URL进行包装 final
 String uri = request.getUri();
 // 展开URL分析
 final String path = sanitizeUri(uri);
 if (path == null) {
 sendError(ctx, FORBIDDEN);
 return;
 }
 File file = new File(path);
 // 如果文件不存在或者是系统隐藏文件，则构造404 异常返回
 if (file.isHidden() || !file.exists()) {
 sendError(ctx, NOT_FOUND);
 return;
 }
 // 如果文件是目录，则发送目录的连接给客户端浏览器
 if (file.isDirectory()) {
 if (uri.endsWith("/")) {
 sendListing(ctx, file);
 } else {
 sendRedirect(ctx, uri + '/');
 }
 return;
 }
 // 用户在浏览器上第几超链接直接打开或者下载文件，合法性监测
 if (!file.isFile()) {
 sendError(ctx, FORBIDDEN);
 return;
 }
 // IE下才会打开文件，其他浏览器都是直接下载
 // 随机文件读写类以读的方式打开文件
 RandomAccessFile randomAccessFile = null;
 try {
 randomAccessFile = new RandomAccessFile(file, "r");
 // 以只读的方式打开文件
 } catch (FileNotFoundException fnfe) {
 sendError(ctx, NOT_FOUND);
 return;
 }
 // 获取文件长度，构建成功的http应答消息
 long fileLength = randomAccessFile.length();
 HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);
 setContentLength(response, fileLength);
 setContentTypeHeader(response, file);
 if (isKeepAlive(request)) {
 response.headers().set(CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
 }
 ctx.write(response);
 ChannelFuture sendFileFuture;
 // 同过netty的村可多File对象直接将文件写入到发送缓冲区，最后为sendFileFeature增加GenericFeatureListener，
 // 如果发送完成，打印“Transfer complete”
 sendFileFuture = ctx.write(new ChunkedFile(randomAccessFile, 0, fileLength, 8192), ctx.newProgressivePromise());
 sendFileFuture.addListener(new ChannelProgressiveFutureListener() {
 @Override
 public void operationProgressed(ChannelProgressiveFuture future, long progress, long total) {
 if (total < 0) {
 // total unknown
 System.err.println("Transfer progress: " + progress);
 } else {
 System.err.println("Transfer progress: " + progress + " / " + total);
 }
 }
 
 @Override
 public void operationComplete(ChannelProgressiveFuture future) throws Exception {
 System.out.println("Transfer complete.");
 }
 });
 ChannelFuture lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
 if (!isKeepAlive(request)) {
 lastContentFuture.addListener(ChannelFutureListener.CLOSE);
 }
 }
 
 @Override
 public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
 cause.printStackTrace();
 if (ctx.channel().isActive()) {
 sendError(ctx, INTERNAL_SERVER_ERROR);
 }
 }
 
 private static final Pattern INSECURE_URI = Pattern.compile(".*[<>&\"].*");
 
 private String sanitizeUri(String uri) {
 try {
 // 使用JDK的URLDecoder进行解码
 uri = URLDecoder.decode(uri, "UTF-8");
 } catch (UnsupportedEncodingException e) {
 try {
 uri = URLDecoder.decode(uri, "ISO-8859-1");
 } catch (UnsupportedEncodingException e1) {
 throw new Error();
 }
 }
 // URL合法性判断
 if (!uri.startsWith(url)) {
 return null;
 }
 if (!uri.startsWith("/")) {
 return null;
 }
 // 将硬编码的文件路径
 uri = uri.replace('/', File.separatorChar);
 if (uri.contains(File.separator + '.') || uri.contains('.' + File.separator) || uri.startsWith(".") || uri.endsWith(".") || INSECURE_URI.matcher(uri).matches()) {
 return null;
 }
 return System.getProperty("user.dir") + File.separator + uri;
 }
 
 private static final Pattern ALLOWED_FILE_NAME = Pattern.compile("[A-Za-z0-9][-_A-Za-z0-9\\.]*");
 
 /**
 * 这里是构建了一个html页面返回给浏览器
 *
 * @param ctx
 * @param dir
 */
 private static void sendListing(ChannelHandlerContext ctx, File dir) {
 FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, OK);
 response.headers().set(CONTENT_TYPE, "text/html; charset=UTF-8");
 StringBuilder buf = new StringBuilder();
 String dirPath = dir.getPath();
 buf.append("<!DOCTYPE html>\r\n");
 buf.append("<html><head><title>");
 buf.append(dirPath);
 buf.append(" 目录：");
 buf.append("</title></head><body>\r\n");
 buf.append("<h3>");
 buf.append(dirPath).append(" 目录：");
 buf.append("</h3>\r\n");
 buf.append("<ul>");
 // 此处打印了一个 .. 的链接 buf.append("<li>链接：<a href=\"../\">..</a></li>\r\n");
 // 用于展示根目录下的所有文件和文件夹，同时使用超链接标识
 for (File f : dir.listFiles()) {
 if (f.isHidden() || !f.canRead()) {
 continue;
 }
 String name = f.getName();
 if (!ALLOWED_FILE_NAME.matcher(name).matches()) {
 continue;
 }
 buf.append("<li>链接：<a href=\"");
 buf.append(name);
 buf.append("\">");
 buf.append(name);
 buf.append("</a></li>\r\n");
 }
 buf.append("</ul></body></html>\r\n");
 ByteBuf buffer = Unpooled.copiedBuffer(buf, CharsetUtil.UTF_8);
 response.content().writeBytes(buffer);
 buffer.release();
 ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
 }
 
 private static void sendRedirect(ChannelHandlerContext ctx, String newUri) {
 FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, FOUND);
 response.headers().set(LOCATION, newUri);
 ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
 }
 
 private static void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) {
 FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, status, Unpooled.copiedBuffer("Failure: " + status.toString() + "\r\n", CharsetUtil.UTF_8));
 response.headers().set(CONTENT_TYPE, "text/plain; charset=UTF-8");
 ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
 }
 
 private static void setContentTypeHeader(HttpResponse response, File file) {
 MimetypesFileTypeMap mimeTypesMap = new MimetypesFileTypeMap();
 response.headers().set(CONTENT_TYPE, mimeTypesMap.getContentType(file.getPath()));
 }
 
 
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_27_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_27_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_27_color_FFFFFF_t_70 2][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_27_color_FFFFFF_t_70]: /images/20220503/eb9288f6f19e4ceeb0ddfe5228c7ef2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_27_color_FFFFFF_t_70 1]: /images/20220503/37233f3817704b45a57663c77eac6904.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_27_color_FFFFFF_t_70 2]: /images/20220503/ab387712c15b42cab245a367be0c5f61.png