Golang模板中的装饰器模式实现

在Go语言中，使用HTML模板实现装饰器模式可以通过模板组合和嵌套执行来实现。以下是基于你的代码示例的改进实现：

package main

import (
    "encoding/json"
    "html/template"
    "io"
    "os"
    "strings"
)

type FormFieldDescription struct {
    Name        string `json:"name"`
    Description string `json:"description"`
    Type        string `json:"type"`
    Required    bool   `json:"req"`
    Placeholder string `json:"placeholder,omitempty"`
    Value       string `json:"value,omitempty"`
}

type FormData struct {
    Action string
    Method string
    Fields []FormFieldDescription
}

const (
    inputTemplate = `{{define "field.input"}}
<label for="{{.Name}}">{{if .Required}}*{{end}}{{.Description}}</label>
<input type="text" name="{{.Name}}" id="{{.Name}}" value="{{.Value}}" placeholder="{{.Placeholder}}" />
{{end}}`

    textareaTemplate = `{{define "field.textarea"}}
<label for="{{.Name}}">{{if .Required}}*{{end}}{{.Description}}</label>
<textarea name="{{.Name}}" id="{{.Name}}" placeholder="{{.Placeholder}}">{{.Value}}</textarea>
{{end}}`

    divDecorator = `{{define "decorator.div"}}
<div class="decorator{{if .Required}} required{{end}}">
{{.Content}}
</div>
{{end}}`

    formTemplate = `{{define "form"}}
<form action="{{.Action}}" method="{{.Method}}">
{{range .Fields}}{{.}}{{end}}
</form>
{{end}}`
)

// 装饰器执行函数
type DecoratorFunc func(io.Writer, interface{}) error

func main() {
    fields := []FormFieldDescription{
        {
            Name:        "firstname",
            Description: "First name",
            Placeholder: "Enter your first name",
            Type:        "input",
            Required:    true,
            Value:       "John",
        },
        {
            Name:        "lastname",
            Description: "Last name",
            Placeholder: "Enter your last name",
            Type:        "input",
            Required:    true,
            Value:       "Doe",
        },
        {
            Name:        "age",
            Description: "Age",
            Placeholder: "Enter your age",
            Type:        "input",
            Required:    true,
            Value:       "27",
        },
        {
            Name:        "descr",
            Description: "Description",
            Placeholder: "Enter description",
            Type:        "textarea",
            Required:    false,
            Value:       "",
        },
    }

    jsonb, _ := json.MarshalIndent(&fields, "", "  ")
    fmt.Printf("Generating from:\n%v\n\n", string(jsonb))

    // 创建模板并解析所有定义
    tpl := template.New("html")
    tpl.Parse(inputTemplate)
    tpl.Parse(textareaTemplate)
    tpl.Parse(divDecorator)
    tpl.Parse(formTemplate)

    // 定义装饰器链
    decoratorChain := []string{"field", "decorator.div"}

    fmt.Println("Into HTML:")

    // 处理每个字段
    var processedFields []string
    for _, field := range fields {
        var output strings.Builder
        
        // 执行基础字段模板
        fieldType := field.Type
        if fieldType == "input" {
            fieldType = "input"
        }
        tpl.ExecuteTemplate(&output, "field."+fieldType, field)
        
        // 应用装饰器链
        fieldContent := output.String()
        for _, decorator := range decoratorChain {
            if decorator == "field" {
                continue // 已经执行过基础字段模板
            }
            
            var decoratedOutput strings.Builder
            data := struct {
                Content  string
                Required bool
            }{
                Content:  fieldContent,
                Required: field.Required,
            }
            tpl.ExecuteTemplate(&decoratedOutput, decorator, data)
            fieldContent = decoratedOutput.String()
        }
        
        processedFields = append(processedFields, fieldContent)
    }

    // 应用表单装饰器
    formData := FormData{
        Action: "foo",
        Method: "post",
        Fields: processedFields,
    }
    
    tpl.ExecuteTemplate(os.Stdout, "form", formData)
}

更灵活的装饰器管道实现：

package main

import (
    "bytes"
    "html/template"
    "io"
)

// 装饰器类型
type Decorator struct {
    Name string
    Template *template.Template
}

// 执行装饰器链
func applyDecorators(w io.Writer, data interface{}, decorators []Decorator) error {
    var content bytes.Buffer
    
    // 执行基础模板
    if err := decorators[0].Template.Execute(&content, data); err != nil {
        return err
    }
    
    // 应用装饰器链
    currentContent := content.String()
    for i := 1; i < len(decorators); i++ {
        var decoratedContent bytes.Buffer
        decoratorData := struct {
            Content interface{}
        }{
            Content: template.HTML(currentContent),
        }
        
        if err := decorators[i].Template.Execute(&decoratedContent, decoratorData); err != nil {
            return err
        }
        currentContent = decoratedContent.String()
    }
    
    _, err := w.Write([]byte(currentContent))
    return err
}

// 使用示例
func main() {
    // 创建装饰器模板
    fieldTemplates := `
{{define "input"}}
<label for="{{.Name}}">{{if .Required}}*{{end}}{{.Description}}</label>
<input type="text" name="{{.Name}}" id="{{.Name}}" value="{{.Value}}" placeholder="{{.Placeholder}}" />
{{end}}

{{define "textarea"}}
<label for="{{.Name}}">{{if .Required}}*{{end}}{{.Description}}</label>
<textarea name="{{.Name}}" id="{{.Name}}" placeholder="{{.Placeholder}}">{{.Value}}</textarea>
{{end}}

{{define "div"}}
<div class="decorator{{if .Content.Required}} required{{end}}">
{{.Content}}
</div>
{{end}}

{{define "form"}}
<form action="{{.Action}}" method="{{.Method}}">
{{range .Fields}}{{.}}{{end}}
</form>
{{end}}`

    tpl := template.Must(template.New("decorators").Parse(fieldTemplates))
    
    // 定义装饰器链
    inputDecorators := []Decorator{
        {Name: "input", Template: tpl},
        {Name: "div", Template: tpl},
    }
    
    textareaDecorators := []Decorator{
        {Name: "textarea", Template: tpl},
        {Name: "div", Template: tpl},
    }
    
    // 应用装饰器
    field := FormFieldDescription{
        Name:        "firstname",
        Description: "First name",
        Type:        "input",
        Required:    true,
        Value:       "John",
    }
    
    var output bytes.Buffer
    applyDecorators(&output, field, inputDecorators)
    
    // 输出结果
    fmt.Println(output.String())
}

这种实现方式允许你灵活地组合不同的装饰器，并且可以轻松地添加、删除或重新排列装饰器链。装饰器的执行顺序是从基础模板开始，然后依次应用每个装饰器。