AI 助理
备案控制台
开发者社区 云计算 文章 正文

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

2021-12-02 175
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 通过学习搭建一个简单的文件服务器，使用http协议对外提供服务，当客户端通过浏览器访问文件服务器时，对访问路径进行检查，检查失败时返回403错误，该页无法访问，如果校验通过，以链接的方式打开当前文件目录，每个目录下是超链接，可以递归访问，如果是文件则下载。


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

代码实现

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()));
  }
}

测试效果

地址输出错的请求

image.png

访问成功

image.png

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


文章标签：
云数据库 ClickHouse
关键词：
HTTP协议
HTTPS协议
Netty入门
Netty服务端
Netty http
游客a74jvhcp7vclg
目录
相关文章
LALA
|
2月前
|
缓存 应用服务中间件 网络安全
Nginx中配置HTTP2协议的方法
Nginx中配置HTTP2协议的方法
LALA
125 7
蓝易云
|
13天前
|
域名解析 缓存 网络协议
Web基础与HTTP协议
通过掌握这些基础知识和技术，开发者可以更加高效地构建和优化Web应用，提供更好的用户体验和系统性能。
蓝易云
64 15
三三是该溜子
|
8天前
|
前端开发 网络协议 安全
【网络原理】——HTTP协议、fiddler抓包
HTTP超文本传输，HTML，fiddler抓包，URL，urlencode,HTTP首行方法，GET方法，POST方法
三三是该溜子
40 9
猫林老师
|
10天前
|
JSON Dart 前端开发
鸿蒙应用开发从入门到入行 - 篇7：http网络请求
在本篇文章里，您将掌握鸿蒙开发工具DevEco的基本使用、ArkUI里的基础组件，并通过制作一个简单界面掌握使用
猫林老师
47 8
技术内容小助手
|
10天前
|
缓存 网络协议 算法
从零开始掌握HTTP协议
本文介绍HTTP协议的演变，从HTTP1.0到HTTP2.0。HTTP1.0为无状态连接，每次请求独立；HTTP1.1引入持久连接、管道化请求和更多状态码；HTTP2.0采用二进制分帧、多路复用、头部压缩及服务器主动推送，大幅提升性能与用户体验。了解这些区别有助于开发者优化应用和服务。
技术内容小助手
48 2
栈江湖
|
11天前
|
网络协议 安全 网络安全
探索网络模型与协议：从OSI到HTTPs的原理解析
OSI七层网络模型和TCP/IP四层模型是理解和设计计算机网络的框架。OSI模型包括物理层、数据链路层、网络层、传输层、会话层、表示层和应用层，而TCP/IP模型则简化为链路层、网络层、传输层和 HTTPS协议基于HTTP并通过TLS/SSL加密数据，确保安全传输。其连接过程涉及TCP三次握手、SSL证书验证、对称密钥交换等步骤，以保障通信的安全性和完整性。数字信封技术使用非对称加密和数字证书确保数据的机密性和身份认证。 浏览器通过Https访问网站的过程包括输入网址、DNS解析、建立TCP连接、发送HTTPS请求、接收响应、验证证书和解析网页内容等步骤，确保用户与服务器之间的安全通信。
栈江湖
57 1
阿里云云原生
|
2月前
|
Dubbo 安全 应用服务中间件
Apache Dubbo 正式发布 HTTP/3 版本 RPC 协议，弱网效率提升 6 倍
在 Apache Dubbo 3.3.0 版本之后，官方推出了全新升级的 Triple X 协议，全面支持 HTTP/1、HTTP/2 和 HTTP/3 协议。本文将围绕 Triple 协议对 HTTP/3 的支持进行详细阐述，包括其设计目标、实际应用案例、性能测试结果以及源码架构分析等内容。
阿里云云原生
189 7
sunrr
|
2月前
|
安全 搜索推荐 网络安全
HTTPS协议是**一种通过计算机网络进行安全通信的传输协议
HTTPS协议是**一种通过计算机网络进行安全通信的传输协议
sunrr
70 11
sunrr
|
2月前
|
缓存 安全 网络协议
HTTPS协议的历史发展
HTTPS协议的历史发展
sunrr
48 8
sunrr
|
2月前
|
安全 应用服务中间件 Linux
判断一个网站是否使用HTTPS协议
判断一个网站是否使用HTTPS协议
sunrr
81 4

热门文章

最新文章

  • 1
    Nettyの网络聊天室&扩展序列化算法
  • 2
    如何给IP地址添加SSL证书（https）
  • 3
    内网/局域网IP地址申请https证书方法
  • 4
    信息检索和信息提取的区别 原文出自[易百教程] 转载请保留原文链接: https://www.yiibai.com/geek/331046
  • 5
    Servlet+MySQL增删改查 原文出自[易百教程] 转载请保留原文链接: https://www.yiibai.com/geek/1391
  • 6
    ip地址https证书免费试用—政企单位专用
  • 7
    单模和多模光纤电缆的区别 原文出自[易百教程] 转载请保留原文链接: https://www.yiibai.com/geek/330968
  • 8
    HTTPS协议是**一种通过计算机网络进行安全通信的传输协议
  • 9
    免费泛域名https证书教程—无限免费续签
  • 10
    IP地址能否申请HTTPS证书？
  • 1
    【网络安全 | 网络协议】一文讲清HTTP协议
    154
  • 2
    socket，tcp，http三者之间的原理和区别
    70
  • 3
    Linux命令发送http
    109
  • 4
    http-server实现本地服务器
    162
  • 5
    干货｜代理IP协议有何区别？深入了解 SOCKS5、HTTP 代理
    70
  • 6
    干货｜代理IP协议有何区别？深入了解 SOCKS5、HTTP 代理
    345
  • 7
    对于Android的http请求的容错管理
    40
  • 8
    android通过http上传文件，服务器端用php写(原创)
    72
  • 9
    Java中如何通过代理实现对HTTP2网站的访问？
    101
  • 10
    常见的http状态码
    46

    • 相关课程

    更多
  • Java Web开发-Web应用、Tomcat、HTTP请求与响应
  • 云安全基础课- HTTP协议基础

    • 相关电子书

    更多
  • 阿里巴巴HTTP 2.0实践及无线通信协议的演进之路
  • CDN助力企业网站进入HTTPS时代
  • 低代码开发师（初级）实战教程

    • 相关实验场景

    更多
  • 通过轻量消息队列（原MNS）主题HTTP订阅+ARMS实现自定义数据多渠道告警
  • 通过HTTPS加速网关快速部署网站加密
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月