使用Go语言编写邮件内容解析功能

保存为readmsg.go

 

package main

import (
    "bytes"
    "database/sql"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "io"
    "io/ioutil"
    "log"
    "mime"
    "mime/multipart"
    "net/mail"
    "regexp"
    "strings"
    "time"

    _ "github.com/go-sql-driver/mysql"
    "golang.org/x/net/html/charset"
)

type Email struct {
    Id         int
    Created    string
    RemoteAddr string
    MailFrom   string
    RcptTo     string
    Data       []byte
    Header     string
    Subject    string
    BodyPlain  []byte
    BodyHtml   []byte
}

func main() {
    for {
        mysql_email_update()
        time.Sleep(time.Second * 10)
    }
}
func mysql_email_update() {
    log.Print("mysql connecting...")
    db, err := sql.Open("mysql", "firadio_mail:firadio_mail@tcp(39.101.248.243:3306)/firadio_mail")
    if err != nil {
        panic(err.Error())
    }
    log.Print("mysql connected!")
    defer db.Close()

    rows, err := db.Query("SELECT id,created,remote_addr,mail_from,rcpt_to,data FROM emails WHERE 0 OR ISNULL(subject)")
    if err != nil {
        panic(err.Error())
    }
    defer rows.Close()

    for rows.Next() {
        var email Email
        err := rows.Scan(&email.Id, &email.Created, &email.RemoteAddr, &email.MailFrom, &email.RcptTo, &email.Data)
        if err != nil {
            panic(err.Error())
        }
        //log.Println(email)
        err = saveMail(db, email)
        if err != nil {
            log.Panicln(err)
        }
    }
    if err := rows.Err(); err != nil {
        panic(err.Error())
    }
    log.Print("mysql updated!")
}

func saveMail(db *sql.DB, email Email) error {
    // 解析并存储邮件
    log.Println("updating...", email.Id)

    // 准备插入语句
    stmt, err := db.Prepare("UPDATE emails SET header=?, subject=?, body_plain=?, body_html=? WHERE id=?")
    if err != nil {
        return fmt.Errorf("db.Prepare: %w", err)
    }
    defer stmt.Close()

    data := email.Data
    msg, err := mail.ReadMessage(bytes.NewReader(data))
    if err != nil {
        return fmt.Errorf("ReadMessage: %w", err)
    }

    if true {
        jsonHeader, err := GetJsonByMsg(msg)
        if err != nil {
            return fmt.Errorf("GetJsonByMsg: %w", err)
        }
        //log.Println(jsonHeader)
        email.Header = jsonHeader
    }

    if true {
        subject, err := GetSubjectByMsg(msg)
        if err != nil {
            return fmt.Errorf("GetSubjectByMsg: %w", err)
        }
        //log.Println(subject)
        email.Subject = subject
    }
    // 一次性把MultipartBody部分全部读过来
    multipartBody, err := GetMultipartBody(msg)
    if err != nil {
        return fmt.Errorf("GetMultipartBody: %w", err)
    }

    if true {
        msg_body_plain, err := GetBodyByMsg(msg, multipartBody, "text/plain")
        if err != nil {
            return fmt.Errorf("GetBodyByMsg.text/plain: %w", err)
        }
        //log.Println("text/plain", string(msg_body_plain))
        email.BodyPlain = msg_body_plain
    }

    if true {
        msg_body_html, err := GetBodyByMsg(msg, multipartBody, "text/html")
        if err != nil {
            return fmt.Errorf("GetBodyByMsg.text/html: %w", err)
        }
        //log.Println("text/html", string(msg_body_html))
        email.BodyHtml = msg_body_html
    }

    // 执行插入语句
    _, err = stmt.Exec(email.Header, email.Subject, email.BodyPlain, email.BodyHtml, email.Id)
    if err != nil {
        return err
    }

    return nil
}

func DecodeRFC2047String(str string) (string, error) {

    // 通过匹配正则的方式来处理
    re := regexp.MustCompile("[\\s]?=\\?([\\w\\-]+)\\?([A-Z])\\?([\\w+/=]+={0,2})\\?=")

    // 定义一个替换函数
    replaceFunc := func(match string, submatches []string) string {
        // 调用你的方法来处理子匹配项并返回结果
        s, err := DecodeRFC2047String_one(match, submatches[1], submatches[2], submatches[3])
        if err != nil {
            return ""
        }
        return s
    }

    // 使用正则表达式和替换函数来替换字符串
    newStr := re.ReplaceAllStringFunc(str, func(match string) string {
        submatches := re.FindStringSubmatch(match)
        return replaceFunc(match, submatches)
    })

    return newStr, nil
}

func DecodeRFC2047String_one(_match string, _charset string, _type string, _encoded string) (string, error) {

    var sDecoded string
    var err error

    if _type == "Q" {
        dec := new(mime.WordDecoder)
        sDecoded, err = dec.DecodeHeader(_match)
        if err != nil {
            return "", err
        }
        return sDecoded, nil
    }

    if _type == "B" {
        // 将编码后的字符串解码为字节数组
        bDecoded, err := base64.StdEncoding.DecodeString(_encoded)
        if err != nil {
            return "", err
        }
        sDecoded = string(bDecoded)
    }

    // 将字节数组转换为UTF-8编码的字符串
    reader := strings.NewReader(sDecoded)
    utf8Reader, err := charset.NewReaderLabel(_charset, reader)
    if err != nil {
        return "", err
    }

    utf8Bytes, err := ioutil.ReadAll(utf8Reader)
    if err != nil {
        return "", err
    }
    return string(utf8Bytes), nil
}

func GetSubjectByMsg(msg *mail.Message) (string, error) {
    // 读取Header中的邮件主题
    subject, err := DecodeRFC2047String(msg.Header.Get("Subject"))
    if err != nil {
        return "", err
    }
    return subject, nil
}

func GetJsonByMsg(msg *mail.Message) (string, error) {
    // 读取Header并转换为JSON
    for k, v := range msg.Header {
        for kk, vv := range v {
            vvv, err := DecodeRFC2047String(vv)
            if err != nil {
                continue
            }
            msg.Header[k][kk] = vvv
        }
    }
    sJson, err := json.Marshal(msg.Header)
    if err != nil {
        return "", err
    }
    return string(sJson), nil
}

func GetBodyByMsg(msg *mail.Message, multipartBody []MsgPartBody, _ContentType string) ([]byte, error) {
    // 读取Data中的指定格式的内容，如果没有就返回空
    ContentType := msg.Header.Get("Content-Type")
    var err error
    var params map[string]string
    mediaType := ""
    if ContentType != "" {
        mediaType, params, err = mime.ParseMediaType(ContentType)
        if err != nil {
            return nil, err
        }
    }
    if mediaType == "" || mediaType == _ContentType {
        bodyBytes, err := ioutil.ReadAll(msg.Body)
        if err != nil {
            return nil, err
        }
        if encoding := msg.Header.Get("Content-Transfer-Encoding"); encoding == "base64" {
            dst := make([]byte, base64.StdEncoding.DecodedLen(len(bodyBytes)))
            _, err := base64.StdEncoding.Decode(dst, bodyBytes)
            if err != nil {
                return nil, err
            }
            return dst, nil
        }

        if params["charset"] != "" {
            //log.Println(params["charset"])
            // 将字节数组转换为UTF-8编码的字符串
            reader := strings.NewReader(string(bodyBytes))
            utf8Reader, err := charset.NewReaderLabel(params["charset"], reader)
            if err != nil {
                return nil, err
            }
            utf8Bytes, err := ioutil.ReadAll(utf8Reader)
            if err != nil {
                return nil, err
            }
            return utf8Bytes, nil
        }

        return bodyBytes, nil
    }
    body, err := GetBodyByMsgPartBodys(multipartBody, _ContentType)
    if err != nil {
        return nil, err
    }
    return body, nil
}

type MsgPartBody struct {
    ContentType string
    Body        []byte
}

func GetMultipartBody(msg *mail.Message) ([]MsgPartBody, error) {
    // 一次性取得需要的MultipartBody
    // 解析Multipart格式的邮件，并存入[]MsgPartBody数组
    bodys := []MsgPartBody{}
    mediaType, params, err := mime.ParseMediaType(msg.Header.Get("Content-Type"))
    if err != nil {
        return bodys, nil
    }
    if !strings.HasPrefix(mediaType, "multipart/") {
        return bodys, nil
    }
    mr := multipart.NewReader(msg.Body, params["boundary"])
    for {
        part, err := mr.NextPart()
        if err == io.EOF {
            break
        }
        if err != nil {
            return nil, err
        }
        partMediaType, _, err := mime.ParseMediaType(part.Header.Get("Content-Type"))
        if err != nil {
            continue
        }
        partBytes, err := ioutil.ReadAll(part)
        if err != nil {
            return nil, err
        }
        if encoding := part.Header.Get("Content-Transfer-Encoding"); encoding == "base64" {
            dst := make([]byte, base64.StdEncoding.DecodedLen(len(partBytes)))
            _, err := base64.StdEncoding.Decode(dst, partBytes)
            if err != nil {
                return nil, err
            }
            bodys = append(bodys, MsgPartBody{ContentType: partMediaType, Body: dst})
        }
        bodys = append(bodys, MsgPartBody{ContentType: partMediaType, Body: partBytes})

    }
    return bodys, nil
}

func GetBodyByMsgPartBodys(bodys []MsgPartBody, ContentType string) ([]byte, error) {
    // 从一次性取得并解析好的[]MsgPartBody获取邮件内容
    for _, v := range bodys {
        if v.ContentType == ContentType {
            return v.Body, nil
        }
    }
    return nil, nil
}

 

 

然后编译