JAVA读取jar包内部配置文件
Java实现从jar包中读取指定文件的方法
Java实现从jar包中读取指定⽂件的⽅法本⽂实例讲述了Java实现从jar包中读取指定⽂件的⽅法。
分享给⼤家供⼤家参考，具体如下：以下的Java代码实现了从⼀个jar包中读取指定⽂件的功能：/*** This class implements the funcationality of reading and writing files in jar files.*/package com.leo.util;import java.io.InputStream;import java.io.FileOutputStream;import java.util.jar.*;import java.util.Enumeration;/*** @author Leo Share* @since 08/09/2007* @version 1.0*/public class JarFileAccess {private static final String fileSeparator = System.getProperty("file.separator");public void accessJarFile(String jarFileName, String fromDir, String toDir) throws Exception{JarFile myJarFile = new JarFile(fromDir+fileSeparator+jarFileName);Enumeration myEnum = myJarFile.entries();while(myEnum.hasMoreElements()){JarEntry myJarEntry = (JarEntry)myEnum.nextElement();if(myJarEntry.getName().equals("jbossall-client.jar")){InputStream is = myJarFile.getInputStream(myJarEntry);FileOutputStream fos = new FileOutputStream(toDir+fileSeparator+myJarEntry.getName());byte[] b = new byte[1024];int len;while((len = is.read(b))!= -1){fos.write(b, 0, len);}fos.close();is.close();break;} else{continue;}}myJarFile.close();}}更多关于java算法相关内容感兴趣的读者可查看本站专题：《》、《》、《》和《》希望本⽂所述对⼤家java程序设计有所帮助。
解决SpringBootjar包中的文件读取问题
解决SpringBootjar包中的⽂件读取问题前⾔SpringBoot微服务已成为业界主流，从开发到部署都⾮常省时省⼒，但是最近⼩明开发时遇到⼀个问题：在代码中读取资源⽂件(⽐如word⽂档、导出模版等)，本地开发时可以正常读取，但是，当我们打成jar包发布到服务器后，再次执⾏程序时就会抛出找不到⽂件的异常。
背景这个问题是在⼀次使⽤freemarker模版引擎导出word报告时发现的。
⼤概说⼀下docx导出java实现思路：导出word的⽂档格式为docx，事先准备好⼀个排好版的docx⽂档作为模版，读取解析该模版，将其中的静态资源替换再导出。
docx⽂档本⾝其实是⼀个压缩的zip⽂件，将其解压过后就会发现它有⾃⼰的⽬录结构。
问题这个docx⽂档所在⽬录如下图所⽰：在本地调试时，我使⽤如下⽅式读取：import org.springframework.util.ResourceUtils;public static void main(String[] args) throws IOException {File docxTemplate = ResourceUtils.getFile("classpath:templates/docxTemplate.docx");}可以正常解析使⽤，但是打包发布到beta环境却不可⽤。
抛出异常如下：java.io.FileNotFoundException: class path resource [templates/docxTemplate.docx] cannot be resolved to absolute file path because it does not reside in the file system: jar:file:/usr/local/subject-server.jar!/BOOT-INF/classes!/templates/docxTe显⽽易见，这个异常告诉我们：没有找到⽂件，但是将jar包解压过后，发现这个⽂件是真真实实存在的。
java解析jar文件，读取并进行调用
java解析jar⽂件，读取并进⾏调⽤简单介绍了如何使⽤java.util.jar包提供的API操作jar⽂件，下⾯通过⼀个相对复杂的例⼦讲述⼀些Jar⽂件相关的⾼级应⽤。
仔细读读这篇⽂章并参考⼀下相关的java doc会对你学习java语⾔有很⼤的帮助。
下⾯的应⽤程序将实现从http服务器装载并执⾏⼀个jar⽂件的功能，⽐如你的Jar⽂件的地址为。
要实现这个功能我们应该⾸先建⽴与这个⽂件的连接然后通过MANIFEST的信息描述得到Main-Class的值，最后装载并运⾏这个class。
这⾥⾯需要⽤到和反射的⼀些重要知识。
这个应⽤程序由两个类组成：JarClassLoader和JarRunner。
JarClassLoader扩展了URLClassLoader，它有⼀个成员为URL类型的url变量。
public JarClassLoader(URL url){super(new URL[] { url });this.url = url;}它的两个重要⽅法是getMainClassName()和invokeClass()，其中前者的⽬的是通过URL和jar取得连接后，读取MANIFEST的Main-Class属性从⽽得到应⽤程序的⼊点，这⾮常重要。
得到⼊点后我们就可以通过反射机制装载和运⾏得到的主类。
public String getMainClassName() throws IOException {URL u = new URL("jar", "", url + "!/");JarURLConnection uc = (JarURLConnection)u.openConnection();Attributes attr = uc.getMainAttributes();return attr != nullattr.getValue(.MAIN_CLASS): null;}public void invokeClass(String name, String[] args)throws ClassNotFoundException,NoSuchMethodException,InvocationTargetException{Class c = this.loadClass(name);Method m = c.getMethod("main", new Class[] { args.getClass() });m.setAccessible(true);int mods = m.getModifiers();if (m.getReturnType() != void.class || !Modifier.isStatic(mods) ||!Modifier.isPublic(mods)) {throw new NoSuchMethodException("main");}try {m.invoke(null, new Object[] { args });} catch (IllegalAccessException e) {// This should not happen, as we have disabled access checks}}URL u = new URL("jar", "", url + "!/");JarURLConnection uc = (JarURLConnection)u.openConnection();这两段代码构造⼀个JarURLConnection的实例，注意!/的分隔符的意思是这个url表⽰的是整个jar⽂件。
java打jar包的几种方式详解
java打jar包的⼏种⽅式详解⼀、制作只含有字节码⽂件的jar包我们先来看只含有字节码⽂件，即只含有class⽂件的jar包怎么制作，这是最简单的形式1、最简单的jar包——直接输出hello最终⽣成的jar包结构META-INFHello.class⽅法步骤（1）⽤记事本写⼀个Hello.java的⽂件class Hello{public static void main(String[] agrs){System.out.println("hello");}}（2）⽤命令⾏进⼊到该⽬录下，编译这个⽂件 javac Hello.java（3）将编译后的Hello.class⽂件打成jar包 jar -cvf hello.jar Hello.class c表⽰要创建⼀个新的jar包，v表⽰创建的过程中在控制台输出创建过程的⼀些信息，f表⽰给⽣成的jar包命名（4）运⾏jar包 java -jar hello.jar 这时会报如下错误 hello.jar中没有主清单属性 添加Main-Class属性 ⽤压缩软件打开hello.jar，会发现⾥⾯多了⼀个META-INF⽂件夹，⾥⾯有⼀个MENIFEST.MF的⽂件，⽤记事本打开Manifest-Version: 1.0Created-By: 1.8.0_121 (Oracle Corporation) 在第三⾏的位置写⼊ Main-Class: Hello （注意冒号后⾯有⼀个空格，整个⽂件最后有⼀⾏空⾏），保存 再次运⾏ java -jar hello.jar ，此时成功在控制台看到 hello ，成功2、含有两个类的jar包——通过调⽤输出hello最终⽣成的jar包结构META-INFTom.classHello.class⽅法步骤（1）⽤记事本写⼀个Hello.java和⼀个Tom.java的⽂件 ⽬的是让Hello调⽤Tom的speak⽅法class Hello{public static void main(String[] agrs){Tom.speak();}}class Tom{public static void speak(){System.out.println("hello");}}（2）编译： javac Hello.java 此时Hello.java和Tom.java同时被编译，因为Hello中调⽤了Tom，在编译Hello的过程中发现还需要编译Tom（3）打jar包，这次我们换⼀种⽅式直接定义Main-Class。
java获取配置文件的参数的方法
一、概述Java是一种流行的编程语言，广泛应用于企业级软件开发。
在Java应用程序中，经常需要读取配置文件中的参数，以便程序在不同环境下能够灵活运行。
本文将介绍在Java中获取配置文件参数的方法。
二、使用Properties类在Java中，可以使用Properties类来读取配置文件。
Properties是HashTable的子类，它用于处理键值对形式的配置信息。
下面是使用Properties类获取配置文件参数的步骤：1. 创建Properties对象首先使用Properties类创建一个对象，用于存储配置文件中的参数。
可以通过以下代码实现：```javaProperties props = new Properties();```2. 加载配置文件接下来，需要将配置文件加载到Properties对象中。
通常配置文件的格式是.properties，可以通过以下代码加载：```javatry{InputStream inputStream =getClass().getClassLoader().getResourceAsStream("config.prope rties");props.load(inputStream);}catch(IOException e){e.printStackTrace();}```上述代码中，使用ClassLoader的getResourceAsStream方法加载配置文件，并使用Properties的load方法将文件内容加载到props 对象中。
3. 获取参数值一旦配置文件加载到props对象中，就可以通过getProperty方法获取参数值。
获取名为"db.url"的参数值可以使用以下代码：```javaString dbUrl = props.getProperty("db.url");```通过上述步骤，就可以在Java中轻松获取配置文件中的参数值了。
打jar包之后读不到properties文件
打jar包之后读不到properties⽂件（1）在Spring项⽬中有专门读取properties⽂件的类代码如下：import org.springframework.core.io.support.PropertiesLoaderUtils;Properties ret = PropertiesLoaderUtils.loadProperties(new ClassPathResource("XXX.properties"));rs = ret.getProperty("proname");(2)在普通项⽬中读取properties⽂件Properties properties = new Properties();InputStream in = this.getClass().getClassLoader().getResourceAsStream("/configfilename.properties");properties.load(in);String str = properties.getProperty("name");遇到的问题是项⽬打成jar包后⽆法读取到jar包内的properties⽂件发现在eclipse⾥⼀切正常，但打成jar包后就⽆法读取到properties⽂件了。
之前的程序是这样获取配置⽂件的:Thread.currentThread().getContextClassLoader().getResource("").getPath() +filename+".properties")来获取properties⽂件，但发现⼀运⾏就报错.后来将代码改成:this.getClass().getClassLoader().getResourceAsStream(filename+".properties")⼀切正常~关于java 的 classloader 还是有点概念不清，需要补补~~⼀般在项⽬中使⽤properties配置⽂件的时候都将相关的properties⽂件放在src⽬录下，在将该app打包⽣成jar后，相应的properties配置⽂件⽣成在jar包中，这样的话要修改配置⽂件⼜要重新打jar包，那是相当的⿇烦。
java读JAR包里的配置文件
private static String getXmlContent()throws IOException {Reader f = newInputStreamReader(QueryWeather.class.getClass().getResourceAsStream("/weather/we ather.xml"));BufferedReader fb = new BufferedReader(f);StringBuffer sb = new StringBuffer(“”);String s = "";while((s = fb.readLine()) != null) {sb = sb.append(s);}return sb.toString();}package com.read;import java.io.*;public class Resource {public void getResource() throws IOException{//返回读取指定资源的输入流InputStream is=this.getClass().getResourceAsStream("/struts-default.xml"); BufferedReader br=new BufferedReader(new InputStreamReader(is));String s="";while((s=br.readLine())!=null)System.out.println(s);}}这个类是jar包中的类,同时jar根下还有个struts-default.xml文件。
ClassLoader classloader = Thread.currentThread().getContextClassLoader(); InputStream is = classloader.getResourceAsStream("com/xxx/xxxx/yourfile.xml");一般情况下properties文件都是在工程内使用的，如果application打成jar包之后，修改properties文件后就需要重新打jar，很麻烦。
调用jar包外配置文件
项目中，经常把一部分功能独立出来，做一个java project，然后打成jar包供其他项目引用。
这时候，如果jar包中需要读取配置文件信息，则很少把该配置打进jar包，因为它不方便修改，更多都是采用jar包读取外部配置文件。
案例：项目工程名：auth -- 很明显，做鉴权使用的项目配置文件：init.properties log4j.properties项目引用jar包：lib/servlet-api.jarlib/log4j-1.2.15.jarlib/commons-collections-3.1.jarlib/commons-logging-1.0.4.jarlib/commons-pool.jarlib/ojdbc14.jar读取配置文件示例：目录结构如下：解决方案I：自定义manifest.mf 文件解释：Manifest-Version: 1.0 版本号，没啥特殊含义，但一定要有；Class-Path: 所有引用的jar包注意：每个“：”后面都要加空格，Class-Path中每个jar包间也加空格最后一行为空行截图如下：b.通过Eclipse 到处jar包右键项目工程----Export -- 选择Java下JAR File，下一步件外部读取），选择导出jar包的位置；注意：右侧的.classpath这些都不要选中，只把src下的java文件打包。
下一步下一步：选中自定义的manifest.mf文件，完成测试：新建项目，导入刚刚生成的jar包和jar需要的所有包（把jar包所在工程lib下所有引用jar拿过来），在src下写入配置文件,目录结构如下：测试：测试结果：这就是方案1，总结：自定义manifest.mf 文件，配置清楚jar所需要的所有lib。
当其他系统引用该jar时，相当于把包拉到系统中（jar的内容相当于系统自定义的），它读取的配置文件就是从系统的classpath下读取。
java 引用外部配置文件的方法
java 引用外部配置文件的方法Java作为一种广泛应用的编程语言，经常需要引用外部配置文件来获取程序的设置参数。
本文将介绍几种常用的方法来实现这个目的。
一、使用Properties类Properties类是Java提供的一个用于处理配置文件的工具类，它可以读取和写入配置文件的键值对。
使用Properties类引用外部配置文件的步骤如下：1. 创建一个Properties对象。
2. 使用load()方法读取配置文件，将配置文件的内容加载到Properties对象中。
3. 使用getProperty()方法根据键名获取配置项的值。
下面是一个示例代码：```javaimport java.io.FileInputStream;import java.io.IOException;import java.util.Properties;public class ConfigReader {public static void main(String[] args) {Properties properties = new Properties();try {FileInputStream fis = newFileInputStream("config.properties");properties.load(fis);fis.close();} catch (IOException e) {e.printStackTrace();}String url = properties.getProperty("url");String username = properties.getProperty("username"); String password = properties.getProperty("password"); System.out.println("url: " + url);System.out.println("username: " + username);System.out.println("password: " + password);}}```在这个例子中，我们使用了一个名为config.properties的配置文件，其中包含了url、username和password三个配置项的值。
Java命令行启动jar包更改默认端口以及配置文件的几种方式
Java命令⾏启动jar包更改默认端⼝以及配置⽂件的⼏种⽅式1. java -jar xxx.jar --server.port=80812. java -jar xxx.jar --spring.profiles.active=dev*这种⽅式，你打的jar包⾥得有application-dev.properties或application-dev.yml这类资源⽂件3. java -jar xxx.jar --spring.config.location=D:\Java\application.properties或 java -jar xxx.jar --spring.config.location=D:\Java\application.yml*指定加载某个资源⽂件，也可以使⽤相对路径4. java -jar xxx.jar --spring.config.location=D:\Java\application.properties -Dserver.port=8081 -Dserver.address=127.0.0.1*扩展，你加载的指定配置⽂件⾥的有server.port和server.address配置项例如：我⼯程⾥有mapper\xxx.xml数据库CRUD接⼝映射⽂件，我编译后的⽬录⽂件其实是在target\classes\mapper\xxx.xml当我使⽤指定资源配置⽂件启动的时候，由于我指定的配置⽂件⾥配置的 mapper-locations: classpath:mapper/*.xml是这样的加载路径，调试运⾏时没问题，但是在编译后的⽬标⽬录⾥启动时，就会因为路径不对⽽导致启动失败。
如果我这样启java -jar xxx.jar --spring.config.location=.\classes\application.yml下⾯⼀定会报mybatis-plus相关的⼀些错误，例如找不到映射⽂件之类的那，如果我这样启java -jar xxx.jar --spring.config.location=.\classes\application.yml -Dmybatis-plus.mapper-locations=.\classes\mapper就能正常加载资源配置⽂件并启动成功，其他配置项的加载道理也⼀样。
JAVA中读写配置文件
JAVA中读写配置文件2007-12-22java中读写属性文件下面的文章来自CSDN hyde82的专栏,因为很实用,所以就摘下来放在此处,具体网址忘记啦.无论是有图形化的选项配置对话框，或者是系统提供的注册表，文本形式的本地配置文件依然是最牢靠、应用最广泛的配置信息保存形式。
配置信息的一般模式就是一个配置项对应一个值，前者一般是个字符串，后者可能是数字或者字符串或者别的什么。
在传统win32编程中有系统提供的api供我们解读.ini文件，后来也有操作注册表的封装好的api，在.net中更是有解读XML形式.config文件的现成方法。
在Java中，对配置文件的使用进行封装也是十分有意义的。
封装应该达到这样的效果：应用只管从配置信息进行按名读取值、设置值、保存等操作，而不需要关心具体以什么文件格式保存、如何解析。
文件格式(纯文本?XML?数据库?)、IO 方式(本地文件?远程文件?控制台流?)在封装类内部的变更，都不会影响应用对配置信息的感知。
从键名-值的对应关系以及文件的存取，我们最容易想到的就是java.util.Properties对象，他是HashTable的子类，保存的就是很多组键名-值的对应二原组，并提供快速的查询和直接的从文件读取、保存为文件的方法。
具体请参考相关文档，我们直接看程序。
首先自定义一个异常：//ConfigurationException.javapackage configuration;public class ConfigurationException extends Exception{ public ConfigurationException(){}public ConfigurationException(String msg){super(msg);}}然后是我们的封装类：//Configuration.javapackage configuration;import java.io.*;import java.util.*;import configuration.*;public class Configuration {private Properties config=new Properties();//记录配置项private String fn=null;//记录配置文件名//此构造方法用于新建配置文件public Configuration(){}//从指定文件名读入配置信息public Configuration(String fileName)throws ConfigurationException {try {FileInputStream fin = new FileInputStream(fileName); config.load(fin); //载入文件fin.close();}catch (IOException ex) {throw new ConfigurationException("无法读取指定的配置文件:"+fileName);}fn=fileName;}//指定配置项名称，返回配置值public String getValue(String itemName){return config.getProperty(itemName);}//指定配置项名称和默认值，返回配置值public String getValue(String itemName,String defaultValue){return config.getProperty(itemName,defaultValue);}//设置配置项名称及其值public void setValue(String itemName,String value){ config.setProperty(itemName,value);return;}//保存配置文件，指定文件名和抬头描述public void saveFile(String fileName,String description) throws ConfigurationException {try {FileOutputStream fout= new FileOutputStream(fileName);config.store(fout, description);//保存文件fout.close();}catch (IOExeption ex) {throw new ConfigurationException("无法保存指定的配置文件:"+fileName);}}//保存配置文件，指定文件名public void saveFile(String fileName)throws ConfigurationException {saveFile(fileName,"");}//保存配置文件，采用原文件名public void saveFile() throws ConfigurationException { if(fn.length()==0)throw new ConfigurationException("需指定保存的配置文件名");saveFile(fn);}}从这个封装类我们可以看到，实例化对象的时候我们可以指定一个文件名使得从中读取配置信息，通过getValue方法取得属性值，setValue方法设置属性值，saveFile方法保存文件。
java获取文件内容的方法
java获取文件内容的方法【实用版4篇】篇1 目录I.获取文件内容的方法概述II.使用Scanner类读取文件内容III.使用BufferedReader类读取文件内容IV.使用FileInputStream类读取文件内容V.使用FileChannel类读取文件内容篇1正文Java中获取文件内容的方法有很多种，下面介绍几种常用的方法：1.使用Scanner类读取文件内容Scanner类是Java中常用的类之一，它可以帮助我们方便地读取文件内容。
具体实现方法如下：```javatry (Scanner scanner = new Scanner(new File("filename.txt"))) {while (scanner.hasNextLine()) {String line = scanner.nextLine();// 处理每一行内容}} catch (FileNotFoundException e) {e.printStackTrace();}```2.使用BufferedReader类读取文件内容BufferedReader类可以帮助我们快速读取文件内容，它可以读取文本文件、CSV文件等。
具体实现方法如下：```javatry (BufferedReader reader = new BufferedReader(new FileReader("filename.txt"))) {String line;while ((line = reader.readLine()) != null) {// 处理每一行内容}} catch (IOException e) {e.printStackTrace();}```3.使用FileInputStream类读取文件内容FileInputStream类可以帮助我们读取二进制文件，它可以读取图片、音频、视频等文件。
java读取资源文件的方法
java读取资源文件的方法Java是一种广泛应用于开发各种应用程序的编程语言。
在Java中，读取资源文件是一项常见的任务，它允许我们从外部文件中获取数据或配置信息。
本文将介绍几种常用的Java读取资源文件的方法。
一、使用ClassLoader读取资源文件Java中的ClassLoader是用于加载类的关键组件之一。
它不仅可以加载类，还可以加载其他类型的资源文件。
通过ClassLoader，我们可以很方便地读取资源文件。
我们需要使用ClassLoader的getResourceAsStream()方法获取资源文件的输入流。
这个方法可以接受一个相对路径作为参数，并返回一个InputStream对象。
然后，我们可以使用这个输入流来读取资源文件的内容。
下面是一个使用ClassLoader读取资源文件的示例代码：```javaClassLoader classLoader = getClass().getClassLoader(); InputStream inputStream = classLoader.getResourceAsStream("config.properties");```在上面的代码中，我们使用了getClass().getClassLoader()方法获取当前类的ClassLoader。
然后，我们调用getResourceAsStream()方法获取资源文件config.properties的输入流。
二、使用InputStream读取资源文件除了使用ClassLoader，我们还可以使用InputStream来读取资源文件。
这种方法适用于读取位于文件系统中的资源文件。
我们需要创建一个File对象，用于表示资源文件的路径。
然后，我们可以使用FileInputStream来打开这个文件，并获取其输入流。
最后，我们可以使用这个输入流来读取资源文件的内容。
下面是一个使用InputStream读取资源文件的示例代码：```javaFile file = new File("path/to/config.properties"); InputStream inputStream = new FileInputStream(file);```在上面的代码中，我们创建了一个File对象，表示资源文件config.properties的路径。
Java如何读取Jar中的资源
Java如何读取Jar中的资源Java如何读取Jar中的资源导语：在开发java项目的.时候，经常会用到jar包，这里就说下如何读取，需要的朋友可以参考下：详解Java读取Jar中资源文件及实现代码：直接上代码，文章的注释部分说的比较清楚，大家可以参考下，工具类源代码: ResourceLoadFromJarUtil.java实现代码：import java.io.IOException;import java.io.InputStream;import .JarURLConnection;import .MalformedURLException;import .URL;import java.util.jar.JarEntry;import java.util.jar.JarFile;import mons.io.IOUtils;public class ResourceLoadFromJarUtil {/*** @param args* @throws IOException*/public static void main(String[] args) throws IOException {/* 资源文件路径,不能以'/'字符字符开头 */String resourcePath = "struts-plugin.xml";/* 获取ClassPath下的所有jar路径 */String[] cps = System.getProperty("java.class.path").split(";");/* 读取本地Jar文件 */for (String cp : cps) {if (!cp.endsWith(".jar")) {continue;}InputStream in = loadResourceFromJarFile(cp, resourcePath);if (in != null) {System.err.println(IOUtils.toString(in));in.close();}}/* 读取本地Jar文件 */for (String cp : cps) {if (!cp.endsWith(".jar")) {continue;}InputStream in = loadResourceFromJarURL(cp, resourcePath);if (in != null) {System.err.println(IOUtils.toString(in));in.close();}}/* 读取网络Jar文件 */InputStream in = loadResourceFromJarURL("http://localhost:8080/SpringStruts2Integration/struts2-spring-plugin-2.3.4.1.jar", resourcePath);if (in != null) {System.err.println(IOUtils.toString(in));in.close();}}/*** 读取Jar文件中的资源** @param jarPath* 本地jar文件路径* @param resPath* 资源文件所在jar中的路径(不能以'/'字符开头)* @return 如果资源加载失败,返回null*/public static InputStream loadResourceFromJarFile(String jarPath, String resPath) {if (!jarPath.endsWith(".jar")) {return null;}try {JarFile jarFile = new JarFile(jarPath);JarEntry jarEntry = jarFile.getJarEntry(resPath);if (jarEntry == null) {return null;}return jarFile.getInputStream(jarEntry);} catch (IOException e) {e.printStackTrace();return null;}}/*** 读取Jar文件中的资源** @param jarUrl* 本地jar文件或网络上(ttp://host:port/subpath/jarfile.jar)jar文件路径* @param resPath* 资源文件所在jar中的路径(不能以'/'字符开头)* @return 如果资源加载失败,返回null*/public static InputStream loadResourceFromJarURL(String jarUrl, String resPath) {if (!jarUrl.endsWith(".jar")) {return null;}URL url = null;if (jarUrl.startsWith("http://")) {try {url = new URL("jar:" + jarUrl + "!/");} catch (MalformedURLException e) {e.printStackTrace();return null;}} else {try {url = new URL("jar:file:/" + jarUrl + "!/");} catch (MalformedURLException e) {e.printStackTrace();return null;}}try {JarURLConnection jarURLConnection;jarURLConnection = (JarURLConnection) url.openConnection();JarFile jarFile = jarURLConnection.getJarFile(); JarEntry jarEntry = jarFile.getJarEntry(resPath); if (jarEntry == null) {return null;}return jarFile.getInputStream(jarEntry);} catch (IOException e) {e.printStackTrace();return null;}}}【Java如何读取Jar中的资源】。
java程序打包成jar配置文件信息路径
java程序打包成jar配置⽂件信息路径⼀个普通的java project，⾥⾯引⽤了config.properties配置⽂件，将项⽬打成Runnable jar，然后将config.properties放到打包后的jar路径下，执⾏该jar包，出错，原⼯程中properties⽂件读取代码如下：InputStream in = SystemConfig.class.getResourceAsStream("/config.properties");FileInputStream in = new FileInputStream(rootPath+"/config.properties");上⽹搜了下class.getResource⽅式读取配置⽂件时，在eclipse中运⾏是没有问题的。
将该类打包成jar包执⾏，如果配置⽂件没有⼀起打包到该jar包中，⽂件查找的路径就会报错。
但是对于配置⽂件，我们⼀般不希望将其打包到jar包中，⽽是⼀般放到jar包外，随时进⾏配置。
修改⽅式如下：String rootPath = System.getProperty("user.dir").replace("\\", "/");FileInputStream in = new FileInputStream(rootPath+"/config.properties");⾸先程序获取程序的执⾏路径，也就是你打包后的jar存放路径，然后找到该路径下的config.properties⽂件读取，就可以了。
备注：对于其他的⼀些配置⽂件读取，也要相应修改，例如mybatis读取配置⽂件，默认⽅式是java.io.Reader reader = Resources.getResourceAsReader("Configuration.xml");factory = new SqlSessionFactoryBuilder().build(reader);如果打包到jar运⾏，Configuration.xml没有打包进去，也会报错，统⼀修改成String rootPath = System.getProperty("user.dir").replace("\\", "/");java.io.Reader reader = new FileReader(rootPath+"/Configuration.xml");factory = new SqlSessionFactoryBuilder().build(reader);。
Java读取jar包资源文件
Java读取jar包资源⽂件把java项⽬打包成jar包，如果jar包中存在资源⽂件需要访问，需要采取stream的形式访问，可以调⽤getResourceAsStream()⽅法，⽽不能采⽤路径的⽅式访问（⽂件已经被打到jar⾥⾯了，不符合路径的）。
使⽤getResourceAsStream()⽅法⽂件可以有两种⽅式存放：（1）⽂件存放在src的类路径下。
（2）⽂件存放在资源⽂件夹下⾯，通过Build Path—Use as Source Folder来把普通⽂件夹变成资源⽂件夹。
如图，把testA打包成jar包，导⼊testB中（Build Path—Add To Build Path），在testB中访问testA.txt和testB.txt。
1 @Test2public void test() {3 String line = null;4 BufferedReader bufferReader = null;5try {6 InputStream inputStream = App.class.getResourceAsStream("testA.txt");7 bufferReader = new BufferedReader(new InputStreamReader(inputStream));8while((line = bufferReader.readLine()) != null) {9 System.out.println(line);10 }11 } catch(Exception e) {12 e.printStackTrace();13 } finally {14try {15 bufferReader.close();16 } catch (IOException e) {17 e.printStackTrace();18 }19 }20 }访问testB时要把获取inputStream语句改为InputStream inputStream = App.class.getResourceAsStream("/testB.txt")。
如何读取jar包中的文件
如何读取jar包中的⽂件1.getResource//当前类⽂件为根⽬录，取其⼦⽬录x下的y⽂件Main.class.getResource("x/y")//当前类⽂件的根⽬录为根⽬录，取其⼦⽬录x下的y⽂件Main.class.getResource("/x/y")上⾯的解释有点拗⼝，其实就是路径不以斜线开头，表⽰从当前class⽂件为根⽬录，然后找⽂件，路径以斜线开头，则从当前class的⽂件的根⽬录，⽐如当前class如果有包限定的话，那就是从包的最顶层，作为根⽬录，来加载⽂件。
2.getResourceAsStreamprivate static String readFile(String file) throws IOException {InputStream input = null;BufferedInputStream bis = null;StringBuilder sb = new StringBuilder();try {input = Main.class.getResourceAsStream(file);bis = new BufferedInputStream(input);byte[] temp = new byte[1024];int len;while ((len = bis.read(temp)) != -1) {sb.append(new String(temp, 0, len, StandardCharsets.UTF_8));}} finally {if (bis != null) {bis.close();}if (input != null) {input.close();}}return sb.toString();}这⾥要注意的是，上⾯的写法中是Main.class.getResourceAsStream(file)，即从当前类的范围内去找file，如果写成Main.class.getClassLoader().getResourceAsStream(file)，则有可能找不到⽂件，因为已经从加载器的可见范围去找⽂件了。
springboot读取配置文件的顺序
springboot读取配置⽂件的顺序Spring Boot启动会扫描以下位置的application.properties或者application.yml⽂件作为Spring Boot的默认配置⽂件外部配置的加载顺序说明SpringApplication loads properties from application.properties files in the following locations and adds them to the Spring Environment:1. A /config subdirectory of the current directory2. The current directory3. A classpath /config package4. The classpath rootThe list is ordered by precedence (properties defined in locations higher in the list override those defined in lower locations).读取位置就是：1. file:/config/2. file:/3. classpath:/config/4. classpath:/以上顺序按照优先级从⾼到低的顺序，所有位置的⽂件都会被加载，⾼优先级的配置内容会覆盖低优先级配置的内容，其中配置⽂件中的内容是互补配置，即存在相同的配置内容，⾼优先级的内容会覆盖低优先级的内容存在不同的内容的时候，⾼优先级和低优先级的配置内容取并集我们也可以通过spring.config.location来改变默认的配置，具体做法就是项⽬打包好以后，我们可以使⽤命令⾏参数的形式，启动项⽬的时候来指定配置⽂件的新位置，指定配置⽂件和默认加载的配置⽂件共同起作⽤称为互补配置java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=D:/application.properties外部配置的加载顺序命令⾏参数命令⾏参数的优先级是最⾼的，假定内部配置的最⾼优先级配置⽂件配置的启动端⼝号是8081，启动命令⾏参数如以下设置：java -jar spring-boot-02-config-02.0.0.1-SNAPSHOT.jar --server.port=8089那么启动的端⼝就改成了8089，命令⾏可以把项⽬的所有的配置选项全部都改掉Spring Boot也可以从以下位置加载配置：优先级从⾼到低顺序，⾼优先级覆盖低优先级，如有不同内容，⾼优先级和低优先级形成互补配置1. 来⾃java:comp/env的JNDI属性2. java系统属性(System.getProperties())3. 操作系统环境变量4. RandomValuePropertySource配置的random.*属性值5. jar包外部的application-{profile}.properties或者application.yml(带spring.profile)配置⽂件6. jar包内部的application-{profile}.properties或者application.yml(带spring.profile)配置⽂件7. jar包外部的application.properties或者application.yml(不带spring.profile)配置⽂件8. jar包内部的application.properties或者application.yml(不带spring.profile)配置⽂件9. @Configuration注解类上的@PropertySource10. 通过SpringApplication.setDefaultProperties指定的默认属性其它搭建springcloud项⽬，抽出了个公共的common模块，其他服务依赖于common模块。