冷冷冷，冻死了

导航

springmvc项目集成minio

springmvc项目如何集成minio

1.是导入相关依赖

        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.0.3</version>
        </dependency>

2.创建minio的配置文件

minio.url=http://xxx.xxx.xxx.xxx:xxxx
minio.username=xxx
minio.password=xxx
minio.bucketName=xxx
minio.address=xxx

3.配置minio的配置类

public class MinioConfig {



    public MinioClient getMinioClient() {
        Map<String, String> map = propertiesToMap("minio");
        String url = map.get("minio.url");
        String username = map.get("minio.username");
        String password = map.get("minio.password");
        System.out.println("执行了MinioConfig.getMinioClient" + url);

        MinioClient minioClient = MinioClient.builder().endpoint(url)
                .credentials(username, password).build();
        return minioClient;
    }

    public Map<String, String> propertiesToMap(String properties) {
        // 获得资源包

        ResourceBundle bundle = ResourceBundle.getBundle(properties);
        // 通过资源包拿到所有的名称
        Enumeration<String> allName = bundle.getKeys();
        Map<String, String> map= new HashMap();
        // 遍历
        while (allName.hasMoreElements()) {

            // 获取每一个名称
            String name = (String) allName.nextElement();
            // 利用已得到的名称通过资源包获得相应的值
            String value = bundle.getString(name);
            map.put(name, value);

        }
        return map;
    }

}

 

4.最后提供一下工具类

public class MinioUtils {

    private static Logger log = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);
    private static String bucketName;
    private static String address;
    private static MinioClient minioClient;
    private static final Logger logger = LogManager.getLogger(TotalQueryController.class);
    static{
        MinioConfig minioConfig = new MinioConfig();
        minioClient = minioConfig.getMinioClient();
        Map<String, String> map = minioConfig.propertiesToMap("minio");
        bucketName = map.get("minio.bucketName");
        address = map.get("minio.address");

    }


    /**
     * 查看存储bucket是否存在
     * @return boolean
     */
    public static Boolean bucketExists(String bucketName) {
        //MinioClient minioClient = getMinioClient();
        Boolean found;
        try {
            found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            //e.printStackTrace();
            return false;
        }
        return found;
    }

    /**
     * 创建存储bucket
     * @return Boolean
     */
    public static Boolean makeBucket(String bucketName) {
        //MinioClient minioClient = getMinioClient();
        try {
            minioClient.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("创建存储bucket时出现异常...",e);
            return false;
        }
        return true;
    }
    /**
     * 删除存储bucket
     * @return Boolean
     */
    public static Boolean removeBucket(String bucketName) {
        //MinioClient minioClient = getMinioClient();
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("删除存储bucket时出现异常...",e);
            return false;
        }
        return true;
    }
    /**
     * 获取全部bucket
     */
    public static List<Bucket> getAllBuckets() {
        //MinioClient minioClient = getMinioClient();
        try {
            return minioClient.listBuckets();
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("获取存储bucket时出现异常...",e);
        }
        return null;
    }

    /**
     * 文件上传
     * @param file 文件
     * @return Boolean
     */
    public static String upload(MultipartFile file) {
        //MinioClient minioClient = getMinioClient();
        // 修饰过的文件名 非源文件名
        logger.info("执行了upload");
        StringBuilder fileName =  new StringBuilder();
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        InputStream inputStream = null;
        Date dd=new Date();
        //格式化
        SimpleDateFormat simTime =new SimpleDateFormat("yyyy/MM/dd");
        String time=simTime.format(dd);
        //拼接字符串为了实现分片
        fileName = fileName.append(address).append("/").append(time)
                .append("/").append(file.getOriginalFilename());
        File toFile = multipartFileToFile(file);
        //判断文件是否是pdf文件，如果是pdf文件，那么将contentType = "application/pdf"，不这样做预览会出现问题
        String temp = fileName.toString();
        String str1 = temp.substring(0, temp.indexOf("."));
        String name = temp.substring(str1.length()+1, temp.length());
        String contentType = file.getContentType();
        if("pdf".equals(name)){
            contentType = "application/pdf";
        }

        try {
            inputStream = new FileInputStream(toFile);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(bucketName).object(fileName.toString())
                    .stream(inputStream,file.getSize(),-1).contentType(contentType).build();

            //文件名称相同会覆盖
            minioClient.putObject(objectArgs);

        } catch (Exception e) {
            e.printStackTrace();
            logger.error("文件上传时出现异常...",e);
        }
        return fileName.toString();
    }


    /**
     * 预览图片
     * @param fileName
     * @return
     */
    public static String preview(String fileName){
        //MinioClient minioClient = getMinioClient();
        // 查看文件地址
        GetPresignedObjectUrlArgs build = new GetPresignedObjectUrlArgs().builder().bucket(bucketName).object(fileName).method(Method.GET).build();
        try {
            String url = minioClient.getPresignedObjectUrl(build);
            return url;
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("预览图片时出现异常...",e);
        }
        return null;
    }

    /**
     * 文件下载
     * @param fileName 文件名称
     * @param res response
     * @return Boolean
     */
    public static void download(String fileName, HttpServletResponse res) {
        //MinioClient minioClient = getMinioClient();
        GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(bucketName)
                .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.setContentType("application/force-download");
                res.addHeader("Content-Disposition", "attachment;fileName=" + fileName);
                try (ServletOutputStream stream = res.getOutputStream()){
                    stream.write(bytes);
                    stream.flush();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("文件下载时出现异常...",e);
        }
    }

    /**
     * 查看文件对象
     * @return 存储bucket内文件对象信息
     */
    public static List<Item> listObjects() {
        //MinioClient minioClient = getMinioClient();
        Iterable<Result<Item>> results = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).build());
        List<Item> items = new ArrayList<>();
        try {
            for (Result<Item> result : results) {
                items.add(result.get());
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("查看文件对象时出现异常...",e);
            return null;
        }
        return items;
    }

    /**
     * 删除相关附件
     * @param fileName:文件名称
     * @return
     * @throws Exception
     */
    public static boolean remove(String fileName){
        //MinioClient minioClient = getMinioClient();
        try {
            minioClient.removeObject( RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
        }catch (Exception e){
            logger.error("删除相关附件时出现异常...",e);
            return false;
        }
        return true;
    }

    /**
     * 批量删除文件对象（没测试）
     * @param objects 对象名称集合
     */
    public static Iterable<Result<DeleteError>> removeObjects(List<String> objects) {
        //MinioClient minioClient = getMinioClient();
        List<DeleteObject> dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
        Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(dos).build());
        return results;
    }

    /**
     *
     * @Description 返回MultipartFile文件
     * @return org.springframework.web.multipart.MultipartFile
     * @date 2019/1/5 11:08
     * @auther dell
     */
    public static MultipartFile getFile(String filePath, String copyFile) throws IOException {
        File file = new File(filePath);
        FileItem fileItem = new DiskFileItem(copyFile, Files.probeContentType(file.toPath()),false,file.getName(),(int)file.length(),file.getParentFile());
        byte[] buffer = new byte[4096];
        int n;
        try (InputStream inputStream = new FileInputStream(file); OutputStream os = fileItem.getOutputStream()){
            while ( (n = inputStream.read(buffer,0,4096)) != -1){
                os.write(buffer,0,n);
            }
            //也可以用IOUtils.copy(inputStream,os);
            MultipartFile multipartFile = new CommonsMultipartFile(fileItem);
            System.out.println(multipartFile.getName());
            return multipartFile;
        }catch (IOException e){
            logger.error("返回MultipartFile文件时出现异常...",e);
            e.printStackTrace();
        }
        return null;
    }

    public static Map<String, String> propertiesToMap(String properties) {
        // 获得资源包
        ResourceBundle bundle = ResourceBundle.getBundle(properties);
        // 通过资源包拿到所有的名称
        Enumeration<String> allName = bundle.getKeys();
        Map<String, String> map= new HashMap();
        // 遍历
        while (allName.hasMoreElements()) {

            // 获取每一个名称
            String name = (String) allName.nextElement();
            // 利用已得到的名称通过资源包获得相应的值
            String value = bundle.getString(name);
            map.put(name, value);

        }
        return map;
    }

    /**
     * MultipartFile装换成File文件
     * @param multiFile
     * @return
     */
    public static File multipartFileToFile(MultipartFile multiFile) {
        // 获取文件名
        String fileName = multiFile.getOriginalFilename();
        // 获取文件后缀
        String prefix = fileName.substring(fileName.lastIndexOf("."));
        // 若须要防止生成的临时文件重复,能够在文件名后添加随机码

        try {
            File file = File.createTempFile(fileName, prefix);
            multiFile.transferTo(file);
            return file;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static void deleteFileToName(String fileName){
        File file=new File(fileName);       //要删除的路径
        deleteFile(file);    //调用删除文件方法

    }

    /**
     * 删除暂存在tomcat中的附件
     * @param file
     */
    private static void deleteFile(File file){

        if (file.exists()) {            //测试文件或目录是否存在，存在进入下一步
            if (file.isFile()) {        //判断file 是不是文件，如果是直接删除
                file.delete();
            }else{            //如果不是，则一定是文件夹
                File[] files = file.listFiles();        //获取文件夹下的file对象列表
                if (files.length==0) {                    //判断此文件夹下有没有文件或目录
                    file.delete();                            //没有的话，直接删除此路径，有的话，遍历此路径，重复以上动作
                }else{
                    for (File file1 : files) {
                        deleteFile(file1);
                    }
                    file.delete();                //文件夹下所有文件和目录均被清空，删除本文件夹
                }
            }

        }else{
            System.out.println("文件或目录不存在");
        }
    }
    /**
     * 将file文件装换成为
     */
    public static MultipartFile fileToMultipartFile(String fileName) throws IOException {
        File file = new File(fileName);
        FileItemFactory factory = new DiskFileItemFactory(16, null);
        FileItem item=factory.createItem(file.getName(),"text/plain",true,file.getName());
        int bytesRead = 0;
        byte[] buffer = new byte[8192];
        try {
            FileInputStream fis = new FileInputStream(file);
            OutputStream os = item.getOutputStream();
            while ((bytesRead = fis.read(buffer, 0, 8192)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            os.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        MultipartFile multipartFile = new CommonsMultipartFile(item);
        return  multipartFile;

    }
}

最后补充一下

关于上传方法有一个坑，上传pdf的时候一定要指定清楚文件类型，可能会出现预览的时候乱码的问题

 

 

public class MinioUtils {

    private static Logger log = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);
    private static String bucketName;
    private static String address;
    private static MinioClient minioClient;
    private static final Logger logger = LogManager.getLogger(TotalQueryController.class);
    static{
        MinioConfig minioConfig = new MinioConfig();
minioClient = minioConfig.getMinioClient();
Map<String, String> map = minioConfig.propertiesToMap("minio");
bucketName = map.get("minio.bucketName");
address = map.get("minio.address");

}


    /**
     * 查看存储bucket是否存在
* @return boolean
     */
public static Boolean bucketExists(String bucketName) {
        //MinioClient minioClient = getMinioClient();
Boolean found;
        try {
            found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
} catch (Exception e) {
            //e.printStackTrace();
return false;
}
        return found;
}

    /**
     * 创建存储bucket
     * @return Boolean
     */
public static Boolean makeBucket(String bucketName) {
        //MinioClient minioClient = getMinioClient();
try {
            minioClient.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
} catch (Exception e) {
            e.printStackTrace();
logger.error("创建存储bucket时出现异常...",e);
            return false;
}
        return true;
}
    /**
     * 删除存储bucket
     * @return Boolean
     */
public static Boolean removeBucket(String bucketName) {
        //MinioClient minioClient = getMinioClient();
try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
} catch (Exception e) {
            e.printStackTrace();
logger.error("删除存储bucket时出现异常...",e);
            return false;
}
        return true;
}
    /**
     * 获取全部bucket
     */
public static List<Bucket> getAllBuckets() {
        //MinioClient minioClient = getMinioClient();
try {
            return minioClient.listBuckets();
} catch (Exception e) {
            e.printStackTrace();
logger.error("获取存储bucket时出现异常...",e);
}
        return null;
}

    /**
     * 文件上传
* @param file 文件
* @return Boolean
     */
public static String upload(MultipartFile file) {
        //MinioClient minioClient = getMinioClient();
        // 修饰过的文件名 非源文件名
logger.info("执行了upload");
StringBuilder fileName =  new StringBuilder();
ExecutorService threadPool = Executors.newFixedThreadPool(5);
InputStream inputStream = null;
Date dd=new Date();
//格式化
SimpleDateFormat simTime =new SimpleDateFormat("yyyy/MM/dd");
String time=simTime.format(dd);
//拼接字符串为了实现分片
fileName = fileName.append(address).append("/").append(time)
                .append("/").append(file.getOriginalFilename());
File toFile = multipartFileToFile(file);
//判断文件是否是pdf文件，如果是pdf文件，那么将contentType = "application/pdf"，不这样做预览会出现问题
String temp = fileName.toString();
String str1 = temp.substring(0, temp.indexOf("."));
String name = temp.substring(str1.length()+1, temp.length());
String contentType = file.getContentType();
        if("pdf".equals(name)){
            contentType = "application/pdf";
}

        try {
            inputStream = new FileInputStream(toFile);
} catch (IOException e) {
            e.printStackTrace();
}

        try {
            PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(bucketName).object(fileName.toString())
                    .stream(inputStream,file.getSize(),-1).contentType(contentType).build();

//文件名称相同会覆盖
minioClient.putObject(objectArgs);

} catch (Exception e) {
            e.printStackTrace();
logger.error("文件上传时出现异常...",e);
}
        return fileName.toString();
}


    /**
     * 预览图片
* @param fileName
* @return
*/
public static String preview(String fileName){
        //MinioClient minioClient = getMinioClient();
        // 查看文件地址
GetPresignedObjectUrlArgs build = new GetPresignedObjectUrlArgs().builder().bucket(bucketName).object(fileName).method(Method.GET).build();
        try {
            String url = minioClient.getPresignedObjectUrl(build);
            return url;
} catch (Exception e) {
            e.printStackTrace();
logger.error("预览图片时出现异常...",e);
}
        return null;
}

    /**
     * 文件下载
* @param fileName 文件名称
* @param res response
     * @return Boolean
     */
public static void download(String fileName, HttpServletResponse res) {
        //MinioClient minioClient = getMinioClient();
GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(bucketName)
                .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.setContentType("application/force-download");
res.addHeader("Content-Disposition", "attachment;fileName=" + fileName);
                try (ServletOutputStream stream = res.getOutputStream()){
                    stream.write(bytes);
stream.flush();
}
            }
        } catch (Exception e) {
            e.printStackTrace();
logger.error("文件下载时出现异常...",e);
}
    }

    /**
     * 查看文件对象
* @return 存储bucket内文件对象信息
*/
public static List<Item> listObjects() {
        //MinioClient minioClient = getMinioClient();
Iterable<Result<Item>> results = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).build());
List<Item> items = new ArrayList<>();
        try {
            for (Result<Item> result : results) {
                items.add(result.get());
}
        } catch (Exception e) {
            e.printStackTrace();
logger.error("查看文件对象时出现异常...",e);
            return null;
}
        return items;
}

    /**
     * 删除相关附件
* @param fileName:文件名称
* @return
* @throws Exception
     */
public static boolean remove(String fileName){
        //MinioClient minioClient = getMinioClient();
try {
            minioClient.removeObject( RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
}catch (Exception e){
            logger.error("删除相关附件时出现异常...",e);
            return false;
}
        return true;
}

    /**
     * 批量删除文件对象（没测试）
* @param objects 对象名称集合
*/
public static Iterable<Result<DeleteError>> removeObjects(List<String> objects) {
        //MinioClient minioClient = getMinioClient();
List<DeleteObject> dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(dos).build());
        return results;
}

    /**
     *
     * @Description 返回MultipartFile文件
* @return org.springframework.web.multipart.MultipartFile
     * @date 2019/1/5 11:08
     * @auther dell
     */
public static MultipartFile getFile(String filePath, String copyFile) throws IOException {
        File file = new File(filePath);
FileItem fileItem = new DiskFileItem(copyFile, Files.probeContentType(file.toPath()),false,file.getName(),(int)file.length(),file.getParentFile());
        byte[] buffer = new byte[4096];
        int n;
        try (InputStream inputStream = new FileInputStream(file); OutputStream os = fileItem.getOutputStream()){
            while ( (n = inputStream.read(buffer,0,4096)) != -1){
                os.write(buffer,0,n);
}
            //也可以用IOUtils.copy(inputStream,os);
MultipartFile multipartFile = new CommonsMultipartFile(fileItem);
System.out.println(multipartFile.getName());
            return multipartFile;
}catch (IOException e){
            logger.error("返回MultipartFile文件时出现异常...",e);
e.printStackTrace();
}
        return null;
}

    public static Map<String, String> propertiesToMap(String properties) {
        // 获得资源包
ResourceBundle bundle = ResourceBundle.getBundle(properties);
// 通过资源包拿到所有的名称
Enumeration<String> allName = bundle.getKeys();
Map<String, String> map= new HashMap();
// 遍历
while (allName.hasMoreElements()) {

            // 获取每一个名称
String name = (String) allName.nextElement();
// 利用已得到的名称通过资源包获得相应的值
String value = bundle.getString(name);
map.put(name, value);

}
        return map;
}

    /**
     * MultipartFile装换成File文件
* @param multiFile
* @return
*/
public static File multipartFileToFile(MultipartFile multiFile) {
        // 获取文件名
String fileName = multiFile.getOriginalFilename();
// 获取文件后缀
String prefix = fileName.substring(fileName.lastIndexOf("."));
// 若须要防止生成的临时文件重复,能够在文件名后添加随机码

try {
            File file = File.createTempFile(fileName, prefix);
multiFile.transferTo(file);
            return file;
} catch (Exception e) {
            e.printStackTrace();
}
        return null;
}
    public static void deleteFileToName(String fileName){
        File file=new File(fileName);       //要删除的路径
deleteFile(file);  //调用删除文件方法

}

    /**
     * 删除暂存在tomcat中的附件
* @param file
*/
private static void deleteFile(File file){

        if (file.exists()) {          //测试文件或目录是否存在，存在进入下一步
if (file.isFile()) {      //判断file 是不是文件，如果是直接删除
file.delete();
}else{       //如果不是，则一定是文件夹
File[] files = file.listFiles();      //获取文件夹下的file对象列表
if (files.length==0) {             //判断此文件夹下有没有文件或目录
file.delete();                   //没有的话，直接删除此路径，有的话，遍历此路径，重复以上动作
}else{
                    for (File file1 : files) {
                        deleteFile(file1);
}
                    file.delete();          //文件夹下所有文件和目录均被清空，删除本文件夹
}
            }

        }else{
            System.out.println("文件或目录不存在");
}
    }
    /**
     * 将file文件装换成为
*/
public static MultipartFile fileToMultipartFile(String fileName) throws IOException {
        File file = new File(fileName);
FileItemFactory factory = new DiskFileItemFactory(16, null);
FileItem item=factory.createItem(file.getName(),"text/plain",true,file.getName());
        int bytesRead = 0;
        byte[] buffer = new byte[8192];
        try {
            FileInputStream fis = new FileInputStream(file);
OutputStream os = item.getOutputStream();
            while ((bytesRead = fis.read(buffer, 0, 8192)) != -1) {
                os.write(buffer, 0, bytesRead);
}
            os.close();
fis.close();
} catch (IOException e) {
            e.printStackTrace();
}
        MultipartFile multipartFile = new CommonsMultipartFile(item);
        return  multipartFile;

}







}

posted on 2022-01-12 16:54  沙湖遇雨  阅读(283)  评论(0)    收藏  举报