栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

kotliin整合Minio

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

kotliin整合Minio

kotliin整合Minio 1.安装minio,请移步—> Docker安装Minio 2.在build.gradle文件中引入minio依赖
implementation 'io.minio:minio:8.3.1'
3.在yml文件中添加配置
minio:
  endpoint: http://192.168.209.136:9000 // minio 服务地址
  accessKey: minio	// 登录账号
  secretKey: minio123	// 登录密码
4.写配置类
package com.zo.config

import io.minio.MinioClient
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration



@Configuration
@ConfigurationProperties(prefix = "minio")
class MinIoConfig {

    
    var endpoint: String = ""

    
    var accessKey: String = ""

    
    var secretKey: String = ""

    
    @Bean
    fun initMinioClient(): MinioClient {
        return MinioClient.builder().endpoint(endpoint).credentials(accessKey, secretKey).build()
    }
}
5.写工具类
package com.zo.util

import com.google.common.base.Preconditions
import com.zo.config.MinIoConfig
import io.minio.*
import io.minio.http.Method
import io.minio.messages.*
import io.minio.messages.Retention
import org.apache.commons.io.FileUtils
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Component
import org.springframework.web.multipart.MultipartFile
import java.io.ByteArrayInputStream
import java.io.File
import java.io.FileInputStream
import java.io.InputStream
import java.time.ZonedDateTime
import java.util.concurrent.TimeUnit
import javax.activation.MimetypesFileTypeMap



@Component
class MinioTemplate{

    private val logger = LoggerFactory.getLogger(MinioTemplate::class.java)

    @Autowired
    lateinit var minIoConfig: MinIoConfig

    
    fun minioClient(): MinioClient {
        return minIoConfig.initMinioClient()
    }

    
    fun bucketExists(bucketName: String): Boolean {
        return minioClient().bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())
    }

    
    fun createBucket(bucketName: String) {
        val bucketExists = bucketExists(bucketName)
        if (!bucketExists) {
            minioClient().makeBucket(MakeBucketArgs.builder().bucket(bucketName).build())
        }
    }

    
    fun createBucket(bucketName: String, regionName: String) {
        val bucketExists = bucketExists(bucketName)
        if (!bucketExists) {
            minioClient().makeBucket(MakeBucketArgs.builder().bucket(bucketName).region(regionName).build())
        }
    }

    
    fun createBucket(bucketName: String, regionName: String, isLock: Boolean) {
        val bucketExists = bucketExists(bucketName)
        if (!bucketExists) {
            minioClient().makeBucket(MakeBucketArgs.builder().bucket(bucketName).region(regionName).objectLock(isLock).build())
        }
    }

    
    fun setBucketPolicy(bucketName: String, policy: String) {
        minioClient().setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(policy).build())
    }

    
    fun getBucketPolicy(bucketName: String): String {
        return minioClient().getBucketPolicy(GetBucketPolicyArgs.builder().bucket(bucketName).build())
    }

    
    fun deleteBucketPolicy(bucketName: String) {
        minioClient().deleteBucketPolicy(DeleteBucketPolicyArgs.builder().bucket(bucketName).build())
    }

    
    fun setBucketNotification(bucketName: String, config: NotificationConfiguration) {
        return minioClient().setBucketNotification(SetBucketNotificationArgs.builder().bucket(bucketName).config(config).build())
    }

    
    fun getBucketNotification(bucketName: String): NotificationConfiguration {
        return minioClient().getBucketNotification(GetBucketNotificationArgs.builder().bucket(bucketName).build())
    }

    
    fun deleteBucketNotification(bucketName: String) {
        minioClient().deleteBucketNotification(DeleteBucketNotificationArgs.builder().bucket(bucketName).build())
    }

    
    fun listBuckets(): List {
        return minioClient().listBuckets()
    }

    
    fun listBucketsDetail(listBuckets: List): List {
        val bucketDetails = mutableListOf()
        for (bucket in listBuckets) {
            val bucketDetail = BucketDetail()
            bucketDetail.bucketName = bucket.name()
            bucketDetail.creationDate = bucket.creationDate()
            bucketDetails.add(bucketDetail)
        }
        return bucketDetails
    }

    
    fun removeBucket(bucketName: String) {
        val bucketExists = bucketExists(bucketName)
        // TODO 判断桶是否为空
        if (bucketExists) {
            minioClient().removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build())
        }
    }

    
    fun listObjects(bucketName: String): Iterable> {
        return minioClient().listObjects(ListObjectsArgs.builder().bucket(bucketName).build())
    }

    
    fun listObjects(bucketName: String, recursive: Boolean = true): Iterable> {
        return minioClient().listObjects(ListObjectsArgs.builder().bucket(bucketName).recursive(recursive).build())
    }

    
    fun listObjects(bucketName: String, startAfter: String, prefix: String, maxKeys: Int): Iterable> {
        return minioClient().listObjects(ListObjectsArgs.builder().bucket(bucketName).startAfter(startAfter).prefix(prefix).maxKeys(maxKeys).build())
    }

    
    fun listObjects(bucketName: String, startAfter: String, prefix: String, maxKeys: Int, includeVersions: Boolean = true): Iterable> {
        return minioClient().listObjects(ListObjectsArgs.builder().bucket(bucketName).startAfter(startAfter).prefix(prefix).maxKeys(maxKeys).includeVersions(includeVersions).build())
    }

    
    fun setBucketEncryption(bucketName: String, config: SseConfiguration) {
        minioClient().setBucketEncryption(SetBucketEncryptionArgs.builder().bucket(bucketName).config(config).build())
    }

    
    fun getBucketEncryption(bucketName: String): SseConfiguration {
        return minioClient().getBucketEncryption(GetBucketEncryptionArgs.builder().bucket(bucketName).build())
    }

    
    fun deleteBucketEncryption(bucketName: String) {
        minioClient().deleteBucketEncryption(DeleteBucketEncryptionArgs.builder().bucket(bucketName).build())
    }

    
    fun setBucketReplication(bucketName: String, config: ReplicationConfiguration) {
        minioClient().setBucketReplication(SetBucketReplicationArgs.builder().bucket(bucketName).config(config).build())
    }

    
    fun getBucketReplication(bucketName: String): ReplicationConfiguration {
        return minioClient().getBucketReplication(GetBucketReplicationArgs.builder().bucket(bucketName).build())
    }

    
    fun deleteBucketReplication(bucketName: String) {
        minioClient().deleteBucketReplication(DeleteBucketReplicationArgs.builder().bucket(bucketName).build())
    }

    
    fun setBucketTags(bucketName: String, tagMap: MutableMap) {
        minioClient().setBucketTags(SetBucketTagsArgs.builder().bucket(bucketName).tags(tagMap).build())
    }

    
    fun getBucketTags(bucketName: String): Tags {
        return minioClient().getBucketTags(GetBucketTagsArgs.builder().bucket(bucketName).build())
    }

    
    fun deleteBucketTags(bucketName: String) {
        minioClient().deleteBucketTags(DeleteBucketTagsArgs.builder().bucket(bucketName).build())
    }

    
    fun setBucketVersioning(bucketName: String, isOpen: Boolean) {
        if (isOpen) {
            minioClient().setBucketVersioning(SetBucketVersioningArgs.builder().bucket(bucketName).config(VersioningConfiguration(VersioningConfiguration.Status.ENABLED, null)).build())
        } else {
            minioClient().setBucketVersioning(SetBucketVersioningArgs.builder().bucket(bucketName).config(VersioningConfiguration(VersioningConfiguration.Status.SUSPENDED, null)).build())
        }
    }

    
    fun getBucketVersioning(bucketName: String): VersioningConfiguration {
        return minioClient().getBucketVersioning(GetBucketVersioningArgs.builder().bucket(bucketName).build())
    }

    
    fun setObjectLockConfiguration(
        bucketName: String,
        // 将保留模式设置为Compliance,且持续时间为100天
        config: ObjectLockConfiguration? = ObjectLockConfiguration(
            RetentionMode.COMPLIANCE,
            RetentionDurationDays(100)
        )
    ) {
        minioClient().setObjectLockConfiguration(SetObjectLockConfigurationArgs.builder().bucket(bucketName).config(config).build())
    }

    
    fun getObjectLockConfiguration(bucketName: String): ObjectLockConfiguration {
        return minioClient().getObjectLockConfiguration(GetObjectLockConfigurationArgs.builder().bucket(bucketName).build())
    }

    
    fun deleteObjectLockConfiguration(bucketName: String){
        minioClient().deleteObjectLockConfiguration(DeleteObjectLockConfigurationArgs.builder().bucket(bucketName).build())
    }

    
    fun setBucketLifecycle(bucketName: String, rules: MutableList) {
        val lifecycleConfiguration = LifecycleConfiguration(rules)
        minioClient().setBucketLifecycle(SetBucketLifecycleArgs.builder().bucket(bucketName).config(lifecycleConfiguration).build())
    }

    
    fun getBucketLifecycle(bucketName: String): LifecycleConfiguration{
        return minioClient().getBucketLifecycle(GetBucketLifecycleArgs.builder().bucket(bucketName).build())
    }

    
    fun deleteBucketLifecycle(bucketName: String){
        minioClient().deleteBucketLifecycle(DeleteBucketLifecycleArgs.builder().bucket(bucketName).build())
    }

    
    fun putObject(bucketName: String, destPath: String, file: MultipartFile) {
        minioClient().putObject(
            PutObjectArgs.builder().bucket(bucketName).`object`(destPath).contentType(file.contentType).stream(
                file.inputStream,
                file.inputStream.available().toLong(), -1
            ).build()
        )
    }

    
    fun putObject(bucketName: String, destPath: String?, contentType: String?, stream: InputStream) {
        // 上传流
        minioClient().putObject(
            PutObjectArgs.builder()
                .bucket(bucketName)
                .`object`(destPath)
                .stream(stream, stream.available().toLong(), -1)
                .contentType(contentType)
                .build()
        )
        stream.close()
    }

    
    fun putObject(bucketName: String, destPath: String?, contentType: String?, bytes: ByteArray) {
        // 字节转文件流
        val stream = ByteArrayInputStream(bytes)
        // 上传流
        minioClient().putObject(
            PutObjectArgs.builder()
                .bucket(bucketName)
                .`object`(destPath)
                .stream(stream, stream.available().toLong(), -1)
                .contentType(contentType)
                .build()
        )
        stream.close()
    }

    
    fun putObject(bucketName: String, destPath: String, file: File, contentType: String?) {
        val stream = FileInputStream(file)
        minioClient().putObject(
            PutObjectArgs.builder().bucket(bucketName).`object`(destPath).contentType(contentType).stream(
                stream,
                stream.available().toLong(), -1
            ).build()
        )
    }

    
    fun uploadObject(bucketName: String, destPath: String, sourcePath: String, contentType: String) {
        val bucketExists = this.bucketExists(bucketName)
        if (!bucketExists) {
            this.createBucket(bucketName)
        }
        minioClient().uploadObject(
            UploadObjectArgs.builder()
                .bucket(bucketName)         // 桶名
                .`object`(destPath)         // 上传到minio后的文件路径
                .filename(sourcePath)       // 源文件路径
                .contentType(contentType)   //文件类型
                .build()
        )
    }

    
    fun getObject(bucketName: String, sourcePath: String, destPath: String) {
        // 获取对象的InputStream
        val stream =
            minioClient().getObject(GetObjectArgs.builder().bucket(bucketName).`object`(sourcePath).build())
        // 读流
        val sourceFile = File(destPath)
        FileUtils.copyInputStreamToFile(stream, sourceFile)
//        println(stream.bucket() + stream.headers() + stream.`object`() + stream.region())
        stream.close()
    }

    
    fun downloadObject(bucketName: String, sourcePath: String, destPath: String) {
        minioClient().downloadObject(DownloadObjectArgs.builder()
            .bucket(bucketName)
            .`object`(sourcePath)
            .filename(destPath)
            .build())
    }

    
    fun getPreSignedObjectUrl(bucketName: String, sourcePath: String): String {
        return minioClient().getPresignedObjectUrl(
            GetPresignedObjectUrlArgs.builder()
                .method(Method.GET)
                .bucket(bucketName)
                .`object`(sourcePath)   // 默认:秒
                .build()
        )
    }

    fun getPreSignedObjectUrl(bucketName: String, sourcePath: String, expiryTime: Int, timeUnit: TimeUnit?): String {
        return if (timeUnit == null) {
            minioClient().getPresignedObjectUrl(
                GetPresignedObjectUrlArgs.builder()
                    .method(Method.GET)
                    .bucket(bucketName)
                    .`object`(sourcePath)
                    .expiry(expiryTime)
                    .build()
            )
        } else {
            minioClient().getPresignedObjectUrl(
                GetPresignedObjectUrlArgs.builder()
                    .method(Method.GET)
                    .bucket(bucketName)
                    .`object`(sourcePath)
                    .expiry(expiryTime, timeUnit)
                    .build()
            )
        }
    }

    
    fun copyObject(destBucketName: String, destPath: String, sourceBucketName: String, sourcePath: String) {
        minioClient().copyObject(
            CopyObjectArgs.builder()
                .bucket(destBucketName)
                .`object`(destPath)
                .source(CopySource.builder().bucket(sourceBucketName).`object`(sourcePath).build())
                .build()
        )
    }

    
    fun removeObject(bucketName: String, sourcePath: String) {
        minioClient().removeObject(RemoveObjectArgs.builder().bucket(bucketName).`object`(sourcePath).build())
    }

    
    fun removeObject(bucketName: String, sourcePath: String, versionId: String) {
        minioClient().removeObject(RemoveObjectArgs.builder().bucket(bucketName).`object`(sourcePath).versionId(versionId).build())
    }

    
    fun removeObjects(bucketName: String, deleteObjects: MutableList): Iterable> {
        return minioClient().removeObjects(
            RemoveObjectsArgs.builder().bucket(bucketName).objects(deleteObjects).build()
        )
    }

    
    fun statObject(bucketName: String, sourcePath: String): StatObjectResponse{
        return minioClient().statObject(StatObjectArgs.builder().bucket(bucketName).`object`(sourcePath).build())
    }

    fun composeSource(bucketName: String, sourcePath: String): ComposeSource {
        return ComposeSource.builder().bucket(bucketName).`object`(sourcePath).build()
    }

    
    fun composeObject(destBucketName: String, destPath: String, sources: MutableList): ObjectWriteResponse {
        return minioClient().composeObject(ComposeObjectArgs.builder().bucket(destBucketName).`object`(destPath).sources(sources).build())
    }

    
    fun getObjectRetention(bucketName: String, sourcePath: String): Retention {
        val retention = minioClient().getObjectRetention(
            GetObjectRetentionArgs.builder()
                .bucket(bucketName)
                .`object`(sourcePath).build()
        )
        Preconditions.checkArgument(retention != null, "该对象未设置保留配置")
        return retention
    }

    
    fun setObjectRetention(bucketName: String, sourcePath: String, dateTime: ZonedDateTime) {
        minioClient().setObjectRetention(SetObjectRetentionArgs.builder().bucket(bucketName).`object`(sourcePath).config(Retention(RetentionMode.COMPLIANCE, dateTime)).bypassGovernanceMode(true).build())
    }

    
    fun disableObjectLegalHold(bucketName: String, sourcePath: String) {
        minioClient().disableObjectLegalHold(DisableObjectLegalHoldArgs.builder().bucket(bucketName).`object`(sourcePath).build())
    }

    
    fun enableObjectLegalHold(bucketName: String, sourcePath: String) {
        minioClient().enableObjectLegalHold(EnableObjectLegalHoldArgs.builder().bucket(bucketName).`object`(sourcePath).build())
    }

    
    fun isObjectLegalHoldEnabled(bucketName: String, sourcePath: String): Boolean {
        return minioClient().isObjectLegalHoldEnabled(IsObjectLegalHoldEnabledArgs.builder().bucket(bucketName).`object`(sourcePath).build())
    }

    
    fun isObjectLegalHoldEnabled(bucketName: String, sourcePath: String, versionId: String): Boolean {
        return minioClient().isObjectLegalHoldEnabled(IsObjectLegalHoldEnabledArgs.builder().bucket(bucketName).`object`(sourcePath).versionId(versionId).build())
    }

     
    fun getObjectTags(bucketName: String, sourcePath: String): Tags {
        return minioClient().getObjectTags(
            GetObjectTagsArgs.builder().bucket(bucketName).`object`(sourcePath).build())
    }
}

data class BucketDetail(
    var bucketName: String? = null,
    var creationDate: ZonedDateTime? = null
)

// 通过文件名/文件路径获取contentType
fun String.getContentType() = MimetypesFileTypeMap().getContentType(File(this))


转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/979466.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号