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(+ " : " + 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(+ " : " + 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(+ " : " + table.getCellValue(i));
  84.                 }
  85.         }
  86.  
  87. }
  88.  
  89. class Table extends Subject {
  90.         private Scanner scan;
  91.         int[] data = { 00000 };
  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. }


'java > design_pattern' 카테고리의 다른 글

Chain of Responsibility Pattern - 책임의 전가  (0) 2014.07.01
MediatorPattern - 중재자 패턴  (0) 2014.07.01
Factory method pattern  (0) 2014.06.27
Flyweight Pattern  (0) 2014.06.27
Prototype Pattern  (0) 2014.06.27

+ Recent posts