Curl、OpenOffice 文件转换、Docker工具类、短url、MinIo工具类

﹏ヽ暗。殇╰゛Y 2022-10-23 09:55 262阅读 0赞

## 一、MinIo工具类 ##

import com.tools.module.app.util.MinIoProperties;
    import io.minio.MinioClient;
    import io.minio.PutObjectOptions;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    @Slf4j
    @Component
    @Configuration
    @EnableConfigurationProperties({ MinIoProperties.class})
    public class MinIoUtils { 
    
    
        private MinIoProperties minIo;
    
        public MinIoUtils(MinIoProperties minIo) { 
            this.minIo = minIo;
        }
    
        private MinioClient instance;
    
        @PostConstruct
        public void init() { 
            try { 
                instance = new MinioClient(minIo.getEndpoint(), minIo.getAccessKey(), minIo.getSecretKey());
            } catch (Exception e) { 
                log.error("MinIo初始化失败，请配置正确的参数");
            }
        }
    
        /** * 获取地址 */
        public String getEndpoint() { 
            return minIo.getEndpoint();
        }
    
        /** * 获取桶 */
        public String getBucketName() { 
            return minIo.getBucketName();
        }
    
        /** * 判断 bucket是否存在 * * @param bucketName * @return */
        public boolean bucketExists(String bucketName) { 
            try { 
                return instance.bucketExists(bucketName);
            } catch (Exception e) { 
                log.error(" bucket是否存在异常：{}",e);
            }
            return false;
        }
    
        /** * 创建 bucket * * @param bucketName */
        public void makeBucket(String bucketName) { 
            try { 
                boolean isExist = instance.bucketExists(bucketName);
                if (!isExist) { 
                    instance.makeBucket(bucketName);
                }
            } catch (Exception e) { 
                log.error("创建 bucket异常：{}",e);
            }
        }
    
        /** * 文件上传 * * @param bucketName * @param objectName * @param filename */
        public void putObject(String bucketName, String objectName, String filename) { 
            try { 
                instance.putObject(bucketName, objectName, filename, null);
            } catch (Exception e) { 
                log.error("文件上传异常：{}",e);
            }
        }
    
        /** * 文件上传 * * @param bucketName * @param objectName * @param stream */
        public void putObject(String bucketName, String objectName, InputStream stream, PutObjectOptions options) { 
            try { 
                instance.putObject(bucketName, objectName, stream, options);
            } catch (Exception e) { 
                log.error("文件上传异常：{}",e);
            }
        }
    
        /** * 删除文件 * * @param bucketName * @param objectName */
        public void removeObject(String bucketName, String objectName) { 
            try { 
                instance.removeObject(bucketName, objectName);
            } catch (Exception e) { 
                log.error("删除文件异常：{}",e);
            }
        }
    
        /** * 文件下载 * * @param bucketName * @param objectName * @param downloadPath */
        public void downloadFile(String bucketName, String objectName, String downloadPath) { 
            File file = new File(downloadPath);
            try (OutputStream out = new FileOutputStream(file)) { 
                InputStream inputStream = instance.getObject(bucketName, objectName);
                byte[] bytes = new byte[1024];
                int byteRead;
                while ((byteRead = inputStream.read(bytes)) != -1) { 
                    out.write(bytes, 0, byteRead);
                }
            } catch (Exception e) { 
                log.error("文件下载异常：{}",e);
            }
        }
    
        /** * 文件下载 * * @param bucketName * @param objectName */
        public InputStream downloadFile(String bucketName, String objectName) { 
            try { 
                return instance.getObject(bucketName, objectName);
            } catch (Exception e) { 
                log.error("文件下载异常：{}",e);
            }
            return null;
        }
    
        /** * 获取下载链接 * * @param bucketName 存储桶名称 * @param objectName 存储桶里的对象名称 * @param expiry 失效时间（以秒为单位），默认是7天，不得大于七天。 * @return */
        public String presignedGetObject(String bucketName, String objectName, int expiry) { 
            try { 
                return instance.presignedGetObject(bucketName, objectName, expiry);
            } catch (Exception e) { 
                log.error("获取下载链接异常：{}",e);
            }
            return null;
        }
    }

import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    @Data
    @ConfigurationProperties(prefix = "min.io")
    public class MinIoProperties { 
    
        private String endpoint;
        private String accessKey;
        private String secretKey;
        private String bucketName;
    
    }

## 二、长url生成短url ##

例如· ：将 `"http://www.xhcomvip.top" +"/r/"+ "uINbUr" == "http://www.xhcomvip.top/thread-39510-1-1.html"`  
短连接 ：http://www.xhcomvip.top/r/uINbUr  
长连接： http://www.xhcomvip.top/thread-39510-1-1.html

import com.tools.common.util.EncriptUtil;
    import org.springframework.stereotype.Component;
    
    /** * 1)将长网址用md5算法生成32位签名串，分为4段,，每段8个字符； * * 2)对这4段循环处理，取每段的8个字符, 将他看成16进制字符串与0x3fffffff(30位1)的位与操作。超过30位的忽略处理。 * * 3)将每段得到的这30位又分成6段，每5位的数字作为字母表的索引取得特定字符，依次进行获得6位字符串； * * 4)这样一个md5字符串能够获得4个6位串。取里面的随意一个就可作为这个长url的短url地址。 */
    @Component
    public class TinyUrlUtil { 
    
        public String[] ShortText(String string){ 
            String key = "qwe20210309";//自己定义生成MD5加密字符串前的混合KEY
            String[] chars = new String[]{ //要使用生成URL的字符
                    "a","b","c","d","e","f","g","h",
                    "i","j","k","l","m","n","o","p",
                    "q","r","s","t","u","v","w","x",
                    "y","z","0","1","2","3","4","5",
                    "6","7","8","9","A","B","C","D",
                    "E","F","G","H","I","J","K","L",
                    "M","N","O","P","Q","R","S","T",
                    "U","V","W","X","Y","Z"
            };
    
            String hex = EncriptUtil.md5(key + string);
            int hexLen = hex.length();
            int subHexLen = hexLen / 8;
            String[] ShortStr = new String[4];
            for (int i = 0; i < subHexLen; i++) { 
                String outChars = "";
                int j = i + 1;
                String subHex = hex.substring(i * 8, j * 8);
                long idx = Long.valueOf("3FFFFFFF", 16) & Long.valueOf(subHex, 16);
    
                for (int k = 0; k < 6; k++) { 
                    int index = (int) (Long.valueOf("0000003D", 16) & idx);
                    outChars += chars[index];
                    idx = idx >> 5;
                }
                ShortStr[i] = outChars;
            }
    
            return ShortStr;
        }
    }

## 三、DockerUtils ##

import org.apache.commons.lang3.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    /** * DockerUtils * */
    public abstract class DockerUtils { 
        private static final Logger LOGGER = LoggerFactory.getLogger(DockerUtils.class);
    
        /** Environment param keys */
        private static final String ENV_KEY_HOST = "JPAAS_HOST";
        private static final String ENV_KEY_PORT = "JPAAS_HTTP_PORT";
        private static final String ENV_KEY_PORT_ORIGINAL = "JPAAS_HOST_PORT_8080";
    
        /** Docker host & port */
        private static String DOCKER_HOST = "";
        private static String DOCKER_PORT = "";
    
        /** Whether is docker */
        private static boolean IS_DOCKER;
    
        static { 
            retrieveFromEnv();
        }
    
        /** * Retrieve docker host * * @return empty string if not a docker */
        public static String getDockerHost() { 
            return DOCKER_HOST;
        }
    
        /** * Retrieve docker port * * @return empty string if not a docker */
        public static String getDockerPort() { 
            return DOCKER_PORT;
        }
    
        /** * Whether a docker * * @return */
        public static boolean isDocker() { 
            return IS_DOCKER;
        }
    
        /** * Retrieve host & port from environment */
        private static void retrieveFromEnv() { 
            // retrieve host & port from environment
            DOCKER_HOST = System.getenv(ENV_KEY_HOST);
            DOCKER_PORT = System.getenv(ENV_KEY_PORT);
    
            // not found from 'JPAAS_HTTP_PORT', then try to find from 'JPAAS_HOST_PORT_8080'
            if (StringUtils.isBlank(DOCKER_PORT)) { 
                DOCKER_PORT = System.getenv(ENV_KEY_PORT_ORIGINAL);
            }
    
            boolean hasEnvHost = StringUtils.isNotBlank(DOCKER_HOST);
            boolean hasEnvPort = StringUtils.isNotBlank(DOCKER_PORT);
    
            // docker can find both host & port from environment
            if (hasEnvHost && hasEnvPort) { 
                IS_DOCKER = true;
    
                // found nothing means not a docker, maybe an actual machine
            } else if (!hasEnvHost && !hasEnvPort) { 
                IS_DOCKER = false;
    
            } else { 
                LOGGER.error("Missing host or port from env for Docker. host:{}, port:{}", DOCKER_HOST, DOCKER_PORT);
                throw new RuntimeException(
                        "Missing host or port from env for Docker. host:" + DOCKER_HOST + ", port:" + DOCKER_PORT);
            }
        }
    
    }

## 四、OpenOffice 文件转换 ##

import org.jodconverter.core.office.OfficeException;
    import org.jodconverter.core.office.OfficeUtils;
    import org.jodconverter.local.JodConverter;
    import org.jodconverter.local.office.LocalOfficeManager;
    
    import java.io.File;
    
    
    /** * OpenOffice 文件转换 */
    public class OpenOfficeService { 
    
        static { 
            LocalOfficeManager.builder()
                    .portNumbers(2002)
                    .build();
        }
    
        public static void main(String[] args) { 
            LocalOfficeManager officeManager = LocalOfficeManager.install();
            try { 
                officeManager.start();
                JodConverter
                        .convert(new File("F:\\前端.txt"))
                        .to(new File("E:\\home\\1.pdf"))
                        .execute();
            } catch (OfficeException e) { 
                e.printStackTrace();
            } finally { 
                OfficeUtils.stopQuietly(officeManager);
            }
        }
    }

## 五、CurlUtil ##

import cn.hutool.core.collection.CollectionUtil;
    import jodd.util.StringUtil;
    
    /** */
    public class CurlUtil { 
    
        public static  final String URL_CONTENT_TYPE = "application/x-www-form-urlencoded;charset=utf-8";
    
        public static String toCurl(CurlRequest request) { 
            StringBuilder sb = new StringBuilder();
            sb.append("curl");
            sb.append(" -X");
            sb.append(" ").append(request.getType());
            if (request.getUrl().indexOf("https") == 0) { 
                sb.append(" -k");
            }
            if (StringUtil.isNotEmpty(request.getContentType())&&
                    !URL_CONTENT_TYPE.equals(request.getContentType())) { 
                sb.append(" -H");
                sb.append(" 'Content-Type: ").append(request.getContentType()).append("'");
            }
            if (CollectionUtil.isNotEmpty(request.getReqHeaders())) { 
                for (ApiReqHeader reqHeader : request.getReqHeaders()) { 
                    sb.append(" -H");
                    if (StringUtil.isEmpty(reqHeader.getValue())) { 
                        sb.append(" '" + reqHeader.getName() + "'");
                    } else { 
                        sb.append(" '" + reqHeader.getName() + ':' + reqHeader.getValue() + "'");
                    }
                }
            }
            sb.append(" -i");
            // append request url
            sb.append(" ").append(request.getUrl());
            if (StringUtil.isNotEmpty(request.getBody())) { 
                sb.append(" --data");
                sb.append(" '" + request.getBody() + "'");
            }
            return sb.toString();
        }
    }

import java.util.List;
    
    /** */
    public class CurlRequest { 
    
        private String type;
    
        private List<ApiReqHeader> reqHeaders;
    
        private String url;
    
        private String body;
    
        private String contentType;
    
        public static CurlRequest builder() { 
            return new CurlRequest();
        }
    
        public String getType() { 
            return type;
        }
    
        public CurlRequest setType(String type) { 
            this.type = type;
            return this;
        }
    
        public List<ApiReqHeader> getReqHeaders() { 
            return reqHeaders;
        }
    
        public CurlRequest setReqHeaders(List<ApiReqHeader> reqHeaders) { 
            this.reqHeaders = reqHeaders;
            return this;
        }
    
        public String getUrl() { 
            return url;
        }
    
        public CurlRequest setUrl(String url) { 
            this.url = url;
            return this;
        }
    
        public String getBody() { 
            return body;
        }
    
        public CurlRequest setBody(String body) { 
            this.body = body;
            return this;
        }
    
        public String getContentType() { 
            return contentType;
        }
    
        public CurlRequest setContentType(String contentType) { 
            this.contentType = contentType;
            return this;
        }
    }

import java.util.Objects;
    
    /** */
    public class ApiReqHeader { 
    
        /** * Request header name */
        private String name;
    
        /** * Request header type */
        private String type;
    
        /** * request header defaultValue */
        private String value;
    
        /** * Request header description */
        private String desc;
    
        /** * required flag * * @since 1.7.0 */
        private boolean required;
    
        /** * Starting version number * * @since 1.7.0 */
        private String since = "-";
    
        @Deprecated
        public static ApiReqHeader header() { 
            return new ApiReqHeader();
        }
    
        public static ApiReqHeader builder() { 
            return new ApiReqHeader();
        }
    
        public String getName() { 
            return name;
        }
    
        public ApiReqHeader setName(String name) { 
            this.name = name;
            return this;
        }
    
        public String getType() { 
            return type;
        }
    
        public ApiReqHeader setType(String type) { 
            this.type = type;
            return this;
        }
    
        public String getDesc() { 
            return desc;
        }
    
        public ApiReqHeader setDesc(String desc) { 
            this.desc = desc;
            return this;
        }
    
        public boolean isRequired() { 
            return required;
        }
    
        public ApiReqHeader setRequired(boolean required) { 
            this.required = required;
            return this;
        }
    
        public String getSince() { 
            return since;
        }
    
        public ApiReqHeader setSince(String since) { 
            this.since = since;
            return this;
        }
    
        public String getValue() { 
            return value;
        }
    
        public ApiReqHeader setValue(String value) { 
            this.value = value;
            return this;
        }
    
        @Override
        public boolean equals(Object o) { 
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            ApiReqHeader that = (ApiReqHeader) o;
            return Objects.equals(name, that.name);
        }
    
        @Override
        public int hashCode() { 
            return Objects.hash(name);
        }
    
        @Override
        public String toString() { 
            final StringBuilder sb = new StringBuilder("{");
            sb.append("\"name\":\"")
                    .append(name).append('\"');
            sb.append(",\"type\":\"")
                    .append(type).append('\"');
            sb.append(",\"value\":\"")
                    .append(value).append('\"');
            sb.append(",\"desc\":\"")
                    .append(desc).append('\"');
            sb.append(",\"required\":")
                    .append(required);
            sb.append(",\"since\":\"")
                    .append(since).append('\"');
            sb.append('}');
            return sb.toString();
        }
    }