Discuter de l'utilisation et du traitement de diverses méthodes de requête dans Laravel

Laravel est un framework PHP populaire pour le développement d'applications Web. Il fournit de nombreuses fonctionnalités et outils pratiques qui permettent aux développeurs d'effectuer les tâches courantes plus efficacement. L'une des tâches courantes consiste à gérer les requêtes HTTP. Laravel prend en charge une variété de méthodes de requête différentes, notamment GET, POST, PUT, DELETE, etc. Dans cet article, nous explorerons l'utilisation et le traitement de diverses méthodes de requête dans Laravel.

Requête et réponse HTTP

Avant de commencer à présenter diverses méthodes de requête, présentons brièvement les concepts de base des requêtes et réponses HTTP. Une requête HTTP fait référence à une requête envoyée par le client au serveur, qui comprend l'URL cible de la requête, les informations d'en-tête de la requête et le corps de la requête (pour les requêtes POST). Après avoir reçu la demande, le serveur effectuera les opérations de traitement correspondantes puis enverra une réponse HTTP au client. La réponse comprend des informations d'en-tête de réponse, un code de réponse et un corps de réponse. Le code de réponse indique le résultat du traitement de la demande par le serveur, par exemple 200 indiquant le succès, 404 indiquant que la ressource demandée est introuvable, etc.

GET request

GET request est une méthode de requête utilisée pour obtenir des données du serveur. Ses paramètres de requête seront ajoutés à l'URL avec un point d'interrogation (?) comme délimiteur. Dans Laravel, nous pouvons utiliser la méthode Route::get() pour définir une route GET. Par exemple :

Route::get('/users', function () {
    return view('users');
});

Cette route correspondra au chemin /users et renverra une vue nommée users. Dans cette vue, nous pouvons utiliser certaines balises HTML pour générer une requête GET :

<form action="/users" method="get">
   <button type="submit">Get Users</button>
</form>

Ici, nous utilisons un formulaire pour envoyer une requête GET. L'attribut action du formulaire indique l'URL cible de la requête et l'attribut méthode spécifie la méthode de requête comme GET. Lorsque l'utilisateur clique sur le bouton, le navigateur envoie une requête GET au serveur et ajoute les paramètres de la requête après l'URL. Par exemple, si l'on saisit un paramètre nommé « John » dans le formulaire, l'URL demandée deviendra /users?name=John. Côté serveur, nous pouvons utiliser l'objet $request pour obtenir les paramètres de la requête :

Route::get('/users', function (Illuminate\Http\Request $request) {
   $name = $request->input('name');
   // 查询数据库，返回符合条件的用户列表
   $users = App\User::where('name', $name)->get();
   return view('users', ['users' => $users]);
});

Ce code montre comment utiliser l'objet $request pour obtenir les paramètres de la requête. Nous avons d'abord appelé la méthode input() pour obtenir la valeur du paramètre nommé "name", puis nous l'avons utilisée pour interroger la base de données et enfin renvoyé une liste d'utilisateurs qualifiés. Cette liste sera transmise à la vue des utilisateurs précédemment définie pour affichage.

Requête POST

La requête POST est une méthode de requête utilisée pour soumettre des données au serveur. Ses paramètres de requête seront ajoutés au corps de la requête et envoyés au serveur sous forme de messages HTTP. Dans Laravel, nous pouvons utiliser la méthode Route::post() pour définir une route POST. Par exemple :

Route::post('/users', function (Illuminate\Http\Request $request) {
   $name = $request->input('name');
   $email = $request->input('email');
   // 将用户数据保存到数据库
   $user = new App\User;
   $user->name = $name;
   $user->email = $email;
   $user->save();
   return redirect('/users');
});

Cette route correspondra au chemin /users et enregistrera les données de la requête POST reçue dans la base de données. L'envoi d'une requête POST dans un formulaire est similaire à l'envoi d'une requête GET. Changez simplement la valeur de l'attribut de la méthode en "post" :

<form action="/users" method="post">
   @csrf
   <input type="text" name="name" placeholder="Name">
   <input type="email" name="email" placeholder="Email">
   <button type="submit">Add User</button>
</form>

Ici, nous avons également ajouté un champ de formulaire caché nommé "_token" (@csrf ). Ce champ masqué est requis pour la fonction de protection CSRF de Laravel, qui est utilisée pour empêcher les attaques de falsification de requêtes intersites. Côté serveur, nous devons utiliser la méthode IlluminateSupportFacadesURL::csrfToken() dans le routage pour générer un token CSRF :

Route::post('/users', function () {
   return view('users');
})->middleware('web');

Ce middleware indique que la requête doit être traitée par le middleware web, et le middleware web ajoutera automatiquement CSRF à chaque demande.

Requêtes PUT et DELETE

Les requêtes PUT et DELETE sont utilisées pour mettre à jour et supprimer des ressources côté serveur. Elles sont utilisées et traitées de la même manière que les requêtes GET et POST. Dans Laravel, nous pouvons utiliser les méthodes Route::put() et Route::delete() pour définir les routes PUT et DELETE. Par exemple :

Route::put('/users/{id}', function (Illuminate\Http\Request $request, $id) {
   $user = App\User::findOrFail($id);
   $user->name = $request->input('name');
   $user->email = $request->input('email');
   $user->save();
   return redirect('/users');
});

Route::delete('/users/{id}', function ($id) {
   $user = App\User::findOrFail($id);
   $user->delete();
   return redirect('/users');
});

Ici, nous définissons une route PUT et une route DELETE pour mettre à jour et supprimer les informations utilisateur. Dans le client, nous pouvons utiliser du code JavaScript pour envoyer des requêtes PUT et DELETE :

// 发送PUT请求
fetch('/users/1', {
   method: 'PUT',
   headers: {
      'Content-Type': 'application/json'
   },
   body: JSON.stringify({
      name: 'John Smith',
      email: 'john@example.com'
   })
}).then(response => {
   if (response.ok) {
      // 成功处理响应
   } else {
      // 处理响应错误
   }
}).catch(error => {
   // 处理网络请求错误
});

// 发送DELETE请求
fetch('/users/1', {
   method: 'DELETE'
}).then(response => {
   if (response.ok) {
      // 成功处理响应
   } else {
      // 处理响应错误
   }
}).catch(error => {
   // 处理网络请求错误
});

Ce code montre comment utiliser la fonction fetch() pour envoyer des requêtes PUT et DELETE. Lors de l'envoi d'une requête PUT, nous convertissons les données du corps de la requête au format JSON et spécifions le Content-Type comme application/json dans l'en-tête de la requête. Côté serveur, nous obtenons des informations sur les utilisateurs et mettons à jour ou supprimons les enregistrements de la base de données en utilisant la méthode findOrFail().

Résumé

Laravel fournit une variété de méthodes de requête HTTP différentes, ce qui nous permet de traiter plus facilement les ressources côté serveur. Lors du développement d'applications Web, nous utilisons généralement plusieurs méthodes de requête pour effectuer différentes tâches, telles que l'obtention de données via des requêtes GET, la soumission de données de formulaire via des requêtes POST, ainsi que la mise à jour et la suppression de ressources via des requêtes PUT et DELETE. Grâce au système de routage de Laravel, nous pouvons facilement définir les itinéraires correspondants pour différentes méthodes de requête et traiter les données de requête et les résultats de réponse côté serveur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!