devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java http请求头部工具类_servletutils.getrequest()

作者：2023面试高手 | 2024-03-25 12:25:51

赞

踩

servletutils.getrequest()
  1.  
  2. /**
  3.  * 权限相关通用常量
  4.  *
  5.  * @author ws
  6.  */
  7. public class SecurityConstants {
  8.     /**
  9.      * 令牌自定义标识
  10.      */
  11.     public static final String TOKEN_AUTHENTICATION = "Authorization";
  12.  
  13.     /**
  14.      * 令牌前缀
  15.      */
  16.     public static final String TOKEN_PREFIX = "Bearer ";
  17.  
  18.     /**
  19.      * 用户ID字段
  20.      */
  21.     public static final String USER_ID = "user_id";
  22.  
  23.     /**
  24.      * 用户NO字段
  25.      */
  26.     public static final String USER_NO = "user_no";
  27.  
  28.     /**
  29.      * 用户ID字段
  30.      */
  31.     public static final String USER_TYPE = "user_type";
  32.  
  33.     /**
  34.      * 用户名字段
  35.      */
  36.     public static final String LOGIN_NAME = "login_name";
  37.  
  38.     /**
  39.      * 用户名称
  40.      */
  41.     public static final String USER_NAME = "user_name";
  42.  
  43.     /**
  44.      * 昵称
  45.      */
  46.     public static final String NICK_NAME = "nick_name";
  47.  
  48.     /**
  49.      * 授权信息字段
  50.      */
  51.     public static final String AUTHORIZATION_HEADER = "authorization";
  52.  
  53.  
  54.     /**
  55.      * open  id
  56.      */
  57.     public static final String OPEN_ID = "open_id";
  58.  
  59.     /**
  60.      * company name
  61.      */
  62.     public static final String COMPANY_NAME = "company_name";
  63.  
  64.     /**
  65.      * customer no
  66.      */
  67.     public static final String CUSTOMER_NO = "customer_no";
  68.  
  69. }

 

  1. import com.destination.destinationquery.util.StringUtils;
  2. import org.springframework.web.context.request.RequestAttributes;
  3. import org.springframework.web.context.request.RequestContextHolder;
  4. import org.springframework.web.context.request.ServletRequestAttributes;
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletResponse;
  7. import javax.servlet.http.HttpSession;
  8. import java.io.IOException;
  9.  
  10. /**
  11.  * @author ws
  12.  * @title: Result
  13.  * @description: 客户端工具类
  14.  * @date 2021/2/5
  15.  */
  16. public class ServletUtils {
  17.     /**
  18.      * 获取String参数
  19.      */
  20.     public static String getParameter(String name) {
  21.         return getRequest().getParameter(name);
  22.     }
  23.  
  24.     /**
  25.      * 获取String参数
  26.      */
  27.     public static String getParameter(String name, String defaultValue) {
  28.         return ConvertUtils.toStr(getRequest().getParameter(name), defaultValue);
  29.     }
  30.  
  31.     /**
  32.      * 获取Integer参数
  33.      */
  34.     public static Integer getParameterToInt(String name) {
  35.         return ConvertUtils.toInt(getRequest().getParameter(name));
  36.     }
  37.  
  38.     /**
  39.      * 获取Integer参数
  40.      */
  41.     public static Integer getParameterToInt(String name, Integer defaultValue) {
  42.         return ConvertUtils.toInt(getRequest().getParameter(name), defaultValue);
  43.     }
  44.  
  45.     /**
  46.      * 获取request
  47.      */
  48.     public static HttpServletRequest getRequest() {
  49.         return getRequestAttributes().getRequest();
  50.     }
  51.  
  52.     /**
  53.      * 获取response
  54.      */
  55.     public static HttpServletResponse getResponse() {
  56.         return getRequestAttributes().getResponse();
  57.     }
  58.  
  59.     /**
  60.      * 获取session
  61.      */
  62.     public static HttpSession getSession() {
  63.         return getRequest().getSession();
  64.     }
  65.  
  66.     public static ServletRequestAttributes getRequestAttributes() {
  67.         RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
  68.         return (ServletRequestAttributes) attributes;
  69.     }
  70.  
  71.     /**
  72.      * 将字符串渲染到客户端
  73.      *
  74.      * @param response 渲染对象
  75.      * @param string   待渲染的字符串
  76.      * @return null
  77.      */
  78.     public static String renderString(HttpServletResponse response, String string) {
  79.         try {
  80.             response.setContentType("application/json");
  81.             response.setCharacterEncoding("utf-8");
  82.             response.getWriter().print(string);
  83.         } catch (IOException e) {
  84.             e.printStackTrace();
  85.         }
  86.         return null;
  87.     }
  88.  
  89.     /**
  90.      * 是否是Ajax异步请求
  91.      *
  92.      * @param request
  93.      */
  94.     public static boolean isAjaxRequest(HttpServletRequest request) {
  95.  
  96.         String accept = request.getHeader("accept");
  97.         if (accept != null && accept.indexOf("application/json") != -1) {
  98.             return true;
  99.         }
  100.  
  101.         String xRequestedWith = request.getHeader("X-Requested-With");
  102.         if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1) {
  103.             return true;
  104.         }
  105.  
  106.         String uri = request.getRequestURI();
  107.         if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml")) {
  108.             return true;
  109.         }
  110.  
  111.         String ajax = request.getParameter("__ajax");
  112.         if (StringUtils.inStringIgnoreCase(ajax, "json", "xml")) {
  113.             return true;
  114.         }
  115.  
  116.         return false;
  117.     }
  118. }
  119.  
  1. package com.destination.destinationquery.util.Security;
  2.  
  3. import cn.hutool.core.lang.Assert;
  4. import cn.hutool.core.util.StrUtil;
  5.  
  6. import com.destination.destinationquery.util.StringUtils;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import org.springframework.http.server.reactive.ServerHttpRequest;
  10. import org.springframework.stereotype.Component;
  11.  
  12. import javax.servlet.http.HttpServletRequest;
  13. import java.io.UnsupportedEncodingException;
  14. import java.net.URLDecoder;
  15.  
  16. /**
  17.  * 权限获取工具类
  18.  *
  19.  * @author ws
  20.  */
  21. @Component
  22. public class SecurityUtils {
  23.     private static final Logger log = LoggerFactory.getLogger(SecurityUtils.class);
  24.     public static String urlDecode(String str)
  25.     {
  26.         try
  27.         {
  28.             return URLDecoder.decode(str,"UTF-8");
  29.         }
  30.         catch (UnsupportedEncodingException e)
  31.         {
  32.             return "";
  33.         }
  34.     }
  35.     /**
  36.      * 获取用户手机号
  37.      */
  38.     public static String getPhone_NO() {
  39.         String customerNo = ServletUtils.getRequest().getHeader(SecurityConstants.Phone_NO);
  40.         Assert.isFalse(StrUtil.isBlank(customerNo), () -> new BusinessException("手机号不能为空"));
  41.         return urlDecode(customerNo);
  42.     }
  43.     /**
  44.      * 获取用户权限
  45.      */
  46.     public static String getRole_Type() {
  47.         String customerNo = ServletUtils.getRequest().getHeader(SecurityConstants.ROLE_TYPE);
  48.         Assert.isFalse(StrUtil.isBlank(customerNo), () -> new BusinessException("权限不能为空"));
  49.         return urlDecode(customerNo);
  50.     }
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.     /**
  59.      * 获取请求token
  60.      */
  61.     public static String getToken() {
  62.         return getToken(ServletUtils.getRequest());
  63.     }
  64.  
  65.     /**
  66.      * 根据request获取请求token
  67.      */
  68.     public static String getToken(HttpServletRequest request) {
  69.         String token = request.getHeader(SecurityConstants.TOKEN_AUTHENTICATION);
  70.         return replaceTokenPrefix(token);
  71.     }
  72.  
  73.     /**
  74.      * 根据request获取请求token
  75.      */
  76.     public static String getToken(ServerHttpRequest request) {
  77.         String token = request.getHeaders().getFirst(SecurityConstants.TOKEN_AUTHENTICATION);
  78.         return replaceTokenPrefix(token);
  79.     }
  80.  
  81.     /**
  82.      * 替换token前缀
  83.      */
  84.     public static String replaceTokenPrefix(String token) {
  85.         if (StringUtils.isNotEmpty(token) && token.startsWith(SecurityConstants.TOKEN_PREFIX)) {
  86.             token = token.replace(SecurityConstants.TOKEN_PREFIX, "");
  87.         }
  88.         return token;
  89.     }
  90.  
  91.  
  92. }
  93.  
  1. import com.destination.destinationquery.util.StringUtils;
  2. import java.math.BigDecimal;
  3. import java.math.BigInteger;
  4. import java.nio.ByteBuffer;
  5. import java.nio.charset.Charset;
  6. import java.text.NumberFormat;
  7. import java.util.Set;
  8.  
  9. /**
  10.  * 类型转换器
  11.  *
  12.  * @author p&s
  13.  */
  14. public class ConvertUtils {
  15.  
  16.     /**
  17.      * 转换为字符串<br>
  18.      * 如果给定的值为null，或者转换失败，返回默认值<br>
  19.      * 转换失败不会报错
  20.      *
  21.      * @param value        被转换的值
  22.      * @param defaultValue 转换错误时的默认值
  23.      * @return 结果
  24.      */
  25.     public static String toStr(Object value, String defaultValue) {
  26.         if (null == value) {
  27.             return defaultValue;
  28.         }
  29.         if (value instanceof String) {
  30.             return (String) value;
  31.         }
  32.         return value.toString();
  33.     }
  34.  
  35.     /**
  36.      * 转换为字符串<br>
  37.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  38.      * 转换失败不会报错
  39.      *
  40.      * @param value 被转换的值
  41.      * @return 结果
  42.      */
  43.     public static String toStr(Object value) {
  44.         return toStr(value, null);
  45.     }
  46.  
  47.     /**
  48.      * 转换为字符<br>
  49.      * 如果给定的值为null，或者转换失败，返回默认值<br>
  50.      * 转换失败不会报错
  51.      *
  52.      * @param value        被转换的值
  53.      * @param defaultValue 转换错误时的默认值
  54.      * @return 结果
  55.      */
  56.     public static Character toChar(Object value, Character defaultValue) {
  57.         if (null == value) {
  58.             return defaultValue;
  59.         }
  60.         if (value instanceof Character) {
  61.             return (Character) value;
  62.         }
  63.  
  64.         final String valueStr = toStr(value, null);
  65.         return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
  66.     }
  67.  
  68.     /**
  69.      * 转换为字符<br>
  70.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  71.      * 转换失败不会报错
  72.      *
  73.      * @param value 被转换的值
  74.      * @return 结果
  75.      */
  76.     public static Character toChar(Object value) {
  77.         return toChar(value, null);
  78.     }
  79.  
  80.     /**
  81.      * 转换为byte<br>
  82.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
  83.      * 转换失败不会报错
  84.      *
  85.      * @param value        被转换的值
  86.      * @param defaultValue 转换错误时的默认值
  87.      * @return 结果
  88.      */
  89.     public static Byte toByte(Object value, Byte defaultValue) {
  90.         if (value == null) {
  91.             return defaultValue;
  92.         }
  93.         if (value instanceof Byte) {
  94.             return (Byte) value;
  95.         }
  96.         if (value instanceof Number) {
  97.             return ((Number) value).byteValue();
  98.         }
  99.         final String valueStr = toStr(value, null);
  100.         if (StringUtils.isEmpty(valueStr)) {
  101.             return defaultValue;
  102.         }
  103.         try {
  104.             return Byte.parseByte(valueStr);
  105.         } catch (Exception e) {
  106.             return defaultValue;
  107.         }
  108.     }
  109.  
  110.     /**
  111.      * 转换为byte<br>
  112.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  113.      * 转换失败不会报错
  114.      *
  115.      * @param value 被转换的值
  116.      * @return 结果
  117.      */
  118.     public static Byte toByte(Object value) {
  119.         return toByte(value, null);
  120.     }
  121.  
  122.     /**
  123.      * 转换为Short<br>
  124.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
  125.      * 转换失败不会报错
  126.      *
  127.      * @param value        被转换的值
  128.      * @param defaultValue 转换错误时的默认值
  129.      * @return 结果
  130.      */
  131.     public static Short toShort(Object value, Short defaultValue) {
  132.         if (value == null) {
  133.             return defaultValue;
  134.         }
  135.         if (value instanceof Short) {
  136.             return (Short) value;
  137.         }
  138.         if (value instanceof Number) {
  139.             return ((Number) value).shortValue();
  140.         }
  141.         final String valueStr = toStr(value, null);
  142.         if (StringUtils.isEmpty(valueStr)) {
  143.             return defaultValue;
  144.         }
  145.         try {
  146.             return Short.parseShort(valueStr.trim());
  147.         } catch (Exception e) {
  148.             return defaultValue;
  149.         }
  150.     }
  151.  
  152.     /**
  153.      * 转换为Short<br>
  154.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  155.      * 转换失败不会报错
  156.      *
  157.      * @param value 被转换的值
  158.      * @return 结果
  159.      */
  160.     public static Short toShort(Object value) {
  161.         return toShort(value, null);
  162.     }
  163.  
  164.     /**
  165.      * 转换为Number<br>
  166.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  167.      * 转换失败不会报错
  168.      *
  169.      * @param value        被转换的值
  170.      * @param defaultValue 转换错误时的默认值
  171.      * @return 结果
  172.      */
  173.     public static Number toNumber(Object value, Number defaultValue) {
  174.         if (value == null) {
  175.             return defaultValue;
  176.         }
  177.         if (value instanceof Number) {
  178.             return (Number) value;
  179.         }
  180.         final String valueStr = toStr(value, null);
  181.         if (StringUtils.isEmpty(valueStr)) {
  182.             return defaultValue;
  183.         }
  184.         try {
  185.             return NumberFormat.getInstance().parse(valueStr);
  186.         } catch (Exception e) {
  187.             return defaultValue;
  188.         }
  189.     }
  190.  
  191.     /**
  192.      * 转换为Number<br>
  193.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  194.      * 转换失败不会报错
  195.      *
  196.      * @param value 被转换的值
  197.      * @return 结果
  198.      */
  199.     public static Number toNumber(Object value) {
  200.         return toNumber(value, null);
  201.     }
  202.  
  203.     /**
  204.      * 转换为int<br>
  205.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  206.      * 转换失败不会报错
  207.      *
  208.      * @param value        被转换的值
  209.      * @param defaultValue 转换错误时的默认值
  210.      * @return 结果
  211.      */
  212.     public static Integer toInt(Object value, Integer defaultValue) {
  213.         if (value == null) {
  214.             return defaultValue;
  215.         }
  216.         if (value instanceof Integer) {
  217.             return (Integer) value;
  218.         }
  219.         if (value instanceof Number) {
  220.             return ((Number) value).intValue();
  221.         }
  222.         final String valueStr = toStr(value, null);
  223.         if (StringUtils.isEmpty(valueStr)) {
  224.             return defaultValue;
  225.         }
  226.         try {
  227.             return Integer.parseInt(valueStr.trim());
  228.         } catch (Exception e) {
  229.             return defaultValue;
  230.         }
  231.     }
  232.  
  233.     /**
  234.      * 转换为int<br>
  235.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  236.      * 转换失败不会报错
  237.      *
  238.      * @param value 被转换的值
  239.      * @return 结果
  240.      */
  241.     public static Integer toInt(Object value) {
  242.         return toInt(value, null);
  243.     }
  244.  
  245.     /**
  246.      * 转换为Integer数组<br>
  247.      *
  248.      * @param str 被转换的值
  249.      * @return 结果
  250.      */
  251.     public static Integer[] toIntArray(String str) {
  252.         return toIntArray(",", str);
  253.     }
  254.  
  255.     /**
  256.      * 转换为Long数组<br>
  257.      *
  258.      * @param str 被转换的值
  259.      * @return 结果
  260.      */
  261.     public static Long[] toLongArray(String str) {
  262.         return toLongArray(",", str);
  263.     }
  264.  
  265.     /**
  266.      * 转换为Integer数组<br>
  267.      *
  268.      * @param split 分隔符
  269.      * @param split 被转换的值
  270.      * @return 结果
  271.      */
  272.     public static Integer[] toIntArray(String split, String str) {
  273.         if (StringUtils.isEmpty(str)) {
  274.             return new Integer[]{};
  275.         }
  276.         String[] arr = str.split(split);
  277.         final Integer[] ints = new Integer[arr.length];
  278.         for (int i = 0; i < arr.length; i++) {
  279.             final Integer v = toInt(arr[i], 0);
  280.             ints[i] = v;
  281.         }
  282.         return ints;
  283.     }
  284.  
  285.     /**
  286.      * 转换为Long数组<br>
  287.      *
  288.      * @param split 是否忽略转换错误，忽略则给值null
  289.      * @param str   被转换的值
  290.      * @return 结果
  291.      */
  292.     public static Long[] toLongArray(String split, String str) {
  293.         if (StringUtils.isEmpty(str)) {
  294.             return new Long[]{};
  295.         }
  296.         String[] arr = str.split(split);
  297.         final Long[] longs = new Long[arr.length];
  298.         for (int i = 0; i < arr.length; i++) {
  299.             final Long v = toLong(arr[i], null);
  300.             longs[i] = v;
  301.         }
  302.         return longs;
  303.     }
  304.  
  305.     /**
  306.      * 转换为String数组<br>
  307.      *
  308.      * @param str 被转换的值
  309.      * @return 结果
  310.      */
  311.     public static String[] toStrArray(String str) {
  312.         return toStrArray(",", str);
  313.     }
  314.  
  315.     /**
  316.      * 转换为String数组<br>
  317.      *
  318.      * @param split 分隔符
  319.      * @param split 被转换的值
  320.      * @return 结果
  321.      */
  322.     public static String[] toStrArray(String split, String str) {
  323.         return str.split(split);
  324.     }
  325.  
  326.     /**
  327.      * 转换为long<br>
  328.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  329.      * 转换失败不会报错
  330.      *
  331.      * @param value        被转换的值
  332.      * @param defaultValue 转换错误时的默认值
  333.      * @return 结果
  334.      */
  335.     public static Long toLong(Object value, Long defaultValue) {
  336.         if (value == null) {
  337.             return defaultValue;
  338.         }
  339.         if (value instanceof Long) {
  340.             return (Long) value;
  341.         }
  342.         if (value instanceof Number) {
  343.             return ((Number) value).longValue();
  344.         }
  345.         final String valueStr = toStr(value, null);
  346.         if (StringUtils.isEmpty(valueStr)) {
  347.             return defaultValue;
  348.         }
  349.         try {
  350.             // 支持科学计数法
  351.             return new BigDecimal(valueStr.trim()).longValue();
  352.         } catch (Exception e) {
  353.             return defaultValue;
  354.         }
  355.     }
  356.  
  357.     /**
  358.      * 转换为long<br>
  359.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  360.      * 转换失败不会报错
  361.      *
  362.      * @param value 被转换的值
  363.      * @return 结果
  364.      */
  365.     public static Long toLong(Object value) {
  366.         return toLong(value, null);
  367.     }
  368.  
  369.     /**
  370.      * 转换为double<br>
  371.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  372.      * 转换失败不会报错
  373.      *
  374.      * @param value        被转换的值
  375.      * @param defaultValue 转换错误时的默认值
  376.      * @return 结果
  377.      */
  378.     public static Double toDouble(Object value, Double defaultValue) {
  379.         if (value == null) {
  380.             return defaultValue;
  381.         }
  382.         if (value instanceof Double) {
  383.             return (Double) value;
  384.         }
  385.         if (value instanceof Number) {
  386.             return ((Number) value).doubleValue();
  387.         }
  388.         final String valueStr = toStr(value, null);
  389.         if (StringUtils.isEmpty(valueStr)) {
  390.             return defaultValue;
  391.         }
  392.         try {
  393.             // 支持科学计数法
  394.             return new BigDecimal(valueStr.trim()).doubleValue();
  395.         } catch (Exception e) {
  396.             return defaultValue;
  397.         }
  398.     }
  399.  
  400.     /**
  401.      * 转换为double<br>
  402.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  403.      * 转换失败不会报错
  404.      *
  405.      * @param value 被转换的值
  406.      * @return 结果
  407.      */
  408.     public static Double toDouble(Object value) {
  409.         return toDouble(value, null);
  410.     }
  411.  
  412.     /**
  413.      * 转换为Float<br>
  414.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  415.      * 转换失败不会报错
  416.      *
  417.      * @param value        被转换的值
  418.      * @param defaultValue 转换错误时的默认值
  419.      * @return 结果
  420.      */
  421.     public static Float toFloat(Object value, Float defaultValue) {
  422.         if (value == null) {
  423.             return defaultValue;
  424.         }
  425.         if (value instanceof Float) {
  426.             return (Float) value;
  427.         }
  428.         if (value instanceof Number) {
  429.             return ((Number) value).floatValue();
  430.         }
  431.         final String valueStr = toStr(value, null);
  432.         if (StringUtils.isEmpty(valueStr)) {
  433.             return defaultValue;
  434.         }
  435.         try {
  436.             return Float.parseFloat(valueStr.trim());
  437.         } catch (Exception e) {
  438.             return defaultValue;
  439.         }
  440.     }
  441.  
  442.     /**
  443.      * 转换为Float<br>
  444.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  445.      * 转换失败不会报错
  446.      *
  447.      * @param value 被转换的值
  448.      * @return 结果
  449.      */
  450.     public static Float toFloat(Object value) {
  451.         return toFloat(value, null);
  452.     }
  453.  
  454.     /**
  455.      * 转换为boolean<br>
  456.      * String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br>
  457.      * 转换失败不会报错
  458.      *
  459.      * @param value        被转换的值
  460.      * @param defaultValue 转换错误时的默认值
  461.      * @return 结果
  462.      */
  463.     public static Boolean toBool(Object value, Boolean defaultValue) {
  464.         if (value == null) {
  465.             return defaultValue;
  466.         }
  467.         if (value instanceof Boolean) {
  468.             return (Boolean) value;
  469.         }
  470.         String valueStr = toStr(value, null);
  471.         if (StringUtils.isEmpty(valueStr)) {
  472.             return defaultValue;
  473.         }
  474.         valueStr = valueStr.trim().toLowerCase();
  475.         switch (valueStr) {
  476.             case "true":
  477.                 return true;
  478.             case "false":
  479.                 return false;
  480.             case "yes":
  481.                 return true;
  482.             case "ok":
  483.                 return true;
  484.             case "no":
  485.                 return false;
  486.             case "1":
  487.                 return true;
  488.             case "0":
  489.                 return false;
  490.             default:
  491.                 return defaultValue;
  492.         }
  493.     }
  494.  
  495.     /**
  496.      * 转换为boolean<br>
  497.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  498.      * 转换失败不会报错
  499.      *
  500.      * @param value 被转换的值
  501.      * @return 结果
  502.      */
  503.     public static Boolean toBool(Object value) {
  504.         return toBool(value, null);
  505.     }
  506.  
  507.     /**
  508.      * 转换为Enum对象<br>
  509.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  510.      *
  511.      * @param clazz        Enum的Class
  512.      * @param value        值
  513.      * @param defaultValue 默认值
  514.      * @return Enum
  515.      */
  516.     public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue) {
  517.         if (value == null) {
  518.             return defaultValue;
  519.         }
  520.         if (clazz.isAssignableFrom(value.getClass())) {
  521.             @SuppressWarnings("unchecked")
  522.             E myE = (E) value;
  523.             return myE;
  524.         }
  525.         final String valueStr = toStr(value, null);
  526.         if (StringUtils.isEmpty(valueStr)) {
  527.             return defaultValue;
  528.         }
  529.         try {
  530.             return Enum.valueOf(clazz, valueStr);
  531.         } catch (Exception e) {
  532.             return defaultValue;
  533.         }
  534.     }
  535.  
  536.     /**
  537.      * 转换为Enum对象<br>
  538.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  539.      *
  540.      * @param clazz Enum的Class
  541.      * @param value 值
  542.      * @return Enum
  543.      */
  544.     public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value) {
  545.         return toEnum(clazz, value, null);
  546.     }
  547.  
  548.     /**
  549.      * 转换为BigInteger<br>
  550.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  551.      * 转换失败不会报错
  552.      *
  553.      * @param value        被转换的值
  554.      * @param defaultValue 转换错误时的默认值
  555.      * @return 结果
  556.      */
  557.     public static BigInteger toBigInteger(Object value, BigInteger defaultValue) {
  558.         if (value == null) {
  559.             return defaultValue;
  560.         }
  561.         if (value instanceof BigInteger) {
  562.             return (BigInteger) value;
  563.         }
  564.         if (value instanceof Long) {
  565.             return BigInteger.valueOf((Long) value);
  566.         }
  567.         final String valueStr = toStr(value, null);
  568.         if (StringUtils.isEmpty(valueStr)) {
  569.             return defaultValue;
  570.         }
  571.         try {
  572.             return new BigInteger(valueStr);
  573.         } catch (Exception e) {
  574.             return defaultValue;
  575.         }
  576.     }
  577.  
  578.     /**
  579.      * 转换为BigInteger<br>
  580.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  581.      * 转换失败不会报错
  582.      *
  583.      * @param value 被转换的值
  584.      * @return 结果
  585.      */
  586.     public static BigInteger toBigInteger(Object value) {
  587.         return toBigInteger(value, null);
  588.     }
  589.  
  590.     /**
  591.      * 转换为BigDecimal<br>
  592.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  593.      * 转换失败不会报错
  594.      *
  595.      * @param value        被转换的值
  596.      * @param defaultValue 转换错误时的默认值
  597.      * @return 结果
  598.      */
  599.     public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue) {
  600.         if (value == null) {
  601.             return defaultValue;
  602.         }
  603.         if (value instanceof BigDecimal) {
  604.             return (BigDecimal) value;
  605.         }
  606.         if (value instanceof Long) {
  607.             return new BigDecimal((Long) value);
  608.         }
  609.         if (value instanceof Double) {
  610.             return new BigDecimal((Double) value);
  611.         }
  612.         if (value instanceof Integer) {
  613.             return new BigDecimal((Integer) value);
  614.         }
  615.         final String valueStr = toStr(value, null);
  616.         if (StringUtils.isEmpty(valueStr)) {
  617.             return defaultValue;
  618.         }
  619.         try {
  620.             return new BigDecimal(valueStr);
  621.         } catch (Exception e) {
  622.             return defaultValue;
  623.         }
  624.     }
  625.  
  626.     /**
  627.      * 转换为BigDecimal<br>
  628.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  629.      * 转换失败不会报错
  630.      *
  631.      * @param value 被转换的值
  632.      * @return 结果
  633.      */
  634.     public static BigDecimal toBigDecimal(Object value) {
  635.         return toBigDecimal(value, null);
  636.     }
  637.  
  638.     /**
  639.      * 将对象转为字符串<br>
  640.      * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
  641.      *
  642.      * @param obj 对象
  643.      * @return 字符串
  644.      */
  645.     public static String utf8Str(Object obj) {
  646.         return str(obj, Charset.forName("UTF-8"));
  647.     }
  648.  
  649.     /**
  650.      * 将对象转为字符串<br>
  651.      * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
  652.      *
  653.      * @param obj         对象
  654.      * @param charsetName 字符集
  655.      * @return 字符串
  656.      */
  657.     public static String str(Object obj, String charsetName) {
  658.         return str(obj, Charset.forName(charsetName));
  659.     }
  660.  
  661.     /**
  662.      * 将对象转为字符串<br>
  663.      * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
  664.      *
  665.      * @param obj     对象
  666.      * @param charset 字符集
  667.      * @return 字符串
  668.      */
  669.     public static String str(Object obj, Charset charset) {
  670.         if (null == obj) {
  671.             return null;
  672.         }
  673.  
  674.         if (obj instanceof String) {
  675.             return (String) obj;
  676.         } else if (obj instanceof byte[] || obj instanceof Byte[]) {
  677.             return str((Byte[]) obj, charset);
  678.         } else if (obj instanceof ByteBuffer) {
  679.             return str((ByteBuffer) obj, charset);
  680.         }
  681.         return obj.toString();
  682.     }
  683.  
  684.     /**
  685.      * 将byte数组转为字符串
  686.      *
  687.      * @param bytes   byte数组
  688.      * @param charset 字符集
  689.      * @return 字符串
  690.      */
  691.     public static String str(byte[] bytes, String charset) {
  692.         return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
  693.     }
  694.  
  695.     /**
  696.      * 解码字节码
  697.      *
  698.      * @param data    字符串
  699.      * @param charset 字符集，如果此字段为空，则解码的结果取决于平台
  700.      * @return 解码后的字符串
  701.      */
  702.     public static String str(byte[] data, Charset charset) {
  703.         if (data == null) {
  704.             return null;
  705.         }
  706.  
  707.         if (null == charset) {
  708.             return new String(data);
  709.         }
  710.         return new String(data, charset);
  711.     }
  712.  
  713.     /**
  714.      * 将编码的byteBuffer数据转换为字符串
  715.      *
  716.      * @param data    数据
  717.      * @param charset 字符集，如果为空使用当前系统字符集
  718.      * @return 字符串
  719.      */
  720.     public static String str(ByteBuffer data, String charset) {
  721.         if (data == null) {
  722.             return null;
  723.         }
  724.  
  725.         return str(data, Charset.forName(charset));
  726.     }
  727.  
  728.     /**
  729.      * 将编码的byteBuffer数据转换为字符串
  730.      *
  731.      * @param data    数据
  732.      * @param charset 字符集，如果为空使用当前系统字符集
  733.      * @return 字符串
  734.      */
  735.     public static String str(ByteBuffer data, Charset charset) {
  736.         if (null == charset) {
  737.             charset = Charset.defaultCharset();
  738.         }
  739.         return charset.decode(data).toString();
  740.     }
  741.  
  742.     // ----------------------------------------------------------------------- 全角半角转换
  743.  
  744.     /**
  745.      * 半角转全角
  746.      *
  747.      * @param input String.
  748.      * @return 全角字符串.
  749.      */
  750.     public static String toSBC(String input) {
  751.         return toSBC(input, null);
  752.     }
  753.  
  754.     /**
  755.      * 半角转全角
  756.      *
  757.      * @param input         String
  758.      * @param notConvertSet 不替换的字符集合
  759.      * @return 全角字符串.
  760.      */
  761.     public static String toSBC(String input, Set<Character> notConvertSet) {
  762.         char c[] = input.toCharArray();
  763.         for (int i = 0; i < c.length; i++) {
  764.             if (null != notConvertSet && notConvertSet.contains(c[i])) {
  765.                 // 跳过不替换的字符
  766.                 continue;
  767.             }
  768.  
  769.             if (c[i] == ' ') {
  770.                 c[i] = '\u3000';
  771.             } else if (c[i] < '\177') {
  772.                 c[i] = (char) (c[i] + 65248);
  773.  
  774.             }
  775.         }
  776.         return new String(c);
  777.     }
  778.  
  779.     /**
  780.      * 全角转半角
  781.      *
  782.      * @param input String.
  783.      * @return 半角字符串
  784.      */
  785.     public static String toDBC(String input) {
  786.         return toDBC(input, null);
  787.     }
  788.  
  789.     /**
  790.      * 替换全角为半角
  791.      *
  792.      * @param text          文本
  793.      * @param notConvertSet 不替换的字符集合
  794.      * @return 替换后的字符
  795.      */
  796.     public static String toDBC(String text, Set<Character> notConvertSet) {
  797.         char c[] = text.toCharArray();
  798.         for (int i = 0; i < c.length; i++) {
  799.             if (null != notConvertSet && notConvertSet.contains(c[i])) {
  800.                 // 跳过不替换的字符
  801.                 continue;
  802.             }
  803.  
  804.             if (c[i] == '\u3000') {
  805.                 c[i] = ' ';
  806.             } else if (c[i] > '\uFF00' && c[i] < '\uFF5F') {
  807.                 c[i] = (char) (c[i] - 65248);
  808.             }
  809.         }
  810.         String returnString = new String(c);
  811.  
  812.         return returnString;
  813.     }
  814.  
  815.     /**
  816.      * 数字金额大写转换 先写个完整的然后将如零拾替换成零
  817.      *
  818.      * @param n 数字
  819.      * @return 中文大写数字
  820.      */
  821.     public static String digitUppercase(double n) {
  822.         String[] fraction = {"角", "分"};
  823.         String[] digit = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
  824.         String[][] unit = {{"元", "万", "亿"}, {"", "拾", "佰", "仟"}};
  825.  
  826.         String head = n < 0 ? "负" : "";
  827.         n = Math.abs(n);
  828.  
  829.         String s = "";
  830.         for (int i = 0; i < fraction.length; i++) {
  831.             s += (digit[(int) (Math.floor(n * 10 * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");
  832.         }
  833.         if (s.length() < 1) {
  834.             s = "整";
  835.         }
  836.         int integerPart = (int) Math.floor(n);
  837.  
  838.         for (int i = 0; i < unit[0].length && integerPart > 0; i++) {
  839.             String p = "";
  840.             for (int j = 0; j < unit[1].length && n > 0; j++) {
  841.                 p = digit[integerPart % 10] + unit[1][j] + p;
  842.                 integerPart = integerPart / 10;
  843.             }
  844.             s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
  845.         }
  846.         return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
  847.     }
  848. }
  849.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/309871
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号