Spring Data JPA va Hibernate: entity, persistence context va soʻrovlar qanday ishlaydi
Bu sahifa Spring Data JPA va Hibernate qanday ishlashini chuqur tushuntiradi: entity va repository, mapping va bogʻlanishlar, persistence context, dirty checking va flush, tranzaksiyalar, lazy loading va N+1, locking va katta hajmdagi maʼlumot. Murakkab joylar qadamma-qadam animatsiya bilan koʻrsatilgan.
Boʻlimlar asoslardan chuqurroq mavzularga qarab ketadi. Bilgan joyingizni oʻtkazib yuborishingiz yoki istalgan boʻlimdan boshlashingiz mumkin. Kod Java 21, Spring Boot 3.x va Hibernate 6 uchun yozilgan; Spring Boot 4 va Hibernate 7 dagi farqlar oʻz joyida aytilgan.
Har boʻlim oxirida tushunganingizni tekshiradigan savollar bor. Avval javobni oʻzingiz oʻylab koʻring, keyin oching.
1JPA, Hibernate va Spring Data JPA
Javaʼda relational baza bilan obyektlar orqali ishlashda uchta qatlam bor va ularni ajratib bilish muhim. JPA (Jakarta Persistence) — standart: annotatsiyalar (@Entity, @Id, @OneToMany), EntityManager interfeysi va JPQL soʻrov tili. Unda ishlaydigan kod yoʻq, faqat kontrakt. Hibernate — shu standartning eng koʻp ishlatiladigan implementationʼi: SQL yasash, persistence context, lazy loading va cacheʼlarni aynan u bajaradi. Spring Data JPA esa JPA ustidagi qatlam: u repository interfeysidan implementation yasab beradi.
| Qatlam | Nima | Siz nima yozasiz |
|---|---|---|
| JPA (Jakarta Persistence) | standart: annotatsiyalar, EntityManager, JPQL | @Entity, @Id, @ManyToOne va hokazo |
| Hibernate | JPA implementationʼi va undan ortiq imkoniyatlar | sozlamalar, kerak boʻlsa @BatchSize, @DynamicUpdate kabi oʻz annotatsiyalari |
| Spring Data JPA | repository: interfeysdan implementation | interface OrderRepository extends JpaRepository<Order, Long> |
| Spring Boot | hammasini avtomatik sozlaydi | spring.datasource.* va spring.jpa.* sozlamalari |
Versiyalar haqida. Spring Boot 3 (2022) Jakarta EE ga oʻtdi: annotatsiyalar endi javax.persistence emas, jakarta.persistence paketida. Internetdagi javax.persistence bilan yozilgan misollar Spring Boot 2 va Hibernate 5 davridan. Bu sahifadagi kod Spring Boot 3.x, Spring Data JPA 3.x va Hibernate 6 uchun. Spring Boot 4 (2025-yil noyabr) Hibernate 7 va Jakarta Persistence 3.2 ga oʻtdi, muhim farqlar oʻz joyida aytilgan.
Eng oddiy entity va repository shunday koʻrinadi. order SQLʼda kalit soʻz, shuning uchun jadval nomi @Table bilan orders qilib berilgan:
@Entity
@Table(name = "orders")
public class Order {
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE)
private Long id;
@Enumerated(EnumType.STRING)
private OrderStatus status;
private BigDecimal total;
// JPA uchun: argumentsiz konstruktor
protected Order() {}
public Order(BigDecimal total) {
this.total = total;
this.status = OrderStatus.NEW;
}
// getter va setterlar
}
public interface OrderRepository
extends JpaRepository<Order, Long> {
List<Order> findByStatus(OrderStatus status);
}Repository uchun implementation yozilmaydi. Ilova ishga tushganda Spring Data har bir repository interfeysi uchun proxy yaratadi. save, findById, findAll, deleteById kabi tayyor metodlarni SimpleJpaRepository klassi bajaradi — uning ichida oddiy EntityManager chaqiruvlari. findByStatus kabi metodlar uchun esa Spring Data metod nomini tahlil qilib, JPQL soʻrov yasaydi.
Soʻrov yozishning uch yoʻli bor:
| Usul | Misol | Qachon |
|---|---|---|
| derived query | findByStatusAndTotalGreaterThan(status, sum) | oddiy shartlar: bir-ikki field, sort, Top yoki First |
@Query va JPQL | select o from Order o where o.customer.city = :city | join, murakkabroq shart, projection yoki metod nomi juda uzayib ketsa |
@Query(nativeQuery = true) | select * from orders … for update skip locked | bazaning oʻz imkoniyatlari: window function, on conflict, JSONB |
JPQL SQLʼga oʻxshaydi, lekin jadval va ustunlar bilan emas, entity va fieldʼlar bilan ishlaydi: Order — klass nomi, o.customer.city — fieldʼlar boʻylab yoʻl, JOIN shartini esa Hibernate mappingʼdan oʻzi oladi. Hibernate JPQLʼni bazaning dialectʼidagi SQLʼga tarjima qiladi. Native SQL esa bazaga oʻzgarishsiz ketadi va shu bazaga bogʻlanib qoladi.
Tushunganingizni tekshiring
JPA va Hibernate farqi nimada? Spring Data JPA ularning qayerida turadi?Javob
JPA (Jakarta Persistence) — standart: annotatsiyalar, EntityManager interfeysi va JPQL. Hibernate — shu standartning implementationʼi, SQLʼni aynan u yasaydi va bajaradi. Spring Data JPA esa JPA ustidagi qatlam: repository interfeyslaridan implementation yasaydi.
Kodingiz jakarta.persistence annotatsiyalari va EntityManagerga tayanadi, ularning orqasida esa Hibernate ishlaydi. Nazariy jihatdan implementationʼni almashtirish mumkin (masalan, EclipseLink bilan), amalda esa Spring Boot loyihalarining deyarli hammasi Hibernate bilan ishlaydi va uning standartdan tashqari imkoniyatlaridan ham foydalanadi: @BatchSize, @DynamicUpdate, @NaturalId, HQL kengaytmalari, statistika.
Spring Data JPA oʻzi SQL yasamaydi va bazaga bormaydi: u EntityManager metodlarini chaqiradi, qolgan ishni Hibernate qiladi. Shuning uchun persistence context, flush, lazy loading — Hibernate va JPA mavzulari, repository esa ularning ustidagi qulay qobiq. Repository bilan ishlaydigan har qanday kod baribir shu mexanizmlar ichida yashaydi.
Spring Boot 3 bilan paket nomi oʻzgardi: javax.persistence → jakarta.persistence. Bu Java EE Eclipse Foundationʼga oʻtib, Jakarta EE deb nomlanganidan kelib chiqqan. Hibernate 6 va undan keyingi versiyalar jakarta.persistence annotatsiyalari bilan ishlaydi.
Repository interfeysini yozdingiz, lekin implementation yozmadingiz. Uni kim yozadi va findByEmail qanday ishlaydi?Javob
Spring Data ilova ishga tushganda har bir repository interfeysi uchun proxy yaratadi. Tayyor CRUD metodlarni SimpleJpaRepository bajaradi, findByEmail kabi metodlar uchun esa Spring Data metod nomidan JPQL soʻrov yasaydi.
Spring Boot Repositorydan (odatda JpaRepositorydan) meros olgan interfeyslarni topadi va har biri uchun bean roʻyxatdan oʻtkazadi. Bean — dynamic proxy: chaqirilgan metod save, findById yoki findAll boʻlsa, chaqiruv SimpleJpaRepositoryga boradi. Uning ichida entityManager.persist, merge, find kabi oddiy JPA chaqiruvlari.
Interfeysda eʼlon qilingan metodlar uchun proxy soʻrovni oldindan tayyorlab qoʻyadi. findByEmailAndActiveTrue nomi boʻlaklarga ajratiladi: find…By — select, Email va Active — entity fieldʼlari, And va True — shartlar. Nomda entityʼda yoʻq field boʻlsa, xato soʻrov chaqirilganda emas, ilova ishga tushayotganda chiqadi. @Querydagi JPQL ham Spring Data JPA 3.x da ishga tushishda tekshiriladi, native SQL esa tekshirilmaydi.
Oʻzingizning implementationʼingiz kerak boʻlsa (masalan, Criteria API bilan), alohida interfeys va nomi Impl bilan tugaydigan klass yoziladi, repository esa shu interfeysdan ham meros oladi. Spring Data ularni bitta proxyʼga birlashtiradi.
public interface OrderRepository
extends JpaRepository<Order, Long>,
OrderSearch {
// … where status = ? order by created_at desc
List<Order> findTop10ByStatusOrderByCreatedAtDesc(
OrderStatus status);
boolean existsByCustomerIdAndStatus(
Long customerId, OrderStatus status);
}
interface OrderSearch {
List<Order> search(OrderFilter filter);
}
// nomi: interfeys nomi + "Impl"
class OrderSearchImpl implements OrderSearch {
@PersistenceContext
private EntityManager em;
public List<Order> search(OrderFilter f) {
return em.createQuery("""
select o from Order o
where o.total > :min
""", Order.class)
.setParameter("min", f.minTotal())
.getResultList();
}
}Derived query, @Query bilan JPQL va native SQL: qachon qaysi birini tanlaysiz?Javob
Oddiy shartlar uchun derived query — metod nomining oʻzi soʻrov. Join, projection yoki uzun shart kerak boʻlsa — @Query bilan JPQL. Bazaning oʻziga xos imkoniyati kerak boʻlsa (window function, on conflict, JSONB, skip locked) — nativeQuery = true.
Derived query bir-ikki shartgacha qulay: findByEmail, countByStatus, findTop20ByOrderByCreatedAtDesc. Shart koʻpaysa, findByStatusAndCustomerCityAndTotalGreaterThanAndCreatedAtAfter kabi nomni oʻqib boʻlmaydi — bu @Queryga oʻtish vaqti.
JPQL entity va fieldʼlar bilan ishlaydi: select o from Order o join o.customer c where c.city = :city. JOIN shartini yozish shart emas — Hibernate uni mappingʼdan oladi. Natija entity boʻlsa, ular persistence contextʼga managed boʻlib tushadi. Hibernate JPQLʼni har bir baza uchun mos SQLʼga tarjima qiladi.
Native SQL bazaga oʻzgarishsiz boradi. U entity ham qaytara oladi, lekin unda tanlangan ustunlar entity mappingʼiga mos boʻlishi kerak; koʻpincha natija projection qilib olinadi. Native soʻrovni Spring Data ishga tushishda tekshirmaydi va bazani almashtirsangiz, u oʻzi oʻzgarmaydi — shuning uchun undan aniq sabab boʻlganda foydalaniladi.
// JPQL: entity va fieldʼlar
@Query("""
select o from Order o
join o.customer c
where c.city = :city and o.status = :status
""")
List<Order> findByCity(String city,
OrderStatus status);
// native: PostgreSQLʼning oʻz sintaksisi,
// tranzaksiya ichida chaqiriladi
@Query(value = """
select * from orders
where status = 'NEW'
order by created_at
limit 10
for update skip locked
""", nativeQuery = true)
List<Order> lockNextBatch();2Entity mapping: ID, ustunlar, enum va inheritance
Entity — jadvaldagi bitta qatorni ifodalaydigan klass. Unga @Entity va @Id kerak, yana argumentsiz konstruktor (public yoki protected): Hibernate obyektni avval shu konstruktor bilan yaratib, keyin fieldʼlarni toʻldiradi. JPA spec boʻyicha klass final boʻlmasligi kerak; Hibernate bunga yoʻl qoʻyadi, lekin unda lazy loading uchun proxy subclass yarata olmaydi. Java record esa entity boʻla olmaydi: unda argumentsiz konstruktor yoʻq va fieldʼlari final, Hibernate esa obyektni yaratib, fieldʼlarni keyin toʻldiradi va oʻzgartiradi. Projection uchun esa record juda qulay.
@Column ustun nomi va xususiyatlarini beradi: name, nullable, length (default 255), unique, precision va scale. Ular asosan Hibernate schema yaratganda ishlatiladi. Productionʼda schema odatda Flyway yoki Liquibase migratsiyalari bilan boshqariladi, spring.jpa.hibernate.ddl-auto esa validate yoki none boʻladi. validate bilan mapping va haqiqiy jadval mos kelmasa, ilova ishga tushmaydi.
ID yaratishning asosiy strategiyalari:
| Strategiya | ID qachon maʼlum boʻladi | Batch insert |
|---|---|---|
IDENTITY | INSERT bajarilgandan keyin: IDʼni baza identity yoki auto_increment ustuni bilan beradi | ishlamaydi |
SEQUENCE | INSERTdan oldin: Hibernate sequenceʼdan oladi, odatda 50 tadan zaxira bilan | ishlaydi |
UUID | persist() paytida, Java tomonda (INSERTdan oldin; Jakarta Persistence 3.1 dan) | ishlaydi |
AUTO (default) | Hibernate tanlaydi: sonli ID uchun sequence, baza sequenceʼni qoʻllamasa — jadval | tanlovga bogʻliq |
IDENTITY bilan Hibernate yangi entityʼning IDʼsini faqat INSERTdan keyin biladi. Shuning uchun persist() chaqirilishi bilan INSERT darhol bajariladi va Hibernate bunday entityʼlar uchun JDBC batch insertʼni oʻchiradi. SEQUENCE bilan ID oldindan olinadi, INSERTlar esa flushʼgacha yigʻilib, batch boʻlib ketishi mumkin. Hibernate 6 da sequence nomi berilmasa, har bir entity uchun alohida <nom>_seq sequence kutiladi; Hibernate 5 da hammasi uchun bitta hibernate_sequence edi.
Enum default holatda ORDINAL boʻlib saqlanadi — tartib raqami: NEW = 0, PAID = 1. Kimdir enumʼning oʻrtasiga yangi qiymat qoʻshsa yoki tartibini almashtirsa, bazadagi eski raqamlar boshqa qiymatni bildira boshlaydi va buni hech kim sezmaydi. @Enumerated(EnumType.STRING) nomni saqlaydi: bir oz koʻproq joy oladi, lekin tartib oʻzgarishi xavfsiz va bazani oʻqish oson.
Entityʼlar orasida meros boʻlsa, JPA uni jadvallarga uch xil yoʻl bilan joylaydi. Merosning oʻzi kerak boʻlmasa, faqat umumiy fieldʼlarni (id, createdAt, version) har entityʼda qayta yozmaslik kerak boʻlsa, @MappedSuperclass yetarli.
| Strategiya | Jadvallar | Polymorphic soʻrov | Kamchiligi |
|---|---|---|---|
SINGLE_TABLE (default) | hamma subclass bitta jadvalda, turi discriminator ustunida | eng tez: JOIN yoʻq | subclass ustunlari NOT NULL boʻla olmaydi, jadval keng |
JOINED | umumiy jadval va har subclass uchun oʻz jadvali, bir xil primary key bilan | hamma subclass jadvallari bilan LEFT JOIN | har INSERT ikki jadvalga, soʻrovlar ogʻirroq |
TABLE_PER_CLASS | har konkret klass uchun toʻliq jadval | UNION ALL | IDENTITY ishlatib boʻlmaydi, polymorphic soʻrov sekin |
@MappedSuperclass | oʻz jadvali yoʻq, fieldʼlari har entity jadvaliga koʻchadi | yoʻq: u entity emas | unga soʻrov ham, bogʻlanish ham yoʻq |
Tushunganingizni tekshiring
IDENTITY va SEQUENCE farqi nima? Nega katta hajmda SEQUENCE tanlanadi?Javob
IDENTITYda IDʼni baza INSERT paytida beradi, shuning uchun Hibernate INSERTni darhol bajaradi va batch insert qila olmaydi. SEQUENCEda ID INSERTdan oldin sequenceʼdan olinadi: INSERTlar flushʼgacha yigʻiladi va batch boʻlib ketadi.
IDENTITY bilan persist() chaqirilgan zahoti INSERT ketadi: Hibernate entityʼni persistence contextʼda ID boʻyicha saqlashi kerak, IDʼni esa faqat baza biladi. Shu sababli Hibernate IDENTITY entityʼlari uchun JDBC batch insertʼni jimgina oʻchiradi: 10 000 ta entity — 10 000 ta alohida INSERT, har biri bazaga alohida borib keladi.
SEQUENCE bilan Hibernate nextval qiladi va pooled optimizer tufayli bir marta borib 50 ta ID oladi (allocationSize default 50). Keyingi 49 ta entity bazaga murojaat qilmasdan ID oladi, INSERTlar esa hibernate.jdbc.batch_size boʻyicha guruhlanadi. Bazadagi sequence ham increment by 50 bilan yaratilishi kerak: Hibernate ishga tushishda ularni solishtiradi va farq topsa, default holatda xato beradi.
MySQLʼda sequence yoʻq, u yerda odatda IDENTITY (auto_increment) ishlatiladi va koʻp qator yozish kerak boʻlsa, boshqa yoʻl tanlanadi: masalan, JDBC yoki jOOQ bilan koʻp qatorli INSERT. PostgreSQLʼda esa SEQUENCE tabiiy tanlov.
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE,
generator = "orders_seq")
@SequenceGenerator(name = "orders_seq",
sequenceName = "orders_seq",
allocationSize = 50)
private Long id;
// migratsiyada (PostgreSQL):
// create sequence orders_seq increment by 50;Nega enumʼni @Enumerated(EnumType.STRING) bilan saqlash tavsiya qilinadi?Javob
Default holatda enum ORDINAL, yaʼni tartib raqami boʻlib saqlanadi. Enumʼga oʻrtadan yangi qiymat qoʻshilsa yoki tartibi almashsa, bazadagi eski raqamlar boshqa qiymatni bildira boshlaydi. STRING nomni saqlaydi va bu muammodan xoli.
enum OrderStatus { NEW, PAID, SHIPPED } ORDINAL bilan bazaga 0, 1, 2 boʻlib yoziladi. Keyinroq kimdir NEW va PAID orasiga CONFIRMED qoʻshsa, eski qatorlardagi 1 endi PAID emas, CONFIRMED boʻlib oʻqiladi. Hech qanday xato chiqmaydi — maʼlumot jimgina buziladi. Bundan tashqari, bazaga qaragan odam status = 2 nimani bildirishini bilmaydi.
STRING bilan PAID matn boʻlib saqlanadi. Tartib endi ahamiyatsiz, lekin enum konstantasining nomini oʻzgartirib boʻlmaydi: eski qatorlar uchun migratsiya kerak. Bazada qiymatlarni cheklash uchun migratsiyada check (status in (…)) constraint yoziladi.
Nom va bazadagi qiymat ajralishi kerak boʻlsa (masalan, P kabi qisqa kod), AttributeConverter yoziladi. Jakarta Persistence 3.2 (Hibernate 7) da buning uchun @EnumeratedValue ham qoʻshilgan: enumʼning qaysi fieldʼi bazaga yozilishini koʻrsatadi.
public enum OrderStatus { NEW, PAID, SHIPPED }
@Enumerated(EnumType.STRING)
@Column(nullable = false, length = 20)
private OrderStatus status;Entity inheritance uchun SINGLE_TABLE, JOINED va TABLE_PER_CLASSdan qaysi birini tanlaysiz?Javob
Polymorphic soʻrov kerak boʻlmasa — inheritance emas, @MappedSuperclass. Kerak boʻlsa va subclassʼlarning oʻz ustunlari kam boʻlsa — SINGLE_TABLE, u eng tez. Subclassʼlarda koʻp va majburiy ustunlar boʻlsa — JOINED. TABLE_PER_CLASS kam ishlatiladi.
SINGLE_TABLEda select p from Payment p bitta jadvaldan JOINʼsiz oʻqiladi, turi discriminator ustunidan aniqlanadi. Narxi — bitta keng jadval: CardPaymentning card_last4 ustuni BankPayment qatorlarida boʻsh turadi, shuning uchun uni bazada NOT NULL qilib boʻlmaydi — faqat turiga qarab check constraint bilan cheklash mumkin.
JOINEDda har subclass oʻz jadvaliga ega va uning primary keyʼi umumiy jadvalga foreign key. Schema normal, ustunlar NOT NULL boʻla oladi. Lekin har INSERT ikki jadvalga yoziladi, select p from Payment p esa hamma subclass jadvallari bilan LEFT JOIN qiladi — subclassʼlar koʻp boʻlsa, soʻrov ogʻirlashadi.
TABLE_PER_CLASSda umumiy jadval yoʻq: polymorphic soʻrov hamma jadvallarni UNION ALL bilan birlashtiradi. ID hamma jadvallar boʻyicha unikal boʻlishi kerak, shuning uchun IDENTITY ishlatib boʻlmaydi.
@MappedSuperclass — umumiy fieldʼlarni bir joyda yozish uchun: id, createdAt, version. U entity emas: select b from BaseEntity b deb soʻrab ham, unga @ManyToOne bilan bogʻlanib ham boʻlmaydi. Koʻp loyihalarga aynan shu yetarli.
@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "kind")
public abstract class Payment {
@Id @GeneratedValue
private Long id;
private BigDecimal amount;
}
@Entity
@DiscriminatorValue("CARD")
public class CardPayment extends Payment {
private String cardLast4;
}
// select … from payment p where p.kind = 'CARD'
List<CardPayment> cards = em
.createQuery("select c from CardPayment c",
CardPayment.class)
.getResultList();3Bogʻlanishlar: owning side, cascade va orphanRemoval
Bazada bogʻlanish bitta narsa — foreign key: order_item.order_id ustuni orders.idga koʻrsatadi. Javaʼda esa uni ikki tomondan koʻrsatish mumkin: OrderItemda @ManyToOne Order order va Orderda @OneToMany List<OrderItem> items. Ikkalasi bitta foreign keyʼni ifodalaydi, shuning uchun JPA ulardan bittasini owning side deb biladi.
Owning side — foreign key ustuni bor tomon, yaʼni @ManyToOne. @OneToMany(mappedBy = "order") — inverse side: u «bu bogʻlanish OrderItem.order fieldʼida saqlangan» deydi. Hibernate foreign keyʼni faqat owning sideʼga qarab yozadi. Shuning uchun ikkala tomonni birga oʻzgartiradigan helper metodlar yoziladi:
@Entity
public class OrderItem {
@Id @GeneratedValue
private Long id;
// owning side: order_id ustuni shu yerda
@ManyToOne(fetch = FetchType.LAZY,
optional = false)
@JoinColumn(name = "order_id")
private Order order;
// getter va setterlar
}
@Entity
@Table(name = "orders")
public class Order {
@Id @GeneratedValue
private Long id;
@OneToMany(mappedBy = "order",
cascade = CascadeType.ALL,
orphanRemoval = true)
private List<OrderItem> items = new ArrayList<>();
public void addItem(OrderItem item) {
items.add(item);
item.setOrder(this);
}
public void removeItem(OrderItem item) {
items.remove(item);
item.setOrder(null);
}
}Cascade — bitta entity ustidagi amalni bogʻlangan entityʼlarga ham tarqatish: PERSIST, MERGE, REMOVE, REFRESH, DETACH va hammasi birga — ALL. Cascade parentʼdan childʼga qarab, child parentning bir qismi boʻlganda qoʻyiladi: buyurtma va uning qatorlari. Mustaqil entityʼlar orasida, ayniqsa @ManyToOneda cascade qoʻyilmaydi: OrderItemdan Productga REMOVE cascade bitta qatorni oʻchirganda mahsulotni ham oʻchirishga urinadi.
orphanRemoval = true bir qadam ortiq: childʼni parentning listidan olib tashlashning oʻzi DELETE hisoblanadi. Faqat CascadeType.REMOVE boʻlsa, listdan chiqarish qatorni oʻchirmaydi: owning side oʻzgarmasa, bazada hech narsa oʻzgarmaydi, item.setOrder(null) qilinsa esa order_id null boʻlib, egasiz qator qoladi.
@ManyToManyda List oʻrniga Set ishlatiladi: Listdan bitta element olib tashlansa, Hibernate join tableʼdagi shu parentning hamma qatorlarini oʻchirib, qolganlarini qayta yozadi. Join tableʼda qoʻshimcha ustun kerak boʻlsa (qachon qoʻshilgani, rol), u alohida entity qilinadi va ikkita @ManyToOnega boʻlinadi.
Tushunganingizni tekshiring
mappedBy nimani bildiradi va bogʻlanishning egasi qaysi tomon?Javob
Ikki tomonlama bogʻlanishda foreign key ustuni bor tomon — owning side, odatda @ManyToOne. mappedBy inverse sideʼda yoziladi va «bu bogʻlanish oʻsha tomondagi fieldʼda saqlangan» deydi. Hibernate foreign keyʼni faqat owning sideʼga qarab yozadi.
@OneToMany(mappedBy = "order") List<OrderItem> items foreign keyʼni yozmaydi. item.setOrder(order) qilinmasa, order.getItems().add(item) order_idni toʻldirmaydi: qator null foreign key bilan saqlanadi, ustun NOT NULL boʻlsa esa flushʼda xato chiqadi.
Teskarisi ham chalkashlik beradi: faqat item.setOrder(order) qilinsa, bazaga toʻgʻri yoziladi, lekin shu persistence context ichida allaqachon yuklangan order.getItems() yangi itemʼni koʻrsatmaydi — Hibernate Java obyektlarini oʻzi sinxronlamaydi. Ikkala tomonni bitta metodda (addItem, removeItem) oʻzgartirish ikkala muammoni yopadi.
mappedBysiz bir tomonlama @OneToMany ham yozish mumkin, lekin unda Hibernate default holatda alohida join table kutadi. @JoinColumn bilan foreign key child jadvalida boʻladi, ammo uni boshqaradigan tomon parent boʻlgani uchun Hibernate koʻpincha qoʻshimcha UPDATElar yuboradi. Koʻp holatda eng oddiy va samarali variant — faqat @ManyToOne, kerak boʻlsa unga mappedBy bilan @OneToMany qoʻshiladi.
Cascade qachon kerak va orphanRemoval CascadeType.REMOVEdan nimasi bilan farq qiladi?Javob
Cascade parent ustidagi amalni (persist, merge, remove) childʼlarga ham tarqatadi va child parentning bir qismi boʻlganda kerak. CascadeType.REMOVE childʼni parent oʻchirilganda oʻchiradi, orphanRemoval = true esa child parentning listidan olib tashlanganda ham DELETE qiladi.
Yaxshi misol — buyurtma va uning qatorlari: qatorlar buyurtmasiz mavjud emas, ular birga yaratiladi va birga oʻchadi. Bu yerda cascade = CascadeType.ALL, orphanRemoval = true mos: orders.save(order) qatorlarni ham saqlaydi, order.removeItem(item) esa flushʼda DELETE beradi.
Yomon misol — mustaqil entityʼlar orasidagi cascade. @ManyToOne(cascade = CascadeType.REMOVE) Customer customer bitta buyurtma oʻchirilganda customerʼni ham oʻchirishga urinadi, uning boshqa buyurtmalari boʻlsa esa foreign key xatosi chiqadi. Koʻp childʼli parentni REMOVE cascade bilan oʻchirish ham qimmat: Hibernate har bir childʼni yuklab, ularni bittadan DELETE qiladi.
orphanRemoval child egasiz qolganda uni oʻchiradi. Shuning uchun butun kolleksiyani yangi list bilan almashtirib boʻlmaydi: order.setItems(newList)dan keyin Hibernate eski kolleksiya yoʻqolganini koʻradi va xato beradi. Kolleksiyaning oʻzini emas, uning ichini oʻzgartirish kerak: clear() va add.
Order order = orders.findById(id).orElseThrow();
OrderItem item = order.getItems().get(0);
// orphanRemoval: flushʼda delete from order_item
order.removeItem(item);
// xato: kolleksiyani almashtirish
order.setItems(new ArrayList<>(newItems));
// toʻgʻri: oʻsha kolleksiyaning ichini oʻzgartirish
order.getItems().clear();
newItems.forEach(order::addItem);Entity uchun equals va hashCodeni qanday yozasiz? Nega generatsiya qilinadigan ID tuzoq?Javob
Generatsiya qilinadigan ID persistgacha null, shuning uchun ID boʻyicha hisoblangan hashCode entity saqlangandan keyin oʻzgaradi va HashSet uni yoʻqotadi. Ikki yoʻl bor: oʻzgarmaydigan business key boʻyicha equals va hashCode yoki ID boʻyicha equals va hamma obyekt uchun bir xil hashCode.
Muammo: Set<OrderItem>ga yangi item qoʻshildi, uning hashCodei id = null boʻyicha hisoblandi. Flushʼdan keyin ID paydo boʻldi va hashCode oʻzgardi, item esa eski bucketda qoldi: endi items.contains(item) false qaytaradi va items.remove(item) ishlamaydi. Bu Java Collectionsʼdagi mutable key muammosining oʻzi.
equals va hashCodeni umuman override qilmaslik ham variant: persistence context bitta ID uchun bitta obyekt beradi, shuning uchun bitta context ichida reference boʻyicha solishtirish toʻgʻri ishlaydi. Lekin turli contextʼlardan kelgan obyektlar (masalan, detached va yangi yuklangan) teng boʻlmay qoladi.
Business key — tabiiy, oʻzgarmaydigan va entity yaratilganda maʼlum boʻladigan qiymat: ISBN, email, buyurtma raqami. Bunday kalit boʻlmasa, equals ID boʻyicha (null ID hech kimga teng emas), hashCode esa klass uchun doimiy qilinadi. Doimiy hashCode katta HashSetda sekin, lekin entity kolleksiyalari odatda kichik. Nozik joy: solishtirilayotgan obyekt Hibernate proxy boʻlishi mumkin, shuning uchun getClass() oʻrniga instanceof, fieldʼning oʻrniga esa getter ishlatiladi — proxyʼning oʻz fieldʼlari boʻsh.
Kotlin data class va Lombok @Data aynan shu sababli entity uchun mos emas: ular equals, hashCode va toStringni hamma fieldʼlar boʻyicha yasaydi (Kotlinʼda — primary constructorʼdagi hamma property boʻyicha). Bunda lazy bogʻlanishlar yuklanib ketadi yoki LazyInitializationException chiqadi, ikki tomonlama bogʻlanishda esa ular bir-birini cheksiz chaqirib, StackOverflowError beradi. Kotlin klasslari default final boʻlgani uchun Hibernate lazy proxy ham yarata olmaydi: kotlin("plugin.jpa") argumentsiz konstruktor qoʻshadi, entityʼlarni ochish uchun esa allOpen sozlamasi kerak.
@Entity
public class OrderItem {
@Id @GeneratedValue
private Long id;
@Override
public boolean equals(Object o) {
if (this == o) return true;
// proxy ham OrderItemʼning subclassʼi
if (!(o instanceof OrderItem other))
return false;
return id != null && id.equals(other.getId());
}
@Override
public int hashCode() {
// ID paydo boʻlganda ham oʻzgarmaydi
return OrderItem.class.hashCode();
}
public Long getId() { return id; }
}4Persistence context: entity holatlari, dirty checking va flush
Persistence context — EntityManager ichidagi xotira: u shu tranzaksiyada yuklangan yoki saqlangan har bir entityʼni ID boʻyicha saqlaydi va ularni kuzatib turadi. Spring Boot ilovasida odatda bitta tranzaksiya — bitta persistence context: @Transactional metod boshlanganda ochiladi va tugaganda yopiladi. Open-in-view buni oʻzgartiradi, u haqda keyinroq.
Entity toʻrt holatdan birida boʻladi. Ular orasidagi oʻtishlarni koʻring:
new Order() — oddiy Java obyekt. Persistence context undan bexabar, bazada qatori yoʻq: bu holat transient.| Holat | Persistence contextʼda | Bazada | Qanday tushadi |
|---|---|---|---|
| transient | yoʻq | yoʻq | new Order() |
| managed | bor, kuzatiladi | bor yoki flushʼda yoziladi | persist, find, soʻrov natijasi, merge qaytargan nusxa |
| detached | yoʻq | bor | context yopildi, detach yoki clear |
| removed | bor, oʻchirishga belgilangan | flushʼgacha bor | remove |
Persistence context ikki ishni bajaradi. Birinchisi — first-level cache: bitta context ichida bitta ID uchun doim bitta obyekt. find avval contextʼdan qidiradi va topsa, bazaga bormaydi. Ikkinchisi — dirty checking: entity yuklanganda Hibernate uning holatidan snapshot oladi, flush paytida esa har bir managed entityʼni shu nusxa bilan solishtiradi. Farq boʻlsa — UPDATE. Shuning uchun managed entityʼni oʻzgartirish uchun save() chaqirish shart emas:
em.find(User.class, 1L): persistence contextʼda User#1 yoʻq, shuning uchun SELECT ketadi. Hibernate obyektni contextʼga qoʻyadi va uning holatidan snapshot oladi.Flush — persistence contextʼdagi oʻzgarishlarni SQL qilib bazaga yuborish. Bu commit emas: flushʼdan keyin ham tranzaksiya rollback boʻlishi mumkin. Default FlushModeType.AUTOda Hibernate commitʼdan oldin, navbatdagi oʻzgarishlarga tegadigan JPQL soʻrovdan oldin, EntityManager orqali native SQL soʻrovdan oldin va flush() aniq chaqirilganda flush qiladi. IDENTITY entity uchun esa persistning oʻzi INSERT qiladi.
Flushʼda SQL siz yozgan tartibda emas, Hibernateʼning oʻz tartibida ketadi: avval INSERTlar, keyin UPDATElar va kolleksiya oʻzgarishlari, remove qilingan entityʼlarning DELETElari esa eng oxirida. Odatda buni sezmaysiz, lekin baʼzan aynan shu tartib xato beradi (quyidagi savolda).
Tushunganingizni tekshiring
Entity qanday holatlarda boʻladi va persist, detach, merge ularni qanday oʻzgartiradi?Javob
Toʻrt holat: transient — oddiy yangi obyekt, managed — persistence context kuzatadigan obyekt, detached — context yopilgan yoki undan chiqarilgan obyekt, removed — oʻchirishga belgilangan obyekt. persist transientʼni managed qiladi, detach va contextʼning yopilishi — detached, merge esa detached obyektning managed nusxasini qaytaradi.
Managed entity — persistence context «biladigan» obyekt: uning oʻzgarishlari flushʼda bazaga yoziladi, lazy bogʻlanishlari yuklanadi. Detached entityʼda qatorning maʼlumoti bor, lekin Hibernate uni endi kuzatmaydi: oʻzgartirsangiz, hech narsa yozilmaydi, initialize qilinmagan lazy bogʻlanishga murojaat qilsangiz — LazyInitializationException.
merge(detached) obyektning oʻzini managed qilmaydi. Hibernate shu ID boʻyicha managed nusxani contextʼdan topadi yoki SELECT bilan yuklaydi, detached obyektning holatini unga koʻchiradi va managed nusxani qaytaradi. Shundan keyingi oʻzgarishlar qaytarilgan obyektda qilinishi kerak — eski obyekt detached boʻlib qoladi.
remove faqat managed entity bilan ishlaydi: detached entityʼni oʻchirish uchun avval uni yuklash yoki merge qilish kerak, Spring Data delete() buni ichida qiladi. Removed entity flushʼgacha contextʼda turadi, DELETE esa flush paytida ketadi.
@Transactional
public Order update(Order detached) {
// kerak boʻlsa SELECT, holat nusxaga koʻchadi
Order managed = em.merge(detached);
managed.setNote("yoziladi"); // kuzatiladi
detached.setNote("yoʻqoladi"); // kuzatilmaydi
return managed;
}Spring Data save() ichida nima boʻladi: persistmi yoki merge?Javob
save() entity yangimi yoki yoʻqligini tekshiradi: yangi boʻlsa — persist va oʻsha obyekt qaytadi, aks holda — merge va managed nusxa qaytadi. Default holatda yangilik ID boʻyicha aniqlanadi: ID null (primitiv turda 0) boʻlsa — yangi. Entityʼda wrapper turidagi @Version field boʻlsa, uning nullligi boʻyicha.
Shuning uchun save() qaytargan qiymatni ishlatish kerak: merge boʻlganda qaytgan obyekt siz bergan obyekt emas. repo.save(order); order.setStatus(PAID); — bu detached obyektdagi oʻzgarish, u yozilmaydi.
ID qoʻlda berilsa (UUID konstruktorda yaratilsa yoki tashqi tizimdan kelsa), save() entityʼni yangi deb hisoblamaydi va merge chaqiradi. merge avval shu IDʼni SELECT bilan qidiradi, topmagach INSERT qiladi: har yangi qator uchun ortiqcha soʻrov. Yechim — Persistable<ID> interfeysi, unda isNew()ni oʻzingiz yozasiz, yoki wrapper turidagi @Version field: yangi entityʼda u null.
Managed entity uchun save() umuman kerak emas: tranzaksiya ichida findById bilan olingan entityʼni oʻzgartirsangiz, dirty checking UPDATEni oʻzi yuboradi. save() chaqirilsa ham zarar yoʻq, lekin u hech narsa qoʻshmaydi va kodni oʻqiganga «save qilinmasa, saqlanmaydi» degan notoʻgʻri tasavvur beradi.
@Entity
public class Shipment implements Persistable<UUID> {
@Id
private UUID id = UUID.randomUUID();
@Transient
private boolean isNew = true;
@Override public UUID getId() { return id; }
@Override public boolean isNew() { return isNew; }
// saqlashdan oldin va bazadan yuklanganda
@PrePersist @PostLoad
void markNotNew() { isNew = false; }
}Nega save() chaqirilmasa ham UPDATE ketadi? Flush qachon boʻladi?Javob
Managed entity yuklanganda Hibernate uning holatidan snapshot saqlaydi. Flush paytida har bir managed entity shu nusxa bilan solishtiriladi va farq boʻlsa, UPDATE yuboriladi — bu dirty checking. Default holatda flush commitʼdan oldin, taʼsirlanishi mumkin boʻlgan soʻrovdan oldin va flush() chaqirilganda boʻladi.
Dirty checking bepul emas: flush paytida contextʼdagi hamma managed entity tekshiriladi. Bitta tranzaksiyada 50 000 entity yuklansa, har flush ularning hammasini solishtiradi va xotirada har biri ikki nusxada turadi. Faqat oʻqiladigan joyda @Transactional(readOnly = true) yoki projection, katta hajmda esa vaqti-vaqti bilan flush() va clear() yordam beradi.
Default holatda Hibernate UPDATEda faqat oʻzgargan ustunni emas, hamma ustunlarni yozadi: SQL har safar bir xil boʻlgani uchun u bir marta tayyorlanib, qayta ishlatiladi. Faqat oʻzgarganlarini yozish kerak boʻlsa (keng jadval, katta matn ustunlari), entityʼga @DynamicUpdate qoʻyiladi.
Flush SQLʼni bazaga yuboradi, lekin tranzaksiyani yakunlamaydi: rollback boʻlsa, flush qilingan oʻzgarishlar ham bekor boʻladi. Boshqa tranzaksiyalar esa bu oʻzgarishlarni commitʼgacha koʻrmaydi — READ COMMITTED va undan qatʼiy isolation levelʼlarda.
@Transactional
public void markPaid(Long id) {
Order order = orders.findById(id).orElseThrow();
order.setStatus(OrderStatus.PAID);
// save() yoʻq: commitʼdan oldin flush
// update orders set status=?, … where id=?
}5Tranzaksiyalar: chegaralar, readOnly va propagation
JPAʼda tranzaksiya faqat commit va rollback emas, u persistence contextʼning chegarasi hamdir: Spring tranzaksiya boshlanganda EntityManager ochadi, commitʼdan oldin flush qiladi va tranzaksiya tugaganda contextʼni yopadi. Shuning uchun tranzaksiya qayerda boshlanib, qayerda tugashi entityʼlar qachon managed va qachon detached boʻlishini ham belgilaydi.
Repository oʻzi ham tranzaksiyali. SimpleJpaRepository klass darajasida @Transactional(readOnly = true) bilan belgilangan, oʻzgartiradigan metodlari (save, delete…, flush) esa oddiy @Transactional bilan. Siz repository interfeysida eʼlon qilgan metodlarga (findByEmail, @Query) esa default holatda tranzaksiya qoʻyilmaydi. Bu qiymatlar faqat tashqarida tranzaksiya yoʻq boʻlganda ishlaydi: service metodida tranzaksiya ochiq boʻlsa, repository default REQUIRED bilan unga qoʻshiladi.
Tranzaksiya ichidan boshqa @Transactional metod chaqirilsa, default REQUIRED propagation bilan u shu tranzaksiyaga va shu persistence contextʼga qoʻshiladi: ikkala metod bir xil managed obyektlarni koʻradi. REQUIRES_NEW esa joriy tranzaksiyani toʻxtatib qoʻyadi va yangi tranzaksiya bilan birga yangi EntityManager ochadi — bu alohida persistence context va pooldan alohida connection.
Isolation level — bazaning ishi, lekin persistence context unga oʻz qatlamini qoʻshadi: bir marta yuklangan entity shu tranzaksiya davomida contextʼdan olinadi. PostgreSQLʼning default READ COMMITTED levelʼida qatorni qayta soʻrasangiz, baza boshqa tranzaksiya commit qilgan yangi qiymatni qaytaradi, lekin Hibernate qator allaqachon contextʼda ekanini koʻrib, eski obyektni beradi va uning holatini yangilamaydi. Bazadan qayta oʻqish kerak boʻlsa — em.refresh(entity).
Tushunganingizni tekshiring
Nega @Transactional service qatlamiga qoʻyiladi, repository oʻzi tranzaksiyali boʻlsa ham?Javob
Repository tranzaksiyasi bitta metod chaqiruvini qamraydi, biznes amal esa odatda bir nechta oʻqish va yozishdan iborat. Service metodidagi @Transactional ularni bitta tranzaksiya va bitta persistence contextʼga birlashtiradi: hammasi birga commit yoki rollback boʻladi, entityʼlar esa metod oxirigacha managed qoladi.
Service metodida tranzaksiya boʻlmasa, natija open-in-viewʼga bogʻliq. Open-in-view oʻchiq boʻlsa yoki kod HTTP soʻrovdan tashqarida (masalan, scheduled job) ishlasa, har repository chaqiruvi alohida tranzaksiya: findById qaytargan entity darhol detached boʻladi, uning oʻzgarishi dirty checking bilan yozilmaydi, keyingi save() esa merge qilib, yana bir SELECT yuboradi. Spring MVCʼning default open-in-view rejimida esa entity managed qoladi va save() SELECTsiz oʻtadi, lekin ikki yozish baribir ikki alohida commit boʻladi: ular orasida xato chiqsa, birinchisi allaqachon commit boʻlgan boʻladi.
Controllerʼda tranzaksiya ochish ham yaxshi emas: tranzaksiya JSON yozish va boshqa veb ishlari vaqtida ham ochiq turadi, connection esa band boʻladi. Repository darajasida esa tranzaksiya biznes amalni qamramaydi. Service — biznes amalning chegarasi, tranzaksiya chegarasi ham shu yerda.
Tranzaksiya ichida tashqi HTTP chaqiruv yoki uzoq hisob-kitob qilmaslik kerak: u davom etgan butun vaqt connection pooldan band boʻladi va lockʼlar ushlanib turadi. Tashqi ish tranzaksiyadan oldin yoki keyin, tranzaksiyaning oʻzi esa qisqa.
// @Transactional yoʻq; open-in-view oʻchiq
// yoki HTTP soʻrovdan tashqarida (scheduled job)
public void pay(Long orderId) {
// 1-tranzaksiya: findById, keyin context yopiladi
Order order = orders.findById(orderId)
.orElseThrow();
order.markPaid(); // detached: oʻzi yozilmaydi
// 2-tranzaksiya: merge → SELECT va UPDATE
orders.save(order);
}@Transactional(readOnly = true) nima beradi?Javob
Hibernate uchun bu flushʼni oʻchiradi (FlushMode.MANUAL): dirty checking ishlamaydi va oʻzgarishlar bazaga yozilmaydi. Tranzaksiya oʻz EntityManagerini ochsa, entityʼlar read-only yuklanadi va snapshot saqlanmaydi — xotira va CPU tejaladi. JDBC connection ham read-only deb belgilanadi.
Spring HibernateJpaDialect read-only tranzaksiyada Hibernate sessionʼini FlushMode.MANUALga oʻtkazadi. Tranzaksiya yangi EntityManager bilan boshlangan boʻlsa, session default read-only ham qilinadi: yuklangan entityʼlar uchun snapshot saqlanmaydi. Koʻp entity oʻqiladigan roʻyxat va hisobotlarda bu sezilarli farq beradi.
Spring Boot sozlamalarida connection ham setReadOnly(true) oladi. Uning taʼsiri drayverga bogʻliq: PostgreSQL drayveri default sozlamada tranzaksiyani READ ONLY qilib boshlaydi va unda yozish xato beradi, baʼzi drayverlar esa uni eʼtiborsiz qoldiradi. Read-only belgisi asosida soʻrovlarni replicaʼga yoʻnaltirish ham mumkin.
Tuzoq: read-only tranzaksiyada entityʼni oʻzgartirsangiz, xato chiqmaydi — UPDATE shunchaki ketmaydi. Read-only metod ichidan yozadigan metod chaqirilsa, u default REQUIRED bilan shu read-only tranzaksiyaga qoʻshiladi va uning oʻzgarishlari ham flush qilinmasligi mumkin. Shuning uchun qulay qoida: klass darajasida readOnly = true, yozadigan metodlarda esa oddiy @Transactional.
@Service
@Transactional(readOnly = true)
public class OrderQueries {
private final OrderRepository orders;
// konstruktor
// flush yoʻq, snapshot yoʻq
public List<OrderRow> list(OrderStatus status) {
return orders.findRows(status);
}
@Transactional // yozadigan metod
public void cancel(Long id) {
orders.findById(id).orElseThrow().cancel();
}
}REQUIRES_NEW bilan chaqirilgan metod persistence context bilan qanday ishlaydi?Javob
REQUIRES_NEW joriy tranzaksiyani toʻxtatib qoʻyadi va yangisini oʻzining EntityManageri va connectionʼi bilan ochadi. Tashqi tranzaksiyada yuklangan entityʼlar ichkarida managed emas. Ichki tranzaksiya commit boʻlsa, tashqisi rollback boʻlganda ham uning natijasi qoladi.
Odatiy ishlatilishi — natijasi asosiy amaldan qatʼi nazar saqlanishi kerak boʻlgan yozuvlar: audit log yoki «urinish boʻldi» qaydi. Asosiy amal yiqilib, rollback boʻlsa ham, bu yozuv qoladi.
Persistence context alohida boʻlgani uchun tashqi metoddan berilgan entity ichkarida detached hisoblanadi: uni oʻzgartirish ichki commitʼda yozilmaydi. Ichki metod qatorni ID boʻyicha qayta yuklasa, u boshqa obyekt oladi, tashqi metoddagi obyekt esa eski holatda qoladi. Shuning uchun ichki metodga entity emas, ID yoki oddiy qiymatlar beriladi.
Har REQUIRES_NEW bir vaqtda ikkinchi connection talab qiladi: toʻxtatilgan tashqi tranzaksiyaning connectionʼi ham band. Pool kichik va yuk katta boʻlsa, hamma threadʼlar tashqi connectionʼni ushlab, ichkisini kutib qoladi. Yana bir nozik joy: ichki tranzaksiya tashqisi oʻzgartirib flush qilgan, lekin hali commit qilmagan qatorni yangilamoqchi boʻlsa, row lock tufayli tashqisini kutadi, tashqisi esa ichkisi qaytishini — bu deadlockʼni baza aniqlay olmaydi, chunki tashqi tranzaksiya bazada emas, Javaʼda kutyapti.
@Service
public class AuditService {
private final AuditRepository audit;
// konstruktor
// boshqa beanʼdan chaqiriladi
@Transactional(
propagation = Propagation.REQUIRES_NEW)
public void record(Long orderId, String action) {
audit.save(new AuditEntry(orderId, action));
}
}6Lazy loading, LazyInitializationException va open-in-view
Bogʻlangan entityʼlar ikki xil yuklanadi. Eager — entity bilan birga darhol. Lazy — birinchi murojaatda: Hibernate fieldʼga haqiqiy obyekt oʻrniga proxy qoʻyadi va bazaga faqat proxyʼdan maʼlumot soʻralganda boradi. Default qiymatlar JPA specʼda belgilangan:
| Annotatsiya | Default fetch | Tavsiya |
|---|---|---|
@ManyToOne | EAGER | fetch = FetchType.LAZY yozing |
@OneToOne | EAGER | owning sideʼda LAZY yozing |
@OneToMany | LAZY | default qoldiring |
@ManyToMany | LAZY | default qoldiring |
@ElementCollection | LAZY | default qoldiring |
To-one bogʻlanishlarning EAGER boʻlishi JPA 1.0 dan qolgan default: spec boʻyicha EAGER — provider uchun majburiyat, LAZY esa faqat hint. Amalda EAGER bogʻlanish entity qayerda va qanday yuklansa ham yuklanadi, unga kerak boʻlmagan joyda ham. Shuning uchun qabul qilingan qoida: hamma bogʻlanish LAZY, kerakli joyda esa soʻrovning oʻzida yuklanadi.
Lazy proxy — Hibernate runtimeʼda yaratgan subclass (masalan, Customer$HibernateProxy; eski versiyalarda oxiriga tasodifiy qoʻshimcha qoʻshilardi). Unda ID va sessionʼga havola bor. Proxyʼning maʼlumotiga birinchi murojaat qilinganda u oʻzini initialize qiladi: SELECT yuborib, haqiqiy obyektni yuklaydi. Lazy kolleksiyalar ham shunday: order.getItems() Hibernateʼning PersistentBag yoki PersistentSet obyektini qaytaradi va u birinchi size() yoki iteratsiyada yuklanadi.
Proxy faqat persistence context ochiq paytda yuklana oladi. Context yopilgandan keyin initialize qilinmagan proxy yoki kolleksiyaga murojaat qilinsa — LazyInitializationException. Spring ilovalarida bu eng koʻp uchraydigan JPA xatolaridan biri va uning sababi odatda bitta: maʼlumot tranzaksiya tugagandan keyin, controllerʼda yoki JSON serializationʼda soʻralgan.
Spring Boot buni default holatda open-in-view bilan «yumshatadi»: Spring MVC ilovasida EntityManager HTTP soʻrov boshida ochilib, javob yozilgandan keyin yopiladi, shuning uchun lazy bogʻlanishlar controllerʼda ham yuklanadi. Shu sababli ilova ishga tushganda Spring Boot spring.jpa.open-in-view is enabled by default deb ogohlantiradi — Spring Boot 3 da ham, 4 da ham.
Tushunganingizni tekshiring
LazyInitializationException nega chiqadi va uni qanday toʻgʻri hal qilasiz?Javob
Initialize qilinmagan lazy proxy yoki kolleksiyaga persistence context yopilgandan keyin murojaat qilinganda chiqadi: Hibernate endi bazaga bora olmaydi. Toʻgʻri yechim — kerakli maʼlumotni tranzaksiya ichida, soʻrovning oʻzida yuklash: fetch join, @EntityGraph yoki DTO projection.
Odatiy holat: service findById bilan buyurtmani qaytaradi, tranzaksiya tugaydi, controller esa order.getCustomer().getName()ni chaqiradi yoki Jackson butun obyektni JSONʼga yozadi. customer — proxy, context yopilgan, natija — exception. Xato servisda emas, maʼlumot kerak boʻlgan joyda chiqadi, shuning uchun sababini topish qiyinroq.
Yechimlar: kerakli bogʻlanishni soʻrovda yuklash (join fetch, @EntityGraph); controllerʼga entity emas, tranzaksiya ichida yigʻilgan DTO qaytarish; tranzaksiya ichida Hibernate.initialize(order.getCustomer()) chaqirish. Uchalasida ham nima yuklanishi bitta joyda koʻrinib turadi.
Yomon yechimlar: bogʻlanishni EAGER qilish — u endi hamma joyda yuklanadi va N+1 manbaiga aylanadi; open-in-viewʼga tayanish; hibernate.enable_lazy_load_no_trans=true — bu sozlama har bir lazy yuklash uchun vaqtinchalik session ochadi va N+1ʼni yashirin qiladi.
// open-in-view oʻchiq: LazyInitializationException
@GetMapping("/orders/{id}/customer")
public String customerName(@PathVariable Long id) {
Order order = orderService.find(id);
return order.getCustomer().getName();
}
// toʻgʻri: kerakli bogʻlanish soʻrovda yuklanadi
@EntityGraph(attributePaths = "customer")
Optional<Order> findWithCustomerById(Long id);Open Session in View nima va Spring Boot nega u haqida ogohlantiradi?Javob
Spring MVC ilovalarida default holatda spring.jpa.open-in-view=true: EntityManager HTTP soʻrov boshida ochiladi va javob yozilgandan keyin yopiladi. Lazy bogʻlanishlar controllerʼda va JSON serializationʼda ham ishlaydi, lekin ular yashirin soʻrovlarga aylanadi va connection soʻrov oxirigacha band qolishi mumkin.
OpenEntityManagerInViewInterceptor soʻrov boshida EntityManagerni threadʼga bogʻlaydi. Service tranzaksiyasi tugagach ham entityʼlar managed qoladi va controller ulardagi lazy bogʻlanishlarga murojaat qila oladi — har murojaat tranzaksiyadan tashqarida, auto-commit rejimida alohida SELECT. Jackson entityʼni JSONʼga yozayotib bogʻlanishlarni aylanib chiqsa, sahifa sezdirmasdan oʻnlab soʻrov yuboradi.
Connection masalasi: Spring Boot sozlagan Hibernate connectionʼni birinchi kerak boʻlganda oladi va EntityManager yopilguncha ushlab turadi. Open-in-view bilan EntityManager soʻrov oxirida yopiladi, demak connection JSON yozish va sekin klientni kutish vaqtida ham pooldan band. Yuk ostida pool tezroq tugaydi.
Yana bir yashirin taʼsir: open-in-view bilan controllerʼda oʻzgartirilgan managed entity keyingi @Transactional chaqiruv commit boʻlganda u bilan birga flush qilinadi, chunki ikkalasi bitta persistence contextʼda.
spring.jpa.open-in-view=false qilingach, tranzaksiyadan tashqaridagi lazy yuklash LazyInitializationException beradi. Bu aniq signal: kerakli maʼlumotni service ichida fetch join, @EntityGraph yoki DTO bilan yuklash kerak. Yangi loyihada uni boshidanoq oʻchirish oson, eski loyihada esa oʻchirib, testlar va loglar boʻyicha joylar birma-bir tuzatiladi.
# application.yml
spring:
jpa:
open-in-view: false7Roʻyxatlarni oʻqish: N+1, projection va filtr
Roʻyxat ekrani — JPA performance muammolari eng koʻp chiqadigan joy. Klassik holat: buyurtmalarni customer nomi bilan chiqarish. Kod beozor koʻrinadi, lekin har bir buyurtmaning lazy customer bogʻlanishiga murojaat alohida soʻrov:
findAll(): bitta soʻrov 4 ta buyurtmani oladi. customer — LAZY: har bir buyurtmada hozircha faqat customer IDʼsi boʻlgan proxy.Bu N+1: roʻyxat uchun 1 ta soʻrov va bogʻlangan entityʼlar uchun yana N ta. Lokal bazada 20 ta qatorda sezilmaydi, productionʼda har soʻrov tarmoq orqali borib kelgani uchun 500 ta qatorda sahifa soniyalab ochiladi.
Yechim — bogʻlanishni soʻrovning oʻzida yuklash. join fetch JPQLʼda, @EntityGraph esa derived query yoki @Query ustida ishlaydi; ikkalasi ham bitta SQL beradi. Farqi: join fetch — inner join, customerʼsiz buyurtmalar natijadan tushib qoladi (left join fetch bunday emas), @EntityGraph esa Hibernateʼda left join boʻladi.
@Query("""
select o from Order o
join fetch o.customer
where o.status = :status
""")
List<Order> findWithCustomer(OrderStatus status);
// xuddi shu natija entity graph bilan
@EntityGraph(attributePaths = "customer")
List<Order> findByStatus(OrderStatus status);Collection fetch join bilan ehtiyot boʻlish kerak. join fetch o.items har buyurtmani itemʼlari soniga qarab bir nechta qatorga koʻpaytiradi. Hibernate 6 takrorlangan buyurtmalarni natijadan oʻzi olib tashlaydi (Hibernate 5 da buning uchun distinct kerak edi), lekin sahifalash bazada ishlamaydi: limit qatorlarni kesgan boʻlardi, shuning uchun Hibernate SQLʼga limit qoʻymaydi — hamma qatorni oʻqib, sahifani xotirada kesadi. Ikkita List kolleksiyani bitta soʻrovda fetch join qilib ham boʻlmaydi — Hibernate MultipleBagFetchException beradi.
Roʻyxat ekraniga koʻpincha entity umuman kerak emas — bir nechta ustun kerak. Toʻliq entity oʻqilsa, hamma ustunlar keladi, har bir entity persistence contextʼga managed boʻlib tushadi, snapshot oladi va flushʼda tekshiriladi. Projection faqat soʻralgan ustunlarni oʻqiydi va hech narsani kuzatmaydi:
| Usul | Qanday | Qachon |
|---|---|---|
| interface projection | getterʼlardan iborat interfeys, Spring Data unga proxy yasaydi | derived query bilan tez yozish |
| DTO projection | record va JPQLʼda select new …(…) | aniq tur, API javobiga toʻgʻridan-toʻgʻri |
| native SQL va projection | native soʻrov natijasi interface yoki DTOʼga | murakkab SQL, hisobotlar |
Filtrli qidiruvda shartlar foydalanuvchiga qarab qoʻshiladi: status tanlangan boʻlishi ham, boʻlmasligi ham mumkin. Har kombinatsiya uchun alohida metod yozib boʻlmaydi. Uchta asosiy yoʻl bor: Specification — Criteria API ustidagi Spring Data qobigʻi, Criteria APIʼning oʻzi va Querydsl — annotation processor generatsiya qilgan QOrder kabi klasslar bilan type-safe soʻrov. Hammasi Pageable bilan birga ishlaydi.
Sahifalashda natija turi ham muhim. Page<T> sahifa bilan birga umumiy sonni ham qaytaradi — buning uchun Spring Data har safar qoʻshimcha select count(…) bajaradi. Katta jadvalda va murakkab filtrda u asosiy soʻrovdan ham qimmat boʻlishi mumkin. Slice<T> esa faqat keyingi sahifa bor-yoʻqligini biladi: size + 1 ta qator oʻqiydi va count soʻrovi yoʻq.
Tushunganingizni tekshiring
N+1 muammosi nima, qanday aniqlanadi va qanday hal qilinadi?Javob
Roʻyxat uchun 1 ta soʻrov, keyin har bir elementning lazy bogʻlanishi uchun yana bittadan — jami N+1. SQL logida bir xil select … where id = ? qatorlarining ketma-ket kelishidan koʻrinadi. Hal qilish — bogʻlanishni soʻrovning oʻzida yuklash: join fetch, @EntityGraph yoki batch fetching.
N+1 kodda koʻrinmaydi: order.getCustomer().getName() oddiy getter, soʻrovni Hibernate proxy yuboradi. Koʻpincha u Jackson entityʼni JSONʼga yozayotganda yoki toString()da paydo boʻladi. EAGER bogʻlanish ham N+1ʼdan qutqarmaydi: findAll() va JPQL soʻrovlarda Hibernate EAGER bogʻlanishlarni alohida SELECTlar bilan yuklaydi.
join fetch va @EntityGraph bogʻlanishni JOIN bilan bitta soʻrovda oladi. Batch fetching (@BatchSize(size = 50) yoki hibernate.default_batch_fetch_size) esa soʻrovni oʻzgartirmaydi: birinchi proxy initialize qilinganda Hibernate contextʼdagi shu turdagi boshqa initialize qilinmagan proxyʼlarni ham bitta soʻrovda, bir nechta ID boʻyicha yuklaydi. 1 + N oʻrniga taxminan 1 + N/50 — kodga tegmasdan yaxshi himoya.
Eng ishonchlisi — muammoni test bilan ushlash: muhim roʻyxat soʻrovlari uchun SQL soni tekshiriladi va kimdir yangi lazy bogʻlanishga murojaat qoʻshsa, test yiqiladi. Bu keyingi savolda.
-- N+1: 1 + har bir customer uchun bittadan
select o.id, o.customer_id, o.total from orders o;
select c.id, c.name from customer c where c.id = ?;
select c.id, c.name from customer c where c.id = ?;
-- …
-- join fetch: bitta soʻrov
select o.id, o.total, c.id, c.name
from orders o
join customer c on c.id = o.customer_id;Sahifa ORM sabab sekin ishlayapti. Generatsiya qilingan SQLʼni qanday koʻrasiz va soʻrovlar sonini testda qanday tekshirasiz?Javob
SQLʼni org.hibernate.SQL loggeri, parametrlarni Hibernate 6 da org.hibernate.orm.jdbc.bind loggeri koʻrsatadi. Soʻrovlar sonini Hibernate statistics (hibernate.generate_statistics) sanaydi — uni testda ham ishlatib, muhim soʻrovlar uchun SQL sonini assert qilish mumkin.
Avval faktlar: bitta HTTP soʻrovda nechta SQL ketdi va qaysilari sekin. spring.jpa.show-sql=true SQLʼni toʻgʻridan-toʻgʻri stdoutʼga chiqaradi va logging sozlamalariga boʻysunmaydi, shuning uchun logger orqali yoqish yaxshiroq. generate_statistics yoqilsa, Hibernate har session oxirida nechta JDBC statement bajarilgani va ularga qancha vaqt ketgani haqida log yozadi. Productionʼda esa SQLʼni bazaning oʻzi koʻrsatadi: PostgreSQLʼda pg_stat_statements va EXPLAIN ANALYZE.
Logdagi odatiy belgilar: bir xil select … where id = ? seriyasi — N+1; bitta soʻrovda keraksiz JOINʼlar va ustunlar — EAGER bogʻlanishlar yoki toʻliq entity; har INSERT alohida — batching yoqilmagan yoki IDENTITY; flushʼda kutilmagan UPDATElar — kimdir managed entityʼni bilmasdan oʻzgartirgan.
Native SQLʼga oʻtish ORMʼdan voz kechish emas, muayyan soʻrov uchun tanlov: hisobotlar, window function va CTE kerak boʻlgan agregatsiyalar, bazaning oʻziga xos imkoniyatlari (on conflict, JSONB, for update skip locked). Natija DTO yoki interface projection boʻlib qaytsa, persistence contextʼga ham tegmaydi.
# application.yml
logging.level:
org.hibernate.SQL: debug
# parametr qiymatlari (Hibernate 6)
org.hibernate.orm.jdbc.bind: trace
// test: roʻyxat bitta SQL bilan oʻqilishi kerak
@DataJpaTest(properties = "spring.jpa.properties"
+ ".hibernate.generate_statistics=true")
class OrderQueriesTest {
@Autowired EntityManager em;
@Autowired OrderRepository orders;
@Test
void listIsOneQuery() {
// test maʼlumotlari saqlangan deb olamiz;
// context boʻsh: hammasi bazadan oʻqiladi
em.flush();
em.clear();
Statistics stats = em.getEntityManagerFactory()
.unwrap(SessionFactory.class)
.getStatistics();
stats.clear();
orders.findWithCustomer(OrderStatus.NEW)
.forEach(o -> o.getCustomer().getName());
assertThat(stats.getPrepareStatementCount())
.isEqualTo(1);
}
}Roʻyxat ekrani uchun nega toʻliq entity emas, projection oʻqiladi? Interface va DTO projection farqi nima?Javob
Toʻliq entity hamma ustunlarni oʻqiydi, persistence contextʼga managed boʻlib tushadi, snapshot oladi va flushʼda tekshiriladi. Projection faqat kerakli ustunlarni oʻqiydi va hech narsani kuzatmaydi. Interface projectionʼga Spring Data proxy yasaydi, DTO projection esa oddiy klass yoki record.
Interface projection — getterʼlardan iborat interfeys. U derived query qaytarish turi boʻlsa, Spring Data faqat shu fieldʼlarni select qiladi — bu closed projection. @Value("#{…}") bilan hisoblanadigan open projection esa butun entityʼni yuklaydi va tejash yoʻqoladi. @Query bilan ishlatilsa, ustunlarga getter nomida alias beriladi: select o.id as id, c.name as customerName ….
DTO projection JPQLʼda constructor expression bilan yoziladi: select new com.app.orders.OrderRow(o.id, o.number, c.name) from Order o join o.customer c. Klassning toʻliq nomi yoziladi, konstruktor parametrlari esa select tartibiga mos boʻlishi kerak. Javaʼda buning uchun record qulay.
Projection hamma joyda yaxshi emas: biror narsani oʻzgartirish kerak boʻlsa (holatni almashtirish, biznes qoida), entity kerak — dirty checking, @Version va cascade faqat entity bilan ishlaydi. Oddiy qoida: roʻyxat va hisobot — projection, oʻzgartirish — entity.
public record OrderRow(Long id, String number,
String customerName) {}
public interface OrderRepository
extends JpaRepository<Order, Long> {
@Query("""
select new com.app.orders.OrderRow(
o.id, o.number, c.name)
from Order o join o.customer c
where o.status = :status
""")
List<OrderRow> findRows(OrderStatus status);
}Filtrli qidiruvni qanday yozasiz va Page bilan Slice farqi nima?Javob
Shartlar dinamik boʻlsa — Specification, Criteria API yoki Querydsl: har filtr alohida predicate, keraklilari birlashtiriladi. Page umumiy sonni ham beradi va buning uchun har safar qoʻshimcha count soʻrovi bajaradi. Slice esa faqat keyingi sahifa bor-yoʻqligini biladi va count qilmaydi.
Specification<T> — (root, query, cb) -> Predicate funksiyasi. Repository JpaSpecificationExecutor<T>dan meros olsa, findAll(spec, pageable) paydo boʻladi. Filtrlarni kichik static metodlar qilib yozish va Specification.allOf(…) bilan birlashtirish qulay: filtr berilmagan boʻlsa, u roʻyxatga qoʻshilmaydi.
Criteria API — JPA standarti, lekin uning kodi uzun; Hibernate metamodel generatori yasaydigan Order_ kabi klasslar bilan field nomlari type-safe boʻladi. Querydsl xuddi shu ishni qisqaroq qiladi: annotation processor QOrder klassini generatsiya qiladi va soʻrov order.status.eq(NEW).and(order.total.gt(min)) koʻrinishida yoziladi. U alohida kutubxona va build sozlamasini talab qiladi.
Count soʻrovi katta jadvalda qimmat: select count(…) shartga mos hamma qatorlarni sanab chiqishi kerak, sahifada esa atigi 20 tasi kerak. Cheksiz scroll yoki «keyingi» tugmasi boʻlgan ekranlarda Slice yetarli. Juda chuqur sahifalarda offsetning oʻzi ham sekinlashadi — baza tashlab yuborilgan qatorlarni ham oʻqiydi. Buning uchun keyset pagination bor: Spring Data 3.1 dan ScrollPosition va Window.
public interface OrderRepository
extends JpaRepository<Order, Long>,
JpaSpecificationExecutor<Order> {}
class OrderSpecs {
static Specification<Order> status(OrderStatus s) {
return (r, q, cb) ->
cb.equal(r.get("status"), s);
}
static Specification<Order> min(BigDecimal v) {
return (r, q, cb) -> cb.greaterThanOrEqualTo(
r.get("total"), v);
}
}
List<Specification<Order>> specs = new ArrayList<>();
if (f.status() != null) specs.add(status(f.status()));
if (f.min() != null) specs.add(min(f.min()));
Pageable p = PageRequest.of(0, 20,
Sort.by("createdAt").descending());
Page<Order> page =
orders.findAll(Specification.allOf(specs), p);8Parallel oʻzgarishlar: optimistic va pessimistic locking
Ikki foydalanuvchi bitta buyurtmani bir vaqtda ochib, ikkalasi ham oʻzgartirib saqlasa, ikkinchisining UPDATEi birinchisining ishini jimgina bosib ketadi — bu lost update. PostgreSQLʼning default READ COMMITTED isolation levelʼi buning oldini olmaydi: har bir UPDATE alohida olganda toʻgʻri, xato ularning ketma-ketligida. JPA buning uchun ikki yondashuv beradi.
Optimistic locking konflikt kam boʻladi deb hisoblaydi va lock olmaydi. Entityʼga @Version field qoʻshiladi, Hibernate har UPDATEda versiyani oshiradi va WHEREda eskisini tekshiradi:
version = 3 bilan oʻqidi va oʻzgartirdi.Pessimistic locking esa qatorni oʻqish paytidayoq lock qiladi. @Lock(LockModeType.PESSIMISTIC_WRITE)ni PostgreSQLʼda Hibernate 6 va 7 select … for no key update qilib yuboradi. Boshqa tranzaksiyalar shu qatorni oʻzgartirish, oʻchirish yoki lock qilish uchun birinchisi tugashini kutadi; faqat unga foreign key bilan bogʻlangan yangi qator qoʻshish toʻxtamaydi.
| Mezon | Optimistic (`@Version`) | Pessimistic (`PESSIMISTIC_WRITE`) |
|---|---|---|
| Lock | yoʻq, konflikt flush paytida aniqlanadi | qator tranzaksiya oxirigacha lock qilinadi |
| Konflikt boʻlsa | OptimisticLockException, amalni qaytadan bajarish kerak | ikkinchi tranzaksiya kutadi |
| Qachon mos | konflikt kam; foydalanuvchi tahrir qiladigan maʼlumot, soʻrovlar orasidagi «oʻylash vaqti» | konflikt tez-tez va kritik qism qisqa: balans, qoldiq, navbat |
| Xavfi | konflikt koʻp boʻlsa, retryʼlar koʻpayadi | deadlock, kutish, connection uzoq band |
Tushunganingizni tekshiring
@Version qanday ishlaydi va OptimisticLockException qachon chiqadi?Javob
Hibernate har UPDATEda versiyani bittaga oshiradi va WHEREga eski versiyani qoʻshadi: where id = ? and version = ?. Boshqa tranzaksiya qatorni oldinroq oʻzgartirgan boʻlsa, versiya mos kelmaydi, UPDATE 0 ta qatorga taʼsir qiladi va Hibernate OptimisticLockException tashlaydi.
Versiya fieldʼi odatda Long yoki Integer, vaqt turi ham boʻlishi mumkin. Uni oʻzingiz oʻzgartirmaysiz — Hibernate boshqaradi. Exception flush paytida chiqadi, Spring ilovasida koʻpincha @Transactional metod tugab commit boʻlayotganda, shuning uchun metod ichidagi try/catch uni ushlamaydi. Spring uni ObjectOptimisticLockingFailureExceptionga oʻraydi, u OptimisticLockingFailureExceptionning subclassʼi.
Konflikt boʻlganda tranzaksiya rollback boʻladi va uni shu tranzaksiya ichida davom ettirib boʻlmaydi: persistence context eskirgan. Amalni yangi tranzaksiyada qaytadan bajarish kerak — qatorni yangi versiya bilan qayta oʻqib, oʻzgarishni qayta qoʻllash. Foydalanuvchi tahririda esa avtomatik retry emas, «maʼlumot oʻzgargan, yangilab qayta urinib koʻring» degan javob — HTTP 409 — toʻgʻriroq.
Foydalanuvchi formani ochib, besh daqiqadan keyin saqlasa, bu vaqt bir nechta HTTP soʻrovga boʻlinadi. Himoya ishlashi uchun klient versiyani ham olib, qaytarib yuborishi kerak: server yuklangan entity versiyasini klientdan kelgan versiya bilan solishtiradi va farq boʻlsa, oʻzgarishni qabul qilmaydi. Aks holda @Version faqat bitta soʻrov ichidagi qisqa oraliqni himoya qiladi.
JPQL bulk update versiyani oʻzi oshirmaydi: uni soʻrovning oʻzida o.version = o.version + 1 deb yozish kerak, HQLʼda buning uchun update versioned ham bor.
@Entity
@Table(name = "orders")
public class Order {
@Id @GeneratedValue
private Long id;
@Version
private Long version;
// …
}
// Hibernate yuboradigan SQL:
// update orders set status=?, version=?
// where id=? and version=?Pessimistic locking qachon kerak va PESSIMISTIC_WRITE qanday ishlaydi?Javob
@Lock(LockModeType.PESSIMISTIC_WRITE) qatorni lock bilan oʻqiydi — PostgreSQLʼda select … for no key update: boshqa tranzaksiyalar uni oʻzgartirish, oʻchirish yoki lock qilish uchun birinchisi tugashini kutadi. U konflikt tez-tez boʻladigan va kritik qism qisqa joylarda kerak: balans, ombordagi qoldiq, ish navbati.
Lock tranzaksiya oxirigacha turadi, shuning uchun tranzaksiya imkon qadar qisqa boʻlishi kerak: tashqi chaqiruvlarsiz, faqat oʻqish, tekshirish va yozish. Lockʼli soʻrov tranzaksiyasiz chaqirilsa, u bajarilmaydi: JPA spec boʻyicha bu TransactionRequiredException.
Ikki tranzaksiya ikki qatorni teskari tartibda lock qilsa — deadlock: baza ulardan birini xato bilan toʻxtatadi. Bir nechta qatorni lock qilganda ularni doim bir xil tartibda, masalan ID boʻyicha olish kerak. Kutish vaqtini cheklash ham foydali: PostgreSQLʼda lock_timeout. JPAʼning jakarta.persistence.lock.timeout hintini esa har baza dialecti har xil qoʻllaydi.
Koʻpincha lockʼsiz ham boʻladi: atomik UPDATE bitta soʻrovda tekshiradi va yozadi — update account set balance = balance - :sum where id = :id and balance >= :sum. Natija 0 qator boʻlsa, mablagʻ yetmagan. Ish navbati uchun esa native SQLʼdagi for update skip locked: har worker boshqalar lock qilgan qatorlarni oʻtkazib, boʻshini oladi.
public interface AccountRepository
extends JpaRepository<Account, Long> {
// … where id = ? for no key update
@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("select a from Account a where a.id = :id")
Optional<Account> findForUpdate(Long id);
}
@Transactional
public void transfer(long fromId, long toId,
BigDecimal sum) {
// deadlock boʻlmasligi uchun: kichik ID birinchi
Map<Long, Account> locked = new HashMap<>();
for (long id : List.of(Math.min(fromId, toId),
Math.max(fromId, toId)))
locked.put(id, accounts.findForUpdate(id)
.orElseThrow());
locked.get(fromId).withdraw(sum);
locked.get(toId).deposit(sum);
}9Katta hajm, second-level cache va JPA qachon mos emas
JPA bir vaqtda oʻnlab entity bilan ishlaydigan biznes amallar uchun yaratilgan. Yuz minglab qatorni yozish yoki oʻqishda uning qulayliklari — persistence context va dirty checking — xarajatga aylanadi: har entity xotirada ikki nusxada turadi, har flush hammasini tekshiradi. Katta hajmda uchta narsa muhim: batching, persistence contextʼni tozalab turish va kerak boʻlmasa entityʼdan voz kechish.
Batch insert uchun Hibernateʼda JDBC batching yoqiladi — u default holatda oʻchiq (hibernate.jdbc.batch_size = 0). IDENTITY generatorli entityʼlar uchun u baribir ishlamaydi.
spring:
jpa:
properties:
hibernate.jdbc.batch_size: 50
hibernate.order_inserts: true
hibernate.order_updates: true
datasource:
# PostgreSQL: batch → koʻp qatorli INSERT
url: jdbc:postgresql://db/app?reWriteBatchedInserts=trueCache haqida. Persistence context — bitta tranzaksiyaning cacheʼi. Second-level cache esa butun EntityManagerFactory uchun umumiy: hamma tranzaksiyalar va threadʼlar uni boʻlishadi. U default holatda ishlamaydi va provider talab qiladi: JCache orqali Ehcache 3 yoki Caffeine, yoki Infinispan, Hazelcast.
| Cache | Qamrovi | Nimani saqlaydi | Qachon ishlatiladi |
|---|---|---|---|
| first-level | bitta persistence context | managed obyektlarning oʻzi | doim, oʻchirib boʻlmaydi |
| second-level | EntityManagerFactory, odatda bitta JVM | entity maʼlumoti ID boʻyicha, obyekt emas | find, findById, ID boʻyicha lazy yuklash |
| query cache | EntityManagerFactory, odatda bitta JVM | soʻrov natijasi parametrlar boʻyicha | faqat cacheable deb belgilangan soʻrovlar |
spring:
jpa:
properties:
hibernate.cache.use_second_level_cache: true
hibernate.cache.use_query_cache: true
# classpathʼda JCache provider: Ehcache 3
# yoki Caffeine jcache moduli
hibernate.cache.region.factory_class: jcacheJPAʼning oʻzi ham hamma joyga mos emas. Spring ekotizimida soddaroq yoʻllar bor:
| Vosita | Nima beradi | Nima yoʻq | Qachon |
|---|---|---|---|
| JPA va Hibernate | obyekt grafi, dirty checking, lazy loading, cache, inheritance | SQL ustidan toʻliq nazorat va oddiylik | boy domain, koʻp yozish amallari |
| Spring Data JDBC | repository, aggregate birga yuklanadi va saqlanadi | persistence context, lazy loading, dirty checking | aniq aggregateʼlar, oldindan aytsa boʻladigan SQL |
| jOOQ | schemadan generatsiya qilingan type-safe SQL | persistence context, lazy loading; tijoriy bazalar uchun bepul versiya | murakkab SQL, hisobotlar |
JdbcClient, JdbcTemplate | oddiy SQL va qatorni obyektga mapping | deyarli hamma narsa qoʻlda | bir nechta soʻrov, kichik servis, batch |
Tushunganingizni tekshiring
Yuz minglab qatorni JPA bilan qanday yozasiz va qanday oʻqiysiz?Javob
Yozishda: hibernate.jdbc.batch_size bilan JDBC batching, SEQUENCE ID (IDENTITY batchingʼni oʻchiradi) va har necha oʻnlab entityʼda flush() va clear(). Oʻqishda: hammasini bitta Listga olmasdan, sahifalab (Slice, keyset) yoki tranzaksiya ichida Stream bilan, entityʼlarni contextʼdan chiqarib borib.
Batching bir xil INSERTlarni bitta tarmoq chaqiruviga yigʻadi. order_inserts har xil entityʼlar aralash saqlanganda ularni turi boʻyicha guruhlaydi, aks holda har tur almashganda batch uziladi. saveAll() bularning hammasini oʻzi qilmaydi: u har element uchun save() chaqiradi, batching esa Hibernate sozlamasidan keladi.
flush() va clear()siz bitta tranzaksiyada 100 000 entity persistence contextʼda qoladi: xotira oʻsadi, har keyingi flush esa hammasini qayta tekshiradi. Har batch oʻlchamida flush() — SQL yuboriladi, clear() — context boʻshaydi; xotira va vaqt bir tekis qoladi.
Stream<Order> qaytaradigan repository metodi tranzaksiya ichida chaqirilishi va try-with-resources bilan yopilishi kerak. Natija haqiqatan qismlab kelishi uchun fetch size beriladi: PostgreSQL drayveri fetch sizeʼsiz hamma qatorni birdan xotiraga oladi. Oʻqilgan entityʼlar baribir contextʼda yigʻiladi, shuning uchun ularni em.detach() qilib borish yoki projection oqimini oʻqish kerak.
Hamma qatorni bir xil oʻzgartiradigan amal uchun entity yuklash shart emas: @Modifying @Query("update …") bitta SQL bilan bajariladi. U persistence contextʼni chetlab oʻtadi: contextʼdagi entityʼlar eski qiymatda qoladi (clearAutomatically = true contextʼni tozalaydi), @Version esa oʻzi oshmaydi.
@Transactional
public void importOrders(List<OrderDto> rows) {
for (int i = 0; i < rows.size(); i++) {
em.persist(Order.from(rows.get(i)));
// batch_size bilan bir xil oʻlcham
if ((i + 1) % 50 == 0) {
em.flush();
em.clear();
}
}
}
@QueryHints(@QueryHint(
name = "org.hibernate.fetchSize",
value = "500"))
@Query("select o from Order o where o.status = :s")
Stream<Order> streamByStatus(OrderStatus s);
@Transactional(readOnly = true)
public void export(OrderStatus status, Writer out) {
try (var s = orders.streamByStatus(status)) {
s.forEach(o -> {
write(out, o);
em.detach(o);
});
}
}First-level va second-level cache farqi nima? Second-level cache qachon eskirgan maʼlumot qaytaradi?Javob
First-level cache — persistence contextʼning oʻzi: bitta tranzaksiya ichida ishlaydi va uni oʻchirib boʻlmaydi. Second-level cache butun EntityManagerFactory uchun umumiy, ixtiyoriy va alohida provider talab qiladi. U Hibernateʼdan oʻtmagan oʻzgarishlarni bilmaydi: boshqa servis, qoʻlda yozilgan SQL yoki boshqa ilova instansiyasi orqali qilingan oʻzgarishdan keyin eski maʼlumot qaytarishi mumkin.
Second-level cache entity maʼlumotini ID boʻyicha saqlaydi va find, findById hamda ID boʻyicha lazy yuklashda bazaga bormaslikka yordam beradi. Eng mos joy — koʻp oʻqiladigan, kam oʻzgaradigan maʼlumot: mamlakatlar, tariflar, sozlamalar. Tez-tez yoziladigan entity uchun foydasi kam: har yozish cacheʼni yangilashi yoki bekor qilishi kerak.
Query cache soʻrov natijasini parametrlar boʻyicha saqlaydi va soʻrovdagi jadvallardan biri Hibernate orqali oʻzgarishi bilan uni bekor qiladi. Jadval tez-tez yozilsa, natija deyarli doim bekor qilingan boʻladi — foyda yoʻq, ustiga xarajat. Shuning uchun u faqat aniq cacheable deb belgilangan va kam oʻzgaradigan maʼlumot ustidagi soʻrovlar uchun.
Eskirgan maʼlumotning asosiy manbalari: bazani Hibernateʼni chetlab oʻzgartirish (migratsiya, boshqa servis, psql) va bir nechta ilova instansiyasi. Ehcache yoki Caffeine odatda har instansiyada lokal: A instansiya yozgan oʻzgarishni B instansiyaning cacheʼi bilmaydi. Buning uchun distributed provider (Infinispan, Hazelcast), qisqa TTL yoki cacheʼni faqat oʻzgarmaydigan maʼlumot uchun ishlatish kerak.
@Entity
@Cacheable
@org.hibernate.annotations.Cache(
usage = CacheConcurrencyStrategy.READ_WRITE)
public class Tariff {
@Id
private Long id;
private String name;
private boolean active;
}
// query cache: faqat belgilangan soʻrov
@QueryHints(@QueryHint(
name = "org.hibernate.cacheable",
value = "true"))
List<Tariff> findByActiveTrue();Yangi servis uchun JPA, Spring Data JDBC, jOOQ yoki oddiy SQLʼdan qaysi birini tanlaysiz?Javob
Domain boy, entity grafi koʻp va amallar asosan «yukla, oʻzgartir, saqla» boʻlsa — JPA oʻzini oqlaydi. Aggregateʼlar aniq va oldindan aytsa boʻladigan SQL muhim boʻlsa — Spring Data JDBC. SQLʼning oʻzi asosiy boʻlsa (hisobot, murakkab soʻrov) — jOOQ yoki JdbcClient.
JPAʼning narxi — oʻrganish va yashirin xatti-harakat: persistence context, flush tartibi, lazy loading, N+1, open-in-view. Bu narx boy domain modelda oʻzini oqlaydi: obyekt grafi bilan ishlash, dirty checking, cascade, optimistic locking — bir annotatsiya bilan. Jamoa bu mexanizmlarni bilmasa, xuddi shu qulayliklar production muammolariga aylanadi.
Spring Data JDBC — repository qulayligi, lekin sehrsiz: persistence context, lazy loading va dirty checking yoʻq. Aggregate root oʻzining ichki entityʼlari bilan birga yuklanadi va birga saqlanadi, boshqa aggregateʼlarga esa faqat ID orqali murojaat qilinadi. Mavjud aggregate saqlanganda uning ichki qatorlari oʻchirilib, qayta yoziladi — shuning uchun aggregateʼlar kichik boʻlishi kerak.
jOOQ schemadan Java klasslarini generatsiya qiladi va SQLʼni type-safe DSL bilan yozdiradi: window function, CTE, on conflict — hammasi kompilyator tekshiruvi ostida. Ochiq bazalar uchun bepul, Oracle va SQL Server kabi tijoriy bazalar uchun pullik litsenziya kerak. JdbcClient (Spring Framework 6.1 dan) esa eng oddiy yoʻl: SQL qatori, parametrlar va natijani recordga mapping.
Bitta servisda aralash ham boʻladi: biznes amallar va yozish JPA bilan, ogʻir hisobot va roʻyxatlar native SQL, jOOQ yoki JdbcClient bilan. Muhimi — tanlovni har soʻrov uchun ongli qilish.
record CityTotal(String city, BigDecimal total) {}
List<CityTotal> totals = jdbc.sql("""
select c.city, sum(o.total) as total
from orders o
join customer c on c.id = o.customer_id
where o.created_at >= :from
group by c.city
order by total desc
""")
.param("from", from)
.query(CityTotal.class)
.list();Tushunganingizni suhbatda sinab koʻring
Mavzuli mock intervyuda «Spring Data JPA va Hibernate»ni tanlang. AI shu kabi savollarni beradi, javobingizga qarab chuqurroq savol soʻraydi va har javobingizga fikr bildiradi.