Գնահատել նախագիծը
← Բոլոր հրապարակումները

Micronaut IOC-ի հիմունքները

Այս հոդվածի նպատակն է մանրամասն ներկայացնել Micronaut IOC կոնտեյները՝ նրա առանձնահատկությունները, հնարավորությունները և կիրառման դեպքերը։ Այն դիտարկում է բնորոշ սցենարները և նշում աշխատանքի լավագույն պրակտիկաները։

9 րոպե
MicronautJavaֆրեյմվորքներ

Այս հոդվածի նպատակն է մանրամասն ներկայացնել 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 սկզբնավորման համար հիմք ունեք, մի քանի տարբերակ կա։

  1. Կիրառել @Context scope-ը
  2. Կարգավորել bean կոնտեքստը, ինչը սակայն վերաբերում է բոլոր singleton-ներին
public class MicronautApp {

    public static void main(String[] args) {
        Micronaut.build(args)
            .eagerInitSingletons(true)
            .mainClass(Application.class)
            .start();
    }
}
  1. Համատեղել @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-երը և դրանց կիրառումը։ Մնացեք մեզ հետ։