当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。
使用场景：

  • 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
  • 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
  • 一个对象必须通知其他对象，而并不知道这些对象是谁。
  • 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
import javax.crypto.interfaces.PBEKey;
import java.util.ArrayList;
import java.util.List;

/**
 * Description
 * Author cloudr
 * Date 2020/8/14 21:03
 * Version 1.0
 **/
class Publish {
    public int single;
    public List<Reader> readers = new ArrayList<>();

    public void setSingle(int single) {
        this.single = single;
        notifyAllReader();
    }

    public int getSingle() {
        return single;
    }

    public void  addReader(Reader reader){
        readers.add(reader);
    }


    public void notifyAllReader(){
        for (Reader reader : readers) {
            reader.doSomething();
        }
    }
}

class   Reader{
    public Publish publish = new Publish();

    public void doSomething() {

    }

}

class ReadA extends Reader {

    public ReadA(Publish publish){
        this.publish = publish;
        this.publish.addReader(this);
    }


    public void doSomething(){
        System.out.println("I'm A, single =" + publish.getSingle());
    }
}

class ReadB extends Reader{
    public ReadB(Publish publish){
        this.publish = publish;
        this.publish.addReader(this);
    }

    public void doSomething(){
        System.out.println("I'm B, single ="+ publish.getSingle());
    }
}

public class PublishReaderDemo{
    public static void main(String[] args) {
        Publish publish = new Publish();
        Reader readerA = new ReadA(publish);
        Reader readerB = new ReadA(publish);
        publish.setSingle(1);
        publish.setSingle(2);
    }
}

参考