观察者模式

观察者模式的优点

优点1：将观察者与被观察者进行解耦，便于后期二者独立进行功能扩展，不会形成任何的钳制关系。

观察者模式的缺点

缺点1：由于是链式触发，当观察者比较多的时候，性能问题是比较令人担忧的。
缺点2：在链式结构中，比较容易出现循环引用的错误，造成系统假死。

示例

被观察者：

/**
 * 被观察者
 */
public class ProductList extends Observable {

    private List<String> productList = null;

    /**
     * 类唯一实例
     */
    private static ProductList instance;

    /**
     * 构造方法私有化
     */
    private ProductList() { }

    /**
     * 单例模式获取唯一的实例(线程安全的懒汉式的单例实现)
     *
     * @return
     */
    public static synchronized ProductList getInstance() {
        if (instance == null) {
            instance = new ProductList();
            instance.productList = new ArrayList<>();
        }
        return instance;
    }


    /**
     * 增加观察者
     *
     * @param oberver
     */
    public void addProductListObserver(Observer oberver) {
        this.addObserver(oberver);
    }

    /**
     * 删除观察者
     *
     * @param oberver
     */
    public void deleteProductListObserver(Observer oberver){
        this.deleteObserver(oberver);
    }
    /**
     * 新增产品
     *
     * @param newProduct
     */
    public void addProduct(String newProduct) {
        productList.add(newProduct);
        System.out.println("[ProductList] add new product: " + newProduct);
        this.setChanged();
        //通知观察者，并且传递新增的产品作为参数
        this.notifyObservers(newProduct);
    }

}

1号观察者TaoBaoObserver

/**
 * 模拟观察者1号：天猫旗舰店
 */
public class TaoBaoObserver implements Observer {

    @Override
    public void update(Observable o, Object product) {
        String newProduct = (String) product;
        String message = String.format("[TaoBaoObserver] receivers: %s",newProduct);
        System.out.println(message);
    }
}

2号观察者


/**
 * 模拟观察者2号：京东旗舰店
 */
public class JDObserver implements Observer {

    @Override
    public void update(Observable o, Object product) {
        String newProduct = (String) product;
        String message = String.format("[JDObserver] receives %s", newProduct);
        System.out.println(message);
    }
}

测试程序：


import com.netease.learn.BaseTest;
import com.netease.learn.designPattern.observer.JDObserver;
import com.netease.learn.designPattern.observer.ProductList;
import com.netease.learn.designPattern.observer.TaoBaoObserver;
import org.junit.Before;
import org.junit.Test;

import java.util.Observer;

/**
 * 观察者模式测试类
 */
public class ObserverPatternTest extends BaseTest {

    private ProductList productList;

    private Observer jdObserver;

    private Observer taoBaoObserver;

    @Before
    public void init() {
        // 初始化被观察者
        productList = ProductList.getInstance();

        // 初始化观察者
        jdObserver = new JDObserver();
        taoBaoObserver = new TaoBaoObserver();
    }

    @Test
    public void test1() {
        // 观察者添加监听
        productList.addProductListObserver(jdObserver);
        productList.addProductListObserver(taoBaoObserver);

        // 测试被观察者是否将消息送达给先前订阅消息的观察者
        productList.addProduct("good product");

        // 观察者取消监听
        productList.deleteProductListObserver(taoBaoObserver);

        // 测试被观察者是否将消息送达给先前订阅消息的观察者
        productList.addProduct("bad product");
    }

    /**
     * Demo Result:
     *
     * [ProductList] add new product: good product
     * [TaoBaoObserver] receivers: good product
     * [JDObserver] receives good product
     * [ProductList] add new product: bad product
     * [JDObserver] receives bad product
     */
}