一，需求
文件服務器使用HTTP協議對外提供服務。用戶通過瀏覽器訪問文件服務器，首先對URL進行檢查，若失敗返回403錯誤；若通過校驗，以鏈接的方式打開當前目錄，每個目錄或文件都以超鏈接的形式展現，可遞歸訪問，並下載文件。
二，關鍵實現代碼
①文件服務器啟動類
需要添加的通道處理器如下：
@Override protected void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast("http-decoder", new HttpRequestDecoder()); ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(65536)); ch.pipeline().addLast("http-encoder", new HttpResponseEncoder()); ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler()); ch.pipeline().addLast("fileServerHandler", new HttpFileServerHandler(url)); }
1) HttpRequestDecoder
Decodes {@link ByteBuf}s into {@link HttpRequest}s and {@link HttpContent}s.
它負責把字節解碼成Http請求。
2) HttpObjectAggregator
A {@link ChannelHandler} that aggregates an {@link HttpMessage} and its following {@link HttpContent}s into a single {@link FullHttpRequest} or {@link FullHttpResponse} (depending on if it used to handle requests or responses)
它負責把多個HttpMessage組裝成一個完整的Http請求或者響應。到底是組裝成請求還是響應，則取決於它所處理的內容是請求的內容，還是響應的內容。這其實可以通過Inbound和Outbound來判斷，對於Server端而言，在Inbound 端接收請求，在Outbound端返回響應。
It is useful when you don't want to take care of HTTP messages whose transfer encoding is 'chunked'.
如果Server向Client返回的數據指定的傳輸編碼是 chunked。則，Server不需要知道發送給Client的數據總長度是多少，它是通過分塊發送的，參考分塊傳輸編碼
Be aware that you need to have the {@link HttpResponseEncoder} or {@link HttpRequestEncoder} before the {@link HttpObjectAggregator} in the {@link ChannelPipeline}.
注意，HttpObjectAggregator通道處理器必須放到HttpRequestDecoder或者HttpRequestEncoder后面。
3) HttpResponseEncoder
當Server處理完消息后，需要向Client發送響應。那么需要把響應編碼成字節，再發送出去。故添加HttpResponseEncoder處理器。
4)ChunkedWriteHandler
A {@link ChannelHandler} that adds support for writing a large data stream asynchronously neither spending a lot of memory nor getting {@link OutOfMemoryError}.
該通道處理器主要是為了處理大文件傳輸的情形。大文件傳輸時，需要復雜的狀態管理，而ChunkedWriteHandler實現這個功能。
5) HttpFileServerHandler
自定義的通道處理器，其目的是實現文件服務器的業務邏輯。
通道處理器添加完畢之后，需要啟動服務器。代碼如下：
ChannelFuture f = b.bind("localhost", port).sync();
f.channel().closeFuture().sync();
因為在Netty中所有的事件都是異步的，因此bind操作是一個異步操作，通道的關閉也是一個異步操作。因此使用ChannelFuture來作為一個 palceholder,代表操作執行之后的結果。
最后關閉事件線程，代碼如下：
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
②文件處理器類
HttpFileServerHandler.java是自定義的通道處理器，用來實現HTTP文件服務器的業務邏輯。從上面添加的Handler可以看出，在HTTP文件服務器的實現過程中，Netty已經為我們解決了很多工作，如：HttpRequestDecoder自動幫我們解析HTTP請求(解析byte)；再比如：HttpObjectAggregator把多個HTTP請求中的數據組裝成一個，當服務器發送的response事先不知道響應的長度時就很有用。
文件處理器通過繼承SimpleChannelInboundHandler來實現，代碼如下：
public class HttpFileServerHandler extends SimpleChannelInboundHandler<FullHttpRequest>{ private final String url; public HttpFileServerHandler(String url) { this.url = url; } @Override protected void messageReceived(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception { if(!request.decoderResult().isSuccess()) { sendError(ctx, HttpResponseStatus.BAD_REQUEST); return; } if(request.method() != HttpMethod.GET) { sendError(ctx, HttpResponseStatus.METHOD_NOT_ALLOWED); return; }
當服務器接收到消息時，會自動觸發 messageReceived方法。該方法首先對URL進行判斷，並只接受GET請求。
相關的驗證通過后，通過RandomAccessFile類打開文件，並構造響應。
RandomAccessFile randomAccessFile = null; try{ randomAccessFile = new RandomAccessFile(file, "r"); }catch(FileNotFoundException fnfd){ sendError(ctx, HttpResponseStatus.NOT_FOUND); return; } long fileLength = randomAccessFile.length(); HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
如果請求中帶有“KEEP-ALIVE”，則不關閉連接。
if(HttpHeaderUtil.isKeepAlive(request)){ response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE); }
進行數據的發送
sendFileFuture = ctx.write(new ChunkedFile(randomAccessFile, 0, fileLength, 8192), ctx.newProgressivePromise()); sendFileFuture.addListener(new ChannelProgressiveFutureListener() { @Override public void operationComplete(ChannelProgressiveFuture future) throws Exception { System.out.println("Transfer complete."); }
ctx.write(response);
當發送完數據之后，由於采用的是Transfer-Encoding：chunk模式來傳輸數據，因此需要在發送一個長度為0的chunk用來標記數據傳輸完成。
ChannelFuture lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT); if(!HttpHeaderUtil.isKeepAlive(request)) lastContentFuture.addListener(ChannelFutureListener.CLOSE); }
使用Keep-Alive，可以減少HTTP連接建立的次數，在HTTP1.1中該選項是默認開啟的。
Connection: Keep-Alive When the server processes the request and generates a response, it also adds a header to the response: Connection: Keep-Alive When this is done, the socket connection is not closed as before, but kept open after sending the response. When the client sends another request, it reuses the same connection. The connection will continue to be reused until either the client or the server decides that the conversation is over, and one of them drops the connection.
在使用Keep-Alive的情況下，當Server處理了Client的請求且生成一個response后，在response的頭部添加Connection: Keep-Alive選項，把response返回給client，此時Socket連接並不會關閉。
【若沒有Keep-Alive，一次HTTP請求響應之后，本次Socket連接就關閉了】
由於連接還沒有關閉，當client再發送另一個請求時，就會重用這個Socket連接，直至其中一方drops the connection.
關於Keep-Alive的討論，參考：
整個源碼參考：
package httpFileServer; 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.HttpRequestEncoder; import io.netty.handler.codec.http.HttpResponseEncoder; import io.netty.handler.stream.ChunkedWriteHandler; public class HttpFileServer { private static final String DEFAULT_URL = "/src/"; 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)); ch.pipeline().addLast("http-encoder", new HttpResponseEncoder()); ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler()); ch.pipeline().addLast("fileServerHandler", new HttpFileServerHandler(url)); } }); ChannelFuture f = b.bind("localhost", port).sync(); System.out.println("HTTP 文件服務器啟動, 地址是： " + "http://localhost:" + port + url); f.channel().closeFuture().sync(); }finally{ bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } public static void main(String[] args)throws Exception { int port = 8888; if(args.length > 0) { try{ port = Integer.parseInt(args[0]); }catch(NumberFormatException e){ port = 8080; } } String url = DEFAULT_URL; if(args.length > 1) url = args[1]; new HttpFileServer().run(port, url); } } package httpFileServer; import java.io.File; import java.io.FileNotFoundException; import java.io.RandomAccessFile; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import java.util.regex.Pattern; import javax.activation.MimetypesFileTypeMap; import javax.swing.text.html.MinimalHTMLWriter; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.Channel; 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.HttpHeaderNames; import io.netty.handler.codec.http.HttpHeaderUtil; import io.netty.handler.codec.http.HttpHeaderValues; import io.netty.handler.codec.http.HttpHeaders; import io.netty.handler.codec.http.HttpMessage; import io.netty.handler.codec.http.HttpMethod; import io.netty.handler.codec.http.HttpResponse; import io.netty.handler.codec.http.HttpResponseStatus; import io.netty.handler.codec.http.HttpVersion; import io.netty.handler.codec.http.LastHttpContent; import io.netty.handler.codec.http2.Http2Headers; import io.netty.handler.stream.ChunkedFile; import io.netty.util.CharsetUtil; import io.netty.util.concurrent.Future; import io.netty.util.concurrent.GenericFutureListener; public class HttpFileServerHandler extends SimpleChannelInboundHandler<FullHttpRequest>{ private final String url; public HttpFileServerHandler(String url) { this.url = url; } @Override protected void messageReceived(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception { if(!request.decoderResult().isSuccess()) { sendError(ctx, HttpResponseStatus.BAD_REQUEST); return; } if(request.method() != HttpMethod.GET) { sendError(ctx, HttpResponseStatus.METHOD_NOT_ALLOWED); return; } final String uri = request.uri(); final String path = sanitizeUri(uri); if(path == null) { sendError(ctx, HttpResponseStatus.FORBIDDEN); return; } File file = new File(path); if(file.isHidden() || !file.exists()) { sendError(ctx, HttpResponseStatus.NOT_FOUND); return; } if(file.isDirectory()) { if(uri.endsWith("/")) { sendListing(ctx, file); }else{ sendRedirect(ctx, uri + "/"); } return; } if(!file.isFile()) { sendError(ctx, HttpResponseStatus.FORBIDDEN); return; } RandomAccessFile randomAccessFile = null; try{ randomAccessFile = new RandomAccessFile(file, "r"); }catch(FileNotFoundException fnfd){ sendError(ctx, HttpResponseStatus.NOT_FOUND); return; } long fileLength = randomAccessFile.length(); HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK); HttpHeaderUtil.setContentLength(response, fileLength); // setContentLength(response, fileLength); setContentTypeHeader(response, file); if(HttpHeaderUtil.isKeepAlive(request)){ response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE); } ctx.write(response); ChannelFuture sendFileFuture = null; sendFileFuture = ctx.write(new ChunkedFile(randomAccessFile, 0, fileLength, 8192), ctx.newProgressivePromise()); sendFileFuture.addListener(new ChannelProgressiveFutureListener() { @Override public void operationComplete(ChannelProgressiveFuture future) throws Exception { System.out.println("Transfer complete."); } @Override public void operationProgressed(ChannelProgressiveFuture future, long progress, long total) throws Exception { if(total < 0) System.err.println("Transfer progress: " + progress); else System.err.println("Transfer progress: " + progress + "/" + total); } }); ChannelFuture lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT); if(!HttpHeaderUtil.isKeepAlive(request)) lastContentFuture.addListener(ChannelFutureListener.CLOSE); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); if(ctx.channel().isActive()) sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR); } private static final Pattern INSECURE_URI = Pattern.compile(".*[<>&\"].*"); private String sanitizeUri(String uri){ try{ uri = URLDecoder.decode(uri, "UTF-8"); }catch(UnsupportedEncodingException e){ try{ uri = URLDecoder.decode(uri, "ISO-8859-1"); }catch(UnsupportedEncodingException e1){ throw new Error(); } } 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\\.]*"); private static void sendListing(ChannelHandlerContext ctx, File dir){ FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK); // response.headers().set("CONNECT_TYPE", "text/html;charset=UTF-8"); response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html;charset=UTF-8"); String dirPath = dir.getPath(); StringBuilder buf = new StringBuilder(); 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(HttpVersion.HTTP_1_1, HttpResponseStatus.FOUND); // response.headers().set("LOCATIN", newUri); response.headers().set(HttpHeaderNames.LOCATION, newUri); ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE); } private static void sendError(ChannelHandlerContext ctx, HttpResponseStatus status){ FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, Unpooled.copiedBuffer("Failure: " + status.toString() + "\r\n", CharsetUtil.UTF_8)); response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html;charset=UTF-8"); ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE); } private static void setContentTypeHeader(HttpResponse response, File file){ MimetypesFileTypeMap mimetypesFileTypeMap = new MimetypesFileTypeMap(); response.headers().set(HttpHeaderNames.CONTENT_TYPE, mimetypesFileTypeMap.getContentType(file.getPath())); } }