mthoutai

  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理
程序猿的量化交易之路（30）--Cointrader之ConfigUtil（17）

转载须注明出处：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);
}
我们首先来分析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去读取一个文件：

我们引用（抄袭）一个非常好非常easy的帖子：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



posted on 2017-05-08 13:19  mthoutai  阅读(541)  评论(0)  编辑  收藏  举报