Java加载properties文件的六种方法
java读取properties
at com.liuchen.getProperties.<clinit>(getProperties.java:16)
Exception in thread "main"
似乎config.load(in);这里的in是null,但有文件啊,这是怎么回事?谢谢!问题补充:
已经放在src目录了,但还是报那个错的
}
}
public static void main(String args[]) {
// String LaSaPhone=config.getProperty("LaSaPhone");
// System.out.println(LaSaPhone);
// System.out.println(getPhone.readValue("LaSaPhone"));
java读取properties文件
public class getProperties {
private static Properties config = null;
static {
InputStream in = getProperties.class.getClassLoader().getResourceAsStream(
"config.properties");
这一句换个写法试试:
Properties props = new Properties();
String url = this.getClass().getClassLoader().getResource(
Properties读取
java读取 .properties配置文件的几种方法java中的properties文件是一种配置文件,主要用于表达配置信息,文件类型为*.properties,格式为文本文件,文件的内容是格式是 "键=值"的格式,在properties文件中,可以用"#"来作注释,properties文件在Java编程中用到的地方很多,操作很方便。
JDK中的Properties类存在于胞Java.util中,该类继承自Hashtable,它提供了几个主要的方法:1.getProperty(String key) 用指定的键在此属性列表中搜索属性。
也就是通过参数key ,得到key 所对应的value;2.load(InputStream inStream) 从输入流中读取属性列表(键和元素对)。
通过对指定的文件(如test.properties文件)进行装载来获取该文件中的所有键 - 值对。
以供getProperty(String key)来搜索。
3.setProperty(String key,String value),调用Hashtable的方法put。
他通过调用基类的put方法来设值键 - 值对。
4.store(OutputStream out,String comments),以适合使用load方法加载到Properties表中的格式,将此Properties表中的属性列表(键和元素对)写入输出流。
与load()方法相反,该方法将键 - 值对写入到指定的文件中去。
5.clear(),清除所有装载的键 - 值对。
该方法在基类中提供。
方式一使用java.util.Properties类的load()方法关键代码如下:try{// 创建Properties对象Properties p = new Properties();// 设置读取文件路径String s_xmlpath="config.properties";InputStream io=Test.class.getClassLoader().getResourceAsStream(s_xmlpath);// 加载文件p.load(io);// 取得文件的值system.out.println(p.getProperty("key"));// 关闭流io.close();}catch(Exception ex){ex.printStackTrace();}该方法可放到Servlet中,在工程初期化时一次性加载配置文件,具体代码如下:import java.io.IOException;import java.io.InputStream;import java.io.PrintWriter;import java.util.Properties;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class Test extends HttpServlet {public static Properties p;private static Test instance = null;/*** Constructor of the object.* 默认构造方法*/public Test() {super();}/*** Constructor of the object.* 私有构造方法,调用init()方法读取配置文件*/private Test(String str) {super();try {this.init();} catch (ServletException e) {e.printStackTrace();}/*** 静态方法,取得对象实例* @return*/public static Test getInstance(){// 当前实例为空时if(instance == null){instance = new Test("");}return instance;}/*** Destruction of the servlet. <br>*/public void destroy() {super.destroy(); // Just puts "destroy" string in log// Put your code here}/*** The doGet method of the servlet. <br>* This method is called when a form has its tag value method equals to get.*/public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {……}/*** The doPost method of the servlet. <br>* This method is called when a form has its tag value method equals to post.*/public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {……}/*** Initialization of the servlet. <br>* @throws ServletException if an error occurs*/public void init() throws ServletException {try{// 创建Properties对象p = new Properties();// 设置读取文件路径String s_xmlpath="sql.properties";InputStream io=Test.class.getClassLoader().getResourceAsStream(s_xmlpath);// 加载文件p.load(io);// 关闭流io.close();}catch(Exception ex){ex.printStackTrace();}}}在工程的web.xml文件中添加以下配置:<description>This is the description of my J2EE component</description><display-name>This is the display name of my J2EE component</display-name><servlet-name>Test</servlet-name><servlet-class>com.Test</servlet-class><load-on-startup>1</load-on-startup></servlet>经过以上配置,可以通过Test类的静态属性读取配置文件中的值。
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中轻松获取配置文件中的参数值了。
JAVAProperties配置文件的读写
JAVAProperties配置⽂件的读写 通常我们就会看到⼀个配置⽂件,⽐如:jdbc.properties,它是以“.properties”格式结尾的。
在java中,这种⽂件的内容以键值对<key,value>存储,通常以“=”分隔key和value,当然也可以⽤":"来分隔,但通常不这么⼲。
读取配置⽂件 这⾥有⼀个⽂件叫asfds.properties,⾥⾯简单的存了两个键值对,如下图所⽰: 读取配置⽂件的基本步骤是:1. 实例化⼀个Properties对象;2. 将要读取的⽂件放⼊数据流中;3. 调⽤Properties对象的load⽅法,将属性⽂件的键值对加载到Properties类对象中;4. 调⽤Properties对象的getProperty(String key)读⼊对应key的value值。
注:如果想要读取key值,可以调⽤Properties对象的stringPropertyNames()⽅法获取⼀个set集合,然后遍历set集合即可。
读取配置⽂件的⽅法: 1/**2 * read properties file3 * @param paramFile file path4 * @throws Exception5*/6public static void inputFile(String paramFile) throws Exception7 {8 Properties props=new Properties();//使⽤Properties类来加载属性⽂件9 FileInputStream iFile = new FileInputStream(paramFile);10 props.load(iFile);1112/**begin*******直接遍历⽂件key值获取*******begin*/13 Iterator<String> iterator = props.stringPropertyNames().iterator();14while (iterator.hasNext()){15 String key = iterator.next();16 System.out.println(key+":"+props.getProperty(key));17 }18/**end*******直接遍历⽂件key值获取*******end*/1920/**begin*******在知道Key值的情况下,直接getProperty即可获取*******begin*/21 String user=props.getProperty("user");22 String pass=props.getProperty("pass");23 System.out.println("\n"+user+"\n"+pass);24/**end*******在知道Key值的情况下,直接getProperty即可获取*******end*/25 iFile.close();2627 }写⼊配置⽂件 写⼊配置⽂件的基本步骤是:1. 实例化⼀个Properties对象;2. 获取⼀个⽂件输出流对象(FileOutputStream);3. 调⽤Properties对象的setProperty(String key,String value)⽅法设置要存⼊的键值对放⼊⽂件输出流中;4. 调⽤Properties对象的store(OutputStream out,String comments)⽅法保存,comments参数是注释; 写⼊配置⽂件的⽅法:1/**2 *write properties file3 * @param paramFile file path4 * @throws IOException5*/6private static void outputFile(String paramFile) throws IOException {7///保存属性到b.properties⽂件8 Properties props=new Properties();9 FileOutputStream oFile = new FileOutputStream(paramFile, true);//true表⽰追加打开10 props.setProperty("testKey", "value");11//store(OutputStream,comments):store(输出流,注释) 注释可以通过“\n”来换⾏12 props.store(oFile, "The New properties file Annotations"+"\n"+"Test For Save!");13 oFile.close();14 }测试输出 ⽂件读取: @Testpublic void testInputFile(){//read properties filetry {inputFile("resources/asfds.properties");} catch (Exception e) {e.printStackTrace();}} 输出: ⽂件写⼊:@Testpublic void testOutputFile(){//write properties filetry {outputFile("resources/test.properties");} catch (Exception e) {e.printStackTrace();}} 写⼊的⽂件:。
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⽬录),因此路径要以“/”开头。
五种方式让你在java中读取properties文件内容不再是难题
五种⽅式让你在java中读取properties⽂件内容不再是难题 最近,在项⽬开发的过程中,遇到需要在properties⽂件中定义⼀些⾃定义的变量,以供java程序动态的读取,修改变量,不再需要修改代码的问题。
就借此机会把Spring+SpringMVC+Mybatis整合开发的项⽬中通过java程序读取properties⽂件内容的⽅式进⾏了梳理和分析,现和⼤家共享。
Spring 4.2.6.RELEASESpringMvc 4.2.6.RELEASEMybatis 3.2.8Maven 3.3.9Jdk 1.7Idea 15.04⽅式1.通过context:property-placeholder加载配置⽂件jdbc.properties中的内容<context:property-placeholder location="classpath:jdbc.properties" ignore-unresolvable="true"/> 上⾯的配置和下⾯配置等价,是对下⾯配置的简化<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="ignoreUnresolvablePlaceholders" value="true"/><property name="locations"><list><value>classpath:jdbc.properties</value></list></property></bean>注意:这种⽅式下,如果你在spring-mvc.xml⽂件中有如下配置,则⼀定不能缺少下⾯的红⾊部分,关于它的作⽤以及原理,参见另⼀篇博客:<!-- 配置组件扫描,springmvc容器中只扫描Controller注解 --><context:component-scan base-package="com.hafiz.www" use-default-filters="false"><context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/></context:component-scan>⽅式2.使⽤注解的⽅式注⼊,主要⽤在java代码中使⽤注解注⼊properties⽂件中相应的value值<bean id="prop" class="org.springframework.beans.factory.config.PropertiesFactoryBean"><!-- 这⾥是PropertiesFactoryBean类,它也有个locations属性,也是接收⼀个数组,跟上⾯⼀样 --><property name="locations"><array><value>classpath:jdbc.properties</value></array></property></bean>⽅式3.使⽤util:properties标签进⾏暴露properties⽂件中的内容<util:properties id="propertiesReader" location="classpath:jdbc.properties"/>注意:使⽤上⾯这⾏配置,需要在spring-dao.xml⽂件的头部声明以下红⾊的部分<beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:util="/schema/util"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.2.xsd/schema/context/schema/context/spring-context-3.2.xsd/schema/util /schema/util/spring-util.xsd">⽅式4.通过PropertyPlaceholderConfigurer在加载上下⽂的时候暴露properties到⾃定义⼦类的属性中以供程序中使⽤<bean id="propertyConfigurer" class="com.hafiz.www.util.PropertyConfigurer"><property name="ignoreUnresolvablePlaceholders" value="true"/><property name="ignoreResourceNotFound" value="true"/><property name="locations"><list><value>classpath:jdbc.properties</value></list></property></bean>⾃定义类PropertyConfigurer的声明如下:package com.hafiz.www.util;import org.springframework.beans.BeansException;import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;import java.util.Properties;/*** Desc:properties配置⽂件读取类* Created by hafiz.zhang on 2016/9/14.*/public class PropertyConfigurer extends PropertyPlaceholderConfigurer {private Properties props; // 存取properties配置⽂件key-value结果@Overrideprotected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)throws BeansException {super.processProperties(beanFactoryToProcess, props);this.props = props;}public String getProperty(String key){return this.props.getProperty(key);}public String getProperty(String key, String defaultValue) {return this.props.getProperty(key, defaultValue);}public Object setProperty(String key, String value) {return this.props.setProperty(key, value);}}使⽤⽅式:在需要使⽤的类中使⽤@Autowired注解注⼊即可。
Java获取properties的几种方式
Java获取properties的⼏种⽅式⽬录第1种:直接在spring的xml中使⽤第2种:在java 启动加Conifg库中或者在controller中调⽤第3种:不要在spring.xml中引⽤commonConfig.properties,在类注⼊时引⽤,然后使⽤Environment获取它的值第4种:不需要借⽤spring,直接在类中读取.但要注意:(redisson.properties配置⽂件中不能有.句号),否则将报错spring下获取Properties⽅式⽐如已有的commonConfig.propertiesmain.db.driverClassName=com.mysql.jdbc.Drivermain.db.url=jdbc\:mysql\://\:3306/huagang?useUnicode\=true&characterEncoding\=UTF-8&zeroDateTimeBehavior\=convertToNullername=huagangmain.db.password=xxxHGtest在spring中引⽤commonConfig.properties第1种:直接在spring的xml中使⽤<!-- 加载配置⽂件 --><bean id="propertyConfig" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="location"><value>classpath:/resources/config/commonConfig.properties</value></property></bean> <!--或者引⼊多配置⽂件<context:property-placeholder location="classpath:/resources/config/commonConfig.properties,classpath:XXX.properties"/> --><!-- 配置数据源 --><bean id="ajbDataSource" class="boPooledDataSource" destroy-method="close"><!--驱动类 --><property name="driverClass"><value>${main.db.driverClassName}</value></property><!--url连接串 --><property name="jdbcUrl"><value>${main.db.url}</value></property><!--⽤户名 --><property name="user"><value>${ername}</value></property><!--密码 --><property name="password"><value>${main.db.password}</value></property><!-- 连接池中保留的最⼩连接数最⼩链接数 --><property name="minPoolSize"><value>1</value></property><!--连接池中保留的最⼤连接数最⼤连接数 --><property name="maxPoolSize"><value>4</value></property><!-- 最⼤空闲的时间,单位是秒,⽆⽤的链接再过时后会被回收 --><property name="maxIdleTime"><value>1800</value></property><!-- 在当前连接数耗尽的时候,⼀次获取的新的连接数 --><property name="acquireIncrement"><value>1</value></property><!--JDBC的标准参数,⽤以控制数据源内加载的PreparedStatements数量。
properties类的load方法
properties类的load方法
Properties 类的load方法是指 Java 提供的一个方法,用于读取属性文件并将内容加载到 Properties 对象中,以便更方便的处理和读取数据。
1、load方法能够加载属性文件中文件的性质,它只能将文件加载到 Properties 对象中,无法将复杂的文件结构读取到 Properties 对象中;
2、load方法支持三种文件格式,分别是.txt、.ini、.xml,文件内容可以是普通字符文本文件;
3、load方法在加载属性文件时,会将文件中的内容转换为键值对,方便后续通过键值对中的key获取指定的属性值;
4、使用load方法加载的属性文件是不能修改的,因此,2015.10.27只能被用来读取属性文件的内容,不能用于修改和更新属性文件的内容;
5、load方法可以从文件、流中加载属性文件,也可以从应用程序中加载,通过输入字符串数组等方式加载;
6、load方法是一种不太推荐使用的方法,它只是 Properties 的一个静态函数,它本身在多线程环境中并不安全;
7、Properties 类的load方法的作用是:属性文件的信息由键值组成,load方法可以将这种格式的文件加载到 Properties 对象中,以将文件的内容读取出来,从而可以根据键名获取该键对应的值。
properties文件java用法
【主题】properties文件java用法介绍在Java开发中,properties文件是一种常见的配置文件格式,它通常用来存储键值对的配置信息。
在本文中,我将深入探讨properties文件在Java中的用法,包括读取、写入、使用和常见问题的解决方法。
通过本文的学习,你将能够全面了解properties文件在Java开发中的重要性和灵活性。
1. properties文件的基本概念在Java中,properties文件是一种简单的配置文件,通常以.key=value的形式存储配置信息。
它可以被用于各种用途,如国际化、设置参数、环境配置等。
在Java中,我们可以使用java.util.Properties类来操作properties文件,包括读取、写入和修改。
2. properties文件的读取与写入在Java中,我们可以使用Properties类的load和store方法来读取和写入properties文件。
通过load方法,我们可以将properties 文件中的配置信息加载到Properties对象中;而通过store方法,我们可以将Properties对象中的配置信息写入到properties文件中。
这种简单而直观的读取与写入方式使得properties文件在Java中被广泛应用。
3. properties文件的使用在Java开发中,properties文件可以用于各种情境。
我们可以将数据库的连接信息、系统的参数配置、界面的文本信息等存储在properties文件中,从而实现配置与代码的分离,方便后期的维护和修改。
在国际化开发中,properties文件也扮演着重要的角色,我们可以通过不同的properties文件实现不同语言环境下的文本切换。
4. 常见问题及解决方法在使用properties文件的过程中,我们常常会遇到各种问题。
如何处理中文乱码问题、如何实现动态更新properties文件、如何处理properties文件中的注释等。
java如何读取properties文件
java如何读取properties⽂件1.情景展⽰ 将要访问的接⼝地址等常⽤的配置添加到properties⽂件中,⽐直接写到java类中的好处在于: 当我们需要修改相应配置时,直接修改properties⽂件,重启tomcat即可,避免了重新编译引⽤该配置的java⽂件,同时,也便于项⽬的维护。
⽅式⼀ 通过spring的⼯具类PropertiesLoaderUtils来实现对properties⽂件的解析 所需jar包:spring的核⼼jar包,spring-core-版本号.jarimport java.io.IOException;import java.util.HashMap;import java.util.Map;import java.util.Properties;import org.springframework.core.io.support.PropertiesLoaderUtils;/*** 借助spring读取Properties⽂件* @explain Spring 提供的 PropertiesLoaderUtils* 允许您直接通过基于类路径的⽂件地址加载属性资源最⼤的好处就是:实时加载配置⽂件,修改后⽴即⽣效,不必重启* @author Marydon* @creationTime 2018年5⽉23⽇上午9:58:59* @version 1.0* @since* @email marydon20170307@*/public class PropertiesUtils {/*** 读取properties⽂件* @param fileName properties⽂件名及所在路径* @explain 参数说明* 1.传递的参数不是properties类型⽂件,不会报错,返回的是空Map;* 2.传递的参数是根本不存在的properties⽂件,也不会报错,返回的是空Map;* 3.传递的参数可以带路径,可以正常解析到* @return*/public static Map<String, String> readProperties(String fileName) {Map<String, String> resultMap = new HashMap<String, String>();try {Properties props = PropertiesLoaderUtils.loadAllProperties(fileName);for (Object key : props.keySet()) {resultMap.put(key.toString(), props.get(key).toString());}} catch (IOException e) {e.printStackTrace();}return resultMap;}/*** @param args*/public static void main(String[] args) {// Map map = readProperties("base/web/imageInfo/fileRootDirectories.properties");Map map = readProperties("fileRootDirectories.properties");for (Object key : map.keySet()) {System.out.println(key.toString() + "=" + map.get(key).toString());}// 打印结果// fileRootPath=uploadFiles}} 这种⽅式的缺点在于: 每次调⽤都要重新解析对应的properties⽂件,所以,我们可以在项⽬启动的时候,就把该⽂件加载到内存中(⼀次加载解析,永久使⽤)。
java读取properties文件的几种方法
java读取properties⽂件的⼏种⽅法⼀、项⽬中经常会需要读取配置⽂件(properties⽂件),因此读取⽅法总结如下:1、通过java.util.Properties读取1 Properties p=new Properties();2//p需要InputStream对象进⾏读取⽂件,⽽获取InputStream有多种⽅法:3//1、通过绝对路径:InputStream is=new FileInputStream(filePath);4//2、通过Class.getResourceAsStream(path);5//3、通过ClassLoader.getResourceAsStream(path);6 p.load(InputStream is);7 is.close();8 p.getString(String(key))2、通过java.util.ResourceBundle读取ResourceBundle rb=ResourceBundle.getBundle(packageName);rb.getString(String key);⼆、Class.getResourceAsStream与ClassLoader.getResourceAsStream的区别⾸先,Java中的getResourceAsStream有以下⼏种:1. Class.getResourceAsStream(String path) : path 不以’/'开头时默认是从此类所在的包下取资源,以’/'开头则是从ClassPath根下获取。
其只是通过path构造⼀个绝对路径,最终还是由 ClassLoader获取资源。
2. Class.getClassLoader.getResourceAsStream(String path) :默认则是从ClassPath根下获取,path不能以’/'开头,最终是由ClassLoader 获取资源。
Java读取.properties配置文件的几种方式
Java读取.properties配置⽂件的⼏种⽅式Java 开发中,需要将⼀些易变的配置参数放置再 XML 配置⽂件或者 properties 配置⽂件中。
然⽽ XML 配置⽂件需要通过DOM 或 SAX ⽅式解析,⽽读取 properties 配置⽂件就⽐较容易。
介绍⼏种读取⽅式:1、基于ClassLoder读取配置⽂件注意:该⽅式只能读取类路径下的配置⽂件,有局限但是如果配置⽂件在类路径下⽐较⽅便。
Properties properties = new Properties();// 使⽤ClassLoader加载properties配置⽂件⽣成对应的输⼊流InputStream in = PropertiesMain.class.getClassLoader().getResourceAsStream("config/config.properties");// 使⽤properties对象加载输⼊流properties.load(in);//获取key对应的value值properties.getProperty(String key);2、基于 InputStream 读取配置⽂件注意:该⽅式的优点在于可以读取任意路径下的配置⽂件Properties properties = new Properties();// 使⽤InPutStream流读取properties⽂件BufferedReader bufferedReader = new BufferedReader(new FileReader("E:/config.properties"));properties.load(bufferedReader);// 获取key对应的value值properties.getProperty(String key);3、通过 java.util.ResourceBundle 类来读取,这种⽅式⽐使⽤ Properties 要⽅便⼀些1>通过 ResourceBundle.getBundle() 静态⽅法来获取(ResourceBundle是⼀个抽象类),这种⽅式来获取properties属性⽂件不需要加.properties后缀名,只需要⽂件名即可 properties.getProperty(String key);//config为属性⽂件名,放在包com.test.config下,如果是放在src下,直接⽤config即可ResourceBundle resource = ResourceBundle.getBundle("com/test/config/config");String key = resource.getString("keyWord");2>从 InputStream 中读取,获取 InputStream 的⽅法和上⾯⼀样,不再赘述ResourceBundle resource = new PropertyResourceBundle(inStream);注意:在使⽤中遇到的最⼤的问题可能是配置⽂件的路径问题,如果配置⽂件⼊在当前类所在的包下,那么需要使⽤包名限定,如:config.properties⼊在com.test.config包下,则要使⽤com/test/config/config.properties(通过Properties来获取)或com/test/config/config(通过ResourceBundle来获取);属性⽂件在src根⽬录下,则直接使⽤config.properties或config即可。
Java在Web项目中读取properties文件
56
{
57
inputStream.close();
58
}
59
}
60
catch (IOException e)
61
{
62
e.printStackTrace();
63
}
64
}
65
return properties;
66 }
67
68 /**
69 * 获得数据源
70 *
71 * @return
72 */
73 public static DataSource getDataSource()
74 {
75
return ds;
76 }
77
78 public static void closeConnection() throws SQLException
79 {
80
if (ds != null && ds.getConnection() != null && !ds.getConnection().isClosed())
InputStream inputStream = null;
36
Properties properties = null;
37
try
38
{
39
inputStream = JDBCUtils.class.getClassLoader().getResourceAsStream(fileName);
40
29 {
30
if (null == fileName || fileName.equals(""))
JAVA读取PROPERTIES文件方式一
JAVA读取PROPERTIES⽂件⽅式⼀ 1import java.io.BufferedReader;2import java.io.IOException;3import java.io.InputStream;4import java.io.InputStreamReader;5import java.util.Properties;67import mons.logging.Log;8import mons.logging.LogFactory;910/**11 * 配置⽂件读取⼯具12*/13public class ConfigurableConstants14 {1516protected static final String PROPERTIES_PATH = "config.properties";1718protected static Log logger = LogFactory.getLog(ConfigurableConstants.class);19protected static Properties p = new Properties();20static21 {22 init(PROPERTIES_PATH);23 }2425/**26 * 静态读⼊属性⽂件到Properties p变量中27*/28protected static void init(String propertyFileName)29 {30 InputStream in = null;31try32 {33// class.getClassLoader()获得该class⽂件加载的web应⽤的⽬录,如WEB-INF/classes/就是根⽬录34// getResourceAsStream(relativeFilePath):定位该⽂件且获得它的输出流35 in = ConfigurableConstants.class.getClassLoader().getResourceAsStream(propertyFileName);36 BufferedReader bf = null;37if (in != null)38// load输出流到Properties对象中39// 因为字节流是⽆法读取中⽂的,所以采取reader把inputStream转换成reader⽤字符流来读取中⽂。
Java读取Properties文件的六种方法
返回rb.getLocale();
}
公共对象的GetObject(String键){
返回rb.getObject(关键);
}
公共字符串的getString(String键){
返回rb.getString(关键);
}
名称=“\ \的COM \ \ kindani \ \测试\ \ LocalStrings.properties”;
P值JProperties.loadProperties(姓名,JProperties.BY_SYSTEM_CLASSLOADER);
Properties p = new Properties();
InputStream in = null;
if (type == BY_PROPERTIES) {
in = new BufferedInputStream(new FileInputStream(name));
}否则如果(类型== BY_CLASSLOADER){
断言(JProperties.class.getClassLoader()。等于(新JProperties()。的getClass()。getClassLoader ()));
。在= JProperties.class.getClassLoader()getResourceAsStream(姓名);
assert (in != null);
ResourceBundle rb = new PropertyResourceBundle(in);
p = new ResourceBundleAdapter(rb);
} else if (type == BY_CLASS) {
Java读取、获取配置文件.properties中的数据
Java读取、获取配置⽂件.properties中的数据java获取配置⽂件.properties中的数据,具体内容如下所⽰:⽅法太多,只写⼀种⽐较简单的。
⽂件test1.properties内容test1 = 123;test2=3211Properties prop = new Properties();prop.load(new FileInputStream("src/test1.properties"));System.out.println(prop.get("test1"));输出123;1简单封装⼀下,完整代码package propertis.test;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.util.Properties;public class Test {/*** @param args* @throws IOException* @throws FileNotFoundException*/public static void main(String[] args) throws FileNotFoundException, IOException {// TODO Auto-generated method stubProperties prop = new Properties();prop.load(new FileInputStream("src/test1.properties"));System.out.println(prop.get("test1"));System.out.println(ProUtil.getTest1Value("test1"));System.out.println(ProUtil.getTest1Value("test2"));}}class ProUtil{private static Properties prop = new Properties();static{try {prop.load(new FileInputStream("src/test1.properties"));} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}public static Object getTest1Value(String key){return prop.get(key);}}输出123;123;321下⾯看下Java 读取Properties配置⽂件⽅法:Properties properties = new Properties();FileInputStream in = new FileInputStream("**.properties");properties.load(in);in.close();配置⽂件:driver=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8username=rootpassword=代码实现:import java.io.FileInputStream;import java.util.Properties;public class PropertiesTest {private static final String PROPERTIES_NAME = "db.properties";public static String DB_DRIVER = null;public static String DB_URL = null;public static String DB_USER = null;public static String DB_PWD = null;static{FileInputStream in = null;try{Properties properties = new Properties();in = new FileInputStream(PROPERTIES_NAME);properties.load(in);DB_DRIVER = properties.getProperty("driver");DB_URL = properties.getProperty("url");DB_USER = properties.getProperty("username");DB_PWD = properties.getProperty("passworld");System.out.println("读取配置信息成功!");showConfig();}catch(Exception e){e.printStackTrace();System.out.println("读取配置信息失败!");}finally{if(in != null){try{in.close();}catch(Exception e){e.printStackTrace();}}}}private static void showConfig(){System.out.println("-----------------------配置信息-----------------");System.out.println("dirver: "+DB_DRIVER);System.out.println("url: "+DB_URL);System.out.println("user: "+DB_USER);System.out.println("passworld: "+DB_PWD);System.out.println("----------------------------------------------");}public static void main(String[] args){}}运⾏结果:读取配置信息成功!-----------------------配置信息-----------------dirver: com.mysql.jdbc.Driverurl: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8user: rootpassworld: null----------------------------------------------总结以上所述是⼩编给⼤家介绍的Java 读取、获取配置⽂件.properties中的数据,希望对⼤家有所帮助,如果⼤家有任何疑问请给我留⾔,⼩编会及时回复⼤家的。
读取properties配置文件的方法
读取properties配置文件的方法读取properties配置文件的方法有多种,下面列举两种常见的方法:方法一:使用Java的Properties类1. 创建一个Properties对象2. 使用load()方法加载配置文件3. 使用getProperty()方法获取配置项的值示例代码如下:```import java.io.FileInputStream;import java.util.Properties;public class ReadPropertiesFile {public static void main(String[] args) {try {//创建一个Properties对象Properties properties = new Properties();//加载配置文件FileInputStream file = newFileInputStream("config.properties");properties.load(file);//获取配置项的值String value = properties.getProperty("key");System.out.println("Value: " + value);file.close();} catch (Exception e) {e.printStackTrace();}}}```方法二:使用Spring的PropertyPlaceholderConfigurer类1. 在Spring配置文件中引入PropertyPlaceholderConfigurer类2. 配置properties文件的位置和文件名3. 使用${key}的形式获取配置项的值示例代码如下:```importorg.springframework.beans.factory.config.PropertyPlaceholderCon figurer;importorg.springframework.context.support.ClassPathXmlApplicationCo ntext;public class ReadPropertiesFile {public static void main(String[] args) {try (ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml")) { //获取配置项的值String value =context.getEnvironment().getProperty("key");System.out.println("Value: " + value);} catch (Exception e) {e.printStackTrace();}}}```注意:需要将配置文件(config.properties)放置在项目的根目录或者resources目录下。
java对properties文件的操作
对properties文件的操作
1. 资源文件所存放的位置
资源文件妨碍classpath下,即工程项目的class包下
2. 获取系统资源文件的方式有2中
a. 通过 InputStream inputstream =
ClassLoader.getSystemResourceAsStream("info.properties");
b. 通过 InputStream inputstream =
this.getClass().getResourceAsStream("/info.properties");
采用第一种方式获取资源文件时,文件不以"/" 开头,而采用方法b的话,文件必须"/"开头
3. 提取加载资源文件的信息
Java代码
4. 操作资源文件
a. 根据key值在资源文件中查询value值
1. getProperty(String key) 用指定的键在此属性列表中搜索属性。
2. getProperty(String key, String defaultValue) 用指定的键在属性列表中搜索属性。
b. 获取所有的键值对的信息
c. 向资源文件中添加键值信息,如果key值相同就会将原有的信息覆盖Java代码
d. 删除相关的键值对
Java代码。
properties类的方法
properties类的方法properties类是Java中常用的一个类,它提供了一系列方法用于操作和管理属性文件。
在本文中,我们将介绍一些常用的properties类的方法,包括getProperty、setProperty、load和store等。
一、getProperty方法getProperty方法用于获取属性文件中指定键对应的值。
它的语法如下:String getProperty(String key)该方法接收一个键值作为参数,返回该键对应的值。
如果属性文件中不存在该键,则返回null。
二、setProperty方法setProperty方法用于设置属性文件中指定键的值。
它的语法如下:Object setProperty(String key, String value)该方法接收两个参数,分别是键和值。
它会将指定键的值设置为给定的值,并返回之前的值。
如果属性文件中不存在该键,则会创建一个新的键值对。
三、load方法load方法用于从输入流中加载属性列表。
它的语法如下:void load(InputStream inStream)该方法接收一个输入流作为参数,将输入流中的属性列表加载到properties对象中。
属性列表的格式为键值对的形式,每个键值对占一行,以等号分隔。
四、store方法store方法用于将属性列表存储到输出流中。
它的语法如下:void store(OutputStream out, String comments)该方法接收两个参数,一个是输出流,用于指定存储的目标位置;另一个是注释,用于在存储的属性列表前添加一行注释。
五、其它方法除了上述常用的方法外,properties类还提供了一些其它方法,如getPropertyOrDefault、put、remove等。
getPropertyOrDefault方法用于获取指定键的值,如果不存在则返回默认值;put方法用于添加或修改键值对;remove方法用于删除指定键对应的键值对。
java读取properties文件总结
java读取properties文件总结一、java读取properties文件总结在java项目中,操作properties文件是经常要做的,因为很多的配置信息都会写在properties文件中,这里主要是总结使用getResourceAsStream方法和InputStream流去读取properties文件,使用getResourceAsStream方法去读取properties文件时需要特别注意properties文件路径的写法,测试项目如下:1.1.项目的目录结构1.2. java读取properties文件代码测试复制代码/* 范例名称:java读取properties文件总结* 源文件名称:PropertiesFileReadTest.java* 要点:* 1. 使用getResourceAsStream方法读取properties文件* 2. 使用InPutStream流读取properties文件* 3. 读取properties文件的路径写法问题* 时间:2014/4/2*/package propertiesFile.read.test;import java.io.BufferedInputStream;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.io.InputStream;import java.text.MessageFormat;import java.util.Properties;public class PropertiesFileReadTest {/*** @param args*/public static void main(String[] args) {try {readPropFileByGetResourceAsStream();System.out.println("");readPropFileByInPutStream();} catch (Exception e) {e.printStackTrace();// TODO: handle exception}}/*** 使用getResourceAsStream方法读取properties文件*/static void readPropFileByGetResourceAsStream() {/*** 读取src下面config.properties包内的配置文件* test1.properties位于config.properties包内*/InputStream in1 = PropertiesFileReadTest.class.getClassLoader().getResourceAsStream("config/properties/test1.properties");/*** 读取和PropertiesFileReadTest类位于同一个包里面的配置文件* test2.properties和PropertiesFileReadTest类在同一个包里面*/InputStream in2 = PropertiesFileReadTest.class.getResourceAsStream("test2.properties");/*** 读取src根目录下文件的配置文件* jdbc.properties位于src目录*/InputStream in3 = PropertiesFileReadTest.class.getClassLoader().getResourceAsStream("jdbc.properties");/*** 读取位于另一个source文件夹里面的配置文件* config是一个source文件夹,config.properties位于config source文件夹中*/InputStream in4 = PropertiesFileReadTest.class.getClassLoader().getResourceAsStream("config.properties");Properties p = new Properties();System.out.println("----使用getResourceAsStream方法读取properties文件----");try {System.out.println("----------------------------------------------");p.load(in1);System.out.println("test1.properties:name=" + p.getProperty("name")+ ",age=" + p.getProperty("age"));System.out.println("----------------------------------------------");p.load(in2);System.out.println("test2.properties:name=" + p.getProperty("name") + ",age=" + p.getProperty("age"));System.out.println("----------------------------------------------");p.load(in3);System.out.println("jdbc.properties:");System.out.println(String.format("jdbc.driver=%s",p.getProperty("jdbc.driver")));// 这里的%s是java String占位符System.out.println(String.format("jdbc.url=%s",p.getProperty ("jdbc.url")));System.out.println(String.format("ename=%s",p.getProperty("ename")));System.out.println(String.format("jdbc.password=%s",p.getProperty("jdbc.password")));System.out.println("----------------------------------------------");p.load(in4);System.out.println("config.properties:");System.out.println(MessageFormat.format("dbuser={0}",p.getProperty("dbuser")));// {0}是一个java的字符串占位符System.out.println(MessageFormat.format("dbpassword={0}",p.getProperty("dbpassword")));System.out.println(MessageFormat.format("database={0}",p.getProperty("database")));System.out.println("----------------------------------------------");} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {if (in1 != null) {try {in1.close();} catch (IOException e) {e.printStackTrace();}}if (in2 != null) {try {in2.close();} catch (IOException e) {e.printStackTrace();}}if (in3 != null) {try {in3.close();} catch (IOException e) {e.printStackTrace();}}if (in4 != null) {try {in4.close();} catch (IOException e) {e.printStackTrace();}}}}/*** 使用InPutStream流读取properties文件*/static void readPropFileByInPutStream() {InputStream in1 = null;InputStream in2 = null;InputStream in3 = null;InputStream in4 = null;System.out.println("----使用InputStream流读取properties文件----");try {/*** 读取src根目录下文件的配置文件* jdbc.properties位于src目录*/in1 = new BufferedInputStream(new FileInputStream("src/jdbc.properties"));/*** 读取src下面config.properties包内的配置文件* test1.properties位于config.properties包内*/in2 = new BufferedInputStream(new FileInputStream("src/config/properties/test1.properties"));/*** 读取和PropertiesFileReadTest类位于同一个包里面的配置文件* test2.properties和PropertiesFileReadTest类在同一个包里面*/in3 = new BufferedInputStream(new FileInputStream("src/propertiesFile/read/test/test2.properties"));/*** 读取位于另一个source文件夹里面的配置文件* config是一个source文件夹,config.properties位于config source文件夹中*/in4 = new FileInputStream("config/config.properties");Properties p = new Properties();System.out.println("----------------------------------------------");p.load(in1);System.out.println("jdbc.properties:");System.out.println(String.format("jdbc.driver=%s",p.getProperty("jdbc.driver")));// 这里的%s是java String占位符System.out.println(String.format("jdbc.url=%s",p.getProperty("jdbc.url")));System.out.println(String.format("ename=%s",p.getProperty("ename")));System.out.println(String.format("jdbc.password=%s",p.getProperty("jdbc.password")));System.out.println("----------------------------------------------");p.load(in2);System.out.println("test1.properties:name=" + p.getProperty("name")+ ",age=" + p.getProperty("age"));System.out.println("----------------------------------------------");p.load(in3);System.out.println("test2.properties:name=" + p.getProperty("name")+ ",age=" + p.getProperty("age"));System.out.println("----------------------------------------------");p.load(in4);System.out.println("config.properties:");System.out.println(MessageFormat.format("dbuser={0}",p.getProperty("dbuser")));// {0}是一个java的字符串占位符System.out.println(MessageFormat.format("dbpassword={0}",p.getProperty("dbpassword")));System.out.println(MessageFormat.format("database={0}",p.getProperty("database")));System.out.println("----------------------------------------------");} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (in1 != null) {try {in1.close();} catch (IOException e) {e.printStackTrace();}}if (in2 != null) {try {in2.close();} catch (IOException e) {e.printStackTrace();}}if (in3 != null) {try {in3.close();} catch (IOException e) {e.printStackTrace();}}if (in4 != null) {try {in4.close();} catch (IOException e) {e.printStackTrace();}}}}}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
p.load(in);
完整的示例,可以参考附件文件 如何上传文件,谁知道请告诉以下。 只好把 source 都贴上来了 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;
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 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();
if (in != null) {
in.close(); } return p;
}
// ---------------------------------------------- servlet used
// ---------------------------------------------- support class
}
}
JPropertiesTest.java 文件
package com.kindani.test;
import junit.framework.*; import com.kindani.JProperties;
//import javax.servlet.ServletContext; import java.util.Properties;
public String[] getStringArray(String key) { return rb.getStringArray(key); }
protected Object handleGetObject(String key) { return ((PropertyResourceBundle) rb).handleGetObject(key); }
public ResourceBundle getBundle(String baseName, Locale locale, ClassLoader loader) { return ResourceBundle.getBundle(baseName, locale, loader); }
public Enumeration getKeys() { return rb.getKeys(); }
6。使用 ng.ClassLoader 类的 getSystemResourceAsStream()静态方 法 示例:InputStream in = ClassLoader.getSystemResourceAsStream(name); Properties p = new Properties(); p.load(in);
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);
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);
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); }
补充
Servlet 中可以使用 javax.servlet.ServletContext 的 getResourceAsStream() 方法 示例:InputStream in = context.getResourceAsStream(path); Properties p = new Properties();
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 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 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)); } }