设计模式案例(一)

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)
}

package main
import _case "adapter/case"
func main() {
  _case.AdapterCase()
}

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)
}

package main
import _case "observer/case"
func main() {
  _case.ObserverCase()
}

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)
}

package main
import _case "design-pattern/proxy/case"
func main() {
  _case.ProxyCase()
}