Netty实现文件下载和服务

发表时间:2017-09-13 14:57:33 浏览量( 21 ) 留言数( 0 )

学习目标:

1、掌握本节课得代码

2、加深Netty对Http协议得支持


学习过程:

    使用Netty实现使用HTTP协议对外提供服务。用户通过浏览器访问文件服务器,首先对URL进行检查,若失败返回403错误;若通过校验,以链接的方式打开当前目录,每个目录或文件都以超链接的形式展现,可递归访问,并下载文件。

1、看看我们使用到得handler

	ChannelPipeline pipeline = ch.pipeline();
	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(DEFAULT_URL));

2、HttpFileServerHandler是我们自定义

    
	private final String url;

    public HttpFileServerHandler(String url) {
    	this.url = url;
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
    	//对请求的解码结果进行判断:
		if (!request.decoderResult().isSuccess()) {
			// 400
		    sendError(ctx, BAD_REQUEST);
		    return;
		}
		//对请求方式进行判断:如果不是get方式(如post方式)则返回异常
		if (request.method() != GET) {
			// 405
		    sendError(ctx, METHOD_NOT_ALLOWED);
		    return;
		}
		//获取请求uri路径
		final String uri = request.uri();
		//对url进行分析,返回本地系统
		final String path = sanitizeUri(uri);
		//如果 路径构造不合法,则path为null
		if (path == null) {
			//403
		    sendError(ctx, FORBIDDEN);
		    return;
		}
		// 创建file对象
		File file = new File(path);
		// 判断文件是否为隐藏或者不存在
		if (file.isHidden() || !file.exists()) {
			// 404 
		    sendError(ctx, NOT_FOUND);
		    return;
		}
		// 如果为文件夹
		if (file.isDirectory()) {
		    if (uri.endsWith("/")) {
		    	//如果以正常"/"结束 说明是访问的一个文件目录:则进行展示文件列表(web服务端则可以跳转一个Controller,遍历文件并跳转到一个页面)
		    	sendListing(ctx, file);
		    } else {
		    	//如果非"/"结束 则重定向,补全"/" 再次请求
		    	sendRedirect(ctx, uri + '/');
		    }
		    return;
		}
		// 如果所创建的file对象不是文件类型
		if (!file.isFile()) {
			// 403
		    sendError(ctx, FORBIDDEN);
		    return;
		}
		
		//随机文件读写类
		RandomAccessFile randomAccessFile = null;
		try {
		    randomAccessFile = new RandomAccessFile(file, "r");// 以只读的方式打开文件
		} catch (FileNotFoundException fnfe) {
			// 404
		    sendError(ctx, NOT_FOUND);
		    return;
		}
		
		//获取文件长度
		long fileLength = randomAccessFile.length();
		//建立响应对象
		HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);
		//设置响应信息
		response.headers().set(HttpHeaderNames.CONTENT_LENGTH,fileLength);
		//设置响应头
		setContentTypeHeader(response, file);
		//如果一直保持连接则设置响应头信息为:HttpHeaders.Values.KEEP_ALIVE
		boolean keepAlive = HttpUtil.isKeepAlive(request);
		if (keepAlive) {
			response.headers().set(HttpHeaderNames.CONNECTION,HttpHeaderValues.KEEP_ALIVE);
		}
		//进行写出
		ctx.write(response);
		
		//构造发送文件线程,将文件写入到Chunked缓冲区中
		ChannelFuture sendFileFuture;
		//写出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.");
		    }
		});
		
		//如果使用Chunked编码,最后则需要发送一个编码结束的看空消息体,进行标记,表示所有消息体已经成功发送完成。
		ChannelFuture lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
		//如果当前连接请求非Keep-Alive ,最后一包消息发送完成后 服务器主动关闭连接
		if (!keepAlive) {
		    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);
		    ctx.close();
		}
    }

    //非法URI正则
    private static final Pattern INSECURE_URI = Pattern.compile(".*[<>&\"].*");

    /**
     * <B>方法名称:</B>解析URI<BR>
     * <B>概要说明:</B>对URI进行分析<BR>
     * @param uri netty包装后的字符串对象
     * @return path 解析结果
     */
    private String sanitizeUri(String uri) {
		try {
			//使用UTF-8字符集
		    uri = URLDecoder.decode(uri, "UTF-8");
		} catch (UnsupportedEncodingException e) {
		    try {
		    	//尝试ISO-8859-1
		    	uri = URLDecoder.decode(uri, "ISO-8859-1");
		    } catch (UnsupportedEncodingException e1) {
		    	//抛出预想外异常信息
		    	throw new Error();
		    }
		}
		// 对uri进行细粒度判断:4步验证操作
		// step 1 基础验证
		if (!uri.startsWith(url)) {
		    return null;
		}
		// step 2 基础验证
		if (!uri.startsWith("/")) {
		    return null;
		}
		// step 3 将文件分隔符替换为本地操作系统的文件路径分隔符
		uri = uri.replace('/', File.separatorChar);
		// step 4 二次验证合法性
		if (uri.contains(File.separator + '.')
			|| uri.contains('.' + File.separator) || uri.startsWith(".")
			|| uri.endsWith(".") || INSECURE_URI.matcher(uri).matches()) {
		    return null;
		}
		//当前工程所在目录 + URI构造绝对路径进行返回 
		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 ret = new StringBuilder();
		String dirPath = dir.getPath();
		ret.append("<!DOCTYPE html>\r\n");
		ret.append("<html><head><title>");
		ret.append(dirPath);
		ret.append(" 目录:");
		ret.append("</title></head><body>\r\n");
		ret.append("<h3>");
		ret.append(dirPath).append(" 目录:");
		ret.append("</h3>\r\n");
		ret.append("<ul>");
		ret.append("<li>链接:<a href=\"../\">..</a></li>\r\n");
		
		// 遍历文件 添加超链接
		for (File f : dir.listFiles()) {
			//step 1: 跳过隐藏或不可读文件 
		    if (f.isHidden() || !f.canRead()) {
		    	continue;
		    }
		    String name = f.getName();
		    //step 2: 如果不被允许,则跳过此文件
		    if (!ALLOWED_FILE_NAME.matcher(name).matches()) {
		    	continue;
		    }
		    //拼接超链接即可
		    ret.append("<li>链接:<a href=\"");
		    ret.append(name);
		    ret.append("\">");
		    ret.append(name);
		    ret.append("</a></li>\r\n");
		}
		ret.append("</ul></body></html>\r\n");
		//构造结构,写入缓冲区
		ByteBuf buffer = Unpooled.copiedBuffer(ret, CharsetUtil.UTF_8);
		//进行写出操作
		response.content().writeBytes(buffer);
		//重置写出区域
		buffer.release();
		//使用ctx对象写出并且刷新到SocketChannel中去 并主动关闭连接(这里是指关闭处理发送数据的线程连接)
		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对象写出并且刷新到SocketChannel中去 并主动关闭连接(这里是指关闭处理发送数据的线程连接)
		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对象写出并且刷新到SocketChannel中去 并主动关闭连接(这里是指关闭处理发送数据的线程连接)
    	ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }

    private static void setContentTypeHeader(HttpResponse response, File file) {
    	//使用mime对象获取文件类型
    	MimetypesFileTypeMap mimeTypesMap = new MimetypesFileTypeMap();
    	response.headers().set(CONTENT_TYPE, mimeTypesMap.getContentType(file.getPath()));
    }

}


3、启动类:

public class HttpServer {

private int port;


public HttpServer(int port) {

this.port = port;

}


public void run() throws Exception {

EventLoopGroup bossGroup = new NioEventLoopGroup(); //

EventLoopGroup workerGroup = new NioEventLoopGroup();

try {

ServerBootstrap b = new ServerBootstrap(); //

b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class) // 

.childHandler(new HttpPipelineInitializer(false)); // 


// 绑定端口,开始接收进来的连接

ChannelFuture f = b.bind(port).sync(); //


// 等待服务器 socket 关闭 。

// 在这个例子中,这不会发生,但你可以优雅地关闭你的服务器。

f.channel().closeFuture().sync();

} finally {

workerGroup.shutdownGracefully();

bossGroup.shutdownGracefully();

}

}


public static void main(String[] args) throws Exception {

int port;

if (args.length > 0) {

port = Integer.parseInt(args[0]);

} else {

port = 80;

}

new HttpServer(port).run();

}

}


效果

attcontent/ed6aacb6-6132-470e-8c76-cf9e0e48f5f4.png