本文摘自网络，作者，侵删。
手撸golang 结构型设计模式 享元模式
缘起
最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
本系列笔记拟采用golang练习之
享元模式
享元模式（Flyweight Pattern）又叫作轻量级模式，是对象池的一种实现。享元模式提供了减少对象数量从而改善应用所需的对象结构的方式。其宗旨是共享细粒度对象，不必为每个访问者都创建一个单独的对象，以此来降低内存的消耗，属于结构型设计模式。
_
场景
- 某火车票查询系统, 可根据发站和到站, 查询余票信息
- 火车票包含基本信息(发站, 到站, 经停站, 出发时间, 到站时间...)和剩余票数信息
- 基本信息字段较多, 且只跟发站和到站相关, 因此可采用享元模式进行池化处理
- 剩余票数信息由于实时变化, 因此由余票服务另外提供
设计
- ITicket: 定义车票基本信息接口
- ITicketRemaining: 继承ITicket, 并添加余票数信息
- ITicketService: 定义车票信息服务接口
- ITicketRemainingService: 定义余票信息服务接口. 根据发站和到站, 查询余票信息.
- tMockTicket: 车票信息实体, 实现ITicket接口
- tMockTicketService: 车票信息服务, 通过享元模式池化了车票信息.
- tMockTicketRemaining: 余票信息实体, 实现ITicketRemaining接口
- tMockTicketRemainingService: 余票信息服务, 通过ITicketService获取车票基本信息. 根据发站和到站, 查询余票信息.
单元测试
flyweight_pattern_test.go
package structural_patterns
import (
"learning/gooop/structural_patterns/flyweight"
"testing"
)
func Test_FlyweightPattern(t *testing.T) {
from := "福田"
to := "广州南"
ticket := flyweight.NewMockTicket(1, from, to, 100)
flyweight.MockTicketService.Save(ticket)
flyweight.MockTicketRemainingService.Save(ticket.ID(), 10)
remaining := flyweight.MockTicketRemainingService.Get(from, to)
t.Logf("from=%s, to=%s, price=%v, remaining=%v\n", remaining.From(), remaining.To(), remaining.Price(), remaining.Remaining())
}
测试输出
t$ go test -v flyweight_pattern_test.go
=== RUN Test_FlyweightPattern
flyweight_pattern_test.go:16: from=福田, to=广州南, price=100, remaining=10
--- PASS: Test_FlyweightPattern (0.00s)
PASS
ok command-line-arguments 0.003sITicket.go
定义车票基本信息接口
package flyweight
// 车票信息
type ITicket interface {
ID() int
From() string
To() string
LeavingTime() string
ArrivalTime() string
InterList() []string
Price() float64
}
ITicketRemaining.go
继承ITicket, 并添加余票数信息
package flyweight
// 余票信息
type ITicketRemaining interface {
ITicket
Remaining() int
}ITicketService.go
定义车票信息服务接口
package flyweight
type ITicketService interface {
Get(from string, to string) ITicket
Save(it ITicket)
}ITicketRemainingService.go
定义余票信息服务接口, 根据发站和到站, 查询余票信息.
package flyweight
type ITicketRemainingService interface {
Get(from string, to string) ITicketRemaining
Save(id int, num int)
}**
tMockTicket.go
车票信息实体, 实现ITicket接口
package flyweight
import "strings"
type tMockTicket struct {
iID int
sFrom string
sTo string
sLeavingTime string
sArrivalTime string
mInterList []string
fPrice float64
iRemaining int
}
func NewMockTicket(id int, from string, to string, price float64) *tMockTicket {
return &tMockTicket{
iID: id,
sFrom: from,
sTo: to,
sLeavingTime: "09:00",
sArrivalTime: "11:30",
mInterList: strings.Split("深圳北,虎门", ","),
fPrice: price,
}
}
func (me *tMockTicket) ID() int {
return me.iID
}
func (me *tMockTicket) From() string {
return me.sFrom
}
func (me *tMockTicket) To() string {
return me.sTo
}
func (me *tMockTicket) LeavingTime() string {
return me.sLeavingTime
}
func (me *tMockTicket) ArrivalTime() string {
return me.sArrivalTime
}
func (me *tMockTicket) InterList() []string {
return me.mInterList
}
func (me *tMockTicket) Price() float64 {
return me.fPrice
}tMockTicketService.go
车票信息服务, 实现ITicketService接口, 通过享元模式池化了车票信息.
package flyweight
import "sync"
type tMockTicketService struct {
mTickets map[string]ITicket
mRWMutex *sync.RWMutex
}
func newMockTicketService() *tMockTicketService {
return &tMockTicketService{
make(map[string]ITicket, 0),
new(sync.RWMutex),
}
}
func (me *tMockTicketService) Get(from string, to string) ITicket {
k := from + "-" + to
me.mRWMutex.RLock()
defer me.mRWMutex.RUnlock()
it,ok := me.mTickets[k]
if ok {
return it
} else {
return nil
}
}
func (me *tMockTicketService) Save(it ITicket) {
k := it.From() + "-" + it.To()
me.mRWMutex.Lock()
defer me.mRWMutex.Unlock()
me.mTickets[k] = it
}
var MockTicketService ITicketService = newMockTicketService()tMockTicketRemaining.go
余票信息实体, 实现ITicketRemaining接口
package flyweight
type tMockTicketRemaining struct {
ITicket
iRemaining int
}
func newMockTicketRemaining(it ITicket, num int) *tMockTicketRemaining {
return &tMockTicketRemaining{
it, num,
}
}
func (me *tMockTicketRemaining) Remaining() int {
return me.iRemaining
}tMockTicketRemainingService.go
余票信息服务, 实现ITicketRemainingService接口. 通过ITicketService获取车票基本信息. 根据发站和到站, 查询余票信息.
package flyweight
import "sync"
type tMockTicketRemainingService struct {
mRemaining map[int]int
mRWMutex *sync.RWMutex
}
func newMockTicketRemainingService() *tMockTicketRemainingService {
return &tMockTicketRemainingService{
make(map[int]int, 16),
new(sync.RWMutex),
}
}
func (me *tMockTicketRemainingService) Get(from string, to string) ITicketRemaining {
ticket := MockTicketService.Get(from, to)
if ticket == nil {
return nil
}
r := newMockTicketRemaining(ticket, 0)
me.mRWMutex.RLock()
defer me.mRWMutex.RUnlock()
num,ok := me.mRemaining[ticket.ID()]
if ok {
r.iRemaining = num
}
return r
}
func (me *tMockTicketRemainingService) Save(id int, num int) {
me.mRWMutex.Lock()
defer me.mRWMutex.Unlock()
me.mRemaining[id] = num
}
var MockTicketRemainingService ITicketRemainingService = newMockTicketRemainingService()享元模式小结
享元模式是对象池的一种应用.
享元模式的优点
（1）减少对象的创建，降低内存中对象的数量，降低系统的内存，提高效率。
（2）减少内存之外的其他资源占用。
享元模式的缺点
（1）关注内、外部状态，关注线程安全问题。
（2）使系统、程序的逻辑复杂化。
_
(end)
本文来自：Segmentfault
感谢作者：.container .card .information strong
查看原文：手撸golang 结构型设计模式 享元模式
相关阅读 >>
[系列] Go - 学习 grpc.dial(target string, opts …dialoption) 的写法
更多相关阅读请进入《Go》频道 >>
Go语言101
一个与时俱进的Go编程知识库。
