Java实现配置加载机制

时间 2019-12-10

标签 java 实现配置加载机制栏目 Java 繁體版

原文原文链接

前言

现现在几乎大多数Java应用，例如咱们耳熟能详的tomcat, struts2, netty...等等数都数不过来的软件，
要知足通用性，都会提供配置文件供使用者定制功能。java

甚至有一些例如Netty这样的网络框架，几乎彻底就是由配置驱动，这样的软件咱们也一般称之为"微内核架构"的软件。
你把它配置成什么，它就是什么。数据库

It is what you configure it to be.

最多见的配置文件格式是XML, Properties等等文件。apache

本文探讨加载配置中最通用也是最多见的场景，那就是把一个配置文件映射成Java里的POJO对象.
并探讨如何实现不一样方式的加载，例如，有一些配置是从本地XML文件里面加载的，而有一些配置须要从本地Properties文件加载，
更有甚者，有一些配置须要经过网络加载配置。tomcat

如何实现这样一个配置加载机制，让咱们拥有这个机制后，不会让加载配置的代码散布获得处都是，而且可扩展，可管理。微信

配置加载器

首先，咱们须要一个配置加载器，而这个配置加载器是能够有多种不一样的加载方式的，所以，咱们用一个接口来描述它，以下所示：网络

/**
 * 
 *
 * @author Bean
 * @date 2016年1月21日 上午11:47:12
 * @version 1.0
 *
 */
public interface IConfigLoader<T> {
    
    /**
     * load the config typed by T
     *
     * @return
     * @throws ConfigException
     */
    public T load() throws ConfigException;
}

但是，为何咱们须要在这个接口上声明泛型<T> ?
很明显，当咱们要使用一个配置加载器时，你得告诉这个配置加载器你须要加载后获得什么结果。
例如，你但愿加载配置后获得一个AppleConfig对象，那么你就能够这么去使用上述定义的接口：架构

IConfigLoader<AppleConfig> loader = new AppleConfigLoader<AppleConfig>();
    AppleConfig config = loader.load();

因而你将配置文件里的信息转化成了一个AppleConfig对象，而且你能获得这个AppleConfig对象实例。app

到目前，貌似只要咱们的AppleConfigLoader里面实现了怎么加载配置文件的具体劳动，咱们就能够轻易加载配置了。框架

能够这么说，可是不是尚未考虑到，配置可能经过不一样的方式加载呢，好比经过Properties加载，经过dom方式加载，经过sax方式加载，或者经过某些第三方的开源库来加载。dom

所以，除了配置加载器，咱们还须要另一种角色，配置加载方式的提供者。暂且，咱们就叫它IConfigProvider。

配置加载方式的提供者

配置加载方式的提供者能够提供一种加载方式给配置加载器，换言之，提供一个对象给配置加载器。

若是经过dom方式加载，那么提供者提供一个Document对象给加载器。
若是经过Properties方式加载，那么提供者提供一个Properties对象给加载器
若是经过第三方类库提供的方式加载，好比apache-commons-digester3(tomcat的配置加载)，那么提供者提供一个Digester对象给加载器

提供者的职责就是提供，仅此而已，只提供配置加载器所须要的对象，但它自己并不参与配置加载的劳动。

咱们用一个接口IConfigProvider来定义这个提供者

/**
 *
 *
 * @author Bean
 * @date 2016年1月21日 上午11:54:28
 * @version 1.0
 *
 */
public interface IConfigProvider<T> {

    /**
     * provide a config source used for loading config
     *
     * @return
     * @throws ConfigException
     */
    public T provide() throws ConfigException;
}

这里为何又会有<T>来声明泛型呢？
若是须要一个提供者，那么至少得告诉这个提供者它该提供什么吧。

所以，一个提供者会提供什么，由这个<T>来决定。

同时，到这里，咱们能够先建造一个工厂，让它来生产特定的提供者:

/**
 *
 *
 * @author Bean
 * @date 2016年1月21日 上午11:56:28
 * @version 1.0
 *
 */
public class ConfigProviderFactory {

    private ConfigProviderFactory() {
        throw new UnsupportedOperationException("Unable to initialize a factory class : "
                + getClass().getSimpleName());
    }

    public static IConfigProvider<Document> createDocumentProvider(String filePath) {
        return new DocumentProvider(filePath);
    }

    public static IConfigProvider<Properties> createPropertiesProvider(String filePath) {
        return new PropertiesProvider(filePath);
    }
    
    public static IConfigProvider<Digester> createDigesterProvider(String filePath) {
            return new DigesterProvider(filePath);
    }
}

能够开始实现具体配置加载器了?

还不行!

到这里，假设咱们有一个配置文件，叫apple.xml。并且咱们要经过DOM方式把这一份apple.xml加载后变成AppleConfig对象。

那么，首先我要经过提供者工厂给我制造一个能提供Document的提供者。而后拿到这个提供者，我就能够调用它的provide方法来得到Document对象，
有了document对象，那么我就能够开始来加载配置了。

但是，若是要加载BananaConfig、PearConfig.......呢，其步骤都是同样的。所以咱们还要有一个抽象类，来实现一些默认的共同行为。

/**
 *
 *
 * @author Bean
 * @date 2016年1月21日 上午11:59:19
 * @version 1.0
 *
 */
public abstract class AbstractConfigLoader <T, U> implements IConfigLoader<T>{

    protected IConfigProvider<U> provider;
    
    protected AbstractConfigLoader(IConfigProvider<U> provider) {
        this.provider = provider;
    }

    /*
     * @see IConfigLoader#load()
     */
    @Override
    public T load() throws ConfigException {
        return load(getProvider().provide());
    }

    public abstract T load(U loaderSource) throws ConfigException;
    
    protected IConfigProvider<U> getProvider() {
        return this.provider;
    }
}

每一个配置加载器都有一个带参数构造器，接收一个Provider。

泛型<T>指明了我要加载的是AppleConfig仍是BananConfig，泛型<U>指明了要用什么加载方式加载，是Document呢，仍是Properties，或者其余。

实战运用实例

有一份菜市场配置文件market.xml，配置了菜市场的商品，里面有两种商品，分别是苹果和鸡蛋。

<market>
    <apple>
        <color>red</color>
        <price>100</price>
    </apple>
    <egg>
        <weight>200</weight>
    </egg>
</market>

另外还有一份关于各个档口老板名字的配置文件，owner.properties

port1=Steve Jobs
port2=Bill Gates
port3=Kobe Bryant

咱们先定义好以下类:
MarketConfig.java

/**
 *
 *
 * @author Bean
 * @date 2016年1月21日 下午11:03:37
 * @version 1.0
 *
 */
public class MarketConfig {

    private AppleConfig appleConfig;
    private EggConfig eggConfig;
    private OwnerConfig ownerConfig;
    
    public AppleConfig getAppleConfig() {
        return appleConfig;
    }
    public void setAppleConfig(AppleConfig appleConfig) {
        this.appleConfig = appleConfig;
    }
    public EggConfig getEggConfig() {
        return eggConfig;
    }
    public void setEggConfig(EggConfig eggConfig) {
        this.eggConfig = eggConfig;
    }
    public OwnerConfig getOwnerConfig() {
        return ownerConfig;
    }
    public void setOwnerConfig(OwnerConfig ownerConfig) {
        this.ownerConfig = ownerConfig;
    }
}

AppleConfig.java

/**
 *
 *
 * @author Bean
 * @date 2016年1月21日 下午11:03:45
 * @version 1.0
 *
 */
public class AppleConfig {

    private int price;
    private String color;
    
    public void setPrice(int price) {
        this.price = price;
    }
    
    public int getPrice() {
        return this.price;
    }
    
    public void setColor(String color) {
        this.color = color;
    }
    
    public String getColor() {
        return this.color;
    }
}

EggConfig.java

/**
 *
 *
 * @author Bean
 * @date 2016年1月21日 下午11:03:58
 * @version 1.0
 *
 */
public class EggConfig {

    private int weight;
    
    public void setWeight(int weight) {
        this.weight = weight;
    }
    
    public int getWeight() {
        return this.weight;
    }
}

OwnerConfig.java

/**
 *
 *
 * @author Bean
 * @date 2016年1月21日 下午11:04:06
 * @version 1.0
 *
 */
public class OwnerConfig {

    private Map<String, String> owner = new HashMap<String, String>();
    
    public void addOwner(String portName, String owner) {
        this.owner.put(portName, owner);
    }
    
    public String getOwnerByPortName(String portName) {
        return this.owner.get(portName);
    }
    
    public Map<String, String> getOwners() {
        return Collections.unmodifiableMap(this.owner);
    }
}

这个例子有两种配置加载方式，分别是Dom和Properties加载方式。
因此咱们的提供者建造工厂须要制造两种提供者provider.
并且须要定义2个配置加载器，分别是:

OwnerConfigLoader

/**
 *
 *
 * @author Bean
 * @date 2016年1月21日 下午11:24:50
 * @version 1.0
 *
 */
public class OwnerConfigLoader extends AbstractConfigLoader<OwnerConfig, Properties>{

    /**
     * @param provider
     */
    protected OwnerConfigLoader(IConfigProvider<Properties> provider) {
        super(provider);
    }

    /* 
     * @see AbstractConfigLoader#load(java.lang.Object)
     */
    @Override
    public OwnerConfig load(Properties props) throws ConfigException {
        OwnerConfig ownerConfig = new OwnerConfig();
        
        /**
         * 利用props，设置ownerConfig的属性值
         * 
         * 此处代码省略
         */
        return ownerConfig;
    }
}

而后是MarketConfigLoader

import org.w3c.dom.Document;

/**
 *
 *
 * @author Bean
 * @date 2016年1月21日 下午11:18:56
 * @version 1.0
 *
 */
public class MarketConfigLoader extends AbstractConfigLoader<MarketConfig, Document> {

    /**
     * @param provider
     */
    protected MarketConfigLoader(IConfigProvider<Document> provider) {
        super(provider);
    }

    /* 
     * AbstractConfigLoader#load(java.lang.Object)
     */
    @Override
    public MarketConfig load(Document document) throws ConfigException {
        
        MarketConfig marketConfig = new MarketConfig();
        AppleConfig appleConfig = new AppleConfig();
        EggConfig eggConfig = new EggConfig();
        /**
         * 在这里处理document,而后就能获得
         * AppleConfig和EggConfg
         * 
         * 此处代码省略
         */
        marketConfig.setAppleConfig(appleConfig);
        marketConfig.setEggConfig(eggConfig);
        
        /**
         * 因为OwnerConfig是须要properties方式来加载，不是xml
         * 因此这里要新建一个OwnerConfigLoader，委托它来加载OwnerConfig
         */
        
        OwnerConfigLoader ownerConfigLoader = new OwnerConfigLoader(ConfigProviderFactory.createPropertiesProvider(YOUR_FILE_PATH));
        OwnerConfig ownerConfig = ownerConfigLoader.load();
        
        marketConfig.setOwnerConfig(ownerConfig);
        
        return marketConfig;
    }
}

而后，咱们在应用层面如何获取到MarketConfig呢

MarketConfigLoader marketConfigLoader = new MarketConfigLoader(ConfigProviderFactory.createDocumentProvider(YOUR_FILE_PATH));
MarketConfig marketConfig = marketConfigLoader.load();

也许有个地方会人奇怪，明明有四个配置类，为何只有2个配置加载器呢。
由于MarketConfig、EggConfig和AppleConfig，都是从同一个xml配置文件里面加载，因此只要一个Document对象，经过MarketConfigLoader就能够所有加载。

而OwnerConfig是不一样的加载方式，因此须要另一个加载器。

尾声

本文提出的配置加载机制，并不可以实际帮忙加载配置，这事应该留给DOM，SAX，以及其余一些开源库如dom4j，Digester去作。
但本文提出的配置加载机制可以让配置加载机制更灵活，容易扩展，而且可以集成多种配置加载方式，融合到一个机制进来，发挥各自有点。

实际上，有些软件常常须要同时从多种不一样格式的配置文件里面加载配置，例如struts2，以及我最近在研究并被气到吐血的某国产开源数据库中间件软件，
若是没有一套完整的配置加载机制，那么代码会比较散乱，可维护性不高。容易令人吐血。