content: /*
   * Copyright 1999-2018 Alibaba Group Holding Ltd.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package com.alibaba.nacos.config.server.utils;
  
  import com.alibaba.nacos.config.server.constant.Constants;
  
  import java.io.UnsupportedEncodingException;
  import java.security.MessageDigest;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.concurrent.locks.ReentrantLock;
  
  /**
   * md5
   *
   * @author Nacos
   */
  @SuppressWarnings("PMD.ClassNamingShouldBeCamelRule")
  public class MD5 {
      private static char[] digits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
      private final static int DIGITS_COUNT = 16;
      private final static int DIGITS_CHAR_SIZE = 32;
  
      private static Map<Character, Integer> rDigits = new HashMap<Character, Integer>(16);
  
      static {
          for (int i = 0; i < digits.length; ++i) {
              rDigits.put(digits[i], i);
          }
      }
  
      private static MD5 me = new MD5();
      private MessageDigest mHasher;
      private ReentrantLock opLock = new ReentrantLock();
  
      private MD5() {
          try {
              mHasher = MessageDigest.getInstance("md5");
          } catch (Exception e) {
              throw new RuntimeException(e);
          }
  
      }
  
      public static MD5 getInstance() {
          return me;
      }
  
      public String getMD5String(String content) {
          return bytes2string(hash(content));
      }
  
      public String getMD5String(byte[] content) {
          return bytes2string(hash(content));
      }
  
      public byte[] getMD5Bytes(byte[] content) {
          return hash(content);
      }
  
      /**
       * 对字符串进行md5
       *
       * @param str
       * @return md5 byte[16]
       */
      public byte[] hash(String str) {
          opLock.lock();
          try {
              byte[] bt = mHasher.digest(str.getBytes(Constants.ENCODE));
              if (null == bt || bt.length != DIGITS_COUNT) {
                  throw new IllegalArgumentException("md5 need");
              }
              return bt;
          } catch (UnsupportedEncodingException e) {
              throw new RuntimeException("unsupported utf-8 encoding", e);
          } finally {
              opLock.unlock();
          }
      }
  
      /**
       * 对二进制数据进行md5
       *
       * @param str
       * @return md5 byte[16]
       */
      public byte[] hash(byte[] data) {
          opLock.lock();
          try {
              byte[] bt = mHasher.digest(data);
              if (null == bt || bt.length != DIGITS_COUNT) {
                  throw new IllegalArgumentException("md5 need");
              }
              return bt;
          } finally {
              opLock.unlock();
          }
      }
  
      /**
       * 将一个字节数组转化为可见的字符串
       *
       * @param bt
       * @return
       */
      public String bytes2string(byte[] bt) {
          int l = bt.length;
  
          char[] out = new char[l << 1];
  
          for (int i = 0, j = 0; i < l; i++) {
              out[j++] = digits[(0xF0 & bt[i]) >>> 4];
              out[j++] = digits[0x0F & bt[i]];
          }
  
          return new String(out);
      }
  
      /**
       * 将字符串转换为bytes
       *
       * @param str
       * @return byte[]
       */
      public byte[] string2bytes(String str) {
          if (null == str) {
              throw new NullPointerException("参数不能为空");
          }
          if (str.length() != DIGITS_CHAR_SIZE) {
              throw new IllegalArgumentException("字符串长度必须是32");
          }
          byte[] data = new byte[16];
          char[] chs = str.toCharArray();
          for (int i = 0; i < DIGITS_COUNT; ++i) {
              int h = rDigits.get(chs[i * 2]).intValue();
              int l = rDigits.get(chs[i * 2 + 1]).intValue();
              data[i] = (byte)((h & 0x0F) << 4 | (l & 0x0F));
          }
          return data;
      }
  
  }
  