DonanımHaber

Hibernate etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster
Hibernate etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster

Hibernate ileri seviye interview soruları ve cevapları






Hibernate ile ilgili ileri düzey mülakat soruları ve cevapları, genellikle Hibernate'in çekirdek konseptlerini, performans optimizasyon tekniklerini, ilişkisel veri modelleme stratejilerini ve sorgulama mekanizmalarını kapsar. İşte bu konulara yönelik bazı örnek sorular ve kısa cevapları:


Soru: Hibernate'de Lazy Loading nedir ve nasıl çalışır?


Cevap: Lazy Loading, bir nesnenin ilişkili nesnelerinin ihtiyaç duyulduğunda, yani erişildiğinde yüklenmesi yöntemidir. Bu, gereksiz veri yüklemeyi önlemek ve performansı artırmak için kullanılır. Hibernate, proxy nesneleri veya bytecode enhancement kullanarak lazy loading'i gerçekleştirir.


Soru: Hibernate'de Eager Loading ile Lazy Loading arasındaki fark nedir?


Cevap: Eager Loading, bir nesne sorgulandığında ilişkili nesnelerin de hemen yüklenmesi demektir. Lazy Loading ise, ilişkili nesnelerin yalnızca gerçekten ihtiyaç duyulduğunda yüklenmesidir. Eager Loading, veritabanına yapılan sorgu sayısını azaltabilir ancak gereksiz yere fazla veri yüklemeye neden olabilir. Lazy Loading performansı artırabilir ancak ihtiyaç duyulduğunda ekstra sorgular gerektirebilir.


Soru: Hibernate'de @Entity ve @Table annotasyonlarının farkı nedir?


Cevap: @Entity annotasyonu, bir sınıfın bir veritabanı tablosuna karşılık geldiğini Hibernate'e belirtir. @Table annotasyonu ise, sınıfın eşleştirildiği tablonun adını ve isteğe bağlı olarak schema adını belirlemek için kullanılır. @Entity zorunludur, ancak @Table kullanımı isteğe bağlıdır; eğer kullanılmazsa, sınıf adı tablo adı olarak varsayılır.


Soru: Hibernate'de 1. Seviye ve 2. Seviye Önbellek nedir?


Cevap: 1. Seviye Önbellek, Hibernate Session'ın bir parçasıdır ve yalnızca o session süresince yaşar. Her sorgulama veya güncelleme işlemi öncelikle bu önbellekte kontrol edilir. 2. Seviye Önbellek ise, farklı Session'lar arasında paylaşılabilir ve daha genel bir önbellekleme mekanizması sağlar, böylece uygulama genelinde veri tekrar kullanılabilirliğini ve performansı artırabilir.


Soru: Hibernate'de Criteria API ve HQL arasındaki fark nedir?


Cevap: HQL (Hibernate Query Language), veritabanı tabloları üzerinde sorgulama yapmak için kullanılan bir sorgulama dili iken, Criteria API, programatik olarak, nesne yönelimli bir şekilde sorgular oluşturmak için kullanılır. HQL, sorgu yazımında daha esnek ve ifade gücü yüksekken, Criteria API daha dinamik sorgu oluşturma imkanı sunar ve tip güvenliğini artırır.


Soru: Hibernate'de Optimistic ve Pessimistic Kilitlenme nedir?


Cevap: Optimistic Kilitlenme, veri çakışmalarını önlemek için sürüm numarası veya zaman damgası kullanır. Veri güncellenmeden önce, sürüm numarası veya zaman damgasının değişip değişmediği kontrol edilir. Pessimistic Kilitlenme ise, bir kaynağa erişim sırasında veritabanı seviyesinde kilit kullanır, böylece diğer işlemler o kaynağı değiştiremez veya okuyamaz. Optimistic kilitlenme genellikle okuma yoğun uygulamalarda tercih edilirken, Pessimistic kilitlenme yazma yoğun işlemlerde veya yüksek çakışma riski olan durumlarda kullanılır.


Soru: Hibernate'de cascade türleri nelerdir ve nasıl kullanılır?


Cevap: Hibernate'de cascade türleri, bir nesne üzerinde yapılan işlemlerin ilişkili nesnelere nasıl uygulanacağını belirler. Ana cascade türleri şunlardır: ALL, PERSIST, MERGE, REMOVE, REFRESH, DETACH. Örneğin, bir Parent nesnesi Child nesneleri ile bir ilişki içindeyse ve Parent nesnesi kaydedildiğinde (PERSIST) veya güncellendiğinde (MERGE) Child nesnelerinin de otomatik olarak kaydedilmesi veya güncellenmesi isteniyorsa, ilgili cascade türü ilişkide belirtilir.


Soru: Hibernate Query Plan Cache nedir ve performans üzerindeki etkisi nedir?


Cevap: Hibernate Query Plan Cache, sorgu planlarını önbelleklemek için kullanılır. Bu, aynı sorgunun tekrar tekrar çalıştırılması durumunda, sorgu derleme süresini azaltarak performansı artırır. Önbellek, sorgu metni ve bağlamı (örneğin, parametre türleri) bazında sorgu planlarını saklar. Bu özellik, özellikle karmaşık sorguların ve sık çalıştırılan sorguların olduğu uygulamalarda önemli performans iyileştirmeleri sağlayabilir.


Soru: Hibernate'de entity sınıflarını nasıl optimize edebiliriz?


Cevap: Hibernate'de entity sınıflarını optimize etmek için birkaç yöntem vardır:


Lazy Loading kullanımı: Gereksiz veri yüklemeyi önlemek için ilişkili nesneler için lazy loading kullanılmalıdır.

@DynamicUpdate ve @DynamicInsert annotasyonları: Bu annotasyonlar, yalnızca değişen alanların güncellenmesi veya eklenmesi için Hibernate'i yönlendirir, bu da SQL işlemlerinin verimliliğini artırabilir.

@SelectBeforeUpdate annotasyonu: Bu, bir nesnenin güncellenmeden önce veritabanından seçilip seçilmeyeceğini belirler. Gereksiz güncellemeleri önlemek için kullanılabilir.

İlişkileri dikkatli modelleme: @ManyToOne ve @OneToMany gibi ilişkilerin doğru kullanılması ve fetch türlerinin (EAGER veya LAZY) ihtiyaca göre ayarlanması önemlidir.

Soru: Hibernate'de SQL enjeksiyon saldırılarına karşı nasıl korunabiliriz?


Cevap: Hibernate, parametreli sorgular ve HQL/JPQL sorguları kullanarak SQL enjeksiyon saldırılarına karşı koruma sağlar. Bu, kullanıcı girdilerinin doğrudan sorgu metnine eklenmesi yerine parametre olarak geçirilmesini sağlar. Ayrıca, uygulama geliştiricilerin kullanıcı girdilerini doğrulaması ve temizlemesi her zaman iyi bir pratiktir.


Bu sorular ve cevaplar, Hibernate ile ilgili ileri düzey mülakatlar için bir başlangıç noktası sunar. Ancak, her bir konunun derinlemesine anlaşılması ve uygulamalı deneyim, mülakat başarısı için kritik öneme sahiptir.yesinde kilitler kullanarak çakışmaları önler. Bu, veri üzerinde işlem yapılırken başka işlemlerin o veriye erişimini engeller.


Optimistic Kilitlenme genellikle okuma yoğun uygulamalarda tercih edilirken, Pessimistic Kilitlenme yazma işlemlerinin yoğun olduğu durumlar için daha uygun olabilir. Optimistic Kilitlenme, veritabanı kaynaklarını daha az kullanır ve uygulamanın ölçeklenebilirliğini artırabilir, ancak çakışma yönetimi uygulama tarafında yapılmalıdır. Pessimistic Kilitlenme ise, veri tutarlılığını garantiler ancak performansı ve ölçeklenebilirliği olumsuz etkileyebilir.


Soru: Hibernate'de entity sınıflarında inheritance (kalıtım) yönetimi nasıl yapılır?


Cevap: Hibernate, entity sınıfları arasında kalıtımı yönetmek için üç ana strateji sunar: tek tablo (single table), birleştirilmiş tablolar (joined), ve sınıf başına tablo (table per class). Tek tablo stratejisi, tüm sınıf hiyerarşisini tek bir tabloda tutar ve bir discriminator sütunu kullanarak sınıfları ayırt eder. Birleştirilmiş tablolar stratejisi, her sınıf için ayrı bir tablo kullanır ve JOIN operasyonları ile ilişkilendirir. Sınıf başına tablo stratejisi ise, her sınıf için ayrı bir tablo kullanır, ancak kalıtım hiyerarşisindeki ilişkileri veritabanı seviyesinde temsil etmez.


Soru: Hibernate'de Query Cache ve Second Level Cache arasındaki ilişki nedir?


Cevap: Second Level Cache, entity veya collection'ların önbelleklenmesi için kullanılırken, Query Cache, sorgu sonuçlarının önbelleklenmesi için kullanılır. Query Cache'in etkili bir şekilde çalışabilmesi için Second Level Cache'in etkinleştirilmiş olması gerekir. Query Cache, belirli bir sorgunun sonuçlarını önbellekler, ancak bu sonuçlardaki entity'lerin güncel olması için, bu entity'lerin Second Level Cache üzerinden yönetilmesi gereklidir. Dolayısıyla, Query Cache ve Second Level Cache birlikte çalışarak, hem sorgu sonuçlarını hem de bu sonuçlardaki entity'leri önbellekleyerek uygulamanın performansını artırabilir.


Soru: Hibernate'de @OneToMany ve @ManyToOne ilişkilerinde cascade türlerinin kullanımı nasıldır?


Cevap: @OneToMany ve @ManyToOne ilişkilerinde cascade özelliği, ilişkili nesneler üzerinde yapılan işlemlerin (örneğin, kaydetme, güncelleme, silme) nasıl yönetileceğini belirler. Örneğin, bir Parent sınıfı Child sınıfıyla @OneToMany ilişkisi içindeyse ve cascade = CascadeType.ALL ayarlanmışsa, Parent nesnesi üzerinde yapılan bir işlem (kaydetme, güncelleme, silme) otomatik olarak Child nesnelerine de uygulanır. Bu, ilişkili nesneler arasındaki veri tutarlılığını kolayca yönetmek için kullanılır. Ancak, cascade türünün dikkatli seçilmesi gerekir, çünkü gereksiz yere geniş kapsamlı veri işlemlerine yol açabilir.


Soru: Hibernate'de N+1 sorgu problemi nedir ve nasıl çözülür?


Cevap: N+1 sorgu problemi, bir entity ve onun ilişkili nesnelerini yüklerken ortaya çıkan bir performans sorunudur. Örneğin, bir Parent entity'si ile ilişkili çok sayıda Child entity'sini yüklerken, ilk olarak Parent entity'si için bir sorgu çalıştırılır ve ardından her bir Child için ayrı ayrı sorgular çalıştırılır. Bu, toplamda 1 (parent için) + N (N child için) sorgu anlamına gelir ve özellikle N'nin büyük olduğu durumlarda ciddi bir performans düşüklüğüne yol açabilir.


Çözüm Yöntemleri:


Fetch Join Kullanımı: HQL veya JPQL sorgularında JOIN FETCH komutunu kullanarak ilişkili nesnelerin tek bir sorguda yüklenmesini sağlayabilirsiniz. Bu yöntem, ilişkili nesnelerin baştan yüklenmesi gerektiğinde etkili bir çözümdür.


Batch Fetching: Hibernate ayarlarında veya @BatchSize annotasyonu ile belirli bir sayıda ilişkili nesnenin gruplar halinde yüklenmesini sağlayabilirsiniz. Bu, veritabanına yapılan toplam sorgu sayısını azaltır.


Eager Loading: İlişkileri @OneToMany veya @ManyToOne annotasyonlarında fetch = FetchType.EAGER olarak ayarlayarak, ilişkili nesnelerin ana nesneyle birlikte otomatik olarak yüklenmesini sağlayabilirsiniz. Ancak, bu yöntem dikkatli kullanılmalıdır, çünkü gereksiz yere fazla veri yüklemeye ve diğer performans sorunlarına yol açabilir.


Second Level Cache Kullanımı: Hibernate'in Second Level Cache özelliğini etkinleştirerek sık erişilen verilerin önbellekte tutulmasını sağlayabilir ve böylece veritabanı sorgu sayısını azaltabilirsiniz.


N+1 sorgu problemi, veri tabanı sorgu performansını doğrudan etkileyen önemli bir konudur ve bu sorunu çözmek için uygun stratejinin seçilmesi, uygulamanın genel performansı üzerinde büyük bir fark yaratabilir. Sorunun çözümünde kullanılacak yöntem, uygulamanın ihtiyaçlarına ve veri erişim desenlerine göre belirlenmelidir.

N+1 sorununu çözmek için uygulanan stratejilerin yanı sıra, performansı etkileyebilecek diğer faktörler ve çözüm yöntemleri de dikkate alınmalıdır. İşte Hibernate'de performansı iyileştirmeye yönelik ek öneriler:


1. Sorgu Performansını İzleme ve Optimize Etme

SQL Sorgularının İzlenmesi: Hibernate tarafından üretilen SQL sorgularını izleyerek, gereksiz veya verimsiz sorguları tespit edebilirsiniz. Bu, genellikle log ayarlarını değiştirerek yapılabilir.

Sorgu Planlarını Analiz Etme: Veritabanının sorgu planlarını inceleyerek, index kullanımı ve join operasyonlarının optimizasyonu gibi iyileştirmeler yapabilirsiniz.

2. StatelessSession Kullanımı

StatelessSession: StatelessSession, Hibernate'in bir Session nesnesinin sağladığı tüm hizmetlerden bazılarını, özellikle birinci seviye önbelleği ve otomatik kirli veri algılama gibi özellikleri dışlayarak hafifletilmiş bir versiyonudur. Büyük miktarda veri okuma veya yazma işlemleri için StatelessSession kullanmak, hafıza kullanımını azaltabilir ve performansı artırabilir.

3. DDL Otomatik Oluşturma Kullanımını Sınırlama

Hibernate, uygulama başlatıldığında veritabanı şemasını otomatik olarak oluşturabilir veya güncelleyebilir. Ancak, bu özellik geliştirme aşamasında yararlı olmakla birlikte, üretim ortamında kullanımı önerilmez. Üretimde, şema değişikliklerinin kontrol altında ve manuel olarak yapılması daha güvenlidir.

4. İlişkisel Veri Modelinin Optimize Edilmesi

Veritabanı şemasının ve ilişkisel modelin optimizasyonu, sorgu performansı üzerinde doğrudan etkiye sahiptir. Gereksiz ilişkilerin kaldırılması, uygun indekslerin eklenmesi ve normalizasyon/denormalizasyon dengesinin gözetilmesi önemlidir.

5. İşlem Gruplaması ve Batch İşlemleri

Toplu işlemler (batch processing), ağ gecikmesini azaltmak ve veritabanı yükünü düşürmek için etkili bir yöntemdir. Hibernate, toplu ekleme, güncelleme veya silme işlemlerini gruplandırmak için batch boyutu ayarlarını destekler.

6. Connection Pooling

Veritabanı bağlantılarının yönetimi, uygulama performansı üzerinde büyük etkiye sahip olabilir. Bağlantı havuzu (connection pooling), bağlantıların yeniden kullanımını sağlayarak, bağlantı kurma ve kapatma maliyetlerini azaltır. Hibernate, c3p0 veya HikariCP gibi popüler bağlantı havuzu kütüphaneleriyle entegre olarak çalışabilir.

Hibernate kullanırken performansı optimize etmek, uygulamanın gereksinimlerine ve kullanım desenlerine bağlı olarak bir dizi stratejiyi içerir. Önerilen iyileştirmelerin uygulanması, sistemin ölçeklenebilirliğini ve kullanıcı deneyimini önemli ölçüde artırabilir. Her zaman uygulamanızı profilleyerek ve gözlemleyerek, hangi optimizasyon tekniklerinin sizin durumunuz için en etkili olduğunu belirleyin.

Hibernate ve Spring Boot kullanarak EhCache ile yapılan ikinci düzey önbellekleme örneği ve açıklaması.

Hibernate second level cache nedir?

Hibernate, bir Java nesne/ilişkisel eşleme (ORM) çerçevesidir ve uygulamaların veritabanı işlemlerini kolaylaştırmak için kullanılır. Hibernate'de "ikinci seviye önbellek" (second level cache), uygulamanın performansını artırmak için veri erişimini hızlandırmak adına kullanılır.


Bir Hibernate uygulamasında, birincil önbellek otomatik olarak uygulamalar tarafından kullanılır ve herhangi bir ek yapılandırmaya ihtiyaç duymaz. Bu, bir veriye ilk erişildiğinde veritabanından alınan ve bir oturum boyunca kullanılan veriyi ifade eder. Bununla birlikte, bu veri her oturum için ayrı ayrı alınır ve diğer oturumlarla paylaşılmaz.


Buna karşın, ikinci seviye önbellek birden fazla oturum arasında paylaşılır. Bu, daha önce yüklenmiş bir nesne aynı uygulama tarafından tekrar talep edildiğinde, Hibernate'in bu veriyi ikinci seviye önbellekten alabileceği ve bu sayede veritabanına tekrar erişim yapmasına gerek kalmayacağı anlamına gelir. Bu, genellikle uygulamanın performansını önemli ölçüde artırabilir.


Hibernate, ikinci seviye önbellek için birçok popüler önbellek sağlayıcıyı destekler, örneğin EhCache, Infinispan ve Hazlecast. İkinci seviye önbelleği kullanma kararı ve hangi önbellek sağlayıcısını kullanacağınız genellikle uygulamanızın gereksinimlerine ve ölçeklenebilirlik gerekliliklerine bağlıdır.

Hibernate'de ikinci seviye önbellek kullanmanın bazı avantajları vardır:


Performansı Artırır: Veritabanı işlemleri genellikle zaman alır ve bu da uygulamanın performansını etkileyebilir. İkinci seviye önbellek kullanmak, aynı veriye birden fazla kez erişim ihtiyacını azaltır, böylece veritabanı üzerindeki yükü azaltır ve genel performansı artırır.


Ağ Trafiğini Azaltır: Veritabanından veri almak, genellikle ağ üzerinden bir miktar veri transferi gerektirir. Bu, özellikle büyük veri setleriyle çalışırken önemli bir faktör olabilir. İkinci seviye önbellek, ağ trafiğini azaltarak ve gerekli veri transferlerini minimuma indirerek bu yükü azaltır.


Veritabanı Bağlantılarını Azaltır: Her veritabanı bağlantısı, bir miktar sistem kaynağı gerektirir. İkinci seviye önbellek, veritabanı ile yapılacak olan gereksiz bağlantıları önleyerek sistem kaynaklarının daha verimli bir şekilde kullanılmasını sağlar.


Bununla birlikte, ikinci seviye önbelleğin dikkatli bir şekilde yönetilmesi gerekir. Önbellekte tutulan verinin güncel olmaması durumunda, uygulama eski veya yanıltıcı bilgilere dayalı kararlar alabilir. Bu nedenle, önbelleğin düzenli olarak güncellenmesi ve verinin zamanında geçersiz kılınması önemlidir.


Ayrıca, farklı önbellek sağlayıcıları farklı özelliklere sahip olabilir ve her uygulama için en iyi önbellek sağlayıcısını seçmek önemlidir. Önbellek sağlayıcısının seçimi, veritabanı erişiminin gerekliliklerine, uygulamanın ölçeğine ve önbelleğin yönetilme şekline bağlı olabilir.


Hibernate'deki ikinci seviye önbellek (second level cache), oturum fabrikası düzeyinde bulunur. Bu, farklı oturumlar (Session) arasında paylaşılan verinin saklandığı yerdir.


Her Hibernate oturumu (Session), birinci seviye önbellek (first level cache) olarak da bilinen kendi önbelleğine sahiptir. Bir oturum boyunca alınan tüm nesneler bu önbellekte saklanır. Ancak, bu önbellek sadece o oturum için geçerlidir ve oturum sona erdiğinde önbellek de boşaltılır.


Buna karşılık, ikinci seviye önbellek bir oturum fabrikası (SessionFactory) düzeyinde bulunur. Bu, tüm oturumlar arasında paylaşılan ve oturumlar sona erdikten sonra bile veriyi tutabilen bir önbellektir. İkinci seviye önbellek, aynı veriye birden fazla oturumdan erişim gerektiğinde verimlilik sağlar.


Sonuç olarak, ikinci seviye önbellek birden çok oturum arasında paylaşılan veriyi tutar ve bu veriyi tüm oturumlar arasında kullanılabilir hale getirir. Bu, özellikle verinin sık sık kullanıldığı durumlarda performansı önemli ölçüde artırabilir.

Hibernate ve Spring Boot ile ikinci seviye önbellekleme yapmak için bir Cache Provizyonu (Cache Provider) kullanılmalıdır. EhCache, Hazelcast, Infinispan gibi çeşitli cache provizyonları vardır. Bu örnekte, popüler bir cache provizyonu olan EhCache kullanılacak.





Öncelikle projenize EhCache ve Hibernate'in EhCache'i desteklemesi için gereken bağımlılıkları ekleyin:


xml

Copy code

<dependencies>

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-data-jpa</artifactId>

    </dependency>

    <dependency>

        <groupId>net.sf.ehcache</groupId>

        <artifactId>ehcache</artifactId>

    </dependency>

    <dependency>

        <groupId>org.hibernate</groupId>

        <artifactId>hibernate-ehcache</artifactId>

    </dependency>

</dependencies>

Daha sonra application.properties dosyanızda aşağıdaki Hibernate ikinci seviye önbellekleme ayarlarını yapın:


properties

Copy code

spring.jpa.properties.hibernate.cache.use_second_level_cache=true

spring.jpa.properties.hibernate.cache.use_query_cache=true

spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory

Bunlar sırasıyla:


İkinci seviye önbelleklemeyi aktif eder

Sorgu önbellekleme özelliğini aktif eder

Cache bölgesi için fabrika sınıfını ayarlar

Entity sınıflarınızda önbelleklemeyi aktifleştirmek için @Cacheable ve @Cache annotation'ları kullanın:


java

Copy code

import javax.persistence.Entity;

import javax.persistence.Id;

import org.hibernate.annotations.Cache;

import org.hibernate.annotations.CacheConcurrencyStrategy;


@Entity

@Cacheable

@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)

public class Book {


    @Id

    private Long id;


    // other fields, getters and setters...

}

Bu örnekte @Cacheable annotation'ı entity sınıfının önbelleklenebilir olduğunu belirtir ve @Cache annotation'ı önbelleklemenin nasıl yapılacağını belirler. Yukarıdaki durumda, READ_WRITE stratejisi, verinin okuma ve yazma işlemlerinde önbelleklenmesini sağlar.


Son olarak, EhCache yapılandırmasını ehcache.xml dosyası ile yapmanız gerekiyor:


xml

Copy code

<ehcache>


    <defaultCache 

        maxElementsInMemory="100" 

        eternal="false"

        timeToIdleSeconds="120" 

        timeToLiveSeconds="200" >

    </defaultCache>


    <cache 

        name="com.example.Book" 

        maxElementsInMemory="100" 

        eternal="false" 

        timeToIdleSeconds="120" 

        timeToLiveSeconds="200" >

    </cache>


</ehcache>

Bu XML dosyasında, genel ve özelleştirilmiş önbellek politikalarını tanımlarsınız. Bu örnekte, com.example.Book entity'si için özel bir önbellek politikası tanımlanmıştır. Bu dosyayı classpath içinde (genellikle src/main/resources klasörü) oluşturmanız gerekiyor.


Sonuç olarak, bu yaklaşım ile Hibernate ve Spring Boot kullanarak ikinci seviye önbellekleme yapabilirsiniz.


Bahsettiğim bu adımlar genellikle Spring Boot ve Hibernate ile ikinci seviye önbelleklemeyi gerçekleştirmek için gerekli olan adımlardır. Ancak, uygulamanızın ihtiyaçlarına bağlı olarak bazı ek adımlar gerekebilir.


Örneğin, önbellek ayarlarını dinamik olarak değiştirmeniz gerekiyorsa, EhCache Manager'ı kullanabilirsiniz.


java

Copy code

import net.sf.ehcache.CacheManager;

import org.springframework.cache.ehcache.EhCacheCacheManager;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;


@Configuration

public class CacheConfig {


    @Bean

    public EhCacheCacheManager cacheManager() {

        return new EhCacheCacheManager(CacheManager.create());

    }

}

Eğer daha fazla kontrol veya önbellek ile ilgili daha fazla bilgiye ihtiyacınız varsa, Spring'in CacheManager ve Cache arayüzlerini kullanabilirsiniz. CacheManager önbellekleri almak ve yönetmek için kullanılırken, Cache belirli bir önbellek üzerinde işlem yapmak için kullanılır.


java

Copy code

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.cache.Cache;

import org.springframework.cache.CacheManager;

import org.springframework.stereotype.Component;


@Component

public class CacheService {


    private final CacheManager cacheManager;


    @Autowired

    public CacheService(CacheManager cacheManager) {

        this.cacheManager = cacheManager;

    }


    public void evictSingleCacheValue(String cacheName, String cacheKey) {

        Cache cache = cacheManager.getCache(cacheName);

        if (cache != null) {

            cache.evict(cacheKey);

        }

    }


    public void evictAllCacheValues(String cacheName) {

        Cache cache = cacheManager.getCache(cacheName);

        if (cache != null) {

            cache.clear();

        }

    }

}

Bu örnekte CacheService, bir önbellekteki belirli bir değeri kaldırmak veya bir önbellekteki tüm değerleri kaldırmak için kullanılabilir.


Ayrıca, önbellekleme hatalarını işlemek için Spring'in @CacheEvict annotation'ını kullanabilirsiniz. Bu annotation, bir metot çağrısı sonrasında belirli bir önbellekteki değerleri kaldırmak için kullanılır. Örneğin, bir kitap güncellendikten sonra, bu kitapla ilgili önbellekteki tüm değerlerin kaldırılması gerekebilir.


java

Copy code

import org.springframework.cache.annotation.CacheEvict;

import org.springframework.stereotype.Service;


@Service

public class BookService {


    @Autowired

    private BookRepository bookRepository;


    @CacheEvict(cacheNames = "books", allEntries = true)

    public void updateBook(Book book) {

        bookRepository.save(book);

    }

}

Bu örnekte @CacheEvict annotation'ı updateBook metodu çağrıldıktan sonra "books" önbellekteki tüm değerlerin kaldırılmasını sağlar. Bu sayede, önbellekte tutulan güncellenmiş kitap bilgilerinin güncel olduğundan emin olabiliriz.


Elbette, belirli senaryolarda, belirli bir önbellekteki değerleri otomatik olarak güncellemek isteyebilirsiniz. Bu durumda @CachePut annotation'ını kullanabilirsiniz. Bu annotation, bir metot çağrıldıktan sonra belirli bir önbellekteki bir değeri otomatik olarak günceller.


java

Copy code

import org.springframework.cache.annotation.CachePut;

import org.springframework.stereotype.Service;


@Service

public class BookService {


    @Autowired

    private BookRepository bookRepository;


    @CachePut(cacheNames = "books", key = "#book.id")

    public Book updateBook(Book book) {

        return bookRepository.save(book);

    }

}

Bu örnekte @CachePut annotation'ı updateBook metodu çağrıldıktan sonra "books" önbellekteki belirli bir değerin (bu durumda güncellenen kitabın ID'si) otomatik olarak güncellenmesini sağlar.


Bir diğer konu da önbelleğin boyutudur. Önbelleğin boyutunu kontrol altında tutmak önemlidir çünkü aşırı büyük bir önbellek hem belleği hem de performansı olumsiz etkileyebilir. EhCache yapılandırma dosyası (ehcache.xml), önbelleğin maksimum boyutunu kontrol etmek için kullanılabilir.


xml

Copy code

<ehcache>


    <defaultCache 

        maxElementsInMemory="100" 

        eternal="false"

        timeToIdleSeconds="120" 

        timeToLiveSeconds="200" >

    </defaultCache>


    <cache 

        name="com.example.Book" 

        maxElementsInMemory="500" 

        eternal="false" 

        timeToIdleSeconds="120" 

        timeToLiveSeconds="200" >

    </cache>


</ehcache>

Bu örnekte, "com.example.Book" önbelleğinin boyutu maksimum 500 element olarak belirlenmiştir.


Son olarak, önbellek durumunu izlemek için JMX (Java Management Extensions) kullanılabilir. JMX, Java uygulamalarını izlemek ve yönetmek için bir standarttır ve EhCache bu standartı destekler. JMX'i kullanarak önbellekte ne kadar alanın kullanıldığını, kaç önbellek girişinin olduğunu ve daha fazlasını görebilirsiniz.


xml

Copy code

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd" updateCheck="true" monitoring="autodetect" dynamicConfig="true">


    <cacheManagerPeerProviderFactory class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory" properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1, multicastGroupPort=4446, timeToLive=32"/>


    <cacheManagerPeerListenerFactory class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory" properties="port=40001, remoteObjectPort=40002"/>


    <defaultCache maxElementsInMemory="100" eternal="false" timeToIdleSeconds="120" timeToLiveSeconds="200"/>


    <cache name="com.example.Book" maxElementsInMemory="500" eternal="false" timeToIdleSeconds="120" timeToLiveSeconds="200">

        <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" properties="replicatePuts=true, replicateUpdates=true, replicateUpdatesViaCopy=true, replicateRemovals=true"/>

    </cache>


</ehcache>

Bu örnekte, EhCache'nin JMX'i desteklemek için yapılandırıldığını ve ayrıca RMICacheManagerPeerListenerFactory ve RMICacheReplicatorFactory'nin kullandığı portların belirtildiğini görüyoruz.


Önbellekleme karmaşık bir konudur ve bu kılavuz genel bir bakış sunmaktadır. Önbelleklemenin yararlarına ulaşmak için uygulamanızın ihtiyaçlarını ve senaryolarını dikkatlice değerlendirmeniz gerekmektedir.

Spring Framework ve Hibernate'de sık kullanılan anatasyonlar, açıklmaları ve örnek kullanım senaryoları


Spring Framework, Java tabanlı bir uygulama çerçevesi olup, pek çok farklı anatasyonu içerir. Bu anatasyonlar, genellikle Spring çerçevesinde uygulamanın davranışını ve işlevlerini düzenlemek için kullanılır. İşte bazı örnekler:


@Component: Sınıfları Spring bean'leri olarak işaretlemek için kullanılır. Spring çerçevesi, bu anatasyonu bulduğunda, belirtilen sınıfın bir örneğini oluşturur ve bunu Spring uygulama bağlamında bir bean olarak kaydeder.

@Component

public class ExampleClass { }

@Autowired: Bağımlılık enjeksiyonu için kullanılır. Bu anatasyon sayesinde, bir Spring bean'i başka bir Spring bean'ine enjekte edebiliriz. Spring, @Autowired anatasyonu bulduğunda, ilgili türde bir bean'i arar ve enjekte eder.


public class ExampleClass {

    @Autowired

    private AnotherExampleClass anotherExampleClass;

}

@Service: İş katmanının bir parçası olan hizmet sınıflarını tanımlamak için kullanılır. @Service anatasyonu, genellikle işlevsel süreçleri uygulayan sınıflar üzerinde kullanılır ve @Component anatasyonuna benzer şekilde, Spring çerçevesi tarafından yönetilir.


@Service

public class ExampleService { }

@Repository: Veritabanı işlemlerini gerçekleştiren DAO (Data Access Object) sınıflarını tanımlamak için kullanılır. Bu anatasyon, Spring veritabanı işlemleri sırasında oluşan hataları Spring DataAccessException türüne çevirir.


@Repository

public class ExampleRepository { }

@Controller: Spring MVC'de, bir HTTP isteğinin nasıl işleneceğini belirlemek için kullanılır. @Controller anatasyonu ile işaretlenmiş bir sınıf, genellikle bir web isteğine yanıt verir.


@Controller

public class ExampleController { }

@RequestMapping: İsteklerin hangi metot tarafından işleneceğini belirtmek için kullanılır. Hem sınıf seviyesinde hem de metot seviyesinde kullanılabilir.


@Controller

@RequestMapping("/home")

public class ExampleController {

    @RequestMapping("/hello")

    public String hello() {

        return "Hello, World!";

    }

}

@PathVariable: Bir HTTP isteği sırasında bir URL parçasını dinamik olarak çekmek için kullanılır.


@RequestMapping("/users/{userId}")

public String getUser(@PathVariable("userId") int userId) { 

    // code here

}

@ResponseBody: Metodun döndürdüğü değerin, yanıt gövdesi olarak kullanılacağını belirtir.


@RequestMapping("/hello")

@ResponseBody

public String hello() {

return "Hello, World!";

}

9. **@Qualifier**: Spring konteyneri içerisinde birden fazla bean aynı türde olduğunda, hangi bean'in `@Autowired` anatasyonu ile enjekte edileceğini belirtmek için kullanılır.


@Autowired

@Qualifier("specificBeanName")

private ExampleClass exampleClass;

@Value: Statik veya dinamik olarak tanımlanmış bir değeri bir alan ya da parametreye enjekte etmek için kullanılır.


@Value("${property.name}")

private String propertyName;

@RestController: @Controller ve @ResponseBody anatasyonlarının birleşimidir. Bir HTTP isteğine yanıt veren ve yanıt gövdesini doğrudan oluşturan bir sınıfı tanımlar.


@RestController

public class ExampleController {

    @RequestMapping("/hello")

    public String hello() {

        return "Hello, World!";

    }

}

@Transactional: Spring tarafından sağlanan bildirimsel işlem yönetimini etkinleştirmek için kullanılır. Bu anatasyon, genellikle bir işlem sınırını tanımlamak için hizmet sınıflarının metotlarına uygulanır.


@Transactional

public void performTransaction() {

    // transactional operations

}

@Configuration: Bir sınıfı bir Spring Konfigürasyon Sınıfı olarak tanımlar. @Bean anatasyonunu kullanarak bean tanımlamalarının bulunabileceği yerleri belirtir.

@Configuration

public class AppConfig {

    @Bean

    public ExampleBean exampleBean() {

        return new ExampleBean();

    }

}

@Bean: Metotları bir Spring Bean'i oluşturmak için kullanılır. Bu metotlar, @Configuration anatasyonu ile işaretlenmiş bir sınıf içinde bulunmalıdır.

@Configuration

public class AppConfig {

    @Bean

    public ExampleBean exampleBean() {

        return new ExampleBean();

    }

}

@Scope: Bir Spring Bean'in kapsamını belirler. Örneğin, "singleton" (varsayılan), "prototype", "request", "session" ve "globalSession" gibi.

@Bean

@Scope("prototype")

public ExampleBean exampleBean() {

    return new ExampleBean();

}

@RequestParam: HTTP isteğinden bir parametreyi çıkarmak için kullanılır.

@RequestMapping("/user")

public String getUser(@RequestParam("id") int id) {

    // code here

}

@RequestBody: HTTP isteğinin gövdesini bir nesneye bağlamak için kullanılır.

@PostMapping("/user")

public String createUser(@RequestBody User user) {

    // code here

}

@GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping: İlgili HTTP metodu için belirli bir isteği işlemek için kullanılır. Örneğin, @GetMapping bir GET isteği için, @PostMapping bir POST isteği için kullanılır ve benzeri.

@GetMapping("/user")

public String getUser() {

    // code here

}


@PostMapping("/user")

public String createUser() {

    // code here

}

@ComponentScan: Spring'e belirli bir paketi veya paketleri tarayarak Spring Bean'leri bulmasını söyler.

java

Copy code

@Configuration

@ComponentScan(basePackages = "com.example.package")

public class AppConfig { }

@EnableAutoConfiguration: Spring Boot'ta, Spring'in bazı varsayılan davranışları otomatik olarak yapılandırmasını sağlar. Örneğin, classpath'teki belirli kitaplıklara dayalı olarak otomatik yapılandırma özelliklerini etkinleştirebilir.

@SpringBootApplication

public class Application {

    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);

    }

}

Not: @SpringBootApplication anatasyonu, @Configuration, @EnableAutoConfiguration ve @ComponentScan anatasyonlarını bir arada kullanır.


@Import: Bir veya daha fazla @Configuration sınıfını mevcut konfigürasyona dahil eder. Bu, mevcut Spring uygulamasına ek yapılandırmalar eklemek için kullanılır.

@Configuration

@Import(AnotherConfig.class)

public class AppConfig { }

@Profile: Bir bean'in veya yapılandırmanın belirli bir profil altında aktif olmasını sağlar. Bu, çeşitli çevreler (örneğin, development, testing, production) için farklı yapılandırmalar sağlamak amacıyla kullanılır.

@Configuration

@Profile("development")

public class DevConfig { }

@PropertySource: Bir özellik dosyasının yolunu belirtir. Spring, belirtilen dosyadaki özellikleri yükler ve bu özellikler uygulama bağlamında kullanılabilir hale gelir.

@Configuration

@PropertySource("classpath:application.properties")

public class AppConfig { }

@Lazy: Bir bean'in sadece ilk talepte oluşturulmasını sağlar. Bu, başlangıçta gerekmeyen ancak sonraki kullanımlar için gerekebilecek olan ağır başlangıç maliyetine sahip bean'ler için kullanışlıdır.

@Bean

@Lazy

public ExampleBean exampleBean() {

    return new ExampleBean();

}

Evet, Spring Framework'deki anatasyonlara daha fazla derinlemesine bakalım:


@ExceptionHandler: Bir yöntemi belirli bir istisnayı işlemek için kullanılır. Bu anatasyon genellikle bir @Controller veya @RestController sınıfında kullanılır ve belirli bir istisna türünün bir metotta işlenmesini sağlar.


@Controller

public class ExampleController {

    // ...


    @ExceptionHandler(Exception.class)

    public ModelAndView handleError(HttpServletRequest req, Exception ex) {

        // handle the exception

    }

}

@ResponseStatus: HTTP durum kodunu bir metoda veya istisna sınıfına bağlar. HTTP yanıt durumunu özelleştirmenin kolay bir yolunu sağlar.


@ResponseStatus(value=HttpStatus.NOT_FOUND, reason="No such Order")

public class OrderNotFoundException extends RuntimeException {

    // ...

}

@EnableAspectJAutoProxy: Spring AOP özelliklerini etkinleştirmek için kullanılır. Spring, AspectJ tarzı anatasyonları kullanarak yönlendirme özelliklerini destekler.

@Configuration

@EnableAspectJAutoProxy

public class AppConfig {

    // ...

}

@Before, @After, @Around, @AfterReturning, @AfterThrowing: Spring AOP'de bir Aspect'in özel bölümlerini işaretlemek için kullanılır.


@Aspect

public class LoggingAspect {

  

  @Before("execution(* com.example.*.*(..))")

  public void logBeforeAllMethods() { ... }

  

  @After("execution(* com.example.service.*.*(..))")

  public void logAfterServiceMethods() { ... }

  

  // ...

}

@EnableTransactionManagement: Spring'deki bildirimsel işlem yönetimini etkinleştirir. Spring, platform işlem yönetimini ve işlem demarcation'ını işlem API'sini kullanarak geniş bir şekilde destekler.


@Configuration

@EnableTransactionManagement

public class AppConfig {

    // ...

}

@EnableScheduling: Spring'deki zamanlanmış görevlerin etkinleştirilmesini sağlar. Spring, cron tarzı görevler, tekrarlanan görevler ve belirli bir gecikme ile başlatılan görevler gibi farklı türdeki görevleri destekler.


@Configuration

@EnableScheduling

public class AppConfig {

    // ...

}

@Scheduled: Bir metodu belirli bir zaman aralığında çalıştırılacak şekilde işaretler.

@Component

public class ScheduledTasks {

    @Scheduled(fixedRate = 5000)

    public void doSomething() {

        // this will be executed every 5 seconds

    }

}

@Order: Bean'lerin veya anatasyonlarla işaretlenmiş yöntemlerin uygulanma sırasını kontrol eder.

@Component

@Order(1)

public class FirstBean { 

    //...

}

@PreAuthorize, @PostAuthorize, @Secured: Spring Security kütüphanesinde kullanılan anatasyonlardır. Belirli bir işlemi gerçekleştirecek kullanıcının yetkilendirme durumunu kontrol etmek için kullanılırlar.

@PreAuthorize("hasRole('ADMIN')")

public void adminTask() { /* code here */ }

@EnableWebMvc: Spring MVC'yi etkinleştirir. Bu anatasyon genellikle bir konfigürasyon sınıfı ile birlikte kullanılır.

@Configuration

@EnableWebMvc

public class WebConfig { /* code here */ }

@SessionAttributes: Model içerisine eklenen belirli özelliklerin oturumda tutulmasını sağlar. Genellikle bir controller sınıfında kullanılır.

@Controller

@SessionAttributes("attributeName")

public class ExampleController { /* code here */ }

@Async: Bir metodun asenkron bir işlem olarak çalıştırılmasını sağlar. Spring, @Async anatasyonu ile işaretlenmiş bir metodun ayrı bir iş parçacığından çalıştırılmasını sağlar.

@Async

public void asyncMethod() { /* code here */ }

@EnableAsync: Spring'deki asenkron işlemleri etkinleştirir. Genellikle bir konfigürasyon sınıfı ile birlikte kullanılır.

@Configuration

@EnableAsync

public class AppConfig { /* code here */ }

@JmsListener: Bir metodu bir JMS mesaj dinleyicisi olarak işaretler. Spring JMS, Java'nın Mesajlaşma Hizmetini Spring uygulamalarında kullanmayı kolaylaştırır.

@JmsListener(destination = "mailbox", containerFactory = "myFactory")

public void receiveMessage(Email email) { /* code here */ }

@EnableJms: Spring JMS konfigürasyonunu etkinleştirir. Genellikle bir konfigürasyon sınıfı ile birlikte kullanılır.

@Configuration

@EnableJms

public class AppConfig { /* code here */ }

@JsonView: Jackson kitaplığı tarafından kullanılan bir anatasyon. Bir model sınıfının hangi özelliklerinin JSON olarak serileştirileceğini belirtmek için kullanılır.

public class Example {

    @JsonView(Views.Public.class)

    public String publicAttribute;


    @JsonView(Views.Internal.class)

    public String internalAttribute;

}

@EnableCaching: Spring uygulamasında caching özelliklerini etkinleştirir.

java

Copy code

@Configuration

@EnableCaching

public class AppConfig { }

@Cacheable: Bir metodu caching için işaretler. Bu anatasyon ile işaretlenmiş bir metot çalıştırıldığında, sonuçları cache'e eklenir ve aynı girdilere sahip gelecek çağrılar için sonuç cache'den getirilir.

@Cacheable("books")

public Book findBook(ISBN isbn) {...}

@CacheEvict: Cache'den bir girdiyi silmek için kullanılır. Genellikle bir veriyi güncelledikten veya sildikten sonra cache'i güncellemek için kullanılır.

@CacheEvict(value = "books", key = "#isbn")

public void updateBook(ISBN isbn, BookDescriptor descriptor) {...}

@Primary: Birden fazla bean aynı türde olduğunda ve Spring hangisini enjekte etmesi gerektiğini belirleyemezse, @Primary anatasyonu kullanılabilir. @Primary anatasyonu ile işaretlenmiş olan bean tercih edilir.

@Bean

@Primary

public MyBean myBean() {...}

@ControllerAdvice: Global hata işlemcisi veya global @InitBinder gibi özellikleri bir controller'a eklemek için kullanılır. Bu anatasyon genellikle global exception handler'lar için kullanılır.

@ControllerAdvice

public class GlobalExceptionHandler {

    @ExceptionHandler(value = {Exception.class})

    public ResponseEntity<Object> handleAnyException(Exception e) {...}

}

@PathVariable: Bir URL'deki değişken bir değeri bir metot parametresine bağlar.

@GetMapping("/books/{isbn}")

public Book getBook(@PathVariable("isbn") String isbn) {...}

@EnableRetry: Spring uygulamasında yeniden deneme mekanizmasını etkinleştirir.

@Configuration

@EnableRetry

public class AppConfig { }

@Retryable: Bir metot çağrısının belirli bir istisna durumunda yeniden deneneceğini belirtir.

@Retryable(value = {ServiceUnavailableException.class}, maxAttempts = 3)

public void retryableService() {...}

@Recover: Belirli bir istisna durumunda bir yeniden deneme operasyonunun başarısız olmasının ardından geri almak için kullanılır.

@Recover

public void recover(ServiceUnavailableException e) {...}

@CrossOrigin: Bir controller veya handler metotları üzerinde CORS (Cross-Origin Resource Sharing) davranışını yapılandırmak için kullanılır.

@CrossOrigin(origins = "http://example.com")

@GetMapping("/hello")

public String hello() {...}

@RequestBody: HTTP isteğinin body'sinde bulunan değerlerin bir nesneye otomatik olarak bağlanmasını sağlar.

@PostMapping("/books")

public void addBook(@RequestBody Book book) {...}

@ResponseBody: Bir metodun dönüş değerinin HTTP yanıtının body'si olacağını belirtir.

@GetMapping("/books/{id}")

@ResponseBody

public Book getBook(@PathVariable Long id) {...}

@ResponseEntity: HTTP yanıtını tamamen kontrol etmek için kullanılır. HTTP durum kodu, header'lar ve body'yi özelleştirebiliriz.

@GetMapping("/books/{id}")

public ResponseEntity<Book> getBook(@PathVariable Long id) {

    ...

    return new ResponseEntity<>(book, HttpStatus.OK);

}

@RequestMapping: Bir metodun bir HTTP isteğiyle nasıl eşleştirileceğini belirtir. HTTP metodu, yol, parametreler, header'lar ve medya türleri üzerinde eşleştirme yapabilir.

@RequestMapping(value = "/books/{id}", method = RequestMethod.GET, produces = "application/json")

public Book getBook(@PathVariable Long id) {...}

@GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping: @RequestMapping anatasyonunun daha özelleştirilmiş sürümleridir. Sırasıyla GET, POST, PUT, DELETE ve PATCH HTTP metotlarıyla eşleştirirler.

@GetMapping("/books/{id}")

public Book getBook(@PathVariable Long id) {...}

@RequestParam: HTTP isteğindeki bir query parametresini bir metot parametresine bağlar.

@GetMapping("/books")

public List<Book> getBooks(@RequestParam(name = "author", required = false) String author) {...}

@RequestHeader: HTTP isteğindeki bir header'ı bir metot parametresine bağlar.

@GetMapping("/books/{id}")

public Book getBook(@RequestHeader("Authorization") String token, @PathVariable Long id) {...}

@CookieValue: Bir HTTP cookie değerini bir metot parametresine bağlar.

@GetMapping("/books/{id}")

public Book getBook(@CookieValue("sessionId") String sessionId, @PathVariable Long id) {...}

@SessionAttribute: Oturumda saklanan bir özelliği bir metot parametresine bağlar.

@GetMapping("/books/{id}")

public Book getBook(@SessionAttribute("user") User user, @PathVariable Long id) {...}

@ModelAttribute: Modelden bir özelliği bir metot parametresine bağlar, ya da bir model özelliğini bir nesne ile doldurur.

@GetMapping("/books/{id}")

public String getBook(@ModelAttribute("user") User user, @PathVariable Long id, Model model) {

    Book book = findBook(id);

    model.addAttribute("book", book);

    return "book";

}

@Profile: Belirli bir Spring profili altında bir bean'in ya da configuration'ın aktif olmasını belirtir.

@Configuration

@Profile("development")

public class DevConfig { }

@Import: Bir başka configuration sınıfını içeri almak için kullanılır. Bu, genellikle bir configuration'ın bir başkasını genişletmesi gerektiğinde kullanılır.

@Configuration

@Import(AnotherConfig.class)

public class AppConfig { }

@ImportResource: XML konfigürasyon dosyalarını içeri almak için kullanılır. Bu, genellikle mevcut XML tabanlı bir konfigürasyonu yeni Java tabanlı bir konfigürasyonla birleştirmeniz gerektiğinde kullanılır.

@Configuration

@ImportResource("classpath:/com/myco/app-config.xml")

public class AppConfig { }

@Value: Bir property'nin değerini bir field veya metod parametresine enjekte etmek için kullanılır.

@Component

public class MyComponent {

    @Value("${property.name}")

    private String propertyName;

}

@Lazy: Bir bean'in lazy initialization'ı için kullanılır. Bu, Spring context'in başlangıcında bean'in oluşturulmasını engeller ve bean ilk kez talep edildiğinde oluşturulur.

@Component

@Lazy

public class LazyBean { }

@Controller, @RestController, @Service, @Repository, @Component: Bu anatasyonlar Spring'in bileşen tarama özelliklerini kullanarak bean'leri otomatik olarak tanımlamak için kullanılır.

@Controller

public class MyController { }


@Service

public class MyService { }


@Repository

public class MyRepository { }


@Component

public class MyComponent { }

@EnableGlobalMethodSecurity: Metod seviyesinde güvenlik anatasyonlarını etkinleştirir. Bu, genellikle @PreAuthorize veya @PostAuthorize gibi anatasyonları etkinleştirmek için kullanılır.

@Configuration

@EnableGlobalMethodSecurity(prePostEnabled = true)

public class SecurityConfig extends WebSecurityConfigurerAdapter { }

@SpringBootApplication: Spring Boot uygulamasının başlangıç noktasını işaretler. Bu anatasyon genellikle ana sınıfın üzerinde bulunur ve @Configuration, @EnableAutoConfiguration ve @ComponentScan anatasyonlarını içerir.

@SpringBootApplication

public class Application {

    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);

    }

}

@ExceptionHandler: Bir controller içinde bir exception'ı işlemek için kullanılır. Controller'da herhangi bir metot tarafından atılan exception'ı yakalar ve işler.

@Controller

public class MyController {

    @ExceptionHandler(Exception.class)

    public String handleException(Exception e) {

        return "error";

    }

}

@EnableTransactionManagement: Spring'in açıklamaya dayalı işlem yönetimini etkinleştirir. Genellikle bir konfigürasyon sınıfında kullanılır.

@Configuration

@EnableTransactionManagement

public class AppConfig { }

@Transactional: Bir metot çağrısının bir veritabanı işlemi içinde gerçekleşmesi gerektiğini belirtir.

@Service

public class MyService {

    @Transactional

    public void doSomeDataOperation() { }

}

@EnableScheduling: Spring'in scheduled task işlemlerini etkinleştirir. Genellikle bir konfigürasyon sınıfında kullanılır.

@Configuration

@EnableScheduling

public class AppConfig { }

@Scheduled: Bir metodu belirli bir zaman aralığında ya da belirli bir saatte çalıştırılacak bir görev olarak işaretler.

@Component

public class MyTask {

    @Scheduled(fixedRate = 1000)

    public void doSomething() { }

}

@EnableAspectJAutoProxy: Spring uygulamasında AspectJ otomatik proxy oluşturmayı etkinleştirir.

@Configuration

@EnableAspectJAutoProxy

public class AppConfig { }

@Aspect, @Pointcut, @Before, @After, @Around, @AfterReturning, @AfterThrowing: Spring AOP (Aspect-Oriented Programming) kütüphanesinde kullanılan anatasyonlardır. AOP, çapraz kesitli endişeleri (logging, caching, transaction management vb.) yönetmek için kullanılır.

@Aspect

public class LoggingAspect {

    @Pointcut("execution(* com.myapp.service.*.*(..))")

    public void serviceMethods() { }


    @Before("serviceMethods()")

    public void logBefore(JoinPoint joinPoint) { }

}

@WebMvcTest: Spring Boot uygulamasında bir controller'ın slice testini gerçekleştirmek için kullanılır.

@WebMvcTest(MyController.class)

public class MyControllerTest { }

@DataJpaTest: Spring Boot uygulamasında bir repository'nin slice testini gerçekleştirmek için kullanılır.

@DataJpaTest

public class MyRepositoryTest { }

@RestClientTest: Spring Boot uygulamasında bir REST istemcisini test etmek için kullanılır.

@RestClientTest(MyRestClient.class)

public class MyRestClientTest { }

@MockBean: Spring Boot testlerinde bir bean'i mock etmek için kullanılır.

@SpringBootTest

public class MyServiceTest {

    @MockBean

    private MyDependency mockDependency;

}

@EnableJpaRepositories: Spring Data JPA repository tanımlarını konfigüre etmek ve etkinleştirmek için kullanılır.

@Configuration

@EnableJpaRepositories(basePackages = "com.example.myapp.repository")

public class AppConfig {}

@EntityScan: Spring Data JPA entity sınıflarını taramak için kullanılır.

@Configuration

@EntityScan(basePackages = "com.example.myapp.model")

public class AppConfig {}

@Table: Bir entity sınıfının hangi veritabanı tablosu ile ilişkili olduğunu belirtir.

@Entity

@Table(name = "books")

public class Book {...}

@Column: Bir entity sınıfındaki bir field'ın hangi veritabanı sütunu ile ilişkili olduğunu belirtir.

@Entity

public class Book {

    @Column(name = "title")

    private String title;

}

@Id: Bir entity sınıfındaki bir field'ın primary key olduğunu belirtir.

@Entity

public class Book {

    @Id

    private Long id;

}

@GeneratedValue: Bir entity sınıfındaki bir field'ın nasıl otomatik olarak oluşturulacağını belirtir.

@Entity

public class Book {

    @Id

    @GeneratedValue(strategy = GenerationType.AUTO)

    private Long id;

}

@EnableJpaAuditing: JPA auditing özelliklerini etkinleştirmek için kullanılır.

@Configuration

@EnableJpaAuditing

public class AppConfig {}

@CreatedDate, @CreatedBy, @LastModifiedDate, @LastModifiedBy: Bu anatasyonlar, entity sınıflarındaki field'larda audit bilgilerinin otomatik olarak doldurulmasını sağlar.

@Entity

@EntityListeners(AuditingEntityListener.class)

public class Book {

    @CreatedDate

    private LocalDateTime createdDate;


    @CreatedBy

    private String createdBy;


    @LastModifiedDate

    private LocalDateTime lastModifiedDate;


    @LastModifiedBy

    private String lastModifiedBy;

}

@Version: Bir entity sınıfındaki bir field'ın, entity'nin her güncellenmesiyle otomatik olarak artırılacağını belirtir. Bu, genellikle optimistic locking stratejilerinde kullanılır.

@Entity

public class Book {

    @Version

    private Long version;

}

@Query: Bir repository metodu için custom bir sorgu tanımlar.

public interface BookRepository extends JpaRepository<Book, Long> {

    @Query("SELECT b FROM Book b WHERE b.title = :title")

    List<Book> findByTitle(@Param("title") String title);

}

Bu anatasyonlar, Spring ve Spring Data JPA uygulamalarını yapılandırma ve kontrol etmek için kullanılır ve her biri belirli bir amaca hizmet eder.

@PrePersist, @PreRemove, @PostPersist, @PostRemove, @PreUpdate, @PostUpdate, @PostLoad: Bu anatasyonlar, JPA entity lifecycle event'leri üzerinde callback metotlarını belirtmek için kullanılır.

@Entity

public class Book {

    @PrePersist

    public void prePersist() {...}


    @PostPersist

    public void postPersist() {...}

}

@JoinColumn: İki entity arasındaki ilişkiyi belirtirken kullanılır. Bir tablodaki foreign key sütununu belirtir.

@Entity

public class Book {

    @ManyToOne

    @JoinColumn(name = "author_id")

    private Author author;

}

@OneToMany, @ManyToOne, @OneToOne, @ManyToMany: Entity'ler arasındaki ilişkileri belirtir.

@Entity

public class Book {

    @ManyToOne

    private Author author;

}


@Entity

public class Author {

    @OneToMany(mappedBy = "author")

    private List<Book> books;

}

@OrderBy: Bir collection tipindeki bir field'ın sıralanmasını belirtir.

@Entity

public class Author {

    @OneToMany

    @OrderBy("title")

    private List<Book> books;

}

@Embedded, @Embeddable: Bir sınıfın bir başka sınıf içinde gömülü olarak kullanılacağını belirtir. @Embeddable anatasyonu gömülü sınıfa, @Embedded anatasyonu ise host sınıftaki field'a uygulanır.

@Embeddable

public class Address {...}


@Entity

public class Author {

    @Embedded

    private Address address;

}

@AttributeOverride, @AttributeOverrides: @Embedded anatasyonu ile gömülü bir sınıfın field'larının isimlerini override etmek için kullanılır.

@Entity

public class Author {

    @Embedded

    @AttributeOverride(name = "street", column = @Column(name = "home_street"))

    private Address homeAddress;

}

@Transactional(readOnly = true): İşlem boyunca veritabanı üzerinde herhangi bir değişiklik yapılmasını önler.

@Service

public class BookService {

    @Transactional(readOnly = true)

    public Book findBook(Long id) {...}

}

@EntityGraph: JPA entity'lerinin fetch türünü değiştirmek için kullanılır.

public interface BookRepository extends JpaRepository<Book, Long> {

    @EntityGraph(attributePaths = {"author"})

    List<Book> findAll();

}

@DynamicUpdate: Bir entity sınıfının update sorgularında sadece değişen field'ların dikkate alınacağını belirtir.

@Entity

@DynamicUpdate

public class Book {...}

@MappedSuperclass: Bir sınıfın başka bir entity sınıfı tarafından miras alındığında field'larının da o entity sınıfı tarafından miras alınacağını belirtir.


@MappedSuperclass

public class BaseEntity {

    @Id

    @GeneratedValue


@Entity


Bu annotasyon, bir sınıfın bir veritabanı tablosuna karşılık geldiğini belirtmek için kullanılır.

Kullanım Senaryosu: Bir varlık sınıfının (Entity) veritabanında bir tabloya dönüştürülmesi.

java

Copy code

import javax.persistence.Entity;

import javax.persistence.Id;


@Entity

public class Customer {

    @Id

    private Long id;

    private String name;

    // getters and setters

}

@Table


Bu annotasyon, varlık sınıfının veritabanındaki tablo adını belirtmek için kullanılır.

Kullanım Senaryosu: Varlık sınıfının tablo adını özelleştirmek.


import javax.persistence.Entity;

import javax.persistence.Table;

import javax.persistence.Id;


@Entity

@Table(name = "tbl_customers")

public class Customer {

    @Id

    private Long id;

    private String name;

    // getters and setters

}

@Id


Bu annotasyon, bir varlık sınıfının benzersiz bir tanımlayıcısının olduğunu belirtmek için kullanılır.

Kullanım Senaryosu: Varlık sınıfının birincil anahtarını belirtmek.


import javax.persistence.Entity;

import javax.persistence.Id;


@Entity

public class Customer {

    @Id

    private Long id;

    private String name;

    // getters and setters

}

@GeneratedValue


Bu annotasyon, bir varlık sınıfının benzersiz tanımlayıcısının nasıl otomatik olarak oluşturulacağını belirtmek için kullanılır.

Kullanım Senaryosu: Otomatik olarak artan (auto-increment) bir tanımlayıcıya sahip oluşturma işlemi.


import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;


@Entity

public class Customer {

    @Id

    @GeneratedValue(strategy = GenerationType.AUTO)

    private Long id;

    private String name;

    // getters and setters

}

@Column


Bu annotasyon, bir varlık sınıfındaki alanın veritabanındaki sütununun özelliklerini belirtmek için kullanılır.

Kullanım Senaryosu: Bir alanın veritabanı sütununu özelleştirmek.


import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Id;


@Entity

public class Customer {

    @Id

    private Long id;

    

    @Column(name = "full_name", nullable = false, length = 50)

    private String name;

    

    // getters and setters

}

@OneToMany


Bu annotasyon, ilişkili varlık arasında bir "birçok" ilişkisini belirtmek için kullanılır. Bir varlık, diğer varlıkla birçok ilişkiye sahip olabilir.

Kullanım Senaryosu: Bir varlığın diğer varlıkla birçok ilişkisi bulunması.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.OneToMany;

import java.util.List;


@Entity

public class Customer {

    @Id

    private Long id;

    private String name;

    

    @OneToMany(mappedBy = "customer")

    private List<Order> orders;

    

    // getters and setters

}

@ManyToOne


Bu annotasyon, ilişkili varlık arasında "çok bir" ilişkisini belirtmek için kullanılır. Bir varlık, diğer varlıkla tek bir ilişkiye sahip olabilir.

Kullanım Senaryosu: Bir varlığın diğer varlıkla tek bir ilişkisi bulunması.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.ManyToOne;


@Entity

public class Order {

    @Id

    private Long id;

    private String orderNumber;

    

    @ManyToOne

    private Customer customer;

    

    // getters and setters

}

@JoinColumn


Bu annotasyon, ilişkili sütunları birleştirmek için kullanılır. İki varlık arasındaki ilişkinin nasıl sağlandığını belirtir.

Kullanım Senaryosu: İki varlık arasındaki ilişkiyi tanımlamak ve birleştirmek.

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.ManyToOne;

import javax.persistence.JoinColumn;


@Entity

public class Order {

    @Id

    private Long id;

    private String orderNumber;

    

    @ManyToOne

    @JoinColumn(name = "customer_id")

    private Customer customer;

    

    // getters and setters

}

@Transient


Bu annotasyon, bir alanın veritabanına dönüştürülmemesini belirtmek için kullanılır. Bu alanlar, veritabanında saklanmaz.

Kullanım Senaryosu: Bir alanın veritabanına dönüştürülmemesi gerektiği durumlar.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Transient;


@Entity

public class Customer {

    @Id

    private Long id;

    private String name;

    

    @Transient

    private int age;

    

    // getters and setters

}


@Embedded

Bu annotasyon, bir varlık sınıfında başka bir gömülü varlık sınıfını temsil etmek için kullanılır.

Kullanım Senaryosu: Bir varlık sınıfında başka bir gömülü varlık kullanmak.


import javax.persistence.Embeddable;


@Embeddable

public class Address {

    private String street;

    private String city;

    private String country;

    

    // getters and setters

}


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Embedded;


@Entity

public class Customer {

    @Id

    private Long id;

    private String name;

    

    @Embedded

    private Address address;

    

    // getters and setters

}

@Enumerated

Bu annotasyon, bir alanın veritabanında nasıl temsil edileceğini belirtmek için kullanılır. Özellikle enum türlerinde kullanılır.

Kullanım Senaryosu: Bir enum alanının veritabanında nasıl temsil edileceğini belirtmek.

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Enumerated;


public enum Gender {

    MALE,

    FEMALE

}


@Entity

public class Customer {

    @Id

    private Long id;

    private String name;

    

    @Enumerated

    private Gender gender;

    

    // getters and setters

}

@Temporal

Bu annotasyon, bir tarih veya zaman alanının veritabanında nasıl temsil edileceğini belirtmek için kullanılır.

Kullanım Senaryosu: Bir tarih veya zaman alanının veritabanında nasıl temsil edileceğini belirtmek.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Temporal;

import javax.persistence.TemporalType;

import java.util.Date;


@Entity

public class Event {

    @Id

    private Long id;

    private String name;

    

    @Temporal(TemporalType.DATE)

    private Date eventDate;

    

    // getters and setters

}

@Lob

Bu annotasyon, bir alanın büyük nesne (LOB) verilerini temsil ettiğini belirtmek için kullanılır. Genellikle metin veya binary veriler için kullanılır.

Kullanım Senaryosu: Bir alanın büyük nesne (LOB) verilerini temsil etmek.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Lob;


@Entity

public class Document {

    @Id

    private Long id;

    private String name;

    

    @Lob

    private byte[] content;

    

    // getters and setters

}

@Version

Bu annotasyon, optimistic locking için bir alanı belirtmek için kullanılır. Bu alan, bir varlık nesnesinin değişikliklerinin yönetilmesinde sürüm kontrolü için kullanılır.

Kullanım Senaryosu: Optimistik kilit mekanizmasını kullanarak bir alanı sürüm kontrolü için belirtmek.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Version;


@Entity

public class Product {

    @Id

    private Long id;

    private String name;

    

    @Version

    private int version;

    

    // getters and setters

}

@JoinTable

Bu annotasyon, bir ilişkideki birleştirme tablosunu belirtmek için kullanılır. İlişkili varlıklar arasındaki ilişkiyi yönetmek için bir ara tablo oluşturulur.

Kullanım Senaryosu: İlişkili varlıklar arasındaki birleştirme tablosunu belirtmek.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.ManyToMany;

import javax.persistence.JoinTable;

import javax.persistence.JoinColumn;

import java.util.List;


@Entity

public class Student {

    @Id

    private Long id;

    private String name;

    

    @ManyToMany

    @JoinTable(

        name = "student_course",

        joinColumns = @JoinColumn(name = "student_id"),

        inverseJoinColumns = @JoinColumn(name = "course_id")

    )

    private List<Course> courses;

    

    // getters and setters

}

@Formula

Bu annotasyon, veritabanı sütunlarını oluşturmak veya değerlerini hesaplamak için özel bir SQL formülü kullanmak için kullanılır.

Kullanım Senaryosu: Bir SQL formülüyle veritabanı sütununu oluşturmak veya değerini hesaplamak.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Formula;


@Entity

public class Product {

    @Id

    private Long id;

    private String name;

    private double price;

    

    @Formula("price * 1.1")

    private double priceWithTax;

    

    // getters and setters

}

@Cascade

Bu annotasyon, bir ilişki üzerindeki otomatik kaydetme, güncelleme ve silme işlemlerinin nasıl yönetileceğini belirtmek için kullanılır.

Kullanım Senaryosu: Bir ilişkideki kaydetme, güncelleme ve silme işlemlerini yönetmek.

java

Copy code

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.CascadeType;

import javax.persistence.OneToMany;

import org.hibernate.annotations.Cascade;


@Entity

public class Customer {

    @Id

    private Long id;

    private String name;

    

    @OneToMany(mappedBy = "customer")

    @Cascade(CascadeType.ALL)

    private List<Order> orders;

    

    // getters and setters

}

@NamedQuery

Bu annotasyon, adlandırılmış bir sorgu tanımlamak için kullanılır. Bu, daha karmaşık sorguları yönetmek ve yeniden kullanmak için kullanışlıdır.

Kullanım Senaryosu: Adlandırılmış bir sorgu tanımlamak ve kullanmak.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.NamedQuery;

import javax.persistence.Column;

import javax.persistence.Table;


@Entity

@Table(name = "tbl_customers")

@NamedQuery(name = "Customer.findByName", query = "SELECT c FROM Customer c WHERE c.name = :name")

public class Customer {

    @Id

    @Column(name = "customer_id")

    private Long id;

    private String name;

    

    // getters and setters

}

@Cacheable

Bu annotasyon, bir varlığın önbelleğe alınması için kullanılır. Önbellekleme performansı artırabilir.

Kullanım Senaryosu: Bir varlığın önbelleğe alınması.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Cacheable;

import org.hibernate.annotations.Cache;

import org.hibernate.annotations.CacheConcurrencyStrategy;


@Entity

@Cacheable

@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)

public class Product {

    @Id

    private Long id;

    private String name;

    

    // getters and setters

}

@SQLInsert

Bu annotasyon, özel bir SQL INSERT ifadesini belirtmek için kullanılır. Veritabanına yeni bir varlık eklerken özelleştirilmiş bir INSERT ifadesi kullanılmasını sağlar.

Kullanım Senaryosu: Özelleştirilmiş bir SQL INSERT ifadesi kullanarak veritabanına yeni bir varlık eklemek.


import javax.persistence.Entity;

import javax.persistence.Id;

import org.hibernate.annotations.SQLInsert;


@Entity

@SQLInsert(sql = "INSERT INTO customers (customer_id, customer_name) VALUES (?, ?)")

public class Customer {

    @Id

    private Long id;

    private String name;

    

    // getters and setters

}

@Where

Bu annotasyon, bir sorgu üzerinde bir filtre koşulu belirtmek için kullanılır. Belirtilen filtre koşuluna uyan varlıklar, sorgu sonuçlarında yer alır.

Kullanım Senaryosu: Bir sorgu üzerinde bir filtre koşulu belirlemek.


import javax.persistence.Entity;

import javax.persistence.Id;

import org.hibernate.annotations.Where;


@Entity

@Where(clause = "active = true")

public class Product {

    @Id

    private Long id;

    private String name;

    private boolean active;

    

    // getters and setters

}

@DiscriminatorColumn

Bu annotasyon, kalıtım hiyerarşisinde diskriminatör sütununun tanımlanması için kullanılır. Diskriminatör sütunu, alt sınıflar arasındaki farklılıkları belirtir.

Kullanım Senaryosu: Kalıtım hiyerarşisinde diskriminatör sütununun belirtilmesi.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Inheritance;

import javax.persistence.InheritanceType;

import javax.persistence.DiscriminatorColumn;


@Entity

@Inheritance(strategy = InheritanceType.SINGLE_TABLE)

@DiscriminatorColumn(name = "product_type")

public abstract class Product {

    @Id

    private Long id;

    private String name;

    

    // getters and setters

}


@Entity

public class Book extends Product {

    private String author;

    

    // getters and setters

}


@SecondaryTable

Bu annotasyon, bir varlığın birden fazla tabloya sahip olduğunu belirtmek için kullanılır. İlgili alanlar, ek tabloda depolanır ve ilişkili verilerin doğru bir şekilde tutulmasını sağlar.

Kullanım Senaryosu: Bir varlığın birden fazla tabloya sahip olduğunu belirtmek.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Column;

import javax.persistence.SecondaryTable;


@Entity

@SecondaryTable(name = "customer_details", pkJoinColumns = @PrimaryKeyJoinColumn(name = "customer_id"))

public class Customer {

    @Id

    private Long id;

    private String name;

    

    @Column(table = "customer_details")

    private String email;

    

    // getters and setters

}

@NamedNativeQuery

Bu annotasyon, adlandırılmış bir Native SQL sorgusu tanımlamak için kullanılır. Native SQL sorguları, özelleştirilmiş veritabanı sorgularını doğrudan kullanmanızı sağlar.

Kullanım Senaryosu: Adlandırılmış bir Native SQL sorgusu tanımlamak ve kullanmak.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.NamedNativeQuery;

import javax.persistence.Column;

import javax.persistence.Table;


@Entity

@Table(name = "tbl_customers")

@NamedNativeQuery(name = "Customer.findByCity", query = "SELECT * FROM tbl_customers WHERE city = :city", resultClass = Customer.class)

public class Customer {

    @Id

    @Column(name = "customer_id")

    private Long id;

    private String name;

    private String city;

    

    // getters and setters

}

Bu, Hibernate 5'te kullanılan diğer annotasyonlara örnek verilmiştir. Bu annotasyonlar, veritabanı işlemlerini daha fazla özelleştirmek, performansı artırmak ve doğrudan SQL sorguları kullanmak için kullanılır.






User

devam


ChatGPT

Tabii, işte devamı:


@MapKey

Bu annotasyon, bir Map koleksiyonunun anahtarının hangi varlık alanına eşleneceğini belirtmek için kullanılır.

Kullanım Senaryosu: Bir Map koleksiyonunun anahtarını belirlemek.

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.OneToMany;

import javax.persistence.MapKey;

import java.util.Map;


@Entity

public class Order {

    @Id

    private Long id;

    private String customerName;

    

    @OneToMany(mappedBy = "order")

    @MapKey(name = "productCode")

    private Map<String, OrderItem> items;

    

    // getters and setters

}

@Index

Bu annotasyon, bir veritabanı indeksinin oluşturulmasını sağlar. İndeksler, veritabanı sorgularının performansını artırır.

Kullanım Senaryosu: Bir veritabanı indeksi oluşturmak.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Index;

import javax.persistence.Table;


@Entity

@Table(name = "tbl_products", indexes = {@Index(columnList = "category"), @Index(columnList = "price")})

public class Product {

    @Id

    private Long id;

    private String name;

    private String category;

    private double price;

    

    // getters and setters

}

@OnDelete

Bu annotasyon, bir ilişki üzerinde silme işlemi gerçekleştirildiğinde ne yapılacağını belirtmek için kullanılır. Örneğin, bir ana varlık silindiğinde ilişkili alt varlıkları da silmek için kullanılabilir.

Kullanım Senaryosu: İlişkili alt varlıkları silmek için bir silme işlemi gerçekleştirildiğinde.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.OneToMany;

import org.hibernate.annotations.OnDelete;

import org.hibernate.annotations.OnDeleteAction;

import java.util.List;


@Entity

public class Department {

    @Id

    private Long id;

    private String name;

    

    @OneToMany(mappedBy = "department")

    @OnDelete(action = OnDeleteAction.CASCADE)

    private List<Employee> employees;

    

    // getters and setters

}

@Any

Bu annotasyon, çeşitli varlık türleri arasında dinamik bir ilişki belirtmek için kullanılır. İlişkilendirilen varlığın türü çalışma zamanında belirlenir.

Kullanım Senaryosu: Dinamik ilişkileri yönetmek için kullanılır.

java

Copy code

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.ManyToOne;

import javax.persistence.Any;

import javax.persistence.JoinColumn;


@Entity

public class Review {

    @Id

    private Long id;

    private String content;

    

    @ManyToOne

    @JoinColumn(name = "item_id")

    @Any(metaColumn = @Column(name = "item_type"))

    private Item item;

    

    // getters and setters

}

@Lob

Bu annotasyon, bir alanın büyük nesne (LOB) verilerini temsil ettiğini belirtmek için kullanılır. Büyük veriler, metin, görüntü, ses vb. gibi veri tiplerini içerebilir.

Kullanım Senaryosu: Büyük nesne verilerini temsil etmek için kullanılır.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Lob;


@Entity

public class Document {

    @Id

    private Long id;

    private String name;

    

    @Lob

    private byte[] content;

    

    // getters and setters

}

@AttributeOverride

Bu annotasyon, bir varlık sınıfında tanımlanan bir alanın, kalıtım yoluyla alınan bir üst sınıfta belirtilen bir alanı geçersiz kılmasını sağlar.

Kullanım Senaryosu: Kalıtım hiyerarşisinde bir alanın üst sınıfta belirtilen alanı geçersiz kılması.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.AttributeOverride;

import javax.persistence.AttributeOverrides;


@Entity

@AttributeOverrides({

    @AttributeOverride(name = "firstName", column = @Column(name = "customer_first_name")),

    @AttributeOverride(name = "lastName", column = @Column(name = "customer_last_name"))

})

public class Customer extends Person {

    @Id

    private Long id;

    

    // getters and setters

}

@NaturalId

Bu annotasyon, bir varlık alanının doğal bir kimlik (natural id) olarak işaretlendiğini belirtmek için kullanılır. Doğal kimlik, benzersiz bir değere sahip bir alanı temsil eder.

Kullanım Senaryosu: Bir varlık alanını doğal kimlik olarak işaretlemek.


import javax.persistence.Entity;

import javax.persistence.Id;

import org.hibernate.annotations.NaturalId;


@Entity

public class User {

    @Id

    private Long id;

    

    @NaturalId

    private String username;

    

    // getters and setters

}

@Immutable

Bu annotasyon, bir varlığın değişmez (immutable) olduğunu belirtmek için kullanılır. Değişmez varlıklar, bir kez oluşturulduktan sonra durumlarının değiştirilemez olduğu anlamına gelir.

Kullanım Senaryosu: Bir varlığı değişmez olarak işaretlemek.


import javax.persistence.Entity;

import javax.persistence.Id;

import org.hibernate.annotations.Immutable;


@Entity

@Immutable

public class Product {

    @Id

    private Long id;

    private String name;

    private double price;

    

    // getters and setters

}

@BatchSize

Bu annotasyon, ilişkili bir koleksiyonun yüklenirken kaç varlık için bir sorgu yapılacağını belirtmek için kullanılır. Büyük koleksiyonların yüklenme performansını artırmak için kullanışlıdır.

Kullanım Senaryosu: İlişkili bir koleksiyonun yüklenme performansını artırmak.

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.OneToMany;

import org.hibernate.annotations.BatchSize;

import java.util.List;


@Entity

public class Order {

    @Id

    private Long id;

    private String customerName;

    

    @OneToMany(mappedBy = "order")

    @BatchSize(size = 20)

    private List<OrderItem> items;

    

    // getters and setters

}

@LazyGroup

Bu annotasyon, ilişkili bir varlığın belirli ilişki gruplarının tembel yüklenmesini sağlamak için kullanılır. Bu sayede ilişkili varlıklar sadece ihtiyaç duyulduğunda yüklenir, performansı artırır.

Kullanım Senaryosu: İlişkili varlıkların tembel yüklenmesini belirli ilişki gruplarına göre sağlamak.

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.ManyToOne;

import org.hibernate.annotations.LazyGroup;


@Entity

public class OrderItem {

    @Id

    private Long id;

    private String productName;

    

    @ManyToOne

    @LazyGroup("basic")

    private Order order;

    

    // getters and setters

}

@Filter

Bu annotasyon, bir filtreleme kuralı tanımlamak ve uygulamak için kullanılır. Filtreleme kuralları, sorguları veya ilişkili verileri belirli kriterlere göre sınırlamak için kullanılabilir.

Kullanım Senaryosu: Filtreleme kurallarını tanımlamak ve uygulamak.


import javax.persistence.Entity;

import javax.persistence.Id;

import org.hibernate.annotations.Filter;

import org.hibernate.annotations.FilterDef;

import org.hibernate.annotations.ParamDef;


@Entity

@FilterDef(name = "activeProducts", parameters = @ParamDef(name = "isActive", type = "boolean"))

@Filter(name = "activeProducts", condition = "is_active = :isActive")

public class Product {

    @Id

    private Long id;

    private String name;

    private boolean isActive;

    

    // getters and setters

}

@NaturalIdCache

Bu annotasyon, doğal kimlik (natural id) tabanlı önbelleğe alma için kullanılır. Doğal kimlik tabanlı önbellekleme, doğal kimliğe göre sık erişilen varlıkların performansını artırır.

Kullanım Senaryosu: Doğal kimlik tabanlı önbelleğe alma işlemini gerçekleştirmek.

import javax.persistence.Entity;

import javax.persistence.Id;

import org.hibernate.annotations.NaturalIdCache;


@Entity

@NaturalIdCache

public class User {

    @Id

    private Long id;

    

    // ...

}

@NaturalId

Bu annotasyon, bir varlık alanının doğal bir kimlik (natural id) olarak işaretlendiğini belirtmek için kullanılır. Doğal kimlik, benzersiz bir değere sahip bir alanı temsil eder.

Kullanım Senaryosu: Bir varlık alanını doğal kimlik olarak işaretlemek.


import javax.persistence.Entity;

import javax.persistence.Id;

import org.hibernate.annotations.NaturalId;


@Entity

public class User {

    @Id

    private Long id;


    @NaturalId

    private String username;


    // getters and setters

}

@Immutable

Bu annotasyon, bir varlığın değişmez (immutable) olduğunu belirtmek için kullanılır. Değişmez varlıklar, bir kez oluşturulduktan sonra durumlarının değiştirilemez olduğu anlamına gelir.

Kullanım Senaryosu: Bir varlığı değişmez olarak işaretlemek.


import javax.persistence.Entity;

import javax.persistence.Id;

import org.hibernate.annotations.Immutable;


@Entity

@Immutable

public class Product {

    @Id

    private Long id;

    private String name;

    private double price;


    // getters and setters

}

@BatchSize

Bu annotasyon, ilişkili bir koleksiyonun yüklenirken kaç varlık için bir sorgu yapılacağını belirtmek için kullanılır. Büyük koleksiyonların yüklenme performansını artırmak için kullanışlıdır.

Kullanım Senaryosu: İlişkili bir koleksiyonun yüklenme performansını artırmak.


import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.OneToMany;

import org.hibernate.annotations.BatchSize;

import java.util.List;


@Entity

public class Order {

    @Id

    private Long id;

    private String customerName;


    @OneToMany(mappedBy = "order")

    @BatchSize(size = 20)

    private List<OrderItem> items;


    // getters and setters

}





Hibernate Kursu - Hüseyin Babal - Türkçe - Playlist

 





Bu dizide, Hibernate iç özelliklerini ele alıyoruz ve her derste, Hibernate hakkındaki teorik bilgilerinizi gerçek hayattaki uygulamalarla kolayca geliştirebileceğiniz canlı bir kodlama oturumumuz var.

JPA - Hibernate Konu Anlatımı - Türkçe (ChatGPT)







JPA, nesne yönelimli programlama yaklaşımını veritabanı işlemlerine uygulayarak, veritabanı işlemlerini daha anlaşılır ve bakımı daha kolay hale getirir. JPA, veritabanı tabloları ve Java sınıfları arasındaki ilişkileri yönetmek için kullanılan JPA işaretçileri sayesinde birçok veritabanı işlemini otomatikleştirir.

JPA ile veritabanı işlemlerini gerçekleştirmek için Entity Manager nesnesini kullanabilirsiniz. Entity Manager, veritabanı işlemlerini gerçekleştirmek için kullanılan bir nesnedir. EntityManager, JPA'nın sağladığı API'leri kullanarak veritabanı işlemlerini gerçekleştirir. EntityManager, veritabanı tablolarındaki kayıtları işlemek için CRUD işlemlerini (Create, Read, Update, Delete) destekler.

JPA, Entity sınıflarını kullanarak veritabanı tabloları ve Java sınıfları arasındaki ilişkileri yönetir. Bir Entity sınıfı, bir veritabanı tablosuna karşılık gelir. Entity sınıflarında, veritabanı tablosundaki her sütun bir özellik (property) olarak tanımlanır. Entity sınıflarında tanımlanan özellikler, veritabanındaki sütunlarla eşleştirilir.

JPA işaretçileri, veritabanı işlemleri için kullanılan özel işaretçilerdir. Bu işaretçileri kullanarak, bir Entity sınıfının bir veritabanı tablosuna karşılık geldiğini belirtebilirsiniz. Ayrıca, bir Entity sınıfındaki bir özelliğin bir veritabanı sütununa karşılık geldiğini belirtebilirsiniz.

JPA, bir veritabanından veri almak için JPQL (Java Persistence Query Language) adında özel bir sorgu dilini de destekler. JPQL, SQL benzeri bir sorgu dilidir. JPQL, bir Entity Manager üzerinden çalışır ve veritabanından veri çekmek için kullanılır.

JPA'nın avantajları arasında veritabanı işlemlerinin daha kolay ve anlaşılır hale getirilmesi, nesne yönelimli programlama yaklaşımının veritabanı işlemlerine uygulanması, ORM araçlarının desteklenmesi, JPQL'nin kullanımı ve daha az kod yazımı gibi konular yer alır.

JPA, veritabanı işlemlerinin daha kolay ve anlaşılır hale getirilmesi, daha az kod yazma ihtiyacı ve veritabanı işlemlerinin daha hızlı gerçekleştirilmesi gibi avantajları nedeniyle Java programlama dili için popüler bir ORM aracıdır. JPA (Java Persistence API), Java programlama dilinde bir ORM (Object-Relational Mapping) aracıdır. ORM araçları, veritabanı işlemlerini gerçekleştirmek için kullanılan SQL (Structured Query Language) sorgularını yazmak yerine, Java nesneleri arasındaki ilişkileri kullanarak veritabanı işlemlerini gerçekleştirmeyi mümkün kılar.

JPA, özellikle Java EE (Enterprise Edition) uygulamalarında kullanılmak üzere tasarlanmıştır. JPA'nın temel amacı, veritabanı tabloları ve Java sınıfları arasındaki ilişkileri yönetmektir. Bu sayede, veritabanı işlemleri için kullanılan SQL sorgularını yazmak zorunda kalmadan, Java kodu üzerinden veritabanı işlemlerini gerçekleştirebilirsiniz.

JPA, JDBC (Java Database Connectivity) kütüphanesine dayanır. Ancak, JDBC'de olduğu gibi doğrudan SQL sorguları yazmak yerine, JPA'da veritabanı işlemleri için bir Entity Manager kullanılır. Entity Manager, veritabanı işlemlerini gerçekleştirmek için kullanılan bir nesnedir. Veritabanı işlemleri, Entity Manager aracılığıyla gerçekleştirilir.

JPA'nın en büyük avantajlarından biri, nesne yönelimli programlama yaklaşımının veritabanı işlemlerine uygulanmasıdır. Bu sayede, veritabanı işlemleri için kullanılan kodların daha anlaşılır ve bakımı daha kolay olur. Ayrıca, veritabanı tabloları ve Java sınıfları arasındaki ilişkileri yönetmek için kullanılan JPA işaretçileri (annotations) sayesinde, birçok veritabanı işlemi otomatikleştirilir.

JPA, farklı ORM (Object-Relational Mapping) araçlarını destekler. Hibernate, EclipseLink ve OpenJPA gibi farklı ORM araçları, JPA'nın desteği altındadır. Bu sayede, bir uygulamanın veri tabanı işlemlerini yönetmek için kullanılan Hibernate veya EclipseLink gibi bir ORM aracını değiştirerek JPA'ya geçebilirsiniz.

JPA ayrıca, bir veritabanından veri almak için JPQL (Java Persistence Query Language) adında özel bir sorgu dilini de destekler. JPQL, SQL benzeri bir sorgu dilidir, ancak Java sınıfları ve JPA işaretçileri kullanarak veritabanından veri çekmeyi mümkün kılar.

Sonuç olarak, JPA, Java programlama dili için veritabanı işlemlerini yönetmek için kullanılan bir ORM aracıdır. JPA, JDBC kütüphanesine dayanır ve veritabanı işlemleri için Entity Manager nesnesini kullanır.

PA (Java Persistence API) işaretçileri, Java sınıfları ve veritabanı tabloları arasındaki ilişkileri tanımlamak için kullanılan özel işaretçilerdir

  1. @Entity: Bir Java sınıfının bir veritabanı tablosuna karşılık geldiğini belirtir.
  2. @Table: Bir Java sınıfının hangi veritabanı tablosuna karşılık geldiğini belirtir.
  3. @Id: Bir sınıf özelliğinin bir veritabanı tablosundaki birincil anahtar (primary key) sütunu olduğunu belirtir.
  4. @GeneratedValue: Birincil anahtar sütununun nasıl oluşturulacağını belirler.
  5. @Column: Bir sınıf özelliğinin bir veritabanı sütunu olduğunu belirtir.
  6. @Basic: Bir sınıf özelliğinin basit bir veritabanı sütunu olduğunu belirtir.
  7. @Temporal: Bir tarih veya zaman özelliğinin veritabanındaki tarih veya zaman sütunlarına nasıl eşleneceğini belirler.
  8. @Transient: Bir sınıf özelliğinin veritabanına kaydedilmemesi gerektiğini belirtir.
  9. @OneToOne: Bir sınıfın diğer bir sınıf ile bir-bir ilişkisi olduğunu belirtir.
  10. @OneToMany: Bir sınıfın diğer bir sınıf ile bir-çok ilişkisi olduğunu belirtir.
  11. @ManyToOne: Bir sınıfın diğer bir sınıf ile çok-bir ilişkisi olduğunu belirtir.
  12. @ManyToMany: İki sınıf arasında birçok-çok ilişkisi olduğunu belirtir.
  13. @JoinColumn: İki sınıf arasındaki ilişkide kullanılacak veritabanı sütununu belirtir.
  14. @JoinTable: İki sınıf arasındaki ilişki için kullanılacak ortak bir tablonun adını belirtir.
  15. @Index: Bir veritabanı tablosunda bir indeksin tanımlanmasını sağlar.
  16. @NamedQuery: Bir JPQL (Java Persistence Query Language) sorgusunun adını ve sorgusunu tanımlar.
  17. @NamedQueries: Birden fazla @NamedQuery tanımlar.
  18. @QueryHint: Bir JPQL sorgusu için veritabanı yönetim sistemine yönelik bir ipucu sağlar.
  19. @SqlResultSetMapping: SQL sorguları tarafından döndürülen sonuçların nasıl eşleneceğini belirler.
  20. @Cacheable: Bir sınıfın ve/veya bir sınıf özelliğinin önbelleğe alınması gerektiğini belirtir.
  21. @Cache: Bir önbellek için yapılandırma bilgilerini sağlar.
  22. @ElementCollection: Bir sınıf özelliğinin bir koleksiyon olarak tutulacağını belirtir.
  23. @Embedded: Bir sınıf özelliğinin başka bir sınıfın özellikleriyle birleştirileceğini belirtir.
  24. @Embeddable: Bir sınıfın diğer bir sınıfın özelliği olarak kullanılabileceğini belirtir.
  25. @AttributeOverride: @Embedded sınıfının özelliklerinin nasıl eşleneceğini belirler.
  26. @AttributeOverrides: Birden fazla @AttributeOverride tanımlar.
  27. @Transient: Bir sınıf özelliğinin geçici olduğunu ve veritabanına kaydedilmemesi gerektiğini belirtir.
  28. @Version: Bir sınıfın optimistik kilitlemesini belirtir.
  29. @Access: Bir sınıf özelliğinin nasıl erişilebileceğini belirtir.
  30. @DiscriminatorColumn: Kalıtımlı sınıfların nasıl ayırt edileceğini belirler.
  31. @DiscriminatorValue: Bir kalıtımlı sınıfın değerini belirler.
  32. @Inheritance: Kalıtım stratejisini belirler.
  33. @NamedQuery: JPQL sorgularının adını ve sorgusunu tanımlar.
  34. @NamedQueries: Birden fazla @NamedQuery tanımlar.
  35. @SecondaryTable: Bir sınıfın birincil tablosuna ek olarak kullanılacak bir veya daha fazla tablonun adını belirtir.
  36. @SecondaryTables: Birden fazla @SecondaryTable tanımlar.
  37. @SequenceGenerator: Bir sınıfın birincil anahtarının nasıl oluşturulacağını belirler.
  38. @TableGenerator: Bir sınıfın birincil anahtarının nasıl oluşturulacağını belirler.
  39. @ExcludeSuperclassListeners: Bir sınıfın ana sınıfının olay dinleyicilerinin kullanılmamasını belirtir.
  40. @ExcludeDefaultListeners: Bir sınıfın varsayılan olay dinleyicilerinin kullanılmamasını belirtir.
  41. @EntityListeners: Bir sınıfın olay dinleyicilerini belirtir.
  42. @PrePersist: Bir sınıf örneği kalıcı hale getirilmeden önce çalışacak işlemi belirtir.
  43. @PostPersist: Bir sınıf örneği kalıcı hale getirildikten sonra çalışacak işlemi belirtir.
  44. @PreUpdate: Bir sınıf örneği güncellenmeden önce çalışacak işlemi belirtir.
  45. @PostUpdate: Bir sınıf örneği güncellendikten sonra çalışacak işlemi belirtir.
  46. @PreRemove: Bir sınıf örneği silinmeden önce çalışacak işlemi belirtir.
  47. @PostRemove: Bir sınıf örneği silindikten sonra çalışacak işlemi belirtir.
  48. @PostLoad: Bir sınıf örneği veritabanından yüklendikten sonra çalışacak işlemi belirtir.
  49. @MapKeyColumn: Bir harita sınıfının anahtar sütununun adını belirtir.
  50. @MapKeyJoinColumn: Bir harita sınıfının anahtar sütununu belirleyen bir join column oluşturur.
  51. @OrderBy: Bir koleksiyonun veya sıralı bir haritanın nasıl sıralanacağını belirler.
  52. @Lob: Bir sınıf özelliğinin büyük verileri tutmak için kullanılabileceğini belirtir.
  53. @NamedNativeQuery: Native SQL sorgularının adını ve sorgusunu tanımlar.
  54. @NamedNativeQueries: Birden fazla @NamedNativeQuery tanımlar.
  55. @SqlResultSetMappings: Native SQL sorguları tarafından döndürülen sonuçların nasıl eşleneceğini belirler.
  56. @SqlResultSetMapping: Bir SQL sonucu kümesinin bir sınıfa nasıl eşleneceğini belirtir.
  57. @Convert: Bir sınıf özelliğinin veritabanına nasıl dönüştürüleceğini belirler.
  58. @Converter: Bir dönüştürücü sınıfını belirtir.
  59. @AttributeConverter: Bir sınıf özelliğinin nasıl dönüştürüleceğini belirleyen bir dönüştürücü sınıfını belirtir.
  60. @ElementCollection: Bir sınıf özelliğinin bir koleksiyon olarak tutulacağını belirtir.
  61. @CollectionTable: Bir @ElementCollection için tablo ismini belirler.
  62. @AssociationOverride: Kalıtım hiyerarşisinde bir ilişkiyi geçersiz kılar.
  63. @AttributeOverride: Bir gömülü sınıfın veya bir sınıfın özelliklerinin nasıl eşleneceğini belirler.
  64. @BatchSize: Hibernate tarafından kullanılan önbellekleme için yüksek bir sayı belirtir.
  65. @Proxy: Hibernate tarafından kullanılan proxy'lerin davranışını belirler.
  66. @NaturalId: Bir sınıf özelliğinin doğal bir kimlik olduğunu belirtir.
  67. @NaturalIdCache: Bir doğal kimlik için önbellekleme bilgilerini sağlar.
  68. @Immutable: Bir sınıfın değiştirilemez olduğunu belirtir.
  69. @Filter: Bir sınıfın veya koleksiyonun dinamik olarak filtrelenmesine izin verir.
  70. @Filters: Birden fazla @Filter tanımlar.
  71. @TypeDef: Bir özel tip tanımlar.
  72. @Type: Bir sınıf özelliğinin özel bir tiple ilişkili olduğunu belirtir.
  73. @Loader: Bir ilişki yükleyicisini belirtir.
  74. @FetchProfile: Bir yük profili tanımlar.
  75. @PersistenceContext: Bir EntityManager referansı almak için kullanılır.
  76. @PersistenceUnit: Bir EntityManagerFactory referansı almak için kullanılır.
  77. @Enumerated: Bir özellik için belirtilen enum tipinin nasıl eşleneceğini belirler.
  78. @SequenceGenerator: Bir sınıfın birincil anahtarının nasıl oluşturulacağını belirler.
JPA (Java Persistence API) yaşam döngüsü, bir nesnenin oluşturulmasından, veritabanına kaydedilmesine ve nihayetinde veritabanından silinmesine kadar geçen süreçleri kapsar. JPA yaşam döngüsü, JPA entegrasyonu olan herhangi bir uygulama tarafından kullanılabilir.

JPA yaşam döngüsü, şu aşamalardan oluşur:

  1. Yeni nesne oluşturma: Bir nesne oluşturulduğunda, bu nesne henüz JPA yönetimi altında değildir. Bu aşamada nesne "new" durumundadır.
  2. Yönetilen durum: Bir EntityManager tarafından yönetilen bir nesne oluşturulduğunda, JPA tarafından yönetilen bir duruma girer. Bu aşamada nesne "managed" durumundadır.
  3. Yönetilen durumda değişiklikler: Yönetilen bir nesnedeki değişiklikler, otomatik olarak EntityManager tarafından izlenir ve veritabanına yansıtılır. Bu aşamada nesne "managed" durumunda kalır.
  4. Yönetilen durumdan ayrılma: EntityManager'dan çıkarılan bir nesne, "detached" duruma geçer. Detached durumdaki nesne, EntityManager tarafından yönetilmemekte ve veritabanında değişiklikler yansıtılmamaktadır.
  5. Yönetilen duruma geri getirme: EntityManager tarafından yönetilmeyen bir nesne, EntityManager tarafından tekrar yönetilen bir nesne haline getirilebilir. Bu durumda nesne tekrar "managed" durumuna geçer.
  6. Silme: EntityManager tarafından yönetilen bir nesne silindiğinde, nesne "removed" durumuna geçer.
  7. Veritabanına kaydetme: EntityManager tarafından yönetilen bir nesne veritabanına kaydedildiğinde, nesne "persistent" durumuna geçer.
  8. Veritabanından silme: EntityManager tarafından yönetilen bir nesne veritabanından silindiğinde, nesne "transient" durumuna geçer.


JPA yaşam döngüsü, EntityManager nesnesinin yönettiği nesnelerin her birinde gerçekleşir ve JPA özelliklerini kullanarak nesnenin durumunu izler. Bu süreç, JPA entegrasyonu olan herhangi bir uygulama tarafından kullanılabilir ve nesnelerin veritabanı ile etkileşimini yönetmek için çok önemlidir.

Hibernate, bir JPA (Java Persistence API) uygulamasıdır ve JPA yaşam döngüsünü takip eder. Hibernate'in yaşam döngüsü, bir nesnenin oluşturulmasından, veritabanına kaydedilmesine ve nihayetinde veritabanından silinmesine kadar geçen süreçleri kapsar. Hibernate yaşam döngüsü, bir Hibernate uygulamasında kullanılabilir.

Hibernate yaşam döngüsü, şu aşamalardan oluşur:


  1. Yeni nesne oluşturma: Bir nesne oluşturulduğunda, bu nesne henüz Hibernate yönetimi altında değildir. Bu aşamada nesne "transient" durumundadır.


  1. Kalıcı nesne: Bir nesne Hibernate tarafından yönetildiğinde, Hibernate tarafından yönetilen bir duruma girer. Bu aşamada nesne "persistent" durumundadır.

  2. Yönetilen durumda değişiklikler: Yönetilen bir nesnedeki değişiklikler, Hibernate tarafından izlenir ve veritabanına yansıtılır. Bu aşamada nesne "persistent" durumunda kalır.

  3. Yönetilen durumdan ayrılma: Session'dan çıkarılan bir nesne, "detached" duruma geçer. Detached durumdaki nesne, Hibernate tarafından yönetilmemekte ve veritabanında değişiklikler yansıtılmamaktadır.
    Ayrılmış durum için kullanılan yöntemler şunlardır:
            session.detach(e);
            session.evict(e);
            session.clear();
            session.close();




// Transient State
Employee e = new Employee("Neha Shri Rudra", 21, 180103);

// Persistent State 
session.save(e); 


// Detached State
session.close(); 
            

4.Yönetilen duruma geri getirme: Session tarafından yönetilmeyen bir nesne, Session tarafından tekrar yönetilen bir nesne haline getirilebilir. Bu durumda nesne tekrar "persistent" durumuna geçer.


5.Silme: Session tarafından yönetilen bir nesne silindiğinde, nesne "removed" durumuna geçer.


6.Veritabanına kaydetme: Session tarafından yönetilen bir nesne veritabanına kaydedildiğinde, nesne "persistent" durumuna geçer
7.Veritabanından silme: Session tarafından yönetilen bir nesne veritabanından silindiğinde, nesne "transient" durumuna geçer.

Hibernate yaşam döngüsü, Session nesnesinin yönettiği nesnelerin her birinde gerçekleşir ve Hibernate özelliklerini kullanarak nesnenin durumunu izler. Bu süreç, Hibernate entegrasyonu olan herhangi bir uygulama tarafından kullanılabilir ve nesnelerin veritabanı ile etkileşimini yönetmek için çok önemlidir.









Hibernate'de persistent durumunda olan nesnelerdeki değişiklikler, Hibernate tarafından otomatik olarak takip edilir ve veritabanına yansıtılır. Ancak bu işlem, bir işlem sırasında farklı noktalarda gerçekleşebilir.

Genellikle, bir Hibernate işlemi, bir transaction (işlem) içinde gerçekleştirilir. Bir transaction içinde, nesnelerin veritabanına yansıtılması tam olarak kontrol edilebilir. Bir transaction içinde, veritabanındaki herhangi bir değişiklik (oluşturma, güncelleme, silme vb.) geri alınabilir.

Persistent nesnelerde yapılan değişiklikler, transaction'in commit (onaylama) işlemi gerçekleştirildiğinde veritabanına yansıtılır. Örneğin, bir nesne üzerinde yapılan değişiklikler, Session'ın flush() metodu çağrıldığında, transaction commit edildiğinde veya Session kapatıldığında veritabanına yansıtılır.

Hibernate, bir Session içindeki tüm persistent nesneleri otomatik olarak takip eder ve değişiklikleri otomatik olarak veritabanına yansıtır. Bu sayede, geliştiricinin değişiklikleri elle takip etmesine gerek yoktur.

Ancak, bazı durumlarda, bazı değişikliklerin otomatik olarak veritabanına yansıtılmasını istemeyebilirsiniz. Bu durumlarda, Session'ın setFlushMode() metodu kullanılarak flush mode (sıfırlama modu) ayarlanabilir. Bu modda, otomatik flush işlemi devre dışı bırakılabilir veya flush işlemi, geliştiricinin belirlediği bir zaman diliminde gerçekleştirilebilir.

Özetle, Hibernate'de persistent durumunda olan nesnelerde yapılan değişiklikler, Session'ın flush işlemi gerçekleştirdiği anda veya transaction commit edildiğinde veritabanına yansıtılır. Ancak, Session'ın flush modu ayarlanarak, flush işlemi geciktirilebilir veya devre dışı bırakılabilir.

Hibernate'de flush() metodunu veya commit() metodunu çağırmazsam nesne yine de veritabanına kaydedilir mi?







Hibernate'de flush() veya commit() metotlarının çağrılmaması durumunda, Hibernate otomatik olarak bir flush işlemi gerçekleştirir. Bu flush işlemi, nesnenin veritabanına kaydedilmesini sağlar.

Ancak, otomatik flush işleminin zamanlaması, bir Session'in flush moduna bağlıdır. Hibernate'de flush modu, Session'ın flush işleminin ne zaman gerçekleştirileceğini kontrol eder. Varsayılan olarak, Hibernate, transaction commit edildiğinde veya bir sorgu çalıştırıldığında otomatik flush işlemi gerçekleştirir.

Ancak, flush modu değiştirilerek flush işlemi zamanlaması kontrol edilebilir. Örneğin, Session'ın setFlushMode() metodu kullanılarak FlushModeType.MANUAL moduna ayarlandığında, otomatik flush işlemi devre dışı bırakılır. Bu durumda, nesnenin veritabanına kaydedilmesi için flush() metodu çağrılması gerekir.

Özetle, Hibernate'de, Session'ın flush() veya commit() metotları çağrılmadığında bile, Hibernate otomatik olarak bir flush işlemi gerçekleştirir ve nesnenin veritabanına kaydedilmesini sağlar. Ancak, flush modu değiştirilerek flush işlemi zamanlaması kontrol edilebilir ve flush() metodu çağrılmadan önce veritabanına kaydetmek için flush işlemi manuel olarak gerçekleştirilmelidir.

Hibernate'de removed state'inde bulunan bir nesne veritabanından otomatik olarak silinir mi?

Hibernate'de removed state'inde bulunan bir nesne, veritabanından otomatik olarak silinmez. Removed state, sadece nesnenin Hibernate tarafından veritabanından silinmek üzere işaretlendiği durumdur. Nesnenin veritabanından silinmesi için, işaretlenmiş olmasına rağmen, Hibernate tarafından bir delete işlemi gerçekleştirilmesi gerekir.

Removed state'e geçirilen bir nesne, Session tarafından yönetilen nesneler listesinden kaldırılır ve Hibernate tarafından veritabanından silinmek üzere işaretlenir. Bu, nesnenin Session tarafından yönetilmediği anlamına gelir, ancak nesne henüz veritabanından silinmemiştir.

Hibernate'de veritabanından bir nesneyi silmek için, Session.delete() metodu kullanılır. Bu metot, veritabanındaki nesneyi siler ve Hibernate Session'dan da kaldırır. Bu yöntem çağrılmadan önce, nesnenin persistent state'de olması gerekir.

Özetle, Hibernate'de removed state'inde bulunan bir nesne, veritabanından otomatik olarak silinmez. Nesnenin veritabanından silinmesi için, Hibernate tarafından delete() metodu çağrılması gerekir.


Converting Persistent State to Removed State

Example

// Java Pseudo code to Illustrate Remove State
 
// Transient State
Employee e = new Employee();     
Session s = sessionfactory.openSession();
e.setId(01);


// Persistent State
session.save(e)  

// Removed State                 
session.delete(e);


Hibernate'de detach ile evict arasındaki fark nedir?

Hibernate'de detach() ve evict() metotları, bir nesnenin Session yönetiminden kaldırılmasını sağlar. Ancak, bu iki metot arasında bazı farklılıklar vardır.

detach() metodu, bir nesnenin Session ile olan bağlantısını keser, ancak nesne Hibernate Session yönetiminde kalır. Yani, nesne, detached (bağlantısı kesilmiş) bir nesne haline gelir, ancak hala Session içinde yer alır ve Session'ın kontrolü altındadır. Detach() metodu çağrıldığında, nesnenin Hibernate Session yönetiminden kaldırılması, nesnenin veritabanındaki durumunu etkilemez.

Öte yandan, evict() metodu, bir nesnenin Session yönetiminden kaldırılmasını ve Session tarafından tamamen unutulmasını sağlar. Yani, nesne Hibernate Session yönetiminden tamamen kaldırılır ve nesne artık Session tarafından yönetilmez. Evict() metodu çağrıldığında, nesnenin Hibernate Session yönetiminden kaldırılması, nesnenin veritabanındaki durumunu etkilemez. Ancak, bir nesne evict edildikten sonra, Session tarafından yeniden yönetilmek istenirse, nesne tekrar yüklenmesi gerekir.Genel olarak, detach() metodu, nesnenin Session yönetiminden çıkarılmasını sağlar, ancak nesne ile ilgili verilerin Session'dan kaldırılmamasını sağlar. Bu nedenle, nesne ile ilgili değişiklikler, daha sonra yeniden yönetildiğinde veritabanına kaydedilebilir. Öte yandan, evict() metodu, nesneyi tamamen unutulmuş hale getirir ve yeniden yüklenene kadar nesnenin değişiklikleri kaydedilmez. Bu nedenle, evict() metodu, nesnenin Session yönetiminden kalıcı olarak kaldırılması gerektiği durumlarda kullanılır.



Hibernate'de detach edilmiş bir nesne tekrar sesiona nasıl eklenir?

Hibernate'de detach edilmiş bir nesne, daha sonra tekrar Session'a eklemek için merge() veya update() metotları kullanılabilir. Bu iki metot arasındaki farklılıklar şunlardır:

Merge() metodu, detach edilmiş nesne üzerinde yapılan değişiklikleri korur ve yeni bir persistent nesne oluşturur. Detach edilmiş nesne, merge edildikten sonra, Hibernate Session'ın yönetimine geri alınır.

MyEntity detachedEntity = ...;

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

MyEntity persistentEntity = (MyEntity) session.merge(detachedEntity);

tx.commit();

session.close();


Update() metodu, detach edilmiş nesnenin verilerini veritabanından yeniden yükler. Bu nedenle, detach edilmiş nesne üzerinde yapılan değişiklikler kaybedilir ve veritabanındaki verilere göre nesne yeniden oluşturulur.


MyEntity detachedEntity = ...;

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

session.update(detachedEntity);

tx.commit();

session.close();

Özetle, detach edilmiş bir nesneyi tekrar Hibernate Session'a eklemek için, merge() veya update() metotları kullanılabilir. Merge() metodu, nesnenin değişikliklerini korurken, update() metodu, nesneyi veritabanından yeniden yükleyerek, değişiklikleri kaybeder.




Rastgele İçerik

© tüm hakları saklıdır
made with by templateszoo