$ go get -u github.com/robfig/cron

// 首先我们在 model 上加上 硬删除 接口
func CleanAllTag() bool {
	db.Unscoped().Where("deleted_on != ? ", 0).Delete(&Tag{})
 
	return true
}
 
func CleanAllArticle() bool {
	db.Unscoped().Where("deleted_on != ? ", 0).Delete(&Article{})
 
	return true
}
 
// 然后我们写一个job 
 
func main() {
	log.Println("Starting...")
 
	c := cron.New()
    // 会根据本地时间创建一个新（空白）的 Cron job runner
    // 建议使用  c := cron.New(cron.WithSeconds())，它能支持 秒级别 的job
 
    // 加一个job fn 他会 以按给定的时间表运行，这里我们直接传递匿名的fn
	c.AddFunc("* * * * * *", func() {
		log.Println("Run models.CleanAllTag...")
		models.CleanAllTag()
	})
	c.AddFunc("* * * * * *", func() {
		log.Println("Run models.CleanAllArticle...")
		models.CleanAllArticle()
	})
 
    // 启动
	c.Start()
	// 模拟了一个 堵塞的效果
 
    // 下面的代码 如果有js的来表示就是 setInterval(fn, 1000)
    // 1.会创建一个新的定时器，持续你设定的时间 d 后发送一个 channel 消息
	t1 := time.NewTimer(time.Second * 10)
    // 2. 阻塞 select 等待 channel
	for {
		select {
		case <-t1.C:
            // 会重置定时器，让它重新开始计时
            // t1.c 已经取走 ，重新reset
			t1.Reset(time.Second * 10)
		}
	}
}

// 首先我们要获取到文件，我们有两种 一种是 一个http携带来多个文件，一个是http携带一份文件
// 注意 都要求请求是 form-data 的格式
 
// 单文件
// 为 multipart forms 设置较低的内存限制 (默认是 32 MiB)
func main() {
	router := gin.Default()
	
    // 为 multipart forms 设置较低的内存限制 (默认是 32 MiB)
	router.MaxMultipartMemory = 8 << 20  // 8 MiB
	router.POST("/upload", func(c *gin.Context) {
		// 单文件
		file, _ := c.FormFile("file") // 直接从formfile 上取
		log.Println(file.Filename)
 
		dst := "./" + file.Filename // 上传文件至指定的完整文件路径
		c.SaveUploadedFile(file, dst) // 保存到某路径下
 
		c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
	})
	router.Run(":8080")
}
 
// 多文件
func main() {
	router := gin.Default()
	// 为 multipart forms 设置较低的内存限制 (默认是 32 MiB)
	router.MaxMultipartMemory = 8 << 20  // 8 MiB
	router.POST("/upload", func(c *gin.Context) {
		// Multipart form
		form, _ := c.MultipartForm()
		files := form.File["upload[]"]
 
		for _, file := range files {
			log.Println(file.Filename)
 
			// 上传文件至指定目录
			c.SaveUploadedFile(file, dst)
		}
		c.String(http.StatusOK, fmt.Sprintf("%d files uploaded!", len(files)))
	})
	router.Run(":8080")
}

// 在gin中设置这样的东西，非常的简单， 假设我们的文件都上传到了 /assets 下
 
func main() {
	router := gin.Default()
	router.Static("/assets", "./assets")
	router.StaticFS("/more_static", http.Dir("my_file_system"))
	router.StaticFile("/favicon.ico", "./resources/favicon.ico")
	// 如果你感兴趣 可深入看看里面的实现
    
    
	// 监听并在 0.0.0.0:8080 上启动服务
	router.Run(":8080")
}
 
 
 

// 首先我们取参数的
 
func UploadImage(c *gin.Context) {
	code := e.SUCCESS
	data := make(map[string]string)
 
	file, image, err := c.Request.FormFile("image") // 读取form-data中的数据
	
    if err != nil {
		logging.Warn(err)
		code = e.ERROR
		c.JSON(http.StatusOK, gin.H{
			"code": code,
			"msg":  e.GetMsg(code),
			"data": data,
		})
	}
 
	if image == nil {
		code = e.INVALID_PARAMS
	} else {
		// 合法图片将会进行 下一步的处理
		imageName := upload.GetImageName(image.Filename)
		fullPath := upload.GetImageFullPath()
		savePath := upload.GetImagePath()
 
		src := fullPath + imageName
		if !upload.CheckImageExt(imageName) || !upload.CheckImageSize(file) {
			code = e.ERROR_UPLOAD_CHECK_IMAGE_FORMAT
		} else {
			err := upload.CheckImage(fullPath)
			if err != nil {
				logging.Warn(err)
				code = e.ERROR_UPLOAD_CHECK_IMAGE_FAIL
				// gin能够通过这个方法的调用 进行保存  这几个方法调用成功就存上了
			} else if err := c.SaveUploadedFile(image, src); err != nil {
				logging.Warn(err)
				code = e.ERROR_UPLOAD_SAVE_IMAGE_FAIL
			} else {
				data["image_url"] = upload.GetImageFullUrl(imageName)
				data["image_save_url"] = savePath + imageName
			}
		}
	}
 
	c.JSON(http.StatusOK, gin.H{
		"code": code,
		"msg":  e.GetMsg(code),
		"data": data,
	})
}
 
main.go
++++
	r.POST("/upload", api.UploadImage) // 上传图片
 
++++
 
// 存储的时候 编写一些 对文件操作的pkg 工具包
// 获取图片完整访问 URL
func GetImageFullUrl(name string) string {
    // 注意，我们可以设置一个 上传存储路径也可以不设置，随你好啦
	return setting.AppSetting.ImagePrefixUrl + "/" + GetImagePath() + name
}
 
 
func GetImageName(name string) string {
	ext := path.Ext(name)
	fileName := strings.TrimSuffix(name, ext)
	fileName = util.EncodeMD5(fileName)
 
	return fileName + ext
}
 
func GetImagePath() string {
	return setting.AppSetting.ImageSavePath
}
 
func GetImageFullPath() string {
	return setting.AppSetting.RuntimeRootPath + GetImagePath()
}
 
// 检查图片后缀
func CheckImageExt(fileName string) bool {
	ext := file.GetExt(fileName)
	for _, allowExt := range setting.AppSetting.ImageAllowExts {
		if strings.ToUpper(allowExt) == strings.ToUpper(ext) {
			return true
		}
	}
 
	return false
}
 
func CheckImageSize(f multipart.File) bool {
	size, err := file.GetSize(f)
	if err != nil {
		log.Println(err)
		logging.Warn(err)
		return false
	}
 
	return size <= setting.AppSetting.ImageMaxSize
}
 
// 检查图片 是否合法
func CheckImage(src string) error {
	dir, err := os.Getwd()
	if err != nil {
		return fmt.Errorf("os.Getwd err: %v", err)
	}
 
	err = file.IsNotExistMkDir(dir + "/" + src)
	if err != nil {
		return fmt.Errorf("file.IsNotExistMkDir err: %v", err)
	}
 
	perm := file.CheckPermission(src)
	if perm == true {
		return fmt.Errorf("file.CheckPermission Permission denied src: %s", src)
	}
 
	return nil
}
 
// 需要重命名 用md5 转一下
package util
import (
	"crypto/md5"
	"encoding/hex"
)
func EncodeMD5(value string) string {
	m := md5.New()
	m.Write([]byte(value))
	return hex.EncodeToString(m.Sum(nil))
}
 
 
// 访问的时候要路径就好啦
r.StaticFS("/upload/images", http.Dir(upload.GetImageFullPath())) // 路径静态资源访问支持 ，每个静态资源访问都需要独立去控制

你的配置要加上 redis 哈
[redis]
Host = 127.0.0.1:6379
Password =
MaxIdle = 30
MaxActive = 30
IdleTimeout = 200

go get github.com/garyburd/redigo/redis

package gredis
 
import (
	"encoding/json"
	"time"
 
	"github.com/BM-laoli/go-gin-example/pkg/setting"
	"github.com/garyburd/redigo/redis"
)
 
var RedisConn *redis.Pool
// 链接池 句柄
 
func Setup() error {
    // 开始设置 链接参数 
	RedisConn = &redis.Pool{
		MaxIdle:     setting.RedisSetting.MaxIdle, 
		MaxActive:   setting.RedisSetting.MaxActive,
		IdleTimeout: setting.RedisSetting.IdleTimeout,
    	// 最大空闲链接数、在给定时间内允许非配的最大链接数=0 = 无限制
        // 在给定时间内会保持空链接，如果达到时间就关闭链接
        
        Dial: func() (redis.Conn, error) {
            // 提供创建和配置应用程序连接的一个函数 cb
			c, err := redis.Dial("tcp", setting.RedisSetting.Host)
			if err != nil {
				return nil, err
			}
			if setting.RedisSetting.Password != "" {
				if _, err := c.Do("AUTH", setting.RedisSetting.Password); err != nil {
					c.Close()
					return nil, err
				}
			}
			return c, err
		},
		TestOnBorrow: func(c redis.Conn, t time.Time) error {
            // 可选的应用程序检查健康功能 cb
			_, err := c.Do("PING")
			return err
		},
	}
 
	return nil
}
 
func Set(key string, data interface{}, time int) error {
	conn := RedisConn.Get() // 在连接池中获取一个活跃连接
	defer conn.Close()
 
	value, err := json.Marshal(data)
	if err != nil {
		return err
	}
 
    // 向 Redis 服务器发送命令并返回收到的答复
	_, err = conn.Do("SET", key, value)
	if err != nil {
		return err
	}
 
	_, err = conn.Do("EXPIRE", key, time)
	if err != nil {
		return err
	}
 
	return nil
}
 
func Exists(key string) bool {
	conn := RedisConn.Get()
	defer conn.Close()
 
    // 将命令 返回转 为布尔值
	exists, err := redis.Bool(conn.Do("EXISTS", key))
	if err != nil {
		return false
	}
 
	return exists
}
 
func Get(key string) ([]byte, error) {
	conn := RedisConn.Get()
	defer conn.Close()
 
    // 将命令 返回 转为Bytes
	reply, err := redis.Bytes(conn.Do("GET", key))
	if err != nil {
		return nil, err
	}
 
	return reply, nil
}
 
func Delete(key string) (bool, error) {
	conn := RedisConn.Get()
	defer conn.Close()
 
	return redis.Bool(conn.Do("DEL", key))
}
 
func LikeDeletes(key string) error {
	conn := RedisConn.Get()
	defer conn.Close()
 
    // 将命令 返回 转为 []string
	keys, err := redis.Strings(conn.Do("KEYS", "*"+key+"*"))
	if err != nil {
		return err
	}
 
	for _, key := range keys {
		_, err = Delete(key)
		if err != nil {
			return err
		}
	}
 
	return nil
}
// 实际上你可以不用 封装 ，直接用 redigo 中提供的也可以，但是我们初学者还是要深挖一下哈
 
// 对于你读的时候 最好做容错然后 返回使用 bytes
 
	key := cache.GetArticleKey()
	if gredis.Exists(key) {
		data, err := gredis.Get(key)
		if err != nil {
			logging.Info("errerrerrerrerrerr")
		} else {
			json.Unmarshal(data, &cacheArticle)
			return cacheArticle, nil
		}
	}
 

// 生成token的地方要存入 key 和token 注意过期时间一定要 > jwt中设置的时间
var jwtSecret = []byte(configuration.AppSetting.JwtSecret)
 
type Claims struct {
	Username string `json:"username"`
	Password string `json:"password"`
	Uid      string
	jwt.StandardClaims
}
 
// 生成Token
func GenerateToken(username, password, uid string) (string, error) {
	nowTime := time.Now()
	expireTime := nowTime.Add(3 * time.Hour) // 设置过期时间
 
	claims := Claims{ // 准备把信息签名 jwt-go 提供
		username,
		password,
		uid,
		jwt.StandardClaims{
			ExpiresAt: expireTime.Unix(),
			Issuer:    "gin-blog",
		},
	}
 
	// SigningMethodHS256  + Secret加密
	tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	token, err := tokenClaims.SignedString(jwtSecret)
 
	return token, err
}
 
 
// 生产token并返回 类似于登录
func GetAuth(c *gin.Context) {
	var (
		appG = res.Gin{C: c}
		user dto.UserDto
	)
 
	httpCode, errCode := req.BindAndValidForJSON(c, &user)
	if errCode != error2.SUCCESS {
		appG.Response(httpCode, errCode, nil)
		return
	}
 
	authService := UserType{
		Username: user.Username,
		Password: user.Password,
	}
 
	// 1.把这个用户名的密码给找出来 从数据库
	// 2. 进行密码核对
	// 3. 若成功就下发token签名
 
	isValid, uid, _ := authService.VerifyUser()
 
	if !isValid {
		appG.Response(http.StatusInternalServerError, error2.ERROR_ADD_TAG_FAIL, nil)
		return
	}
 
	key := "uid_" + strconv.Itoa(uid)
 
	// 开始生产token
	token, err2 := GenerateToken(authService.Username, "", key)
	if err2 != nil {
		appG.Response(http.StatusInternalServerError, error2.ERROR_ADD_TAG_FAIL, nil)
		return
	}
 
	// 把user_id 作为key token 做value 存入redis
	core_redis.Set(key, token, 1800) // 注意这个时间需要 >= jwt_token 过期时间
 
	appG.Response(http.StatusOK, error2.SUCCESS, map[string]interface{}{
		"token": token,
	})
}
 
// jwt 中间件
func GenerateToken(username, password, uid string) (string, error) {
	nowTime := time.Now()
	expireTime := nowTime.Add(3 * time.Hour) // 设置过期时间
 
	claims := Claims{ // 准备把信息签名 jwt-go 提供
		username,
		password,
		uid,
		jwt.StandardClaims{
			ExpiresAt: expireTime.Unix(),
			Issuer:    "gin-blog",
		},
	}
 
	// SigningMethodHS256  + Secret加密
	tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	token, err := tokenClaims.SignedString(jwtSecret)
 
	return token, err
}
 

1、 proxy_pass：配置反向代理的路径。需要注意的是如果 proxy_pass 的 url 最后为 /，则表示绝对路径。否则（不含变量下）表示相对路径，所有的路径都会被代理过去
 
2、 upstream：配置负载均衡，upstream 默认是以轮询的方式进行负载，另外还支持四种模式，分别是：
 
（1）weight：权重，指定轮询的概率，weight 与访问概率成正比
 
（2）ip_hash：按照访问 IP 的 hash 结果值分配
 
（3）fair：按后端服务器响应时间进行分配，响应时间越短优先级别越高
 
（4）url_hash：按照访问 URL 的 hash 结果值分配
 

127.0.0.1 api.golang-laoli.com

worker_processes  1;
 
events {
    worker_connections  1024;
}
 
 
http {
    include       mime.types;
    default_type  application/octet-stream;
 
    sendfile        on;
    keepalive_timeout  65;
 
    upstream api.blog.com {
        server 127.0.0.1:8001;
        server 127.0.0.1:8002;
    }
 
    server {
        listen       8081;
        server_name  api.blog.com;
 
        location / {
            proxy_pass http://api.blog.com/;
        }
    }
}

$ nginx -t
nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful
$ nginx -s reload

 docker run --name mysql -p 3306:3306 -e 
   MYSQL_ROOT_PASSWORD=rootroot 
   -v /data/docker-mysql:/var/lib/mysql 
   -d mysql
 

FROM scratch 
# 载入一个空的初始化环境
 
WORKDIR $GOPATH/src/github.com/EDDYCJY/go-gin-example
# 把工作目录设置到 这个下面
COPY . $GOPATH/src/github.com/EDDYCJY/go-gin-example
# 复制源代码过去
 
 
EXPOSE 8000
# EXPOSE 指令是声明运行时容器提供服务端口，
# 这只是一个声明，在运行时并不会因为这个声明应用就会开启这个端口的服务
ENTRYPOINT ["./go-gin-example"]
 

CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o go-gin-example .
# 编译所生成的可执行文件会依赖一些库，并且是动态链接。
# 在这里因为使用的是 scratch 镜像，它是空镜像，
# 因此我们需要将生成的可执行文件静态链接所依赖的库

docker build -t gin-blog-docker-scratch .
 
# 注意哈，这个时候先不要着急去run ，你需要把这个容器 启动时候 和 mysql 的容器关联起来
# 增加命令 --link mysql:mysql 让 Golang 容器与 Mysql 容器互联；
# 通过 --link，可以在容器内直接使用其关联的容器别名进行访问，
# 而不通过 IP，但是--link只能解决单机容器间的关联，
# 在分布式多机的情况下，需要通过别的方式进行连接 比如zk config 上去配置ip等手段
 
docker run --link mysql:mysql -p 8000:8000 gin-blog-docker
 

CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o go-gin-example .
 

$ go env
GOARCH="amd64"
GOBIN=""
GOCACHE="/root/.cache/go-build"
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
...
GCCGO="gccgo"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
...

go build .
 
# -a
# 强制重新编译，简单来说，就是不利用缓存或已编译好的部分文件，直接所有包都是最新的代码重新编译和关联
 
 
# -installsuffix
# 在软件包安装的目录中增加后缀标识，以保持输出与默认版本分开
 
# -o 指定编译后的可执行文件名称
 

[target] ... : [prerequisites] ...
# 目标 ： 前置条件
<tab>[command]
# 命令
    ...
    ...
 

.PHONY: build clean tool lint help
// 称为伪目标（phony）
// 声明为伪目标后：在执行对应的命令时，make 就不会去检查是否存在 
// build / clean / tool / lint / help 其对应的文件，而是每次都会运行标签对应的命令
// 若不声明：恰好存在对应的文件，则 make 将会认为 xx 文件已存在，没有重新构建的必要了
 
all: build
build:
	go build -v .
 
tool:
	go vet ./...; true
	gofmt -w .
 
lint:
	golint ./...
 
clean:
	rm -rf go-gin-example
	go clean -i .
 
help:
	@echo "make: compile packages and dependencies"
	@echo "make tool: run specified go tool"
	@echo "make lint: golint ./..."
	@echo "make clean: remove object files and cached files"

# 确保你在根目录下
make