Ang tagsibol ay para sa mga tamad. Mga pangunahing kaalaman, pangunahing konsepto at mga halimbawa na may code. Bahagi 2

Sa huling artikulo , ipinaliwanag ko sa maikling salita kung ano ang tagsibol, kung ano ang mga bin at konteksto. Ngayon ay oras na upang subukan kung paano gumagana ang lahat. Ako mismo ang gagawa nito sa Intellij Idea Enterprise Edition. Ngunit lahat ng aking mga halimbawa ay dapat ding gumana sa libreng Intellij Idea Community Edition. Kung nakikita mo sa mga screenshot na mayroon akong ilang uri ng window na wala ka, huwag mag-alala, hindi ito kritikal para sa proyektong ito :) Una, gumawa tayo ng walang laman na proyekto ng Maven. Ipinakita ko kung paano gawin ito sa artikulo (basahin hanggang sa mga salitang " Oras na para gawing web project ang aming maven project. ", pagkatapos nito ay ipinapakita na nito kung paano gumawa ng web project, at hindi na namin ito kailangan ngayon) Gawin natin ito sa src/main folder /java ay ilang pakete (sa aking kaso tinawag ko itong " ru.javarush.info.fatfaggy.animals", maaari mo itong pangalanan kahit anong gusto mo, huwag kalimutang palitan ito ng iyong pangalan sa mga tamang lugar). At gumawa tayo ng klase Mainkung saan gagawa tayo ng paraan

public static void main(String[] args) {
    ...
}

Pagkatapos ay buksan ang pom.xml file at magdagdag ng isang seksyon doon dependencies. Pumunta kami ngayon sa repositoryo ng Maven at hanapin ang konteksto ng tagsibol ng pinakabagong stable na bersyon doon, at i-paste ang nakuha namin sa loob ng seksyon dependencies. Inilarawan ko ang prosesong ito nang mas detalyado sa artikulong ito (tingnan ang seksyong " Pagkonekta ng mga dependency sa Maven "). Pagkatapos Maven mismo ay mahahanap at i-download ang mga kinakailangang dependencies, at sa huli ay dapat kang makakuha ng isang bagay na tulad nito: Sa kaliwang window makikita mo ang istraktura ng proyekto kasama ang package at klase Main. Ipinapakita ng gitnang window kung ano ang hitsura ng aking pom.xml. Nagdagdag din ako ng isang seksyon ng mga pag-aari doon , kung saan ipinahiwatig ko kay Maven kung aling bersyon ng Java ang ginagamit ko sa source code at kung aling bersyon ang isasama. Ito ay para lamang hindi ko makuha ang ideya ng isang babala kapag nagsimula na ang isang lumang bersyon ng Java ay ginagamit. Magagawa mo ito, hindi mo magagawa) Sa kanang window - makikita mo na kahit na ikinonekta lang namin ang konteksto ng tagsibol - awtomatiko itong nagdagdag ng core, beans, aop at expression. Posibleng ikonekta ang bawat module nang hiwalay, na nagrerehistro ng dependency para sa bawat isa sa memorya na may tahasang indikasyon ng bersyon, ngunit sa ngayon ay masaya kami sa opsyon na ito ngayon. Ngayon gumawa tayo ng isang pakete entities(mga entidad) at lumikha ng 3 klase dito: Cat, Dog, Parrot. Hayaan ang bawat hayop na magkaroon ng isang pangalan ( private String name, maaari mong i-hardcode ang ilang mga halaga doon), at ang mga getter/setters ay pampubliko. Pumunta ngayon sa klase Mainat main()sumulat ng ganito sa pamamaraan:

public static void main(String[] args) {
	// create an empty spring context that will search for its beans by annotations in the specified package
	ApplicationContext context =
		new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals.entities");

	Cat cat = context.getBean(Cat.class);
	Dog dog = (Dog) context.getBean("dog");
	Parrot parrot = context.getBean("parrot-kesha", Parrot.class);

	System.out.println(cat.getName());
	System.out.println(dog.getName());
	System.out.println(parrot.getName());
}

Una, lumikha kami ng isang bagay sa konteksto, at sa tagabuo ay binibigyan namin ito ng pangalan ng pakete na kailangang i-scan para sa pagkakaroon ng mga beans. Ibig sabihin, dadaan si Spring sa package na ito at susubukang maghanap ng mga klase na minarkahan ng mga espesyal na anotasyon na nagpapaalam kay Spring na ito ay isang bean. Pagkatapos nito ay lumilikha ito ng mga bagay ng mga klase na ito at inilalagay ang mga ito sa konteksto nito. Pagkatapos nito ay nakakakuha kami ng pusa mula sa kontekstong ito. Kapag tinutugunan ang object ng konteksto, hinihiling namin na bigyan kami ng isang bean (object), at ipahiwatig kung anong klase ng object ang kailangan namin (dito, sa pamamagitan ng paraan, maaari mong tukuyin hindi lamang ang mga klase, kundi pati na rin ang mga interface). Pagkatapos kung saan ang Spring ay nagbabalik ng isang bagay ng klase na ito sa amin, na ise-save namin sa isang variable. Susunod, hinihiling namin kay Spring na kumuha kami ng bean na tinatawag na "aso". Kapag ang Spring ay lumikha ng isang object ng klase, Dogbibigyan ito ng isang karaniwang pangalan (kung ang pangalan ng bean na nilikha ay hindi tahasang tinukoy), na kung saan ay ang pangalan ng klase ng object, na may maliit na titik lamang. Samakatuwid, dahil ang aming klase ay tinatawag na Dog, ang pangalan ng naturang bean ay magiging "aso". Kung mayroon kaming isang bagay doon BufferedReader, bibigyan ito ng Spring ng default na pangalan na "bufferedReader". At dahil sa kasong ito (sa Java) walang eksaktong katiyakan kung anong klase ang magiging object, ibinabalik lang nito ang isang tiyak Object, na kung saan manu-mano naming inihagis sa uri na kailangan namin Dog. Ang opsyon na may tahasang indikasyon ng klase ay mas maginhawa. Well, sa pangatlong kaso, nakakakuha tayo ng bean ayon sa klase at pangalan. Maaaring mayroong isang sitwasyon kung saan sa konteksto ay magkakaroon ng ilang mga beans ng isang klase, at upang ipahiwatig kung aling partikular na bean ang kailangan namin, ipinapahiwatig namin ang pangalan nito. Dahil malinaw din naming ipinahiwatig ang klase dito, hindi na namin kailangang mag-cast. Mahalaga!Kung lumabas na ang Spring ay nakahanap ng ilang beans ayon sa mga kinakailangan na tinukoy namin dito, hindi nito matutukoy kung aling bean ang ibibigay sa amin at magtatapon ng exception. Samakatuwid, subukang ipahiwatig sa kanya nang tumpak hangga't maaari kung aling bin ang kailangan mo, upang ang mga ganitong sitwasyon ay hindi lumitaw. Kung ang Spring ay hindi makahanap ng isang solong bean sa konteksto nito ayon sa iyong mga kondisyon, ito ay magtapon din ng isang pagbubukod. Kaya, ipinapakita lang namin ang mga pangalan ng aming mga hayop sa screen upang matiyak na ang mga ito ay talagang eksaktong mga bagay na kailangan namin. Ngunit kung patakbuhin natin ang programa ngayon, makikita natin na ang Spring ay sumusumpa na hindi nito mahanap ang mga hayop na kailangan natin sa konteksto nito. Nangyari ito dahil hindi niya nilikha ang mga beans na ito. Gaya ng nasabi ko na, kapag nag-scan ng mga klase ang Spring, hinahanap nito ang mga "nito" na anotasyon ng Spring doon. At kung hindi niya ito mahanap, hindi nito nakikita ang mga klase tulad ng mga beans na kailangan niyang likhain. Para ayusin ito, magdagdag lang ng anotasyon @Componentsa harap ng klase sa aming mga klase ng hayop.

@Component
public class Cat {
	private String name = "Barsik";
	...
}

Ngunit hindi lang iyon. Kung kailangan nating tahasang ipahiwatig sa Spring na ang bean para sa klase na ito ay dapat magkaroon ng isang partikular na pangalan, ang pangalang ito ay maaaring ipahiwatig sa mga panaklong pagkatapos ng anotasyon. Halimbawa, upang maibigay ng Spring ang pangalan na kailangan natin sa parrot-keshaparrot bean, kung saan mainmatatanggap natin ang loro na ito, kailangan nating gawin ang isang bagay tulad nito:

@Component("parrot-kesha")
public class Parrot {
	private String name = "Kesha";
	...
}

Ito ang buong punto ng awtomatikong pagsasaayos . Isusulat mo ang iyong mga klase, markahan ang mga ito ng kinakailangang mga anotasyon, at ipahiwatig sa Spring ang isang pakete kasama ng iyong mga klase, kung saan ito napupunta, naghahanap ng mga anotasyon at lumilikha ng mga bagay ng naturang mga klase. Siyanga pala, maghahanap ang Spring hindi lamang sa mga anotasyon @Component, kundi pati na rin sa lahat ng iba pang anotasyon na minana mula sa isang ito. Halimbawa, @Controller, @RestController, @Service, @Repositoryat iba pa, na makikilala natin sa karagdagang mga artikulo. Ngayon subukan nating gawin ang pareho, ngunit gamit ang java configuration . Una, alisin natin ang mga anotasyon @Componentsa ating mga klase. Upang palubhain ang gawain, isipin natin na ang mga ito ay hindi sarili nating mga self-written na klase, na madali nating mababago, magdagdag ng isang bagay, kabilang ang mga anotasyon. Para bang ang mga klase na ito ay nakaimpake sa ilang silid-aklatan. Sa kasong ito, hindi namin maaaring i-edit ang mga klase sa anumang paraan upang matanggap ang mga ito sa tagsibol. Ngunit kailangan namin ng mga bagay ng mga klase na ito! Dito kakailanganin natin ang pagsasaayos ng java upang lumikha ng mga naturang bagay. Upang magsimula, lumikha tayo ng isang pakete, halimbawa configs, at sa loob nito - isang regular na klase ng Java, halimbawa, MyConfigat markahan ito ng isang anotasyon@Configuration

@Configuration
public class MyConfig {
}

Ngayon kailangan nating bahagyang i-tweak main()ang paraan ng paglikha ng konteksto sa pamamaraan. Maaari naming direktang tukuyin ang aming klase na may configuration doon:

ApplicationContext context =
	new AnnotationConfigApplicationContext(MyConfig.class);

Kung mayroon kaming iba't ibang klase kung saan gumagawa kami ng mga bean at gusto naming ikonekta ang ilan sa mga ito nang sabay-sabay, ipinapahiwatig lang namin ang mga ito doon na pinaghihiwalay ng mga kuwit:

ApplicationContext context =
	new AnnotationConfigApplicationContext(MyConfig.class, MyAnotherConfig.class);

Buweno, kung mayroon tayong napakarami sa kanila, at gusto nating ikonekta silang lahat nang sabay-sabay, ipinapahiwatig lamang natin dito ang pangalan ng pakete kung saan mayroon tayo:

ApplicationContext context =
	new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals.configs");

Sa kasong ito, dadaan ang Spring sa package na ito at hahanapin ang lahat ng klase na minarkahan ng anotasyon @Configuration. Kung sakaling mayroon kaming isang malaking programa kung saan ang mga config ay nahahati sa iba't ibang mga pakete, ipinapahiwatig lamang namin ang mga pangalan ng mga pakete na may mga config na pinaghihiwalay ng mga kuwit:

ApplicationContext context =
	new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals.database.configs",
		"ru.javarush.info.fatfaggy.animals.root.configs",
		"ru.javarush.info.fatfaggy.animals.web.configs");

Well, o ang pangalan ng isang package na mas karaniwan sa kanilang lahat:

ApplicationContext context =
	new AnnotationConfigApplicationContext("ru.javarush.info.fatfaggy.animals");

Magagawa mo ito ayon sa gusto mo, ngunit tila sa akin na ang pinakaunang opsyon, kung saan kailangan mo lamang tukuyin ang isang klase na may mga config, ay pinakaangkop sa aming programa. Kapag gumagawa ng konteksto, hahanapin ng Spring ang mga klaseng iyon na minarkahan ng anotasyon @Configurationat gagawa ng mga mismong object ng mga klase na ito. Pagkatapos nito ay susubukan nitong tawagan ang mga pamamaraan sa mga klase na ito na minarkahan ng annotation @Bean, na nangangahulugan na ang mga naturang pamamaraan ay magbabalik ng mga beans (mga bagay) na inilagay na nito sa konteksto nito. Ngayon, gumawa tayo ng pusa, aso at parrot beans sa ating klase na may java configuration. Ginagawa ito nang simple:

@Bean
public Cat getCat() {
	return new Cat();
}

Lumalabas na kami mismo ang gumawa ng aming pusa at ibinigay ito kay Spring, at inilagay na niya ang bagay na ito sa kanyang konteksto. Dahil hindi namin tahasang tinukoy ang pangalan ng aming bean, bibigyan ng Spring ang bean ng parehong pangalan bilang ang pangalan ng pamamaraan. Sa aming kaso, ang buto ng pusa ay magkakaroon ng pangalang " getCat". Ngunit dahil sa main-e nakuha pa rin natin ang pusa hindi sa pangalan, ngunit ayon sa klase, kung gayon sa kasong ito ang pangalan ng bin na ito ay hindi mahalaga sa amin. Gumawa ng isang bean sa isang aso sa parehong paraan, ngunit tandaan na ang Spring ay pangalanan ang naturang bean sa pamamagitan ng pangalan ng pamamaraan. Upang tahasang pangalanan ang aming bean ng loro, ipahiwatig lamang ang pangalan nito sa mga panaklong pagkatapos ng anotasyon @Bean:

@Bean("parrot-kesha")
public Object weNeedMoreParrots() {
	return new Parrot();
}

Tulad ng nakikita mo, dito ko ipinahiwatig ang uri ng return value Object, at tinawag ang pamamaraan kahit ano. Hindi nito naaapektuhan ang pangalan ng bean sa anumang paraan dahil tahasan namin itong itinakda dito. Ngunit mas mainam na ipahiwatig ang uri ng halaga ng pagbabalik at pangalan ng pamamaraan nang hindi biglaan, ngunit mas malinaw. Kahit na para sa iyong sarili, kapag binuksan mo ang proyektong ito sa isang taon. :) Ngayon isaalang-alang natin ang isang sitwasyon kung saan gagawa ng isang bean kailangan nating gumamit ng isa pang bean . Halimbawa, gusto naming ang pangalan ng pusa sa cat bean ay binubuo ng pangalan ng loro at ang string na "-killer". Walang problema!

@Bean
public Cat getCat(Parrot parrot) {
	Cat cat = new Cat();
	cat.setName(parrot.getName() + "-killer");
	return cat;
}

Dito makikita ng Spring na bago likhain ang bean na ito, kakailanganin niyang ilipat dito ang nalikha nang parrot bean. Samakatuwid, siya ay bubuo ng isang kadena ng mga tawag sa aming mga pamamaraan upang ang paraan para sa paglikha ng isang loro ay tinawag muna, at pagkatapos ay ipinapasa ang loro na ito sa paraan para sa paglikha ng isang pusa. Dito nagtrabaho ang bagay na tinatawag na dependency injection : Spring mismo ang nagpasa ng kinakailangang parrot bean sa aming pamamaraan. Kung nagrereklamo ang ideya tungkol sa isang variable parrot, huwag kalimutang baguhin ang uri ng pagbabalik sa paraan para sa paglikha ng parrot mula Objectsa Parrot. Bilang karagdagan, pinapayagan ka ng configuration ng Java na ganap na maisagawa ang anumang Java code sa mga pamamaraan para sa paglikha ng mga beans. Maaari mo talagang gawin ang anumang bagay: lumikha ng iba pang mga pantulong na bagay, tumawag sa anumang iba pang mga pamamaraan, kahit na ang mga hindi minarkahan ng mga anotasyon sa tagsibol, gumawa ng mga loop, kundisyon - anuman ang naiisip! Ang lahat ng ito ay hindi makakamit gamit ang awtomatikong pagsasaayos, lalo na sa paggamit ng mga xml config. Ngayon tingnan natin ang isang mas nakakatuwang problema. Sa polymorphism at mga interface :) Gumawa tayo ng interface WeekDayat lumikha ng 7 klase na magpapatupad ng interface na ito: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday. Gumawa tayo ng paraan sa interface String getWeekDayName()na magbabalik ng pangalan ng araw ng linggo ng kaukulang klase. Ibig sabihin, Mondayibabalik ng klase ang " monday", atbp. Sabihin nating ang gawain kapag naglulunsad ng aming aplikasyon ay maglagay ng bean sa konteksto na tumutugma sa kasalukuyang araw ng linggo. Hindi lahat ng beans ng lahat ng klase na nagpapatupad WeekDayng interface, ngunit ang kailangan lang natin. Maaari itong gawin tulad nito:

@Bean
public WeekDay getDay() {
	DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek();
	switch (dayOfWeek) {
		case MONDAY: return new Monday();
		case TUESDAY: return new Tuesday();
		case WEDNESDAY: return new Wednesday();
		case THURSDAY: return new Thursday();
		case FRIDAY: return new Friday();
		case SATURDAY: return new Saturday();
		default: return new Sunday();
	}
}

Narito ang uri ng halaga ng pagbabalik ay ang aming interface, at ang pamamaraan ay nagbabalik ng mga tunay na bagay ng mga klase sa pagpapatupad ng interface depende sa kasalukuyang araw ng linggo. Ngayon sa pamamaraan main()magagawa natin ito:

WeekDay weekDay = context.getBean(WeekDay.class);
System.out.println("It's " + weekDay.getWeekDayName() + " today!");

Sinabi nito sa akin na Linggo ngayon :) Sigurado ako na kung patakbuhin ko ang programa bukas, isang ganap na naiibang bagay ang lilitaw sa konteksto. Pakitandaan na dito nakukuha natin ang bean sa pamamagitan lamang ng interface: context.getBean(WeekDay.class). Titingnan ng Spring ang konteksto nito upang makita kung alin sa mga bean nito ang nagpapatupad ng ganoong interface at ibabalik ito. Buweno, lumalabas na WeekDaymayroong isang bagay ng uri sa isang variable na uri Sunday, at ang polymorphism, na pamilyar sa ating lahat, ay nagsisimula kapag nagtatrabaho sa variable na ito. :) At ilang salita tungkol sa pinagsamang diskarte , kung saan ang ilan sa mga bean ay nilikha ng Spring mismo, gamit ang pag-scan ng mga pakete para sa pagkakaroon ng mga klase na may annotation @Component, at ilang iba pang beans ay nilikha gamit ang java config. Upang gawin ito, bumalik tayo sa orihinal na bersyon, kapag ang mga klase Cat, Dogat Parrotminarkahan ng isang anotasyon @Component. Sabihin nating gusto naming gumawa ng mga bin para sa aming mga hayop gamit ang awtomatikong pag-scan ng package entitiessa tagsibol, ngunit gumawa ng bin na may araw ng linggo tulad ng ginawa namin. Ang kailangan mo lang gawin ay idagdag sa antas ng klase MyConfig, na tinutukoy namin kapag lumilikha ng konteksto sa main-th annotation @ComponentScan, at ipahiwatig sa mga bracket ang package na kailangang i-scan at ang mga bean ng mga kinakailangang klase ay awtomatikong nilikha:

@Configuration
@ComponentScan("ru.javarush.info.fatfaggy.animals.entities")
public class MyConfig {
	@Bean
	public WeekDay getDay() {
		DayOfWeek dayOfWeek = LocalDate.now().getDayOfWeek();
		switch (dayOfWeek) {
			case MONDAY: return new Monday();
			case TUESDAY: return new Tuesday();
			case WEDNESDAY: return new Wednesday();
			case THURSDAY: return new Thursday();
			case FRIDAY: return new Friday();
			case SATURDAY: return new Saturday();
			default: return new Sunday();
		}
	}
}

Lumalabas na kapag gumagawa ng konteksto, nakikita ng Spring na kailangan nitong iproseso ang klase MyConfig. Pumasok siya dito at nakita niya na kailangan niyang i-scan ang package " ru.javarush.info.fatfaggy.animals.entities" at lumikha ng mga beans ng mga klase na iyon, pagkatapos ay isagawa niya ang pamamaraan getDay()mula sa klase MyConfigat idagdag ang uri ng bean WeekDaysa kanyang konteksto. Sa pamamaraan, main()mayroon na tayong access sa lahat ng beans na kailangan natin: ang mga bagay na hayop at ang bean sa araw ng linggo. Paano masigurado na ang Spring ay nakakakuha din ng ilang xml config - google mo ito sa Internet kung kinakailangan :) Buod:

• subukang gumamit ng awtomatikong pagsasaayos;
• sa panahon ng awtomatikong pagsasaayos, ipinapahiwatig namin ang pangalan ng pakete na naglalaman ng mga klase na ang mga bean ay kailangang malikha;
• ang mga ganitong klase ay minarkahan ng anotasyon@Component;
• ang tagsibol ay dumaan sa lahat ng gayong klase at lumilikha ng kanilang mga bagay at inilalagay ang mga ito sa konteksto;
• kung ang awtomatikong pagsasaayos ay hindi angkop sa amin para sa ilang kadahilanan, gumagamit kami ng java configuration;
• sa kasong ito, lumikha kami ng isang regular na klase ng Java na ang mga pamamaraan ay magbabalik ng mga bagay na kailangan namin, at markahan ang ganoong klase ng isang anotasyon @Configurationkung sakaling i-scan namin ang buong pakete sa halip na tukuyin ang isang partikular na klase na may pagsasaayos kapag gumagawa ng konteksto;
• Ang mga pamamaraan ng klase na ito na nagbabalik ng mga beans ay minarkahan ng anotasyon @Bean;
kung gusto naming paganahin ang awtomatikong pag-scan kapag ginagamit ang configuration ng java, ginagamit namin ang anotasyon @ComponentScan.

Kung walang malinaw, subukang basahin ang artikulong ito sa loob ng ilang araw. Buweno, o kung ikaw ay nasa maagang antas ng Javarash, marahil ay medyo maaga para sa iyo na matuto ng tagsibol. Maaari kang bumalik sa artikulong ito sa ibang pagkakataon, kapag mas kumpiyansa ka sa programming sa Java. Kung malinaw na ang lahat, maaari mong subukang ilipat ang ilan sa iyong mga proyekto ng alagang hayop sa Spring :) Kung may malinaw, ngunit may hindi gaanong, mangyaring magkomento :) Mayroon ding mga mungkahi at komento kung napunta ako sa isang lugar o nagsulat ako ng isang bagay na katangahan ) Sa susunod na artikulo, sumisid kami nang malalim sa spring-web-mvc at gagawa ng isang simpleng web application gamit ang spring.