抽象工厂&责任链模式&观察者模式【Java】

小阿飞_

已于 2022-06-24 19:54:37 修改

阅读量200

点赞数 10

分类专栏： java 文章标签： java 责任链模式观察者模式抽象工厂模式

于 2022-06-22 10:55:20 首次发布

本文链接：https://blog.csdn.net/yifei_345678/article/details/125402225

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

上期文章简单给大家介绍了一下什么是单例模式和工厂模式，感兴趣的可以去看看：常见的设计模式【单例模式&工厂模式】_小阿飞_的博客-CSDN博客常见开发模式中单例模式、工厂模式的相关介绍https://blog.csdn.net/yifei_345678/article/details/125372132?spm=1001.2014.3001.5501

本期精彩：

抽象工厂

概念

用于生成指定产品族，一个产品族中包括多种产品。例如：
我们都比较熟悉的电脑制造相关行业，有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容器中的过滤器算是责任链模式的一个经典场景。另外举个例子：当在论坛上提交内容时，论坛系统需要对一些关键词进行处理，看看有没有包含一些敏感词汇，而这些敏感词汇我们可以使用责任链模式进行处理。

责任链模式的类图

从上图中可以看到ChackSyntaxFilter(语法结构过滤)类和WordFilter(关键词过滤)类共同实现Filter接口

代码

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();

    }
}