Spring for lazy people Foundation, mga pangunahing konsepto, at mga halimbawa na may code. Bahagi 1

Sa artikulong ito, hindi ko sasabihin sa iyo kung paano mapapatakbo ang isang gumaganang proyekto sa Spring sa loob ng 5 minuto gamit ang aking code. Isusulat ko lang ang mga pangunahing kaalaman — mga bagay na maaaring hindi mo alam at gagawa ka pa rin ng proyekto. Ngunit sa artikulong ito, hindi mo pa rin mauunawaan kung ano ang nangyayari at, higit sa lahat, kung bakit.

Ano ang Spring Framework?

Ang Spring Framework, o simpleng Spring, ay isa sa pinakasikat na frameworks para sa paglikha ng mga web application sa Java. Ang isang balangkas ay tulad ng isang silid-aklatan (marahil ay mas pamilyar ka sa terminong ito), ngunit mayroong isang bagay na dapat isaalang-alang. Sa halos pagsasalita, kapag gumamit ka ng library, gagawa ka lang ng mga pagkakataon ng mga klase na nilalaman nito, tawagan ang mga pamamaraan na kailangan mo, at sa gayon ay makuha ang resulta na kailangan mo. Sa madaling salita, ito ay mas mahalagang diskarte: sa iyong programa, tahasan mong ipinapahiwatig ang partikular na sandali kung kailan kailangan mong lumikha kung aling bagay, kung kailan tatawagan kung aling partikular na paraan, atbp. Sa mga balangkas, ang mga bagay ay bahagyang naiiba. Sumulat ka lamang ng ilang mga klase sa iyong sarili at magsulat ng ilang lohika sa mga ito, ngunit pagkatapos ay ang balangkas mismo ay lumilikha ng mga pagkakataon ng iyong mga klase at tinatawag ang kanilang mga pamamaraan. Ang iyong mga klase ay karaniwang nagpapatupad ng ilang mga interface mula sa balangkas o namamana ng ilan sa mga klase nito, kaya nagbibigay sa iyo ng ilang functionality na naisulat na para sa iyo. Ngunit hindi ito palaging nangyayari. Halimbawa, sinusubukan ng Spring hangga't maaari upang maiwasan ang gayong mahigpit na pagkakabit (kung saan direktang nakasalalay ang iyong mga klase sa mga klase/interface sa balangkas). Gumagamit ito ng mga anotasyon upang makamit ito. Babalik tayo dito mamaya. Ngunit mahalagang maunawaan na ang Spring ay isang koleksyon lamang ng mga klase at interface na magagamit mo :) Gusto ko ring tandaan kaagad na ang Spring ay magagamit hindi lamang para sa mga web application, kundi pati na rin para sa mga pinakakaraniwang console program. na sobrang pamilyar sa ating lahat. At isusulat pa namin ang isa sa mga ito ngayon. kaya nagbibigay sa iyo ng ilang functionality na naisulat na para sa iyo. Ngunit hindi ito palaging nangyayari. Halimbawa, sinusubukan ng Spring hangga't maaari upang maiwasan ang gayong mahigpit na pagkakabit (kung saan direktang nakasalalay ang iyong mga klase sa mga klase/interface sa balangkas). Gumagamit ito ng mga anotasyon upang makamit ito. Babalik tayo dito mamaya. Ngunit mahalagang maunawaan na ang Spring ay isang koleksyon lamang ng mga klase at interface na magagamit mo :) Gusto ko ring tandaan kaagad na ang Spring ay magagamit hindi lamang para sa mga web application, kundi pati na rin para sa mga pinakakaraniwang console program. na sobrang pamilyar sa ating lahat. At isusulat pa namin ang isa sa mga ito ngayon. kaya nagbibigay sa iyo ng ilang functionality na naisulat na para sa iyo. Ngunit hindi ito palaging nangyayari. Halimbawa, sinusubukan ng Spring hangga't maaari upang maiwasan ang gayong mahigpit na pagkakabit (kung saan direktang nakasalalay ang iyong mga klase sa mga klase/interface sa balangkas). Gumagamit ito ng mga anotasyon upang makamit ito. Babalik tayo dito mamaya. Ngunit mahalagang maunawaan na ang Spring ay isang koleksyon lamang ng mga klase at interface na magagamit mo :) Gusto ko ring tandaan kaagad na ang Spring ay magagamit hindi lamang para sa mga web application, kundi pati na rin para sa mga pinakakaraniwang console program. na sobrang pamilyar sa ating lahat. At isusulat pa namin ang isa sa mga ito ngayon. Sinusubukan ng Spring hangga't maaari upang maiwasan ang gayong mahigpit na pagkakabit (kung saan direktang nakasalalay ang iyong mga klase sa mga klase/interface sa balangkas). Gumagamit ito ng mga anotasyon upang makamit ito. Babalik tayo dito mamaya. Ngunit mahalagang maunawaan na ang Spring ay isang koleksyon lamang ng mga klase at interface na magagamit mo :) Gusto ko ring tandaan kaagad na ang Spring ay magagamit hindi lamang para sa mga web application, kundi pati na rin para sa mga pinakakaraniwang console program. na sobrang pamilyar sa ating lahat. At isusulat pa namin ang isa sa mga ito ngayon. Sinusubukan ng Spring hangga't maaari upang maiwasan ang gayong mahigpit na pagkakabit (kung saan direktang nakasalalay ang iyong mga klase sa mga klase/interface sa balangkas). Gumagamit ito ng mga anotasyon upang makamit ito. Babalik tayo dito mamaya. Ngunit mahalagang maunawaan na ang Spring ay isang koleksyon lamang ng mga klase at interface na magagamit mo :) Gusto ko ring tandaan kaagad na ang Spring ay magagamit hindi lamang para sa mga web application, kundi pati na rin para sa mga pinakakaraniwang console program. na sobrang pamilyar sa ating lahat. At isusulat pa namin ang isa sa mga ito ngayon. ) Gusto ko ring tandaan kaagad na ang Spring ay maaaring gamitin hindi lamang para sa mga web application, kundi pati na rin para sa mga pinakakaraniwang console program na pamilyar sa ating lahat. At isusulat pa namin ang isa sa mga ito ngayon. ) Gusto ko ring tandaan kaagad na ang Spring ay maaaring gamitin hindi lamang para sa mga web application, kundi pati na rin para sa mga pinakakaraniwang console program na pamilyar sa ating lahat. At isusulat pa namin ang isa sa mga ito ngayon.

Istruktura

Ngunit ang Spring ay hindi lamang isang partikular na balangkas. Sa halip, ito ay isang karaniwang pangalan na ginagamit upang sumangguni sa ilang maliliit na balangkas, na ang bawat isa ay gumagawa ng sarili nitong uri ng gawain.

https://docs.spring.io/spring/docs/4.3.26.RELEASE/spring-framework-reference/htmlsingle/
Larawan 2.1. Pangkalahatang-ideya ng Spring Framework

Tulad ng nakikita mo, ang Spring ay modular. Hinahayaan kaming ikonekta lamang ang mga module na kailangan namin para sa aming aplikasyon at hindi ikonekta ang mga malinaw na hindi namin gagamitin. Sa pagkakaalam ko, ang diskarteng ito ang nagbigay-daan sa Spring na madaig ang kakumpitensya nito noon (EJB) at manguna. Ang mga application na gumagamit ng EJB ay nag-drag ng maraming dependencies sa likod nila, at bilang isang resulta, sila ay naging tamad at mabagal. Ipinapakita ng larawan na ang Spring Framework ay binubuo ng ilang mga module:

• Access sa Data
• Web
• Core
• at iba pa

Ngayon ay makikilala natin ang ilang konsepto na makikita sa pangunahing module: beans, konteksto, at iba pa. Tulad ng maaaring nahulaan mo, ang Data Access module ay naglalaman ng mga tool para sa pagtatrabaho sa data (pangunahin ang mga database), at ang Web module ay para sa pagtatrabaho sa isang network (kabilang ang paggawa ng mga web application, na tatalakayin sa ibang pagkakataon). Bilang karagdagan, mayroong isang komprehensibong imprastraktura na sumusuporta sa Spring: maraming iba pang mga proyekto na hindi opisyal na kasama sa mismong balangkas, ngunit walang putol na isinama sa iyong proyekto sa Spring (halimbawa, Spring Security, na inaasahan ko ring hawakan, ay para sa pagpapatunay ng isang gumagamit sa isang website).

Bakit may Spring Framework ang Java?

Buweno, bukod sa ito ay sunod sa moda, makinis, at sariwa, masasabi ko ngayon na sa sandaling makakuha ka ng kahit kaunting kasanayan sa paggamit ng Spring, mauunawaan mo kung paano mayroong lahat ng uri ng trabaho na wala ka na. gawin, at kung gaano karaming trabaho ang kailangan ng Spring. Maaari kang magsulat ng ilang dosenang linya ng mga setting ng pagsasaayos at magsulat ng ilang klase, at magtatapos ka sa isang gumaganang proyekto. Ngunit sa sandaling magsimula kang magtaka kung gaano karaming mga bagay ang nasa ilalim ng hood, gaano karaming trabaho ang ginagawa, at gaano karaming code ang kailangan mong isulat kung ipapatupad mo ang parehong proyekto batay sa mga plain servlet o socket at purong Java, ang iyong buhok ay tatayo :) Ang tagsibol ay inilarawan pa bilang isang uri ng mahika. Nararanasan mo ito kapag nakita mong gumagana ang lahat, ngunit mayroon ka ring magaspang na ideya kung paano at kung gaano karaming trabaho ang nangyayari sa likod ng mga eksena — kaya tila talagang mayroong ilang uri ng mahika na kumikilos :) Mas madaling tawagin itong magic kaysa subukang ipaliwanag kung paano magkakaugnay ang lahat. :) Ang pangalawang argumento na pabor sa pag-aaral ng Spring ay ang humigit-kumulang 90% ng mga bakanteng trabaho para sa mga junior developer (batay sa aking mga personal na obserbasyon) ay nangangailangan ng alinman sa kaalaman o hindi bababa sa isang pangkalahatang ideya kung ano ang Spring'sData, Web MVC, at Securitymga module ay nag-aalok ng mga sopistikadong developer :) Ngunit ngayon ay tungkol lamang sa mga pangunahing kaalaman.

DI/IoC

Kung sinubukan mong basahin ang tungkol sa Spring, malamang na ang unang bagay na nakatagpo mo ay ang mga acroynym na ito: DI/IoC. Ngayon, lubos kong inirerekomenda na magpahinga ka sa artikulong ito at basahin ang artikulong ito ng DZone ! Ang IoC ay nangangahulugang pagbabaligtad ng kontrol. Nabanggit ko na ito sa pagpasa noong isinulat ko na ang paggamit ng isang library ay nagsasangkot sa iyong sarili na nagpapahiwatig sa iyong code kung aling paraan ang tatawagan kung aling bagay, ngunit ang paggamit ng isang balangkas ay karaniwang nangangahulugan na ang balangkas ay tatawag sa iyong code sa tamang oras. Sa madaling salita, sa huling kaso na ito, hindi mo na pinamamahalaan ang proseso ng pagpapatupad ng code/program — ginagawa ito ng framework para sa iyo. Ipinasa mo ang kontrol sa balangkas (inversion of control). Ang DI ay kumakatawan sa dependency injection. Sa dependency injection, hindi ka gagawa ng mga bagay na pusa sa pangunahing pamamaraan at pagkatapos ay ipapasa ang mga ito sa iyong mga pamamaraan. Sa halip, nilikha ng Spring Framework ang mga ito para sa iyo. Magsasabi ka lang ng isang bagay tulad ng "Gusto kong makakuha ng pusa dito" at ang balangkas ay ipapasa sa iyo ang isa sa iyong pamamaraan. Makikita natin ang pagdadaglat na ito sa mga susunod na artikulo.

Beans at konteksto

Ang isa sa mga pangunahing konsepto sa Spring ay isang bean. Sa katunayan, ito ay isang bagay lamang ng ilang klase. Ipagpalagay na mayroon kaming isang programa na nangangailangan ng 3 bagay: isang pusa, isang aso, at isang loro. At mayroon kaming isang grupo ng mga klase na may isang grupo ng mga pamamaraan. Minsan kailangan natin ng pusa para sa isang pamamaraan, minsan kailangan natin ng aso para sa ibang pamamaraan, at kung minsan ang ating mga pamamaraan ay nangangailangan ng parehong pusa at loro (halimbawa, ang paraan ng pagpapakain sa pusa, ha-ha). Para sa iba pang mga pamamaraan, lahat ng tatlong bagay ay kailangan. Oo, maaari muna nating likhain ang tatlong bagay na ito sa pangunahing pamamaraan, at pagkatapos ay ipasa ang mga ito sa ating mga klase, at pagkatapos ay sa loob ng mga klaseng ito ipasa ang mga ito sa mga kaugnay na pamamaraan... At iba pa sa buong programa. Ngunit kung ipagpalagay din natin na paminsan-minsan ay gusto nating baguhin ang listahan ng mga parameter ng input para sa ating mga pamamaraan (halimbawa, nagpasya kaming muling isulat ang isang bagay o magdagdag ng bagong pag-andar), pagkatapos ay kailangan naming gumawa ng kaunting pagbabago sa code. At ngayon isipin na wala tayong 3, ngunit 300 tulad ng mga bagay. Ang isang alternatibo ay ang tipunin ang lahat ng aming mga bagay sa isang listahan (List<Object>), ipasa ito sa bawat pamamaraan, at pagkatapos ay kunin ang kinakailangang bagay habang nasa loob ng mga pamamaraan. Ngunit habang tumatakbo ang programa, paano kung ang ilang bagay ay idinagdag sa listahang ito, o mas masahol pa, paano kung ang isa ay tinanggal? Ito ay may potensyal na masira ang bawat paraan kung saan gumagamit kami ng isang index upang makakuha ng mga bagay mula sa listahan. Upang maiwasan ang problemang ito, nagpasya kaming iimbak ang aming mga bagay hindi sa isang listahan, ngunit sa isang mapa, kung saan ang susi ay ang pangalan ng bagay at ang halaga ay ang bagay mismo. Ito ay nagpapahintulot sa amin na makuha ang mga bagay na kailangan namin sa pamamagitan lamang ng paggamit ng kanilang pangalan, hal. get("parrot"), at bilang tugon ay nakuha namin ang parrot object. O ang susi ay maaaring ang klase ng bagay, at ang halaga ay maaaring ang bagay mismo. Sa kasong ito, sa halip na tukuyin ang pangalan ng bagay, ngunit maaari lamang tiyakin ang klase ng bagay na kailangan natin. Maginhawa din iyon. O maaari tayong magsulat ng ilang uri ng wrapper para sa mapa, kung saan ang ilang mga pamamaraan ay nakakakuha ng mga bagay ayon sa kanilang pangalan, at ang iba pang mga pamamaraan ay nakakakuha ng mga bagay ayon sa kanilang klase. Ang narating namin dito ay tinatawag na ankonteksto ng aplikasyon sa Spring Framework. Ang konteksto ay isang koleksyon ng mga beans (mga bagay). Ina-access namin ang isang konteksto upang makuha ang bean (bagay) na kailangan namin sa pamamagitan ng pangalan nito, sa uri nito, o sa iba pang paraan. Bukod pa rito, maaari naming hilingin sa Spring mismo na tingnan ang sarili nitong konteksto para sa bean na kailangan namin at ipasa ito sa aming pamamaraan. Halimbawa, ipagpalagay na mayroon kaming isang paraan tulad nito:

public void doSomething(Cat cat) {
    ...
}

Nang tinawag ng Spring ang pamamaraang ito, kinuha nito ang aming pusa object mula sa konteksto nito at ipinasa ito sa pamamaraan. Ngunit ngayon napagpasyahan namin na, bilang karagdagan sa isang pusa, ang aming pamamaraan ay nangangailangan din ng isang loro. Sa Spring, walang mas madali! Sumulat lang kami:

public void doSomething(Cat cat, Parrot parrot) {
    ...
}

Ngayon kapag tinawag ng Spring ang aming pamamaraan, naiintindihan nito ang pangangailangang ipasa ang isang pusa at isang loro, kaya pumunta ito sa konteksto nito, kunin ang dalawang bagay na ito, at ipasa ang mga ito sa aming pamamaraan. Sa pamamagitan ng paglipat ng mga renda ng kontrol sa Spring, inililipat din namin ang responsibilidad para sa paglikha ng mga bagay at pagpasa sa mga ito sa aming mga pamamaraan, na tatawagin ng Spring. Nagtatanong ito: paano nalalaman ng Spring kung aling mga bagay (beans) ang lilikhain?

Mga paraan upang i-configure ang isang application

Mayroong tatlong pangunahing paraan upang i-configure ang isang application , iyon ay, mga paraan upang sabihin nang eksakto sa Spring kung aling mga bagay ang kailangan namin:

1. XML configuration file
2. Java-based na configuration
3. awtomatikong pagsasaayos

Ang mga tagalikha ng Spring ay nagbibigay-priyoridad sa kanila sa ganitong pagkakasunud-sunod:

• ang pamamaraan na may pinakamataas na priyoridad, na dapat na mas gusto, ay awtomatikong pagsasaayos
• kung ang awtomatikong pagsasaayos ay hindi magagamit upang wastong i-configure ang lahat ng posibleng beans, gamitin ang Java-based na configuration (na kinabibilangan ng paglikha ng mga bagay gamit ang Java code)
• at ang pinakamababang priyoridad na paraan ay ang makalumang paraan — gamit ang mga XML config file.

Hinahayaan din tayo ng Spring na pagsamahin ang mga pamamaraang ito. Halimbawa, hayaan ang Spring na i-configure ang lahat ng maaaring awtomatikong i-configure, gamitin ang Java-based na configuration kung saan mo kailangan ng mga espesyal na parameter, at gumamit ng XML para sa anumang legacy na configuration. Ang lahat ng ito ay gumagana upang maging lubos na nababaluktot. Gayunpaman, kung awtomatikong mai-configure ang lahat, piliin ang opsyong iyon. Isasaalang-alang ko lamang ang awtomatikong pagsasaayos at pagsasaayos na nakabatay sa Java. Ang mga XML config ay ginagamit sa halos bawat halimbawa ng Spring sa Internet. Higit pa, kapag naunawaan mo kung paano gumagana ang configuration na nakabatay sa Java, dapat ay wala kang problema sa pagbabasa ng XML file na gumagawa ng parehong bagay. Ginagamit ang awtomatikong pagsasaayos kapag kailangan nating magtrabaho sa mga bagay ng mga klase na isinulat namin. Kung ang paglikha ng isa sa aming mga bagay ay nangangailangan ng ilang partikular na lohika, o kung hindi kami makagawa ng ilang klase na may anotasyong kinakailangan para sa awtomatikong pagsasaayos, maaari naming gamitin ang Java-based na configuration para gawin ang kailangang gawin. Nasasa susunod na bahagi , gagawa kami ng isang proyekto ng Maven, ikonekta ang isang pares ng mga pangunahing module ng Spring, at gagawa ng aming mga unang beans.