Spring Core va Spring Boot: beanʼlar, proxy va auto-configuration qanday ishlaydi
Bu sahifa Spring Core va Spring Boot mavzusini chuqur tushuntiradi: IoC container beanʼlarni qanday yaratadi va bir-biriga ulaydi, Spring Boot ishga tushganda nima boʻladi, auto-configuration beanʼlarni qanday tanlaydi va `@Transactional`, `@Async`, `@Cacheable` kabi annotatsiyalar proxy orqali qanday ishlaydi. Murakkab joylar qadamma-qadam animatsiya bilan koʻrsatilgan.
Boʻlimlar asoslardan chuqurroq mavzularga qarab ketadi: dependency injection va REST controllerʼdan konteynerning ichki tuzilishi, tranzaksiya tuzoqlari va productionʼgacha. Misollar Spring Boot 3.x (Spring Framework 6, Java 17+) uchun yozilgan, Spring Boot 4 da oʻzgargan joylar alohida aytilgan. Spring Data JPA va Hibernate bu yerda koʻrilmaydi — ular alohida mavzu.
Har boʻlim oxirida tushunganingizni tekshiradigan savollar bor. Avval javobni oʻzingiz oʻylab koʻring, keyin oching.
1IoC container, bean va dependency injection
Oddiy Java kodida obyekt oʻziga kerakli boshqa obyektlarni oʻzi yaratadi: OrderService ichida new JdbcOrderRepository(). Shunda u aniq bitta implementationʼga bogʻlanib qoladi, testda uni almashtirish ham qiyin. Dependency injection buni teskari qiladi: OrderService kerakli narsalarni constructor orqali oladi, ularni kim va qanday yaratishi uni qiziqtirmaydi.
Obyektlarni yaratib, bir-biriga ulab beradigan qism — IoC container. Springʼda bu ApplicationContext: u ishga tushishda konfiguratsiyani oʻqiydi, qaysi obyektlar kerakligini aniqlaydi, ularni dependency tartibida yaratadi va kerakli joyga inject qiladi. Container yaratgan va boshqaradigan obyekt bean deyiladi. Beanʼni containerga uch yoʻl bilan tanitish mumkin:
| Usul | Qayerda yoziladi | Qachon ishlatiladi |
|---|---|---|
@Component, @Service, @Repository, @Controller | klassning oʻzida; component scanning topadi | oʻzingiz yozgan klasslar |
@Bean metod | @Configuration klass ichida: obyektni oʻzingiz yaratib qaytarasiz | kutubxona klasslari yoki yaratish logikasi murakkab boʻlganda |
@Import | @Configuration klassda | boshqa konfiguratsiya klasslarini aniq koʻrsatib ulash; auto-configuration ham shu mexanizmga tayanadi |
@Service, @Repository va @Controller — @Componentning oʻzi, faqat vazifani bildiradi. @Repositoryga qoʻshimcha imkoniyat bor: Spring undagi texnologiyaga xos exceptionʼlarni (masalan, JPA exceptionʼlarini) umumiy DataAccessException ierarxiyasiga oʻgira oladi.
Dependency uch yoʻl bilan beriladi: constructor orqali, setter orqali yoki fieldʼga @Autowired bilan. Tavsiya etilgani — constructor injection: dependencyʼlar final, obyekt toʻliq holatda yaratiladi. Klassda bitta constructor boʻlsa, @Autowired yozish shart emas:
@Service
public class OrderService {
private final OrderRepository repo;
private final PaymentClient payments;
// yagona constructor: @Autowired shart emas
public OrderService(OrderRepository repo,
PaymentClient payments) {
this.repo = repo;
this.payments = payments;
}
}Scope container bitta bean uchun nechta obyekt yaratishini belgilaydi:
| Scope | Nechta obyekt | Izoh |
|---|---|---|
singleton (default) | bitta container uchun bitta | hamma threadʼlar shu bitta obyektni ishlatadi — unda soʻrovga bogʻliq mutable state saqlanmaydi |
prototype | har safar soʻralganda yangisi | container uni yaratib beradi va keyin kuzatmaydi: destroy callbackʼlar chaqirilmaydi |
request | har bir HTTP soʻrov uchun bitta | faqat web ilovada |
session | har bir HTTP session uchun bitta | faqat web ilovada |
Web ilovada yana application (butun ServletContext uchun bitta) va websocket scopeʼlari bor, lekin ular kam ishlatiladi.
Lifecycle callbackʼlari: bean yaratilib, hamma dependencyʼlari inject qilingandan keyin @PostConstruct metodi chaqiriladi — dependencyʼlar bilan ishlaydigan tayyorgarlik shu yerda qilinadi. Context yopilayotganda @PreDestroy chaqiriladi: connectionʼlarni yopish yoki bufferʼni yozib tugatish uchun. Ikkalasi jakarta.annotation paketidan (Spring Boot 2 da javax.annotation edi). @Bean(initMethod = ..., destroyMethod = ...) ham shu ishni qiladi, @Bean bilan yaratilgan obyektda public close() yoki shutdown() metodi boʻlsa esa, Spring uni context yopilganda oʻzi chaqiradi.
Bir turdagi bir nechta bean boʻlsa, Spring qaysi birini inject qilishni bilmaydi va context NoUniqueBeanDefinitionException bilan ishga tushmaydi. Default variantni @Primary bilan belgilaysiz, aniq nom boʻyicha tanlashni @Qualifier bilan bildirasiz, hammasi kerak boʻlsa — List<T> yoki Map<String, T> sifatida inject qilasiz.
Tushunganingizni tekshiring
Dependency injection nima va IoC container nima qiladi?Javob
Dependency injection — obyekt oʻziga kerak boʻlgan boshqa obyektlarni oʻzi yaratmaydi, ularni tashqaridan oladi. IoC container — shu ishni bajaradigan qism: beanʼlarni yaratadi, ularni bir-biriga ulaydi va lifecycleʼini boshqaradi.
Oddiy kodda OrderService new JdbcOrderRepository() deb oʻzi yaratadi va shu implementationʼga qattiq bogʻlanadi. DIʼda u faqat OrderRepository interfeysini constructorʼda qabul qiladi, qaysi implementation berilishini container hal qiladi. Testda esa uning oʻrniga fake yoki mock berish oson.
Inversion of Control degani — obyektlarni yaratish va ulash nazorati sizning kodingizdan frameworkʼga oʻtadi. Springʼda bu ApplicationContext: u ishga tushishda har bir bean uchun BeanDefinition tuzadi, keyin beanʼlarni dependency tartibida yaratadi va kerakli joyga inject qiladi.
Bean — container yaratgan va boshqaradigan obyekt. new bilan oʻzingiz yaratgan obyekt bean emas: unga injection ham, @Transactional kabi proxy orqali ishlaydigan imkoniyatlar ham ishlamaydi.
Nega constructor injection field injectionʼdan afzal?Javob
Constructor injectionʼda dependencyʼlar final boʻladi, obyekt hech qachon chala holatda boʻlmaydi va uni Springʼsiz, oddiy new bilan test qilish mumkin. Field injection dependencyʼlarni yashiradi, ularni esa reflectionʼsiz toʻldirib boʻlmaydi.
Constructor — kontrakt: obyektni yaratish uchun nima kerakligi darhol koʻrinadi. Klassda bitta constructor boʻlsa, Spring 4.3 dan beri @Autowired yozish shart emas.
Field injectionʼda (@Autowired private OrderRepository repo;) field final boʻlolmaydi va constructor ishlayotgan paytda u hali null. Testda uni toʻldirish uchun Spring context yoki reflection kerak. Dependencyʼlar soni 7–8 taga yetganini ham sezmay qolasiz; constructorʼda esa bu darhol koʻzga tashlanadi va klass juda koʻp ish qilayotganini bildiradi.
Constructor injection circular dependencyʼni ham darhol koʻrsatadi: ikki bean bir-birini constructorʼda talab qilsa, context ishga tushmaydi. Setter injection ixtiyoriy dependency uchun qoladi.
@Test
void calculatesTotal() {
// Spring context kerak emas
var service = new OrderService(
new InMemoryOrderRepository(),
new FakePaymentClient());
assertEquals(1500, service.total(42));
}Singleton va prototype scope farqi nima? Prototype beanʼni singletonʼga inject qilsangiz nima boʻladi?Javob
Singleton — bitta container uchun bitta obyekt, default scope. Prototype — har safar soʻralganda yangi obyekt. Lekin singletonʼga inject qilingan prototype faqat bir marta, singleton yaratilganda olinadi — keyin u ham amalda bitta boʻlib qoladi.
Spring singletonʼi klassik Singleton pattern emas: u «bitta container ichida bitta», klass darajasida cheklov yoʻq — new bilan yana yaratish mumkin. Singleton bean hamma threadʼlar uchun umumiy, shuning uchun unda soʻrovga bogʻliq mutable field saqlash race conditionʼga olib keladi. Odatda servislar stateless yoziladi.
Injection bir marta — bean yaratilganda boʻladi. Singleton ichiga prototype inject qilinsa, singleton doim oʻsha bitta nusxani ishlatadi. Har safar yangisi kerak boʻlsa, ObjectProvider<T> inject qilinadi va getObject() chaqiriladi: har chaqiruv yangi obyekt beradi.
Request va session scope bilan ham shunga oʻxshash muammo: singleton yaratilayotganda hali HTTP soʻrov yoʻq. Shuning uchun bunday beanʼlar scoped proxy orqali inject qilinadi: singletonʼga proxy beriladi, u har bir chaqiruvda joriy soʻrovning obyektini topadi. @RequestScope va @SessionScope annotatsiyalari proxyʼni oʻzi yoqadi.
@Component
@Scope("prototype")
class Draft { /* holatli obyekt */ }
@Service
class ReportService {
private final ObjectProvider<Draft> drafts;
ReportService(ObjectProvider<Draft> drafts) {
this.drafts = drafts;
}
Report build(List<Row> rows) {
// har chaqiruvda yangi Draft
Draft d = drafts.getObject();
return d.addAll(rows).toReport();
}
}NoUniqueBeanDefinitionException nega chiqadi va bir turdagi bir nechta beanʼdan keraklisini qanday tanlaysiz?Javob
Injection nuqtasiga turi mos keladigan bean bir nechta va qaysi biri kerakligi aniq emas. Bittasini @Primary bilan default qilish, @Qualifier bilan aniq nomini koʻrsatish yoki hammasini List yoki Map sifatida olish mumkin.
Spring avval tur boʻyicha qidiradi. Nomzodlar bir nechta boʻlsa, ularni @Qualifier boʻyicha saralaydi, keyin @Primary belgilanganini tanlaydi. Bu ham yordam bermasa, parametr yoki field nomi bean nomiga mos kelsa, oʻshani oladi (constructor parametrining nomi uchun kod -parameters bilan kompilyatsiya qilingan boʻlishi kerak — Spring Bootʼning Gradle plugini va parent POMʼi buni oʻzi yoqadi). Hech biri ishlamasa — exception, context ishga tushmaydi.
List<PaymentProvider> inject qilinsa, Spring shu turdagi hamma beanʼlarni beradi, ularning tartibini @Order belgilaydi. Map<String, PaymentProvider>da kalit — bean nomi: strategiyani nom boʻyicha tanlash uchun qulay.
ObjectProvider<T> beanʼni darhol emas, kerak boʻlganda oladi: getIfAvailable() bean boʻlmasa null qaytaradi, getIfUnique() bir nechta boʻlsa ham exception tashlamaydi, orderedStream() hammasini tartib bilan beradi. Ixtiyoriy dependency va prototype beanʼlar uchun mos.
@Service
class PaymentService {
private final Map<String, PaymentProvider> byName;
private final PaymentProvider fallback;
PaymentService(Map<String, PaymentProvider> byName,
@Qualifier("click")
PaymentProvider fallback) {
this.byName = byName;
this.fallback = fallback;
}
void pay(String provider, long amount) {
byName.getOrDefault(provider, fallback)
.pay(amount);
}
}2Spring Boot: ishga tushish, auto-configuration va konfiguratsiya
Spring Boot — Spring Framework ustidagi qatlam: u beanʼlarning katta qismini oʻzi sozlaydi, web serverni ilova ichiga joylaydi va sozlamalarni bir joyga yigʻadi. Hammasi bitta annotatsiya va bitta metoddan boshlanadi:
@SpringBootApplication
public class ShopApplication {
public static void main(String[] args) {
SpringApplication.run(
ShopApplication.class, args);
}
}@SpringBootApplication — uchta annotatsiyaning birikmasi: @SpringBootConfiguration (bu klass ham @Configuration), @EnableAutoConfiguration (auto-configurationʼni yoqadi) va @ComponentScan (shu klass turgan paket va uning ichki paketlarini skanerlaydi). Shuning uchun main klass paketlarning eng yuqorisida turadi: undan tashqaridagi paketdagi @Service topilmaydi.
SpringApplication.run avval ilova turini aniqlaydi (classpathʼda Spring MVC bormi, WebFlux bormi), Environmentni tayyorlaydi — application.yml, environment variableʼlar, argumentlar — va mos ApplicationContext yaratadi. Keyin contextʼning refresh() bosqichi boshlanadi:
| Bosqich | Nima boʻladi |
|---|---|
| Bean definitionʼlar | ConfigurationClassPostProcessor (oʻzi ham BeanFactoryPostProcessor) component scanning, @Configuration va auto-configurationʼni oʻqib BeanDefinitionʼlar tuzadi; hali obyekt yoʻq |
Qolgan BeanFactoryPostProcessorʼlar | definitionʼlar obyektlar yaratilishidan oldin oʻzgartirilishi mumkin |
| Embedded server tayyorlanadi | Tomcat (yoki Jetty) yaratiladi, lekin port hali ochilmagan |
| Singleton beanʼlar | lazy boʻlmagan hamma singletonʼlar dependency tartibida yaratiladi |
| Server ishga tushadi | port ochiladi va soʻrovlar qabul qilina boshlaydi |
Runnerʼlar, ApplicationReadyEvent | CommandLineRunner va ApplicationRunner chaqiriladi, keyin ilova tayyor deb eʼlon qilinadi |
Auto-configuration — Spring Boot ichidagi oddiy @Configuration klasslar, faqat ularning har biri shartli. Ularning roʻyxati har bir jarʼdagi META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports faylida turadi (Boot 2.7 gacha spring.factoriesda edi, Boot 3 da auto-configuration spring.factories orqali endi yuklanmaydi). Bu klasslar sizning konfiguratsiyangizdan keyin qayta ishlanadi, shuning uchun ularning shartlari sizning beanʼlaringizni allaqachon koʻradi:
DataSource beanʼi bor. Auto-configuration klasslari undan keyin, navbat bilan tekshiriladi.| Annotatsiya | Shart |
|---|---|
@ConditionalOnClass | koʻrsatilgan klass classpathʼda bor |
@ConditionalOnMissingBean | bunday turdagi bean hali yoʻq — oʻzingiz yozsangiz, Boot oʻzinikini yaratmaydi |
@ConditionalOnProperty | property berilgan qiymatga ega (masalan, app.audit.enabled=true) |
@ConditionalOnBean | boshqa bir bean allaqachon bor |
@ConditionalOnWebApplication | ilova web ilova sifatida ishga tushgan |
Starter — deyarli kodsiz dependency toʻplami: spring-boot-starter-web Spring MVC, embedded Tomcat va Jacksonʼni olib keladi. Kutubxonalar classpathʼga tushgach, ularga mos auto-configuration shartlari bajariladi va beanʼlar paydo boʻladi. Boot 4 da starterʼlar mayda modullarga boʻlindi: masalan, spring-boot-starter-web oʻrniga spring-boot-starter-webmvc.
Qaysi auto-configuration ishlagani va qaysi biri nega ishlamagani conditions reportʼda koʻrinadi: ilovani --debug argumenti yoki debug=true property bilan ishga tushirsangiz, u logga chiqadi; Actuator boʻlsa — /actuator/conditions endpointʼida (uni expose qilish kerak). Keraksiz auto-configuration @SpringBootApplication(exclude = ...) yoki spring.autoconfigure.exclude property bilan oʻchiriladi.
Sozlamalar application.yml (yoki application.properties) faylida turadi. YAML ierarxik: spring.datasource.url uch darajali kalit boʻlib yoziladi, roʻyxat elementlari - bilan, bitta fayldagi alohida hujjatlar esa --- bilan ajratiladi. Bir xil property bir nechta joyda berilishi mumkin, va ulardan biri ustun keladi. Soddalashtirilgan tartib — pastdagisi yuqoridagini bosib ketadi:
| Manba | Misol |
|---|---|
jar ichidagi application.yml | default qiymatlar |
jar ichidagi application-{profile}.yml | application-prod.yml |
jar tashqarisidagi application.yml va application-{profile}.yml | serverdagi fayl |
| OS environment variable | SPRING_DATASOURCE_URL |
| Java system property | -Dserver.port=9090 |
| command line argument | --server.port=9090 |
Environment variable nomi property nomidan shunday hosil boʻladi: nuqta _ bilan almashtiriladi, tire olib tashlanadi, hammasi katta harf. spring.datasource.url → SPRING_DATASOURCE_URL, app.payment.read-timeout → APP_PAYMENT_READTIMEOUT. Docker va Kubernetesʼda sozlamalar odatda shu yoʻl bilan beriladi, parol va kalitlar esa repodagi faylga emas, environmentʼga yoki secret storeʼga qoʻyiladi.
Profile — muhitga xos sozlamalar toʻplami. spring.profiles.active=prod berilsa, application.ymldan keyin application-prod.yml ham oʻqiladi va uning qiymatlari ustun keladi. @Profile("dev") bilan beanʼni ham faqat bitta muhitda yaratish mumkin.
Bir guruh sozlamani tiplangan obyektga bogʻlash uchun @ConfigurationProperties ishlatiladi. Record bilan yozilsa, qiymatlar constructor orqali beriladi va obyekt immutable boʻladi; @Validated bilan notoʻgʻri sozlamada ilova ishga tushmaydi. Klass @ConfigurationPropertiesScan yoki @EnableConfigurationProperties(PaymentProperties.class) bilan yoqiladi:
app:
payment:
base-url: https://pay.example.com
read-timeout: 5s@Validated
@ConfigurationProperties("app.payment")
public record PaymentProperties(
@NotBlank String baseUrl,
Duration readTimeout,
@DefaultValue("3") int retries) {
}Tushunganingizni tekshiring
Spring Boot ilovasi ishga tushganda nima boʻladi?Javob
SpringApplication.run Environmentni tayyorlaydi va ApplicationContext yaratadi. Context refresh() paytida bean definitionʼlarni yigʻadi — component scanning va auto-configuration shu yerda — keyin singleton beanʼlarni yaratadi va embedded serverni ishga tushiradi. Oxirida runnerʼlar chaqiriladi va ApplicationReadyEvent chiqadi.
@SpringBootApplicationdagi @ComponentScan main klass paketidan boshlab @Component va uning turlarini qidiradi, @EnableAutoConfiguration esa auto-configuration klasslarini import qiladi. Ikkalasi ham dastlab faqat BeanDefinition beradi: qaysi klassdan, qaysi scope bilan, nimaga bogʻliq.
Servlet ilova uchun AnnotationConfigServletWebServerApplicationContext yaratiladi. refresh() ichida embedded Tomcat tayyorlanadi, lekin port faqat hamma singleton beanʼlar yaratilgandan keyin ochiladi. Shuning uchun bean yaratishda xato boʻlsa, ilova birorta soʻrov qabul qilmasdan toʻxtaydi.
Port ochilgach ApplicationStartedEvent chiqadi, CommandLineRunner va ApplicationRunner beanʼlari chaqiriladi, oxirida ApplicationReadyEvent. Ishga tushishda bir marta bajariladigan ish — masalan, cacheʼni isitish — shu yerga qoʻyiladi, @PostConstructga emas: u paytda beanʼning oʻz proxyʼsi hali yaratilmagan boʻladi.
Auto-configuration qanday ishlaydi va Boot yaratgan beanʼni qanday almashtirasiz?Javob
Auto-configuration — Boot ichidagi shartli @Configuration klasslar. Ular classpathʼdagi kutubxonalar, propertyʼlar va mavjud beanʼlarga qarab bean yaratadi. Koʻp beanʼlar @ConditionalOnMissingBean bilan belgilangan: shu turdagi beanʼni oʻzingiz yozsangiz, Boot oʻzinikini yaratmaydi.
@EnableAutoConfiguration auto-configuration klasslari roʻyxatini AutoConfiguration.imports fayllaridan oʻqiydi — har bir starter yoki kutubxona oʻz faylini olib kelishi mumkin. Bu klasslar sizning konfiguratsiyangizdan keyin qayta ishlanadi: shuning uchun @ConditionalOnMissingBean sizning beanʼlaringizni koʻra oladi.
Avval klass darajasidagi shartlar tekshiriladi: masalan, @ConditionalOnClass bajarilmasa, butun konfiguratsiya oʻtkazib yuboriladi. Keyin har bir @Bean metodining oʻz shartlari. Boot beanʼini toʻliq almashtirish shart boʻlmasa, odatda uning propertyʼlarini oʻzgartirish yoki ...Customizer beanʼini yozish yetarli: ObjectMapperni Bootʼning builderʼisiz oʻzingiz yaratsangiz, spring.jackson.* sozlamalari endi unga taʼsir qilmaydi, customizer esa Boot yaratgan obyektga faqat qoʻshimcha sozlama qoʻshadi. Boot 4 da Jackson 3 ga oʻtilgan va bu customizer JsonMapperBuilderCustomizer deb ataladi.
Nima boʻlganini taxmin qilish shart emas: conditions report har bir auto-configuration uchun qaysi shart bajarilgani yoki bajarilmaganini «Positive matches» va «Negative matches» boʻlimlarida yozadi. U debug=true bilan logga chiqadi yoki Actuatorʼdagi /actuator/conditions endpointʼida koʻrinadi.
@Configuration
class JsonConfig {
// Boot yaratgan ObjectMapper qoladi,
// unga faqat bitta sozlama qoʻshiladi
@Bean
Jackson2ObjectMapperBuilderCustomizer json() {
return b -> b.failOnUnknownProperties(true);
}
}Bitta property application.ymlda ham, environment variableʼda ham berilsa, qaysi biri ishlaydi? Profileʼlar bunga qanday taʼsir qiladi?Javob
Environment variable ustun keladi: Spring Boot property manbalarini qatʼiy tartibda koʻradi va command line argument, system property va environment variable konfiguratsiya fayllaridan ustun turadi. Fayllar orasida esa profileʼga xos application-prod.yml oddiy application.ymlni bosib ketadi.
Shu tartib tufayli bitta jar har xil muhitda ishlaydi: default qiymatlar application.ymlda, muhitga xoslari profile faylida, parollar va muhitga bogʻliq manzillar esa environment variableʼda. Docker yoki Kubernetesʼda SPRING_DATASOURCE_URL berish faylni oʻzgartirmasdan sozlamani almashtiradi.
Profile spring.profiles.active (yoki SPRING_PROFILES_ACTIVE) bilan yoqiladi. Bir nechta profile yoqilsa, roʻyxatda keyinroq turgani ustun. Bitta faylning ichida ham --- bilan ajratilgan qismni spring.config.activate.on-profile orqali faqat bitta profileʼga bogʻlash mumkin.
Profileʼlarni kod ichidagi ifga aylantirmaslik kerak: @Profile("prod") bilan belgilangan beanʼlar koʻpaysa, testda tekshirilgan konfiguratsiya bilan productionʼdagisi bir-biridan uzoqlashadi. Muhitlar orasidagi farq iloji boricha faqat sozlama qiymatlarida qolgani maʼqul.
# application.yml — hamma muhit uchun
app:
payment:
read-timeout: 5s
---
spring:
config:
activate:
on-profile: prod
app:
payment:
read-timeout: 2s
# APP_PAYMENT_READTIMEOUT=3s ikkalasini
# ham bosib ketadi3REST controller va soʻrovning yoʻli
@RestController — @Controller va @ResponseBody birikmasi: metod qaytargan obyekt view nomi emas, javobning tanasi deb qaraladi va JSONʼga aylantiriladi. Mapping annotatsiyalari URL va HTTP metodni controller metodiga bogʻlaydi, parametr annotatsiyalari esa soʻrovning qaysi qismini olishni bildiradi:
@RestController
@RequestMapping("/orders")
class OrderController {
private final OrderService orders;
OrderController(OrderService orders) {
this.orders = orders;
}
@GetMapping("/{id}")
OrderDto get(@PathVariable long id) {
return orders.find(id);
}
@PostMapping
ResponseEntity<OrderDto> create(
@Valid @RequestBody CreateOrder req) {
OrderDto dto = orders.create(req);
var uri = URI.create("/orders/" + dto.id());
return ResponseEntity.created(uri).body(dto);
}
}Status kod — javobning bir qismi, u klientga nima boʻlganini aytadi. Topilmagan resurs uchun 200 va boʻsh tana emas, 404; yaratilgan resurs uchun 201 va Location header; tanasiz muvaffaqiyatli javob uchun 204. Koʻp ishlatiladiganlari:
| Kod | Qachon |
|---|---|
| 200 OK | muvaffaqiyatli, tanasi bor |
| 201 Created | yangi resurs yaratildi; Location header — uning manzili |
| 204 No Content | muvaffaqiyatli, tana yoʻq (masalan, DELETE) |
| 400 Bad Request | soʻrov notoʻgʻri: validatsiyadan oʻtmadi yoki JSON buzilgan |
| 401 / 403 | 401 — kim ekanligi aniqlanmagan; 403 — aniqlangan, lekin ruxsat yoʻq |
| 404 Not Found | resurs topilmadi |
| 409 Conflict | joriy holat bilan ziddiyat: masalan, bunday email allaqachon bor |
| 500 Internal Server Error | serverdagi kutilmagan xato — klient aybdor emas |
Kiruvchi maʼlumot @Valid bilan tekshiriladi: DTOʼdagi @NotBlank, @Email, @Positive kabi Bean Validation annotatsiyalari ishlaydi (buning uchun spring-boot-starter-validation kerak). Tekshiruvdan oʻtmasa, controller metodi umuman chaqirilmaydi — MethodArgumentNotValidException chiqadi va default holatda javob 400 boʻladi.
Xatolarni har bir controllerʼda try/catch bilan ushlash oʻrniga ular bir joyda — @RestControllerAdvice klassida ishlanadi. Undagi @ExceptionHandler metodlari exception turini status kod va javob tanasiga aylantiradi. Spring 6 dan javob tanasi uchun standart format bor — ProblemDetail (RFC 9457, avvalgi RFC 7807):
@RestControllerAdvice
class ApiErrors {
@ExceptionHandler(OrderNotFound.class)
ProblemDetail notFound(OrderNotFound e) {
return ProblemDetail.forStatusAndDetail(
HttpStatus.NOT_FOUND, e.getMessage());
}
@ExceptionHandler(DuplicateEmail.class)
ProblemDetail conflict(DuplicateEmail e) {
return ProblemDetail.forStatusAndDetail(
HttpStatus.CONFLICT, e.getMessage());
}
}Soʻrov controllerʼga yetguncha bir necha qatlamdan oʻtadi. Ularni bilish xatoni qayerda ushlash kerakligini, autentifikatsiya qayerda qilinishini va nega baʼzi exceptionʼlar @ControllerAdvicega yetib kelmasligini tushuntiradi:
POST /orders Tomcat threadʼiga keldi. Avval u servlet filterʼlardan oʻtadi — masalan, Spring Security filterʼlari. Ular DispatcherServletdan tashqarida.Filter — Servlet APIʼning qismi: u DispatcherServletdan oldin turadi va har qanday soʻrovni, hatto Spring MVC controllerʼi boʻlmagan soʻrovni ham koʻradi. Spring Security shu darajada ishlaydi. HandlerInterceptor esa Spring MVCʼniki: u DispatcherServlet ichida, handler topilgandan keyin ishlaydi va qaysi controller metodi chaqirilishini biladi.
| Jihat | Filter | HandlerInterceptor |
|---|---|---|
| Qayerda | servlet container, DispatcherServletdan oldin | DispatcherServlet ichida |
| Nimani koʻradi | soʻrov va javob (HttpServletRequest, HttpServletResponse) | soʻrov, javob va tanlangan handler — controller metodi |
| Metodlar | doFilter: zanjirning keyingi qadamini oʻzi chaqiradi | preHandle, postHandle, afterCompletion |
Exception @ControllerAdvicega yetadimi | yoʻq | ha, preHandle va postHandledan |
| Odatda nima uchun | security, logging, soʻrovni oʻrash | controllerʼga bogʻliq tekshiruvlar, oʻlchovlar |
Tushunganingizni tekshiring
Controller metodi qaytargan obyekt qanday qilib JSON boʻlib qoladi? Status kodni qanday tanlaysiz?Javob
@RestController metodining natijasi HttpMessageConverterga beriladi: klientning Accept headerʼi va classpathʼdagi kutubxonalarga qarab mos converter tanlanadi — Spring Bootʼda JSON uchun bu Jackson. Status default holatda 200; boshqasi kerak boʻlsa, ResponseEntity, @ResponseStatus yoki exception handler orqali beriladi.
Kirishda ham xuddi shunday: @RequestBody parametri uchun converter soʻrov tanasini Content-Type boʻyicha oʻqiydi va obyektga aylantiradi. JSON buzilgan boʻlsa — HttpMessageNotReadableException va 400.
ResponseEntity status, header va tanani birga beradi: ResponseEntity.created(uri).body(dto) — 201 va Location, ResponseEntity.noContent().build() — 204. Metod doim bir xil status qaytarsa, unga @ResponseStatus(HttpStatus.CREATED) qoʻyish yetarli.
Entity klassini toʻgʻridan-toʻgʻri qaytarish xavfli: ichki fieldʼlar (parol hash, ichki ID) tashqariga chiqib ketadi, entityʼdagi har bir oʻzgarish esa API kontraktini buzadi. Kirish va chiqish uchun alohida DTO yoziladi — koʻpincha record.
@Valid bilan validatsiya qanday ishlaydi va xatolarni qanday qilib bir joyda, toʻgʻri status bilan qaytarasiz?Javob
@Valid @RequestBody obyektni controller metodi chaqirilishidan oldin Bean Validation bilan tekshiradi; xato boʻlsa, MethodArgumentNotValidException chiqadi. Exceptionʼlar @RestControllerAdvicedagi @ExceptionHandlerlarda status kod va bir xil formatdagi javobga, masalan ProblemDetailga, aylantiriladi.
Validatsiya HandlerAdapter metod argumentlarini tayyorlayotganda boʻladi, shuning uchun xato boʻlsa controller kodi umuman ishlamaydi. Klientga qaysi field notoʻgʻri ekanini aytish uchun MethodArgumentNotValidExceptionni adviceʼda ushlab, getBindingResult().getFieldErrors()dan field nomlari va xabarlarni olasiz. Ichma-ich obyekt ham tekshirilishi uchun uning fieldʼiga ham @Valid qoʻyiladi.
Spring 6.1 dan @RequestParam yoki @PathVariablega toʻgʻridan-toʻgʻri qoʻyilgan constraintʼlar (@Min, @Size) ham Spring MVCʼning oʻzida tekshiriladi, ularning xatosi HandlerMethodValidationException boʻladi. Shunday constraint birorta parametrda boʻlsa (@Valid parametrdagi @NotNull ham), @RequestBody xatosi ham HandlerMethodValidationException boʻladi — adviceʼda ikkalasini ham ushlang. Ilgari buning uchun klassga @Validated qoʻyilardi; endi u qolsa, tekshiruv eski yoʻl bilan, AOP proxy orqali ishlaydi.
Adviceʼda eng aniq exception turiga mos handler tanlanadi, controllerʼning oʻz ichidagi @ExceptionHandler esa adviceʼdagidan ustun. Kutilmagan exceptionʼlar uchun umumiy Exception handler 500 qaytaradi va xatoni logga yozadi — stack trace klientga chiqmaydi. Spring Bootʼda spring.mvc.problemdetails.enabled=true Spring MVCʼning oʻz exceptionʼlari uchun ham ProblemDetail formatini yoqadi.
record CreateOrder(
@NotNull Long productId,
@Positive int quantity,
@Valid @NotNull Address address) {
}
record Address(@NotBlank String city,
@NotBlank String street) {
}Filter va HandlerInterceptor farqi nima? @ControllerAdvice qayerda ishlaydi?Javob
Filter servlet darajasida, DispatcherServletdan oldin ishlaydi va hamma soʻrovni koʻradi. Interceptor Spring MVC ichida, handler topilgandan keyin ishlaydi va qaysi controller metodi chaqirilishini biladi. @ControllerAdvice ham DispatcherServlet ichida: u controller va interceptorʼlardan chiqqan exceptionʼlarni ushlaydi, filterʼdagilarni emas.
DispatcherServlet — front controller: hamma soʻrov bitta servletʼga keladi. U HandlerMappingdan handlerʼni — controller metodini va unga tegishli interceptorʼlarni — oladi, interceptorʼlarning preHandleini chaqiradi, keyin HandlerAdapter orqali metodni chaqiradi: argument resolverʼlar parametrlarni tayyorlaydi, natijani esa HttpMessageConverter javobga yozadi.
Exception chiqsa, DispatcherServlet uni HandlerExceptionResolverʼlarga beradi; ulardan biri @ExceptionHandler metodlarini — avval controllerʼning oʻzida, keyin @ControllerAdviceda — qidiradi. Filter bu zanjirdan tashqarida: unda chiqqan exception servlet containerʼga ketadi va javobni Spring Bootʼning /error sahifasi beradi.
Tuzoq: @ResponseBody yoki ResponseEntity qaytaradigan metodlarda javob HandlerAdapter ichida yoziladi va commit qilinadi, shuning uchun postHandleda javobni oʻzgartirib boʻlmaydi. preHandle true qaytargan boʻlsa, xato boʻlganda ham chaqiriladigan joy — afterCompletion. Autentifikatsiya va security uchun Spring hujjatlari interceptorʼni emas, filter darajasini — Spring Securityʼni — tavsiya qiladi.
4Boshqa servislarni chaqirish: HTTP client va Spring Cloud
Springʼda uchta HTTP client bor: RestTemplate — eng eskisi, WebClient — reactive, RestClient — Spring 6.1 (Spring Boot 3.2) da qoʻshilgan yangi sinxron client. Yangi sinxron kod uchun RestClient olinadi: APIʼsi WebClientga oʻxshash fluent, lekin chaqiruv oddiy, bloklovchi. Spring Framework 7.0 hujjatlarida RestTemplate RestClient foydasiga deprecated deb eʼlon qilingan, 7.1 da (Spring Boot 4.2) klassning oʻzi @Deprecated(forRemoval = true) boʻladi, 8.0 da esa olib tashlanadi.
| Client | Model | Qachon |
|---|---|---|
RestClient | sinxron, fluent API | Spring MVC ilovasida yangi kod uchun |
WebClient | reactive, non-blocking | WebFlux ilovasi yoki streaming |
RestTemplate | sinxron, template metodlar | eski kod; yangi kodda ishlatilmaydi |
Timeout — eng koʻp unutiladigan sozlama. JDK HttpClientda ham, HttpURLConnectionda ham default holatda javobni kutish vaqti cheklanmagan: sekin ishlayotgan servis soʻrovni bajarayotgan threadʼni cheksiz ushlab turadi. Bunday threadʼlar yigʻilib, ilova yangi soʻrovlarga javob bermay qoladi. Timeout ikki xil: connect timeout — ulanishni oʻrnatish uchun, read timeout — javobni kutish uchun.
@Configuration
class PaymentClientConfig {
@Bean
RestClient paymentClient(RestClient.Builder b) {
var http = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(2))
.build();
var rf = new JdkClientHttpRequestFactory(http);
rf.setReadTimeout(Duration.ofSeconds(5));
return b.baseUrl("https://pay.example.com")
.requestFactory(rf)
.build();
}
}Spring Boot 3.4 dan timeoutʼlarni property bilan ham berish mumkin: spring.http.client.connect-timeout va spring.http.client.read-timeout (Boot 4 da spring.http.clients.*). Bootʼning RestClient.Builderini inject qilib ishlatish maʼqul: unda Boot sozlagan JSON converterʼlar va metrika, tracing allaqachon ulangan.
Klientni interfeys sifatida ham yozish mumkin — @HttpExchange (Spring 6). Spring interfeys uchun proxy yaratadi, u har bir metod chaqiruvini HTTP soʻrovga aylantiradi:
@HttpExchange("/payments")
interface PaymentApi {
@PostExchange
PaymentResult create(@RequestBody NewPayment p);
@GetExchange("/{id}")
PaymentResult get(@PathVariable String id);
}
@Bean
PaymentApi paymentApi(RestClient paymentClient) {
var adapter = RestClientAdapter.create(
paymentClient);
return HttpServiceProxyFactory.builderFor(adapter)
.build()
.createClient(PaymentApi.class);
}Spring Framework 7 da bunday interfeyslarni guruhlab roʻyxatdan oʻtkazish uchun @ImportHttpServices qoʻshildi, Spring Boot 4 esa ularni spring.http.serviceclient.<guruh>.base-url kabi propertyʼlar bilan sozlaydi.
Spring Cloud — taqsimlangan tizim uchun vositalar toʻplami. Ularning baʼzilari Kubernetes oʻzi beradigan narsalarni takrorlaydi:
| Vosita | Nima qiladi | Kubernetesʼda |
|---|---|---|
| OpenFeign | interfeys orqali deklarativ HTTP client | Kubernetesga bogʻliq emas; loyiha feature-complete, oʻrniga @HttpExchange tavsiya etiladi |
| Config Server | hamma servislar sozlamasi bitta joyda, koʻpincha Gitʼda | koʻp holatda ConfigMap va Secret yetarli |
| Service discovery (Eureka) | servislar bir-birini nom boʻyicha topadi | Kubernetes Service va DNS buni oʻzi qiladi |
| Spring Cloud Gateway | routing, filterʼlar, rate limiting | oddiy routing uchun Ingress yoki Gateway API; ilovaga xos logika boʻlsa — Gateway |
| Circuit breaker (Resilience4j) | ishlamayotgan servisga chaqiruvlarni vaqtincha toʻxtatadi | hali ham kerak (yoki service mesh) |
Tushunganingizni tekshiring
Boshqa servisni qaysi client bilan chaqirasiz va xato va timeoutʼlarni qanday ishlaysiz?Javob
Sinxron ilovada — RestClient, reactive ilovada — WebClient. Har bir client uchun connect va read timeout aniq beriladi, chunki default holatda javobni kutish cheklanmagan boʻlishi mumkin. 4xx va 5xx javoblar default holatda exception boʻladi, ularni onStatus bilan oʻz exceptionʼingizga aylantirasiz.
retrieve() 4xx da HttpClientErrorException, 5xx da HttpServerErrorException tashlaydi — ikkalasi ham RestClientResponseException. Timeout yoki ulanish xatosi esa ResourceAccessException boʻladi. Bu exceptionʼlarni servis qatlamigacha olib chiqmasdan, client ichida domenga mos xatoga aylantirgan maʼqul: PaymentDeclined, PaymentUnavailable.
Retry faqat idempotent soʻrovlar uchun xavfsiz: GET yoki idempotency key bilan yuborilgan POST. Aks holda timeout boʻlgan, lekin aslida bajarilgan toʻlov ikki marta oʻtadi. Spring Framework 7 da @Retryable va RetryTemplate frameworkʼning oʻziga qoʻshildi; Boot 3 da buning uchun Spring Retry yoki Resilience4j ishlatiladi.
Ishlamay qolgan servisga timeout yetarli emas: har bir soʻrov baribir timeoutʼgacha kutadi. Circuit breaker (masalan, Resilience4j) xatolar koʻpayganda chaqiruvlarni vaqtincha darhol rad etadi va servisga tiklanishga vaqt beradi.
PaymentResult charge(NewPayment p) {
return client.post()
.uri("/payments")
.body(p)
.retrieve()
.onStatus(HttpStatusCode::is4xxClientError,
(req, res) -> {
throw new PaymentDeclined(
res.getStatusCode());
})
.body(PaymentResult.class);
}Kubernetesʼda ishlaydigan ilovaga Spring Cloudʼning qaysi qismlari hali kerak?Javob
Service discovery va client-side load balancing koʻpincha kerak emas — buni Kubernetes Service va DNS qiladi. Sozlamalar uchun koʻp holatda ConfigMap va Secret yetarli. Circuit breaker va retry kabi resilience vositalari, ilovaga xos logikali gateway esa hali ham foydali.
Kubernetesʼda http://payment-service deb murojaat qilish kifoya: DNS Serviceʼni topadi va soʻrov tirik podʼlardan biriga boradi. Eureka va Spring Cloud LoadBalancer shu ishni ilova ichida qiladi — Kubernetesʼda bu ikkinchi, ortiqcha qatlam.
ConfigMap va Secret podʼga environment variable yoki fayl sifatida beriladi, Spring Boot ularni oddiy property sifatida oʻqiydi (fayllar uchun spring.config.import=configtree:...). Config Server esa sozlama Git tarixi bilan versiyalanishi, koʻp servisga umumiy boʻlishi yoki restartʼsiz yangilanishi kerak boʻlganda oʻzini oqlaydi.
OpenFeign loyihasi 2022 yil oxirida feature-complete deb eʼlon qilingan: yangi imkoniyatlar qoʻshilmaydi, oʻrniga Springʼning oʻz HTTP interfeyslari (@HttpExchange) tavsiya etiladi. Routing va TLS uchun Kubernetes Ingress yoki Gateway API yetarli; Spring Cloud Gateway token tekshirish, foydalanuvchi boʻyicha rate limiting yoki soʻrovni oʻzgartirish kabi ilovaga xos ish kerak boʻlganda olinadi.
5Testlash: @SpringBootTest va slice testlar
Spring ilovasini uch darajada test qilish mumkin. Unit test — Springʼsiz: constructor injection tufayli klassni new bilan yaratib, dependencyʼlar oʻrniga fake yoki mock berasiz. @SpringBootTest — butun contextʼni koʻtaradi. Slice testlar — oʻrtasi: contextʼda faqat bitta qatlam uchun kerakli beanʼlar boʻladi.
| Annotatsiya | Contextʼda nima boʻladi | Nima uchun |
|---|---|---|
@SpringBootTest | hamma beanʼlar va auto-configuration | qatlamlar birga toʻgʻri ishlashini tekshirish |
@WebMvcTest | controller, @ControllerAdvice, filter, converter, WebMvcConfigurer; servislar yoʻq | mapping, validatsiya, JSON, status kodlar |
@DataJpaTest | JPA, repositoryʼlar, DataSource | queryʼlar va mapping |
@JsonTest | faqat JSON (Jackson) | JSON shakli |
@SpringBootTest default holatda haqiqiy server ishga tushirmaydi (webEnvironment = MOCK): soʻrovlar @AutoConfigureMockMvc bilan sozlangan MockMvc orqali yuboriladi. RANDOM_PORT bilan esa haqiqiy Tomcat tasodifiy portda ishga tushadi va test unga HTTP orqali murojaat qiladi.
Spring test contextʼlarni cache qiladi: konfiguratsiyasi bir xil test klasslari bitta contextʼni qayta ishlatadi. Har bir yangi mock toʻplami, boshqa profile yoki property — alohida context, va testlar aynan shundan sekinlashadi.
@WebMvcTest(OrderController.class)
class OrderControllerTest {
@Autowired MockMvc mvc;
@MockitoBean OrderService orders;
@Test
void returns404WhenMissing() throws Exception {
when(orders.find(42))
.thenThrow(new OrderNotFound(42));
mvc.perform(get("/orders/42"))
.andExpect(status().isNotFound());
}
}Tushunganingizni tekshiring
@SpringBootTest va @WebMvcTest farqi nima? Qachon qaysi birini ishlatasiz?Javob
@SpringBootTest butun ilova contextʼini koʻtaradi — sekin, lekin qatlamlar birga ishlashini tekshiradi. @WebMvcTest faqat web qatlamini: controller, advice, filter, JSON; servislar yoʻq, ular mock bilan almashtiriladi. Mapping, validatsiya va status kodlarni tekshirish uchun slice test yetarli va ancha tez.
@WebMvcTest(OrderController.class) faqat shu controllerʼni va MVC infratuzilmasini yaratadi. @Service va @Repository beanʼlari contextʼga kirmaydi — ularni @MockitoBean bilan berasiz. Spring Security classpathʼda boʻlsa, uning filterʼlari ham ishlaydi, shuning uchun testda foydalanuvchini koʻrsatish kerak boʻladi.
@DataJpaTest repository qatlamini sinaydi: default holatda har bir test tranzaksiyada ishlaydi va oxirida rollback qilinadi. Natija productionʼga yaqin boʻlishi uchun Testcontainers bilan haqiqiy PostgreSQL koʻtariladi; Spring Boot 3.1 dan @ServiceConnection ulanish sozlamalarini containerʼdan oʻzi oladi. 3.4 gacha esa @DataJpaTestda @AutoConfigureTestDatabase(replace = Replace.NONE) kerak edi, aks holda baza embedded bazaga almashtirilardi.
Hammasini @SpringBootTest bilan yozish oson tuyuladi, lekin har bir context koʻtarilishi vaqt oladi va testlar koʻpaygan sari suite sekinlashadi. Odatda taqsimot shunday: biznes logika — oddiy unit test, web va repository qatlamlari — slice test, asosiy oqimlar — bir nechta @SpringBootTest.
Testda beanʼni mock bilan qanday almashtirasiz va bu nega testlarni sekinlashtirishi mumkin?Javob
@MockitoBean (Spring Framework 6.2) contextʼdagi beanʼni Mockito mock bilan almashtiradi, @MockitoSpyBean esa haqiqiy beanʼni spy bilan oʻraydi. Ular Spring Boot 3.4 da deprecated boʻlgan va Boot 4 da olib tashlangan @MockBean va @SpyBean oʻrnini egalladi. Har bir mock toʻplami context cache kalitining bir qismi.
Spring TestContext koʻtarilgan contextʼni uning konfiguratsiyasi boʻyicha cache qiladi. Ikki test klassi har xil beanʼlarni mock qilsa, ular bitta contextʼni boʻlisha olmaydi — har biri uchun yangi context koʻtariladi. Yuzlab test klassi boʻlganda suite vaqtining asosiy qismi aynan shunga ketadi.
Yechim — mockʼlarni umumiy joyga yigʻish: bir xil @MockitoBeanʼli abstract base klass yoki umumiy test konfiguratsiyasi. Tashqi servislar uchun mock oʻrniga koʻpincha WireMock kabi soxta HTTP server ishlatiladi: shunda HTTP client sozlamalari — URL, timeout, xatolarni ishlash — ham test qilinadi.
Mock chegarada maʼqul: tashqi servis, vaqt (Clock), tasodifiy qiymatlar. Oʻz kodingizdagi hamma narsani mock qilsangiz, test faqat mock sozlamalarini tekshiradigan boʻlib qoladi.
@SpringBootTest
class CheckoutFlowTest {
@MockitoBean PaymentApi payments;
@Autowired CheckoutService checkout;
@Test
void marksOrderPaid() {
when(payments.create(any()))
.thenReturn(PaymentResult.ok("p-1"));
checkout.pay(42L);
assertTrue(checkout.isPaid(42L));
}
}6Spring konteyneri qanday tuzilgan: BeanPostProcessor, proxy va AOP
Context ishga tushishi ikki bosqichdan iborat. Birinchisida obyektlar emas, ularning tavsifi yigʻiladi — BeanDefinition: klass, scope, lazy yoki yoʻq, constructor argumentlari, @Primary, init va destroy metodlari. Ikkinchisida shu tavsiflar boʻyicha obyektlar yaratiladi.
Har bir bosqichga kirish nuqtasi bor. BeanFactoryPostProcessor definitionʼlar bilan ishlaydi — u paytda hali birorta oddiy bean yaratilmagan. Masalan, @Configuration klasslarni oʻqib, @ComponentScan, @Import va @Bean metodlardan definition yaratadigan ConfigurationClassPostProcessor shunday ishlaydi. BeanPostProcessor esa har bir yaratilgan obyekt bilan ishlaydi: uni oʻzgartirishi yoki boshqa obyekt — masalan, proxy — bilan almashtirishi mumkin.
ConfigurationClassPostProcessor — oʻzi ham BeanFactoryPostProcessor — component scanning, @Bean metodlar va auto-configurationʼni oʻqib, har bir bean uchun BeanDefinition tuzadi: klass, scope, dependencyʼlar.Springʼning koʻp «sehri» aslida BeanPostProcessor: @Autowired va @Valueni AutowiredAnnotationBeanPostProcessor, @PostConstruct va @PreDestroyni CommonAnnotationBeanPostProcessor ishlaydi, @Transactional, @Cacheable va @Aspect uchun proxyʼni auto-proxy creator yaratadi, @Async uchun — AsyncAnnotationBeanPostProcessor.
Proxy — asl obyekt oʻrnida turadigan obyekt: u chaqiruvni qabul qiladi, oldin va keyin qoʻshimcha ish qiladi (tranzaksiya ochadi, cacheʼga qaraydi) va asl metodni chaqiradi. Spring AOP shu mexanizm ustiga qurilgan: aspect — qoʻshimcha logika joylashgan klass, pointcut — u qaysi metodlarga qoʻllanishi, advice — qachon ishlashi (@Before, @AfterReturning, @AfterThrowing, @After, @Around). Oʻz aspectʼlaringiz uchun spring-boot-starter-aop kerak (Boot 4 da spring-boot-starter-aspectj):
@Aspect
@Component
class TimingAspect {
private static final Logger log =
LoggerFactory.getLogger(TimingAspect.class);
@Around("@annotation(com.shop.LogTime)")
public Object time(ProceedingJoinPoint jp)
throws Throwable {
long start = System.nanoTime();
try {
return jp.proceed();
} finally {
long ms = (System.nanoTime() - start)
/ 1_000_000;
log.info("{} {}ms", jp.getSignature(), ms);
}
}
}Proxy ikki xil yaratiladi. JDK dynamic proxy — bean implement qilgan interfeyslarni implement qiladigan yangi klass; uni faqat interfeys turi orqali inject qilish mumkin. CGLIB proxy — bean klassining runtimeʼda yaratilgan subclassʼi. Spring Framework default holatda, interfeys boʻlsa, JDK proxyʼni tanlaydi, Spring Boot esa spring.aop.proxy-target-class=true bilan default holatda CGLIBʼni ishlatadi. Istisno: Boot 3 da faqat @Asyncli, interfeysli bean @EnableAsync(proxyTargetClass = true) boʻlmasa JDK proxy oladi; Spring Framework 7 da bu sozlama @Asyncga ham qoʻllanadi. Proxy nimani ushlay olmaydi:
| Holat | Nima boʻladi |
|---|---|
final klass | CGLIB undan subclass yarata olmaydi — proxy kerak boʻlsa, context ishga tushmaydi |
final metod | override qilinmaydi: chaqiruv proxy obyektining oʻzida bajariladi, advice ishlamaydi; proxyʼning fieldʼlari toʻldirilmagan, shuning uchun bu koʻpincha NullPointerException bilan tugaydi |
private metod | proxy uni koʻrmaydi va chaqira olmaydi — advice ishlamaydi |
klass ichidan this.method() | bu self-invocation: chaqiruv proxyʼdan oʻtmaydi, advice ishlamaydi |
new bilan yaratilgan obyekt | bean emas, unda proxy yoʻq |
Tushunganingizni tekshiring
BeanFactoryPostProcessor va BeanPostProcessor farqi nima? @Autowired va proxy qaysi bosqichda paydo boʻladi?Javob
BeanFactoryPostProcessor obyektlar yaratilishidan oldin BeanDefinitionʼlar bilan ishlaydi. BeanPostProcessor har bir yaratilgan obyekt bilan ishlaydi. @Autowired fieldʼlar obyekt yaratilgandan keyin, init metodlaridan oldin toʻldiriladi; proxy esa eng oxirida — postProcessAfterInitializationda, @PostConstructdan keyin yaratiladi.
Bitta bean uchun tartib: constructor (constructor injection shu yerda) → @Autowired fieldʼlar va setterʼlar → BeanNameAware kabi Aware callbackʼlar → postProcessBeforeInitialization (@PostConstruct shu yerda) → afterPropertiesSet va initMethod → postProcessAfterInitialization (proxy shu yerda). Container va boshqa beanʼlar oxirgi bosqich qaytargan obyektni oladi.
Amaliy xulosa: @PostConstruct ichida this hali proxy emas. U yerdan oʻz @Transactional yoki @Async metodingizni chaqirsangiz, annotatsiya ishlamaydi. Ishga tushishda tranzaksiya kerak boʻlsa, ApplicationReadyEvent listenerʼi yoki ApplicationRunner ishlatiladi — ular hamma beanʼlar tayyor boʻlgandan keyin chaqiriladi.
BeanPostProcessorʼlarning oʻzi oddiy beanʼlardan oldin yaratiladi. Ular dependency sifatida talab qilgan beanʼlar ham erta yaratiladi va hamma BeanPostProcessorʼlardan oʻta olmaydi — masalan, proxy olmaydi; logdagi «is not eligible for getting processed by all BeanPostProcessors» xabari shu haqida. BeanFactoryPostProcessor qaytaradigan @Bean metod esa static qilib yoziladi, aks holda u oʻzi turgan @Configuration klassni juda erta yaratib yuboradi.
Circular dependency qanday paydo boʻladi va Spring Boot nega uni default holatda taqiqlaydi?Javob
A beanʼga B kerak, B ga esa A — yoki uzunroq halqa. Constructor injectionʼda Spring buni oʻzi hal qila olmaydi. Field injection bilan Spring chala yaratilgan obyektni erta berib, halqani yopa olardi, lekin Spring Boot 2.6 dan bu default holatda oʻchirilgan va context xato bilan toʻxtaydi.
Constructor injectionʼda A ni yaratish uchun B kerak, B ni yaratish uchun A — hech biri birinchi boʻla olmaydi, Spring BeanCurrentlyInCreationException tashlaydi. Field injectionʼda esa Spring A ni constructor bilan yaratib, fieldʼlari hali toʻlmagan holda erta reference sifatida saqlab qoʻyadi va B ga shuni beradi. Proxy kerak boʻlsa, uni ham erta yaratadi.
Bu mexanizm halqani yashiradi: B ning @PostConstructi chala A ni koʻrishi mumkin, baʼzi BeanPostProcessorʼlar esa erta referenceʼni qoʻllab-quvvatlamaydi — @Async beanʼda «in its raw version as part of a circular reference» degan xato shundan. Shuning uchun Spring Boot 2.6 dan spring.main.allow-circular-references default holatda false.
Toʻgʻri yechim — dizaynni tuzatish: ikkala beanʼga kerak boʻlgan qismni uchinchi beanʼga ajratish, bogʻliqlikni bir tomonlama qilish yoki teskari chaqiruvni event bilan almashtirish. @Lazy injection nuqtasiga proxy beradi va halqani uzadi, lekin bu vaqtinchalik yechim: dizayndagi halqa qoladi, faqat koʻzdan yashirinadi.
@Service
class OrderService {
private final CustomerService customers;
OrderService(CustomerService customers) {
this.customers = customers;
}
}
@Service
class CustomerService {
private final OrderService orders;
// halqa: Order → Customer → Order
CustomerService(OrderService orders) {
this.orders = orders;
}
}Spring AOP qanday ishlaydi? JDK dynamic proxy va CGLIB farqi nima?Javob
Spring AOP proxy orqali ishlaydi: bean oʻrniga proxy inject qilinadi, u chaqiruvni ushlab, adviceʼlarni bajaradi va asl metodni chaqiradi. JDK dynamic proxy bean interfeyslarini implement qiladi, CGLIB esa bean klassidan subclass yaratadi. Spring Boot koʻp holatda CGLIBʼni ishlatadi.
JDK proxy faqat interfeys metodlarini ushlaydi va uning turi — interfeys. Beanʼni OrderServiceImpl klassi orqali inject qilib boʻlmaydi: contextdagi obyekt OrderServiceImpl emas, interfeysni implement qilgan proxy. CGLIB proxy klassning oʻzidan meros oladi, shuning uchun uni klass turi orqali ham inject qilish mumkin.
CGLIB uchun Spring runtimeʼda subclass yaratadi va uning metodlarini override qiladi. Cheklovlar shundan kelib chiqadi: final klassdan subclass yaratib boʻlmaydi, final va private metodlarni esa override qilib boʻlmaydi — ularda advice ishlamaydi. Kotlinʼda klasslar default holatda final, shuning uchun kotlin-spring plugini Spring annotatsiyali klasslarni avtomatik open qiladi.
Spring AOP faqat bean metodlarining tashqaridan chaqirilishini ushlaydi: field oʻqish, constructor yoki new bilan yaratilgan obyekt metodi ushlanmaydi. Bunday imkoniyat kerak boʻlsa, AspectJ weaving bor — u klass bytecodeʼini kompilyatsiya yoki yuklash paytida oʻzgartiradi, lekin uni kamdan-kam ishlatishadi.
7@Transactional: proxy, propagation va tuzoqlar
@Transactional — oldingi boʻlimdagi proxy mexanizmining eng koʻp ishlatiladigan qoʻllanishi. Proxy ichidagi TransactionInterceptor metoddan oldin tranzaksiya ochadi yoki mavjudiga qoʻshiladi, metod tugagach commit qiladi, RuntimeException yoki Error chiqsa — rollback. Connection joriy threadʼga bogʻlanadi, shuning uchun bitta tranzaksiya ichidagi hamma repository chaqiruvlari bitta connectionʼni ishlatadi.
orderService aslida proxy. Asl OrderService obyekti uning ichida turadi.Shundan muhim xulosa: tranzaksiya threadʼga bogʻliq. @Async metod yoki CompletableFuture.supplyAsync ichidagi kod boshqa threadʼda ishlaydi va chaqiruvchining tranzaksiyasini koʻrmaydi.
Propagation chaqirilgan metod mavjud tranzaksiyaga nima qilishini belgilaydi:
| Propagation | Tranzaksiya bor boʻlsa | Yoʻq boʻlsa |
|---|---|---|
REQUIRED (default) | unga qoʻshiladi | yangisini ochadi |
REQUIRES_NEW | uni toʻxtatib turadi va yangi, mustaqil tranzaksiya ochadi | yangisini ochadi |
SUPPORTS | unga qoʻshiladi | tranzaksiyasiz ishlaydi |
MANDATORY | unga qoʻshiladi | exception |
NOT_SUPPORTED | uni toʻxtatib turadi va tranzaksiyasiz ishlaydi | tranzaksiyasiz ishlaydi |
NEVER | exception | tranzaksiyasiz ishlaydi |
NESTED | savepoint bilan ichki tranzaksiya | yangisini ochadi |
Rollback qoidasining ham defaultʼi bor: RuntimeException va Error rollback qiladi, checked exception esa yoʻq — tranzaksiya commit boʻladi. Bu EJB davridan qolgan kelishuv: checked exception «kutilgan biznes holati» deb qaraladi.
Tranzaksiya ochiq turgan butun vaqt pooldagi bitta connection band boʻladi. Shuning uchun tranzaksiya qisqa boʻlishi kerak: uning ichida tashqi HTTP chaqiruv, fayl yuklash yoki uzoq hisob-kitob boʻlmagani maʼqul. REQUIRES_NEW esa bitta soʻrovga ikkita connection kerak qiladi — bu pool tugashining koʻp uchraydigan sababi.
Tushunganingizni tekshiring
@Transactional qanday ishlaydi va nega oʻsha klass ichidan chaqirilgan metodda ishlamaydi?Javob
Spring beanʼni proxy bilan oʻraydi: proxy metoddan oldin tranzaksiya ochadi, keyin commit yoki rollback qiladi. Klass ichidagi this.other() chaqiruvi proxyʼdan oʻtmaydi — u toʻgʻridan-toʻgʻri asl obyektga boradi, shuning uchun other()dagi @Transactional hisobga olinmaydi. Bu self-invocation muammosi.
Tashqi kod beanʼni chaqirganda aslida proxyʼni chaqiradi. Proxy TransactionInterceptor orqali PlatformTransactionManagerdan tranzaksiya oladi va asl metodni chaqiradi. Asl metod ichida this — asl obyekt, proxy emas: undan chaqirilgan hamma metodlar oddiy Java chaqiruvi.
Shu sababdan private metoddagi @Transactional ishlamaydi: proxy uni chaqira olmaydi. Spring 6.0 dan CGLIB proxy protected va package-private metodlarni ham ushlaydi, lekin faqat ular proxy orqali — boshqa klassdan chaqirilganda. JDK proxyʼda esa faqat interfeysdagi public metodlar.
Yechimlar: metodni alohida beanʼga koʻchirish (eng toʻgʻrisi), tranzaksiya chegarasini TransactionTemplate bilan kodda aniq belgilash yoki beanʼga oʻz proxyʼsini @Lazy bilan inject qilish. Oxirgisi ishlaydi, lekin dizayn muammosini yashiradi. AspectJ rejimi (mode = AdviceMode.ASPECTJ) self-invocationʼni ham ushlaydi, lekin weaving sozlashni talab qiladi.
@Service
class ImportService {
private final TransactionTemplate tx;
private final ProductRepository products;
ImportService(PlatformTransactionManager tm,
ProductRepository products) {
this.tx = new TransactionTemplate(tm);
this.products = products;
}
void importAll(List<Product> batch) {
for (Product p : batch) {
// har bir element alohida tranzaksiyada
tx.executeWithoutResult(
status -> products.save(p));
}
}
}REQUIRED va REQUIRES_NEW farqi nima? Ichki metod exception tashlasa nima boʻladi?Javob
REQUIRED mavjud tranzaksiyaga qoʻshiladi: ichki va tashqi metod bitta tranzaksiyada, biri rollback qilinsa — hammasi. REQUIRES_NEW tashqi tranzaksiyani toʻxtatib turadi va alohida connection bilan yangisini ochadi: u mustaqil commit yoki rollback qilinadi.
Klassik tuzoq: ichki REQUIRED metod RuntimeException tashladi, tashqi metod uni catch qilib, ishni davom ettirdi. Lekin ichki metodning proxyʼsi tranzaksiyani allaqachon rollback-only deb belgilab qoʻygan. Tashqi metod tugab, commit qilinmoqchi boʻlganda UnexpectedRollbackException chiqadi: «Transaction silently rolled back because it has been marked as rollback-only».
REQUIRES_NEW asosiy ish muvaffaqiyatsiz boʻlsa ham saqlanib qolishi kerak boʻlgan yozuvlar uchun: audit log, urinishlar hisobi. Lekin u bir vaqtning oʻzida ikkita connection ushlaydi: tashqi tranzaksiyaniki toʻxtatilgan, lekin poolʼga qaytarilmagan.
Pool shunday tugaydi: HikariCP default holatda 10 ta connection beradi. 10 ta parallel soʻrovning har biri bittadan connection olib, REQUIRES_NEW uchun ikkinchisini kutsa, hech biri uni ololmaydi — hammasi connectionTimeout (default 30 soniya) tugaguncha kutib, xato bilan tugaydi. Bu deadlockʼning bir turi: yuk ostida paydo boʻladi, oddiy testda esa koʻrinmaydi.
@Service
class AuditService {
private final AuditRepository entries;
AuditService(AuditRepository entries) {
this.entries = entries;
}
// place() rollback boʻlsa ham yozuv qoladi
@Transactional(propagation = REQUIRES_NEW)
public void record(String what, long id) {
entries.save(new AuditEntry(what, id));
}
}Nega checked exception tranzaksiyani rollback qilmaydi va buni qanday oʻzgartirasiz?Javob
Default qoida shunday: RuntimeException va Error rollback qiladi, checked exception esa commit. Buni @Transactional(rollbackFor = Exception.class) bilan metod darajasida, Spring 6.2 dan esa @EnableTransactionManagement(rollbackOn = ALL_EXCEPTIONS) bilan butun ilova uchun oʻzgartirish mumkin.
Masalan, metod bazaga buyurtmalarni yozdi, keyin faylni arxivga koʻchirishda IOException tashladi. Exception chaqiruvchiga yetadi, lekin buyurtmalar commit qilingan. Kod muallifi esa «xato boʻldi, demak hech narsa saqlanmadi» deb oʻylagan boʻladi.
Qoida exception turi va uning subclassʼlariga qoʻllanadi: rollbackFor = IOException.class FileNotFoundExceptionni ham qamraydi. Teskarisi — noRollbackFor: kutilgan biznes exceptionʼida ham shu paytgacha qilingan yozuvlar saqlanib qolishi kerak boʻlsa.
Kotlinʼda checked exception tushunchasi yoʻq, lekin Javaʼning Exceptionidan meros olgan exception baribir commit qiladi. Spring hujjatlari, EJB uslubidagi biznes exceptionʼlarga tayanmasangiz, ALL_EXCEPTIONSga oʻtishni tavsiya qiladi — Kotlinʼda ayniqsa.
@Transactional(rollbackFor = Exception.class)
public void importFile(Path file) throws IOException {
orders.saveAll(parse(Files.readAllLines(file)));
// IOException → endi rollback
archive.move(file);
}Tranzaksiya ichida tashqi HTTP chaqiruv qilish nega xavfli?Javob
Tranzaksiya ochiq turgan butun vaqt connection band, bazadagi lockʼlar ham ushlab turiladi. HTTP chaqiruv sekinlashsa, connection pool tez tugaydi va ilova toʻxtab qoladi. Ustiga, HTTP chaqiruvni rollback qilib boʻlmaydi: toʻlov oʻtib, tranzaksiya esa bekor boʻlishi mumkin.
Hisoblab koʻraylik: pool 10 connection, tashqi servis 5 soniyada javob beradi. Soniyasiga 3 ta shunday soʻrov kelsa, bir vaqtda taxminan 15 ta tranzaksiya ochiq boʻladi — pool yetmaydi, qolgan soʻrovlar esa HTTPʼga aloqasi yoʻq endpointʼlarda ham connection kutadi.
Ikkinchi muammo — ikki tizim orasidagi izchillik. Toʻlov servisi pulni yechdi, keyin bizning commit xato bilan tugadi: pul yechilgan, buyurtma yoʻq. Yoki teskarisi: buyurtma saqlandi, toʻlov soʻrovi esa timeout boʻldi va u bajarilganmi-yoʻqmi nomaʼlum.
Yechim — HTTP chaqiruvni tranzaksiyadan tashqariga chiqarish: avval qisqa tranzaksiyada buyurtmani PENDING holatda yozish, keyin tashqi chaqiruv, keyin ikkinchi qisqa tranzaksiyada natijani saqlash. Commitʼdan keyin bajarilishi kerak boʻlgan ish uchun @TransactionalEventListener, kafolat kerak boʻlsa — outbox pattern: xabar shu tranzaksiyada jadvalga yoziladi, alohida worker esa uni keyin yuboradi.
// tranzaksiyasiz metod; orders metodlari
// oʻzi @Transactional (boshqa beanʼda)
public void checkout(long orderId) {
// 1-tranzaksiya: qisqa, faqat baza
Order o = orders.markPending(orderId);
// tranzaksiyasiz: tashqi servis
PaymentResult r = payments.charge(o.total());
// 2-tranzaksiya: natijani saqlash
orders.complete(orderId, r);
}8@Async, @Scheduled, cache va eventʼlar
Bu annotatsiyalarning hammasini Spring ishga tushishda roʻyxatdan oʻtgan post-processorʼlar topadi, lekin ular har xil ishlaydi. @Async va @Cacheable proxy orqali ishlaydi, shuning uchun proxy cheklovlari — self-invocation, private va final metodlar — ularga ham amal qiladi. @Scheduled va @EventListenerda proxy yoʻq: Spring metodni topib, uni oʻzi chaqiradi. Spring Boot @EnableAsync, @EnableScheduling va @EnableCachingni oʻzi qoʻymaydi: ularsiz annotatsiyalar hech qanday xatosiz, jimgina ishlamaydi.
| Annotatsiya | Yoqish | Spring Boot default holatda |
|---|---|---|
@Async | @EnableAsync | ThreadPoolTaskExecutor: 8 ta core thread, navbat cheklanmagan |
@Scheduled | @EnableScheduling | ThreadPoolTaskScheduler: bitta thread |
@Cacheable | @EnableCaching | classpathʼdagi provider (Caffeine, Redis va boshqalar); hech biri boʻlmasa — oddiy ConcurrentHashMap |
@EventListener | kerak emas | sinxron, event chiqargan threadʼning oʻzida |
spring.threads.virtual.enabled=true boʻlsa (Java 21+), @Async va @Scheduled uchun virtual thread ishlatadigan SimpleAsyncTaskExecutor va SimpleAsyncTaskScheduler sozlanadi, pool sozlamalari esa hisobga olinmaydi.
Event — beanʼlarni bir-biriga bogʻlamasdan xabar berish usuli. ApplicationEventPublisher.publishEvent(...) bilan istalgan obyekt chiqariladi, @EventListener metodlari uni turiga qarab qabul qiladi. Default holatda listener sinxron: u event chiqargan threadʼda, oʻsha tranzaksiya ichida ishlaydi va uning exceptionʼi event chiqargan kodga qaytadi. @TransactionalEventListener esa tranzaksiyaning maʼlum bosqichini kutadi — default holatda commitʼni:
// OrderService ichida
@Transactional
public void place(Order o) {
repo.save(o);
events.publishEvent(new OrderPlaced(o.id()));
}
// boshqa beanʼda: faqat commitʼdan keyin
@TransactionalEventListener
void onPlaced(OrderPlaced e) {
sms.sendOrderConfirmation(e.orderId());
}Cache abstraction ham proxy: @Cacheable metod chaqirilishidan oldin cacheʼga qaraydi va qiymat boʻlsa, metodni umuman chaqirmaydi. Qaysi cache ishlatilishini CacheManager belgilaydi — Spring Boot uni classpathʼga qarab oʻzi tanlaydi.
Tushunganingizni tekshiring
@Async metod qaysi threadʼda ishlaydi va undagi exception qayerga ketadi?Javob
@Async metod proxy orqali executorʼga topshiriladi va boshqa threadʼda ishlaydi — Spring Bootʼda bu default holatda 8 ta core threadli ThreadPoolTaskExecutor. void metodning exceptionʼi AsyncUncaughtExceptionHandlerga boradi va default holatda faqat logga yoziladi. CompletableFuture qaytarsa, exception future ichida qoladi: uni hech kim tekshirmasa, u yoʻqoladi.
Boot executorʼining navbati cheklanmagan, qoʻshimcha threadʼlar esa faqat navbat toʻlganda yaratiladi — shuning uchun amalda 8 tadan ortiq thread boʻlmaydi va yuk ostida vazifalar navbatda cheksiz yigʻiladi. Chegara spring.task.execution.pool.queue-capacity va max-size bilan qoʻyiladi. Oʻzingiz Executor beanʼini yaratsangiz, Boot default holatda oʻz executorʼini yaratmaydi.
@Async metod chaqiruvchining kontekstini olib ketmaydi: tranzaksiya, SecurityContext va MDCʼdagi log qiymatlari threadʼga bogʻliq, yangi threadʼda ular yoʻq. Kerak boʻlsa, executorʼga TaskDecorator qoʻyiladi. Self-invocation muammosi bu yerda ham bor: klass ichidan chaqirilgan @Async metod oddiy, sinxron chaqiruv boʻladi.
@Scheduled uchun Boot bitta threadli scheduler sozlaydi: hamma @Scheduled metodlar navbat bilan shu threadʼda ishlaydi va bitta uzun job qolganlarini kechiktiradi. Thread soni spring.task.scheduling.pool.size bilan oshiriladi. Takrorlanadigan job ichidagi exception logga yoziladi va keyingi ishga tushirishlar davom etadi.
@Async
public CompletableFuture<Report> build(long id) {
return CompletableFuture.completedFuture(
generate(id));
}
// exceptionʼni chaqiruvchi oʻzi koʻrishi kerak
reports.build(42).exceptionally(e -> {
log.error("Report failed", e);
return null;
});@Cacheable qanday ishlaydi va qachon jimgina ishlamay qoladi?Javob
@Cacheable metod natijasini kalit boʻyicha cacheʼga qoʻyadi: keyingi chaqiruvda proxy metodni chaqirmasdan cacheʼdagi qiymatni qaytaradi. @CachePut metodni har safar bajarib, natijani cacheʼga yozadi, @CacheEvict esa yozuvni oʻchiradi. @EnableCaching boʻlmasa yoki chaqiruv proxyʼdan oʻtmasa, cache hech qanday xatosiz ishlamaydi.
Kalit default holatda metod parametrlaridan tuziladi: parametr yoʻq — boʻsh kalit, bitta — parametrning oʻzi, bir nechta — hammasidan SimpleKey. Shuning uchun parametr klassida equals va hashCode toʻgʻri boʻlishi shart. Kalitni SpEL bilan aniq berish mumkin: key = "#id". Bir xil cache nomini ishlatgan ikki metod bir xil parametr bilan bir-birining qiymatini olib qoʻyishi mumkin.
Caffeine — ilova xotirasidagi tez cache: oʻlcham va TTL bilan, lekin har bir instansda oʻziniki: bir instansdagi @CacheEvict boshqalarining cacheʼiga tegmaydi. Redis — umumiy cache: hamma instans bir xil qiymatni koʻradi, lekin har bir oʻqish tarmoq chaqiruvi va qiymat serialize qilinadi. Hech qanday provider boʻlmasa, Boot oddiy ConcurrentHashMapga asoslangan cache yaratadi: unda TTL ham, oʻlcham chegarasi ham yoʻq.
Jimgina ishlamay qolish holatlari: @EnableCaching yoʻq; metod shu klass ichidan chaqirilgan; metod private. Yana bir tuzoq: in-memory cacheʼda obyektning oʻzi saqlanadi, shuning uchun qaytgan mutable obyektni oʻzgartirgan kod cacheʼdagi qiymatni ham oʻzgartiradi. Bir vaqtda koʻp soʻrov bir xil yoʻq kalitni soʻrasa, hammasi metodni chaqiradi — sync = true buni har bir instans ichida bitta chaqiruvga kamaytiradi.
@Cacheable(cacheNames = "products", key = "#id")
public ProductDto find(long id) {
return toDto(repo.findById(id).orElseThrow());
}
@CacheEvict(cacheNames = "products",
key = "#upd.id()")
public void update(ProductUpdate upd) {
repo.update(upd);
}@EventListener va @TransactionalEventListener farqi nima?Javob
@EventListener event chiqarilgan zahoti, oʻsha thread va oʻsha tranzaksiya ichida ishlaydi. @TransactionalEventListener esa default holatda tranzaksiya commit qilingandan keyin (AFTER_COMMIT) ishlaydi: rollback boʻlsa, listener umuman chaqirilmaydi. SMS, email yoki boshqa servisga xabar kabi qaytarib boʻlmaydigan ishlar uchun aynan shu kerak.
Oddiy @EventListenerda SMS yuborilsa-yu, keyin tranzaksiya rollback boʻlsa, mijoz mavjud boʻlmagan buyurtma haqida xabar oladi. Uning exceptionʼi esa event chiqargan metodga qaytadi va butun tranzaksiyani rollback qilishi mumkin.
Tranzaksiya yoʻq paytda chiqarilgan event @TransactionalEventListenerga umuman yetmaydi, agar fallbackExecution = true qoʻyilmagan boʻlsa. AFTER_COMMIT listenerʼi baribir sinxron: u commitʼdan keyin, lekin oʻsha threadʼda ishlaydi va javobni kechiktiradi. Sekin ish uchun unga @Async qoʻshiladi.
Listener ichida bazaga yozish kerak boʻlsa, unga @Transactional(propagation = REQUIRES_NEW) kerak: asosiy tranzaksiya allaqachon commit qilingan. Spring 6.1 dan bunday listenerʼda REQUIRES_NEW yoki NOT_SUPPORTEDdan boshqa propagationʼli @Transactional — Spring 6.2 dan klassga qoʻyilgani ham — xato hisoblanadi va context ishga tushmaydi. Commit va listener orasida ilova toʻxtab qolsa, event yoʻqoladi — kafolat kerak boʻlsa, outbox pattern ishlatiladi.
9Production: Actuator, virtual threadʼlar, ishga tushish va versiyani yangilash
Actuator (spring-boot-starter-actuator) ilovaning holatini tashqariga chiqaradi: /actuator/health — ishlayaptimi, /actuator/metrics va /actuator/prometheus — metrikalar, /actuator/loggers — log darajasini restartʼsiz oʻzgartirish, /actuator/threaddump va /actuator/heapdump — muammoni tekshirish uchun. Default holatda HTTP orqali faqat health ochiq, qolganlari management.endpoints.web.exposure.include bilan ochiladi. Ularni internetga ochib qoʻymaslik kerak: masalan, heapdumpda parol va tokenlar ham boʻlishi mumkin.
Kubernetes ikki xil tekshiruv qiladi va ular har xil savolga javob beradi:
| Probe | Savol | Muvaffaqiyatsiz boʻlsa | Endpoint |
|---|---|---|---|
| Liveness | ilovaning ichki holati buzilmaganmi | pod qayta ishga tushiriladi | /actuator/health/liveness |
| Readiness | hozir soʻrov qabul qilishga tayyormi | pod trafikdan chiqariladi, restart yoʻq | /actuator/health/readiness |
Spring Boot 3 da bu ikki endpoint ilova Kubernetesʼda ishga tushganda oʻzi yoqiladi (yoki management.endpoint.health.probes.enabled=true bilan), Boot 4 da esa default holatda yoqilgan. Default holatda ular bazani tekshirmaydi — va bu ataylab: baza ishlamay qolsa, liveness hamma podʼlarni restart qilib, muammoni kattalashtirgan boʻlardi.
Metrikalar Micrometer orqali yigʻiladi: Boot http.server.requests (endpoint boʻyicha soʻrovlar soni va vaqti), JVM xotirasi, GC, threadʼlar va connection pool metrikalarini oʻzi yozadi. Prometheus registry qoʻshilsa, ular /actuator/prometheusda chiqadi. Oʻz metrikangizda tag qiymatlari cheklangan boʻlishi kerak: userId yoki orderId tag boʻlsa, har bir qiymat alohida time series boʻladi va xotira oʻsib ketadi.
Graceful shutdown: SIGTERM kelganda server yangi soʻrov qabul qilishni toʻxtatadi, ishlayotganlariga tugashga vaqt beradi (spring.lifecycle.timeout-per-shutdown-phase, default 30 soniya), keyin context yopiladi. Spring Boot 3.4 dan bu default holatda yoqilgan, undan oldin server.shutdown=graceful kerak edi.
Virtual threadʼlar (Java 21+, Spring Boot 3.2+) spring.threads.virtual.enabled=true bilan yoqiladi: Tomcat har bir soʻrovni virtual threadʼda bajaradi, @Async va @Scheduled ham virtual threadʼga oʻtadi. Bloklovchi kod (JDBC, RestClient) oʻzgarmaydi, lekin endi minglab soʻrov bir vaqtda kutishi mumkin — va tor joy threadʼlar emas, connection pool boʻlib qoladi.
Ishga tushishni tezlashtirishning uchta yoʻli bor va har biri oʻz narxini toʻlaydi:
| Usul | Nima beradi | Narxi |
|---|---|---|
spring.main.lazy-initialization=true | beanʼlar birinchi kerak boʻlganda yaratiladi — ishga tushish tezroq | konfiguratsiya xatosi ishga tushishda emas, birinchi soʻrovda chiqadi; birinchi soʻrovlar sekinroq |
| CDS yoki AOT cache | JVM klasslarni oldindan tayyorlangan arxivdan yuklaydi | arxiv uchun ilovani bir marta «oʻqitish» rejimida ishga tushirish kerak; arxiv aynan shu JVM va jar uchun |
| GraalVM native image | ishga tushish soniyalar oʻrniga millisekundlarda, xotira kamroq | build uzoq, reflection uchun hint kerak, beanʼlar toʻplami build paytida qatʼiylashadi |
Major versiyani yangilash — eng xavfli rutin ish. Spring Boot 2 → 3 ning asosiy oʻzgarishlari: Java 17 minimal versiya, javax.* paketlar jakarta.*ga oʻtdi (Jakarta EE 9+), spring.factoriesdagi auto-configuration endi yuklanmaydi, baʼzi propertyʼlar nomi oʻzgardi (spring.redis.* → spring.data.redis.*), Spring Security 6 da WebSecurityConfigurerAdapter olib tashlangan. Boot 3 → 4: Java 17 hali ham minimal, Jakarta EE 11 (Servlet 6.1), Jackson 3, modulli starterʼlar, @MockBean olib tashlangan, Undertow endi qoʻllab-quvvatlanmaydi.
Tushunganingizni tekshiring
Liveness va readiness farqi nima? Health checkʼga baza tekshiruvini qoʻshish kerakmi?Javob
Liveness — «ilova tirikmi, restart kerakmi», readiness — «hozir unga soʻrov bersa boʻladimi». Baza ishlamasa, ilovani restart qilish yordam bermaydi, shuning uchun baza tekshiruvi livenessʼga kirmaydi. Readinessʼga qoʻshish mumkin, lekin oqibatini oʻylab: baza tushsa, hamma pod birdaniga trafikdan chiqadi.
Spring Boot liveness va readiness holatini ilovaning oʻz holatidan oladi: ishga tushish tugaguncha readiness REFUSING_TRAFFIC, ApplicationReadyEventdan keyin ACCEPTING_TRAFFIC, shutdown boshlanganda yana REFUSING_TRAFFIC. Ilova holatni oʻzi ham oʻzgartira oladi — masalan, tuzatib boʻlmaydigan xatoda LivenessState.BROKEN eʼlon qiladi.
Tashqi tizimni readinessʼga qoʻshish: management.endpoint.health.group.readiness.include=readinessState,db. Bu baza vaqtincha uzilganda trafikni boshqa podʼlarga yoʻnaltiradi — lekin ular ham shu bazaga ulangan boʻlsa, foydasi yoʻq: hamma pod trafikdan chiqadi. Koʻpincha baza xatosini soʻrov darajasida, 503 bilan qaytarish yaxshiroq.
Shutdownʼdagi nozik joy: Kubernetes podʼni oʻchirayotganda SIGTERM yuborish va podʼni Service endpointʼlaridan olib tashlash bir vaqtda boshlanadi, shuning uchun bir necha soniya davomida soʻrovlar hali kelishi mumkin. Odatda preStop hookʼda qisqa sleep qoʻyiladi, terminationGracePeriodSeconds esa Springʼning shutdown timeoutʼidan katta qilinadi.
management:
endpoints:
web:
exposure:
include: health, prometheus
endpoint:
health:
probes:
enabled: trueSpring Bootʼda virtual threadʼlarni yoqsangiz nima oʻzgaradi va nimaga eʼtibor berish kerak?Javob
spring.threads.virtual.enabled=true (Java 21+) bilan Tomcat har bir soʻrovni yangi virtual threadʼda bajaradi, @Async va @Scheduled ham virtual threadʼga oʻtadi. Bloklovchi kod oʻz holicha qoladi, lekin bir vaqtda ishlaydigan soʻrovlar soni endi Tomcat pooli bilan cheklanmaydi — tor joy connection pool va tashqi servislarga koʻchadi.
Platform threadʼlarda Tomcat pooli (default 200 thread) tabiiy chegara edi: ortiqcha soʻrovlar navbatda kutardi. Virtual threadʼlarda bunday chegara yoʻq: 2000 ta soʻrov bir vaqtda HikariCPʼning 10 ta connectionʼi uchun navbatga turadi va connectionTimeoutdan keyin xato bilan tugaydi. Yuk sinovi, toʻgʻri pool oʻlchami va kerak boʻlsa Semaphore bilan aniq chegara kerak.
Pinning: Java 21–23 da synchronized blok ichida bloklangan virtual thread oʻz carrier threadʼini ham band qilib qoʻyadi. Java 24 da (JEP 491) bu tuzatilgan, shuning uchun Spring Boot hujjatlari Java 24+ ni qattiq tavsiya qiladi. Java 21 da eski kutubxonalardagi synchronized ichidagi I/O muammo boʻlishi mumkin.
Virtual threadʼlar — daemon thread: ilovani faqat @Scheduled joblar tirik ushlab tursa (web server yoʻq), JVM chiqib ketishi mumkin. Buning uchun spring.main.keep-alive=true. ThreadLocalda katta obyektni cache qilish ham endi ortiqcha xotira: har bir soʻrov — yangi thread, demak har safar yangi nusxa.
Spring Boot ilovasi sekin ishga tushsa va koʻp xotira olsa, nima qilasiz? GraalVM native imageʼning kompromisslari nimada?Javob
Avval sababini oʻlchash kerak: qaysi beanʼlar uzoq yaratilyapti (BufferingApplicationStartup bilan /actuator/startup). Keyin variantlar: lazy initialization, CDS yoki AOT cache va GraalVM native image. Native image millisekundlarda ishga tushadi va kam xotira oladi, lekin build uzoq, reflection cheklangan va beanʼlar toʻplami build paytida qatʼiylashadi.
Lazy initialization arzon, lekin xavfli: notoʻgʻri sozlangan bean ishga tushishda emas, birinchi soʻrovda xato beradi, birinchi soʻrovlar esa sekinroq boʻladi. Kubernetesʼda readiness «tayyor» degan pod aslida hali toʻliq tayyor boʻlmay chiqadi.
CDS (Class Data Sharing) va uning davomi AOT cache kodni oʻzgartirmaydi: ilova bir marta «oʻqitish» rejimida ishga tushiriladi (-Dspring.context.exit=onRefresh), JVM yuklangan klasslarni arxivga yozadi, keyingi ishga tushishlar esa shu arxivdan tezroq boʻladi. Java 25 va undan yangi versiyalarda Spring Boot CDS oʻrniga AOT cacheʼni tavsiya qiladi.
Native image — butunlay boshqa model. Build paytida Spring AOT contextʼni oldindan hisoblaydi, GraalVM esa closed world tamoyili boʻyicha faqat yetib boriladigan kodni mashina kodiga kompilyatsiya qiladi. Shuning uchun classpath va beanʼlar toʻplami build paytida qatʼiy: @Profile yoki @ConditionalOnProperty runtimeʼda boshqa beanʼlarni tanlay olmaydi. Reflection, resurslar va dynamic proxyʼlar uchun hint kerak (RuntimeHints, @RegisterReflectionForBinding), kutubxonalarning hammasi ham native imageʼga tayyor emas. JIT boʻlmagani uchun uzoq ishlaydigan servisda eng yuqori throughput JVMʼdagidan past boʻlishi mumkin.
# CDS: arxivni tayyorlash va ishlatish
java -Djarmode=tools -jar app.jar \
extract --destination app
cd app
java -XX:ArchiveClassesAtExit=app.jsa \
-Dspring.context.exit=onRefresh -jar app.jar
java -XX:SharedArchiveFile=app.jsa -jar app.jarSpring Bootʼning major versiyasini qanday xavfsiz yangilaysiz?Javob
Bosqichma-bosqich: avval joriy major versiyaning oxirgi minor versiyasiga oʻtib, deprecation ogohlantirishlarini tuzatasiz — keyingi majorʼda aynan ular olib tashlanadi. Keyin yangi majorʼga oʻtib, spring-boot-properties-migrator va OpenRewrite kabi vositalar bilan oʻzgarishlarni topasiz, testlar va bosqichli deploy bilan tekshirasiz.
Boot 2 → 3 uchun avval 2.7 ga, Boot 3 → 4 uchun avval 3.5 ga. Java versiyasi ham alohida qadam: avval yangi Javaʼda eski Boot bilan ishlab koʻrish, keyin Bootʼni yangilash — ikki xavfni bir vaqtda olmaslik uchun.
javax → jakarta koʻchishi asosan importlarni almashtirish: javax.persistence, javax.servlet, javax.validation, javax.annotation.PostConstruct. Lekin javax.sql.DataSource yoki javax.crypto JDKʼning oʻzida va oʻzgarmaydi — koʻr-koʻrona almashtirish ularni ham buzadi. Tranzitiv kutubxonalar ham jakarta versiyasiga yangilanishi kerak: eski javax versiyasi classpathʼda qolsa, xato koʻpincha faqat runtimeʼda chiqadi.
spring-boot-properties-migrator runtime dependency sifatida qoʻshiladi: ishga tushishda nomi oʻzgargan yoki olib tashlangan propertyʼlar haqida ogohlantiradi va vaqtincha ularni yangi nomga koʻchiradi. OpenRewrite recipeʼlari import va API oʻzgarishlarining katta qismini avtomatik qiladi. Oxirgi qadam — productionʼga bosqichma-bosqich: avval bitta instans yoki trafikning kichik qismi, metrikalar va loglarni kuzatib.
Tushunganingizni suhbatda sinab koʻring
Mavzuli mock intervyuda «Spring Core va Boot»ni tanlang. AI shu kabi savollarni beradi, javobingizga qarab chuqurroq savol soʻraydi va har javobingizga fikr bildiradi.