avalanche

lawine is een Python web framework gebouwd op de top van webapp2 & nbsp;. Het maakt gebruik van Jinja2 als een standaard template systeem en niet omvat alle persistentie laag.
Avalanche doelen (of waarom een ​​andere web framework?)
Lawine ontwerp focus op testbaarheid en herbruikbaarheid.
Natuurlijk Avalanche doet geen wonderen doen. Testbaarheid en herbruikbaarheid zal uiteindelijk af van de applicatie code. Maar het raamwerk hebben een grote rol in het opzetten van de juiste weg.
De doelen zijn hieronder weergegeven, hopelijk na het lezen van het ontwerp en zelfstudie het zal u duidelijk zijn hoe deze doelen worden bereikt.
Testbaarheid
Avalanche is ontworpen op een manier die het maakt het mogelijk (voor u gemakkelijker) om goede unit-tests voor uw code te schrijven. Dat is niet alleen waardoor het gemakkelijk is om tests te schrijven. Een unit-test moet:
- Geef een duidelijke foutmelding als het niet lukt
- Niet alleen wanneer de functie te testen is gebroken, niet op elke wijziging van de code
- Snel zijn
Herbruikbaarheid
Meestal elke kader beweert dat herbruikbaarheid is een van hun doelstellingen uit het ontwerp. Hier "herbruikbaarheid" betekent source-code herbruikbaarheid.
Veel kaders bieden een aantal mechanismen voor herbruikbare / plugable sub-toepassingen is het echter niet altijd gemakkelijk om opnieuw te gebruiken deze toepassingen broncode voor het geval u nodig hebt om te configureren / wijzigen. Plugable toepassingen is ook een zeer belangrijk kenmerk maar vanaf nu Avalanche heeft geen ondersteuning voor.
Het moet niet alleen mogelijk zijn om herbruikbare code te schrijven, de code moet herbruikbaar op de eerste keer dat je het schrijven zijn. Je moet niet worden geadviseerd om de code te schrijven op één manier, en dan later hebben om het te wijzigen om het weer bruikbaar te maken. D.w.z. het is tegen zeggen "Gebruik view (handler) functies". En dan ... "als u wilt dat uw uitzicht te worden herbruikbaar ze converteren naar uitzicht-klasse gebaseerde!".
Project Details
- Website / docs
- Dit is een open-source project (MIT licentie) geschreven in python.
- Downloaden van PyPi
- Project management (bug tracker, feature requests en broncode) op BitBucket.
- Vragen en feedback op google groep.
Avalanche Ontwerp
Waarschuwing
Avalanche is op de vroege stadia van ontwikkeling (alpha). De API zou kunnen veranderen in de toekomst en er is geen garantie dat zal de compatibiliteit te houden.
voorbij MVC (model-view-controller)
MVC is een software architecturale patroon gemaakt met het doel om te isoleren "domain logica" van de gebruikersinterface. Deze scheiding van zorg maakt de creatie van een betere toepassing code. Dit patroon was zeer succesvol voor vele desktop kaders en dus diende als een verwijzing naar het creëren van web-frameworks. Het probleem is dat deze architectuur niet direct kunnen worden toegewezen aan de manier waarop web-applicaties werken.
Zelfs de zogenaamde MVC frameworks niet echt MVC. Dus laten we gewoon het doel van de MVC's te houden. Dat is om schone, herbruikbaar en toetsbaar code te schrijven.
webapplicaties
Wezen al een web-applicatie te doen is een HTTP-verzoek ontvangen, verwerken en het genereren van een HTTP response.
& Nbsp; + ------------------ +
HTTP Request ------> | webapplicatie + -----> HTTP Response
& Nbsp; + ------------------ +
Verzenden en ontvangen van HTTP wordt afgehandeld door een web-server. Laten we eens een kijkje in wat de webapplicatie doet:
& Nbsp; + ------ + + ------- +
HTTP request ----> | router | -----> | handler | ----> HTTP response
& Nbsp; + ------ + + ------- +
De router zal de URL van de aanvraag controleren en dit naar een behandelaar die de reactie zal maken. Avalanche gebruikt de webapp2 router.
behandelaar stijlen
Er zijn hoofdzakelijk 3 stijlen van de behandelaar.
- Een enkele functie
- Een klasse methode
- Een klas
Avalanche (en webapp2) maakt gebruik van de derde stijl, een klasse. Met een klasse als behandelaar past beter onze doelen omdat het een grotere flexibiliteit, makkelijker aan te passen / breiden en opnieuw te gebruiken delen van de geleider.
behandelaar verwerking
De behandelaar verwerking kan worden onderverdeeld in 3 fasen:
& Nbsp; + ----------------- + + ----------------- + + --------- - +
vragen ----> | param omzetter | ---- param objecten ----> | context builder | --- context -----> | renderer | ----> reactie
& Nbsp; + ----------------- + + ----------------- + + --------- - +
1. param converter - krijgen parameters van HTTP request
& Nbsp; HTTP is een tekst-protocol, zal de applicatie doorgaans nog wat parameters van het verzoek en zetten koordwaarden in een aantal inheemse soorten gegevens. Deze parameters zijn afkomstig uit de URI pad, URI-query, post-gegevens, cookies, etc.
2. context bouwer - verwerking
& Nbsp; Context is een term voor de gegevens die worden gebruikt door een renderer vertegenwoordigen.
& Nbsp; Deze verwerking is de applicatie logica. Het zal vaak toegang tot een persistentie laag (soms aangeduid als model), maar dit is geheel aan de applicatie code en het raamwerk heeft geen rol op dat.
& Nbsp; Een webpagina wordt vaak samengesteld uit verschillende elementen dus soms is het zinvol om het werk in meer dan een "context bouwer" verdelen.
3. renderer - output genereren
& Nbsp; De renderer zal het resultaat van de verwerking te zetten in tekst voor de HTTP respons. Deze fase kan worden overgeslagen als het antwoord een HTTP redirect. De renderer zal doorgaans gebruik maken van een template systeem om HTML-code te genereren of om te zetten van de gegevens naar JSON.
Op lawine moet je code voor de 3 fasen van de handler afzonderlijk schrijven en laat het kader lijm de verschillende onderdelen aan elkaar.
. Ga verder met de tutorial om te zien hoe het eruit ziet

Eisen

• Python