基于Netty实现一个高性能下载服务，支持断点下载

最新推荐文章于 2025-04-09 08:10:26 发布

玛卡~巴卡

最新推荐文章于 2025-04-09 08:10:26 发布

阅读量967

点赞数 12

分类专栏： Java进阶文章标签： 1024程序员节 netty

本文链接：https://blog.csdn.net/qq_61635026/article/details/143210343

版权

Java进阶专栏收录该内容

15 篇文章

订阅专栏

文章目录

一、认识 Netty 框架
二、下载服务

一、认识 Netty 框架

1.1 什么是 Netty

Netty 是一个基于 Java NIO 的异步事件驱动的高性能网络应用框架。它简化了网络编程的复杂性，提供了一套丰富的 API，方便开发者构建高性能、可伸缩的网络应用。

Netty 的核心是非阻塞 I/O 模型，它能够处理大量并发连接，充分利用多核 CPU 提升程序性能。对于下载服务而言，Netty 的高并发、异步 I/O 特性可以显著提升下载效率，尤其是在处理大文件和多用户并发下载时。

1.2 Netty 的优势

高并发处理：基于事件驱动的非阻塞 I/O 模型，适合处理大量客户端的并发请求。
易扩展性：通过编写 Handler，可以灵活地处理不同类型的网络事件。
跨平台支持：支持多种协议如 HTTP、WebSocket 等，同时能够跨平台运行。

1.3 Netty 的核心组件

Channel：表示一个到目标地址的连接，负责读写操作。
EventLoop：管理 Channel 中的事件循环，负责处理 I/O 操作。
Handler：事件处理器，用于自定义数据处理逻辑。

通过合理地配置这些组件，Netty 能够实现高效的下载服务

二、下载服务

2.1 断点续传的概念

断点续传指的是在文件下载过程中，如果下载被中断，能够从中断的位置继续下载，而无需从头开始。对于大文件下载尤其重要，它能够减少不必要的带宽浪费，提高用户体验。

实现断点续传主要涉及到 HTTP 协议中的 Range 头字段。客户端通过设置该字段请求文件的特定字节段，服务器返回相应的部分数据。

2.2 基于 Netty 实现的断点下载思路

请求解析：通过 Netty 的 HttpRequestDecoder 解析 HTTP 请求，提取出 Range 头信息。
文件定位：根据 Range 请求头中的字节范围，打开目标文件并定位到相应的偏移位置。
分段传输：通过 Netty 的 Channel 进行数据的分段传输，将对应的字节流返回给客户端。

2.3 代码实现

2.3.1 引入依赖

首先，确保项目中引入了 Netty 相关依赖：

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.66.Final</version>
</dependency>

2.3.2 启动服务

public class NettyFileServer {

    public static void main(String[] args) {
        int port = 8080;

        String filePath = "C:/Users/xxx/Desktop/tmp";

        if(args.length == 2){
            port = Integer.parseInt(args[0]);

            filePath = args[1];
        }


        System.out.println("port: " + port);
        System.out.println("filePath: " + filePath);

        // 启动服务
        new NettyFileServer().bind(port, filePath);
    }

    private void bind(int port, String filePath){
        // 用于接收连接
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        // 用于处理连接
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // 用于启动服务
            ServerBootstrap bootstrap = new ServerBootstrap();

            // 设置两个线程组
            bootstrap.group(bossGroup, workerGroup)
                    // 设置服务端通道实现类型
                    .channel(NioServerSocketChannel.class)
                    // 初始化处理新连接的通道
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            // 获取通道pipeline
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            // 添加Http编解码器
                            pipeline.addLast(new HttpServerCodec());
                            // 添加Http聚合器
                            pipeline.addLast(new HttpObjectAggregator(65535));
                            // 添加ChunkedWriteHandler，用于大数据的分块传输
                            pipeline.addLast(new ChunkedWriteHandler());
                            // 添加自定义处理器
                            pipeline.addLast(new FileServerHandler(filePath));
                        }
                    });

            // 绑定端口并启动服务器
            ChannelFuture future = bootstrap.bind(port).sync();
            System.out.println("文件服务器启动成功，监听端口：" + port);
            // 等待服务器关闭
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 关闭两个线程组
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

在这段代码中，NettyFileServer 类负责启动整个文件下载服务。主要包括以下几个步骤：

主方法：读取参数并启动服务

main() 方法是程序的入口。它首先从命令行参数中读取端口号和文件目录，如果没有传入参数，则默认使用端口 8080 和路径 C:/Users/xxx/Desktop/tmp。然后，调用 bind() 方法启动服务。

绑定端口并启动服务器

bind() 方法是核心部分，它使用 Netty 框架来启动一个异步、非阻塞的文件服务器。

重要组件解释

NioEventLoopGroup：Netty 中的线程池。bossGroup 负责处理新连接，workerGroup 负责处理已经建立的连接及其 I/O 操作。
ServerBootstrap：Netty 的引导类，用于配置服务器的参数、处理器等。
NioServerSocketChannel：代表服务器端的 NIO 通道，它是基于 Java NIO 实现的非阻塞式通道。
ChannelInitializer：用于配置每个新连接的处理器。在 initChannel() 方法中，Netty 的 pipeline 会被初始化。pipeline 是一组处理器的链，数据沿着这条链依次处理。
HttpServerCodec：HTTP 编解码器，将字节流转换为 HTTP 请求或响应。
HttpObjectAggregator：将 HTTP 片段聚合为完整的消息，简化处理逻辑。
ChunkedWriteHandler：用于处理大文件的分块传输，防止内存溢出。
FileServerHandler：自定义的文件处理器，用于实现文件的下载逻辑，包括断点续传等功能。

2.3.3 处理HTTP请求

public class FileServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

    private final String FILE_PATH;

    private static final Pattern ALLOWED_FILE_NAME = Pattern.compile("[A-Za-z0-9][-_A-Za-z0-9.]*");
    public static final String HTTP_DATE_FORMAT = "EEE, dd MMM yyyy HH:mm:ss zzz";
    public static final String HTTP_DATE_GMT_TIMEZONE = "GMT";
    public static final int HTTP_CACHE_SECONDS = 60;
    public static SimpleDateFormat dateFormatter = new SimpleDateFormat(HTTP_DATE_FORMAT, Locale.US);
    private static final Pattern INSECURE_URI = Pattern.compile(".*[<>&\"].*");

    public FileServerHandler(String filePath) {
        this.FILE_PATH = filePath;
    }
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {

        String uri = request.uri();
        System.out.println("请求地址：" + uri);

        // 文件路径
        String path = sanitizeUri(uri);

        // uri 不合法, 拒绝访问
        if (path == null){
            sendError(ctx, HttpResponseStatus.FORBIDDEN);
            return;
        }

        File file = new File(path);

        if (file.isFile()) {
            // 下载文件请求
            download(ctx, request, file);

        } else if(file.isDirectory()){
            if (uri.endsWith("/")) {
                // 如果目录带 / ，则显示该目录下面的文件列表
                sendListing(ctx, file);
            } else {
                // 如果不带 / ，则添加一个 / , 重定向到该路径下
                sendRedirect(ctx, uri + '/');
            }
        } else {
            sendError(ctx, HttpResponseStatus.NOT_FOUND);
        }
    }

    private void download(ChannelHandlerContext ctx, FullHttpRequest request, File downloadedFilefile) throws IOException, ParseException {
        // 从uri中解析出文件名
        String fileName = downloadedFilefile.getName();

        String filePath = downloadedFilefile.getPath();

        if (HttpMethod.GET.equals(request.method())) {

            // 客户端缓存校验
            if (cacheValidation(ctx, request, downloadedFilefile))
                return;

            // 打开指定的文件
            RandomAccessFile raf = new RandomAccessFile(filePath, "r");
            long fileLength = raf.length();

            // 创建HTTP响应
            HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
            // 设置文件大小
            HttpUtil.setContentLength(response, fileLength);
            // 根据文件的类型，设置 Content-Type
            setContentTypeHeader(response, downloadedFilefile);
            // response.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/octet-stream");
            // 设置日期和缓存
            setDateAndCacheHeaders(response, downloadedFilefile);
            response.headers().set(HttpHeaderNames.CONTENT_DISPOSITION, "attachment; filename=" + fileName);

            // 设置是否保持连接
            if (isKeepAlive(request)) {
                response.headers().set(CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
            }

            // 获取HTTP 请求中的 Range 头信息，处理断点续传。例如 Range: bytes=0-1023
            String rangeHeader = request.headers().get(HttpHeaderNames.RANGE); //
            if (rangeHeader != null) {
                // 解析Range头部信息，获取起始字节和结束字节
                String[] ranges = rangeHeader.split("=")[1].split("-");
                long start = Long.parseLong(ranges[0]); // 范围的起始字节位置
                // 如果Range头部指定了结束字节，则使用指定的结束字节；否则使用文件的最后一个字节位置
                long end = ranges.length > 1 ? Long.parseLong(ranges[1]) : fileLength - 1;

                // 设置HTTP响应状态为 206 Partial Content，表示响应的是文件的部分内容
                response.setStatus(HttpResponseStatus.PARTIAL_CONTENT);
                // 设置响应的Content-Length头，指示下载内容的长度
                HttpUtil.setContentLength(response, end - start + 1);
                // 设置响应的Content-Range头，指示响应的内容范围
                response.headers().set(HttpHeaderNames.CONTENT_RANGE, "bytes " + start + "-" + end + "/" + fileLength);

                // 将文件读取指针移动到起始字节位置
                raf.seek(start);

                // 将响应头部写入到响应流中
                ctx.write(response);
                // 创建ChunkedFile对象，从文件的起始字节位置开始，读取指定长度的文件内容并写入到响应流中
                ctx.write(new ChunkedFile(raf, start, end - start + 1, 8192), ctx.newProgressivePromise());
            } else {
                // 普通下载
                ctx.write(response);
                // 零拷贝
                ctx.write(new DefaultFileRegion(raf.getChannel(), 0, fileLength), ctx.newProgressivePromise());
                // ctx.write(new ChunkedFile(file, 0, fileLength, 8192), ctx.newProgressivePromise());
            }

            // 发送响应并关闭连接
            ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT).addListener(ChannelFutureListener.CLOSE);
        } else {
            sendError(ctx, HttpResponseStatus.METHOD_NOT_ALLOWED);
        }
    }


    /**
     * 客户端缓存校验
     */
    private static boolean cacheValidation(ChannelHandlerContext ctx, FullHttpRequest request, File file) throws ParseException {
        // 获取客户端缓存的修改日期
        String ifModifiedSince = request.headers().get(IF_MODIFIED_SINCE);
        if (ifModifiedSince != null && !ifModifiedSince.isEmpty()) {
            // 格式化日期
            Date ifModifiedSinceDate = dateFormatter.parse(ifModifiedSince);
            // 将日期转换为秒
            long ifModifiedSinceDateSeconds = ifModifiedSinceDate.getTime() / 1000;
            // 获取文件的最后修改时间, 并将其转换为秒
            long fileLastModifiedSeconds = file.lastModified() / 1000;
            // 如果客户端提供的时间与文件的最后修改时间相同，说明缓存有效
            if (ifModifiedSinceDateSeconds == fileLastModifiedSeconds) {
                sendNotModified(ctx);
                return true;
            }
        }
        // 缓存无效
        return false;
    }

    /**
     * 发送向客户端响应发送 304
     * @param ctx
     */
    private static void sendNotModified(ChannelHandlerContext ctx) {
        FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, NOT_MODIFIED);

        // 创建日期格式
        dateFormatter.setTimeZone(TimeZone.getTimeZone(HTTP_DATE_GMT_TIMEZONE));

        Calendar time = new GregorianCalendar();
        response.headers().set(DATE, dateFormatter.format(time.getTime()));

        // 发送完成后关闭连接
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }

    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("文件下载");
        buf.append("</title></head><body>\r\n");

        buf.append("<h3>当前路径: ");
        buf.append(dirPath);
        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);
    }


    // 验证uri是否合法
    private String sanitizeUri(String uri) {
        // 解码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();
            }
        }

        uri = uri.replace('/', File.separatorChar);

        // 验证uri是否合法
        if (uri.contains(File.separator + '.') ||
                uri.contains('.' + File.separator) ||
                uri.startsWith(".") || uri.endsWith(".") ||
                INSECURE_URI.matcher(uri).matches()) {
            return null;
        }

        // 构建文件路径
        return FILE_PATH + File.separator + uri;
    }

    private static void setContentTypeHeader(HttpResponse response, File file) {
        MimetypesFileTypeMap mimeTypesMap = new MimetypesFileTypeMap();
        response.headers().set(CONTENT_TYPE, mimeTypesMap.getContentType(file.getPath()));
    }

    private void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) {
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status,
                Unpooled.copiedBuffer("Failure: " + status + "\r\n", java.nio.charset.StandardCharsets.UTF_8));
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8");
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        if (ctx.channel().isActive()) {
            sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR);
        }
    }

    // 设置日期和缓存头
    private static void setDateAndCacheHeaders(HttpResponse response, File fileToCache) {

        dateFormatter.setTimeZone(TimeZone.getTimeZone(HTTP_DATE_GMT_TIMEZONE));

        // 设置日期
        Calendar time = new GregorianCalendar();
        response.headers().set(DATE, dateFormatter.format(time.getTime()));

        // 设置缓存
        time.add(Calendar.SECOND, HTTP_CACHE_SECONDS);
        response.headers().set(EXPIRES, dateFormatter.format(time.getTime()));
        response.headers().set(CACHE_CONTROL, "private, max-age=" + HTTP_CACHE_SECONDS);
        response.headers().set(LAST_MODIFIED, dateFormatter.format(new Date(fileToCache.lastModified())));
    }
}

在这部分代码中，FileServerHandler 类负责处理客户端的 HTTP 请求，特别是文件下载的请求。这个处理器继承自 SimpleChannelInboundHandler<FullHttpRequest>，并根据请求的类型和 URI 提供相应的响应。

URI 检查与清理

在 channelRead0() 方法中，服务器首先获取请求的 URI，并通过 sanitizeUri() 方法对其进行检查与清理。这个方法确保 URI 是合法的，并且不会包含潜在的安全风险（例如通过 . 和 .. 来访问系统的敏感文件）。如果 URI 不合法，服务器会返回一个 403 Forbidden 错误响应。

String path = sanitizeUri(uri);

// uri 不合法, 拒绝访问
if (path == null){
    sendError(ctx, HttpResponseStatus.FORBIDDEN);
    return;
}

文件类型处理

根据 URI 指向的路径，服务器会判断这是一个文件还是一个目录：

如果是文件，则调用 download() 方法处理文件的下载请求。
如果是目录，并且 URI 以 / 结尾，服务器会列出该目录中的文件列表。
如果是目录，但 URI 不以 / 结尾，服务器会进行重定向。

if (file.isFile()) {
    download(ctx, request, file);
} else if(file.isDirectory()){
    if (uri.endsWith("/")) {
        sendListing(ctx, file);
    } else {
        sendRedirect(ctx, uri + '/');
    }
}

文件下载与断点续传

在 download() 方法中，服务器处理了完整文件下载和断点续传两种情况：

如果请求头中包含 Range 字段，则表示客户端要求断点续传。服务器通过解析 Range 头信息，获取请求的文件片段范围，并只返回该部分数据，响应状态码为 206 Partial Content。

String rangeHeader = request.headers().get(HttpHeaderNames.RANGE); 
if (rangeHeader != null) {
    String[] ranges = rangeHeader.split("=")[1].split("-");
    long start = Long.parseLong(ranges[0]); 
    long end = ranges.length > 1 ? Long.parseLong(ranges[1]) : fileLength - 1;
    
    response.setStatus(HttpResponseStatus.PARTIAL_CONTENT);
    HttpUtil.setContentLength(response, end - start + 1);
    response.headers().set(HttpHeaderNames.CONTENT_RANGE, "bytes " + start + "-" + end + "/" + fileLength);

    raf.seek(start);
    ctx.write(response);
    ctx.write(new ChunkedFile(raf, start, end - start + 1, 8192), ctx.newProgressivePromise());
}

如果请求中没有 Range 头，则服务器会返回整个文件，使用 DefaultFileRegion 进行零拷贝传输以提高传输效率。

ctx.write(response);
ctx.write(new DefaultFileRegion(raf.getChannel(), 0, fileLength), ctx.newProgressivePromise());

缓存与客户端校验

为了减少重复的下载请求，服务器实现了缓存机制。通过 If-Modified-Since 头字段，客户端可以校验本地缓存是否过期。如果文件自客户端缓存以来未被修改，服务器会返回 304 Not Modified，告诉客户端使用本地缓存。

String ifModifiedSince = request.headers().get(IF_MODIFIED_SINCE);
if (ifModifiedSince != null && !ifModifiedSince.isEmpty()) {
    Date ifModifiedSinceDate = dateFormatter.parse(ifModifiedSince);
    long ifModifiedSinceDateSeconds = ifModifiedSinceDate.getTime() / 1000;
    long fileLastModifiedSeconds = file.lastModified() / 1000;
    if (ifModifiedSinceDateSeconds == fileLastModifiedSeconds) {
        sendNotModified(ctx);
        return;
    }
}

错误处理与其他方法

在整个文件传输过程中，错误处理至关重要。例如，当客户端请求了不存在的文件时，服务器会返回 404 Not Found。如果 URI 不合法或文件无法访问，服务器会返回 403 Forbidden。

此外，服务器提供了目录的 HTML 列表展示功能，通过 sendListing() 方法生成简单的文件列表，方便用户在浏览器中查看可下载的文件。

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");
    // 构建 HTML 文件列表
}