下载文档原格式
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包中的⽂件读取问题前⾔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 根据路径获取文件方法Java是一种广泛应用于软件开发的高级编程语言。
在Java中，我们经常需要根据路径获取文件。
本文将介绍如何使用Java来实现这一功能，并提供一步一步的指导。
第一步：导入相关的Java类库要使用Java来获取文件，我们需要导入相关的Java类库。
在这个场景下，我们需要导入java.io类库中的File类。
在Java中，File类提供了一些方法来操作文件和目录。
要导入File类，我们可以在Java源文件的开头添加以下代码：javaimport java.io.File;第二步：创建File对象在Java中，要获取文件，我们需要先创建一个File对象。
File对象代表文件系统中的一个文件或目录。
我们可以使用其构造函数来创建一个File 对象，构造函数可以接受文件路径作为参数。
以下是一个创建File对象的示例代码：javaString path = "C:\\myFolder\\myFile.txt";File file = new File(path);在上面的示例中，我们创建了一个名为file的File对象，该对象代表了路径为C:\myFolder\myFile.txt的文件。
请注意，在Java中，文件路径使用双反斜杠（\）来表示文件分隔符。
第三步：检查文件是否存在在创建File对象后，我们可以使用其exists()方法来检查文件是否存在。
exists()方法返回一个布尔值，如果文件存在，则返回true，否则返回false。
以下是一个检查文件是否存在的示例代码：javaif (file.exists()) {System.out.println("文件存在");} else {System.out.println("文件不存在");}第四步：获取文件的绝对路径要获取文件的绝对路径，我们可以使用File对象的getAbsolutePath()方法。
用于解压jar文件的命令在软件开发过程中，我们经常会遇到需要解压jar文件的情况。
jar 文件是一种Java归档文件，包含了Java程序的类、资源文件等。
解压jar文件可以帮助我们查看、修改和提取其中的内容。
本文将介绍一些常用的命令，以帮助您轻松完成jar文件的解压操作。
一、使用jar命令解压jar文件jar命令是Java开发工具包（JDK）自带的命令行工具，可以用于创建、查看和解压jar文件。
要解压jar文件，可以使用以下命令：jar -xf <jar文件名>例如，要解压名为example.jar的jar文件，可以运行以下命令：jar -xf example.jar执行该命令后，jar文件将被解压到当前目录下的一个与文件名相同的文件夹中。
您可以在该文件夹中查看和修改jar文件中的内容。
二、使用unzip命令解压jar文件除了jar命令，还可以使用unzip命令解压jar文件。
unzip命令是Linux和Unix系统中常用的解压命令，也可以用于解压jar文件。
要解压jar文件，可以使用以下命令：unzip <jar文件名>例如，要解压名为example.jar的jar文件，可以运行以下命令：unzip example.jar执行该命令后，jar文件将被解压到当前目录下。
您可以在当前目录中查看和修改jar文件中的内容。
三、使用7-Zip解压jar文件除了命令行工具，还可以使用图形化界面的压缩软件7-Zip来解压jar文件。
7-Zip是一款开源的压缩软件，支持多种格式的压缩文件，包括jar文件。
要解压jar文件，可以按照以下步骤进行操作：1. 下载并安装7-Zip软件；2. 打开7-Zip软件，找到要解压的jar文件；3. 右键点击jar文件，选择“7-Zip”菜单，然后选择“解压到指定文件夹”；4. 选择解压的目标文件夹，点击“确定”按钮。
执行以上步骤后，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")。
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包中的⽂件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)，则有可能找不到⽂件，因为已经从加载器的可见范围去找⽂件了。
标签：分类：Computer and I杂谈在编写完Java程序后，打包成Jar时发布，会发现找不到Jar文件中的图片和文本文件，其原因是程序中载入图片或文本文件时，使用了以当前工作路径为基准的方式来指定文件和路径。
这与用户运行Jar包时的当前工作路径并不一致。
问题分析：例如：以Windows为例说明，以下是开发项目“AAA”的部分代码，开发和调试时的根路径为D:\aaa，这样程序运行时当前路径为"D:\aaa"，大家可以用System.getProperty("user.dir")方法求证当前用户工作路径。
//下面代码使用了基于当前工作路径的方式指定了文件对象File imageFile = new File("/images/sample.gif");ImageIcon imageIcon = new ImageIcon(File.toURI);File iniFile = new File("/conf.ini");FileInputStream fileInputStream = new FileInputStream(iniFile.toU RI);以上的代码应用绝对路径信息指定了文件对象，在开发和调试期（未打包前），是没有问题的，但在打包后，由于所有图片文件和文本文件都将打包到Jar文件中，由于System中的"user.dir"属性发生了变化，会造成用绝对路径的方式无法找到Jar文件中包含路径和文件。
例如大家将上面的项目“AAA”中的所有类文件、图片文件和文本文件等打包为E:\aaa.jar文件并发布，在用户执行该aaa.jar中的程序时，当前路径取决于用户运行该程序的当前路径。
例如: 在“E:\”目录下运行该程序：E:\> java -jar aaa.jar此时用户的当前路径（System的user.dir属性）是“E:\”，而非开发者所期望的“E:\aaa”，所以会按以下路径来搜索文件：E:\images\sample.gifE:\conf.ini但是所有的图片和文本文件包含在E:\aaa.jar文件中，所以会致使程序无法正常运行。
java读取外部配置文件的方法在Java中，您可以使用多种方法来读取外部配置文件，这有助于将应用程序配置信息从代码中分离，使得配置更加灵活。
以下是一些常见的方法：1.使用`Properties`类：可以使用Java的`Properties`类来读取键值对形式的配置文件，通常是`.properties`文件。
例如：```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 fileInputStream=newFileInputStream("config.properties")){properties.load(fileInputStream);String value=properties.getProperty("key");System.out.println("Value:"+value);}catch(IOException e){e.printStackTrace();}}}```2.使用`ResourceBundle`类：如果您的配置文件在类路径中，可以使用`ResourceBundle`类来读取配置信息。
这对于国际化和本地化也很有用。
```javaimport java.util.ResourceBundle;public class ConfigReader{public static void main(String[]args){ResourceBundle bundle=ResourceBundle.getBundle("config");String value=bundle.getString("key");System.out.println("Value:"+value);}}```3.使用第三方库：除了标准Java库，您还可以使用第三方库，如Apache Commons Configuration或Typesafe Config，来更灵活地处理配置文件。
idea打包java项目生成jar 原理-概述说明以及解释1.引言1.1 概述在Java开发中，项目的打包是必不可少的环节。
打包后的项目可以方便地部署和传输，使得程序在不同的环境中能够运行。
而JAR（Java Archive）文件则是一种常见的打包格式，它将Java项目的所有源代码、资源文件和依赖库等打包在一起，并且可以被Java虚拟机（JVM）识别和执行。
JAR打包对于Java项目的部署和运行起到了至关重要的作用。
在打包过程中，所有的源代码、配置文件、第三方库以及其他所需的资源文件都会被打包成一个可执行的JAR文件。
这个JAR文件可以被轻松地传输、备份和部署到其他环境中。
了解JAR打包的原理对于Java开发人员来说是非常重要的。
它可以帮助我们更好地理解项目的结构和组成，并且能够正确地配置和优化JAR 文件，以满足项目的需求和性能要求。
另外，掌握JAR打包的原理还有助于我们更好地理解Java的类加载机制，从而能够更好地调试和优化项目的运行效率。
本文将从概念和背景开始，介绍Java项目打包成JAR的原理。
我们将探讨JAR文件的组成和结构，以及JAR打包过程中的一些关键步骤和技巧。
最后，我们将总结JAR打包的重要性，并强调了解JAR打包原理的好处。
通过阅读本文，希望读者能够对Java项目的打包有更深入的了解，并能够在实际开发中灵活应用JAR打包技术。
1.2文章结构文章结构部分的内容主要是对本篇长文的章节和内容进行概括和介绍。
以下是文章结构部分的内容：1.2 文章结构本文主要围绕着"idea打包Java项目生成JAR"的原理展开讨论，旨在帮助读者了解Java项目打包成JAR文件的概念、背景和原理。
为了使读者更好地理解，本文按照以下章节进行组织和阐述。
第一部分是引言部分，包括概述、文章结构和目的。
在本部分，我们将对整篇文章进行简要回顾，并明确文章的目的和意义，以便读者能够更好地理解和把握文章内容的整体框架。
Springboot读取jar包中的MANIFEST.MF⽂件内容Springboot打包成可执⾏jar包后，包结构如下所⽰：⼯程编译后的⽂件都在BOOT-INF/classes⽬录下，如果需要读取并显⽰META-INF/MANIFEST.MF⽂件内容，那么可以⽤以下⽅式来实现：import org.springframework.util.ClassUtils;import org.springframework.util.FileCopyUtils;import java.io.InputStreamReader;import java.io.StringReader;import java.io.StringWriter;import java.util.jar.JarEntry;import java.util.jar.JarFile;………………………………JarFile jarFile = null;try { // 获取jar的运⾏路径，因linux下jar的路径为”file:/app/.../test.jar!/BOOT-INF/class!/“这种格式，所以需要去掉”file:“和”!/BOOT-INF/class!/“String jarFilePath = ClassUtils.getDefaultClassLoader().getResource("").getPath().replace("!/BOOT-INF/classes!/", "");if (jarFilePath.startsWith("file")) {jarFilePath = jarFilePath.substring(5);}log.debug("jarFilePath:" + jarFilePath); // 通过JarFile的getJarEntry⽅法读取META-INF/MANIFEST.MFjarFile = new JarFile(jarFilePath);JarEntry entry = jarFile.getJarEntry("META-INF/MANIFEST.MF"); // 如果读取到MANIFEST.MF⽂件内容，则转换为stringif (entry != null) {StringWriter writer = new StringWriter();FileCopyUtils.copy(new InputStreamReader(jarFile.getInputStream(entry)), writer);jarFile.close();String content = IOUtils.toString(new StringReader(writer.toString()));log.debug("MANIFEST.MF content:" + content); return content;} else {return null;}} catch (Exception ex) {log.error("error when reading MANIFEST.MF", ex);} finally {if (jarFile != null) {jarFile.close();}}。
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读取资源文件的方法。
一、使用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是一种广泛应用的编程语言，其灵活性和强大的功能使其在软件开发领域得到了广泛的运用。
在Java编程中，我们常常会用到java -jar命令来执行一些特定的方法或程序。
本文将从执行方法的基本语法、常见问题及解决方法等方面进行介绍，以帮助读者更好地理解和应用java -jar命令。
一、java -jar执行方法的基本语法在Java编程中，我们可以使用java -jar命令来执行一个打包成jar包的程序或方法。
其基本语法如下：java -jar <jar文件名> [参数]其中，<jar文件名>表示要执行的jar包文件名，参数是可选的，可以在执行方法时传入给程序。
在执行java -jar命令时，需要在命令行中切换到jar包所在的目录，然后输入以上命令即可执行指定的程序或方法。
二、java -jar执行方法的常见问题及解决方法在使用java -jar命令执行方法时，有时会遇到一些常见的问题，下面将介绍一些常见问题及其解决方法：1. 无法找到或加载主类当执行java -jar命令时，如果出现"无法找到或加载主类"的错误提示，这通常是由于指定的jar包中的MANIFEST文件中未正确指定主类名所致。
解决方法是打开MANIFEST文件并检查M本人n-Class项是否正确指定了主类名，确保没有拼写错误。
2. 缺少依赖库有时在执行java -jar命令时，会出现"找不到类xxx"的错误提示，这通常是由于jar包所需的依赖库未正确引入或缺失所致。
解决方法是在编译jar包时将所需的依赖库一起打包进去，或者将依赖库放在与jar包相同的目录下。
3. 参数传递错误当执行java -jar命令需要传递参数给程序时，有时会因参数传递错误而导致程序出现异常或错误。
解决方法是检查传递的参数是否符合程序要求，并且要注意参数的顺序和格式是否正确。
三、java -jar执行方法的注意事项在使用java -jar命令执行方法时，还需要注意一些事项，以确保程序能够正常执行：1. 确保jar包正确打包在执行java -jar命令时，需要确保jar包已经正确打包，并且MANIFEST文件中正确指定了主类名和依赖库。
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⼯程读取resources中资源⽂件路径的问题
正常在Java⼯程中读取某路径下的⽂件时，可以采⽤绝对路径和相对路径，绝对路径没什么好说的，相对路径，即相对于当前类的路径。
在本地⼯程和服务器中读取⽂件的⽅式有所不同，以下图配置⽂件为例。
本地读取资源⽂件
java类中需要读取properties中的配置⽂件，可以采⽤⽂件（File）⽅式进⾏读取：
File file = new File("src/main/resources/properties/basecom.properties");
InputStream in = new FileInputStream(file);
当在eclipse中运⾏（不部署到服务器上），可以读取到⽂件。
服务器（Tomcat）读取资源⽂件
当⼯程部署到Tomcat中时，按照上边⽅式，则会出现找不到该⽂件路径的异常。
经搜索资料知道，Java⼯程打包部署到Tomcat中时，properties的路径变到顶层（classes下）：
并且，此时读取⽂件需要采⽤流（stream）的⽅式读取，如下：
InputStream in = this.getClass().getResourceAsStream("/properties/basecom.properties");
其中properties前的斜杠，相对于调⽤类，共同的顶层路径。
以上这篇浅谈Java⼯程读取resources中资源⽂件路径的问题就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。
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文件run指令000前段时间由于研究原来广为传播的String和StringBuffer的性能问题，自己做了几个小实验并得出一些结论，但是从网友的反应来看那个研究并没有起到应有的目的，而且网友也很中肯的提出了自己的意见并对实验中的一些内容指出了其缺陷，针对他们的反应我又反编译了代码来进行对比，但是几位网友仍然不是很信服，而且上次实验的结果和反编译得到的结论并不能完全吻合，因为反编译代码的对比基本上是基于语句的多少，因此这个这个对比也确实不能使人信服，但是这给我的下一步行动指引了方向：研究JVM指令和JVM结构，在对反编译后的代码有完全的理解才能给出可能使人信服的结论。
本文以及以后将要写的一些文章就是我研究JVM规范的一些心得，我希望在和大家共同理解的基础上进行我们下一轮的深入研究。
好，闲话少说，开始我们的正文。
JVM执行的对象就是大家非常熟悉的class文件，我们也称为类文件，JVM规范定义的这个编译完成的代码文件(虽然并非强制要求是实际的文件)的格式非常的详实，但是我们这里只说一些宏观的内容，以后有机会再研究细节的内容吧。
JVM要求的类文件的格式是和硬件和操作系统无关的一种二进制格式，它精确定义了类或者接口的表示，它甚至包含了字节顺序这样的细节，而字节顺序在特定平台的目标文件格式中一般都是固定的，不会进行说明。
JVM所支持的数据类型和Java语言规范中定义的几乎一样，请注意是几乎一样！也就是原始类型和引用类型，他们可以被存储在变量表中，也可以作为参数传递、被方法返回，更通常的就是成为操作的对象。
为什么和Java语言规范中定义的不完全一样呢？因为JVM中有一种Java语言所没有的原始类型：返回地址类型(returnAddress type)。
该类型是jsr, ret以及jsr_w指令需要使用到的，它的值是JVM指令的操作码的指针，并且它的值是不能被运行中的程序所修改的。
另外需要提到的就是布尔类型的值，虽然在Java语言中它是完全独立的值，但是在JVM中只提供了对它的有限支持，表现在：没有单独的操作布尔类型的指令，源代码中的布尔类型的操作在编译以后是作为int类型的值进行操作的。
