MinIO学习指南看这一篇就够了

setx minio_root_user name 

 setx minio_root_password password

.\minio.exe server d:\develpo\minio\data --console-address "127.0.0.1:9000" --address "127.0.0.1:9005"

export minio_storage_class_standard=ec:4
export minio_storage_class_rrs=ec:2

mc admin config set myminio/ storage_class standard="ec:4"
mc admin config set myminio/ storage_class rrs="ec:2"
# 重启minio服务
mc admin service restart myminio/

mc ls <alias>

mc mb <alias>/<bucket_name>

mc cp <file_path> <alias>/<bucket_name>

mc cp <alias>/<bucket_name>/<file_name> <local_file_path>

mc cp <source> <target>

mc mv <source> <target>

mc rm <alias>/<bucket_name>/<object_name>

mc rb <alias>/<bucket_name>

 <dependency>
       <groupid>io.minio</groupid>
       <artifactid>minio</artifactid>
       <version>8.2.2</version>
 </dependency>

minio:
  config:
    url: http://127.0.0.1:9005 #ip地址
    accesskey: admin #  账号
    secretkey: admin962464 #  密码
    secure: false #如果是true，则用的是https而不是http,默认值是true
    bucketname: "test"  # 桶的名字 相当于文件夹

import io.minio.minioclient;
import lombok.data;
import org.springframework.boot.context.properties.configurationproperties;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
@data
@configuration
@configurationproperties(prefix = "minio.config")
public class minioconfig {
    /**
     * 服务地址
     */
    private string url;
    /**
     * 用户名
     */
    private string accesskey;
    /**
     * 密码
     */
    private string secretkey;
    /**
     * 存储桶名称
     */
    private string bucketname;
    @bean
    public minioclient getminioclient() {
        return minioclient.builder().endpoint(url).credentials(accesskey, secretkey).build();
    }
}

import com.jjy.shopping_file_service.config.minioconfig;
import io.minio.*;
import io.minio.http.method;
import io.minio.messages.bucket;
import io.minio.messages.item;
import lombok.allargsconstructor;
import lombok.extern.slf4j.slf4j;
import org.springframework.stereotype.component;
import org.springframework.util.fastbytearrayoutputstream;
import org.springframework.util.stringutils;
import org.springframework.web.multipart.multipartfile;
import javax.annotation.resource;
import javax.servlet.servletoutputstream;
import javax.servlet.http.httpservletresponse;
import java.text.simpledateformat;
import java.util.arraylist;
import java.util.date;
import java.util.list;
import java.util.uuid;
@slf4j
@component
public class minioutil {
    @resource
    private minioconfig minioconfig;
    @resource
    private minioclient minioclient;
    /**
     * 查看存储bucket是否存在
     *
     * @param bucketname 存储桶名称
     * @return boolean
     */
    public boolean bucketexists(string bucketname) {
        boolean found;
        try {
            found = minioclient.bucketexists(bucketexistsargs.builder().bucket(bucketname).build());
        } catch (exception e) {
            e.printstacktrace();
            return false;
        }
        return found;
    }
    /**
     * 创建存储bucket
     *
     * @param bucketname 存储桶名称
     * @return boolean
     */
    public boolean makebucket(string bucketname) {
        try {
            minioclient.makebucket(makebucketargs.builder()
                    .bucket(bucketname)
                    .build());
        } catch (exception e) {
            e.printstacktrace();
            return false;
        }
        return true;
    }
    /**
     * 删除存储bucket
     *
     * @param bucketname 存储桶名称
     * @return boolean
     */
    public boolean removebucket(string bucketname) {
        try {
            minioclient.removebucket(removebucketargs.builder()
                    .bucket(bucketname)
                    .build());
        } catch (exception e) {
            e.printstacktrace();
            return false;
        }
        return true;
    }
    /**
     * 获取全部bucket
     *
     * @return 存储桶列表
     */
    public list<bucket> getallbuckets() {
        try {
            return minioclient.listbuckets();
        } catch (exception e) {
            e.printstacktrace();
        }
        return null;
    }
    /**
     * 文件上传
     *
     * @param file 文件
     * @return 文件对象名称
     */
    public string upload(multipartfile file) {
        string originalfilename = file.getoriginalfilename();
        system.out.println(originalfilename);
        if (!stringutils.hastext(originalfilename)) {
            throw new runtimeexception();
        }
        string filename = uuid.randomuuid() + originalfilename.substring(originalfilename.lastindexof("."));
        string prefix = new simpledateformat("yyyy/mm/dd").format(new date());
        string objectname = prefix + "/" + filename;
        try {
            putobjectargs objectargs = putobjectargs.builder().bucket(minioconfig.getbucketname()).object(objectname)
                    .stream(file.getinputstream(), file.getsize(), -1).contenttype(file.getcontenttype()).build();
            // 文件名称相同会覆盖
            minioclient.putobject(objectargs);
        } catch (exception e) {
            e.printstacktrace();
            return null;
        }
        return objectname;
    }
    /**
     * 预览图片
     *
     * @param filename 文件名称
     * @return 文件预览链接
     */
    public string preview(string filename) {
        // 查看文件地址
        getpresignedobjecturlargs build = getpresignedobjecturlargs
                .builder()
                .bucket(minioconfig.getbucketname())
                .object(filename).method(method.get).build();
        try {
            string url = minioclient.getpresignedobjecturl(build);
            return url;
        } catch (exception e) {
            e.printstacktrace();
        }
        return null;
    }
    /**
     * 文件下载
     *
     * @param filename 文件名称
     * @param res      response
     */
    public void download(string filename, httpservletresponse res) {
        getobjectargs objectargs = getobjectargs.builder().bucket(minioconfig.getbucketname())
                .object(filename).build();
        try (getobjectresponse response = minioclient.getobject(objectargs)) {
            byte[] buf = new byte[1024];
            int len;
            try (fastbytearrayoutputstream os = new fastbytearrayoutputstream()) {
                while ((len = response.read(buf)) != -1) {
                    os.write(buf, 0, len);
                }
                os.flush();
                byte[] bytes = os.tobytearray();
                res.setcharacterencoding("utf-8");
                res.addheader("content-disposition", "attachment;filename=" + filename);
                try (servletoutputstream stream = res.getoutputstream()) {
                    stream.write(bytes);
                    stream.flush();
                }
            }
        } catch (exception e) {
            e.printstacktrace();
        }
    }
    /**
     * 查看文件对象
     *
     * @return 存储bucket内文件对象信息
     */
    public list<item> listobjects() {
        iterable<result<item>> results = minioclient.listobjects(
                listobjectsargs.builder().bucket(minioconfig.getbucketname()).build());
        list<item> items = new arraylist<>();
        try {
            for (result<item> result : results) {
                items.add(result.get());
            }
        } catch (exception e) {
            e.printstacktrace();
            return null;
        }
        return items;
    }
    /**
     * 删除
     *
     * @param filename 文件名称
     * @return 是否删除成功
     */
    public boolean remove(string filename) {
        try {
            minioclient.removeobject(removeobjectargs.builder()
                    .bucket(minioconfig.getbucketname())
                    .object(filename)
                    .build());
        } catch (exception e) {
            return false;
        }
        return true;
    }
}

import com.cyw.miniodemo.config.minioconfig;
import com.cyw.miniodemo.pojo.rst;
import com.cyw.miniodemo.service.fileuploadservice;
import com.cyw.miniodemo.utils.minioutil;
import lombok.allargsconstructor;
import lombok.extern.slf4j.slf4j;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.multipartfile;
import javax.servlet.http.httpservletresponse;
import java.util.hashmap;
import java.util.map;
@slf4j
@restcontroller
@requestmapping("/api/file")
@allargsconstructor
public class fileuploadcontroller {
    private minioconfig minioconfig;
    private minioutil minioutil;
    private fileuploadservice fileuploadservice;
    @getmapping("/bucketexists")
    public rst bucketexists(@requestparam("bucketname") string bucketname) {
        map<string, object> map = new hashmap<>();
        map.put("bucketexists", minioutil.bucketexists(bucketname));
        return rst.ok("查询成功", map);
    }
    @getmapping("/makebucket")
    public rst makebucket(@requestparam("bucketname") string bucketname) {
        map<string, object> map = new hashmap<>();
        map.put("makebucketsuccess", minioutil.makebucket(bucketname));
        return rst.ok("创建成功", map);
    }
    @getmapping("/removebucket")
    public rst removebucket(@requestparam("bucketname") string bucketname) {
        map<string, object> map = new hashmap<>();
        map.put("deletebucketsuccess", minioutil.removebucket(bucketname));
        return rst.ok("删除成功", map);
    }
    @getmapping("/getallbuckets")
    public rst getallbuckets() {
        map<string, object> map = new hashmap<>();
        map.put("buckets", minioutil.getallbuckets());
        return rst.ok("查询成功", map);
    }
    @postmapping("/upload")
    public rst upload(@requestparam("file") multipartfile file) {
        string objectname = minioutil.upload(file);
        if (objectname != null) {
            map<string, object> map = new hashmap<>();
            map.put("url", (minioconfig.getendpoint() + "/" + minioconfig.getbucketname() + "/" + objectname));
            return rst.ok("上传成功", map);
        }
        return rst.fail("上传失败");
    }
    @getmapping("/preview")
    public rst preview(@requestparam("filename") string filename) {
        map<string, object> map = new hashmap<>();
        map.put("url", minioutil.preview(filename));
        return rst.ok("预览成功", map);
    }
    @getmapping("/download")
    public rst download(@requestparam("filename") string filename, httpservletresponse resp) {
        minioutil.download(filename, resp);
        return rst.ok();
    }
    @postmapping("/delete")
    public rst remove(@requestbody map<string, string> params) {
        string url = params.get("url");
        string objname = url.substring(url.lastindexof(minioconfig.getbucketname() + "/") + minioconfig.getbucketname().length() + 1);
        log.info("删除对象: {}", objname);
        minioutil.remove(objname);
        return rst.ok("删除成功");
    }
}