手撸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.003s

ITicket.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 结构型设计模式 享元模式

• 编辑
• 预览