如何使用HttpClient下载网络资源（包括下载ssl认证的资源）

最新推荐文章于 2023-01-14 17:54:30 发布
最新推荐文章于 2023-01-14 17:54:30 发布
阅读量4.1k 收藏 2
点赞数
分类专栏： 可复用代码和开源软件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WitsMakeMen/article/details/12002961
版权

看了两篇不错的博客，这里总结一下：

第一篇博客（http://hackerzhou.me/2010/08/support-ssl-proxy-post-get-the-webclient-using-httpclient-4-0-1.html）：

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
 
import org.apache.http.Header;
import org.apache.http.HttpException;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.params.ClientPNames;
import org.apache.http.client.params.CookiePolicy;
import org.apache.http.conn.routing.HttpRoute;
import org.apache.http.conn.routing.HttpRoutePlanner;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreProtocolPNames;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;
 
public class WebClient {
    private DefaultHttpClient httpClient = new DefaultHttpClient();
    private String url;
    private HTTPMethod method;
    private byte[] content;
    private Map<String, String> headers = new HashMap<String, String>();
    private int responseCode;
    private List<NameValuePair> postParameter = new ArrayList<NameValuePair>();
 
    private static final Pattern pageEncodingReg = Pattern.compile(
            "content-type.*charset=([^\">\\\\]+)", Pattern.CASE_INSENSITIVE);
    private static final Pattern headerEncodingReg = Pattern.compile(
            "charset=(.+)", Pattern.CASE_INSENSITIVE);
 
    public static void main(String[] args) throws Exception {
        WebClient web = new WebClient("http://www.baidu.com/", HTTPMethod.GET);
        web.enableProxy("10.58.32.51", 8080, false, null, null, "127.0.0.1");
        System.out.println(web.getTextContent());
        System.out.println("------------------------------------------");
        web.setUrl("https://mail.google.com/mail/");
        System.out.println(web.getTextContent());
        System.out.println("------------------------------------------");
        web.setUrl("http://www.snee.com/xml/crud/posttest.cgi");
        web.setMethod(HTTPMethod.POST);
        web.addPostParameter("fname", "ababab");
        web.addPostParameter("lname", "cdcdcd");
        System.out.println(web.getTextContent());
        System.out.println("------------------------------------------");
    }
 
    // Without proxy
    public WebClient(String url, HTTPMethod method) {
        this(url, method, false, null, 0, false, null, null, null);
    }
 
    // Proxy without auth
    public WebClient(String url, HTTPMethod method, String proxyHost,
            int proxyPort) {
        this(url, method, true, proxyHost, proxyPort, false, null, null, null);
    }
 
    // All in one settings
    public WebClient(String url, HTTPMethod method, boolean useProxy,
            String proxyHost, int proxyPort, boolean needAuth, String username,
            String password, String nonProxyReg) {
        setUrl(url);
        setMethod(method);
        if (useProxy) {
            enableProxy(proxyHost, proxyPort, needAuth, username, password,
                    nonProxyReg);
        }
    }
 
    public void setMethod(HTTPMethod method) {
        this.method = method;
    }
 
    public void setUrl(String url) {
        if (isStringEmpty(url)) {
            throw new RuntimeException("[Error] url is empty!");
        }
        this.url = url;
        headers.clear();
        responseCode = 0;
        postParameter.clear();
        content = null;
        if (url.startsWith("https://")) {
            enableSSL();
        } else {
            disableSSL();
        }
    }
 
    public Map<String, String> getRequestHeaders() {
        return headers;
    }
 
    public void addPostParameter(String name, String value) {
        this.postParameter.add(new BasicNameValuePair(name, value));
    }
 
    public void setTimeout(int connectTimeout, int readTimeout) {
        HttpParams params = httpClient.getParams();
        HttpConnectionParams.setConnectionTimeout(params, connectTimeout);
        HttpConnectionParams.setSoTimeout(params, readTimeout);
    }
 
    private void enableSSL() {
        try {
            SSLContext sslcontext = SSLContext.getInstance("TLS");
            sslcontext.init(null, new TrustManager[] { truseAllManager }, null);
            SSLSocketFactory sf = new SSLSocketFactory(sslcontext);
            sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            Scheme https = new Scheme("https", sf, 443);
            httpClient.getConnectionManager().getSchemeRegistry()
                    .register(https);
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
 
    private void disableSSL() {
        SchemeRegistry reg = httpClient.getConnectionManager()
                .getSchemeRegistry();
        if (reg.get("https") != null) {
            reg.unregister("https");
        }
    }
 
    public void disableProxy() {
        httpClient.getCredentialsProvider().clear();
        httpClient.setRoutePlanner(null);
    }
 
    public void enableProxy(final String proxyHost, final int proxyPort,
            boolean needAuth, String username, String password,
            final String nonProxyHostRegularExpression) {
        if (needAuth) {
            httpClient.getCredentialsProvider().setCredentials(
                    new AuthScope(proxyHost, proxyPort),
                    new UsernamePasswordCredentials(username, password));
        }
        // Simple proxy setting, can't handle non-proxy-host
        // httpClient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,new
        // HttpHost(proxyHost, proxyPort));
        httpClient.setRoutePlanner(new HttpRoutePlanner() {
            @Override
            public HttpRoute determineRoute(HttpHost target,
                    HttpRequest request, HttpContext contenxt)
                    throws HttpException {
                HttpRoute proxyRoute = new HttpRoute(target, null,
                        new HttpHost(proxyHost, proxyPort), "https"
                                .equalsIgnoreCase(target.getSchemeName()));
                if (nonProxyHostRegularExpression == null) {
                    return proxyRoute;
                }
                Pattern pattern = Pattern
                        .compile(nonProxyHostRegularExpression,
                                Pattern.CASE_INSENSITIVE);
                Matcher m = pattern.matcher(target.getHostName());
                if (m.find()) {
                    return new HttpRoute(target, null, target, "https"
                            .equalsIgnoreCase(target.getSchemeName()));
                } else {
                    return proxyRoute;
                }
            }
        });
    }
 
    private void fetch() throws IOException {
        if (url == null || method == null) {
            throw new RuntimeException(
                    "Fetch exception: URL and Method is null");
        }
        httpClient.getParams().setParameter(ClientPNames.COOKIE_POLICY,
                CookiePolicy.BROWSER_COMPATIBILITY);
        HttpResponse response = null;
        HttpUriRequest req = null;
        if (method.equals(HTTPMethod.GET)) {
            req = new HttpGet(url);
        } else {
            req = new HttpPost(url);
            ((HttpPost) req).setEntity(new UrlEncodedFormEntity(
                    this.postParameter, HTTP.UTF_8));
        }
        for (Entry<String, String> e : headers.entrySet()) {
            req.addHeader(e.getKey(), e.getValue());
        }
 
        //
        // Turn off "except" http header, some proxy server and web server do
        // not support it, may cause "417 Expectation Failed"
        //
        // HttpClient's doc says: 100-continue handshake should be used with
        // caution, as it may cause problems with HTTP servers and proxies that
        // do not support HTTP/1.1 protocol.
        //
        req.getParams().setBooleanParameter(
                CoreProtocolPNames.USE_EXPECT_CONTINUE, false);
        response = httpClient.execute(req);
        Header[] header = response.getAllHeaders();
        headers.clear();
        for (Header h : header) {
            headers.put(h.getName(), h.getValue());
        }
        content = EntityUtils.toByteArray(response.getEntity());
        responseCode = response.getStatusLine().getStatusCode();
    }
 
    private boolean isStringEmpty(String s) {
        return s == null || s.length() == 0;
    }
 
    public int getResponseCode() throws IOException {
        if (responseCode == 0) {
            fetch();
        }
        return responseCode;
    }
 
    public Map<String, String> getResponseHeaders() throws IOException {
        if (responseCode == 0) {
            fetch();
        }
        return headers;
    }
 
    public byte[] getByteArrayContent() throws IOException {
        if (content == null) {
            fetch();
        }
        return content;
    }
 
    public String getTextContent() throws IOException {
        if (content == null) {
            fetch();
        }
        if (content == null) {
            throw new RuntimeException("[Error] Can't fetch content!");
        }
        String headerContentType = null;
        if ((headerContentType = headers.get("Content-Type")) != null) {
            // use http header encoding
            Matcher m1 = headerEncodingReg.matcher(headerContentType);
            if (m1.find()) {
                return new String(content, m1.group(1));
            }
        }
        // Use html's encoding
        String html = new String(content);
        Matcher m2 = pageEncodingReg.matcher(html);
        if (m2.find()) {
            html = new String(content, m2.group(1));
        }
        return html;
    }
 
    public DefaultHttpClient getHttpClient() {
        return httpClient;
    }
 
    public enum HTTPMethod {
        GET, POST
    }
 
    // SSL handler (ignore untrusted hosts)
    private static TrustManager truseAllManager = new X509TrustManager() {
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
 
        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
        }
 
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
        }
    };
}

最近研究了下HttpClient 4.0.1，主要是因为Java自己的HttpURLConnection对SSL支持的不好，而且控制起来不太方便，而且HttpClient还支持抓取非信任的站点，别的实现方式貌似需要在代码中显式导入证书。

需要的jar包：commons-logging-1.1.1.jar，httpclient-4.0.1.jar，httpcore-4.0.1.jar

Coding的时候遇到了些非常规问题：

1.HttpClient支持使用Java默认的Properties方式设置代理，不过我还是使用了HttpClient的代理设置方式。因而遇到了一个很诡异的问题，Properties方式设置的代理可以设置代理例外，即本地地址不通过代理访问，HttpClient没有简单的一句话设置的方法，必须写HttpRoutePlanner来自定义，比较繁琐。
如果使用HttpClient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,new HttpHost(proxyHost, proxyPort));来设置代理，则所有的请求都会往这个代理发送，没有例外，故弃之。

2.HTTP Header中的“Except”字段引起的问题，我向一些网页直接提交POST没有问题，但如果使用squid proxy进行post的话就会出现417 Expectation Failed错误，网上查了http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html 发现这个问题是因为proxy server/web server不能理解或满足Except字段中指定的值，则会引发这个错误，而HttpClient默认会发送这个字段，只要指示request不发送这个字段即可。

3.不受信任的HTTPS站点的访问问题，通过X509TrustManager来完成，将方法重写成返回null的或者是啥都不做的，理论上要是checkServerTrusted或checkClientTrusted方法检测到不受信任的站点，会抛出异常，但如果什么都不做，则被视为通过检查。

4.写了个getTextContent方法，用来获取返回的文本，解决乱码问题的方法其实很简单，首先用正则提取HTTP Header中Content-Type里的charset，如果没有,使用默认编码分析html head中Content-Type里的charset，如果没有，使用系统默认编码。


第二篇博客（http://eyecm.com/httpclient-download/）：

使用HttpClient下载文件
2012年08月03日  ⁄ 编程整理 ⁄ 共 1268字 ⁄ +0 ⁄ 被围观 2,737+

在之前的文章《HttpClient4.1入门教程-利用官方例子讲解httpClient4.1的用法》中介绍了HttpClient4的基本用户，本篇文章以实例的方式介绍如何使用HttpClient下载文件。

事实上我们仍然发送GET或者POST请求，但对响应写入到文件流中即可。通过这段代码，也许你就明白下载软件或采集器的写法了。

package sitemap;

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

import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

public class SitemapDownloader
{
public static void main(String[] args) throws Exception
{
int min = 1;
int max = 806;

String url = "http://www.foxnews.com/sitemap.xml?idx=";

while (min < max)
{
Thread.sleep(500);

HttpClient httpClient1 = new DefaultHttpClient();

HttpGet httpGet1 = new HttpGet(url+min);
HttpResponse httpResponse1 = httpClient1.execute(httpGet1);

StatusLine statusLine = httpResponse1.getStatusLine();
if(statusLine.getStatusCode() == 200)
{

File xml = new File("d:/sitemap/"+min+".xml");

FileOutputStream outputStream = new FileOutputStream(xml);
InputStream inputStream = httpResponse1.getEntity().getContent();
byte b[] = new byte[1024];
int j = 0;
while( (j = inputStream.read(b))!=-1)
{
outputStream.write(b,0,j);
}
outputStream.flush();
outputStream.close();

min++;
System.out.println("存储了XML: " +min);
}

httpClient1.getConnectionManager().shutdown();
}
}
}

最后，将第一篇博客中的ssl认证功能加到第二篇博客中，就可以下载https资源： 

package com.adobe.touchstone.plus.updownload;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;


public class SitemapDownloader{
    // SSL handler (ignore untrusted hosts)
    private static TrustManager truseAllManager = new X509TrustManager() {
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
 
        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
        }
 
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
        }
    };
    
    private static void enableSSL(HttpClient httpClient) {
        try {
            SSLContext sslcontext = SSLContext.getInstance("TLS");
            sslcontext.init(null, new TrustManager[] { truseAllManager }, null);
            SSLSocketFactory sf = new SSLSocketFactory(sslcontext);
            sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            Scheme https = new Scheme("https", sf, 443);
            httpClient.getConnectionManager().getSchemeRegistry()
                    .register(https);
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
	public static void main(String[] args) throws Exception{
	
	
		String url = "https://mail.google.com/mail/";
		
		HttpClient httpClient1 = new DefaultHttpClient() ;
		enableSSL(httpClient1);
		HttpGet httpGet1 = new HttpGet(url);
		HttpResponse httpResponse1 = httpClient1.execute(httpGet1);
		
		StatusLine statusLine = httpResponse1.getStatusLine();
		if(statusLine.getStatusCode() == 200){
			File xml = new File( "d:/mail.html" );
			
			FileOutputStream outputStream = new FileOutputStream(xml);
			InputStream inputStream = httpResponse1.getEntity().getContent();
			
			byte b[] = new byte[1024];
			int j = 0;
			while( (j = inputStream.read(b))!=-1){
				System.out.println("Writing : "+b.toString());
				outputStream.write(b,0,j);
			}
			outputStream.flush();
			outputStream.close();
			
			System.out.println( "存储了文件: " +xml.toString());
			httpClient1.getConnectionManager(). shutdown();
		}
	}
}


WitsMakeMen
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java资源包01
08-31
Tomcat Native 这个项目可以让 Tomcat 使用 Apache 的 apr 包来处理包括文件和网络IO操作，以提升性能。 预输入搜索 Cleo Cleo 是一个灵活的软件库用于处理一些预输入和自动完成的搜索功能，该项目是 LinkedIn 公司...
WebClient图片下载
weixin_30687051的博客
07-11 111
使用WebClient下载文件非常方便，针对有部分网站通过请求头的Referer，做了图片防盗链，可以在webClient加上Referer 来模拟请求 string basePath = Path.Combine(Environment.CurrentDirectory, "imgs"); if (!System.IO.Directory....
Java自带的httpclient实现文件的上传与下载以及表单提交和网页访问
yuan__once的博客
01-14 4458
为了方便使用，这里将Java11的HttpClient封装成了一个轻量级的Http客户端。
HttpClient 模拟登录携带Cookie去搞事情
百世经纶『一页書』
11-17 4027
HttpClient 模拟登录携带Cookie
使用Java代码下载网页图片
Aslixzhou
12-05 1432
利用Java代码下载网页图片
轻松把玩HttpClient之配置ssl，采用绕过证书验证实现https
YHJ
06-06 4270
上篇文章说道httpclient不能直接访问https的资源，这次就来模拟一下环境，然后配置https测试一下。在前面的文章中，分享了一篇自己生成并在tomcat中配置ssl的文章《Tomcat配置SSL》，大家可以据此来在本地配置https。我已经配置好了，效果是这样滴： 可以看到已经信任该证书（显示浅绿色小锁），浏览器可以正常访问。现在我们用代码测试一下： public static void main(String[] args) throws ParseException, IOExce
JAVA上百实例源码以及开源项目
01-03
1个目标文件，JNDI的使用例子，有源代码，可以下载参考，JNDI的使用，初始化Context,它是连接JNDI树的起始点，查找你要的对象，打印找到的对象，关闭Context…… ftp文件传输 2个目标文件，FTP的目标是：（1）提高...
JAVA上百实例源码以及开源项目源代码
12-11
EJB中JNDI的使用源码例子 1个目标文件，JNDI的使用例子，有源代码，可以下载参考，JNDI的使用，初始化Context,它是连接JNDI树的起始点，查找你要的对象，打印找到的对象，关闭Context…… ftp文件传输 2个目标文件...
java开源包10
06-28
Tomcat Native 这个项目可以让 Tomcat 使用 Apache 的 apr 包来处理包括文件和网络IO操作，以提升性能。 预输入搜索 Cleo Cleo 是一个灵活的软件库用于处理一些预输入和自动完成的搜索功能，该项目是 LinkedIn 公司...
java开源包2
06-28
Tomcat Native 这个项目可以让 Tomcat 使用 Apache 的 apr 包来处理包括文件和网络IO操作，以提升性能。 预输入搜索 Cleo Cleo 是一个灵活的软件库用于处理一些预输入和自动完成的搜索功能，该项目是 LinkedIn 公司...
使用webclient下载图片实例
03-03
很实用 很方便的一个实例性指导文件。下了你就知道了，没的说啊。
WebClient下载文件
06-01
WebClient下载文件 winform下载文件
使用HttpClient下载图片
05-10
HttpURLConnection与HttpClient的区别： HttpClient是个很不错的开源框架（org.appache.http），封装了访问http的请求头，参数，内容体，响应等等，使用起来更方面更强大。 HttpURLConnection是java的标准类，可以实现简单的基于URL请求、响应功能，什么都没封装，用起来太原始，比如重访问的自定义，以及一些高级功能等。
HttpClient请求Https证书问题解决
排长性感的小屁屁
06-02 2603
本地使用HttpClient请求https时没有问题，但是放到服务器上，运行出现报错，出现异常为： PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target 通过查阅网上资料，将解决方案整如下： 1.通过在服务器端安装证书 步骤： 1.现在指定的https链接下载证书，保存为
基于http 和 https的文件下载
Brook
09-26 9637
基于Http的文件下载
HttpClient对于https的支持和配置
qq_22752667的博客
09-02 3130
网上有许多对于https的支持配置，但是对于一些新手而言，显然不够直接拿来复制粘贴然后运行出来，所以今天就将整套代码拿出来与大家分享，希望指正错误和帮我优化代码
httpclient https
xiaomin1991222的专栏
07-22 420
1.首先你要去打开一个https:///www.xxx.com的网站 导出一个steven.cer的证书文件 2.   3.     public static void main(String[] args) throws ClientProtocolException, IOException, KeyStoreException, NoSuchAlgorith...
HttpClient 通过资源URL下载资源
梅川酷紫
12-05 7718
HttpClient 通过资源URL下载资源 使用富文本编辑器写文章什么的，从第三方拷贝过来的图文，里面的资源内容都是第三方的，如果第三方删除该资源，导致该文章也无法访问，故需要把文章中的第三方资源通过http下载到本地服务器，永久保存。 用到了以下三种方法： 1、纯IO写文件 /** * 根据url下载文件，保存到filepath中 * @param url * @param filepa...
使用httpclient连接https 自签名也可以
棋牌游戏
07-04 274
申请了ssl证书，总算搭起了https，但问题又来了，android和java居然不认这个证书，必须要用定制方式。问题就大了 在android的 httpclient 版本应该是4.0，几乎网上很少有讲到4.0的开发，定制ssl就更少了。 上官网查了一下，有个简单的例子是关于定制 [url]http://svn.apache.org/repos/asf/httpcomponent...
[Java] 使用HttpClient实现文件下载
最新发布
04-08
好的，关于使用HttpClient实现文件下载，您需要先创建一个HttpClient对象，然后构建一个HttpGet请求，并设置请求头等相关参数，最后将请求发送给服务器并获取服务器响应，将响应流保存到本地文件即可。具体操作可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WitsMakeMen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值