[享学Netflix] 二、Apache Commons Configuration事件监听机制及使用ReloadingStrategy实现热更新

public class ConfigurationEvent extends EventObject {
	
	// 事件类型
	private int type;
	// 属性名
	private String propertyName;
	// 属性值
	private Object propertyValue;
	// update之前标志位 默认是false
	// 标记此事件是在源配置更新之前还是之后生成的。
	private boolean beforeUpdate;

	// 请注意：父类还有个最重要的属性：事件对象  它是不能为null的
	protected transient Object  source;
	
	... // 省略构造器，以及所有get方法
}

public class ConfigurationErrorEvent extends ConfigurationEvent {
	
	// 导致发送此事件的错误原因
	private Throwable cause;
	... // 省略构造器及getCause()方法
}

public interface ConfigurationListener {
	void configurationChanged(ConfigurationEvent event);
}

public interface ConfigurationErrorListener {
	void configurationError(ConfigurationErrorEvent event);
}

public class EventSource {

	// 注册的监听器们
	private Collection<ConfigurationListener> listeners;
	private Collection<ConfigurationErrorListener> errorListeners;

	private final Object lockDetailEventsCount = new Object();
	// 详细事件的计数器
	private int detailEvents;

	// 唯一构造器：完成集合的初始化 变为线程安全的集合CopyOnWriteArrayList
    public EventSource() {
        initListeners();
    }
    private void initListeners() {
        listeners = new CopyOnWriteArrayList<ConfigurationListener>();
        errorListeners = new CopyOnWriteArrayList<ConfigurationErrorListener>();
    }

	public void addConfigurationListener(ConfigurationListener l) { ... }
	public boolean removeConfigurationListener(ConfigurationListener l) { ... }
	// 返回的是个视图
	public Collection<ConfigurationListener> getConfigurationListeners() { ... }
    public void clearConfigurationListeners() {
        listeners.clear();
    }
    ... // 省略error的增删改查方法

	// 确定是否应生成详细事件。如果启用,一些方法可以生成多个更新事件。
	// 注意这个方法记录调用次数，例如如果setDetailEvents(false)}被调用三次
	// 您将必须经常调用该方法以启用细节。
	public void setDetailEvents(boolean enable) { ... detailEvents++; ... }
    private boolean checkDetailEvents(int limit) {
        synchronized (lockDetailEventsCount) {
            return detailEvents > limit;
        }
    }

	// 创建事件对象，并将其交付给所有已注册的事件。也就是让所有关心它的监听器执行
	// 注意：这里执行的正常事件（非错误事件）
	protected void fireEvent(int type, String propName, Object propValue, boolean before) {
		if (checkDetailEvents(-1)) {
			Iterator<ConfigurationListener> it = listeners.iterator();
			if (it.hasNext()) { // 这句相当于判空，下面while才是一个个执行
				ConfigurationEvent event = createEvent(type, propName, propValue, before);
				// 把监听器一个个的执行掉
                while (it.hasNext()) {
                    it.next().configurationChanged(event);
                }
			}
		}
	}
	protected void fireError(int type, String propName, Object propValue, Throwable ex) { ... }

	// 子类可复写构造一个ConfigurationEvent 实例的方法
	// 比如根据type、propName来判断等等逻辑
    protected ConfigurationEvent createEvent(int type, String propName, Object propValue, boolean before) {
        return new ConfigurationEvent(this, type, propName, propValue, before);
    }
	...
}

public abstract class AbstractConfiguration extends EventSource implements Configuration {

	// 它定义了很多事件类型哦，并且还都是public可访问的
	public static final int EVENT_ADD_PROPERTY = 1;
	public static final int EVENT_CLEAR_PROPERTY = 2;
	public static final int EVENT_SET_PROPERTY = 3;
	public static final int EVENT_CLEAR = 4;
	public static final int EVENT_READ_PROPERTY = 5;

	// 可以使用${}引用其它属性值
	protected static final String START_TOKEN = "${";
	protected static final String END_TOKEN = "}";

	// List请用逗号分隔
	private static char defaultListDelimiter = ',';
	
	... // 生路基本属性的赋值、get方法

	// 下面是对Configuration的改变方法，需要发出事件
	
	// 动作前、后都发出了对应的事件
    public void addProperty(String key, Object value) {
        fireEvent(EVENT_ADD_PROPERTY, key, value, true);
        addPropertyValues(key, value, isDelimiterParsingDisabled() ? DISABLED_DELIMITER : getListDelimiter());
        fireEvent(EVENT_ADD_PROPERTY, key, value, false);
    }
    // 抽象方法：直接添加 -> 不触发事件的发送
    protected abstract void addPropertyDirect(String key, Object value);

	// 同样的，前后均发送事件
	public void setProperty(String key, Object value) {
		fireEvent(EVENT_SET_PROPERTY, key, value, true);
		setDetailEvents(false);
        try {
            clearProperty(key);
            addProperty(key, value);
        } finally {
            setDetailEvents(true);
        }
        fireEvent(EVENT_SET_PROPERTY, key, value, false);
	}
	... // 其它的类同
}

DatabaseConfiguration：

	public Object getProperty(String key) {
		...
		try {
			...
		} catch (SQLException e) {
			fireError(EVENT_READ_PROPERTY, key, null, e);
		}
		...
	}

JNDIConfiguration：

	public Object getProperty(String key) {
		...
		try {
			...
		} catch (NamingException e)
			fireError(EVENT_READ_PROPERTY, key, null, e);
			return null;
		}
		...
	}

@Test
public void fun4() throws ConfigurationException {
    PropertiesConfiguration configuration = new PropertiesConfiguration("1.properties");
    // 注册一个监听器
    configuration.addConfigurationListener(event -> {
        Object source = event.getSource(); // 事件源
        int type = event.getType();
        if(!event.isBeforeUpdate()){ // 只关心update后的事件，否则会执行两次哦，请务必注意
            System.out.println("事件源：" + source.getClass());
            System.out.println("事件type类型：" + type);

            // 处理你自己的逻辑
        }
    });

    // 增加一个属性，会同步触发监听器去执行
    configuration.addProperty("common.addition","additionOne");
    System.out.println(configuration.getString("common.addition"));
}

事件源：class org.apache.commons.configuration.PropertiesConfiguration
事件type类型：1
additionOne

public interface ReloadingStrategy {
	// 设置configuration被这个策略所管理的
	void setConfiguration(FileConfiguration configuration);
	
	// 初始化此策略
	void init();
	// 评估策略：是否需要重新加载配置
	boolean reloadingRequired();
	
	// 通知策略文件已被重新加载（通知）
	void reloadingPerformed();
}

public class FileChangedReloadingStrategy implements ReloadingStrategy {

	private static final String JAR_PROTOCOL = "jar";
	// 默认最多5秒钟才会去访问一次磁盘，这就是最大延迟
	private static final int DEFAULT_REFRESH_DELAY = 5000;
	// 它的实例有形如：PropertiesConfiguration、XMLConfiguration等都是它的子类
	protected FileConfiguration configuration;
	// 最后一次修改的时间戳
	protected long lastModified;
	// minimum delay
	protected long refreshDelay = DEFAULT_REFRESH_DELAY;

	// 标志位：是否正在正在重新加载中
	private boolean reloading;
	
	...
	
	@Override
    public void setConfiguration(FileConfiguration configuration) {
        this.configuration = configuration;
    }
    // 初始化的时候，就touch一下lastModified时间戳
    @Override
    public void init() {
        updateLastModified();
    }
    @Override
    public void reloadingPerformed() {
        updateLastModified();
    }

    // 给lastModified重新赋值
    protected void updateLastModified() {
		// 拿到这个配置关联到的文件，如：configuration.getFile() / configuration.getURL()
        File file = getFile();
        if (file != null) {
            lastModified = file.lastModified();
        }
        reloading = false;
    }

	@Override
    public boolean reloadingRequired() {
    	// 如果没有正在重新加载中，那就进来处理
        if (!reloading) {
            long now = System.currentTimeMillis();
			// 继续判断：两次间隔超过了refreshDelay，才继续执行
            if (now > lastChecked + refreshDelay) {
                lastChecked = now;
				// file.lastModified() > lastModified 证明文件已经改变过啦
                if (hasChanged()) {
                    if (logger.isDebugEnabled())
                        logger.debug("File change detected: " + getName());
                    reloading = true;
                }
            }
        }
        return reloading;
    }
    ...
}

AbstractFileConfiguration：

	protected ReloadingStrategy strategy;
    public void reload() {
        reload(false);
    }
    public boolean reload(boolean checkReload) {
		...
		if (strategy.reloadingRequired()) {
			// 发送事件
			refresh(); 
			strategy.reloadingPerformed();
		}
    }

	// 刷新 --> 重要方法
	public void refresh() throws ConfigurationException {
		... // 发送before事件，事件类型是：EVENT_RELOAD
		try {
			clear(); // 先情况，再加载
			load(); // 重新从文件里加载最新内容
		} finally { ... }
		clear();
		load();
		... // 发送after事件，事件类型是：EVENT_RELOAD
	}

AbstractFileConfiguration：

    @Override
    public Object getProperty(String key) {
    	...
    	reload();
    	return super.getProperty(key);
    }
    @Override
    public boolean isEmpty() {
    	reload();
    	return super.isEmpty();
    }
    @Override
    public boolean containsKey(String key) {
    	reload();
    	return super.containsKey(key);
    }
    @Override
    public Iterator<String> getKeys() {
    	reload();
    	...
    }

@Test
public void fun5() throws ConfigurationException {
    PropertiesConfiguration configuration = new PropertiesConfiguration("1.properties");

    // 监听到配置文件被重新加载了就输出一条日志喽~
    configuration.addConfigurationListener(event -> {
        // 只监听到重新加载事件
        if (event.getType() == PropertiesConfiguration.EVENT_RELOAD) {
            System.out.println("配置文件重载...");
            configuration.getKeys().forEachRemaining(k -> {
                System.out.println("/t " + k + "-->" + configuration.getString(k));
            });
        }
    });

    // 使用文件改变重载策略：让改变文件能热加载
    FileChangedReloadingStrategy reloadingStrategy = new FileChangedReloadingStrategy();
    reloadingStrategy.setRefreshDelay(3000L); // 设置最小事件间隔，单位是毫秒
    configuration.setReloadingStrategy(reloadingStrategy);

    // 使用另外一个线程模拟去get
    otherThreadGet(configuration);

    // hold住main线程，不让程序终止
    while (true) {}
}

private void otherThreadGet(PropertiesConfiguration configuration) {
    new Thread(() -> {
        while (true) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            configuration.getString("commmon.name");
        }
    }).start();

}

配置文件重载...
/t common.name-->YourBatman
/t common.age-->18
/t common.addr-->China
/t common.count-->4
/t common.out-->1
/t common.fullname-->YourBatman-Bryant
/t java.version-->1.8.123
配置文件重载...
// 注意：common.name这一行是被我动态删除掉了，所以此处木有
/t common.age-->18
/t common.addr-->China
/t common.count-->4
/t common.fullname-->YourBatman-Bryant
/t java.version-->1.8.123