Laravel lazy loading vs eager loading
Jul 28, 2025 am 04:23 AMLazy loading only queries when accessing associations can easily lead to N 1 problems, which is suitable for scenarios where the associated data is not determined. 2. Emergency loading uses with() to load associated data in advance to avoid N 1 queries, which is suitable for batch processing scenarios; 3. Emergency loading should be used to optimize performance, and N 1 problems can be detected through tools such as Laravel Debugbar, and the $with attribute of the model is carefully used to avoid unnecessary performance overhead.
In Laravel, Lazy Loading and Eager Loading are the two main ways to process model-associated data. They are clearly different in performance and usage scenarios, and understanding their differences is very important for optimizing application performance.

What is Lazy Loading
Lazy loading refers to the database that only when accessing the model's association relationship, it will query and load data.
for example:

$books = Book::all(); foreach ($books as $book) { echo $book->author->name; // Every time you access author, a query will be triggered}
The above code will first query all books (1 query), and then each time you access author
of a book
, you will execute a query separately to obtain the author information. If there are 100 books, an additional 100 queries will be performed - this is a typical N 1 query problem .
? Pros:

- Simple to use, intuitive code
- Load data only when it is really needed
? Disadvantages:
- It can easily lead to N 1 query problems and seriously reduce performance
- Especially dangerous when accessing associated data in loops
What is emergency loading
Emergency loading is to load the associated data in advance when querying the main model, using the with()
method.
for example:
$books = Book::with('author')->get(); foreach ($books as $book) { echo $book->author->name; // The data has been loaded, and the database is no longer query}
This code will only execute 2 queries:
- Query all books
- Query all authors corresponding to these books (by
IN
query)
? Pros:
- Avoid N 1 problems and greatly improve performance
- Suitable for batch processing of associated data
? Disadvantages:
- If the associated data is large but not actually used, it will cause waste of resources
- Not available for dynamic conditions (unless constraints are used)
How to choose: lazy load vs urgent load?
Scene | Recommended method | illustrate |
---|---|---|
Accessing associated data in loop | ? Emergency loading | Avoid N 1 query |
Process only a small amount of data or not sure if association is required | ? Lazy loading | Simple and direct, avoid unnecessary inquiries |
Complex or large data volume | ?? Cautioned to load urgently | May cause high memory usage |
Need to add conditions to the association | ? with() closure | Support conditional filtering |
Example: Emergency loading with conditions
$books = Book::with(['author' => function ($query) { $query->where('active', 1); }])->get();
How to detect N 1 problems?
You can use Laravel's debugging tools, such as:
- Laravel Debugbar
- Clockwork
- Or use
DB::listen()
to listen to the number of queries
These tools can help you discover unexpected multiple queries.
Best Practice Recommendations
- Emergency loading is preferred by default , especially when the list page or API returns multiple resources
- Preload common associations using
with()
- Avoid accessing unpreloaded associations in Blade templates (easily trigger lazy loading)
- Some associations can be automatically preloaded (used with caution) by setting
$with
property through the model:
class Book extends Model { protected $with = ['author']; // Automatic preload author }
?? Note: Global $with
affects all queries and may result in unnecessary performance overhead.
Basically that's it. Simply put: lazy loading is convenient but easy to get stuck, urgent loading is efficient but planning is necessary . In actual development, N 1 queries should be avoided as much as possible, and with()
should be used first to optimize performance.
The above is the detailed content of Laravel lazy loading vs eager loading. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

Lazy loading only queries when accessing associations can easily lead to N 1 problems, which is suitable for scenarios where the associated data is not determined whether it is needed; 2. Emergency loading uses with() to load associated data in advance to avoid N 1 queries, which is suitable for batch processing scenarios; 3. Emergency loading should be used to optimize performance, and N 1 problems can be detected through tools such as LaravelDebugbar, and the $with attribute of the model is carefully used to avoid unnecessary performance overhead.

UseaRESTAPItobridgePHPandMLmodelsbyrunningthemodelinPythonviaFlaskorFastAPIandcallingitfromPHPusingcURLorGuzzle.2.RunPythonscriptsdirectlyfromPHPusingexec()orshell_exec()forsimple,low-trafficusecases,thoughthisapproachhassecurityandperformancelimitat

Laravel supports the use of native SQL queries, but parameter binding should be preferred to ensure safety; 1. Use DB::select() to execute SELECT queries with parameter binding to prevent SQL injection; 2. Use DB::update() to perform UPDATE operations and return the number of rows affected; 3. Use DB::insert() to insert data; 4. Use DB::delete() to delete data; 5. Use DB::statement() to execute SQL statements without result sets such as CREATE, ALTER, etc.; 6. It is recommended to use whereRaw, selectRaw and other methods in QueryBuilder to combine native expressions to improve security

Responsive programming implements high concurrency, low latency non-blocking services in Java through ProjectReactor and SpringWebFlux. 1. ProjectReactor provides two core types: Mono and Flux, supports declarative processing of asynchronous data flows, and converts, filters and other operations through operator chains; 2. SpringWebFlux is built on Reactor, supports two programming models: annotation and functional. It runs on non-blocking servers such as Netty, and can efficiently handle a large number of concurrent connections; 3. Using WebFlux Reactor can improve the concurrency capability and resource utilization in I/O-intensive scenarios, and naturally supports SSE and WebSo.

MapStruct is a compile-time code generator used to simplify mapping between JavaBeans. 1. It automatically generates implementation classes by defining interfaces to avoid manually writing lengthy set/get mapping code; 2. It has type-safe, no runtime overhead, supports automatic mapping of the same name fields, custom expressions, nested objects and collection mapping; 3. It can be integrated with Spring and uses @Mapper(componentModel="spring") to inject mapper into Springbean; 4. Simple configuration, just introduce mapstruct dependencies and annotationProcessorPaths inserts

Use regular expression capture group in Notepad to effectively reorganize text. First, you need to open the replacement dialog box (Ctrl H), select "Search Mode" as "regular expression", 1. Use () to define the capture group, such as (\w ) to capture words; 2. Use \1 and \2 to reference the corresponding group in the replacement box; 3. Example: Exchange the name "JohnDoe" as "Doe, John", find (\w )\s (\w ), replace it with \2,\1; 4. Date format conversion 2023-12-25 to 25/12/2023, find (\d{4})-(\d{2})-(\d{2}), replace it with \3/\2/\1; 5. Log reordering can extract time, level, ID and other information

UseefficientdatastructureslikeArrayListoverLinkedListandprimitivecollectionstoreduceoverhead;2.Minimizeobjectcreationbyreusingobjects,usingStringBuilderforconcatenation,andcachingexpensiveobjects;3.Preventmemoryleaksbynullifyingreferences,usingstatic

Python's ternary operator is used to concisely implement if-else judgment, and its syntax is "value_if_trueif conditionelsevalue_if_false"; 1. It can be used for simple assignment, such as returning the corresponding string based on positive and negative values; 2. It can avoid division errors, such as determining that the denominator is non-zero and then division; 3. It can select content according to conditions in string format; 4. It can assign labels to different elements in list derivation formula; it should be noted that this operator is only suitable for binary branches and should not be nested multiple layers. Complex logic should use the traditional if-elif-else structure to ensure readability.
