HTML过滤和补齐（四）

/**
* 取得本地化的字符串。
*/
public static String localize(String str) {
   return localize(str, null);
}

/**
* 取得制定locale的字符串
*
* @param str
* @param locale
* @return
*/
public static String localize(String str, Locale locale) {
   if (str == null) {
    return null;
   }

   return new LocalizeTokenizer(str, locale).parse();
}

private static class LocalizeTokenizer {
   private static final char BLOCK_START = '{';
   private static final char BLOCK_END = '}';
   private static final char LOCALE_START = '[';
   private static final char LOCALE_END = ']';
   private String str;
   private Locale locale;
   private int blockStartIndex;
   private int blockEndIndex;
   private int localeStartIndex;
   private int localeEndIndex;
   private Locale currentLocale;

   public LocalizeTokenizer(String str, Locale locale) {
    this.str = str;
    this.locale = locale;
   }

   public String parse() {
    StringBuffer result = new StringBuffer(str.length());
    String block;
    int index = 0;

    while ((block = findBlock(index)) != null) {
     // findBlock返回非null时，blockStartIndex和blockEndIndex同时被设置。
     result.append(str.substring(index, blockStartIndex));
     result.append(block);

     index = blockEndIndex + 1;
    }

    result.append(str.substring(index));

    return result.toString();
   }

   // 查找"{"和"}"之间的block。
   private String findBlock(int index) {
    Map blocks = new HashMap(4);

    blockEndIndex = index;

    for (;;) {
     blockStartIndex = str.indexOf(BLOCK_START, index);

     if ((blockStartIndex != -1) && (blockEndIndex != -1)) {
      blockEndIndex = str.indexOf(BLOCK_END, blockStartIndex + 1);
      index = blockStartIndex + 1; // 下次循环从blockStartIndex之后开始

      if (blockEndIndex != -1) {
       // 扫描block中的localized block，在(blockStartIndex,
       // blockEndIndex)范围内。
       String localizedBlock;
       Locale lastLocale = null;
       int localizedIndex = blockStartIndex + 1;

       while ((localizedBlock = findLocalizedBlock(localizedIndex)) != null) {
        // findLocalizedBlock返回非null时，currentLocale,
        // localeStartIndex和localeEndIndex同时被设置。
        blocks.put(ObjectUtil.toString(lastLocale),
          localizedBlock);
        lastLocale = currentLocale;
        localizedIndex = localeEndIndex + 1;
       }

       break;
      }
     } else {
      break;
     }
    }

    // 选择locale。
    if (!blocks.isEmpty()) {
     if (blocks.size() == 1) {
      String key = (String) blocks.keySet().iterator().next();

      if (StringUtil.isEmpty(key)) {
       return "" + BLOCK_START + blocks.get(key) + BLOCK_END;
      }
      return (String) blocks.get(key);
     }
     List locales = LocaleUtil.calculateBundleNames("",
       (locale == null) ? LocaleUtil.getContext().getLocale()
         : locale);

     for (int i = locales.size() - 1; i >= 0; i--) {
      String localizedBlock = (String) blocks.get(locales.get(i));

      if (localizedBlock != null) {
       return localizedBlock;
      }
     }
    }

    return null;
   }

   // 查找blockStartIndex和blockEndIndex之间的localized block。
   private String findLocalizedBlock(int localizedIndex) {
    int startIndex = localizedIndex;
    boolean eof = false;

    if (startIndex >= blockEndIndex) {
     return null;
    }

    currentLocale = null;
    localeEndIndex = localizedIndex;

    for (;;) {
     localeStartIndex = str.indexOf(LOCALE_START, localizedIndex);

     if ((localeStartIndex >= blockStartIndex)
       && (localeStartIndex < blockEndIndex)
       && (localeEndIndex >= blockStartIndex)
       && (localeEndIndex < blockEndIndex)) {
      localeEndIndex = str.indexOf(LOCALE_END,
        localeStartIndex + 1);
      localizedIndex = localeStartIndex + 1; // 下次循环从localeStartIndex之后开始

      if ((localeEndIndex >= blockStartIndex)
        && (localeEndIndex < blockEndIndex)) {
       String localeName = str.substring(localeStartIndex + 1,
         localeEndIndex);

       if (StringUtil.isNotEmpty(localeName)) {
        currentLocale = LocaleUtil.parseLocale(localeName);

        if (LocaleUtil.isLocaleSupported(currentLocale)) {
         return str.substring(startIndex,
           localeStartIndex);
        }
        currentLocale = null;
       }
      }
     } else {
      eof = true;
      break;
     }
    }

    if (eof) {
     localeStartIndex = startIndex;
     localeEndIndex = blockEndIndex;
     return str.substring(startIndex, blockEndIndex);
    }
    return null;
   }
}

/**
* Trim a HTML string to <code>maxSize</code>.
*
* <p>
* The string may contain HTML tags. After conversion, all HTML tags still
* remain in the string, however, if the rest part of the string is longer
* than <code>maxSize</code>, it will be trimed and to
* <code>maxSize</code>, and has an ellipsis <code>...</code> appended
* to it.
*
* <p>
* Single byte characters are counted as half length of double byte
* characters.
*
* <p>
* For the sake of simplicity and performance, we don't use HTML parser,
* instead we use a naive method to deal with HTML tags.
*
* @param string -
*            the string to be trimmed.
* @param maxLength -
*            max length of the string.
*
* @return - a trimmed string
*/
public static String trimHTMLString(String string, int maxLength) {
   if (string == null) {
    return "";
   } else if (string.length() <= maxLength) {
    return string;
   } else {
    StringBuffer result = new StringBuffer();

    int maxWeight = 2 * maxLength;
    int weight = 0;

    int totalLength = string.length();
    int index = 0;
    int leftTagCount = 0;

    while ((index < totalLength)
      && ((weight <= maxWeight) || (leftTagCount > 0))) {
     char c = string.charAt(index);

     index++;

     if (c == '<') {
      // eat all tags
      result.append(c);

      if (index < totalLength) {
       c = string.charAt(index);
       index++;
       result.append(c);

       if (c == '/') {
        if (leftTagCount > 0) {
         leftTagCount--;
        }
       } else {
        leftTagCount++;
       }
      }

      while ((c != '>') && (index < totalLength)) {
       c = string.charAt(index);
       index++;
       result.append(c);
      }
     } else {
      if (weight <= maxWeight) {
       if (weight == maxWeight) {
        result.append("...");
        weight += 3;
       } else {
        if (c == '&') {
         // peek to see if it is a html entity
         int peekIndex = string.indexOf(';', index);

         if (peekIndex > 0) {
          int entityValue = Entities.HTML40
            .getEntityValue(string.substring(
              index, peekIndex));

          if (entityValue > 0) {
           // count as one;
           result.append(string.substring(
             index - 1, peekIndex + 1));
           index = peekIndex + 1;

           if (entityValue < 256) {
            weight += 1;
           } else {
            weight += 2;
           }

           if (weight > maxWeight) {
            result.append("...");
            weight += 3;
           }

           continue;
          }
         }
        }

        // ordinary characters
        result.append(c);

        if (c < 256) {
         weight += 1;
        } else {
         weight += 2;
        }

        if (weight > maxWeight) {
         result.append("...");
         weight += 3;
        }
       }
      }
     }
    }

    return result.toString();
   }
}

/**
* 转换字符串为int
*
* @param s
* @param def
* @return
*/
public static int getInt(String s, int def) {
   int i = def;
   try {
    i = Integer.parseInt(s);
   } catch (NumberFormatException e) {
    // ignore
   }
   return i;
}

/**
* 转换字符串为int
*
* @param s
* @return
*/
public static int getInt(String s) {
   return getInt(s, 0);
}