0
点赞
收藏
分享

微信扫一扫

HTML+CSS:动态搜索框

四月Ren间 03-03 22:30 阅读 2

文章目录

1.观察者模式概述

基本概念:
  1. 被观察者(Subject):也称为主题或发布者,是状态的持有者,当其状态发生变化时会通知所有订阅者。被观察者通常包含注册、删除和通知观察者的方法。
  2. 观察者(Observer):也称为订阅者,是被动接收被观察者状态变化通知的对象。观察者需要实现接收通知并作出相应动作的方法。
  3. 通知(Notification):是被观察者向观察者发送的消息,用于告知观察者被观察者的状态发生了变化。
工作原理:
  1. 建立订阅关系:观察者通过订阅(注册)的方式与被观察者建立联系。被观察者维护一个观察者列表,可以动态添加或删除观察者。
  2. 状态变化通知:当被观察者的状态发生变化时,它会遍历观察者列表,依次调用每个观察者的通知方法,将状态变化的消息传递给观察者。
  3. 观察者响应:每个观察者接收到通知后,会执行预定义的更新逻辑,以便与被观察者的状态保持一致。观察者可以根据通知的内容进行相应的处理,比如更新界面、发送邮件等。
  4. 解耦合:观察者模式通过将被观察者和观察者解耦,使得它们之间的关系更加灵活和可扩展。被观察者不需要知道具体的观察者是谁,而观察者也不需要了解被观察者的具体实现细节,从而降低了对象之间的依赖关系。

2.案例-音乐会抢票

2.1.具体实现

image-20240228222155961

2.1.1.被观察者接口
/**
 * 被观察者接口
 * @author 13723
 * @version 1.0
 * 2024/1/29 10:12
 */
public interface Observable {
	/**
	 * 添加观察者
	 * @param observer 观察者
	 */
	void addObserver(Observer observer);

	/**
	 * 删除观察者
	 * @param observer 观察者
	 */
	void removeObserver(Observer observer);

	/**
	 * 通知观察者
	 * @param count 通知内容
	 */
	void notifyObserver(AtomicInteger count);
}

2.1.2.被观察者实现类

构建被观察者:ConcertTicketSalesService类的设计与实现,包括售票操作和通知观察者的功能。

/**
 *
 * 被观察者实现类
 * @author 13723
 * @version 1.0
 * 2024/1/29 10:14
 */
public class ConcertTicketSalesService implements Observable{
	private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

	/**
	 * 观察者集合
	 */
	private final List<Observer> observers = new ArrayList<>();

	public static final AtomicInteger count = new AtomicInteger(0);

	/**
	 * 添加观察者
	 * @param observer 观察者
	 */
	@Override
	public void addObserver(Observer observer) {
		this.observers.add(observer);
	}

	/**
	 * 删除观察者
	 * @param observer 观察者
	 */
	@Override
	public void removeObserver(Observer observer) {
		this.observers.remove(observer);
	}
	/**
	 * 通知观察者
	 * @param count 通知内容
	 */
	@Override
	public void notifyObserver(AtomicInteger count) {
		// 通知所有观察者
		for (Observer observer : this.observers) {
			observer.make(count);
		}
	}
	public void sale(int ticketNum){
		count.addAndGet(ticketNum);
		logger.error("原始售票数量:{}",ticketNum);
		logger.error(" --------- 开始售票 --------- ");
		notifyObserver(count);
	}
}

2.1.3.定义观察者接口
/**
 * 观察者接口
 * 观察者模式又称为发布/订阅(Publish/Subscribe)模式,在对象之间定义了一对多的依赖,
 * 这样一来,当一个对象改变状态,依赖它的对象会收到通知并自动更新触发行为
 */
public interface Observer {
	/**
	 * 观察者接收到通知后的处理逻辑
	 * @param count 通知内容
	 */
	void make(AtomicInteger count);
}
2.1.3.定义观察者实现类
/**
 * 粉丝接收通知,开启抢票
 * @author 13723
 * @version 1.0
 * 2024/1/29 10:23
 */
public class FansService implements Observer  {
	private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

	/**
	 * 粉丝接收通知,开启抢票
	 * @param count 通知内容
	 */
	@Override
	public void make(AtomicInteger count) {
		int andDecrement = count.getAndDecrement();
		logger.error("粉丝接收通知,开启抢票,剩余票数{}",andDecrement);
	}
}

/**
 * 黄牛接收通知,开启抢票
 * @author 13723
 * @version 1.0
 * 2024/1/29 10:26
 */
public class CattleService implements Observer{
	private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

	/**
	 * 黄牛接收通知,开启抢票
	 * @param count 通知内容
	 */
	@Override
	public void make(AtomicInteger count) {
		int andDecrement = count.getAndDecrement();
		logger.error("黄牛接收通知,开启抢票,剩余票数{}",andDecrement);
	}
}

2.1.4.测试观察者
public class ObserverTest {
	private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());


	@Test
	@DisplayName("测试-观察者模式")
	public void test(){
		ArrayList<Thread> threads = new ArrayList<>();
		// 创建被观察者
		ConcertTicketSalesService concertTicketSalesService = new ConcertTicketSalesService();
		// 创建观察者(粉丝)
		for (int i = 0; i < 30; i++) {
			Thread thread = new Thread(() -> {
				FansService fansService = new FansService();
				concertTicketSalesService.addObserver(fansService);
			}, "f" + i);
			threads.add(thread);
		}
		// 创建观察者(黄牛)
		for (int i = 0; i < 10; i++) {
			Thread thread = new Thread(() -> {
				CattleService cattleService = new CattleService();
				concertTicketSalesService.addObserver(cattleService);
			}, "t" + i);
			threads.add(thread);
		}
		threads.forEach(Thread::start);
		// 被观察者开始执行卖票操作
		concertTicketSalesService.sale(100);


	}
}

image-20240228221718969

3.总结

3.1.优点和局限性

优点

  1. 松散耦合(Loose Coupling):观察者模式通过定义了一个抽象的观察者接口和被观察者对象之间的联系,使得它们可以相互独立地变化。这种松散耦合的设计使得系统更易于维护和扩展。
  2. 可扩展性(Scalability):由于观察者模式将被观察者对象与观察者对象分离,因此可以方便地增加新的观察者或者修改现有的观察者,而不需要修改被观察者对象的代码。
  3. 通知机制(Notification Mechanism):观察者模式提供了一种通知机制,使得被观察者对象发生改变时能够自动通知所有的观察者对象。这样可以确保所有相关的对象都能及时获取到最新的信息。
  4. 解耦合(Decoupling):观察者模式可以降低对象之间的耦合度,使得系统中的各个对象之间相互独立,降低了代码的复杂度。

局限性

  1. 过多的通知:如果被观察者对象频繁地发生改变,可能会导致观察者对象收到过多的通知,造成性能上的开销。
  2. 可能引发循环依赖:在某些情况下,观察者和被观察者之间可能出现循环依赖的情况,导致系统设计不合理。
  3. 难以调试:由于观察者模式中对象之间的关系比较复杂,当系统出现问题时,可能需要花费较多的时间和精力来进行调试和定位问题。
  4. 可能引起内存泄漏:如果观察者没有被正确地移除或者被长期持有,可能会导致内存泄漏问题,影响系统的性能和稳定性。

3.2.思考

  1. 事件驱动架构:观察者模式可以作为构建事件驱动架构的基础之一。通过将各个模块之间的交互建立在事件的发布与订阅之上,可以实现系统的高内聚、低耦合,使得系统更加灵活和可扩展。
  2. 异步通信:观察者模式可以与异步通信结合,实现异步事件处理。通过消息队列或者异步任务,观察者可以在收到通知后异步处理事件,提高系统的并发能力和响应速度。
  3. 领域驱动设计(DDD):在领域驱动设计中,观察者模式可以用于实现领域事件的发布与订阅。各个领域对象可以作为观察者,订阅感兴趣的领域事件,从而实现领域对象之间的解耦合和协同工作。
  4. 消息传递:观察者模式可以被用作消息传递的机制。不同模块之间的消息交互可以通过观察者模式实现,从而简化系统的通信方式,提高系统的灵活性和可维护性。
举报

相关推荐

HTML+CSS

HTML+CSS 2022.4.22

【html+css】阴影

html+css 案例

HTML+CSS使用

HTML+CSS笔记

HTML+CSS基础

html+css学习(中)

0 条评论