Observer

---

定义

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

何时可以用到

两个Object需要互通有无的时候

实现

引入一个Observer类，由他来完成消息通知

Observer类在通知方注册，又包含被通知方的信息

package eternal.fire;

public class Main {
    public static void main(String[] args) {
        Admin admin = new Admin();
        Customer customer = new Customer();
        Store store = new Store();
        store.addObserver(admin);
        store.addObserver(customer);
        store.addObserver(new ProductObserver() {
            @Override
            public void onPublished(Product product) {
                System.out.println("Icognition class:" + product);
            }

            @Override
            public void onPriceChanged(Product product) {
                System.out.println("Icognition class:" + product);
            }
        });
        store.addNewProduct("R7-2700", 1000);
        store.addNewProduct("RX-580", 1099);
    }
}

package eternal.fire;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class Store {
    private List<ProductObserver> observers = new LinkedList<>();
    private Map<String, Product> products = new HashMap<>();

    public void addObserver(ProductObserver productObserver) {
        this.observers.add(productObserver);
    }

    public void removeObserver(ProductObserver productObserver) {
        this.observers.remove(productObserver);
    }

    public void addNewProduct(String name, double price) {
        Product product = new Product(name, price);
        products.put(name, product);
        observers.forEach(productObserver -> productObserver.onPublished(product));
    }


    public void setProductPrice(String name, double price) {
        Product product = products.get(name);
        product.setPrice(price);
        observers.forEach(productObserver -> productObserver.onPriceChanged(product));
    }
}

package eternal.fire;

public interface ProductObserver {
    void onPublished(Product product);

    void onPriceChanged(Product product);

}

package eternal.fire;

public class Product {
    public String name;
    public double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

package eternal.fire;

public class Admin implements ProductObserver{
    @Override
    public void onPublished(Product product) {
        System.out.println("[Admin] message received:" + product);
    }

    @Override
    public void onPriceChanged(Product product) {
        System.out.println("[Admin] price message received:" + product);
    }
}

package eternal.fire;

public class Customer implements ProductObserver{
    @Override
    public void onPublished(Product product) {
        System.out.println("[customer]message received:" + product);
    }

    @Override
    public void onPriceChanged(Product product) {
        System.out.println("[customer]price message received:" + product);
    }
}

优势

耦合性小

扩充方便