Java constant string too long Exception - Runtime

Question

I am having a List of DTO which is mapped from a HTTP response(using RestTemplate call) having two value id and content. When I am iterating over list of DTO's, I am escaping HTML characters in content and replacing some unwated characters using the code below:

    String content = null;
    for(TestDto testDto: testDtoList) {
        try {
            content = StringEscapeUtils.unescapeHtml4(testDto.getContent()).
                                       replaceAll("<style(.+?)</style>", "").
                                       replaceAll("<script(.+?)</script>", "").
                                       replaceAll("(?s)<[^>]*>(\\s*<[^>]*>)*", " ").
                                       replaceAll("[^a-zA-Z0-9\\\\.]+", " ").
                                       replace("\\n", " ").
                                       replaceAll("\\\\r","").trim();
            processContent(content);
        } catch (Exception e) {
          System.out.println("Content err: " + e.getMessage());
        }
    }

In between the loop, code get halted due to java constant string too long exception. Even I am not able to catch this exception. How should I handle this problem?

EDIT :

The length of getContent() String can exceeds Integer.MAX_VALUE

Answer 1

That code is hard to read anyways so you might want to refactor it. One thing you could try is to use a StringBuffer along with Pattern, Matcher and the appendReplacement() and appendTail() methods. That way you could prove a list of patterns and replacements, iterate over it, iterate over all occurences of the current pattern and replace it. Unfortunately those methods don't accept StringBuilder but it might at least be worth a try. In fact, the replaceAll() method basically does the same but by doing it yourself you could skip the return sb.toString(); part which probably causes the problem.

Example:

class ReplacementInfo {
  String pattern;
  String replacement;
}

List<ReplacementInfo> list = ...; //build it

StringBuffer input = new StringBuffer( testDto.getContent() );
StringBuffer output = new StringBuffer( );

for( ReplacementInfo replacementInfo : list ) {
  //create the pattern and matcher for the current input
  Pattern pattern = Pattern.compile( replacementInfo.pattern );
  Matcher matcher = pattern.matcher( input );

  //replace all occurences of the pattern
  while( matcher.find() ) {
    matcher.appendReplacement( output, replacementInfo.replacement );
  }
  //add the rest of the input
  matcher.appendTail( output );

  //reuse the output as the input for the next iteration
  input = output;
  output = new StringBuffer();
}

At the end input would contain the result unless you handle reusing the intermediate steps differently, e.g. by clearing the buffers and adding output to input thus keeping output until the next iteration.

Btw, you might also want to look into using StringEscapeUtils.UNESCAPE_HTML4.translate(input, writer) along with a StringWriter that allows you to access the underlying StringBuffer and thus completely operate on the content without using String.

Answer 2

Change your catch block like below,

    String content = null;
    for(TestDto testDto: testDtoList) {
        try {
            content = StringEscapeUtils.unescapeHtml4(testDto.getContent()).
                                   replaceAll("<style(.+?)</style>", "").
                                   replaceAll("<script(.+?)</script>", "").
                                   replaceAll("(?s)<[^>]*>(\\s*<[^>]*>)*", " ").
                                   replaceAll("[^a-zA-Z0-9\\\\.]+", " ").
                                   replace("\\n", " ").
                                   replaceAll("\\\\r","").trim();
        } catch (ContentTooLongException e) {
            System.out.println("Content err: " + e.getMessage());
        }catch (Exception e) {
            System.out.println("other err: " + e.getMessage());
        }
    }

Now you'll be able to handle any exception.

Answer 3

Supposing your DTO isn't big enough, you could:

1. store the response in a temporary file,
2. add a catch clause with the specific exception that is thrown during the runtime, and inside the clause the handling code for it.

That way you can parse the strings and when the exception hits, you could handle the long string by splitting it in parts and cleaning it.