轉載須註明出處：http://blog.csdn.net/minimicall?viewmode=contents，http://cloudtrade.top/
一個完整的系統，必然會涉及到配置文件。配置文件可以是xml、屬性文件等形式。大多數而言我們並不需要重寫配置讀取解析模塊，只需要使用開源的即可，這裏使用的是apapche.commons.configuration的。
我們這裏要說的是Cointrader的ConfigUtil類，它涉及到配置和註解成員之間的賦值等問題。
下面通過代碼學習：
package org.cryptocoinpartners.util;
import org.apache.commons.configuration.*;
import org.apache.commons.configuration.tree.OverrideCombiner;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nullable;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URL;
import java.util.*;
/**
* @author Tim Olson
*/
@SuppressWarnings("UnusedDeclaration")
public class ConfigUtil {
public static CombinedConfiguration combined() { return combined; }
public static PropertiesConfiguration defaults() { return defaultConfig; }
public static PropertiesConfiguration user() { return userConfig; }
public static PropertiesConfiguration buildtime() { return buildtimeConfig; }
public static SystemConfiguration system() { return sysConfig; }
public static MapConfiguration commandLine() { return clConfig; }
/**
* Finds all non-static members tagged with @Config and populates them with the current combined() configuration * 額，這個註釋是錯誤的。不僅僅是@Config吧。就是素有的非靜態成員的註解
*/
public static void applyConfiguration( Object instance ) {
Class<?> cls = instance.getClass();
for( Field field : cls.getFields() ) {
Config annotation = field.getAnnotation(Config.class);
if( annotation != null )
inject(combined(), instance, field, annotation);
}
}
/**
* Examines injectee for any setters or fields marked with @Config, then sets those fields to values from the
* Configuration object.
*/
public static void applyConfiguration(Object injectee, Configuration config) {
Class<?> cls = injectee.getClass();
for( Field field : cls.getFields() ) {
Config annotation = field.getAnnotation(Config.class);
if( annotation != null )
inject((AbstractConfiguration) config, injectee, field, annotation);
}
}
public static void init(String filename, Map<String,String> commandLine ) throws ConfigurationException {
boolean loadUserPropertiesFile = new File(filename).exists();
if( !loadUserPropertiesFile )
log.warn("Could not find configuration file \"" + filename + "\"");
clConfig = new MapConfiguration(commandLine);
sysConfig = new SystemConfiguration();
if( loadUserPropertiesFile )
userConfig = new PropertiesConfiguration(filename);
else
userConfig = new PropertiesConfiguration();
URL defaultProps = ConfigUtil.class.getResource("/cointrader-default.properties");//加載配置文件
if( defaultProps == null )
throw new ConfigurationException("Could not load cointrader-default.properties");
defaultConfig = new PropertiesConfiguration(defaultProps);
URL buildtimeProps = ConfigUtil.class.getResource("/org/cryptocoinpartners/buildtime.properties");
if( buildtimeProps == null )
throw new ConfigurationException("Could not load buildtime.properties");
buildtimeConfig = new PropertiesConfiguration(buildtimeProps);
combined = buildConfig(Collections.<AbstractConfiguration>emptyList());
if( log.isDebugEnabled() )
log.debug("Combined Configuration:\n"+ asString(combined));
}
public static CombinedConfiguration forModule(Object... keyValuePairs) {
if( keyValuePairs.length % 2 != 0 )
throw new Error("Configuration parameters must be key-value pairs. Found an odd number.");
HashMap<String,Object> map = new HashMap<>();
for( int i = 0; i < keyValuePairs.length; i++ )
map.put(keyValuePairs[i++].toString(),keyValuePairs[i]);
return forModule(Collections.singletonList(new MapConfiguration(map)));
}
public static CombinedConfiguration forModule(Collection<? extends AbstractConfiguration> moduleConfigs) {
CombinedConfiguration result = buildConfig(moduleConfigs);
if( log.isDebugEnabled() )
log.debug("Module Configuration:\n"+ asString(result));
return result;
}
public static List<String> getPathProperty(String pathProperty) {
CombinedConfiguration config = combined();
return getPathProperty(config, pathProperty);
}
public static List<String> getPathProperty(CombinedConfiguration config, String pathProperty) {
String modulePath = config.getString(pathProperty, "");
List<String> paths = new ArrayList<>(Arrays.asList(modulePath.split(":")));
paths.add("org.cryptocoinpartners.module");
paths.remove("");
return paths;
}
private static CombinedConfiguration buildConfig(Collection<? extends AbstractConfiguration> intermediateConfigs) {
final CombinedConfiguration result = new CombinedConfiguration(new OverrideCombiner());
result.addConfiguration(buildtimeConfig); // buildtime config cannot be overridden
result.addConfiguration(clConfig);
result.addConfiguration(sysConfig);
for( AbstractConfiguration moduleConfig : intermediateConfigs )
result.addConfiguration(moduleConfig);
if( !userConfig.isEmpty() )
result.addConfiguration(userConfig);
result.addConfiguration(defaultConfig);
return result;
}
public static String asString(Configuration configuration) {
StringWriter out = new StringWriter();
PrintWriter pout = new PrintWriter(out);
ConfigurationUtils.dump(configuration, pout);
try {
pout.close();
out.close();
}
catch( IOException e ) {
throw new Error(e);
}
ArrayList<String> outLines = new ArrayList<>();
for( String line : out.toString().split("\n") ) {
if( !isSecret(line) )
outLines.add(line);
}
Collections.sort(outLines);
return StringUtils.join(outLines,"\n");
}
protected static boolean isSecret(String line) {
return line.contains("password") || line.contains("secret");
}
private static void inject(@Nullable Object instance, Field field ) {
inject(combined(), instance, field, null);
}
private static void inject(AbstractConfiguration configuration, @Nullable Object instance, Field field, @Nullable Config configAnnotation ) {
if( instance == null && !Modifier.isStatic(field.getModifiers()) )//如果instance爲null或者該數據成員爲靜態的，則不可賦值
return;
if( Modifier.isFinal(field.getModifiers()) ) {//該數據成員是final修飾的，不可以修改。
log.warn("Field " + field.getDeclaringClass().getName()+"."+field.getName() + " is tagged with @Config but is declared final. Config for this field failed.");
return;
}
if( configAnnotation == null )//如果configAnnotation爲null，則直接獲取field的註解。
configAnnotation = field.getAnnotation(Config.class);
String key = null;
if( configAnnotation != null )
key = configAnnotation.value();//標註的值作爲鍵
if( key == null )
key = field.getName();//如果標註沒有值，那麼直接拿數據成員的名字作爲鍵
Config classConfigAnnotation = field.getDeclaringClass().getAnnotation(Config.class);//獲取成員聲明所在類的註解,即類註解
if( classConfigAnnotation != null )
key = classConfigAnnotation.value() + "." + key;//用“.”號連接類註解和成員註解
Object value = getDynamic(field.getType(), configuration, key);//獲取該註解對應配置的值
if( value != null ) {
try {
field.set(instance, value);//將值反射注入到instance對象的改數據成員中。
if( log.isDebugEnabled() ) {
// hide values marked as passwords
String printValue = isSecret(key) ? "**-hidden-**" : field.get(instance).toString();
log.debug("Set field " + field.getDeclaringClass()
.getName() + "." + field.getName() + " to " + printValue);
}
}
catch( IllegalAccessException e ) {
log.error("Could not set config on field " + field.getDeclaringClass().getName() + "." + field.getName(),e);
}
}
}
public static <T> T getDynamic(Class<T> resultType, AbstractConfiguration configuration, String key) {
return getDynamic(resultType, configuration, key, null);
}
//從配置文件中讀取屬性值
@SuppressWarnings("unchecked")
public static <T> T getDynamic(Class<T> resultType, AbstractConfiguration configuration, String key, T defaultValue) {
if( resultType.isAssignableFrom(String.class) )
return (T) configuration.getString(key, (String) defaultValue);
else if( resultType.isAssignableFrom(Boolean.class) || resultType.isAssignableFrom(Boolean.TYPE) )
return (T) configuration.getBoolean(key, (Boolean) defaultValue);
else if( resultType.isAssignableFrom(Long.class) || resultType.isAssignableFrom(Long.TYPE) )
return (T) configuration.getLong(key, (Long) defaultValue);
else if( resultType.isAssignableFrom(Integer.class) || resultType.isAssignableFrom(Integer.TYPE) )
return (T) configuration.getInteger(key, (Integer) defaultValue);
else if( resultType.isAssignableFrom(Short.class) || resultType.isAssignableFrom(Short.TYPE) )
return (T) configuration.getShort(key, (Short) defaultValue);
else if( resultType.isAssignableFrom(Byte.class) || resultType.isAssignableFrom(Byte.TYPE) )
return (T) configuration.getByte(key, (Byte) defaultValue);
else if( resultType.isAssignableFrom(Double.class) || resultType.isAssignableFrom(Double.TYPE) )
return (T) configuration.getDouble(key, (Double) defaultValue);
else if( resultType.isAssignableFrom(Float.class) || resultType.isAssignableFrom(Float.TYPE) )
return (T) configuration.getFloat(key, (Float) defaultValue);
else if( resultType.isAssignableFrom(List.class) )
return (T) configuration.getList(key, (List) defaultValue);
else if( resultType.isAssignableFrom(BigDecimal.class) )
return (T) configuration.getBigDecimal(key, (BigDecimal) defaultValue);
else if( resultType.isAssignableFrom(BigInteger.class) )
return (T) configuration.getBigInteger(key, (BigInteger) defaultValue);
throw new IllegalArgumentException("Cannot cast configuration values to "+resultType.getName());
}
private static PropertiesConfiguration defaultConfig;
private static PropertiesConfiguration buildtimeConfig;
private static PropertiesConfiguration userConfig;
private static MapConfiguration clConfig;
private static SystemConfiguration sysConfig;
private static CombinedConfiguration combined;
private static Logger log = LoggerFactory.getLogger(ConfigUtil.class);
}
在這裏我們補一下獲取一個成員的註解的知識：學習代碼如下：
package com.yiibai;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
// declare a new annotation
@Retention(RetentionPolicy.RUNTIME)
@interface Demo {
String str();
int val();
}
public class PackageDemo {
// set values for the annotation
@Demo(str = "Demo Annotation", val = 100)
// a method to call in the main
public static void example() {
PackageDemo ob = new PackageDemo();
try {
Class c = ob.getClass();
// get the method example
Method m = c.getMethod("example");
// get the annotation for class Demo
Demo annotation = m.getAnnotation(Demo.class);
// print the annotation
System.out.println(annotation.str() + " " + annotation.val());
} catch (NoSuchMethodException exc) {
exc.printStackTrace();
}
}
public static void main(String args[]) {
example();
}
}
讓我們來編譯和運行上面的程序，這將產生以下結果：
Demo Annotation 100下面還有一個getResource去讀取一個文件：
我們引用（抄襲）一個很好很簡單的帖子：http://blog.csdn.net/lcj8/article/details/3502849
class.getResource()的用法
用JAVA獲取文件，聽似簡單，但對於很多像我這樣的新人來說，還是掌握頗淺，用起來感覺頗深，大常最經常用的，就是用JAVA的File類，如要取得c:/test.txt文件，就會這樣用File file = newFile("c:/test.txt");這樣用有什麼問題，相信大家都知道，就是路徑硬編碼，對於JAVA精神來說，應用應該一次成型，到處可用，並且從現實應用來講，最終生成的應用也會部署到Windows外的操作系統中，對於linux來說，在應用中用了c:/這樣的字樣，就是失敗，所以，我們應該儘量避免使用硬編碼，即直接使用絕對路徑。
在Servlet應用中，有一個getRealPath(String str)的方法，這個方法儘管也可以動態地獲得文件的路徑，不祕直接手寫絕對路徑，但這也是一個不被建議使用的方法，那麼，我們有什麼方法可以更好地獲得文件呢?
那就是Class.getResource()與Class.getResourceAsStream()方法，但很多人還是不太懂它的用法，因爲很多人（比如不久前的我）都不知道應該傳怎麼樣的參數給它，當然，有些人己經用得如火純青，這些人是不需要照顧的，在此僅給不會或者還不是很熟的人解釋一點點。
比如我們有以下目錄
|--project
|--src
|--javaapplication
|--Test.java
|--file1.txt
|--file2.txt
|--build
|--javaapplication
|--Test.class
|--file3.txt
|--file4.txt
在上面的目錄中，有一個src目錄，這是JAVA源文件的目錄，有一個build目錄，這是JAVA編譯後文件(.class文件等）的存放目錄
那麼，我們在Test類中應該如何分別獲得
file1.txt file2.txt file3.txt file4.txt這四個文件呢？
首先講file3.txt與file4.txt
file3.txt:
方法一：File file3 = new File(Test.class.getResource("file3.txt").getFile());
方法二：File file3 = new File(Test.class.getResource("/javaapplication/file3.txt").getFile());
方法三：File file3 = new File(Test.class.getClassLoader().getResource("javaapplication/file3.txt").getFile());
file4.txt:
方法一：File file4 = new File(Test.class.getResource("/file4.txt").getFile());
方法二：File file4 = new File(Test.class.getClassLoader().getResource("file4.txt").getFile());
很好，我們可以有多種方法選擇，但是file1與file2文件呢？如何獲得？
答案是，你只能寫上它們的絕對路徑，不能像file3與file4一樣用class.getResource()這種方法獲得，它們的獲取方法如下
假如整個project目錄放在c:/下，那麼file1與file2的獲取方法分別爲
file1.txt
方法一：File file1 = new File("c:/project/src/javaapplication/file1.txt");
方法二：。。。沒有
file2.txt
方法一：File file2 = new File("c:/project/src/file2.txt");
方法二：。。。也沒有
總結一下，就是你想獲得文件，你得從最終生成的.class文件爲着手點，不要以.java文件的路徑爲出發點，因爲真正使用的就是.class，不會拿個.java文件就使用，因爲java是編譯型語言嘛
至於getResouce()方法的參數，你以class爲出發點，再結合相對路徑的概念，就可以準確地定位資源文件了，至於它的根目錄嘛，你用不同的IDEbuild出來是不同的位置下的，不過都是以頂層package作爲根目錄，比如在Web應用中，有一個WEB-INF的目錄，WEB-INF目錄裏面除了web.xml文件外，還有一個classes目錄，沒錯了，它就是你這個WEB應用的package的頂層目錄，也是所有.class的根目錄“/”，假如clasaes目錄下面有一個file.txt文件，它的相對路徑就是"/file.txt"，如果相對路徑不是以"/"開頭，那麼它就是相對於.class的路徑。。
還有一個getResourceAsStream()方法，參數是與getResouce()方法是一樣的，它相當於你用getResource()取得File文件後，再new InputStream(file)一樣的結果
class.getResource("/") --> 返回class文件所在的頂級目錄，一般爲包名的頂級目錄。 --> file:/home/duanyong/workspace/cxxx/xxxx/bin/WEB-INF/classes/
class.getResource("/xxx.txt") --> 返回頂級目錄下的xxx.txt路徑。 file://..../bin/WEB-INF/classes/xxx.txt
getResource(String path),path是以class文件的頂級目標所在的相對路徑。如果頂級目錄爲classes，在classes/xxx/yyy.txt這樣一個文件。取得yyy.txt的語法爲：class.getResource("/xxx/yyy.txt");
示例代碼：
查看複製到剪切板打印
//取得classes頂級目錄下的/xxx/yyy.txt文件
System.out.println(Test.class.getResource("/xxx/yyy.txt"));
//取得本class的上路徑
System.out.println(Test.class.getResource(Test.class.getSimpleName() + ".class"));
[Java] view plaincopy
//取得classes頂級目錄下的/xxx/yyy.txt文件
System.out.println(Test.class.getResource("/xxx/yyy.txt"));
//取得本class的上路徑
System.out.println(Test.class.getResource(Test.class.getSimpleName() + ".class"));
結果：
file:/home/duanyong/workspace/test/bin/WEB-INF/classes/xxx/yyy.txt
file:/home/duanyong/workspace/test/bin/WEB-INF/classes/cn/duanyong/test/Test.class