手撸 golang 结构型设计模式 装璜器模式

缘起

最近温习设计模式
拜读谭勇德的 << 设计模式就该这样学 >>
本系列笔记拟采纳 golang 练习之

装璜器模式

装璜器模式（Decorator Pattern）也叫作包装器模式（Wrapper Pattern），指在不扭转原有对象的根底上，动静地给一个对象增加一些额定的职责。就减少性能来说，装璜器模式相比生成子类更为灵便，属于结构型设计模式。
_

装璜器模式 vs 代理模式

• 装璜器模式就是代理模式的一个非凡利用。
• 装璜器模式强调本身性能的扩大。
• 代理模式强调对代理过程的管制。

_

场景

• 某业务零碎, 输入日志信息到文件
• 现要求集成第三方日志剖析服务
• 日志服务须要 json 格局的日志流
• 因而须要革新原日志输入的实现, 实现 json 格局输入性能

设计

• ILogger: 定义日志器接口
• ILoggerFactory: 定义日志器工厂
• tConsoleLogger: 默认的日志器实现, 应用 console 输入日志音讯
• tConsoleLoggerFactory: 默认的日志器工厂
• tJsonLogger: 应用 json 格局输入日志音讯的日志器. 应用装璜器模式, 减少了将日志音讯格式化为 json 的性能.
• tJsonLoggerFactory: json 日志器的工厂

单元测试 – decorator_pattern_test.go

通过切换日志工厂, 测试日志输入的不同成果

package structural_patterns

import (
    "learning/gooop/structural_patterns/decorator"
    "testing"
)

func Test_DecoratorPattern(t *testing.T) {fnTestLogger := func(factory decorator.ILoggerFactory) {logger := factory.GetLogger("testing.Test_DecoratorPattern")
        logger.Debug("This is a DEBUG msg")
        logger.Info("This is an INFO msg")
    }

    fnTestLogger(decorator.ConsoleLoggerFactory)
    fnTestLogger(decorator.JsonLoggerFactory)
}

测试输入

$ go test -v decorator_pattern_test.go 
=== RUN   Test_DecoratorPattern
2021-02-02T15:50:10 [testing.Test_DecoratorPattern] DEBUG This is a DEBUG msg
2021-02-02T15:50:10 [testing.Test_DecoratorPattern] INFO This is an INFO msg
2021-02-02T15:50:10 [testing.Test_DecoratorPattern] DEBUG {
  "Time": "2021-02-02T15:50:10",
  "Level": "DEBUG",
  "Msg": "This is a DEBUG msg"
}
2021-02-02T15:50:10 [testing.Test_DecoratorPattern] DEBUG {
  "Time": "2021-02-02T15:50:10",
  "Level": "INFO",
  "Msg": "This is an INFO msg"
}
--- PASS: Test_DecoratorPattern (0.00s)
PASS
ok      command-line-arguments  0.002s

ILogger.go

定义日志器接口

package decorator

type ILogger interface {Debug(msg string)
    Info(msg string)
    Warn(msg string)
    Error(msg string)
}

ILoggerFactory.go

定义日志器工厂

package decorator

type ILoggerFactory interface {GetLogger(name string) ILogger
}

tConsoleLogger.go

默认的日志器实现, 应用 console 输入日志音讯

package decorator

import (
    "fmt"
    "time"
)

type tConsoleLogger struct {name string}


func nowString() string {return time.Now().Format("2006-01-02T15:04:05")
}

func (me *tConsoleLogger) log(msg string, level string) {fmt.Printf("%s [%s] %s %s\n", nowString(), me.name, level, msg)
}

func (me *tConsoleLogger) Debug(msg string) {me.log(msg, "DEBUG")
}

func (me *tConsoleLogger) Info(msg string) {me.log(msg, "INFO")
}


func (me *tConsoleLogger) Warn(msg string) {me.log(msg, "WARN")
}


func (me *tConsoleLogger) Error(msg string) {me.log(msg, "ERROR")
}

tConsoleLoggerFactory.go

默认的日志器工厂

package decorator

type tConsoleLoggerFactory struct {
}

func newConsoleLoggerFactory() ILoggerFactory {return &tConsoleLoggerFactory{}
}

func (me *tConsoleLoggerFactory) GetLogger(name string) ILogger {
    return &tConsoleLogger{name,}
}

var ConsoleLoggerFactory = newConsoleLoggerFactory()

tJsonLogger.go

应用 json 格局输入日志音讯的日志器. 应用装璜器模式, 减少了将日志音讯格式化为 json 的性能.

package decorator

import ("encoding/json")

type tJsonLogger struct {
    sName string
    mLogger ILogger
}


type tJsonMsg struct {
    Time string
    Level string
    Msg string
}

func (me *tJsonMsg) String() string {j, e := json.MarshalIndent(me, "","  ")
    if e != nil {return ""}
    return string(j)
}

func newJsonLogger(name string, logger ILogger) ILogger {
    return &tJsonLogger{
        name,
        logger,
    }
}

func (me *tJsonLogger) toJson(msg string, level string) string {
    j := &tJsonMsg{Time: nowString(),
        Level: level,
        Msg: msg,
    }
    return j.String()}

func (me *tJsonLogger) Debug(msg string) {me.mLogger.Debug(me.toJson(msg, "DEBUG"))
}

func (me *tJsonLogger) Info(msg string) {me.mLogger.Debug(me.toJson(msg, "INFO"))
}

func (me *tJsonLogger) Warn(msg string) {me.mLogger.Debug(me.toJson(msg, "WARN"))
}

func (me *tJsonLogger) Error(msg string) {me.mLogger.Debug(me.toJson(msg, "ERROR"))
}

tJsonLoggerFactory.go

json 日志器的工厂

package decorator

type tJsonLoggerFactory struct {
}

func newJsonLoggerFactory() ILoggerFactory {return &tJsonLoggerFactory{}
}

func (me *tJsonLoggerFactory) GetLogger(name string) ILogger {logger := ConsoleLoggerFactory.GetLogger(name)
    return newJsonLogger(name, logger)
}

var JsonLoggerFactory = newJsonLoggerFactory()

装璜器模式小结

装璜器模式的长处
（1）装璜器是继承的无力补充，比继承灵便，在不扭转原有对象的状况下，动静地给一个对象扩大性能，即插即用。
（2）通过应用不同装璜类及这些装璜类的排列组合，能够实现不同成果。
（3）装璜器模式齐全恪守开闭准则。
装璜器模式的毛病
（1）会呈现更多的代码、更多的类，减少程序的复杂性。
（2）动静装璜在多层装璜时会更简单。
_

(end)