关于用java实现RMI通信的项目，MeetingRMI

最新推荐文章于 2021-03-13 17:59:29 发布
最新推荐文章于 2021-03-13 17:59:29 发布
阅读量2.4k 收藏 5
点赞数 2
分类专栏： Java 文章标签： java 分布式 通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u013592371/article/details/52742760
版权

一、项目需求介绍
应用Java RMI构建一个分布式议程服务(Agenda Service)。不同的客户应能连接到这一共享的议程服务，并查询、添加和删除议程中的会晤（meeting）安排。服务程序应具备新用户注册、清除某一用户所有会晤安排等管理功能。
（1）功能要求
功能1、用户注册:
注册新用户，用户设置一个唯一的用户名以及一个对应密码。如果注册时提供的用户名已由其他用户使用，应反馈出错信息；成功注册后，反馈成功注册的信息。
功能2、添加议程:
已注册的用户可以添加一个新议程到其议程安排中。规定议程仅允许在两个已注册的用户间举行，不可创建无另一已注册用户的议程。 添加议程时提供的信息应包括：议程的起始时间start time和终止时间end time、描述本次议程的标签title、以及预约的另一用户名字otherUser。 成功添加议程后，它应既出现在发起该议程的用户的议程中，也应出现在该议程所预约的另一用户的议程中。 注意，用户不允许分身参加多个议程，即如果用户自己或被预约的用户已有一个议程安排与新议程在时间上相互重叠（冲突），该新议程将无法成功添加到议程管理系统中。 用户在添加议程后，获得适当的反馈信息以得知是成功地添加了新议程还是在添加过程出现了某些错误。
功能3、查询议程:
已注册的用户可以查询自己的议程中某一时间段（time interval）的所有议程安排。查询议程时提供的参数应包括所关注时间段的起始时间和终止时间； 查询结果返回该用户议程中在指定时间范围内找到的所有议程安排的列表， 在列表中给出每一议程的起始时间、终止时间、标签、以及被预约的另一用户的名字。
功能4、删除议程:
已注册的用户可以删除自己登记的某一议程安排。删除议程时，提供的参数除执行删除功能的用户的名字及其密码外， 还包括一个能惟一地标识待删除的议程的参数。
功能5、清除议程:
已注册的用户可以清除自己创建的所有议程安排。
（2）接口约定
客户程序通过命令行参数访问远程服务，客户端各功能的命令格式如下：
注册用户命令：
register:java client [localhost] [1099] register [username] [password]
添加议程命令：
add:java client [localhost] [1099] add [username] [password] [ScheduleUser] [label] [start] [end] [tile]
查询议程命令：
query:java client [localhost] [1099] query [username] [password] [start] [end]
删除议程命令：
delete:java client [localhost] [1099] clear [username] [password] [meetingid]
清空议程命令：
clear:java client [localhost] [1099] clear [username] [password]

二、项目设计
MeetingRMI架构图
三、源代码
1.首先定义服务接口

package Meetingrmi;
/*define remote interface 
 * @author basara 
 * */
import java.rmi.*;
import java.sql.SQLException;

public interface ServiceInterface extends Remote {
    public boolean register(String userName, String password) throws RemoteException, SQLException;

    public boolean add(String userName, String password, String schedule_user, String title, String label, String startTime, String endTime) throws RemoteException;

    public String[] query(String userName, String start, String end) throws RemoteException, SQLException;

    public boolean delete(String userName, int meetingID) throws RemoteException, SQLException;

    public boolean clear(String userName) throws RemoteException;
}

2.然后实现上述接口，定义操作数据库的具体方法

package Meetingrmi;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

@SuppressWarnings("serial")
public class ServiceImpl extends UnicastRemoteObject implements ServiceInterface {

    public java.sql.Connection conn = null;
    public java.sql.ResultSet rs = null;
    java.sql.Statement st=null;
    java.sql.Statement st1=null;
    java.sql.Statement st2=null;
    java.sql.Statement st3=null;
    java.sql.Statement st4=null;
    java.sql.Statement st5=null;
    java.sql.Statement st6=null;
    java.sql.Statement st7=null;
    java.sql.Statement st8=null;
    java.sql.Statement st9=null;
    ResultSet a,b,c,d,e,f,g,h,i,j;
    public ServiceImpl() throws RemoteException {
        try {
            //注册驱动
            //com.microsoft.sqlserver.jdbc.SQLServerDriver
            //Class.forName("org.objectweb.rmijdbc.Driver").newInstance();
            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver").newInstance();
            //创建数据库连接
            String url = "jdbc:sqlserver://localhost:1433;"+"DatabaseName=MeetingManager;UserName = sa;PassWord = 123";
            //创建执行对象
            conn = DriverManager.getConnection(url);        
            st = conn.createStatement();
            st1 = conn.createStatement();
            st2 = conn.createStatement();
            st3 = conn.createStatement();
            st4 = conn.createStatement();
            st5 = conn.createStatement();
            st6 = conn.createStatement();
            st7 = conn.createStatement();
            st8 = conn.createStatement();
            st9 = conn.createStatement();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public int register(String sql){
        int num=0;
        try{
            num=st.executeUpdate(sql);
        }
        catch(SQLException e){}
        return num;
    }
    public ResultSet query(String sql){
        rs=null;
        try{
            rs=st.executeQuery(sql);
        }
        catch(SQLException e){
            e.printStackTrace();
        }
        return rs;
    }
    public int add(String sql){
        int num=0;
        try{
            num=st.executeUpdate(sql);
        }catch(SQLException e){}
        return num;
    }
    public int delete(String sql){
        int num=0;
        try{
            num=st.executeUpdate(sql);
        }
        catch(SQLException e){}
        //CloseDataBase();
        return num;
    }
    public int clearAll(String sql){
        int num=0;
        try{
            num=st.executeUpdate(sql);
        }
        catch(SQLException e){}
        //CloseDataBase();
        return num;
    }
    public void CloseDataBase(){
        try{
            conn.close();
            st.close();
        }
        catch(Exception e){}
    }
    // add a meeting
    @Override
    public boolean add(String userName, String password, String schedule_user,
            String title, String label, String startTime, String endTime) throws RemoteException {

        boolean flag = false;
        boolean flag1=true;
        boolean flag2=true;
        int meetingID = 0;
        int rowCount=0;
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        Date startDate = null;
        Date endDate = null;
            try {
                startDate = sdf.parse(startTime);
                endDate = sdf.parse(endTime);
            } catch (ParseException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            try {
                a=st.executeQuery("select * from userinfo where userName='"+userName+"'");
                j=st9.executeQuery("select * from userinfo where userName='"+schedule_user+"'");
                if (a.next()&&j.next()) {
                    flag = true;
                }
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // judge if user& schedule user have other meeting
                try {
                    b=st1.executeQuery("select * from meeting where userName='"+userName+"'");
                    c=st2.executeQuery("select * from meeting where schedule_user='"+schedule_user+"'");
                    while(b.next()){
                        String StartString=b.getString(6);

                        String EndString=b.getString(7);

                        Date StartDate = sdf.parse(StartString);
                        Date EndDate = sdf.parse(EndString);

                        if((startDate.getTime()<=StartDate.getTime()&&endDate.getTime()>=StartDate.getTime())||
                            (startDate.getTime()<=EndDate.getTime()&&endDate.getTime()>=EndDate.getTime())){
                            System.out.println("预约人的时间有冲突！");//与user的时间冲突
                            flag1=false;
                            break;
                        }       
                    }
                    while(c.next()){
                        String schedule_StartString=c.getString(6);
                        String schedule_EndString=c.getString(7);
                        Date schedule_StartDate = sdf.parse(schedule_StartString);
                        Date schedule_EndDate = sdf.parse(schedule_EndString);
                        if((startDate.getTime()<=schedule_StartDate.getTime()&&endDate.getTime()>=schedule_StartDate.getTime())||
                                (startDate.getTime()<=schedule_EndDate.getTime()&&endDate.getTime()>=schedule_EndDate.getTime()))
                        {
                            System.out.println("参会者的时间有冲突！");//与anotherUser的时间冲突
                            flag2=false;
                            break;
                        }

                    }
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (ParseException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            if(flag&&flag1&&flag2){
                try {
                    i=st8.executeQuery("select * from meeting");
                    while(i.next()) 
                    {
                        rowCount++;
                    }
                    meetingID=rowCount+1;
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                String sql = "insert into meeting(meetingID,userName,schedule_user,title,label,startTime,endTime) values("
                    +meetingID+",'"+userName+"','"+schedule_user+"','"+title+"','"+label+"','"+startTime+"','"+endTime+"')";
                add(sql);

                System.out.println("增加会议成功！会议ID：" + meetingID);

                return true;
            }
        else{
            System.out.println("客户尚未预约或存在时间冲突！");
            return false;
            }
    }

    // clean all
    @Override
    public boolean clear(String userName) throws RemoteException {

        boolean flag = false;
        try {
            d=st3.executeQuery("select * from userinfo where userName='"+userName+"'");
        } catch (SQLException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        try {
            if (d.next()) {
                System.out.println("操作人已注册！");
                flag = true;
            }
        } catch (SQLException e) {e.printStackTrace();}
        if (flag) {
            String sql="delete from meeting where userName='"+userName+"'";
            clearAll(sql);
            System.out.println(userName+"创建的会议已被清除！");
            return true;
        }
        else {
            System.out.println("操作人未注册！");
            return false;
        }
    }

    //delete a meeting
    public boolean delete(String userName, int meetingID) throws RemoteException, SQLException {

        boolean flag = false;
        try {
            e=st4.executeQuery("select * from userinfo where userName='"+userName+"'");
        } catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        try {
            if (e.next()) {
                System.out.println("操作人已注册！");
                flag = true;
            }
        } catch (SQLException e) {e.printStackTrace();}

            if (flag) {
                String sql="delete from meeting where userName='"+userName+"' and meetingID='"+meetingID+"'";
                delete(sql);
                System.out.println(userName+"创建的ID为"+meetingID+"的会议已被清除！");
                return true;
            }
            else {
                System.out.println("操作人未注册或密码错误！");
                return false;}
    }

    //query meeting
    @Override
    public String[] query(String userName, String start, String end) throws RemoteException,SQLException {

        boolean flag = false;
        SimpleDateFormat sdf=new SimpleDateFormat("yy-MM-dd");
        try {
            f=st5.executeQuery("select * from userinfo where userName='"+userName+"'");
        } catch (SQLException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        String[] s = new String[100];

            if (f.next()) {
                System.out.println("操作人已注册！");
                flag = true;
            }

            if (flag) {
                Date startDate = null;
                Date endDate = null;
                try {
                    startDate = sdf.parse(start.trim());
                    endDate = sdf.parse(end.trim());
                } catch (ParseException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                String sql="select * from meeting where userName='"+userName+"'or schedule_user = '"+userName+"'and startTime>='"+startDate.toLocaleString()+"'  and endTime<='"+endDate.toLocaleString()+"'";
                try {
                    g=st6.executeQuery(sql);
                } catch (SQLException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                int i=0;
                while (g.next()) {
                    s[i]="ID:"+g.getInt(1)+" 参会人:<"+g.getString(2)+"&"+g.getString(3)+"> "+"Title:"+g.getString(4)+" Label:"+g.getString(5);
                    i++;
                }
                return s;       
            }
            else{
                System.out.println("操作人未注册！");
                String[] err= new String[1];
                err[0]="查询失败，请检查是否已注册！";
                return err;
            }
    }

    //register 
    @Override
    public boolean register(String userName, String password) throws RemoteException, SQLException {

            try {
                h=st7.executeQuery("select * from userinfo where userName='"+userName+"'");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            if (h.next()) {
                System.out.println("客户端注册失败！其所使用的用户名已经存在！");
                return false;
            }

            else{
            String sql="insert into userinfo(userName,password) values ('"+userName+"','"+password+"')";
            register(sql);
            System.out.println("客户端注册成功！");
            return true;
            }
    }
}

3.服务端

package Meetingrmi;
/*server of RMI*/
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;

public class Server { 

    private static int PORT = 8099;

    public static void main(String[] args) {

        String registryURL = "rmi://localhost:"+PORT+"/RMIServer";
        try {       
            ServiceImpl service = new ServiceImpl();
            LocateRegistry.createRegistry(PORT);
            Naming.bind(registryURL, service);
            System.out.println("-->Service Started");
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

4.客户端

package Meetingrmi;

import java.util.Scanner;
import java.net.MalformedURLException;
import java.rmi.*;
import java.sql.SQLException;

public class Client 
{
    static String userName;
    static String password;
    static String schedule_user;
    static String title; static String label;
    static String startTime; static String endTime;
    static int meetingID;
    private static int PORT = 8099;

    public static void main(String[] args)
    {

        System.out.println("请在“Client”后面添加命令！");
        System.out.println("命令列表：");
        System.out.println("-r register  注册用户");
        System.out.println("-a add  添加会议");
        System.out.println("-q query  查询相关会议");
        System.out.println("-d delete  删除相关会议");
        System.out.println("-c clear  清除某预约人的所有会议");
        System.out.println("end  结束程序");
        args = new String[100];
        args[0]="start";

        //SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String registryURL = "rmi://localhost:"+PORT+"/RMIServer";
        ServiceInterface service = null;
        try {
            service = (ServiceInterface)Naming.lookup(registryURL);
            Scanner scan = new Scanner(System.in);
        while(!args[0].equals("end")){
            System.out.println("请输入命令：（例如： -a）");
            args[0]=scan.nextLine();

            if(args[0].equals("-r"))
            {
                System.out.print("请输入用户名: ");
                  userName = scan.nextLine();
                  System.out.print("请输入密码: ");
                  password = scan.nextLine();
                  if (service.register(userName, password)) {
                      System.out.println("注册成功！");
                }else{
                    System.out.println("注册失败！您所使用的用户名已经存在！");
                    }
            }

            else if(args[0].equals("-a"))
            {

                System.out.println("请依次输入预约人、密码、其他参会人、会议主题、标签、起始时间和终止时间，用回车符分隔：");
                userName = scan.nextLine(); password = scan.nextLine();
                schedule_user = scan.nextLine(); title = scan.nextLine();
                label = scan.nextLine(); startTime = scan.nextLine();
                endTime = scan.nextLine();
                if (service.add(userName, password, schedule_user, title, label, startTime,endTime)) {
                    System.out.println("预约成功！");
                }
                else {
                    System.out.println("预约失败！请检查：");
                    System.out.println("1、您是否已注册");
                    System.out.println("2、您或者其他参会人已有会议安排");
                    System.out.println("3、会议时间是否存在冲突");
                }
            }

            else if(args[0].equals("-q"))
            {
                System.out.println("请依次输入查询人、起始时间和终止时间，用回车符分隔：");
                userName = scan.nextLine();
                startTime = scan.nextLine();
                endTime = scan.nextLine();
                String[] queryresult= new String[100];
                queryresult = service.query(userName,startTime,endTime);

                if(queryresult.length>=1&&queryresult[0] != null){
                    for(int i=0;i<queryresult.length;i++){
                        if(queryresult[i] != null){
                            System.out.println(queryresult[i]);
                        }
                    }
                }
                else
                    {System.out.println("未查询到相关会议信息！");}
            }

            else if(args[0].equals("-d"))
            {

                System.out.println("请依次输入预约人和会议ID，用回车符分隔：");
                userName = scan.nextLine();
                meetingID = scan.nextInt();
                if(service.delete(userName,meetingID))
                    System.out.println("删除成功！");
                else
                    System.out.println("请检查预约人或会议ID是否输入有误！");
            }
            else if(args[0].equals("-c"))
            {

                System.out.println("请输入预约人：");
                userName = scan.nextLine();
                if(service.clear(userName)){
                System.out.println("清除完成！");}
                else {
                    System.out.println("操作失败！");
                }

            }
            else
            {System.out.println("非法命令！");}
        }
        } catch (MalformedURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (RemoteException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NotBoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

附数据库中两张表：
meeting表

user表

本项目中使用SQLServer数据库，有交互性，基本的事件冲突判断都具有，不足之处在于只在本机上进行实验，未曾在两台主机之间进行测试。
特此分享，代码结构尚不完善，望各位大神不吝赐教，共同进步！

Java中RMI的实现
一亩三分地
05-28 797
最近在学习Java中的设计模式，在代理模式中有一种远程代理，它是通过RMI来实现的。1、作用 RMI是通过网络使得本地对象能够方便地远程对象的方法，使得本地对象调用远程对象的方法跟调用本地对象的方法一样。2、 调用过程 如上图，客户端中的客户对象调用服务端服务对象的方法A()，其过程是： (1) 客户对象调用远程对象的方法A()； (2) 客户辅助对象将请求进行包装，通过网络发送到服务端
Java-RMI:Java 的 RMI 实现，在 Java 中
07-05
RMI是Java在分布式环境中实现对象间通信的重要手段，它简化了分布式应用程序的开发过程。在这个Java-RMI项目中，我们可以看到它是作为卡内基梅隆大学15-440分布式系统课程的一个实践部分，旨在让学生深入理解和应用...
原创的JavaRMI项目
11-05
这是原创的最简单的Java RMI入门项目，内含二个Eclipse项目，一是服务器端，二是客户端。非常简单，只看其中的注释就能理解（当然先要知道什么是RMI了），只供入门用。 这是用Java 1.7编辑的，如果你用的版本低，则可以修改项目的版本，或新建项目，然后把代码复制到新项目中运行。
java进程通信方式rmi_java 进程通信之： RMI（远程方法调用）
weixin_31098573的博客
02-13 225
1/4：import java.rmi.Remote;import java.rmi.RemoteException;import java.util.Map;/*** 远程RMI 页面采集接口***/public interface IPageCollectRMI extends Remote {public String test(String str) throws RemoteExcept...
RMI
duguyidao的专栏
05-11 166
RMI RMI（Remote Method Invocation，远程方法调用）是用Java在JDK1.1中实现的，它大大增强了Java开发分布式应用的能力。Java作为一种风靡一时的网络开发语言，其巨大的威力就体现在它强大的开发分布式网络应用的能力上，而RMI就是开发百分之百纯Java的网络分布式应用系统的核心解决方案之一。其实它可以被看作是RPC的Java版本。但是传统RPC并不能很...
java rmi通信,一个完整的Java RMI通信的例子
weixin_42423349的博客
03-13 188
一个完整的Java RMI通讯的例子完整的代码，请参考附件。服务器端：public class RmiUserServiceImpl extends UnicastRemoteObject implementsRmiUserService {UserService service = new UserServiceImpl();public RmiUserServiceImpl() throws ...
RMI.rar_Java RMI_java.rmi_java.rmi.Remot_remote
09-20
总之，Java RMI是构建分布式Java应用的重要工具，它简化了网络通信的复杂性，让开发者可以专注于业务逻辑，而不是底层网络实现。虽然现代的Java框架如Spring、EJB等提供了更高级别的分布式服务，但理解RMI的基本原理...
java_rmi.rar_RMI java_java.rmi
09-19
- **安全性**：RMI可以通过SSL/TLS加密通信，并且可以使用Java的安全管理器来控制访问权限。 - **动态导出和导入**：服务器可以在运行时动态地导出或导入远程对象，提供更大的灵活性。 学习和理解Java RMI对于开发...
JAVA分布式之RMI实例教程网络通信原理[收集].pdf
10-19
JAVA分布式之RMI实例教程网络通信原理[收集].pdf
java-rmi.zip_RMI java_rmi
09-14
"java-rmi.zip_RMI java_rmi"这个文件很可能是包含了一些关于RMI实现的示例代码或库文件。RMI在分布式计算环境中非常有用，它使得开发者可以构建分布式应用程序，这些程序可以跨越网络调用方法，就像它们在同一台...
RMI的JAVA实现
10-26
RMI的JAVA实现 JAVA RMI
RMI测试项目
12-18
RMI远程方法调用测试项目
一个完整的Java RMI通讯的例子
04-16
NULL 博文链接：https://javapub.iteye.com/blog/1807349
Java RMI通讯
Lkyphoon的博客
03-29 444
java开发之RMI通讯 RMI概要：RMI远程方法调用是计算机之间通过网络实现对象调用的一种通讯机制，使用这种机制，一台计算机上的对象可以调用另外一台计算机上的对象来获取远程数据 优点：与通过TCP/IP协议或者socket来实现远程通讯相比，RMI是一种面向对象的开放方式 使用步骤： 1，制作远程接口 （继承Remote接口） 2，实现远程接口    3，注册RMI服务端，开启服务
Java RMI实现
Radom&7
10-18 320
定义一个远程接口 public interface IService extends Remote{ public String queryName(String no) throws RemoteException; } 实现远程的接口 public class ServiceImpl extends UnicastRemoteObject implements IServic...
Java分布式通信之RMI
xufaxi的专栏
04-28 910
RMI概述    在Java中实现远程调用的方式主要有两种技术，一个是RMI，一个是webservice,本次主要讲解RMI技术。RMI是Remote Method Invocation缩写,是Java用于透明远程调用的重要机制，它使客户机上运行的程序可以调用远程服务器上的对象，在远程调用中，客户端只要拥有服务端提供的接口，通过此接口实现对远程服务端的调用，它的目的在于对开发人员屏蔽横跨不同JVM和
Java RMI
扶我起来。。。
08-17 1202
一. Java RMI概述 RMI远程方法调用是计算机之间通过网络实现对象调用的一种通讯机制。使用这种机制，一台计算机上的对象可以调用另外一台计算机上的对象来获取远程数据。 二.示例 1.先看下示例结构 2. agent:是本地的意思；remote是远程服务端。 3. 先看下远端服务包下的类： ...
Java RMI通讯实例
Snow的专栏
08-01 476
服务接口   import java.rmi.Remote; import java.rmi.RemoteException; /**  * 接口继承Remote,并且方法抛出RemoteException  * @author sihang  *  */ public interface IHelloService extends Remote{          publ...
通过动态调试了解Java RMI底层通信
hldfight
03-14 983
0 前言 为了明白ysoserial中提供的exploit中的JRMPClient与JRMPListener攻击原理，于是去动态调试了Java RMI来了解其底层通信原理，在此做个记录： 1 RMI服务端 首先先调试RMI服务端的代码，如下是我编写的简易RMIServer代码： public class RMIServer { public stati...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值