Imagine a Laravel project with 100+ routes, including separate modules for Guest, User, Administrator, etc. Do you really want to write everything in one file? So how do you group them and add a prefix to the URL? Let’s see what methods are available
1. Separate WEB and API routing
This is simple, because Laravel has already done it for you. There are the following two files:
routes/web.php
routes/api.php
Therefore, if your project has both a front-end page and an API (the more the usage scenario (Laiyueguang), please put the API routing in api.php.
For example, if you have the /users page and the /api/users/ endpoint, write them in their own routing files to avoid confusion caused by the same name appearing in the same file.
But I recently saw a counterexample from the official Laravel project. In Laravel Horizon, Taylor only has API routing, but he did not write it separately. He still wrote it in routes/web.php:
Another example proves that Laravel is still very personal ation, even Taylor himself did not follow the standards 100%.
2. Group the routes/web.php file into a structured structure
The following example is also from Laravel’s official documentation:
Route::middleware(['first', 'second'])->group(function () { Route::get('/', function () { // 使用 first 和 second 中间件 }); Route::get('user/profile', function () { // 使用 first 和 second 中间件 }); });
The most basic The usage is to include different routing groups in different middleware. For example, you want one group to be restricted by the auth middleware by default, another group to be restricted by a separate admin custom middleware, etc.
In this way, you can also use route grouping methods such as name and prefix. Again, the example is given in the official documentation:
Route::prefix('admin')->group(function () { Route::get('users', function () { // 匹配 URL 「/admin/users」 }); }); Route::name('admin.')->group(function () { Route::get('users', function () { // 路由名为 「admin.users」... })->name('users'); });
Also, if you want to add all middleware name prefixes to a group, it's easier to understand by putting them in an array:
// 而不是这样做: Route::name('admin.')->prefix('admin')->middleware('admin')->group(function () { // ... }); // 可以使用数组 Route::group([ 'name' => 'admin.', 'prefix' => 'admin', 'middleware' => 'auth' ], function () { // ... });
Let's combine this into a real example with three route groups:
The "guest" group with /front/XXXXX URL and no middleware
with /user/ "Users" group with XXXXX URL and auth middleware
"Administrator" group with /admin/XXXXX URL and custom admin middleware
Here's how to group everything into routes / A method in the web.php file:
Route::group([ 'name' => 'admin.', 'prefix' => 'admin', 'middleware' => 'admin' ], function () { // URL链接:/admin/users // 路由名称:admin.users Route::get('users', function () { return 'Admin: user list'; })->name('users'); }); Route::group([ 'name' => 'user.', 'prefix' => 'user', 'middleware' => 'auth' ], function () { // URL链接:/user/profile // 路由名称:user.profile Route::get('profile', function () { return 'User profile'; })->name('profile'); }); Route::group([ 'name' => 'front.', 'prefix' => 'front' ], function () { // 这里没有中间件 // URL链接:/front/about-us // 路由名称:front.about Route::get('about-us', function () { return 'About us page'; })->name('about'); });
3. Group controllers using namespaces
In the above example, we are not using controls processor, just returned static text as an example. Let's add a controller and get a little fancy — we'll structure them into folders in their own different namespaces, like this:
Then we can Use them in routing files:
Route::group([ 'name' => 'front.', 'prefix' => 'front' ], function () { Route::get('about-us', 'Front.boutController@index')->name('about'); });
But what if in this group we have many controllers? Should we keep adding Front.omeController? of course not. You can also pass a namespace as one of the parameters.
Route::group([ 'name' => 'front.', 'prefix' => 'front', 'namespace' => 'Front', ], function () { Route::get('about-us', 'AboutController@index')->name('about'); Route::get('contact', 'ContactController@index')->name('contact'); });
4. Group nested group
The above situation is divided into 3 groups. In fact, this is simplified. The structure of the actual project is slightly different. – are two groups: front and auth. Then within auth, there are two subgroups: user and admin. To do this, we can create subgroups in routes/web.php and assign different middlewares/prefixes etc.
Route::group([ 'middleware' => 'auth', ], function() { Route::group([ 'name' => 'admin.', 'prefix' => 'admin', 'middleware' => 'admin' ], function () { // URL: /admin/users // Route name: admin.users Route::get('users', 'UserController@index')->name('users'); }); Route::group([ 'name' => 'user.', 'prefix' => 'user', ], function () { // URL: /user/profile // Route name: user.profile Route::get('profile', 'ProfileController@index')->name('profile'); }); });
We can even have multiple levels of nesting, which is an example of an open source project. Akaunting:
Route::group(['middleware' => 'language'], function () { Route::group(['middleware' => 'auth'], function () { Route::group(['prefix' => 'uploads'], function () { Route::get('{id}', 'Common.ploads@get'); Route::get('{id}/show', 'Common.ploads@show'); Route::get('{id}/download', 'Common.ploads@download'); }); Route::group(['middleware' => 'permission:read-admin-panel'], function () { Route::group(['prefix' => 'wizard'], function () { Route::get('/', 'Wizard.ompanies@edit')->name('wizard.index'); // ...
Another example comes from another popular Laravel CRM called Monica:
Route::middleware(['auth', 'verified', 'mfa'])->group(function () { Route::name('dashboard.')->group(function () { Route::get('/dashboard', 'DashboardController@index')->name('index'); Route::get('/dashboard/calls', 'DashboardController@calls'); Route::get('/dashboard/notes', 'DashboardController@notes'); Route::get('/dashboard/debts', 'DashboardController@debts'); Route::get('/dashboard/tasks', 'DashboardController@tasks'); Route::post('/dashboard/setTab', 'DashboardController@setTab'); });
5. Global Settings in RouteServiceProvider
There is a file that serves all routing settings – app/Providers/RouteServiceProvider.php. It has a map() method that binds two routing files – web and API:
public function map() { $this->mapApiRoutes(); $this->mapWebRoutes(); } protected function mapWebRoutes() { Route::middleware('web') ->namespace($this->namespace) ->group(base_path('routes/web.php')); } protected function mapApiRoutes() { Route::prefix('api') ->middleware('api') ->namespace($this->namespace) ->group(base_path('routes/api.php')); }
Did you notice that in the method And middleware, namespace and prefix? This is where you can set global configurations for the entire file, so you don't have to repeat these settings for every routing group in the file.
It is mainly used for API routing, as their settings are usually the same, as shown below:
protected function mapApiRoutes() { Route::group([ 'middleware' => ['api'], 'namespace' => $this->namespace, 'prefix' => 'api/v1', ], function ($router) { require base_path('routes/api.php'); }); }
The above method will prefix all API URLs with api/v1/ at the beginning.
6. Grouping into more files – is it worth it?
If you have a large number of routes and want to group them into separate files, then you can use the same file mentioned in the previous section – app/Providers/RouteServiceProvider.php. If you look closely at its map() method, you'll see the comment position at the end:
public function map() { $this->mapApiRoutes(); $this->mapWebRoutes(); // }
If you like, you can interpret this as an "invitation" to add more files. So you can create another method inside this file like mapAdminRoutes() and then add it to the map() method and your file will be automatically registered and loaded.
But, personally, I don't see any advantage to this approach, and I don't see it done very often. It would bring more routing separation, but sometimes you can get lost in those files and not sure where to look for a specific route.
7. Find a specific route using the Artisan route:list command
Speaking of larger routes and getting lost in there, we have an Artisan command that can help locate a certain route.
You probably know that php artisan route:list will display all the routes in your project
but you know there are more filtering capabilities to find what you want Want something? Just add –method, or –name, or –path with arguments.
Filter by method – GET, POST, etc.:
Filter by name or URL part:
Recommended tutorial: "Laravel"
The above is the detailed content of How to organize your routing in a large Laravel project. For more information, please follow other related articles on the PHP Chinese website!

Laravel stands out by simplifying the web development process and delivering powerful features. Its advantages include: 1) concise syntax and powerful ORM system, 2) efficient routing and authentication system, 3) rich third-party library support, allowing developers to focus on writing elegant code and improve development efficiency.

Laravelispredominantlyabackendframework,designedforserver-sidelogic,databasemanagement,andAPIdevelopment,thoughitalsosupportsfrontenddevelopmentwithBladetemplates.

Laravel and Python have their own advantages and disadvantages in terms of performance and scalability. Laravel improves performance through asynchronous processing and queueing systems, but due to PHP limitations, there may be bottlenecks when high concurrency is present; Python performs well with the asynchronous framework and a powerful library ecosystem, but is affected by GIL in a multi-threaded environment.

Laravel is suitable for projects that teams are familiar with PHP and require rich features, while Python frameworks depend on project requirements. 1.Laravel provides elegant syntax and rich features, suitable for projects that require rapid development and flexibility. 2. Django is suitable for complex applications because of its "battery inclusion" concept. 3.Flask is suitable for fast prototypes and small projects, providing great flexibility.

Laravel can be used for front-end development. 1) Use the Blade template engine to generate HTML. 2) Integrate Vite to manage front-end resources. 3) Build SPA, PWA or static website. 4) Combine routing, middleware and EloquentORM to create a complete web application.

PHP and Laravel can be used to build efficient server-side applications. 1.PHP is an open source scripting language suitable for web development. 2.Laravel provides routing, controller, EloquentORM, Blade template engine and other functions to simplify development. 3. Improve application performance and security through caching, code optimization and security measures. 4. Test and deployment strategies to ensure stable operation of applications.

Laravel and Python have their own advantages and disadvantages in terms of learning curve and ease of use. Laravel is suitable for rapid development of web applications. The learning curve is relatively flat, but it takes time to master advanced functions. Python's grammar is concise and the learning curve is flat, but dynamic type systems need to be cautious.

Laravel's advantages in back-end development include: 1) elegant syntax and EloquentORM simplify the development process; 2) rich ecosystem and active community support; 3) improved development efficiency and code quality. Laravel's design allows developers to develop more efficiently and improve code quality through its powerful features and tools.


Hot AI Tools

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

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

Undress AI Tool
Undress images for free

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

Atom editor mac version download
The most popular open source editor

SublimeText3 Linux new version
SublimeText3 Linux latest version

mPDF
mPDF is a PHP library that can generate PDF files from UTF-8 encoded HTML. The original author, Ian Back, wrote mPDF to output PDF files "on the fly" from his website and handle different languages. It is slower than original scripts like HTML2FPDF and produces larger files when using Unicode fonts, but supports CSS styles etc. and has a lot of enhancements. Supports almost all languages, including RTL (Arabic and Hebrew) and CJK (Chinese, Japanese and Korean). Supports nested block-level elements (such as P, DIV),

Zend Studio 13.0.1
Powerful PHP integrated development environment

SecLists
SecLists is the ultimate security tester's companion. It is a collection of various types of lists that are frequently used during security assessments, all in one place. SecLists helps make security testing more efficient and productive by conveniently providing all the lists a security tester might need. List types include usernames, passwords, URLs, fuzzing payloads, sensitive data patterns, web shells, and more. The tester can simply pull this repository onto a new test machine and he will have access to every type of list he needs.