Java的观察者与被观察者模式

1.观察者模式：定义了一种一对多(1-n)的依赖关系，让多个观察者对象同时监听同一个主题对象，当主题对象内部状态发生变化时，通知所有观察者

观察者模式有以下组成：

-两个抽象角色：一个是观察者，一个是被观察者

---（被观察者）抽象主题角色：将所有观察者对象的引用放到一个集合里，提供接口用于增删，一般用抽象类或者接口实现，使用java提供的Observable接口,程序中的被观察者类需要继承Observable，具体看AccountObserveable.java。

---（观察者）抽象观察者：使用java提供的Observer，作为观察者类，需要实现这个接口中的update（）方法。具体实现看ApiObserver.java。

AccountObserveable.java

public class AccountObserveable extends Observable {

    private static BaseLog log = BaseLog.getInstance(AccountObserveable.class.getName());

    private static AccountObserveable accoutObserved = new AccountObserveable();

    private AccountObserveable() {
    }

    public static AccountObserveable getInstance() {
        return accoutObserved;
    }

    @Override
    public synchronized void addObserver(Observer o) {
        log.info("AccountObserveable addObserver " + o.getClass().getName());
        super.addObserver(o);
    }

    /**
     * 上链回调
     */
    public boolean sendResult(TransactionIndex tranIndex) {
        log.info("AccountObserveable sendResult");
        boolean result = false;
        if (tranIndex == null)
            return result;

        try {
            this.setChanged();
            this.notifyObservers(tranIndex);
            result = true;
        } catch (WebBaseException wbe) {
            log.error(wbe.getExceptionMessage().toString());
            return result;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return result;
        }
        return result;
    }

/**
     * 错误信息返回
     * 
     * @param error
     */
    public boolean sendResult(ErrorResult error) {
        log.info("AccountObserveable sendResult ErrorResult:" + error);
        boolean result = false;
        if (error == null)
            return result;

        try {
            this.setChanged();
            this.notifyObservers(error);
            result = true;
        } catch (WebBaseException wbe) {
            log.debug(wbe.getExceptionMessage().toString());
            result = false;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            result = false;
        }
        return result;
    }
 

ApiObserver.java：

public class ApiObserver implements Observer {
    static BaseLog log = BaseLog.getInstance(ApiObserver.class.getName());
    private static ApiObserver apiObserver = new ApiObserver();

    private ApiObserver() {
    }

    public static ApiObserver getInstance() {
        return apiObserver;
    }

    /**
     * 接收通知者的通知,做出相应改变
     */
    @Override
    public void update(Observable o, Object param) {
        log.info("ApiObserver update:" + param);
        if (param instanceof TransactionIndex) {
            // 交易上链
            TransactionIndex transIndex = (TransactionIndex) param;
            ClientInterface.transaction(transIndex);
        } else if (param instanceof ErrorResult) {
            // 错误返回接口
            ErrorResult error = (ErrorResult) param;
            ClientInterface.errorMsg(error);
        } 
    }

}