minio 文件服务器,【golang】minio文件服务器使用教程

项目中需要大量用到从文件服务器获取文件，为了减少一丁点内存的复用，使用了基本的sync.pool，具体代码如下：

var defaultBucketName = "worker"

var defaultLocation = "us-east-1"

var minioServerPool *sync.Pool

func init() {

minioServerPool = &sync.Pool{

New: func() interface{} {

return &MinioServe{}

},

}

}

type MinioBucket struct {

BucketName string

Location string

}

type MinioFileObject struct {

ObjectName string

FilePath string

ContentType string

Bucket MinioBucket

Config MinioConfig

}

type MinioConfig struct {

EndPoint string `json:"endpoint"`

AccessKeyID string `json:"accessKeyId"`

SecretAccessKey string `json:"secretAccessKey"`

UseSSL bool `json:"useSSL"`

}

func (c *MinioConfig) Validate() error {

if c.EndPoint == "" {

return errors.New("endpoint is not specified")

}

if c.AccessKeyID == "" {

return errors.New("accessKeyId is not specified")

}

if c.SecretAccessKey == "" {

return errors.New("secretAccessKey is not specified")

}

return nil

}

func (c *MinioConfig) GetClient() (*minio.Client, error) {

if err := c.Validate(); err != nil {

return nil, err

}

client, err := minio.New(c.EndPoint, c.AccessKeyID, c.SecretAccessKey, c.UseSSL)

if err != nil {

return nil, err

}

return client, nil

}

type MinioServerOption func(*MinioServe)

func WithMinioServerClient(c *minio.Client) MinioServerOption {

return func(s *MinioServe) {

s.Client = c

}

}

type MinioServe struct {

Client *minio.Client

}

func NewMinioServer(opts ...MinioServerOption) (*MinioServe, error) {

m := &MinioServe{}

for _, opt := range opts {

opt(m)

}

return m, nil

}

func (m *MinioServe) Reset() {

m.Client = nil

}

func (m *MinioServe) createBucket(name string, loc string) (bool, error) {

// 判断桶是否存在

exists, err := m.Client.BucketExists(name)

if err == nil && exists {

return true, nil

}

// 创建新桶

err = m.Client.MakeBucket(name, loc)

if err != nil {

return false, err

}

return true, nil

}

func (m *MinioServe) FileUpload(obj *MinioFileObject) (int64, error) {

_, err := m.createBucket(obj.Bucket.BucketName, obj.Bucket.Location)

if err != nil {

return 0, err

}

n, err := m.Client.FPutObject(obj.Bucket.BucketName, obj.ObjectName, obj.FilePath, minio.PutObjectOptions{ContentType: obj.ContentType})

if err != nil {

return 0, err

}

return n, nil

}

func (m *MinioServe) FileDownloadToList(obj *MinioFileObject) ([]string, error) {

res := make([]string, 0)

ctx, cancel := context.WithTimeout(context.Background(), 200*time.Second)

defer cancel()

file, err := m.Client.GetObjectWithContext(ctx, obj.Bucket.BucketName, obj.ObjectName, minio.GetObjectOptions{})

if err != nil {

return res, err

}

defer file.Close()

reader := bufio.NewReader(file)

for {

data, _, err := reader.ReadLine()

if err != nil {

if err == io.EOF {

break

} else {

return res, err

}

}

res = append(res, string(data))

}

return res, nil

}

func (m *MinioServe) FileDownloadToDic(obj *MinioFileObject) (string, error) {

ctx, cancel := context.WithTimeout(context.Background(), 200*time.Second)

defer cancel()

file, err := m.Client.GetObjectWithContext(ctx, obj.Bucket.BucketName, obj.ObjectName, minio.GetObjectOptions{})

if err != nil {

return "", err

}

defer file.Close()

name := filepath.Base(obj.ObjectName)

if util.FileExists(name) {

log.Printf("[minio] %s already exists", name)

return name, nil

}

locatFile, err := os.Create(fmt.Sprintf("%s", name))

if err != nil {

return "", err

}

defer locatFile.Close()

_, err = io.Copy(locatFile, file)

if err != nil {

return "", err

}

return name, nil

}

func acquireMinioServer() *MinioServe {

return minioServerPool.Get().(*MinioServe)

}

func releaseMinioServer(m *MinioServe) {

m.Reset()

minioServerPool.Put(m)

}

func FileUpload(obj *MinioFileObject) (int64, error) {

m := acquireMinioServer()

client, err := obj.Config.GetClient()

if err != nil {

return 0, err

}

m.Client = client

n, err := m.FileUpload(obj)

if err != nil {

return 0, err

}

releaseMinioServer(m)

log.Printf("[minio] file upload successed")

return n, nil

}

func FileDownloadToList(obj *MinioFileObject) ([]string, error) {

m := acquireMinioServer()

client, err := obj.Config.GetClient()

if err != nil {

return nil, err

}

defer func() {

releaseMinioServer(m)

}()

m.Client = client

res, err := m.FileDownloadToList(obj)

if err != nil {

return res, err

}

log.Printf("[minio] file download successed")

return res, nil

}

func FileDownloadToDic(obj *MinioFileObject) (string, error) {

m := acquireMinioServer()

client, err := obj.Config.GetClient()

if err != nil {

return "", err

}

defer func() {

releaseMinioServer(m)

}()

m.Client = client

name, err := m.FileDownloadToDic(obj)

if err != nil {

return name, err

}

log.Printf("[minio] file download successed")

return name, nil

}