java 解析hiveserver2日志 解析HiveSQL 获取表的使用次数 热度

最新推荐文章于 2024-07-26 15:16:16 发布
最新推荐文章于 2024-07-26 15:16:16 发布
阅读量6.2k 收藏 5
点赞数 2
分类专栏： 大数据 文章标签： java hive
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38151907/article/details/125925710
版权

java 解析hiveserver2日志 解析HiveSQL 获取表的使用次数 热度

首先逐行读取hiveserver2日志
日志里每个sql之前都会包含Executing command关键字
故先匹配关键字

if (str.contains("Executing command"))

每行的打头都是固定的头部，使用正则表达式进行切割

String sqlRegex = ".*Executing command\\(queryId=[\\w-]*\\):";
String sql = str.replaceAll(sqlRegex, " ").trim();

下面是解析日志的工具类，首先导入依赖

<properties>
        <hive.version>1.1.0</hive.version>
        <hadoop.version>2.6.0</hadoop.version>
        <poi.version>4.1.2</poi.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>${poi.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>${poi.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml-schemas</artifactId>
            <version>${poi.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-scratchpad</artifactId>
            <version>${poi.version}</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>${hive.version}</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>${hadoop.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-mapreduce-client-core</artifactId>
            <version>${hadoop.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>

        <dependency>
            <groupId>commons-httpclient</groupId>
            <artifactId>commons-httpclient</artifactId>
            <version>3.1</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.36</version>
        </dependency>

    </dependencies>

一些类似mysql的依赖可以按需去掉，一些依赖因为后面的博客要用，我这边就一起写在这
下面是Hive日志解析工具类的代码

import org.apache.hadoop.hive.ql.parse.*;

import java.util.*;

/**
 * 目的：获取AST中的表，列，以及对其所做的操作，如SELECT,INSERT
 * 重点：获取SELECT操作中的表和列的相关操作。其他操作这判断到表级别。
 * 实现思路：对AST深度优先遍历，遇到操作的token则判断当前的操作，
 *                     遇到TOK_TAB或TOK_TABREF则判断出当前操作的表，遇到子句则压栈当前处理，处理子句。
 *                    子句处理完，栈弹出。
 *
 */
public class HiveParseUtils {

    private static final String UNKNOWN = "UNKNOWN";
    private static Map<String, String> alias = new HashMap<>();
    private static Map<String, String> cols = new TreeMap<>();
    private static Map<String, String> colAlais = new TreeMap<>();
    public static List<String> tables = new ArrayList<>();
    private static Stack<String> tableNameStack = new Stack<>();
    private static Stack<Oper> operStack = new Stack<>();
    private static String nowQueryTable = "";//定义及处理不清晰，修改为query或from节点对应的table集合或许好点。目前正在查询处理的表可能不止一个。
    private static Oper oper ;
    private static boolean joinClause = false;

    private enum Oper {
        SELECT, INSERT, DROP, TRUNCATE, LOAD, CREATETABLE, ALTER
    }
    public static Set<String> parseIteral(ASTNode ast) {
        Set<String> set= new HashSet<>();//当前查询所对应到的表集合
        prepareToParseCurrentNodeAndChilds(ast);
        set.addAll(parseChildNodes(ast));
        set.addAll(parseCurrentNode(ast ,set));
        endParseCurrentNode(ast);
        return set;
    }
    private static void endParseCurrentNode(ASTNode ast){
        if (ast.getToken() != null) {
            switch (ast.getToken().getType()) {//join 从句结束，跳出join
                case HiveParser.TOK_RIGHTOUTERJOIN:
                case HiveParser.TOK_LEFTOUTERJOIN:
                case HiveParser.TOK_JOIN:
                    joinClause = false;
                    break;
                case HiveParser.TOK_QUERY:
                    break;
                case HiveParser.TOK_INSERT:
                case HiveParser.TOK_SELECT:
                    nowQueryTable = tableNameStack.pop();
                    oper = operStack.pop();
                    break;
            }
        }
    }
    private static Set<String> parseCurrentNode(ASTNode ast, Set<String> set){
        if (ast.getToken() != null) {
            switch (ast.getToken().getType()) {
                case HiveParser.TOK_TABLE_PARTITION:
                    if (ast.getChildCount() != 2) {
                        String table = BaseSemanticAnalyzer
                                .getUnescapedName((ASTNode) ast.getChild(0));
                        if (oper == Oper.SELECT) {
                            nowQueryTable = table;
                        }
                        tables.add(table + "  " + oper);
                    }
                    break;

                case HiveParser.TOK_TAB:// outputTable
                    String tableTab = BaseSemanticAnalyzer
                            .getUnescapedName((ASTNode) ast.getChild(0));
                    if (oper == Oper.SELECT) {
                        nowQueryTable = tableTab;
                    }
                    tables.add(tableTab + "  " + oper);
                    break;
                case HiveParser.TOK_TABREF:// inputTable
                    ASTNode tabTree = (ASTNode) ast.getChild(0);
                    String tableName = (tabTree.getChildCount() == 1) ? BaseSemanticAnalyzer
                            .getUnescapedName((ASTNode) tabTree.getChild(0))
                            : BaseSemanticAnalyzer
                            .getUnescapedName((ASTNode) tabTree.getChild(0))
                            + "." + tabTree.getChild(1);
                    if (oper == Oper.SELECT) {
                        if(joinClause && !"".equals(nowQueryTable) ){
                            nowQueryTable += "&"+tableName;//
                        }else{
                            nowQueryTable = tableName;
                        }
                        set.add(tableName);
                    }
                    tables.add(tableName + "  " + oper);
                    if (ast.getChild(1) != null) {
                        String alia = ast.getChild(1).getText().toLowerCase();
                        alias.put(alia, tableName);
                    }
                    break;
                case HiveParser.TOK_TABLE_OR_COL:
                    if (ast.getParent().getType() != HiveParser.DOT) {
                        String col = ast.getChild(0).getText().toLowerCase();
                        if (alias.get(col) == null
                                && colAlais.get(nowQueryTable + "." + col) == null) {
                            if(nowQueryTable.indexOf("&") > 0){//sql23
                                cols.put(UNKNOWN + "." + col, "");
                            }else{
                                cols.put(nowQueryTable + "." + col, "");
                            }
                        }
                    }
                    break;
                case HiveParser.TOK_ALLCOLREF:
                    cols.put(nowQueryTable + ".*", "");
                    break;
                case HiveParser.TOK_SUBQUERY:
                    if (ast.getChildCount() == 2) {
                        String tableAlias = unescapeIdentifier(ast.getChild(1)
                                .getText());
                        String aliaReal = "";
                        for(String table : set){
                            aliaReal+=table+"&";
                        }
                        if(aliaReal.length() !=0){
                            aliaReal = aliaReal.substring(0, aliaReal.length()-1);
                        }
                        alias.put(tableAlias, aliaReal);
                    }
                    break;

                case HiveParser.TOK_SELEXPR:
                    if (ast.getChild(0).getType() == HiveParser.TOK_TABLE_OR_COL) {
                        String column = ast.getChild(0).getChild(0).getText()
                                .toLowerCase();
                        if(nowQueryTable.indexOf("&") > 0){
                            cols.put(UNKNOWN + "." + column, "");
                        }else if (colAlais.get(nowQueryTable + "." + column) == null) {
                            cols.put(nowQueryTable + "." + column, "");
                        }
                    } else if (ast.getChild(1) != null) {
                        String columnAlia = ast.getChild(1).getText().toLowerCase();
                        colAlais.put(nowQueryTable + "." + columnAlia, "");
                    }
                    break;
                case HiveParser.DOT:
                    if (ast.getType() == HiveParser.DOT) {
                        if (ast.getChildCount() == 2) {
                            if (ast.getChild(0).getType() == HiveParser.TOK_TABLE_OR_COL
                                    && ast.getChild(0).getChildCount() == 1
                                    && ast.getChild(1).getType() == HiveParser.Identifier) {
                                String alia = BaseSemanticAnalyzer
                                        .unescapeIdentifier(ast.getChild(0)
                                                .getChild(0).getText()
                                                .toLowerCase());
                                String column = BaseSemanticAnalyzer
                                        .unescapeIdentifier(ast.getChild(1)
                                                .getText().toLowerCase());
                                String realTable = null;
                                if (!tables.contains(alia + "" + oper)
                                        && alias.get(alia) == null) {// [b SELECT, a
                                    // SELECT]
                                    alias.put(alia, nowQueryTable);
                                }
                                if (tables.contains(alia + "" + oper)) {
                                    realTable = alia;
                                } else if (alias.get(alia) != null) {
                                    realTable = alias.get(alia);
                                }
                                if (realTable == null || realTable.length() == 0 || realTable.indexOf("&") > 0) {
                                    realTable = UNKNOWN;
                                }
                                cols.put(realTable + "." + column, "");

                            }
                        }
                    }
                    break;
                case HiveParser.TOK_ALTERTABLE_ADDPARTS:
                case HiveParser.TOK_ALTERTABLE_RENAME:
                case HiveParser.TOK_ALTERTABLE_ADDCOLS:
                    ASTNode alterTableName = (ASTNode) ast.getChild(0);
                    tables.add(alterTableName.getText() + "" + oper);
                    break;
            }
        }
        return set;
    }
    private static Set<String> parseChildNodes(ASTNode ast){
        Set<String> set= new HashSet<String>();
        int numCh = ast.getChildCount();
        if (numCh > 0) {
            for (int num = 0; num < numCh; num++) {
                ASTNode child = (ASTNode) ast.getChild(num);
                set.addAll(parseIteral(child));
            }
        }
        return set;
    }
    private static void prepareToParseCurrentNodeAndChilds(ASTNode ast){
        if (ast.getToken() != null) {
            switch (ast.getToken().getType()) {//join 从句开始
                case HiveParser.TOK_RIGHTOUTERJOIN:
                case HiveParser.TOK_LEFTOUTERJOIN:
                case HiveParser.TOK_JOIN:
                    joinClause = true;
                    break;
                case HiveParser.TOK_QUERY:
                    tableNameStack.push(nowQueryTable);
                    operStack.push(oper);
                    nowQueryTable = "";//sql22
                    oper = Oper.SELECT;
                    break;
                case HiveParser.TOK_INSERT:
                    tableNameStack.push(nowQueryTable);
                    operStack.push(oper);
                    oper = Oper.INSERT;
                    break;
                case HiveParser.TOK_SELECT:
                    tableNameStack.push(nowQueryTable);
                    operStack.push(oper);
                    oper = Oper.SELECT;
                    break;
                case HiveParser.TOK_DROPTABLE:
                    oper = Oper.DROP;
                    break;
                case HiveParser.TOK_TRUNCATETABLE:
                    oper = Oper.TRUNCATE;
                    break;
                case HiveParser.TOK_LOAD:
                    oper = Oper.LOAD;
                    break;
                case HiveParser.TOK_CREATETABLE:
                    oper = Oper.CREATETABLE;
                    break;
            }
            if (ast.getToken() != null
                    && ast.getToken().getType() >= HiveParser.TOK_ALTERDATABASE_PROPERTIES
                    && ast.getToken().getType() <= HiveParser.TOK_ALTERVIEW_RENAME) {
                oper = Oper.ALTER;
            }
        }
    }
    public static String unescapeIdentifier(String val) {
        if (val == null) {
            return null;
        }
        if (val.charAt(0) == '`' && val.charAt(val.length() - 1) == '`') {
            val = val.substring(1, val.length() - 1);
        }
        return val;
    }

    //获取字段和别名
    private static void output(Map<String, String> map) {
        Iterator<String> it = map.keySet().iterator();
        while (it.hasNext()) {
            String key = it.next();
            System.out.println(key + "" + map.get(key));
        }
    }

    public static List<String> splitSql(String sql) {
        sql = sql.replaceAll("^\\s*|\\s*$", "");
        char[] cs = sql.toCharArray();
        int quotTimes = 0;
        List<Integer> marksSplit = new ArrayList();
        for (int i = 0; i < cs.length; i++) {
            char c = cs[i];
            if (c == 39) {
                quotTimes++;
            }
            if (c == 59 && quotTimes % 2 == 0) {
                marksSplit.add(i);
            }
            if (i == cs.length - 1 && c != 59) {
                marksSplit.add(i + 1);
            }
        }
        List<String> sqls = new ArrayList<>();
        if (!marksSplit.isEmpty()) {
            for (int i = 0; i < marksSplit.size(); i++) {
                if (i == 0) {
                    sqls.add(sql.substring(0, marksSplit.get(i)));
                } else {
                    sqls.add(sql.substring(marksSplit.get(i - 1) + 1, marksSplit.get(i)));
                }
            }
        } else {
            sqls.add(sql);
        }
        return sqls;
    }

    public static Map<String, Hashtable<String, Integer>> sqlParse(String sql) throws ParseException {
        ParseDriver pd = new ParseDriver();
        List<String> sqlList = splitSql(sql);
        Map<String, Hashtable<String, Integer>> map = new HashMap<>();
        for(String s : sqlList) {
            ASTNode ast = pd.parse(s);
            parseIteral(ast);
            Hashtable<String, Integer> hashtable = new Hashtable<>();
            for (String table : tables) {
            	String[] split = table.split("  ");
            	String tableName = split[0];
            	if(hashtable.containsKey(tableName)) {
            		hashtable.put(tableName, hashtable.get(tableName)+1);
            	}else {
            		hashtable.put(tableName, 1);
            	}
            }
            map.put("tables", hashtable);
        }
        return map;
    }
    /**
     * 解析sql并选出指定类型的相关表
     * @param sql
     * @param type
     * @return
     * @throws ParseException
     */
    public static Map<String, Hashtable<String, Integer>> sqlParseAssignType(String sql,String type) throws Exception {
        ParseDriver pd = new ParseDriver();
        List<String> sqlList = splitSql(sql);
        Map<String, Hashtable<String, Integer>> map = new HashMap<>();
        for(String s : sqlList) {
        	ASTNode ast = pd.parse(s);

            parseIteral(ast);
            Hashtable<String, Integer> hashtable = new Hashtable<>();
            for (String table : tables) {
            	String[] split = table.split("  ");
            	String tableName = split[0];
            	String tableType = split[1];
            	if(tableType.equalsIgnoreCase(type)) {  //只有符合类型的才会被保存
            		if(hashtable.containsKey(tableName)) {
                		hashtable.put(tableName, hashtable.get(tableName)+1);
                	}else {
                		hashtable.put(tableName, 1);
                	}
            	}

            }
            map.put("tables", hashtable);
        }
        return map;
    }

    public static Map<String, Hashtable<String, Integer>> sqlParseAssignType(String sql) throws Exception {
        ParseDriver pd = new ParseDriver();
        List<String> sqlList = splitSql(sql);
        Map<String, Hashtable<String, Integer>> map = new HashMap<>();
        for(String s : sqlList) {
            ASTNode ast = pd.parse(s);
            parseIteral(ast);
            Hashtable<String, Integer> hashtable = new Hashtable<>();
            for (String table : tables) {
                String[] split = table.split("  ");
                String tableName = split[0];
                if(hashtable.containsKey(tableName)) {
                    hashtable.put(tableName, hashtable.get(tableName)+1);
                }else {
                    hashtable.put(tableName, 1);
                }
            }
            map.put("tables", hashtable);
        }
        return map;
    }

}

定义一个集合收集一下解析的内容

Map<String, Hashtable<String, Integer>> sqlParse=new HashMap<>();

对sql进行解析

HiveParseUtils.tables = new ArrayList<>();
sqlParse = HiveParseUtils.sqlParseAssignType(line);

获得热度

//得到内容
Map<String,Integer> result=new HashMap<>();
Hashtable<String, Integer> hashtable = sqlParse.get("tables");
//循环遍历，key为表名，value为表的使用次数
for (Iterator itr = hashtable.keySet().iterator(); itr.hasNext(); ) {
                    String key = (String) itr.next();
                    String table = key.trim().toLowerCase();
                    if (key.contains(".")) {
                    //这里这步是只获取表名，不要库名，可按需改造
                        table = key.split("\\.")[1];
                    }
                    
                    int value = hashtable.get(key);
                }

搞定！！！

MIDSUMMER_yy
关注
专栏目录
hive 日誌怎麼查看_Hive SQL运行状态监控（HiveSQLMonitor）
weixin_39623273的博客
12-22 1250
引言目前数据平台使用Hadoop构建，为了方便数据分析师的工作，使用Hive对Hadoop MapReduce任务进行封装，我们面对的不再是一个个的MR任务，而是一条条的SQL语句。数据平台内部通过类似JDBC的接口与HiveServer进行交互，仅仅能够感知到一条SQL的开始与结束，而中间的这个过程通常是漫长的(两个因素：数据量、SQL复杂度)，某些场景下用户需要了解这条SQL语句的执行进度，从...
hive sql创建表
weixin_43805387的博客
09-18 2927
hive sql语句 创建外部表 因而外部表仅仅删除元数据 create external table t2( id int ,name string ,hobby array<string> ,add map<String,string> ) row format delimited fields terminated...
hiveServer2logparser:HS2 日志的 Perl 解析器
05-30
HiveServer2日志摘要器 用法 #download latest script wget https://raw.githubusercontent.com/abajwa-hw/hiveServer2logparser/master/hiveServer2logparser.pl #run script perl hiveServer2logparser.pl <path> 输出 其中包含为便于在Excel中过滤而运行的查询摘要
HiveServer2 获取日志
遥望......
01-11 2829
讨论的版本为: HiveServer2 版本 : 2.3.1 + tez 由于最近在弄WEBIDE，其中在连接Hiveserver2的时候，在Hiveserver2的获取日志的方式，发现了两个坑，找了许多文献，也没有找到解决的办法。 其中一个坑，有一个同事在看到hive的BUG反馈中，看到一些类似情况，解决的。 而另外一个坑，是走了很多很多崎岖的路途，一步一步的发现出来的解决办法。 1.HIVESERVER 2 没有日志 在其他配置(启动日志配置,log4j,等等)都没有别的问题的时候,依..
日志审计系统_深入理解HiveServer2审计日志_0基础白帽子入门教程
最新发布
程序员六七的博客
07-26 361
HiveServer2审计日志是监控和诊断Hive Server2操作的重要工具。本文将详细解析审计日志的结构和内容，以及如何利用这些信息。
查看Hive SQL执行日志
Alex
06-21 3103
yarn logs -applicationId application_1622563480758_1071631
HiveSQL：求累计访问量
epitomizelu的专栏
12-29 1150
数据 userId visitDate visitCount u01 2017/1/21 5 u02 2017/1/23 6 u03 2017/1/22 8 u04 2017/1/20 3 u01 2017/1/23 6 u01 2017/2/21 8 U02 2017/1/23 6 U01 2017/2/22 4 需求一：逐行求相同用户的累计访问次数
dlt645-2007电能表协议解析源码+串口编程源码
05-15
本文将深入探讨该协议的解析原理以及如何通过Java进行串口编程实现与电能表的通信。 1. DLT645-2007电能表协议解析： DLT645协议是一种基于串行通信的电能表通讯协议，包含了命令帧结构、数据编码、校验方式等多个...
Java解析XML的jar包+四种解析方法
08-11
java解析xml的四种方法的比较，还有四种方法所用到的jar包 附带程序例子 1.DOM生成和解析XML文档 2.SAX生成和解析XML文档 3.DOM4J生成和解析XML文档 4.JDOM生成和解析XML
java代码导入hive_把本地的文件数据导入到Hive分区表--系列①Java代码
weixin_35048609的博客
02-27 1754
本篇博客,小菌为大家带来关于如何将本地的多个文件导入到Hive分区表中对应的分区上的方法。一共有四种方法,本篇将介绍第一种—Java代码。首先编写代码,通过MapReduce将处理好的数据写入到HDFS的目录下。下面提供一种参考!Mappublic class Mapper01 extends Mapper {/**** @param key 行首偏移量* @param value 一整行的...
使用HiveSQL实现开始到结束日期之间的所有日期
JnYoung的博客
05-13 4169
查询1： set hive.exec.mode.local.auto=true; --开启本地模式 set hive.cli.print.header=true; --打印表.列名 select tmp.*, t.*, date_add(start_date, pos) as mid_date from( select '1' as uid, '2020-01-01' as start_date, '2020-01-05' as end_date
hive sql语句查询
11-25
数据库相关操作 Hive配置单元包含一个名为 default 默认的数据库. create database [if not exists] ；---创建数据库 show databases; --显示所有数据库 drop database if exists [restrict|cascade]; --删除数据库，默认情况下，hive不允许删除含有表的数据库，要先将数据库中的表清空才能drop，否则会报错 --加入cascade关键字，可以强制删除一个数据库,默认是restrict，表示有限制的 eg. hive> drop database if exists users cascade; use ; --切换数据库
【每天一练：Hive SQL】求单月访问次数和总访问次数
debimeng
02-24 2329
HiveSQL题： 求单月访问次数和总访问次数 数据如下： A,2015-01,5 A,2015-01,15 B,2015-01,5 A,2015-01,8 B,2015-01,25 A,2015-01,5 A,2015-02,4 A,2015-02,6 B,2015-02,10 B,2015-02,5 A,2015-03,16 A,2015-03,22 B,2015-03,23 B,2015-...
java程序获取hive日志
liyonghui123的专栏
08-27 1099
         获取hive日志比较麻烦，通常的做法是执行shell命令获取日志，但是这样有一些问题，比如：输出的结果需要程序解析等，可以改进hive，采用jdbc的方式执行hive sql，并且把输出到控制台的日志保存到redis，其中kill job的命令日志用不同的key缓存到redis，如此可很方便获取查询结果、日志、kill命令。   具体实现方式如下：   修改hive-exec...
摒弃低效的sql，利用hive的统计信息，快速收集表信息
weixin_34190136的博客
11-22 836
2019独角兽企业重金招聘Python工程师标准>>> ...
hiveserver2日志配置
qq_32068809的博客
06-30 2038
刚安装的hive需要到将conf/hive-log4j2.properties.template文件更名为hive-log4j2.properties，并将其内容中的property.hive.log.dir配置项设置为正确的日志路径，这样开启hiveserver2后就会在该路径下看到启动日志
hive JDBC 进度和日志查看
weixin_34372728的博客
07-04 4238
为什么80%的码农都做不了架构师？>>> ...
Hiveserver2的使用
u013385925的专栏
07-22 1145
hive的版本是hive-2.1.1 日志放在哪？ Hive中的日志分为两种 1. 系统日志，记录了hive的运行情况，错误状况。 2. Job 日志，记录了Hive 中job的执行的历史过程。 系统日志存储在什么地方呢 ？ 在hive/conf/ hive-log4j.properties 文件中记录了Hive日志的存储情况， 默认的存储情况： hive.root.log
hive 日誌怎麼查看_Hive各个日志里都存放了什么信息？
weixin_30228803的博客
12-31 913
审计日志首先，对于审计日志来说，记录了某个时间点某个用户从哪个IP发起对HiveServer或者MetaStore的请求以及记录执行的语句是什么。如下的HiveServer审计日志，表示在2016-02-01 14:51:22 用户user_chen向HiveServer发起了show tables请求，客户端IP为192.168.1.18。如下面MetaStore审计日志，表示在2016-01-...
Java文件路径获取完全解析
"Java文件路径获取方法的总结，包括使用`getResourceAsStream()`和`getClassLoader().getResourceAsStream()`的差异以及如何正确处理路径" 在Java编程中，获取文件路径是一项常见的任务，特别是在处理资源文件或者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MIDSUMMER_yy

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

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

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

打赏作者

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

抵扣说明：

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

余额充值