使用Golang实现装饰器模式扩展文章生成功能

装饰器模式是一种结构型设计模式，它允许在不修改原有对象结构的情况下动态地扩展其功能。在Golang中，我们可以利用函数一等公民的特性，通过函数包装来实现装饰器模式。

装饰器模式基础实现

首先，我们定义一个基础的生成器接口：

go type ArticleGenerator interface { Generate(title, keywords, description string) (string, error) }

然后实现一个基础的生成器：

go
type BasicGenerator struct{}

func (g *BasicGenerator) Generate(title, keywords, description string) (string, error) {
// 基础生成逻辑
return fmt.Sprintf("标题: %s\n关键词: %s\n描述: %s\n正文: 这是一篇基础生成的文章...",
title, keywords, description), nil
}

实现装饰器

1. 连贯性装饰器

go
type CoherenceDecorator struct {
generator ArticleGenerator
}

func NewCoherenceDecorator(generator ArticleGenerator) *CoherenceDecorator {
return &CoherenceDecorator{generator: generator}
}

func (d *CoherenceDecorator) Generate(title, keywords, description string) (string, error) {
content, err := d.generator.Generate(title, keywords, description)
if err != nil {
return "", err
}

// 添加段落过渡和连贯性处理
parts := strings.Split(content, "\n")
if len(parts) > 3 {
    body := parts[3]
    // 添加过渡句
    body = strings.Replace(body, "。", "。不仅如此，", -1)
    body = strings.Replace(body, "，", "，而且", -1)
    parts[3] = body
}

return strings.Join(parts, "\n"), nil

}

2. 自然语言装饰器

go
type NaturalLanguageDecorator struct {
generator ArticleGenerator
}

func NewNaturalLanguageDecorator(generator ArticleGenerator) *NaturalLanguageDecorator {
return &NaturalLanguageDecorator{generator: generator}
}

func (d *NaturalLanguageDecorator) Generate(title, keywords, description string) (string, error) {
content, err := d.generator.Generate(title, keywords, description)
if err != nil {
return "", err
}

// 去除AI常见表达
aiPhrases := []string{"综上所述", "总而言之", "需要注意的是", "从本质上讲"}
for _, phrase := range aiPhrases {
    content = strings.ReplaceAll(content, phrase, "")
}

// 添加人性化表达
humanPhrases := []string{"我们不难发现", "在实际生活中", "根据我的经验", "有人可能会问"}
for _, phrase := range humanPhrases {
    if strings.Contains(content, "。") {
        sentences := strings.Split(content, "。")
        if len(sentences) > 1 {
            sentences[0] = sentences[0] + "。" + phrase
            content = strings.Join(sentences, "。")
        }
    }
}

return content, nil

}

3. 深度内容装饰器

go
type DepthDecorator struct {
generator ArticleGenerator
}

func NewDepthDecorator(generator ArticleGenerator) *DepthDecorator {
return &DepthDecorator{generator: generator}
}

func (d *DepthDecorator) Generate(title, keywords, description string) (string, error) {
content, err := d.generator.Generate(title, keywords, description)
if err != nil {
return "", err
}

// 确保内容长度达到1000字左右
parts := strings.Split(content, "\n")
if len(parts) > 3 {
    body := parts[3]
    if len([]rune(body)) < 800 {
        // 扩展内容深度
        expanded := expandContentDepth(body, keywords)
        parts[3] = expanded
    }
    content = strings.Join(parts, "\n")
}

return content, nil

}

func expandContentDepth(body string, keywords string) string {
// 实际应用中这里会有更复杂的逻辑
keywordList := strings.Split(keywords, ",")
for _, kw := range keywordList {
if len(kw) > 0 {
body += fmt.Sprintf("\n\n关于%s，我们可以从多个角度进行分析。首先，从历史发展的角度来看...", strings.TrimSpace(kw))
body += fmt.Sprintf("\n其次，在当今社会背景下，%s的影响也不容忽视...", strings.TrimSpace(kw))
}
}
return body
}

组合使用装饰器

go
func main() {
// 创建基础生成器
base := &BasicGenerator{}

// 装饰器链
generator := NewDepthDecorator(
    NewNaturalLanguageDecorator(
        NewCoherenceDecorator(base),
    ),
)

title := "Golang装饰器模式实践"
keywords := "Golang,设计模式,装饰器"
description := "本文详细介绍了如何在Golang中实现装饰器模式来扩展文章生成功能"

content, err := generator.Generate(title, keywords, description)
if err != nil {
    fmt.Println("生成文章出错:", err)
    return
}

fmt.Println(content)

}

函数式装饰器实现

Golang的函数特性允许我们以更简洁的方式实现装饰器：

go
type GeneratorFunc func(title, keywords, description string) (string, error)

func CoherenceDecoratorFunc(f GeneratorFunc) GeneratorFunc {
return func(title, keywords, description string) (string, error) {
content, err := f(title, keywords, description)
if err != nil {
return "", err
}

    // 连贯性处理逻辑
    return addTransitions(content), nil
}

}

func NaturalLanguageDecoratorFunc(f GeneratorFunc) GeneratorFunc {
return func(title, keywords, description string) (string, error) {
content, err := f(title, keywords, description)
if err != nil {
return "", err
}

    // 自然语言处理逻辑
    return humanizeContent(content), nil
}

}

// 使用函数式装饰器
func main() {
baseFunc := func(title, keywords, description string) (string, error) {
return fmt.Sprintf("标题: %s\n关键词: %s\n描述: %s\n正文: 基础内容...",
title, keywords, description), nil
}

decorated := NaturalLanguageDecoratorFunc(
    CoherenceDecoratorFunc(baseFunc),
)

content, _ := decorated("标题", "关键词", "描述")
fmt.Println(content)

}

装饰器模式的优势

1. 灵活性：可以动态地添加或修改功能，而不需要修改原有代码
2. 可组合性：多个装饰器可以组合使用，按需构建功能
3. 单一职责：每个装饰器只关注一个特定的功能增强
4. 开闭原则：对扩展开放，对修改关闭