Example usage for org.springframework.core.annotation AnnotationConfigurationException AnnotationConfigurationException

Introduction

In this page you can find the example usage for org.springframework.core.annotation AnnotationConfigurationException AnnotationConfigurationException.

Prototype

public AnnotationConfigurationException(String message) 

Source Link

Document

Construct a new AnnotationConfigurationException with the supplied message.

Usage

From source file:org.springframework.core.annotation.AnnotationUtils.java

/**
 * Post-process the supplied {@link AnnotationAttributes}.
 * <p>Specifically, this method enforces <em>attribute alias</em> semantics
 * for annotation attributes that are annotated with {@link AliasFor @AliasFor}
 * and replaces default value placeholders with their original default values.
 * @param annotatedElement the element that is annotated with an annotation or
 * annotation hierarchy from which the supplied attributes were created;
 * may be {@code null} if unknown/*from w w  w. ja  v  a 2 s  .  com*/
 * @param attributes the annotation attributes to post-process
 * @param classValuesAsString whether to convert Class references into Strings (for
 * compatibility with {@link org.springframework.core.type.AnnotationMetadata})
 * or to preserve them as Class references
 * @param nestedAnnotationsAsMap whether to convert nested annotations into
 * {@link AnnotationAttributes} maps (for compatibility with
 * {@link org.springframework.core.type.AnnotationMetadata}) or to preserve them as
 * {@code Annotation} instances
 * @since 4.2
 * @see #retrieveAnnotationAttributes(Object, Annotation, boolean, boolean)
 * @see #getDefaultValue(Class, String)
 */
static void postProcessAnnotationAttributes(@Nullable Object annotatedElement,
        @Nullable AnnotationAttributes attributes, boolean classValuesAsString,
        boolean nestedAnnotationsAsMap) {

    if (attributes == null) {
        return;
    }

    Class<? extends Annotation> annotationType = attributes.annotationType();

    // Track which attribute values have already been replaced so that we can short
    // circuit the search algorithms.
    Set<String> valuesAlreadyReplaced = new HashSet<>();

    if (!attributes.validated) {
        // Validate @AliasFor configuration
        Map<String, List<String>> aliasMap = getAttributeAliasMap(annotationType);
        for (String attributeName : aliasMap.keySet()) {
            if (valuesAlreadyReplaced.contains(attributeName)) {
                continue;
            }
            Object value = attributes.get(attributeName);
            boolean valuePresent = (value != null && !(value instanceof DefaultValueHolder));

            for (String aliasedAttributeName : aliasMap.get(attributeName)) {
                if (valuesAlreadyReplaced.contains(aliasedAttributeName)) {
                    continue;
                }

                Object aliasedValue = attributes.get(aliasedAttributeName);
                boolean aliasPresent = (aliasedValue != null && !(aliasedValue instanceof DefaultValueHolder));

                // Something to validate or replace with an alias?
                if (valuePresent || aliasPresent) {
                    if (valuePresent && aliasPresent) {
                        // Since annotation attributes can be arrays, we must use ObjectUtils.nullSafeEquals().
                        if (!ObjectUtils.nullSafeEquals(value, aliasedValue)) {
                            String elementAsString = (annotatedElement != null ? annotatedElement.toString()
                                    : "unknown element");
                            throw new AnnotationConfigurationException(String.format(
                                    "In AnnotationAttributes for annotation [%s] declared on %s, "
                                            + "attribute '%s' and its alias '%s' are declared with values of [%s] and [%s], "
                                            + "but only one is permitted.",
                                    attributes.displayName, elementAsString, attributeName,
                                    aliasedAttributeName, ObjectUtils.nullSafeToString(value),
                                    ObjectUtils.nullSafeToString(aliasedValue)));
                        }
                    } else if (aliasPresent) {
                        // Replace value with aliasedValue
                        attributes.put(attributeName, adaptValue(annotatedElement, aliasedValue,
                                classValuesAsString, nestedAnnotationsAsMap));
                        valuesAlreadyReplaced.add(attributeName);
                    } else {
                        // Replace aliasedValue with value
                        attributes.put(aliasedAttributeName, adaptValue(annotatedElement, value,
                                classValuesAsString, nestedAnnotationsAsMap));
                        valuesAlreadyReplaced.add(aliasedAttributeName);
                    }
                }
            }
        }
        attributes.validated = true;
    }

    // Replace any remaining placeholders with actual default values
    for (String attributeName : attributes.keySet()) {
        if (valuesAlreadyReplaced.contains(attributeName)) {
            continue;
        }
        Object value = attributes.get(attributeName);
        if (value instanceof DefaultValueHolder) {
            value = ((DefaultValueHolder) value).defaultValue;
            attributes.put(attributeName,
                    adaptValue(annotatedElement, value, classValuesAsString, nestedAnnotationsAsMap));
        }
    }
}

---