Tavasz a lustáknak Alapítvány, alapfogalmak és példák kóddal. 2. rész

Az előző cikkben röviden elmagyaráztam, mi a tavasz, és mi az a bab és a kontextus. Itt az ideje, hogy kipróbáld. Az IntelliJ IDEA Enterprise Edition használatával fogom megtenni. De minden példámnak működnie kell az ingyenes IntelliJ IDEA Community Editionben is. Ha a képernyőképeken azt látja, hogy van néhány ablakom, amivel Ön nem rendelkezik, ne aggódjon – ez nem fontos ennél a projektnél :) Először is hozzon létre egy üres Maven projektet. Az ezen a linken található cikkben megmutattam, hogyan kell ezt megtenni . Olvassa el a szavakat: " Itt az ideje, hogy a Maven projektünket webes projektté alakítsuk. " - ezt követően a cikk bemutatja, hogyan készítsünk webes projektet, de erre most nincs szükségünk. Az src/main/java fájlbanmappát, hozzon létre egy csomagot (esetemben " en.codegym.info.fatfaggy.animals. Nevezheti, ahogy akarja. Csak ne felejtse el a csomagnevemet a megfelelő helyen lecserélni a csomagnevére. Most hozza létre az osztályt, Mainés adjon hozzá egy módszer

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

Ezután nyissa meg a pom.xml fájlt, és adja hozzá a dependenciesrészt. Most lépjen a Maven adattárba , és keresse meg a tavaszi környezetet a legújabb stabil verzióhoz. Amit találtunk, tegyük a dependenciesszakaszba. Ezt a folyamatot részletesebben leírtam ebben a másik CodeGym-cikkben (lásd a " Függőségek összekapcsolása a Mavenben " című részt ). Ezután maga a Maven megkeresi és letölti a szükséges függőségeket. A végén valami ilyesmit kell kapnod: A bal oldali ablakban láthatod a projekt struktúráját a csomaggal és az Mainosztállyal. A középső ablak megmutatja, hogyan néz ki nekem a pom.xml. Hozzáadtam egy tulajdonságot isszakaszt hozzá. Ez a szakasz megmondja a Mavennek, hogy a Java melyik verzióját használom a forrásfájljaimban, és melyik verziót kell lefordítani. Ez csak azért van, hogy az IDEA ne figyelmeztetjen arra, hogy a Java régi verzióját használom. Ez opcionális :) A jobb oldali ablakban jól látható, hogy bár csak a rugó-kontextus modult csatlakoztattuk, az automatikusan behúzta a rugómag, tavaszi bab, rugó-aop és rugó-kifejezés modult. Minden modult külön-külön is csatlakoztathattunk volna, és minden modulhoz kiírhattuk volna a függőséget az explicit verzióval a pom.xml fájlban, de egyelőre elégedettek vagyunk a dolgokkal úgy, ahogy vannak. Most hozza létre a entitiescsomagot, és hozzon létre benne 3 osztályt: Cat, Dog, Parrot. Adjunk nevet minden állatnak (private String name— néhány értéket kódolhat ott). A getterek/beállítók nyilvánosak. Most továbblépünk az Mainosztályra és a main()metódusra, és valami ilyesmit írunk:

public static void main(String[] args) {
	// Create an empty Spring context that will look for its own beans based on the annotations in the specified package
	ApplicationContext context = 
		new AnnotationConfigApplicationContext("en.codegym.info.fatfaggy.animals.entities");

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

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

Először létrehozunk egy kontextusobjektumot, amely megmondja a konstruktornak, hogy melyik csomagban keressen babot. Más szóval, a Spring átmegy ezen a csomagon, és megpróbálja megtalálni azokat az osztályokat, amelyek speciális megjegyzésekkel vannak megjelölve, amelyek azt jelzik, hogy babról van szó. Ezután létrehozza ezen osztályok objektumait, és kontextusba helyezi őket. Ezek után ebből a szövegkörnyezetből macskát kapunk. Felszólítjuk a kontextus objektumot, hogy adjon nekünk egy babot (objectet), jelezve a kívánt objektum osztályát (egyébként interfészeket is megadhatunk, nem csak osztályokat). Ezt követően a Spring visszaadja a kért osztály objektumát, amit aztán elmentünk egy változóba. Ezután megkérjük Spring-et, hogy szerezzen nekünk egy babot, amelyet "kutyának" hívnak. Amikor a tavasz megteremti aDogobjektumhoz, szabványos nevet ad az objektumnak (kivéve, ha a létrehozott komponenshez kifejezetten hozzá van rendelve egy név), amely az osztálynév, de egy kis kezdőbetűvel. Ebben az esetben az osztályunk neve Dog, tehát a bab neve "kutya". Ha szükségünk lenne egy BufferedReaderobjektumra, akkor a Spring "bufferedReader"-nek nevezné el. És mivel a Java nem lehet 100%-ig biztos, hogy melyik osztályt akarjuk, egy objektumot ad vissza Object, amit aztán manuálisan a kívánt típusba öntünk, pl.Dog. Kényelmesebb az a lehetőség, ahol az osztály kifejezetten meg van jelölve. A harmadik lehetőség az, hogy egy babot osztálynév és babnév alapján szerezzünk be. Lehetséges, hogy a kontextusnak egyetlen osztály több babja is lehet. Annak érdekében, hogy jelezzük az adott babot, amire szükségünk van, feltüntetjük a nevét. Mivel itt is kifejezetten megjelöljük az osztályt, már nem kell leadni. FONTOS!Ha a Spring több olyan babot talál, amelyek megfelelnek az igényeinknek, akkor nem tudja eldönteni, melyik babot adja nekünk, ezért kivételt tesz. Ennek megfelelően, hogy elkerülje ezt a helyzetet, próbálja meg a lehető legpontosabban elmondani a tavasznak, hogy melyik babra van szüksége. Ha a Spring a kontextusát keresi, és nem talál egyetlen olyan babot sem, amely megfelel a követelményeinknek, akkor szintén kivételt dob. Végül egyszerűen megjelenítjük állataink nevét, hogy ellenőrizzük, valóban megkaptuk-e a szükséges tárgyakat. De ha most lefuttatjuk a programot, látni fogjuk, hogy a tavasz boldogtalan – nem találja kontextusában azokat az állatokat, amelyekre szükségünk van. Ez azért van, mert nem ez hozta létre ezeket a babokat. Ahogy korábban mondtam, amikor a Spring átvizsgálja az osztályokat, megkeresi a saját tavaszi megjegyzéseit. És ha a tavasz nem találja meg ezeket a megjegyzéseket, akkor nem nem gondolja, hogy ezek az osztályok olyan baboknak felelnek meg, amelyeket létre kell hoznia. Ennek kijavításához egyszerűen hozzá kell adni a@Componentmegjegyzést minden állatosztályunk előtt.

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

De van több is. Ha kifejezetten meg kell mondanunk a Springnek, hogy az osztályhoz tartozó babnak konkrét neve legyen, akkor a nevet a megjegyzés után zárójelben jelezzük. Például, ha meg akarjuk mondani Springnek, hogy a " parrot-polly" nevet adja a papagájbabnak, ami az a név, hogy ezt a papagájt megkapjuk a módszerben main, valami ilyesmit kell tennünk:

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

Ez az automatikus konfiguráció lényege . Megírod az óráidat, megjelölöd a szükséges megjegyzésekkel, és elmondod Springnek a csomagot, amelyben az óráid vannak. Ez az a csomag, amelyen a keretrendszer átfut, hogy megjegyzéseket keressen és objektumokat hozzon létre ezekből az osztályokból. A Spring egyébként nem csak @Componenta kommentárokat keresi, hanem az összes többi annotációt is, amely ezt örökli. Például: @Controller, @RestController, @Service, @Repository, és egyebek, amelyeket a következő cikkekben mutatunk be. Most megpróbáljuk megtenni ugyanezt Java alapú konfigurációval . A kezdéshez távolítsa el a@Componentjegyzetek osztályainkról. A dolgok nagyobb kihívása érdekében képzeljük el, hogy nem mi írtuk ezeket az osztályokat, így nem tudjuk könnyen módosítani őket, ami azt jelenti, hogy nem tudunk megjegyzéseket hozzáadni. Mintha ezeket az órákat valamilyen könyvtárba csomagolnák. Ebben az esetben nincs módunk úgy szerkeszteni ezeket az osztályokat, hogy a Spring felismerje őket. De szükségünk van ezeknek az osztályoknak a tárgyaira! Itt Java alapú konfigurációra van szükségünk az objektumok létrehozásához. A kezdéshez hozzon létre egy csomagot ilyen névvel configs. Ebben a csomagban hozzon létre egy szokásos Java osztályt, valami hasonlót MyConfig, és jelölje meg a megjegyzéssel @Configuration.

@Configuration
public class MyConfig {
}

Most módosítanunk kell a main()módszert, megváltoztatva a kontextus létrehozásának módját. Vagy kifejezetten jelezhetjük, hogy melyik osztály rendelkezik a konfigurációnkkal:

ApplicationContext context =
	new AnnotationConfigApplicationContext(MyConfig.class);

Ha több különböző osztályunk van, amelyek babot hoznak létre, és egyszerre többet szeretnénk összekapcsolni belőlük, egyszerűen jelezzük ott őket vesszővel elválasztva:

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

Ha pedig túl sok van belőlük, és egyszerre szeretnénk mindet összekapcsolni, akkor egyszerűen jelezzük a csomag nevét, amelyben szerepelnek:

ApplicationContext context =
	new AnnotationConfigApplicationContext("en.codegym.info.fatfaggy.animals.configs");

Ebben az esetben a Spring átmegy a csomagon, és megtalálja az összes megjegyzéssel jelölt osztályt @Configuration. Nos, és ha van egy igazán nagy programunk, ahol a konfigurációk különböző csomagokra vannak felosztva, akkor egyszerűen jelezzük a konfigurációkat tartalmazó csomagok vesszővel tagolt névlistáját:

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

Vagy egy csomag neve, amely mindenki számára közös:

ApplicationContext context =
	new AnnotationConfigApplicationContext("en.codegym.info.fatfaggy.animals");

Csinálhatod, ahogy akarod, de nekem úgy tűnik, hogy a legelső opció, amely egyszerűen csak egy osztályt jelöl a konfigurációkkal, a programunknak felel meg a legjobban. A kontextus létrehozásakor a Spring megkeresi a megjegyzéssel jelölt osztályokat @Configuration, és létrehozza ezekből az osztályokból saját objektumokat. Megkísérli meghívni az annotációval jelölt metódusokat @Bean, ami azt jelenti, hogy ezek a metódusok babokat (objektumokat) adnak vissza, amelyeket a Spring hozzáad a kontextushoz. Most pedig egy macskának, kutyának és papagájnak készítünk babot osztályunkban Java-alapú konfigurációval. Ez meglehetősen egyszerű megtenni:

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

Itt manuálisan létrehozzuk a macskánkat, és átadjuk a Springnek, aki aztán a kontextusában tartja tárgyunkat. Mivel nem adtunk kifejezetten nevet a babunknak, a Spring ugyanazt a nevet fogja adni neki, mint a metódus nevét. A mi esetünkben a macskababot " getCat" fogjuk hívni. De mivel az osztályt használjuk, nem a nevet, hogy megkapjuk a macskababot a metódusban main, ezért a bab neve nem fontos számunkra. Hasonlóképpen hozzon létre egy kutyababot, szem előtt tartva, hogy a tavasz a módszer nevét adja a babnak. A papagájbabunk kifejezett elnevezéséhez egyszerűen jelöljük meg a nevét zárójelben a @Beanmegjegyzés után:

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

Mint látható, itt egy Objectvisszatérési típust jeleztem, és a metódusnak tetszőleges nevet adtam. Ez nem befolyásolja a bab nevét, mert itt kifejezetten megadtuk a nevet. Mégis jobb, ha egy többé-kevésbé értelmes visszatérési értéket és metódusnevet jelez. Tegye ezt, ha nem másért, mint hogy szívességet tegyen magának, amikor egy év múlva újraindítja a projektet. :) Most nézzük meg azt a helyzetet, amikor szükségünk van egy babra egy másik bab létrehozásához . Tegyük fel például, hogy a macskababban lévő macska neve a papagáj neve és a „-killer” karakterlánc. Nincs mit!

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

Itt a tavasz látni fogja, hogy ennek a babnak a létrehozásához a keretnek át kell haladnia a korábban létrehozott papagájbabban. Ennek megfelelően elrendezi a szükséges metódushívási láncot: először a papagáj-létrehozó metódust hívják meg, majd a keretrendszer átadja az új papagájt a macska-alkotó metódusnak. Itt jön képbe a függőségi injekció : A tavasz maga adja át a szükséges papagájbabot a módszerünknek. Ha az IDEA ideges lesz a parrotváltozó miatt, ne felejtse el megváltoztatni a papagáj-létrehozó metódus visszatérési típusát -ról Object-ra Parrot. Ezenkívül a Java-alapú konfiguráció lehetővé teszi, hogy bármilyen Java kódot futtassonbabteremtő módszereidben. Valójában bármit megtehet: létrehozhat más segédobjektumokat, meghívhat bármilyen más metódust, még azokat is, amelyek nincsenek megjelölve tavaszi megjegyzésekkel, hurkokat, logikai feltételeket hozhat létre – ami eszébe jut! Ez nem lehetséges automatikus konfigurációval, és még kevésbé az XML-konfigurációval. Most nézzünk meg egy kicsit szórakoztatóbb problémát. Polimorfizmus és interfészek :) Létrehozunk egy WeekDayinterfészt és 7 osztályt, amelyek megvalósítják ezt a felületet: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday. Adunk a felületnek egy String getWeekDayName()metódust, amely a hét napjának nevét adja vissza a megfelelő osztályhoz. Más szóval, az Mondayosztály visszatér "Monday" stb. Az alkalmazás indításakor tegyük fel, hogy az a feladatunk, hogy a hét aktuális napjának megfelelő bean-t helyezzünk a kontextusba. Nem bean az összes interfészt megvalósító osztályhoz - csak az egy bean, amelyre szükségünk van WeekDay. csináld kb így:

@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();
	}
}

Itt a visszatérési típus a mi felületünk. A metódus a felületet megvalósító osztályok egyikének jóhiszemű objektumát adja vissza, a hét aktuális napjától függően. Most a következőt tehetjük a metódusban main():

WeekDay weekDay = context.getBean(WeekDay.class);
System.out.println("Today is " + weekDay.getWeekDayName() + "!");

Nekem a program azt mondja, hogy vasárnap van :) Bízom benne, hogy ha holnap lefuttatom a programot, akkor a kontextus egy teljesen más objektumot tartalmaz. Vegye figyelembe, hogy a babot egyszerűen a következő felület használatával kapjuk meg: context.getBean(WeekDay.class). A Spring megkeresi a környezetében az interfészt megvalósító babot, és visszaadja. Aztán kiderül, hogy WeekDaya változónk egy Sunday objektumhoz kötődik, és a polimorfizmus ismert fogalma érvényesül, amikor ezzel a változóval dolgozunk. :) Most néhány szó a kombinált megközelítésről , amelyben néhány babot a Spring automatikusan hoz létre, néhányat az annotációval ellátott osztályok csomagjainak szkennelésével @Component, másokat pedig Java alapú konfiguráció. Ennek figyelembevételével visszatérünk az eredeti verzióhoz, ahol a Cat, Dog, ésParrotosztályokat a megjegyzéssel jelöltük @Component. Tegyük fel, hogy babot akarunk létrehozni az állataink számára úgy, hogy a Spring automatikusan átvizsgálja a entitiescsomagot, de szeretnénk létrehozni egy babot is a hét napjával, ahogy az imént tettük. Csak annyit kell tennie, hogy hozzáadja @ComponentScanaz osztály szintjén az annotációt MyConfig, amelyet a kontextus létrehozásakor jelez main(), és zárójelben jelzi a vizsgálandó csomagot, és automatikusan létrehozza a szükséges osztályok babjait:

@Configuration
@ComponentScan("en.codegym.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();
		}
	}
}

A kontextus létrehozásakor a Spring látja, hogy fel kell dolgoznia az MyConfigosztályt. Belép az osztályba, és látja, hogy meg kell vizsgálnia a " en.codegym.info.fatfaggy.animals.entities" csomagot, és létre kell hoznia az osztályok komponenseit, majd végrehajtja az MyConfigosztály getDay()metódusát, és hozzáad egy WeekDaykomponenst a környezethez. A main()módszerben most minden babhoz hozzáférünk, amire szükségünk van: mind az állati tárgyakhoz, mind a babhoz a hét napjával. Ha valaha is arra van szüksége, hogy a Spring is vegyen fel néhány XML konfigurációs fájlt, saját internetes keresést végezhet, hogy magyarázatot találjon :) Összegzés:

• Próbáljon meg automatikus konfigurációt használni
• Az automatikus konfiguráció során adja meg annak a csomagnak a nevét, amely azokat az osztályokat tartalmazza, amelyek beanjeit létre kell hozni
• @ComponentEzeket az osztályokat annotációval jelöljük
• A tavasz mindezen az osztályokon végigfut, objektumokat hoz létre, és kontextusba helyezi;
• Ha az automatikus konfiguráció valamiért nem felel meg nekünk, Java alapú konfigurációt használunk
• Ebben az esetben létrehozunk egy közönséges Java osztályt, amelynek metódusai visszaadják a számunkra szükséges objektumokat. Ezt az osztályt a megjegyzéssel jelöljük meg @Configuration, ha a teljes csomagot szeretnénk átvizsgálni, nem pedig egy adott osztályt jelezni a konfigurációval a kontextus létrehozásakor
• Ennek az osztálynak a beaneket visszaadó metódusai a megjegyzéssel vannak @Beanmegjelölve
Ha engedélyezni akarjuk az automatikus keresést Java alapú konfiguráció használatakor, akkor a @ComponentScanmegjegyzést használjuk.

Ha ez a cikk teljesen zavaró volt, próbálja meg néhány napon belül elolvasni. Vagy ha a CodeGym egyik korai szintjén jársz, akkor lehet, hogy egy kicsit korai lenne a Spring tanulmányozása. Bármikor visszatérhet ehhez a cikkhez egy kicsit később, amikor magabiztosabbnak érzi magát Java programozási készségeiben. Ha minden világos, akkor megpróbálhatod átkonvertálni valamelyik kisállat-projektedet tavaszra :) Ha néhány dolog világos, de mások nem, akkor kérlek írj egy megjegyzést :) Ha rosszul csináltam, jelezd a javaslataidat és a kritikáidat. valahol, vagy írtál valami hülyeséget :) A következő cikkben hirtelen belemerülünk a spring-web-mvc- be , és készítünk egy egyszerű webes alkalmazást a Spring segítségével.