Sobes.tech
Հարցազրույցի օգնություն
Ռեսուրսներ
Հարցազրույցի պատրաստում
Ռեսուրսներ
Աշխատանքի որոնում
Ռեսուրսներ
Իրավական
Վերադարձ դեպի հարցեր
Middle

Ինչպե՞ս կարելի է կիրառել կախվածությունների ներդնումը Spring Bean-ով։

sobes.tech AI

Պատասխան AI-ից

Spring IoC-կոնտեյները կառավարում է Spring Bean-ների (օբյեկտների) կյանքի ցիկլը։ Bean-ները հիմնական շինանյութերն են Spring հավելվածների համար։ Զависությունների ներդնումը (DI) Spring Bean-ների միջոցով իրականացվում է կոնֆիգուրացիայի միջոցով, որը ցույց է տալիս կոնտեյներին, թե ինչպես ստեղծել և կապել կոմպոնենտները:

Առկա են երեք հիմնական մեթոդներ՝ Զависությունների ներդնում Spring-ում՝

  1. Կոնստրուկտորով ներդնում (Constructor Injection): Spring-ը կանչում է համապատասխան կոնստրուկտորին՝ Bean-ի ստեղծման ժամանակ։ Սա նախընտրելի մեթոդ է, քանի որ ապահովում է, որ բոլոր անհրաժեշտ կախվածությունները հստակեցված են՝ ստեղծման ժամանակ, և թույլ է տալիս դարձնել կախվածությունները անփոփոխ։
  2. Սետերով ներդնում (Setter Injection): Spring-ը կանչում է սեթեր մեթոդները՝ կախվածությունները տեղադրելու համար՝ Bean-ի ստեղծումից հետո։ Այս մեթոդը օգտակար է ընտրովի կախվածությունների համար։
  3. Ֆիլդերով ներդնում (Field Injection): Spring-ը օգտագործում է ռեֆլեկցիա՝ ուղղակիորեն ներդնելու կախվածությունները՝ դասի ֆիլդերում։ Այս մեթոդը չի խորհուրդ տրվում, քանի որ դժվարացնում է թեստավորումը և խախտում է ինկապսուլյացիան։

Կոնֆիգուրացիան՝ կախվածությունների ներդրման համար, կարող է կատարվել՝

  • Անոտացիաներով: @Autowired, @Qualifier, @Value։ Այս մոտեցումը առավել տարածված է ժամանակակից Spring հավելվածներում։
// Օրինակ՝ կոնստրուկտորով ներդնում՝ անոտացիայով
@Component // Դարձնում ենք դասը Spring Bean
public class MyService {

 private final MyDependency dependency;

 @Autowired // Spring-ին ցույց տալ՝ ներդնել կախվածությունը կոնստրուկտորով
 public MyService(MyDependency dependency) {
 this.dependency = dependency;
 }

 // ...
}

@Component
public class MyDependency {
 // ...
}

// Օրինակ՝ սեթերով ներդնում՝ անոտացիայով
@Component
public class AnotherService {

 private AnotherDependency dependency;

 @Autowired // Spring-ին ցույց տալ՝ ներդնել կախվածությունը սեթերով
 public void setDependency(AnotherDependency dependency) {
 this.dependency = dependency;
 }

 // ...
}

@Component
public class AnotherDependency {
 // ...
}

// Օրինակ՝ ֆիլդով ներդնում՝ անոտացիայով (չի խորհուրդ տրվում)
@Component
public class FieldInjectedService {

 @Autowired // Spring-ին ցույց տալ՝ ներդնել կախվածությունը ֆիլդում
 private FinalDependency dependency;

 // ...
}

@Component
public class FinalDependency {
 // ...
}
  • XML կոնֆիգուրացիան: Օգտագործվում է ավելի հին կամ հատուկ նախագծերում։
<!-- Օրինակ՝ կոնստրուկտորով ներդնում XML-ում -->
<beans>
 <bean id="myDependency" class="com.example.MyDependency"/>

 <bean id="myService" class="com.example.MyService">
 <constructor-arg ref="myDependency"/>
 </bean>
</beans>

<!-- Օրինակ՝ սեթերով ներդնում XML-ում -->
<beans>
 <bean id="anotherDependency" class="com.example.AnotherDependency"/>

 <bean id="anotherService" class="com.example.AnotherService">
 <property name="dependency" ref="anotherDependency"/>
 </bean>
</beans>
  • Java կոնֆիգուրացիաներ (@Configuration և @Bean օգտագործելով): Ժամանակակից մոտեցում, որը թույլ է տալիս կոնֆիգուրացնել Spring կոնտեյները Java կոդով։
// Օրինակ՝ Java կոնֆիգուրացիա
@Configuration // նշում է, որ սա կոնֆիգուրացիոն դաս է
public class AppConfig {

 @Bean // հայտարարում է Bean myDependency
 public MyDependency myDependency() {
 return new MyDependency();
 }

 @Bean // հայտարարում է Bean myService
 public MyService myService(MyDependency myDependency) {
 // ներդրում՝ կոնստրուկտորով՝ Bean-ի ստեղծման ժամանակ
 return new MyService(myDependency);
 }
}

Spring IoC կոնտեյները սկանավորում է կոնֆիգուրացիան (անոտացիաները, XML-ը, Java դասերը), ստեղծում է Bean-ների օրինակները, կառավարում նրանց կյանքի ցիկլը և ավտոմատ կերպով ներդնում է կախվածությունները։ Սա նվազեցնում է կոմպոնենտների կապակցվածությունը, հեշտացնում է թեստավորումը (կարող եք հեշտությամբ փոխարինել կախվածությունները mock-օբյեկտներով) և դարձնում է կոդը ավելի պահպանվող։

ՆախորդՀաջորդը