ObserverPattern - 관찰자 패턴

Observer Pattern

 - 관찰자(Observer), 대상자(Subject)

Subject 에서 Observer에 데이터를 전달하는 2가지 방식

 1. Push -> Subject가 Observer에게 전달하는 방식

 2.  Pull -> Observer가 Subject로 부터 직접 꺼내가는 방식

1. // Pull 방식
2. abstract class IObserver {
3.         private Subject subject;
4.  
5.         public Subject getSubject() {
6.                 return subject;
7.         }
8.  
9.         public abstract void update(Object arg);
10.  
11.         public void setSubject(Subject ib) {
12.                 subject = ib;
13.         }
14. }
15.  
16. abstract class Subject {
17.         List<IObserver> observers = new ArrayList<>();
18.  
19.         public Subject() {
20.                
21.         }
22.         public void addObserver(IObserver ib) {
23.                 observers.add(ib);
24.                 ib.setSubject(this);
25.         }
26.  
27.         public void removeObjserver(IObserver ib) {
28.                 observers.remove(ib);
29.         }
30.  
31.  
32.         public void notifyDataSetChanged(Object data) {
33.                 for (IObserver e : observers) {
34.                         e.update(data);
35.                 }
36.         }
37.  
38.         public abstract boolean edit();
39. }
40.  
41. class BarGraph extends IObserver {
42.  
43.         @Override
44.         public void update(Object arg) {
45.                 int[] data = (int[]) arg;
46.                 System.out.println("########### Bar Graph ############");
47.                 for (int i = 0; i < data.length; i++) {
48.                         System.out.println(i + " : " + data[i]);
49.                 }
50.         }
51.  
52. }
53. class CircleGraph extends IObserver {
54.        
55.         @Override
56.         public void update(Object arg) {
57.                 int[] data = (int[]) arg;
58.                 System.out.println("########### Circle Graph ############");
59.                 for (int i = 0; i < data.length; i++) {
60.                         System.out.println(i + " : " + data[i]);
61.                 }
62.         }
63.        
64. }
65.  
66. class PieGraph extends IObserver {
67.  
68.         @Override
69.         public void update(Object arg) {
70.                 int[] data = (int[]) arg;
71.                 // Pull 방식
72.                 // Subject가 변겨오디었을 경우 표에서 data를 끌어와야한다.
73.                 // Subject의 참조를 얻어낸다.
74.                 Table table = (Table) getSubject(); // 강하게 결합된다.
75.                 // 단점 : 캐스팅이 필요하다.
76.                 // 장점 : Table의 모든 메소드를 호출 가능하므로
77.                 // data를 인자로 전달 받을 때 마다 훨씬ㄷ ㅓ많은 정보를 얻어낼 수 있다.
78.                 // 강하게 결합된다.
79.                 // 디자인 측면에서 좋지 않다.
80.                 // Push 방식이 더 선호된다.
81.                 System.out.println("########### Pie Graph ############");
82.                 for (int i = 0; i < data.length; i++) {
83.                         System.out.println(i + " : " + table.getCellValue(i));
84.                 }
85.         }
86.  
87. }
88.  
89. class Table extends Subject {
90.         private Scanner scan;
91.         int[] data = { 0, 0, 0, 0, 0 };
92.         public int getCellValue(int index) {
93.                 return data[index];
94.         }
95.  
96.         public boolean edit() {
97.                 scan = new Scanner(System.in);
98.                 System.out.println("Index >>");
99.                 int idx = scan.nextInt();
100.                 if (idx == 99) {
101.                         return false;
102.                 }
103.                 System.out.println("Data >>");
104.                 data[idx] = scan.nextInt();
105.  
106.                 notifyDataSetChanged(data);
107.                 return true;
108.         }
109. }
110.  
111. public class Ex2 {
112.  
113.         public static void main(String[] args) {
114.                 Table table = new Table();
115.                 table.addObserver(new PieGraph());
116.                 table.addObserver(new BarGraph());
117.                 while (table.edit()) {
118.                 }
119.         }
120.  
121. }