Install the spatie/laravel-sitemap package: Install and introduce the spatie/laravel-sitemap package through Composer to support sitemap generation function; 2. Optional configuration: Publish configuration files to customize cache, tags or style settings; 3. Create routes to generate sitemap: Create routes in web.php using SitemapGenerator and return sitemap.xml; 4. Recommended use of planning tasks: Create Artisan commands and generate sitemap regularly daily through Laravel scheduler to improve performance; 5. Service static files: The route only returns the generated static sitemap.xml files to avoid duplicate generation; 6. Add dynamic URLs: Manually add dynamic content such as blog posts through Sitemap::create() and set update frequency, priority and other attributes; 7. Submit to search engines: Submit the generated sitemap.xml to Google Search Console and Bing Webmaster Tools to complete SEO optimization, ultimately implementing efficient and maintainable sitemap integration for Laravel applications.
Adding a sitemap to a Laravel application is a straightforward process, especially if you're using a package like spatie/laravel-sitemap
—which is the most popular and well-maintained solution. Here's how to do it step by step.

1. Install the Spatie Sitemap Package
First, install the package via Composer:
composer requires spatie/laravel-sitemap
This package handles generating sitemaps, managing URLs, and even support sitemap indexes for large sites.

2. Publish and Configure (Optional)
You can publish the config file to customize behavior:
php artisan vendor:publish --provider="Spatie\Sitemap\SitemapServiceProvider"
This creates config/sitemap.php
. You usually don't need to change anything unless you want to customize cache settings, tags, or styling.

3. Generate the Sitemap
Create a route in routes/web.php
to generate and serve the sitemap:
use Spatie\Sitemap\SitemapGenerator; Route::get('/sitemap.xml', function () { // Generate the sitemap SitemapGenerator::create(config('app.url'))->writeToFile(public_path('sitemap.xml')); // Return the file return response()->file(public_path('sitemap.xml')); });
?? Note : This regenerates the sitemap on every request. That's fine for small or infrequently changing sites, but not ideal for large or high-traffic ones.
4. Better Approach: Use a Scheduled Command (Recommended)
For production, generate the sitemap periodically using Laravel's task scheduler.
a. Create an Artisan Command
php artisan make:command GenerateSitemap
Edit the new command in app/Console/Commands/GenerateSitemap.php
:
<?php namespace App\Console\Commands; use Illuminate\Console\Command; use Spatie\Sitemap\SitemapGenerator; class GenerateSitemap extends Command { protected $signature = 'sitemap:generate'; protected $description = 'Generate the sitemap'; public function handle() { SitemapGenerator::create(config('app.url')) -> writeToFile(public_path('sitemap.xml')); $this->info('Sitemap generated successfully.'); } }
b. Schedule the Command
In app/Console/Kernel.php
, add the command to the schedule:
protected function schedule(Schedule $schedule) { $schedule->command('sitemap:generate')->daily(); }
Now the sitemap will be regenerated once per day.
c. Serve the Static File
Update your route to just serve the static file without regenerating:
Route::get('/sitemap.xml', function () { return response()->file(public_path('sitemap.xml')); });
Make sure the file exists. You can manually run the command once to create it:
php artisan sitemap:generate
5. Add Dynamic URLs (Optional)
If you have dynamic content (eg, blog posts), you can manually add them:
use Spatie\Sitemap\Sitemap; use App\Models\Post; Sitemap::create() ->add('/home') ->add('/about') ->add('/contact') ->add( Post::where('published', true)->get() ->map(function (Post $post) { return $post->toSitemapTag(); }) ) -> writeToFile(public_path('sitemap.xml'));
Make sure your model (eg, Post
) implements Spatie\Sitemap\Tags\Url
or use ->add()
with Url::create()
:
use Spatie\Sitemap\Tags\Url; ->add(Url::create("/blog/{$post->slug}") ->setLastModificationDate($post->updated_at) ->setChangeFrequency('weekly') ->setPriority(0.8))
6. Submit to Search Engines
Once your sitemap.xml
is accessible (eg, https://yoursite.com/sitemap.xml
), submit it to:
- Google Search Console
- Bing Webmaster Tools
Summary
- ? Use
spatie/laravel-sitemap
for easy integration - ? Generate sitemap via a scheduled command in production
- ? Serve a static XML file for performance
- ? Include dynamic content by manually adding URLs
- ? Submit to search engines
That's it. Your Laravel app now has a working, SEO-friendly sitemap.
The above is the detailed content of How to add a sitemap to a Laravel application?. 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

There are three ways to add custom validation rules in Laravel: using closures, Rule classes, and form requests. 1. Use closures to be suitable for lightweight verification, such as preventing the user name "admin"; 2. Create Rule classes (such as ValidUsernameRule) to make complex logic clearer and maintainable; 3. Integrate multiple rules in form requests and centrally manage verification logic. At the same time, you can set prompts through custom messages methods or incoming error message arrays to improve flexibility and maintainability.

The core methods for Laravel applications to implement multilingual support include: setting language files, dynamic language switching, translation URL routing, and managing translation keys in Blade templates. First, organize the strings of each language in the corresponding folders (such as en, es, fr) in the /resources/lang directory, and define the translation content by returning the associative array; 2. Translate the key value through the \_\_() helper function call, and use App::setLocale() to combine session or routing parameters to realize language switching; 3. For translation URLs, paths can be defined for different languages ??through prefixed routing groups, or route alias in language files dynamically mapped; 4. Keep the translation keys concise and

ToworkeffectivelywithpivottablesinLaravel,firstaccesspivotdatausingwithPivot()orwithTimestamps(),thenupdateentrieswithupdateExistingPivot(),managerelationshipsviadetach()andsync(),andusecustompivotmodelswhenneeded.1.UsewithPivot()toincludespecificcol

Laravelprovidesacleanandflexiblewaytosendnotificationsviamultiplechannelslikeemail,SMS,in-appalerts,andpushnotifications.Youdefinenotificationchannelsinthevia()methodofanotificationclass,andimplementspecificmethodsliketoMail(),toDatabase(),ortoVonage

ServiceProvider is the core mechanism used in the Laravel framework for registering services and initializing logic. You can create a custom ServiceProvider through the Artisan command; 1. The register method is used to bind services, register singletons, set aliases, etc., and other services that have not yet been loaded cannot be called; 2. The boot method runs after all services are registered and is used to register event listeners, view synthesizers, middleware and other logic that depends on other services; common uses include binding interfaces and implementations, registering Facades, loading configurations, registering command-line instructions and view components; it is recommended to centralize relevant bindings to a ServiceProvider to manage, and pay attention to registration

Dependency injection automatically handles class dependencies through service containers in Laravel without manual new objects. Its core is constructor injection and method injection, such as automatically passing in the Request instance in the controller. Laravel parses dependencies through type prompts and recursively creates the required objects. The binding interface and implementation can be used by the service provider to use the bind method, or singleton to bind a singleton. When using it, you need to ensure type prompts, avoid constructor complications, use context bindings with caution, and understand automatic parsing rules. Mastering these can improve code flexibility and maintenance.

Laravel performance optimization can improve application efficiency through four core directions. 1. Use the cache mechanism to reduce duplicate queries, store infrequently changing data through Cache::remember() and other methods to reduce database access frequency; 2. Optimize database from the model to query statements, avoid N 1 queries, specifying field queries, adding indexes, paging processing and reading and writing separation, and reduce bottlenecks; 3. Use time-consuming operations such as email sending and file exporting to queue asynchronous processing, use Supervisor to manage workers and set up retry mechanisms; 4. Use middleware and service providers reasonably to avoid complex logic and unnecessary initialization code, and delay loading of services to improve startup efficiency.

The core methods for handling exceptions and recording errors in Laravel applications include: 1. Use the App\Exceptions\Handler class to centrally manage unhandled exceptions, and record or notify exception information through the report() method, such as sending Slack notifications; 2. Use Monolog to configure the log system, set the log level and output method in config/logging.php, and enable error and above level logs in production environment. At the same time, detailed exception information can be manually recorded in report() in combination with the context; 3. Customize the render() method to return a unified JSON format error response, improving the collaboration efficiency of the front and back end of the API. These steps are
