How to do lazy loading in Spring beans

Key takeaways:
Lazy loading in Spring allows beans to be loaded only when needed, improving performance and reducing resource consumption.
It defers the initialization of a bean until it is requested, enhancing application startup speed.
Benefits include reduced startup time, minimized memory usage, and better dependency management.
Implement lazy loading using the @Lazy annotation on beans or via XML configuration.
Be cautious of potential overhead when accessing lazily loaded beans and ensure proper handling of circular dependencies.
Use eager initialization for critical beans required at startup to avoid runtime issues.
Lazy loading is particularly useful in large applications for optimizing resource use.

Lazy loading is a design pattern commonly used in software development, particularly in frameworks like Spring. It allows you to load beans only when needed, rather than at the start of the application. This can enhance performance and reduce resource consumption, especially in large applications. In this Answer, we will explore how to implement lazy loading in Spring beans.

What is lazy loading?

Lazy loading defers the initialization of a bean until it is needed. In Spring, this means that if a bean is configured for lazy loading, it will not be instantiated until it is requested by another bean or directly accessed.

Benefits

The benefits of lazy loading in Spring beans are:

Performance improvement: Reduces startup time as not all beans are loaded at application startup.
Resource optimization: Minimizes memory usage by loading only the necessary beans.
Dependency management: Allows better handling of dependencies, especially in complex applications.

Code example

The example below will focus on lazy loading a specific bean in the Spring application. Here, we’ll define and configure a Book class to be lazily loaded using the @Lazy annotation. The example illustrates how to apply lazy loading to a single bean, ensuring that it is only initialized when needed within the application.

@REM ----------------------------------------------------------------------------
@REM Licensed to the Apache Software Foundation (ASF) under one
@REM or more contributor license agreements.  See the NOTICE file
@REM distributed with this work for additional information
@REM regarding copyright ownership.  The ASF licenses this file
@REM to you under the Apache License, Version 2.0 (the
@REM "License"); you may not use this file except in compliance
@REM with the License.  You may obtain a copy of the License at
@REM
@REM    https://www.apache.org/licenses/LICENSE-2.0
@REM
@REM Unless required by applicable law or agreed to in writing,
@REM software distributed under the License is distributed on an
@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
@REM KIND, either express or implied.  See the License for the
@REM specific language governing permissions and limitations
@REM under the License.
@REM ----------------------------------------------------------------------------

@REM ----------------------------------------------------------------------------
@REM Apache Maven Wrapper startup batch script, version 3.2.0
@REM
@REM Required ENV vars:
@REM JAVA_HOME - location of a JDK home dir
@REM
@REM Optional ENV vars
@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
@REM     e.g. to debug Maven itself, use
@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
@REM ----------------------------------------------------------------------------

@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
@echo off
@REM set title of command window
title %0
@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%

@REM set %HOME% to equivalent of $HOME
if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")

@REM Execute a user defined script before this one
if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
@REM check for pre script, once with legacy .bat ending and once with .cmd ending
if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
:skipRcPre

@setlocal

set ERROR_CODE=0

@REM To isolate internal variables from possible post scripts, we use another setlocal
@setlocal

@REM ==== START VALIDATION ====
if not "%JAVA_HOME%" == "" goto OkJHome

echo.
echo Error: JAVA_HOME not found in your environment. >&2
echo Please set the JAVA_HOME variable in your environment to match the >&2
echo location of your Java installation. >&2
echo.
goto error

:OkJHome
if exist "%JAVA_HOME%\bin\java.exe" goto init

echo.
echo Error: JAVA_HOME is set to an invalid directory. >&2
echo JAVA_HOME = "%JAVA_HOME%" >&2
echo Please set the JAVA_HOME variable in your environment to match the >&2
echo location of your Java installation. >&2
echo.
goto error

@REM ==== END VALIDATION ====

:init

@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
@REM Fallback to current working directory if not found.

set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir

set EXEC_DIR=%CD%
set WDIR=%EXEC_DIR%
:findBaseDir
IF EXIST "%WDIR%"\.mvn goto baseDirFound
cd ..
IF "%WDIR%"=="%CD%" goto baseDirNotFound
set WDIR=%CD%
goto findBaseDir

:baseDirFound
set MAVEN_PROJECTBASEDIR=%WDIR%
cd "%EXEC_DIR%"
goto endDetectBaseDir

:baseDirNotFound
set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
cd "%EXEC_DIR%"

:endDetectBaseDir

IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig

@setlocal EnableExtensions EnableDelayedExpansion
for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%

:endReadAdditionalConfig

SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain

set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"

FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
    IF "%%A"=="wrapperUrl" SET WRAPPER_URL=%%B
)

@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
if exist %WRAPPER_JAR% (
    if "%MVNW_VERBOSE%" == "true" (
        echo Found %WRAPPER_JAR%
    )
) else (
    if not "%MVNW_REPOURL%" == "" (
        SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
    )
    if "%MVNW_VERBOSE%" == "true" (
        echo Couldn't find %WRAPPER_JAR%, downloading it ...
        echo Downloading from: %WRAPPER_URL%
    )

    powershell -Command "&{"^
		"$webclient = new-object System.Net.WebClient;"^
		"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
		"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
		"}"^
		"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%WRAPPER_URL%', '%WRAPPER_JAR%')"^
		"}"
    if "%MVNW_VERBOSE%" == "true" (
        echo Finished downloading %WRAPPER_JAR%
    )
)
@REM End of extension

@REM If specified, validate the SHA-256 sum of the Maven wrapper jar file
SET WRAPPER_SHA_256_SUM=""
FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
    IF "%%A"=="wrapperSha256Sum" SET WRAPPER_SHA_256_SUM=%%B
)
IF NOT %WRAPPER_SHA_256_SUM%=="" (
    powershell -Command "&{"^
       "$hash = (Get-FileHash \"%WRAPPER_JAR%\" -Algorithm SHA256).Hash.ToLower();"^
       "If('%WRAPPER_SHA_256_SUM%' -ne $hash){"^
       "  Write-Output 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^
       "  Write-Output 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^
       "  Write-Output 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^
       "  exit 1;"^
       "}"^
       "}"
    if ERRORLEVEL 1 goto error
)

@REM Provide a "standardized" way to retrieve the CLI args that will
@REM work with both Windows and non-Windows executions.
set MAVEN_CMD_LINE_ARGS=%*

%MAVEN_JAVA_EXE% ^
  %JVM_CONFIG_MAVEN_PROPS% ^
  %MAVEN_OPTS% ^
  %MAVEN_DEBUG_OPTS% ^
  -classpath %WRAPPER_JAR% ^
  "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
  %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
if ERRORLEVEL 1 goto error
goto end

:error
set ERROR_CODE=1

:end
@endlocal & set ERROR_CODE=%ERROR_CODE%

if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
@REM check for post script, once with legacy .bat ending and once with .cmd ending
if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
:skipRcPost

@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
if "%MAVEN_BATCH_PAUSE%"=="on" pause

if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%

cmd /C exit /B %ERROR_CODE%

Lazy loading for a specified bean

In Book.java:

Line 9: The book bean is being annotated with @Lazy at the top of the class.

In App.java:

Lines 12–14: We auto-wired the Book bean and annotate it with @Lazy as well.

Note: Here notice that we used @Lazy on class as well on the auto-wired bean in App.class. If we remove any of these, lazy loading would not work.

As we see here, when we run the application, “Book is initialized” is printed later after the “App is initialized” has been printed out. This shows that the book has been lazy-loaded. If we remove the annotation of @Lazy “Book is initialized” will get printed after the “App is initialized.”

Without lazy loading

If for the same code, we don’t use lazy loading. The book bean will be loaded before application initialization, thus increasing the app start time. So try removing the lazy initialization. The application initialization will be increased from 29.1 to 30.2. Thus, if we need to load a lot of beans at the start of the application, it can significantly affect our application's start time. Here is a screenshot:

Lazy Loading is very helpful If we want quick loading of our application. But many problems may arise which have to come on compile-time will be hided by lazy loading and they will cause runtime errors, which is also very risky.

Considerations

Overhead: While lazy loading can improve performance, it may introduce overhead when accessing beans for the first time. Assess the trade-offs in the context of your application.
Circular dependencies: Lazy loading can help avoid circular dependency issues but may complicate the design if not handled properly. Ensure your bean dependencies are well-structured.
Eager initialization: Use eager initialization for beans that are critical to the startup of your application to ensure they are ready when the application starts.

Conclusion

Implementing lazy loading in Spring beans can significantly enhance the performance and resource efficiency of your application. By understanding and applying the @Lazy annotation and XML configurations, you can ensure that your beans are only instantiated when necessary. This approach is especially beneficial in large applications where resource optimization is crucial. As always, carefully consider the architecture and dependencies of your application when integrating lazy loading to achieve the best results.

Frequently asked questions

Haven’t found what you were looking for? Contact Us

How do you make lazy loading?

You can implement lazy loading in Spring by using the @Lazy annotation on the bean definition or by configuring it in XML. This instructs Spring to delay the instantiation of the bean until it is explicitly requested.

What are the methods of lazy loading?

@Lazy annotation: Applied at the class or field level to specify lazy initialization.
XML configuration: Sets the lazy-init attribute to true for specific bean definitions in the XML configuration file.
Proxy-based lazy loading: Using Spring AOP to create proxy objects that initialize the target bean only when a method is invoked.

How do you trigger lazy loading?

Lazy loading is triggered when a bean marked as lazy is requested, either by being injected into another bean or explicitly called in the application code.

Is lazy loading good or bad?

There’s no absolute good or bad regarding lazy loading; it depends on the specific use case. Lazy loading is beneficial when you prefer to allocate resources at runtime rather than during application startup, which can enhance performance in many scenarios. However, in real-time applications, using a buffer to pre-load resources might be more advantageous to avoid delays, contrasting with lazy loading’s approach.

Free AI Mock Interviews

Coding Interview

Coding PatternsFree Interview

Gain insights and practical experience with coding patterns through targeted MCQs and coding problems, designed to match and challenge your expertise level.

System Design

YouTubeFree Interview

Learn to design a video streaming platform like YouTube by tackling functional and non-functional requirements, core components, and high-level to detailed design challenges.

Free Resources