Bygningsudsigt i Flask

Inden for modellen eller udviklingsparadigmet, den foreslår KolbeEt af de vigtigste punkter er styringen af ​​visningerne, da disse giver os mulighed for at definere den måde, hvorpå brugeren vil interagere med vores side eller applikation.

Den enkleste måde at arbejde med en visning er ved at definere operationen direkte i definitionen af ​​dens vej, men dette er ikke altid nyttigt eller tilstrækkeligt, især hvis vi bygger store applikationer.

KravVi har brug for en funktionel installation af Kolbe og af kompatibilitetsgrunde har vi brug for en version, der er højere end den 0.7 da en af ​​de komponenter, som vi vil arbejde med, ikke var inkluderet i rammen før efter den nævnte version. Vi skal også starte en applikation eller have en applikation Kolbe så vi kan inkludere eksemplerne i visningsafsnittet og dermed kunne eksekvere dem via browser.

Rollebaserede visninger

Det er en af ​​de enkleste måder at opbygge interaktion med brugeren, vi behøver kun at skrive en funktion og dekorere den med ruten, dette gør, når routeren Kolbe modtager anmodningen, kontrollerer den, om der er en funktion, der venter på ruten, og hvis den får den, udfører den den.

Generelt kræver denne type visninger i det mindste metoden FÅ af HTTPSom en god praksis og af sikkerhedsmæssige årsager kan vi imidlertid også bruge metoden, hvis vi ønsker at tilføje værdier til vores data -persistensstruktur. STOLPE.

Oprettelse af en visning med GET

Vi vil oprette en visning ved hjælp af metoden FÅFor at gøre dette skal du blot definere dets navn i en funktion og tildele en rute til den, så inden for funktionen placerer vi vores indhold, lad os se følgende kode for at illustrere os selv.

 @ app.route ('/ view-get') def view (): value = request.args.get ('content', 'sample') return 'Dette er en visning, der bruger GET og modtager en værdi:% s'% værdi

I koden så ser vi, hvordan vi bruger dekoratør For at angive hvilken rute vi venter på, definerer vi den tilsvarende funktion, og inden for dette foretager vi et opkald med anmodning til argumenterne modtaget af FÅ, i dette tilfælde søger vi efter et argument kaldet indhold og tildeler det til en variabel kaldet værdi, hvis dette argument ikke findes, vil "prøve" blive placeret som standardværdi, og til sidst returnerer vi en tekst og sender værdiens indhold videre .

Hvis vi kører vores eksempel i browseren, får vi følgende:

Oprettelse af en visning med POST

Hvad sker der, hvis det, vi ønsker, er at modtage følsomme data, og vi ikke ønsker at videregive det via parametre i URL'en, for i disse tilfælde skal vi bruge POST -metoden, da det sender dataene skjult for brugerens visning, selvfølgelig er der er andre sikkerhedsforanstaltninger, som vi bør bruge, men i øjeblikket har vi ikke brug for dem til denne sag.

For at opbygge en visning, der modtager data via POST, skal du kun angive den forventede metode i dekoratør som modtager den rute, vi ønsker, til dette bruger vi den ekstra parameter metoder.

Så inden for vores funktion kan vi bruge anmodning For at opnå værdierne skal vi i modsætning til det foregående eksempel i stedet for at kræve argumenterne angive, at vi modtager værdierne fra en formular. Lad os se på koden for det, vi lige har forklaret.

 @ app.route ('/ post-view', methods = ['POST',]) def post_view (): value = request.form.get ('content', 'sample') return 'This is a view using POST og modtager en værdi:% s '% værdi

Vi kan bemærke, at det er næsten den samme kode som ovenfor bortset fra de allerede nævnte forskelle, men lad os se, hvad der sker, hvis vi kører vores kode direkte i vores browser:

FORSTØRRE

Hvordan angiver vi kun, at vi kan modtage metoden STOLPE, når adgang via FÅ vores ansøgning afviser posten og sender os derfor en kode 405 Metoden er ikke tilladt, så uden værdier, der kommer fra en POST -anmodning, viser denne visning ingen oplysninger.

Kombination af GET og POST i visningen

Da håndtering af forskellige visninger for hver metode ikke altid er det, vi ønsker, kan vi bruge begge metoder i samme visning, dette er meget nyttigt, især når vi vil behandle formularer, for eksempel med metoden FÅ vi viser formen og med STOLPE vi behandler forsendelsen af ​​det samme.

For at bruge denne tilstand skal vi kun tilføje FÅ på listen, som vi gik videre til metoder når du definerer dekoratør med stien, lad os se koden herunder:

 @ app.route ('/ view', methods = ['GET', 'POST',]) def view (): if request.method == "GET": return '' 'Show Views' '' else: value = request.form.get ('indhold', 'prøve') return 'Dette er en visning ved hjælp af GET og POST, der modtager en værdi:% s'% værdi

Når du kalder ruten fra browser med metode FÅ får vi følgende:

Så ved at skrive noget i tekstfeltet og trykke på Enter sender vi formularen til den samme sti, men med metoden STOLPE, hvilket giver os et resultat som følgende:

Her har vi så skrevet en sand funktionsbaseret visning, som giver os mulighed for at bruge og drage fordel af begge metoder til HTTP at udføre vores operationer.

Klassebaserede visninger

Da oprettelsen af ​​funktioner, selvom de tjener vores formål, undertiden er meget besværlig og egner sig til at have mere kode end nødvendigt, Kolbe gennemførte opkaldene klassebaserede visninger, et koncept han har lånt fra Django, og det giver os mulighed for at skrive klasser, som vi vil generere visninger med, disse klasser kan være generiske, som vi kan gøre arv til, hvis vi ønsker det.

For at bruge denne type komponent skal vi først importere fra kolbe.visninger, hvor klassen Udsigt Det er en generisk klasse, der giver os mulighed for at tilføje de grundlæggende funktionaliteter for at kunne sende ruter og definere metoder.

Oprettelse af vores klassebaserede opfattelse

I dette eksempel vil vi skabe den samme opfattelse, som vi gjorde i det foregående eksempel, men ud fra en klassebaseret tilgang, på denne måde kan vi fastslå forskellene mellem begge former, husk at selvom det ikke vises i eksempelkoden, vi har lavet importere i klassen View.

Lad os se på koden til vores eksempel:

 class ViewClass (View): methods = ['GET', 'POST',] def dispatch_request (self): if request.method == "GET": return '' 'Show Views' '' if request.method == " POST ": value = request.form.get ('content', 'sample') return 'Dette er en visning ved hjælp af GET og POST, der modtager en værdi:% s'% valorapp.add_url_rule ('/ view-class', view_func = VistaClase.as_view ('view-class'))

Dette er den mest grundlæggende form for denne visningsstil, men vi ser, at vi ikke længere er afhængige af dekoratør, hvad vi gør er at kalde metoden afsendelsesanmodning og vi passerede ham selv så det modtager sit samme objekt med dette, kan vi bestemme de anmodninger, vi modtager, så angiver vi, at vi vil modtage begge metoder, og endelig definerer vi vores adfærd, resultatet pr. browser vil være det samme som den forrige, vi vil have en feltet, og når vi sender det, modtager vi det angivne svar.

Men hvad nu hvis vi vil skrive meget renere kode? Til dette kan vi bruge klassen MethodView af Kolbe som giver os mulighed for at skabe metoder inden for klassen til at definere metoderne HTTP på en enklere måde.

Lad os se følgende eksempel, hvor vi omskriver den tidligere kode for at bruge denne tilstand:

 class ViewClass (MethodView): def get (self): return '' 'Show Views' '' def post (self): value = request.form.get ('content', 'sample') return 'This is a view using GET og POST, der modtager en værdi:% s '% valorapp.add_url_rule ('/ view-class ', view_func = ViewClass.as_view (' view-class '))

Som vi kan se, har vi undladt definitionen af ​​de metoder, vi vil modtage, derudover bruger vi ikke længere metoden afsendelse, vi definerer simpelthen, hvad vi vil gøre i metoden STOLPE, og hvad vi vil gøre i GET, hvilket giver meget mere rengøring af vores syn.

Der er stadig en debat om, at hvis det er bedre at rollebaserede synspunkter bølger klassebaseret, men der er virkelig ikke den ene bedre end den anden, der er simpelthen to måder at arbejde på, anbefalingen er, at hvis visningen er meget enkel, kan vi gøre det med funktioner, og hvis det allerede har en mere komplet logik, gør vi det med klasser .

Med dette har vi afsluttet denne vejledning, hvor vi har opbygget en vigtig base ved at vide, hvordan visninger fungerer, og hvordan vi kan arbejde med deres forskellige metoder HTTP, da dette er grundlaget, som vi kan bruge til at oprette mere avancerede applikationer.