Micronaut IOC-ի հիմունքները
Այս հոդվածի նպատակն է մանրամասն ներկայացնել Micronaut IOC կոնտեյները՝ նրա առանձնահատկությունները, հնարավորությունները և կիրառման դեպքերը։ Այն դիտարկում է բնորոշ սցենարները և նշում աշխատանքի լավագույն պրակտիկաները։
Այս հոդվածի նպատակն է մանրամասն ներկայացնել Micronaut IOC կոնտեյները՝ նրա առանձնահատկությունները, հնարավորությունները և կիրառման դեպքերը։ Այն դիտարկում է բնորոշ սցենարները և նշում կոնտեյների հետ աշխատանքի լավագույն պրակտիկաները։ Դրանից բացի, կա բաժին խորհուրդներով, անձնական փորձով և գործնական գիտելիքներով, որը նախատեսված է հատկապես Spring Boot-ից եկող ընթերցողների համար՝ Micronaut-ին անցումը հեշտացնելու նպատակով։
Inversion of Control (IOC) կոնտեյներ
IOC կոնտեյները պատասխանատու է օբյեկտների ստեղծման համար՝ ներդնելով (inject) նրանց համար նախապես հայտարարված կախվածությունները, ապա նաև այդ օբյեկտների կառավարման համար։ Այդպիսի օբյեկտները կոչվում են bean-եր, և դրանք ստեղծվում են տրված նկարագրության համաձայն։ Մենք կարող ենք դրանք հայտարարել՝ կա՛մ նշելով մեր դասերը որպես bean, կա՛մ գրելով factory մեթոդներ։ Այսպիսով՝ օբյեկտների սկզբնավորման համար պատասխանատու է կոնտեյները, այլ ոչ թե մեր կոդը։
Micronaut IoC կոնտեյները իրականացնում է JSR-330 ստանդարտը և օգտագործում է AOT կոմպիլյացիա՝ ռեֆլեկսիան նվազագույնի հասցնելու և հավելվածի գործարկումը կրճատելու համար, ինչը այն դարձնում է թեթև և հարմար native կոմպիլյացիայի համար։ Այն մնացած ֆրեյմվորքից անկախ մոդուլ է, ուստի կարելի է այն օգտագործել նույն կերպ, ինչպես հայտնի Guice-ը կամ Dagger-ը։
Dependency Injection (DI) տեսակները
Ինչպես մեծ մասամբ IoC կոնտեյների դեպքում, Micronaut-ը առաջարկում է կախվածությունների ներդրման 3 եղանակ @Inject annotation-ի միջոցով
Կոնստրուկտոր
class Car {
private final Engine engine;
@Inject
public Car(Engine engine) {
this.engine = engine;
}
Եթե դասն ունի ընդամենը մեկ կոնստրուկտոր, @Inject annotation-ը անհրաժեշտ չէ, քանի որ կոնտեյները ինքնուրույն ընտրում է այդ կոնստրուկտորը։ Երբ կոնստրուկտորները մի քանիսն են, դրանցից մեկը պետք է annotation-ով նշվի։
Մեթոդ/Setter
class Car {
private Engine engine;
@Inject
public void setEngine(Engine engine) {
this.engine = engine;
}
Դաշտ
class Car {
@Inject
Engine engine;
}
Այդուհանդերձ, կոնստրուկտորի միջոցով ներդրումը ամենաառաջարկվող տարբերակն է, քանի որ թույլ է տալիս պահանջել կախվածությունները օբյեկտի ստեղծման պահին, և final հիմնաբառի հետ միասին ապահովում է null-ից ավելի ուժեղ պաշտպանություն։ Կոնստրուկտորով ներդրումը նաև հեշտացնում է կոդի թեստավորումը, քանի որ unit թեստում կարելի է mock-եր փոխանցել առանց IoC կոնտեյների։ Setter-ով և դաշտով ներդրումը պետք է դիտարկել որպես վերջին միջոց՝ օգտագործելով միայն այն դեպքում, երբ այլ տարբերակ չկա։
Կախվածություններ
Ստորև բերված են Micronaut IoC կոնտեյները և այս ձեռնարկի օրինակները գործարկելու համար անհրաժեշտ նվազագույն կախվածությունները։ Որպես այլընտրանք՝ կարող եք գեներացնել նմուշային նախագիծ micronaut.io/launch հասցեում։ Հետագա օրինակներում օգտագործվում են Micronaut 3.8.2 տարբերակը և JDK 17-ը։
Gradle
plugins {
id 'io.micronaut.library' version '1.3.2'
}
micronaut {
version("3.8.2")
}
...
dependencies {
annotationProcessor "io.micronaut:micronaut-inject-java"
implementation "io.micronaut:micronaut-inject"
implementation "io.micronaut:micronaut-runtime"
testImplementation "io.micronaut.test:micronaut-test-junit5"
testImplementation "org.junit.jupiter:junit-jupiter-engine:5.9.1"
}
Scope-եր
JSR-330 սպեցիֆիկացիայի համաձայն՝ bean-ի կյանքի ցիկլը որոշվում է նրա Scope-ով։ Scope-ը ասում է IOC կոնտեյներին, թե երբ ստեղծել bean-երը և ինչպես վարվել արդեն գոյություն ունեցողների հետ՝ հետևելով նախապես սահմանված կանոններին։ Micronaut-ը տրամադրում է 7 scope. դրանցից մի քանիսը ուղղակիորեն վերցված են սպեցիֆիկացիայից, իսկ մյուսները ավելացրել են ֆրեյմվորքի հեղինակները։
Հասանելի scope-երը
- Singleton – scope այն bean-ի համար, որը կարող է ունենալ ընդամենը մեկ օրինակ,
ստեղծվում է lazy կերպով՝ առաջին անգամ ներդրվելիս - Context – singleton-ին մոտ scope, սակայն նրա կյանքի ցիկլը կապված է BeanContext-ի հետ, և bean-ը ստեղծվում է eager կերպով՝ կոնտեքստի գործարկման պահին։ Հեղինակները որպես լռելյայն ընտրություն խորհուրդ են տալիս @Singleton-ը. դիմեք @Context-ին միայն այն դեպքում, երբ eager սկզբնավորում է պետք, քանի որ այն ազդում է հավելվածի գործարկման վրա
- Prototype – bean-ի լռելյայն scope-ը, որտեղ յուրաքանչյուր ներդրում ստանում է նոր օրինակ
- RequestScope – scope այն bean-ի համար, որի կյանքի ցիկլը կապված է HTTP հարցման հետ. պահանջում է HTTP մոդուլ
- Infrastructure – scope կարևոր bean-ի համար, որը հնարավոր չէ փոխարինել @Replaces-ով։ Օգտակար է գրադարանների և ընդլայնումների հեղինակների համար
- ThreadLocal – scope, որը ստեղծում է bean-ի առանձին օրինակ յուրաքանչյուր thread-ի համար
- Refreshable – scope, որի bean-ի վիճակը թարմացվում է /refresh-ի միջոցով կամ RefreshEvent հրապարակելով
Հիշեք, որ bean-ի լռելյայն scope-ը prototype է՝ ի տարբերություն հանրահայտ Spring Boot-ի, որտեղ լռելյայնը Singleton-ն է։ Մենք կկենտրոնանանք վերջին երեքի վրա, քանի որ իմ կարծիքով հենց դրանք են Micronaut-ը տարբերում մյուս հայտնի IoC կոնտեյներներից։
Infrastructure
Պատկերացրեք կարևոր bean, որը հաշվում է ուղղանկյան մակերեսը, և մենք չենք ուզում, որ որևէ մեկը այն փոխարինի, քանի որ դա կարող է կոտրել հավելվածը։ Հենց դրա համար էլ կիրառում ենք @Infrastructure annotation-ը։
@Infrastructure
public class RectangleAreaCalculator {
public double calculate(double a, double b) {
return a * b;
}
Իսկ ի՞նչ կլինի, եթե օգտատերը փորձի վերասահմանել bean-ը՝ սխալ իրականացմամբ ենթադասի վրա դնելով @Replaces։
@Singleton
@Replaces(RectangleAreaCalculator.class)
public class InvalidRectangleAreaCalculator extends RectangleAreaCalculator {
@Override
public double calculate(double a, double b) {
return a - b;
}
Իրականում ոչինչ չի լինում. InvalidRectangleAreaCalculator bean-ը ո՛չ ստեղծվում է, ո՛չ էլ օգտագործվում է RectangleAreaCalculator-ի փոխարեն։
@MicronautTest
class InfrastructureTest {
@Inject
RectangleAreaCalculator rectangleAreaCalculator;
@Test
void infrastructureBeanDoesNotGetReplaced() {
Assertions.assertInstanceOf(RectangleAreaCalculator.class, rectangleAreaCalculator);
Assertions.assertEquals(20, rectangleAreaCalculator.calculate(4, 5));
}
ThreadLocal
Նախքան հենց scope-ին անցնելը, օգտակար է իմանալ, որ Java API-ն ներառում է ThreadLocal մեխանիզմ։ Այն ապահովում է, որ ThreadLocal-ի .get() մեթոդը կանչող յուրաքանչյուր thread ստանա օբյեկտի իր առանձին օրինակը։ Կարող եք այն պատկերացնել որպես HashMap, որտեղ thread-ը հանդես է գալիս որպես անուղղակի բանալի։
Սկզբնավորման ժամանակ պետք է իրականացնենք ֆունկցիոնալ ինտերֆեյս, որի մեթոդը վերադարձնում է սկզբնական արժեքը։
ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 27);
Դրանից հետո get() մեթոդը մեզ տալիս է ընթացիկ thread-ին յուրահատուկ օրինակ։
Integer myUniqueInteger = threadLocal.get();
Այստեղ սկզբնական արժեքը մեր bean-ի նկարագրությունն է։ Ներքուստ այս scope-ը իրականացված է proxy-ի միջոցով, որը պահում է ThreadLocal փոփոխական և մեթոդների կանչերը փոխանցում է ճիշտ օրինակին։ Դրա շնորհիվ bean-ը կարող է կիսվել նույն thread-ում աշխատող այլ bean-երի հետ։
Տեսությունը անցանք, այժմ դիտարկենք օրինակ։ Կստեղծենք պարզ bean, որի միակ խնդիրը String պահելն է։
@ThreadLocal
public class ThreadLocalStorage {
private String text;
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
Համաձայն ThreadLocal scope-ի գաղափարի՝ յուրաքանչյուր thread պետք է ցույց տա bean-ի իր սեփական օրինակը։ Արդյունքում «text» դաշտի արժեքը կիսվում է միայն մեկ thread-ի ներսում, ինչպես ցույց է տալիս ստորև բերված թեստը։
@MicronautTest
class ThreadLocalExampleTest {
@Inject
ThreadLocalStorage storage;
@Test
void test() {
storage.setText("Main test thread");
assertEquals("Main test thread", storage.getText());
runBlockingInNewThread(() -> {
assertNull(storage.getText()); (1)
storage.setText("Sub-thread in test");
assertEquals("Sub-thread in test", storage.getText());
runBlockingInNewThread(() -> {
assertNull(storage.getText());
storage.setText("Sub-sub-thread in test");
assertEquals("Sub-sub-thread in test", storage.getText());
});
assertEquals("Sub-thread in test", storage.getText()); (2)
});
assertEquals("Main test thread", storage.getText());
}
private void runBlockingInNewThread(Runnable runnable) throws RuntimeException {
try {
final var thread = new Thread(runnable);
thread.start();
thread.join();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
(1) Այս thread-ը չպետք է տեսնի գլխավոր թեստի thread-ում դրված տեքստը, ուստի արժեքը պետք է լինի null։
(2) Ստուգում ենք, որ ներքին thread-ը չի վերագրել արժեքը։
Վերը բերված թեստը ցույց է տալիս, որ տվյալ bean-ի վրա մեթոդների կանչերի հերթականությունը կարևոր չէ։ Կանչերի միջև փոխանցվող վիճակը կարևոր է միայն մեկ thread-ի ներսում։
Refreshable
Refreshable scope-ը թույլ է տալիս թարմացնել մեր bean-ի վիճակը։ Գործնականում @PostConstruct-ով նշված մեթոդը bean-ի վրա կանչվում է ևս մեկ անգամ։ Այս scope-ի հնարավոր կիրառումներից են bean-ի կոնֆիգուրացիայի վերաբեռնումը, քեշի մաքրումը կամ ցանկացած այլ կողմնակի էֆեկտի ակտիվացումը։ Արդյո՞ք ես կվստահեի դրան գործնականում։ Դա առանձին հոդվածի թեմա է, բայց հնարավորությունը կա։
Օրինակի համար կգրենք RefreshableSeed դաս՝ init() և latestSeed() մեթոդներով։
@Refreshable
public class RefreshableSeed {
private int seed;
@PostConstruct
public void init() {
seed = new Random().nextInt();
}
public int latestSeed() {
return seed;
}
Ինչպես արդեն նշվեց, վիճակը թարմացնելու երկու եղանակ կա։ Մեկը /refresh endpoint-ն է, որը Micronaut-ը սահմանում է լռելյայն, թեև այն պահանջում է HTTP մոդուլ
Publishing RefreshEvent using ApplicationEventPublisher
eventPublisher.publishEvent(new RefreshEvent());
Թեստի և դեմոյի համար կընտրենք event publisher-ի մոտեցումը։
@MicronautTest
class RefreshableSeedTest {
@Inject
RefreshableSeed refreshableSeed;
@Inject
ApplicationEventPublisher<RefreshEvent> eventPublisher;
@Test
void refreshableBeanGetsRefreshedWithRefreshEvent() {
final var firstSeed = refreshableSeed.latestSeed();
// Should not change before event
assertEquals(firstSeed, refreshableSeed.latestSeed());
eventPublisher.publishEvent(new RefreshEvent());
assertNotEquals(firstSeed, refreshableSeed.latestSeed());
}
Վերը բերված թեստը ցույց է տալիս, որ իրադարձության ակտիվացումը փոխեց միայն bean-ի վիճակը։
Spring-ից անցնողների համար
Micronaut-ին անցնող շատերը նախկինում աշխատել են Spring-ի հետ։ Ֆրեյմվորքի հեղինակներն էլ դա գիտեն և ստեղծում են հատուկ մոդուլներ, օրինակ՝ Micronaut for Spring, որպեսզի հեշտացնեն գոյություն ունեցող հավելվածների տեղափոխումը Micronaut էկոհամակարգ։ Նման մոդուլի թերությունն այն է, որ այն խնդիրը լուծում է միայն մասամբ, քանի որ վերջում խառնվում է երկու տարբեր ֆրեյմվորքի կոդ։ Իմ կարծիքով՝ այս մոդուլները լավագույն տարբերակը չեն, ուստի փոխարենը ես կնշեմ հիմնական տարբերությունները, որոնք կարևոր են Spring-ի մշակողների համար։
Լռելյայն scope-ը տարբեր է
Ամենամեծ տարբերությունն այն է, որ Micronaut կոնտեյների լռելյայն scope-ը Prototype-ն է՝ @Bean-ի այլանունը, այլ ոչ թե Singleton, ինչպես Spring Boot-ում։ Խորհուրդ եմ տալիս լինել հստակ և օգտագործել հենց scope-ը սահմանող annotation-ներ, ինչպիսիք են @Singleton-ը կամ @Prototype-ը, այլ ոչ թե հենվել լռելյայն արժեքների վրա։
Singleton scope-ը նույն կերպ չի աշխատում
Singleton scope-ը տարբերվում է Spring Boot-ի scope-ից։ Micronaut-ում Singleton-ը լռելյայն lazy է. այն ստեղծվում է ոչ թե կոնտեքստի գործարկման պահին, այլ միայն երբ անհրաժեշտ է։ Spring Boot-ի @Scope(“Singleton”)-ին իրականում համապատասխանում է @Context-ը։ Սա գիտակցված ընտրություն է. հեղինակները այն այդպես են կառուցել՝ հավելվածի գործարկման ժամանակը էլ ավելի կրճատելու համար։ Այդ պատճառով eager սկզբնավորում օգտագործեք միայն այն դեպքում, երբ իսկապես ունեք ծանրակշիռ հիմքեր կամ հիմնավորում։
| Spring Boot | Micronaut |
|---|---|
| @Component | @Context |
| @Lazy @Component | @Singleton |
Eager singleton Micronaut-ում
Ինչպես ասվեց նախկինում, lazy singleton սկզբնավորումը նախընտրելի մոտեցումն է և պետք է լինի ձեր առաջին ընտրությունը։ Սակայն եթե eager սկզբնավորման համար հիմք ունեք, մի քանի տարբերակ կա։
- Կիրառել @Context scope-ը
- Կարգավորել bean կոնտեքստը, ինչը սակայն վերաբերում է բոլոր singleton-ներին
public class MicronautApp {
public static void main(String[] args) {
Micronaut.build(args)
.eagerInitSingletons(true)
.mainClass(Application.class)
.start();
}
}
- Համատեղել @Parallel annotation-ը @Singleton-ի հետ
Annotation-ների չիթ-շիթ
Ես նաև կազմել եմ Spring Boot-ում հաճախ օգտագործվող annotation-ների կարճ չիթ-շիթ՝ դրանց Micronaut համարժեքները գտնելու համար։
| Spring | Micronaut |
|---|---|
| @Component | Ուղիղ 1:1 համարժեքը @Context-ն է, բայց նախընտրեք @Singleton։ Context-ը թողեք այն դեպքերի համար, երբ eager սկզբնավորումն իսկապես անհրաժեշտ է։ |
| @Service | Ուղիղ 1:1 համարժեքը @Context-ն է, բայց նախընտրեք @Singleton։ Context-ը թողեք այն դեպքերի համար, երբ eager սկզբնավորումն իսկապես անհրաժեշտ է։ |
| @Repository | @Repository |
| @RestController | @Controller |
| @Bean | Ուղիղ 1:1 համարժեքը @Context-ն է, բայց նախընտրեք @Singleton։ Context-ը թողեք այն դեպքերի համար, երբ eager սկզբնավորումն իսկապես անհրաժեշտ է։ @Bean-ը չի համապատասխանում, քանի որ Micronaut-ի լռելյայն scope-ը @Prototype է |
| @Scope | @Singleton @Context @Prototype @Infrastructure @ThreadLocal @Refreshable @RequestScope |
| @Autowired | @Inject |
| @Value | @Value |
| @Qualifier | @Named |
| @Configuration | @Factory |
| @Profile(“test”) | @Requires(env=“test”) |
| @Import | @Import |
| @Primary | @Primary |
Ամփոփում
Հուսով եմ՝ այս հոդվածը օգտակար էր ձեզ և տվեց Micronaut-ում IoC-ի ամուր հիմնական ներածություն՝ անկախ Spring Framework-ի հետ ձեր նախկին փորձից։ Հաջորդ բլոգային գրառման մեջ կուսումնասիրենք bean կոնտեյներները, պայմանական bean-երը և դրանց կիրառումը։ Մնացեք մեզ հետ։