欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

MinIO使用基礎(chǔ)教程(最新整理)

 更新時間：2025年03月07日 12:14:39   作者：容若只如初見  
文章介紹了MinIO云存儲服務(wù)的快速安裝和使用,并通過SpringBoot實現(xiàn)文件上傳和查詢的功能,感興趣的朋友跟隨小編一起看看吧

一、背景

對于網(wǎng)站系統(tǒng)，若為降低成本投入，將文件存儲服務(wù)和網(wǎng)站系統(tǒng)部署在同一臺服務(wù)器中，訪問量不大，基本不會有問題，但訪問量逐漸升高，網(wǎng)站文件資源讀取逐漸頻繁，單機服務(wù)器可能難以承載較大的請求量，可能會出現(xiàn)網(wǎng)站打不開，甚至系統(tǒng)異常等問題。

解決方案：采用云存儲服務(wù)，將訪問很頻繁的文件資源服務(wù)，由本地改成云廠商提供的文件存儲服務(wù)，比如阿里云 OSS、七牛云、騰訊云、百度云等等，遷移之后，網(wǎng)站的訪問壓力會得到極大的釋放，服務(wù)也會變得更加穩(wěn)定。

但是，這些云存儲服務(wù)大部分都是收費的，以阿里云為例，數(shù)據(jù)存儲通常按照 0.12 元/GB/月的標準來收費，日積月累也是一筆巨款。

采用免費開源的 fastDFS 工具來作為文件存儲服務(wù)器，雖然性能不錯，但軟件安裝環(huán)境非常復(fù)雜，且沒有完整的技術(shù)文檔，大部分都是公司或者網(wǎng)友自己總結(jié)的文檔，維護起來非常困難。

直到 MinIO應(yīng)運而生，云存儲服務(wù)工具便多一個新的可選項。

MinIO 是一款號稱世界上速度最快的對象存儲服務(wù)，專為大規(guī)模數(shù)據(jù)存儲和分析而設(shè)計。支持在各種環(huán)境中部署，包括物理服務(wù)器、虛擬機、容器等，最關(guān)鍵的是它的技術(shù)文檔非常完善，非常容易上手；同時，對個人用戶是完全開源免費的。

二、快速安裝

2.1 虛擬機安裝

Centos7安裝Minio筆記

docker啟動minio命令：

docker run \
   -p 9000:9000 \
   -p 9001:9001 \
   --name minio1 \
   -v D:\minio\data:/data \
   -e "MINIO_ROOT_USER=ROOTUSER" \
   -e "MINIO_ROOT_PASSWORD=CHANGEME123" \
   quay.io/minio/minio server /data --console-address ":9001"

相關(guān)參數(shù)解讀：

docker run：表示啟動運行容器
-p：表示為容器綁定一個本地的端口
-name：表示為容器創(chuàng)建一個本地的名字
-v：表示將文件路徑設(shè)置為容器使用的持久卷位置。當 MinIO 將數(shù)據(jù)寫入 /data時，該數(shù)據(jù)會鏡像到本地路徑~/minio/data, 使其能夠在容器重新啟動時保持持久化。您可以設(shè)置任何具有讀取、寫入和刪除權(quán)限的文件路徑來使用。
-e：表示設(shè)置登陸控制臺的用戶名和密碼。其中控制臺的訪問地址為http://本機ip:9001，api 的訪問地址為http://本機ip:9000。

2.2 Windows安裝

2.2.1 下載MinIO服務(wù)器

下載地址:

https://dl.minio.org.cn/server/minio/release/windows-amd64/minio.exe

ps：不能雙擊文件來運行，下一步包括運行可執(zhí)行文件的指令。

2.2.2 啟動 MinIO Server

在PowerShell或命令提示符中，cd命令進到可執(zhí)行文件的位置，或添加minio.exe文件所在路徑 至windows系統(tǒng)環(huán)境變量 $PATH 中。

假設(shè)存放路徑為：D:\tool\minio\minio.exe，就需要：cd D:\tool\minio，
然后執(zhí)行命令：

.\minio.exe server D:\tool\minio --console-address :9090

控制臺窗口會輸出打印內(nèi)容：

API: http://192.0.2.10:9000  http://127.0.0.1:9000
RootUser: minioadmin
RootPass: minioadmin

Console: http://192.0.2.10:9090 http://127.0.0.1:9090
RootUser: minioadmin
RootPass: minioadmin

Command-line: https://minio.org.cn/docs/minio/linux/reference/minio-mc.html
   $ mc alias set myminio http://192.0.2.10:9000 minioadmin minioadmin

Documentation: https://minio.org.cn/docs/minio/linux/index.html

WARNING: Detected default credentials 'minioadmin:minioadmin', we recommend that you change these values with 'MINIO_ROOT_USER' and 'MINIO_ROOT_PASSWORD' environment variables.

該服務(wù)與當前PowerShell 或命令提示符窗口相綁定。 關(guān)閉窗口將停止服務(wù)器并結(jié)束該服務(wù)。

2.2.3 通過瀏覽器訪問MinIO服務(wù)控制臺

訪問 MinIO控制臺：

http://127.0.0.1:9090

MinIO使用監(jiān)聽的端口為 9000 端口，這個端口使用API與MinIO服務(wù)器進行通信和進行SDK調(diào)用,通過瀏覽器訪問 9000 端口會自動跳轉(zhuǎn)至MinIO控制臺。

登錄MinIO 控制臺可以使用默認的 Root用戶名/密碼 登錄： minioadmin / minioadmin 。
就可以顯示相關(guān)控制臺的詳細信息。

三、使用介紹

在對象存儲服務(wù)里面，所有的文件都是以桶的形式來組織的。簡單說，可以將桶看作是目錄，這個目錄下有很多的文件或者文件夾，這和其它云存儲服務(wù)基本一致。

3.1 創(chuàng)建存儲桶

所有的文件必須要存儲到桶中，因此需要先創(chuàng)建存儲桶。

若要修改存儲桶信息，點擊左側(cè)的Buckets菜單，即可展示存儲桶配置信息。

3.2 上傳和下載文件

點擊Object Browser菜單，可看到剛剛創(chuàng)建的存儲桶public-bucket，點擊進入，上傳想要存儲的文件。

若想下載文件或者預(yù)覽文件，點擊文件，右側(cè)會彈出相關(guān)的操作按鈕，點擊相應(yīng)的操作按鈕即可。

3.3 設(shè)置文件公開訪問

默認創(chuàng)建的存儲桶，均為私有桶，無法被公開訪問。

以 api 方式直接訪問，會提示無權(quán)限：

127.0.0.1:9000/public-bucket/sso流程圖.png

通常而言，要將數(shù)據(jù)寫入操作進行控制；而讀操作，很多不涉及安全問題，希望能被互聯(lián)網(wǎng)公開訪問，以便加快文件的訪問速度。

可以在存儲桶里面配置，將數(shù)據(jù)讀取權(quán)限設(shè)置為公開訪問：

再次訪問：

此時文件可以公開訪問。

四、實戰(zhàn)SpringBoot + Minio實現(xiàn)文件上傳和查詢

引入依賴：

<!-- 操作minio的java客戶端-->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.5.2</version>
</dependency>
<!-- 操作minio的java客戶端-->
 <dependency>
    <groupId>io.minio</groupId>
     <artifactId>minio</artifactId>
     <version>8.2.1</version>
</dependency>
<!--        jwt鑒權(quán)相應(yīng)依賴-->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.2</version>
</dependency>

獲取API訪問憑證:

編寫配置文件：

server:
    port: 8080
spring:
    servlet:
        multipart:
            max-file-size: 10MB
            max-request-size: 10MB
    #minio配置
    minio:
        access-key: dAMaxkWaXUD1CV1JHbqw
        secret-key: AXt3SD0JFkDENFbMeJKOOQb5wj8KvabZWu33Rs84
        url: http://192.168.18.14:9090  #訪問地址
        bucket-name: public-bucket

創(chuàng)建Minio的配置類：

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 = "spring.minio")
public class MinioConfig {
    private String accessKey;
    private String secretKey;
    private String url;
    private String bucketName;
    @Bean
    public MinioClient minioClient(){
        return MinioClient.builder()
                .endpoint(url)
                .credentials(accessKey,secretKey)
                .build();
    }
}

創(chuàng)建Minio的工具類：

import com.xiaohui.config.MinioConfig;
import io.minio.*;
import io.minio.errors.*;
import io.minio.http.Method;
import lombok.SneakyThrows;
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.time.ZonedDateTime;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
 * @Description Minio工具類
 */
@Component
public class MinioUtils {
    @Autowired
    private MinioClient minioClient;
    @Autowired
    private MinioConfig configuration;
    /**
     * @param name 名字
     * @Description description: 判斷bucket是否存在，不存在則創(chuàng)建
     */
    public boolean existBucket(String name) {
        boolean exists;
        try {
            exists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(name).build());
            if (!exists) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(name).build());
                exists = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
            exists = false;
        }
        return exists;
    }
    /**
     * @param bucketName 存儲bucket名稱
     * @Description 創(chuàng)建存儲bucket
     */
    public Boolean makeBucket(String bucketName) {
        try {
            minioClient.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    /**
     * @param bucketName 存儲bucket名稱
     * @Description 刪除存儲bucket
     */
    public Boolean removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    /**
     * @param fileName 文件名稱
     * @param time     時間
     * @Description 獲取上傳臨時簽名
     */
    @SneakyThrows
    public Map getPolicy(String fileName, ZonedDateTime time) {
        PostPolicy postPolicy = new PostPolicy(configuration.getBucketName(), time);
        postPolicy.addEqualsCondition("key", fileName);
        try {
            Map<String, String> map = minioClient.getPresignedPostFormData(postPolicy);
            HashMap<String, String> map1 = new HashMap<>();
            map.forEach((k, v) -> {
                map1.put(k.replaceAll("-", ""), v);
            });
            map1.put("host", configuration.getUrl() + "/" + configuration.getBucketName());
            return map1;
        } catch (ErrorResponseException e) {
            e.printStackTrace();
        } catch (InsufficientDataException e) {
            e.printStackTrace();
        } catch (InternalException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InvalidResponseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        } catch (XmlParserException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * @param objectName 對象名稱
     * @param method     方法
     * @param time       時間
     * @param timeUnit   時間單位
     * @Description 獲取上傳文件的url
     */
    public String getPolicyUrl(String objectName, Method method, int time, TimeUnit timeUnit) {
        try {
            return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .method(method)
                    .bucket(configuration.getBucketName())
                    .object(objectName)
                    .expiry(time, timeUnit).build());
        } catch (ErrorResponseException e) {
            e.printStackTrace();
        } catch (InsufficientDataException e) {
            e.printStackTrace();
        } catch (InternalException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InvalidResponseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (XmlParserException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * @param file     文件
     * @param fileName 文件名稱
     * @Description 上傳文件
     */
    public void upload(MultipartFile file, String fileName) {
        // 使用putObject上傳一個文件到存儲桶中。
        try {
            InputStream inputStream = file.getInputStream();
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(configuration.getBucketName())
                    .object(fileName)
                    .stream(inputStream, file.getSize(), -1)
                    .contentType(file.getContentType())
                    .build());
        } catch (ErrorResponseException e) {
            e.printStackTrace();
        } catch (InsufficientDataException e) {
            e.printStackTrace();
        } catch (InternalException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InvalidResponseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        } catch (XmlParserException e) {
            e.printStackTrace();
        }
    }
    /**
     * @param objectName 對象名稱
     * @param time       時間
     * @param timeUnit   時間單位
     * @Description 根據(jù)filename獲取文件訪問地址
     */
    public String getUrl(String objectName, int time, TimeUnit timeUnit) {
        String url = null;
        try {
            url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .method(Method.GET)
                    .bucket(configuration.getBucketName())
                    .object(objectName)
                    .expiry(time, timeUnit).build());
        } catch (ErrorResponseException e) {
            e.printStackTrace();
        } catch (InsufficientDataException e) {
            e.printStackTrace();
        } catch (InternalException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InvalidResponseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (XmlParserException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
        return url;
    }
    /**
     * @Description description: 下載文件
     */
    public ResponseEntity<byte[]> download(String fileName) {
        ResponseEntity<byte[]> responseEntity = null;
        InputStream in = null;
        ByteArrayOutputStream out = null;
        try {
            in = minioClient.getObject(GetObjectArgs.builder().bucket(configuration.getBucketName()).object(fileName).build());
            out = new ByteArrayOutputStream();
            IOUtils.copy(in, out);
            //封裝返回值
            byte[] bytes = out.toByteArray();
            HttpHeaders headers = new HttpHeaders();
            try {
                headers.add("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            headers.setContentLength(bytes.length);
            headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
            headers.setAccessControlExposeHeaders(Arrays.asList("*"));
            responseEntity = new ResponseEntity<byte[]>(bytes, headers, HttpStatus.SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return responseEntity;
    }
    /**
     * @param objectFile 對象文件
     */
    public String getFileUrl(String objectFile) {
        try {
            return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .method(Method.GET)
                    .bucket(configuration.getBucketName())
                    .object(objectFile)
                    .build()
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

其中包含的常量
http請求狀態(tài)：

/**
 * @Description http請求狀態(tài)
 */
public class HttpStatus
{
    /**
     * 操作成功
     */
    public static final int SUCCESS = 200;
    /**
     * 對象創(chuàng)建成功
     */
    public static final int CREATED = 201;
    /**
     * 請求已經(jīng)被接受
     */
    public static final int ACCEPTED = 202;
    /**
     * 操作已經(jīng)執(zhí)行成功，但是沒有返回數(shù)據(jù)
     */
    public static final int NO_CONTENT = 204;
    /**
     * 資源已被移除
     */
    public static final int MOVED_PERM = 301;
    /**
     * 重定向
     */
    public static final int SEE_OTHER = 303;
    /**
     * 資源沒有被修改
     */
    public static final int NOT_MODIFIED = 304;
    /**
     * 參數(shù)列表錯誤（缺少，格式不匹配）
     */
    public static final int BAD_REQUEST = 400;
    /**
     * 未授權(quán)
     */
    public static final int UNAUTHORIZED = 401;
    /**
     * 訪問受限，授權(quán)過期
     */
    public static final int FORBIDDEN = 403;
    /**
     * 資源，服務(wù)未找到
     */
    public static final int NOT_FOUND = 404;
    /**
     * 不允許的http方法
     */
    public static final int BAD_METHOD = 405;
    /**
     * 資源沖突，或者資源被鎖
     */
    public static final int CONFLICT = 409;
    /**
     * 不支持的數(shù)據(jù)，媒體類型
     */
    public static final int UNSUPPORTED_TYPE = 415;
    /**
     * 系統(tǒng)內(nèi)部錯誤
     */
    public static final int ERROR = 500;
    /**
     * 接口未實現(xiàn)
     */
    public static final int NOT_IMPLEMENTED = 501;
    /**
     * 系統(tǒng)警告消息
     */
    public static final int WARN = 601;
}

通用常量信息：

import io.jsonwebtoken.Claims;
/**
 * @Description 通用常量信息
 */
public class Constants
{
    /**
     * UTF-8 字符集
     */
    public static final String UTF8 = "UTF-8";
    /**
     * GBK 字符集
     */
    public static final String GBK = "GBK";
    /**
     * www主域
     */
    public static final String WWW = "www.";
    /**
     * http請求
     */
    public static final String HTTP = "http://";
    /**
     * https請求
     */
    public static final String HTTPS = "https://";
    /**
     * 通用成功標識
     */
    public static final String SUCCESS = "0";
    /**
     * 通用失敗標識
     */
    public static final String FAIL = "1";
    /**
     * 登錄成功
     */
    public static final String LOGIN_SUCCESS = "Success";
    /**
     * 注銷
     */
    public static final String LOGOUT = "Logout";
    /**
     * 注冊
     */
    public static final String REGISTER = "Register";
    /**
     * 登錄失敗
     */
    public static final String LOGIN_FAIL = "Error";
    /**
     * 驗證碼有效期（分鐘）
     */
    public static final Integer CAPTCHA_EXPIRATION = 2;
    /**
     * 令牌
     */
    public static final String TOKEN = "token";
    /**
     * 令牌前綴
     */
    public static final String TOKEN_PREFIX = "Bearer ";
    /**
     * 令牌前綴
     */
    public static final String LOGIN_USER_KEY = "login_user_key";
    /**
     * 用戶ID
     */
    public static final String JWT_USERID = "userid";
    /**
     * 用戶名稱
     */
    public static final String JWT_USERNAME = Claims.SUBJECT;
    /**
     * 用戶頭像
     */
    public static final String JWT_AVATAR = "avatar";
    /**
     * 創(chuàng)建時間
     */
    public static final String JWT_CREATED = "created";
    /**
     * 用戶權(quán)限
     */
    public static final String JWT_AUTHORITIES = "authorities";
    /**
     * 資源映射路徑 前綴
     */
    public static final String RESOURCE_PREFIX = "/profile";
    /**
     * RMI 遠程方法調(diào)用
     */
    public static final String LOOKUP_RMI = "rmi:";
    /**
     * LDAP 遠程方法調(diào)用
     */
    public static final String LOOKUP_LDAP = "ldap:";
    /**
     * LDAPS 遠程方法調(diào)用
     */
    public static final String LOOKUP_LDAPS = "ldaps:";
    /**
     * 定時任務(wù)白名單配置（僅允許訪問的包名，如其他需要可以自行添加）
     */
    public static final String[] JOB_WHITELIST_STR = { "com.ruoyi" };
    /**
     * 定時任務(wù)違規(guī)的字符
     */
    public static final String[] JOB_ERROR_STR = { "java.net.URL", "javax.naming.InitialContext", "org.yaml.snakeyaml",
            "org.springframework", "org.apache", "com.ruoyi.common.utils.file", "com.ruoyi.common.config" };
}

創(chuàng)建Ajax請求工具類：

/**
 * @Description ajax結(jié)果
 */
public class AjaxResult extends HashMap<String, Object>
{
    private static final long serialVersionUID = 1L;
    /** 狀態(tài)碼 */
    public static final String CODE_TAG = "code";
    /** 返回內(nèi)容 */
    public static final String MSG_TAG = "msg";
    /** 數(shù)據(jù)對象 */
    public static final String DATA_TAG = "data";
    /**
     * 初始化一個新創(chuàng)建的 AjaxResult 對象，使其表示一個空消息。
     */
    public AjaxResult()
    {
    }
    /**
     * 初始化一個新創(chuàng)建的 AjaxResult 對象
     *
     * @param code 狀態(tài)碼
     * @param msg 返回內(nèi)容
     */
    public AjaxResult(int code, String msg)
    {
        super.put(CODE_TAG, code);
        super.put(MSG_TAG, msg);
    }
    /**
     * 初始化一個新創(chuàng)建的 AjaxResult 對象
     *
     * @param code 狀態(tài)碼
     * @param msg 返回內(nèi)容
     * @param data 數(shù)據(jù)對象
     */
    public AjaxResult(int code, String msg, Object data)
    {
        super.put(CODE_TAG, code);
        super.put(MSG_TAG, msg);
        if (data!=null)
        {
            super.put(DATA_TAG, data);
        }
    }
    /**
     * 返回成功消息
     *
     * @return 成功消息
     */
    public static AjaxResult success()
    {
        return AjaxResult.success("操作成功");
    }
    /**
     * 返回成功數(shù)據(jù)
     *
     * @return 成功消息
     */
    public static AjaxResult success(Object data)
    {
        return AjaxResult.success("操作成功", data);
    }
    /**
     * 返回成功消息
     *
     * @param msg 返回內(nèi)容
     * @return 成功消息
     */
    public static AjaxResult success(String msg)
    {
        return AjaxResult.success(msg, null);
    }
    /**
     * 返回成功消息
     *
     * @param msg 返回內(nèi)容
     * @param data 數(shù)據(jù)對象
     * @return 成功消息
     */
    public static AjaxResult success(String msg, Object data)
    {
        return new AjaxResult(HttpStatus.SUCCESS, msg, data);
    }
    /**
     * 返回警告消息
     *
     * @param msg 返回內(nèi)容
     * @return 警告消息
     */
    public static AjaxResult warn(String msg)
    {
        return AjaxResult.warn(msg, null);
    }
    /**
     * 返回警告消息
     *
     * @param msg 返回內(nèi)容
     * @param data 數(shù)據(jù)對象
     * @return 警告消息
     */
    public static AjaxResult warn(String msg, Object data)
    {
        return new AjaxResult(HttpStatus.WARN, msg, data);
    }
    /**
     * 返回錯誤消息
     *
     * @return 錯誤消息
     */
    public static AjaxResult error()
    {
        return AjaxResult.error("操作失敗");
    }
    /**
     * 返回錯誤消息
     *
     * @param msg 返回內(nèi)容
     * @return 錯誤消息
     */
    public static AjaxResult error(String msg)
    {
        return AjaxResult.error(msg, null);
    }
    /**
     * 返回錯誤消息
     *
     * @param msg 返回內(nèi)容
     * @param data 數(shù)據(jù)對象
     * @return 錯誤消息
     */
    public static AjaxResult error(String msg, Object data)
    {
        return new AjaxResult(HttpStatus.ERROR, msg, data);
    }
    /**
     * 返回錯誤消息
     *
     * @param code 狀態(tài)碼
     * @param msg 返回內(nèi)容
     * @return 錯誤消息
     */
    public static AjaxResult error(int code, String msg)
    {
        return new AjaxResult(code, msg, null);
    }
    /**
     * 方便鏈式調(diào)用
     *
     * @param key 鍵
     * @param value 值
     * @return 數(shù)據(jù)對象
     */
    @Override
    public AjaxResult put(String key, Object value)
    {
        super.put(key, value);
        return this;
    }
}

創(chuàng)建Minio文件操作接口層：

import com.xiaohui.utils.AjaxResult;
import com.xiaohui.utils.MinioUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.util.HashMap;
/**
 * @Description minio文件上傳控制器
 */
@CrossOrigin
@RestController
@RequestMapping("/api")
public class MinioFileUploadController {
    @Autowired
    private MinioUtils minioUtils;
    /**
     * @param file     文件
     * @param fileName 文件名稱
     * @Description 上傳文件
     */
    @GetMapping("/upload")
    public AjaxResult uploadFile(@RequestParam("file") MultipartFile file, String fileName) {
        minioUtils.upload(file, fileName);
        return AjaxResult.success("上傳成功");
    }
    /**
     * @param fileName 文件名稱
     * @Description dowload文件
     */
    @GetMapping("/dowload")
    public ResponseEntity dowloadFile(@RequestParam("fileName") String fileName) {
        return minioUtils.download(fileName);
    }
    /**
     * @param fileName 文件名稱
     * @Description 得到文件url
     */
    @GetMapping("/getUrl")
    public AjaxResult getFileUrl(@RequestParam("fileName") String fileName){
        HashMap map=new HashMap();
        map.put("FileUrl",minioUtils.getFileUrl(fileName));
        return AjaxResult.success(map);
    }
}

五、測試

Minio大文件上傳：http://localhost:8080/api/upload
Minio大文件查詢：http://locahost:8080/api/getUr?fileName=測試

六、小結(jié)

minio 用來做個人云存儲工具完全是開源免費的，若當前需要一個云存儲工具，首推minio。

到此這篇關(guān)于MinIO使用基礎(chǔ)教程(最新整理)的文章就介紹到這了,更多相關(guān)Minio使用教程內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

相關(guān)文章

  • 淺析k8s中各組件和kube?apiserver通信時的認證和鑒權(quán)問題

    淺析k8s中各組件和kube?apiserver通信時的認證和鑒權(quán)問題

    這篇文章主要介紹了k8s中各組件和kube?apiserver通信時的認證和鑒權(quán),本文使用的k8s集群是用kubekey搭建，命令是./kk create cluster --with-kubernetes v1.21.5 --with-kubesphere v3.2.1，需要的朋友可以參考下
    2022-06-06
  • 一文搞懂K8S中的NodeSelector

    一文搞懂K8S中的NodeSelector

    NodeSelector是Kubernetes用于指定Pod運行節(jié)點的機制,通過節(jié)點上的標簽（label）來選擇性地調(diào)度Pod,增加調(diào)度的靈活性和精確性,首先需要給節(jié)點打上標簽,本文給大家介紹K8S中的NodeSelector,感興趣的朋友一起看看吧
    2024-10-10
  • 一篇文章讀懂K8S的PV和PVC以及實踐攻略

    一篇文章讀懂K8S的PV和PVC以及實踐攻略

    本文詳細介紹了Kubernetes中的存儲卷（Volume）機制,包括PersistentVolume（PV）、PersistentVolumeClaim（PVC）及其與后端存儲的關(guān)系,文中通過代碼介紹的非常詳細,需要的朋友可以參考下
    2024-10-10
  • K8s-helm簡介及基本概念詳解

    K8s-helm簡介及基本概念詳解

    ?Helm?使用的包格式稱為?chart，它是一個描述?Kubernetes?相關(guān)資源對象的文件集合，這篇文章主要介紹了K8s-helm簡介及基本概念,需要的朋友可以參考下
    2022-07-07
  • 理解k8s控制器DaemonSet創(chuàng)建及使用場景

    理解k8s控制器DaemonSet創(chuàng)建及使用場景

    這篇文章主要為大家介紹了k8s控制器DaemonSet創(chuàng)建及使用場景詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
    2022-09-09
  • K8s實戰(zhàn)教程之容器和?Pods資源分配問題

    K8s實戰(zhàn)教程之容器和?Pods資源分配問題

    這篇文章主要介紹了K8s實戰(zhàn)教程之容器和?Pods資源分配,本篇文章通過配置集群中運行的容器的?CPU?請求和限制，你可以有效利用集群上可用的?CPU?資源，通過將?Pod?CPU?請求保持在較低水平，可以使?Pod?更有機會被調(diào)度，需要的朋友可以參考下
    2022-07-07
  • Rainbond云原生部署開源社區(qū)Discourse的配置過程

    Rainbond云原生部署開源社區(qū)Discourse的配置過程

    這篇文章主要為大家介紹了Rainbond云原生部署開源社區(qū)Discourse配置過程，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
    2022-04-04
  • 云原生Kubernetes初始化容器Init使用教程

    云原生Kubernetes初始化容器Init使用教程

    這篇文章主要為大家介紹了云原生Kubernetes初始化容器Init使用教程，有需要的朋友可以借鑒參考下，希望能夠有所幫助祝大家多多進步早日升職加薪
    2022-03-03
  • Kubernetes訪問控制之鑒權(quán)方法詳解

    Kubernetes訪問控制之鑒權(quán)方法詳解

    這篇文章主要為大家介紹了Kubernetes訪問控制之鑒權(quán)方法詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
    2023-09-09
  • kubelet為cadvisor添加namespace/pod/container標簽示例詳解

    kubelet為cadvisor添加namespace/pod/container標簽示例詳解

    這篇文章主要為大家介紹了kubelet為cadvisor添加namespace/pod/container標簽示例詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
    2023-09-09

最新評論