Contrôleurs
Les contrôleurs sont responsables du traitement des demandes entrantes et de l'envoi des réponses au client.
Le rôle d'un contrôleur est de gérer des requêtes spécifiques pour l'application. Le mécanisme de routage détermine quel contrôleur traitera chaque requête.
Dans Nexy, un contrôleur est simplement tout fichier controller.py situé dans le répertoire app ou ses sous-répertoires.
Route
Une route est une association entre un chemin URL et une action dans l'application. Lorsqu'un utilisateur accède à une URL spécifique, la route correspondante est identifiée et exécutée pour traiter la demande.
Dans Nexy, une route est définie par la structure de répertoires dans le dossier app. Le répertoire app lui-même représente la route principale, et chaque sous-répertoire définit une route imbriquée.
Route dynamique
Les routes dynamiques permettent d'identifier des ressources spécifiques en utilisant des paramètres de route. Ces paramètres sont définis dans le chemin de la route et peuvent être extraits par la fonction de traitement de la route.
Dans Nexy, une route devient dynamique lorsque le nom du répertoire ou dossier est encadré par des crochets, comme ceci : [dossier].
Les routes dynamiques fonctionnent de la même manière pour tous les types d'endpoints.
Endpoint
Un endpoint représente un point d'interface complet exposé par l'application qui permet l'interaction avec des services, des ressources ou des fonctionnalités spécifiques. Il comprend :
- ① Le chemin d'accès URL qui identifie la ressource
- ② Le protocole de communication (HTTP ou WebSocket)
- ③ La fonction de traitement qui gère les requêtes entrantes
Dans Nexy, le framework prend en charge deux types d'endpoints principaux :
- ① Les endpoints HTTP
- ② Les endpoints WebSocket
Endpoints HTTP
Les endpoints HTTP suivent le modèle requête-réponse traditionnel et sont utilisés pour effectuer des opérations CRUD (Create, Read, Update, Delete) sur des ressources.
Pour créer un endpoint HTTP dans Nexy, il suffit de définir une fonction ( asynchrone ou pas comme dans FastAPI ) dont le nom correspond à la méthode HTTP souhaitée (GET, POST, PUT, DELETE, etc.) dans un fichier controller.py.
GET
La méthode GET est la méthode fondamentale de récupération de données. Elle permet de lire des informations sans modifier l'état du serveur,
ce qui en fait la méthode la plus sécurisée et la plus utilisée.
Son utilisation principale concerne l'affichage des pages et la consultation des ressources comme les profils utilisateurs ou les listes de produits.
app/**/controller.pyfrom typing import Dict
def GET() -> Dict[str, str] :
return {"message":"Salut Espoir Loém"}
Dans une route dynamique, il est possible d'extraire les paramètres de la route en utilisant le nom de la route dynamique comme paramètre de la fonction .
app/users/[userId]/controller.pyfrom typing import Dict
def GET(userId : int) -> Dict[str, str] :
users = ["Espoir Loém", "Force Espoir","LOEMBA PACKA"]
return {"user": users[userId]}
POST
Complémentaire à GET, la méthode POST est dédiée à la création de nouvelles ressources. Elle assure un transfert sécurisé des données vers le serveur, avec une validation systématique avant sauvegarde.
Cette méthode est essentielle pour toutes les opérations d'ajout, que ce soit la création de comptes utilisateurs ou la publication de nouveaux contenus.
app/**/controller.pyfrom typing import Dict, List
userList : List[Dict[str, str]] = None
def POST() -> List[Dict[str, str]] :
userList.append({"name":"Espoir Loém", "nationality":"Congolese"})
return userList
Dans une route dynamique
app/users/[userId]/controller.pyfrom nexy import Request, Depends
from .service import AppService
async def POST(
userId: int,
service: Depends(AppService),
request: Request,
) -> Dict[str, str]:
comment_data = await request.json()
data = await service.add_comment(userId, comment_data)
return data
Chaque endpoint HTTP est caractérisé par :
- ① une communication ponctuelle et sans état
- ② l'utilisation d'une méthode HTTP spécifique
- ③ une structure de données d'entrée et de sortie bien définie
Endpoints WebSocket
Les endpoints WebSocket établissent une connexion persistante et bidirectionnelle entre le client et le serveur, permettant des communications en temps réel.
Ces endpoints sont particulièrement adaptés pour :
- ① Les applications nécessitant des mises à jour instantanées
- ② Les fonctionnalités de chat et de messagerie
- ③ Les tableaux de bord en temps réel
- ④ Les notifications push
Un endpoint WebSocket dans Nexy maintient un état de connexion et permet l'envoi de messages dans les deux sens à tout moment, contrairement aux endpoints HTTP qui suivent un strict modèle de requête-réponse.
Comment créer un endpoint WebSocket ?
Tout comme pour les endpoints HTTP, il suffit de créer une fonction asynchrone nommée SOCKET dans un fichier controller.py.
app/**/controller.pyfrom nexy import WebSocket
async def SOCKET(ws: WebSocket):
await ws.accept() # Accept the WebSocket connection
try:
while True:
# Receive message from client
message = await ws.receive_text()
# Echo the message back
await ws.send_text(f"Server received: {message}")
except Exception:
await ws.close()
Tout comme pour les endpoints HTTP, il est possible d'extraire les paramètres de la route en utilisant le nom de la route dynamique comme paramètre de la fonction.
app/users/[userId]/controller.pyfrom nexy import WebSocket
async def SOCKET(userId: int, ws: WebSocket):
await ws.accept()
await ws.send_text(f"Hello user {userId}")
await ws.close()
👌 Bravo !
Maintenant que vous avez appris à propos des contrôleurs et des endpoints, vous pouvez commencer à construire la structure API de votre application !
Découvrons comment faire cela dans la section suivante.