观察者模式

定义

定义对象间一种一对多的依赖关系，使得当一个对象改变状态，所以依赖它的对象都会收到通知并被自动更新。

使用场景

• 事件多级触发场景
• 跨系统的消息交互场景，消息队列、事件总线、广播
• 关联行为场景、一对多且变化频繁的场景、如UI改变

结构

• Subject

抽象主题，也就是被观察者Observable，把所有观察者对象的引用保存在一个集合里，每个主题都可以有任意数量的观察者，会提供接口来增加和删除观察者对象

• ConcreateSubject

  具体主题，将有关状态存入具体观察者对象，在具体主题对象内部发生变化时，给所有注册过的观察者发送通知

• Observer

  抽象观察者，定义更新接口，使得在得到主题更改的通知时候更新自己

• ConcreateObserver

  具体观察者，实现抽象观察者角色定义的更新接口

JDK中已经内置了抽象主题对象Observable和抽象观察者对象Observer，可以直接使用

简单实现

//抽象目标类，被观察者
public abstract class Login {
    protected ArrayList observers = new ArrayList();

    public abstract void register(LoginObserver observer);

    public abstract void unregister(LoginObserver observer);

    public abstract void loginNotify(UserBean loginBean);

    public abstract void exitNotify();

}

//抽象观察者类
public interface LoginObserver {

    void login(UserBean loginBean);//登录成功

    void exit();//退出登录
}

//具体目标类,具体目标类的变动将引发具体观察者类做出相应的动作
public class ConcreteLogin extends Login {

    private static ConcreteLogin concreteLogin;

    public static ConcreteLogin getInstance() {
        if (concreteLogin == null) {
            synchronized (ConcreteLogin.class) {
                if (concreteLogin == null) {
                    concreteLogin = new ConcreteLogin();
                }
            }
        }

        return concreteLogin;
    }


    @Override
    public void register(LoginObserver observer) {
        observers.add(observer);
    }

    @Override
    public void unregister(LoginObserver observer) {
        observers.remove(observer);
    }

    @Override
    public void loginNotify(UserBean loginBean) {
        String password = loginBean.getPassword();
        String userName = loginBean.getUserName();

        Boolean success = false;
        //模拟登录
        if (password.contains("123") && userName.contains("123")) {
            success = true;
        }

        for (Object obs : observers) {
            LoginObserver loginObserver = (LoginObserver) obs;
            if (success) {
                Log.v(getClass().getSimpleName(), "登录成功");
                loginObserver.login(loginBean);
            } else {
                Log.v(getClass().getSimpleName(), "登录失败");
            }
        }

    }

    @Override
    public void exitNotify() {
        Log.v(getClass().getSimpleName(), "退出登录");
        for (Object obs : observers) {
            LoginObserver loginObserver = (LoginObserver) obs;
            loginObserver.exit();
        }
    }
}

//具体观察者2
public class ObserverActivity2 extends AppCompatActivity implements LoginObserver, View.OnClickListener {
    TextView account, pwd;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_observer2);

        account = (TextView) findViewById(R.id.account);
        pwd = (TextView) findViewById(R.id.pwd);

        ConcreteLogin.getInstance().register(this);

        findViewById(R.id.bt_login).setOnClickListener(this);

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ConcreteLogin.getInstance().unregister(this);
    }


    @Override
    public void login(UserBean loginBean) {
        //登录用户信息变动   UI做出相应调整
        account.setText(loginBean.getPassword());
        pwd.setText(loginBean.getUserName());
        //对用户数据做出相应处理  ...
    }

    @Override
    public void exit() {
        account.setText("");
        pwd.setText("");
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.bt_login:
                Intent intent = new Intent();
                intent.setClass(this, LoginControlActivity.class);
                startActivity(intent);
                break;
            default:
                break;
        }
    }
}

LoginControlActivity关键代码

    public void doLogin(View view) {
        UserBean loginBean = new UserBean(getUserName(), getPwd());
        ConcreteLogin.getInstance().loginNotify(loginBean);
    }


    public void doExit(View view) {
        ConcreteLogin.getInstance().exitNotify();
    }

当执行doLogin（）方法时，如果登录成功，则所有注册了注册过的观察者对象都将收到通知，即会执行LoginObserver接口的login（）回调，从而来执行UI更新等逻辑。

使用观察者模式，记得在不需要使用的时候将观察者注销掉，否则容易造成内存泄露

小结

观察者模式最大的特点就是对象的解耦，观察者与被观察完全隔离，只依赖于Observer和Observable抽象；

观察者模式的思想被众多框架和控制吸收，如 Rxjava事件流、Eventbus消息监听、Listview和RecyclerView的Adapter更新ui、广播、事件机制等