Netty基于Http协议的服务端入门开发

喜欢ヅ旅行 2022-02-20 15:21 253阅读 0赞

通过学习搭建一个简单的文件服务器，使用http协议对外提供服务，当客户端通过浏览器访问文件服务器时，对访问路径进行检查，检查失败时返回403错误，该页无法访问，如果校验通过，以链接的方式打开当前文件目录，每个目录下是超链接，可以递归访问，如果是文件则下载。

# 代码实现 #

## HttpFileServer ##

package com.dpb.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 { 
    
    	private static final String DEFAULT_URL = "/src/main/java/com/dpb/netty/";
    
    	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());
    							//HttpObjectAggregator的作用 将多个消息转换为单一的FullHttpRequest或者FullHttpResponse
    							ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(65536));
    							// 添加响应解码器
    							ch.pipeline().addLast("http-encoder", new HttpResponseEncoder());
    							// 支持异步发送大的码流(大的文件传输),但不占用过多的内存，防止java内存溢出
    							ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
    							// 添加自定义handler 处理文件服务器业务逻辑
    							ch.pipeline().addLast("fileServerHandler", new HttpFileServerHandler(url));
    						}
    					});
    			ChannelFuture future = b.bind("127.0.0.1", port).sync();
    			System.out.println("HTTP文件目录服务器启动，网址是 : " + "http://127.0.0.1:" + port + url);
    			future.channel().closeFuture().sync();
    		} finally { 
    			bossGroup.shutdownGracefully();
    			workerGroup.shutdownGracefully();
    		}
    	}
    
    	public static void main(String[] args) throws Exception { 
    		int port = 8080;
    		if (args.length > 0) { 
    			try { 
    				port = Integer.parseInt(args[0]);
    			} catch (NumberFormatException e) { 
    				e.printStackTrace();
    			}
    		}
    		String url = DEFAULT_URL;
    		if (args.length > 1)
    			url = args[1];
    		new HttpFileServer().run(port, url);
    	}
    }

## HttpFileServerHandler ##

package com.dpb.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 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;
    
    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;
    
    public class HttpFileServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> { 
    
    	private final String url;
    
    	public HttpFileServerHandler(String url) { 
    		this.url = url;
    	}
    
    	@Override
    	public void messageReceived(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception { 
    		// 解码失败 400
    		if (!request.getDecoderResult().isSuccess()) { 
    			sendError(ctx, BAD_REQUEST);
    			return;
    		}
    		// 只支持get方法
    		if (request.getMethod() != GET) { 
    			sendError(ctx, METHOD_NOT_ALLOWED);
    			return;
    		}
    		// 
    		final String uri = request.getUri();
    		// 处理Uri地址
    		final String path = sanitizeUri(uri);
    		
    		if (path == null) { 
    			sendError(ctx, FORBIDDEN);
    			return;
    		}
    		File file = new File(path);
    		// 如果文件不存在，或不可访问
    		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;
    		}
    		RandomAccessFile randomAccessFile = null;
    		try { 
    			randomAccessFile = new RandomAccessFile(file, "r");// 以只读的方式打开文件
    		} catch (FileNotFoundException fnfe) { 
    			sendError(ctx, NOT_FOUND);
    			return;
    		}
    		long fileLength = randomAccessFile.length();
    		// 创建一个默认的Http响应
    		HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);
    		// 设置响应文件大小
    		setContentLength(response, fileLength);
    		// 设置 content Type
    		setContentTypeHeader(response, file);
    		// 设置 keep alive
    		if (isKeepAlive(request)) { 
    			response.headers().set(CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
    		}
    		ctx.write(response);
    		ChannelFuture sendFileFuture;
    		//通过Netty的ChunkedFile对象直接将文件写入发送到缓冲区中
    		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);
    		//如果不支持keep-Alive，服务器端主动关闭请求
    		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(".*[<>&\"].*");
    
    	/** * 格式化uri并且获取路径 * @param uri * @return */
    	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(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_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70]

## 访问成功 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 1]

搭建很简单，可以跑下代码，关键多推敲下代码~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70]: /images/20220220/fec6d1ba7ec349a2bf523bcf798e071a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 1]: /images/20220220/5a47def141ca4e4bb19b568eb66b62f7.png