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


本文摘自网络,作者,侵删。

手撸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] Info {
  "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.Info(me.toJson(msg, "INFO"))
}

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

func (me *tJsonLogger) Error(msg string) {
    me.mLogger.Error(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)


本文来自:Segmentfault

感谢作者:.container .card .information strong

查看原文:手撸golang 结构型设计模式 装饰器模式

相关阅读 >>

手撸Golang 基本数据结构与算法 数组

Golang cap是什么意思

leetcode354 俄罗斯套娃信封问题 Golang

19 Golang包以及Go mod

手撸Golang 行为型设计模式 责任链模式

Go中sync.cond源码解读

Go-slice

Go函数用法实战

Golang 能开发前端吗?

Golang中sort包如何实现

更多相关阅读请进入《Go》频道 >>




打赏

取消

感谢您的支持,我会继续努力的!

扫码支持
扫码打赏,您说多少就多少

打开支付宝扫一扫,即可进行扫码打赏哦

分享从这里开始,精彩与您同在

评论

管理员已关闭评论功能...