/** * Return suggestions for actual bean property names that closely match * the invalid property name, if any. */ @Nullable public String[] getPossibleMatches() { return this.possibleMatches; }
/** * Return the name of the class we were trying to load. */ @Nullable public String getBeanClassName() { return this.beanClassName; }
/** * Return the property value with the given name, if any. * @param propertyName the name to search for * @return the property value, or {@code null} if none */ @Nullable PropertyValue getPropertyValue(String propertyName);
/** * Return a type descriptor for the specified property: * preferably from the read method, falling back to the write method. * @param propertyName the property to check * (may be a nested path and/or an indexed/mapped property) * @return the property type for the particular property, * or {@code null} if not determinable * @throws PropertyAccessException if the property was valid but the * accessor method failed */ @Nullable TypeDescriptor getPropertyTypeDescriptor(String propertyName) throws BeansException;
/** * Create a new BeanDefinitionStoreException. * @param msg the detail message (used as exception message as-is) * @param cause the root cause (may be {@code null}) */ public BeanDefinitionStoreException(String msg, @Nullable Throwable cause) { super(msg, cause); this.resourceDescription = null; this.beanName = null; }
/** * Return the name of the bean requested, if any. */ @Nullable public String getBeanName() { return this.beanName; }
/** * Find a custom property editor for the given type and property. * @param requiredType the type of the property (can be {@code null} if a property * is given but should be specified in any case for consistency checking) * @param propertyPath the path of the property (name or nested path), or * {@code null} if looking for an editor for all properties of the given type * @return the registered editor, or {@code null} if none */ @Nullable PropertyEditor findCustomEditor(@Nullable Class<?> requiredType, @Nullable String propertyPath);
/** * Override the target scope of this bean, specifying a new scope name. * @see #SCOPE_SINGLETON * @see #SCOPE_PROTOTYPE */ void setScope(@Nullable String scope);
/** * Return the bean names that this bean depends on. */ @Nullable String[] getDependsOn();
/** * Set the name of the initializer method. * @since 5.1 */ void setInitMethodName(@Nullable String initMethodName);
/** * Return the name of the initializer method. * @since 5.1 */ @Nullable String getInitMethodName();
@Override @Nullable public Method getReadMethod() { return this.readMethod; }
@Override @Nullable public Class<?> getPropertyEditorClass() { return this.propertyEditorClass; }
/** * Return the offending constructor, if known. * @return the constructor in use, or {@code null} in case of a * factory method or in case of default instantiation * @since 4.3 */ @Nullable public Constructor<?> getConstructor() { return this.constructor; }
/** * Create a new {@code TypeMismatchException} without a {@code PropertyChangeEvent}. * @param value the offending value that couldn't be converted (may be {@code null}) * @param requiredType the required target type (or {@code null} if not known) * @see #initPropertyName */ public TypeMismatchException(@Nullable Object value, @Nullable Class<?> requiredType) { this(value, requiredType, null); }
/** * Set the configuration source {@code Object} for this metadata element. * <p>The exact type of the object will depend on the configuration mechanism used. */ public void setSource(@Nullable Object source) { this.source = source; }
/** * Return the wrapped MethodParameter, if any. * <p>Note: Either MethodParameter or Field is available. * @return the MethodParameter, or {@code null} if none */ @Nullable public MethodParameter getMethodParameter() { return this.methodParameter; }
/** * Return the resolution strategy for expressions in bean definition values. * @since 3.0 */ @Nullable BeanExpressionResolver getBeanExpressionResolver();
/** * Specify a Spring 3.0 ConversionService to use for converting * property values, as an alternative to JavaBeans PropertyEditors. * @since 3.0 */ void setConversionService(@Nullable ConversionService conversionService);
/** * Return the Scope implementation for the given scope name, if any. * <p>This will only return explicitly registered scopes. * Built-in scopes such as "singleton" and "prototype" won't be exposed. * @param scopeName the name of the scope * @return the registered Scope implementation, or {@code null} if none * @see #registerScope */ @Nullable Scope getRegisteredScope(String scopeName);