google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
Custom String Template Processors in Java
awiskar acharya
November 13, 2025
11:46 am

String Templates (JEP 430) are a new feature in Java that enable string interpolation and custom string processing. This comprehensive guide covers creating custom template processors for various use cases.

Understanding String Template Components

Key Components:

  • String Templates: Embedded expressions in string literals
  • Template Processors: Process templates and embedded expressions
  • STR Processor: Built-in processor for basic interpolation
  • FMT Processor: Built-in processor for formatting
  • RAW Template: Unprocessed template for custom processing

Project Setup (Java 21+)

<properties> <maven.compiler.source>21</maven.compiler.source> <maven.compiler.target>21</maven.compiler.target> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> <!-- For JSON processing in examples --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.16.1</version> </dependency> <!-- For testing --> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter</artifactId> <version>5.10.0</version> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.11.0</version> <configuration> <compilerArgs> <arg>--enable-preview</arg> </compilerArgs> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>3.1.2</version> <configuration> <argLine>--enable-preview</argLine> </configuration> </plugin> </plugins> </build>

Basic Template Processor Foundation

package com.example.templates; import java.lang.StringTemplate; import java.util.List; import java.util.function.Function; /** * Foundation for custom template processors */ public class TemplateProcessorFoundation { /** * Basic template processor that simply interpolates values */ public static final StringTemplate.Processor<String, RuntimeException> SIMPLE = StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder sb = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { sb.append(fragments.get(i)); if (i < values.size()) { sb.append(values.get(i)); } } return sb.toString(); }); /** * Template processor that applies a transformation to each value */ public static StringTemplate.Processor<String, RuntimeException> createTransformingProcessor( Function<Object, String> transformer) { return StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder sb = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { sb.append(fragments.get(i)); if (i < values.size()) { sb.append(transformer.apply(values.get(i))); } } return sb.toString(); }); } /** * Processor that validates template structure */ public static final StringTemplate.Processor<String, IllegalArgumentException> VALIDATING = StringTemplate.Processor.of((StringTemplate st) -> { List<String> fragments = st.fragments(); List<Object> values = st.values(); // Validate that we have exactly one more fragment than values if (fragments.size() != values.size() + 1) { throw new IllegalArgumentException( "Invalid template structure: expected " + (values.size() + 1) + " fragments, got " + fragments.size()); } StringBuilder sb = new StringBuilder(); for (int i = 0; i < fragments.size(); i++) { sb.append(fragments.get(i)); if (i < values.size()) { sb.append(values.get(i)); } } return sb.toString(); }); }

Security-Focused Template Processors

package com.example.templates; import java.lang.StringTemplate; import java.util.List; import java.util.regex.Pattern; /** * Security-focused template processors for safe string interpolation */ public class SecurityProcessors { // Patterns for validation private static final Pattern SQL_INJECTION_PATTERN = Pattern.compile("([';]+|(--)+|(\\/\\*)+|(\\*\\/)+|(xp_)+)", Pattern.CASE_INSENSITIVE); private static final Pattern HTML_SPECIAL_CHARS = Pattern.compile("[<>&\"']"); private static final Pattern PATH_TRAVERSAL_PATTERN = Pattern.compile("\\.\\.|~|\\/\\/|\\\\"); /** * SQL-safe template processor that prevents SQL injection */ public static final StringTemplate.Processor<String, SecurityException> SQL_SAFE = StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder sb = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { sb.append(fragments.get(i)); if (i < values.size()) { String value = String.valueOf(values.get(i)); // Validate for SQL injection patterns if (SQL_INJECTION_PATTERN.matcher(value).find()) { throw new SecurityException( "Potential SQL injection detected in value: " + value); } // Escape single quotes for SQL safety String safeValue = value.replace("'", "''"); sb.append(safeValue); } } return sb.toString(); }); /** * HTML-safe template processor that escapes HTML special characters */ public static final StringTemplate.Processor<String, RuntimeException> HTML_SAFE = StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder sb = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { sb.append(fragments.get(i)); if (i < values.size()) { String value = String.valueOf(values.get(i)); String escapedValue = escapeHtml(value); sb.append(escapedValue); } } return sb.toString(); }); /** * Path-safe template processor for file system operations */ public static final StringTemplate.Processor<String, SecurityException> PATH_SAFE = StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder sb = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { sb.append(fragments.get(i)); if (i < values.size()) { String value = String.valueOf(values.get(i)); // Validate for path traversal attempts if (PATH_TRAVERSAL_PATTERN.matcher(value).find()) { throw new SecurityException( "Potential path traversal detected in value: " + value); } sb.append(value); } } return sb.toString(); }); /** * Creates a processor with custom validation rules */ public static StringTemplate.Processor<String, SecurityException> createValidatingProcessor( Pattern forbiddenPattern, String validationName) { return StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder sb = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { sb.append(fragments.get(i)); if (i < values.size()) { String value = String.valueOf(values.get(i)); // Apply custom validation if (forbiddenPattern.matcher(value).find()) { throw new SecurityException( String.format("Validation failed for %s in value: %s", validationName, value)); } sb.append(value); } } return sb.toString(); }); } private static String escapeHtml(String input) { return input.replace("&", "&amp;") .replace("<", "&lt;") .replace(">", "&gt;") .replace("\"", "&quot;") .replace("'", "&#39;"); } /** * Sanitizes input for logging (removes sensitive data) */ public static final StringTemplate.Processor<String, RuntimeException> LOG_SAFE = StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder sb = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { sb.append(fragments.get(i)); if (i < values.size()) { Object value = values.get(i); String safeValue = sanitizeForLogging(value); sb.append(safeValue); } } return sb.toString(); }); private static String sanitizeForLogging(Object value) { if (value == null) return "null"; String str = String.valueOf(value); // Mask potential sensitive data if (str.matches(".*[pP]assword.*") || str.matches(".*[kK]ey.*")) { return "***MASKED***"; } // Mask credit card-like numbers if (str.matches("\\d{13,19}")) { return str.substring(0, 4) + "****" + str.substring(str.length() - 4); } // Mask email addresses if (str.matches("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$")) { String[] parts = str.split("@"); if (parts[0].length() > 2) { return parts[0].substring(0, 2) + "***@" + parts[1]; } return "***@" + parts[1]; } return str; } }

JSON Template Processors

package com.example.templates; import java.lang.StringTemplate; import java.util.List; import java.util.Map; import java.util.HashMap; import com.fasterxml.jackson.databind.ObjectMapper; /** * Template processors for JSON generation and manipulation */ public class JsonProcessors { private static final ObjectMapper objectMapper = new ObjectMapper(); /** * Creates a JSON object from template * Template format: "{"name": \{name}, "age": \{age}}" */ public static final StringTemplate.Processor<String, RuntimeException> JSON = StringTemplate.Processor.of((StringTemplate st) -> { // For simple cases, we can process the template as JSON StringBuilder sb = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { String fragment = fragments.get(i); sb.append(fragment); if (i < values.size()) { Object value = values.get(i); String jsonValue = toJsonValue(value); sb.append(jsonValue); } } // Validate JSON format try { objectMapper.readTree(sb.toString()); return sb.toString(); } catch (Exception e) { throw new RuntimeException("Invalid JSON generated: " + sb, e); } }); /** * Creates a JSON array from multiple values */ public static final StringTemplate.Processor<String, RuntimeException> JSON_ARRAY = StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder sb = new StringBuilder("["); List<Object> values = st.values(); for (int i = 0; i < values.size(); i++) { if (i > 0) { sb.append(", "); } String jsonValue = toJsonValue(values.get(i)); sb.append(jsonValue); } sb.append("]"); return sb.toString(); }); /** * Creates a parameterized JSON template processor */ public static StringTemplate.Processor<Map<String, Object>, RuntimeException> JSON_OBJECT = StringTemplate.Processor.of((StringTemplate st) -> { Map<String, Object> result = new HashMap<>(); List<String> fragments = st.fragments(); List<Object> values = st.values(); // Extract key-value pairs from template for (int i = 0; i < fragments.size() - 1; i++) { String fragment = fragments.get(i); // Extract key from fragment (simplified approach) String key = extractJsonKey(fragment); if (key != null && i < values.size()) { result.put(key, values.get(i)); } } return result; }); /** * JSON processor with pretty printing */ public static final StringTemplate.Processor<String, RuntimeException> JSON_PRETTY = StringTemplate.Processor.of((StringTemplate st) -> { // First create compact JSON String compactJson = JSON.process(st); // Then pretty print it try { Object json = objectMapper.readValue(compactJson, Object.class); return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(json); } catch (Exception e) { throw new RuntimeException("Failed to pretty print JSON", e); } }); private static String toJsonValue(Object value) { if (value == null) { return "null"; } else if (value instanceof String) { return "\"" + escapeJsonString((String) value) + "\""; } else if (value instanceof Number) { return value.toString(); } else if (value instanceof Boolean) { return value.toString(); } else { // For complex objects, serialize to JSON try { return objectMapper.writeValueAsString(value); } catch (Exception e) { throw new RuntimeException("Failed to serialize value to JSON: " + value, e); } } } private static String escapeJsonString(String input) { return input.replace("\\", "\\\\") .replace("\"", "\\\"") .replace("\b", "\\b") .replace("\f", "\\f") .replace("\n", "\\n") .replace("\r", "\\r") .replace("\t", "\\t"); } private static String extractJsonKey(String fragment) { // Simple extraction - looks for "key": pattern int quoteIndex = fragment.lastIndexOf('"'); if (quoteIndex > 0) { int colonIndex = fragment.indexOf(':', quoteIndex); if (colonIndex > 0) { int startQuote = fragment.lastIndexOf('"', quoteIndex - 1); if (startQuote >= 0) { return fragment.substring(startQuote + 1, quoteIndex); } } } return null; } }

Database and SQL Template Processors

package com.example.templates; import java.lang.StringTemplate; import java.util.List; import java.util.ArrayList; /** * Template processors for database and SQL operations */ public class DatabaseProcessors { /** * SQL query processor with parameter placeholder generation * Converts template to prepared statement format */ public static final StringTemplate.Processor<PreparedStatementTemplate, RuntimeException> SQL = StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder query = new StringBuilder(); List<Object> parameters = new ArrayList<>(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { query.append(fragments.get(i)); if (i < values.size()) { query.append("?"); parameters.add(values.get(i)); } } return new PreparedStatementTemplate(query.toString(), parameters); }); /** * SQL IN clause processor for dynamic lists */ public static final StringTemplate.Processor<PreparedStatementTemplate, RuntimeException> SQL_IN = StringTemplate.Processor.of((StringTemplate st) -> { if (st.values().size() != 1) { throw new IllegalArgumentException("SQL_IN processor expects exactly one value (a collection)"); } Object value = st.values().get(0); if (!(value instanceof Iterable)) { throw new IllegalArgumentException("SQL_IN processor expects an Iterable value"); } StringBuilder query = new StringBuilder(); List<Object> parameters = new ArrayList<>(); List<String> fragments = st.fragments(); // Build IN clause with placeholders query.append(fragments.get(0)); Iterable<?> iterable = (Iterable<?>) value; List<String> placeholders = new ArrayList<>(); for (Object item : iterable) { placeholders.add("?"); parameters.add(item); } query.append(String.join(", ", placeholders)); if (fragments.size() > 1) { query.append(fragments.get(1)); } return new PreparedStatementTemplate(query.toString(), parameters); }); /** * Record representing a prepared statement template */ public static record PreparedStatementTemplate(String query, List<Object> parameters) { public String getQuery() { return query; } public List<Object> getParameters() { return parameters; } @Override public String toString() { return "Query: " + query + ", Parameters: " + parameters; } } /** * SQL UPDATE statement processor */ public static final StringTemplate.Processor<PreparedStatementTemplate, RuntimeException> SQL_UPDATE = StringTemplate.Processor.of((StringTemplate st) -> { List<String> fragments = st.fragments(); List<Object> values = st.values(); if (fragments.size() < 2 || values.size() % 2 != 0) { throw new IllegalArgumentException( "SQL_UPDATE expects template format: UPDATE table SET \{field1} = \{value1}, \{field2} = \{value2} WHERE \{condition}"); } StringBuilder query = new StringBuilder(); List<Object> parameters = new ArrayList<>(); query.append(fragments.get(0)); // "UPDATE table SET " // Process field-value pairs for (int i = 0; i < values.size() - 1; i += 2) { if (i > 0) { query.append(", "); } query.append(values.get(i)).append(" = ?"); parameters.add(values.get(i + 1)); } // Add WHERE clause query.append(fragments.get(1)); // " WHERE " query.append("?"); parameters.add(values.get(values.size() - 1)); return new PreparedStatementTemplate(query.toString(), parameters); }); }

Logging Template Processors

package com.example.templates; import java.lang.StringTemplate; import java.util.List; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; /** * Template processors for structured logging */ public class LoggingProcessors { private static final DateTimeFormatter TIMESTAMP_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"); /** * Structured log processor with timestamp and level */ public static StringTemplate.Processor<String, RuntimeException> createLogger(String level) { return StringTemplate.Processor.of((StringTemplate st) -> { String timestamp = LocalDateTime.now().format(TIMESTAMP_FORMATTER); String message = StringTemplate.Processor.string().process(st); return String.format("[%s] [%s] %s", timestamp, level, message); }); } // Predefined log level processors public static final StringTemplate.Processor<String, RuntimeException> LOG_ERROR = createLogger("ERROR"); public static final StringTemplate.Processor<String, RuntimeException> LOG_WARN = createLogger("WARN"); public static final StringTemplate.Processor<String, RuntimeException> LOG_INFO = createLogger("INFO"); public static final StringTemplate.Processor<String, RuntimeException> LOG_DEBUG = createLogger("DEBUG"); public static final StringTemplate.Processor<String, RuntimeException> LOG_TRACE = createLogger("TRACE"); /** * JSON log processor for structured logging */ public static final StringTemplate.Processor<String, RuntimeException> JSON_LOG = StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder logEntry = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); // Build a structured log entry logEntry.append("{"); logEntry.append("\"timestamp\": \"").append(LocalDateTime.now().format(TIMESTAMP_FORMATTER)).append("\""); logEntry.append(", \"message\": \""); // Reconstruct the message for (int i = 0; i < fragments.size(); i++) { logEntry.append(fragments.get(i)); if (i < values.size()) { logEntry.append("{}"); // Placeholder for structured logging } } logEntry.append("\""); // Add values as separate fields for (int i = 0; i < values.size(); i++) { logEntry.append(", \"param").append(i).append("\": "); String jsonValue = toJsonLogValue(values.get(i)); logEntry.append(jsonValue); } logEntry.append("}"); return logEntry.toString(); }); /** * Performance logging processor with timing */ public static final StringTemplate.Processor<String, RuntimeException> PERF_LOG = StringTemplate.Processor.of((StringTemplate st) -> { long startTime = System.currentTimeMillis(); String message = StringTemplate.Processor.string().process(st); long duration = System.currentTimeMillis() - startTime; return String.format("[PERF] %s (took %d ms)", message, duration); }); private static String toJsonLogValue(Object value) { if (value == null) return "null"; if (value instanceof String) return "\"" + escapeJsonString((String) value) + "\""; if (value instanceof Number) return value.toString(); if (value instanceof Boolean) return value.toString(); return "\"" + String.valueOf(value).replace("\"", "\\\"") + "\""; } private static String escapeJsonString(String input) { return input.replace("\\", "\\\\") .replace("\"", "\\\"") .replace("\n", "\\n") .replace("\r", "\\r") .replace("\t", "\\t"); } }

Internationalization (i18n) Processors

package com.example.templates; import java.lang.StringTemplate; import java.util.List; import java.util.Locale; import java.util.ResourceBundle; import java.text.MessageFormat; /** * Template processors for internationalization and localization */ public class I18nProcessors { /** * Creates a localized message processor for a specific locale */ public static StringTemplate.Processor<String, RuntimeException> createLocalizedProcessor( String baseName, Locale locale) { return StringTemplate.Processor.of((StringTemplate st) -> { ResourceBundle bundle = ResourceBundle.getBundle(baseName, locale); List<String> fragments = st.fragments(); // Use the first fragment as the message key if (fragments.isEmpty()) { throw new IllegalArgumentException("Template must start with a message key"); } String messageKey = fragments.get(0).trim(); String pattern = bundle.getString(messageKey); // Use MessageFormat for parameter substitution Object[] params = st.values().toArray(); return MessageFormat.format(pattern, params); }); } /** * Currency formatting processor */ public static StringTemplate.Processor<String, RuntimeException> createCurrencyProcessor(Locale locale) { return StringTemplate.Processor.of((StringTemplate st) -> { java.text.NumberFormat currencyFormat = java.text.NumberFormat.getCurrencyInstance(locale); StringBuilder result = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { result.append(fragments.get(i)); if (i < values.size()) { Object value = values.get(i); if (value instanceof Number) { result.append(currencyFormat.format(value)); } else { result.append(value); } } } return result.toString(); }); } /** * Date formatting processor */ public static StringTemplate.Processor<String, RuntimeException> createDateProcessor(Locale locale) { return StringTemplate.Processor.of((StringTemplate st) -> { java.text.DateFormat dateFormat = java.text.DateFormat.getDateInstance( java.text.DateFormat.MEDIUM, locale); StringBuilder result = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { result.append(fragments.get(i)); if (i < values.size()) { Object value = values.get(i); if (value instanceof java.util.Date) { result.append(dateFormat.format(value)); } else { result.append(value); } } } return result.toString(); }); } }

Advanced Composite Processors

package com.example.templates; import java.lang.StringTemplate; import java.util.List; import java.util.function.Function; /** * Advanced template processors with composition and transformation */ public class AdvancedProcessors { /** * Processor that composes multiple processors */ @SafeVarargs public static StringTemplate.Processor<String, RuntimeException> compose( Function<String, String>... transformers) { return StringTemplate.Processor.of((StringTemplate st) -> { String result = StringTemplate.Processor.string().process(st); for (Function<String, String> transformer : transformers) { result = transformer.apply(result); } return result; }); } /** * Processor that conditionally processes templates */ public static StringTemplate.Processor<String, RuntimeException> conditional( Function<StringTemplate, Boolean> condition, StringTemplate.Processor<String, RuntimeException> trueProcessor, StringTemplate.Processor<String, RuntimeException> falseProcessor) { return StringTemplate.Processor.of((StringTemplate st) -> { if (condition.apply(st)) { return trueProcessor.process(st); } else { return falseProcessor.process(st); } }); } /** * Processor that caches template processing results */ public static StringTemplate.Processor<String, RuntimeException> cached() { return new StringTemplate.Processor<String, RuntimeException>() { private final java.util.Map<String, String> cache = new java.util.concurrent.ConcurrentHashMap<>(); @Override public String process(StringTemplate st) { String templateKey = createTemplateKey(st); return cache.computeIfAbsent(templateKey, k -> StringTemplate.Processor.string().process(st)); } private String createTemplateKey(StringTemplate st) { StringBuilder key = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { key.append(fragments.get(i)); if (i < values.size()) { key.append("_").append(values.get(i).getClass().getSimpleName()); } } return key.toString(); } }; } /** * Processor that measures processing time */ public static StringTemplate.Processor<TimedResult, RuntimeException> timed() { return StringTemplate.Processor.of((StringTemplate st) -> { long startTime = System.nanoTime(); String result = StringTemplate.Processor.string().process(st); long duration = System.nanoTime() - startTime; return new TimedResult(result, duration); }); } /** * Processor that retries on failure */ public static StringTemplate.Processor<String, RuntimeException> withRetry(int maxRetries) { return StringTemplate.Processor.of((StringTemplate st) -> { RuntimeException lastException = null; for (int attempt = 0; attempt < maxRetries; attempt++) { try { return StringTemplate.Processor.string().process(st); } catch (RuntimeException e) { lastException = e; if (attempt < maxRetries - 1) { try { Thread.sleep(100 * (attempt + 1)); // Exponential backoff } catch (InterruptedException ie) { Thread.currentThread().interrupt(); throw new RuntimeException("Interrupted during retry", ie); } } } } throw new RuntimeException("Failed after " + maxRetries + " attempts", lastException); }); } public static record TimedResult(String result, long durationNanos) { public long getDurationMillis() { return durationNanos / 1_000_000; } @Override public String toString() { return String.format("Result: %s (took %d ns)", result, durationNanos); } } }

Practical Usage Examples

package com.example.templates; import java.lang.StringTemplate; import java.util.List; import java.util.Locale; /** * Practical examples demonstrating custom template processors */ public class TemplateExamples { public static void main(String[] args) { demonstrateSecurityProcessors(); demonstrateJsonProcessors(); demonstrateDatabaseProcessors(); demonstrateLoggingProcessors(); demonstrateI18nProcessors(); demonstrateAdvancedProcessors(); } private static void demonstrateSecurityProcessors() { System.out.println("=== Security Processors ==="); String userInput = "John'; DROP TABLE users; --"; String name = "John"; try { // This will throw SecurityException String sql = SecurityProcessors.SQL_SAFE."SELECT * FROM users WHERE name = '\{userInput}'"; } catch (SecurityException e) { System.out.println("SQL injection prevented: " + e.getMessage()); } // Safe usage String safeSql = SecurityProcessors.SQL_SAFE."SELECT * FROM users WHERE name = '\{name}'"; System.out.println("Safe SQL: " + safeSql); // HTML escaping String htmlContent = "<script>alert('XSS')</script>"; String safeHtml = SecurityProcessors.HTML_SAFE."<div>\{htmlContent}</div>"; System.out.println("Safe HTML: " + safeHtml); // Log sanitization String password = "mySecretPassword123"; String creditCard = "4111111111111111"; String safeLog = SecurityProcessors.LOG_SAFE."User login: password=\{password}, card=\{creditCard}"; System.out.println("Safe log: " + safeLog); } private static void demonstrateJsonProcessors() { System.out.println("\n=== JSON Processors ==="); String name = "Alice"; int age = 30; boolean active = true; // Simple JSON object String json = JsonProcessors.JSON.""" {"name": "\{name}", "age": \{age}, "active": \{active}}"""; System.out.println("JSON: " + json); // JSON array List<String> hobbies = List.of("reading", "gaming", "hiking"); String jsonArray = JsonProcessors.JSON_ARRAY."\{hobbies}"; System.out.println("JSON Array: " + jsonArray); // Pretty JSON String prettyJson = JsonProcessors.JSON_PRETTY.""" {"user": {"name": "\{name}", "profile": {"age": \{age}, "active": \{active}}}}"""; System.out.println("Pretty JSON:\n" + prettyJson); } private static void demonstrateDatabaseProcessors() { System.out.println("\n=== Database Processors ==="); String tableName = "users"; String userName = "Alice"; int minAge = 25; // SQL with parameters var preparedStmt = DatabaseProcessors.SQL.""" SELECT * FROM \{tableName} WHERE name = '\{userName}' AND age > \{minAge}"""; System.out.println("Prepared Statement: " + preparedStmt); // SQL IN clause List<Integer> ids = List.of(1, 2, 3, 4, 5); var inClauseStmt = DatabaseProcessors.SQL_IN.""" SELECT * FROM users WHERE id IN (\{ids})"""; System.out.println("IN Clause Statement: " + inClauseStmt); } private static void demonstrateLoggingProcessors() { System.out.println("\n=== Logging Processors ==="); String userId = "user123"; String action = "login"; int attemptCount = 3; // Different log levels String errorLog = LoggingProcessors.LOG_ERROR."User \{userId} failed to \{action} after \{attemptCount} attempts"; String infoLog = LoggingProcessors.LOG_INFO."User \{userId} performed action: \{action}"; System.out.println(errorLog); System.out.println(infoLog); // JSON logging String jsonLog = LoggingProcessors.JSON_LOG."User \{userId} performed \{action}"; System.out.println("JSON Log: " + jsonLog); // Performance logging String perfLog = LoggingProcessors.PERF_LOG."Processing user \{userId}"; System.out.println(perfLog); } private static void demonstrateI18nProcessors() { System.out.println("\n=== I18n Processors ==="); // Note: This requires actual resource bundle files // For demonstration, we'll show the concept String product = "Java"; double price = 99.99; int quantity = 5; // Currency formatting var usCurrency = I18nProcessors.createCurrencyProcessor(Locale.US); String priceDisplay = usCurrency."Total: \{price}"; System.out.println("US Price: " + priceDisplay); var jpCurrency = I18nProcessors.createCurrencyProcessor(Locale.JAPAN); String jpPriceDisplay = jpCurrency."Total: \{price}"; System.out.println("JP Price: " + jpPriceDisplay); } private static void demonstrateAdvancedProcessors() { System.out.println("\n=== Advanced Processors ==="); String data = "important data"; // Timed processing var timedResult = AdvancedProcessors.timed()."Processing: \{data}"; System.out.println("Timed result: " + timedResult); // Cached processing var cachedProcessor = AdvancedProcessors.cached(); String result1 = cachedProcessor."Hello \{data}"; String result2 = cachedProcessor."Hello \{data}"; // Should be cached System.out.println("Cached results equal: " + result1.equals(result2)); // Conditional processing var conditionalProcessor = AdvancedProcessors.conditional( st -> st.values().size() > 2, LoggingProcessors.LOG_INFO, LoggingProcessors.LOG_DEBUG ); String conditionalResult = conditionalProcessor."Testing: \{data}"; System.out.println("Conditional: " + conditionalResult); } }

Testing Custom Template Processors

package com.example.templates; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; /** * Unit tests for custom template processors */ class TemplateProcessorsTest { @Test void testSecurityProcessors() { // Test SQL injection prevention assertThrows(SecurityException.class, () -> { SecurityProcessors.SQL_SAFE."SELECT * FROM users WHERE name = '\{"; DROP TABLE users; --}'"; }); // Test HTML escaping String result = SecurityProcessors.HTML_SAFE."<div>\{"<script>alert('XSS')</script>"}</div>"; assertTrue(result.contains("&lt;")); assertTrue(result.contains("&gt;")); } @Test void testJsonProcessors() { String name = "Test"; int value = 42; String json = JsonProcessors.JSON."{\"name\": \"\{name}\", \"value\": \{value}}"; assertTrue(json.contains("\"name\": \"Test\"")); assertTrue(json.contains("\"value\": 42")); } @Test void testDatabaseProcessors() { var result = DatabaseProcessors.SQL."SELECT * FROM \{ "users" } WHERE id = \{ 123 }"; assertEquals("SELECT * FROM users WHERE id = ?", result.query()); assertEquals(List.of("users", 123), result.parameters()); } @Test void testLoggingProcessors() { String log = LoggingProcessors.LOG_INFO."User \{ "testuser" } logged in"; assertTrue(log.contains("INFO")); assertTrue(log.contains("testuser")); } }

Best Practices

  1. Type Safety: Always specify the correct exception type in processor signature
  2. Performance: Cache processors when possible, especially for i18n
  3. Security: Always validate and sanitize inputs in security-sensitive contexts
  4. Composition: Build complex processors by composing simpler ones
  5. Testing: Thoroughly test processors with various inputs and edge cases
  6. Documentation: Clearly document the expected template format for each processor
  7. Error Handling: Provide meaningful error messages for template validation failures

Conclusion

Custom String Template Processors in Java provide a powerful mechanism for:

  • Type-Safe String Processing: Compile-time validation of template usage
  • Domain-Specific Languages: Create processors for specific domains (SQL, JSON, etc.)
  • Security: Built-in protection against injection attacks
  • Internationalization: Simplified localization of application strings
  • Performance: Optimized processing for specific use cases
  • Composability: Combine processors for complex transformations

By leveraging custom template processors, you can create more secure, maintainable, and expressive string processing code while maintaining Java's type safety and performance characteristics.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper