Java Socket基础

于 2012-10-25 16:35:00 发布
阅读量108 收藏
点赞数
文章标签： java
本文详细介绍Java Socket的基础通信原理，包括长连接与短连接的应用场景。通过示例代码讲解客户端和服务端如何实现消息交互，覆盖文本及对象数据传输，并提供常见异常处理方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Java Socket基础
较基础的Java Socket通信样例！
一、长连接通信
客户端和服务端建立通道后，Socket一直开着。两端通过read()等待消息。
1）简易聊天
服务端可主动对各个客户端发送消息，而各客户端只能单独发送给服务端。当然，只要你愿意，在服务端改下，即可转发了。
附件解压工程ChatSocket，运行TestServer、TestClient即可。src下还有两批处理，详细看TestServer文件内注释了。
1.1）ChatServer.java 


  1. /**
  2. *长连接、1对n主动发消息的服务器
  3. *
  4. *@authorJoin
  5. */
  6. publicclassChatServerextendsThread{
  8. /**服务端口*/
  9. privateintport;
  10. /**服务套接字*/
  11. privateServerSocketmServerSocket;
  12. /**线程池*/
  13. privateExecutorServicepool;
  14. /**客户端套接字集合*/
  15. privateArrayList<Socket>mClientList;
  17. publicChatServer(intport){
  18. this.port=port;
  19. pool=Executors.newCachedThreadPool();//缓存线程池
  20. mClientList=newArrayList<Socket>();
  21. }
  23. @Override
  24. publicvoidrun(){
  25. try{
  26. mServerSocket=newServerSocket(port);//创建本地特定端口服务器套接字
  27. Socketclient=null;
  28. while(true){
  29. client=mServerSocket.accept();//接收连接的套接字
  30. mClientList.add(client);//加入客户端列表
  31. System.out.println(client.getInetAddress()+"建立了连接");
  32. pool.execute(newThreadServer(client));//新线程执行任务
  33. }
  34. }catch(BindExceptione){//端口使用中
  35. System.out.println("端口使用中，请关闭后重开！");
  36. }catch(IOExceptione){
  37. e.printStackTrace();
  38. }
  39. }
  41. /**各个连接客户端的服务线程*/
  42. privateclassThreadServerextendsThread{
  44. privateSocketclient;
  46. publicThreadServer(Socketclient){
  47. this.client=client;
  48. }
  50. @Override
  51. publicvoidrun(){
  52. DataInputStreamin=null;
  53. DataOutputStreamout=null;
  54. try{
  55. in=newDataInputStream(client.getInputStream());
  56. out=newDataOutputStream(client.getOutputStream());
  57. BufferedReaderwt=newBufferedReader(newInputStreamReader(
  58. System.in));//控制台输入流
  59. while(true){
  60. if(in.available()>0){
  61. /*有数据时接收*/
  62. Stringstr=in.readUTF();
  63. System.out.println(str);
  64. /*接收end或空时，退出*/
  65. if(null==str||"end".equals(str)){
  66. System.out
  67. .println(client.getInetAddress()+"正常退出");
  68. break;
  69. }
  70. /*回复或转发已接收数据*/
  71. }else{
  72. if(wt.ready()){
  73. /*控制台有数据时发送*/
  74. Stringstr=wt.readLine();
  75. sendMessage(str);//群发消息
  76. }else{
  77. try{
  78. /*发送紧急数据，判断连接*/
  79. client.sendUrgentData(0xFF);
  80. Thread.sleep(100);
  81. }catch(Exceptione){
  82. System.out.println(client.getInetAddress()
  83. +"断开连接");
  84. break;
  85. }
  86. }
  87. }
  88. }
  89. }catch(SocketExceptione){//Connectionreset
  90. System.out.println(client.getInetAddress()+"异常退出");
  91. }catch(IOExceptione){
  92. e.printStackTrace();
  93. }finally{
  94. mClientList.remove(client);//移除当前客户端
  95. try{
  96. if(null!=in){
  97. in.close();
  98. }
  99. if(null!=out){
  100. out.close();
  101. }
  102. if(null!=client){
  103. client.close();
  104. }
  105. }catch(IOExceptione){
  106. e.printStackTrace();
  107. }
  108. }
  109. }
  111. }
  113. /**
  114. *群发信息
  115. *@throwsIOException
  116. */
  117. publicvoidsendMessage(Stringmsg)throwsIOException{
  118. DataOutputStreamout=null;
  119. for(Socketclient:mClientList){
  120. out=newDataOutputStream(client.getOutputStream());
  121. out.writeUTF(msg);
  122. out.flush();
  123. }
  124. }
  126. }
 

 


 1.2）ChatClient.java

 



  1. /**
  2. *接收和发送消息的客户端
  3. *
  4. *@authorJoin
  5. */
  6. publicclassChatClientextendsThread{
  8. /**套接字地址*/
  9. privateSocketAddressaddress;
  10. /**超时时间*/
  11. privateinttimeout;
  13. publicChatClient(Stringhost,intport,inttimeout){
  14. this.address=newInetSocketAddress(host,port);
  15. this.timeout=timeout;
  16. }
  18. @Override
  19. publicvoidrun(){
  20. Socketsocket=newSocket();//创建未连接套接字
  21. try{
  22. //socket.setOOBInline(false);//默认即是false，表示不处理紧急数据
  23. socket.connect(address,timeout);//连接到服务器，并指定超时时间
  24. handleSocket(socket);//数据接收发送处理
  25. }catch(ConnectExceptione){//拒绝连接
  26. System.out.println("连接不上服务器");
  27. }catch(SocketTimeoutExceptione){//连接超时
  28. System.out.println("连接服务器超时");
  29. }catch(IOExceptione){
  30. e.printStackTrace();
  31. }finally{
  32. try{
  33. if(null!=socket){
  34. socket.close();//关闭Socket
  35. }
  36. }catch(IOExceptione){
  37. e.printStackTrace();
  38. }
  39. }
  40. }
  42. privatevoidhandleSocket(Socketsocket){
  44. DataInputStreamin=null;
  45. DataOutputStreamout=null;
  46. try{
  47. in=newDataInputStream(socket.getInputStream());
  48. out=newDataOutputStream(socket.getOutputStream());
  49. BufferedReaderwt=newBufferedReader(newInputStreamReader(
  50. System.in));//控制台输入流
  51. while(true){
  52. if(wt.ready()){
  53. /*控制台有数据时发送*/
  54. Stringstr=wt.readLine();
  55. out.writeUTF(str);
  56. out.flush();
  57. /*发送end时，自身也退出*/
  58. if(str.equals("end")){
  59. break;
  60. }
  61. }else{
  62. try{
  63. /*发送紧急数据，判断连接*/
  64. socket.sendUrgentData(0xFF);
  65. Thread.sleep(100);
  66. }catch(Exceptione){
  67. System.out.println("服务器断开连接");
  68. break;
  69. }
  70. }
  71. /*有数据时接收并输出*/
  72. if(in.available()>0)
  73. System.out.println(in.readUTF());
  74. }
  75. }catch(SocketExceptione){//Connectionreset
  76. System.out.println("服务器异常");
  77. }catch(IOExceptione){
  78. e.printStackTrace();
  79. }finally{
  80. try{
  81. if(null!=in){
  82. in.close();
  83. }
  84. if(null!=out){
  85. out.close();
  86. }
  87. }catch(IOExceptione){
  88. e.printStackTrace();
  89. }
  90. }
  91. }
  93. }
 

 

 

 

 

2）对象消息
 


  发送对象消息。服务端有LinkServer和LinkServer2两个，分别支持单客户端与多客户端，方式也有些不一样。

 


  附件解压工程LinkedSocketB，.test包内Test开头的即是测试类了。服务端接收到客户端连接时，直接一个循环发送n个对象过去，没什么大问题^^。

 

 


 2.1）LinkClient.java

 



  1. /**
  2. *只建立一个Socket，长连接Server接收数据。
  3. *
  4. *@authorJoin
  5. */
  6. publicclassLinkClientextendsThread{
  8. /**套接字地址*/
  9. privateSocketAddressaddress;
  10. /**超时时间*/
  11. privateinttimeout;
  12. /**客户端监听接口*/
  13. privateOnLinkClientListenerlistener;
  15. /**
  16. *构造客户端
  17. *
  18. *@paramhost服务器名称
  19. *@paramport服务器端口
  20. *@paramtimeout连接超时时间
  21. */
  22. publicLinkClient(Stringhost,intport,inttimeout){
  23. this.address=newInetSocketAddress(host,port);
  24. this.timeout=timeout;
  25. }
  27. @Override
  28. publicvoidrun(){
  29. Socketsocket=newSocket();//创建未连接套接字
  30. try{
  31. socket.connect(address,timeout);//连接到服务器，并指定超时时间
  32. if(null!=listener){
  33. listener.onConnected();
  34. }
  35. receiveObj(socket);//接收服务器数据
  36. }catch(ConnectExceptione){//拒绝连接
  37. if(null!=listener){
  38. listener.onConnectException();
  39. }
  40. }catch(SocketTimeoutExceptione){//连接超时
  41. if(null!=listener){
  42. listener.onTimeoutException();
  43. }
  44. }catch(IOExceptione){
  45. e.printStackTrace();
  46. }finally{
  47. try{
  48. if(null!=socket){
  49. socket.close();//关闭Socket
  50. }
  51. }catch(IOExceptione){
  52. e.printStackTrace();
  53. }
  54. }
  55. }
  57. /**接收服务器发送的对象*/
  58. privatevoidreceiveObj(Socketsocket){
  59. //socket.shutdownOutput();//半关闭输出流
  61. ObjectInputStreamis=null;
  62. try{
  63. is=newObjectInputStream(newBufferedInputStream(
  64. socket.getInputStream()));
  65. /**循环接收对象*/
  66. while(true){
  67. Objectobj=is.readObject();
  68. if(null==obj){
  69. break;
  70. }
  71. if(null!=listener){
  72. listener.onReceive(obj);
  73. }
  74. }
  75. if(null!=listener){
  76. listener.onExited();
  77. }
  78. }catch(SocketExceptione){//Connectionreset
  79. if(null!=listener){
  80. listener.onSocketException();
  81. }
  82. }catch(IOExceptione){
  83. e.printStackTrace();
  84. }catch(ClassNotFoundExceptione){
  85. e.printStackTrace();
  86. }finally{
  87. try{
  88. if(null!=is){
  89. is.close();
  90. }
  91. if(null!=socket){
  92. socket.close();
  93. }
  94. }catch(IOExceptione){
  95. e.printStackTrace();
  96. }
  97. }
  98. }
  100. /**设置客户端监听接口*/
  101. publicvoidsetOnLinkClientListener(OnLinkClientListenerlistener){
  102. this.listener=listener;
  103. }
  105. }
 

 


 2.2）LinkServer.java

 



  1. /**
  2. *开启服务器，长连接一个Socket，主动发送数据
  3. *
  4. *@authorJoin
  5. */
  6. publicclassLinkServerextendsThread{
  8. /**服务端口*/
  9. privateintport;
  10. /**服务套接字*/
  11. privateServerSocketmServerSocket;
  12. /**线程池*/
  13. privateExecutorServicepool;
  14. /**服务器监听接口*/
  15. privateOnLinkServerListenerlistener;
  17. /**同步对象*/
  18. privateObjectlockObj=newObject();
  19. /**是否等待*/
  20. privatebooleanisWaiting=false;
  21. /**发送对象集合*/
  22. privateArrayList<Object>sendObjList;
  24. publicLinkServer(intport){
  25. this.port=port;
  26. pool=Executors.newCachedThreadPool();//缓存线程池
  27. sendObjList=newArrayList<Object>();
  28. }
  30. @Override
  31. publicvoidrun(){
  32. try{
  33. mServerSocket=newServerSocket(port);//创建本地特定端口服务器套接字
  34. Socketclient=null;
  35. client=mServerSocket.accept();//接收连接的套接字
  36. if(null!=listener){
  37. listener.onClientConnected(client.getInetAddress());
  38. }
  39. pool.execute(newThreadServer(client));//新线程执行任务
  40. }catch(BindExceptione){//端口使用中
  42. if(null!=listener){
  43. listener.onBindException();
  44. }
  45. }catch(IOExceptione){
  46. e.printStackTrace();
  47. }
  49. }
  51. /**各个连接客户端的服务线程*/
  52. privateclassThreadServerextendsThread{
  54. privateSocketclient;
  56. publicThreadServer(Socketclient){
  57. this.client=client;
  58. }
  60. @Override
  61. publicvoidrun(){
  62. ObjectOutputStreamos=null;
  63. try{
  64. os=newObjectOutputStream(client.getOutputStream());
  66. ObjectsendObj;
  67. synchronized(lockObj){
  68. while(true){
  69. if(sendObjList.size()<=0){
  70. isWaiting=true;
  71. lockObj.wait();
  72. }
  73. sendObj=sendObjList.get(0);
  74. os.writeObject(sendObj);
  75. os.flush();
  77. /*发送null时，表示退出了*/
  78. if(null==sendObj){
  79. if(null!=listener){
  80. listener.onExited(client.getInetAddress());
  81. }
  82. break;
  83. }
  84. sendObjList.remove(0);
  85. }
  86. }
  88. }catch(SocketExceptione){//Connectionreset
  89. if(null!=listener){
  90. listener.onSocketException(client.getInetAddress());
  91. }
  92. }catch(IOExceptione){
  93. e.printStackTrace();
  94. }catch(InterruptedExceptione){
  95. e.printStackTrace();
  96. }finally{
  97. try{
  98. if(null!=os){
  99. os.close();
  100. }
  101. if(null!=client){
  102. client.close();
  103. }
  104. }catch(IOExceptione){
  105. e.printStackTrace();
  106. }
  107. }
  108. }
  110. }
  112. /**发送序列化对象*/
  113. publicvoidsendObj(Objectobj){
  114. /*这个判断非必需的，记得就好*/
  115. if(null!=obj&&!isSerializable(obj))
  116. thrownewIllegalArgumentException(
  117. "Objectneedstoimplementjava.io.Serializable!");
  119. sendObjList.add(obj);
  121. if(isWaiting){
  122. synchronized(lockObj){
  123. lockObj.notifyAll();
  124. }
  125. isWaiting=false;
  126. }
  127. }
  129. /**判断是否序列化*/
  130. privatebooleanisSerializable(Objectobj){
  131. Class<?>[]cls=obj.getClass().getInterfaces();
  132. for(Class<?>clazz:cls){
  133. if(clazz.getName().equals(Serializable.class.getName()))
  134. returntrue;
  135. }
  136. returnfalse;
  137. }
  139. /**设置服务器监听接口*/
  140. publicvoidsetOnLinkServerListener(OnLinkServerListenerlistener){
  141. this.listener=listener;
  142. }
  144. }
 

 
 

  2.3）LinkServer2.java
 
 
 

 
  1. /**
  2. *开启服务器，长连接各个Socket，主动发送数据
  3. *
  4. *@authorJoin
  5. */
  6. publicclassLinkServer2extendsThread{
  8. /**服务端口*/
  9. privateintport;
  10. /**服务套接字*/
  11. privateServerSocketmServerSocket;
  12. /**服务器监听接口*/
  13. privateOnLinkServerListenerlistener;
  15. /**客户端套接字集合*/
  16. privateArrayList<Socket>clientList;
  17. /**客户端的输出流集合*/
  18. privateArrayList<ObjectOutputStream>osList;
  20. publicLinkServer2(intport){
  21. this.port=port;
  22. clientList=newArrayList<Socket>();
  23. osList=newArrayList<ObjectOutputStream>();
  24. }
  26. @Override
  27. publicvoidrun(){
  28. try{
  29. mServerSocket=newServerSocket(port);//创建本地特定端口服务器套接字
  30. Socketclient=null;
  31. while(true){
  32. client=mServerSocket.accept();//接收连接的套接字
  33. if(null!=listener){
  34. listener.onClientConnected(client.getInetAddress());
  35. }
  36. clientList.add(client);
  37. osList.add(newObjectOutputStream(client.getOutputStream()));//增加连接的输出流
  38. }
  39. }catch(BindExceptione){//端口使用中
  40. if(null!=listener){
  41. listener.onBindException();
  42. }
  43. }catch(IOExceptione){
  44. e.printStackTrace();
  45. }
  47. }
  49. /**发送序列化对象*/
  50. publicvoidsendObj(Objectobj){
  51. /*这个判断非必需的，记得就好*/
  52. if(null!=obj&&!isSerializable(obj))
  53. thrownewIllegalArgumentException(
  54. "Objectneedstoimplementjava.io.Serializable!");
  57. ObjectOutputStreamout=null;
  58. for(inti=0;i<osList.size();i++){
  59. try{
  60. out=osList.get(i);
  61. out.writeObject(obj);
  62. out.flush();
  64. /*发送null时，表示退出了*/
  65. if(null==obj){
  66. if(null!=listener){
  67. listener.onExited(clientList.get(i).getInetAddress());
  68. }
  69. closeSocket(i);//关闭当前Socket
  70. i--;//少了个记得减
  71. }
  72. }catch(SocketExceptione){//Connectionreset
  73. if(null!=listener){
  74. listener.onSocketException(clientList.get(i)
  75. .getInetAddress());
  76. }
  77. closeSocket(i);//关闭当前Socket
  78. i--;//少了个记得减
  79. }catch(IOExceptione){
  80. e.printStackTrace();
  81. closeSocket(i);//关闭当前Socket
  82. i--;//少了个记得减
  83. }
  84. }
  85. }
  87. /**关闭某个Socket*/
  88. privatevoidcloseSocket(intindex){
  89. try{
  90. osList.get(index).close();
  91. osList.remove(index);
  92. clientList.get(index).close();
  93. clientList.remove(index);
  94. }catch(IOExceptione1){
  95. e1.printStackTrace();
  96. }
  97. }
  99. /**判断是否序列化*/
  100. privatebooleanisSerializable(Objectobj){
  101. Class<?>[]cls=obj.getClass().getInterfaces();
  102. for(Class<?>clazz:cls){
  103. if(clazz.getName().equals(Serializable.class.getName()))
  104. returntrue;
  105. }
  106. returnfalse;
  107. }
  109. /**设置服务器监听接口*/
  110. publicvoidsetOnLinkServerListener(OnLinkServerListenerlistener){
  111. this.listener=listener;
  112. }
  114. }
 
 
 

 


 二、短连接通信

 


  客户端请求一次，建立一次Socket，完成后即可关闭。服务端通过accept()等待。

 

 


 1）对象消息

 


  客户端发送对象，服务端接受对象，很简单的例子。

 

 


 1.1）EasyClient.java

 



  1. /**
  2. *每次连接服务器发送一个消息
  3. *
  4. *@authorJoin
  5. */
  6. publicclassEasyClient{
  8. /**套接字地址*/
  9. privateSocketAddressaddress;
  10. /**超时时间*/
  11. privateinttimeout;
  12. /**客户端监听接口*/
  13. privateOnClientListenerlistener;
  15. publicEasyClient(Stringhost,intport,inttimeout){
  16. this.address=newInetSocketAddress(host,port);
  17. this.timeout=timeout;
  18. }
  20. /**
  21. *发送一个消息
  22. *
  23. *@paramobj对象消息
  24. */
  25. publicbooleansendMessage(Objectobj){
  26. booleanresult=false;
  27. Socketsocket=null;
  28. try{
  29. socket=newSocket();
  30. socket.connect(address,timeout);
  31. if(null!=listener){
  32. listener.onConnected();
  33. }
  34. result=sendMessage(socket,obj);
  35. }catch(ConnectExceptione){//拒绝连接
  36. if(null!=listener){
  37. listener.onConnectException();
  38. }
  39. }catch(SocketTimeoutExceptione){//连接超时
  40. if(null!=listener){
  41. listener.onTimeoutException();
  42. }
  43. }catch(IOExceptione){
  44. e.printStackTrace();
  45. }finally{
  46. try{
  47. if(null!=socket){
  48. socket.close();//关闭Socket
  49. socket=null;
  50. }
  51. }catch(IOExceptione){
  52. e.printStackTrace();
  53. }
  54. }
  55. returnresult;
  56. }
  58. /**通过Socket发送obj消息*/
  59. privatebooleansendMessage(Socketsocket,Objectobj){
  60. booleanresult=false;
  61. ObjectOutputStreamos=null;
  62. try{
  63. os=newObjectOutputStream(socket.getOutputStream());
  64. os.writeObject(obj);
  65. os.flush();
  66. if(null!=listener){
  67. listener.onMessageSent(obj);
  68. }
  69. result=true;
  70. }catch(SocketExceptione){//Connectionreset
  71. if(null!=listener){
  72. listener.onSocketException();
  73. }
  74. }catch(IOExceptione){
  75. e.printStackTrace();
  76. }finally{
  77. try{
  78. if(null!=os){
  79. os.close();
  80. }
  81. }catch(IOExceptione){
  82. e.printStackTrace();
  83. }
  84. }
  85. returnresult;
  86. }
  88. /**设置客户端监听接口*/
  89. publicvoidsetOnClientListener(OnClientListenerlistener){
  90. this.listener=listener;
  91. }
  93. }
 

 


 1.2）EasyServer.java
 
 

 



  1. publicclassEasyServerextendsThread{
  3. /**服务端口*/
  4. privateintport;
  5. /**服务套接字*/
  6. privateServerSocketmServerSocket;
  7. /**服务器监听接口*/
  8. privateOnServerListenerlistener;
  10. publicEasyServer(intport){
  11. this.port=port;
  12. }
  14. @Override
  15. publicvoidrun(){
  16. try{
  17. mServerSocket=newServerSocket(port);//创建本地特定端口服务器套接字
  18. Socketsocket=null;
  19. while(true){
  20. socket=mServerSocket.accept();//接收连接的套接字
  21. receiveMessage(socket);//接收socket处理消息
  22. }
  23. }catch(BindExceptione){//端口使用中
  24. if(null!=listener){
  25. listener.onBindException();
  26. }
  27. }catch(IOExceptione){
  28. e.printStackTrace();
  29. }
  30. }
  32. /**接收处理每个Socket信息*/
  33. privatevoidreceiveMessage(Socketsocket){
  34. ObjectInputStreamis=null;
  35. try{
  36. is=newObjectInputStream(newBufferedInputStream(
  37. socket.getInputStream()));
  38. Objectobj=is.readObject();
  39. if(null!=listener){
  40. listener.onReceive(socket.getInetAddress(),obj);
  41. }
  42. }catch(SocketExceptione){//Connectionreset
  43. if(null!=listener){
  44. listener.onSocketException(socket.getInetAddress());
  45. }
  46. }catch(IOExceptione){
  47. e.printStackTrace();
  48. }catch(ClassNotFoundExceptione){
  49. e.printStackTrace();
  50. }finally{
  51. try{
  52. if(null!=is){
  53. is.close();
  54. }
  55. if(null!=socket){
  56. socket.close();
  57. }
  58. }catch(IOExceptione){
  59. e.printStackTrace();
  60. }
  61. }
  62. }
  64. /**设置服务器监听接口*/
  65. publicvoidsetOnServerListener(OnServerListenerlistener){
  66. this.listener=listener;
  67. }
  69. }
 

 


 三、后记

 


  恩，哦，socket还有个比较常用的是setSoTimeout()，在read()阻塞超时会报SocketTimeoutException，catch住处理即可。

 

 


  更多的如SSLSocket、NIO的简单例子，可以先
 Click here！这个整理好的样例工程就不提供了，自己动手^^！

 

 

 ps：老遇到8W冗余字符，拆着拆着就三个了==！
 

 

 

 

出处http://vaero.blog.51cto.com/4350852/893847
 


                

        




    

    
  



    

      

        

            

              
                
                  iteye_11539
                
              
            

            

                关注
              
            

        

        

          
      

      










            

  



          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值