java转输文件到linux服务器

java转输文件到linux服务器

参考JAVA 上传文件到另一台远程服务器(包含搭建文件服务器 基于Linux)java传输文件到另一个服务器Code_bot_00的博客-CSDN博客

SFTP创建目录和判断目录是否存在channelsftp判断目录是否存在@小顽皮的博客-CSDN博客

1、搭载文件服务器

1)下载tomcat,解压到linux服务器,修改web.xml文件,在webapps下创建files文件夹,启动tomcat

 

 

2)启动完成后即可访问,如果不能访问,看下网络策略,防火墙等是否关闭,建议这里使用nginx代理

 

2、上传功能代码

1)pom引入依赖

        <dependency>
           <groupId>commons-net</groupId>
           <artifactId>commons-net</artifactId>
           <version>3.6</version>
       </dependency>
       <dependency>
           <groupId>com.jcraft</groupId>
           <artifactId>jsch</artifactId>
           <version>0.1.54</version>
       </dependency>

2)功能代码

    @RequestMapping(value="/testUpload",method = RequestMethod.GET)
   public String testUpload(String url){
       try {
           MultipartFile multipartFile = UploadUtil.urlToMultipartFile(url);//将文件url地址转MultipartFile
           
           String fileName = extractFilename(multipartFile);//生成唯一文件名,我这里用的是若依的方法
           String path = DateUtils.datePath();//根据日期生成路径 yyyy/mm/dd
           
           //上传方法
           UploadUtil.uploadFile(path,fileName,multipartFile.getInputStream());
           return "上传成功!";
      } catch (Exception e) {
           e.printStackTrace();
      }
       return "上传失败!";
  }


/**
    * 编码文件名
    */
   public static final String extractFilename(MultipartFile file)
  {
       return StringUtils.format("{}_{}.{}",
               FilenameUtils.getBaseName(file.getOriginalFilename()), Seq.getId(Seq.uploadSeqType), getExtension(file));
  }



   /**
    * 获取文件名的后缀
    *
    * @param file 表单文件
    * @return 后缀名
    */
   public static final String getExtension(MultipartFile file)
  {
       String extension = FilenameUtils.getExtension(file.getOriginalFilename());
       if (StringUtils.isEmpty(extension))
      {
           extension = MimeTypeUtils.getExtension(Objects.requireNonNull(file.getContentType()));
      }
       return extension;
  }
package com.czry.interfacetest.util;

import com.jcraft.jsch.*;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.net.ftp.FTPClient;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Properties;

public class UploadUtil {
   private static ChannelSftp sftp = null;
   /**
    * Description: 向FTP服务器上传文件
    * @param filename 上传到FTP服务器上的文件名
    * @param input   输入流
    * @return 成功返回true,否则返回false
    */
   public static boolean uploadFile(String path,String filename, InputStream input) {
       boolean result = false;
       FTPClient ftp = new FTPClient();
       File file = null;
       try {
           JSch jsch = new JSch();
           //获取sshSession 账号-ip-端口
           Session sshSession = jsch.getSession("root", "192.168.10.129", 22);
           //添加密码
           sshSession.setPassword("123456");
           Properties sshConfig = new Properties();
           //严格主机密钥检查
           sshConfig.put("StrictHostKeyChecking", "no");
           sshSession.setConfig(sshConfig);
           //开启sshSession链接
           sshSession.connect();
           //获取sftp通道
           Channel channel = sshSession.openChannel("sftp");
           //开启
           channel.connect();
           sftp = (ChannelSftp) channel;
           //服务器路径
           /*file = new File("/home/tomcat/apache-tomcat-9.0.39/webapps/files/"+path);
           file.mkdirs();*/
           //设置为被动模式
           ftp.enterLocalPassiveMode();
           //验证是否存在目录,不存在的话创建
           if(createDir("/home/tomcat/apache-tomcat-9.0.39/webapps/files/"+path,sftp)){
               //设置上传文件的类型为二进制类型
               //进入到要上传的目录 然后上传文件
               sftp.cd("/home/tomcat/apache-tomcat-9.0.39/webapps/files/"+path);
               sftp.put(input, filename);
          }
           input.close();
           result = true;
      } catch (Exception e) {
           e.printStackTrace();
      } finally {
           if (ftp.isConnected()) {
               try {
                   ftp.disconnect();
              } catch (IOException ioe) {
              }
          }
      }
       return result;
  }


   /**
    * url转MultipartFile
    * @param url
    * @return
    * @throws Exception
    */
   public static MultipartFile urlToMultipartFile(String url) {
       File file = null;
       MultipartFile multipartFile = null;
       try {
           HttpURLConnection httpUrl = (HttpURLConnection) new URL(url).openConnection();
           httpUrl.connect();
           file = inputStreamToFile(httpUrl.getInputStream(),"template.png");

           multipartFile = fileToMultipartFile(file);
           file.delete();
           httpUrl.disconnect();
      } catch (Exception e) {
           e.printStackTrace();
      }
       return multipartFile;
  }

   /**
    * inputStream 转 File
    * @param ins
    * @param name
    * @return
    * @throws Exception
    */
   public static File inputStreamToFile(InputStream ins, String name) throws Exception{
       File file = new File(System.getProperty("user.dir") + File.separator + name);
       OutputStream os = new FileOutputStream(file);
       int bytesRead;
       int len = 8192;
       byte[] buffer = new byte[len];
       while ((bytesRead = ins.read(buffer, 0, len)) != -1) {
           os.write(buffer, 0, bytesRead);
      }
       os.close();
       ins.close();
       return file;
  }

   /**
    * file转multipartFile
    * @param file
    * @return
    */
   public static MultipartFile fileToMultipartFile(File file) {
       FileItemFactory factory = new DiskFileItemFactory(16, null);
       FileItem item=factory.createItem(file.getName(),"text/plain",true,file.getName());
       int bytesRead = 0;
       byte[] buffer = new byte[8192];
       try {
           FileInputStream fis = new FileInputStream(file);
           OutputStream os = item.getOutputStream();
           while ((bytesRead = fis.read(buffer, 0, 8192)) != -1) {
               os.write(buffer, 0, bytesRead);
          }
           os.close();
           fis.close();
      } catch (IOException e) {
           e.printStackTrace();
      }
       return new CommonsMultipartFile(item);
  }


   /**
    * 创建目录
    * @param createpath
    * @return
    */
   public static boolean createDir(String createpath, ChannelSftp sftp) {
       try
      {
           if (isDirExist(createpath,sftp)) {
               sftp.cd(createpath);
               return true;
          }
           String pathArry[] = createpath.split("/");
           StringBuffer filePath = new StringBuffer("/");
           for (String path : pathArry) {
               if (path.equals("")) {
                   continue;
              }
               filePath.append(path + "/");
               if (isDirExist(filePath.toString(),sftp)) {
                   sftp.cd(filePath.toString());
              } else {
                   // 建立目录
                   sftp.mkdir(filePath.toString());
                   // 进入并设置为当前目录
                   sftp.cd(filePath.toString());
              }
          }
           sftp.cd(createpath);
           return true;
      }
       catch (SftpException e) {
           e.printStackTrace();
      }
       return false;
  }


   /**
    * 判断目录是否存在
    * @param directory
    * @return
    */
   public static boolean isDirExist(String directory, ChannelSftp sftp)
  {
       boolean isDirExistFlag = false;
       try
      {
           SftpATTRS sftpATTRS = sftp.lstat(directory);
           isDirExistFlag = true;
           return sftpATTRS.isDir();
      }
       catch (Exception e)
      {
           if (e.getMessage().toLowerCase().equals("no such file"))
          {
               isDirExistFlag = false;
          }
      }
       return isDirExistFlag;
  }


}


下面的类都是为了生成唯一文件名,和路径用的

package com.czry.interfacetest.util;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

/**
* 字符集工具类
*
* @author ruoyi
*/
public class CharsetKit
{
   /** ISO-8859-1 */
   public static final String ISO_8859_1 = "ISO-8859-1";
   /** UTF-8 */
   public static final String UTF_8 = "UTF-8";
   /** GBK */
   public static final String GBK = "GBK";

   /** ISO-8859-1 */
   public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1);
   /** UTF-8 */
   public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8);
   /** GBK */
   public static final Charset CHARSET_GBK = Charset.forName(GBK);

   /**
    * 转换为Charset对象
    *
    * @param charset 字符集,为空则返回默认字符集
    * @return Charset
    */
   public static Charset charset(String charset)
  {
       return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset);
  }

   /**
    * 转换字符串的字符集编码
    *
    * @param source 字符串
    * @param srcCharset 源字符集,默认ISO-8859-1
    * @param destCharset 目标字符集,默认UTF-8
    * @return 转换后的字符集
    */
   public static String convert(String source, String srcCharset, String destCharset)
  {
       return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset));
  }

   /**
    * 转换字符串的字符集编码
    *
    * @param source 字符串
    * @param srcCharset 源字符集,默认ISO-8859-1
    * @param destCharset 目标字符集,默认UTF-8
    * @return 转换后的字符集
    */
   public static String convert(String source, Charset srcCharset, Charset destCharset)
  {
       if (null == srcCharset)
      {
           srcCharset = StandardCharsets.ISO_8859_1;
      }

       if (null == destCharset)
      {
           destCharset = StandardCharsets.UTF_8;
      }

       if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset))
      {
           return source;
      }
       return new String(source.getBytes(srcCharset), destCharset);
  }

   /**
    * @return 系统字符集编码
    */
   public static String systemCharset()
  {
       return Charset.defaultCharset().name();
  }
}
package com.czry.interfacetest.util;

import org.apache.commons.lang3.ArrayUtils;

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;

/**
* 类型转换器
*
* @author ruoyi
*/
public class Convert
{
   /**
    * 转换为字符串<br>
    * 如果给定的值为null,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   public static String toStr(Object value, String defaultValue)
  {
       if (null == value)
      {
           return defaultValue;
      }
       if (value instanceof String)
      {
           return (String) value;
      }
       return value.toString();
  }

   /**
    * 转换为字符串<br>
    * 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static String toStr(Object value)
  {
       return toStr(value, null);
  }

   /**
    * 转换为字符<br>
    * 如果给定的值为null,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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);
  }

   /**
    * 转换为字符<br>
    * 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static Character toChar(Object value)
  {
       return toChar(value, null);
  }

   /**
    * 转换为byte<br>
    * 如果给定的值为<code>null</code>,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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;
      }
  }

   /**
    * 转换为byte<br>
    * 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static Byte toByte(Object value)
  {
       return toByte(value, null);
  }

   /**
    * 转换为Short<br>
    * 如果给定的值为<code>null</code>,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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;
      }
  }

   /**
    * 转换为Short<br>
    * 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static Short toShort(Object value)
  {
       return toShort(value, null);
  }

   /**
    * 转换为Number<br>
    * 如果给定的值为空,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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;
      }
  }

   /**
    * 转换为Number<br>
    * 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static Number toNumber(Object value)
  {
       return toNumber(value, null);
  }

   /**
    * 转换为int<br>
    * 如果给定的值为空,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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;
      }
  }

   /**
    * 转换为int<br>
    * 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static Integer toInt(Object value)
  {
       return toInt(value, null);
  }

   /**
    * 转换为Integer数组<br>
    *
    * @param str 被转换的值
    * @return 结果
    */
   public static Integer[] toIntArray(String str)
  {
       return toIntArray(",", str);
  }

   /**
    * 转换为Long数组<br>
    *
    * @param str 被转换的值
    * @return 结果
    */
   public static Long[] toLongArray(String str)
  {
       return toLongArray(",", str);
  }

   /**
    * 转换为Integer数组<br>
    *
    * @param split 分隔符
    * @param split 被转换的值
    * @return 结果
    */
   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;
  }

   /**
    * 转换为Long数组<br>
    *
    * @param split 分隔符
    * @param str 被转换的值
    * @return 结果
    */
   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;
  }

   /**
    * 转换为String数组<br>
    *
    * @param str 被转换的值
    * @return 结果
    */
   public static String[] toStrArray(String str)
  {
       return toStrArray(",", str);
  }

   /**
    * 转换为String数组<br>
    *
    * @param split 分隔符
    * @param split 被转换的值
    * @return 结果
    */
   public static String[] toStrArray(String split, String str)
  {
       return str.split(split);
  }

   /**
    * 转换为long<br>
    * 如果给定的值为空,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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;
      }
  }

   /**
    * 转换为long<br>
    * 如果给定的值为<code>null</code>,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static Long toLong(Object value)
  {
       return toLong(value, null);
  }

   /**
    * 转换为double<br>
    * 如果给定的值为空,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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;
      }
  }

   /**
    * 转换为double<br>
    * 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static Double toDouble(Object value)
  {
       return toDouble(value, null);
  }

   /**
    * 转换为Float<br>
    * 如果给定的值为空,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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;
      }
  }

   /**
    * 转换为Float<br>
    * 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static Float toFloat(Object value)
  {
       return toFloat(value, null);
  }

   /**
    * 转换为boolean<br>
    * String支持的值为:true、false、yes、ok、no,1,0 如果给定的值为空,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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":
           case "yes":
           case "ok":
           case "1":
               return true;
           case "false":
           case "no":
           case "0":
               return false;
           default:
               return defaultValue;
      }
  }

   /**
    * 转换为boolean<br>
    * 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static Boolean toBool(Object value)
  {
       return toBool(value, null);
  }

   /**
    * 转换为Enum对象<br>
    * 如果给定的值为空,或者转换失败,返回默认值<br>
    *
    * @param clazz Enum的Class
    * @param value 值
    * @param defaultValue 默认值
    * @return Enum
    */
   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;
      }
  }

   /**
    * 转换为Enum对象<br>
    * 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
    *
    * @param clazz Enum的Class
    * @param value 值
    * @return Enum
    */
   public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value)
  {
       return toEnum(clazz, value, null);
  }

   /**
    * 转换为BigInteger<br>
    * 如果给定的值为空,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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;
      }
  }

   /**
    * 转换为BigInteger<br>
    * 如果给定的值为空,或者转换失败,返回默认值<code>null</code><br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static BigInteger toBigInteger(Object value)
  {
       return toBigInteger(value, null);
  }

   /**
    * 转换为BigDecimal<br>
    * 如果给定的值为空,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @param defaultValue 转换错误时的默认值
    * @return 结果
    */
   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 BigDecimal.valueOf((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;
      }
  }

   /**
    * 转换为BigDecimal<br>
    * 如果给定的值为空,或者转换失败,返回默认值<br>
    * 转换失败不会报错
    *
    * @param value 被转换的值
    * @return 结果
    */
   public static BigDecimal toBigDecimal(Object value)
  {
       return toBigDecimal(value, null);
  }

   /**
    * 将对象转为字符串<br>
    * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    *
    * @param obj 对象
    * @return 字符串
    */
   public static String utf8Str(Object obj)
  {
       return str(obj, CharsetKit.CHARSET_UTF_8);
  }

   /**
    * 将对象转为字符串<br>
    * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    *
    * @param obj 对象
    * @param charsetName 字符集
    * @return 字符串
    */
   public static String str(Object obj, String charsetName)
  {
       return str(obj, Charset.forName(charsetName));
  }

   /**
    * 将对象转为字符串<br>
    * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
    *
    * @param obj 对象
    * @param charset 字符集
    * @return 字符串
    */
   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();
  }

   /**
    * 将byte数组转为字符串
    *
    * @param bytes byte数组
    * @param charset 字符集
    * @return 字符串
    */
   public static String str(byte[] bytes, String charset)
  {
       return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
  }

   /**
    * 解码字节码
    *
    * @param data 字符串
    * @param charset 字符集,如果此字段为空,则解码的结果取决于平台
    * @return 解码后的字符串
    */
   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);
  }

   /**
    * 将编码的byteBuffer数据转换为字符串
    *
    * @param data 数据
    * @param charset 字符集,如果为空使用当前系统字符集
    * @return 字符串
    */
   public static String str(ByteBuffer data, String charset)
  {
       if (data == null)
      {
           return null;
      }

       return str(data, Charset.forName(charset));
  }

   /**
    * 将编码的byteBuffer数据转换为字符串
    *
    * @param data 数据
    * @param charset 字符集,如果为空使用当前系统字符集
    * @return 字符串
    */
   public static String str(ByteBuffer data, Charset charset)
  {
       if (null == charset)
      {
           charset = Charset.defaultCharset();
      }
       return charset.decode(data).toString();
  }

   // ----------------------------------------------------------------------- 全角半角转换
   /**
    * 半角转全角
    *
    * @param input String.
    * @return 全角字符串.
    */
   public static String toSBC(String input)
  {
       return toSBC(input, null);
  }

   /**
    * 半角转全角
    *
    * @param input String
    * @param notConvertSet 不替换的字符集合
    * @return 全角字符串.
    */
   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);
  }

   /**
    * 全角转半角
    *
    * @param input String.
    * @return 半角字符串
    */
   public static String toDBC(String input)
  {
       return toDBC(input, null);
  }

   /**
    * 替换全角为半角
    *
    * @param text 文本
    * @param notConvertSet 不替换的字符集合
    * @return 替换后的字符
    */
   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;
  }

   /**
    * 数字金额大写转换 先写个完整的然后将如零拾替换成零
    *
    * @param n 数字
    * @return 中文大写数字
    */
   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("^整$", "零元整");
  }
}
package com.czry.interfacetest.util;

import org.apache.commons.lang3.time.DateFormatUtils;

import java.lang.management.ManagementFactory;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.util.Date;

/**
* 时间工具类
*
* @author ruoyi
*/
public class DateUtils extends org.apache.commons.lang3.time.DateUtils
{
   public static String YYYY = "yyyy";

   public static String YYYY_MM = "yyyy-MM";

   public static String YYYY_MM_DD = "yyyy-MM-dd";

   public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

   public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

   private static String[] parsePatterns = {
           "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
           "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
           "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};

   /**
    * 获取当前Date型日期
    *
    * @return Date() 当前日期
    */
   public static Date getNowDate()
  {
       return new Date();
  }

   /**
    * 获取当前日期, 默认格式为yyyy-MM-dd
    *
    * @return String
    */
   public static String getDate()
  {
       return dateTimeNow(YYYY_MM_DD);
  }

   public static final String getTime()
  {
       return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
  }

   public static final String dateTimeNow()
  {
       return dateTimeNow(YYYYMMDDHHMMSS);
  }

   public static final String dateTimeNow(final String format)
  {
       return parseDateToStr(format, new Date());
  }

   public static final String dateTime(final Date date)
  {
       return parseDateToStr(YYYY_MM_DD, date);
  }

   public static final String parseDateToStr(final String format, final Date date)
  {
       return new SimpleDateFormat(format).format(date);
  }

   public static final Date dateTime(final String format, final String ts)
  {
       try
      {
           return new SimpleDateFormat(format).parse(ts);
      }
       catch (ParseException e)
      {
           throw new RuntimeException(e);
      }
  }

   /**
    * 日期路径 即年/月/日 如2018/08/08
    */
   public static final String datePath()
  {
       Date now = new Date();
       return DateFormatUtils.format(now, "yyyy/MM/dd");
  }

   /**
    * 日期路径 即年/月/日 如20180808
    */
   public static final String dateTime()
  {
       Date now = new Date();
       return DateFormatUtils.format(now, "yyyyMMdd");
  }

   /**
    * 日期型字符串转化为日期 格式
    */
   public static Date parseDate(Object str)
  {
       if (str == null)
      {
           return null;
      }
       try
      {
           return parseDate(str.toString(), parsePatterns);
      }
       catch (ParseException e)
      {
           return null;
      }
  }

   /**
    * 获取服务器启动时间
    */
   public static Date getServerStartDate()
  {
       long time = ManagementFactory.getRuntimeMXBean().getStartTime();
       return new Date(time);
  }

   /**
    * 计算相差天数
    */
   public static int differentDaysByMillisecond(Date date1, Date date2)
  {
       return Math.abs((int) ((date2.getTime() - date1.getTime()) / (1000 * 3600 * 24)));
  }

   /**
    * 计算时间差
    *
    * @param endTime 最后时间
    * @param startTime 开始时间
    * @return 时间差(天/小时/分钟)
    */
   public static String timeDistance(Date endDate, Date startTime)
  {
       long nd = 1000 * 24 * 60 * 60;
       long nh = 1000 * 60 * 60;
       long nm = 1000 * 60;
       // long ns = 1000;
       // 获得两个时间的毫秒时间差异
       long diff = endDate.getTime() - startTime.getTime();
       // 计算差多少天
       long day = diff / nd;
       // 计算差多少小时
       long hour = diff % nd / nh;
       // 计算差多少分钟
       long min = diff % nd % nh / nm;
       // 计算差多少秒//输出结果
       // long sec = diff % nd % nh % nm / ns;
       return day + "天" + hour + "小时" + min + "分钟";
  }

   /**
    * 增加 LocalDateTime ==> Date
    */
   public static Date toDate(LocalDateTime temporalAccessor)
  {
       ZonedDateTime zdt = temporalAccessor.atZone(ZoneId.systemDefault());
       return Date.from(zdt.toInstant());
  }

   /**
    * 增加 LocalDate ==> Date
    */
   public static Date toDate(LocalDate temporalAccessor)
  {
       LocalDateTime localDateTime = LocalDateTime.of(temporalAccessor, LocalTime.of(0, 0, 0));
       ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
       return Date.from(zdt.toInstant());
  }
}
package com.czry.interfacetest.util;

/**
* 媒体类型工具类
*
* @author ruoyi
*/
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",
           // word excel powerpoint
           "doc", "docx", "xls", "xlsx", "ppt", "pptx", "html", "htm", "txt",
           // 压缩文件
           "rar", "zip", "gz", "bz2",
           // 视频格式
           "mp4", "avi", "rmvb",
           // pdf
           "pdf" };

   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 "";
      }
  }
}
package com.czry.interfacetest.util;

import java.util.concurrent.atomic.AtomicInteger;

/**
* @author ruoyi 序列生成类
*/
public class Seq
{
   // 通用序列类型
   public static final String commSeqType = "COMMON";

   // 上传序列类型
   public static final String uploadSeqType = "UPLOAD";

   // 通用接口序列数
   private static AtomicInteger commSeq = new AtomicInteger(1);

   // 上传接口序列数
   private static AtomicInteger uploadSeq = new AtomicInteger(1);

   // 机器标识
   private static final String machineCode = "A";

   /**
    * 获取通用序列号
    *
    * @return 序列值
    */
   public static String getId()
  {
       return getId(commSeqType);
  }

   /**
    * 默认16位序列号 yyMMddHHmmss + 一位机器标识 + 3长度循环递增字符串
    *
    * @return 序列值
    */
   public static String getId(String type)
  {
       AtomicInteger atomicInt = commSeq;
       if (uploadSeqType.equals(type))
      {
           atomicInt = uploadSeq;
      }
       return getId(atomicInt, 3);
  }

   /**
    * 通用接口序列号 yyMMddHHmmss + 一位机器标识 + length长度循环递增字符串
    *
    * @param atomicInt 序列数
    * @param length 数值长度
    * @return 序列值
    */
   public static String getId(AtomicInteger atomicInt, int length)
  {
       String result = DateUtils.dateTimeNow();
       result += machineCode;
       result += getSeq(atomicInt, length);
       return result;
  }

   /**
    * 序列循环递增字符串[1, 10 的 (length)幂次方), 用0左补齐length位数
    *
    * @return 序列值
    */
   private synchronized static String getSeq(AtomicInteger atomicInt, int length)
  {
       // 先取值再+1
       int value = atomicInt.getAndIncrement();

       // 如果更新后值>=10 的 (length)幂次方则重置为1
       int maxSeq = (int) Math.pow(10, length);
       if (atomicInt.get() >= maxSeq)
      {
           atomicInt.set(1);
      }
       // 转字符串,用0左补齐
       return StringUtils.padl(value, length);
  }
}
package com.czry.interfacetest.util;

/**
* 字符串格式化
*
* @author ruoyi
*/
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 = '}';

   /**
    * 格式化字符串<br>
    * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
    * 如果想输出 {} 使用 \\转义 { 即可,如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
    * 例:<br>
    * 通常使用:format("this is {} for {}", "a", "b") -> this is a for b<br>
    * 转义{}: format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
    * 转义\: format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
    *
    * @param strPattern 字符串模板
    * @param argArray 参数列表
    * @return 结果
    */
   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();
  }
}
package com.czry.interfacetest.util;


import org.springframework.util.AntPathMatcher;

import java.util.*;

/**
* 字符串工具类
*
* @author ruoyi
*/
public class StringUtils extends org.apache.commons.lang3.StringUtils
{
   /** 空字符串 */
   private static final String NULLSTR = "";

   /** 下划线 */
   private static final char SEPARATOR = '_';

   /**
    * 获取参数不为空值
    *
    * @param value defaultValue 要判断的value
    * @return value 返回值
    */
   public static <T> T nvl(T value, T defaultValue)
  {
       return value != null ? value : defaultValue;
  }

   /**
    * * 判断一个Collection是否为空, 包含List,Set,Queue
    *
    * @param coll 要判断的Collection
    * @return true:为空 false:非空
    */
   public static boolean isEmpty(Collection<?> coll)
  {
       return isNull(coll) || coll.isEmpty();
  }

   /**
    * * 判断一个Collection是否非空,包含List,Set,Queue
    *
    * @param coll 要判断的Collection
    * @return true:非空 false:空
    */
   public static boolean isNotEmpty(Collection<?> coll)
  {
       return !isEmpty(coll);
  }

   /**
    * * 判断一个对象数组是否为空
    *
    * @param objects 要判断的对象数组
    ** @return true:为空 false:非空
    */
   public static boolean isEmpty(Object[] objects)
  {
       return isNull(objects) || (objects.length == 0);
  }

   /**
    * * 判断一个对象数组是否非空
    *
    * @param objects 要判断的对象数组
    * @return true:非空 false:空
    */
   public static boolean isNotEmpty(Object[] objects)
  {
       return !isEmpty(objects);
  }

   /**
    * * 判断一个Map是否为空
    *
    * @param map 要判断的Map
    * @return true:为空 false:非空
    */
   public static boolean isEmpty(Map<?, ?> map)
  {
       return isNull(map) || map.isEmpty();
  }

   /**
    * * 判断一个Map是否为空
    *
    * @param map 要判断的Map
    * @return true:非空 false:空
    */
   public static boolean isNotEmpty(Map<?, ?> map)
  {
       return !isEmpty(map);
  }

   /**
    * * 判断一个字符串是否为空串
    *
    * @param str String
    * @return true:为空 false:非空
    */
   public static boolean isEmpty(String str)
  {
       return isNull(str) || NULLSTR.equals(str.trim());
  }

   /**
    * * 判断一个字符串是否为非空串
    *
    * @param str String
    * @return true:非空串 false:空串
    */
   public static boolean isNotEmpty(String str)
  {
       return !isEmpty(str);
  }

   /**
    * * 判断一个对象是否为空
    *
    * @param object Object
    * @return true:为空 false:非空
    */
   public static boolean isNull(Object object)
  {
       return object == null;
  }

   /**
    * * 判断一个对象是否非空
    *
    * @param object Object
    * @return true:非空 false:空
    */
   public static boolean isNotNull(Object object)
  {
       return !isNull(object);
  }

   /**
    * * 判断一个对象是否是数组类型(Java基本型别的数组)
    *
    * @param object 对象
    * @return true:是数组 false:不是数组
    */
   public static boolean isArray(Object object)
  {
       return isNotNull(object) && object.getClass().isArray();
  }

   /**
    * 去空格
    */
   public static String trim(String str)
  {
       return (str == null ? "" : str.trim());
  }

   /**
    * 截取字符串
    *
    * @param str 字符串
    * @param start 开始
    * @return 结果
    */
   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);
  }

   /**
    * 截取字符串
    *
    * @param str 字符串
    * @param start 开始
    * @param end 结束
    * @return 结果
    */
   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);
  }

   /**
    * 格式化文本, {} 表示占位符<br>
    * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
    * 如果想输出 {} 使用 \\转义 { 即可,如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
    * 例:<br>
    * 通常使用:format("this is {} for {}", "a", "b") -> this is a for b<br>
    * 转义{}: format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
    * 转义\: format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
    *
    * @param template 文本模板,被替换的部分用 {} 表示
    * @param params 参数值
    * @return 格式化后的文本
    */
   public static String format(String template, Object... params)
  {
       if (isEmpty(params) || isEmpty(template))
      {
           return template;
      }
       return StrFormatter.format(template, params);
  }


   /**
    * 字符串转set
    *
    * @param str 字符串
    * @param sep 分隔符
    * @return set集合
    */
   public static final Set<String> str2Set(String str, String sep)
  {
       return new HashSet<String>(str2List(str, sep, true, false));
  }

   /**
    * 字符串转list
    *
    * @param str 字符串
    * @param sep 分隔符
    * @param filterBlank 过滤纯空白
    * @param trim 去掉首尾空白
    * @return list集合
    */
   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;
  }

   /**
    * 判断给定的collection列表中是否包含数组array 判断给定的数组array中是否包含给定的元素value
    *
    * @param collection 给定的集合
    * @param array 给定的数组
    * @return boolean 结果
    */
   public static boolean containsAny(Collection<String> collection, String... array)
  {
       if (isEmpty(collection) || isEmpty(array))
      {
           return false;
      }
       else
      {
           for (String str : array)
          {
               if (collection.contains(str))
              {
                   return true;
              }
          }
           return false;
      }
  }

   /**
    * 查找指定字符串是否包含指定字符串列表中的任意一个字符串同时串忽略大小写
    *
    * @param cs 指定字符串
    * @param searchCharSequences 需要检查的字符串数组
    * @return 是否包含任意一个字符串
    */
   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();
  }

   /**
    * 是否包含字符串
    *
    * @param str 验证字符串
    * @param strs 字符串组
    * @return 包含返回true
    */
   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;
  }

   /**
    * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空,则返回空字符串。 例如:HELLO_WORLD->HelloWorld
    *
    * @param name 转换前的下划线大写方式命名的字符串
    * @return 转换后的驼峰式命名的字符串
    */
   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();
  }

   /**
    * 驼峰式命名法
    * 例如:user_name->userName
    */
   public static String toCamelCase(String s)
  {
       if (s == null)
      {
           return null;
      }
       if (s.indexOf(SEPARATOR) == -1)
      {
           return s;
      }
       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();
  }

   /**
    * 查找指定字符串是否匹配指定字符串列表中的任意一个字符串
    *
    * @param str 指定字符串
    * @param strs 需要检查的字符串数组
    * @return 是否匹配
    */
   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;
  }

   /**
    * 判断url是否与规则配置:
    * ? 表示单个字符;
    * * 表示一层路径内的任意字符串,不可跨层级;
    * ** 表示任意层路径;
    *
    * @param pattern 匹配规则
    * @param url 需要匹配的url
    * @return
    */
   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;
  }

   /**
    * 数字左边补齐0,使之达到指定长度。注意,如果数字转换为字符串后,长度大于size,则只保留 最后size个字符。
    *
    * @param num 数字对象
    * @param size 字符串指定长度
    * @return 返回数字的字符串格式,该字符串为指定长度。
    */
   public static final String padl(final Number num, final int size)
  {
       return padl(num.toString(), size, '0');
  }

   /**
    * 字符串左补齐。如果原始字符串s长度大于size,则只保留最后size个字符。
    *
    * @param s 原始字符串
    * @param size 字符串指定长度
    * @param c 用于补齐的字符
    * @return 返回指定长度的字符串,由原字符串左补齐或截取得到。
    */
   public static final String padl(final String s, final int size, final char c)
  {
       final StringBuilder sb = new StringBuilder(size);
       if (s != null)
      {
           final int len = s.length();
           if (s.length() <= size)
          {
               for (int i = size - len; i > 0; i--)
              {
                   sb.append(c);
              }
               sb.append(s);
          }
           else
          {
               return s.substring(len - size, len);
          }
      }
       else
      {
           for (int i = size; i > 0; i--)
          {
               sb.append(c);
          }
      }
       return sb.toString();
  }
}
 

 

posted @   sumling  阅读(496)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 全程不用写代码,我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了,比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· DeepSeek 开源周回顾「GitHub 热点速览」
· 白话解读 Dapr 1.15:你的「微服务管家」又秀新绝活了
点击右上角即可分享
微信分享提示