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

最新推荐文章于 2024-02-22 18:08:08 发布

赤诚&

最新推荐文章于 2024-02-22 18:08:08 发布

阅读量153

点赞数 5

分类专栏： J2EE 文章标签：责任链模式观察者模式 java

本文链接：https://blog.csdn.net/weixin_67150631/article/details/125402067

版权

J2EE 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文介绍了设计模式中的抽象工厂、责任链和观察者模式。抽象工厂用于创建产品族，如电脑配件，不同品牌对应不同工厂。责任链模式通过对象形成的链条传递请求，实现请求处理的透明性，如论坛文章审查。观察者模式则是一种发布/订阅模式，一个对象的状态变化可通知多个观察者，如按钮监听事件。这些设计模式提高了系统的灵活性和可维护性。

摘要由CSDN通过智能技术生成

抽象工厂

用于生成指定产品族，一个产品族中包括多种产品。例如：
我们都比较熟悉的电脑制造相关行业，有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;
//	}

}

mouse

package abstractfactory;

public abstract class Mouse {

    abstract String getInfo();
}

keyboard

package abstractfactory;

public abstract class Keyboard {

    abstract String getInfo();

}

hpfactory

package abstractfactory;

public class HpFactory extends PcFactory {

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

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

}

LogicFactory

package abstractfactory;

public class LogicFactory extends PcFactory {

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

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

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

package abstractfactory;

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

package abstractfactory;

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

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

责任链模式

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

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

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

package com.chian.v02;

import com.chian.Message;

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

    boolean doFilter(Message message);

}

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

}

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

}

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

}

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

}

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

观察者模式（Obsever）

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

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

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

package observer01;

public interface Observer {

    void bell(BellEvent event);

}

BellEvent

package observer01;

public class BellEvent extends Event {

    long timestamp;

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

}

Docter

package observer01;

public class Docter implements Observer {

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

}

Nurse

package observer01;

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

}

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

}

wife

package observer01;

public class Wife implements Observer {

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

}

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

    }
}