The core of handling routing in modern PHP frameworks is to understand the unified entry mechanism and routing configuration methods. 1. The basic routing definition maps URLs to controller methods through routes.php or annotations, such as Laravel's Route::get(). It is recommended to centrally manage routes and use named routes to improve maintainability; 2. Routing parameters support dynamic path extraction and verification, such as using where() to limit parameter types to avoid injection risks; 3. Routing packets combine middleware to achieve permission control and modular management, reduce duplicate code and improve organizational logic capabilities; 4. Resource routing supports RESTful style, automatically creates standard CRUD routes, improves development efficiency and enhances collaboration consistency. Mastering these common practices allows you to flexibly respond to routing needs in different frameworks.

In modern PHP frameworks, the core is to understand its unified entry mechanism and routing configuration method. Most mainstream frameworks (such as Laravel, Symfony, Laminas, etc.) provide flexible routing systems that allow you to map URLs to the corresponding controller methods. Here are some practical practices to help you better understand and use the routing features in these frameworks.

1. Basic routing definition: from URL to controller

Modern PHP frameworks usually define routes through a routes.php or annotation. Taking Laravel as an example, you can write this:

 Route::get('/about', [AboutController::class, 'index']);

This means that when the user accesses /about , index method in AboutController will be called. This structure clearly separates the URL and business logic.

suggestion:

• Centrally manage all routes for easy maintenance.
• Use named routes to facilitate link generation and redirection generation:

   Route::get('/contact', [ContactController::class, 'show'])->name('contact.show');

• For simple GET/POST requests, just use the shortcut method provided by the framework.

2. Routing parameters and verification: not just passing values

Routing parameters are the basis of dynamic content, such as paths like /user/{id} . You can extract id from it and pass it to the controller.

Example:

 Route::get('/user/{id}', [UserController::class, 'show']);

Advanced skills:

• Add parameter validation rules to avoid invalid requests:

   Route::get('/user/{id}', [UserController::class, 'show'])->where('id', '[0-9] ');

• Use optional parameters (for frameworks such as Symfony):

   user_profile:
    path: /user/{id}/{tab?}
    defaults: { tab: 'overview' }

Notes:

• Don't over-nest parameters, the URL should be concise and easy to read.
• It is best to limit the parameter types to avoid injection or error handling.

3. Routing grouping and middleware: Organizing more complex logic

As the project gets bigger, you need to group the routes, such as setting prefixes and middleware for the API and background respectively.

Laravel example:

 Route::prefix('admin')->middleware('auth')->group(function () {
    Route::get('/dashboard', [AdminController::class, 'dashboard']);
});

benefit:

• Public prefix reduces duplicate code.
• Middleware unified control permissions, logs and other behaviors.
• Routes can be divided by module to improve maintainability.

Tips:

• When developing APIs, it is a good habit to use api.php to store interface routing separately.
• Use middleware combinations reasonably, such as verifying login and role permissions at the same time.

4. Resource routing and RESTful style: write less and do more

Many frameworks support "resource routing" to help you automatically create standard CRUD routes.

Laravel example:

 Route::resource('photos', PhotoController::class);

This statement will automatically generate the following route:

• GET /photos → List
• GET /photos/{id} → View
• POST /photos → Create
• PUT /photos/{id} → Update
• DELETE /photos/{id} → Delete

Advantages:

• Reduce repetitive labor.
• Comply with RESTful design specifications.
• It's easier to collaborate with other developers.

Basically that's it. By mastering these common practices, you can flexibly respond to various routing needs in different PHP frameworks. Although the grammar of each framework is slightly different, the ideas are basically the same, and the key is to understand the design pattern behind it.

The above is the detailed content of how to handle routing in a modern php framework. For more information, please follow other related articles on the PHP Chinese website!