国产精品美女www爽爽爽,国产精品一区二区三区成人,日本高清视频一区二区三区

fly — Tue, 27 Nov 2018 14:51:00 GMT

1. 前言

单例(Singleton)应该是开发者们最熟悉的设计模式了�Q��ƈ且好像也是最�Ҏ��实现�?#8212;—基本上每个开发者都能够随手写出——但是�Q�真的是�q�样吗？

作�ؓ一个Java开发者，也许你觉得自己对单例模式的了解已�l��够多了。我�q�不惛_��a�耸听说一定还有你不知道的——毕竟我自��q��了解也的��有限，但究竟你自己了解的程度到底怎样呢？往下看�Q�我们一��h��聊聊看~

2. 什么是单例�Q?/p>

单例对象的类必须保证只有一个实例存�?#8212;—�q�是�l�基癄��上对单例的定义，�q�也可以作�ؓ�Ҏ��囑֮�现单例模式的代码�q�行��验的标准�?/p>

对单例的实现可以分�ؓ两大�c?#8212;—懒汉式和饿汉式，他们的区别在于：

懒汉式：指全局的单例实例在�W�一�ơ被使用时构建�?/p>
饿汉式：指全局的单例实例在�c�装载时构徏�?/p>

从它们的区别也能看出来，日常我们使用的较多的应该是懒汉式的单例，毕竟按需加蝲才能做到资源的最大化利用嘛~

3. 懒汉式单�?/p>

先来看一下懒汉式单例的实现方式�?/p>

3.1 ��单版�?/p>

看最��单的写法Version 1�Q?/p>

// Version 1 public class Single1 {     private static Single1 instance;     public static Single1 getInstance() {         if (instance == null) {             instance = new Single1();         }         return instance;     } }

或者再�q�一步，把构造器改�ؓ�U�有的，�q�样能够防止被外部的�c�调用�?/p>

// Version 1.1 public class Single1 {     private static Single1 instance;     private Single1() {}     public static Single1 getInstance() {         if (instance == null) {             instance = new Single1();         }         return instance;     } }

我仿佛记得当初学校的教科书就是这么教的？—— 每次获取instance之前先进行判断，如果instance为空��new一个出来，否则��q��接返回已存在的instance�?/p>

�q�种写法在大多数的时候也是没问题的。问题在于，当多�U�程工作的时候，如果有多个线�E�同时运行到if (instance == null)�Q�都判断为null�Q�那么两个线�E�就各自会创��Z��个实�?#8212;—�q�样一来，��׃��是单例了�?/p>

3.2 synchronized版本

那既然可能会因�ؓ多线�E�导致问题，那么加上一个同步锁吧！

修改后的代码如下�Q�相对于Version1.1�Q�只是在�Ҏ��{�֐�上多加了一个synchronized�Q?/p>

// Version 2  public class Single2 {     private static Single2 instance;     private Single2() {}     public static synchronized Single2 getInstance() {         if (instance == null) {             instance = new Single2();         }         return instance;     } }

OK�Q�加上synchronized关键字之后，getInstance�Ҏ��׃��锁上了。如果有两个�U�程�Q�T1、T2�Q�同时执行到�q�个�Ҏ��Ӟ��会有其中一个线�E�T1获得同步锁，得以�l�箋执行�Q�而另一个线�E�T2则需要等待，当第T1执行完毕getInstance之后�Q�完成了null判断、对象创建、获得返回��g��后）�Q�T2�U�程才会执行执行�?#8212;—所以这端代码也��避免了Version1中，可能出现因�ؓ多线�E�导致多个实例的情况�?/p>

但是�Q�这�U�写法也有一个问题：�l�gitInstance�Ҏ��加锁�Q�虽然会避免了可能会出现的多个实例问题，但是会强刉��T1之外的所有线�E�等待，实际上会对程序的执行效率造成负面影响�?/p>

3.3 双重��查（Double-Check�Q�版�?/p>

Version2代码相对于Version1d代码的效率问题，其实是�ؓ了解�?%几率的问题，而��用了一�?00%出现的防护盾。那有一个优化的思�\�Q�就是把100%出现的防护盾�Q�也改�ؓ1%的几率出玎ͼ�使之只出现在可能会导致多个实例出现的地方�?/p>

——有没有这��L��Ҏ��呢？当然是有的，改进后的代码Vsersion3如下�Q?/p>

// Version 3  public class Single3 {     private static Single3 instance;     private Single3() {}     public static Single3 getInstance() {         if (instance == null) {             synchronized (Single3.class) {                 if (instance == null) {                     instance = new Single3();                 }             }         }         return instance;     } }

�q�个版本的代码看��h��有点复杂�Q�注意其中有两次if (instance == null)的判断，�q�个叫做『双重检�?Double-Check』�?/p>

�W�一个if (instance == null)�Q�其实是��Z��解决Version2中的效率问题�Q�只有instance为null的时候，才进入synchronized的代码段——大大减少了几率�?/p>
�W�二个if (instance == null)�Q�则是跟Version2一��P��是�ؓ了防止可能出现多个实例的情况�?/p>

—— �q�段代码看�v来已�l�完��无瑕了�?/p>

……

—— 当然�Q�只是『看��h��』，�q�是有小概率出现问题的�?/p>

�q�弄清楚��Z��么这里可能出现问题，首先�Q�我们需要弄清楚几个概念�Q�原子操作、指令重排�?/p>

知识点：什么是原子操作�Q?/p>

��单来��_��原子操作�Q�atomic�Q�就是不可分割的操作�Q�在计算��Z��Q�就是指不会因�ؓ�U�程调度被打断的操作�?/p>

比如�Q�简单的赋值是一个原子操作：

m = 6; // �q�是个原子操�?/span>

假如m原先的��gؓ0�Q�那么对于这个操作，要么执行成功m变成�?�Q�要么是没执行m�q�是0�Q�而不会出现诸如m=3�q�种中间�?#8212;—即��是在�q�发的线�E�中�?/p>

而，声明�q�赋值就不是一个原子操作：

int n = 6; // �q�不是一个原子操�?/span>

对于�q�个语句�Q�至��有两个操作�Q?/p>

①声明一个变量n

②�l�n赋��gؓ6

——�q�样��׃��有一个中间状态：变量n已经被声明了但是�q�没有被赋值的状态�?/p>

——�q�样�Q�在多线�E�中�Q�由于线�E�执行顺序的不确定性，如果两个�U�程都��用m�Q�就可能会导致不�E�_��的结果出现�?/p>

知识点：什么是指��o重排�Q?/p>

��单来��_��是计算��Zؓ了提高执行效率，会做的一些优化，在不影响最�l�结果的情况下，可能会对一些语句的执行��序�q�行调整�?/p>

比如�Q�这一�D�代码：

int a ;   // 语句1   a = 8 ;   // 语句2  int b = 9 ;     // 语句3  int c = a + b ; // 语句4

正常来说�Q�对于顺序结构，执行的顺序是自上��C��Q�也�?234�?/p>

但是�Q�由于指令重排的原因�Q�因��Z��影响最�l�的�l�果�Q�所以，实际执行的顺序可能会变成3124或�?324�?/p>

�׃��语句3�?没有原子性的问题�Q�语�?和语�?也可能会拆分成原子操作，再重排�?/p>

——也就是说�Q�对于非原子性的操作�Q�在不媄响最�l�结果的情况下，其拆分成的原子操作可能会被重新排列执行顺序�?/p>

OK�Q�了解了原子操作和指令重排的概念之后�Q�我们再�l�箋看Version3代码的问题�?/p>

下面�q�段话直接从陈皓的文�?深入��出单实例SINGLETON设计模式)中复制而来�Q?/p>

主要在于singleton = new Singleton()�q�句�Q�这�q��是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情�?/p>

1. �l?singleton 分配内存

2. 调用 Singleton 的构造函数来初始化成员变量，形成实例

3. ��singleton对象指向分配的内存空��_��执行完这�?singleton才是�?null 了）

但是�?JVM 的即时编译器中存在指令重排序的优化。也��是说上面的�W�二步和�W�三步的��序是不能保证的�Q�最�l�的执行��序可能�?1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕�? 未执行之前，被线�E�二抢占了，�q�时 instance 已经是非 null 了（但却没有初始化）�Q�所以线�E�二会直接返�?instance�Q�然后��用，然后��理成章地报错�?/p>

再稍微解释一下，��是��_��׃��有一个『instance已经不�ؓnull但是仍没有完成初始化』的中间状态，而这个时候，如果有其他线�E�刚好运行到�W�一层if (instance == null)�q�里�Q�这里读取到的instance已经不�ؓnull了，所以就直接把这个中间状态的instance拿去用了�Q�就会��生问题�?/p>

�q�里的关键在�?#8212;—�U�程T1对instance的写操作没有完成�Q�线�E�T2��执行了��L��作�?/p>

3.4 �l�极版本�Q�volatile

对于Version3中可能出现的问题�Q�当然这�U�概率已�l�非常小了，但毕竟还是有的嘛~�Q�，解决�Ҏ��是：只需要给instance的声明加上volatile关键字即可，Version4版本�Q?/p>

// Version 4   public class Single4 {      private static volatile Single4 instance;      private Single4() {}      public static Single4 getInstance() {          if (instance == null) {              synchronized (Single4.class) {                  if (instance == null) {                      instance = new Single4();                  }              }          }          return instance;      }  }

volatile关键字的一个作用是��止指��o重排�Q�把instance声明为volatile之后�Q�对它的写操作就会有一个内存屏障（什么是内存屏障�Q�）�Q�这��P��在它的赋值完成之前，��׃��用会调用��L��作�?/p>

注意�Q�volatile��L��的不singleton = new Singleton()�q�句话内部[1-2-3]的指令重排，而是保证了在一个写操作�Q�[1-2-3]�Q�完成之前，不会调用��L��作（if (instance == null)�Q��?/p>

——也就��d��防止了Version3中的问题发生�?/p>

——好了�Q�现在彻底没什么问题了吧？

……

好了�Q�别紧张�Q�的��没问题了。大名鼎鼎的EventBus中，其入口方法EventBus.getDefault()��是用这�U�方法来实现的�?/p>

……

不过�Q�非要挑点刺的话�q�是能挑出来的，��是�q�个写法有些复杂了，不够优雅、简�z��?/p>

4. 饿汉式单�?/p>

下面再聊了解一下饿汉式的单例�?/p>

如上所��_��饿汉式单例是指：指全局的单例实例在�c�装载时构徏的实现方式�?/p>

�׃��c�装载的�q�程是由�c�d��载器�Q�ClassLoader�Q�来执行的，�q�个�q�程也是由JVM来保证同步的�Q�所以这�U�方式先天就有一个优�?#8212;—能够免疫许多由多�U�程引�v的问题�?/p>

4.1 饿汉式单例的实现方式

饿汉式单例的实现如下�Q?/p>

//饿汉式实�?/span>  public class SingleB {      private static final SingleB INSTANCE = new SingleB();      private SingleB() {}      public static SingleB getInstance() {          return INSTANCE;      }  }

对于一个饿汉式单例的写法来��_��它基本上是完��的了�?/p>

所以它的缺点也��只是饿汉式单例本��n的缺�Ҏ��在了——�׃��INSTANCE的初始化是在�c�d��载时�q�行的，而类的加载是由ClassLoader来做的，所以开发者本来对于它初始化的时机��很隑֎�准确把握�Q?/p>

可能�׃��初始化的太早�Q�造成资源的浪�?/p>
如果初始化本�w�依赖于一些其他数据，那么也就很难保证其他数据会在它初始化之前准备好�?/p>

当然�Q�如果所需的单例占用的资源很少�Q��ƈ且也不依赖于其他数据�Q�那么这�U�实现方式也是很好的�?/p>

知识点：什么时候是�c�装载时�Q?/p>

前面提到了单例在�c�装载时被实例化�Q�那�I�竟什么时候才是『类装蝲时』呢�Q?/p>

不严格的��_��大致有这么几个条件会触发一个类被加载：

1. new一个对象时

2. 使用反射创徏它的实例�?/p>

3. 子类被加载时�Q�如果父�c�还没被加蝲�Q�就先加载父�c?/p>

4. jvm启动时执行的�ȝ��会首先被加蝲

5. 一些其他的实现方式

5.1 Effective Java 1 —— 静态内部类

《Effective Java》一书的�W�一版中推荐了一个中写法�Q?/p>

// Effective Java �W�一版推荐写�?/span>  public class Singleton {      private static class SingletonHolder {          private static final Singleton INSTANCE = new Singleton();      }      private Singleton (){}      public static final Singleton getInstance() {          return SingletonHolder.INSTANCE;      }  }

�q�种写法非常巧妙�Q?/p>

对于内部�c�SingletonHolder�Q�它是一个饿汉式的单例实玎ͼ�在SingletonHolder初始化的时候会由ClassLoader来保证同步，使INSTANCE是一个真·单例�?/p>
同时�Q�由于SingletonHolder是一个内部类�Q�只在外部类的Singleton的getInstance()中被使用�Q�所以它被加载的时机也就是在getInstance()�Ҏ��W�一�ơ被调用的时候�?/p>

——它利用了ClassLoader来保证了同步�Q�同时又能让开发者控制类加蝲的时机。从内部看是一个饿汉式的单例，但是从外部看来，又的��是懒汉式的实现�?/p>

��直是��乎其技�?/p>

5.2 Effective Java 2 —— 枚�D

你以为到�q�就��完了？不，�q�没有，因�ؓ厉害的大��又发现了其他的�Ҏ��?/p>

《Effective Java》的作者在�q�本书的�W�二版又推荐了另外一�U�方法，来直接看代码�Q?/p>

// Effective Java �W�二版推荐写�?/span>  public enum SingleInstance {      INSTANCE;      public void fun1() {           // do something      }  }     // 使用  SingleInstance.INSTANCE.fun1();

看到了么�Q�这是一个枚丄��?#8230;…�q�class都不用了�Q�极��?/p>

�׃��创徏枚�D实例的过�E�是�U�程安全的，所以这�U�写法也没有同步的问题�?/p>

作者对�q�个�Ҏ��的评��P��

�q�种写法在功能上与共有域�Ҏ��相近�Q�但是它更简�z�，无偿地提供了序列化机�Ӟ��l�对防止�Ҏ��实例化，即��是在面对复杂的序列化或者反��攻�ȝ��时候。虽然这中方法还没有�q�泛采用�Q�但是单元素的枚丄��型已�l�成为实现Singleton的最��x��法�?/p>

枚�D单例�q�种�Ҏ��问世一些，许多分析文章都称它是实现单例的最完美�Ҏ��——写法��񔽎�单，而且又能解决大部分的问题�?/p>

不过我个��U�方法虽然很优秀�Q�但是它仍然不是完美�?#8212;—比如�Q�在需要��承的场景�Q�它��׃��适用了�?/p>

6. �ȝ��

OK�Q�看到这里，你还会觉得单例模式是最��单的设计模式了么�Q�再回头看一下你之前代码中的单例实现�Q�觉得是无懈可击的么�Q?/p>

可能我们在实际的开发中�Q�对单例的实现�ƈ没有那么严格的要求。比如，我如果能保证所有的getInstance都是在一个线�E�的话，那其实第一�U�最��单的教科书方式就够用了。再比如�Q�有时候，我的单例变成了多例也可能对程序没什么太大媄�?#8230;…

但是�Q�如果我们能了解更多其中的细节，那么如果哪天�E�序��Z��些问题，我们��L��能多一个排查问题的炏V��早点解决问题，��p��早点回家吃饭……

—— �q�有�Q�完��的�Ҏ��是不存在�Q��Q何方式都会有一个『度』的问题。比如，你的觉得代码已经无懈可击了，但是因�ؓ你用的是JAVA语言�Q�可能ClassLoader有些BUG�?#8230;…你的代码谁运行在JVM上的�Q�可能JVM本��n有BUG�?#8230;…你的代码�q�行在手��Z��Q�可能手机系�l�有问题�?#8230;…你生�z�d��q�个宇宙里，可能宇宙本��n有些BUG�?#8230;…

所以，��力做到能做到的最好就行了�?/p>

—— 感谢你花费了不少旉��看到�q�里�Q�但愿你没有觉得虚度�?/p>

fly 2018-11-27 22:51 发表评论

fly — Tue, 06 Jun 2017 05:36:00 GMT

�?Effecitve Java 一书的�W?48 条中提到了双重检查模式，�q�指��U�模式在 Java 中通常�q�不适用。该模式的结构如下所�C�：

[java] view plain copy

public Resource getResource() {
if (resource == null) {
synchronized(this){
if (resource==null) {
resource = new Resource();
}
}
}
return resource;
}

该模式是对下面的代码改进�Q?/p>

[java] view plain copy

public synchronized Resource getResource(){
if (resource == null){
resource = new Resource();
}
return resource;
}

�q�段代码的目的是�?resource 延迟初始化。但是每�ơ访问的时候都需要同步。�ؓ了减��同步的开销�Q�于是有了双重检查模式�?/p>

�?Java 中双重检查模式无效的原因是在不同步的情况下引用类型不是线�E�安全的。对于除�?long �?double 的基本类型，双重��查模式是适用的。比如下面这�D�代码就是正��的�Q?/p>

[java] view plain copy

private int count;
public int getCount(){
if (count == 0){
synchronized(this){
if (count == 0){
count = computeCount(); //一个耗时的计��?nbsp;
}
}
}
return count;
}

上面��是关于java中双重检查模式（double-check idiom�Q�的一般结论。但是事情还没有�l�束�Q�因为java的内存模式也在改�q�中。Doug Lea 在他的文章中写道�Q?#8220;�Ҏ��最新的 JSR133 �?Java 内存模型�Q�如果将引用�c�d��声明�?volatile�Q�双重检查模式就可以工作�?#8221;�Q�参�?nbsp;http://gee.cs.oswego.edu/dl/cpj/updates.html �?/p>

所以以后要�?Java 中��用双重检查模式，可以使用下面的代码：

[java] view plain copy

private volatile Resource resource;
public Resource getResource(){
if (resource == null){
synchronized(this){
if (resource==null){
resource = new Resource();
}
}
}
return resource;
}

当然了，得是在遵�?JSR133 规范�?Java 中�?/p>

所以，double-check �?J2SE 1.4 或早期版本在多线�E�或�?JVM 调优时由�?out-of-order writes�Q�是不可用的�?�q�个问题�?J2SE 5.0 中已�l�被修复�Q�可以��?volatile 关键字来保证多线�E�下的单例�?/p>

[java] view plain copy

public class Singleton {
private volatile Singleton instance = null;
public Singleton getInstance() {
if (instance == null) {
synchronized(this) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}

推荐�Ҏ�� 是Initialization on Demand Holder�Q�IODH�Q�，

详见 http://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom

[java] view plain copy

public class Singleton {
static class SingletonHolder {
static Singleton instance = new Singleton();
}
public static Singleton getInstance(){
return SingletonHolder.instance;
}
}

fly 2017-06-06 13:36 发表评论

设计模式学习�W�记-观察者模�?�?

fly — Sun, 11 Aug 2013 15:41:00 GMT

设计模式学习�W�记-观察者模�?/a>

1. 概述

　　有时被称作发�?订阅模式�Q�观察者模式定义了一�U�一对多的依赖关�p�，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时�Q�会通知所有观察者对象，使它们能够自动更新自己�?/p>

2. 解决的问�?/p>

　　��一个系�l�分割成一个一些类�怺�协作的类有一个不好的副作用，那就是需要维护相兛_��象间的一致性。我们不希望��Z��l�持一致性而��各类紧密耦合�Q�这样会�l�维护、扩展和重用都带来不�ѝ��观察者就是解册��cȝ��耦合关系的�?/p>

3. 模式中的角色

　　3.1 抽象主题�Q�Subject�Q�：它把所有观察者对象的引用保存��C��个聚集里�Q�每个主题都可以有�Q何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象�?/p>

　　3.2 具体主题�Q�ConcreteSubject�Q�：��有关状态存入具体观察者对象；在具体主题内部状态改变时�Q�给所有登记过的观察者发出通知�?/p>

　　3.3 抽象观察者（Observer�Q�：为所有的具体观察者定义一个接口，在得��C��题通知时更新自己�?/p>

　　3.4 具体观察者（ConcreteObserver�Q�：实现抽象观察者角色所要求的更新接口，以便使本�w�的状态与主题状态协调�?/p>

4. 模式解读

　　4.1 观察者模式的�c�d��　　

　　4.2 观察者模式的代码

    /// 
    /// 抽象主题�c?
    /// 
    public abstract class Subject
    {
        private IList observers = new List();

        /// 
        /// 增加观察�?
        /// 
        /// 
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }

        /// 
        /// �U�除观察�?
        /// 
        /// 
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }

        /// 
        /// 向观察者（们）发出通知
        /// 
        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
            }
        }
    }

    /// 
    /// 抽象观察者类�Q��ؓ所有具体观察者定义一个接口，在得到通知时更新自�?
    /// 
    public abstract class Observer
    {
        public abstract void Update();
    }

    /// 
    /// 具体观察者或具体通知者，���有关状态存入具体观察者对象；在具体主题的内部状态改变时�Q�给所有登记过的观察者发出通知。具体主题角色通常用一个具体子�c�d��现�?
    /// 
    public class ConcreteSubject : Subject
    {
        private string subjectState;

        /// 
        /// 具体观察者的状�?
        /// 
        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
    }

    /// 
    /// 具体观察者，实现抽象观察者角色所要求的更新接口，已是本��n状态与主题状态相协调
    /// 
    public class ConcreteObserver : Observer
    {
        private string observerState;
        private string name;
        private ConcreteSubject subject;

        /// 
        /// 具体观察者用一个具体主题来实现
        /// 
        public ConcreteSubject Subject
        {
            get { return subject; }
            set { subject = value; }
        }

        public ConcreteObserver(ConcreteSubject subject, string name)
        {
            this.subject = subject;
            this.name = name;
        }

        /// 
        /// 实现抽象观察者中的更新操�?
        /// 
        public override void Update()
        {
            observerState = subject.SubjectState;
            Console.WriteLine("The observer's state of {0} is {1}", name, observerState);
        }
    }

　　4.3 客户端代�?/p>

    class Program
    {
        static void Main(string[] args)
        {
            // 具体主题角色通常用具体自来来实现
            ConcreteSubject subject = new ConcreteSubject();

            subject.Attach(new ConcreteObserver(subject, "Observer A"));
            subject.Attach(new ConcreteObserver(subject, "Observer B"));
            subject.Attach(new ConcreteObserver(subject, "Observer C"));

            subject.SubjectState = "Ready";
            subject.Notify();

            Console.Read();
        }
    }

　　�q�行�l�果

5. 模式�ȝ��

　　5.1 优点

　　　　5.1.1 观察者模式解除了主题和具体观察者的耦合�Q�让耦合的双斚w��依赖于抽象，而不是依赖具体。从而��得各自的变化都不会媄响另一边的变化�?/p>

　　5.2 �~�点

　　　　5.2.1 依赖关系�q�未完全解除�Q�抽象通知者依旧依赖抽象的观察者�?/p>

　　5.3 适用场景

　　　　5.3.1 当一个对象的改变需要给变其它对象时�Q�而且它不知道具体有多��个对象有待改变时�?/p>

　　　　5.3.2 一个抽象某型有两个斚w��Q�当其中一个方面依赖于另一个方面，�q�时用观察者模式可以将�q�两者封装在独立的对象中使它们各自独立地改变和复用�?/p>

6. 模式引申�Q�应用C#中的事�g委托来彻底解除通知者和观察者之间的耦合�?/p>

　　　6.1 关于委托的定义：委托是一�U�引用方法的�c�d��。一旦�ؓ委托分配了方法，委托��与该方法有相同的行为。委托方法可以像其它��M��Ҏ��一��P��h��参数和返回倹{��委托可以看作是对函敎ͼ��Ҏ��Q�的的抽象，是函数的“�c?#8221;�Q�委托的实例代表一个（或多个）具体的函敎ͼ�它可以是多播的�?/p>

　　　6.2 关于事�g�Q�事件基于委托，为委托提供了一�U�发�?订阅机制。事件的订阅与取消与我们刚才讲的观察者模式中的订阅与取消�c�M��Q�只是表现�Ş式有所不同。在观察者模式中�Q�订阅��用方法Attach�Q�）来进行；在事件的订阅中��?#8220;+=”。类似地�Q�取消订阅在观察者模式中用Dettach�Q�）�Q�而事件的取消�?#8220;-=”�?/p>

7. 下面例子分别用观察者模式，事�g机制来实�?/p>

　　7.1 实例描述�Q�客��h��付了订单��N��Q�这时胦务需要开具发��，出纳需要记账，配送员需要配货�?/p>

　　7.2 观察者模式的实现

　　　　7.2.1 �c�d��

　　　　7.2.2 代码实现

    /// 
    /// 抽象观察�?
    /// 
    public interface ISubject
    {
        void Notify();
    }

    /// 
    /// 工作岗位�Q�作�����里的观察者的抽象
    /// 
    public abstract class JobStation
    {
        public abstract void Update();
    }

    /// 
    /// 具体主题�Q�这里是客户
    /// 
    public class Customer : ISubject
    {
        private string customerState;

        private IList observers = new List();

        /// 
        /// 增加观察�?
        /// 
        /// 
        public void Attach(JobStation observer)
        {
            this.observers.Add(observer);
        }

        /// 
        /// �U�除观察�?
        /// 
        /// 
        public void Detach(JobStation observer)
        {
            this.observers.Remove(observer);
        }

        /// 
        /// 客户状�?
        /// 
        public string CustomerState
        {
            get { return customerState; }
            set { customerState = value; }
        }

        public void Notify()
        {
            foreach (JobStation o in observers)
            {
                o.Update();
            }
        }
    }

    /// 
    /// 会计
    /// 
    public class Accountant : JobStation
    {
        private string accountantState;
        private Customer customer;

        public Accountant(Customer customer)
        {
            this.customer = customer;
        }

        /// 
        /// 更新状�?
        /// 
        public override void Update()
        {
            if (customer.CustomerState == "已付��?/span>")
            {
                Console.WriteLine("我是会计�Q�我来开具发����?/span>");
                accountantState = "已开发票";
            }
        }
    }

    /// 
    /// 出纳
    /// 
    public class Cashier : JobStation
    {
        private string cashierState;
        private Customer customer;

        public Cashier(Customer customer)
        {
            this.customer = customer;
        }

        public override void Update()
        {
            if (customer.CustomerState == "已付��?/span>")
            {
                Console.WriteLine("我是出纳员，我给登记入�̎�?/span>");
                cashierState = "已入�?/span>";
            }
        }
    }

    /// 
    /// 配送员
    /// 
    public class Dilliveryman : JobStation
    {
        private string dillivierymanState;
        private Customer customer;

        public Dilliveryman(Customer customer)
        {
            this.customer = customer;
        }

        public override void Update()
        {
            if (customer.CustomerState == "已付��?/span>")
            {
                Console.WriteLine("我是配送员�Q�我来发货�?/span>");
                dillivierymanState = "已发�?/span>";
            }
        }
    }

　　　　7.2.3 客户端代�?/p>

    class Program
    {
        static void Main(string[] args)
        {

            Customer subject = new Customer();

            subject.Attach(new Accountant(subject));
            subject.Attach(new Cashier(subject));
            subject.Attach(new Dilliveryman(subject));

            subject.CustomerState = "已付��?/span>";
            subject.Notify();

            Console.Read();
        }
    }

　　　　�q�行�l�果�Q?/p>

　　　　我是会计�Q�我来开具发��?/span>
　　　　我是出纳员，我给登记入�̎�?/span>
　　　　我是配送员�Q�我来发货�?/span>

　　7.3 事�g实现

　　　　7.3.1 �c�d��

　　　　通过�c�d��来看�Q�观察者和主题之间已经不存在�Q何依赖关�p�M��?/p>

　　　　7.3.2 代码实现

    /// 
    /// 抽象主题
    /// 
    public interface ISubject
    {
        void Notify();
    }

    /// 
    /// 声明委托
    /// 
    public delegate void CustomerEventHandler();

    /// 
    /// 具体主题
    /// 
    public class Customer : ISubject
    {
        private string customerState;

        // 声明一个委托事�Ӟ���c�d���?CustomerEventHandler
        public event CustomerEventHandler Update;

        public void Notify()
        {
            if (Update != null)
            {
                // 使用事�g来通知�l�订阅�?/span>
                Update();
            }
        }

        public string CustomerState
        {
            get { return customerState; }
            set { customerState = value; }
        }
    }

    /// 
    /// 财务�Q�已�l�不需要实现抽象的观察者类�Q��ƈ且不用引用具体的主题
    /// 
    public class Accountant
    {
        private string accountantState;

        public Accountant()
        { }

        /// 
        /// 开发票
        /// 
        public void GiveInvoice()
        {
            Console.WriteLine("我是会计�Q�我来开具发����?/span>");
            accountantState = "已开发票";
        }
    }

    /// 
    /// 出纳�Q�已�l�不需要实现抽象的观察者类�Q��ƈ且不用引用具体的主题
    /// 
    public class Cashier
    {
        private string cashierState;

        public void Recoded()
        {
            Console.WriteLine("我是出纳员，我给登记入�̎�?/span>");
            cashierState = "已入�?/span>";
        }
    }

    /// 
    /// 配送员�Q�已�l�不需要实现抽象的观察者类�Q��ƈ且不用引用具体的主题
    /// 
    public class Dilliveryman
    {
        private string dillivierymanState;

        public void Dilliver()
        {
            Console.WriteLine("我是配送员�Q�我来发货�?/span>");
            dillivierymanState = "已发�?/span>";
        }
    }

　　　　7.3.3 客户端代�?/p>

    class Program
    {
        static void Main(string[] args)
        {

            Customer subject = new Customer();

            Accountant accountant = new Accountant();
            Cashier cashier = new Cashier();
            Dilliveryman dilliveryman = new Dilliveryman();

            // 注册事�g
            subject.Update += accountant.GiveInvoice;
            subject.Update += cashier.Recoded;
            subject.Update += dilliveryman.Dilliver;

            /*
             * 以上写法也可以用下面代码来替�?
            subject.Update += new CustomerEventHandler(accountant.GiveInvoice);
            subject.Update += new CustomerEventHandler(cashier.Recoded);
            subject.Update += new CustomerEventHandler(dilliveryman.Dilliver);
             */

            subject.CustomerState = "已付��?/span>";
            subject.Notify();

            Console.Read();
        }
    }

　　　　�q�行�l�果

　　　　我是会计�Q�我来开具发��?/span>
　　　　我是出纳员，我给登记入�̎�?/span>
　　　　我是配送员�Q�我来发货�?/span>

fly 2013-08-11 23:41 发表评论