抽象工厂是什么?责任链模式是什么?观察者模式是什么?
目录
类图
抽象工厂
概念
用于生成指定产品族,一个产品族中包括多种产品。例如:
我们都比较熟悉的电脑制造相关行业,有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等等
感谢收看鸭~