项目打包class文件（打补丁更新）的工具类

于 2021-07-22 09:26:51 发布
阅读量328 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49605579/article/details/118991099
版权

文件管理 自动化复制 update.txt 文件路径解析 Java工具类
关键词由CSDN通过智能技术生成

1.创建update.txt，为相对路径加/方式

/tobacco_qdn/WebRoot/WEB-INF/pages/regulation/training/files/list.jsp
/tobacco_qdn/regulation/cn/mos/restructure/controller/training/files/TrainingFiles.java

2.创建getFile工具类，适当修改配置

package cn.mos;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;


/**
 * @author
 * @name IgagaCinemasAction
 */

public class GetFile {
    private static long lastmodifytime = 3 * 24 * 60 * 60 * 1000;  //默认找两小时内的文件,用于getTxtByTime方法来更新update.txt
    private static String resultFloder = "C:\\Users\\jrkj_21\\Desktop\\upload";  //导出文件放的位置
    private static String projectname = "";//工程名称

    public static void main(String[] args) throws IOException {
//			getTxtByTime();//打印出近期更新文件，时间以lastmodifytime为准

        proFileByTxt(); //根据update.txt输出更新文件

    }


    private static String baseFloderNoproject = null;
    private static String baseFloder = null;
    private static String updatefile = null;
    private static String webRoot = "WebRoot";  //工程WebRoot地址,一般不改	

    static {
        //*********************默认配置为当前工程，不用管********************************/
        baseFloder = GetFile.class.getResource("/").toString();
        if (baseFloder != null) {
            baseFloder = baseFloder.substring(6, baseFloder.indexOf("/WebRoot"));//如果是windwos将5变成6  
            baseFloder = baseFloder.replaceAll("\\/", "\\\\");
            projectname = baseFloder.substring(baseFloder.lastIndexOf("\\") + 1);
            baseFloderNoproject = baseFloder.substring(0, baseFloder.lastIndexOf("\\"));
            resultFloder = resultFloder + "\\" + projectname;
        }
        System.out.println("当前工程路径" + baseFloder);
        updatefile = baseFloder + "\\src\\update.txt";   //升级文档
        System.out.println("升级文档路径" + updatefile);
        //*********************默认配置为当前工程，不用管********************************/


    }


    private static void getTxtByTime() {
        File dir = new File(baseFloder);
        System.out.println("");
        System.out.println("");
        System.out.println("============以下为近期更新文件=================");
        getTxtByTime(dir);//根据时间，更新update.txt			
    }

    private static void getTxtByTime(File dir) {
        if (dir.isDirectory()) {
            String[] children = dir.list();
            for (int i = 0; i < children.length; i++) {
                getTxtByTime(new File(dir, children[i]));
            }
        } else {
            //如果不是目录 
//		        	Calendar cl = java.util.Calendar.getInstance();
//	        		cl.setTimeInMillis(dir.lastModified());
//	        		System.out.println(dir.lastModified()+" "+Kit.formatDate(cl.getTime(), "yyyy-MM-dd"));
            if ((System.currentTimeMillis() - dir.lastModified()) < lastmodifytime) {
                if (dir.getName().contains(".") && !dir.getName().endsWith(".class") && !dir.getName().endsWith(".txt") && !dir.getName().contains(".svn")) {
                    if (!dir.getPath().contains("\\WEB-INF\\classes\\")) {
                        if (!dir.getName().contains("GetFile")) {//排除掉当前文件
                            long timemiao = (System.currentTimeMillis() - dir.lastModified()) / 1000;
                            String selfpath = dir.getAbsolutePath();
                            if (selfpath.contains("src")) {
                                selfpath = selfpath.substring(selfpath.indexOf("src") + 4);
                                selfpath = selfpath.replaceAll("\\\\", ".");
                            }
                            if (selfpath.contains(webRoot)) {
                                selfpath = selfpath.substring(selfpath.indexOf(webRoot));
                            }
//		        					selfpath = selfpath.substring();
//		        					System.out.println(selfpath);
                            //System.out.println(dir.getName()+" "+dir.lastModified());
                        }
                    }
                }
            }
        }
    }

    private static void proFileByTxt() {
        List loglist = new ArrayList();

        if (!resultFloder.contains("upload")) {
            System.out.println("安全警告，建议输出目录名包括upload，防止错误的删除一般目录");
            return;
        }
        File rfloder = new File(resultFloder);
        if (!rfloder.exists()) {
            rfloder.mkdirs();
        } else {
            System.out.println("===================输出目录存在，删除重建================");
            deleteDir(rfloder);
            rfloder.mkdirs();
        }
        Map map = readUpdateFile(updatefile, baseFloder, webRoot, resultFloder, loglist);//读升级文档
        copyFiles(map, loglist);//把文件拷贝到另一外文件夹
        writelog(resultFloder, loglist);//写日志
    }


    private static void writelog(String resultFloder, List loglist) {
        File rfloder = new File(resultFloder);
        if (!rfloder.exists()) {
            rfloder.mkdirs();
        }
        rfloder = new File(resultFloder);
        String logcontent = "";
        for (int i = 0; i < loglist.size(); i++) {
            logcontent += (String) loglist.get(i) + "\r\n";
        }
        writeFile(rfloder.getAbsolutePath() + "\\更新log.txt", logcontent, "gbk");
    }

    /**
     * 递归获取文件列表
     *
     * @param tempbp
     * @param rsbp
     * @param map
     */
    private static void getFilsByFloler(String tempbp, String rsbp, Map map) {
        File tf = new File(tempbp);
        if (tf.exists() && tf.isDirectory()) {
            File[] fs = tf.listFiles();
            if (fs != null && fs.length > 0) {
                for (int i = 0; i < fs.length; i++) {
                    if (fs[i].isFile()) {
                        map.put(tempbp + fs[i].getName(), rsbp + fs[i].getName());
                    } else if (fs[i].isDirectory()) {
                        String next_tempbp = tempbp + fs[i].getName() + "\\";
                        String next_rsbp = rsbp + fs[i].getName() + "\\";
                        getFilsByFloler(next_tempbp, next_rsbp, map);
                    }
                }
            }
        } else if (tf.isFile()) {
            map.put(tempbp + tf.getName(), rsbp + tf.getName());
        }
    }

    private static Map readUpdateFile(String updatefile, String baseFloder, String webRoot, String resultFloder, List loglist) {
        LinkedHashMap map = new LinkedHashMap();
        try {
            File file = new File(updatefile);
            if (file.exists()) {  //文件存在时  

                if (!resultFloder.endsWith("\\")) {//统一添加结尾的斜杠
                    resultFloder = resultFloder.replaceAll("/", "\\");
                    resultFloder += "\\";
                }
                if (!baseFloder.endsWith("\\")) {//统一添加结尾的斜杠
                    baseFloder = baseFloder.replaceAll("/", "\\");
                    baseFloder += "\\";
                }


                String line;
                BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
                int count = 0;
                while ((line = reader.readLine()) != null) {
                    if (line != null) {
                        line = line.trim();
                        String rs = "未处理";
                        String tempbp = "";
                        if (!"".equals(line)) {

                            if (line.contains("/WebRoot/")) {
                                line = "/" + line.split("/WebRoot/")[1];
//				    				  System.out.println(line);
                            }

                            if (line.startsWith("/" + projectname)) {//注意，新版本的myeclipse复制文件
                                int gedp = line.indexOf("/cn/");
                                if (gedp <= 3) {
                                    gedp = line.indexOf("/com/");
                                }
                                line = line.substring(gedp + 1);
                            }


                            if (line.endsWith(".java") && (line.startsWith("com") || line.startsWith("cn"))) {//类文件
                                if (line.endsWith(".java")) {
                                    line = line.substring(0, line.length() - 5);
                                }
                                tempbp = baseFloder + webRoot + "\\WEB-INF\\classes\\" + line.replaceAll("\\.", "\\\\") + ".class";
                                String rsbp = resultFloder + webRoot + "\\WEB-INF\\classes\\" + line.replaceAll("\\.", "\\\\") + ".class";
                                if (isExists(tempbp)) {
                                    rs = "路径正确 " + getTime(tempbp) + " ";
                                    map.put(tempbp, rsbp);
                                } else {
                                    rs = "不正确";
                                }

                                for (int i = 1; i < 10; i++) {
                                    String tempbp2 = baseFloder + webRoot + "\\WEB-INF\\classes\\" + line.replaceAll("\\.", "\\\\") + "$" + i + ".class";
                                    String rsbp2 = resultFloder + webRoot + "\\WEB-INF\\classes\\" + line.replaceAll("\\.", "\\\\") + "$" + i + ".class";

                                    if (isExists(tempbp2)) {
                                        map.put(tempbp2, rsbp2);
                                    } else {
                                        break;
                                    }

                                }


                            } else if (line.endsWith("xml") && (line.contains("cn") || line.contains("com"))) {
                                if (line.endsWith(".xml")) {
                                    line = line.substring(0, line.length() - 4);
                                }
                                tempbp = baseFloder + webRoot + "\\WEB-INF\\classes\\" + line.replaceAll("\\.", "\\\\") + ".xml";
                                String rsbp = resultFloder + webRoot + "\\WEB-INF\\classes\\" + line.replaceAll("\\.", "\\\\") + ".xml";
                                if (isExists(tempbp)) {
                                    rs = "路径正确 " + getTime(tempbp) + " ";
                                    map.put(tempbp, rsbp);
                                } else {
                                    rs = "不正确";
                                }

                            } else if (line.endsWith("xml")) {//配置文件


//				    				  tempbp = baseFloderNoproject+line;	
//				    				  line = line.replaceAll("/", "\\\\");
//				    				  if(line.startsWith("\\")){
//				    					  line =line.substring(1);
//				    				  }
//			    					  String rsbp = resultFloder+line;
//			    					  if(isExists(tempbp)){
//			        					  rs="路径正确 "+getTime(tempbp)+" ";
//			        					  map.put(tempbp, rsbp);
//			        				  }else{
//			        					  rs="不正确";
//			        				  }


//				    				  if(line.indexOf("\\")<0){
//				    					  tempbp = baseFloder+webRoot+"\\WEB-INF\\classes\\"+line;	 
//				    					  String rsbp = resultFloder+webRoot+"\\WEB-INF\\classes\\"+line;
//				    					  if(isExists(tempbp)){
//				        					  rs="路径正确 "+getTime(tempbp)+" ";
//				        					  map.put(tempbp, rsbp);
//				        				  }else{
//				        					  rs="不正确";
//				        				  }
//				    				  }else{
//				    					  line = line.replaceAll("/", "\\\\");
//					    				  if(line.startsWith("\\")){
//					    					  line =line.substring(1);
//					    				  }
//					    				  if(!line.startsWith(webRoot)){
//					    					  line = webRoot+"\\"+line;
//					    				  }
//					    				  tempbp = baseFloder+line;
//					    				  String rsbp = resultFloder+line;
//					    				  File tf = new File(tempbp);
//					    				  if(tf.exists()&&tf.isDirectory()&&!line.endsWith("\\")){
//					    					  tempbp = tempbp+"\\";
//					    					  rsbp = rsbp+"\\";
//					    				  }
//					    				  if(isExists(tempbp)){
//					    					  rs="路径正确 "+getTime(tempbp)+" ";
//					    					  map.put(tempbp, rsbp);
//					    				  }else{
//					    					  rs="不正确";
//					    				  }
//				    				  }
                            } else if (line.endsWith("*")) {
                                line = line.substring(0, line.length() - 1);
                                line = line.replaceAll("/", "\\\\");
                                if (line.startsWith("\\")) {
                                    line = line.substring(1);
                                }
                                if (!line.startsWith(webRoot)) {
                                    line = webRoot + "\\" + line;
                                }
                                if (!line.endsWith("\\")) {
                                    line = line + "\\";
                                }

                                tempbp = baseFloder + line;
                                String rsbp = resultFloder + line;
                                if (isExists(tempbp)) {
                                    rs = "路径正确******（注意，目录下全部被拷贝）" + getTime(tempbp) + " ";
                                    map.put(tempbp, rsbp);
                                } else {
                                    rs = "不正确";
                                }

                                //取该目录下的文件,注意，仅取其下一级文件，（目录不取）
                                File tf = new File(tempbp);
                                if (tf.exists() && tf.isDirectory()) {
                                    getFilsByFloler(tempbp, rsbp, map);
//				    					  File[] fs = tf.listFiles();
//				    					  if(fs!=null&&fs.length>0){
//				    						for (int i = 0; i < fs.length; i++) {
//				    							if(fs[i].isFile()){
//				    								map.put(tempbp+fs[i].getName(), rsbp+fs[i].getName());
//				    							}
//											}
//				    					  }
                                }


                            } else {//一般文件				    				 
                                line = line.replaceAll("/", "\\\\");
                                if (line.startsWith("\\")) {
                                    line = line.substring(1);
                                }
                                if (!line.startsWith(webRoot)) {
                                    line = webRoot + "\\" + line;
                                }
                                tempbp = baseFloder + line;
                                String rsbp = resultFloder + line;
                                File tf = new File(tempbp);
                                if (tf.exists() && tf.isDirectory() && !line.endsWith("\\")) {
                                    tempbp = tempbp + "\\";
                                    rsbp = rsbp + "\\";
                                }
                                if (isExists(tempbp)) {
                                    rs = "路径正确 " + getTime(tempbp) + " ";
                                    map.put(tempbp, rsbp);
                                } else {
                                    rs = "不正确";
                                }
                            }
                            String temlog = rs + " : " + ("".equals(tempbp) ? line : tempbp);
                            loglist.add(temlog);
                            System.out.println(temlog);
                        }
                    }
                }
                reader.close();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return map;
    }

    private static void copyFiles(Map map, List loglist) {
        System.out.println("================================ ");
        System.out.println("开始拷贝 ");
        System.out.println("================================ ");
        loglist.add("================================ ");
        loglist.add("开始拷贝 ");
        loglist.add("================================ ");
        if (!map.isEmpty()) {
            Iterator it = map.keySet().iterator();
            while (it.hasNext()) {
                String logstr = "";
                String oldp = (String) it.next();
                String newp = (String) map.get(oldp);
                newp = newp.replaceAll("/", "\\\\");
                if (isExists(newp) && !new File(newp).isDirectory()) {//已经存在，且不是文件夹
                    logstr = "错误:已经存在文件 " + newp;
                    System.out.println(logstr);
                } else {
                    String path = newp;
                    path = newp.substring(0, path.lastIndexOf("\\"));
                    File newpath = new File(path);
                    if (!newpath.exists()) {
                        newpath.mkdirs();
                    }

                    copy(oldp, newp);
                    if (isExists(newp)) {
                        logstr = "正确:拷贝成功:" + newp;
                        System.out.println(logstr);
                    } else {
                        logstr = "错误:拷贝失败:" + newp;
                        System.out.println(logstr);
                    }
                }
                loglist.add(logstr);
            }
        }

    }

    private static boolean isExists(String filename) {
        File file = new File(filename);
        if (file.exists()) {
            return true;
        }
        return false;
    }

    private static String getTime(String filename) {
        File file = new File(filename);
        Long time = file.lastModified();
        Calendar cd = Calendar.getInstance();
        cd.setTimeInMillis(time);
        return cd.getTime().toLocaleString();
    }


    private static boolean copy(String fileFrom, String fileTo) {
        try {
            FileInputStream in = new java.io.FileInputStream(fileFrom);
            FileOutputStream out = new FileOutputStream(fileTo);
            byte[] bt = new byte[1024];
            int count;
            while ((count = in.read(bt)) > 0) {
                out.write(bt, 0, count);
            }
            in.close();
            out.close();
            return true;
        } catch (IOException ex) {
            return false;
        }
    }

    public static boolean writeFile(String filepath, String content, String code) {
        try {
            File file = new File(filepath);
            if (!file.exists()) {
                file.createNewFile();
            }
            OutputStream outputStream = new FileOutputStream(file);
            Writer out = new OutputStreamWriter(outputStream, code);
            out.write(content);
            out.flush();
            out.close();
            return true;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除空目录
     *
     * @param dir 将要删除的目录路径
     */
    private static void doDeleteEmptyDir(String dir) {
        boolean success = (new File(dir)).delete();
        if (success) {
            System.out.println("Successfully deleted empty directory: " + dir);
        } else {
            System.out.println("Failed to delete empty directory: " + dir);
        }
    }

    /**
     * 递归删除目录下的所有文件及子目录下所有文件
     *
     * @param dir 将要删除的文件目录
     * @return boolean Returns "true" if all deletions were successful.
     * If a deletion fails, the method stops attempting to
     * delete and returns "false".
     */
    private static boolean deleteDir(File dir) {
        if (dir.isDirectory()) {
            String[] children = dir.list();
            //递归删除目录中的子目录下
            for (int i = 0; i < children.length; i++) {
                boolean success = deleteDir(new File(dir, children[i]));
                if (!success) {
                    return false;
                }
            }
        }
        // 目录此时为空，可以删除
        return dir.delete();
    }
}
小小花__
关注
专栏目录
GameFramework框架详解之 资源打包和热更新流程
TxNet
04-02 2036
GameFramework 是一个非常出色开源游戏框架，框架中自带了资源，UI，对象池，状态机等等很多模块，可以让我们更加高效和方便的开发游戏。当然毋庸置疑，它也支持热更新。今天我们就来详解一下GameFramework如何实现热更新。
最简单打增量包的方法（已附上打包的java类）
热门推荐
weixin_41961162的博客
12-13 1万+
前言： 打增量包的目的是快捷打包出项目两次更新版本之间的差异文件（除了打包出新增文件，还能打包出原有已经被改变的文件）。 问题1： 打包出这些增量文件有什么作用？ 答：快速部署这些增量文件到tomcat的webapps文件夹对应的项目中。进行增量部署。 问题2： 打包的工具是什么？ 答：用svn插件，百度一下MyEclipse如果安装SVN插件。自己装好继续下一步。 流程如下： 1、前提存在一个项...
Java类库代码动态打补丁工具JavaAsist.rar
07-04
java类库代码动态打补丁，可以在没有源代码的基础机型源代码级修改，文件类：URLClassPath.class，Translator.class，SerialVersionUID.class，NotFoundException.class，LoaderClassPath.class，DirClassPath.class，CodeConverter.class..............
GUI实现 javaWeb增量包 自动打包成class包 的可视化小工具
aolv3500的博客
01-16 118
源码 （包含直接运行的exe文件） 支持编译*$.class 的自动拷贝 使用： 转载于:https://www.cnblogs.com/nhz-M/p/10275061.html
class文件工具 抓包 打包压缩工具
qq_23013625的博客
01-06 267

把.class用jar工具打包成可执行程序
pigDeity的专栏
03-31 691
    1.新建一个 main.txt 文件    2.在main.txt文件中写入:Main-Class:(空格)mainclass(即你想打包的主类名)(换行符)    3.保存文件(和.class同目录)    注意:        1 "(空格)"表示要在此处加空格符        2 "(换行符)"表示要在此处加换行符        3 mainclass只是类名 没有.class扩
java增量补丁_eclipse实现JavaWeb项目 增量打包
weixin_36218209的博客
02-24 313
packageverysoft.freepath;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.BufferedReader;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOut...
java swing补丁工具,打包class文件，jsp，html，js,css,xml,jar等文件,同时也支持其他格式的文件打包
04-03
分享自己做的的打包工具，希望能帮助到平时为一堆补丁文件class(自动包含class内部类)，jsp，html，js,css,xml,jar等文件花费很长时间整理的朋友，有了我这个工具，似乎这一切都变得简单，你只需要选择路径，然后在...
Intellij Idea 一键打补丁插件
08-08
IntelliJ IDEA是一款广受欢迎的Java集成开发环境（IDE），...out目录则是IDE编译生成的输出目录，包含了编译后的类文件和打包的资源。在使用插件前，确保这些文件都在正确的位置，并且配置正确，才能保证插件正常工作。
java项目开发如何自制java打补丁工具
Arlbenstock的博客
05-04 6751
目的：随着java项目开发的繁重，随之手动打补丁也是个头疼的事情。如刚修改的几个jsp页面，几个java类啊。我们是人不是机器人，不可能自己一个一个的去创建文件夹然后把修改好的文件放进去，虽然这样做也可以，但是相对浪费时间，而且准确率也不是很高，到时候自己找问题还发现是自己的补丁打错了，漏了一个文件夹之类的。虽然现在网上有补丁工具，但是我要讲的是可以自定义的打补丁工具。用到的基本是java中io流
打jar包工具(classes打包工具)
06-25
打jar包工具，可以加进右键中去11111111111111111111111111111111111111111111111111111111111111111111111111
java class文件或jar文件反编译工具.rar
08-10
Java class文件或jar文件反编译工具 运行jd-gui.exe，在打开的软件中选择file，打开jar文件或class文件即可反编译
java web项目自动打补丁包 web工程项目 自动化 补丁包
08-01
1、通过bat实现，更新部署（maven方式），之后svn -log 记录更新日志，之后python根据更新日志，替换相应的文件；
把.class用jar工具打包成可执行程序.doc
06-20
把.class用jar工具打包成可执行程序。
BCFormats.bcpkg高版本class对比工具包
10-28
BCompare4的class反编译对比工具包，官网下载的不支持高版本jdk编译后的class，因此手动升级过，支持高版本class反编译对比
SVN代码增量打包工具
听雨咚咚的博客
05-22 1035
获取SVN提交版本记录 打开SVN历史提交记录,选择需要增量的修订，右键点击“Generate ChangeLog”,粘贴处其中的全部内容 修改打包方法中的路径 修改工具方法中modelFile的txt文件路径及名称，内容为粘贴的修订记录；woekPath为项目编译后的代码位置；packPath为生成增量包位置；rep数组为替换的SVN修订记录标签（有需要可以增加） ...
如何打WEB项目的升级补丁包
kfy31kfy
01-11 405
如何打WEB项目的升级补丁包 2011年03月01日 　　 以前没有打过项目包，更没有打过升级的补丁包，今天属于赶鸭子上架，摸索着搞了出来。有一个现成的WEB项目跑在服务器上面，根据需要进行bug的修改和功能的提升； 　　项目路径：/opt/ns/stat/web/ROOT/jsp 　　/opt/ns/stat/web/ROOT/bin 　　/opt/ns/stat...
替换class文件打补丁时值得注意的一个问题
szmq2的专栏
02-23 1909
有过一些正式线上运维操作的coding应该会知道这样一个“小窍门”: 在我们代码中出现有些小调整而又需要马上更新线上服务器时，我们可能会把修改好的java文件对应的class文件复制出来，替换掉线上服务器下的class文件，再把服务器重器一下，问题立马解决！
WEB实现在线版本升级工具的一些想法[WEB OTA]
weixin_30469895的博客
08-01 825
由于tomcat环境支持的的web端需要远程部署，每次维护和升级都要一对一操作，效率低下，耗费人力成本，且容易造成版本混乱，增加维护难度。为了解决上述问题，实现WEB的OTA方案，拟设计一个“web在线升级工具”： 1、工具涉及停止和启用windows的tomcat6服务，windows覆盖文件操作，拟使用delphi语言实现；2、项目目录中增加version.inf版本文件，存放当前web项目...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值