含占位符的Java回调URL验证方案及错误提示需求咨询

Nice problem to solve—here's a practical approach that leans on Apache's existing libraries to get both accurate validation and clear error messages, without having to roll your own complex URL regex:

Step 1: Validate Placeholder Legality First #

Since you know the exact set of allowed placeholders, start by checking that the URL only uses those. This lets you fail fast with a clear message if invalid placeholders are present.

Implementation Details: #

• Use a regex to extract all placeholders matching ${placeholderName} format
• Compare the extracted set against your pre-defined allowed list
• Return a specific error if any unapproved placeholders are found

Code Example:

import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

// Define your allowed placeholders upfront
private static final Set<String> ALLOWED_PLACEHOLDERS = Set.of("placeholder1", "placeholder2");

public String validatePlaceholders(String url) {
    Pattern placeholderPattern = Pattern.compile("\\$\\{([^}]+)\\}");
    Matcher matcher = placeholderPattern.matcher(url);
    Set<String> foundPlaceholders = new HashSet<>();

    while (matcher.find()) {
        foundPlaceholders.add(matcher.group(1));
    }

    // Check for invalid placeholders
    Set<String> invalidPlaceholders = new HashSet<>(foundPlaceholders);
    invalidPlaceholders.removeAll(ALLOWED_PLACEHOLDERS);
    if (!invalidPlaceholders.isEmpty()) {
        return String.format("Invalid placeholders: %s. Allowed values are: %s",
                String.join(", ", invalidPlaceholders),
                String.join(", ", ALLOWED_PLACEHOLDERS));
    }
    return null; // No placeholder errors
}

Step 2: Validate URL Structure (With Placeholders Replaced) #

Once you've confirmed all placeholders are allowed, replace them with URL-safe dummy values and use Apache's UrlValidator to check the core URL structure. The key here is using placeholder values that won't break URL validation (e.g., simple alphanumeric strings).

Implementation Details: #

• Use StrSubstitutor to replace all allowed placeholders with a standard valid value (like "valid-demo-value")
• Configure UrlValidator to match your requirements (e.g., restrict to HTTP/HTTPS, allow subdomains)
• Add custom checks to translate UrlValidator's boolean result into actionable error messages

Code Example:

import org.apache.commons.text.StrSubstitutor;
import org.apache.commons.validator.routines.UrlValidator;

public String validateUrlStructure(String url) {
    // Replace placeholders with a URL-safe dummy value
    StrSubstitutor substitutor = new StrSubstitutor();
    substitutor.setVariableResolver(name -> "valid-demo-value");
    String substitutedUrl = substitutor.replace(url);

    // Configure UrlValidator for your use case (adjust options as needed)
    UrlValidator urlValidator = new UrlValidator(new String[]{"http", "https"}, UrlValidator.NO_FRAGMENTS);
    
    if (urlValidator.isValid(substitutedUrl)) {
        return null; // No structure errors
    }

    // Generate specific error messages based on common URL issues
    if (!substitutedUrl.startsWith("http://") && !substitutedUrl.startsWith("https://")) {
        return "URL must start with http:// or https://";
    }
    if (substitutedUrl.contains(" ")) {
        return "URL contains invalid whitespace characters";
    }
    // Add more checks for domain validity, path formatting, etc., as needed
    return "Invalid URL structure. Please check the format excluding placeholders.";
}

Step 3: Combine Both Validations #

Run the placeholder check first, then the structure check. This ensures users get the most relevant error message first (e.g., invalid placeholder before URL structure issues).

Code Example:

public String validateConfiguredUrl(String url) {
    // First check placeholder legality
    String placeholderError = validatePlaceholders(url);
    if (placeholderError != null) {
        return placeholderError;
    }

    // Then check URL structure
    return validateUrlStructure(url);
}

Why This Works: #

• Reuses Apache's battle-tested libraries instead of building custom regex (which is error-prone for URLs)
• Separates concerns, making it easy to update allowed placeholders or URL validation rules later
• Provides clear, actionable error messages for both placeholder and URL structure issues

内容的提问来源于stack exchange，提问作者Yannholo