读取配置信息功能设计

功能需求

我们在设计系统的过程当中， 经常会遇到需要读取配置信息需求， 可以想到的几个设计要点是

• 1 将系统所有的配置信息都存放在数据库的一张表中， 这样想查询相关业务只要筛选key字段即可。
• 2 我们希望数据可以自动更新， 这样修改了数据后不必重启服务
• 3 这个问题是一个技术问题， 也就是我们希望减少在bean初始化过程（如标记了{@link javax.annotation.PostConstruct}的方法）中使用配置项而导致的麻烦， 那么我们需要提供一个可以在Spring自动注入开始前获取配置项holder的方法， 也就是说获取的是一个代理类， 在实际取值的时候才会去调用数据库

功能实现

• 1 首先说自动更新问题， 很显然我们需要实现一个定时任务， 我们可以实现http://www.jianshu.com/writer#/notebooks/13667805/notes/13753006 这里的抽象类来完成定时更新功能。
• 2 要实现自动更新， 我们很容易想到发布订阅模式， 很显然每个需要读取配置的地方都应该在config类中订阅， 然后在合适的时候由config类进行通知。那么我们可以设置一个ConfigListener接口， 所有需要读取配置的类都要实现这个接口

public interface ConfigListener {

    void update();

}

• 3 由于{@link javax.annotation.PostConstruct} 注解无法保证初始化的顺序，而其他类会在{@link javax.annotation.PostConstruct}过程中使用配置信息， 因此需要设置一个代理， 采用动态代理的好处是不需要对原代码进行更改， 我们只需要加入从数据库读取配置信息以及注册的逻辑即可。
  我们需要实现InvocationHandler接口， 那么一个读取配置信息的client类就可以这么写

private class ConfigClientProxy implements InvocationHandler, ConfigListener {

        private ConfigClient client = new configClientImpl(); //这里是原client

        private volatile boolean init = false;

        public ConfigClient getClient() {
            return (ConfigClient) Proxy.newProxyInstance(
                    client.getClass().getClassLoader(),
                    client.getClass().getInterfaces(),
                    this);
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if (!init) {
                init();
                init = true;
            }
            return method.invoke(client, args);
        }

        private void init() {
            update();
            configService.registerListener(ConfigConstants.APP_ID, this);
            configService.registerListener(ConfigConstants.CODE, this);
            configService.registerListener(ConfigConstants.TOKEN_URL, this);
            configService.registerListener(ConfigConstants.BASE_URL, this);
            configService.registerListener(ConfigConstants.SECRET, this);
            configService.registerListener(ConfigConstants.SOURCE, this);
            configService.registerListener(ConfigConstants.TARGET, this);
        }

        @Override
        public void update() {
            String appId = configService.getData(ConfigConstants.APP_ID, String.class);
            String authCode = configService.getData(ConfigConstants.AUTH_CODE, String.class);
            String tokenUrl = configService.getData(ConfigConstants.TOKEN_URL, String.class);
            String baseUrl = configService.getData(ConfigConstants.BASE_URL, String.class);
            String secret = configService.getData(ConfigConstants.SECRET, String.class);
            String source = configService.getData(ConfigConstants.SOURCE, String.class);
            String target = configService.getData(ConfigConstants.TARGET, String.class);
            client.setParameters(appId, authCode, tokenUrl, baseUrl, secret, source, target);
        }

    }

• 4 接下来我们就要看一下configService这个类该怎么实现了， 通过刚刚提示的功能， 我们可知接口类应该提供这么几个方法

public interface ConfigService {

    /**
     * 获取指定key的配置值
     *
     * @param key
     * @return
     */
    String getData(String key);

    /**
     * 获取指定key的配置值
     *
     * @param key 配置key
     * @param valueClass 配置值的类型
     * @param <T>
     * @return
     */
    <T> T getData(String key, Class<T> valueClass);

    /**
     * 获取指定key的配置值，并通过给的的转换器转换类型，若不存在则获取默认key的配置值并转换
     *
     * @param key
     * @param converter
     * @param <T>
     * @return
     */
    <T> T getData(String key, ConfigConverter<T> converter);

    /**
     * 将指定的监听器注册到指定的配置项上，当该配置项的值变化时会通知该监听器
     *
     * @param key
     * @param configListener
     */
    void registerListener(String key, ConfigListener configListener);

}

具体实现代码

@Service
public class ConfigServiceImpl extends ScheduledService implements ConfigService {

    @Autowired
    private DataDao dataDao;

    private volatile Map<String, String> values = new HashMap<String, String>();

    private ConcurrentHashMap<String, Set<ConfigListener>> listenerMap = new ConcurrentHashMap<String, Set<ConfigListener>>();

    /** 是否进行过初始化 */
    private volatile boolean init = false;

    /**
     * 默认的转换机制是使用Nutz的转换器
     *
     * @param valueClass
     * @param <T>
     * @return
     */
    private static <T> ConfigConverter<T> getDefaultConverter(final Class<T> valueClass) {
        return new ConfigConverter<T>() {
            @Override
            public T convert(String value) {
                return Castors.me().castTo(value, valueClass);
            }
        };
    }

    @Override
    public int updatePeriod() {
        return TimeConstants.MINUTE_IN_SECONDS;
    }

    @Override
    public void update() {
        List<Data> datas = dataDao.getAllDatas();
        Map<String, String> values = new HashMap<String, String>();
        for (Data data : datas) {
            values.put(data.getDataKey(), data.getDataValue());
        }
        Map<String, String> oldValues = this.values;
        this.values = values;
        invokeHolder(values, oldValues);
    }

    /**
     * 检查配置值是否有变化，若有变化，通知相关的holder
     *
     * @param newValues
     * @param oldValues
     */
    private void invokeHolder(Map<String, String> newValues, Map<String, String> oldValues) {
        Set<String> allKeys = new HashSet<String>();
        allKeys.addAll(newValues.keySet());
        allKeys.addAll(oldValues.keySet());
        for (String key : allKeys) {
            String newValue = newValues.get(key);
            String oldValue = oldValues.get(key);
            if (newValue == oldValue || (null != newValue && newValue.equals(oldValue))) {
                continue;
            }
            Set<ConfigListener> listeners = listenerMap.get(key);
            if (null == listeners) {
                continue;
            }
            for (ConfigListener holder : listeners) {
                try {
                    holder.update();
                } catch (Exception e) {
                    LogUtils.warning("ConfigServiceImpl: invoke error! " + key, e);
                }
            }
        }
    }

    @Override
    public String getData(String key) {
        if (!init) {
            update();
            init = true;
        }
        return values.get(key);
    }

    @Override
    public <T> T getData(String key, Class<T> valueClass) {
        return getData(key, getDefaultConverter(valueClass));
    }

    @Override
    public <T> T getData(String key, ConfigConverter<T> converter) {
        String value = getData(key);
        // 使用指定的转换器
        return converter.convert(value);
    }

    @Override
    public void registerListener(String key, ConfigListener configListener) {
        Set<ConfigListener> listeners = listenerMap.get(key);
        if (null == listeners) {
            listenerMap.putIfAbsent(key, Collections.newSetFromMap(new ConcurrentHashMap<ConfigListener, Boolean>()));
            listeners = listenerMap.get(key);
        }
        listeners.add(configListener);
    }

}

• 5 看了刚才的代码， 可能觉得每次使用配置文件有些太复杂了， 每次引用还需要自己去写一个动态代理类， 那么我们可以写一个工具类， 对这个过程做一个简化， 也就是我们默认写好一个holder实现了刚才的注册等功能， 每次调用的时候只需要执行

private ConfigHolder<String> lastName = ConfigUtils.getHolder(ConfigConstants.LAST_NAME, String.class);
address.setLastName(lastName.getValue());

也就是说我们获取的值都是一个个holder， 只要调用它的getValue方法， 就可以保证读到的都是最新的值。

/**
 * 系统配置工具类
 * <p />
 * 该类提供了{@link utils.ConfigUtils.ConfigHolder}的实现，通过该Holder，可以获取到指定配置的值。
 * 该类提供了这样一种机制，可以在Spring自动注入开始前获取到相关配置信息的Holder，
 * 虽然这些Holder需要等到Spring自动注入完成后才能使用，但能够在自动注入开始前（比如构造方法里）初始化Holder，
 * 可以在一些场景下简化代码的实现。
 *
 */
public class ConfigUtils {

    /**
     * 一个可以自动更新配置值的配置获取器
     *
     * @param <T>
     */
    public interface ConfigHolder<T> {

        /** 获取配置名称 */
        String getKey();

        /** 获取配置值 */
        T getValue();

    }

    private static abstract class BaseConfigHolder<T> implements ConfigHolder<T>, ConfigListener {

        private String key;

        private T value;

        private boolean init = false;

        public BaseConfigHolder(String key) {
            this.key = key;
        }

        @Override
        public String getKey() {
            return key;
        }

        /**
         * 获取配置的值
         * <p />
         * <b>注意</b>：该方法实际使用了{@link ConfigUtils#configService}来获取配置值，因此必须在Spring自动注入后才能调用
         *
         * @return
         */
        public final T getValue() {
            if (!init) {
                init();
                init = true;
            }
            return value;
        }

        private void init() {
            update();
            configService.registerListener(key, this);
        }

        @Override
        public final void update() {
            value = getValueFromConfigService();
        }

        /**
         * 从{@link ConfigUtils#configService}获取配置值的方法，
         * 子类通过实现该方法可以实现不同类型的Holder
         *
         * @return
         */
        protected abstract T getValueFromConfigService();

    }

    private static class ClassBasedConfigHolder<T> extends BaseConfigHolder<T> {

        private Class<T> valueClazz;

        public ClassBasedConfigHolder(String key, Class<T> valueClazz) {
            super(key);
            this.valueClazz = valueClazz;
        }

        @Override
        protected T getValueFromConfigService() {
            return configService.getData(getKey(), valueClazz);
        }

    }

    private static class ConverterBasedConfigHolder<T> extends BaseConfigHolder<T> {

        private ConfigConverter<T> configConverter;

        public ConverterBasedConfigHolder(String key, ConfigConverter<T> configConverter) {
            super(key);
            this.configConverter = configConverter;
        }

        @Override
        protected T getValueFromConfigService() {
            return configService.getData(getKey(), configConverter);
        }

    }

    /**
     * 一个{@link ConfigService}的指针，用于在{@link ConfigHolder}中使用，
     * 该值实际的赋值过程发生在{@link service.config.ConfigServiceImpl}的构造方法里，
     * 因此只有在Spring自动注入后才会拥有合法值
     */
    private static ConfigService configService;

    /**
     * 注入{@link ConfigService}的过程，其他情况下不应该被调用
     *
     * @param configService
     */
    public void setConfigService(ConfigService configService) {
        ConfigUtils.configService = configService;
    }

    /**
     * 提供一个可以在Spring自动注入开始前获取配置项holder的方法，以便减少在bean初始化过程中初始化配置项而导致的编码困难。
     * <p />
     * 通过该方法获取配置值时，配置值通过Nutz的自动转换机制转换为指定的类型
     * <p />
     * <b>注意</b>：该方法虽然可以在自动注入前获取到holder，但此时holder是无法获取配置值的，需等到自动注入完成才能使用！
     *
     * @param key
     * @param valueClass
     * @param <T>
     * @return
     */
    public static <T> ConfigHolder<T> getHolder(String key, Class<T> valueClass) {
        return new ClassBasedConfigHolder<T>(key, valueClass);
    }

    /**
     * 提供一个可以在Spring自动注入开始前获取配置项holder的方法，以便减少在bean初始化过程中初始化配置项而导致的编码困难。
     * <p />
     * 通过该方法获取配置值时，配置值通过指定的转换器转换为指定的类型
     * <p />
     * <b>注意</b>：该方法虽然可以在自动注入前获取到holder，但此时holder是无法获取配置值的，需等到自动注入完成才能使用！
     *
     * @param key
     * @param converter
     * @param <T>
     * @return
     */
    public static <T> ConfigHolder<T> getHolder(String key, ConfigConverter<T> converter) {
        return new ConverterBasedConfigHolder<T>(key, converter);
    }

}