Merge branch 'mdc_hyjs_master'

zhangherong

2025-06-25 23855599412c4d61b38d78f0f3abd3430a48b5b1

 lxzn-boot-base-core/src/main/java/org/jeecg/common/util/oConvertUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,695 @@
package org.jeecg.common.util;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.SymbolConstant;
import org.springframework.beans.BeanUtils;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.sql.Date;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *
 * @Author  å¼ ä»£æµ©
 *
 */
@Slf4j
public class oConvertUtils {
   public static boolean isEmpty(Object object) {
      if (object == null) {
         return (true);
      }
      if ("".equals(object)) {
         return (true);
      }
      if (CommonConstant.STRING_NULL.equals(object)) {
         return (true);
      }
      return (false);
   }

   public static boolean isNotEmpty(Object object) {
      if (object != null && !"".equals(object) && !object.equals(CommonConstant.STRING_NULL)) {
         return (true);
      }
      return (false);
   }

   public static String decode(String strIn, String sourceCode, String targetCode) {
      String temp = code2code(strIn, sourceCode, targetCode);
      return temp;
   }

   @SuppressWarnings("AlibabaLowerCamelCaseVariableNaming")
    public static String StrToUTF(String strIn, String sourceCode, String targetCode) {
      strIn = "";
      try {
         strIn = new String(strIn.getBytes("ISO-8859-1"), "GBK");
      } catch (UnsupportedEncodingException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
      return strIn;

   }

   private static String code2code(String strIn, String sourceCode, String targetCode) {
      String strOut = null;
      if (strIn == null || "".equals(strIn.trim())) {
         return strIn;
      }
      try {
         byte[] b = strIn.getBytes(sourceCode);
         for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + "  ");
         }
         strOut = new String(b, targetCode);
      } catch (Exception e) {
         e.printStackTrace();
         return null;
      }
      return strOut;
   }

   public static int getInt(String s, int defval) {
      if (s == null || s == "") {
         return (defval);
      }
      try {
         return (Integer.parseInt(s));
      } catch (NumberFormatException e) {
         return (defval);
      }
   }

   public static int getInt(String s) {
      if (s == null || s == "") {
         return 0;
      }
      try {
         return (Integer.parseInt(s));
      } catch (NumberFormatException e) {
         return 0;
      }
   }

   public static int getInt(String s, Integer df) {
      if (s == null || s == "") {
         return df;
      }
      try {
         return (Integer.parseInt(s));
      } catch (NumberFormatException e) {
         return 0;
      }
   }

   public static Integer[] getInts(String[] s) {
      if (s == null) {
         return null;
      }
      Integer[] integer = new Integer[s.length];
      for (int i = 0; i < s.length; i++) {
         integer[i] = Integer.parseInt(s[i]);
      }
      return integer;

   }

   public static double getDouble(String s, double defval) {
      if (s == null || s == "") {
         return (defval);
      }
      try {
         return (Double.parseDouble(s));
      } catch (NumberFormatException e) {
         return (defval);
      }
   }

   public static double getDou(Double s, double defval) {
      if (s == null) {
         return (defval);
      }
      return s;
   }

   /*public static Short getShort(String s) {
      if (StringUtil.isNotEmpty(s)) {
         return (Short.parseShort(s));
      } else {
         return null;
      }
   }*/

   public static int getInt(Object object, int defval) {
      if (isEmpty(object)) {
         return (defval);
      }
      try {
         return (Integer.parseInt(object.toString()));
      } catch (NumberFormatException e) {
         return (defval);
      }
   }

   public static Integer getInt(Object object) {
      if (isEmpty(object)) {
         return null;
      }
      try {
         return (Integer.parseInt(object.toString()));
      } catch (NumberFormatException e) {
         return null;
      }
   }

   public static int getInt(BigDecimal s, int defval) {
      if (s == null) {
         return (defval);
      }
      return s.intValue();
   }

   public static Integer[] getIntegerArry(String[] object) {
      int len = object.length;
      Integer[] result = new Integer[len];
      try {
         for (int i = 0; i < len; i++) {
            result[i] = new Integer(object[i].trim());
         }
         return result;
      } catch (NumberFormatException e) {
         return null;
      }
   }

   public static String getString(String s) {
      return (getString(s, ""));
   }

   /**
    * è½¬ä¹‰æˆUnicode编码
    * @param s
    * @return
    */
   /*public static String escapeJava(Object s) {
      return StringEscapeUtils.escapeJava(getString(s));
   }*/

   public static String getString(Object object) {
      if (isEmpty(object)) {
         return "";
      }
      return (object.toString().trim());
   }

   public static String getString(int i) {
      return (String.valueOf(i));
   }

   public static String getString(float i) {
      return (String.valueOf(i));
   }

   public static String getString(String s, String defval) {
      if (isEmpty(s)) {
         return (defval);
      }
      return (s.trim());
   }

   public static String getString(Object s, String defval) {
      if (isEmpty(s)) {
         return (defval);
      }
      return (s.toString().trim());
   }

   public static long stringToLong(String str) {
      Long test = new Long(0);
      try {
         test = Long.valueOf(str);
      } catch (Exception e) {
      }
      return test.longValue();
   }

   /**
    * èŽ·å–本机IP
    */
   public static String getIp() {
      String ip = null;
      try {
         InetAddress address = InetAddress.getLocalHost();
         ip = address.getHostAddress();

      } catch (UnknownHostException e) {
         e.printStackTrace();
      }
      return ip;
   }

   /**
    * åˆ¤æ–­ä¸€ä¸ªç±»æ˜¯å¦ä¸ºåŸºæœ¬æ•°æ®ç±»åž‹ã€‚
    *
    * @param clazz
    *            è¦åˆ¤æ–­çš„类。
    * @return true è¡¨ç¤ºä¸ºåŸºæœ¬æ•°æ®ç±»åž‹ã€‚
    */
   private static boolean isBaseDataType(Class clazz) throws Exception {
      return (clazz.equals(String.class) || clazz.equals(Integer.class) || clazz.equals(Byte.class) || clazz.equals(Long.class) || clazz.equals(Double.class) || clazz.equals(Float.class) || clazz.equals(Character.class) || clazz.equals(Short.class) || clazz.equals(BigDecimal.class) || clazz.equals(BigInteger.class) || clazz.equals(Boolean.class) || clazz.equals(Date.class) || clazz.isPrimitive());
   }

   /**
    * @param request
    *            IP
    * @return IP Address
    */
   public static String getIpAddrByRequest(HttpServletRequest request) {
      String ip = request.getHeader("x-forwarded-for");
      if (ip == null || ip.length() == 0 || CommonConstant.UNKNOWN.equalsIgnoreCase(ip)) {
         ip = request.getHeader("Proxy-Client-IP");
      }
      if (ip == null || ip.length() == 0 || CommonConstant.UNKNOWN.equalsIgnoreCase(ip)) {
         ip = request.getHeader("WL-Proxy-Client-IP");
      }
      if (ip == null || ip.length() == 0 || CommonConstant.UNKNOWN.equalsIgnoreCase(ip)) {
         ip = request.getRemoteAddr();
      }
      return ip;
   }

   /**
    * @return æœ¬æœºIP
    * @throws SocketException
    */
   public static String getRealIp() throws SocketException {
        // æœ¬åœ°IP，如果没有配置外网IP则返回它
      String localip = null;
        // å¤–网IP
      String netip = null;

      Enumeration<NetworkInterface> netInterfaces = NetworkInterface.getNetworkInterfaces();
      InetAddress ip = null;
        // æ˜¯å¦æ‰¾åˆ°å¤–网IP
      boolean finded = false;
      while (netInterfaces.hasMoreElements() && !finded) {
         NetworkInterface ni = netInterfaces.nextElement();
         Enumeration<InetAddress> address = ni.getInetAddresses();
         while (address.hasMoreElements()) {
            ip = address.nextElement();
                // å¤–网IP
            if (!ip.isSiteLocalAddress() && !ip.isLoopbackAddress() && ip.getHostAddress().indexOf(":") == -1) {
               netip = ip.getHostAddress();
               finded = true;
               break;
            } else if (ip.isSiteLocalAddress() && !ip.isLoopbackAddress() && ip.getHostAddress().indexOf(":") == -1) {
                    // å†…网IP
                localip = ip.getHostAddress();
            }
         }
      }

      if (netip != null && !"".equals(netip)) {
         return netip;
      } else {
         return localip;
      }
   }

   /**
    * java去除字符串中的空格、回车、换行符、制表符
    *
    * @param str
    * @return
    */
   public static String replaceBlank(String str) {
      String dest = "";
      if (str != null) {
          String reg = "\\s*|\t|\r|\n";
         Pattern p = Pattern.compile(reg);
         Matcher m = p.matcher(str);
         dest = m.replaceAll("");
      }
      return dest;

   }

   /**
    * åˆ¤æ–­å…ƒç´ æ˜¯å¦åœ¨æ•°ç»„内
    *
    * @param substring
    * @param source
    * @return
    */
   public static boolean isIn(String substring, String[] source) {
      if (source == null || source.length == 0) {
         return false;
      }
      for (int i = 0; i < source.length; i++) {
         String aSource = source[i];
         if (aSource.equals(substring)) {
            return true;
         }
      }
      return false;
   }

   /**
    * èŽ·å–Map对象
    */
   public static Map<Object, Object> getHashMap() {
      return new HashMap<>(5);
   }

   /**
    * SET转换MAP
    *
    * @param str
    * @return
    */
   public static Map<Object, Object> setToMap(Set<Object> setobj) {
      Map<Object, Object> map = getHashMap();
      for (Iterator iterator = setobj.iterator(); iterator.hasNext();) {
         Map.Entry<Object, Object> entry = (Map.Entry<Object, Object>) iterator.next();
         map.put(entry.getKey().toString(), entry.getValue() == null ? "" : entry.getValue().toString().trim());
      }
      return map;

   }

   public static boolean isInnerIp(String ipAddress) {
      boolean isInnerIp = false;
      long ipNum = getIpNum(ipAddress);
      /**
       * ç§æœ‰IP：Aç±» 10.0.0.0-10.255.255.255 Bç±» 172.16.0.0-172.31.255.255 Cç±» 192.168.0.0-192.168.255.255 å½“然，还有127这个网段是环回地址
       **/
      long aBegin = getIpNum("10.0.0.0");
      long aEnd = getIpNum("10.255.255.255");
      long bBegin = getIpNum("172.16.0.0");
      long bEnd = getIpNum("172.31.255.255");
      long cBegin = getIpNum("192.168.0.0");
      long cEnd = getIpNum("192.168.255.255");
      String localIp = "127.0.0.1";
      isInnerIp = isInner(ipNum, aBegin, aEnd) || isInner(ipNum, bBegin, bEnd) || isInner(ipNum, cBegin, cEnd) || localIp.equals(ipAddress);
      return isInnerIp;
   }

   private static long getIpNum(String ipAddress) {
      String[] ip = ipAddress.split("\\.");
      long a = Integer.parseInt(ip[0]);
      long b = Integer.parseInt(ip[1]);
      long c = Integer.parseInt(ip[2]);
      long d = Integer.parseInt(ip[3]);

      long ipNum = a * 256 * 256 * 256 + b * 256 * 256 + c * 256 + d;
      return ipNum;
   }

   private static boolean isInner(long userIp, long begin, long end) {
      return (userIp >= begin) && (userIp <= end);
   }

   /**
    * å°†ä¸‹åˆ’线大写方式命名的字符串转换为驼峰式。
    * å¦‚果转换前的下划线大写方式命名的字符串为空，则返回空字符串。</br>
    * ä¾‹å¦‚：hello_world->helloWorld
    *
    * @param name
    *            è½¬æ¢å‰çš„下划线大写方式命名的字符串
    * @return è½¬æ¢åŽçš„驼峰式命名的字符串
    */
   public static String camelName(String name) {
      StringBuilder result = new StringBuilder();
      // å¿«é€Ÿæ£€æŸ¥
      if (name == null || name.isEmpty()) {
         // æ²¡å¿…要转换
         return "";
      } else if (!name.contains(SymbolConstant.UNDERLINE)) {
         // ä¸å«ä¸‹åˆ’线，仅将首字母小写
         //update-begin--Author:zhoujf  Date:20180503 for：TASK #2500 ã€ä»£ç ç”Ÿæˆå™¨ã€‘代码生成器开发一通用模板生成功能
         //update-begin--Author:zhoujf  Date:20180503 for：TASK #2500 ã€ä»£ç ç”Ÿæˆå™¨ã€‘代码生成器开发一通用模板生成功能
         return name.substring(0, 1).toLowerCase() + name.substring(1).toLowerCase();
         //update-end--Author:zhoujf  Date:20180503 for：TASK #2500 ã€ä»£ç ç”Ÿæˆå™¨ã€‘代码生成器开发一通用模板生成功能
      }
      // ç”¨ä¸‹åˆ’线将原始字符串分割
      String[] camels = name.split("_");
      for (String camel : camels) {
         // è·³è¿‡åŽŸå§‹å­—符串中开头、结尾的下换线或双重下划线
         if (camel.isEmpty()) {
            continue;
         }
         // å¤„理真正的驼峰片段
         if (result.length() == 0) {
            // ç¬¬ä¸€ä¸ªé©¼å³°ç‰‡æ®µï¼Œå…¨éƒ¨å­—母都小写
            result.append(camel.toLowerCase());
         } else {
            // å…¶ä»–的驼峰片段，首字母大写
            result.append(camel.substring(0, 1).toUpperCase());
            result.append(camel.substring(1).toLowerCase());
         }
      }
      return result.toString();
   }

   /**
    * å°†ä¸‹åˆ’线大写方式命名的字符串转换为驼峰式。
    * å¦‚果转换前的下划线大写方式命名的字符串为空，则返回空字符串。</br>
    * ä¾‹å¦‚：hello_world,test_id->helloWorld,testId
    *
    * @param name
    *            è½¬æ¢å‰çš„下划线大写方式命名的字符串
    * @return è½¬æ¢åŽçš„驼峰式命名的字符串
    */
   public static String camelNames(String names) {
      if(names==null||"".equals(names)){
         return null;
      }
      StringBuffer sf = new StringBuffer();
      String[] fs = names.split(",");
      for (String field : fs) {
         field = camelName(field);
         sf.append(field + ",");
      }
      String result = sf.toString();
      return result.substring(0, result.length() - 1);
   }

   //update-begin--Author:zhoujf  Date:20180503 for：TASK #2500 ã€ä»£ç ç”Ÿæˆå™¨ã€‘代码生成器开发一通用模板生成功能
   /**
    * å°†ä¸‹åˆ’线大写方式命名的字符串转换为驼峰式。(首字母写)
    * å¦‚果转换前的下划线大写方式命名的字符串为空，则返回空字符串。</br>
    * ä¾‹å¦‚：hello_world->HelloWorld
    *
    * @param name
    *            è½¬æ¢å‰çš„下划线大写方式命名的字符串
    * @return è½¬æ¢åŽçš„驼峰式命名的字符串
    */
   public static String camelNameCapFirst(String name) {
      StringBuilder result = new StringBuilder();
      // å¿«é€Ÿæ£€æŸ¥
      if (name == null || name.isEmpty()) {
         // æ²¡å¿…要转换
         return "";
      } else if (!name.contains(SymbolConstant.UNDERLINE)) {
         // ä¸å«ä¸‹åˆ’线，仅将首字母小写
         return name.substring(0, 1).toUpperCase() + name.substring(1).toLowerCase();
      }
      // ç”¨ä¸‹åˆ’线将原始字符串分割
      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();
   }
   //update-end--Author:zhoujf  Date:20180503 for：TASK #2500 ã€ä»£ç ç”Ÿæˆå™¨ã€‘代码生成器开发一通用模板生成功能

   /**
    * å°†é©¼å³°å‘½åè½¬åŒ–成下划线
    * @param para
    * @return
    */
   public static String camelToUnderline(String para){
       int length = 3;
        if(para.length()<length){
           return para.toLowerCase();
        }
        StringBuilder sb=new StringBuilder(para);
        //定位
        int temp=0;
        //从第三个字符开始 é¿å…å‘½åä¸è§„范
        for(int i=2;i<para.length();i++){
            if(Character.isUpperCase(para.charAt(i))){
                sb.insert(i+temp, "_");
                temp+=1;
            }
        }
        return sb.toString().toLowerCase();
   }

   /**
    * éšæœºæ•°
    * @param place å®šä¹‰éšæœºæ•°çš„位数
    */
   public static String randomGen(int place) {
      String base = "qwertyuioplkjhgfdsazxcvbnmQAZWSXEDCRFVTGBYHNUJMIKLOP0123456789";
      StringBuffer sb = new StringBuffer();
      Random rd = new Random();
      for(int i=0;i<place;i++) {
         sb.append(base.charAt(rd.nextInt(base.length())));
      }
      return sb.toString();
   }

   /**
    * èŽ·å–类的所有属性，包括父类
    *
    * @param object
    * @return
    */
   public static Field[] getAllFields(Object object) {
      Class<?> clazz = object.getClass();
      List<Field> fieldList = new ArrayList<>();
      while (clazz != null) {
         fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
         clazz = clazz.getSuperclass();
      }
      Field[] fields = new Field[fieldList.size()];
      fieldList.toArray(fields);
      return fields;
   }

   /**
     * å°†map的key全部转成小写
    * @param list
    * @return
    */
   public static List<Map<String, Object>> toLowerCasePageList(List<Map<String, Object>> list){
      List<Map<String, Object>> select = new ArrayList<>();
      for (Map<String, Object> row : list) {
          Map<String, Object> resultMap = new HashMap<>(5);
          Set<String> keySet = row.keySet();
          for (String key : keySet) {
             String newKey = key.toLowerCase();
             resultMap.put(newKey, row.get(key));
          }
          select.add(resultMap);
      }
      return select;
   }

   /**
    * å°†entityList转换成modelList
    * @param fromList
    * @param tClass
    * @param <F>
    * @param <T>
    * @return
    */
   public static<F,T> List<T> entityListToModelList(List<F> fromList, Class<T> tClass){
      if(fromList == null || fromList.isEmpty()){
         return null;
      }
      List<T> tList = new ArrayList<>();
      for(F f : fromList){
         T t = entityToModel(f, tClass);
         tList.add(t);
      }
      return tList;
   }

   public static<F,T> T entityToModel(F entity, Class<T> modelClass) {
      log.debug("entityToModel : Entity属性的值赋值到Model");
      Object model = null;
      if (entity == null || modelClass ==null) {
         return null;
      }

      try {
         model = modelClass.newInstance();
      } catch (InstantiationException e) {
         log.error("entityToModel : å®žä¾‹åŒ–异常", e);
      } catch (IllegalAccessException e) {
         log.error("entityToModel : å®‰å…¨æƒé™å¼‚常", e);
      }
      BeanUtils.copyProperties(entity, model);
      return (T)model;
   }

   /**
    * åˆ¤æ–­ list æ˜¯å¦ä¸ºç©º
    *
    * @param list
    * @return true or false
    * list == null      : true
    * list.size() == 0   : true
    */
   public static boolean listIsEmpty(Collection list) {
      return (list == null || list.size() == 0);
   }

   /**
    * åˆ¤æ–­ list æ˜¯å¦ä¸ä¸ºç©º
    *
    * @param list
    * @return true or false
    * list == null      : false
    * list.size() == 0   : false
    */
   public static boolean listIsNotEmpty(Collection list) {
      return !listIsEmpty(list);
   }

   /**
    * è¯»å–静态文本内容
    * @param url
    * @return
    */
   public static String readStatic(String url) {
      String json = "";
      try {
         //换个写法，解决springboot读取jar包中文件的问题
         InputStream stream = oConvertUtils.class.getClassLoader().getResourceAsStream(url.replace("classpath:", ""));
         json = IOUtils.toString(stream,"UTF-8");
      } catch (IOException e) {
         log.error(e.getMessage(),e);
      }
      return json;
   }

   public static <T> List<T> castList(Object obj, Class<T> clazz)
   {
      List<T> result = new ArrayList<T>();
      if(obj instanceof List<?>)
      {
         for (Object o : (List<?>) obj)
         {
            result.add(clazz.cast(o));
         }
         return result;
      }
      return null;
   }

}