Netty学习(十)-Netty文件上传(1)，2024年最新阿里+头条+腾讯大厂Linux运维笔试真题

最新推荐文章于 2024-05-16 13:48:44 发布

2401_83621499

最新推荐文章于 2024-05-16 13:48:44 发布

阅读量705

点赞数 9

分类专栏： 2024年程序员学习文章标签：运维 linux 学习

本文链接：https://blog.csdn.net/2401_83621499/article/details/137781758

版权

2024年程序员学习专栏收录该内容

291 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Linux运维全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上运维知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注运维）

正文

public void setEndPos(int endPos) {
    this.endPos = endPos;
}

public byte[] getBytes() {
    return bytes;
}

public void setBytes(byte[] bytes) {
    this.bytes = bytes;
}

public File getFile() {
    return file;
}

public void setFile(File file) {
    this.file = file;
}

public String getFile\_md5() {
    return file_md5;
}

public void setFile\_md5(String file_md5) {
    this.file_md5 = file_md5;
}

}


输出为：

块儿长度：894
长度：8052
-----------------------------894
byte 长度：894
块儿长度：894
长度：7158
-----------------------------894
byte 长度：894
块儿长度：894
长度：6264
-----------------------------894
byte 长度：894
块儿长度：894
长度：5370
-----------------------------894
byte 长度：894
块儿长度：894
长度：4476
-----------------------------894
byte 长度：894
块儿长度：894
长度：3582
-----------------------------894
byte 长度：894
块儿长度：894
长度：2688
-----------------------------894
byte 长度：894
块儿长度：894
长度：1794
-----------------------------894
byte 长度：894
块儿长度：894
长度：900
-----------------------------894
byte 长度：894
块儿长度：894
长度：6
-----------------------------6
byte 长度：6
块儿长度：894
长度：0
-----------------------------0
文件已经读完--------0

Process finished with exit code 0


这样就实现了服务器端文件的上传，当然我们也可以使用http的形式。


server端：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class HttpFileServer implements Runnable {
private int port;

public HttpFileServer(int port) {
    super();
    this.port = port;
}

@Override
public void run() {
    EventLoopGroup bossGroup = new NioEventLoopGroup(1);
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    ServerBootstrap serverBootstrap = new ServerBootstrap();
    serverBootstrap.group(bossGroup, workerGroup);
    serverBootstrap.channel(NioServerSocketChannel.class);
    //serverBootstrap.handler(new LoggingHandler(LogLevel.INFO));
    serverBootstrap.childHandler(new HttpChannelInitlalizer());
    try {
        ChannelFuture f = serverBootstrap.bind(port).sync();
        f.channel().closeFuture().sync();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

public static void main(String[] args) {
    HttpFileServer b = new HttpFileServer(9003);
    new Thread(b).start();
}

}


Server端initializer：

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.stream.ChunkedWriteHandler;

public class HttpChannelInitlalizer extends ChannelInitializer {

@Override
protected void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    pipeline.addLast(new HttpServerCodec());
    pipeline.addLast(new HttpObjectAggregator(65536));
    pipeline.addLast(new ChunkedWriteHandler());
    pipeline.addLast(new HttpChannelHandler());
}

}


server端hadler：

import static io.netty.handler.codec.http.HttpHeaders.Names.CONTENT_TYPE;
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.INTERNAL_SERVER_ERROR;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
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.HttpChunkedInput;
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.HttpVersion;
import io.netty.handler.codec.http.LastHttpContent;
import io.netty.handler.stream.ChunkedFile;
import io.netty.util.CharsetUtil;
import io.netty.util.internal.SystemPropertyUtil;

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;

public class HttpChannelHandler extends SimpleChannelInboundHandler {
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;

@Override
protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
    // 监测解码情况
    if (!request.getDecoderResult().isSuccess()) {
        sendError(ctx, BAD_REQUEST);
        return;
    }
    final String uri = request.getUri();
    final String path = sanitizeUri(uri);
    System.out.println("get file："+path);
    if (path == null) {
        sendError(ctx, FORBIDDEN);
        return;
    }
    //读取要下载的文件
    File file = new File(path);
    if (file.isHidden() || !file.exists()) {
        sendError(ctx, NOT_FOUND);
        return;
    }
    if (!file.isFile()) {
        sendError(ctx, FORBIDDEN);
        return;
    }
    RandomAccessFile raf;
    try {
        raf = new RandomAccessFile(file, "r");
    } catch (FileNotFoundException ignore) {
        sendError(ctx, NOT_FOUND);
        return;
    }
    long fileLength = raf.length();
    HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
    HttpHeaders.setContentLength(response, fileLength);
    setContentTypeHeader(response, file);
    //setDateAndCacheHeaders(response, file);
    if (HttpHeaders.isKeepAlive(request)) {
        response.headers().set("CONNECTION", HttpHeaders.Values.KEEP_ALIVE);
    }

    // Write the initial line and the header.
    ctx.write(response);

    // Write the content.
    ChannelFuture sendFileFuture =
    ctx.write(new HttpChunkedInput(new ChunkedFile(raf, 0, fileLength, 8192)), ctx.newProgressivePromise());
    //sendFuture用于监视发送数据的状态
    sendFileFuture.addListener(new ChannelProgressiveFutureListener() {
        @Override
        public void operationProgressed(ChannelProgressiveFuture future, long progress, long total) {
            if (total < 0) { // total unknown
                System.err.println(future.channel() + " Transfer progress: " + progress);
            } else {
                System.err.println(future.channel() + " Transfer progress: " + progress + " / " + total);
            }
        }

        @Override
        public void operationComplete(ChannelProgressiveFuture future) {
            System.err.println(future.channel() + " Transfer complete.");
        }
    });

    // Write the end marker
    ChannelFuture lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);

    // Decide whether to close the connection or not.
    if (!HttpHeaders.isKeepAlive(request)) {
        // Close the connection when the whole content is written out.
        lastContentFuture.addListener(ChannelFutureListener.CLOSE);
    }
}

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

private static final Pattern INSECURE_URI = Pattern.compile(".\*[<>&\"].\*");

private static String sanitizeUri(String uri) {
    // Decode the path.
    try {
        uri = URLDecoder.decode(uri, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        throw new Error(e);
    }

    if (!uri.startsWith("/")) {
        return null;
    }

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

    // Simplistic dumb security check.
    // You will have to do something serious in the production environment.
    if (uri.contains(File.separator + '.') || uri.contains('.' + File.separator) || uri.startsWith(".") || uri.endsWith(".")
            || INSECURE_URI.matcher(uri).matches()) {
        return null;
    }

    // Convert to absolute path.
    return SystemPropertyUtil.get("user.dir") + File.separator + uri;
}


private static void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) {
    FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, status, Unpooled.copiedBuffer("Failure: " + status + "\r\n", CharsetUtil.UTF_8));
    response.headers().set(CONTENT_TYPE, "text/plain; charset=UTF-8");

    // Close the connection as soon as the error message is sent.
    ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
}

/\*\*

* Sets the content type header for the HTTP Response
*
* @param response
* HTTP response
* @param file
* file to extract content type
*/
private static void setContentTypeHeader(HttpResponse response, File file) {
MimetypesFileTypeMap m = new MimetypesFileTypeMap();
String contentType = m.getContentType(file.getPath());
if (!contentType.equals(“application/octet-stream”)) {
contentType += “; charset=utf-8”;
}
response.headers().set(CONTENT_TYPE, contentType);
}

}


client端：

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.DefaultFullHttpRequest;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpRequestEncoder;
import io.netty.handler.codec.http.HttpResponseDecoder;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.stream.ChunkedWriteHandler;

import java.net.URI;

public class HttpDownloadClient {
/**
* 下载http资源向服务器下载直接填写要下载的文件的相对路径
* （↑↑↑建议只使用字母和数字对特殊字符对字符进行部分过滤可能导致异常↑↑↑）
* 向互联网下载输入完整路径
* @param host 目的主机ip或域名
* @param port 目标主机端口
* @param url 文件路径
* @param local 本地存储路径
* @throws Exception
*/
public void connect(String host, int port, String url, final String local) throws Exception {
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
Bootstrap b = new Bootstrap();
b.group(workerGroup);
b.channel(NioSocketChannel.class);
b.option(ChannelOption.SO_KEEPALIVE, true);
b.handler(new ChildChannelHandler(local));

        // Start the client.
        ChannelFuture f = b.connect(host, port).sync();

        URI uri = new URI(url);
        DefaultFullHttpRequest request = new DefaultFullHttpRequest(
                HttpVersion.HTTP_1_1, HttpMethod.GET, uri.toASCIIString());

        // 构建http请求
        request.headers().set(HttpHeaders.Names.HOST, host);
        request.headers().set(HttpHeaders.Names.CONNECTION,
                HttpHeaders.Values.KEEP_ALIVE);
        request.headers().set(HttpHeaders.Names.CONTENT_LENGTH,
                request.content().readableBytes());
        // 发送http请求
        f.channel().write(request);
        f.channel().flush();
        f.channel().closeFuture().sync();
    } finally {
        workerGroup.shutdownGracefully();
    }

}

private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
    String local;
    public ChildChannelHandler(String local) {
        this.local = local;
    }

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        // 客户端接收到的是httpResponse响应，所以要使用HttpResponseDecoder进行解码
        ch.pipeline().addLast(new HttpResponseDecoder());
        // 客户端发送的是httprequest，所以要使用HttpRequestEncoder进行编码
        ch.pipeline().addLast(new HttpRequestEncoder());
        ch.pipeline().addLast(new ChunkedWriteHandler());
        ch.pipeline().addLast(new HttpDownloadHandler(local));
    }

}
public static void main(String[] args) throws Exception {
    HttpDownloadClient client = new HttpDownloadClient();
    //client.connect("127.0.0.1", 9003,"/file/pppp/1.doc","1.doc");

// client.connect(“zlysix.gree.com”, 80, “http://zlysix.gree.com/HelloWeb/download/20m.apk”, “20m.apk”);
client.connect(“www.ghost64.com”, 80, “http://www.ghost64.com/qqtupian/zixunImg/local/2017/05/27/1495855297602.jpg”, “1495855297602.jpg”);

}


client端handler：

import java.io.File;
import java.io.FileOutputStream;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.HttpContent;
//import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.LastHttpContent;
import io.netty.util.internal.SystemPropertyUtil;
/**
* @Author:yangyue
* @Description:
* @Date: Created in 9:15 on 2017/5/28.
*/

public class HttpDownloadHandler extends ChannelInboundHandlerAdapter {
private boolean readingChunks = false; // 分块读取开关
private FileOutputStream fOutputStream = null;// 文件输出流
private File localfile = null;// 下载文件的本地对象
private String local = null;// 待下载文件名
private int succCode;// 状态码

public HttpDownloadHandler(String local) {
    this.local = local;
}

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg)
        throws Exception {
    if (msg instanceof HttpResponse) {// response头信息
        HttpResponse response = (HttpResponse) msg;
        succCode = response.getStatus().code();
        if (succCode == 200) {
            setDownLoadFile();// 设置下载文件
            readingChunks = true;
        }
        // System.out.println("CONTENT\_TYPE:"
        // + response.headers().get(HttpHeaders.Names.CONTENT\_TYPE));
    }
    if (msg instanceof HttpContent) {// response体信息
        HttpContent chunk = (HttpContent) msg;
        if (chunk instanceof LastHttpContent) {
            readingChunks = false;
        }

        ByteBuf buffer = chunk.content();
        byte[] dst = new byte[buffer.readableBytes()];
        if (succCode == 200) {
            while (buffer.isReadable()) {
                buffer.readBytes(dst);
                fOutputStream.write(dst);
                buffer.release();
            }
            if (null != fOutputStream) {
                fOutputStream.flush();
            }
        }

    }
    if (!readingChunks) {
        if (null != fOutputStream) {
            System.out.println("Download done->"+ localfile.getAbsolutePath());
            fOutputStream.flush();
            fOutputStream.close();
            localfile = null;
            fOutputStream = null;
        }
        ctx.channel().close();
    }
}

/\*\*

* 配置本地参数，准备下载
*/
private void setDownLoadFile() throws Exception {
if (null == fOutputStream) {
local = SystemPropertyUtil.get(“user.dir”) + File.separator +local;
//System.out.println(local);
localfile = new File(local);
if (!localfile.exists()) {
localfile.createNewFile();
}
fOutputStream = new FileOutputStream(localfile);
}
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
        throws Exception {
    System.out.println("管道异常：" + cause.getMessage());
    cause.printStackTrace();
    ctx.channel().close();
}

}


这里客户端我放的是网络连接，下载的是一副图片，启动服务端和客户端就可以看到这个图片被下载到了工程的根目录下。

![](https://img-blog.csdnimg.cn/img_convert/9a8cb5f8c0ec69e6499adead0da6e95b.png)



最全的Linux教程，Linux从入门到精通

======================

1.  **linux从入门到精通(第2版)**

2.  **Linux系统移植**

3.  **Linux驱动开发入门与实战**

4.  **LINUX 系统移植 第2版**

5.  **Linux开源网络全栈详解 从DPDK到OpenFlow**



![华为18级工程师呕心沥血撰写3000页Linux学习笔记教程](https://img-blog.csdnimg.cn/img_convert/59742364bb1338737fe2d315a9e2ec54.png)



第一份《Linux从入门到精通》466页

====================

内容简介

====

本书是获得了很多读者好评的Linux经典畅销书**《Linux从入门到精通》的第2版**。本书第1版出版后曾经多次印刷，并被51CTO读书频道评为“最受读者喜爱的原创IT技术图书奖”。本书第﹖版以最新的Ubuntu 12.04为版本，循序渐进地向读者介绍了Linux 的基础应用、系统管理、网络应用、娱乐和办公、程序开发、服务器配置、系统安全等。本书附带1张光盘，内容为本书配套多媒体教学视频。另外,本书还为读者提供了大量的Linux学习资料和Ubuntu安装镜像文件，供读者免费下载。



![华为18级工程师呕心沥血撰写3000页Linux学习笔记教程](https://img-blog.csdnimg.cn/img_convert/9d4aefb6a92edea27b825e59aa1f2c54.png)



**本书适合广大Linux初中级用户、开源软件爱好者和大专院校的学生阅读，同时也非常适合准备从事Linux平台开发的各类人员。**

> 需要《Linux入门到精通》、《linux系统移植》、《Linux驱动开发入门实战》、《Linux开源网络全栈》电子书籍及教程的工程师朋友们劳烦您转发+评论




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注运维）**
![img](https://img-blog.csdnimg.cn/img_convert/4520d77d640a3c9f59525575f5e1b39c.jpeg)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
置、系统安全等。本书附带1张光盘，内容为本书配套多媒体教学视频。另外,本书还为读者提供了大量的Linux学习资料和Ubuntu安装镜像文件，供读者免费下载。



![华为18级工程师呕心沥血撰写3000页Linux学习笔记教程](https://img-blog.csdnimg.cn/img_convert/9d4aefb6a92edea27b825e59aa1f2c54.png)



**本书适合广大Linux初中级用户、开源软件爱好者和大专院校的学生阅读，同时也非常适合准备从事Linux平台开发的各类人员。**

> 需要《Linux入门到精通》、《linux系统移植》、《Linux驱动开发入门实战》、《Linux开源网络全栈》电子书籍及教程的工程师朋友们劳烦您转发+评论




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注运维）**
[外链图片转存中...(img-zUClgCb7-1713164773642)]

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

2401_83621499

关注

9
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
Netty学习(十)-Netty文件上传(1)，2024年最新阿里+头条+腾讯大厂Linux运维笔试真题

/ 下载文件的本地对象。* （↑↑↑建议只使用字母和数字对特殊字符对字符进行部分过滤可能导致异常↑↑↑）private String local = null;* 下载http资源向服务器下载直接填写要下载的文件的相对路径。* @param local 本地存储路径。文件已经读完--------0。byte 长度：894。byte 长度：894。byte 长度：894。byte 长度：894。byte 长度：894。byte 长度：894。
复制链接

扫一扫