SpringBoot 封装Minio 文件服务器基本操作(桶创建、桶策略修改、文件上传、文件下载、文件删除)等基础功能

ゝ一世哀愁。 2023-10-10 12:42 9阅读 0赞

## 1、Minio简介 ##

Minio是GlusterFS创始人之一Anand Babu Periasamy发布新的开源项目。可以做为云存储的解决方案用来保存海量的图片，视频，文档。由于采用Golang实现，服务端可以工作在Windows,Linux, OS X和FreeBSD上。配置简单，基本是复制可执行程序，单行命令可以运行起来。

## 2、Minio 依赖Jar包 ##

<dependency>
    			<groupId>io.minio</groupId>
    			<artifactId>minio</artifactId>
    			<version>8.0.0</version>
    		</dependency>
    		<dependency>
    			<groupId>com.squareup.okhttp3</groupId>
    			<artifactId>okhttp</artifactId>
    			<version>4.9.1</version>
    		</dependency>
    		<dependency>
    			<groupId>org.jetbrains.kotlin</groupId>
    			<artifactId>kotlin-stdlib</artifactId>
    			<version>1.3.70</version>
    		</dependency>

## 3、Minio 封装核心功能代码 ##

### 3.1、实体对象 ###

package com.zzg.minio;
    
    /**
     * 
     * @ClassName:  MinioUpload   
     * @Description: Minio 文件式服务器工具类 
     * @author:  zzg
     * @date:   2021年4月9日 上午11:35:02   
     *     
     */
    public class MinioUploadEntity {
    	
    	private String url = "";
        private String access = "";
        private String secret = "";
        
    	public String getUrl() {
    		return url;
    	}
    	public void setUrl(String url) {
    		this.url = url;
    	}
    	public String getAccess() {
    		return access;
    	}
    	public void setAccess(String access) {
    		this.access = access;
    	}
    	public String getSecret() {
    		return secret;
    	}
    	public void setSecret(String secret) {
    		this.secret = secret;
    	}
    	public MinioUploadEntity(String url, String access, String secret) {
    		super();
    		this.url = url;
    		this.access = access;
    		this.secret = secret;
    	}
    }

### 3.2、桶策略 ###

package com.zzg.minio.policy;
    
    import io.minio.MinioClient;
    
    public interface BucketPolicyInterface {
    	/**
    	 * 
    	 * @Title: createBucketPolicy   
    	 * @Description: 设置桶策略 
    	 * @param: @param client
    	 * @param: @param bucket
    	 * @param: @return      
    	 * @return: boolean      
    	 * @throws
    	 */
    	boolean createBucketPolicy(MinioClient client, String bucket);
    
    }

package com.zzg.minio.policy;
    
    import java.io.IOException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import io.minio.MinioClient;
    import io.minio.SetBucketPolicyArgs;
    import io.minio.errors.ErrorResponseException;
    import io.minio.errors.InsufficientDataException;
    import io.minio.errors.InternalException;
    import io.minio.errors.InvalidResponseException;
    import io.minio.errors.ServerException;
    import io.minio.errors.XmlParserException;
    
    public class BuckerReadPolicy implements BucketPolicyInterface {
    	// 日志记录
    	public static final Logger logger = LoggerFactory.getLogger(BuckerReadPolicy.class);
    	 /**
         * 桶占位符
         */
        private static final String BUCKET_PARAM = "${bucket}";
        /**
         * bucket权限-只读
         */
        private static final String READ_ONLY = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucket\"],\"Resource\":[\"arn:aws:s3:::" + BUCKET_PARAM + "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetObject\"],\"Resource\":[\"arn:aws:s3:::" + BUCKET_PARAM + "/*\"]}]}";
    	
    	@Override
    	public boolean createBucketPolicy(MinioClient client, String bucket) {
    		// TODO Auto-generated method stub
    		try {
    			client.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucket).config(READ_ONLY.replace(BUCKET_PARAM, bucket)).build());
    			return true;
    		} catch (InvalidKeyException | ErrorResponseException | InsufficientDataException | InternalException
    				| InvalidResponseException | NoSuchAlgorithmException | ServerException | XmlParserException
    				| IllegalArgumentException | IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		}
    		return false;
    	}
    
    }

package com.zzg.minio.policy;
    
    import java.io.IOException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import io.minio.MinioClient;
    import io.minio.SetBucketPolicyArgs;
    import io.minio.errors.ErrorResponseException;
    import io.minio.errors.InsufficientDataException;
    import io.minio.errors.InternalException;
    import io.minio.errors.InvalidResponseException;
    import io.minio.errors.ServerException;
    import io.minio.errors.XmlParserException;
    
    public class BuckerWritePoliy implements BucketPolicyInterface {
    	// 日志记录
    	public static final Logger logger = LoggerFactory.getLogger(BuckerWritePoliy.class);
    	 /**
         * 桶占位符
         */
        private static final String BUCKET_PARAM = "${bucket}";
        
        /**
         * bucket权限-只读
         */
        private static final String WRITE_ONLY = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucketMultipartUploads\"],\"Resource\":[\"arn:aws:s3:::" + BUCKET_PARAM + "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:AbortMultipartUpload\",\"s3:DeleteObject\",\"s3:ListMultipartUploadParts\",\"s3:PutObject\"],\"Resource\":[\"arn:aws:s3:::" + BUCKET_PARAM + "/*\"]}]}";
    
    	@Override
    	public boolean createBucketPolicy(MinioClient client, String bucket) {
    		// TODO Auto-generated method stub
    		try {
    			client.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucket).config(WRITE_ONLY.replace(BUCKET_PARAM, bucket)).build());
    			return true;
    		} catch (InvalidKeyException | ErrorResponseException | InsufficientDataException | InternalException
    				| InvalidResponseException | NoSuchAlgorithmException | ServerException | XmlParserException
    				| IllegalArgumentException | IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		}
    		return false;
    	}
    
    }

package com.zzg.minio.policy;
    
    import java.io.IOException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import io.minio.MinioClient;
    import io.minio.SetBucketPolicyArgs;
    import io.minio.errors.ErrorResponseException;
    import io.minio.errors.InsufficientDataException;
    import io.minio.errors.InternalException;
    import io.minio.errors.InvalidResponseException;
    import io.minio.errors.ServerException;
    import io.minio.errors.XmlParserException;
    
    public class BuckerReadWriterPolicy implements BucketPolicyInterface {
    	// 日志记录
    	public static final Logger logger = LoggerFactory.getLogger(BuckerReadWriterPolicy.class);
    	 /**
         * 桶占位符
         */
        private static final String BUCKET_PARAM = "${bucket}";
        
        /**
         * bucket权限-读写
         */
        private static final String READ_WRITE = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucket\",\"s3:ListBucketMultipartUploads\"],\"Resource\":[\"arn:aws:s3:::" + BUCKET_PARAM + "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:DeleteObject\",\"s3:GetObject\",\"s3:ListMultipartUploadParts\",\"s3:PutObject\",\"s3:AbortMultipartUpload\"],\"Resource\":[\"arn:aws:s3:::" + BUCKET_PARAM + "/*\"]}]}";
    
    	@Override
    	public boolean createBucketPolicy(MinioClient client, String bucket) {
    		// TODO Auto-generated method stub
    		try {
    			client.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucket).config(READ_WRITE.replace(BUCKET_PARAM, bucket)).build());
    			return true;
    		} catch (InvalidKeyException | ErrorResponseException | InsufficientDataException | InternalException
    				| InvalidResponseException | NoSuchAlgorithmException | ServerException | XmlParserException
    				| IllegalArgumentException | IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		}
    		return false;
    	}
    
    }

package com.zzg.minio.policy;
    
    import io.minio.MinioClient;
    
    public class BuckerDefaultPolicy implements BucketPolicyInterface {
    
    	@Override
    	public boolean createBucketPolicy(MinioClient client, String bucket) {
    		// TODO Auto-generated method stub
    		return false;
    	}
    
    }

package com.zzg.minio.policy;
    
    import java.util.HashMap;
    import java.util.Map;
    import com.zzg.minio.content.BuckerPolicyContent;
    
    public class BuckerPolicyFactory {
    	static Map<String, BucketPolicyInterface> operationMap = new HashMap<>();
    	static {
    		operationMap.put(BuckerPolicyContent.READ, new BuckerReadPolicy());// 只读
    		operationMap.put(BuckerPolicyContent.WRITE, new BuckerWritePoliy());// 只写
    		operationMap.put(BuckerPolicyContent.READ_WRITE, new BuckerReadWriterPolicy());// 读写
    	}
    	
    	public static BucketPolicyInterface getBucketPolicyInterface(String poliy){
    		BucketPolicyInterface object = operationMap.get(poliy);
    		if(object == null){
    			object = new BuckerDefaultPolicy();
    		}
    		return object;
    	}
    
    }

### 3.3、桶常量 ###

package com.zzg.minio.content;
    
    public class BuckerPolicyContent {
    	
    	public static final String READ ="read";
    	
    	public static final String WRITE ="write";
    	
    	public static final String READ_WRITE ="read-write";
    }

### 3.4、Minio 核心功能代码 ###

package com.zzg.minio;
    
    import java.io.InputStream;
    
    public interface MinioUploadInteface {
    	/**
    	 * 
    	 * @Title: uploadFile   
    	 * @Description: 文件上传  
    	 * @param: @param file
    	 * @param: @param bucket
    	 * @param: @param contentType
    	 * @param: @param suffix
    	 * @param: @return      
    	 * @return: String      
    	 * @throws
    	 */
    	String uploadFile(InputStream stream, String bucket, String contentType, String suffix);
    	
    	/**
    	 * 
    	 * @Title: removeFile   
    	 * @Description: 文件删除   
    	 * @param: @param objectKey
    	 * @param: @param bucket
    	 * @param: @return      
    	 * @return: String      
    	 * @throws
    	 */
    	boolean removeFile(String objectKey, String bucket);
    	
    	/**
    	 * 
    	 * @Title: downloadFile   
    	 * @Description: 文件下载  
    	 * @param: @param objectKey
    	 * @param: @param bucket
    	 * @param: @return      
    	 * @return: File      
    	 * @throws
    	 */
    	InputStream downloadFile(String objectKey, String bucket);
    	
    	/**
    	 * 
    	 * @Title: createBucket   
    	 * @Description: 创建桶,并指定桶策略   
    	 * @param: @param bucket
    	 * @param: @param policy
    	 * @param: @return      
    	 * @return: boolean      
    	 * @throws
    	 */
    	boolean createBucket(String bucket);
    	
    	/**
    	 * 
    	 * @Title: removeBucket   
    	 * @Description: 移除指定桶  
    	 * @param: @param bucket
    	 * @param: @return      
    	 * @return: boolean      
    	 * @throws
    	 */
    	boolean removeBucket(String bucket);
    	
    	/**
    	 * 
    	 * @Title: setBucketPolicy   
    	 * @Description: 设置桶策略   
    	 * @param: @param bucket
    	 * @param: @param policy
    	 * @param: @return      
    	 * @return: boolean      
    	 * @throws
    	 */
    	boolean setBucketPolicy(String bucket, String policy);
    	
    	
    
    }

package com.zzg.minio;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.InputStream;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import org.apache.commons.io.FileUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import com.zzg.common.util.UUIDUtils;
    import com.zzg.minio.policy.BuckerPolicyFactory;
    import com.zzg.minio.policy.BucketPolicyInterface;
    import io.minio.BucketExistsArgs;
    import io.minio.GetObjectArgs;
    import io.minio.MakeBucketArgs;
    import io.minio.MinioClient;
    import io.minio.PutObjectArgs;
    import io.minio.RemoveBucketArgs;
    import io.minio.RemoveObjectArgs;
    import io.minio.errors.ErrorResponseException;
    import io.minio.errors.InsufficientDataException;
    import io.minio.errors.InternalException;
    import io.minio.errors.InvalidResponseException;
    import io.minio.errors.ServerException;
    import io.minio.errors.XmlParserException;
    
    public class MinioUploadUtil implements MinioUploadInteface {
    	// 日志记录
    	public static final Logger logger = LoggerFactory.getLogger(MinioUploadUtil.class);
    	
    	private MinioUploadEntity entity;
    	
    	public MinioUploadEntity getEntity() {
    		return entity;
    	}
    
    	public void setEntity(MinioUploadEntity entity) {
    		this.entity = entity;
    	}
    	
    	
    	public MinioUploadUtil(MinioUploadEntity entity) {
    		super();
    		this.entity = entity;
    	}
    	
    	public MinioClient createMinioClient(){
    		//创建MinioClient对象
            MinioClient minioClient = MinioClient.builder()
                    .endpoint(entity.getUrl())
                    .credentials(entity.getAccess(), entity.getSecret())
                    .build();
    		return minioClient;
    	}
    	
    
    	@Override
    	public String uploadFile(InputStream stream, String bucket, String contentType, String suffix) {
    		// TODO Auto-generated method stub
    		//创建MinioClient对象
            MinioClient minioClient = this.createMinioClient();
            // 生成文件上传唯一名称
            String objectKey =UUIDUtils.getUUID().concat(".").concat(suffix);
            // 文件流上传
            try {
    			minioClient.putObject(PutObjectArgs.builder().bucket(bucket).object(objectKey).stream(stream, stream.available(), -1).contentType(contentType).build());
    			// 返回文件上传的唯一标识
    			return objectKey;
    		} catch (InvalidKeyException | ErrorResponseException | InsufficientDataException | InternalException
    				| InvalidResponseException | NoSuchAlgorithmException | ServerException | XmlParserException
    				| IllegalArgumentException | IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		}
    		return null;
    	}
    
    	@Override
    	public boolean removeFile(String objectKey, String bucket) {
    		// TODO Auto-generated method stub
    		//创建MinioClient对象
            MinioClient minioClient = this.createMinioClient();
            try {
    			minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucket).object(objectKey).build());
    			return true;
    		} catch (InvalidKeyException | ErrorResponseException | InsufficientDataException | InternalException
    				| InvalidResponseException | NoSuchAlgorithmException | ServerException | XmlParserException
    				| IllegalArgumentException | IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		}
    		return false;
    	}
    
    	@Override
    	public InputStream downloadFile(String objectKey, String bucket) {
    		// TODO Auto-generated method stub
    		//创建MinioClient对象
            MinioClient minioClient = this.createMinioClient();
            try {
            	// 返回文件流
    			return minioClient.getObject(GetObjectArgs.builder().bucket(bucket).object(objectKey).build());
    		} catch (InvalidKeyException | ErrorResponseException | InsufficientDataException | InternalException
    				| InvalidResponseException | NoSuchAlgorithmException | ServerException | XmlParserException
    				| IllegalArgumentException | IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		}
    		return null;
    	}
    
    	@Override
    	public boolean createBucket(String bucket) {
    		// TODO Auto-generated method stub
    		boolean target = false;
    		//创建MinioClient对象
            MinioClient minioClient = this.createMinioClient();
            // 判断桶是否存在
            BucketExistsArgs exist = BucketExistsArgs.builder().bucket(bucket).build();
            
            try {
            	boolean result = minioClient.bucketExists(exist);
            	if(!result){
            		MakeBucketArgs create =MakeBucketArgs.builder().bucket(bucket).build();
            		minioClient.makeBucket(create);
            		target = true;
            	}
    			
    		} catch (InvalidKeyException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		} catch (ErrorResponseException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		} catch (InsufficientDataException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		} catch (InternalException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		} catch (InvalidResponseException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		} catch (NoSuchAlgorithmException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		} catch (ServerException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		} catch (XmlParserException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		}
    
    		return target;
    	}
    
    	@Override
    	public boolean removeBucket(String bucket) {
    		// TODO Auto-generated method stub
    		//创建MinioClient对象
            MinioClient minioClient = this.createMinioClient();
            // 判断桶是否存在
            BucketExistsArgs exist = BucketExistsArgs.builder().bucket(bucket).build();
            try {
    			boolean result = minioClient.bucketExists(exist);
    			if(result){
    				minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucket).build());
    				return true;
    			}
    		} catch (InvalidKeyException | ErrorResponseException | InsufficientDataException | InternalException
    				| InvalidResponseException | NoSuchAlgorithmException | ServerException | XmlParserException
    				| IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		}
    		return false;
    	}
    	
    	@Override
    	public boolean setBucketPolicy(String bucket, String policy) {
    		// TODO Auto-generated method stub
    		//创建MinioClient对象
            MinioClient minioClient = this.createMinioClient();
            // 判断桶是否存在
            BucketExistsArgs exist = BucketExistsArgs.builder().bucket(bucket).build();
            
            try {
    			boolean result = minioClient.bucketExists(exist);
    			if(result){
    				BucketPolicyInterface bucketPolicy = BuckerPolicyFactory.getBucketPolicyInterface(policy);
    				return bucketPolicy.createBucketPolicy(minioClient, bucket);
    			} 
    		} catch (InvalidKeyException | ErrorResponseException | InsufficientDataException | InternalException
    				| InvalidResponseException | NoSuchAlgorithmException | ServerException | XmlParserException
    				| IOException e) {
    			// TODO Auto-generated catch block
    			logger.error("error: {}", e.getMessage(), e);
    		}
    		return false;
    	}
    	
    	public static void main(String[] args) {
    //		MinioUploadEntity entity = new MinioUploadEntity("http://192.168.1.74:9000/", "minioadmin", "minioadmin");
    //		MinioUploadUtil util = new MinioUploadUtil(entity);
    //		boolean target = util.createBucket("zzg-img");
    //		if(target){
    //			System.out.println("桶创建成功");
    //		} else {
    //			System.out.println("桶已经存在");
    //		}
    		
    //		MinioUploadEntity entity = new MinioUploadEntity("http://192.168.1.74:9000", "minioadmin", "minioadmin");
    //		MinioUploadUtil util = new MinioUploadUtil(entity);
    //		//boolean target = util.setBucketPolicy("zzg-img", BuckerPolicyContent.READ);
    //		boolean target = util.setBucketPolicy("gxpt-img", BuckerPolicyContent.READ_WRITE);
    //		if(target){
    //			System.out.println("桶策略更新成功");
    //		} else {
    //			System.out.println("桶策略更新失败");
    //		}
    		
    //		MinioUploadEntity entity = new MinioUploadEntity("http://192.168.1.74:9000/", "minioadmin", "minioadmin");
    //		MinioUploadUtil util = new MinioUploadUtil(entity);
    //		boolean target = util.removeBucket("zzg-img");
    //		if(target){
    //			System.out.println("桶删除成功");
    //		} else {
    //			System.out.println("桶删除失败");
    //		}
    		
    //		MinioUploadEntity entity = new MinioUploadEntity("http://192.168.1.74:9000", "minioadmin", "minioadmin");
    //		MinioUploadUtil util = new MinioUploadUtil(entity);
    //		File file = new File("C:\\logo.png");
    //		// 获取文件后缀类型
    //		String suffix = FilenameUtils.getExtension(file.getPath());
    //		FileInputStream stream = null;
    //		try {
    //			stream = new FileInputStream(file);
    //		} catch (FileNotFoundException e) {
    //			// TODO Auto-generated catch block
    //			e.printStackTrace();
    //		}
    //		if(stream != null){
    //			String key = util.uploadFile(stream, "gxpt-img", "image/png", suffix);
    //			if(StringUtils.isNotBlank(key)){
    //				System.out.println("文件上传成功：" + key);
    //			} else {
    //				System.out.println("文件上传失败：" + key);
    //			}
    //		}
    		
    //		MinioUploadEntity entity = new MinioUploadEntity("http://192.168.1.74:9000", "minioadmin", "minioadmin");
    //		MinioUploadUtil util = new MinioUploadUtil(entity);
    //		String objectKey ="3b7e34cd0df242bdb2af1846755c9058.png";
    //		String bucket ="gxpt-img";
    //		boolean target = util.removeFile(objectKey, bucket);
    //		if(target){
    //			System.out.println("指定文件删除成功");
    //		} else {
    //			System.out.println("指定文件删除失败");
    //		}
    		
    		MinioUploadEntity entity = new MinioUploadEntity("http://192.168.1.74:9000", "minioadmin", "minioadmin");
    		MinioUploadUtil util = new MinioUploadUtil(entity);
    		String objectKey ="20200830141924415.png";
    		String bucket ="gxpt-img";
    		InputStream stream = util.downloadFile(objectKey, bucket);
    		// 目标文件
    		File targetFile = new File("D:\\20200830141924415.png");
    		
    		try {
    			if(!targetFile.exists()){
    				targetFile.createNewFile();
    			}
    			FileUtils.copyInputStreamToFile(stream, targetFile);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			logger.error("error: {}", e.getMessage(), e);
    		}
    	}
    
    	
    
    }