功能需求
我们在设计系统的过程当中， 经常会遇到需要读取配置信息需求， 可以想到的几个设计要点是
- 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
* @return
*/
T getData(String key, Class valueClass);
/**
* 获取指定key的配置值，并通过给的的转换器转换类型，若不存在则获取默认key的配置值并转换
*
* @param key
* @param converter
* @param
* @return
*/
T getData(String key, ConfigConverter 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 values = new HashMap();
private ConcurrentHashMap> listenerMap = new ConcurrentHashMap>();
/** 是否进行过初始化 */
private volatile boolean init = false;
/**
* 默认的转换机制是使用Nutz的转换器
*
* @param valueClass
* @param
* @return
*/
private static ConfigConverter getDefaultConverter(final Class valueClass) {
return new ConfigConverter() {
@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 datas = dataDao.getAllDatas();
Map values = new HashMap();
for (Data data : datas) {
values.put(data.getDataKey(), data.getDataValue());
}
Map oldValues = this.values;
this.values = values;
invokeHolder(values, oldValues);
}
/**
* 检查配置值是否有变化，若有变化，通知相关的holder
*
* @param newValues
* @param oldValues
*/
private void invokeHolder(Map newValues, Map oldValues) {
Set allKeys = new HashSet();
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 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 getData(String key, Class valueClass) {
return getData(key, getDefaultConverter(valueClass));
}
@Override
public T getData(String key, ConfigConverter converter) {
String value = getData(key);
// 使用指定的转换器
return converter.convert(value);
}
@Override
public void registerListener(String key, ConfigListener configListener) {
Set listeners = listenerMap.get(key);
if (null == listeners) {
listenerMap.putIfAbsent(key, Collections.newSetFromMap(new ConcurrentHashMap()));
listeners = listenerMap.get(key);
}
listeners.add(configListener);
}
}
- 5 看了刚才的代码， 可能觉得每次使用配置文件有些太复杂了， 每次引用还需要自己去写一个动态代理类， 那么我们可以写一个工具类， 对这个过程做一个简化， 也就是我们默认写好一个holder实现了刚才的注册等功能， 每次调用的时候只需要执行
private ConfigHolder lastName = ConfigUtils.getHolder(ConfigConstants.LAST_NAME, String.class);
address.setLastName(lastName.getValue());
也就是说我们获取的值都是一个个holder， 只要调用它的getValue方法， 就可以保证读到的都是最新的值。
/**
* 系统配置工具类
*
* 该类提供了{@link utils.ConfigUtils.ConfigHolder}的实现，通过该Holder，可以获取到指定配置的值。
* 该类提供了这样一种机制，可以在Spring自动注入开始前获取到相关配置信息的Holder，
* 虽然这些Holder需要等到Spring自动注入完成后才能使用，但能够在自动注入开始前（比如构造方法里）初始化Holder，
* 可以在一些场景下简化代码的实现。
*
*/
public class ConfigUtils {
/**
* 一个可以自动更新配置值的配置获取器
*
* @param
*/
public interface ConfigHolder {
/** 获取配置名称 */
String getKey();
/** 获取配置值 */
T getValue();
}
private static abstract class BaseConfigHolder implements ConfigHolder, ConfigListener {
private String key;
private T value;
private boolean init = false;
public BaseConfigHolder(String key) {
this.key = key;
}
@Override
public String getKey() {
return key;
}
/**
* 获取配置的值
*
* 注意：该方法实际使用了{@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 extends BaseConfigHolder {
private Class valueClazz;
public ClassBasedConfigHolder(String key, Class valueClazz) {
super(key);
this.valueClazz = valueClazz;
}
@Override
protected T getValueFromConfigService() {
return configService.getData(getKey(), valueClazz);
}
}
private static class ConverterBasedConfigHolder extends BaseConfigHolder {
private ConfigConverter configConverter;
public ConverterBasedConfigHolder(String key, ConfigConverter 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初始化过程中初始化配置项而导致的编码困难。
*
* 通过该方法获取配置值时，配置值通过Nutz的自动转换机制转换为指定的类型
*
* 注意：该方法虽然可以在自动注入前获取到holder，但此时holder是无法获取配置值的，需等到自动注入完成才能使用！
*
* @param key
* @param valueClass
* @param
* @return
*/
public static ConfigHolder getHolder(String key, Class valueClass) {
return new ClassBasedConfigHolder(key, valueClass);
}
/**
* 提供一个可以在Spring自动注入开始前获取配置项holder的方法，以便减少在bean初始化过程中初始化配置项而导致的编码困难。
*
* 通过该方法获取配置值时，配置值通过指定的转换器转换为指定的类型
*
* 注意：该方法虽然可以在自动注入前获取到holder，但此时holder是无法获取配置值的，需等到自动注入完成才能使用！
*
* @param key
* @param converter
* @param
* @return
*/
public static ConfigHolder getHolder(String key, ConfigConverter converter) {
return new ConverterBasedConfigHolder(key, converter);
}
}