Golang oss基础操作

• oss 初始化 全局调用

package main

import (
	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

type Client struct {
	Cli             *oss.Client
	Bucket          *oss.Bucket
	Endpoint        string
	AccessKeyId     string
	AccessKeySecret string
	BucketName      string
}

var Service *Client

func InitClient(endPoint, accessKeyId, accessKeySecret, bucketName string) error {
	var ossClient *oss.Client
	var err error
	ossClient, err = oss.New(endPoint, accessKeyId, accessKeySecret)
	if err != nil {
		return err
	}
	var ossBucket *oss.Bucket
	ossBucket, err = ossClient.Bucket(bucketName)
	if err != nil {
		return err
	}
	Service = &Client{
		Cli:             ossClient,
		Bucket:          ossBucket,
		Endpoint:        endPoint,
		AccessKeyId:     accessKeyId,
		AccessKeySecret: accessKeySecret,
		BucketName:      bucketName,
	}
	return nil
}

 

• oss 基础操作

// 官网参考链接：https://help.aliyun.com/product/31815.html?spm=5176.7933691.J_1309819.7.35e92a66wfzQYc

// 创建
func (c *Client) TempCreate() {
	// 上传字符串。
	var err error
	err = c.Bucket.PutObject("", strings.NewReader("yourObjectValue"))
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	// 上传Byte数组。
	err = c.Bucket.PutObject("", bytes.NewReader([]byte("yourObjectValueByteArrary")))
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	// 上传文件流。
	var fd *os.File
	err = c.Bucket.PutObject("", fd)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	// 上传本地文件。
	err = c.Bucket.PutObjectFromFile("", "")
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
}

// 下载
func (c *Client) TempUpload() {
	// 下载文件到流。
	body, err := c.Bucket.GetObject("")
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	// 数据读取完成后，获取的流必须关闭，否则会造成连接泄漏，导致请求无连接可用，程序无法正常工作。
	defer body.Close()

	data, err := ioutil.ReadAll(body)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	fmt.Println("data:", string(data))

	// 下载文件到缓存。
	body, err = c.Bucket.GetObject("")
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	defer body.Close()

	buf := new(bytes.Buffer)
	io.Copy(buf, body)
	fmt.Println("buf:", buf)

	// 下载文件到本地文件流。
	body, err = c.Bucket.GetObject("")
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	defer body.Close()

	fd, err := os.OpenFile("LocalFile", os.O_WRONLY|os.O_CREATE, 0660)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	defer fd.Close()

	io.Copy(fd, body)

}

// 删除
func (c *Client) TempDelete() {
	var err error
	// 删除单个文件。objectName表示删除OSS文件时需要指定包含文件后缀在内的完整路径，例如abc/efg/123.jpg。
	// 如需删除文件夹，请将objectName设置为对应的文件夹名称。如果文件夹非空，则需要将文件夹下的所有object删除后才能删除该文件夹。
	err = c.Bucket.DeleteObject("objectName")
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	// 返回删除成功的文件。
	delRes, err := c.Bucket.DeleteObjects([]string{"my-object-1", "my-object-2"})
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	fmt.Println("Deleted Objects:", delRes.DeletedObjects)

	// 不返回删除的结果。
	_, err = c.Bucket.DeleteObjects([]string{"my-object-3", "my-object-4"},
		oss.DeleteObjectsQuiet(true))
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	// 列举所有包含指定前缀的文件并删除。
	marker := oss.Marker("")
	prefix := oss.Prefix("")
	count := 0
	for {
		lor, err := c.Bucket.ListObjects(marker, prefix)
		if err != nil {
			fmt.Println("Error:", err)
			os.Exit(-1)
		}

		objects := []string{}
		for _, object := range lor.Objects {
			objects = append(objects, object.Key)
		}

		delRes, err := c.Bucket.DeleteObjects(objects, oss.DeleteObjectsQuiet(true))
		if err != nil {
			fmt.Println("Error:", err)
			os.Exit(-1)
		}

		if len(delRes.DeletedObjects) > 0 {
			fmt.Println("these objects deleted failure,", delRes.DeletedObjects)
			os.Exit(-1)
		}

		count += len(objects)

		prefix = oss.Prefix(lor.Prefix)
		marker = oss.Marker(lor.NextMarker)
		if !lor.IsTruncated {
			break
		}
	}
	fmt.Printf("success,total delete object count:%d\n", count)
}

// 拷贝
func (c *Client) TempCopy() {
	var err error
	// 拷贝文件到同一个存储空间的另一个文件。
	_, err = c.Bucket.CopyObject("objectName", "destObjectName")
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	// 从其它存储空间（srcBucketName）拷贝源文件（srcObjectName）到本存储空间。
	c.Bucket.CopyObjectFrom("srcBucketName", "srcObjectName", "dstObjectName")
	if err != nil {
		fmt.Println("CopyObjectFrom Error:", err)
		os.Exit(-1)
	}

	// 从本存储空间拷贝源文件（srcObjectName）到其它存储空间（dstBucketName）。
	c.Bucket.CopyObjectTo("dstBucketName", "dstObjectName", "srcObjectName")
	if err != nil {
		fmt.Println("CopyObjectTo Error:", err)
		os.Exit(-1)
	}
}

// 图片处理
func (c *Client) TempPicture() {
	var err error
	// 原图名称。若图片不在Bucket根目录，需携带文件访问路径，例如example/example.jpg。
	sourceImageName := ""
	// 指定处理后的图片名称。
	targetImageName := ""
	// 将图片缩放为固定宽高100 px后保存在本地。
	style := "image/resize,m_fixed,w_100,h_100"
	err = c.Bucket.GetObjectToFile(sourceImageName, targetImageName, oss.Process(style))
	if err != nil {
		//HandleError(err)
	}

	// 原图名称。若图片不在Bucket根目录，需携带文件访问路径，例如example/example.jpg。
	sourceImageName = ""
	// 指定处理后的图片名称。
	targetImageName = ""
	// 将图片缩放为固定宽高100 px后，再旋转90°，之后保存在本地。
	style = "image/resize,m_fixed,w_100,h_100/rotate,90"
	err = c.Bucket.GetObjectToFile(sourceImageName, targetImageName, oss.Process(style))
	if err != nil {
		//HandleError(err)
	}

	// 原图名称。若图片不在Bucket根目录，需携带文件访问路径，例如example/example.jpg。
	sourceImageName = ""
	// 指定处理后的图片名称。
	targetImageName = ""
	// 指定图片样式。
	style = "style/"
	// 将处理后的图片保存在本地。
	err = c.Bucket.GetObjectToFile(sourceImageName, targetImageName, oss.Process(style))
	if err != nil {
		//HandleError(err)
	}

	// 原图名称。若图片不在Bucket根目录，需携带文件访问路径，例如example/example.jpg。
	sourceImageName = ""
	// 指定处理后的图片名称。
	targetImageName = ""
	// 将图片缩放为固定宽高100 px后转存到当前存储空间。
	style = "image/resize,m_fixed,w_100,h_100"
	process := fmt.Sprintf("%s|sys/saveas,o_%v", style, base64.URLEncoding.EncodeToString([]byte(targetImageName)))
	result, err := c.Bucket.ProcessObject(sourceImageName, process)
	if err != nil {
		//HandleError(err)
	} else {
		fmt.Println(result)
	}

}

• 获取上传密钥

package deal

import (
	"crypto/hmac"
	"crypto/sha1"
	"encoding/base64"
	"encoding/json"
	"hash"
	"io"
	"time"
)

type PreSigned struct {
	AccessKeyId string `json:"access_key_id"`
	Host        string `json:"host"`
	Expire      int64  `json:"expire"`
	Signature   string `json:"signature"`
	Policy      string `json:"policy"`
	Directory   string `json:"dir"`
}

func GetPreSigned(doMain, accessKeyId, accessKeySecret, objectName string, expireTime time.Duration) (preSigned PreSigned, err error) {
	expireEnd := time.Now().Unix() + int64(expireTime)
	var tokenExpire = time.Unix(expireEnd, 0).Format("2006-01-02T15:04:05Z")
	//create post policy json
	var config ConfigStruct
	config.Expiration = tokenExpire
	var condition []string
	condition = append(condition, "starts-with")
	condition = append(condition, "$key")
	condition = append(condition, objectName)
	config.Conditions = append(config.Conditions, condition)

	result, err := json.Marshal(config)
	if err != nil {
		return preSigned, err
	}
	policy := base64.StdEncoding.EncodeToString(result)
	h := hmac.New(func() hash.Hash { return sha1.New() }, []byte(accessKeySecret))
	_, err = io.WriteString(h, policy)
	if err != nil {
		return preSigned, err
	}
	//calculation signature
	signedStr := base64.StdEncoding.EncodeToString(h.Sum(nil))
	preSigned.Expire = expireEnd
	preSigned.Signature = signedStr
	preSigned.Policy = policy
	preSigned.Directory = objectName
	preSigned.AccessKeyId = accessKeyId
	preSigned.Host = doMain
	return preSigned, err
}