Example usage for org.springframework.util StringValueResolver resolveStringValue

Introduction

In this page you can find the example usage for org.springframework.util StringValueResolver resolveStringValue.

Prototype

@Nullable
String resolveStringValue(String strVal);

Source Link

Document

Resolve the given String value, for example parsing placeholders.

Usage

From source file:craterdog.security.EncryptedPropertyConfigurer.java

/**
 * This is method is needed because of https://jira.springsource.org/browse/SPR-8928
 *
 * @param beanFactoryToProcess The factory to be used for the processing.
 * @param valueResolver The value resolver to be used.
 *//*from ww w.  j  av a  2s . c  o m*/
@Override
protected void doProcessProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
        final StringValueResolver valueResolver) {
    StringValueResolver valueConvertingResolver = (String strVal) -> convertPropertyValue(
            valueResolver.resolveStringValue(strVal));
    super.doProcessProperties(beanFactoryToProcess, valueConvertingResolver);
}

---

From source file:com.harrywu.springweb.common.PropertyPlaceholderHelper.java

protected String parseStringValue(String strVal, StringValueResolver placeholderResolver,
        Set<String> visitedPlaceholders) {

    StringBuilder buf = new StringBuilder(strVal);

    int startIndex = strVal.indexOf(this.placeholderPrefix);
    while (startIndex != -1) {
        int endIndex = findPlaceholderEndIndex(buf, startIndex);
        if (endIndex != -1) {
            String placeholder = buf.substring(startIndex + this.placeholderPrefix.length(), endIndex);
            if (!visitedPlaceholders.add(placeholder)) {
                throw new IllegalArgumentException(
                        "Circular placeholder reference '" + placeholder + "' in property definitions");
            }/*from  w w w .j a v  a  2  s  .c  o m*/
            // Recursive invocation, parsing placeholders contained in the placeholder key.
            placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);

            // Now obtain the value for the fully resolved key...
            String propVal = placeholderResolver.resolveStringValue(placeholder);
            if (propVal == null && this.valueSeparator != null) {
                int separatorIndex = placeholder.indexOf(this.valueSeparator);
                if (separatorIndex != -1) {
                    String actualPlaceholder = placeholder.substring(0, separatorIndex);
                    String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
                    propVal = placeholderResolver.resolveStringValue(actualPlaceholder);
                    if (propVal == null) {
                        propVal = defaultValue;
                    }
                }
            }
            if (propVal != null) {
                // Recursive invocation, parsing placeholders contained in the
                // previously resolved placeholder value.
                propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
                buf.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);

                if (logger.isTraceEnabled()) {
                    logger.trace("Resolved placeholder '" + placeholder + "'");
                }

                startIndex = buf.indexOf(this.placeholderPrefix, startIndex + propVal.length());
            } else if (this.ignoreUnresolvablePlaceholders) {
                // Proceed with unprocessed value.
                startIndex = buf.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
            } else {
                throw new IllegalArgumentException("Could not resolve placeholder '" + placeholder + "'");
            }

            visitedPlaceholders.remove(placeholder);
        } else {
            startIndex = -1;
        }
    }

    return buf.toString();
}

---

From source file:org.springframework.beans.factory.DefaultListableBeanFactoryTests.java

@Test
public void resolveEmbeddedValue() {
    DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
    StringValueResolver r1 = mock(StringValueResolver.class);
    StringValueResolver r2 = mock(StringValueResolver.class);
    StringValueResolver r3 = mock(StringValueResolver.class);
    bf.addEmbeddedValueResolver(r1);/* ww  w.j a v a 2  s. co  m*/
    bf.addEmbeddedValueResolver(r2);
    bf.addEmbeddedValueResolver(r3);
    given(r1.resolveStringValue("A")).willReturn("B");
    given(r2.resolveStringValue("B")).willReturn(null);
    given(r3.resolveStringValue(isNull())).willThrow(new IllegalArgumentException());

    bf.resolveEmbeddedValue("A");

    verify(r1).resolveStringValue("A");
    verify(r2).resolveStringValue("B");
    verify(r3, never()).resolveStringValue(isNull());
}

---

From source file:org.springframework.core.SimpleAliasRegistry.java

/**
 * Resolve all alias target names and aliases registered in this
 * factory, applying the given StringValueResolver to them.
 * <p>The value resolver may for example resolve placeholders
 * in target bean names and even in alias names.
 * @param valueResolver the StringValueResolver to apply
 *//*  ww w  .  j av a  2  s.c  o  m*/
public void resolveAliases(StringValueResolver valueResolver) {
    Assert.notNull(valueResolver, "StringValueResolver must not be null");
    synchronized (this.aliasMap) {
        Map<String, String> aliasCopy = new HashMap<>(this.aliasMap);
        aliasCopy.forEach((alias, registeredName) -> {
            String resolvedAlias = valueResolver.resolveStringValue(alias);
            String resolvedName = valueResolver.resolveStringValue(registeredName);
            if (resolvedAlias == null || resolvedName == null || resolvedAlias.equals(resolvedName)) {
                this.aliasMap.remove(alias);
            } else if (!resolvedAlias.equals(alias)) {
                String existingName = this.aliasMap.get(resolvedAlias);
                if (existingName != null) {
                    if (existingName.equals(resolvedName)) {
                        // Pointing to existing alias - just remove placeholder
                        this.aliasMap.remove(alias);
                        return;
                    }
                    throw new IllegalStateException("Cannot register resolved alias '" + resolvedAlias
                            + "' (original: '" + alias + "') for name '" + resolvedName
                            + "': It is already registered for name '" + registeredName + "'.");
                }
                checkForAliasCircle(resolvedName, resolvedAlias);
                this.aliasMap.remove(alias);
                this.aliasMap.put(resolvedAlias, resolvedName);
            } else if (!registeredName.equals(resolvedName)) {
                this.aliasMap.put(alias, resolvedName);
            }
        });
    }
}

---