NettyExample 1.2 Http文件的上传和下载

最新推荐文章于 2023-02-12 19:25:36 发布
最新推荐文章于 2023-02-12 19:25:36 发布
阅读量853 收藏 1
点赞数
分类专栏： Netty 文章标签： Netty文件上传下载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mdq11111/article/details/78946775
版权
NettyExample 1.2 Http文件的上传和下载

Netty服务端。
注意：如果文件过大需要调整 HttpObjectAggregator的初始化参数，数据传输的大小
public class NettyHttpServer {
     private static Logger log = LoggerFactory.getLogger(NettyHttpServer.class);
     static final boolean SSL = System.getProperty("ssl") != null;
     static final int PORT = Integer.parseInt(System.getProperty("port", SSL ? "8443" : "8080"));

     public void start(int port) throws Exception {
           EventLoopGroup bossGroup = new NioEventLoopGroup();
           EventLoopGroup workerGroup = new NioEventLoopGroup();
           try {
                ServerBootstrap b = new ServerBootstrap();
                b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class) // (3)
            .childHandler(new ChannelInitializer<SocketChannel>() { // (4)
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            // server端发送的是httpResponse，所以要使用HttpResponseEncoder进行编码
                            ch.pipeline().addLast(new HttpResponseEncoder());
                            // server端接收到的是httpRequest，所以要使用HttpRequestDecoder进行解码
                            ch.pipeline().addLast(new HttpRequestDecoder());
                            ch.pipeline().addLast(new HttpObjectAggregator(65536*100));
                            ch.pipeline().addLast(new HttpServerInboundHandler());
                        }
                    }).option(ChannelOption.SO_BACKLOG, 128) // (5)
            .childOption(ChannelOption.SO_KEEPALIVE, true); // (6)

                ChannelFuture f = b.bind(port).sync();
                f.channel().closeFuture().sync();
           } finally {
                workerGroup.shutdownGracefully();
                bossGroup.shutdownGracefully();
           }
     }

     public static void main(String[] args) throws Exception {
           NettyHttpServer server = new NettyHttpServer();
           log.info("Http Server listening on 8844 ...");
           server.start(8844);
     }
}

服务端处理handler。
public class HttpServerInboundHandler extends ChannelInboundHandlerAdapter {
     private static Logger logger = LoggerFactory.getLogger(HttpServerInboundHandler.class);
     private Gson gson = new Gson();
     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;
     private static String PDF_SOURCE_DIR = PDFConfig.SOURCE_DIR;
     private static String PDF_PARSE_DIR = PDFConfig.PARSE_DIR;

     @Override
     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
           HashMap<String, String> params = new HashMap<String, String>();
           String taskId = UUID.randomUUID().toString().replaceAll("-", "");
           System.out.println(msg.getClass().toString());
           if (msg instanceof FullHttpRequest) {
                FullHttpRequest fullrequest = (FullHttpRequest) msg;
                String uri = fullrequest.uri(); // 获取请求uri
                logger.info("【url ：{} taskid;{}】", uri, taskId);
                System.out.println(fullrequest.headers().get("messageType")); // 获取头部信息

                if (uri.contains("download")) {
                    SendFile(pb.getParseFileName(), ctx, fullrequest);  //发送文件
                } else {
                       params = RequestParse.parseHttp(fullrequest, taskId); // 解析get/post请求参数（对post请求中的文件数据进行保存）
                     String res = "I am OK";
                     String fileName = params.get("fileName");
                     if (StringUtils.isBlank(fileName)) {
                           res = "file Name is Blank";
                     }
                     PdfParseBean pb = PdfToolsUtil.PdfParse(fileName, "txt", taskId, true, "TEXT_LEFT");
                      SendFile(pb.getParseFileName(), ctx, fullrequest);  //发送文件
                     return;
                }
                // ctx.flush();
           }
     }

     @Override
     public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
           ctx.flush();
     }

     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
           logger.error(cause.getMessage());
           ctx.close();
     }

     private static void setDateAndCacheHeaders(HttpResponse response, File fileToCache) {
           SimpleDateFormat dateFormatter = new SimpleDateFormat(HTTP_DATE_FORMAT, Locale.US);
          dateFormatter.setTimeZone(TimeZone.getTimeZone(HTTP_DATE_GMT_TIMEZONE));

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

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

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

     public void SendFile(String fileName, ChannelHandlerContext ctx, FullHttpRequest request) throws IOException {
           String filePath = PDF_PARSE_DIR + fileName;
           File file = new File(filePath);
           RandomAccessFile raf;
           try {
                raf = new RandomAccessFile(file, "r");
           } catch (FileNotFoundException ignore) {
                logger.error("【获取解析文件失败】：{}", file);
                return;
           }
           long fileLength = raf.length();

           HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);
           HttpUtil.setContentLength(response, fileLength);
           setContentTypeHeader(response, file);
           setDateAndCacheHeaders(response, file);
           response.headers().set("Content-Disposition", "attachment; filename=" + URLEncoder.encode(fileName));
           if (HttpUtil.isKeepAlive(request)) {
                response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
           }

           ctx.write(response);

           ChannelFuture sendFileFuture;
           ChannelFuture lastContentFuture;
           if (ctx.pipeline().get(SslHandler.class) == null) {
                sendFileFuture = ctx.write(new DefaultFileRegion(raf.getChannel(), 0, fileLength),
                           ctx.newProgressivePromise());
                lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
           } else {
                sendFileFuture = ctx.writeAndFlush(new HttpChunkedInput(new ChunkedFile(raf, 0, fileLength, 8192)),
                           ctx.newProgressivePromise());
                lastContentFuture = sendFileFuture;
           }

           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.");
                }
           });

           if (!HttpUtil.isKeepAlive(request)) {
                lastContentFuture.addListener(ChannelFutureListener.CLOSE);
           }
//         raf.close();                 
//不能将raf.close。否则会导致文件块传输过程中Netty客户端无法获取lastHttpContent导致无法获取完整的文件。浏览器下载文件无法下载完整的文件。
           while(!request.release());   //防止内存溢出，需要释放掉request中bytebuf数据块，否则会因为不断上传文件导致内存溢出
           if (httpChunkedInput!=null) {
                try {
                     httpChunkedInput.close();
                } catch (Exception e) {
                     logger.error("httpChunkedInput.close() error ",e);
                }
           }
     }
}

对Http请求参数的解析，获取FileUpLoad保存文件到服务端。
public class RequestParse {
     private static Logger logger = LoggerFactory.getLogger(RequestParse.class);
     private static String PDF_SOURCE_DIR = PDFConfig.SOURCE_DIR;
     private static String PDF_PARSE_DIR = PDFConfig.PARSE_DIR;
     private static Gson gson = new Gson();
     static{
           DiskFileUpload.baseDirectory = PDF_SOURCE_DIR;
     }
     /**
      * 解析Netty HttpRequest的请求参数，GET/POST的解析结果都为一个Map
      * @param request
      * @param taskId    本次请求taskId
      * @return HashMap<String, String>
      */
     public static HashMap<String, String> parseHttp(FullHttpRequest request, String taskId) throws Exception {
           HashMap<String, String> params = new HashMap<String, String>();
           HttpMethod method = request.method();
           String uri = request.uri();
           System.out.println(request.getClass().toString());
           if (HttpMethod.GET.equals(method)) {
               ........
           } else if (HttpMethod.POST.equals(method)) {
                HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(new DefaultHttpDataFactory(false), request);
                List<InterfaceHttpData> postData = decoder.getBodyHttpDatas(); //
                for (InterfaceHttpData data : postData) {
                     if (data.getHttpDataType() == HttpDataType.Attribute) {
                           Attribute attribute = (Attribute) data;
                           params.put(attribute.getName(), attribute.getValue());
                     } else if(data.getHttpDataType() == HttpDataType.FileUpload) {
                           FileUpload fileUpload = (FileUpload) data;
                           String fileName = taskId + "-" + fileUpload.getFilename();
                           if(fileUpload.isCompleted()) {
                                //保存到磁盘
                                File dir = new File(DiskFileUpload.baseDirectory);
                                if (!dir.exists() || !dir.isDirectory()) {
                                     dir.mkdirs();
                                }
                                StringBuffer fileNameBuf = new StringBuffer();
                                fileNameBuf.append(DiskFileUpload.baseDirectory).append(fileName);
                                fileUpload.renameTo(new File(fileNameBuf.toString()));
                           }
                           params.put("fileName", fileName);
                     }
                }
                logger.info("【POST 接受参数】：{}", gson.toJson(params));
           } else {
                throw new MethodNotSupportedException("not sopport such method. please use CET or POST");
           }
           return params;
     }
}


Netty客户端
public class MyUploadClient {
    static String Filepath = "D:/pdf/×ST八钢2016年年度报告.pdf";
    public void connect(String host, int port) throws Exception {

        EventLoopGroup workerGroup = new NioEventLoopGroup();
        HttpDataFactory factory = new DefaultHttpDataFactory(DefaultHttpDataFactory.MINSIZE);
        try {
            Bootstrap b = new Bootstrap();
            b.group(workerGroup);
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.SO_KEEPALIVE, true);
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ChannelPipeline pipeline = ch.pipeline();
                    pipeline.addLast("codec", new HttpClientCodec());
                    pipeline.addLast("inflater", new HttpContentDecompressor());
                    pipeline.addLast("chunkedWriter", new ChunkedWriteHandler());
                    pipeline.addLast(new HttpClientInboundHandler());
                }
            });
            // Start the client.
            ChannelFuture f = b.connect(host, port).sync(); // 

            String uriSting = new URI("http://127.0.0.1:8844/").toASCIIString();
            ChannelFuture future = b.connect(SocketUtils.socketAddress(host, port));
            Channel channel = future.sync().channel();

            //不能使用FullHttpRequest
            HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST,uriSting);

            HttpPostRequestEncoder bodyRequestEncoder =
                    new HttpPostRequestEncoder(factory, request, true); // true => multipart

            HttpHeaders headers1 = request.headers();
            headers1.set(HttpHeaderNames.HOST, host);
            headers1.set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE);
            headers1.set(HttpHeaderNames.ACCEPT_ENCODING, HttpHeaderValues.GZIP + "," + HttpHeaderValues.DEFLATE);
            headers1.set(HttpHeaderNames.ACCEPT_CHARSET, "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
            headers1.set(HttpHeaderNames.ACCEPT_LANGUAGE, "fr");
            headers1.set(HttpHeaderNames.USER_AGENT, "Netty Simple Http Client side");
            headers1.set(HttpHeaderNames.ACCEPT, "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");

            File file = new File(Filepath);
            bodyRequestEncoder.addBodyFileUpload("myfile", file, "application/x-zip-compressed", false);
            // finalize request
            bodyRequestEncoder.finalizeRequest();
            // send request
            channel.write(request);
            // test if request was chunked and if so, finish the write
            if (bodyRequestEncoder.isChunked()) {
                channel.write(bodyRequestEncoder);
            }
            channel.flush();
            // Now no more use of file representation (and list of HttpData)
            bodyRequestEncoder.cleanFiles();
            // Wait for the server to close the connection.
            channel.closeFuture().sync();

        } finally {
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        MyUploadClient client = new MyUploadClient();
        client.connect("127.0.0.1", 8844);
    }
}


Client端对文件的保存。
文件通过Chunk块传输。每获取的HttpContent是文件的一部分，所以需要对每个数据块进行保存，得到一个完成的文件数据流。
注意：
【1】如何确定文件传输已经完成。HttpContent 的类型instanceof 等于LastHttpContent时。说明传输已经完成。
【2】使用对数据块进行保存的时候，在toString过程中导致byte[]被切分。数据块不完成导致了文件部分出现乱码。（前后两个数据块之间间隔的文字）
原因是使用了一下代码。导致转为String的时候byte[]不完整导致中文乱码，再从String转回byte[]时数据就缺失了
ByteBuf buffer = chunk.content();
byte[] vArray = buffer.toString(CharsetUtil.UTF_8).getBytes();  //Netty的ByteBuf转String，最后一个中文可能会乱码（byte[]不全）
ans = byteMerger(ans, vArray);
//以下是正确的使用规范
ByteBuf buffer = chunk.content();
byte[] vArray = new byte[buffer.capacity()]; 
buffer.readBytes(vArray); //读取ByteBuf的数据。
ans = byteMerger(ans, vArray);

public class HttpClientInboundHandler extends ChannelInboundHandlerAdapter {
     private byte[] ans = {};

     @Override
     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
           if (msg instanceof HttpResponse) {
                HttpResponse response = (HttpResponse) msg;
                System.out.println("CONTENT_TYPE:" + response.headers().get(HttpHeaderNames.CONTENT_TYPE));
           }
           if (msg instanceof HttpContent) {
                HttpContent chunk = (HttpContent) msg;
                ByteBuf buffer = chunk.content();
                byte[] vArray = new byte[buffer.capacity()];
                buffer.readBytes(vArray);
                ans = byteMerger(ans, vArray);
                if (chunk instanceof LastHttpContent) {
                     save(ans, "/pdf/", "xST八钢2016年年度报告.txt");
                }

           }
     }

     private void save(byte[] fileByte, String download_path, String filename) throws Exception {
           FileOutputStream fileOutputStream = null;
           String fileName = (System.currentTimeMillis()) + "-" + filename;
           String fileFullPath = download_path + fileName;
           try {
                fileOutputStream = new FileOutputStream(fileFullPath);
                fileOutputStream.write(fileByte);
           } catch (Exception e) {
                throw e;
           } finally {
                if (fileOutputStream != null) {
                     fileOutputStream.close();
                }
           }
     }

     public static byte[] byteMerger(byte[] byte_1, byte[] byte_2) {
           byte[] byte_3 = new byte[byte_1.length + byte_2.length];
           System.arraycopy(byte_1, 0, byte_3, 0, byte_1.length);
           System.arraycopy(byte_2, 0, byte_3, byte_1.length, byte_2.length);
           return byte_3;
     }
}















强迫症患者m
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
http协议解决粘包拆包半包 的编码解码过程、 以及netty 使用http协议的原理
FREEDOM
08-02 8532
本文主要介绍netty对http协议解析原理，着重讲解keep-alive，gzip，truncked等机制，详细描述了netty如何实现对http解析的高性能。 1 http协议 1.1 描述 标示 ASCII 描述 字符 CR 13 Carriage return (回车) \r LF 10 Line feed character(换行) \n SP 30　　 Horizontal space(...
Netty+H5实现实时进度条文件上传，支持断点续传
07-23
Netty+H5实现实时进度条文件上传，支持断点续传。 1、WebSocketServer：服务启动类 2、服务启动后，浏览器访问http://localhost:9999 3、FileWebSocketFrameHandler类SERVER_SAVE_PATH常量为文件上传保存路经
nettyexample
07-08
nettyexample
Python Django 前后端数据交互 之 HttpRequest、HttpResponse、render、redirect
weixin_34358092的博客
12-28 750
在使用三神装的时候，首先当然是得要导入它们： from django.shortcuts import HttpResponse, render, redirect 一、HttpRequest捕获请求 捕获请求——HttpRequest对象 1、属性 HttpRequest.scheme #一个字符串，表示请求的方案(通常是http或者https)HttpRequest.body...
Django第二章（Httprequest详解-用户登录-搜索-文件上传-文件下载）
weixin_43546282的博客
10-20 645
djiango实现模拟搜索/模拟用户登陆/模拟上传下载
【Netty权威指南】06-Http协议开发应用
通往神秘的道路的专栏
03-17 533
1、Netty Http服务端入门开发 由于Netty天生是异步事件驱动的架构,因此基于NIOTCP协议栈开发的HTTP协议栈也是异步非阻塞的。 Netty的HTTP协议栈无论在性能还是可靠性上,都表现优异,非常适合在非Web容器的场景下应用,相比于传统的 Tomcat、Jetty等web容器,它更加轻量和小巧,灵活性和定制性也更好。 1.1、HTTP服务端例程场景描述 我们以文件服务器为例...
Netty之获取FullHttpRequest中的请求参数信息(x-www-form-urlencoded协议)
IUNIQUE技术册
12-01 8277
获取FullHttpRequest中的请求参数信息FullHttpRequestHTTP请求行HTTP请求头HTTP请求参数 FullHttpRequest 使用Netty开发一个HTTP服务器，Content-Type为 x-www-form-urlencoded的类型，需要从中获取请求参数信息 HTTP请求行 fullRequest.getMethod().name(); //获取请求方法 fullRequest.getMethod().getUri(); //获取请求URI fullRequest.g
netty~http客户端与服务端
houkai的博客
10-07 768
描述 netty对http消息提供了FullHttpRequest接口，此接口合并HttpRequest和FullHttpMessage ，因此请求是一个完整的HTTP请求。 服务端消息处理器 /** * @describe: http服务端对消息的处理 * @author: houkai */ public class HttpHandler extends SimpleChannelInboundHandler<FullHttpRequest> { @Over...
HttpFullResponse和普通ByteBuf数据回收
m0_53246313的博客
02-23 620
FullHttpResponse的ByteBuf数据回收
netty对http协议解析原理解析
glowd的专栏
07-13 586
转载自 https://blog.csdn.net/xiangzhihong8/article/details/52029446 本文主要介绍netty对http协议解析原理，着重讲解keep-alive，gzip，truncked等机制，详细描述了netty如何实现对http解析的高性能。 1 http协议 1.1 描述 标示 ASCII 描述 字符 CR 13 Car...
Netty4.0的DefaultHttpRequest与FullHttpRequest
热门推荐
naruto_Mr的专栏
04-10 1万+
本人用netty4.0做Http服务器模块时，出现了一个Bug，从平台发送过来的充值请求接收不到，充值请求是Post方式，自己写了个post工具模拟充值请求，发现：能收到HttpRequest，但收不到HttpContent。 消息分发器代码： protected void channelRead0(ChannelHandlerContext ctx, Object data) thr
Python入门自学进阶-Web框架——4、HttpRequest和HttpResponse及模板
kaoa000的专栏——非淡泊无以明志，非宁静无以致远
04-08 2041
HTTP请求中产生两个核心的对象： http请求：HttpRequest对象 http响应：HttpResponse对象 所在位置django.http，前边用的reques就是HttpRequest对象。 HttpRequest对象的属性： path：请求页面的全路径，不包括域名和端口method：请求中使用的HTTP方法的字符串表示，全大写表示，如POST、GET等GET：包含所有HTTP GET参数的类字典对象POST：包含所有HTTP POST参数的类字典对象。服务器收到空的POST请求的情况
flask使用request获取表单提交数据和获取url
菲宇运维
12-15 2906
Centos下安装指定版本软件 假设这里是我们想安装的是mariadb ：# yum list | grep mariadb 指定你想要的版本 #yum install mariadb-5.5.56-2.el7.x86_64 安装完后，就是检查pcre的版本了，输入： # rpm -qa | grep MariaDB 查询可用版本 [root@localhost ~]# yum list ...
基于Netty写一个http协议的服务
shelly南瓜
02-08 429
第一步：引入netty的jar包，本文是使用的是netty-all-4.1.9.Final.jar第二步：创建netty服务import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import org.slf4j.Logger; import org.springframework.beans.fact...
Java 使用 Netty DefaultFullHttpRequest 实现Post发送数据包的功能
xbt312的专栏
08-20 7116
// 向SQLMAPAPI传送开始测试的指令 NioEventLoopGroup workerGroup = new NioEventLoopGroup(); try { Bootstrap bootstrap = new Bootstrap(); bootstrap.group(workerGroup).channel(NioSocketChannel.class).o...
netty官方例子 二 http静态文件读取
akfly的专栏
11-19 3378
官方例子中  httpstaticFile   核心的类就是 下面这几个channelHandler pipeline.addLast(new HttpServerCodec()); pipeline.addLast(new HttpObjectAggregator(65536)); pipeline.addLast(new ChunkedWriteHan
从request中获取文件
最新发布
weixin_47119456的博客
02-12 2407
从request中获取文件
Netty4 文件传输零拷贝 使用Http协议
小和尚的修行庙
03-24 845
结合http协议的零拷贝
netty实现http server端
Limitedapm的博客
07-28 2010
在网上查了很多netty server端实现的例子，感觉还是有很多坑，这里记录一下自己的实现，也把自己踩的坑记录一下，利人利己。 首先创建一个server类，用来初始化netty的server端 public class NettyHttpServer { private Logger logger = LoggerFactory.getLogger(NettyHttpServer.class); private int inetPort; public NettyHtt
吃透Netty源码系列四十五之HttpObjectAggregator详解
王伟王胖胖的博客
03-02 8089
吃透Netty源码系列四十五之HttpObjectAggregator详解聚合消息先介绍一下一些属性结构MessageAggregatoracceptInboundMessage判断类型decode真正的聚合HttpObjectAggregator的isStartMessageHttpObjectAggregator的isLastContentMessageHttpObjectAggregator...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值