java读取properties文件问题
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包，那是相当的⿇烦。
properties文件乱码的解决方法
序号一、问题描述：在开发过程中，我们经常会使用到properties文件来存储配置信息。
然而，有时候我们会遇到properties文件乱码的情况，导致配置信息无法正确读取。
那么，对于properties文件乱码的问题，我们应该如何解决呢？序号二、问题原因：1. 字符编码不一致：在不同的操作系统或编辑器下，可能会出现字符编码不一致的情况，导致properties文件乱码。
2. 属性文件保存时使用了非UTF-8编码：在保存properties文件时，如果使用了不支持的编码格式，也会导致乱码问题。
序号三、解决方法：针对上述问题，我们可以采取以下方法来解决properties文件乱码的情况：1. 使用正确的字符编码：在编写和保存properties文件时，要确保使用统一的字符编码格式，推荐使用UTF-8编码。
2. 使用专门的工具进行转换：可以使用一些专门的工具来进行字符编码的转换，如Notepad++等文本编辑器，通过转换编码格式来解决乱码问题。
3. 使用Java代码进行转换：可以编写Java代码来读取properties文件，并在读取时指定正确的字符编码格式，以解决乱码问题。
序号四、示例代码：以下是使用Java代码进行转换的示例：```javaimport java.io.*;import java.util.Properties;public class PropertiesFileReader {public static void main(String[] args) {try {// 读取properties文件InputStream inputStream = newFileInputStream("config.properties");InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "UTF-8");BufferedReader bufferedReader = new BufferedReader(inputStreamReader);Properties properties = new Properties();properties.load(bufferedReader);// 获取属性值String value = properties.getProperty("key");System.out.println(value);} catch (IOException e) {e.printStackTrace();}}}```在上面的示例中，我们使用了InputStreamReader来指定了UTF-8的字符编码格式，从而解决了properties文件乱码的问题。
Properties的相对路径以及文件的读取操作
Properties的相对路径以及⽂件的读取操作在我们平时写程序的时候，有些参数是经常改变的，⽽这种改变不是我们预知的。
⽐如说我们开发了⼀个操作数据库的模块，在开发的时候我们连接本地的数据库那么 IP ，数据库名称，表名称，数据库主机等信息是我们本地的，要使得这个操作数据的模块具有通⽤性，那么以上信息就不能写死在程序⾥。
通常我们的做法是⽤配置⽂件来解决。
各种语⾔都有⾃⼰所⽀持的配置⽂件类型。
⽐如 Python，他⽀持 .ini⽂件。
因为他内部有⼀个 ConfigParser类来⽀持 .ini⽂件的读写，根据该类提供的⽅法程序员可以⾃由的来操作 .ini⽂件。
⽽在 Java中， Java⽀持的是 .properties⽂件的读写。
JDK内置的 java.util.Properties类为我们操作 .properties⽂件提供了便利。
⼀． .properties⽂件的形式 ==========================================================#以下为服务器、数据库信息dbPort = localhostdatabaseName = mydbdbUserName = rootdbPassword = root#以下为数据库表信息dbTable = mytable#以下为服务器信息ip = 192.168.0.9······在上⾯的⽂件中我们假设该⽂件名为： test.properties⽂件。
其中 #开始的⼀⾏为注释信息；在等号“ =”左边的我们称之为 key；等号“ =”右边的我们称之为 value 。
（其实就是我们常说的键 -值对） key应该是我们程序中的变量。
⽽ value是我们根据实际情况配置的。
⼆． JDK中的 Properties类 Properties类存在于胞 Java.util中，该类继承⾃ Hashtable ，它提供了⼏个主要的⽅法：1． ( key) ，⽤指定的键在此属性列表中搜索属性。
java读取properties文件中文乱码的解决方法
java读取properties文件时，如果包含中文，那么该中文字段读出为乱码。这是因为java中文件大多以UTF-8或GBK的方式保存，而java程序在读出properties文件时则采用unicode编码方式，这样自然会导致中文乱码情况的发生。
}
public String getProperties(String key) throws Exception{
is=new FileInputStream(propPath);
prop.load(is);
return prop.getProperty(key);
}
}
public class TestPorperty {
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at ng.reflect.Method.invoke(Method.java:597)
at org.junit.internal.runners.TestMethodRunner.executeMethodBody(TestMethodRunner.java:99)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:386)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)
prop.load(is);
properties文件乱码的解决方法 -回复
properties文件乱码的解决方法-回复【properties文件乱码的解决方法】乱码问题是在处理properties文件时经常遇到的一个问题，本文将详细介绍properties文件乱码问题的原因以及解决方法，并提供一步一步详细的指导。
1. 引言properties文件是常用的配置文件格式，它使用键值对的方式储存数据，通常以ASCII编码的形式存储文本信息。
然而，当中文等非ASCII字符出现时，就会出现乱码问题。
2. 乱码问题的原因了解乱码问题的原因对于解决问题至关重要。
通常，乱码问题是由于使用了不正确的字符编码导致的。
以下是几种常见的原因：a) properties文件本身使用的字符编码与读取它的程序使用的编码不一致；b) properties文件中的字符编码与IDE或编辑器使用的编码不一致；c) properties文件中的特定字符没有被正确地编码。
3. 解决乱码问题的方法解决properties文件乱码问题，我们需要从多个角度考虑。
下面是一些常用的解决方法：步骤1：确认字符编码的一致性确保properties文件本身使用的字符编码与读取它的程序使用的编码保持一致。
一般情况下，properties文件使用的是ISO-8859-1编码，如果程序读取时使用的是其他编码，就会出现乱码。
步骤2：检查IDE或编辑器的字符编码设置确保IDE或编辑器的字符编码设置与properties文件中使用的字符编码保持一致。
如果两者不一致，就会导致乱码。
可以在IDE或编辑器的设置界面中查找相关选项进行调整。
步骤3：使用正确的字符编码加载properties文件在读取properties文件时，使用正确的字符编码加载文件。
通常，在Java中使用的是Unicode编码，可以通过指定字符集来读取文件。
使用`InputStreamReader`类，并设置特定的字符集来保证正确的编码。
如下所示：javaFileInputStream fis = newFileInputStream("yourPropertiesFile.properties");InputStreamReader isr = new InputStreamReader(fis, "UTF-8");Properties properties = new Properties();properties.load(isr);步骤4：处理特定字符的编码问题如果properties文件中包含特定字符（如中文、特殊符号等），需要确保这些字符被正确地编码。
properties基础用法
properties基础用法Properties是Java编程语言中的一个关键字，用于描述类或对象的特性或属性。
在Java中，通过创建属性可以使对象具有更多的状态和行为，从而增强程序的灵活性和可扩展性。
本文将简要介绍Properties的基本用法，并逐步回答有关Properties的问题。
Properties的基本概念Properties是Java中的一个类，它继承自Hashtable类，因此也是一个键值对的集合。
不同之处在于，Properties的键和值都是字符串类型。
在Java中，可以使用Properties来读取和写入配置文件，存储一些设置和信息，以便在程序运行时进行访问和修改。
通常情况下，配置文件的后缀名是.properties，其格式为键值对的形式。
Properties的创建与初始化Properties类提供了多种构造方法来创建对象。
例如，可以使用无参构造方法来创建一个空的Properties对象，并使用setProperty()方法来添加键值对。
Properties properties = new Properties();properties.setProperty("age", "25");Properties的读取与写入通过加载配置文件，可以将其内容读取到Properties对象中，以便在程序中进行访问。
可以使用load()方法来加载配置文件。
FileInputStream fis = new FileInputStream("config.properties"); Properties properties = new Properties();properties.load(fis);fis.close();在加载配置文件后，就可以使用getProperty()方法来读取配置文件中的值。
String name = properties.getProperty("name");String age = properties.getProperty("age");同样，当需要将数据写入配置文件时，可以使用store()方法。
Springboot从配置文件properties读取字符串乱码的解决
Springboot从配置⽂件properties读取字符串乱码的解决⽬录从配置⽂件properties读取字符串乱码⽅式⼀⽅法⼆properties⽂件的属性值为中⽂，读取时乱码把属性值直接转成unicode编码在⽅法中转码从配置⽂件properties读取字符串乱码当读取properties的内容为：发现中⽂乱码。
原因是由于默认读取的为ISO-8859-1格式，因此需要切换为UTF-8。
主要⽅式有如下两种：⽅式⼀在你的application.properties中增加如下配置，避免中⽂乱码spring.http.encoding.enabled=true⽅法⼆在你的settings⾥⾯的File Encodings进⾏更改为如图1.1 中红框。
图1.1properties⽂件的属性值为中⽂，读取时乱码我们在开发中使⽤properties⽂件时，常会遇到这样的问题，⽐如说：test.property.value=中⽂值我们想把属性值设置成中⽂，这样⽆论使⽤@value还是直接读取出来会出现乱码，总结了两种解决⽅案如下：把属性值直接转成unicode编码写在⽂件中，如：test.property.value.unicode=\u4e2d\u6587\u503c在⽅法中转码如下⾯代码中的getChinese()⽅法package com.xiaobai.util;import lombok.extern.slf4j.Slf4j;import java.io.UnsupportedEncodingException;import java.util.PropertyResourceBundle;import java.util.ResourceBundle;@Slf4jpublic class PropertiesUtil {protected static ResourceBundle erpResponse;protected static final String PROPERTIES_FILE = "propertytest";static {try {erpResponse = PropertyResourceBundle.getBundle(PROPERTIES_FILE);} catch (Exception e) {log.error(PROPERTIES_FILE + "配置⽂件加载失败。
java读取外部配置文件的方法
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，来更灵活地处理配置文件。
jakarta读取properties文件的方法
一、介绍properties文件properties文件是一种常见的配置文件格式，用于存储应用程序的配置信息。
它由一系列的key-value对组成，每一行表示一个属性的键值对。
在Java开发中，properties文件通常被用于存储应用程序的配置信息，如数据库连接信息、日志级别等。
二、使用Java中的Properties类读取properties文件在Java中，可以使用Properties类来读取properties文件中的配置信息。
Properties类是Java.util包中的一个工具类，专门用于处理properties文件。
通过Properties类，可以很方便地将properties 文件中的配置信息读取到内存中，并在程序中使用。
三、通过FileInputStream读取properties文件可以通过FileInputStream类来读取properties文件。
下面是通过FileInputStream类读取properties文件的示例代码：```javaimport java.util.Properties;import java.io.FileInputStream;import java.io.IOException;public class ReadPropertiesFile {public static void m本人n(String[] args) {Properties properties = new Properties();try {properties.load(newFileInputStream("config.properties"));String username = properties.getProperty("username"); String password = properties.getProperty("password"); System.out.println("username: " + username);System.out.println("password: " + password);} catch (IOException e) {e.printStackTrace();}}}```上面的示例代码首先创建了一个Properties对象，然后通过FileInputStream类将properties文件加载到Properties对象中。
property 'files' has no setter method
property 'files' has no setter method作为一名职业写手，我们时常会遇到各种各样的技术性问题。
今天，我们将针对Java中一个常见的问题——“property "files" has no setter method”进行详细的分析和解答。
1.问题概述在Java中，当我们尝试为一个对象的属性赋值时，却发现提示“property "files" has no setter method”。
这意味着该属性的值无法被直接设置，可能是因为该属性没有对应的setter方法，或者setter方法的命名不符合规范。
2.原因分析导致这个问题出现的原因主要有以下两点：（1）属性没有setter方法：在Java中，为了保证代码的健壮性和可维护性，我们通常为类的属性提供getter和setter方法。
如果一个属性没有setter 方法，那么在尝试为其赋值时就会出现这个问题。
（2）setter方法命名不符合规范：Java中的setter方法命名规范通常为“set+属性名”。
如果属性的setter方法命名不符合规范，例如使用了其他字母或数字，则在调用该方法时也会出现上述提示。
3.解决方案针对上述原因，我们可以采取以下解决方案：（1）为属性添加setter方法：如果属性缺少setter方法，我们只需为该属性添加一个符合规范的setter方法即可。
例如，如果属性名为“files”，则可以添加如下setter方法：```javapublic void setFiles(List<File> files) {this.files = files;}```（2）修改setter方法命名：如果setter方法命名不符合规范，只需将其修改为符合规范的命名即可。
例如，将“setFiles”修改为“setFile”。
4.预防措施为了避免在今后遇到类似问题，我们可以采取以下预防措施：（1）遵循命名规范：在编写代码时，遵循Java的命名规范，确保属性和方法的命名符合标准。
使用Java读取Properties资源文件的6种方法
使用J2SE API读取Properties文件的六种方法：1.使用Java.util.Properties类的load()方法示例：InputStream in = lnew BufferedInputStream(new FileInputStream(name));Properties p = new Properties();p.load(in);2.使用java.util.ResourceBundle类的getBundle()方法示例：ResourceBundle rb = ResourceBundle.getBundle(name, Locale.getDefault());3.使用java.util.PropertyResourceBundle类的构造函数示例：InputStream in = new BufferedInputStream(new FileInputStream(name));ResourceBundle rb = new PropertyResourceBundle(in);4.使用class变量的getResourceAsStream()方法示例：InputStream in = JProperties.class.getResourceAsStream(name);Properties p = new Properties();p.load(in);5.使用class.getClassLoader()所得到的ng.ClassLoader的getResourceAsStream()方法示例：InputStream in = JProperties.class.getClassLoader().getResourceAsStream(name);Properties p = new Properties();p.load(in);6.使用ng.ClassLoader类的getSystemResourceAsStream()静态方法示例：InputStream in = ClassLoader.getSystemResourceAsStream(name);Properties p = new Properties();p.load(in);补充Servlet中可以使用javax.servlet.ServletContext的getResourceAsStream()方法示例：InputStream in = context.getResourceAsStream(path);Properties p = new Properties();p.load(in);完整的示例:JProperties.Java文件package com.kindani;//import javax.Servlet.ServletContext;import java.util.*;import java.io.InputStream;import java.io.IOException;import java.io.BufferedInputStream;import java.io.FileInputStream;/*** 使用J2SE API?取Properties文件的六种方法* User: SYNFORM* Date: 2005/07/12* Time: 18:40:55* To change this template use File | Settings | File Templates.*/public class JProperties {public final static int BY_PROPERTIES = 1;public final static int BY_RESOURCEBUNDLE = 2;public final static int BY_PROPERTYRESOURCEBUNDLE = 3;public final static int BY_CLASS = 4;public final static int BY_CLASSLOADER = 5;public final static int BY_SYSTEM_CLASSLOADER = 6;public final static Properties loadProperties(final String name, final int type) throws IOException {Properties p = new Properties();InputStream in = null;if (type == BY_PROPERTIES) {in = new BufferedInputStream(new FileInputStream(name));assert (in != null);p.load(in);} else if (type == BY_RESOURCEBUNDLE) {ResourceBundle rb = ResourceBundle.getBundle(name, Locale.getDefault()); assert (rb != null);p = new ResourceBundleAdapter(rb);} else if (type == BY_PROPERTYRESOURCEBUNDLE) {in = new BufferedInputStream(new FileInputStream(name));assert (in != null);ResourceBundle rb = new PropertyResourceBundle(in);p = new ResourceBundleAdapter(rb);} else if (type == BY_CLASS) {assert (JProperties.class.equals(new JProperties().getClass()));in = JProperties.class.getResourceAsStream(name);assert (in != null);p.load(in);//return new JProperties().getClass().getResourceAsStream(name);} else if (type == BY_CLASSLOADER) {assert (JProperties.class.getClassLoader().equals(new JProperties().getClass().getClassLoader()));in = JProperties.class.getClassLoader().getResourceAsStream(name);assert (in != null);p.load(in);//return new JProperties().getClass().getClassLoader().getResourceAsStream(name);} else if (type == BY_SYSTEM_CLASSLOADER) {in = ClassLoader.getSystemResourceAsStream(name);assert (in != null);p.load(in);}if (in != null) {in.close();}return p;}// ---------------------------------------------- servlet used/*public static Properties loadProperties(ServletContext context, String path) throws IOException {assert (context != null);InputStream in = context.getResourceAsStream(path);assert (in != null);Properties p = new Properties();p.load(in);in.close();return p;}*/// ---------------------------------------------- support class/*** ResourceBundle Adapter class.*/public static class ResourceBundleAdapter extends Properties { public ResourceBundleAdapter(ResourceBundle rb) {assert (rb instanceof java.util.PropertyResourceBundle);this.rb = rb;java.util.Enumeration e = rb.getKeys();while (e.hasMoreElements()) {Object o = e.nextElement();this.put(o, rb.getObject((String) o));}}private ResourceBundle rb = null;public ResourceBundle getBundle(String baseName) {return ResourceBundle.getBundle(baseName);}public ResourceBundle getBundle(String baseName, Locale locale) { return ResourceBundle.getBundle(baseName, locale);}public ResourceBundle getBundle(String baseName,Locale locale, ClassLoader loader) {return ResourceBundle.getBundle(baseName, locale, loader);}public Enumeration getKeys() {return rb.getKeys();}public Locale getLocale() {return rb.getLocale();}public Object getObject(String key) {return rb.getObject(key);}public String getString(String key) {return rb.getString(key);}public String[] getStringArray(String key) {return rb.getStringArray(key);}protected Object handleGetObject(String key) {return ((PropertyResourceBundle) rb).handleGetObject(key);}}}JPropertiesTest.Java文件package com.kindani.test;import junit.Framework.*;import com.kindani.JProperties;//import javax.Servlet.ServletContext;import java.util.Properties;public class JPropertiesTest extends TestCase {JProperties jProperties;String key = "helloworld.title";String value = "Hello World!";public void testLoadProperties() throws Exception {String name = null;Properties p = new Properties();name = "C:IDEAPProperties4MethodssrccomkindanitestLocalStrings.properties";p = JProperties.loadProperties(name, JProperties.BY_PROPERTIES);assertEquals(value, p.getProperty(key));name = "com.kindani.test.LocalStrings";p = JProperties.loadProperties(name,JProperties.BY_RESOURCEBUNDLE);assertEquals(value, p.getProperty(key));assertEquals(value,((JProperties.ResourceBundleAdapter)p).getString(key));name = "C:IDEAPProperties4MethodssrccomkindanitestLocalStrings.properties";p = JProperties.loadProperties(name, JProperties.BY_PROPERTYRESOURCEBUNDLE);assertEquals(value, p.getProperty(key));assertEquals(value,((JProperties.ResourceBundleAdapter)p).getString(key));name = "comkindanitestLocalStrings.properties";p = JProperties.loadProperties(name, JProperties.BY_SYSTEM_CLASSLOADER);assertEquals(value, p.getProperty(key));name = "comkindanitestLocalStrings.properties";p = JProperties.loadProperties(name, JProperties.BY_CLASSLOADER);assertEquals(value, p.getProperty(key));name = "testLocalStrings.properties";p = JProperties.loadProperties(name, JProperties.BY_CLASS);assertEquals(value, p.getProperty(key));}/*public void testLoadProperties2() throws Exception {ServletContext context = null;String path = null;Properties p = null;path = "/Web-INF/classes/LocalStrings.properties";p = JProperties.loadProperties(context, path);assertEquals(value, p.getProperty(key));}*/}properties文件与JPropertiesTest.Java文件相同的目录下LocalStrings.properties文件# $Id: LocalStrings.properties,v 1.1 2000/08/17 00:57:52 horwat Exp $ # Default localized resources for example Servlets# This locale is en_UShelloworld.title=Hello World!requestinfo.title=Request Information Examplebel.method=Method:bel.requesturi=Request URI:bel.protocol=Protocol:bel.pathinfo=Path Info:bel.remoteaddr=Remote Address:requestheader.title=Request Header Examplerequestparams.title=Request Parameters Examplerequestparams.params-in-req=Parameters in this request: requestparams.no-params=No Parameters, Please enter some requestparams.firstname=First Name:stname=Last Name:cookies.title=Cookies Examplecookies.cookies=Your browser is sending the following cookies: cookies.no-cookies=Your browser isn't sending any cookiescookies.make-cookie=Create a cookie to send to your browser =Name:cookies.value=Value:cookies.set=You just sent the following cookie to your browser: sessions.title=Sessions Examplesessions.id=Session ID:sessions.created=Created:stAccessed=Last Accessed:sessions.data=The following data is in your session:sessions.adddata=Add data to your sessionsessions.dataname=Name of Session Attribute:sessions.datavalue=Value of Session Attribute。
idea properties文件乱码的解决方法
在撰写高质量、深度和广度兼具的文章之前，让我们先一起来对“idea properties文件乱码的解决方法”进行全面评估。
我们需要全面地了解Properties文件、乱码问题以及解决方法，以便能够撰写一篇有价值的文章。
让我们深入了解Properties文件。
Properties文件是一种用来存储配置数据的文件，通常以.key=value的键值对形式存在。
在Java开发中，Properties文件被广泛应用于存储应用程序的配置信息，例如数据库连接信息、国际化资源等。
Properties文件通常使用ISO-8859-1编码进行存储。
让我们来探讨乱码问题。
在使用IDEA进行开发时，有时会遇到Properties文件乱码的问题。
这可能是由于文件编码与IDEA的编码设置不匹配，或者文件本身的编码存在问题所致。
乱码问题会导致配置信息无法正确读取，进而影响应用程序的正常运行。
接下来，我们需要仔细研究解决方法。
要解决Properties文件乱码问题，我们可以采取多种方法。
一种常见的解决方法是通过IDEA的设置来修改文件编码，确保其与实际编码相匹配。
我们还可以使用文本编辑器或转码工具来处理乱码问题。
另外，我们也可以以代码方式读取Properties文件，并在读取时指定正确的编码格式。
在文章中，我们需要多次提及“Properties文件乱码的解决方法”，并且以从简到繁、由浅入深的方式来探讨解决问题的方法。
这样读者能够更深入地了解如何解决Properties文件乱码问题。
总结和回顾性的内容也是不可或缺的。
在文章的结尾，我们需要对解决方法进行总结，并回顾所讨论的内容，以便读者能够全面、深刻和灵活地理解解决Properties文件乱码问题的方法。
我也会共享一下我对这个主题的个人观点和理解。
在我看来，理解Properties文件的编码问题并能够有效解决乱码问题，对于Java开发人员来说是非常重要的。
通过深入研究和探讨解决方法，我们能够更好地应对和解决此类问题，提高开发效率和代码质量。
关于系统读取properties配置文件的路径问题，包括打成jar包的运行文件
关于系统读取properties配置⽂件的路径问题，包括打成jar包的运⾏⽂件在当前的⼀个项⽬中，遇到以下业务需要：1.开发环境是在myeclipse⾥运⾏的时候，启动服务后，有⼀个加载配置⽂件属性信息的Global.java。
⽤于得到配置⽂件⾥的配置信息；2.发布系统的时候，需要把系统打成jar执⾏，这时候之前的加载配置⽂件的⽅法就不起作⽤了得不到配置⽂件的路径；3.因在系统刚启动时，需要启动加载⼀个Listener，在Listener⾥⼜加载了⼀个配置⽂件。
4.以上加载配置⽂件，都是只能加载⼀次配置⽂件，当配置⽂件的内容修改后，只能再次重启服务后才能读取到变动的配置内容，系统中有些配置参数是需要时时获取配置⽂件⾥的最新参数信息。
如何在以上场景加载配置⽂件呢，通过来回的找资料、调试，终于搞定。
以下是具体代码：[java]view plaincopy1. package test;2.3. import java.io.FileInputStream;4. import java.io.IOException;5. import java.io.InputStream;6. import java.util.Properties;7.8. import mons.configuration.PropertiesConfiguration;9. import mons.configuration.reloading.FileChangedReloadingStrategy;10. public class Test {11. public static void main(String[] args) throws Exception{12. System.out.println(load1());//通过ClassLoader⽅式加载配置⽂件13. System.out.println(load2());//14.15. }16. /**17. * 通过ClassLoader⽅式加载配置⽂件18. * 这种加载⽅式：19. * 1.可在myeclipse⾥运⾏时得到配置⽂件路径；20. * 2.亦可在把项⽬打成jar包运⾏时，得到配置⽂件路径；21. */22. public static String load1()throws Exception{23. Properties p = new Properties();24. InputStream in = Test.class.getClassLoader().getResourceAsStream("config/config.properties");25. p.load(in);26. return p.getProperty("user_name").toString().trim();27. }28.29. /**30. * ⾃动加载配置⽂件机制，可在修改配置⽂件后，不⽤重启服务也能得到配置⽂件的新内容31. */32. public static String load2()throws Exception{33. String file_name = Test.class.getClassLoader().getResource("config/config.properties").getFile();34. Properties p = new Properties();35. PropertiesConfiguration propconfig =null;//创建⾃动加载的机制36. propconfig = new PropertiesConfiguration();37. propconfig.setEncoding("UTF-8");//设置编码38. propconfig.setReloadingStrategy(new FileChangedReloadingStrategy());//设置⾃动冲加载机制39. p.load(new FileInputStream(file_name));40. return p.getProperty("user_name").toString().trim();//每次调⽤这个⽅法都会从配置⽂件⾥取到最新的参数41. }42. }。
读取properties配置文件中文乱码
读取properties配置⽂件中⽂乱码开发java项⽬时的配置⽂件：配置⽂件位于src同级⽬录（即：将项⽬打包为jar包后，配置⽂件与jar包应放于同⼀⽂件夹中）//配置⽂件编码utf-8//读取配置⽂件中⽂字符不需要重新编码Properties properties=new Properties();String propStr=System.getProperty("user.dir")+"\\office.properties";InputStream url=new FileInputStream(propStr);properties.load(new InputStreamReader(url));//写⼊配置⽂件需要转码properties.store(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(propStr)))), "utf-8");开发Java web项⽬时的配置⽂件：配置⽂件位于src⽬录下//配置⽂件编码utf-8//读取配置⽂件中⽂需要重新编码Properties properties = new Properties();InputStreamReader inStream=new InputStreamReader(BaseDao.class.getClassLoader().getResourceAsStream("dao.properties"),"utf-8");properties.load(inStream);//BaseDao为当前类⼀、加载路径以及乱码问题⼀般配置⽂件放在项⽬结构的src⽬录下，在eclipse开发环境开发Java web项⽬加载该配置⽂件的⽅法为：Properties properties=new Properties();//加载配置⽂件InputStream url=Util.class.getClassLoader().getResourceAsStream("office.properties");properties.load(new InputStreamReader(url));有时候这样的问题在于读取中⽂字符时会乱码（特别是在开发java项⽬的时候）虽然在往配置⽂件中添加数据之前，已经将配置⽂件编码属性修改为utf-8，但是任不可避免的会产⽣乱码问题。
Java程序读取配置文件的几种方法
Java程序读取配置⽂件的⼏种⽅法Java 开发中，需要将⼀些易变的配置参数放置再 XML 配置⽂件或者 properties 配置⽂件中。
然⽽ XML 配置⽂件需要通过 DOM 或 SAX ⽅式解析，⽽读取 properties 配置⽂件就⽐较容易。
1. 读取properties⽂件的⽅法1. 使⽤类加载器ClassLoder类读取配置⽂件InputStream in = MainClass.class.getClassLoader().getResourceAsStream("com/demo/config.properties");MainClass.class是主类的反射对象，因为getClassLoader()是class类的对象⽅法。
在类加载器中调⽤getResourceAsStream()时，采⽤相对路径，起始位置在src⽬录，路径开头没有“/”。
InputStream in = (new MainClass()).getClass().getClassLoader().getResourceAsStream("com/demo/config.properties");因为getClass()是object类的对象⽅法，所有在主类调⽤时要将主类实体化，即new MainClass()。
同理，相对路径起始位置同上。
2. ⽤class对象读取配置⽂件之所以Class对象也可以加载资源⽂件是因为Class类封装的getResourceAsStream⽅法的源码中调⽤了类加载器。
InputStream in = MainClass.class.getResourceAsStream(“/com/demo/config.properties”);同样MainClass.class是主类的反射对象。
在class对象中调⽤getResourceAsStream()时，采⽤绝对路径，起始位置在类路径（bin⽬录），因此路径要以“/”开头。
IntelliJIDEA中properties文件显示乱码问题的解决办法
IntelliJIDEA中properties⽂件显⽰乱码问题的解决办法⾸先，你可能会见到如下提⽰：File encoding is disabled because .properties file (see Settings|Editor|File Encodings|Properties Files)具体如下图。
没截全图，太⼤了，只截取了提⽰部分。
在这之前，我⼀直以为，我已经设置了我这个编辑器下的所有⽂件的编码格式都是utf-8，直到我这次要读取properties⽂件的时候，才惊讶的发现，我的properties⽂件并不都是utf-8的⽂件编码格式。
然后，我就在读取⽂件的时候，当配置⽂件内部有中⽂的时候，就出现了乱码。
然后，我检查了我的idea的默认设置，如下图。
把transparent native-to-ascll conversion勾选上问题就在这⾥了，也许我从svn上down下来的项⽬⾥⾯⾃带的properties⽂件是utf-8的编码格式。
但是，要是我本地⾃⼰⽣成的话，那么⾃⼰⽣成的⽂件编码格式，可就有问题了，他就是我这个系统默认的gbk模式。
在当下开发中，那⾥还有说要使⽤gbk编码这⼀说的，清⼀⾊的都是utf-8的编码格式，所以，这么就是有隐患的。
还好我发现的早啊。
要是⽂件提交了，那领导不就得找我谈话了吗。
最后你把这个默认的设置为utf-8。
就可以了。
或许你电脑上的默认的就是utf-8的呢，（我同事的mac上就默认是这个utf-8），但是我的不是，我的是Windows。
还有就是，Java⽂件的话，可以直接点右下⾓的那个编码格式，选择⾃⼰想要的，⼀般都是utf-8，但是不排除你下载个⽼的代码，他是gbk编码的格式。
但是在properties⽂件⾥⾯，这个却是不能直接点击修改的。
只能如上图那样修改，⽽且是⼀休改之后，整个项⽬的properties ⽂件都变成了utf-8的编码格式啦。
annot read properties of null (reading 'indexof')
annot read properties of null (reading 'indexof') 篇一：标题中的 "annot read properties of null (reading "indexof")" 是指一个 Java 程序在执行时出现的问题。
具体来说，这个程序可能是用注解方式编写的，而且在读取注解时出现了错误。
这个错误通常是由于注解本身存在问题，或者是注解的读取出现了错误导致的。
在 Java 中，注解是一种用于描述程序元素的技术。
例如，可以使用注解来定义注解的属性、作用域、生命周期等。
Java 编译器会将注解转换成对应的字节码，然后在程序运行时进行解析。
然而，如果在注解解析过程中出现了错误，就会导致程序崩溃或者出现类似于 "annot read properties of null (reading "indexof")" 的错误提示。
这个错误提示表明注解的 "indexof" 方法无法找到对应的注解属性。
这可能是由于注解本身存在问题，或者是注解的读取出现了错误导致的。
解决这个错误的方法通常是重新加载注解或者修复注解文件。
如果遇到了类似于 "annot read properties of null (reading "indexof")" 的错误提示，应该先尝试排除注解本身存在的问题，例如检查注解是否有效、是否已经过期等。
如果注解没有问题，再考虑可能是注解的读取出现了错误，需要重新加载或者修复注解文件。
篇二：标题中的 "annot read properties of null (reading "indexof")" 是指一个错误消息，通常出现在使用 JavaScript 引擎时，表示在执行某个操作时无法访问对象的属性。
读写properties配置文件时带上注释
Java使用jdk自带的类操作properties配置文件，特别是更改文件后会把注释全部删掉，再读时会不知道配置是什么意思，下面这个类是我自己写的不删除注释操作properties的类。
import java.io.BufferedWriter;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStreamWriter;import java.io.Reader;import java.io.Writer;import java.util.Date;import java.util.HashMap;import java.util.Iterator;import java.util.LinkedHashMap;import java.util.Map;import java.util.Properties;import java.util.Set;/*** 读取Properties配置文件，同时读出注释。
注释在jdk源方法的LineReader中忽略，* <p>* 此处改造LineReader,并添加存放的变量map* <p>* 同时新加了getPropertyAndComment(key)方法，返回的字符串：如果有注释则为:值#注释，如果无注释，则为:值* <p>* 写入Properties方法是直接从网上下载的方法* @author liuwei* */public class ReadAndWriteProperties extends Properties {/****/private static final long serialVersionUID = 1L;public static void main(String[] args) throws Exception {//写入// ReadAndWriteProperties properties = new ReadAndWriteProperties();// FileOutputStream fileOutputStream = new FileOutputStream(// "D:/test.properties", true);// OutputStreamWriter writer = new OutputStreamWriter(fileOutputStream);// for (int i = 1; i < 10; i++) {// String string = String.valueOf(i);// properties.setP("Name" + string, string, "the name of " + string);// }// properties.orderStore(writer, "This is a test process...");//读取ReadAndWriteProperties props = new ReadAndWriteProperties();File file = new File("E:\\test\\CemsMiddleware.properties");InputStream in = new FileInputStream(file);props.load(in);Set<Object> keySet = props.keySet();Object value = null;for (Object key : keySet) {// value = props.getProperty((String) key);value = props.getPropertyAndComment((String) key);System.out.println(key + ":" + value);}}private LinkedHashMap<String, String> commentMap = new LinkedHashMap<String, String>();//首先是写相关--------------------------------------/*** Constructor.*/public ReadAndWriteProperties() {super();}/*** Constructor.** @param properties* the java propertis.*/public ReadAndWriteProperties(Properties properties) {super(properties);// Initialize the comment.Iterator<Object> iterator = properties.keySet().iterator();while (iterator.hasNext()) {Object key = iterator.next();mentMap.put((String) key, null);}/*** Add comment to a property.** @param key* the key of the property.* @param comment* the comment of the property.* @return true => add it false => don't have this key.*/public boolean addComment(String key, String comment) { if (this.contains(key)) {mentMap.put(key, comment);return true;}return false;}/*** To set property.** @param key* the key of property.配置项名* @param value* the value of property.配置项值* @param comment* the comment of property.注释*/public void setP(String key, String value, String comment) { mentMap.put(key, comment);this.setProperty(key, value);}public void getP(String key, String value, String comment) { mentMap.put(key, comment);this.setProperty(key, value);}/*** To output according to the order of input.* @param writer* the writer* @param comments* the comments of this property file.* @throws IOException* exception.*/public void orderStore(Writer writer, String comments) throws IOException {BufferedWriter bufferedWriter = (writer instanceof BufferedWriter) ? (BufferedWriter) writer: new BufferedWriter(writer);if (comments != null) {ReadAndWriteProperties.writeComments(bufferedWriter, comments);}bufferedWriter.write("#" + new Date().toString());bufferedWriter.newLine();bufferedWriter.newLine();synchronized (this) {Iterator<String> iterator = mentMap.keySet().iterator();while (iterator.hasNext()) {String key = iterator.next();String value = this.getProperty(key);String comment = mentMap.get(key);key = saveConvert(key, true, false);value = saveConvert(value, false, false);key = saveConvert(key, true, false);if (comment != null && !comment.equals("")) {writeComments(bufferedWriter, comment);}bufferedWriter.write(key + "=" + value);bufferedWriter.newLine();bufferedWriter.newLine();}}bufferedWriter.flush();}private String saveConvert(String theString, boolean escapeSpace,boolean escapeUnicode) {int len = theString.length();int bufLen = len * 2;if (bufLen < 0) {bufLen = Integer.MAX_VALUE;}StringBuffer outBuffer = new StringBuffer(bufLen);for (int x = 0; x < len; x++) {char aChar = theString.charAt(x);// Handle common case first, selecting largest block that // avoids the specials belowif ((aChar > 61) && (aChar < 127)) {if (aChar == '\\') {outBuffer.append('\\');outBuffer.append('\\');continue;}outBuffer.append(aChar);continue;}switch (aChar) {case ' ':if (x == 0 || escapeSpace)outBuffer.append('\\');outBuffer.append(' ');break;case '\t':outBuffer.append('\\');outBuffer.append('t');break;case '\n':outBuffer.append('\\');outBuffer.append('n');break;case '\r':outBuffer.append('\\');outBuffer.append('r');break;case '\f':outBuffer.append('\\');outBuffer.append('f');break;case '=': // Fall throughcase ':': // Fall throughcase '#': // Fall throughcase '!':outBuffer.append('\\');outBuffer.append(aChar);break;default:if (((aChar < 0x0020) || (aChar > 0x007e)) & escapeUnicode) {outBuffer.append('\\');outBuffer.append('u');outBuffer.append(toHex((aChar >> 12) & 0xF));outBuffer.append(toHex((aChar >> 8) & 0xF));outBuffer.append(toHex((aChar >> 4) & 0xF));outBuffer.append(toHex(aChar & 0xF));} else {outBuffer.append(aChar);}}}return outBuffer.toString();}/** !!!Copy from java source code.*/private static void writeComments(BufferedWriter bw, String comments) throws IOException {bw.write("#");int len = comments.length();int current = 0;int last = 0;char[] uu = new char[6];uu[0] = '\\';uu[1] = 'u';while (current < len) {char c = comments.charAt(current);if (c > '\u00ff' || c == '\n' || c == '\r') {if (last != current)bw.write(comments.substring(last, current));if (c > '\u00ff') {uu[2] = toHex((c >> 12) & 0xf);uu[3] = toHex((c >> 8) & 0xf);uu[4] = toHex((c >> 4) & 0xf);uu[5] = toHex(c & 0xf);bw.write(new String(uu));} else {bw.newLine();if (c == '\r' && current != len - 1&& comments.charAt(current + 1) == '\n') {current++;}if (current == len - 1|| (comments.charAt(current + 1) != '#' && comments.charAt(current + 1) != '!'))bw.write("#");}last = current + 1;}current++;}if (last != current)bw.write(comments.substring(last, current));bw.newLine();}/** !!! Copy from java source code.*/private static char toHex(int nibble) {return hexDigit[(nibble & 0xF)];}/** A table of hex digits */private static final char[] hexDigit = { '0', '1', '2', '3', '4', '5', '6','7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };// 以下是读相关-----------------------------------------------------Map<String, String> comments = new HashMap<String, String>();public String getPropertyAndComment(String key) {Object oval = super.get(key);String sval = (oval instanceof String) ? (String) oval : null;String coment = comments.get(key);String co = coment == null ? "" : coment;// System.out.println(key+":"+coment);return ((sval == null) && (defaults != null)) ? defaults.getProperty(key) + co : sval + co;}/*** jdk源方法* */public synchronized void load(InputStream inStream) throws IOException { load0(new LineReader(inStream));}/*** jdk源方法,经改造后不忽略注释* */private void load0(LineReader lr) throws IOException {char[] convtBuf = new char[1024];int limit;int keyLen;int valueStart;char c;boolean hasSep;boolean precedingBackslash;String coment = "";while ((limit = lr.readLine()) >= 0) {c = 0;keyLen = 0;valueStart = limit;hasSep = false;precedingBackslash = false;// 注释相关if ('#' == lr.lineBuf[0]) {coment = loadConvert(lr.lineBuf, 0, limit, convtBuf);coment = new String(coment.getBytes("iso8859-1"), "utf-8");// System.out.println(coment);continue;}// System.out.println("line=<" + new String(lineBuf, 0, limit) +// ">");while (keyLen < limit) {c = lr.lineBuf[keyLen];// need check if escaped.if ((c == '=' || c == ':') && !precedingBackslash) {valueStart = keyLen + 1;hasSep = true;break;} else if ((c == ' ' || c == '\t' || c == '\f')&& !precedingBackslash) {valueStart = keyLen + 1;break;}if (c == '\\') {precedingBackslash = !precedingBackslash;} else {precedingBackslash = false;}keyLen++;}while (valueStart < limit) {c = lr.lineBuf[valueStart];if (c != ' ' && c != '\t' && c != '\f') {if (!hasSep && (c == '=' || c == ':')) {hasSep = true;} else {break;}}valueStart++;}String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf);String value = loadConvert(lr.lineBuf, valueStart, limit- valueStart, convtBuf);put(key, value);// 注释相关if (coment != null && coment.length() > 0) {comments.put(key, coment);coment = "";// 重置注释}}}/*** jdk源方法* */private String loadConvert(char[] in, int off, int len, char[] convtBuf) { if (convtBuf.length < len) {int newLen = len * 2;if (newLen < 0) {newLen = Integer.MAX_VALUE;}convtBuf = new char[newLen];}char aChar;char[] out = convtBuf;int outLen = 0;int end = off + len;while (off < end) {aChar = in[off++];if (aChar == '\\') {aChar = in[off++];if (aChar == 'u') {// Read the xxxxint value = 0;for (int i = 0; i < 4; i++) {aChar = in[off++];switch (aChar) {case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':value = (value << 4) + aChar - '0';break;case 'a':case 'b':case 'c':case 'd':case 'e':case 'f':value = (value << 4) + 10 + aChar - 'a';break;case 'A':case 'B':case 'C':case 'D':case 'E':case 'F':value = (value << 4) + 10 + aChar - 'A';break;default:throw new IllegalArgumentException("Malformed \\uxxxx encoding.");}}out[outLen++] = (char) value;} else {if (aChar == 't')aChar = '\t';else if (aChar == 'r')aChar = '\r';else if (aChar == 'n')aChar = '\n';else if (aChar == 'f')aChar = '\f';out[outLen++] = aChar;}} else {out[outLen++] = aChar;}}return new String(out, 0, outLen);}class LineReader {/*** jdk源方法* */public LineReader(InputStream inStream) {this.inStream = inStream;inByteBuf = new byte[8192];}/*** jdk源方法* */public LineReader(Reader reader) {this.reader = reader;inCharBuf = new char[8192];}byte[] inByteBuf;char[] inCharBuf;char[] lineBuf = new char[1024];int inLimit = 0;int inOff = 0;InputStream inStream;Reader reader;/*** jdk源方法,但经过改造，不再忽略注释* */int readLine() throws IOException {int len = 0;char c = 0;boolean skipWhiteSpace = true;boolean isCommentLine = false;boolean isNewLine = true;boolean appendedLineBegin = false;boolean precedingBackslash = false;boolean skipLF = false;while (true) {if (inOff >= inLimit) {inLimit = (inStream == null) ? reader.read(inCharBuf): inStream.read(inByteBuf);inOff = 0;if (inLimit <= 0) {if (len == 0 || isCommentLine) {return -1;}return len;}}if (inStream != null) {// The line below is equivalent to calling a// ISO8859-1 decoder.c = (char) (0xff & inByteBuf[inOff++]);} else {c = inCharBuf[inOff++];}if (skipLF) {skipLF = false;if (c == '\n') {continue;}}if (skipWhiteSpace) {if (c == ' ' || c == '\t' || c == '\f') {continue;}if (!appendedLineBegin && (c == '\r' || c == '\n')) {continue;}skipWhiteSpace = false;appendedLineBegin = false;}if (isNewLine) {isNewLine = false;if (c == '#' || c == '!') {// isCommentLine = true;// continue;}}if (c != '\n' && c != '\r') {lineBuf[len++] = c;if (len == lineBuf.length) {int newLength = lineBuf.length * 2;if (newLength < 0) {newLength = Integer.MAX_VALUE;}char[] buf = new char[newLength];System.arraycopy(lineBuf, 0, buf, 0, lineBuf.length);lineBuf = buf;}// flip the preceding backslash flagif (c == '\\') {precedingBackslash = !precedingBackslash;} else {precedingBackslash = false;}} else {// reached EOLif (isCommentLine || len == 0) {isCommentLine = false;isNewLine = true;skipWhiteSpace = true;len = 0;continue;}if (inOff >= inLimit) {inLimit = (inStream == null) ? reader.read(inCharBuf): inStream.read(inByteBuf);inOff = 0;if (inLimit <= 0) {return len;}}if (precedingBackslash) {len -= 1;// skip the leading whitespace characters in following// lineskipWhiteSpace = true;appendedLineBegin = true;precedingBackslash = false;if (c == '\r') {skipLF = true;}} else {return len;}}}}}}。
浅谈Java工程读取resources中资源文件路径的问题
浅谈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中资源⽂件路径的问题就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
(1)这种方式要求 Properties资源文件必须与当前类文件在同一个包下(同文件夹下) ，如果不在则会报空指针异常，如果不在同一个包(文件夹)下可以使用，如果方
式：
InputStream in = this.getClass().getResourceAsStream("/testcase/test.txt");
保 险 起见，就是这个类的本身名字来直接获取Class对象，如果我这个类为PropertiesUtil.java，可以使用如下方式获取：
PropertiesUtil.class.getClassLoader().getResourceAsStream("/testcase/test.txt")；
2.使用Class.getClassLoader（）的getResourceAsStream（）读取Properties文件（资源文件）的路径问题：
InputStream in = ().getResourceAsStream("testcase/test.txt");
Java 读取Properties文件时应注意的路径问题
1. 使用Class的getResourceAsStream（）方法读取Properties文件（资源文件）的路径问题：
InputStream in = this.getClass().getResourceAsStream("资源Name");
注意：
(1)使用getClassLoader()获取的是classpath路径；
(2)虽然也可以使用Object.class.getClassLoader().getResourceAsStream("/testcase/test.txt")来获取资源文件，但是如果在Web项目中的话，会得到一个Null值，所以
或
InputStream in = PropertiesUtil.class.getResourceAsStream("/testcase/test.txt");
(2)获取获取当前类所在的包路径：
String packagePath = this.getClass().getResource("").getPath();