当前位置：首页 > news >正文

Go Web 编程快速入门 07.4 - 模板（4）：组合模板与逻辑控制

news 2025/10/26 7:58:07

1. 模板继承与布局系统

1.1 模板继承核心系统

package mainimport ("fmt""html/template""strings""sync""time""path/filepath""io/ioutil""errors"
)// TemplateInheritance 模板继承系统
type TemplateInheritance struct {// 布局模板存储layouts map[string]*template.Template// 模板构建器builder *TemplateBuilder// 缓存管理器cache *TemplateCache// 性能监控器monitor *PerformanceMonitormutex sync.RWMutex
}// LayoutConfig 布局配置
type LayoutConfig struct {Name        string            // 布局名称Path        string            // 布局文件路径Blocks      []string          // 定义的块名称Extends     string            // 继承的父布局Variables   map[string]string // 布局变量Metadata    map[string]interface{} // 元数据
}// TemplateBuilder 模板构建器
type TemplateBuilder struct {baseDir     stringfuncMap     template.FuncMaplayouts     map[string]*LayoutConfigpartials    map[string]stringcache       boolmutex sync.RWMutex
}// NewTemplateInheritance 创建模板继承系统
func NewTemplateInheritance(baseDir string) *TemplateInheritance {return &TemplateInheritance{layouts: make(map[string]*template.Template),builder: NewTemplateBuilder(baseDir),cache:   NewTemplateCache(),monitor: NewPerformanceMonitor(),}
}// NewTemplateBuilder 创建模板构建器
func NewTemplateBuilder(baseDir string) *TemplateBuilder {return &TemplateBuilder{baseDir:  baseDir,funcMap:  make(template.FuncMap),layouts:  make(map[string]*LayoutConfig),partials: make(map[string]string),cache:    true,}
}// RegisterLayout 注册布局模板
func (ti *TemplateInheritance) RegisterLayout(config *LayoutConfig) error {ti.mutex.Lock()defer ti.mutex.Unlock()// 验证布局配置if err := ti.validateLayout(config); err != nil {return fmt.Errorf("布局验证失败: %w", err)}// 构建模板tmpl, err := ti.builder.BuildLayout(config)if err != nil {return fmt.Errorf("构建布局失败: %w", err)}ti.layouts[config.Name] = tmplreturn nil
}// validateLayout 验证布局配置
func (ti *TemplateInheritance) validateLayout(config *LayoutConfig) error {if config.Name == "" {return errors.New("布局名称不能为空")}if config.Path == "" {return errors.New("布局路径不能为空")}// 检查文件是否存在fullPath := filepath.Join(ti.builder.baseDir, config.Path)if _, err := ioutil.ReadFile(fullPath); err != nil {return fmt.Errorf("布局文件不存在: %s", fullPath)}// 检查继承关系if config.Extends != "" {if _, exists := ti.layouts[config.Extends]; !exists {return fmt.Errorf("父布局不存在: %s", config.Extends)}}return nil
}// SetupBaseLayouts 设置基础布局
func (ti *TemplateInheritance) SetupBaseLayouts() error {// 主布局mainLayout := &LayoutConfig{Name: "main",Path: "layouts/main.html",Blocks: []string{"title", "head", "content", "scripts"},Variables: map[string]string{"charset": "UTF-8","lang":    "zh-CN",},}// 管理后台布局adminLayout := &LayoutConfig{Name:    "admin",Path:    "layouts/admin.html",Extends: "main",Blocks:  []string{"sidebar", "content", "footer"},Variables: map[string]string{"theme": "admin-dark",},}// 移动端布局mobileLayout := &LayoutConfig{Name:    "mobile",Path:    "layouts/mobile.html",Extends: "main",Blocks:  []string{"header", "content", "navigation"},Variables: map[string]string{"viewport": "width=device-width, initial-scale=1",},}// 注册布局layouts := []*LayoutConfig{mainLayout, adminLayout, mobileLayout}for _, layout := range layouts {if err := ti.RegisterLayout(layout); err != nil {return err}}return nil
}// BuildLayout 构建布局模板
func (tb *TemplateBuilder) BuildLayout(config *LayoutConfig) (*template.Template, error) {tb.mutex.Lock()defer tb.mutex.Unlock()// 读取布局文件fullPath := filepath.Join(tb.baseDir, config.Path)content, err := ioutil.ReadFile(fullPath)if err != nil {return nil, fmt.Errorf("读取布局文件失败: %w", err)}// 创建模板tmpl := template.New(config.Name).Funcs(tb.funcMap)// 处理继承if config.Extends != "" {parentConfig, exists := tb.layouts[config.Extends]if !exists {return nil, fmt.Errorf("父布局不存在: %s", config.Extends)}// 合并父布局内容content = tb.mergeLayouts(parentConfig, config, content)}// 解析模板tmpl, err = tmpl.Parse(string(content))if err != nil {return nil, fmt.Errorf("解析模板失败: %w", err)}// 缓存布局配置tb.layouts[config.Name] = configreturn tmpl, nil
}// mergeLayouts 合并布局
func (tb *TemplateBuilder) mergeLayouts(parent, child *LayoutConfig, childContent []byte) []byte {// 简化的布局合并逻辑// 实际应用中需要更复杂的模板解析和合并parentPath := filepath.Join(tb.baseDir, parent.Path)parentContent, err := ioutil.ReadFile(parentPath)if err != nil {return childContent}// 合并变量mergedVars := make(map[string]string)for k, v := range parent.Variables {mergedVars[k] = v}for k, v := range child.Variables {mergedVars[k] = v}// 替换变量占位符result := string(parentContent)for key, value := range mergedVars {placeholder := fmt.Sprintf("{{.%s}}", key)result = strings.ReplaceAll(result, placeholder, value)}// 插入子模板内容contentPlaceholder := "{{block \"content\" .}}{{end}}"result = strings.ReplaceAll(result, contentPlaceholder, string(childContent))return []byte(result)
}// AddFunction 添加模板函数
func (tb *TemplateBuilder) AddFunction(name string, fn interface{}) {tb.mutex.Lock()defer tb.mutex.Unlock()tb.funcMap[name] = fn
}// SetCacheEnabled 设置缓存启用状态
func (tb *TemplateBuilder) SetCacheEnabled(enabled bool) {tb.mutex.Lock()defer tb.mutex.Unlock()tb.cache = enabled
}

1.2 部分模板管理系统

// PartialManager 部分模板管理器
type PartialManager struct {partials map[string]*PartialTemplatebaseDir  stringfuncMap  template.FuncMapmutex sync.RWMutex
}// PartialTemplate 部分模板
type PartialTemplate struct {Name        stringPath        stringContent     stringDependencies []stringCacheKey    stringLastModified time.TimeMetadata    map[string]interface{}
}// NewPartialManager 创建部分模板管理器
func NewPartialManager(baseDir string) *PartialManager {return &PartialManager{partials: make(map[string]*PartialTemplate),baseDir:  baseDir,funcMap:  make(template.FuncMap),}
}// RegisterPartial 注册部分模板
func (pm *PartialManager) RegisterPartial(name, path string) error {pm.mutex.Lock()defer pm.mutex.Unlock()fullPath := filepath.Join(pm.baseDir, path)content, err := ioutil.ReadFile(fullPath)if err != nil {return fmt.Errorf("读取部分模板失败: %w", err)}// 获取文件信息fileInfo, err := ioutil.Stat(fullPath)if err != nil {return fmt.Errorf("获取文件信息失败: %w", err)}partial := &PartialTemplate{Name:         name,Path:         path,Content:      string(content),Dependencies: pm.extractDependencies(string(content)),CacheKey:     pm.generateCacheKey(name, path),LastModified: fileInfo.ModTime(),Metadata:     make(map[string]interface{}),}pm.partials[name] = partialreturn nil
}// extractDependencies 提取依赖关系
func (pm *PartialManager) extractDependencies(content string) []string {var dependencies []string// 查找模板引用 {{template "name" .}}templatePattern := `{{template\s+"([^"]+)"`re := regexp.MustCompile(templatePattern)matches := re.FindAllStringSubmatch(content, -1)for _, match := range matches {if len(match) > 1 {dependencies = append(dependencies, match[1])}}return dependencies
}// generateCacheKey 生成缓存键
func (pm *PartialManager) generateCacheKey(name, path string) string {return fmt.Sprintf("partial:%s:%s", name, path)
}// SetupCommonPartials 设置常用部分模板
func (pm *PartialManager) SetupCommonPartials() error {commonPartials := map[string]string{"pagination":  "partials/pagination.html","breadcrumb":  "partials/breadcrumb.html","article_card": "partials/article_card.html","comment":     "partials/comment.html","sidebar":     "partials/sidebar.html","footer":      "partials/footer.html","header":      "partials/header.html","navigation":  "partials/navigation.html",}for name, path := range commonPartials {if err := pm.RegisterPartial(name, path); err != nil {return fmt.Errorf("注册部分模板 %s 失败: %w", name, err)}}return nil
}// GetPartial 获取部分模板
func (pm *PartialManager) GetPartial(name string) (*PartialTemplate, error) {pm.mutex.RLock()defer pm.mutex.RUnlock()partial, exists := pm.partials[name]if !exists {return nil, fmt.Errorf("部分模板不存在: %s", name)}return partial, nil
}// ReloadPartial 重新加载部分模板
func (pm *PartialManager) ReloadPartial(name string) error {pm.mutex.Lock()defer pm.mutex.Unlock()partial, exists := pm.partials[name]if !exists {return fmt.Errorf("部分模板不存在: %s", name)}fullPath := filepath.Join(pm.baseDir, partial.Path)content, err := ioutil.ReadFile(fullPath)if err != nil {return fmt.Errorf("重新读取部分模板失败: %w", err)}// 更新内容partial.Content = string(content)partial.Dependencies = pm.extractDependencies(string(content))partial.LastModified = time.Now()return nil
}// TemplateComposer 模板组合器
type TemplateComposer struct {inheritance *TemplateInheritancepartials    *PartialManagerfuncMap     template.FuncMapmutex sync.RWMutex
}// NewTemplateComposer 创建模板组合器
func NewTemplateComposer(inheritance *TemplateInheritance, partials *PartialManager) *TemplateComposer {tc := &TemplateComposer{inheritance: inheritance,partials:    partials,funcMap:     make(template.FuncMap),}// 设置默认函数tc.setupDefaultFunctions()return tc
}// setupDefaultFunctions 设置默认函数
func (tc *TemplateComposer) setupDefaultFunctions() {tc.funcMap["partial"] = tc.renderPartialtc.funcMap["block"] = tc.renderBlocktc.funcMap["extend"] = tc.extendLayouttc.funcMap["include"] = tc.includeTemplatetc.funcMap["yield"] = tc.yieldContent
}// renderPartial 渲染部分模板
func (tc *TemplateComposer) renderPartial(name string, data interface{}) (template.HTML, error) {partial, err := tc.partials.GetPartial(name)if err != nil {return "", err}tmpl, err := template.New(name).Funcs(tc.funcMap).Parse(partial.Content)if err != nil {return "", fmt.Errorf("解析部分模板失败: %w", err)}var buf strings.Builderif err := tmpl.Execute(&buf, data); err != nil {return "", fmt.Errorf("执行部分模板失败: %w", err)}return template.HTML(buf.String()), nil
}// renderBlock 渲染块
func (tc *TemplateComposer) renderBlock(name string, data interface{}) (template.HTML, error) {// 块渲染逻辑return template.HTML(fmt.Sprintf("<!-- Block: %s -->", name)), nil
}// extendLayout 扩展布局
func (tc *TemplateComposer) extendLayout(layoutName string) (template.HTML, error) {// 布局扩展逻辑return template.HTML(fmt.Sprintf("<!-- Extend: %s -->", layoutName)), nil
}// includeTemplate 包含模板
func (tc *TemplateComposer) includeTemplate(templateName string, data interface{}) (template.HTML, error) {// 模板包含逻辑return template.HTML(fmt.Sprintf("<!-- Include: %s -->", templateName)), nil
}// yieldContent 输出内容
func (tc *TemplateComposer) yieldContent(blockName string) (template.HTML, error) {// 内容输出逻辑return template.HTML(fmt.Sprintf("<!-- Yield: %s -->", blockName)), nil
}

2. 模板组合与部分模板

2.1 高级逻辑控制系统

// ConditionalLogic 条件逻辑控制器
type ConditionalLogic struct {conditions map[string]ConditionFuncoperators  map[string]OperatorFuncmutex sync.RWMutex
}// ConditionFunc 条件函数类型
type ConditionFunc func(interface{}) bool// OperatorFunc 操作符函数类型
type OperatorFunc func(interface{}, interface{}) bool// NewConditionalLogic 创建条件逻辑控制器
func NewConditionalLogic() *ConditionalLogic {cl := &ConditionalLogic{conditions: make(map[string]ConditionFunc),operators:  make(map[string]OperatorFunc),}// 设置默认条件和操作符cl.setupDefaultConditions()cl.setupDefaultOperators()return cl
}// setupDefaultConditions 设置默认条件
func (cl *ConditionalLogic) setupDefaultConditions() {cl.conditions["isEmpty"] = func(v interface{}) bool {if v == nil {return true}switch val := v.(type) {case string:return val == ""case []interface{}:return len(val) == 0case map[string]interface{}:return len(val) == 0default:return false}}cl.conditions["isNumber"] = func(v interface{}) bool {switch v.(type) {case int, int8, int16, int32, int64:return truecase uint, uint8, uint16, uint32, uint64:return truecase float32, float64:return truedefault:return false}}cl.conditions["isString"] = func(v interface{}) bool {_, ok := v.(string)return ok}cl.conditions["isBool"] = func(v interface{}) bool {_, ok := v.(bool)return ok}cl.conditions["isEven"] = func(v interface{}) bool {if num, ok := v.(int); ok {return num%2 == 0}return false}cl.conditions["isOdd"] = func(v interface{}) bool {if num, ok := v.(int); ok {return num%2 != 0}return false}
}// setupDefaultOperators 设置默认操作符
func (cl *ConditionalLogic) setupDefaultOperators() {cl.operators["eq"] = func(a, b interface{}) bool {return fmt.Sprintf("%v", a) == fmt.Sprintf("%v", b)}cl.operators["ne"] = func(a, b interface{}) bool {return fmt.Sprintf("%v", a) != fmt.Sprintf("%v", b)}cl.operators["gt"] = func(a, b interface{}) bool {return compareNumbers(a, b) > 0}cl.operators["gte"] = func(a, b interface{}) bool {return compareNumbers(a, b) >= 0}cl.operators["lt"] = func(a, b interface{}) bool {return compareNumbers(a, b) < 0}cl.operators["lte"] = func(a, b interface{}) bool {return compareNumbers(a, b) <= 0}cl.operators["contains"] = func(a, b interface{}) bool {aStr := fmt.Sprintf("%v", a)bStr := fmt.Sprintf("%v", b)return strings.Contains(aStr, bStr)}cl.operators["startsWith"] = func(a, b interface{}) bool {aStr := fmt.Sprintf("%v", a)bStr := fmt.Sprintf("%v", b)return strings.HasPrefix(aStr, bStr)}cl.operators["endsWith"] = func(a, b interface{}) bool {aStr := fmt.Sprintf("%v", a)bStr := fmt.Sprintf("%v", b)return strings.HasSuffix(aStr, bStr)}
}// compareNumbers 比较数字
func compareNumbers(a, b interface{}) int {aFloat := toFloat64(a)bFloat := toFloat64(b)if aFloat > bFloat {return 1} else if aFloat < bFloat {return -1}return 0
}// toFloat64 转换为float64
func toFloat64(v interface{}) float64 {switch val := v.(type) {case int:return float64(val)case int64:return float64(val)case float32:return float64(val)case float64:return valcase string:if f, err := strconv.ParseFloat(val, 64); err == nil {return f}}return 0
}// RegisterCondition 注册条件
func (cl *ConditionalLogic) RegisterCondition(name string, fn ConditionFunc) {cl.mutex.Lock()defer cl.mutex.Unlock()cl.conditions[name] = fn
}// RegisterOperator 注册操作符
func (cl *ConditionalLogic) RegisterOperator(name string, fn OperatorFunc) {cl.mutex.Lock()defer cl.mutex.Unlock()cl.operators[name] = fn
}// EvaluateCondition 评估条件
func (cl *ConditionalLogic) EvaluateCondition(name string, value interface{}) bool {cl.mutex.RLock()defer cl.mutex.RUnlock()if fn, exists := cl.conditions[name]; exists {return fn(value)}return false
}// EvaluateOperator 评估操作符
func (cl *ConditionalLogic) EvaluateOperator(name string, a, b interface{}) bool {cl.mutex.RLock()defer cl.mutex.RUnlock()if fn, exists := cl.operators[name]; exists {return fn(a, b)}return false
}// LoopControl 循环控制器
type LoopControl struct {iterators map[string]IteratorFuncfilters   map[string]FilterFuncsorters   map[string]SorterFuncmutex sync.RWMutex
}// IteratorFunc 迭代器函数类型
type IteratorFunc func(interface{}) []interface{}// FilterFunc 过滤器函数类型
type FilterFunc func(interface{}) bool// SorterFunc 排序器函数类型
type SorterFunc func([]interface{}) []interface{}// NewLoopControl 创建循环控制器
func NewLoopControl() *LoopControl {lc := &LoopControl{iterators: make(map[string]IteratorFunc),filters:   make(map[string]FilterFunc),sorters:   make(map[string]SorterFunc),}// 设置默认迭代器、过滤器和排序器lc.setupDefaultIterators()lc.setupDefaultFilters()lc.setupDefaultSorters()return lc
}// setupDefaultIterators 设置默认迭代器
func (lc *LoopControl) setupDefaultIterators() {lc.iterators["range"] = func(v interface{}) []interface{} {switch val := v.(type) {case []interface{}:return valcase map[string]interface{}:result := make([]interface{}, 0, len(val))for _, value := range val {result = append(result, value)}return resultcase int:result := make([]interface{}, val)for i := 0; i < val; i++ {result[i] = i}return resultdefault:return []interface{}{v}}}lc.iterators["chars"] = func(v interface{}) []interface{} {if str, ok := v.(string); ok {result := make([]interface{}, len(str))for i, char := range str {result[i] = string(char)}return result}return []interface{}{}}lc.iterators["chunk"] = func(v interface{}) []interface{} {// 分块迭代器，将数组分成固定大小的块if arr, ok := v.([]interface{}); ok {chunkSize := 3 // 默认块大小var result []interface{}for i := 0; i < len(arr); i += chunkSize {end := i + chunkSizeif end > len(arr) {end = len(arr)}result = append(result, arr[i:end])}return result}return []interface{}{}}
}// setupDefaultFilters 设置默认过滤器
func (lc *LoopControl) setupDefaultFilters() {lc.filters["notEmpty"] = func(v interface{}) bool {if v == nil {return false}switch val := v.(type) {case string:return val != ""case []interface{}:return len(val) > 0case map[string]interface{}:return len(val) > 0default:return true}}lc.filters["isNumber"] = func(v interface{}) bool {switch v.(type) {case int, int8, int16, int32, int64:return truecase uint, uint8, uint16, uint32, uint64:return truecase float32, float64:return truedefault:return false}}lc.filters["isPositive"] = func(v interface{}) bool {return toFloat64(v) > 0}lc.filters["isNegative"] = func(v interface{}) bool {return toFloat64(v) < 0}
}// setupDefaultSorters 设置默认排序器
func (lc *LoopControl) setupDefaultSorters() {lc.sorters["asc"] = func(items []interface{}) []interface{} {result := make([]interface{}, len(items))copy(result, items)sort.Slice(result, func(i, j int) bool {return fmt.Sprintf("%v", result[i]) < fmt.Sprintf("%v", result[j])})return result}lc.sorters["desc"] = func(items []interface{}) []interface{} {result := make([]interface{}, len(items))copy(result, items)sort.Slice(result, func(i, j int) bool {return fmt.Sprintf("%v", result[i]) > fmt.Sprintf("%v", result[j])})return result}lc.sorters["shuffle"] = func(items []interface{}) []interface{} {result := make([]interface{}, len(items))copy(result, items)// 简单的洗牌算法for i := len(result) - 1; i > 0; i-- {j := int(time.Now().UnixNano()) % (i + 1)result[i], result[j] = result[j], result[i]}return result}
}// RegisterIterator 注册迭代器
func (lc *LoopControl) RegisterIterator(name string, fn IteratorFunc) {lc.mutex.Lock()defer lc.mutex.Unlock()lc.iterators[name] = fn
}// RegisterFilter 注册过滤器
func (lc *LoopControl) RegisterFilter(name string, fn FilterFunc) {lc.mutex.Lock()defer lc.mutex.Unlock()lc.filters[name] = fn
}// RegisterSorter 注册排序器
func (lc *LoopControl) RegisterSorter(name string, fn SorterFunc) {lc.mutex.Lock()defer lc.mutex.Unlock()lc.sorters[name] = fn
}// Iterate 执行迭代
func (lc *LoopControl) Iterate(name string, value interface{}) []interface{} {lc.mutex.RLock()defer lc.mutex.RUnlock()if fn, exists := lc.iterators[name]; exists {return fn(value)}return []interface{}{}
}// Filter 执行过滤
func (lc *LoopControl) Filter(items []interface{}, filterName string) []interface{} {lc.mutex.RLock()defer lc.mutex.RUnlock()if fn, exists := lc.filters[filterName]; exists {var result []interface{}for _, item := range items {if fn(item) {result = append(result, item)}}return result}return items
}// Sort 执行排序
func (lc *LoopControl) Sort(items []interface{}, sorterName string) []interface{} {lc.mutex.RLock()defer lc.mutex.RUnlock()if fn, exists := lc.sorters[sorterName]; exists {return fn(items)}return items
}

3. 高级逻辑控制

3.1 模板缓存与性能优化

// TemplateCache 模板缓存系统
type TemplateCache struct {strategy CacheStrategyconfig   *CacheConfigentries  map[string]*CacheEntrystats    *CacheStatsmutex sync.RWMutex
}// CacheStrategy 缓存策略
type CacheStrategy intconst (CacheNone CacheStrategy = iotaCacheMemoryCacheFileCacheRedisCacheHybrid
)// CacheConfig 缓存配置
type CacheConfig struct {Strategy     CacheStrategyMaxSize      int64TTL          time.DurationCleanupInterval time.DurationRedisAddr    stringRedisDB      intFileDir      string
}// CacheEntry 缓存条目
type CacheEntry struct {Key        stringContent    []byteSize       int64CreatedAt  time.TimeAccessedAt time.TimeAccessCount int64TTL        time.Duration
}// CacheStats 缓存统计
type CacheStats struct {Hits        int64Misses      int64Evictions   int64TotalSize   int64EntryCount  int64mutex sync.RWMutex
}// NewTemplateCache 创建模板缓存
func NewTemplateCache() *TemplateCache {config := &CacheConfig{Strategy:        CacheMemory,MaxSize:         100 * 1024 * 1024, // 100MBTTL:             time.Hour,CleanupInterval: time.Minute * 10,}tc := &TemplateCache{strategy: config.Strategy,config:   config,entries:  make(map[string]*CacheEntry),stats:    &CacheStats{},}// 启动清理协程go tc.startCleanup()return tc
}// Get 获取缓存
func (tc *TemplateCache) Get(key string) ([]byte, bool) {tc.mutex.RLock()defer tc.mutex.RUnlock()entry, exists := tc.entries[key]if !exists {tc.stats.recordMiss()return nil, false}// 检查是否过期if tc.isExpired(entry) {tc.stats.recordMiss()return nil, false}// 更新访问信息entry.AccessedAt = time.Now()entry.AccessCount++tc.stats.recordHit()return entry.Content, true
}// Set 设置缓存
func (tc *TemplateCache) Set(key string, content []byte, ttl time.Duration) {tc.mutex.Lock()defer tc.mutex.Unlock()// 检查是否需要清理空间if tc.needEviction(int64(len(content))) {tc.evictLRU()}entry := &CacheEntry{Key:         key,Content:     content,Size:        int64(len(content)),CreatedAt:   time.Now(),AccessedAt:  time.Now(),AccessCount: 1,TTL:         ttl,}// 如果键已存在，更新统计if oldEntry, exists := tc.entries[key]; exists {tc.stats.TotalSize -= oldEntry.Sizetc.stats.EntryCount--}tc.entries[key] = entrytc.stats.TotalSize += entry.Sizetc.stats.EntryCount++
}// isExpired 检查是否过期
func (tc *TemplateCache) isExpired(entry *CacheEntry) bool {if entry.TTL <= 0 {return false}return time.Since(entry.CreatedAt) > entry.TTL
}// needEviction 检查是否需要清理
func (tc *TemplateCache) needEviction(newSize int64) bool {return tc.stats.TotalSize+newSize > tc.config.MaxSize
}// evictLRU 清理最少使用的条目
func (tc *TemplateCache) evictLRU() {if len(tc.entries) == 0 {return}var oldestKey stringvar oldestTime time.Time = time.Now()for key, entry := range tc.entries {if entry.AccessedAt.Before(oldestTime) {oldestTime = entry.AccessedAtoldestKey = key}}if oldestKey != "" {entry := tc.entries[oldestKey]delete(tc.entries, oldestKey)tc.stats.TotalSize -= entry.Sizetc.stats.EntryCount--tc.stats.Evictions++}
}// cleanup 清理过期条目
func (tc *TemplateCache) cleanup() {tc.mutex.Lock()defer tc.mutex.Unlock()for key, entry := range tc.entries {if tc.isExpired(entry) {delete(tc.entries, key)tc.stats.TotalSize -= entry.Sizetc.stats.EntryCount--}}
}// startCleanup 启动清理协程
func (tc *TemplateCache) startCleanup() {ticker := time.NewTicker(tc.config.CleanupInterval)defer ticker.Stop()for range ticker.C {tc.cleanup()}
}// GetStats 获取缓存统计
func (tc *TemplateCache) GetStats() CacheStats {tc.stats.mutex.RLock()defer tc.stats.mutex.RUnlock()return *tc.stats
}// Clear 清空缓存
func (tc *TemplateCache) Clear() {tc.mutex.Lock()defer tc.mutex.Unlock()tc.entries = make(map[string]*CacheEntry)tc.stats.TotalSize = 0tc.stats.EntryCount = 0
}// Stop 停止缓存
func (tc *TemplateCache) Stop() {tc.Clear()
}// recordHit 记录命中
func (cs *CacheStats) recordHit() {cs.mutex.Lock()defer cs.mutex.Unlock()cs.Hits++
}// recordMiss 记录未命中
func (cs *CacheStats) recordMiss() {cs.mutex.Lock()defer cs.mutex.Unlock()cs.Misses++
}// PerformanceMonitor 性能监控器
type PerformanceMonitor struct {metrics map[string]*TemplateMetricsalerts  map[string]*AlertConfigmutex sync.RWMutex
}// TemplateMetrics 模板性能指标
type TemplateMetrics struct {Name         stringRenderCount  int64TotalDuration time.DurationAvgDuration  time.DurationMaxDuration  time.DurationMinDuration  time.DurationErrorCount   int64CacheHits    int64CacheMisses  int64LastRender   time.Time
}// AlertConfig 告警配置
type AlertConfig struct {MaxDuration   time.DurationMaxErrorRate  float64MinCacheRate  float64Callback      func(*TemplateMetrics)
}// NewPerformanceMonitor 创建性能监控器
func NewPerformanceMonitor() *PerformanceMonitor {return &PerformanceMonitor{metrics: make(map[string]*TemplateMetrics),alerts:  make(map[string]*AlertConfig),}
}// RecordRender 记录渲染性能
func (pm *PerformanceMonitor) RecordRender(templateName string, duration time.Duration, err error) {pm.mutex.Lock()defer pm.mutex.Unlock()metrics, exists := pm.metrics[templateName]if !exists {metrics = &TemplateMetrics{Name:        templateName,MinDuration: duration,}pm.metrics[templateName] = metrics}// 更新指标metrics.RenderCount++metrics.TotalDuration += durationmetrics.AvgDuration = time.Duration(int64(metrics.TotalDuration) / metrics.RenderCount)metrics.LastRender = time.Now()if duration > metrics.MaxDuration {metrics.MaxDuration = duration}if duration < metrics.MinDuration {metrics.MinDuration = duration}if err != nil {metrics.ErrorCount++}// 检查告警pm.checkAlerts(templateName, metrics)
}// RecordCacheHit 记录缓存命中
func (pm *PerformanceMonitor) RecordCacheHit(templateName string, hit bool) {pm.mutex.Lock()defer pm.mutex.Unlock()metrics, exists := pm.metrics[templateName]if !exists {metrics = &TemplateMetrics{Name: templateName}pm.metrics[templateName] = metrics}if hit {metrics.CacheHits++} else {metrics.CacheMisses++}
}// checkAlerts 检查告警
func (pm *PerformanceMonitor) checkAlerts(templateName string, metrics *TemplateMetrics) {alert, exists := pm.alerts[templateName]if !exists {return}// 检查渲染时间告警if alert.MaxDuration > 0 && metrics.AvgDuration > alert.MaxDuration {if alert.Callback != nil {go alert.Callback(metrics)}}// 检查错误率告警if alert.MaxErrorRate > 0 && metrics.RenderCount > 0 {errorRate := float64(metrics.ErrorCount) / float64(metrics.RenderCount)if errorRate > alert.MaxErrorRate {if alert.Callback != nil {go alert.Callback(metrics)}}}// 检查缓存命中率告警if alert.MinCacheRate > 0 {totalCache := metrics.CacheHits + metrics.CacheMissesif totalCache > 0 {cacheRate := float64(metrics.CacheHits) / float64(totalCache)if cacheRate < alert.MinCacheRate {if alert.Callback != nil {go alert.Callback(metrics)}}}}
}// GetMetrics 获取指定模板的性能指标
func (pm *PerformanceMonitor) GetMetrics(templateName string) *TemplateMetrics {pm.mutex.RLock()defer pm.mutex.RUnlock()if metrics, exists := pm.metrics[templateName]; exists {// 返回副本result := *metricsreturn &result}return nil
}// GetAllMetrics 获取所有性能指标
func (pm *PerformanceMonitor) GetAllMetrics() map[string]*TemplateMetrics {pm.mutex.RLock()defer pm.mutex.RUnlock()result := make(map[string]*TemplateMetrics)for name, metrics := range pm.metrics {// 返回副本result[name] = &TemplateMetrics{Name:          metrics.Name,RenderCount:   metrics.RenderCount,TotalDuration: metrics.TotalDuration,AvgDuration:   metrics.AvgDuration,MaxDuration:   metrics.MaxDuration,MinDuration:   metrics.MinDuration,ErrorCount:    metrics.ErrorCount,CacheHits:     metrics.CacheHits,CacheMisses:   metrics.CacheMisses,LastRender:    metrics.LastRender,}}return result
}// SetAlertThreshold 设置告警阈值
func (pm *PerformanceMonitor) SetAlertThreshold(templateName string, config *AlertConfig) {pm.mutex.Lock()defer pm.mutex.Unlock()pm.alerts[templateName] = config
}// PrintReport 打印性能报告
func (pm *PerformanceMonitor) PrintReport() {pm.mutex.RLock()defer pm.mutex.RUnlock()fmt.Println("=== 模板性能报告 ===")fmt.Printf("%-20s %-10s %-15s %-15s %-15s %-10s %-10s\n", "模板名称", "渲染次数", "平均耗时", "最大耗时", "最小耗时", "错误数", "缓存命中率")fmt.Println(strings.Repeat("-", 100))for _, metrics := range pm.metrics {totalCache := metrics.CacheHits + metrics.CacheMissescacheRate := "N/A"if totalCache > 0 {cacheRate = fmt.Sprintf("%.2f%%", float64(metrics.CacheHits)/float64(totalCache)*100)}fmt.Printf("%-20s %-10d %-15s %-15s %-15s %-10d %-10s\n",metrics.Name,metrics.RenderCount,metrics.AvgDuration,metrics.MaxDuration,metrics.MinDuration,metrics.ErrorCount,cacheRate,)}
}// Reset 重置性能指标
func (pm *PerformanceMonitor) Reset() {pm.mutex.Lock()defer pm.mutex.Unlock()pm.metrics = make(map[string]*TemplateMetrics)
}

4. 模板缓存与性能优化

4.1 实战项目：CMS内容管理系统

// CMSSystem CMS内容管理系统
type CMSSystem struct {inheritance *TemplateInheritancepartials    *PartialManagercomposer    *TemplateComposercache       *TemplateCachemonitor     *PerformanceMonitorconditional *ConditionalLogicloop        *LoopControl// 数据模型posts      []Postcategories []Categoryusers      []Usertags       []Tagmutex sync.RWMutex
}// Post 文章模型
type Post struct {ID          int       `json:"id"`Title       string    `json:"title"`Content     string    `json:"content"`Summary     string    `json:"summary"`AuthorID    int       `json:"author_id"`CategoryID  int       `json:"category_id"`Tags        []string  `json:"tags"`Status      string    `json:"status"` // draft, published, archivedViewCount   int       `json:"view_count"`CreatedAt   time.Time `json:"created_at"`UpdatedAt   time.Time `json:"updated_at"`PublishedAt *time.Time `json:"published_at,omitempty"`
}// Category 分类模型
type Category struct {ID          int    `json:"id"`Name        string `json:"name"`Slug        string `json:"slug"`Description string `json:"description"`PostCount   int    `json:"post_count"`ParentID    *int   `json:"parent_id,omitempty"`
}// User 用户模型
type User struct {ID       int    `json:"id"`Username string `json:"username"`Email    string `json:"email"`Name     string `json:"name"`Avatar   string `json:"avatar"`Role     string `json:"role"` // admin, editor, author
}// Tag 标签模型
type Tag struct {ID        int    `json:"id"`Name      string `json:"name"`Slug      string `json:"slug"`PostCount int    `json:"post_count"`
}// NewCMSSystem 创建CMS系统
func NewCMSSystem(baseDir string) *CMSSystem {inheritance := NewTemplateInheritance(baseDir)partials := NewPartialManager(baseDir)composer := NewTemplateComposer(inheritance, partials)cms := &CMSSystem{inheritance: inheritance,partials:    partials,composer:    composer,cache:       NewTemplateCache(),monitor:     NewPerformanceMonitor(),conditional: NewConditionalLogic(),loop:        NewLoopControl(),}// 初始化系统cms.initialize()return cms
}// initialize 初始化CMS系统
func (cms *CMSSystem) initialize() error {// 设置基础布局if err := cms.inheritance.SetupBaseLayouts(); err != nil {return fmt.Errorf("设置基础布局失败: %w", err)}// 设置部分模板if err := cms.partials.SetupCommonPartials(); err != nil {return fmt.Errorf("设置部分模板失败: %w", err)}// 设置CMS专用模板if err := cms.setupCMSTemplates(); err != nil {return fmt.Errorf("设置CMS模板失败: %w", err)}// 初始化示例数据cms.setupSampleData()return nil
}// setupSampleData 设置示例数据
func (cms *CMSSystem) setupSampleData() {// 用户数据cms.users = []User{{ID: 1, Username: "admin", Email: "admin@example.com", Name: "管理员", Role: "admin"},{ID: 2, Username: "editor", Email: "editor@example.com", Name: "编辑", Role: "editor"},{ID: 3, Username: "author", Email: "author@example.com", Name: "作者", Role: "author"},}// 分类数据cms.categories = []Category{{ID: 1, Name: "技术", Slug: "tech", Description: "技术相关文章", PostCount: 5},{ID: 2, Name: "生活", Slug: "life", Description: "生活感悟", PostCount: 3},{ID: 3, Name: "教程", Slug: "tutorial", Description: "教程文章", PostCount: 4},}// 标签数据cms.tags = []Tag{{ID: 1, Name: "Go", Slug: "go", PostCount: 8},{ID: 2, Name: "Web开发", Slug: "web-dev", PostCount: 6},{ID: 3, Name: "模板", Slug: "template", PostCount: 4},{ID: 4, Name: "性能优化", Slug: "performance", PostCount: 3},}// 文章数据cms.posts = []Post{{ID: 1, Title: "Go Web模板系统详解", Content: "这是一篇关于Go Web模板系统的详细教程...",Summary: "深入了解Go Web模板系统的使用方法",AuthorID: 1, CategoryID: 1, Tags: []string{"Go", "Web开发", "模板"},Status: "published", ViewCount: 150,CreatedAt: time.Now().AddDate(0, 0, -7),UpdatedAt: time.Now().AddDate(0, 0, -1),},{ID: 2, Title: "模板缓存与性能优化",Content: "本文介绍如何优化模板渲染性能...",Summary: "提升模板渲染性能的实用技巧",AuthorID: 2, CategoryID: 3, Tags: []string{"性能优化", "模板"},Status: "published", ViewCount: 89,CreatedAt: time.Now().AddDate(0, 0, -5),UpdatedAt: time.Now().AddDate(0, 0, -2),},{ID: 3, Title: "CMS系统架构设计",Content: "分享CMS系统的架构设计思路...",Summary: "从零开始设计一个CMS系统",AuthorID: 3, CategoryID: 1, Tags: []string{"架构", "CMS"},Status: "draft", ViewCount: 0,CreatedAt: time.Now().AddDate(0, 0, -3),UpdatedAt: time.Now().AddDate(0, 0, -1),},}
}// setupCMSTemplates 设置CMS专用模板
func (cms *CMSSystem) setupCMSTemplates() error {// 首页模板homeTemplate := &LayoutConfig{Name: "home",Path: "cms/home.html",Extends: "main",Blocks: []string{"hero", "featured", "recent", "sidebar"},Variables: map[string]string{"page_type": "home","title": "首页",},}// 文章详情模板postTemplate := &LayoutConfig{Name: "post",Path: "cms/post.html", Extends: "main",Blocks: []string{"content", "sidebar", "comments"},Variables: map[string]string{"page_type": "post",},}// 分类页面模板categoryTemplate := &LayoutConfig{Name: "category",Path: "cms/category.html",Extends: "main", Blocks: []string{"header", "posts", "pagination"},Variables: map[string]string{"page_type": "category",},}// 管理后台首页模板adminDashboardTemplate := &LayoutConfig{Name: "admin_dashboard",Path: "cms/admin/dashboard.html",Extends: "admin",Blocks: []string{"stats", "recent_posts", "quick_actions"},Variables: map[string]string{"page_type": "admin_dashboard","title": "管理后台",},}// 注册模板templates := []*LayoutConfig{homeTemplate, postTemplate, categoryTemplate, adminDashboardTemplate,}for _, tmpl := range templates {if err := cms.inheritance.RegisterLayout(tmpl); err != nil {return fmt.Errorf("注册模板 %s 失败: %w", tmpl.Name, err)}}return nil
}// RenderHomePage 渲染首页
func (cms *CMSSystem) RenderHomePage() (string, error) {start := time.Now()// 检查缓存cacheKey := "home_page"if cached, found := cms.cache.Get(cacheKey); found {cms.monitor.RecordCacheHit("home", true)return string(cached), nil}cms.monitor.RecordCacheHit("home", false)// 准备数据data := map[string]interface{}{"title": "欢迎来到我们的博客","featured_posts": cms.getFeaturedPosts(3),"recent_posts": cms.getRecentPosts(5),"categories": cms.categories,"popular_tags": cms.getPopularTags(10),"stats": cms.getStatistics(),}// 渲染模板tmpl, exists := cms.inheritance.layouts["home"]if !exists {return "", errors.New("首页模板不存在")}var buf strings.Buildererr := tmpl.Execute(&buf, data)// 记录性能duration := time.Since(start)cms.monitor.RecordRender("home", duration, err)if err != nil {return "", fmt.Errorf("渲染首页失败: %w", err)}result := buf.String()// 缓存结果cms.cache.Set(cacheKey, []byte(result), time.Hour)return result, nil
}// RenderPost 渲染文章详情
func (cms *CMSSystem) RenderPost(postID int) (string, error) {start := time.Now()// 检查缓存cacheKey := fmt.Sprintf("post_%d", postID)if cached, found := cms.cache.Get(cacheKey); found {cms.monitor.RecordCacheHit("post", true)return string(cached), nil}cms.monitor.RecordCacheHit("post", false)// 查找文章var post *Postfor i := range cms.posts {if cms.posts[i].ID == postID {post = &cms.posts[i]break}}if post == nil {return "", errors.New("文章不存在")}// 准备数据data := map[string]interface{}{"post": post,"author": cms.getUserByID(post.AuthorID),"category": cms.getCategoryByID(post.CategoryID),"related_posts": cms.getRelatedPosts(post.ID, 3),"prev_post": cms.getAdjacentPosts(post.ID, "prev"),"next_post": cms.getAdjacentPosts(post.ID, "next"),"title": post.Title,}// 渲染模板tmpl, exists := cms.inheritance.layouts["post"]if !exists {return "", errors.New("文章模板不存在")}var buf strings.Buildererr := tmpl.Execute(&buf, data)// 记录性能duration := time.Since(start)cms.monitor.RecordRender("post", duration, err)if err != nil {return "", fmt.Errorf("渲染文章失败: %w", err)}result := buf.String()// 缓存结果cms.cache.Set(cacheKey, []byte(result), time.Hour*2)return result, nil
}// RenderCategory 渲染分类页面
func (cms *CMSSystem) RenderCategory(categoryID int, page int) (string, error) {start := time.Now()// 检查缓存cacheKey := fmt.Sprintf("category_%d_page_%d", categoryID, page)if cached, found := cms.cache.Get(cacheKey); found {cms.monitor.RecordCacheHit("category", true)return string(cached), nil}cms.monitor.RecordCacheHit("category", false)// 查找分类var category *Categoryfor i := range cms.categories {if cms.categories[i].ID == categoryID {category = &cms.categories[i]break}}if category == nil {return "", errors.New("分类不存在")}// 准备数据posts := cms.getPostsByCategory(categoryID, page, 10)data := map[string]interface{}{"category": category,"posts": posts,"current_page": page,"total_pages": (category.PostCount + 9) / 10, // 向上取整"title": fmt.Sprintf("%s - 分类", category.Name),}// 渲染模板tmpl, exists := cms.inheritance.layouts["category"]if !exists {return "", errors.New("分类模板不存在")}var buf strings.Buildererr := tmpl.Execute(&buf, data)// 记录性能duration := time.Since(start)cms.monitor.RecordRender("category", duration, err)if err != nil {return "", fmt.Errorf("渲染分类页面失败: %w", err)}result := buf.String()// 缓存结果cms.cache.Set(cacheKey, []byte(result), time.Minute*30)return result, nil
}// RenderAdminDashboard 渲染管理后台首页
func (cms *CMSSystem) RenderAdminDashboard() (string, error) {start := time.Now()// 管理后台不使用缓存，确保数据实时性// 准备数据data := map[string]interface{}{"stats": cms.getStatistics(),"recent_posts": cms.getRecentPosts(10),"draft_posts": cms.getDraftPosts(),"categories": cms.categories,"users": cms.users,"title": "管理后台",}// 渲染模板tmpl, exists := cms.inheritance.layouts["admin_dashboard"]if !exists {return "", errors.New("管理后台模板不存在")}var buf strings.Buildererr := tmpl.Execute(&buf, data)// 记录性能duration := time.Since(start)cms.monitor.RecordRender("admin_dashboard", duration, err)if err != nil {return "", fmt.Errorf("渲染管理后台失败: %w", err)}return buf.String(), nil
}// 辅助方法// getFeaturedPosts 获取推荐文章
func (cms *CMSSystem) getFeaturedPosts(limit int) []Post {var featured []Postcount := 0for _, post := range cms.posts {if post.Status == "published" && post.ViewCount > 100 {featured = append(featured, post)count++if count >= limit {break}}}return featured
}// getRecentPosts 获取最新文章
func (cms *CMSSystem) getRecentPosts(limit int) []Post {var recent []Postcount := 0// 按创建时间倒序for i := len(cms.posts) - 1; i >= 0 && count < limit; i-- {if cms.posts[i].Status == "published" {recent = append(recent, cms.posts[i])count++}}return recent
}// getRelatedPosts 获取相关文章
func (cms *CMSSystem) getRelatedPosts(postID int, limit int) []Post {var related []Postvar currentPost *Post// 找到当前文章for i := range cms.posts {if cms.posts[i].ID == postID {currentPost = &cms.posts[i]break}}if currentPost == nil {return related}count := 0for _, post := range cms.posts {if post.ID != postID && post.Status == "published" && count < limit {// 简单的相关性判断：同分类或有共同标签if post.CategoryID == currentPost.CategoryID {related = append(related, post)count++}}}return related
}// getAdjacentPosts 获取相邻文章
func (cms *CMSSystem) getAdjacentPosts(postID int, direction string) *Post {for i, post := range cms.posts {if post.ID == postID {if direction == "prev" && i > 0 {return &cms.posts[i-1]} else if direction == "next" && i < len(cms.posts)-1 {return &cms.posts[i+1]}break}}return nil
}// getPostsByCategory 按分类获取文章
func (cms *CMSSystem) getPostsByCategory(categoryID, page, pageSize int) []Post {var posts []Postfor _, post := range cms.posts {if post.CategoryID == categoryID && post.Status == "published" {posts = append(posts, post)}}// 分页start := (page - 1) * pageSizeend := start + pageSizeif start >= len(posts) {return []Post{}}if end > len(posts) {end = len(posts)}return posts[start:end]
}// getDraftPosts 获取草稿文章
func (cms *CMSSystem) getDraftPosts() []Post {var drafts []Postfor _, post := range cms.posts {if post.Status == "draft" {drafts = append(drafts, post)}}return drafts
}// getUserByID 根据ID获取用户
func (cms *CMSSystem) getUserByID(userID int) *User {for i := range cms.users {if cms.users[i].ID == userID {return &cms.users[i]}}return nil
}// getCategoryByID 根据ID获取分类
func (cms *CMSSystem) getCategoryByID(categoryID int) *Category {for i := range cms.categories {if cms.categories[i].ID == categoryID {return &cms.categories[i]}}return nil
}// getAllCategories 获取所有分类
func (cms *CMSSystem) getAllCategories() []Category {return cms.categories
}// getPopularTags 获取热门标签
func (cms *CMSSystem) getPopularTags(limit int) []Tag {// 简单返回前N个标签if limit > len(cms.tags) {limit = len(cms.tags)}return cms.tags[:limit]
}// getStatistics 获取统计信息
func (cms *CMSSystem) getStatistics() map[string]interface{} {publishedCount := 0draftCount := 0totalViews := 0for _, post := range cms.posts {if post.Status == "published" {publishedCount++totalViews += post.ViewCount} else if post.Status == "draft" {draftCount++}}return map[string]interface{}{"total_posts": len(cms.posts),"published_posts": publishedCount,"draft_posts": draftCount,"total_categories": len(cms.categories),"total_tags": len(cms.tags),"total_users": len(cms.users),"total_views": totalViews,}
}// RunCMSDemo 运行CMS演示
func RunCMSDemo() {fmt.Println("=== CMS内容管理系统演示 ===")// 创建CMS系统cms := NewCMSSystem("templates")// 渲染首页fmt.Println("\n1. 渲染首页...")homePage, err := cms.RenderHomePage()if err != nil {fmt.Printf("渲染首页失败: %v\n", err)} else {fmt.Printf("首页渲染成功，长度: %d 字符\n", len(homePage))}// 渲染文章详情fmt.Println("\n2. 渲染文章详情...")postPage, err := cms.RenderPost(1)if err != nil {fmt.Printf("渲染文章失败: %v\n", err)} else {fmt.Printf("文章渲染成功，长度: %d 字符\n", len(postPage))}// 渲染分类页面fmt.Println("\n3. 渲染分类页面...")categoryPage, err := cms.RenderCategory(1, 1)if err != nil {fmt.Printf("渲染分类页面失败: %v\n", err)} else {fmt.Printf("分类页面渲染成功，长度: %d 字符\n", len(categoryPage))}// 渲染管理后台fmt.Println("\n4. 渲染管理后台...")adminPage, err := cms.RenderAdminDashboard()if err != nil {fmt.Printf("渲染管理后台失败: %v\n", err)} else {fmt.Printf("管理后台渲染成功，长度: %d 字符\n", len(adminPage))}// 显示性能报告fmt.Println("\n5. 性能监控报告:")cms.monitor.PrintReport()// 显示缓存统计fmt.Println("\n6. 缓存统计:")stats := cms.cache.GetStats()fmt.Printf("缓存命中: %d, 未命中: %d, 命中率: %.2f%%\n", stats.Hits, stats.Misses, float64(stats.Hits)/float64(stats.Hits+stats.Misses)*100)fmt.Printf("缓存条目: %d, 总大小: %d KB\n", stats.EntryCount, stats.TotalSize/1024)
}// main 主函数演示
func main() {RunCMSDemo()
}