org.apache.commons.lang3.StringEscapeUtils#escapeJava ( )源码实例Demo

/**
 * Gets the node reference for a given tag.
 * <p>
 * Returns null if tag is not present and not created.
 * 
 * @param storeRef      store reference
 * @param tag           tag
 * @param create        create a node if one doesn't exist?
 * @return NodeRef      tag node reference or null not exist
 */
private NodeRef getTagNodeRef(StoreRef storeRef, String tag, boolean create)
{
    for (String forbiddenSequence : FORBIDDEN_TAGS_SEQUENCES)
    {
        if (create && tag.contains(forbiddenSequence))
        {
            throw new IllegalArgumentException("Tag name must not contain " + StringEscapeUtils.escapeJava(forbiddenSequence) + " char sequence");
        }
    }
    
    NodeRef tagNodeRef = null;
    Collection<ChildAssociationRef> results = this.categoryService.getRootCategories(storeRef, ContentModel.ASPECT_TAGGABLE, tag, create);
    if (!results.isEmpty())
    {
        tagNodeRef = results.iterator().next().getChildRef();
    }
    return tagNodeRef;
}
 

@Override
public String toString() {
  return "Insert(start line: "
      + startLine
      + ", offset: "
      + startInLineOffset
      + ", line delta: "
      + lineDelta
      + ", offset delta: "
      + offsetDelta
      + ", text: '"
      + StringEscapeUtils.escapeJava(StringUtils.abbreviate(text, 150))
      + "', origin start line: "
      + originStartLine
      + ", offset: "
      + originStartInLineOffset
      + ")";
}
 

@Override
public String toString() {
  String newText = StringEscapeUtils.escapeJava(StringUtils.abbreviate(this.newText, 150));
  String oldText = StringEscapeUtils.escapeJava(StringUtils.abbreviate(replacedText, 150));
  return "TextEditActivity(start: "
      + startPosition
      + ", new text line delta: "
      + newTextLineDelta
      + ", new text offset delta: "
      + newTextOffsetDelta
      + ", new: '"
      + newText
      + "', replaced text line delta: "
      + replacedTextLineDelta
      + ", replaced text offset delta: "
      + replacedTextOffsetDelta
      + ", old: '"
      + oldText
      + "', file: "
      + getResource()
      + ", src: "
      + getSource()
      + ")";
}
 

private String getWwwAuthenticateHeader(Saml2Settings saml2Settings) throws Exception {
    AuthnRequest authnRequest = this.buildAuthnRequest(saml2Settings);

    return "X-Security-IdP realm=\"Open Distro Security\" location=\""
            + StringEscapeUtils.escapeJava(getSamlRequestRedirectBindingLocation(IdpEndpointType.SSO, saml2Settings,
                    authnRequest.getEncodedAuthnRequest(true)))
            + "\" requestId=\"" + StringEscapeUtils.escapeJava(authnRequest.getId()) + "\"";
}
 

public static String attrToXpathString(Attribute attr) {
    String stringValue = attr.getStringValue();
    Object v = attr.getValue();
    if (v instanceof String || v instanceof Enum) {
        stringValue = "\"" + StringEscapeUtils.escapeJava(stringValue) + "\"";
    } else if (v instanceof Boolean) {
        stringValue = v + "()";
    }
    return String.valueOf(stringValue);
}
 

@Override
protected void executeQuery() {

    String invoked = "spark.read()\n"
        + "            .option(\"header\", \"true\")\n"
        + "            .option(\"inferSchema\", \"true\")\n"
        + "            .option(\"timestampFormat\", \"yyyy/MM/dd HH:mm:ss ZZ\")\n"
        + "            .option(\"delimiter\", \",\")\n"
        + "            .csv(\"" + StringEscapeUtils.escapeJava(properties.getProperty("directory")) + "\")\n"
        + "            .toDF()\n"
        + "            .createOrReplaceTempView(\"" + properties.getProperty("tableName") + "\");\n"
        + "        \n"
        + "      tmp = spark.sql(\"" + query.replaceAll("\\.", "_") + "\");";
    composer.handleComposition(ClassBodyComposer.CodeCategory.SENTENCE, invoked);
}
 

private void extractTar( String tarFilePath, String outputDirPath ) {

        TarArchiveEntry entry = null;
        try (TarArchiveInputStream tis = new TarArchiveInputStream(new FileInputStream(tarFilePath))) {
            while ((entry = (TarArchiveEntry) tis.getNextEntry()) != null) {
                if (log.isDebugEnabled()) {
                    log.debug("Extracting " + entry.getName());
                }
                File entryDestination = new File(outputDirPath, entry.getName());
                if (entry.isDirectory()) {
                    entryDestination.mkdirs();
                } else {
                    entryDestination.getParentFile().mkdirs();
                    OutputStream out = new BufferedOutputStream(new FileOutputStream(entryDestination));
                    IoUtils.copyStream(tis, out, false, true);
                }
                if (OperatingSystemType.getCurrentOsType() != OperatingSystemType.WINDOWS) {//check if the OS is UNIX
                    // set file/dir permissions, after it is created
                    Files.setPosixFilePermissions(entryDestination.getCanonicalFile().toPath(),
                                                  getPosixFilePermission(entry.getMode()));
                }
            }
        } catch (Exception e) {
            String errorMsg = null;
            if (entry != null) {
                errorMsg = "Unable to untar " + StringEscapeUtils.escapeJava(entry.getName()) + " from " + tarFilePath
                           + ".Target directory '" + outputDirPath + "' is in inconsistent state.";
            } else {
                errorMsg = "Could not read data from " + tarFilePath;
            }
            throw new FileSystemOperationException(errorMsg, e);
        }

    }
 

public String apply(Map<String, Object> params) {
  List<Object> values = new ArrayList<>(params.size());
  for (String key : keys) {
    Object obj = params.get(key);
    if (obj == null) {
      obj = nullPlaceholder;
    }
    values.add(obj);
  }
  return StringEscapeUtils.escapeJava(String.format(format, values.toArray()));
}
 

public Object referenceInsert(final String reference, final Object value) {
    if (value == null) {
        return null;
    } else {
        return StringEscapeUtils.escapeJava(value.toString());
    }
}
 

public Object referenceInsert(final String reference, final Object value) {
    if (value == null) {
        return null;
    } else {
        return StringEscapeUtils.escapeJava(value.toString());
    }
}
 

protected String printLdcInsnNode(LdcInsnNode ldc, ListIterator<?> it) {
    if (ldc.cst instanceof String)
        return nameOpcode(ldc.getOpcode()) + " \""
                + StringEscapeUtils.escapeJava(ldc.cst.toString()) + "\" ("
                + ldc.cst.getClass().getCanonicalName() + ")";

    return nameOpcode(ldc.getOpcode()) + " "
            + StringEscapeUtils.escapeJava(ldc.cst.toString()) + " ("
            + ldc.cst.getClass().getCanonicalName() + ")";
}
 

protected String printLdcInsnNode(LdcInsnNode ldc, ListIterator<?> it) {
    if (ldc.cst instanceof String)
        return nameOpcode(ldc.getOpcode()) + " \"" + StringEscapeUtils.escapeJava(ldc.cst.toString()) + "\" (" + ldc.cst.getClass().getCanonicalName() + ")";

    return nameOpcode(ldc.getOpcode()) + " " + StringEscapeUtils.escapeJava(ldc.cst.toString()) + " (" + ldc.cst.getClass().getCanonicalName() + ")";
}
 

public static String escape(String str) {
	return StringEscapeUtils.escapeJava(str);
}
 

public static String quoteSqlString(String s){
	return "\"" + StringEscapeUtils.escapeJava(s) + "\"";
}
 

public static String escapeJavaString(String s){
	return StringEscapeUtils.escapeJava(s);
}
 

public static String quoteJavascriptString(String s) {
    return "\"" + StringEscapeUtils.escapeJava(s) + "\"";
}
 

/**
 * <p>Escapes the characters in a <code>String</code> using Java String rules.</p>
 * <p>Delegates the process to {@link StringEscapeUtils#escapeJava(String)}.</p>
 *
 * @param string the string to escape values, may be null
 * @return String with escaped values, <code>null</code> if null string input
 *
 * @see StringEscapeUtils#escapeJava(String)
 */
public String java(Object string)
{
    if (string == null)
    {
        return null;
    }
    return StringEscapeUtils.escapeJava(String.valueOf(string));
}
 

/**
 * Escapes the characters in a {@code String} according to Java string literal
 * rules.
 *
 * Deals correctly with quotes and control-chars (tab, backslash, cr, ff,
 * etc.) so, for example, a tab becomes the characters {@code '\\'} and
 * {@code 't'}.
 *
 * Example:
 * <pre>
 * input string: He didn't say, "Stop!"
 * output string: He didn't say, \"Stop!\"
 * </pre>
 *
 * @param input  String to escape values in, may be null
 * @return String with escaped values, {@code null} if null string input
 */
public static final String escapeJava(String input) {
  return StringEscapeUtils.escapeJava(input);
}
 

/**
 * Gets the text of the search query.
 * @return String containing the query target.
 */
public String getEscapedSearchString() {
    return StringEscapeUtils.escapeJava(searchString);
}
 

/**
 * Escapes the characters in a {@code String} according to Java string literal
 * rules.
 *
 * Deals correctly with quotes and control-chars (tab, backslash, cr, ff,
 * etc.) so, for example, a tab becomes the characters {@code '\\'} and
 * {@code 't'}.
 *
 * Example:
 * <pre>
 * input string: He didn't say, "Stop!"
 * output string: He didn't say, \"Stop!\"
 * </pre>
 *
 * @param input  String to escape values in, may be null
 * @return String with escaped values, {@code null} if null string input
 */
public static final String escapeJava(String input) {
  return StringEscapeUtils.escapeJava(input);
}