【Go学习实战】03-2-博客查询及登录

读取数据库数据

因为我们之前的数据都是假数据，但是真实的场景都是真数据，需要从数据库查询出来的，所以我们需要进行数据库的操作。

初始化数据库

导入sql文件，创建我们的数据库

之后配置我们的mysql，创建dao/mysql.go，注意这里配置自己的用户名密码及ip和端口

package dao

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"log"
	"net/url"
	"time"
)

var DB *sql.DB
func init()  {
	//执行main之前 先执行init方法
	dataSourceName := fmt.Sprintf("root:mysql@tcp(192.168.101.68:3306)/goblog?charset=utf8&loc=%s&parseTime=true",url.QueryEscape("Asia/Shanghai"))
	db, err := sql.Open("mysql", dataSourceName)
	if err != nil {
		log.Println("连接数据库异常")
		panic(err)
	}
	//最大空闲连接数，默认不配置，是2个最大空闲连接
	db.SetMaxIdleConns(5)
	//最大连接数，默认不配置，是不限制最大连接数
	db.SetMaxOpenConns(100)
	// 连接最大存活时间
	db.SetConnMaxLifetime(time.Minute * 3)
	//空闲连接最大存活时间
	db.SetConnMaxIdleTime(time.Minute * 1)
	err = db.Ping()
	if err != nil {
		log.Println("数据库无法连接")
		_ = db.Close()
		panic(err)
	}
	DB = db
}

首页真实数据

为了符合现在主流的MVC的架构，我们也是三层架构，dao层负责与数据库打交道，service层负责业务的具体逻辑

创建service文件夹

分类查询

创建分类查询的dao层，创建dao/category.go，负责分类查询的项目

package dao

import (
	"log"
	"myWeb/models"
)

func GetAllGategory() ([]models.Category, error) {
	row, err := DB.Query("select * from category")
	if err != nil {
		log.Println("查询分类异常")
		return nil, err
	}
	defer row.Close()
	var categorys []models.Category
	for row.Next() {
		var category models.Category
		err := row.Scan(&category.Cid, &category.Name, &category.CreateAt, &category.UpdateAt)
		if err != nil {
			log.Println("查询分类异常")
			return nil, err
		}
		categorys = append(categorys, category)
	}
	return categorys, nil
}

这样查询分类的时候就可以直接通过dao层来获取分类类别

categorys, err := dao.GetAllGategory()

在模板中添加一个统一的报错处理WriteError

func (t *TemplateBlog) WriteError(w io.Writer, err error) {
	if err != nil {
		log.Println(err)
		_, err := w.Write([]byte(err.Error()))
		if err != nil {
			log.Println(err)
			return
		}
	}
}

func (t *TemplateBlog) WriteData(w io.Writer, data interface{}) {
	err := t.Execute(w, data)
	if err != nil {
		t.WriteError(w, err)
	}
}

其他层调用service查询index页面则也可以调用service层

func (api *HTMLApi) Index(w http.ResponseWriter, r *http.Request) {
    index := common.Template.Index
    hr, err := service.GetAllIndexInfo()
    if err != nil {
       log.Printf("查询Index信息异常：%v", err)
       index.WriteError(w, errors.New("查询Index信息异常,请联系管理员"))
    }
    index.WriteData(w, hr)
}

分类查询测试

重启后发现我们的左下角多了个分类，说明我们写的没有问题

文章查询

因为文章可能有很多，所以我们要先分析下表单，然后拿到我们的分页参数

func (*HTMLApi) Index(w http.ResponseWriter, r *http.Request) {
	index := common.Template.Index

	err := r.ParseForm()
	if err != nil {
		log.Printf("解析请求参数异常：%v", err)
		index.WriteError(w, errors.New("解析请求参数异常,请联系管理员"))
		return
	}
	//获取分页信息
	pageStr := r.Form.Get("page")
	page := 1
	if pageStr != "" {
		page, _ = strconv.Atoi(pageStr)
	}
	//获取每页显示的条数
	limitStr := r.Form.Get("limit")
	limit := 10
	if limitStr != "" {
		limit, _ = strconv.Atoi(limitStr)
	}

	hr, err := service.GetAllIndexInfo(page, limit)
	if err != nil {
		log.Printf("查询Index信息异常：%v", err)
		index.WriteError(w, errors.New("查询Index信息异常,请联系管理员"))
	}

	index.WriteData(w, hr)
}

这样获取到分页信息就可以传入到GetAllIndexInfo进行分页查询了

创建dao/article.go

package dao

import "myWeb/models"

func GetPostArticlePage(page, limit int) ([]models.Post, error) {
	row, err := DB.Query("select * from blog_post limit ?,?", (page-1)*limit, limit)
	if err != nil {
		return nil, err
	}
	defer row.Close()
	var posts []models.Post
	for row.Next() {
		var post models.Post
		err := row.Scan(&post.Pid, &post.Title, &post.Content, &post.Markdown, &post.CategoryId, &post.UserId, &post.ViewCount, &post.Type, &post.Slug, &post.CreateAt, &post.UpdateAt)
		if err != nil {
			return nil, err
		}
		posts = append(posts, post)
	}
	return posts, nil
}

因为我们返回的是post类型，而要求返回的是postMore类型，包含用户id等等，所以我们在service层还需要组装一下postMore

中间因为还要查询用户名称及分类名称所以我们先在dao层补全

创建dao/user.go#GetUserNameById

func GetUserNameById(uid int) string {
	var name string
	err := DB.QueryRow("SELECT user_name FROM blog_user WHERE uid = ?", uid).Scan(&name)
	if err != nil {
		if err == sql.ErrNoRows {
			log.Printf("未找到用户ID %d 的用户名", uid)
			return ""
		}
		log.Printf("查询用户名异常：%v", err)
		return ""
	}
	return name
}

在dao/category.go创建

func GetCategoryNameById(cid int) string {
	var name string
	err := DB.QueryRow("SELECT name FROM blog_category WHERE cid = ?", cid).Scan(&name)
	if err != nil {
		if err == sql.ErrNoRows {
			log.Printf("未找到分类 ID %d 的名称", cid)
			return ""
		}
		log.Printf("查询分类名称异常：%v", err)
		return ""
	}
	return name
}

组装PostMore

var postMores []models.PostMore
for _, post := range posts {
    categoryName := dao.GetCategoryNameById(post.CategoryId)
    userName := dao.GetUserNameById(post.UserId)
    content := []rune(post.Content)
    if len(content) > 100 {
       content = content[0:100]
    }
    postMore := models.PostMore{
       post.Pid,
       post.Title,
       post.Slug,
       template.HTML(content),
       post.CategoryId,
       categoryName,
       post.UserId,
       userName,
       post.ViewCount,
       post.Type,
       models.DateDay(post.CreateAt),
       models.DateDay(post.UpdateAt),
    }
    postMores = append(postMores, postMore)
}

因为最后返回的hr中还有总数及是否为当前页，因此这些也要进行准备

获取文章总页数

func CountGetAllPost() int {
	var count int
	err := DB.QueryRow("SELECT COUNT(1) FROM blog_post").Scan(&count)
	if err != nil {
		log.Printf("查询文章总数失败: %v", err)
		return 0
	}
	return count
}

调用获取文章总数及分页相关

total := dao.CountGetAllPost()
pagesCount := (total-1)/10 + 1
var pages []int
for i := 0; i < pagesCount; i++ {
    pages = append(pages, i+1)
}

package service

import (
	"html/template"
	"ms-go-blog/config"
	"ms-go-blog/dao"
	"ms-go-blog/models"
)

func GetAllIndexInfo(page,pageSize int)  (*models.HomeResponse,error){
	categorys,err := dao.GetAllCategory()
	if err != nil {
		return nil, err
	}
	posts,err := dao.GetPostPage(page,pageSize)
	var postMores []models.PostMore
	for _,post := range posts{
		categoryName := dao.GetCategoryNameById(post.CategoryId)
		userName := dao.GetUserNameById(post.UserId)
		content := []rune(post.Content)
		if len(content) > 100 {
			content = content[0:100]
		}
		postMore := models.PostMore{
			 post.Pid,
			 post.Title,
			 post.Slug,
			 template.HTML(content),
			 post.CategoryId,
			 categoryName,
			 post.UserId,
			 userName,
			 post.ViewCount,
			 post.Type,
			 models.DateDay(post.CreateAt),
			 models.DateDay(post.UpdateAt),
		 }
		 postMores = append(postMores,postMore)
	}
	//11  10 2  10 1 9 1  21 3
	//  (11-1)/10 + 1 = 2
	total := dao.CountGetAllPost()
	pagesCount := (total-1)/limit + 1
	var pages []int
	for i := 0; i < pagesCount; i++ {
		pages = append(pages, i+1)
	}
	var hr = &models.HomeResponse{
		config.Cfg.Viewer,
		categorys,
		postMores, //文章
		total,     //文章总数
		page,      //当前页
		pages,     //页码,两页就是[]int{1,2}
		page != pagesCount,	//是否有下一页
	}
	return hr,nil
}

文章查询测试

分类文章列表

因为我们请求分类文章列表的url路径是http://localhost:8080/c/1，所以我们也要对其进行相对应的路由，1是参数，代表分类的id，就需要把这个id取出来

在router.go中，我们用Category页面来匹配对应的逻辑和/c/路径

http.HandleFunc("/c/", views.HTML.Category)

我们所有的页面和逻辑都在views中，所以创建views/category.go

package views

import (
	"errors"
	"log"
	"myWeb/common"
	"myWeb/service"
	"net/http"
	"strconv"
	"strings"
)

func (*HTMLApi) Category(w http.ResponseWriter, r *http.Request) {
	categoryTemplate := common.Template.Category
	//http://localhost:8080/c/1  1参数 分类的id
	path := r.URL.Path
	cIdStr := strings.TrimPrefix(path, "/c/")
	cId, err := strconv.Atoi(cIdStr)
	if err != nil {
		categoryTemplate.WriteError(w, errors.New("不识别此请求路径"))
		return
	}
	if err := r.ParseForm(); err != nil {
		log.Println("表单获取失败：", err)
		categoryTemplate.WriteError(w, errors.New("系统错误，请联系管理员!!"))
		return
	}
	pageStr := r.Form.Get("page")
	if pageStr == "" {
		pageStr = "1"
	}
	page, _ := strconv.Atoi(pageStr)
	//每页显示的数量
	pageSize := 10
	categoryResponse, err := service.GetPostsByCategoryId(cId, page, pageSize)
	if err != nil {
		categoryTemplate.WriteError(w, err)
		return
	}
	categoryTemplate.WriteData(w, categoryResponse)
}

在对应的接口也要添加上方法

type HTMLRenderer interface {
	Index(w http.ResponseWriter, r *http.Request)
	Category(w http.ResponseWriter, r *http.Request)
}

观察我们的category.html，相比于index.html多了个{{.CategoryName}}，因此我们的model也得相应的多一个

type CategoryResponse struct {
	*HomeResponse
	CategoryName string
}

业务service层也要加上对应的逻辑，创建service/category.go，返回值自然是我们刚刚创建的那个类型

package service

import (
	"log"
	"myWeb/dao"
	"myWeb/models"
)

func GetPostsByCategoryId(cId, page, pageSize int) ([]models.Post, error) {
	posts, err := dao.GetPostPageByCategoryId(cId, page, pageSize)
	if err != nil {
		log.Printf("查询分类ID %d 文章失败: %v", cId, err)
		return nil, err
	}
	return posts, nil
}

查询分类名称逻辑

func GetCategoryNameById(cid int) string {
	var name string
	err := DB.QueryRow("SELECT name FROM blog_category WHERE cid = ?", cid).Scan(&name)
	if err != nil {
		if err == sql.ErrNoRows {
			log.Printf("未找到分类 ID %d 的名称", cid)
			return ""
		}
		log.Printf("查询分类名称异常：%v", err)
		return ""
	}
	return name
}

我们的数据也应该按照分类id进行查询

func CountGetAllPostByCategoryId(cId int) (count int) {
	err := DB.QueryRow("SELECT COUNT(1) FROM blog_post WHERE category_id = ?", cId).Scan(&count)
	if err != nil {
		log.Printf("查询文章总数失败: %v", err)
		return 0
	}
	return count
}

func GetPostPageByCategoryId(cId, page, pageSize int) ([]models.Post, error) {
	page = (page - 1) * pageSize
	rows, err := DB.Query("select * from blog_post where category_id = ? limit ?,?", cId, page, pageSize)
	if err != nil {
		return nil, err
	}
	var posts []models.Post
	for rows.Next() {
		var post models.Post
		err := rows.Scan(
			&post.Pid,
			&post.Title,
			&post.Content,
			&post.Markdown,
			&post.CategoryId,
			&post.UserId,
			&post.ViewCount,
			&post.Type,
			&post.Slug,
			&post.CreateAt,
			&post.UpdateAt,
		)
		if err != nil {
			return nil, err
		}
		posts = append(posts, post)
	}
	return posts, nil
}

接下来就是组装数据了，HomeResponse和index中类似，我们只需要组装上CategoryName就可以了

package service

import (
	"html/template"
	"log"
	"myWeb/config"
	"myWeb/dao"
	"myWeb/models"
)

func GetPostsByCategoryId(cId, page, pageSize int) (*models.CategoryResponse, error) {
	categorys, err := dao.GetAllCategory()
	if err != nil {
		log.Println("查询分类异常")
		return nil, err
	}
	posts, err := dao.GetPostPageByCategoryId(cId, page, pageSize)
	if err != nil {
		log.Println("查询文章异常")
		return nil, err
	}

	var postMores []models.PostMore
	for _, post := range posts {
		categoryName := dao.GetCategoryNameById(post.CategoryId)
		userName := dao.GetUserNameById(post.UserId)
		content := []rune(post.Content)
		if len(content) > 100 {
			content = content[0:100]
		}
		postMore := models.PostMore{
			post.Pid,
			post.Title,
			post.Slug,
			template.HTML(content),
			post.CategoryId,
			categoryName,
			post.UserId,
			userName,
			post.ViewCount,
			post.Type,
			models.DateDay(post.CreateAt),
			models.DateDay(post.UpdateAt),
		}
		postMores = append(postMores, postMore)
	}

	total := dao.CountGetAllPostByCategoryId(cId)
	pagesCount := (total-1)/pageSize + 1
	var pages []int
	for i := 0; i < pagesCount; i++ {
		pages = append(pages, i+1)
	}

	var hr = &models.HomeResponse{
		config.Cfg.Viewer,
		categorys,
		postMores,          //文章
		total,              //文章总数
		page,               //当前页
		pages,              //页码,两页就是[]int{1,2}
		page != pagesCount, //是否有下一页
	}

	categoryName := dao.GetCategoryNameById(cId)

	var categoryResponse = &models.CategoryResponse{
		hr,
		categoryName,
	}
	return categoryResponse, nil

}

测试

重启页面

go分类

java分类

总条数也是正确的。

登录功能

当我们点击登录按钮，请求路径为http://localhost:8080/login，那么我们就要对这个路径进行路由映射

用户登录后，可以进行文章的编写，修改，以及删除

自然在router.go中进行路由

http.HandleFunc("/login/", views.HTML.Login)

登录页面

创建views/login.go，完善views的接口，我们login中需要的信息就是config中配的viewer的信息

package views

import (
	"myWeb/common"
	"myWeb/config"
	"net/http"
)

func (*HTMLApi) Login(w http.ResponseWriter, r *http.Request) {
	login := common.Template.Login

	login.WriteData(w, config.Cfg.Viewer)
}

type HTMLRenderer interface {
	Index(w http.ResponseWriter, r *http.Request)
	Category(w http.ResponseWriter, r *http.Request)
	Login(w http.ResponseWriter, r *http.Request)
}

这样我们的登录页面就做好了，点击登录发起的请求为http://localhost:8080/api/v1/login，发起的是POST请求，有两个参数，一个是passwd，一个是username

查看js中的返回逻辑

$(".login-submint").click(function () {
  var tipEle = $(".login-tip");
  var name = $(".login-name").val();
  var passwd = $(".login-passwd").val();
  if (!name) return tipEle.show().text("请输入用户名");
  if (!passwd) return tipEle.show().text("请输入密码");

  // md5加密
  var MD5Passwd = new Hashes.MD5().hex(passwd + SALT);
  $.ajax({
    url: "/api/v1/login",
    data: JSON.stringify({ username: name, passwd: MD5Passwd }),
    contentType: "application/json",
    type: "POST",
    success: function (res) {
        if (res.code !== 200) {
          return tipEle.show().text(res.error);
        }
        var data = res.data || {};
        localStorage.setItem(TOKEN_KEY, data.token);
        localStorage.setItem(USER_KEY, JSON.stringify(data.userInfo));
        location.href = "/";
    },
    error: function (err) {
      console.log("err", err);
      tipEle.show().text("登录错误，请重试");
    },
  });
});

如果返回是200，就会把token和用户信息保存在localStorage中，并且用location.href = "/";跳转到首页

登录接口

点击登录发起的请求为http://localhost:8080/api/v1/login，发起的是POST请求，有两个参数，一个是passwd，一个是username，我们自然也要进行路由

http.HandleFunc("/api/v1/login", api.API.Login)

因为是要返回请求，不再是页面了，所以我们用api返回，创建api/login.go

package api

import "net/http"

func (*Api) Login(w http.ResponseWriter, r *http.Request) {

}

完善api接口

type APIResponder interface {
    SaveAndUpdatePost(w http.ResponseWriter, r *http.Request)
    Login(w http.ResponseWriter, r *http.Request)
}

因为我们一般返回值有三个，code、date、err，所以我们在model中也要创建对应的基本返回值，创建models/result.go

package models

type Result struct {
	Code int         `json:"code"`
	Data interface{} `json:"data"`
	Error string       `json:"error"`
}

那么我们login返回的时候返回的是result类型，我们所有api返回的时候都会这么组装数据，所以就可以把这样的操作放在common中

成功返回

func SuccessResult(w http.ResponseWriter, data interface{}) {
    var result models.Result
    result.Code = 200
    result.Error = ""
    result.Data = data
    resultJson, _ := json.Marshal(result)
    w.Header().Set("Content-Type", "application/json")
    _, err := w.Write(resultJson)
    if err != nil {
       log.Printf("返回数据失败：%v", err)
       return
    }
}

那么在api/login.go中，我们只需要调用SuccessResult并且返回data就可以，那么怎么获取data呢，我们就要从POST请求中找到我们的两个参数，一个是passwd，一个是username，但是因为是POST请求，不能像GET一样直接从url中取

获取json参数

因为是一个公共方法，我们写在common中

func GetRequestJsonParam(r *http.Request) (map[string]interface{}, error) {
	var params map[string]interface{}
	// 使用 json.NewDecoder 来逐步解码请求体
	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&params)
	if err != nil {
		log.Printf("解析请求参数失败：%v", err)
		return nil, err
	}
	return params, nil
}

自然解析的时候就会解析出来json参数，我们注意到最后的data有两部分组成，一个是token，一个是userInfo，我们也要封装一下到model中

先是userInfo

package models

import "time"

type User struct {
	Uid      int       `json:"uid"`
	Username string    `json:"userName"`
	Password string    `json:"passwd"`
	Avatar   string    `json:"avatar"`
	CreatAt  time.Time `json:"creatAt"`
	UpdateAt time.Time `json:"updateAt"`
}

type UserInfo struct {
	Uid      int    `json:"uid"`
	Username string `json:"userName"`
	Avatar   string `json:"avatar"`
}

再是LoginRes

type LoginRes struct {
	Token    string   `json:"token"`
	UserInfo UserInfo `json:"userInfo"`
}

我们在service进行实现，实现事前我们需要对用户名和密码做匹配所以先查数据库

func GetUser(userName string, passwd string) models.User {
	var user models.User
	err := DB.QueryRow("SELECT uid, user_name, passwd, avatar, creat_at, update_at FROM blog_user WHERE user_name = ? AND passwd = ?", userName, passwd).Scan(&user.Uid, &user.Username, &user.Password, &user.Avatar, &user.CreatAt, &user.UpdateAt)
	if err != nil {
		if err == sql.ErrNoRows {
			log.Printf("未找到用户 %s", userName)
			return models.User{}
		}
		log.Printf("查询用户异常：%v", err)
		return models.User{}
	}
	return user
}

这样调用的时候

func (*Api) Login(w http.ResponseWriter, r *http.Request) {
	params, err := common.GetRequestJsonParam(r)
	if err != nil {
		log.Printf("解析请求参数异常：%v", err)
		return
	}
	userName := params["username"].(string)
	passwd := params["passwd"].(string)
	data,err := service.Login(userName, passwd)
	if err != nil {
		log.Printf("登录异常：%v", err)
		common.ErrorResult(w, err)
		return
	}
	common.SuccessResult(w, data)
}

common.ErrorResult返回

func ErrorResult(w http.ResponseWriter, err error) {
	var result models.Result
	result.Code = 500
	result.Error = err.Error()
	result.Data = nil
	resultJson, _ := json.Marshal(result)
	w.Header().Set("Content-Type", "application/json")
	_, err = w.Write(resultJson)
	if err != nil {
		log.Printf("返回数据失败：%v", err)
		return
	}
}

登录失败测试

符合我们的预期

md5加密

我们对密码进行加密后进行比对，这些放在工具类utils中

package utils

import (
	"crypto/md5"
	"fmt"
	"strings"
)

//给字符串生成md5
//@params str 需要加密的字符串
//@params salt interface{} 加密的盐
//@return str 返回md5码
func Md5Crypt(str string, salt ...interface{}) (CryptStr string) {
	if l := len(salt); l > 0 {
		slice := make([]string, l+1)
		str = fmt.Sprintf(str+strings.Join(slice, "%v"), salt...)
	}
	return fmt.Sprintf("%x", md5.Sum([]byte(str)))
}

这样我们调用的时候再加一次盐，这样更加安全

func Login(userName, passwd string) (*models.LoginRes, error) {
	passwd = utils.Md5Crypt(passwd, "mszlu")
	user := dao.GetUser(userName, passwd)
	if user == nil {
		return nil, errors.New("用户名或密码错误")
	}
	var lr = &models.LoginRes{}
	return lr, nil
}

我们最后返回还有个token，这个是jwt令牌里的所以我们也要用jwt令牌

jwt工具

package utils

import (
	gojwt "github.com/dgrijalva/jwt-go"
	"os"
	"time"
)

var jwtKey []byte

func init() {
	jwtKey = []byte(os.Getenv("JWT_SECRET"))
}

type Claims struct {
	Uid int
	gojwt.StandardClaims
}

// 生成Token
func Award(uid *int) (string, error) {
	// 过期时间 默认7天
	expireTime := time.Now().Add(7 * 24 * time.Hour)
	claims := &Claims{
		Uid: *uid,
		StandardClaims: gojwt.StandardClaims{
			ExpiresAt: expireTime.Unix(),
			IssuedAt:  time.Now().Unix(),
		},
	}
	// 生成token
	token := gojwt.NewWithClaims(gojwt.SigningMethodHS256, claims)
	tokenStr, err := token.SignedString(jwtKey)
	if err != nil {
		return "", err
	}
	return tokenStr, nil
}

// 解析token
func ParseToken(tokenStr string) (*gojwt.Token, *Claims, error) {
	claims := &Claims{}
	token, err := gojwt.ParseWithClaims(tokenStr, claims, func(t *gojwt.Token) (interface{}, error) {
		return jwtKey, nil
	})
	if err != nil {
		return nil, nil, err
	}
	return token, claims, err
}

登录成功测试

我们可以看到我们的token由三部分构成，头部、载荷、签名

文章详情

我们随便点击一个文章，请求路径为http://localhost:8080/p/7.html，那么我们就要对这个路径进行路由映射

与获取分类文章列表类似，这里就不赘述了

views/detail.go

package views

import (
	"errors"
	"myWeb/common"
	"myWeb/service"
	"net/http"
	"strconv"
	"strings"
)

func (*HTMLApi) Detail(w http.ResponseWriter, r *http.Request) {
	detail := common.Template.Detail
	//http://localhost:8080/p/7.html  7参数 文章的id
	path := r.URL.Path
	pIdStr := strings.TrimPrefix(path, "/p/")
	//7.html
	pIdStr = strings.TrimSuffix(pIdStr, ".html")
	pid, err := strconv.Atoi(pIdStr)
	if err != nil {
		detail.WriteError(w, errors.New("不识别此请求路径"))
		return
	}
	postRes, err := service.GetPostDetail(pid)
	if err != nil {
		detail.WriteError(w, errors.New("查询出错"))
		return
	}
	detail.WriteData(w, postRes)
}

service/detail.go

func GetPostDetail(pid int) (*models.PostRes, error) {
    post, err := dao.GetPostById(pid)
    if err != nil {
       return nil, err
    }
    categoryName := dao.GetCategoryNameById(post.CategoryId)
    userName := dao.GetUserNameById(post.UserId)
    postMore := models.PostMore{
       post.Pid,
       post.Title,
       post.Slug,
       template.HTML(post.Content),
       post.CategoryId,
       categoryName,
       post.UserId,
       userName,
       post.ViewCount,
       post.Type,
       models.DateDay(post.CreateAt),
       models.DateDay(post.UpdateAt),
    }
    var postRes = &models.PostRes{
       config.Cfg.Viewer,
       config.Cfg.System,
       postMore,
    }
    return postRes, nil
}

dao层查询

func GetPostById(pid int) (*models.Post, error) {
    row := DB.QueryRow("select * from blog_post where pid = ?", pid)
    var post models.Post
    err := row.Scan(&post.Pid, &post.Title, &post.Content, &post.Markdown, &post.CategoryId, &post.UserId, &post.ViewCount, &post.Type, &post.Slug, &post.CreateAt, &post.UpdateAt)
    if err != nil {
       return nil, err
    }
    return &post, nil
}

测试

成功