- Type Parameters:
R- Processor's process result typeE- Exception thrown type
- All Known Implementing Classes:
FormatProcessorPREVIEW
- Enclosing interface:
StringTemplatePREVIEW
- Functional Interface:
- This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
Processor is a preview API of the Java platform.
process(StringTemplate) is used to validate
and compose a result using a StringTemplate'sPREVIEW fragments and values lists.
For example:
class MyProcessor implements Processor<String, IllegalArgumentException> {
@Override
public String process(StringTemplate st) throws IllegalArgumentException {
StringBuilder sb = new StringBuilder();
Iterator<String> fragmentsIter = st.fragments().iterator();
for (Object value : st.values()) {
sb.append(fragmentsIter.next());
if (value instanceof Boolean) {
throw new IllegalArgumentException("I don't like Booleans");
}
sb.append(value);
}
sb.append(fragmentsIter.next());
return sb.toString();
}
}
MyProcessor myProcessor = new MyProcessor();
try {
int x = 10;
int y = 20;
String result = myProcessor."\{x} + \{y} = \{x + y}";
...
} catch (IllegalArgumentException ex) {
...
}
The user has the option of validating inputs used in composition. For example an SQL
processor could prevent injection vulnerabilities by sanitizing inputs or throwing an
exception of type E if an SQL statement is a potential vulnerability.
Composing allows user control over how the result is assembled. Most often, a
user will construct a new string from the string template, with placeholders
replaced by string representations of value list elements. These string
representations are created as if invoking String.valueOf(java.lang.Object).
Transforming allows the processor to return something other than a string. For instance, a JSON processor could return a JSON object, by parsing the string created by composition, instead of the composed string.
StringTemplate.ProcessorPREVIEW is a FunctionalInterface. This permits
declaration of a processor using lambda expressions;
Processor<String, RuntimeException> processor = st -> {
List<String> fragments = st.fragments();
List<Object> values = st.values();
// check or manipulate the fragments and/or values
...
return StringTemplate.interpolate(fragments, values);
};
StringTemplate.interpolate()PREVIEW method is available for those processors
that just need to work with the string interpolation;
Processor<String, RuntimeException> processor = StringTemplate::interpolate;
String;
Processor<JSONObject, RuntimeException> jsonProcessor = st -> new JSONObject(st.interpolate());
- Implementation Note:
- The Java compiler automatically imports
StringTemplate.STRPREVIEW - See Java Language Specification:
-
15.8.6 Process Template Expressions
- Since:
- 21
- See Also:
-
Nested Class Summary
Nested ClassesModifier and TypeInterfaceDescriptionstatic interfacePreview.Built-in policies using this additional interface have the flexibility to specialize the composition of the templated string by returning a customizedMethodHandlefromlinkagePREVIEW. -
Method Summary
Modifier and TypeMethodDescriptionstatic <T> StringTemplate.ProcessorPREVIEW<T, RuntimeException> of(Function<? super StringTemplatePREVIEW, ? extends T> process) This factory method can be used to create aStringTemplate.ProcessorPREVIEW containing aprocess(java.lang.StringTemplate)method derived from a lambda expression.process(StringTemplatePREVIEW stringTemplate) Constructs a result based on the template fragments and values in the suppliedstringTemplatePREVIEW object.
-
Method Details
-
process
Constructs a result based on the template fragments and values in the suppliedstringTemplatePREVIEW object.- API Note:
- Processing of a
StringTemplatePREVIEW may include validation according to the particular facts relating to each situation. TheEtype parameter indicates the type of checked exception that is thrown byprocess(java.lang.StringTemplate)if validation fails, ex.java.sql.SQLException. If no checked exception is expected thenRuntimeExceptionmay be used. Note that unchecked exceptions, such asRuntimeException,NullPointerExceptionorIllegalArgumentExceptionmay be thrown as part of the normal method arguments processing. Details of which exceptions are thrown will be found in the documentation of the specific implementation. - Parameters:
stringTemplate- aStringTemplatePREVIEW instance- Returns:
- constructed object of type R
- Throws:
E- exception thrown by the template processor when validation fails
-
of
static <T> StringTemplate.ProcessorPREVIEW<T,RuntimeException> of(Function<? super StringTemplatePREVIEW, ? extends T> process) This factory method can be used to create aStringTemplate.ProcessorPREVIEW containing aprocess(java.lang.StringTemplate)method derived from a lambda expression. As an example;The result type of the constructedProcessor<String, RuntimeException> mySTR = Processor.of(StringTemplate::interpolate); int x = 10; int y = 20; String str = mySTR."\{x} + \{y} = \{x + y}";StringTemplate.ProcessorPREVIEW may be derived from the lambda expression, thus this method may be used in a var statement. For example,mySTRfrom above can also be declared using;var mySTR = Processor.of(StringTemplate::interpolate);RuntimeExceptionis the assumed exception thrown type.- Type Parameters:
T- Processor's process result type- Parameters:
process- a function that takes aStringTemplatePREVIEW as an argument and returns the inferred result type- Returns:
- a
StringTemplate.ProcessorPREVIEW
-
Processorwhen preview features are enabled.