外观模式为子系统中的功能接口提供一个一致的界面,此模式定义了一个高层接口,这个接口使得这些子系统更加容易使用。
把电脑拥有的CPU、RAM内存和硬盘视为子系统,调用方想启动电脑要启动这三个子系统,所以在子系统上增加一个外观对象,让调用方直接调用外观对象,由外观对象再分别对接子系统最终完成电脑的启动。
package main
import (
"fmt"
)
const (
BOOT_ADDRESS = 0
BOOT_SECTOR = 0
SECTOR_SIZE = 0
)
type CPU struct{}
func (c *CPU) Freeze() {
fmt.Println("CPU.Freeze()")
}
func (c *CPU) Jump(position int) {
fmt.Println("CPU.Jump()")
}
func (c *CPU) Execute() {
fmt.Println("CPU.Execute()")
}
type Memory struct{}
func (m *Memory) Load(position int, data []byte) {
fmt.Println("Memory.Load()")
}
type HardDrive struct{}
func (hd *HardDrive) Read(lba int, size int) []byte {
fmt.Println("HardDrive.Read()")
return make([]byte, 0)
}
type ComputerFacade struct {
processor *CPU
ram *Memory
hd *HardDrive
}
func NewComputerFacade() *ComputerFacade {
return &ComputerFacade{new(CPU), new(Memory), new(HardDrive)}
}
func (c *ComputerFacade) start() {
c.processor.Freeze()
c.ram.Load(BOOT_ADDRESS, c.hd.Read(BOOT_SECTOR, SECTOR_SIZE))
c.processor.Jump(BOOT_ADDRESS)
c.processor.Execute()
}
func main() {
computer := NewComputerFacade()
computer.start()
}
外观模式的优点
- 简化了调用过程,不用深入了解子系统,以防给子系统带来风险。
- 减少系统依赖,松散耦合。
- 更好地划分访问层次,提高了安全性。
- 遵循迪米特法则
外观模式的缺点
- 当增加子系统和扩展子系统行为时,需要对外观进行重复更改,不符合开闭原则,可能容易带来未知风险。
建造型设计模式—享元模式
享元可以理解为可复用的对象,即可以是对象级别的复用,也可以是对象的字段进行复用(把可复用的字段单独提炼成一个更精细的对象)。节省内存的前提是享元对象是不可变对象,不可变对象指的是初始化之后,对象的状态不会改变了,也就是不会存在被修改的情况。
享元模式的实现思路是,在享元对象的工厂类中,通过一个 Map 来缓存已经创建的享元对象,达到复用的目的。
设计一个多人在线棋牌游戏的平台。如果在平台中每创建一个牌局就需要初始化对应的卡牌,这样显然很浪费,因为一套扑克牌里的卡牌是固定的,不管多少个牌局使用的扑克牌都是一样的,扑克牌在这里就相当于不可变对象,创建后即不可改变。
设计一个 pokerCards
存储多个享元扑克牌对象:
var pokerCards = map[int]*Card{
1: {
Name: "A",
Color: "紅",
},
2: {
Name: "A",
Color: "黑",
},
// 其他卡牌
}
type Card struct {
Name string
Color string
}
每个牌局创建时程序会设定牌局里的卡牌都引用自pokerCards
中的享元
type PokerGame struct {
Cards map[int]*Card
}
func NewPokerGame() *PokerGame {
board := &PokerGame{Cards: map[int]*Card{}}
for id := range pokerCards {
board.Cards[id] = pokerCards[id]
}
return board
}
具体牌局的规则是什么该怎么打,这些业务逻辑以及牌局的进行状态等这些外部状态都由PokerGame
类型来实现,示例代码这里不再过多着墨说明。这里的重点是享元始终是不可改变的,这样才能保证享元在系统中只有一份,起到节省内存的作用。
func main() {
game1 := NewPokerGame()
game2 := NewPokerGame()
fmt.Println(game1.Cards[1] == game2.Cards[1])
}
运行程序可以验证,两个牌局都引用了享元,系统中不存在相同享元对象的多次创建。
享元模式的结构中有一下几个角色:
- Context:上下文或者叫做情景类,包含原始对象中各不相同的外在状态。 情景与享元对象组合在一起就能表示原始对象的全部状态。调用享元方法的参数由情景类提供,也可将行为移动到情景类中, 然后将连入的享元作为单纯的数据对象。
- Flyweight:享元类,包含原始对象中部分能在多个对象中共享的状态。 同一享元对象可在许多不同情景中使用。 享元中存储的状态被称为 “内在状态”。 传递给享元方法的状态被称为 “外在状态”。
- FlyweightFactory:享元工厂,会对已有享元的缓存池进行管理。 有了工厂后, 客户端就无需直接创建享元, 它们只需调用工厂并向其传递目标享元的一些内在状态即可。 工厂会根据参数在之前已创建的享元中进行查找, 如果找到满足条件的享元就将其返回; 如果没有找到就根据参数新建享元。
享元模式其实是对象池的一种应用,在应用该模式之前, 我们需要确定程序中确实存在着大量拥有相同状态(字段)的相似对象同时占用内存的问题。
享元模式的优点是能减少对象的创建,降低内存中对象的数量,降低系统的内存,提高效率。其缺点是 我们在写程序时需要关注内、外部状态,关注线程安全问题,使系统、程序的逻辑复杂化。
参考公众号网管叨bi叨