Design mode-Viewer mode

The Observer pattern is a very common design pattern that can be found in many systems, especially when it comes to the need for notification of changes in the state of the data.
This article takes Abstractcursor as an example, unfolds the analysis.
Observer mode, Observer pattern, is a very practical mode, I have been exposed to various platforms and have been involved in the project in the print template interpreter used in this mode.

1. Intentions
Defines a one-to-many dependency between objects, and when an object's state changes, all objects that depend on it are notified and automatically updated.
Hot words: dependency on Publish-subscribe event Notification Update Listener

2. Structure

This is the simplest observer pattern, where the target object is able to add and remove observers, and when a certain state or behavior changes, the notify notifies the registered observer to update the operation.
Analyzing the specific situation of the abstractcursor, we find that the actual work sometimes requires a unified management of the observer, even the observer type has many kinds and can be divided into several series, this time is to be more complex, through the rational stratification of the problem is good solution. Here's how we draw the observer pattern structure used in ABSTRACTCUROSR in Android, depending on the situation:

The viewer is divided into two series.

3. Code
The relevant core code is listed below:

2. Public Abstract class Abstractcursor {
4. //Definition Manager
6. Datasetobservable mdatasetobservable = new datasetobservable ();
8. Contentobservable mcontentobservable = new contentobservable ();
12. //Register and uninstall two types of observers
14. public void Registercontentobserver (Contentobserver observer) {
16. MCONTENTOBSERVABLE.REGISTEROBSERVER (Observer);
18. }
22. public void Unregistercontentobserver (Contentobserver observer) {
24. //cursor would unregister all observers when it close
26. if (!mclosed) {
28. MCONTENTOBSERVABLE.UNREGISTEROBSERVER (Observer);
30. }
32. }
36. public void Registerdatasetobserver (Datasetobserver observer) {
38. MDATASETOBSERVABLE.REGISTEROBSERVER (Observer);
42. }
46. public void Unregisterdatasetobserver (Datasetobserver observer) {
48. MDATASETOBSERVABLE.UNREGISTEROBSERVER (Observer);
50. }
54. //2 Class Notification method
56. protected void OnChange (boolean selfchange) {
58. synchronized (mselfobserverlock) {
60. Mcontentobservable.dispatchchange (Selfchange);
62. if (Mnotifyuri! = null && selfchange) {
64. Mcontentresolver.notifychange (Mnotifyuri, mselfobserver);
66. }
68. }
70. }
74. protected void Notifydatasetchange () {
76. Mdatasetobservable.notifychanged ();
78. }
80. }

Then look at the Observable<t> class and the Datasetobservable class:

2. Public Abstract class Observable<t> {
4. /**  
6. * Viewer List
8. */
10. protected Final arraylist<t> mobservers = new arraylist<t> ();
14. public void Registerobserver (T observer) {
16. if (Observer = = null) {
18. throw New IllegalArgumentException ("The Observer is null.");
20. }
22. synchronized (mobservers) {
24. if (Mobservers.contains (Observer)) {
26. throw New IllegalStateException ("Observer" + Observer + "is already registered.");
28. }
30. MOBSERVERS.ADD (Observer);
32. }
34. }
40. public void Unregisterobserver (T observer) {
42. if (Observer = = null) {
44. throw New IllegalArgumentException ("The Observer is null.");
46. }
48. synchronized (mobservers) {
50. int index = MOBSERVERS.INDEXOF (Observer);
52. if (index = =-1) {
54. throw New IllegalStateException ("Observer" + Observer + "is not registered.");
56. }
58. Mobservers.remove (index);
60. }
62. }
66. public void UnregisterAll () {
68. synchronized (mobservers) {
70. Mobservers.clear ();
72. }
74. }
76. }

And

2. Public class Datasetobservable extends observable<datasetobserver> {
4. /**  
6. * Notify all observers when data changes
8. */
10. public void notifychanged () {
12. synchronized (mobservers) {
14. For (Datasetobserver observer:mobservers) {
16. Observer.onchanged ();
18. }
20. }
22. }
24. //... ... (Other methods)
26. }

The Observer Datasetobserver class is an abstract class:

1. Public Abstract class Datasetobserver {
2. public void onChanged () {
3. // do nothing
4. }
5. }

So we look at its subclasses specifically:

2. Public class Alphabetindexer extends datasetobserver{
4. /*  
6. * @hide is hidden by the Android system
8. */
10. @Override
12. public void onChanged () {
14. //Observed data changes, observers do what they should do
16. super.onchanged ();
18. Malphamap.clear ();
20. }
22. }

Contentobserver is similar.

4. Effects
(1). Behavioral mode
(2). Abstract coupling between the target and the Observer (Classic implementation).
(3). Support Broadcast communication (believe that Android developers should be enlightened after seeing it).
(4). Pay attention to unexpected updates, which is one of the reasons why the Watcher update is being managed.

Design mode-Viewer mode