Source code
package org.springframework.beans.factory.support;
import org.jspecify.annotations.Nullable;
import org.springframework.util.StringUtils;
/**
* A simple holder for {@code BeanDefinition} property defaults.
*
* @author Mark Fisher
* @author Juergen Hoeller
* @since 2.5
* @see AbstractBeanDefinition#applyDefaults
*/
public class BeanDefinitionDefaults {
private @Nullable Boolean lazyInit;
private int autowireMode = AbstractBeanDefinition.AUTOWIRE_NO;
private int dependencyCheck = AbstractBeanDefinition.DEPENDENCY_CHECK_NONE;
private @Nullable String initMethodName;
private @Nullable String destroyMethodName;
/**
* Set whether beans should be lazily initialized by default.
* <p>If {@code false}, the bean will get instantiated on startup by bean
* factories that perform eager initialization of singletons.
* @see AbstractBeanDefinition#setLazyInit
*/
public void setLazyInit(boolean lazyInit) {
this.lazyInit = lazyInit;
}
/**
* Return whether beans should be lazily initialized by default, i.e. not
* eagerly instantiated on startup. Only applicable to singleton beans.
* @return whether to apply lazy-init semantics ({@code false} by default)
*/
public boolean isLazyInit() {
return (this.lazyInit != null && this.lazyInit);
}
/**
* Return whether beans should be lazily initialized by default, i.e. not
* eagerly instantiated on startup. Only applicable to singleton beans.
* @return the lazy-init flag if explicitly set, or {@code null} otherwise
* @since 5.2
*/
public @Nullable Boolean getLazyInit() {
return this.lazyInit;
}
/**
* Set the autowire mode. This determines whether any automagical detection
* and setting of bean references will happen. Default is AUTOWIRE_NO
* which means there won't be convention-based autowiring by name or type
* (however, there may still be explicit annotation-driven autowiring).
* @param autowireMode the autowire mode to set.
* Must be one of the constants defined in {@link AbstractBeanDefinition}.
* @see AbstractBeanDefinition#setAutowireMode
*/
public void setAutowireMode(int autowireMode) {
this.autowireMode = autowireMode;
}
/**
* Return the default autowire mode.
*/
public int getAutowireMode() {
return this.autowireMode;
}
/**
* Set the dependency check code.
* @param dependencyCheck the code to set.
* Must be one of the constants defined in {@link AbstractBeanDefinition}.
* @see AbstractBeanDefinition#setDependencyCheck
*/
public void setDependencyCheck(int dependencyCheck) {
this.dependencyCheck = dependencyCheck;
}
/**
* Return the default dependency check code.
*/
public int getDependencyCheck() {
return this.dependencyCheck;
}
/**
* Set the name of the default initializer method.
* <p>Note that this method is not enforced on all affected bean definitions
* but rather taken as an optional callback, to be invoked if actually present.
* @see AbstractBeanDefinition#setInitMethodName
* @see AbstractBeanDefinition#setEnforceInitMethod
*/
public void setInitMethodName(@Nullable String initMethodName) {
this.initMethodName = (StringUtils.hasText(initMethodName) ? initMethodName : null);
}
/**
* Return the name of the default initializer method.
*/
public @Nullable String getInitMethodName() {
return this.initMethodName;
}
/**
* Set the name of the default destroy method.
* <p>Note that this method is not enforced on all affected bean definitions
* but rather taken as an optional callback, to be invoked if actually present.
* @see AbstractBeanDefinition#setDestroyMethodName
* @see AbstractBeanDefinition#setEnforceDestroyMethod
*/
public void setDestroyMethodName(@Nullable String destroyMethodName) {
this.destroyMethodName = (StringUtils.hasText(destroyMethodName) ? destroyMethodName : null);
}
/**
* Return the name of the default destroy method.
*/
public @Nullable String getDestroyMethodName() {
return this.destroyMethodName;
}
}
Run 1
The code is highly readable. Package and imports are clear, and the class has a focused responsibility. Fields are logically organized with sensible defaults. All public methods are simple, flat, one-action-per-line getters/setters with no deep nesting. Javadoc comments clearly explain intent, constraints, and defaults, aiding understanding. Method names are descriptive, and the use of @Nullable improves contract clarity. The only minor issue is the slight redundancy of having both isLazyInit() and getLazyInit(), but this is a common spring pattern to distinguish primitive boolean semantics from nullable Boolean. Code length is concise and not bloated. Overall, it follows clean code practices consistently.
Run 2
The code is highly readable with excellent structure and clarity. It follows standard JavaBean conventions with clear field declarations, well-named getters/setters, and comprehensive Javadoc documentation that explains purpose, parameters, and return values. The class has a single responsibility and maintains flat, non-nested logic throughout. Each method performs exactly one action, and the ternary operators in the setter methods are concise without sacrificing clarity. The reading flow is natural, progressing logically through the fields and their accessors. Minor deductions only for slight verbosity in the numerous Javadoc blocks, though this documentation actually enhances maintainability.
Run 3
The code is highly readable, following a clean JavaBean pattern with clear structure and documentation. It is well-organized into fields, setters, and getters, all at a single nesting level. Intent is clear, with comprehensive Javadoc explaining non-obvious behavior. The code is concise without being terse, using simple one-line assignments and a single conditional for null handling. Action granularity is excellent, with each method performing exactly one logical operation. Reading flow is natural, with related fields and methods grouped logically. Minor deductions: the boolean isLazyInit() contains a compound condition that could be slightly clearer, and the 'automagical' wording in Javadoc is informal. Overall, this is exemplary Spring Framework style code.
Run 1
Code Structure: Fields are grouped first, followed by logically paired setters and getters. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive names, explicit default constants, nullable annotations, and informative Javadocs clearly communicate behavior, including the distinction between unset and false lazy initialization. Code length: Implementation is concise, though extensive documentation and repeated accessor patterns make the class somewhat verbose. Action granularity: Each statement performs a single clear operation; the short ternary expressions remain easy to understand. Reading flow: Consistent formatting and predictable method ordering make the class easy to scan from top to bottom. Minor documentation repetition slightly reduces concision, but overall readability is excellent.
Run 2
Code Structure: Fields precede logically paired setters and getters, with consistent formatting and clear separation. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive names, explicit defaults, nullable annotations, and informative Javadocs clearly explain behavior, including the distinction between unset and false lazy initialization. Code length: Implementations are concise; extensive documentation and repetitive accessors add length but are mostly justified. Action granularity: Each statement performs a single assignment or return; simple ternary expressions keep normalization readable. Reading flow: Predictable ordering and consistent method patterns make the class easy to scan. Minor drawbacks include verbose documentation and integer-based modes whose meanings require consulting external constants.
Run 3
Code Structure: Fields are grouped first, followed by logically paired setters and getters. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive names, explicit defaults, nullable annotations, and helpful documentation clearly communicate behavior, including the distinction between unset and false lazy initialization. Code length: Implementations are concise, though extensive accessor documentation adds some repetition. Action granularity: Each statement performs a single assignment or return; the simple ternary expressions remain easy to understand. Reading flow: Consistent formatting and predictable method ordering make the class easy to scan. Integer-based configuration modes require consulting external constants, slightly reducing self-contained readability.