缘起

最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
本系列笔记拟采用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)