Implémentez une application simple avec Python full scratch sans utiliser de framework web.
introduction
Il est maintenant plus facile de développer des applications Web à l'aide de frameworks Web tels que Django et Flask, mais cela n'a pas vraiment de sens d'apprendre simplement à utiliser le framework sans en comprendre les racines. , J'ai décidé de comprendre le mécanisme en implémentant une application de blog simple en utilisant uniquement les fonctions intégrées de python et les bibliothèques standard sans utiliser le framework Web.
Créer une page d'index
Étant donné que le serveur Web renvoie (affiche) quelque chose lors de l'accès à partir d'un navigateur Web, créez la page d'index à afficher en premier en html. J'ai créé une page d'index qui affiche Hello, World!.
index.html
<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<p>Hello, World!</p>
</body>
</html>
Créer un serveur HTTP
webserver.py
from http.server import HTTPServer, SimpleHTTPRequestHandler
def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler):
server_address = ('', 8000)
httpd = server_class(server_address, handler_class)
httpd.serve_forever()
if __name__ == '__main__':
run()
HTTP Server est l'une des bibliothèques standard de python pour l'implémentation des fonctionnalités de serveur Web. Spécifiez le nom du serveur et le numéro de port taple et le gestionnaire de requêtes dans les arguments du serveur HTTP. Tout d'abord, comme test, en tant qu'argument du serveur HTTP, spécifiez le nom du serveur (par défaut, localhost) et le numéro de port (numéro d'identification du programme d'accès) 8000, et c'est l'un des gestionnaires de requêtes qui gère les requêtes des clients. Nous avons spécifié deux SimpleHTTPRequestHandlers (classes simples qui renvoient des fichiers correspondant à l'accès client).
Démarrer le serveur HTTP
Terminal
$ python webserver.py
Lorsque j'accède à localhost: 8000 avec un navigateur, «Hello, World» est affiché.
Remarques sur le serveur HTTP
Si vous vous référez à la documentation officielle [^ 1], il y a un avertissement indiquant qu'elle n'est pas adaptée à un usage commercial http.server.
Attention, http.server n'est pas recommandé pour la production, il n'implémente que des contrôles de sécurité de base.
Étant donné que le serveur intégré est lent et ne peut pas supporter la charge, il est courant d'utiliser une application de serveur Web telle qu'Apache ou Nginx à des fins commerciales. Cette fois, le but est de comprendre et de mettre en œuvre le mécanisme de l'application Web, nous allons donc utiliser le serveur intégré tel quel.
Modifier le traitement du gestionnaire de requêtes
Dans le serveur HTTP exécuté dans le test précédent, SimpleRequestHandler a été spécifié comme gestionnaire de requêtes, mais il s'agissait d'un processus qui ne retournait que index.html, nous allons donc ajouter notre propre processus.
Remplacez la méthode do_GET avec la possibilité d'afficher des chaînes formatées en html dans SimpleRequestHandler. En premier lieu, la méthode do_GET effectue un traitement tel que le renvoi d'une réponse HTTP et le renvoi du fichier correspondant.
webserver.py
with open('index.html', 'r')as f:
index_file = f.read()
class OriginalHTTPRequestHandler(SimpleHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.end_headers()
html = index_file.format(
title = 'Titre du Blog',
content = 'Contenu du blog'
)
self.wfile.write(html.encode('utf-8'))
return None
Correction de la partie où Hello, World était jusqu'à présent codé en dur dans le fichier html.
index.html
<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<h1>{title}</h1>
<p>{content}</p>
</body>
</html>
Lorsque vous démarrez le serveur et accédez à localhost: 8000, vous pouvez voir qu'il s'affiche comme suit.
Titre du blog
Contenu du blog
Réalisez la fonction de publication en soumettant un formulaire
Vous pouvez maintenant afficher la chaîne de caractères formatée en html, mais comme le blog a une fonction de publication et qu'il est supposé que vous pouvez voir la liste des articles, l'article suivant en utilisant des balises de formulaire HTML Implémentez la fonction. Réécrivez index.html comme suit.
index.html
<body>
<h1>{title}</h1>
<p>{content}</p>
<form method = 'POST' action="/result.html">
<textarea name="titlefield" id="titlefield" cols="30" rows="3" maxlength=15 placeholder="entrer le titre"></textarea><br>
<textarea name="contentfield" id="contentfield" cols="30" rows="10" placeholder="Entrez le contenu publié"></textarea><br>
<input type="submit"><br>
</form>
</body>
Changez la méthode de la balise de formulaire en "POST" et l'action en "résultat.html" pour afficher le résultat de la publication. Créez result.html pour afficher les résultats publiés.
result.html
<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<h1>{header}</h1>
<h2>{title}</h2>
<p>{content}</p>
<p><a href="{link}">Revenir à l'écran de publication</a></p>
</body>
</html>
Modifiez ensuite le programme serveur. Ajoutez une méthode do_POST () pour traiter les informations de formulaire soumises. Utilisez la classe FieldStorage du module cgi pour traiter la valeur soumise par le formulaire. FieldStorage est un objet qui gère les informations soumises dans le formulaire.
webserver.py
from cgi import FieldStorage
from http.server import HTTPServer, SimpleHTTPRequestHandler
with open('index.html', 'r') as f:
index_file = f.read()
with open('result.html', 'r') as f:
result_file = f.read()
class OriginalHTTPRequestHandler(SimpleHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.end_headers()
html = index_file.format(
header = 'Écran de publication',
title = 'Titre du Blog',
content = 'Contenu du blog'
)
self.wfile.write(html.encode('UTF-8'))
return None
def do_POST(self):
form = FieldStorage(
fp = self.rfile,
headers=self.headers,
environ={'REQUEST_METHOD':'POST'})
title_form = form['titlefield'].value
content_form = form['contentfield'].value
self.send_response(200)
self.end_headers()
html = result_file.format(
header = 'Résultat de publication',
title_message = 'Titre:',
content_message = 'Contenu publié:',
title = title_form,
content = content_form,
link = '/result.html'
)
self.wfile.write(html.encode('utf-8'))
return None
def run(server_class=HTTPServer, handler_class=OriginalHTTPRequestHandler):
server_address = ('', 8000)
httpd = server_class(server_address, handler_class)
httpd.serve_forever()
if __name__ == '__main__':
run()
Lorsque j'exécute le serveur et que j'accède à localhost: 8000 avec un navigateur, la balise «Form» est sortie.
Vous pouvez maintenant afficher les résultats publiés en appuyant sur le bouton Soumettre.
# Connectez-vous à la base de données
Cependant, si rien n'est fait, le titre et le contenu publié seront écrasés chaque fois que vous postez.
Une façon de résoudre ce problème consiste à enregistrer le contenu d'entrée de la balise Form dans un fichier texte ou dans la base de données, mais cette fois, nous l'enregistrerons dans la base de données.
La base de données qui peut être gérée par la bibliothèque standard de python est Sqlite3 ou DBM qui peut être gérée comme une opération de fichier, donc à partir de la prochaine fois, nous utiliserons Sqlite3 de RDB pour sauvegarder les données.
Matériel de référence
[^ 1]: Document officiel Python --- Serveur HTTP
Recommended Posts