Implementieren Sie eine einfache Anwendung mit Python Full Scratch ohne Verwendung eines Webframeworks.
Einführung
Es ist jetzt einfacher, Web-Apps mit Web-Frameworks wie Django und Flask zu entwickeln, aber es ist nicht wirklich sinnvoll, nur zu lernen, wie man das Framework verwendet, ohne die Wurzeln zu verstehen. Ich beschloss, den Mechanismus zu verstehen, indem ich eine einfache Blog-App implementierte, die nur die in Python integrierten Funktionen und Standardbibliotheken verwendete, ohne das Webframework zu verwenden.
Erstellen einer Indexseite
Da der Webserver beim Zugriff über einen Webbrowser etwas zurückgibt (anzeigt), erstellen Sie die Indexseite, die zuerst in HTML angezeigt werden soll. Ich habe eine Indexseite erstellt, die Hello, World! Ausgibt.
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>
Erstellen eines HTTP-Servers
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 ist eine der Standardbibliotheken von Python zur Implementierung von Webserverfunktionen. Geben Sie in den HTTP-Server-Argumenten den Servernamen und die Portnummer an. Geben Sie als Test als Argument des HTTP-Servers zunächst den Servernamen (Standard ist localhost), die Portnummer (Identifikationsnummer des Zugriffsprogramms) 8000 und einen der Anforderungshandler an, der Anforderungen von Clients verwaltet Wir haben zwei SimpleHTTPRequestHandler angegeben (einfache Klassen, die Dateien zurückgeben, die dem Clientzugriff entsprechen).
Starten Sie den HTTP-Server
Terminal
$ python webserver.py
Wenn ich mit einem Browser auf localhost: 8000 zugreife, wird "Hello, World" ausgegeben.
Hinweise zum HTTP-Server
Wenn Sie sich auf die offizielle Dokumentation [^ 1] beziehen, wird gewarnt, dass sie nicht für die kommerzielle Nutzung von http.server geeignet ist.
Warnung http.server wird für die Produktion nicht empfohlen. Es werden nur grundlegende Sicherheitsüberprüfungen implementiert.
Da der eingebaute Server langsam ist und der Last nicht standhalten kann, wird häufig eine Webserveranwendung wie Apache oder Nginx für den kommerziellen Gebrauch verwendet. Dieses Mal besteht der Zweck darin, den Mechanismus der Webanwendung zu verstehen und zu implementieren, sodass wir den integrierten Server so verwenden, wie er ist.
Ändern Sie die Verarbeitung des Request-Handlers
Auf dem zuvor im Test ausgeführten HTTP-Server wurde SimpleRequestHandler als Anforderungshandler angegeben. Dies war jedoch ein Prozess, der nur index.html zurückgab. Als Nächstes fügen wir unseren eigenen Prozess hinzu.
Überschreiben Sie die do_GET-Methode mit der Möglichkeit, formatierte Zeichenfolgen in HTML in SimpleRequestHandler anzuzeigen. Erstens führt die Methode do_GET eine Verarbeitung durch, z. B. das Zurückgeben einer HTTP-Antwort und das Zurückgeben der entsprechenden Datei.
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 = 'Blog Titel',
content = 'Inhalt des Blogs'
)
self.wfile.write(html.encode('utf-8'))
return None
Korrigieren Sie den Teil, in dem "Hallo Welt" bisher in der HTML-Datei fest codiert war.
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>
Wenn Sie den Server starten und auf localhost: 8000 zugreifen, sehen Sie, dass er wie folgt angezeigt wird.
Blogtitel
Blog-Inhalt
Verwirklichen Sie die Buchungsfunktion, indem Sie ein Formular senden
Jetzt können Sie die formatierte Zeichenfolge in HTML anzeigen. Da das Blog jedoch über eine Posting-Funktion verfügt und davon ausgegangen wird, dass Sie die Postliste sehen können, wird der nächste Post mit dem HTML-Formular-Tag angezeigt Implementieren Sie die Funktion. Schreiben Sie index.html wie folgt um.
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="Titel eingeben"></textarea><br>
<textarea name="contentfield" id="contentfield" cols="30" rows="10" placeholder="Geben Sie den geposteten Inhalt ein"></textarea><br>
<input type="submit"><br>
</form>
</body>
Ändern Sie die Methode des Formular-Tags in "POST" und die Aktion in "result.html", um das Buchungsergebnis anzuzeigen. Erstellen Sie result.html, um die veröffentlichten Ergebnisse anzuzeigen.
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}">Kehren Sie zum Buchungsbildschirm zurück</a></p>
</body>
</html>
Ändern Sie dann das Serverprogramm. Fügen Sie eine do_POST () -Methode hinzu, um die übermittelten Formularinformationen zu verarbeiten. Verwenden Sie die FieldStorage-Klasse des CGI-Moduls, um den vom Formular übermittelten Wert zu verarbeiten. FieldStorage ist ein Objekt, das die im Formular übermittelten Informationen verwaltet.
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 = 'Bildschirm posten',
title = 'Blog Titel',
content = 'Inhalt des Blogs'
)
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 = 'Buchungsergebnis',
title_message = 'Titel:',
content_message = 'Geposteter Inhalt:',
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()
Wenn ich den Server starte und mit einem Browser auf localhost: 8000 zugreife, wird das Formular-Tag ausgegeben.
Sie können jetzt die veröffentlichten Ergebnisse anzeigen, indem Sie auf die Schaltfläche "Senden" klicken.
# Stellen Sie eine Verbindung zur Datenbank her
Der Titel und der veröffentlichte Inhalt werden jedoch bei jedem Beitrag überschrieben.
Eine Möglichkeit, dieses Problem zu lösen, besteht darin, den Eingabeinhalt des Formular-Tags in einer Textdatei oder in der Datenbank zu speichern. Dieses Mal werden wir ihn jedoch in der Datenbank speichern.
Die Datenbank, die von der Standardbibliothek von Python verwaltet werden kann, ist Sqlite3 oder DBM, die wie eine Dateioperation behandelt werden kann. Ab dem nächsten Mal werden Daten mit Sqlite3 von RDB gespeichert.
Referenzmaterial
[^ 1]: offizielles Python-Dokument --- HTTP-Server
Recommended Posts