avalanche

avalanche ay isang Python web framework na binuo sa tuktok ng webapp2 & nbsp;. Gumagamit ito Jinja2 bilang isang sistema ng default na template at hindi kasama ang anumang layer pagtitiyaga.
layunin ng avalanche (o kung bakit ang isa pang web framework?)
Ang avalanche ay focus sa disenyo sa testability at reusability.
Siyempre avalanche ay hindi gawin himala. Testability at reusability habilin sa huli ay depende sa application code. Ngunit sa balangkas ay may isang malaking papel sa pag-set ang tamang path.
Ang layunin ay ipinakita sa ibaba, sana ay matapos basahin ang disenyo at tutorial ito ay maging malinaw sa iyo kung paano ang mga layuning ito ay nakamit.
Testability
Ang avalanche ay idinisenyo sa isang paraan na ginagawang posible (mas madali para sa iyo) na magsulat ng mahusay na unit-pagsusulit para sa iyong code. Iyon ay hindi gumagawa lamang itong mas madali upang isulat ang mga pagsusulit. Ang isang yunit-ng pagsubok ay dapat na:
- Bigyan ng malinaw na mensahe ng error kapag nabigo ito
- Mabibigo lamang kapag ang tampok sa ilalim ng pagsubok ay sira, hindi sa bawat pagbabago ng code
- Maging mabilis
Reusability
Kadalasa'y bawat balangkas ang sinasabing na reusability ay isa sa kanilang mga layunin sa disenyo. Narito "reusability" ay nangangahulugang pinagmumulan-code reusability.
Maraming Framework magbigay ng ilang mga mekanismo para sa muling nagagamit / plugable sub-application gayunpaman ito ay hindi laging madali upang muling gamitin ang mga mapagkukunan ng application code kung kailangan mong i-configure / baguhin ito. Plugable application ding napakahalaga tampok ngunit bilang ng ngayon avalanche ay walang suporta para sa mga iyon.
Dapat ito ay hindi lamang na posible na magsulat ng code magagamit muli, ay dapat na magagamit muli sa unang pagkakataon isulat mo ito sa code. Hindi mo dapat malaman upang isulat ang code na ito sa isang paraan, at sa ibang pagkakataon ay may upang baguhin ito upang gawin itong magagamit muli. Ibig sabihin ito ay sumasalungat sa pagsasabi ng "Gamitin ang view (handler) function". At sa ... "kung nais mo ang iyong mga tanawin sa muling nagagamit convert ang mga ito sa mga tanawin ng klase-based na!".
Mga Detalye Project
- Website / doc
- Ito ay isang open-source na proyekto (MIT lisensya) na nakasulat sa python.
- I-download mula sa PyPi
- (Bug tracker, mga hiling sa tampok at ang source code) ng pamamahala ng proyekto sa bitbucket.
- Mga Tanong at feedback sa google group.
Ang avalanche Design
Babala
Ang avalanche ay nasa maagang yugto ng pag-unlad (alpha). Ang API ay maaaring magbago sa hinaharap at walang kasiguruhan ito ay panatilihin ang pagkakatugma.
lampas MVC (modelo-view-controller)
MVC ay isang software na pang-arkitektura pattern na nilikha gamit ang layunin upang ihiwalay "na domain logic" mula sa user interface. Ang paghihiwalay ng pag-aalala ay nagbibigay-daan sa paglikha ng mas mahusay na application code. Pattern na ito ay lubos na matagumpay para sa maraming mga desktop Framework at kaya nagsilbi bilang isang sanggunian sa paggawa ng web-Framework. Ang problema ay na arkitektura na ito ay hindi maaaring mai-map nang direkta sa paraan ng trabaho web-application.
Kahit na ang tinatawag na Framework MVC ay hindi talaga MVC. Kaya sabihin magpatuloy lang sa layunin ng MVC iyon. Iyon ay sumulat ng malinis, muling nagagamit at testable code.
web application
Mahalaga ang lahat ng web-application gawin ay upang makatanggap ng isang HTTP na kahilingan, ito proseso at bumuo ng isang tugon ng HTTP.
& Nbsp; + ------------------ +
HTTP Request ------> | web application + -----> HTTP Tugon
& Nbsp; + ------------------ +
Pagpapadala at pagtanggap ng HTTP ng paghawak sa pamamagitan ng isang web-server. Tingnan natin ang isang mas malapitan naming tingnan sa kung ano ang ginagawa ng mga web application:
& Nbsp; + ------ + + ------- +
Kahilingan ng HTTP ----> | router | -----> | handler | ----> HTTP response
& Nbsp; + ------ + + ------- +
Router ay lagyan ng check ang URL ng kahilingan at pahatid ito sa isang humahawak ng kahilingan na lumikha ng mga tugon. Ang avalanche ay gumagamit ng webapp2 router.
tagapangasiwa ng kahilingan estilo
Mayroong higit sa lahat 3 mga estilo ng mga handler kahilingan.
- Isang solong pag-andar
- Isang paraan ng klase
- Isang klase
Avalanche (at webapp2) ay gumagamit ng mga third estilo, isang klase. Paggamit ng isang mas mahusay na klase bilang nababagay sa handler kahilingan ng aming mga layunin dahil nagbibigay ito ng isang mas malawak na kakayahang umangkop, mas madaling baguhin / pahabain at mga bahagi ng handler gamiting muli.
hiling na handler pagpoproseso
Ang tagapangasiwa ng kahilingan sa pagpoproseso ay maaaring hinati sa 3 bahagi:
& Nbsp; + ----------------- + + ----------------- + + --------- - +
humiling ----> | param converter | ---- param bagay ----> | konteksto tagabuo | --- konteksto -----> | renderer | ----> tugon
& Nbsp; + ----------------- + + ----------------- + + --------- - +
1. param converter - makakuha ng mga parameter mula sa HTTP na kahilingan
& Nbsp; HTTP ay isang teksto ng protocol, ay karaniwang makuha ang application ng ilang mga parameter mula sa kahilingan at i-convert ang mga halaga ng string sa ilang mga katutubong uri ng data. Mga parameter na ito ay nakuha mula sa URI path, URI ng query, post-data, cookies, atbp
2. tagabuo ng konteksto - sa pagpoproseso ng
& Nbsp; ang konteksto ng terminong ginamit ginamit upang kumatawan sa data na gagamitin sa pamamagitan ng isang taga-render.
& Nbsp; pagpoproseso Ito ang application logic. Ito ay madalas na i-access ang isang pagtitiyaga layer (tinatawag minsan na Modelo) ngunit ito ay ganap na nakasalalay sa application code at sa balangkas ay walang papel sa na.
& Nbsp; Ang isang web page ay madalas na binubuo ng ilang mga elemento sa gayon minsan ang may katuturan na hatiin ang trabaho sa higit sa isang "tagabuo ng konteksto".
3. taga-render - bumuo ng output
& Nbsp; magko-convert na taga-render ang mga resulta ng pagproseso sa teksto para sa HTTP response. Maaaring lampasan ng hakbang na ito kung ang sagot ay isang HTTP pag-redirect. Renderer ay tipikal na gumamit ng isang sistema ng template na ito upang bumuo ng HTML code o-convert ang data sa JSON.
Sa avalanche ay dapat isulat sa iyo ang code para sa 3 na antas ng handler hiwalay at ipaalam sa balangkas ng kola ang iba't ibang mga bahagi nang sama-sama.
. Umusad sa ang tutorial upang makita kung ano ang hitsura nito tulad ng

Mga Kinakailangan :

• Python