[PYTHON] Grundlegende Verwendung von Flask-Classy

Was ist in diesem Artikel zu tun?

• Grundlegende Verwendung von Flask-Classy

In diesem Artikel nicht behandelt

• Verwendung der Flasche
• Handhabung von Endpunkten in Kolbenklasse
• Zuordnung mehrerer Routen zu einer Methode in Flask-Classy
• Wie man mit Subdomains in Flask-Classy umgeht

Die folgenden Artikel werden nicht regelmäßig mit flask-classy geschrieben, sondern während des Studiums nach Bedarf. Wenn Sie Fehler finden, senden Sie bitte eine Bearbeitungsanfrage oder weisen Sie in den Kommentaren darauf hin. Vielen Dank.

Was ist flaschenklasse

Eines der leichtgewichtigen Web-Frameworks, die in Python verfügbar sind, ist flask.

Wenn Sie flask verwenden, erstellen Sie normalerweise eine Anwendung mit Dekoratoren und Funktionen. Wenn Sie jedoch versuchen, eine große Webanwendung über mehrere Dateien hinweg zu erstellen, verwenden Sie einen Typ namens Blueprint. Du musst mit Gonyo Gonyo spielen.

Flask-Classy kann eine einheitliche Routing-Methode einführen, ohne sich damit herumschlagen zu müssen.

Offizielle Seite

https://pythonhosted.org/Flask-Classy/

Ich werde es grob unter Bezugnahme auf die obige Seite beschreiben.

Installation

pip install flask-classy

Mindestverbrauch

1. Erstellen Sie eine Instanz der Flask-Klasse gemäß der normalen Verwendung von flask
2. Erstellen Sie eine Klasse, die FlaskView erbt.
3. ** Verwenden Sie die Klassenmethode `` `register``` der erstellten Klasse mit einer Instanz der Flask-Klasse als Argument **
4. Starten Sie die Anwendung

from flask import Flask
from flask.ext.classy import FlaskView

app = Flask(__name__)

class HelloView(FlaskView):
    def index(self):
        return "hello world"

HelloView.register(app)

if __name__ == '__main__':
    app.run()

Wenn Sie die obige Datei über die Befehlszeile starten, sollten Sie auf `localhost: 5000 / hello``` zugreifen und die Zeichenfolge` hello world``` sehen können.

Bitte beachten Sie, dass der Prozess der Registrierung von "3" in den folgenden Beispielen übersprungen wird.

Routing- und Namenskonventionen

Klassennamenkonvention

flaskviewFür Klassennamen, die von erben, als SuffixviewKann verwendet werden.

helloviewDie URL entspricht/hello/Es wird sein.

"Es kann verwendet werden", so dass es kein Problem gibt, auch wenn Sie kein Suffix verwenden

flaskviewVererbthelloSelbst wenn Sie eine Klasse erstellen, lautet die entsprechende URL/hello/Es wird sein.

Namenskonvention für Methoden

Obwohl es in der minimalen Verwendung aufgetreten ist, sind die folgenden Methoden vorbestimmt, um in den Klassen weitergeleitet zu werden, die von FlaskView erben.

Zusätzlich zu den üblichen Python-Namenskonventionen werden in FlaskView die folgenden Methodennamen verwendet und sollten vermieden werden.

• build_route_name
• build_rule
• decorators
• get_route_base
• make_proxy_method
• parse_options
• register
• route_base
• route_prefix
• trailing_slash

Auf andere Methodennamen als die oben genannten kann wie folgt zugegriffen werden.

Es sind auch einige andere spezielle Methodennamen definiert.

Lebenszyklus

1. @app.before_request
2. class.before_request
3. class.before_ Zielmethode
4. Klasse. Zielmethode
5. class.after_ Zielmethode
6. class.after_request
7. @app.after_request

Wird in der Reihenfolge von sein

Routing überschreiben

Die URL wird durch den Klassennamen und den Funktionsnamen bestimmt. Hier sind jedoch einige Maßnahmen, um dies zu vermeiden.

Überschreiben Sie das Routing vom Klassennamen

Es gibt zwei Möglichkeiten

Deklarieren Sie `` `route_base``` als Klassenvariable

class HelloView(FlaskView):
    route_base='/'

Übergeben Sie `` `route_base```, um sich als Argument zu registrieren

HelloView.register(app, route_base='/')

Beide oben genannten überschreiben `/ hello```, was aus dem Klassennamen definiert werden sollte, und machen es mit` / `` `zugänglich.

Methodenrouting überschreiben

Dies ist eine Möglichkeit

from flask.ext.classy import FlaskView, route

class HelloView(FlaskView):
	@route('/hoge/')
    def index(self):
        return 'hello'

Wie oben erwähnt, verwenden Sie für die Methode der Klasse, die `FlaskView``` erbt,` route, definiert in `` `flask.ext.classy Sie können das Routing überschreiben, indem Sie es dekorieren.

Im Fall des obigen Beispiels kann darauf zugegriffen werden, wenn die URL `/ hello / hoge /` lautet.

HTTP-Methode

flask.ext.Die classsy route kann genau die gleichen Argumente wie die flask route annehmen.

 ** Wie bei einem normalen Kolben können Sie nur durch Definieren von Methoden und Routing GET-Zugriff erhalten. ** **.

 Wenn Sie eine andere http-Methode als GET hinzufügen möchten, übergeben Sie eine Liste mit dem Namen `` `Methoden``` an das Argument` `` @ route```.

 Derzeit scheint es, dass jede Zeichenfolge zum Element der Liste gelangen kann (Überprüfung erforderlich), aber ich denke, dass dies in Ordnung, aber nicht rentabel ist.
 Lassen Sie uns eine normale HTTP-Methode einfügen.


 Unten ist ein Beispiel.


```python3
from flask.ext.classy import FlaskView, route

class HelloView(FlaskView):
	@route('/index/', methods=['GET','POST'])
    def index(self):
        return 'hello'

Wie oben erwähnt, können Sie durch Hinzufügen von `` `Methoden``` mit der entsprechenden HTTP-Methode zugreifen.