02_组间协作模式

最新推荐文章于 2024-07-18 15:51:26 发布
最新推荐文章于 2024-07-18 15:51:26 发布
阅读量108 收藏
点赞数
分类专栏： 设计模式 文章标签： golang 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013671216/article/details/131531624
版权

组件协作 模式

  • 现代软件工业化的结果， 框架与应用
  • 这几个体现最为明显

模板模式

对于某一项任务，它常常有稳定的整体操作结构，但各个子步骤却有很多改变的需求，或者由于固有的原因（比如框架与应用之间的关系）而无法和任务的整体结构同时实现。

运行流程，框架是稳定的，但是具体功能是变化的。

晚绑定，先开发的依赖于后续实现。

定义：

定义一个操作中的算法的骨架(稳定)，而将一些步骤延迟(变化)到子类中。Template Method使得子类可以不改变(复用)一个算法的结构即可重定义(override 重写)该算法的某些特定步骤。

稳定中有变化。

缺点： run()(模板流程)如果不稳定，则不应该用模板模式。都稳定，也没有必要使用设计模式了。

程序例子
Downloader
+Download(uri: string)
Template
- implement: Implement
- uri: string
+newTemplate(impl: Implement)
+Download(uri: string)
+save()
HTTPDownloader
- template: Template
+NewHTTPDownloader()
+download()
+save()
FTPDownloader
- template: Template
+NewFTPDownloader()
+download()
+save()
Implement 
package template

import "fmt"

// Download是一个个模板方法，由具体的步骤
type Downloader interface {
	Download(uri string)
}

type template struct {
	implement
	uri string
}

type implement interface {
	download()
	save()
}

func newTemplate(impl implement) *template {
	return &template{
		implement: impl,
	}
}

// Download方法的具体实现
func (t *template) Download(uri string) {
	t.uri = uri
	fmt.Print("prepare downloading\n")
	t.implement.download()
	t.implement.save()
	fmt.Print("finish downloading\n")
}

// 默认实现
func (t *template) save() {
	fmt.Print("default save\n")
}

// 具体的Http下载
type HTTPDownloader struct {
	*template
}

// http下载器的构造器
func NewHTTPDownloader() Downloader {
	downloader := &HTTPDownloader{}
	template := newTemplate(downloader)
	downloader.template = template
	return downloader
}

func (d *HTTPDownloader) download() {
	fmt.Printf("download %s via http\n", d.uri)
}

func (*HTTPDownloader) save() {
	fmt.Printf("http save\n")
}

type FTPDownloader struct {
	*template
}

func NewFTPDownloader() Downloader {
	downloader := &FTPDownloader{}
	template := newTemplate(downloader)
	downloader.template = template
	return downloader
}

func (d *FTPDownloader) download() {
	fmt.Printf("download %s via ftp\n", d.uri)
}

总结

  • Template Method模式是一种非常基础性的设计模式，在面向对象系统中有着大量的应用。它用最简洁的机制（虚函数的多态性）为很多应用程序框架提供了灵活的扩展点，是代码复用方面的基本实现结构。
  • 除了可以灵活应对子步骤的变化外，“不要调用我，让我来调用你”的反向控制结构是Template Method的典型应用。
  • 在具体实现方面，被Template Method调用的虚方法可以具有实现，也可以没有任何实现（抽象方法、纯虚方法），但一般推荐将它们设置为protected方法。

策略模式

定义一系列算法，把它们一个个封装起来，并且使它们可互相替换（变化）。该模式使得算法可独立于使用它的客户程序(稳定)而变化（扩展，子类化）

动机

  • 在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂；而且有时候支持不使用的算法也是一个性能负担。
  • 如何在运行时根据需要透明地更改对象的算法？将算法与对象本身解耦，从而避免上述问题？

例如，一个计算税率的程序，

package strategy

import "fmt"

const (
	CN = iota
	US
	DE
)

type SalesOrder struct {
	tax int
}

func (s *SalesOrder) CalculateTax() {
	switch s.tax {
	case CN:
		//...
		fmt.Println("CN")
	case US:
		//
		fmt.Println("US")
	case DE:
		fmt.Println("DE")
	default:
		fmt.Println("Not support")
	}
}

如果现在，我们要添加一个法国的税收计算方法，需要这样做：

package strategy

import "fmt"

const (
	CN = iota
	US
	DE
	FR
)

type SalesOrder struct {
	tax int
}

func (s *SalesOrder) CalculateTax() {
	switch s.tax {
	case CN:
		//...
		fmt.Println("CN")
	case US:
		//
		fmt.Println("US")
	case DE:
		fmt.Println("DE")
	case FR:
		fmt.Println("FR")
	default:
		fmt.Println("Not support")
	}
}

这样看似解决了问题，但违背了开闭原则，对扩展开放，对修改封闭。修改了源码，维护更困难。

定义基类

package strategy

import "fmt"

type Context struct {
}

type TaxStrategy interface {
	Calculate(context *Context) float64
}

然后跟分别为CN\US\DE实现计算方法

type CNTax struct {
	TaxStrategy
}

func (tax *CNTax) Calculate(ctx *Context) float64 {
	fmt.Println("CN Tax Calculate")
	return 0
}

type USTax struct {
	TaxStrategy
}

func (tax *USTax) Calculate(ctx *Context) float64 {
	fmt.Println("US Tax Calculate")
	return 0
}

type DETax struct {
	TaxStrategy
}

func (tax *DETax) Calculate(ctx *Context) float64 {
	fmt.Println("DE Tax Calculate")
	return 0
}

使用，会初步设计到工厂模式，展示就理解为返回我们需要的实例

type StrategyFactory struct {
}

func (factor *StrategyFactory) NewStrategy() TaxStrategy {
	//here are some implement
	// 工厂模式
	// 工厂决定返回哪个实例
	return nil
}

type SalesOrder struct {
	taxStrategy TaxStrategy
}

func (s *SalesOrder) New(StrategyFactory *StrategyFactory) *SalesOrder {
	return &SalesOrder{
		taxStrategy: StrategyFactory.NewStrategy(),
	}
}

func (s *SalesOrder) CalculateTex() float64 {
	context := &Context{} //上下文
	//真正的实现
	return s.taxStrategy.Calculate(context)
}

如果现在要添加法国，只需要添加一个新的实现

type FRTax struct {
	TaxStrategy
}

func (tax *FRTax) Calculate(ctx *Context) float64 {
	fmt.Println("FR Tax Calculate")
	return 0
}

调用完全不需要该变，

package strategy

import "testing"

func TestCNTex(t *testing.T) {
	var strategy StrategyFactory
	order := NewSalesOrder(&strategy)
	order.CalculateTex()
}

在这里插入图片描述

总结

  • Strategy及其子类为组件提供了一系列可重用的算法，从而可以使得类型在运行时方便地根据需要在各个算法之间进行切换。
  • Strategy模式提供了用条件判断语句以外的另一种选择，消除条件判断语句，就是在解耦合。含有许多条件判断语句的代码通常都需要Strategy模式。
  • 如果Strategy对象没有实例变量，那么各个上下文可以共享同一个Strategy对象，从而节省对象开销。（单例模式）

如果出现了大量的if else可用用策略模式。if else 是分而治之 。

如果if else绝对不变，不会继续扩展，则不用strategy。

观察者模式/Event模式

定义对象间的一种一对多（变化）的依赖关系，以便当一个对象(Subject)的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

动机

  • 通知依赖的对象，关系又不能太紧密。在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系” ——一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好地抵御变化。
  • 使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合。

实例

package observer

import "strconv"

type FileSplitter struct {
	path string
	nums int
}

func (s *FileSplitter) split() {
	//do something
	//split a big file to nums small files
}

type TextBox struct {
}

func (box *TextBox) getText() string {
	return ""
}

type MainForm struct {
	txtFilePath   *TextBox
	txtFileNumber *TextBox
}

func (main *MainForm) Button1_Click() {
	filePath := main.txtFilePath.getText()
	number, _ := strconv.Atoi(main.txtFileNumber.getText())
	splitter := FileSplitter{filePath, number}
	splitter.split()
}

需要显示进度条，怎么办？

朴素想法，需要使用ProgressBar ,然后更新它，但是进度信息在split里。可能需要在FileSpilter中定义一个ProgressBar

于是得到如下解决方法

package observer

import "strconv"

type ProgressBar struct {
	progress float64
}

type FileSplitter struct {
	path string
	nums int
	psb  *ProgressBar
}

func (s *FileSplitter) split() {
	//do something
	//split a big file to nums small files
	for i := 0; i < s.nums; i++ {

		if s.psb != nil {
			s.psb.progress = float64((i + 1) / s.nums)
		}
	}
}

type TextBox struct {
}

func (box *TextBox) getText() string {
	return ""
}

type MainForm struct {
	txtFilePath   *TextBox
	txtFileNumber *TextBox
	progress      *ProgressBar
}

func (main *MainForm) Button1_Click() {
	filePath := main.txtFilePath.getText()
	number, _ := strconv.Atoi(main.txtFileNumber.getText())
	splitter := FileSplitter{filePath, number, main.progress}
	splitter.split()
}

存在问题：

  • 违背了依赖倒置原则，高层不应该依赖低层，抽象不依赖具体。
  • 抽象依赖是实现细节了，在FileSplitter中依赖了具体的容易变化的ProgressBar.
  • 单纯抽象类也不行，
  • 我们核心是需要有一个通知。

解决方法：

1 实现一个抽象的IProgress接口

type IProgress interface {
	DoProgress(value float64)
}

2 具体的更新进度的方法

type FileSplitter struct {
	path        string
	nums        int
	m_iprogress IProgress//这是最关键的
}

func (s *FileSplitter) split() {
	//do something
	//split a big file to nums small files
	for i := 0; i < s.nums; i++ {

		if s.m_iprogress != nil {
			s.m_iprogress.DoProgress(float64((i + 1) / s.nums))
		}
	}
}

3 实现具体的方法

type MainForm struct {
	txtFilePath   *TextBox
	txtFileNumber *TextBox
	progress      *ProgressBar
	IProgress
}

func (main *MainForm) DoProgress(value float64) {
	main.progress.progress = value
}

func (main *MainForm) Button1_Click() {
	filePath := main.txtFilePath.getText()
	number, _ := strconv.Atoi(main.txtFileNumber.getText())
	splitter := FileSplitter{filePath, number, main}
	splitter.split()
}
IProgress
+DoProgress(value: float64)
ProgressBar
- progress: float64
FileSplitter
- path: string
- nums: int
- m_iprogress: IProgress
+split()
TextBox
- text: string
+getText()
MainForm
- txtFilePath: TextBox
- txtFileNumber: TextBox
- progress: ProgressBar
- IProgress
+DoProgress(value: float64)
+Button1_Click()

目前只有一个观察者，即progress bar。如果我们要支持多个观察者呢？

比如：多一个控制台的程序，

type Console struct {
	IProgress
}

func (c *Console) DoProgress(value float64) {
	fmt.Printf(".")
}

那么此时，我们只能传递要么，main中的ProgressBar，要么console

func (main *MainForm) Button1_Click() {
	filePath := main.txtFilePath.getText()
	number, _ := strconv.Atoi(main.txtFileNumber.getText())
	console := &Console{}
	splitter := FileSplitter{filePath, number, console}
	splitter.split()
}

也就是对于一个数据，只有一个观察者。

我们可用添加一组观察者：

type FileSplitter struct {
	path        string
	nums        int
	m_iprogress []IProgress //多个观察者
}

完整代码

package observer

import (
	"fmt"
	"strconv"
	"time"
)

func removeDuplicates(A []IProgress, B []IProgress) []IProgress {
	result := []IProgress{}
	// 创建一个 map 用于记录切片 B 中的元素
	bMap := make(map[IProgress]bool)
	for _, value := range B {
		bMap[value] = true
	}
	// 遍历切片 A，如果元素不在切片 B 中，则将其添加到结果切片中
	for _, value := range A {
		if !bMap[value] {
			result = append(result, value)
		}
	}
	return result
}

type IProgress interface {
	DoProgress(value float64)
}

type ProgressBar struct {
	progress float64
}

type FileSplitter struct {
	path        string
	nums        int
	m_iprogress []IProgress //多个观察者
}

func (s *FileSplitter) add_IProgress(iprogress ...IProgress) {
	s.m_iprogress = append(s.m_iprogress, iprogress...)
}
func (s *FileSplitter) remove_IProgress(iprogress []IProgress) {
	s.m_iprogress = removeDuplicates(s.m_iprogress, iprogress)
}

// 通知所有观察者
func (s *FileSplitter) OnProgress(value float64) {
	for _, progress := range s.m_iprogress {
		go progress.DoProgress(value)
	}
}
func (s *FileSplitter) split() {
	//do something
	//split a big file to nums small files
	for i := 0; i < s.nums; i++ {
		time.Sleep(1 * time.Second)
		s.OnProgress(float64(i+1) / float64(s.nums))
	}
}

type TextBox struct {
	text string
}

func (box *TextBox) getText() string {
	return box.text
}

type MainForm struct {
	txtFilePath   *TextBox
	txtFileNumber *TextBox
	progress      *ProgressBar
	IProgress
}

func (main *MainForm) DoProgress(value float64) {
	main.progress.progress = value
	//我们可用在这里拿到真正的进度值
	fmt.Printf("progress : %f\n", value)
}

func (main *MainForm) Button1_Click() {
	filePath := main.txtFilePath.getText()
	number, _ := strconv.Atoi(main.txtFileNumber.getText())
	console := &Console{}
	splitter := FileSplitter{filePath, number, nil}
	splitter.add_IProgress(main)
	splitter.add_IProgress(console)
	splitter.split()
}

type Console struct {
	IProgress
}

func (c *Console) DoProgress(value float64) {
	fmt.Printf(".")
}

测试

package observer

import (
	"testing"
)

func TestMainForm(t *testing.T) {
	main := &MainForm{
		txtFilePath:   &TextBox{"Hello.txt"},
		txtFileNumber: &TextBox{"5"},
		progress: &ProgressBar{
			progress: 0,
		},
	}
	main.Button1_Click()
}

类图
1
*
1
1
1
2
IProgress
+DoProgress(value: float64)
ProgressBar
- progress: float64
FileSplitter
- path: string
- nums: int
- m_iprogress: []IProgress
+add_IProgress(iprogress: ...IProgress)
+remove_IProgress(iprogress: []IProgress)
+OnProgress(value: float64)
+split()
TextBox
- text: string
+getText()
MainForm
- txtFilePath: *TextBox
- txtFileNumber: *TextBox
- progress: *ProgressBar
+Button1_Click()
+DoProgress(value: float64)
Console
+DoProgress(value: float64)

书上类图，

在这里插入图片描述

总结

  • 使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达致松耦合。
  • 目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。
  • 观察者自己决定是否需要订阅通知，目标对象对此一无所知。
  • Observer模式是基于事件的UI框架中非常常用的设计模式，也是MVC模式的一个重要组成部分。
都学点
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于网络协作模式的制造服务组合方法
03-12
基于网络协作模式的制造服务组合方法
JavaScript_用于构建协作软件的共享数据类型.zip
05-20
在协作软件中，对象和数组常常被用来存储和传递结构化的数据。 "yjs_main.zip"可能包含了一个名为Yjs的库或框架，这是一个用于实时协作编辑的JavaScript库。Yjs提供了一种数据模型，允许开发者在分布式系统中同步...
瑞_23种设计模式_策略模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
03-11 2526
本文章为瑞_系列专栏之《23种设计模式》的策略模式篇。工厂模式结合策略模式可以替换 if-else 语句。策略模式主要目的是避免使用多重条件语句，并将算法的实现从使用算法的客户端代码中分离出来。在策略模式（Strategy Pattern）中一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。
瑞_23种设计模式_命令模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
03-13 2179
本文章为瑞_系列专栏之《23种设计模式》的命令模式篇。常见的命令模式使用到的接口方法`execute()`。典型命令模式：`Runable`，Runnable担当命令的角色，Thread充当的是调用者，start方法就是其执行方法。
CUDA中的协作组
专注于人工智能领域的小何尚
06-04 977
Cooperative Groups 是 CUDA 9 中引入的 CUDA 编程模型的扩展，用于组织通信线程组。协作组允许开发人员表达线程通信的粒度，帮助他们表达更丰富、更有效的并行分解。从历史上看，CUDA 编程模型为同步协作线程提供了一个单一、简单的构造：线程块的所有线程之间的屏障，如使用 内部函数实现的那样。但是，程序员希望以其他粒度定义和同步线程组，以“集体”组范围功能接口的形式实现更高的性能、设计灵活性和软件重用。为了表达更广泛的并行交互模式，许多面向性能的程序员已经求助于编写自己的临时和不安全
C 嵌入式系统设计模式 10：中介者模式
朱工的专栏
02-23 1317
本文章描述访问硬件的设计模式之三：中介者模式。
UVM设计模式 （七）命令模式、三种sequence启动方式、start_item/finish_item、中介模式、virtual sequence
热门推荐
Holden_Liu的博客
12-27 1万+
a
UML.rar_design patterns_secretxx6_uml _设计模式
09-20
UML中的设计模式体现主要通过类图、对象图、序列图、协作图等不同的视图来展现。例如，工厂模式可以通过UML类图来表示，其中包含一个抽象工厂接口和多个具体工厂类；单例模式则可以利用类图和对象图来描绘其生命周期...
24中設計模式和6中原則.rar_design patterns_设计模式
09-23
设计模式是软件工程中的一种重要...通过理解和应用这些模式，开发人员可以提高代码质量，降低维护成本，同时增强团队间的沟通和协作。阅读《24种设计模式和6种原则》PDF文件，将有助于你深入理解并熟练运用这些概念。
NETand-Design-Patterns.rar_NET与设计模式
09-21
适配器模式则能将不兼容的接口转换为可协作的形式，使旧的类能在新的系统中使用。 行为型模式关注的是对象之间的交互和责任分配。策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，让策略对象...
go 实现websocket以及详细设计流程过程，确保通俗易懂
每天进步一点
07-17 884
数据只能单向传送为单工；数据能双向传送但不能同时双向传送称为半双工；数据能够同时双向传送则称为全双工。上面是简单的接受了websocket情况以及和其他协议的区别及联系，在做之前，还是要了解下这块，对后期实战有帮助。
golang小案例获取命令行的的参数并求得最大值
preserveXing的博客
07-15 229
这个案例是Golang理解os.Args的案例 场景就是: 当我们打包后 生成的.exe文件 执行exe肯定会出现哪些命令 例如 npm install app 这里的npm 就是npm .exe install app 就是我们要获取的参数 我们的案例: 编写go程序---->打包成exe--->执行exe--->添加命令行参数 一些数值---->求得最大化数值
Go: IM系统技术架构梳理 (2)
Wang的专栏
07-15 1081
整个IM系统的一般架构如下我们这张图展示了整个IM系统的一般架构可见分为四层那最上面这一层是前端，包括哪些东西呢？它包括两部分，第一部分是跟用户直接交互的比如说各种IOS APP, 各种安卓 APP还有各种 web APP 在浏览器里面打开的以及windows上面跑的那种客户端第二部分是跟我们程序相关的SDK，API，Websocket这些我们都统称为前端第二个是接入层，这里展示了几种常用的接入协议实际上还会用到Mqtt, Xmpp 等各种协议这是接入层。
解决 go 引用私有包，安装失败
Dreamy_LIN的博客
07-17 213
go mod tidy 或者 go run main.go 时，提示失败，例如 no such host（设置GOPRIVATE）或者 x509: certificate signed by unknown authority 之类的报错（设置GOINSECURE）
Golang中读写锁的底层实现
qq_42538588的博客
07-16 781
读写锁是一种并发控制机制，它允许多个线程同时对共享资源进行读访问，但在进行写操作时需要互斥访问，以确保数据的一致性和完整性。读写锁的主要功能是提高系统在读多写少场景下的并发处理能力，从而提升整体性能。读写锁在实际应用中扮演着重要的角色，可以有效地降低系统的并发访问冲突，提高系统的并发处理能力，同时也能够避免写操作对读操作的阻塞，从而减少了线程的等待时间，提升了系统的整体响应速度。w Mutex // 互斥锁L *Locker本文介绍了如何在Go语言中使用读写锁的应用实例。
go-zero框架入门
最新发布
qq_63728673的博客
07-18 560
使用 Raft 共识算法**，确保了在分布式环境中的强一致性**。再举个例子：正常项目中配置文件写在代码中，若配置文件修改，项目就该重新启动，但是若使用了etcd，每次去查看对应RPC的配置信息时都是从etcd中实时获取。并且etcd本身为分布式系统设计，提供了原生的服务发现和配置管理功能，支持 Watch 机制，可以。之后打开一个命令行窗口，输入：etcd就可以启动了，然后再打开一个黑窗口（上一个不要关）这就是go-zero使用前的前置工作了，下一步就是去写简单的项目。1.在根目录下创建一个user包。
golang mux组件兼容转移url
国产-达芬奇
07-16 229
UseEncodedPath
GO——GMP 好文整理
sy_123a的专栏
07-17 190
GMP相关好文推荐：Golang的协程调度器原理及GMP设计思想
适配器模式解析：接口转换与类的协作
"适配器设计模式是一种结构型设计模式，用于将不同接口的类进行兼容，使得原本因接口不兼容而无法协作的类能够一起工作。它通过创建一个适配器类，将原有类的接口转换为客户期望的接口，以此来适应不同的系统需求。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

都学点

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值