06-netty之http之檔案伺服器

阿新 • • 發佈：2019-02-01

Netty是一個NIO框架，讓你快速、簡單的的開發網路應用。它是一種新的開發網路應用的方式，使得開發網路應用更加簡單，容易擴充套件。它隱藏了許多複雜的細節，並提供簡單的api讓你的業務邏輯和網路處理程式碼分離開來。Netty的所有api都是非同步的，如果大家不瞭解非同步IO,可以先學習一下非同步IO方面的知識。

package 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;

/**
 * @author lilinfeng
 * @date 2014年2月14日
 * @version 1.0
 */
public class HttpFileServer {

    // 這裡目錄要寫完整的相對路徑，包括main/java
    private static final String DEFAULT_URL = "/src/main/java/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());
                    ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(65536));
                    // 新增HTTP響應編碼器，對HTTP響應訊息進行編碼
                    ch.pipeline().addLast("http-encoder", new HttpResponseEncoder());
                    // 新增Chunked handler，主要作用是支援非同步傳送大的碼流（例如大檔案傳輸）
                    // 但是不佔用過多的記憶體，防止發生java記憶體溢位錯誤
                    ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
                    // HttpFileServerHandler用於檔案伺服器的業務邏輯處理
                    ch.pipeline().addLast("fileServerHandler", new HttpFileServerHandler(url));
                }
            });
        String host = "127.0.0.1";
        ChannelFuture future = b.bind(host, port).sync();
        System.out.println("HTTP檔案目錄伺服器啟動，網址是 : http://" + host +":" + port + url);
        future.channel().closeFuture().sync();
    } finally {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
    }

    public static void main(String[] args) throws Exception {
    int port = 8081;
    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);
    }
}

package 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 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;

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;

/**
 * @author lilinfeng
 * @date 2014年2月14日
 * @version 1.0
 */
public class HttpFileServerHandler extends
    SimpleChannelInboundHandler<FullHttpRequest> {
    private final String url;

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

    /**
     *   DefaultFullHttpRequest, decodeResult: success)
     *   GET /src/main/java/netty/ HTTP/1.1
     *   Host: 127.0.0.1:8081
     *   Connection: keep-alive
     *   Cache-Control: max-age=0
     *   User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36
     *   Upgrade-Insecure-Requests: 1
     *   Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*;q=0.8
     *   Accept-Encoding: gzip, deflate, br
     *   Accept-Language: zh-CN,zh;q=0.9
     *   Content-Length: 0
     *
     *
     *   DefaultFullHttpRequest, decodeResult: success)
     *   GET /favicon.ico HTTP/1.1
     *   Host: 127.0.0.1:8081
     *   Connection: keep-alive
     *   Pragma: no-cache
     *   Cache-Control: no-cache
     *   User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.96 Safari/537.36
     *   Accept: image/webp,image/*,*;q=0.8
     *   Referer: http://127.0.0.1:8081/src/main/java/netty/
     *   Accept-Encoding: gzip, deflate, sdch, br
     *   Accept-Language: zh-CN,zh;q=0.8
     *   Content-Length: 0
     *
     *   這裡發現，每次重新整理，或者點選都會有兩個請求，很鬱悶？
     *   瀏覽器每次發起請求，都會同時請求一次favicon.ico（本次不討論瀏覽器快取了favicon.ico）
     *
    */
    @Override
    public void messageReceived(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {

        // 過濾掉瀏覽器每次發起請求，都會同時請求一次favicon.ico
        if(request.getUri().equals("/favicon.ico")){
            return;
        }

        System.out.println("伺服器接受訊息"+request);

        // 首先對HTTP請求小弟的解碼結果進行判斷，如果解碼失敗，直接構造HTTP 400錯誤返回。
        if (!request.getDecoderResult().isSuccess()) {
            sendError(ctx, BAD_REQUEST);
            return;
        }
        // 請求方法：如果不是從瀏覽器或者表單設定為get請求，構造http 405錯誤返回
        if (request.getMethod() != GET) {
            sendError(ctx, METHOD_NOT_ALLOWED);
            return;
        }
        // 對請求的的URL進行包裝
        final String uri = request.getUri();
        // 展開URL分析
        final String path = sanitizeUri(uri);


        if (path == null) {
            sendError(ctx, FORBIDDEN);
            return;
        }
        File file = new File(path);
        // 如果檔案不存在或者是系統隱藏檔案，則構造404 異常返回
        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;
        }

        // IE下才會開啟檔案，其他瀏覽器都是直接下載
        // 隨機檔案讀寫類以讀的方式開啟檔案
        RandomAccessFile randomAccessFile = null;
        try {
            randomAccessFile = new RandomAccessFile(file, "r");// 以只讀的方式開啟檔案
        } catch (FileNotFoundException fnfe) {
            sendError(ctx, NOT_FOUND);
            return;
        }
        // 獲取檔案長度，構建成功的http應答訊息
        long fileLength = randomAccessFile.length();
        HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);
        setContentLength(response, fileLength);
        setContentTypeHeader(response, file);
        if (isKeepAlive(request)) {
            response.headers().set(CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
        }
        ctx.write(response);


        ChannelFuture sendFileFuture;
        // 同過netty的村可多File物件直接將檔案寫入到傳送緩衝區，最後為sendFileFeature增加GenericFeatureListener，
        // 如果傳送完成，列印“Transfer complete”
        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);

        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(".*[<>&\"].*");

    private String sanitizeUri(String uri) {


        try {
            // 使用JDK的URLDecoder進行解碼
            uri = URLDecoder.decode(uri, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            try {
            uri = URLDecoder.decode(uri, "ISO-8859-1");
            } catch (UnsupportedEncodingException e1) {
            throw new Error();
            }
        }
        // URL合法性判斷
        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\\.]*");

    /**
     * 這裡是構建了一個html頁面返回給瀏覽器
     * @param ctx
     * @param dir
     */
    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()));
    }
}

這裡寫圖片描述

06-netty之http之檔案伺服器

Netty是一個NIO框架，讓你快速、簡單的的開發網路應用。它是一種新的開發網路應用的方式，使得開發網路應用更加簡單，容易擴充套件。它隱藏了許多複雜的細節，並提供簡單的api讓你的業務邏輯和網路處理程式碼分離開來。Netty的所有api都是非同步的，如果大家不瞭

Socket+執行緒池實現簡單http單檔案伺服器

import java.io.*; import java.net.*; import java.nio.charset.Charset; import java.nio.file.*; import java.util.concurrent.*; impor

netty之Http伺服器

1. netty可以做的事情 netty可以作為RPC的通訊框架 netty作為長連線伺服器(websockt) netty也可以作為http伺服器(不是基於servlet規範) 2. netty的Hello World(Http伺服器) im

檔案伺服器之NFS伺服器

NFS(Network File System)，它的目的就是想讓不同的機器，不同的作業系統可以彼此共享資料檔案，目前在Unix like當中用來作為檔案伺服器是一個相當不錯的解決方案，基本上Unix like主機連線到另一臺Unix like主機來共享彼此的檔案時，使用NFS要比SAMBA伺服器快速且方便的

LINUX檔案伺服器之二：NFS伺服器

什麼是NFS？？？ NFS為Network File System的簡稱，它的目的就是讓不同的機器，不同的作業系統可以彼此共享資料。網路檔案系統 (NFS) 是 Unix 系統和網路附加儲存檔案管理器常用的網路檔案系統 , 允許多個客戶端通過網路共享檔案訪問。它可用於提供對共享二進位制目錄

圖解HTTP之與HTTP協作的Web伺服器（五）

一臺 Web 伺服器可搭建多個獨立域名的 Web 網站，也可作為通訊路徑上的中轉伺服器提升傳輸效率。 HTTP/1.1 規範允許一臺 HTTP 伺服器搭建多個 Web 站點。在相同的IP地址下，由於虛擬主機可以寄存多個不同主機名和域名的Web網址，因此在傳送HTTP請求時，必須在Ho

Jetty實戰之嵌入式執行Jetty實現簡單檔案伺服器

本文連結：http://blog.csdn.net/kongxx/article/details/7224423對於嵌入式執行Jetty，可以通過簡單的一些程式碼實現一個簡單的檔案伺服器的功能，如下：package com.google.code.garbagecan.jett

NodeJS伺服器篇之簡單靜態檔案合併

NodeJS是一個基於Chrome V8引擎的JavaScript執行環境，其使用了事件驅動、非同步I/O機制，具有執行速度快，效能優異等特點，非常適合在分散式裝置上執行資料密集型的實時應用。本文主要介紹一下通過搭建簡單的NodeJS伺服器，實現靜態檔案的合

HelloCpp開發日記：網站效能優化之檔案伺服器分離技術

閒來無事跟朋友折騰了一個山寨百衲本的網站HelloCpp(http://www.hellocpp.net)。介面我們都是外行，反正基本就是活脫脫一個山寨的www.codeproject.com。不過開發過程中還是蠻有一些心得的。現在寫出來跟大家分享。有不對的地方請大家多多建議。網站效能優化

web伺服器與檔案伺服器分離之磁碟對映

1.磁碟對映（1）將要被對映的檔案伺服器上存放上傳檔案的資料夾共享（2）開啟web伺服器計算機中的我的電腦，點選“對映網路驅動器” （3）在彈出的對話方塊中輸入檔案伺服器的

Tornado原始碼分析之http伺服器篇

一. Tornado是什麼? Facebook釋出了開源網路伺服器框架Tornado，該平臺基於Facebook剛剛收購的社交聚合網站FriendFeed的實時資訊服務開發而來.Tornado由Python編寫，是一款輕量級的Web伺服器，同時又是一個開發框架。採用非阻

分享Windows伺服器網站檔案同步備份解決方案之cwRsyn進行檔案同步

本文和大家分享Windows伺服器網站檔案同步備份解決方案，來自部落格園dudu的文章。對於一個網站來說，使用者上傳檔案的同步備份是必需要解決的問題。對於有著巨量上傳檔案的大型網站，一般採用分散式儲存系統。而對於上傳檔案量不是很大的網站，只要在另外一臺伺服器上儲存上傳檔案的同

鳥哥的Linux私房菜(伺服器)- 第十六章、檔案伺服器之二： SAMBA 伺服器

時至今日，印表機的網路功能已經很強悍了！甚至也有支援無線網路的印表機，因此每臺印表機都可以獨立作為各個 PC 的獨自的印表機，老實說也沒有必要進行 Samba 的網路印表機伺服器啦！但畢竟還是有些比較舊型的機種，或者買不起有內建網路的印表機時，那麼 Samba 的印表機伺服器還是有存在的價值囉。在

從零編寫c++之http伺服器(3)-http服務

http全稱超文字傳輸協議，可除錯性高，擴充套件性也強。上兩個篇章我們已經擁有了epoll事件驅動框架和執行緒池處理網路事件，接下來我們要先寫一個基礎網路套接字，然後在此基礎上擴展出http的套接字。獻上類圖如下

Android與伺服器端通訊方式（一）之HTTP、TCP、Socket

Android作為客戶端，與伺服器的通訊方式主要有兩種：一種是HTTP通訊，一種是Socket通訊。一、HTTP、Socket簡介 HTTP通訊：即使用HTTP協議進行通訊，工作原理是客戶端向伺服器端傳送一條HTTP請求，伺服器收到之後先解析客戶

電商專案之springmvc實現檔案上傳到FTP伺服器（超級重點）

1、前端（name的值和介面的@RequestParam的value相同，並且enctype為multipart/form-data） springmvc檔案上傳到ftp伺服器 <form name="form1" action="/manage/product/upload.do" me

【初學與研發之NETTY】netty4之檔案上傳

客戶端： public class UpLoadClient { private StringBuffer resultBuffer = new StringBuffer(); private EventLoopGroup group = null; private

nodejs之http、fs、querystring模組實現網頁與伺服器的互動

一.實現瀏覽器端請求之後，伺服器響應開啟相應的靜態網頁內容：思路：直接通過瀏覽器端輸入的url值來判斷，從而顯示出該url對應的網頁的內容。直接在配置伺服器的js程式碼裡寫出靜態頁面的內容： //前端頁面和伺服器未分離 var http = requir

【初學與研發之NETTY】netty3之檔案上傳

客戶端： package netty3.socket.client; import static org.jboss.netty.channel.Channels.pipeline; import java.io.File; import java.net.InetSo

lwip之http伺服器

準備工作： 1、下載一個網頁檔案。 2、下載winhex，用winhex開啟網頁檔案，將網頁檔案轉換成c陣列。具體操作如下： Edit--->Copy All------>C Source 這樣操作後，轉換成的c陣列就被複制到剪下板了。開啟一個記事本就可以將陣列貼上進去。 lwip相關操作：

06-netty之http之檔案伺服器

相關推薦