Cookie,IdWorker, Json, Number通用工具类

• Cookie
  
  package com.leyou.common.utils;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import javax.servlet.http.Cookie;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.io.UnsupportedEncodingException;
  import java.net.URLDecoder;
  import java.net.URLEncoder;
  
  /**
   * 
   * Cookie 工具类
   *
   */
  public final class CookieUtils {
  
     protected static final Logger logger = LoggerFactory.getLogger(CookieUtils.class);
  
     /**
      * 得到Cookie的值, 不编码
      * 
      * @param request
      * @param cookieName
      * @return
      */
     public static String getCookieValue(HttpServletRequest request, String cookieName) {
        return getCookieValue(request, cookieName, false);
     }
  
     /**
      * 得到Cookie的值,
      * 
      * @param request
      * @param cookieName
      * @return
      */
     public static String getCookieValue(HttpServletRequest request, String cookieName, boolean isDecoder) {
        Cookie[] cookieList = request.getCookies();
        if (cookieList == null || cookieName == null){
           return null;         
        }
        String retValue = null;
        try {
           for (int i = 0; i < cookieList.length; i++) {
              if (cookieList[i].getName().equals(cookieName)) {
                 if (isDecoder) {
                    retValue = URLDecoder.decode(cookieList[i].getValue(), "UTF-8");
                 } else {
                    retValue = cookieList[i].getValue();
                 }
                 break;
              }
           }
        } catch (UnsupportedEncodingException e) {
           logger.error("Cookie Decode Error.", e);
        }
        return retValue;
     }
  
     /**
      * 得到Cookie的值,
      * 
      * @param request
      * @param cookieName
      * @return
      */
     public static String getCookieValue(HttpServletRequest request, String cookieName, String encodeString) {
        Cookie[] cookieList = request.getCookies();
        if (cookieList == null || cookieName == null){
           return null;         
        }
        String retValue = null;
        try {
           for (int i = 0; i < cookieList.length; i++) {
              if (cookieList[i].getName().equals(cookieName)) {
                 retValue = URLDecoder.decode(cookieList[i].getValue(), encodeString);
                 break;
              }
           }
        } catch (UnsupportedEncodingException e) {
           logger.error("Cookie Decode Error.", e);
        }
        return retValue;
     }
  
     /**
      * 设置Cookie的值 不设置生效时间默认浏览器关闭即失效,也不编码
      */
     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue) {
        setCookie(request, response, cookieName, cookieValue, -1);
     }
  
     /**
      * 设置Cookie的值 在指定时间内生效,但不编码
      */
     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage) {
        setCookie(request, response, cookieName, cookieValue, cookieMaxage, false);
     }
  
     /**
      * 设置Cookie的值 不设置生效时间,但编码
      */
     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, boolean isEncode) {
        setCookie(request, response, cookieName, cookieValue, -1, isEncode);
     }
  
     /**
      * 设置Cookie的值 在指定时间内生效, 编码参数
      */
     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, boolean isEncode) {
        doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, isEncode);
     }
  
     /**
      * 设置Cookie的值 在指定时间内生效, 编码参数(指定编码)
      */
     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, String encodeString) {
        doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, encodeString);
     }
  
     /**
      * 删除Cookie带cookie域名
      */
     public static void deleteCookie(HttpServletRequest request, HttpServletResponse response, String cookieName) {
        doSetCookie(request, response, cookieName, "", -1, false);
     }
  
     /**
      * 设置Cookie的值，并使其在指定时间内生效
      * 
      * @param cookieMaxage
      *            cookie生效的最大秒数
      */
     private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, boolean isEncode) {
        try {
           if (cookieValue == null) {
              cookieValue = "";
           } else if (isEncode) {
              cookieValue = URLEncoder.encode(cookieValue, "utf-8");
           }
           Cookie cookie = new Cookie(cookieName, cookieValue);
           if (cookieMaxage > 0)
              cookie.setMaxAge(cookieMaxage);
           if (null != request)// 设置域名的cookie
              cookie.setDomain(getDomainName(request));
           cookie.setPath("/");
           response.addCookie(cookie);
        } catch (Exception e) {
           logger.error("Cookie Encode Error.", e);
        }
     }
  
     /**
      * 设置Cookie的值，并使其在指定时间内生效
      * 
      * @param cookieMaxage
      *            cookie生效的最大秒数
      */
     private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, String encodeString) {
        try {
           if (cookieValue == null) {
              cookieValue = "";
           } else {
              cookieValue = URLEncoder.encode(cookieValue, encodeString);
           }
           Cookie cookie = new Cookie(cookieName, cookieValue);
           if (cookieMaxage > 0)
              cookie.setMaxAge(cookieMaxage);
           if (null != request)// 设置域名的cookie
              cookie.setDomain(getDomainName(request));
           cookie.setPath("/");
           response.addCookie(cookie);
        } catch (Exception e) {
           logger.error("Cookie Encode Error.", e);
        }
     }
  
     /**
      * 得到cookie的域名
      */
     private static final String getDomainName(HttpServletRequest request) {
        String domainName = null;
  
        String serverName = request.getRequestURL().toString();
        if (serverName == null || serverName.equals("")) {
           domainName = "";
        } else {
           serverName = serverName.toLowerCase();
           serverName = serverName.substring(7);
           final int end = serverName.indexOf("/");
           serverName = serverName.substring(0, end);
           final String[] domains = serverName.split("\\.");
           int len = domains.length;
           if (len > 3) {
              // www.xxx.com.cn
              domainName = domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
           } else if (len <= 3 && len > 1) {
              // xxx.com or xxx.cn
              domainName = domains[len - 2] + "." + domains[len - 1];
           } else {
              domainName = serverName;
           }
        }
  
        if (domainName != null && domainName.indexOf(":") > 0) {
           String[] ary = domainName.split("\\:");
           domainName = ary[0];
        }
        return domainName;
     }
  
  }
  

• IdWorker

package com.leyou.common.utils;

import java.lang.management.ManagementFactory;
import java.net.InetAddress;
import java.net.NetworkInterface;

/**
 * <p>名称：IdWorker.java</p>
 * <p>描述：分布式自增长ID</p>
 * <pre>
 *     Twitter的 Snowflake　JAVA实现方案
 * </pre>
 * 核心代码为其IdWorker这个类实现，其原理结构如下，我分别用一个0表示一位，用—分割开部分的作用：
 * 1||0---0000000000 0000000000 0000000000 0000000000 0 --- 00000 ---00000 ---000000000000
 * 在上面的字符串中，第一位为未使用（实际上也可作为long的符号位），接下来的41位为毫秒级时间，
 * 然后5位datacenter标识位，5位机器ID（并不算标识符，实际是为线程标识），
 * 然后12位该毫秒内的当前毫秒内的计数，加起来刚好64位，为一个Long型。
 * 这样的好处是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞（由datacenter和机器ID作区分），
 * 并且效率较高，经测试，snowflake每秒能够产生26万ID左右，完全满足需要。
 * <p>
 * 64位ID (42(毫秒)+5(机器ID)+5(业务编码)+12(重复累加))
 *
 * @author Polim
 */
public class IdWorker {
    // 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动）
    private final static long twepoch = 1288834974657L;
    // 机器标识位数
    private final static long workerIdBits = 5L;
    // 数据中心标识位数
    private final static long datacenterIdBits = 5L;
    // 机器ID最大值
    private final static long maxWorkerId = -1L ^ (-1L << workerIdBits);
    // 数据中心ID最大值
    private final static long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    // 毫秒内自增位
    private final static long sequenceBits = 12L;
    // 机器ID偏左移12位
    private final static long workerIdShift = sequenceBits;
    // 数据中心ID左移17位
    private final static long datacenterIdShift = sequenceBits + workerIdBits;
    // 时间毫秒左移22位
    private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

    private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
    /* 上次生产id时间戳 */
    private static long lastTimestamp = -1L;
    // 0，并发控制
    private long sequence = 0L;

    private final long workerId;
    // 数据标识id部分
    private final long datacenterId;

    public IdWorker(){
        this.datacenterId = getDatacenterId(maxDatacenterId);
        this.workerId = getMaxWorkerId(datacenterId, maxWorkerId);
    }
    /**
     * @param workerId
     *            工作机器ID
     * @param datacenterId
     *            序列号
     */
    public IdWorker(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }
    /**
     * 获取下一个ID
     *
     * @return
     */
    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }

        if (lastTimestamp == timestamp) {
            // 当前毫秒内，则+1
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                // 当前毫秒内计数满了，则等待下一秒
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = timestamp;
        // ID偏移组合生成最终的ID，并返回ID
        long nextId = ((timestamp - twepoch) << timestampLeftShift)
                | (datacenterId << datacenterIdShift)
                | (workerId << workerIdShift) | sequence;

        return nextId;
    }

    private long tilNextMillis(final long lastTimestamp) {
        long timestamp = this.timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = this.timeGen();
        }
        return timestamp;
    }

    private long timeGen() {
        return System.currentTimeMillis();
    }

    /**
     * <p>
     * 获取 maxWorkerId
     * </p>
     */
    protected static long getMaxWorkerId(long datacenterId, long maxWorkerId) {
        StringBuffer mpid = new StringBuffer();
        mpid.append(datacenterId);
        String name = ManagementFactory.getRuntimeMXBean().getName();
        if (!name.isEmpty()) {
         /*
          * GET jvmPid
          */
            mpid.append(name.split("@")[0]);
        }
      /*
       * MAC + PID 的 hashcode 获取16个低位
       */
        return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
    }

    /**
     * <p>
     * 数据标识id部分
     * </p>
     */
    protected static long getDatacenterId(long maxDatacenterId) {
        long id = 0L;
        try {
            InetAddress ip = InetAddress.getLocalHost();
            NetworkInterface network = NetworkInterface.getByInetAddress(ip);
            if (network == null) {
                id = 1L;
            } else {
                byte[] mac = network.getHardwareAddress();
                id = ((0x000000FF & (long) mac[mac.length - 1])
                        | (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;
                id = id % (maxDatacenterId + 1);
            }
        } catch (Exception e) {
            System.out.println(" getDatacenterId: " + e.getMessage());
        }
        return id;
    }
}

• JsonUtilspackage com.leyou.common.utils;
  
  import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.core.type.TypeReference;
  import com.fasterxml.jackson.databind.ObjectMapper;
  import lombok.AllArgsConstructor;
  import lombok.Data;
  import lombok.NoArgsConstructor;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.lang.Nullable;
  
  import java.io.IOException;
  import java.util.List;
  import java.util.Map;
  
  /**
   * @author: HuYi.Zhang
   * @create: 2018-04-24 17:20
   **/
  @Slf4j
  public class JsonUtils {
  
      public static final ObjectMapper mapper = new ObjectMapper();
      
      @Nullable
      public static String toString(Object obj) {
          if (obj == null) {
              return null;
          }
          if (obj.getClass() == String.class) {
              return (String) obj;
          }
          try {
              return mapper.writeValueAsString(obj);
          } catch (JsonProcessingException e) {
              log.error("json序列化出错：" + obj, e);
              return null;
          }
      }
  
      @Nullable
      public static <T> T toBean(String json, Class<T> tClass) {
          try {
              return mapper.readValue(json, tClass);
          } catch (IOException e) {
              log.error("json解析出错：" + json, e);
              return null;
          }
      }
  
      @Nullable
      public static <E> List<E> toList(String json, Class<E> eClass) {
          try {
              return mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, eClass));
          } catch (IOException e) {
              log.error("json解析出错：" + json, e);
              return null;
          }
      }
  
      @Nullable
      public static <K, V> Map<K, V> toMap(String json, Class<K> kClass, Class<V> vClass) {
          try {
              return mapper.readValue(json, mapper.getTypeFactory().constructMapType(Map.class, kClass, vClass));
          } catch (IOException e) {
              log.error("json解析出错：" + json, e);
              return null;
          }
      }
  
      @Nullable
      public static <T> T nativeRead(String json, TypeReference<T> type) {
          try {
              return mapper.readValue(json, type);
          } catch (IOException e) {
              log.error("json解析出错：" + json, e);
              return null;
          }
      }
      @Data
      @NoArgsConstructor
      @AllArgsConstructor
      static class User{
          String name;
          Integer age;
      }
      public static void main(String[] args) {
          User user = new User("Tom", 27);
          String json = toString(user);
          System.out.println("json = " + json);
  
          User bean = toBean(json, User.class);
          System.out.println("bean = " + bean);
  
          String list = "[1,10,20,50,2]";
          List<Integer> toList = toList(list, Integer.class);
          System.out.println("toList = " + toList);
  
          String map = "{\"name\": \"Tom\", \"age\": 27}";
          Map<String, String> toMap = toMap(map, String.class, String.class);
          System.out.println("toMap = " + toMap);
  
          String complexJson = "[{\"name\": \"Tom\", \"age\": 27},{\"name\": \"Jack\", \"age\": 30}]";
          List<Map<String, String>> mapList = nativeRead(complexJson, new TypeReference<List<Map<String, String>>>() {
          });
  
          for (Map<String, String> map1 : mapList) {
              System.out.println("map1 = " + map1);
          }
      }
  
  }

• NumberUtils

package com.leyou.common.utils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author: HuYi.Zhang
 * @create: 2018-04-25 09:13
 **/
public class NumberUtils {

    public static boolean isInt(Double num) {
        return num.intValue() == num;
    }

    /**
     * 判断字符串是否是数值格式
     * @param str
     * @return
     */
    public static boolean isDigit(String str){
        if(str == null || str.trim().equals("")){
            return false;
        }
        return str.matches("^\\d+$");
    }

    /**
     * 将一个小数精确到指定位数
     * @param num
     * @param scale
     * @return
     */
    public static double scale(double num, int scale) {
        BigDecimal bd = new BigDecimal(num);
        return bd.setScale(scale, RoundingMode.HALF_UP).doubleValue();
    }

    // 从字符串中根据正则表达式寻找，返回找到的数字数组
    public static Double[] searchNumber(String value, String regex){
        List<Double> doubles = new ArrayList<>();
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(value);
        if(matcher.find()) {
            MatchResult result = matcher.toMatchResult();
            for (int i = 1; i <= result.groupCount(); i++) {
                doubles.add(Double.valueOf(result.group(i)));
            }
        }
        return doubles.toArray(new Double[doubles.size()]);
    }

    /**
     * 生成指定位数的随机数字
     * @param len
     * @return
     */
    public static String generateCode(int len){
        len = Math.min(len, 8);
        int min = Double.valueOf(Math.pow(10, len - 1)).intValue();
        int num = new Random().nextInt(Double.valueOf(Math.pow(10, len + 1)).intValue() - 1) + min;
        return String.valueOf(num).substring(0,len);
    }
}