监听者模式示例

public class SwitchMain {

    public static void main(String[] args) {
        Switch switchTest = new Switch();
        switchTest.addListener(new SwitchListener() {
            public void handle(SwitchEvent switchEvent) {
                //Do what ever you want !
                System.out.println("可对该事件进行二次处理: "+switchEvent.getSwitchState());
            }
			public void handle() {
				//SwitchListener=callBack
				 System.out.println("回调执行复杂操作");
				
			}
        });
        //触发
        switchTest.call();
        switchTest.close();
    }
}
/*
 * 类似于Swing中的button
 * 1.添加监听者
 * 2.定义事件同时通知监听者
*/
class Switch {
	private SwitchListener callBack;
	
	public void addListener(SwitchListener callBack){
		this.callBack = callBack;
	}
	
	//此时为回调方法  没有监听者概念
	public void call(){
		callBack.handle();
		//SwitchEvent switchEvent = new SwitchEvent( this, "关");
		//callBack.handle(switchEvent);
	}
	
	public void close(){
		SwitchEvent switchEvent = new SwitchEvent( this, "关");
		notifyListeners(switchEvent);
	}
	
	private void notifyListeners (SwitchEvent switchEvent) {
		callBack.handle(switchEvent);
 }

}
class SwitchEvent  {

    private String switchState;     //表示开关的状态

    public SwitchEvent(Switch source, String switchState) {
        this.switchState = switchState;
    }

    public void setSwitchState(String switchState) {
        this.switchState = switchState;
    }

    public String getSwitchState() {
        return switchState;
    }
}
interface SwitchListener {
	//SwitchListener=callBack()
    void handle();//基于回调的观察者模式
    
    void handle(SwitchEvent event);//支持指定处理事件
}

示例2:监听文件的变化

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class App{
    public static void main( String[] args ) {
    	List<ModulesListener> modules = new ArrayList<ModulesListener>();
    	ModulesListener listener = new ModulesListener("custom.properties");
        listener.addConfigurationListener(new ConfigurationListener() {
            public void configurationChanged(ConfigurationEvent event) {
                System.out.println("ConfigurationListener, " + event.getType() + ", " + event.getModules());
            }
        });
        listener.addKeyListener("name", new PropertiesKeyListener() {
            public void configurationChanged(ConfigurationEvent event, String key, String value) {
                System.out.println("PropertiesKeyListener, " + key + " = " + value);
            }
        });
        ModulesListener listener2 = new ModulesListener("system.properties");
        listener2.addConfigurationListener(new ConfigurationListener() {
            public void configurationChanged(ConfigurationEvent event) {
                System.out.println("ConfigurationListener2, " + event.getType() + ", " + event.getModules());
            }
        });
        listener2.addKeyListener("name", new PropertiesKeyListener() {
            public void configurationChanged(ConfigurationEvent event, String key, String value) {
                System.out.println("PropertiesKeyListener2, " + key + " = " + value);
            }
        });
        modules.add(listener);
        modules.add(listener2);
    	SysProperties.getInstance().addListener(modules);
    	
    }
}
interface ConfigurationListener {
	void configurationChanged(ConfigurationEvent event);
}
interface PropertiesKeyListener {
    void configurationChanged(ConfigurationEvent event, String key, String value);
}

class ConfigurationEvent{
    private EventType type;
    private String modules;
    public ConfigurationEvent(Object source, EventType type) {
        this.type = type;
    }
    public EventType getType() {
        return type;
    }
    public void setType(EventType type) {
        this.type = type;
    }
    public String getModules() {
        return modules;
    }
    public void setModules(String modules) {
        this.modules = modules;
    }
}
class ModulesListener {
    private String name;
    private List<ConfigurationListener> configurationListeners = new ArrayList<ConfigurationListener>();
    private Map<String, PropertiesKeyListener> keyListeners = new HashMap<String, PropertiesKeyListener>();

    public ModulesListener(String name) {
        this.name = name;
    }
	public String getName() {
		return name;
	}
    /**
     * 新增模块更新监听
     *
     * @param listener 监听接口
     */
    public void addConfigurationListener(ConfigurationListener listener) {
        configurationListeners.add(listener);
    }
    /**
     * 新增Properties模块key更新监听
     * @param key 配置项
     * @param listener 监听接口
     */
    public void addKeyListener(String key, PropertiesKeyListener listener) {
        keyListeners.put(key, listener);
    }

    /**
     * 模块更新监听，动作执行
     *
     * @param event
     */
    public void actionConfigurationListener(ConfigurationEvent event) {
        for (ConfigurationListener listener : configurationListeners) {
            listener.configurationChanged(event);
        }
    }
    /**
     * Properties模块key更新监听，动作执行
     *
     * @param event
     * @param key
     * @param value
     */
    public void actionKeyListeners(ConfigurationEvent event, String key, String value) {
        if (keyListeners.containsKey(key)) {
            keyListeners.get(key).configurationChanged(event, key, value);
        }
    }
}
enum EventType {
	ADD, UPDATE, CLEAR;
}

import java.io.File;
import java.io.FileInputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;


/**
 * 读取实时的配置文件信息
 */
public class SysProperties {

	private Map<String, Long> lastModifMap = new HashMap<String, Long>();

	private static SysProperties instance;

	 private Map<String, ModulesListener> modulesListeners = new HashMap<String, ModulesListener>();

	public static SysProperties getInstance() {
		if (instance == null) {
			instance = new SysProperties();
		}
		return instance;
	}

	public void addListener(List<ModulesListener> modules) {
		for(ModulesListener listener:modules){
			modulesListeners.put(listener.getName(), listener);
		}
	}

	/**
	 * @description 私有构造器启动一个线程实时监控配置文件
	 */
	public SysProperties() {

		// 循环监控配置文件的变化，一旦发现文件发生变化了则重读配置文件
		Thread t = new Thread() {
			public void run() {
				while (true) {
					// 间隔1秒
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
					}

					try {
						String path = SysProperties.class.getClass().getResource("/config").getPath();
						File[] tmps = new File(path).listFiles();
						//File[] tmps = new File("E:\\Projects\\JavaProjects\\demo\\src\\main\\resources\\config").listFiles();
						for (File file : tmps) {
							if (file.exists()) {
		                        long l = file.lastModified(); // this can also throw a SecurityException

		                        String fileAbsPath = file.getAbsolutePath();
		                        long lastModif = getLastModif(fileAbsPath);

		                        if (l > lastModif) { // however, if we reached this point this
		                        	recordLastModify(fileAbsPath, l);
		                        	ConfigurationEvent event = null;
		                        	//不知道删除事件
		                        	if(lastModif == 0){
		                        		event = new ConfigurationEvent(file.getName(), EventType.ADD);
										
		                        	}else{
		                        		event = new ConfigurationEvent(file.getName(), EventType.UPDATE);
		                        	}
		                        	event.setModules(file.getName());
		                        	//无法精确key的变化	
									if(modulesListeners.containsKey(file.getName())){
										ModulesListener listener = modulesListeners.get(file.getName());
										Properties properties = transTo(file);
										listener.actionConfigurationListener(event);
										
										listener.actionKeyListeners(event, "name", properties.getProperty("name"));
									}
										
								
		                        }
		                    }
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		};
		t.start();
	}

	
	
	private long getLastModif(String key) {
        long lastModif = 0;
        if (lastModifMap.get(key) != null) {
            lastModif = lastModifMap.get(key).longValue();
        }
        return lastModif;
    }

    private void recordLastModify(String key, Long lastModif) {
        lastModifMap.put(key, lastModif);
    }

    public Properties transTo(File propertyFile){
    	Properties properties = new Properties();
    	FileInputStream inputStreamLocal = null;
		try {
			inputStreamLocal = new FileInputStream(propertyFile);
			properties.load(inputStreamLocal);
			return properties;
		}catch(Exception e){
			e.printStackTrace();
		}
		return properties;
    }
	

}