• 抽象工厂 责任链模式，观察者模式

    目录

    抽象工厂

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

    抽象类图

    在这里提供一个案例
    PcFactory

    package abstractfactory;

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 static final int type_Hp = 1;

	public static final int type_logic = 2;

	public static PcFactory getPcFactory(int pcType) {
		switch (pcType) {
		case 1:
			return hpFactory;
		case 2:
			return logicFactory;

		default:
			return null;
		}
	}

//	public static LogicFactory getLogicFactory() {
//		return logicFactory;
//	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    mouse

    package abstractfactory;

public abstract class Mouse {

    abstract String getInfo();
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    keyboard

    package abstractfactory;

public abstract class Keyboard {

    abstract String getInfo();

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    hpfactory

    package abstractfactory;

public class HpFactory extends PcFactory {

    @Override
    public Mouse makeMouse() {
        return new HpMouse();
    }

    @Override
    public Keyboard makeKeyboard() {
        return new HpKeyboard();
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    LogicFactory

    package abstractfactory;

public class LogicFactory extends PcFactory {

    @Override
    public Mouse makeMouse() {
        return new LogicMouse();
    }

    @Override
    public Keyboard makeKeyboard() {
        return new LogicKeyboard();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    然后再这里，mouse和keyboard都是一样的，只不过是品牌不一样

    package abstractfactory;

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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    package abstractfactory;

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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    好，这就是一个完整的抽象工厂，当然，可以在抽象一些，越抽象越稳定

    责任链模式

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

    为了便于理解我们可以想象一下击鼓传花的游戏，例如在论坛中上传文章审查就是需要责任链模式设计，不是其他的不可以，而是这中模式更是适合于在这中使用场景下；

    责任链
    同样，我也提供一个案例，不过只有关键代码啦
    Filter

    package com.chian.v02;

import com.chian.Message;

/**
 * Filter接口，如果当前filter返回false，则没有
 * 必要执行其后的过滤器链。
 */
public interface Filter {

    boolean doFilter(Message message);

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    ChackSyntaxFilter

    package com.chian.v02;

import com.chian.Message;

public class ChackSyntaxFilter implements Filter {

	@Override
	public boolean doFilter(Message message) {
		String content = message.getContent();

		if (!content.contains("<") && !content.contains(">")) {
			return true;
		}

		content = content.replace("<", "#");
		content = content.replace(">", "#");
		message.setContent(content);

		return false;
	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    FilterChain

    package com.chian.v02;

import com.chian.Message;

import java.util.ArrayList;
import java.util.List;

/**
 * 将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 filter: filters) {
            boolean b = filter.doFilter(message);
            if(!b) return message;
        }
        return message;
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    WordFilter

    package com.chian.v02;

import com.chian.Message;

public class WordFilter implements Filter {

	@Override
	public boolean doFilter(Message message) {

		String content = message.getContent();

		if (!content.contains("苍井空") && !content.contains("波多野结衣")) {
			return true;
		}

		content = content.replace("苍井空", "***");
		content = content.replace("波多野结衣", "*****");
		message.setContent(content);
		return true;
	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    main

    package com.chian.v02;

import com.chian.Message;

public class Main {

    public static void main(String[] args) {
        Message msg = new Message();
        msg.setContent("hello, <abc>, 喜欢波多野结衣， 哈哈哈");

        FilterChain fc = FilterChain.getInstance();
        fc.add(new ChackSyntaxFilter())
                .add(new WordFilter())
                .dofilters(msg);

        System.out.println(msg.getContent());
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    小结：个人认为责任链模式适合于需要有一个传递关系的场景

    观察者模式（Obsever）

    在我学习这个模式的时候，我就一直在想，这会是个什么模式，后来才知道，这和swing的button的监听事件是类似的，观察这模式不仅仅是叫观察者模式，还可以叫发布/订阅模式”或者“监听器模式”。

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

    观察者
    用一个案例来名，像上面的类图所示
    Observer

    package observer01;

public interface Observer {

    void bell(BellEvent event);

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    BellEvent

    package observer01;

public class BellEvent extends Event {

    long timestamp;

    public BellEvent(Object source) {
        this.timestamp = System.currentTimeMillis();
        this.source = source;
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    Docter

    package observer01;

public class Docter implements Observer {

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

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    Nurse

    package observer01;

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

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    Patient

    package observer01;

import java.util.ArrayList;
import java.util.List;

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

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    wife

    package observer01;

public class Wife implements Observer {

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

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    mian`

    package observer01;

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

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    小结： 观察者模式其实就是通过一个对象来传递信息，把一个信息传给多个与你有关的类，以一对多。

    总结，结合上一篇博客，这些就是我们常见的设计模式，通过这些设计模式使得我们的系统变得十分灵活，要维护或者是修改都变得简单。有单例模式，简单工厂模式，抽象工厂模式，责任链模式，观察者模式。

  • 相关阅读:
    Java设计模式 | 简介
    asterisk 使用php脚本连接oralce数据库 通过AMI端口实现预拨号（批量外呼）
    Java 并发编程解析 | 关于线程机制的那些事，你究竟了解多少？
    AWS亚马逊云注册图文详细教程，多币种充值优势分析
    基于单片机的汽车安全气囊系统故障仿真设计
    利用宝塔实现百度自动推送
    QT5.14.2+cmake3.8.2+opencv3.4.0环境配置遇到的问题
    superset-1.5.0 docker版连接Oracle、SQL server、Elasticsearch
    软件设计师软考题目解析12 --每日五题
    JSON，对象深拷贝
  • 原文地址：https://blog.csdn.net/weixin_67150631/article/details/125402067