系列文章目录
例如：第一章 设计模式案例
前言
上一篇文章介绍了常用的几种设计模式和常用场景，便于对设计模式加深理解，此文章主要讲解设计模式的案例。
一、适配器模式
case 包
代码如下（示例）：
package _case import "fmt" func AdapterCase() { var cache StdCache redis := &Redis{data: map[string]string{}} cache = &RedisAdapter{redis: redis} cache.Set("key1", "value1") cache.Set("key2", "value2") cache.Set("key3", "value3") fmt.Println(cache.Get("key1")) fmt.Println(cache.Get("key2")) fmt.Println(cache.Get("key3")) mem := &MemCache{data: map[string]interface{}{}} cache = &MemCacheAdapter{mem: mem} cache.Set("k1", "v1") cache.Set("k2", "v2") cache.Set("k3", "v3") fmt.Println(cache.Get("k1")) fmt.Println(cache.Get("k2")) fmt.Println(cache.Get("k3")) } type Redis struct { data map[string]string } func (r *Redis) GetStr(key string) string { return r.data[key] } func (r *Redis) SetStr(key, value string) { r.data[key] = value } type MemCache struct { data map[string]interface{} } func (m *MemCache) GetItem(key string) interface{} { return m.data[key] } func (m *MemCache) SetItem(key string, value interface{}) { m.data[key] = value } // 定义标准缓存 type StdCache interface { Get(key string) string Set(key, value string) } // 定义Redis适配器 type RedisAdapter struct { redis *Redis } func (adapter *RedisAdapter) Get(key string) string { return adapter.redis.GetStr(key) } func (adapter *RedisAdapter) Set(key, value string) { adapter.redis.SetStr(key, value) } // 定义MemCache适配器 type MemCacheAdapter struct { mem *MemCache } func (adapter *MemCacheAdapter) Get(key string) string { return adapter.mem.GetItem(key).(string) } func (adapter *MemCacheAdapter) Set(key, value string) { adapter.mem.SetItem(key, value) }
代码如下（示例）：main
package main import _case "adapter/case" func main() { _case.AdapterCase() }
二、观察者模式
case 包
代码如下（示例）：case 包
package _case import ( "fmt" ) func ObserverCase() { var ob Observer = &WatchConf{} var ob1 Observer = &WatchConf{} var ob2 Observer = &WatchConf{} var ob3 Observer = &WatchConf{} var pb Publisher = &Config{data: map[string]string{"host": "localhost", "port": "5051"}} //订阅 pb.Subscribe(ob) pb.Subscribe(ob1) pb.Subscribe(ob2) pb.Subscribe(ob3) fmt.Println(pb) pb.UnSubscribe(ob1) fmt.Println(pb) conf := pb.(*Config) // 断言 判断pb 类型 conf.data = map[string]string{"host": "127.0.0.1", "port": "9998"} pb.NotityObserver(conf.data) fmt.Println(pb) } // 定义观察者接口 type Observer interface { Update(data interface{}) } // 定义发布者 type Publisher interface { //关注 Subscribe(observer Observer) //取关 UnSubscribe(observer Observer) //通知 NotityObserver(data interface{}) } // 定义具体发布者 type Config struct { data map[string]string Observers []Observer } // 关注 func (c *Config) Subscribe(o Observer) { c.Observers = append(c.Observers, o) } // 取关 func (c *Config) UnSubscribe(o Observer) { for i, v := range c.Observers { if v == o { c.Observers = append(c.Observers[:i], c.Observers[i+1:]...) break } } } // 通知观察者 func (c *Config) NotityObserver(data interface{}) { for _, ob := range c.Observers { ob.Update(data) } } type WatchConf struct { } func (*WatchConf) Update(data interface{}) { fmt.Println("受到配置更新消息，更新配置为：", data) }
代码如下（示例）：main
package main import _case "observer/case" func main() { _case.ObserverCase() }
三、代理模式
case 包
代码如下（示例）：case 包
package _case import "fmt" func ProxyCase() { var cache Icache cache = &Cache{data: map[string]interface{}{}} proxy := NewProxy(cache) proxy.Set("key1", "value1") proxy.Set("key2", "value2") proxy.Set("key3", "value3") proxy.Set("key4", "value4") fmt.Println(proxy.Get("key1")) fmt.Println(proxy.Get("key2")) fmt.Println(proxy.Get("key3")) fmt.Println(proxy.Get("key4")) } type Icache interface { Get(key string) interface{} Set(key string, value interface{}) } // 被代理对象（真实对象） type Cache struct { data map[string]interface{} } func (c *Cache) Get(key string) interface{} { return c.data[key] } func (c *Cache) Set(key string, value interface{}) { c.data[key] = value } // 代理对象 type Proxy struct { cache Icache } func NewProxy(cache Icache) *Proxy { return &Proxy{ cache: cache, } } func (p *Proxy) Get(key string) interface{} { // 此处可以增加访问控制逻辑等扩展功能 return p.cache.Get(key) } func (p *Proxy) Set(key string, value interface{}) { // 此处可以增加访问控制逻辑等扩展功能 p.cache.Set(key, value) }
代码如下（示例）：main
package main import _case "design-pattern/proxy/case" func main() { _case.ProxyCase() }
总结
提示：这里对文章进行总结：
以上就是今天要讲的内容，本文暂时讲解了部分设计模式案例，后期会在此处持续更新
