程序员的量化交易之路(30)--Cointrader之ConfigUtil(17)

简介:

转载须注明出处:http://blog.csdn.net/minimicall?viewmode=contentshttp://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);
}
我们首先来分析inject函数,它实现的是一个将配置中值注入到对应对象的成员变量中去。

在这里我们补一下获取一个成员的注解的知识:学习代码如下:

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



相关文章