Examples of StrSubstitutor

org.apache.commons.lang.text.StrSubstitutor
Substitutes variables within a string by values.
This class takes a piece of text and substitutes all the variables within it. The default definition of a variable is ${variableName}. The prefix and suffix can be changed via constructors and set methods.
Variable values are typically resolved from a map, but could also be resolved from system properties, or by supplying a custom variable resolver.
The simplest example is to use this class to replace Java System properties. For example:
```
 StrSubstitutor.replaceSystemProperties( "You are running with java.version = ${java.version} and os.name = ${os.name}."); 
```
Typical usage of this class follows the following pattern: First an instance is created and initialized with the map that contains the values for the available variables. If a prefix and/or suffix for variables should be used other than the default ones, the appropriate settings can be performed. After that the replace() method can be called passing in the source text for interpolation. In the returned text all variable references (as long as their values are known) will be resolved. The following example demonstrates this:
```
 Map valuesMap = HashMap(); valuesMap.put("animal", "quick brown fox"); valuesMap.put("target", "lazy dog"); String templateString = "The ${animal} jumped over the ${target}."; StrSubstitutor sub = new StrSubstitutor(valuesMap); String resolvedString = sub.replace(templateString); 
```
yielding:
```
 The quick brown fox jumped over the lazy dog. 
```
In addition to this usage pattern there are some static convenience methods that cover the most common use cases. These methods can be used without the need of manually creating an instance. However if multiple replace operations are to be performed, creating and reusing an instance of this class will be more efficient.
Variable replacement works in a recursive way. Thus, if a variable value contains a variable then that variable will also be replaced. Cyclic replacements are detected and will cause an exception to be thrown.
Sometimes the interpolation's result must contain a variable prefix. As an example take the following source text:
```
 The variable ${${name}} must be used. 
```
Here only the variable's name referred to in the text should be replaced resulting in the text (assuming that the value of the name variable is x):
```
 The variable ${x} must be used. 
```
To achieve this effect there are two possibilities: Either set a different prefix and suffix for variables which do not conflict with the result text you want to produce. The other possibility is to use the escape character, by default '$'. If this character is placed before a variable reference, this reference is ignored and won't be replaced. For example:
```
 The variable $${${name}} must be used. 
```
In some complex scenarios you might even want to perform substitution in the names of variables, for instance
```
 ${jre-${java.specification.version}} 
```
StrSubstitutor supports this recursive substitution in variable names, but it has to be enabled explicitly by setting the {@link #setEnableSubstitutionInVariables(boolean) enableSubstitutionInVariables}property to true. @author Apache Software Foundation @author Oliver Heger @version $Id: StrSubstitutor.java 1057354 2011-01-10 20:48:47Z niallp $ @since 2.2
org.apache.commons.lang3.text.StrSubstitutor
Substitutes variables within a string by values.
This class takes a piece of text and substitutes all the variables within it. The default definition of a variable is ${variableName}. The prefix and suffix can be changed via constructors and set methods.
Variable values are typically resolved from a map, but could also be resolved from system properties, or by supplying a custom variable resolver.
The simplest example is to use this class to replace Java System properties. For example:
```
 StrSubstitutor.replaceSystemProperties( "You are running with java.version = ${java.version} and os.name = ${os.name}."); 
```
Typical usage of this class follows the following pattern: First an instance is created and initialized with the map that contains the values for the available variables. If a prefix and/or suffix for variables should be used other than the default ones, the appropriate settings can be performed. After that the replace() method can be called passing in the source text for interpolation. In the returned text all variable references (as long as their values are known) will be resolved. The following example demonstrates this:
```
 Map valuesMap = HashMap(); valuesMap.put("animal", "quick brown fox"); valuesMap.put("target", "lazy dog"); String templateString = "The ${animal} jumped over the ${target}."; StrSubstitutor sub = new StrSubstitutor(valuesMap); String resolvedString = sub.replace(templateString); 
```
yielding:
```
 The quick brown fox jumped over the lazy dog. 
```
In addition to this usage pattern there are some static convenience methods that cover the most common use cases. These methods can be used without the need of manually creating an instance. However if multiple replace operations are to be performed, creating and reusing an instance of this class will be more efficient.
Variable replacement works in a recursive way. Thus, if a variable value contains a variable then that variable will also be replaced. Cyclic replacements are detected and will cause an exception to be thrown.
Sometimes the interpolation's result must contain a variable prefix. As an example take the following source text:
```
 The variable ${${name}} must be used. 
```
Here only the variable's name refered to in the text should be replaced resulting in the text (assuming that the value of the name variable is x):
```
 The variable ${x} must be used. 
```
To achieve this effect there are two possibilities: Either set a different prefix and suffix for variables which do not conflict with the result text you want to produce. The other possibility is to use the escape character, by default '$'. If this character is placed before a variable reference, this reference is ignored and won't be replaced. For example:
```
 The variable $${${name}} must be used. 
```
@author Apache Software Foundation @author Oliver Heger @version $Id: StrSubstitutor.java 902944 2010-01-25 19:32:08Z sebb $ @since 2.2
org.apache.logging.log4j.core.lookup.StrSubstitutor
Substitutes variables within a string by values.
This class takes a piece of text and substitutes all the variables within it. The default definition of a variable is ${variableName}. The prefix and suffix can be changed via constructors and set methods.
Variable values are typically resolved from a map, but could also be resolved from system properties, or by supplying a custom variable resolver.
The simplest example is to use this class to replace Java System properties. For example:
```
 StrSubstitutor.replaceSystemProperties( "You are running with java.version = ${java.version} and os.name = ${os.name}."); 
```
Typical usage of this class follows the following pattern: First an instance is created and initialized with the map that contains the values for the available variables. If a prefix and/or suffix for variables should be used other than the default ones, the appropriate settings can be performed. After that the replace() method can be called passing in the source text for interpolation. In the returned text all variable references (as long as their values are known) will be resolved. The following example demonstrates this:
```
 Map valuesMap = HashMap(); valuesMap.put("animal", "quick brown fox"); valuesMap.put("target", "lazy dog"); String templateString = "The ${animal} jumped over the ${target}."; StrSubstitutor sub = new StrSubstitutor(valuesMap); String resolvedString = sub.replace(templateString); 
```
yielding:
```
 The quick brown fox jumped over the lazy dog. 
```
In addition to this usage pattern there are some static convenience methods that cover the most common use cases. These methods can be used without the need of manually creating an instance. However if multiple replace operations are to be performed, creating and reusing an instance of this class will be more efficient.
Variable replacement works in a recursive way. Thus, if a variable value contains a variable then that variable will also be replaced. Cyclic replacements are detected and will cause an exception to be thrown.
Sometimes the interpolation's result must contain a variable prefix. As an example take the following source text:
```
 The variable ${${name}} must be used. 
```
Here only the variable's name referred to in the text should be replaced resulting in the text (assuming that the value of the name variable is x):
```
 The variable ${x} must be used. 
```
To achieve this effect there are two possibilities: Either set a different prefix and suffix for variables which do not conflict with the result text you want to produce. The other possibility is to use the escape character, by default '$'. If this character is placed before a variable reference, this reference is ignored and won't be replaced. For example:
```
 The variable $${${name}} must be used. 
```
In some complex scenarios you might even want to perform substitution in the names of variables, for instance
```
 ${jre-${java.specification.version}} 
```
StrSubstitutor supports this recursive substitution in variable names, but it has to be enabled explicitly by setting the {@link #setEnableSubstitutionInVariables(boolean) enableSubstitutionInVariables}property to true.

Examples of org.apache.logging.log4j.core.lookup.StrSubstitutor

            LoggerContext ctx = ContextAnchor.THREAD_CONTEXT.get();
            assertNotNull("No LoggerContext", ctx);
            assertNotNull("No ServletContext", ctx.getExternalContext());
            Configuration config = ctx.getConfiguration();
            assertNotNull("No Configuration", config);
            StrSubstitutor substitutor = config.getStrSubstitutor();
            assertNotNull("No Interpolator", substitutor);
            String value = substitutor.replace("${web:initParam.TestParam}");
            assertNotNull("No value for TestParam", value);
            assertTrue("Incorrect value for TestParam: " + value, "ParamValue".equals(value));
            value = substitutor.replace("${web:attr.TestAttr}");
            assertNotNull("No value for TestAttr", value);
            assertTrue("Incorrect value for TestAttr: " + value, "AttrValue".equals(value));
            value = substitutor.replace("${web:Name1}");
            assertNotNull("No value for Name1", value);
            assertTrue("Incorrect value for Name1: " + value, "Ben".equals(value));
            value = substitutor.replace("${web:Name2}");
            assertNotNull("No value for Name2", value);
            assertTrue("Incorrect value for Name2: " + value, "Jerry".equals(value));
        } catch (final UnavailableException e) {
            fail("Failed to initialize Log4j properly." + e.getMessage());
        }

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.