java抽象工厂&责任链模式&观察者模式

抽象工厂是什么？责任链模式是什么？观察者模式是什么？

---

目录

抽象工厂

        概念

        类图

        代码

责任链模式

        概念

        使用场景

        类图

        代码

观察者模式（Obsever）

        概念

        使用场景

        类图

        代码

        小结

---

抽象工厂

 概念

用于生成指定产品族，一个产品族中包括多种产品。例如：
我们都比较熟悉的电脑制造相关行业，有HP，罗技，联想，戴尔，近几年华为，小米也进来了，每个生产商生产的电脑又包括鼠标，键盘，屏幕等等配件。此时我们需要使用工厂模式来进行管理不同的产品族，这时使用简单工厂（也有叫作工厂方法的）已经无法满足要求，此时可以使用抽象工厂。

 类图

 

从图中可以看到：HPFactory(惠普)和LogicFactory(罗技)子工厂都继承PCFactory电脑产品族总抽象工厂，并具备了制作鼠标和制作键盘的方法，而鼠标抽象工厂Keyboard和键盘抽象工厂Mouse下的子类遵从单一职责原则，各自则负责各自品牌的鼠标或者键盘制作

简单来说，抽象工厂就是在简单工厂的基础上，对多个工厂进行抽象，将不同的工厂类型放入抽象工厂
 

  代码

PcFactory抽象产品族工厂

public abstract class PcFactory {
 
    //制作方法
    public abstract Mouse makeMouse();
    public abstract Keyboard makeKeyboard();
 
    //为得到具体的工厂的方法服务
    private static HpFactory hpFactory = new HpFactory();
    private static LogicFactory logicFactory = new LogicFactory();
    //为得到具体的工厂的方法服务
    public final static int PC_TYPE_HP = 1;
    public final static int PC_TYPE_LG = 2;
 
    /**
     * 得到具体的工厂的方法
     * @param pcType传入表示电脑类型的常数
     * @return 返回PcFactory抽象类：面向抽象编程代替面向具体编程
     */
    public static PcFactory getPcFactory(int pcType) {
        switch (pcType){
            case 1:
                return hpFactory;
            case 2 :
                return logicFactory;
            default:
                return null;
        }
    }
}

HPFactory(惠普)子工厂（继承抽象类PcFactory）

public class HpFactory extends PcFactory {
 
    //返回抽象类：面向抽象编程代替面向具体编程
 
    @Override
    public Mouse makeMouse() {
        return new HpMouse();
    }
 
    @Override
    public Keyboard makeKeyboard() {
        return new HpKeyboard();
    }
 
}

LogicFactory(罗技)子工厂（继承抽象类PcFactory）

public class LogicFactory extends PcFactory {
 
    @Override
    public Mouse makeMouse() {
        return new LogicMouse();
    }
 
    @Override
    public Keyboard makeKeyboard() {
        return new LogicKeyboard();
    }
}

鼠标抽象工厂Keyboard

public abstract class Keyboard {
    abstract String getInfo();
}

HP的键盘制作工厂（继承抽象类Keyboard）

public class HpKeyboard extends Keyboard {
    @Override
    String getInfo() {
        return "HP keyboard";
    }
}

Logic的键盘制作工厂（继承抽象类Keyboard）

public class LogicKeyboard extends Keyboard {
    @Override
    String getInfo() {
        return "logic keyboard";
    }
}

键盘抽象工厂Mouse

public abstract class Mouse {
    abstract String getInfo();
}

HP的鼠标制作工厂（继承抽象类Mouse）

public class HpMouse extends Mouse {
    @Override
    String getInfo() {
        return "HP mouse";
    }
}

Logic的鼠标制作工厂（继承抽象类Mouse）

public class LogicMouse extends Mouse {
    @Override
    String getInfo() {
        return "logic mouse";
    }
}

测试类 

public class Main {
 
    public static void main(String[] args) {
        //通过抽象PcFactory父类得到HP电脑制作工厂
        PcFactory HpFactory = PcFactory.getPcFactory(PcFactory.PC_TYPE_HP);
        //得到HP制作键盘的方法
        Keyboard keyboard = HpFactory.makeKeyboard();
        //得到HP制作鼠标的方法
        Mouse mouse = HpFactory.makeMouse();
        System.out.println(keyboard.getInfo());
        System.out.println(mouse.getInfo());
    }
 
}

---

责任链模式

 概念

责任链模式是一个对象的行为模式，很多对象之间形成一条链条，处理请求在这个链条上进行传递，直到责任链的上的某个对象决定处理请求（也可扩展为几个对象处理），这个过程对于用户来说是透明的，也就是说用户并不需要知道是责任链上的哪个对象处理的请求，对请求是否处理由链条上的对象自己决定。

可以想象一下击鼓传花的游戏。

责任链模式也可以说是行为模式(而抽象工厂叫做建造模式)：拥有相同行为的类共同实现一个接口

 使用场景

web容器中的过滤器算是责任链模式的一个经典场景。另外举个例子：当在论坛上提交内容时，论坛系统需要对一些关键词进行处理，看看有没有包含一些敏感词汇，而这些敏感词汇我们可以使用责任链模式进行处理。

 类图

 

 代码

Filter接口

/**
 * Filter接口，实际上是对变化的抽象
 * 这种方式会逐个的运行Filter，但不能
 * 指定是否需要继续执行后面的Filter。
 * 比如：当发现违法了特殊符号的Filter时
 * 其后的过滤链没有必要执行
 */
public interface Filter {
 
    void doFilter(Message message);
 
}

ChackSyntaxFilter类（继承Filter接口）

public class ChackSyntaxFilter implements Filter {
 
    @Override
    public void doFilter(Message message) {
        String content = message.getContent();
        content = content.replace("<", "#");
        content = content.replace(">", "#");
        message.setContent(content);
    }
 
}

WordFilter类（继承Filter接口）

public class WordFilter implements Filter {
 
    @Override
    public void doFilter(Message message) {
        String content = message.getContent();
        content = content.replace("牛", "***");
        content = content.replace("马", "*****");
        message.setContent(content);
    }
 
}

FilterChain过滤器链

/**
 * 将Filter组织成一个链条
 */
public class FilterChain {
 
    private FilterChain(){}
    
    private static List<Filter> filters = new ArrayList<>();
 
    private static FilterChain instance = new FilterChain();
 
    public static FilterChain getInstance(){
        return instance;
    }
 
    public FilterChain add(Filter filter) {
        filters.add(filter);
        return this;
    }
 
    public Message dofilters(final Message message) {
        for (Filter f : filters) {
            f.doFilter(message);
        }
        return message;
    }
 
}

测试

public class Main {
 
    public static void main(String[] args) {
        Message msg = new Message();
        msg.setContent("hello, <abc>, 牛xx马， 哈哈哈");
 
        FilterChain fc = FilterChain.getInstance();
        fc.add(new ChackSyntaxFilter())
                .add(new WordFilter())
                .dofilters(msg);
 
        System.out.println(msg.getContent());
    }
 
}

---

观察者模式（Obsever）

 概念

观察者模式是对象的行为模式，有时也称为“发布/订阅模式”或者“监听器模式”。

观察者模式定义了被观察者和观察者之间的一对多的关系，让多个观察者对象可以响应一个被观察者对象。

 使用场景

比较经典的使用场景，比如：java中的swing包中对事件的处理。浏览器对鼠标，键盘等事件的处理等， spring中的事件发布机制也是使用该模式

类图

 从上图可以看到：Nurse类、Wife类、Docter类都共同实现Observer接口，BellEvent按铃类继承Event事件抽象类，Patient是病人实体类

 代码

Observer接口

public interface Observer {
    void bell(BellEvent event);
}

Nurse类（继承Observer接口）

public class Nurse implements Observer {
    @Override
    public void bell(BellEvent event) {
        System.out.println("I am nurse, Can I help you?");
    }
}

Wife类（继承Observer接口）

public class Wife implements Observer {
    @Override
    public void bell(BellEvent event) {
        System.out.println("baby, I am here, Don't worry !");
    }
}

Docter类（继承Observer接口）

public class Docter implements Observer {
    @Override
    public void bell(BellEvent event) {
        System.out.println("I am docter, Can I help you?");
    }
}

Event事件抽象类

public abstract class Event {
 
    protected Object source;
 
    public Object getSource() {
        return this.source;
    }
 
}

BellEvent类

public class BellEvent extends Event {
 
    long timestamp;
 
    public BellEvent(Object source) {
        this.timestamp = System.currentTimeMillis();
        this.source = source;
    }
 
}

Patient是病人实体类

public class Patient {
 
    private List<Observer> observers = new ArrayList<>();
 
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
 
    public void ringBell() {
        BellEvent event = new BellEvent(this);
        for (Observer observer: observers) {
            observer.bell(event);
        }
    }
 
}

 测试

public class Main {
 
    public static void main(String[] args) {
 
        Patient patient = new Patient();
 
        patient.addObserver(new Docter());
        patient.addObserver(new Nurse());
        patient.addObserver(new Wife());
 
        patient.ringBell();
 
    }
}

 小结

观察者模式的使用非常广泛，比如：Listener，Hook，Callback等等

感谢收看鸭~