config
MinioConfig 配置信息
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 = "dfs.minio")
public class MinioConfig {
private String url;
private String accessKey;
private String secretKey;
private String bucketName;
private String previewUrl;
@Bean
public MinioClient minioClient(){
return MinioClient.builder().endpoint(url)
.credentials(accessKey, secretKey)
.build();
}
public String getUrl()
{
return url;
}
public void setUrl(String url)
{
this.url = url;
}
public String getAccessKey()
{
return accessKey;
}
public void setAccessKey(String accessKey)
{
this.accessKey = accessKey;
}
public String getSecretKey()
{
return secretKey;
}
public void setSecretKey(String secretKey)
{
this.secretKey = secretKey;
}
public String getBucketName() {
return bucketName;
}
public void setBucketName(String bucketName) {
this.bucketName = bucketName;
}
public String getPreviewUrl() {
return previewUrl;
}
public void setPreviewUrl(String previewUrl) {
this.previewUrl = previewUrl;
}
}
SpringUtils spring工具类 方便在非spring管理环境中获取bean
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
public final class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware
{
private static ConfigurableListableBeanFactory beanFactory;
private static ApplicationContext applicationContext;
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
{
SpringUtils.beanFactory = beanFactory;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
{
SpringUtils.applicationContext = applicationContext;
}
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) throws BeansException
{
return (T) beanFactory.getBean(name);
}
public static <T> T getBean(Class<T> clz) throws BeansException
{
T result = (T) beanFactory.getBean(clz);
return result;
}
public static boolean containsBean(String name)
{
return beanFactory.containsBean(name);
}
public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
{
return beanFactory.isSingleton(name);
}
public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
{
return beanFactory.getType(name);
}
public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
{
return beanFactory.getAliases(name);
}
@SuppressWarnings("unchecked")
public static <T> T getAopProxy(T invoker)
{
return (T) AopContext.currentProxy();
}
public static String[] getActiveProfiles()
{
return applicationContext.getEnvironment().getActiveProfiles();
}
public static String getActiveProfile()
{
final String[] activeProfiles = getActiveProfiles();
return StringUtils.isNotEmpty(activeProfiles) ? activeProfiles[0] : null;
}
}
domin
BaseEntity Entity基类
import java.io.Serializable;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
public class BaseEntity implements Serializable
{
private static final long serialVersionUID = 1L;
private Map<String, Object> params;
private String searchValue;
private Long createBy;
private String createByName;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createDate;
private Long updateBy;
private String updateByName;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateDate;
private String remark;
public String getSearchValue()
{
return searchValue;
}
public void setSearchValue(String searchValue)
{
this.searchValue = searchValue;
}
public Long getCreateBy()
{
return createBy;
}
public void setCreateBy(Long createBy)
{
this.createBy = createBy;
}
public String getCreateByName() {
return createByName;
}
public void setCreateByName(String createByName) {
this.createByName = createByName;
}
public Date getCreateDate() {
return createDate;
}
public void setCreateDate(Date createDate) {
this.createDate = createDate;
}
public Long getUpdateBy()
{
return updateBy;
}
public void setUpdateBy(Long updateBy)
{
this.updateBy = updateBy;
}
public String getUpdateByName() {
return updateByName;
}
public void setUpdateByName(String updateByName) {
this.updateByName = updateByName;
}
public Date getUpdateDate() {
return updateDate;
}
public void setUpdateDate(Date updateDate) {
this.updateDate = updateDate;
}
public String getRemark()
{
return remark;
}
public void setRemark(String remark)
{
this.remark = remark;
}
public Map<String, Object> getParams()
{
if (params == null)
{
params = new HashMap<>(1);
}
return params;
}
public void setParams(Map<String, Object> params)
{
this.params = params;
}
}
OssFile 文件管理对象 oss_file
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.util.Date;
public class OssFile extends BaseEntity
{
private static final long serialVersionUID = 1L;
private Long fileId;
private String fileKey;
private String fileName;
private String fileDir;
private Long fileLength;
private String fileExtension;
private String businessType;
private String businessTypeName;
private Long businessId;
private String businessNo;
private Long orgId;
private String state;
private String dr;
private Date ts;
private Long[] fileIds;
private String url;
public void setFileId(Long fileId)
{
this.fileId = fileId;
}
public Long getFileId()
{
return fileId;
}
public void setFileKey(String fileKey)
{
this.fileKey = fileKey;
}
public String getFileKey()
{
return fileKey;
}
public void setFileName(String fileName)
{
this.fileName = fileName;
}
public String getFileName()
{
return fileName;
}
public void setFileDir(String fileDir)
{
this.fileDir = fileDir;
}
public String getFileDir()
{
return fileDir;
}
public void setFileLength(Long fileLength)
{
this.fileLength = fileLength;
}
public Long getFileLength()
{
return fileLength;
}
public void setFileExtension(String fileExtension)
{
this.fileExtension = fileExtension;
}
public String getFileExtension()
{
return fileExtension;
}
public void setBusinessType(String businessType)
{
this.businessType = businessType;
}
public String getBusinessType()
{
return businessType;
}
public String getBusinessTypeName() {
return businessTypeName;
}
public void setBusinessTypeName(String businessTypeName) {
this.businessTypeName = businessTypeName;
}
public void setBusinessId(Long businessId)
{
this.businessId = businessId;
}
public Long getBusinessId()
{
return businessId;
}
public void setBusinessNo(String businessNo)
{
this.businessNo = businessNo;
}
public String getBusinessNo()
{
return businessNo;
}
public void setOrgId(Long orgId)
{
this.orgId = orgId;
}
public Long getOrgId()
{
return orgId;
}
public void setState(String state)
{
this.state = state;
}
public String getState()
{
return state;
}
public void setDr(String dr)
{
this.dr = dr;
}
public String getDr()
{
return dr;
}
public void setTs(Date ts)
{
this.ts = ts;
}
public Date getTs()
{
return ts;
}
public void setFileIds(Long[] fileIds)
{
this.fileIds = fileIds;
}
public Long[] getFileIds()
{
return fileIds;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
@Override
public String toString() {
return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
.append("fileId", getFileId())
.append("fileKey", getFileKey())
.append("fileName", getFileName())
.append("fileDir", getFileDir())
.append("fileLength", getFileLength())
.append("fileExtension", getFileExtension())
.append("businessType", getBusinessType())
.append("businessId", getBusinessId())
.append("businessNo", getBusinessNo())
.append("orgId", getOrgId())
.append("state", getState())
.append("dr", getDr())
.append("remark", getRemark())
.append("createBy", getCreateBy())
.append("createDate", getCreateDate())
.append("updateBy", getUpdateBy())
.append("updateDate", getUpdateDate())
.append("ts", getTs())
.toString();
}
}
service
Impl
MinioFileServiceImpl Minio 文件存储
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
@Primary
@Service
public class MinioFileServiceImpl implements IFileService {
@Autowired
private MinioConfig minioConfig;
@Override
public OssFile uploadFile(MultipartFile file, OssFile ossFile) throws Exception {
String objectName = FileUploadUtils.extractFilename(file);
String bucketName = minioConfig.getBucketName();
String url = MinioClientUtils.putObject(bucketName, objectName, file);
OssFile valueFile = this.getOssFile(file, ossFile);
valueFile.setUrl(url);
valueFile.setFileKey(objectName);
valueFile.setFileDir(bucketName);
return valueFile;
}
private OssFile getOssFile(MultipartFile file, OssFile ossFile) {
OssFile valueFile = new OssFile();
valueFile.setFileName(file.getOriginalFilename());
valueFile.setFileLength(file.getSize());
valueFile.setFileExtension(FileUploadUtils.getExtension(file));
if (StringUtils.isNotEmpty(ossFile.getBusinessId())) {
valueFile.setBusinessId(ossFile.getBusinessId());
}
valueFile.setBusinessNo(ossFile.getBusinessNo());
return valueFile;
}
}
IFileService 文件上传接口
import org.springframework.web.multipart.MultipartFile;
public interface IFileService {
OssFile uploadFile(MultipartFile file, OssFile ossFile) throws Exception;
}
utils
CharsetKitConsts 字符集工具类
import java.nio.charset.Charset;
public class CharsetKitConsts
{
public static final String ISO_8859_1 = "ISO-8859-1";
public static final String UTF_8 = "UTF-8";
public static final String GBK = "GBK";
public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1);
public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8);
public static final Charset CHARSET_GBK = Charset.forName(GBK);
public static final String HTTP = "http://";
public static final String HTTPS = "https://";
}
Convert 类型转换器
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.text.NumberFormat;
import java.util.Set;
import org.apache.commons.lang3.ArrayUtils;
public class Convert {
public static String toStr(Object value, String defaultValue)
{
if (null == value)
{
return defaultValue;
}
if (value instanceof String)
{
return (String) value;
}
return value.toString();
}
public static String toStr(Object value)
{
return toStr(value, null);
}
public static Character toChar(Object value, Character defaultValue)
{
if (null == value)
{
return defaultValue;
}
if (value instanceof Character)
{
return (Character) value;
}
final String valueStr = toStr(value, null);
return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
}
public static Character toChar(Object value)
{
return toChar(value, null);
}
public static Byte toByte(Object value, Byte defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Byte)
{
return (Byte) value;
}
if (value instanceof Number)
{
return ((Number) value).byteValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Byte.parseByte(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
public static Byte toByte(Object value)
{
return toByte(value, null);
}
public static Short toShort(Object value, Short defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Short)
{
return (Short) value;
}
if (value instanceof Number)
{
return ((Number) value).shortValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Short.parseShort(valueStr.trim());
}
catch (Exception e)
{
return defaultValue;
}
}
public static Short toShort(Object value)
{
return toShort(value, null);
}
public static Number toNumber(Object value, Number defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Number)
{
return (Number) value;
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return NumberFormat.getInstance().parse(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
public static Number toNumber(Object value)
{
return toNumber(value, null);
}
public static Integer toInt(Object value, Integer defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Integer)
{
return (Integer) value;
}
if (value instanceof Number)
{
return ((Number) value).intValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Integer.parseInt(valueStr.trim());
}
catch (Exception e)
{
return defaultValue;
}
}
public static Integer toInt(Object value)
{
return toInt(value, null);
}
public static Integer[] toIntArray(String str)
{
return toIntArray(",", str);
}
public static Long[] toLongArray(String str)
{
return toLongArray(",", str);
}
public static Integer[] toIntArray(String split, String str)
{
if (StringUtils.isEmpty(str))
{
return new Integer[] {};
}
String[] arr = str.split(split);
final Integer[] ints = new Integer[arr.length];
for (int i = 0; i < arr.length; i++)
{
final Integer v = toInt(arr[i], 0);
ints[i] = v;
}
return ints;
}
public static Long[] toLongArray(String split, String str)
{
if (StringUtils.isEmpty(str))
{
return new Long[] {};
}
String[] arr = str.split(split);
final Long[] longs = new Long[arr.length];
for (int i = 0; i < arr.length; i++)
{
final Long v = toLong(arr[i], null);
longs[i] = v;
}
return longs;
}
public static String[] toStrArray(String str)
{
return toStrArray(",", str);
}
public static String[] toStrArray(String split, String str)
{
return str.split(split);
}
public static Long toLong(Object value, Long defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Long)
{
return (Long) value;
}
if (value instanceof Number)
{
return ((Number) value).longValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return new BigDecimal(valueStr.trim()).longValue();
}
catch (Exception e)
{
return defaultValue;
}
}
public static Long toLong(Object value)
{
return toLong(value, null);
}
public static Double toDouble(Object value, Double defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Double)
{
return (Double) value;
}
if (value instanceof Number)
{
return ((Number) value).doubleValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return new BigDecimal(valueStr.trim()).doubleValue();
}
catch (Exception e)
{
return defaultValue;
}
}
public static Double toDouble(Object value)
{
return toDouble(value, null);
}
public static Float toFloat(Object value, Float defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Float)
{
return (Float) value;
}
if (value instanceof Number)
{
return ((Number) value).floatValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Float.parseFloat(valueStr.trim());
}
catch (Exception e)
{
return defaultValue;
}
}
public static Float toFloat(Object value)
{
return toFloat(value, null);
}
public static Boolean toBool(Object value, Boolean defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Boolean)
{
return (Boolean) value;
}
String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
valueStr = valueStr.trim().toLowerCase();
switch (valueStr)
{
case "true":
return true;
case "false":
return false;
case "yes":
return true;
case "ok":
return true;
case "no":
return false;
case "1":
return true;
case "0":
return false;
default:
return defaultValue;
}
}
public static Boolean toBool(Object value)
{
return toBool(value, null);
}
public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (clazz.isAssignableFrom(value.getClass()))
{
@SuppressWarnings("unchecked")
E myE = (E) value;
return myE;
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Enum.valueOf(clazz, valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value)
{
return toEnum(clazz, value, null);
}
public static BigInteger toBigInteger(Object value, BigInteger defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof BigInteger)
{
return (BigInteger) value;
}
if (value instanceof Long)
{
return BigInteger.valueOf((Long) value);
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return new BigInteger(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
public static BigInteger toBigInteger(Object value)
{
return toBigInteger(value, null);
}
public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof BigDecimal)
{
return (BigDecimal) value;
}
if (value instanceof Long)
{
return new BigDecimal((Long) value);
}
if (value instanceof Double)
{
return new BigDecimal((Double) value);
}
if (value instanceof Integer)
{
return new BigDecimal((Integer) value);
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return new BigDecimal(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
public static BigDecimal toBigDecimal(Object value)
{
return toBigDecimal(value, null);
}
public static String utf8Str(Object obj)
{
return str(obj, CharsetKitConsts.CHARSET_UTF_8);
}
public static String str(Object obj, String charsetName)
{
return str(obj, Charset.forName(charsetName));
}
public static String str(Object obj, Charset charset)
{
if (null == obj)
{
return null;
}
if (obj instanceof String)
{
return (String) obj;
}
else if (obj instanceof byte[])
{
return str((byte[]) obj, charset);
}
else if (obj instanceof Byte[])
{
byte[] bytes = ArrayUtils.toPrimitive((Byte[]) obj);
return str(bytes, charset);
}
else if (obj instanceof ByteBuffer)
{
return str((ByteBuffer) obj, charset);
}
return obj.toString();
}
public static String str(byte[] bytes, String charset)
{
return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
}
public static String str(byte[] data, Charset charset)
{
if (data == null)
{
return null;
}
if (null == charset)
{
return new String(data);
}
return new String(data, charset);
}
public static String str(ByteBuffer data, String charset)
{
if (data == null)
{
return null;
}
return str(data, Charset.forName(charset));
}
public static String str(ByteBuffer data, Charset charset)
{
if (null == charset)
{
charset = Charset.defaultCharset();
}
return charset.decode(data).toString();
}
public static String toSBC(String input)
{
return toSBC(input, null);
}
public static String toSBC(String input, Set<Character> notConvertSet)
{
char c[] = input.toCharArray();
for (int i = 0; i < c.length; i++)
{
if (null != notConvertSet && notConvertSet.contains(c[i]))
{
continue;
}
if (c[i] == ' ')
{
c[i] = '\u3000';
}
else if (c[i] < '\177')
{
c[i] = (char) (c[i] + 65248);
}
}
return new String(c);
}
public static String toDBC(String input)
{
return toDBC(input, null);
}
public static String toDBC(String text, Set<Character> notConvertSet)
{
char c[] = text.toCharArray();
for (int i = 0; i < c.length; i++)
{
if (null != notConvertSet && notConvertSet.contains(c[i]))
{
continue;
}
if (c[i] == '\u3000')
{
c[i] = ' ';
}
else if (c[i] > '\uFF00' && c[i] < '\uFF5F')
{
c[i] = (char) (c[i] - 65248);
}
}
String returnString = new String(c);
return returnString;
}
public static String digitUppercase(double n)
{
String[] fraction = { "角", "分" };
String[] digit = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
String[][] unit = { { "元", "万", "亿" }, { "", "拾", "佰", "仟" } };
String head = n < 0 ? "负" : "";
n = Math.abs(n);
String s = "";
for (int i = 0; i < fraction.length; i++)
{
s += (digit[(int) (Math.floor(n * 10 * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");
}
if (s.length() < 1)
{
s = "整";
}
int integerPart = (int) Math.floor(n);
for (int i = 0; i < unit[0].length && integerPart > 0; i++)
{
String p = "";
for (int j = 0; j < unit[1].length && n > 0; j++)
{
p = digit[integerPart % 10] + unit[1][j] + p;
integerPart = integerPart / 10;
}
s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
}
return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
}
}
FileUploadUtils
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.springframework.web.multipart.MultipartFile;
import javax.activation.MimetypesFileTypeMap;
import java.io.File;
import java.util.Date;
public class FileUploadUtils {
public static final String datePath()
{
Date now = new Date();
return DateFormatUtils.format(now, "yyyy/MM/dd");
}
public static final String extractFilename(File file)
{
String fileName = file.getName();
String extension = FileUploadUtils.getExtension(file);
fileName = FileUploadUtils.datePath() + "/" + IdUtils.fastUUID() + "." + extension;
return fileName;
}
public static final String extractFilename(MultipartFile file)
{
String fileName = file.getOriginalFilename();
String extension = getExtension(file);
fileName = FileUploadUtils.datePath() + "/" + IdUtils.fastUUID() + "." + extension;
return fileName;
}
public static final String getExtension(File file)
{
String extension = FilenameUtils.getExtension(file.getName());
if (StringUtils.isEmpty(extension))
{
extension = MimeTypeUtils.getExtension(FileUploadUtils.getContentType(file));
}
return extension;
}
public static String getContentType(String filePath) {
return getContentType(new File(filePath));
}
public static String getContentType(File file) {
String contentType = null;
try {
contentType = new MimetypesFileTypeMap().getContentType(file);
} catch (Exception e) {
e.printStackTrace();
}
return contentType;
}
public static final String getExtension(MultipartFile file)
{
String extension = FilenameUtils.getExtension(file.getOriginalFilename());
if (StringUtils.isEmpty(extension))
{
extension = MimeTypeUtils.getExtension(file.getContentType());
}
return extension;
}
}
IdUtils ID生成器工具类
public class IdUtils {
public static String randomUUID()
{
return UUID.randomUUID().toString();
}
public static String simpleUUID()
{
return UUID.randomUUID().toString(true);
}
public static String fastUUID()
{
return UUID.fastUUID().toString();
}
public static String fastSimpleUUID()
{
return UUID.fastUUID().toString(true);
}
}
MimeTypeUtils 媒体类型工具类
public class MimeTypeUtils
{
public static final String IMAGE_PNG = "image/png";
public static final String IMAGE_JPG = "image/jpg";
public static final String IMAGE_JPEG = "image/jpeg";
public static final String IMAGE_BMP = "image/bmp";
public static final String IMAGE_GIF = "image/gif";
public static final String[] IMAGE_EXTENSION = { "bmp", "gif", "jpg", "jpeg", "png" };
public static final String[] FLASH_EXTENSION = { "swf", "flv" };
public static final String[] MEDIA_EXTENSION = { "swf", "flv", "mp3", "wav", "wma", "wmv", "mid", "avi", "mpg",
"asf", "rm", "rmvb" };
public static final String[] VIDEO_EXTENSION = { "mp4", "avi", "rmvb" };
public static final String[] DEFAULT_ALLOWED_EXTENSION = {
"bmp", "gif", "jpg", "jpeg", "png",
"doc", "docx", "xls", "xlsx", "ppt", "pptx", "html", "htm", "txt",
"rar", "zip", "gz", "bz2",
"mp4", "avi", "rmvb",
"pdf",
"ifc", "rvt", "dwg", "glzip","dgn","gtj"
};
public static String getExtension(String prefix)
{
switch (prefix)
{
case IMAGE_PNG:
return "png";
case IMAGE_JPG:
return "jpg";
case IMAGE_JPEG:
return "jpeg";
case IMAGE_BMP:
return "bmp";
case IMAGE_GIF:
return "gif";
default:
return "";
}
}
}
StrFormatter 字符串格式化
public class StrFormatter
{
public static final String EMPTY_JSON = "{}";
public static final char C_BACKSLASH = '\\';
public static final char C_DELIM_START = '{';
public static final char C_DELIM_END = '}';
public static String format(final String strPattern, final Object... argArray)
{
if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray))
{
return strPattern;
}
final int strPatternLength = strPattern.length();
StringBuilder sbuf = new StringBuilder(strPatternLength + 50);
int handledPosition = 0;
int delimIndex;
for (int argIndex = 0; argIndex < argArray.length; argIndex++)
{
delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
if (delimIndex == -1)
{
if (handledPosition == 0)
{
return strPattern;
}
else
{
sbuf.append(strPattern, handledPosition, strPatternLength);
return sbuf.toString();
}
}
else
{
if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH)
{
if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH)
{
sbuf.append(strPattern, handledPosition, delimIndex - 1);
sbuf.append(Convert.utf8Str(argArray[argIndex]));
handledPosition = delimIndex + 2;
}
else
{
argIndex--;
sbuf.append(strPattern, handledPosition, delimIndex - 1);
sbuf.append(C_DELIM_START);
handledPosition = delimIndex + 1;
}
}
else
{
sbuf.append(strPattern, handledPosition, delimIndex);
sbuf.append(Convert.utf8Str(argArray[argIndex]));
handledPosition = delimIndex + 2;
}
}
}
sbuf.append(strPattern, handledPosition, strPattern.length());
return sbuf.toString();
}
}
StringUtils 字符串工具类
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.util.AntPathMatcher;
public class StringUtils extends org.apache.commons.lang3.StringUtils
{
private static final String NULLSTR = "";
private static final char SEPARATOR = '_';
public static <T> T nvl(T value, T defaultValue)
{
return value != null ? value : defaultValue;
}
public static boolean isEmpty(Collection<?> coll)
{
return isNull(coll) || coll.isEmpty();
}
public static boolean isNotEmpty(Collection<?> coll)
{
return !isEmpty(coll);
}
public static boolean isEmpty(Object[] objects)
{
return isNull(objects) || (objects.length == 0);
}
public static boolean isNotEmpty(Object[] objects)
{
return !isEmpty(objects);
}
public static boolean isEmpty(Map<?, ?> map)
{
return isNull(map) || map.isEmpty();
}
public static boolean isNotEmpty(Map<?, ?> map)
{
return !isEmpty(map);
}
public static boolean isEmpty(String str)
{
return isNull(str) || NULLSTR.equals(str.trim()) || "null".equalsIgnoreCase(str) || "undefined".equalsIgnoreCase(str);
}
public static boolean isNotEmpty(String str)
{
return !isEmpty(str);
}
public static boolean isEmpty(Long val)
{
return isNull(val) || val==0L;
}
public static boolean isNotEmpty(Long val)
{
return !isEmpty(val);
}
public static boolean isEmpty(Integer val)
{
return isNull(val) || val==0;
}
public static boolean isNotEmpty(Integer val)
{
return !isEmpty(val);
}
public static boolean isEmpty(Double val)
{
return isNull(val) || val==0;
}
public static boolean isNotEmpty(Double val)
{
return !isEmpty(val);
}
public static boolean isEmpty(com.alibaba.fastjson.JSONObject val)
{
com.alibaba.fastjson.JSONObject jo = (com.alibaba.fastjson.JSONObject) val;
if(jo==null || jo.isEmpty()){
return true;
}
for (Map.Entry<String, Object> entry : jo.entrySet()) {
if(isNotNull(entry.getValue())){
return false;
}
}
return true;
}
public static boolean isNotEmpty(com.alibaba.fastjson.JSONObject val)
{
return !isEmpty(val);
}
public static boolean isEmpty(com.alibaba.fastjson.JSONArray val)
{
com.alibaba.fastjson.JSONArray arr = (com.alibaba.fastjson.JSONArray) val;
if (arr==null || arr.size()==0)
{
return true;
}
return false;
}
public static boolean isNotEmpty(com.alibaba.fastjson.JSONArray val)
{
return !isEmpty(val);
}
public static boolean isNull(Object object)
{
return object == null;
}
public static boolean isNotNull(Object object)
{
return !isNull(object);
}
public static boolean isArray(Object object)
{
return isNotNull(object) && object.getClass().isArray();
}
public static String trim(String str)
{
return (str == null ? "" : str.trim());
}
public static String substring(final String str, int start)
{
if (str == null)
{
return NULLSTR;
}
if (start < 0)
{
start = str.length() + start;
}
if (start < 0)
{
start = 0;
}
if (start > str.length())
{
return NULLSTR;
}
return str.substring(start);
}
public static String substring(final String str, int start, int end)
{
if (str == null)
{
return NULLSTR;
}
if (end < 0)
{
end = str.length() + end;
}
if (start < 0)
{
start = str.length() + start;
}
if (end > str.length())
{
end = str.length();
}
if (start > end)
{
return NULLSTR;
}
if (start < 0)
{
start = 0;
}
if (end < 0)
{
end = 0;
}
return str.substring(start, end);
}
public static String format(String template, Object... params)
{
if (isEmpty(params) || isEmpty(template))
{
return template;
}
return StrFormatter.format(template, params);
}
public static boolean isHttp(String link)
{
return StringUtils.startsWithAny(link, CharsetKitConsts.HTTP, CharsetKitConsts.HTTPS);
}
public static final Set<String> str2Set(String str, String sep)
{
return new HashSet<String>(str2List(str, sep, true, false));
}
public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim)
{
List<String> list = new ArrayList<String>();
if (StringUtils.isEmpty(str))
{
return list;
}
if (filterBlank && StringUtils.isBlank(str))
{
return list;
}
String[] split = str.split(sep);
for (String string : split)
{
if (filterBlank && StringUtils.isBlank(string))
{
continue;
}
if (trim)
{
string = string.trim();
}
list.add(string);
}
return list;
}
public static boolean containsAnyIgnoreCase(CharSequence cs, CharSequence... searchCharSequences)
{
if (isEmpty(cs) || isEmpty(searchCharSequences))
{
return false;
}
for (CharSequence testStr : searchCharSequences)
{
if (containsIgnoreCase(cs, testStr))
{
return true;
}
}
return false;
}
public static String toUnderScoreCase(String str)
{
if (str == null)
{
return null;
}
StringBuilder sb = new StringBuilder();
boolean preCharIsUpperCase = true;
boolean curreCharIsUpperCase = true;
boolean nexteCharIsUpperCase = true;
for (int i = 0; i < str.length(); i++)
{
char c = str.charAt(i);
if (i > 0)
{
preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
}
else
{
preCharIsUpperCase = false;
}
curreCharIsUpperCase = Character.isUpperCase(c);
if (i < (str.length() - 1))
{
nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
}
if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
{
sb.append(SEPARATOR);
}
else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
{
sb.append(SEPARATOR);
}
sb.append(Character.toLowerCase(c));
}
return sb.toString();
}
public static boolean inStringIgnoreCase(String str, String... strs)
{
if (str != null && strs != null)
{
for (String s : strs)
{
if (str.equalsIgnoreCase(trim(s)))
{
return true;
}
}
}
return false;
}
public static String convertToCamelCase(String name)
{
StringBuilder result = new StringBuilder();
if (name == null || name.isEmpty())
{
return "";
}
else if (!name.contains("_"))
{
return name.substring(0, 1).toUpperCase() + name.substring(1);
}
String[] camels = name.split("_");
for (String camel : camels)
{
if (camel.isEmpty())
{
continue;
}
result.append(camel.substring(0, 1).toUpperCase());
result.append(camel.substring(1).toLowerCase());
}
return result.toString();
}
public static String toCamelCase(String s)
{
if (s == null)
{
return null;
}
s = s.toLowerCase();
StringBuilder sb = new StringBuilder(s.length());
boolean upperCase = false;
for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if (c == SEPARATOR)
{
upperCase = true;
}
else if (upperCase)
{
sb.append(Character.toUpperCase(c));
upperCase = false;
}
else
{
sb.append(c);
}
}
return sb.toString();
}
public static boolean matches(String str, List<String> strs)
{
if (isEmpty(str) || isEmpty(strs))
{
return false;
}
for (String pattern : strs)
{
if (isMatch(pattern, str))
{
return true;
}
}
return false;
}
public static boolean isMatch(String pattern, String url)
{
AntPathMatcher matcher = new AntPathMatcher();
return matcher.match(pattern, url);
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj)
{
return (T) obj;
}
public static String getTailNum(String number){
StringBuffer tailNum = new StringBuffer();
if (number != null && !"".equals(number) && number.length() >= 4) {
int len = number.length();
for (int i = len - 1; i >= len - 4; i--) {
tailNum.append(number.charAt(i));
}
tailNum.reverse();
}
return tailNum.toString();
}
public static boolean hasText(String str)
{
return (str != null && !str.isEmpty() && containsText(str));
}
private static boolean containsText(CharSequence str)
{
int strLen = str.length();
for (int i = 0; i < strLen; i++)
{
if (!Character.isWhitespace(str.charAt(i)))
{
return true;
}
}
return false;
}
}
UUID 提供通用唯一识别码(universally unique identifier)(UUID)实现
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public final class UUID implements java.io.Serializable, Comparable<UUID>
{
private static final long serialVersionUID = -1185015143654744140L;
private static class Holder
{
static final SecureRandom numberGenerator = getSecureRandom();
}
private final long mostSigBits;
private final long leastSigBits;
private UUID(byte[] data)
{
long msb = 0;
long lsb = 0;
assert data.length == 16 : "data must be 16 bytes in length";
for (int i = 0; i < 8; i++)
{
msb = (msb << 8) | (data[i] & 0xff);
}
for (int i = 8; i < 16; i++)
{
lsb = (lsb << 8) | (data[i] & 0xff);
}
this.mostSigBits = msb;
this.leastSigBits = lsb;
}
public UUID(long mostSigBits, long leastSigBits)
{
this.mostSigBits = mostSigBits;
this.leastSigBits = leastSigBits;
}
public static UUID fastUUID()
{
return randomUUID(false);
}
public static UUID randomUUID()
{
return randomUUID(true);
}
public static UUID randomUUID(boolean isSecure)
{
final Random ng = isSecure ? Holder.numberGenerator : getRandom();
byte[] randomBytes = new byte[16];
ng.nextBytes(randomBytes);
randomBytes[6] &= 0x0f;
randomBytes[6] |= 0x40;
randomBytes[8] &= 0x3f;
randomBytes[8] |= 0x80;
return new UUID(randomBytes);
}
public static UUID nameUUIDFromBytes(byte[] name)
{
MessageDigest md;
try
{
md = MessageDigest.getInstance("MD5");
}
catch (NoSuchAlgorithmException nsae)
{
throw new InternalError("MD5 not supported");
}
byte[] md5Bytes = md.digest(name);
md5Bytes[6] &= 0x0f;
md5Bytes[6] |= 0x30;
md5Bytes[8] &= 0x3f;
md5Bytes[8] |= 0x80;
return new UUID(md5Bytes);
}
public static UUID fromString(String name)
{
String[] components = name.split("-");
if (components.length != 5)
{
throw new IllegalArgumentException("Invalid UUID string: " + name);
}
for (int i = 0; i < 5; i++)
{
components[i] = "0x" + components[i];
}
long mostSigBits = Long.decode(components[0]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(components[1]).longValue();
mostSigBits <<= 16;
mostSigBits |= Long.decode(components[2]).longValue();
long leastSigBits = Long.decode(components[3]).longValue();
leastSigBits <<= 48;
leastSigBits |= Long.decode(components[4]).longValue();
return new UUID(mostSigBits, leastSigBits);
}
public long getLeastSignificantBits()
{
return leastSigBits;
}
public long getMostSignificantBits()
{
return mostSigBits;
}
public int version()
{
return (int) ((mostSigBits >> 12) & 0x0f);
}
public int variant()
{
return (int) ((leastSigBits >>> (64 - (leastSigBits >>> 62))) & (leastSigBits >> 63));
}
public long timestamp() throws UnsupportedOperationException
{
checkTimeBase();
return (mostSigBits & 0x0FFFL) << 48
| ((mostSigBits >> 16) & 0x0FFFFL) << 32
| mostSigBits >>> 32;
}
public int clockSequence() throws UnsupportedOperationException
{
checkTimeBase();
return (int) ((leastSigBits & 0x3FFF000000000000L) >>> 48);
}
public long node() throws UnsupportedOperationException
{
checkTimeBase();
return leastSigBits & 0x0000FFFFFFFFFFFFL;
}
@Override
public String toString()
{
return toString(false);
}
public String toString(boolean isSimple)
{
final StringBuilder builder = new StringBuilder(isSimple ? 32 : 36);
builder.append(digits(mostSigBits >> 32, 8));
if (false == isSimple)
{
builder.append('-');
}
builder.append(digits(mostSigBits >> 16, 4));
if (false == isSimple)
{
builder.append('-');
}
builder.append(digits(mostSigBits, 4));
if (false == isSimple)
{
builder.append('-');
}
builder.append(digits(leastSigBits >> 48, 4));
if (false == isSimple)
{
builder.append('-');
}
builder.append(digits(leastSigBits, 12));
return builder.toString();
}
@Override
public int hashCode()
{
long hilo = mostSigBits ^ leastSigBits;
return ((int) (hilo >> 32)) ^ (int) hilo;
}
@Override
public boolean equals(Object obj)
{
if ((null == obj) || (obj.getClass() != UUID.class))
{
return false;
}
UUID id = (UUID) obj;
return (mostSigBits == id.mostSigBits && leastSigBits == id.leastSigBits);
}
@Override
public int compareTo(UUID val)
{
return (this.mostSigBits < val.mostSigBits ? -1 :
(this.mostSigBits > val.mostSigBits ? 1 :
(this.leastSigBits < val.leastSigBits ? -1 :
(this.leastSigBits > val.leastSigBits ? 1 :
0))));
}
private static String digits(long val, int digits)
{
long hi = 1L << (digits * 4);
return Long.toHexString(hi | (val & (hi - 1))).substring(1);
}
private void checkTimeBase()
{
if (version() != 1)
{
throw new UnsupportedOperationException("Not a time-based UUID");
}
}
public static SecureRandom getSecureRandom()
{
try
{
return SecureRandom.getInstance("SHA1PRNG");
}
catch (NoSuchAlgorithmException e)
{
throw new RuntimeException();
}
}
public static ThreadLocalRandom getRandom()
{
return ThreadLocalRandom.current();
}
public static String gen32UUID() {
return UUID.randomUUID().toString().replace("-", "");
}
}
client
MinioClientUtils
import io.minio.*;
import io.minio.messages.Bucket;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.List;
import java.util.Optional;
public class MinioClientUtils {
private static final Log log = LogFactory.getLog(MinioClientUtils.class);
private static MinioConfig minioConfig = SpringUtils.getBean(MinioConfig.class);
private static MinioClient minioClient = SpringUtils.getBean(MinioClient.class);
public static void makeBucket(String bucketName) throws Exception {
if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
}
}
public static List<Bucket> listBuckets() throws Exception {
return minioClient.listBuckets();
}
public static Optional<Bucket> getBucket(String bucketName) throws Exception {
return listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
}
public static void removeBucket(String bucketName) throws Exception {
minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
}
public static String getObjectURL(String bucketName, String objectName) throws Exception {
return getObjectURL(bucketName, objectName, 7);
}
public static String getObjectURL(String bucketName, String objectName, Integer expires) throws Exception {
return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(objectName).expiry(expires).build());
}
public static InputStream getObject(String bucketName, String objectName) throws Exception {
return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
}
public static InputStream getObject(String bucketName, String objectName, long offset, Long length) throws Exception {
return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).offset(offset).length(length).build());
}
public static String getPresignedObjectUrl(String bucketName, String objectName) throws Exception {
return getPresignedObjectUrl(bucketName, objectName, null);
}
public static String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) throws Exception {
return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(objectName).build());
}
public static void removeObject(String bucketName, String objectName) throws Exception {
minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
}
public static String putObject(String bucketName, String objectName, MultipartFile file) throws Exception {
if (objectName== null || "".equals(objectName)) {
objectName = FileUploadUtils.extractFilename(file);
}
PutObjectArgs args = PutObjectArgs.builder()
.bucket(bucketName)
.object(objectName)
.stream(file.getInputStream(), file.getSize(), -1)
.contentType(file.getContentType())
.build();
makeBucket(bucketName);
minioClient.putObject(args);
return minioConfig.getPreviewUrl() + "/" + bucketName + "/" + objectName;
}
public static final String extractFilename(MultipartFile file)
{
String fileName = file.getOriginalFilename();
String extension = FileUploadUtils.getExtension(file);
fileName = FileUploadUtils.datePath() + "/" + IdUtils.fastUUID() + "." + extension;
return fileName;
}
public static final String extractFilename(File file)
{
String fileName = file.getName();
String extension = FileUploadUtils.getExtension(file);
fileName = FileUploadUtils.datePath() + "/" + IdUtils.fastUUID() + "." + extension;
return fileName;
}
public static String putObject(String bucketName, String objectName, File file) throws Exception {
if (objectName== null || "".equals(objectName)) {
objectName = FileUploadUtils.extractFilename(file);
}
InputStream inputStream = new FileInputStream(file);
try {
PutObjectArgs args = PutObjectArgs.builder()
.bucket(bucketName)
.object(objectName)
.stream(inputStream, file.length(), -1)
.contentType(FileUploadUtils.getContentType(file))
.build();
makeBucket(bucketName);
minioClient.putObject(args);
} catch (Exception e) {
throw e;
} finally {
inputStream.close();
}
return minioConfig.getPreviewUrl() + "/" + bucketName + "/" + objectName;
}
public static String putObject(String bucketName, MultipartFile file) throws Exception {
return putObject(bucketName, null, file);
}
public static String putObject(String bucketName, File file) throws Exception {
return putObject(bucketName, null, file);
}
}
如何调用
import com.bg.passcheckweb.minio.domain.OssFile;
import com.bg.passcheckweb.minio.service.IFileService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
@RestController
@RequestMapping("/oss/file")
public class OssFileController {
private static final Logger log = LoggerFactory.getLogger(OssFileController.class);
public static final int FILE_UPLOAD_FAIL = 302;
@Autowired
private IFileService fileService;
@PostMapping("/upload")
public Result upload(MultipartFile file, OssFile paramOssFile) {
try {
OssFile ossFile = fileService.uploadFile(file, paramOssFile);
return Result.success(ossFile);
} catch (Exception e) {
log.error("上传文件失败", e);
}
return Result.fail(String.valueOf(FILE_UPLOAD_FAIL), "上传文件失败");
}
}
返回结果对象的一个类,可以重新写
public class Result {
private boolean flag;
private Object data;
private String errorCode;
private String errorMsg;
public static Result success(Object data) {
Result result = new Result();
result.setFlag(true);
result.setData(data);
return result;
}
public static Result fail(String errorCode, String errorMsg) {
Result result = new Result();
result.setFlag(false);
result.setErrorCode(errorCode);
result.setErrorMsg(errorMsg);
return result;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public String getErrorCode() {
return errorCode;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public String getErrorMsg() {
return errorMsg;
}
public void setErrorMsg(String errorMsg) {
this.errorMsg = errorMsg;
}
}