使用Golang实现站点搜索功能有哪些方案？

在Golang中实现站点搜索功能有多种方案，以下是几种实用的方法：

方案一：使用Bleve全文搜索引擎

Bleve是Go语言中最流行的全文搜索引擎库，特别适合站内搜索：

package main

import (
    "fmt"
    "log"
    "net/http"
    "html/template"
    
    "github.com/blevesearch/bleve/v2"
)

var index bleve.Index

func init() {
    // 创建或打开索引
    mapping := bleve.NewIndexMapping()
    var err error
    index, err = bleve.New("site.bleve", mapping)
    if err != nil {
        index, err = bleve.Open("site.bleve")
        if err != nil {
            log.Fatal(err)
        }
    }
}

// 索引页面内容
func indexPage(id, title, content, url string) error {
    doc := map[string]interface{}{
        "title":   title,
        "content": content,
        "url":     url,
    }
    return index.Index(id, doc)
}

// 搜索处理
func searchHandler(w http.ResponseWriter, r *http.Request) {
    query := r.URL.Query().Get("q")
    if query == "" {
        http.ServeFile(w, r, "search.html")
        return
    }
    
    searchQuery := bleve.NewMatchQuery(query)
    search := bleve.NewSearchRequest(searchQuery)
    search.Fields = []string{"title", "content", "url"}
    searchResults, err := index.Search(search)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    tmpl := template.Must(template.ParseFiles("results.html"))
    tmpl.Execute(w, searchResults)
}

func main() {
    http.HandleFunc("/search", searchHandler)
    http.ListenAndServe(":8080", nil)
}

对应的HTML模板示例：

<!-- search.html -->
<form action="/search" method="get">
    <input type="text" name="q" placeholder="搜索网站内容...">
    <button type="submit">搜索</button>
</form>

<!-- results.html -->
<h2>搜索结果 ({{.Total}})</h2>
{{range .Hits}}
<div class="result">
    <h3><a href="{{.Fields.url}}">{{.Fields.title}}</a></h3>
    <p>{{.Fields.content}}</p>
    <small>相关度: {{.Score}}</small>
</div>
{{end}}

方案二：使用GoQuery进行HTML解析和内存搜索

对于小型网站，可以使用内存中的简单搜索：

package main

import (
    "bytes"
    "fmt"
    "log"
    "net/http"
    "strings"
    "sync"
    
    "github.com/PuerkitoBio/goquery"
)

type Page struct {
    URL     string
    Title   string
    Content string
}

var (
    pages []Page
    mutex sync.RWMutex
)

// 抓取和解析页面
func crawlPage(url string) error {
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    
    doc, err := goquery.NewDocumentFromReader(resp.Body)
    if err != nil {
        return err
    }
    
    title := doc.Find("title").Text()
    content := doc.Find("body").Text()
    
    // 清理内容，移除多余空白
    content = strings.Join(strings.Fields(content), " ")
    
    mutex.Lock()
    pages = append(pages, Page{
        URL:     url,
        Title:   title,
        Content: content,
    })
    mutex.Unlock()
    
    return nil
}

// 简单文本搜索
func searchPages(query string) []Page {
    var results []Page
    query = strings.ToLower(query)
    
    mutex.RLock()
    defer mutex.RUnlock()
    
    for _, page := range pages {
        if strings.Contains(strings.ToLower(page.Title), query) || 
           strings.Contains(strings.ToLower(page.Content), query) {
            results = append(results, page)
        }
    }
    return results
}

func searchHandler(w http.ResponseWriter, r *http.Request) {
    query := r.URL.Query().Get("q")
    if query == "" {
        fmt.Fprint(w, `
            <form method="get">
                <input type="text" name="q">
                <button type="submit">搜索</button>
            </form>
        `)
        return
    }
    
    results := searchPages(query)
    
    var buf bytes.Buffer
    buf.WriteString(fmt.Sprintf("<h2>找到 %d 个结果</h2>", len(results)))
    
    for _, result := range results {
        buf.WriteString(fmt.Sprintf(`
            <div style="margin: 20px 0;">
                <h3><a href="%s">%s</a></h3>
                <p>%s...</p>
            </div>
        `, result.URL, result.Title, truncateText(result.Content, 200)))
    }
    
    w.Header().Set("Content-Type", "text/html")
    w.Write(buf.Bytes())
}

func truncateText(text string, length int) string {
    if len(text) <= length {
        return text
    }
    return text[:length] + "..."
}

func main() {
    // 预先抓取网站页面
    urls := []string{
        "https://yoursite.com/page1",
        "https://yoursite.com/page2",
        // 添加更多URL
    }
    
    for _, url := range urls {
        go crawlPage(url)
    }
    
    http.HandleFunc("/search", searchHandler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

方案三：集成SQLite的FTS5扩展

对于需要持久化存储的场景：

package main

import (
    "database/sql"
    "fmt"
    "log"
    "net/http"
    
    _ "github.com/mattn/go-sqlite3"
)

func setupSearchDB() *sql.DB {
    db, err := sql.Open("sqlite3", "./search.db")
    if err != nil {
        log.Fatal(err)
    }
    
    // 创建FTS5虚拟表
    _, err = db.Exec(`
        CREATE VIRTUAL TABLE IF NOT EXISTS pages USING fts5(
            url, 
            title, 
            content,
            tokenize = 'porter unicode61'
        )
    `)
    if err != nil {
        log.Fatal(err)
    }
    
    return db
}

func searchSQLite(db *sql.DB, query string) ([]map[string]string, error) {
    rows, err := db.Query(`
        SELECT url, title, snippet(pages, 2, '<b>', '</b>', '...', 10) 
        FROM pages 
        WHERE pages MATCH ? 
        ORDER BY rank
    `, query)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var results []map[string]string
    for rows.Next() {
        var url, title, snippet string
        if err := rows.Scan(&url, &title, &snippet); err != nil {
            return nil, err
        }
        results = append(results, map[string]string{
            "url":     url,
            "title":   title,
            "snippet": snippet,
        })
    }
    
    return results, nil
}

这些方案从简单到复杂，可以根据网站规模和性能需求选择合适的实现方式。Bleve方案提供了最完整的搜索功能，包括相关性排序和高亮显示，适合大多数应用场景。