微信支付总结

最新推荐文章于 2019-08-30 09:26:00 发布
最新推荐文章于 2019-08-30 09:26:00 发布
阅读量869 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 支付问题 文章标签： 安卓 微信支付
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tianzhu2725/article/details/52926712

根据微信官方提供的例子只是进行了支付分析;


1.首先把微信提供的jar包 libammsdk.jar 导进来

2.首先创建微信支付的点击按钮

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >

    <Button
        android:id="@+id/pay"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="微信支付" />

</RelativeLayout>

3.在activity中处理支付逻辑

首先在oncreate()方法中初始化支付接口的api;

在微信支付点击按钮的点击事件中  首先判断是否支付微信支付;

开启子线程联网访问支付接口(我这里用的微信提供的访问网络工具类 也可以用自己封装的)并对返回结果封装成json对象,从json对象中提取参数并封装到微信Sdk提供的PayReq类中

调用api的sendReq(req) 方法请求支付结果  // api.sendReq(req);这个方法的返回值将会在另一类中处理

package com.example.weixinpay;
import org.json.JSONObject;

import com.tencent.mm.sdk.constants.Build;
import com.tencent.mm.sdk.modelpay.PayReq;
import com.tencent.mm.sdk.openapi.IWXAPI;
import com.tencent.mm.sdk.openapi.WXAPIFactory;

import android.os.Bundle;
import android.os.Looper;
import android.app.Activity;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends Activity implements OnClickListener {

	private IWXAPI api;
	private Button btn_pay;
	
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        //1 初始化支付api接口对象
        api = WXAPIFactory.createWXAPI(this, "wxb4ba3c02aa476ea1");//参数二为app_key
        
        btn_pay = (Button) findViewById(R.id.pay);
        btn_pay.setOnClickListener(this);
       
    }

    //2 调用微信支付
	@Override
	public void onClick(View v) {
		
		//支付接口  这个是后台给提供的
		final String url = "http://wxpay.weixin.qq.com/pub_v2/app/app_pay.php?plat=android";
		//将按钮设置为不可点击	
		btn_pay.setEnabled(false);
		
		//2.1 先检查是否支付微信支付  
		boolean isPaySupported = api.getWXAppSupportAPI() >= Build.PAY_SUPPORTED_SDK_INT;
		
		if (isPaySupported) {
			Toast.makeText(MainActivity.this, "获取订单中...", Toast.LENGTH_SHORT).show();
			new Thread(){
				public void run() {
					Looper.prepare();
					
					  try{
						  //2.2 联网访问支付接口
							byte[] buf = Util.httpGet(url);
							if (buf != null && buf.length > 0) {
								String content = new String(buf);
								Log.e("get server pay params:",content);
								
								//2.3 将获取到的数据转为json对象
					        	JSONObject json = new JSONObject(content); 
								if(null != json && !json.has("retcode") ){
									
									//2.4 从json对象中提取参数并封装到对象中
									PayReq req = new PayReq();
									//req.appId = "wxf8b4f85f3a794e77";  // 测试用appId
									req.appId			= json.getString("appid");
									req.partnerId		= json.getString("partnerid");
									req.prepayId		= json.getString("prepayid");
									req.nonceStr		= json.getString("noncestr");
									req.timeStamp		= json.getString("timestamp");
									req.packageValue	= json.getString("package");
									req.sign			= json.getString("sign");
									req.extData			= "app data"; // optional
									Toast.makeText(MainActivity.this, "正常调起支付", Toast.LENGTH_SHORT).show();
									
									// 2.5 在支付之前，如果应用没有注册到微信，应该先调用IWXMsg.registerApp将应用注册到微信
									api.sendReq(req);//请求支付
								}else{
						        	Log.d("PAY_GET", "返回错误"+json.getString("retmsg"));
						        	Toast.makeText(MainActivity.this, "返回错误"+json.getString("retmsg"), Toast.LENGTH_SHORT).show();
								}
							}else{
					        	Log.d("PAY_GET", "服务器请求错误");
					        	Toast.makeText(MainActivity.this, "服务器请求错误", Toast.LENGTH_SHORT).show();
					        }
				        }catch(Exception e){
				        	Log.e("PAY_GET", "异常："+e.getMessage());
				        	Toast.makeText(MainActivity.this, "异常："+e.getMessage(), Toast.LENGTH_SHORT).show();
				        }	
					  Looper.loop();
					
					
				};
			}.start();
	      
		}
		
		//将按钮设置为可以点击
        btn_pay.setEnabled(true);
	};	
    
}

微信提供的工具类 

package com.example.weixinpay;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;

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

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.HttpVersion;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.PlainSocketFactory;
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.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import junit.framework.Assert;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Bitmap.CompressFormat;
import android.util.Log;

public class Util {
	
	private static final String TAG = "SDK_Sample.Util";
	
	public static byte[] bmpToByteArray(final Bitmap bmp, final boolean needRecycle) {
		ByteArrayOutputStream output = new ByteArrayOutputStream();
		bmp.compress(CompressFormat.PNG, 100, output);
		if (needRecycle) {
			bmp.recycle();
		}
		
		byte[] result = output.toByteArray();
		try {
			output.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return result;
	}

	public static byte[] httpGet(final String url) {
		if (url == null || url.length() == 0) {
			Log.e(TAG, "httpGet, url is null");
			return null;
		}

		HttpClient httpClient = getNewHttpClient();
		HttpGet httpGet = new HttpGet(url);

		try {
			HttpResponse resp = httpClient.execute(httpGet);
			if (resp.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
				Log.e(TAG, "httpGet fail, status code = " + resp.getStatusLine().getStatusCode());
				return null;
			}

			return EntityUtils.toByteArray(resp.getEntity());

		} catch (Exception e) {
			Log.e(TAG, "httpGet exception, e = " + e.getMessage());
			e.printStackTrace();
			return null;
		}
	}
	
	public static byte[] httpPost(String url, String entity) {
		if (url == null || url.length() == 0) {
			Log.e(TAG, "httpPost, url is null");
			return null;
		}
		
		HttpClient httpClient = getNewHttpClient();
		
		HttpPost httpPost = new HttpPost(url);
		
		try {
			httpPost.setEntity(new StringEntity(entity));
			httpPost.setHeader("Accept", "application/json");
			httpPost.setHeader("Content-type", "application/json");
			
			HttpResponse resp = httpClient.execute(httpPost);
			if (resp.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
				Log.e(TAG, "httpGet fail, status code = " + resp.getStatusLine().getStatusCode());
				return null;
			}

			return EntityUtils.toByteArray(resp.getEntity());
		} catch (Exception e) {
			Log.e(TAG, "httpPost exception, e = " + e.getMessage());
			e.printStackTrace();
			return null;
		}
	}
	
	private static class SSLSocketFactoryEx extends SSLSocketFactory {      
	      
	    SSLContext sslContext = SSLContext.getInstance("TLS");      
	      
	    public SSLSocketFactoryEx(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {      
	        super(truststore);      
	      
	        TrustManager tm = new X509TrustManager() {      
	      
	            public X509Certificate[] getAcceptedIssuers() {      
	                return null;      
	            }      
	      
				@Override
				public void checkClientTrusted(X509Certificate[] chain, String authType) throws java.security.cert.CertificateException {
				}

				@Override
				public void checkServerTrusted(X509Certificate[] chain,	String authType) throws java.security.cert.CertificateException {
				}  
	        };      
	      
	        sslContext.init(null, new TrustManager[] { tm }, null);      
	    }      
	      
		@Override
		public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
			return sslContext.getSocketFactory().createSocket(socket, host,	port, autoClose);
		}

		@Override
		public Socket createSocket() throws IOException {
			return sslContext.getSocketFactory().createSocket();
		} 
	}  

	private static HttpClient getNewHttpClient() { 
	   try { 
	       KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); 
	       trustStore.load(null, null); 

	       SSLSocketFactory sf = new SSLSocketFactoryEx(trustStore); 
	       sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); 

	       HttpParams params = new BasicHttpParams(); 
	       HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); 
	       HttpProtocolParams.setContentCharset(params, HTTP.UTF_8); 

	       SchemeRegistry registry = new SchemeRegistry(); 
	       registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); 
	       registry.register(new Scheme("https", sf, 443)); 

	       ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry); 

	       return new DefaultHttpClient(ccm, params); 
	   } catch (Exception e) { 
	       return new DefaultHttpClient(); 
	   } 
	}
	
	public static byte[] readFromFile(String fileName, int offset, int len) {
		if (fileName == null) {
			return null;
		}

		File file = new File(fileName);
		if (!file.exists()) {
			Log.i(TAG, "readFromFile: file not found");
			return null;
		}

		if (len == -1) {
			len = (int) file.length();
		}

		Log.d(TAG, "readFromFile : offset = " + offset + " len = " + len + " offset + len = " + (offset + len));

		if(offset <0){
			Log.e(TAG, "readFromFile invalid offset:" + offset);
			return null;
		}
		if(len <=0 ){
			Log.e(TAG, "readFromFile invalid len:" + len);
			return null;
		}
		if(offset + len > (int) file.length()){
			Log.e(TAG, "readFromFile invalid file len:" + file.length());
			return null;
		}

		byte[] b = null;
		try {
			RandomAccessFile in = new RandomAccessFile(fileName, "r");
			b = new byte[len]; // 创建合适文件大小的数组
			in.seek(offset);
			in.readFully(b);
			in.close();

		} catch (Exception e) {
			Log.e(TAG, "readFromFile : errMsg = " + e.getMessage());
			e.printStackTrace();
		}
		return b;
	}
	
	private static final int MAX_DECODE_PICTURE_SIZE = 1920 * 1440;
	public static Bitmap extractThumbNail(final String path, final int height, final int width, final boolean crop) {
		Assert.assertTrue(path != null && !path.equals("") && height > 0 && width > 0);

		BitmapFactory.Options options = new BitmapFactory.Options();

		try {
			options.inJustDecodeBounds = true;
			Bitmap tmp = BitmapFactory.decodeFile(path, options);
			if (tmp != null) {
				tmp.recycle();
				tmp = null;
			}

			Log.d(TAG, "extractThumbNail: round=" + width + "x" + height + ", crop=" + crop);
			final double beY = options.outHeight * 1.0 / height;
			final double beX = options.outWidth * 1.0 / width;
			Log.d(TAG, "extractThumbNail: extract beX = " + beX + ", beY = " + beY);
			options.inSampleSize = (int) (crop ? (beY > beX ? beX : beY) : (beY < beX ? beX : beY));
			if (options.inSampleSize <= 1) {
				options.inSampleSize = 1;
			}

			// NOTE: out of memory error
			while (options.outHeight * options.outWidth / options.inSampleSize > MAX_DECODE_PICTURE_SIZE) {
				options.inSampleSize++;
			}

			int newHeight = height;
			int newWidth = width;
			if (crop) {
				if (beY > beX) {
					newHeight = (int) (newWidth * 1.0 * options.outHeight / options.outWidth);
				} else {
					newWidth = (int) (newHeight * 1.0 * options.outWidth / options.outHeight);
				}
			} else {
				if (beY < beX) {
					newHeight = (int) (newWidth * 1.0 * options.outHeight / options.outWidth);
				} else {
					newWidth = (int) (newHeight * 1.0 * options.outWidth / options.outHeight);
				}
			}

			options.inJustDecodeBounds = false;

			Log.i(TAG, "bitmap required size=" + newWidth + "x" + newHeight + ", orig=" + options.outWidth + "x" + options.outHeight + ", sample=" + options.inSampleSize);
			Bitmap bm = BitmapFactory.decodeFile(path, options);
			if (bm == null) {
				Log.e(TAG, "bitmap decode failed");
				return null;
			}

			Log.i(TAG, "bitmap decoded size=" + bm.getWidth() + "x" + bm.getHeight());
			final Bitmap scale = Bitmap.createScaledBitmap(bm, newWidth, newHeight, true);
			if (scale != null) {
				bm.recycle();
				bm = scale;
			}

			if (crop) {
				final Bitmap cropped = Bitmap.createBitmap(bm, (bm.getWidth() - width) >> 1, (bm.getHeight() - height) >> 1, width, height);
				if (cropped == null) {
					return bm;
				}

				bm.recycle();
				bm = cropped;
				Log.i(TAG, "bitmap croped size=" + bm.getWidth() + "x" + bm.getHeight());
			}
			return bm;

		} catch (final OutOfMemoryError e) {
			Log.e(TAG, "decode bitmap failed: " + e.getMessage());
			options = null;
		}

		return null;
	}
	
	public static String sha1(String str) {
		if (str == null || str.length() == 0) {
			return null;
		}
		
		char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
		
		try {
			MessageDigest mdTemp = MessageDigest.getInstance("SHA1");
			mdTemp.update(str.getBytes());
			
			byte[] md = mdTemp.digest();
			int j = md.length;
			char buf[] = new char[j * 2];
			int k = 0;
			for (int i = 0; i < j; i++) {
				byte byte0 = md[i];
				buf[k++] = hexDigits[byte0 >>> 4 & 0xf];
				buf[k++] = hexDigits[byte0 & 0xf];
			}
			return new String(buf);
		} catch (Exception e) {
			return null;
		}
	}
	
	public static List<String> stringsToList(final String[] src) {
		if (src == null || src.length == 0) {
			return null;
		}
		final List<String> result = new ArrayList<String>();
		for (int i = 0; i < src.length; i++) {
			result.add(src[i]);
		}
		return result;
	}
}


4.创建一个activity类 用来接收微信支付返回的结果

这个类要实现IWXAPIEventHandler接口  

oncreate方法中初始化api对象 调用  api.handleIntent(getIntent(), this)方法

重写onNewIntent方法和onResp和onReq方法

处理结果主要在onResp方法中实现  比如弹个对话框

package com.example.weixinpay;



import android.app.Activity;
import android.app.AlertDialog;
import android.content.Intent;
import android.os.Bundle;

import com.tencent.mm.sdk.constants.ConstantsAPI;
import com.tencent.mm.sdk.modelbase.BaseReq;
import com.tencent.mm.sdk.modelbase.BaseResp;
import com.tencent.mm.sdk.openapi.IWXAPI;
import com.tencent.mm.sdk.openapi.IWXAPIEventHandler;
import com.tencent.mm.sdk.openapi.WXAPIFactory;

public class PayResult extends Activity implements IWXAPIEventHandler{
	
	private IWXAPI api;
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.result);
		
		api = WXAPIFactory.createWXAPI(this, Constants.APP_ID);//参数二为你的应用从官方网站申请到的合法appId
        api.handleIntent(getIntent(), this);
    }

	@Override
	protected void onNewIntent(Intent intent) {
		super.onNewIntent(intent);
		setIntent(intent);
        api.handleIntent(intent, this);
	}

	@Override
	public void onReq(BaseReq arg0) {}

	//处理返回结果
	@Override
	public void onResp(BaseResp resp) {
		if (resp.getType() == ConstantsAPI.COMMAND_PAY_BY_WX) {
			//弹出一个对话框
			AlertDialog.Builder builder = new AlertDialog.Builder(this);
			builder.setTitle("提示");
			builder.setMessage(getString(R.string.pay_result_callback_msg, String.valueOf(resp.errCode)));
			builder.show();
		}
		
	}

}



微信支付，支付宝支付，银联支付——三大支付总结
这个时代，作为程序员可能要学习小程序
05-23 2万+
银联支付，支付宝支付，微信支付的三大总结，之前也有写过两篇。&amp;gt; 支付宝植入总结： android 支付宝的植入 《曾经踩过的坑》 微信支付总结： Android 微信支付总结 备注：出于安全考虑，验签我们都是放到后台进行验签的。对于我们移动端节省了很多的劳动力。之前有做过支付宝支付和微信支付，所以这次做起来碰到的问题很少，key申请下来之后很快就搞定了。吼吼效果图：
微信支付个人总结
ming654987的博客
03-13 821
    支付：    六个固定参数       ①appid②mch_id商户号③key商户密匙④微信用户openid⑤支付类型‘JSAPI’⑥nonce_str（随机字符串）    签名验证        服务器端组合各参数，根据字母升序排列后加key（商户密匙）使用md5加密，将各参数拼接成xml        格式请求微信服务器端，微信服务器根据参数重新生成签名，进行签名比对    回调  ...
微信支付V2版本的支付接口，java的SDK
最新发布
11-16
总结以上内容，微信支付V2版本的支付接口与Java的SDK为Java开发者提供了一个强大的工具集，使得开发者可以方便地在应用中集成微信支付功能。然而，开发者在使用时需要严格遵守微信支付的安全规范，并关注接口的更新...
支付宝微信支付总结
12-29
总结起来，支付宝和微信支付作为主流的第三方支付工具，为商家提供了便捷的支付解决方案。开发者在集成这两个支付平台时，需理解并掌握其核心原理、接口调用、回调处理以及安全性保障，以实现安全、高效的支付体验。
微信支付javaSpringboot对接开发微信支付
03-21
### 微信支付Java SpringBoot对接开发详解 #### 一、微信支付配置申请 在进行微信支付集成前，首先需要完成微信支付的基本配置申请。这一步骤至关重要，因为只有完成配置后才能获得接入所需的凭证信息。 1. **...
微信支付总结JAVA包.zip
07-27
微信小程序，微信支付所需所有的jar包，包含各种扫码，出示二维码生成，H5直接支付场景,有问题可联系博主
微信公众号支付总结
a826125399的博客
11-27 1241
公众号支付就尼玛是个天坑   首先场景介绍 https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_1 看完场景介绍后脑子里会觉得这个东西也太简单了8？  然而。。   ps：因为没有登平台没有配图只有文字了。 官方配置 需要在微信公众号平台开通认证（开发者配置迁移到了商户平台），商户平台获取一些必要的参数； 微信公众...
Android支付——微信支付总结
一个简单的程序员
04-22 7851
1、准备工作在微信开放平台进行登记，登记并选择移动应用进行设置后，将该应用提交审核，只有审核通过的应用才能进行开发。 微信支付的开发方式和支付宝不同，微信支付在客户端不需要太多的操作，大多依赖于服务器端。2、导入jar包将libammsdk.jar包放入应用工程的libs目录下。3、修改AndroidManifest.xml文件在AndroidManifest.xml文件中添加如下代码：
微信支付问题总结
qq_33284522的博客
12-06 604
1.第一种原因参数有问题。一般都是秘钥有问题。需自己登陆商家版后台修改  。 2.需要知道微信支付是需要打包才能运行。调不起来可以去微信开放平台看自己配置的参数是否正确。 3.微信支付跟支付宝支付不一样。微信支付同一订单不会第二次跳到支付页面 提示支付失败，同一订单第二次支付的时候直接在请求遇支付订单的时候就会返回preayid为空。应该在吊起支付这一步判断
微信支付小结
weixin_30588675的博客
08-30 489
1、微信支付成功多次回调 微信机制： 　　支付完成后，微信会把相关的支付结果和用户信息发送给商户，商户接收处理并返回应答； 　　对后台交互通知时，如果微信收到商户的应答不是成功或者超时，微信则认为通知失败，微信会通过一定的策略定期重新发起通知，尽可能提高通知的成功率，但不保证最终通知成功。（通知频率为15/15/30/180/1800/1800/1800/1800/3600，单位：...
个人微信支付总结---不喜勿喷
热门推荐
bei215748382的专栏
02-02 1万+
微信支付开发总结 作者:bruce.bei 日期：2018.2.2 QQ同微信：215748382   做微信开发以来到微信支付也有2,3年时间了，做过微信公众号支付、微信H5支付以及在公众号内用h5支付，下面要总结下这有点麻烦的微信支付，以便于以后再次开发。 第一、需要查看微信官网的开发文档，因为微信他本身在更新，一两年后可能接口会有所变化。用到的网站可以通过百度搜索查阅，关键字如：微...
关于微信支付IWXAPIEventHandler接口中onresp不能调用的问题
u012544805的博客
10-12 6878
1.首先确定包名.wxapi 新建个包 放WXPayEntryActivity  是否正确这相比大多人不会弄错。 2容易忽略的是上面的创建的.wxapi包必须跟你申请时，填写的包目录一样，必须放在申请的目录下。格式：申请包+".wxapi"千万不要自作聪明加前缀后缀什么，这样它就找不到就不会跳转成功！
关于微信分享的问题
qq_28469803的博客
04-16 496
谨以此文章记录一下！！！ 微信分享失败的原因: a.AppID问题，跟bundleId不对应，此时会提示如下界面 b.点微信分享没有任何提示，跟代码会发现[WXApi sendRe...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值