`
01jiangwei01
  • 浏览: 543043 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

java 读取配置文件并应用 *.property

    博客分类:
  • java
 
阅读更多

最近在学习Java框架应用,所以从配置文件,并读取配置文件开始学习。

此处以读取SystemGlobals.properties为例

 

SystemGlobals.properties 中的内容如下:

#cache
use_cache=1
cache.implement = com.cqa.platform.cache.MemCacheEngine
cache.mem.initConn = 5
cache.mem.maxConn = 250
cache.mem.maxIdle = 50
cache.mem.maintSleep = 30
cache.mem.socketTO = 3000
cache.mem.socketConnectTO = 0
cache.mem.nagle = false
cache.mem.servers = 192.168.0.11:11211,192.168.0.11:11210

#log
log.show_sql=true

 SystemGlobals.java中的内容如下:

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;

/**
 * @Description 系统变量加载类
 * @ClassName SystemGlobals
 */
public class SystemGlobals {

    /** The preferences. the value of it all is String*/
    private static Properties preferences = new Properties();

    /** The queries. */
    private static Properties queries = new Properties();

    private static Map<String, Object> objectProperties = new HashMap<String, Object>();

    /**
     * Gets the preference.
     *
     * @param key
     *            the key
     * @return the preference
     */
    public static String getPreference(String key) {
	String s = preferences.getProperty(key);
	if (s != null)
	    s = s.trim();
	return s;
    }

    /**
     * Gets the preference.
     *
     * @param key
     *            the key
     * @param defaultValue
     *            the default value
     * @return the preference
     */
    public static String getPreference(String key, String defaultValue) {
	String s = preferences.getProperty(key);
	if (s == null)
	    return defaultValue;
	else
	    return s;
    }

    /**
     * Gets the preference.
     *
     * @param key
     *            the key
     * @param params
     *            the params
     * @return the preference
     */
    public static String getPreference(String key, Object... params) {
	String message = preferences.getProperty(key);
	if (message != null)
	    message = message.trim();

	if (params == null || params.length == 0)
	    return message;

	String[] ss = new String[params.length];
	Object o = null;
	for (int i = 0; i < params.length; i++) {
	    o = params[i];
	    if (o == null) {
		ss[i] = "";
	    } else {
		ss[i] = o.toString();
	    }
	}

	return replacePlaceHolder(message, ss);
    }

    /**
     * Sets the preference.
     *
     * @param key
     *            the key
     * @param value
     *            the value
     */
    public static void setPreference(String key, String value) {
	if (value != null) {
	    value = value.trim();
	    preferences.setProperty(key, value);
	} else {
	    preferences.remove(key);
	}
    }

    /**
     * Gets the int preference.
     *
     * @param key
     *            the key
     * @param defaultValue
     *            the default value
     * @return the int preference
     */
    public static int getIntPreference(String key, int defaultValue) {
	String s = getPreference(key);
	if (StringUtils.isBlank(s))
	    return defaultValue;
	else
	    return Integer.parseInt(s);
    }

    /**
     * Sets the int preference.
     *
     * @param key
     *            the key
     * @param value
     *            the value
     */
    public static void setIntPreference(String key, int value) {
	setPreference(key, String.valueOf(value));
    }

    /**
     * Gets the long preference.
     *
     * @param key
     *            the key
     * @param defaultValue
     *            the default value
     * @return the long preference
     */
    public static long getLongPreference(String key, long defaultValue) {
	String s = getPreference(key);
	if (StringUtils.isBlank(s))
	    return defaultValue;
	else
	    return Long.parseLong(s);
    }

    /**
     * Sets the long preference.
     *
     * @param key
     *            the key
     * @param value
     *            the value
     */
    public static void setLongPreference(String key, long value) {
	setPreference(key, String.valueOf(value));
    }

    /**
     * Gets the boolean preference.
     *
     * @param key
     *            the key
     * @param defaultValue
     *            the default value
     * @return the boolean preference
     */
    public static boolean getBooleanPreference(String key, boolean defaultValue) {
	String s = getPreference(key);
	if (StringUtils.isBlank(s))
	    return defaultValue;
	else
	    return Boolean.parseBoolean(s);
    }

    /**
     * Sets the boolean preference.
     *
     * @param key
     *            the key
     * @param value
     *            the value
     */
    public static void setBooleanPreference(String key, boolean value) {
	setPreference(key, String.valueOf(value));
    }

    /**
     * Gets the sql.
     *
     * @param key
     *            the key
     * @return the sql
     */
    public static String getSql(String key) {
	return queries.getProperty(key);
    }

    /**
     * Load sql.
     *
     * @param file
     *            the file
     */
    public static void loadSql(String file) {
	try {
	    InputStream is = SystemGlobals.class.getClassLoader() .getResourceAsStream(file);
	    queries.load(is);
	} catch (IOException e) {
	    e.printStackTrace();
	}
    }

    /**
     * Load config.
     *
     * @param file
     *            the file
     */
    public static void loadConfig(String file) {
	try {
	    InputStream is = SystemGlobals.class.getClassLoader() .getResourceAsStream(file);
	    preferences.load(is);
	} catch (IOException e) {
	    e.printStackTrace();
	}
    }

    /**
     * Replace place holder.
     *
     * @param message
     *            the message
     * @param params
     *            the params
     * @return the string
     */
    private static String replacePlaceHolder(String message, String[] params) {
	if (StringUtils.isBlank(message))
	    return message;
	if (params == null || params.length == 0)
	    return message;

	Map<String, String> map = new HashMap<String, String>();
	int index = -1;

	Pattern p = Pattern.compile("\\{(\\d+)\\}");
	Matcher m = p.matcher(message);

	while (m.find()) {
	    if (m.groupCount() < 1)
		continue;
	    index = Integer.parseInt(m.group(1));
	    if (index < 0 || index >= params.length)
		continue;

	    map.put(m.group(0), params[index]);
	}

	if (map.isEmpty())
	    return message;

	for (Entry<String, String> entry : map.entrySet()) {
	    message = message.replace(entry.getKey(), entry.getValue());
	}

	return message;
    }

    /**
     * The main method.
     *
     * @param args
     *            the arguments
     */
  public static void main(String[] args) {
	String s = "thia is a {2} or a {1} {0} hahah";
	String[] params = { "AA", "BB", "CC" };

	Map<String, String> map = new HashMap<String, String>();
	int index = -1;

	Pattern p = Pattern.compile("\\{(\\d+)\\}");
	Matcher m = p.matcher(s);

	while (m.find()) {
	    if (m.groupCount() < 1)
		continue;
	    index = Integer.parseInt(m.group(1));
	    if (index < 0 || index >= params.length)
		continue;

	    map.put(m.group(0), params[index]);
	}

	for (Entry<String, String> entry : map.entrySet()) {
	    s = s.replace(entry.getKey(), entry.getValue());
	}

	System.out.println(s);
    }

    public static void setObjectValue(String field, Object value) {
    	objectProperties.put(field, value);
    }

    public static Object getObjectValue(String field) {
    	return objectProperties.get(field);
    }

    /** The Constant DB_JNDI. */
    public static final String DB_JNDI = "db_jndi";

    /** The Constant DB_USERNAME. */
    public static final String DB_USERNAME = "db_userName";

    /** The Constant DB_PASSWD. */
    public static final String DB_PASSWD = "db_password";

    /** The Constant DB_URL. */
    public static final String DB_URL = "db_url";

    /** The Constant SPRING_CONFIG. */
    public static final String SPRING_CONFIG = "spring_config";

}

 在web.xml中进行配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" 
	xmlns="http://java.sun.com/xml/ns/j2ee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
	http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 	<context-param>
		<param-name>com.cqa.config.file</param-name>
		<param-value>SystemGlobals.properties</param-value>
	</context-param>
	
	<listener>
		<listener-class>com.company.listener.ConfigInitializer</listener-class>
	</listener>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

 ConfigInitializer.java 会在程序不完全启动时执行,其的内容为:

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.apache.commons.lang.StringUtils;

import com.company.util.SystemGlobals;

public class ConfigInitializer implements ServletContextListener {

	public void contextDestroyed(ServletContextEvent event) {
		ServletContext context = event.getServletContext();
	}

	public void contextInitialized(ServletContextEvent event) {
		ServletContext servletContext = event.getServletContext();

		String configFile = servletContext.getInitParameter("com.cqa.config.file");
		if (!StringUtils.isBlank(configFile)) {
		    configFile = configFile.trim();
		    SystemGlobals.loadConfig(configFile);
		}
		int useCache = SystemGlobals.getIntPreference("use_cache", 0);
		System.out.println("useCache=="+useCache);
		

	}

}

 可以看到

 SystemGlobals.getIntPreference("name","default")方法并有其他方法放在该java类里了。

以后在程序中可以任意使用。

  • 大小: 6.6 KB
分享到:
评论

相关推荐

    java-property-utils-1.9.1.jar,java-property-utils-1.10.jar

    Java Property Utils是Java开发中的一个实用工具库,主要用于处理和操作Java系统属性和配置文件。在给定的场景中,`java-property-utils-1.9.1.jar` 和 `java-property-utils-1.10.jar` 是这个库的两个不同版本,...

    java操作properties属性文件jp.gr.java_conf.ussiy.app.propedit_5.3.3.jar,有例子

    在部署时,可以将这些文件放在类路径下,或者通过外部配置文件的方式,让应用在运行时动态加载。 5. **标签相关** - `java`:表示与Java语言相关,Properties文件是Java标准库的一部分。 - `J2ee`:强调在Java...

    java的property配置文件的用法.txt

    ### Java的Property配置文件的用法详解 #### 一、引言 在软件开发过程中,配置文件被广泛用于存储各种可变的系统设置或参数,这样可以提高代码的灵活性及可维护性。对于Java开发者来说,`.properties`文件是一种...

    利用Java的Properties 类读取配置文件信息

    在Java编程中,读取配置文件是常见的任务,主要用于存储应用程序的设置或环境变量,以方便管理和维护。Java提供了一个内置的`java.util.Properties`类,用于处理`.properties`文件,这种格式通常用来存储键值对,即...

    java-property-utils-1.9.1.zip

    总结起来,`java-property-utils-1.9.1.zip` 提供了强大的 Java 属性操作工具,而 `cors-filter-1.7.jar` 则是处理 CORS 配置的过滤器,两者结合可以更好地支持现代 Web 应用的开发需求,尤其是在处理配置文件和跨域...

    java读取.properties配置文件的几种方法

    Java NIO(New IO)提供了一种更现代的I/O方式,可以用来读取配置文件。 ```java import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.Properties; ...

    java 动态修改配置文件

    - 使用`Properties`类的`load(Reader reader)`方法,可以读取配置文件。通常,我们通过`InputStreamReader`将输入流转换为字符流,并指定UTF-8编码,以避免中文乱码问题。 ```java Properties props = new ...

    SpringBoot-2.7.6读取配置文件的方式

    本篇文章将详细介绍Spring Boot如何读取配置文件,以及提供一些调试示例代码,帮助你更好地理解和运用。 ### 1. 配置文件位置与优先级 Spring Boot支持多种类型的配置文件,包括`application.properties`和`...

    cors-filter-2.5 + java-property-utils-1.9.1.zip

    例如,`java-property-utils-1.9.1.jar`包含了版本1.9.1的这个库,可以方便地读取和操作配置文件,使得CORS Filter的配置更加灵活。 在实际应用中,为了使用这个CORS Filter,你需要将其部署到Tomcat服务器。首先,...

    java 读取资源文件

    它可以加载并保存到流中,通常是用来处理配置文件。 - `load()` 方法:从输入流加载属性列表,通常是从.properties文件读取。 - `getProperty()` 方法:根据指定的键获取对应的属性值。 - `store()` 方法:将属性...

    java的property配置文件的用法.pdf

    以下是一个简单的示例代码,演示如何使用 Properties 类读取配置文件: ```java package configuration; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; ...

    解决Tomcat跨域的jar包,java-property-utils-1.9.jar

    在Tomcat中,配置跨域通常涉及到修改`web.xml`文件或者使用Filter来设置响应头,这些操作可能需要读取和解析配置文件,这时`java-property-utils`就派上用场了。例如,我们可以用它来读取服务器配置中的跨域允许的...

    xdoclet 用于生成*.hbm.xml

    在实际使用中,将xdoclet添加到项目构建路径后,运行构建过程(如Javadoc),xdoclet就会读取源代码中的注解并生成相应的配置文件。这极大地简化了Hibernate应用的初始化工作,使得开发者能更专注于业务逻辑的实现,...

    cors-filter-1.7.jar 和 java-property-utils-1.9.jar

    而`java-property-utils-1.9.jar` 提供了一些用于处理Java属性文件的工具类,这些工具在配置CORS过滤器时可能会用到,例如读取配置文件中的CORS策略。 在配置CORS过滤器时,首先需要将这两个库添加到项目的类路径中...

    读取配置文件代码

    在Java编程中,读取配置文件是常见的任务,它允许我们分离应用程序的配置信息,使得配置可以在不修改源代码的情况下更改。本示例将详细解释如何使用Java来读取configuration配置文件中的内容,以实现更灵活和可维护...

    Java进程配置文件Reload

    通过`java.io.File`或`java.net.URL`读取配置文件,然后使用`Properties`类解析键值对。当文件发生变化时,再次调用加载方法,更新程序中的配置对象。 6. **线程安全**:在多线程环境中,配置文件的重新加载需要...

    Java 加载配置文件的方式

    在Java编程中,加载配置文件是一项常见的任务,它允许我们动态地设置应用的参数和环境,而无需修改代码。配置文件通常以.properties或.xml格式存储,包含键值对或者结构化数据,使得程序可以根据不同环境或者用户...

    cors-filter-1.7.jar和java-property-utils-1.9.jar

    而“java-property-utils-1.9.jar”则为处理和管理JasperServer的配置文件提供了便利。在实际开发和部署JasperServer时,理解并合理利用这两个库的功能,对于构建健壮、灵活的报表服务至关重要。

    java-property-utils-1.9.jar

    Java属性工具库(Java Property Utils)是一个常用的Java开发中的组件,主要用来处理和操作Java的系统属性和配置文件。在Java编程中,属性文件通常用于存储应用的配置信息,如数据库连接字符串、日志级别等。`java-...

    Java那些事儿之(一)读取property配置文件

    本文将深入探讨如何在Java中读取和操作`properties`配置文件。 1. **什么是Properties文件** `properties`文件是一种文本文件,其内容遵循特定的语法,主要用于存储程序的配置信息,如数据库连接字符串、应用设置...

Global site tag (gtag.js) - Google Analytics