精华内容
下载资源
问答
  • 主要介绍了Java实现从jar包中读取指定文件的方法,涉及java针对jar文件的读取及查找相关操作技巧,需要的朋友可以参考
  • javaJAR包里的配置文件javaJAR包里的配置文件
  • 在编程的某些情况,我们需要读取jar包中的文件,这种情况要区别于我们平时使用类加载器读取配置文件,这个时候配置在jar包中,就能读取到,但是配置文件也可以不在jar包中,只要放在Class-Path就行了,所以这种...

    概述

    在编程的某些情况下,我们需要读取jar包中的文件,这种情况要区别于我们平时使用类加载器读取配置文件,这个时候配置在jar包中,就能读取到,但是配置文件也可以不在jar包中,只要放在Class-Path下就行了,所以这种情况下,我更愿意把它称之为:读取Class-Path下的配置文件。而我今天描述的比较明确,就是要读取jar包中的文件。这种需求可能不多,但是我碰见了,并且发现了几种,今天全部罗列分享一下。
    目前有3种:

    1. JarFile
    2. URL
    3. ClassLoader

    定义接口

    因为有好几种方式,那就直接定义个接口:

    public interface JarReader {
       /**
         * 读取jar包中的文件
         * @param jarPath   jar包路径
         * @param file  jar包中的文件路径
         * @return  文件内容,转换成字符串了,其它需求也可以转换成输入流。
         * @throws IOException
         */
        String readFromJar(String jarPath,String file) throws IOException;
    }
    

    jar包读取器,jar包中的文件读取出来。

    通过JarFile读取

    JarFile是java自带的一种读取jar包的API,很多人应该用过,我就直接贴代码了。

    public class JarFileJarReader implements JarReader {
    
        @Override
        public String readFromJar(String jarPath,String file) throws IOException {
            JarFile jarFile=null;
            try {
                jarFile=new JarFile(jarPath);
                JarEntry jarEntry=jarFile.getJarEntry(file);
                InputStream input=jarFile.getInputStream(jarEntry);
                return IOUtils.toString(input,"UTF-8");
            } catch (IOException e) {
                throw e;
            } finally {
                IOUtils.closeQuietly(jarFile);
            }
        }
    }
    

    代码也比较简单,重点就是最后一定要把jarFile这个对象关闭一下,中间的输入流都可以不用关闭。

    不过我在写这段代码之前,从我的个人经验上来说,JarFile好像更多是用来读取清单文件(MANIFEST.MF)的,可能是见这种情况比较多,当然它的用途肯定远不止如此。
    因此我顺便写了一下读取清单文件的代码:

    public void getManiFest(String jarPath) throws IOException {
            JarFile jarFile=null;
            try {
                jarFile=new JarFile(jarPath);
                Manifest manifest=jarFile.getManifest();
                if (manifest!=null){
                    //获取Class-Path
                    String classPaths = (String) manifest.getMainAttributes().get(new Attributes.Name("Class-Path"));
                    if (classPaths != null && !classPaths.isEmpty()) {
                        String[] classPathArray = classPaths.split(" ");
    
                    }
                    //获取JDK版本
                    String jdkVersion = (String) manifest.getMainAttributes().get(new Attributes.Name("Build-Jdk"));
    
                    //还可以获取其它内容,比如Main-Class等等
                }
    
            } catch (IOException e) {
                throw e;
            } finally {
                IOUtils.closeQuietly(jarFile);
            }
        }
    

    通过URL读取

    java自带的URL是支持读取jar中的文件的,协议是jar,表示方式的话是用"/!"把jar包和文件区分一下。代码如下:

    public class URLJarReader implements JarReader {
        @Override
        public String readFromJar(String jarPath, String file) throws IOException {
            JarURLConnection jarURLConnection=null;
            try {
                URL fileUrl=ParseUtil.fileToEncodedURL(new File(jarPath));
                URL jarUrl=new URL("jar", "", -1, fileUrl + "!/");
                URL moduleUrl = new URL(jarUrl, ParseUtil.encodePath(file, false));
                jarURLConnection = (JarURLConnection)moduleUrl.openConnection();
                return IOUtils.toString(jarURLConnection.getInputStream(),"UTF-8");
            } catch (IOException e) {
                throw e;
            } finally {
                if (jarURLConnection!=null){
                    try {
                        jarURLConnection.getJarFile().close();
                    } catch (IOException ignore) {
                    }
                }
            }
        }
    }
    

    ParseUtil的几个方法是我在看java源码的时候看见的,用来处理一些不规则的文件路径。
    我刚开始用URL的时候,就出现了一个内存泄漏的文件,读取完了以后,jar包被占用,死活不能删除,刚才开始把输入流给关闭了,也没有用。然后想到了类加载器里面有close方法,然后去看了一下,找到了上述代码中的finally块的代码。这样就可以把占用问题解决了,仔细看的话,会发现,getJarFile.close(),因此本质上还是关闭了JarFile,和上面是一样的。

    通过ClassLoader

    这个也是借鉴了我们平时读取配置文件的方式,借用一下ClassLoader来读取。

    public class ClassLoaderJarReader implements JarReader {
        @Override
        public String readFromJar(String jarPath, String file) throws IOException{
            URLClassLoader urlClassLoader=null;
            try {
                URL fileUrl=ParseUtil.fileToEncodedURL(new File(jarPath));
                urlClassLoader=new URLClassLoader(new URL[]{fileUrl},null);
                InputStream inputStream=urlClassLoader.getResourceAsStream(file);
                if (inputStream==null){
                    throw new FileNotFoundException("not find file:"+file+" in jar:"+jarPath);
                }else{
                    return IOUtils.toString(inputStream,"UTF-8");
                }
            } catch (IOException e) {
                throw e;
            } finally {
                IOUtils.closeQuietly(urlClassLoader);
            }
        }
    }
    

    代码也是比较简单,最后把ClassLoader关闭一下就行了。
    关于类加载器的读取方式,我很早之前就看过了,它本质上用的就是上面两种方式结合起来读取文件的。

    总结

    这几种方式的话,其实没有什么区别,从开发角度来说的话,比较推荐第三种,因为是java自带的功能,也是比较完善,也简单,也不容易出错,而且它内部用的就是前面两种。不过从资源消耗上面来说,我猜测,前面两种应该占优,不过我也不纠结这个,没去研究。

    有时候我们或许有另外一种需求,读取jar中的jar中的文件,这个在一些场景下,会使用到。最起码spring-boot确实是用到了,很早之前我看过它的实现,它就是把URL重写了一下,支持了一下多个"/!"表达式,就能够支持这种情况了。

    展开全文
  • java读取jar包中配置文件

    千次阅读 2019-09-18 02:14:14
    当把项目打成jar包发布后jar中的方法就不能通过File file=new File("文件路径")的方式来读取文件了,需要用如下方法: public static String getJarFile()throws IOException { InputStream in=T...

    当把项目打成jar包发布后jar中的方法就不能通过File file=new File("文件路径")的方式来读取文件了,需要用如下方法:

     

    public static String getJarFile()throws IOException {
    		InputStream in=Test.class.getClass().getResourceAsStream("/idcheck-file.properties");//读jar包根目录下的idcheck-file.properties文件
    		Reader f = new InputStreamReader(in);		
    		BufferedReader fb = new BufferedReader(f);
    		StringBuffer sb = new StringBuffer("");
    		String s = "";
    		while((s = fb.readLine()) != null) {
    			sb = sb.append(s);
    		}
    		return sb.toString();
    	}

     该方法同样适用于项目中读取文件

    转载于:https://my.oschina.net/u/2613449/blog/603197

    展开全文
  • private static Properties getProps(String fileName){ Properties properties = new Properties();... //读取当前 jar 包存放的路径 String path = System.getProperty("user.dir"); // System...

    说明:将java的部分配置文件写在外部,可动态进行修改此类配置文件,以适用不同的环境运行。

    private static Properties getProps(String fileName){
    
            Properties properties = new Properties();
            //读取当前 jar 包存放的路径
            String path = System.getProperty("user.dir");
    //        System.out.println(path);
            //判断文件是否存在
            InputStream input = null;
            try {
            	//读取当前文件夹下config文件目录下的配置文件
                input = new FileInputStream(new File(path+File.separator+"config"+File.separator+fileName));
            } catch (FileNotFoundException e) {
                System.out.println("jdbc.properties not find. " + e);
            }
            if (input != null) {
                try {
                    properties.load(input);
                } catch (IOException e) {
                    System.out.println("fail to load the jdbc.properties," + e);
                }
            }
            return properties;
        }
    
    展开全文
  • Java 路径解析 | Jar包中读取配置文件

    千次阅读 2020-01-13 14:39:05
    Java 路径获取 | 文件读取 读取Jar包中的文件 获取Jar包所在路径 获取项目的路径 访问Jar包内的文件

    各种路径获取方式

    项目名:JavaPath
    包名:com.theliang
    说明:包下有一个 Main类,项目下有一个hello.text的文本文件

    在这里插入图片描述

    
    package com.theliang;
    
    import java.io.File;
    import java.io.InputStream;
    import java.net.URL;
    
    public class Main {
    
        public static void main(String[] args) throws Exception {
            //* 1. 获取项目的路径(非Jar包)
            String path1 = System.getProperty("user.dir");
            System.out.println("1.获取项目的路径 = " + path1);
            //* 1. 获取项目的主路径(包级以上级别)(非Jar包)
            String path1_1 = Main.class.getClassLoader().getResource(".").getFile();
            System.out.println("1.获取项目的路径 = " + path1_1);
            //* 2. 获取项目中当前类的路径(非Jar包)
            String path2 = Main.class.getResource("Main.class").getPath();
            System.out.println("2.获取项目中当前类的路径 = " + path2);
            //* 3. 获取Jar包所在路径
            String path3 = System.getProperty("user.dir");
            System.out.println("3.获取Jar包所在路径 = " + path3);
            //* 4. 获取Jar包路径
            String path4 = Main.class.getProtectionDomain().getCodeSource().getLocation().getFile();
            String path4_1 = Main.class.getProtectionDomain().getCodeSource().getLocation().getPath();//两个是相同的
            System.out.println("4.获取Jar包路径 = " + path4);
            System.out.println("4.获取Jar包路径 = " + path4_1);
            //* 5. 获取Jar包中指定资源的路径
            String path5 = Main.class.getClassLoader().getResource("hello.text").getPath();
            String path5_1 = Main.class.getClassLoader().getResource("hello.text").getFile();
            System.out.println("5.获取Jar包中指定资源的路径 = " + path5);
            System.out.println("5.获取Jar包中指定资源的路径 = " + path5_1);
            //* 6. 读取项目下的文件(非Jar包)
            URL url = Main.class.getClassLoader().getResource("hello.text");
            System.out.println("6.读取项目下的文件 = " + url.getPath());
            InputStream is = url.openStream();
    //        is = Main.class.getClassLoader().getResourceAsStream("hello.text");//也可以写成这样
            byte[] bytes = new byte[1024];
            while (is.read(bytes) != -1) {
                System.out.println(new String(bytes, "UTF-8"));
            }
    
            //* 7. 读取Jar包中的文件
            URL url2 = Main.class.getClassLoader().getResource("hello.text");
            System.out.println("7.读取Jar包中的文件 = " + url2.getPath());
            InputStream is2 = url2.openStream();
            byte[] bytes2 = new byte[1024];
            while (is2.read(bytes2) != -1) {
                System.out.println(new String(bytes2, "UTF-8"));
            }
    
            //* 8. 访问Jar包内的文件
            String jarPath = "D:/Project/JavaPath/out/artifacts/JavaPath_jar/JavaPath.jar";
            URL url3 = new URL("jar:file:/" + jarPath + "!/hello.text");
            System.out.println("8.访问Jar包内的文件 = " + url3.getPath());
            InputStream is3 = url3.openStream();
            byte[] bytes3 = new byte[1024];
            while (is3.read(bytes3) != -1) {
                System.out.println(new String(bytes3, "UTF-8"));
            }
    
            //* 9. 乱码问题
            //如果路径包含Unicode字符,还需要将路径转码
            path1 = java.net.URLDecoder.decode(path1, "UTF-8");
        }
    }
    
    

    项目中输出的结果

    1.获取项目的路径 = D:\Project\JavaPath
    2.获取项目中当前类的路径 = /D:/Project/JavaPath/out/production/JavaPath/com/theliang/Main.class
    3.获取Jar包所在路径 = D:\Project\JavaPath
    4.获取Jar包路径 = /D:/Project/JavaPath/out/production/JavaPath/
    4.获取Jar包路径 = /D:/Project/JavaPath/out/production/JavaPath/
    5.获取Jar包中指定资源的路径 = /D:/Project/JavaPath/out/production/JavaPath/hello.text
    5.获取Jar包中指定资源的路径 = /D:/Project/JavaPath/out/production/JavaPath/hello.text
    6.读取项目下的文件 = /D:/Project/JavaPath/out/production/JavaPath/hello.text
    Hello Test
    测试文件
    7.读取Jar包中的文件 = /D:/Project/JavaPath/out/production/JavaPath/hello.text
    Hello Test
    测试文件
    8.访问Jar包内的文件 = file:/D:/Project/JavaPath/out/artifacts/JavaPath_jar/JavaPath.jar!/hello.text
    Hello Test
    测试文件
    
    

    Jar包中输出的结果

    1.获取项目的路径 = D:\Project\JavaPath\out\artifacts\JavaPath_jar
    2.获取项目中当前类的路径 = file:/D:/Project/JavaPath/out/artifacts/JavaPath_jar/JavaPath.jar!/com/theliang/Main.class
    3.获取Jar包所在路径 = D:\Project\JavaPath\out\artifacts\JavaPath_jar
    4.获取Jar包路径 = /D:/Project/JavaPath/out/artifacts/JavaPath_jar/JavaPath.jar
    4.获取Jar包路径 = /D:/Project/JavaPath/out/artifacts/JavaPath_jar/JavaPath.jar
    5.获取Jar包中指定资源的路径 = file:/D:/Project/JavaPath/out/artifacts/JavaPath_jar/JavaPath.jar!/hello.text
    5.获取Jar包中指定资源的路径 = file:/D:/Project/JavaPath/out/artifacts/JavaPath_jar/JavaPath.jar!/hello.text
    6.读取项目下的文件 = file:/D:/Project/JavaPath/out/artifacts/JavaPath_jar/JavaPath.jar!/hello.text
    Hello Test
    测试文件
    7.读取Jar包中的文件 = file:/D:/Project/JavaPath/out/artifacts/JavaPath_jar/JavaPath.jar!/hello.text
    Hello Test
    测试文件
    8.访问Jar包内的文件 = file:/D:/Project/JavaPath/out/artifacts/JavaPath_jar/JavaPath.jar!/hello.text
    Hello Test
    测试文件
    

    差异图:

    在这里插入图片描述

    读取Jar包中的配置文件

    Jar包中配置文件的路径格式是:jar:file/地址/Jar包.jar!/配置文件名

    判断 是class文件执行还是jar文件执行

    public class Main {
        public static void main(String[] args) {
            System.out.println(Main.class.getResource("Main.class").toString());
        }
    }
    

    在Class中会输出:

    file:/D:/Project/JavaPath/out/production/JavaPath/com/theliang/Main.class
    

    在Jar包中会输出:

    jar:file:/D:/Project/JavaPath/out/production/JavaPath/com/theliang/JavaPath.jar!/com/theliang/Main.class
    

    所以我们可以通过前缀判断执行环境

    String filePath = Main.class.getResource("Main.class").toString();
    // true: jar文件启动
    // false: class文件启动
    boolean road = filePath.startsWith("jar:file");
    
    展开全文
  • Java读取外部(第三方)jar配置文件

    千次阅读 2019-12-19 11:20:35
    spring-boot 、 spring 项目同样适用,最主要路径写法是,classpath:/jdbc.properties ,不能用classpath*:/jdbc.properties,外部jar配置文件在classpath路径,具体代码如下 Resource re...
  • java读取jar配置文件

    千次阅读 2015-04-20 23:32:52
    前置条件:使用java -jar XXX.jar运行java程序,其中有部分代码是需要读取jar中的配置文件 问题描述: 发现无法读取到该配置文件 解决思路: 1. 该配置文件没有打到jar包中 2. 该配置文件损坏无法读取 3. ...
  • NULL 博文链接:https://konghaibo.iteye.com/blog/430146
  • import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.Fi...
  • 一般在服务器上部署项目时是一个jar包 旁边放置一个配置文件的文件夹conf,如图所示 , 在IDEA中结构如上所示     那么怎么做到在IDEA中写的代码能加载配置文件,同时放到服务器上不用修改代码呢? 下面...
  • 1.通常导入项目内的配置文件(.properties文件)是如下代码: Properties properties = new Properties(); // 使用ClassLoader加载properties配置文件生成对应的输入流 InputStream in = Propertiesxxx.class....
  • 项目需要,我在使用kerberos认证时,要在jaas.conf配置文件中指定 keytab文件的路径。使用的相对路径,本地运行没问题,打包丢到服务器上该路劲失效,求大神解答。 ![项目路径]...
  • nohup java -jar authentication-1.0.0-SNAPSHOT.jar --spring.cloud.bootstrap.location=/opt/service/...代码内获取外部化配置文件路径: @Value("${spring.cloud.bootstrap.location}") private String path;
  • 读取配置文件所用jar包,本人亲测,可用。 使用PropertiesConfiguration读取配置文件
  • java实现:对jar包中的配置文件修改

    千次阅读 2018-11-20 09:03:54
    注:只修改文件,其他会被清空  package com.mtpc.admin.util; import java.io.*; import java.util.*; import java.util.jar.JarEntry; import java.util.jar.JarFile; import java.util.jar.JarOutputStream; ...
  • 1、获取工程目录下面的配置文件:String workspaceDir = RuleFileUtils.class....2、获取引用jar包中的配置文件:String projectDir = RuleFileUtils.class.getClassLoader().getResource("").getFile();...
  • java代码实现修改jar包中的配置文件

    千次阅读 2019-04-29 17:17:01
    提供SDK给业务系统,需要给各个不同的业务系统设置不同的配置 PS:借鉴https://blog.csdn.net/qq_40375627/article/details/80301743 实现代码 包含 JarTool类与StringReplace方法接口 @FunctionalInterface ...
  • java jar 配置文件的相对路径问题

    万次阅读 2016-05-05 14:34:50
    命令行运行jar包,如何使用与jar包在同一个目录的配置文件。 其实就是当前的工作目录问题。 在eclipse中:String resource = "conf.xml";//此时文件是在src目录 在conf.xml文件中 引用的文件也是在src目录。...
  • Eclipse打包成JAR包读取外部JAR包和外部配置文件 Eclipse 打包 jar 外部JAR 外部配置文件
  •  没打jar包之前,是通过 String rootPath = Thread....获得当前路径然后再加上配置文件所在的目录获得绝对路径的方式,找到config.properties文件。 可是打了jar包以后马上就出错了,找不到文件!不管是用绝
  • Java mven项目打包成jar运行propperties 文件报空指针 InputStream in = ReadData.class.getClassLoader().getResourceAsStream("path.properties");
  • javajar包中读取资源文件

    万次阅读 多人点赞 2019-03-25 22:04:31
    一个JAVA项目需要在应用启动时读取一个文件,在这遇到了一个坑,就是在Idea 中,应用启动时可以正常读取这个文件,但应用打成jar包后直接运行就读取不到。 要读取的文件位于/src/main/resources目录,其相对路径为...
  • 参考 类加载器与 Class.getResourceAsStream 问题解决 ... Java项目导出可运行的jar文件 http://blog.csdn.net/mahoking/article/details/42871937 中间试了很多方法,最终一
  • java读取配置文件以及运行jar的方式

    千次阅读 2018-07-16 23:00:19
    java读取配置文件 package com.hikvision.readproperties; import java.io.FileInputStream; import java.io.IOException; import java.util.Enumeration; import java.util.Properties; public class ...
  • java获取配置文件信息

    2019-11-06 18:39:27
    本地项目和打包成jar获取配置文件信息方法背景本地和打包成jar通用获取配置文件信息 背景 我在本地项目获取app.properties配置文件信息时,没有报错,在打包成jar包之后,日志显示获取不到配置文件路径。 本地和...
  • Eclipse 打包 JAR包 外部配置文件
  • java编程,对json文件进行读写操作,需要引用的jar包。
  • 在项目中有时候要把一些代码打包成jar,只要运行jar就可以执行。...EditConfiguration 弹出的窗口中选择配置文件所在的路径即可。 2、Eclipse 配置arguments 在main函数,右击,在弹出的菜单中选择EditCo...
  • 这时候,如果jar包中需要读取配置文件信息,则很少把该配置打进jar包,因为它不方便修改,更多都是采用jar包读取外部配置文件。 案例: 项目工程名:auth -- 很明显,做鉴权使用的 项目配置文件:init.properties...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 269,290
精华内容 107,716
关键字:

java获取jar下的配置文件

java 订阅