设计模式学习之路-策略模式「附详细案例」

最新推荐文章于 2024-05-07 17:33:22 发布
最新推荐文章于 2024-05-07 17:33:22 发布
阅读量980 收藏 11
点赞数 27
分类专栏： GO 学习之路 设计模式学习之路 文章标签： go 设计模式 架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pengyachuan/article/details/136336988
版权

我写设计模式第 4 篇，前 3 篇内容分别是

深入设计模式之工厂模式「附详细案例」-CSDN博客

深入设计模式-适配器模式「GO 版本」-CSDN博客

深入 GO 选项模式-CSDN博客

学习策略模式强烈建议看看工厂模式，策略模式这篇解决了工厂模式遗留问题。

名词解释

策略模式（Strategy Pattern）是一种行为设计模式。它定义了一系列算法，将每种算法封装在独立的策略实现子类中，并使它们可以互相替换，使得算法变化可以独立于使用算法的使用方。

算法理解成业务逻辑或业务规则；使用方理解成使用代码的业务方。

SOP

本文以“SOP”为案例，“SOP”也叫”营销自动化“。所谓 SOP，是 Standard Operating Procedure 三个单词中首字母的大写 ，即标准作业程序，指将某一事件的标准操作步骤和要求以统一的格式描述出来，用于指导和规范日常的工作标准作业程序_百度百科。比如你去餐厅，服务人员先给你拿菜单、点菜、上菜、买单这一套操作就是标准的流程。

”SOP“旨在帮助企业将复杂场景的用户运营策略自动化执行，并提供运营效果量化追踪的平台。比如：自动发短信、发消息等。

比如你要在情人节给朋友圈客户发送满减活动。你会经历下面这几步

1、 谁来发「员工」

2、 发给谁「客户」

3、 发什么「内容」

4、 何时发「时间」

5、 怎么发「通道」

编码案例围绕「通道」触达用户，通道可能是”短信通道“、”公众号群发通道“、“邮件通道”、“抖音私信通道”、“企业微信群发通道“等。。。假设你做一套解决方案整合通道能力给客户提供更加便利触达用户工具。

工厂设计模式章节，我提到了工厂模式关注的是对象的创建过程，创建过程封装在工厂类中，使用方不需要关心对象的具体创建过程，只需通过工厂方法或抽象工厂获取所需对象即可。

策略模式关注运行时选择不同的算法；将算法的实现与使用算法的业务方代码分离开来，以提高代码的灵活性、可维护性和可复用性时；

算法（策略）定义

策略定义抽象策略接口，若干个实现抽象策略接口的实现类。策略接口和实类不一定要用 Strategy 结尾。代码片段如下

// Sender 定义策略
type Sender interface {
	// SendMsg 定义算法（规则和逻辑）
	SendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error)
}

// SMS 短信通道实现类
type SMS struct {
}

func NewSMS() Sender {
	return &SMS{}
}

// SendMsg 实现具体算法/规则
func (c *SMS) SendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	// todo 通过短信通道触达客户逻辑省略
	fmt.Printf("推送信息,targetID=%v,data=%v\n", targetID, data)
	return data, nil
}

// Tiktok 抖音通道实现类
type Tiktok struct {
}

func NewTiktok() Sender {
	return &Tiktok{}
}

// SendMsg 实现具体算法/规则
func (c *Tiktok) SendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	// todo 通过抖音通道触达客户逻辑省略
	return nil, nil
}

策略创建和使用

仅仅有策略定义，还算不上是完整的策略模式，虽然这些类也能直接用创建对象方式使用，比如创建子类对象就可以使用。代码如下

func TestStrategy(t *testing.T) {
	NewSMS().SendMsg(context.TODO(), "xxx", "您好")
}

如果使用方都各自调用子类，没有发挥策略模式优势，只能说使用了多态的特性。

上篇文章我讲了简单工厂我在给大家回顾下。代码如下：

type SenderType string

const (
	SMSSenderType    SenderType = "sms"
	TiktokSenderType SenderType = "tiktok"
)

// Mgr 工厂类
type Mgr struct {
}

func NewMgr() *Mgr {
	return &Mgr{}
}

func (m *Mgr) GetSender(tp SenderType) (Sender, bool) {
	if tp == SMSSenderType {
		return NewSMS(), true
	} else if tp == TiktokSenderType {
		return NewTiktok(), true
	}
	
	return nil, false
}

上段代码定义了工厂类，工厂类提供方法 GetSender() 获取 Sender。接下来我把上段代码优化下，用 Map 来缓存策略实现类，策略随取随用不用每次 new 新对象，改造代码如下

type SenderType string

const (
	SMSSenderType    SenderType = "sms"
	TiktokSenderType SenderType = "tiktok"
)

var (
	senderMapping = make(map[SenderType]Sender)
)

// 提前初始化并且把策略缓存在 Map 中，即用即去，不用每次都创建对象
func init() {
	senderMapping[SMSSenderType] = NewSMS()
	senderMapping[TiktokSenderType] = NewTiktok()
}

// Mgr 工厂类
type Mgr struct {
}

func NewMgr() *Mgr {
	return &Mgr{}
}

func (m *Mgr) GetSender(tp SenderType) (Sender, bool) {
	v, ok := senderMapping[tp]
	return v, ok
}

定义全局变量 senderMapping 用来缓存策略，业务场景按需组册到 senderMapping 即可。我解释下 init() 函数，在 go 中包加载时候会自动调用，不需要手动调用。在工厂类 Mgr 中，根据 SenderType 获取对应的策略避免了 if else 判断逻辑。不用 Map 用其他数据结构可以吗？其实数组、切片都是可以的，本来策略实现类就不多，效率也没啥区别。

策略使用方比较简单了

func TestStrategy(t *testing.T) {
	strategy, exists := NewMgr().GetSender(SMSSenderType)
	if !exists {
		panic("策略器不存在")
	}
	strategy.SendMsg(context.TODO(), "xxx", "您好")
}

结果输出如下

=== RUN   TestStrategy
推送信息,targetID=xxx,data=您好
--- PASS: TestStrategy (0.00s)
PASS

看到这里有是不是有疑问？策略模式和工厂模式太像了。是的你想的没错，设计模式都是基于接口编程非实现编程，你学习过更多设计模式你会发现都是这样的，另外在开发中设计模式基本都是组合使用。

项目中优化过程

好的代码并不是一开始就是最优的，都是逐步的演变而来。一般都会经历下面几步。

第一步：最简单原则

第一步是最基础的，也是大多数研发同学刚开始选择使用的，对于刚开始使用该模式的人来说是一个很好的步骤。另外也可能因为项目紧急选择的一种方案。

func SMSSendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	fmt.Printf("推送信息,targetID=%v,data=%v\n", targetID, data)
	return data, nil
}

func TiktokSendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	fmt.Printf("推送信息,targetID=%v,data=%v\n", targetID, data)
	return data, nil
}

func WeComSendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	fmt.Printf("推送信息,targetID=%v,data=%v\n", targetID, data)
	return data, nil
}

func TestBasicStrategy(t *testing.T) {
	SendMsg(SMSSenderType, context.TODO(), "xxx", "您好")
}

func SendMsg(tp SenderType, ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	if tp == SMSSenderType {
		return SMSSendMsg(ctx, targetID, data)
	} else if tp == TiktokSenderType {
		return TiktokSendMsg(ctx, targetID, data)
	} else if tp == WeComSenderType {
		return WeComSendMsg(ctx, targetID, data)
	}

	return nil, errors.New("未找到通道实现类")
}

第二步：优化 if-else

如果对自己写的代码有要求，时刻回顾加上需求积累，应该是很容易发现问题。下一步清理 if-else ，它太啰嗦了，并且扩展性差，后期 SendMsg() 方法会非常臃肿，if-else 用 map 优化掉。

var (
	m = make(map[SenderType]func(ctx context.Context, targetID string, data interface{}) (interface{}, error))
)

func init() {
	m[SMSSenderType] = SMSSendMsg
	m[TiktokSenderType] = TiktokSendMsg
	m[WeComSenderType] = WeComSendMsg
}

func SMSSendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	fmt.Printf("推送信息,targetID=%v,data=%v\n", targetID, data)
	return data, nil
}

func TiktokSendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	fmt.Printf("推送信息,targetID=%v,data=%v\n", targetID, data)
	return data, nil
}

func WeComSendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	fmt.Printf("推送信息,targetID=%v,data=%v\n", targetID, data)
	return data, nil
}

func TestBasicStrategy(t *testing.T) {
	SendMsg(SMSSenderType, context.TODO(), "xxx", "您好")
}

func SendMsg(tp SenderType, ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	fn, exists := m[tp]
	if !exists {
		return nil, errors.New("未找到通道实现类")
	}

	return fn(ctx, targetID, data)
}

用 map 替换了 if-else，看上去是扩展性更强了，但并没有定义策略接口，还不算标准策略模式，哪些场景会使用呢？我总结了几点：

1、 你有一些 if 或 switch 语句，希望它们更简洁。

2、 你有一小部分可供选择的算法。

3、 开发代码的童鞋比较偷懒。

第三步：定义抽象策略接口

我比较倾向用这种方式，扩展更强，低耦合。

func init() {
	if err := Register(SMSSenderType, NewSMS()); err != nil {
		panic(err)
	}
}

// SMS 短信通道实现类
type SMS struct {
}

func NewSMS() Sender {
	return &SMS{}
}

// SendMsg 实现具体算法/规则
func (c *SMS) SendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	// todo 通过短信通道触达客户逻辑省略
	fmt.Printf("推送信息,targetID=%v,data=%v\n", targetID, data)
	return data, nil
}

// Tiktok 抖音通道实现类
type Tiktok struct {
}

func init() {
	if err := Register(TiktokSenderType, NewTiktok()); err != nil {
		panic(err)
	}
}

func NewTiktok() Sender {
	return &Tiktok{}
}

// SendMsg 实现具体算法/规则
func (c *Tiktok) SendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	// todo 通过抖音通道触达客户逻辑省略
	return nil, nil
}

type SenderType string

const (
	SMSSenderType    SenderType = "sms"
	TiktokSenderType SenderType = "tiktok"
	WeComSenderType  SenderType = "wecom"
)

var (
	senderMapping = make(map[SenderType]Sender)
)

// Register 注册策略实现类
func Register(tp SenderType, sender Sender) error {
	_, exists := senderMapping[tp]
	if exists {
		return errors.New("重复注册")
	}

	senderMapping[tp] = sender
	return nil
}

// Mgr 工厂类
type Mgr struct {
}

func NewMgr() *Mgr {
	return &Mgr{}
}

func (m *Mgr) GetSender(tp SenderType) (Sender, bool) {
	v, ok := senderMapping[tp]
	return v, ok
}

第三步相比第一步和第二步增加了策略接口，策略类实现了策略接口。工厂类获取策略对象的方式不变，唯一的区别是策略的创建，提供了 Register() 函数，该方法是把策略实现类注册到 senderMapping 中，另外注册逻辑调整到子类 init() 函数，优点是如果增加策略实现类，只需要在实现类中调用 Register() 函数即可。

总结

策略类定义：策略类包含一个抽象策略接口和若干实现该接口的具体实现类。策略接口定义了算法（逻辑）的标准，具体策略类则实现了标准，并提供了特定的算法（逻辑）实现。

策略创建：策略创建由工厂类来完成，工厂类封装了策略创建细节。工厂类负责根据使用方需求创建具体的策略对象，并返回给使用方。

策略使用：使用方用策略对象来执行特定算法（逻辑）。使用方可以选择不同的策略对象，从而实现算法（逻辑）的动态切换。

思考题

1、你们项目中有用策略模式吗？是怎么用的呢？

2、用 map 缓存策略子类，因为对象是可以复用的，所以是单例。如果你的业务场景每次都需要 new 新对象（非单例），应该如何实现？我提供 2 种方案

方案一：高阶函数+闭包

func init() {
	if err := Register(SMSSenderType, func() Sender {
		return NewSMS()
	}); err != nil {
		panic(err)
	}
}

// SMS 短信通道实现类
type SMS struct {
	tag string
}

func NewSMS() Sender {
	return &SMS{}
}

// SendMsg 实现具体算法/规则
func (c *SMS) SendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	// todo 通过短信通道触达客户逻辑省略
	fmt.Printf("推送信息,targetID=%v,data=%v\n", targetID, data)
	return data, nil
}

// Tiktok 抖音通道实现类
type Tiktok struct {
}

func init() {
	if err := Register(TiktokSenderType, func() Sender {
		return NewTiktok()
	}); err != nil {
		panic(err)
	}
}

func NewTiktok() Sender {
	return &Tiktok{}
}

// SendMsg 实现具体算法/规则
func (c *Tiktok) SendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	// todo 通过抖音通道触达客户逻辑省略
	return nil, nil
}

// 工厂类
var (
	dynamicSenderMapping = make(map[SenderType]func() Sender)
)

// Register 注册策略实现类
func Register(tp SenderType, fn func() Sender) error {
	_, exists := senderMapping[tp]
	if exists {
		return errors.New("重复注册")
	}

	dynamicSenderMapping[tp] = fn
	return nil
}

func GetDynamicSender(tp SenderType) (Sender, bool) {
	sender, exists := dynamicSenderMapping[tp]
	if !exists {
		return nil, false
	}

	return sender(), true
}

dynamicSenderMapping 映射一个函数，调用 GetDynamicSender() 函数后通过 fn() 函数来创建新的对象。还可以传参，根据自己的业务场景传参即可。

业务方使用方式如下：

func TestGetDynamicSender(t *testing.T) {
	sender, exists := GetDynamicSender(SMSSenderType)
	if !exists {
		panic("未找到信息")
	}

	fmt.Printf("sender打印地址：%p\n", sender)
	sender1, exists := GetDynamicSender(SMSSenderType)
	if !exists {
		panic("未找到策略实现类")
	}
	fmt.Printf("sender1打印地址：%p\n", sender1)
}

结果输出如下

=== RUN   TestGetDynamicSender
sender打印地址：0xc00005a2a0
sender1打印地址：0xc00005a2b0
--- PASS: TestGetDynamicSender (0.00s)
PASS

方案二：用反射

func init() {
	if err := Register(SMSSenderType, NewSMS()); err != nil {
		panic(err)
	}
}

// SMS 短信通道实现类
type SMS struct {
	tag string
}

func NewSMS() Sender {
	return &SMS{}
}

// SendMsg 实现具体算法/规则
func (c *SMS) SendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	// todo 通过短信通道触达客户逻辑省略
	fmt.Printf("推送信息,targetID=%v,data=%v\n", targetID, data)
	return data, nil
}

// Tiktok 抖音通道实现类
type Tiktok struct {
}

func init() {
	if err := Register(TiktokSenderType, NewTiktok()); err != nil {
		panic(err)
	}
}

func NewTiktok() Sender {
	return &Tiktok{}
}

// SendMsg 实现具体算法/规则
func (c *Tiktok) SendMsg(ctx context.Context, targetID string, data interface{}) (interface{}, error) {
	// todo 通过抖音通道触达客户逻辑省略
	return nil, nil
}

var (
	dynamicSenderMapping = make(map[SenderType]Sender)
)

// Register 注册策略实现类
func Register(tp SenderType, sender Sender) error {
	_, exists := dynamicSenderMapping[tp]
	if exists {
		return errors.New("重复注册")
	}

	dynamicSenderMapping[tp] = sender
	return nil
}

func GetDynamicSender(tp SenderType) (Sender, bool) {
	sender, exists := dynamicSenderMapping[tp]
	if !exists {
		return nil, false
	}

	t := reflect.TypeOf(sender)
	if t.Kind() == reflect.Ptr {
		t = t.Elem()
	}
	val := reflect.New(t)
	out, ok := val.Interface().(Sender)
	if !ok {
		return nil, false
	}

	return out, true
}

函数通过反射获取 sender 的类型，并检查是否是一个指针类型。如果是指针类型，通过 Elem() 方法获取指针指向的值的类型。最后，使用 reflect.New 创建一个新值，类型与 sender 相同。

结果输出如下

=== RUN   TestGetDynamicSender
打印地址：0xc000096270
打印地址：0xc000096280
--- PASS: TestGetDynamicSender (0.00s)
PASS

参考文献

https://zh.wikipedia.org/wiki/%E7%AD%96%E7%95%A5%E6%A8%A1%E5%BC%8F​zh.wikipedia.org/wiki/%E7%AD%96%E7%95%A5%E6%A8%A1%E5%BC%8F

彭亚川Allen
关注
  • 27
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php设计模式之策略模式应用案例详解
10-16
主要介绍了php设计模式之策略模式,结合具体应用案例形式详细分析了php策略模式的原理、定义、实现方法及项目应用案例与操作注意事项,需要的朋友可以参考下
设计模式-策略模式-以购物车的支付策略为例
韩超的博客 (hanchao5272)
07-19 4776
超级链接: Java常用设计模式的实例学习系列-绪论 参考：《HeadFirst设计模式》 1.关于策略模式 策略模式是一种行为模式。 策略模式：如果某种行为拥有多种运作方式，那么把这种行为视为一种策略，把这些运作方式视为策略实现，这些策略实现之间可以相互替换。 这样，行为调用方就可以在运行时，根据不同的需求，将相应的策略实现当做参数，以达到行为按照某种方式运作的目的。 本文以购物车的支付策略为...
Java设计模式——策略模式
热门推荐
涛涛的个人博客
10-29 8万+
策略模式 1.策略模式简介 策略模式：策略模式是一种行为型模式，它将对象和行为分开，将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化，行为之间可以相互替换。每个if判断都可以理解为就是一个策略。本模式使得算法可独立于使用它的用户而变化 2.模式结构 策略模式包含如下角色： Strategy: 抽象策略类：策略是一个接口，该接口定义若干个算法标识，即定义了若干个抽象方法（如下图的algorithm()） Context: 环境类 /上下文类： 上下文是依赖于接口的类（
设计模式之策略模式详解
glass__sky的博客
05-16 6166
​ 该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户（算法的具体实现不同？）。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。.........
JAVA设计模式征服之路-00-设计模式简介
CHQIUU的专栏
06-21 1万+
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
设计模式之【策略模式】，去掉繁琐的if-else，实现算法的动态替换
秃了也弱了
05-23 4024
策略模式（Strategy Pattern）又叫政策模式（Policy Pattern），它是将定义的算法家族分别封装起来，让它们之间可以互相替换，从而让算法的变化不会影响到使用算法的用户。属于行为型模式。策略模式使用的就是面向对象的继承和多态机制，从而实现同一行为在不同场景下具备不同实现。
java设计模式之策略模式
m0_47944994的博客
11-17 1585
java设计模式之策略模式
深入浅出设计模式---7、策略模式
u014526891的博客
03-31 9575
策略模式 定义: 策略模式是对算法的包装，把使用算法的责任和算法本身分隔开，委派给不同的对象管理。策略模式通常把一系列的算法包装 到一系列的策略类里面，作为一个抽象策略类的子类。 简单来说就是就定义一个策略接口，子类策略去实现该接口去定义不同的策略。然后定义一个环境（Context，也就 是需要用到策略的对象）类，以策略接口作为成员变量，根据环境来使用具体的策略。 优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。 缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。 策略模
java设计模式之策略模式+工厂模式（优化if-else）
m0_47944994的博客
11-18 4600
java设计模式之策略模式+工厂模式
Java设计模式之策略模式(UML类图分析+代码详解)
m0_51750419的博客
10-26 4884
策略模式：分别封装行为接口，实现算法族，超类里放行为接口对象，在子类里具体 设定行为对象。1) 策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以 互相替换，此模式让算法的变化独立于使用算法的客户。2) 上面说的1 的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改 动，会影响其他部分。1) 其它鸭子，都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的。1) 应用实例要求 编写程序完成前面的鸭子项目，要求使用策略模式。
【设计模式】策略模式实例
weixin_51167671的博客
05-10 1552
系列文章目录 第六章 行为模式（上） 目录 系列文章目录 前言 一、🌍策略（Strategy）模式是什么？🌍 二、🌍策略（Strategy）模式的优缺点🌍 三、🌍策略（Strategy）模式的结构🌍 四、🌍实例演示🌍1.🌕实例概述🌕 2.🌕代码演示🌕 3.🌕实验结果🌕 总结 前言 设计模式，又称为软件设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 学习设计模式可以提高程序员的思维能力、编程能力和设计能力，使程...
设计模式——策略模式的学习与理解
12-20
什么是策略模式 通俗的来说。策略模式（ Strategy Pattern）就是将算法封装到具有共同接口的独立类中，以独立与客户端，客户端可以灵活的使用或替换算法族里面不同的算法...想要学习一个设计模式，首要的就是了解这个设
php设计模式之策略模式实例分析【星际争霸游戏案例】
10-15
主要介绍了php设计模式之策略模式,结合星际争霸游戏案例形式分析了php策略模式相关原理、用法及操作注意事项,需要的朋友可以参考下
详解Python设计模式之策略模式
12-17
虽然设计模式与语言无关，但这并不意味着每一个模式都能在每一门语言中使用。《设计模式：可复用面向对象软件的基础》一书中有 23 个模式，其中有 16 个在动态语言中“不见了，或者简化了”。 1、策略模式概述 策略...
QT设计模式：外观模式
最新发布
buhuiCyvyan的博客
05-07 111
外观模式（Facade Pattern）是一种设计模式，它提供了一个统一的接口，用于访问子系统中的一群接口，从而简化了客户端与子系统之间的交互，这种方式隐藏了子系统的复杂性，使客户端更容易使用子系统。
设计模式：桥接模式
玉汝于成
05-06 777
接模式是一种对象结构型模式，它将抽象部分与它的实现部分分离，使它们都可以独立地变化。这种分离允许抽象和实现部分独立地扩展，而不会相互影响。桥接模式基于类的最小设计原则，通过封装、聚合及继承等行为让不同的类承担不同的职责。
【学习vue 3.x】(一)基础内容
m0_74187147的博客
04-30 1686
Vue.js是一套构建用户界面的渐进式框架，采用自底向上增量开发的设计，核心库只关注视图层。另一方面，Vue完全有能力驱动采用单文件组件和Vue生态系统支持的库开发的复杂单页应用。 Vue是一个框架，也是一个生态。可以用不同的方式使用Vue： 无需构建步骤，渐进式增强静态的HTML； 在任何页面中作为Web Components嵌入； 单页应用 (SPA)； 全栈/服务端渲染 (SSR)； Jamstack/静态站点生成 (SSG)； 开发桌面端、移动端、WebGL，甚至是命令行终端中的界面。
设计模式: 工厂模式
m0_59925573的博客
05-02 652
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。主要解决接口选择的问题。我们明确地计划不同条件下创建不同实例时。让其子类实现工厂接口，返回的也是一个抽象的产品。创建过程在其子类执行。1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。2、在 Hibernate 中，如果需要更换数据库，工厂模式同样发挥了作用。只需简单地更改方言（Dialect）和数据库驱动（Driver），就能够实现对不同数据库的切换。
Python如何实现抽象工厂模式
一点
04-30 1244
在软件工程中，抽象工厂模式（Abstract Factory Pattern）是一种设计模式，用于在运行时创建一组相关或相互依赖的对象，而不需要指定它们的具体类。这种模式非常适合用于管理系统中对象的创建，同时保持这些对象之间的一致性和隔离性。抽象工厂模式涉及以下几个关键概念：抽象工厂（Abstract Factory）：提供一个创建一系列相关或依赖对象的接口，而不需要指定具体类。具体工厂（Concrete Factory）：实现抽象工厂接口，生产具体的产品对象。
设计模式精解-gof 23 种设计模式解析附 c++实现源码
07-01
它不仅提供了23种设计模式的名字和简介，还详细解释了每种模式的适用场景和应用案例。读者可以通过学习这些设计模式，了解如何将它们应用于自己的软件开发工作中，提高代码的可重用性和可维护性。 书中的C语言实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值