设计模式-观察者模式应用

        这几天,仔细的看了设计模式的观察者部分,认认真真的翻看了几本书的介绍,终于对这个模式有了新的认识.主要还是说说我对它的理解和应用吧

        设计模式主要还是通过抽象来实现的吧~.所以可以到处看到设计模式中不论那个模式都是带有抽象类,接口等结构的.观察者模式也不例外.观察者模式主要有参与者,具体参与者,观察者和具体观察者.

         参与者主要就是被观察对象的抽象,如java.util.Observable类就是被观察对象的抽象类,它实现了观察者的增加,删除以及通知等方法.而一般都不推荐此种使用,为什么呢?因为Java使用单一继承,如果你的类已经继承了某个类，想再实现被观察的话,就不能通过继承Observable这个类来实现了.这个时候就要采取另外的做法,实现接口.接口定义观察者增加,删除,通知以及状态改变的方法,而在实现该接口的类中去实现这些方法.

         在这里,主要还是说说我对这个模式的应用吧.由于是通信工程毕业,因此一直在思考网络即时通信系统,也就是类似QQ的系统了.在会员状态改变的时候,会提示某某会员已经上线,这个QQ是做的很好的~.不过,发现一个有趣的是,就是在会员离线或者状态改变的时候好象通知就不那么的及时了，不知道QQ是怎么实现的,但我觉得观察者模式在这个地方用一定是非常好的.

         我构造一个Person类来表示会员类,然后每个对象就表示一个会员，为了让会员之间能够彼此通知状态改变，也是利用观察者模式实现这个功能,利用Member类同时实现参与者接口和观察者接口,这样就可以实现会员之间相互通知,即时同志好友的状态变化了~.

         参与者接口为Subject, 观察者接口为Observer, 分别定义如下:

        

1. package common;
4. /**
5.  * @author HUHG
6.  *
7.  */
8. public interface Subject {
9.     public void addObserver(Observer observer);
10.     public void deleteObserver(Observer observer);
11.     public void notifyObservers();
12.     
13.     public boolean hasChanged();
14. }

1. package common;
3. /**
4.  * @author HUHG
5.  *
6.  */
7. public interface Observer {
8.     public void update(Person person);
10. }

 

然后类Person设计如下,其中hasChanged()用来判断用户状态改变是否通知观察者,判断条件改变时可通过改变方法实现即可.代码如下:

1. package common;
3. import java.util.ArrayList;
4. import java.util.Iterator;
5. import java.util.List;
7. /**
8.  * 同一个类,实现观察者和可被观察接口
9.  * @author HUHG
10.  *
11.  */
12. public class Person implements Subject, Observer {
13.     private String name= "";
14.     
15.     private int status= 0;
16.     private boolean isChanged= false;
17.     
18.     private List<Observer> observerList;
19.     
20.     /**
21.      * @param status
22.      */
23.     public Person(String name) {
24.         super();
25.         this.name= name;
26.         
27.         observerList= new ArrayList<Observer>();
28.     }
30.     /**
31.      * @return the name
32.      */
33.     public String getName() {
34.         return name;
35.     }
37.     /**
38.      * @param name the name to set
39.      */
40.     public void setName(String name) {
41.         this.name = name;
42.     }
44.     /**
45.      * @return the status
46.      */
47.     public int getStatus() {
48.         return status;
49.     }
51.     /**
52.      * 设置对象状态,并通知观察者状态已改变
53.      * @param status the status to set
54.      */
55.     public void setStatus(int status) {
56.         this.status = status;
57.         
58.         if(hasChanged()){
59.             notifyObservers();
60.         }
61.     }
63.     /* (non-Javadoc)
64.      * @see common.Observable#addObserver(java.util.Observer)
65.      */
66.     public void addObserver(Observer observer) {
67.         observerList.add(observer);
69.     }
71.     /* (non-Javadoc)
72.      * @see common.Observable#deleteObserver(java.util.Observer)
73.      */
74.     public void deleteObserver(Observer observer) {
75.         observerList.remove(observer);
77.     }
79.     /* (non-Javadoc)
80.      * 通知所有观察者对象状态已经改变
81.      * @see common.Observable#notifyObsrevers()
82.      */
83.     public void notifyObservers() {
84.         Iterator<Observer> iterator= observerList.iterator();
85.         while(iterator.hasNext()){
86.             Observer observer= iterator.next();
87.             observer.update(this);
88.         }
90.     }
92.     /* (non-Javadoc)
93.      * 输出显示被观察对象状态已经改变
94.      * @see common.Observer#update(common.Person)
95.      */
96.     public void update(Person person) {
97.         System.out.println("Name: "+ name);
98.         System.out.println("Friend: "+ person.getName()+ " Status has changed! Now status is "+ person.getStatus());
99.         
100.     }
102.     
103.     /* (non-Javadoc)
104.      * 确定是否需要通知观察者状态已改变
105.      * @see common.Subject#hasChanged()
106.      */
107.     public boolean hasChanged() {
108.         // TODO Auto-generated method stub
109.         if(this.getStatus()== 1){
110.             this.isChanged= true;
111.         }
112.         
113.         return isChanged;
114.     }
116. }

        这样所需要的代码就实现了,然后运行测试是否能正确运行.测试类如下:

1. package common;
3. /**
4.  * @author HUHG
5.  *
6.  */
7. public class TestStatus {
9.     /**
10.      * @param args
11.      */
12.     public static void main(String[] args) {
13.         // TODO Auto-generated method stub
14.         Person John= new Person("John");
15.         Person Lily= new Person("Lily");
16.         Person Lucy= new Person("Lucy");
17.         John.addObserver(Lily);
18.         Lucy.addObserver(Lily);
19.         
20.         John.setStatus(1);
21.         Lucy.setStatus(1);
22.     }
24. }

 

运行,输出如下:

Name: Lily
Friend: John Status has changed! Now status is 1
Name: Lily
Friend: Lucy Status has changed! Now status is 1

说明状态改变的时候便会通知好友状态改变,这样就实现了观察者模式的应用~.