<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ziya Orujaliyev on Medium]]></title>
        <description><![CDATA[Stories by Ziya Orujaliyev on Medium]]></description>
        <link>https://medium.com/@ziyaorujaliyev?source=rss-c7f310c37748------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*KY7eHBYX8y8yXxGH-8OQCw.jpeg</url>
            <title>Stories by Ziya Orujaliyev on Medium</title>
            <link>https://medium.com/@ziyaorujaliyev?source=rss-c7f310c37748------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 10:55:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ziyaorujaliyev/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Redis Sentinel ile Yüksek Erişilebilirlik ve Redis Keyspace Notifications ile Yerel Cache Yönetimi…]]></title>
            <link>https://medium.com/akbank-teknoloji/redis-sentinel-ile-y%C3%BCksek-eri%C5%9Filebilirlik-ve-redis-keyspace-notifications-ile-yerel-cache-y%C3%B6netimi-2f016e770bf4?source=rss-c7f310c37748------2</link>
            <guid isPermaLink="false">https://medium.com/p/2f016e770bf4</guid>
            <dc:creator><![CDATA[Ziya Orujaliyev]]></dc:creator>
            <pubDate>Fri, 16 Aug 2024 07:50:23 GMT</pubDate>
            <atom:updated>2024-08-16T07:50:23.537Z</atom:updated>
            <content:encoded><![CDATA[<h3>Redis Sentinel ile Yüksek Erişilebilirlik ve Redis Keyspace Notifications ile Yerel Cache Yönetimi: Spring Boot ile Adım Adım Rehber</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X9kyYc5L8jFw7eUAhIItGA.jpeg" /></figure><h4>Giriş</h4><p>Redis, yüksek performanslı bir key-value veritabanı olarak bilinir ve özellikle hızlı veri erişimi gerektiren uygulamalarda yaygın olarak kullanılır. Ancak, Redis’in sağladığı avantajlardan tam anlamıyla yararlanmak için yerel cache yönetimini ve failover mekanizmalarını da etkin bir şekilde gerçekleştirmek önemlidir. Bu yazıda, Redis Sentinel ve keyspace notifications kullanarak nasıl yerel cache yönetimi ve failover işlemleri gerçekleştirebileceğimizi adım adım ele alacağız.</p><h4><strong>Redis’te Yerel Cache Kullanımı</strong></h4><p>Yerel cache, uygulamanızın performansını önemli ölçüde artırabilir. Redis kullanarak yerel cache yönetimini gerçekleştirirken, sık erişilen verilerin yerel bellekte tutulması ve bu verilere hızlı erişim sağlanması hedeflenir. Ancak, yerel cache’in etkili bir şekilde yönetilmesi için cache’in güncel tutulması gerekir. Bu noktada, Redis keyspace notifications devreye girer. Bu özellik sayesinde, Redis’teki belirli event’ler (örneğin, set, del, expire) dinlenebilir ve yerel cache bu event’lere göre güncellenebilir. Böylece, verilerin güncelliği ve tutarlılığı korunur.</p><h4>Redis Sentinel Nedir?</h4><p>Redis Sentinel, Redis’in yüksek kullanılabilirlik (high availability) ve failover sağlayan bir bileşenidir. Sentinel, Redis sunucularını izler, bir master sunucu başarısız olursa otomatik olarak yeni bir master seçer ve client’ları bu yeni master’a yönlendirir. Bu sayede, uygulamanızın kesintisiz çalışmasını sağlar. Redis Sentinel’in temel görevleri şunlardır:</p><ul><li><strong>Monitor</strong>: Sentinel, Redis sunucularını izleyerek, onların erişilebilir olup olmadığını kontrol eder.</li><li><strong>Notification</strong>: Bir sorun tespit ettiğinde, sistem yöneticilerini bilgilendirir.</li><li><strong>Automatic Failover</strong>: Bir master sunucu başarısız olduğunda, yeni bir master sunucu seçer ve client’ları bu yeni master’a yönlendirir.</li><li><strong>Configuration Provider</strong>: Client’lara mevcut Redis sunucularının adreslerini sağlar.</li></ul><p>Sentinel konfigürasyonunu ayarlamak için, sentinel.conf dosyanızda aşağıdaki gibi yapılandırmalar yapın:</p><pre>sentinel monitor mymaster 127.0.0.1 6379 2<br>sentinel down-after-milliseconds mymaster 5000<br>sentinel failover-timeout mymaster 60000<br>sentinel parallel-syncs mymaster 1</pre><p>Bu ayarlar, Sentinel’in Redis master sunucusunu izleyip gerektiğinde failover işlemlerini gerçekleştirmesini sağlar. sentinel monitor mymaster 127.0.0.1 6379 2 komutu, Sentinel&#39;in izlediği master sunucusunu ve bu sunucunun adresini belirtir. sentinel down-after-milliseconds mymaster 5000 ayarı, master sunucusunun başarısız olduğunu kabul etmek için geçmesi gereken süreyi belirtir. sentinel failover-timeout mymaster 60000 ayarı, failover işleminin tamamlanması için maksimum süreyi belirtir. sentinel parallel-syncs mymaster 1 ayarı ise aynı anda kaç replikanın master ile senkronize olabileceğini belirtir.</p><h4>Redis Keyspace Notifications Nedir?</h4><p>Redis keyspace notifications, Redis sunucusunda gerçekleşen belirli event’lerin (örneğin, set, del, expire) bildirilmesini sağlayan bir özelliktir. Bu bildirimler sayesinde, Redis’teki değişiklikleri dinleyebilir ve buna göre işlemler yapabiliriz. Yerel cache yönetiminde, Redis’teki değişiklikler doğrultusunda yerel cache’i güncel tutmak için bu bildirimleri kullanacağız.</p><p>Redis keyspace notifications özelliğini etkinleştirmek için redis.conf dosyasını aşağıdaki gibi güncelleyin:</p><pre>notify-keyspace-events Ex</pre><h4>Proje Kurulumu</h4><h4>1. Maven Bağımlılıkları</h4><p>Projemizi oluşturmak için Spring Boot kullanacağız. Maven bağımlılıkları, konfigürasyon sınıfları ve servisler gibi gerekli tüm bileşenleri adım adım oluşturacağız.</p><p>pom.xml dosyanıza Spring Data Redis ve Lettuce bağımlılıklarını ekleyin:</p><pre>&lt;dependencies&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>        &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt;<br>    &lt;/dependency&gt;<br>    &lt;dependency&gt;<br>        &lt;groupId&gt;io.lettuce.core&lt;/groupId&gt;<br>        &lt;artifactId&gt;lettuce-core&lt;/artifactId&gt;<br>    &lt;/dependency&gt;<br>&lt;/dependencies&gt;</pre><p>Bu bağımlılıklar, Redis ile Spring Boot uygulamamız arasında entegrasyon sağlayacaktır.</p><h4>2. Redis Konfigürasyonu</h4><p><strong>RedisConfig.java</strong> dosyasını oluşturun ve Redis Sentinel bağlantı ayarlarını yapın:</p><pre>package com.sample.backbone.redis.listener;<br><br>import org.springframework.context.annotation.Bean;<br>import org.springframework.context.annotation.Configuration;<br>import org.springframework.data.redis.connection.RedisPassword;<br>import org.springframework.data.redis.connection.RedisSentinelConfiguration;<br>import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;<br>import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;<br>import org.springframework.data.redis.core.RedisTemplate;<br>import org.springframework.data.redis.core.StringRedisTemplate;<br><br>import javax.annotation.PostConstruct;<br>import java.time.Duration;<br>import java.util.Date;<br><br>@Configuration<br>public class RedisConfig {<br><br>    @Bean<br>    public LettuceConnectionFactory redisConnectionFactory() {<br>        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()<br>                .master(&quot;mymaster&quot;)<br>                .sentinel(&quot;127.0.0.1&quot;, 26379)<br>                .sentinel(&quot;127.0.0.2&quot;, 26379);<br>        sentinelConfig.setPassword(RedisPassword.of(&quot;yourRedisPassword&quot;));<br><br>        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()<br>                .readFrom(LettuceClientConfiguration.ReadFrom.REPLICA_PREFERRED)<br>                .commandTimeout(Duration.ofSeconds(1))<br>                .shutdownTimeout(Duration.ofMillis(1000))<br>                .clientOptions(ClientOptions.builder()<br>                        .autoReconnect(true)<br>                        .pingBeforeActivateConnection(true)<br>                        .socketOptions(SocketOptions.builder()<br>                                .connectTimeout(Duration.ofSeconds(1))<br>                                .build())<br>                        .build())<br>                .build();<br><br>        return new LettuceConnectionFactory(sentinelConfig, clientConfig);<br>    }<br><br>    @Bean<br>    public RedisTemplate&lt;String, String&gt; redisTemplate() {<br>        StringRedisTemplate template = new StringRedisTemplate();<br>        template.setConnectionFactory(redisConnectionFactory());<br>        return template;<br>    }<br><br>    @PostConstruct<br>    public void init() {<br>        System.out.println(&quot;RedisConfig constructed :&quot; + new Date(System.currentTimeMillis()));<br>    }<br>}</pre><h3>RedisConfig.java’nın Detayları</h3><ol><li><strong>RedisSentinelConfiguration</strong></li></ol><ul><li>Redis Sentinel yapılandırmasını içerir.</li><li><strong>master(&quot;mymaster&quot;)</strong> ifadesi, Sentinel&#39;in izlediği master sunucusunun adıdır.</li><li><strong>sentinel(&quot;127.0.0.1&quot;, 26379)</strong> ve <strong>sentinel(&quot;127.0.0.2&quot;, 26379)</strong> ifadeleri ise Sentinel düğümlerinin adresleri ve portlarıdır.</li><li>Bu yapılandırma, Sentinel’in master ve slave sunucuları izleyip gerektiğinde failover işlemini gerçekleştirmesini sağlar.</li><li><strong>setPassword(RedisPassword.of(&quot;yourRedisPassword&quot;))</strong> ifadesi ise Redis sunucusuna bağlanmak için gerekli olan şifreyi belirtir.</li></ul><p>2. <strong>LettuceClientConfiguration</strong></p><ul><li>Redis istemcisi için yapılandırma seçeneklerini içerir. Bu yapılandırmada birkaç önemli özellik bulunur:</li><li><strong>ReadFrom.REPLICA_PREFERRED</strong>: Bu seçenek, okuma işlemlerinin öncelikle replika sunuculardan yapılmasını sağlar. Böylece master sunucunun üzerindeki yük azaltılır ve okuma işlemleri hızlandırılır.</li><li><strong>commandTimeout(Duration.ofSeconds(1))</strong>: Redis komutlarının zaman aşımını 1 saniye olarak ayarlar. Bu, Redis sunucusuna gönderilen bir komutun 1 saniye içinde yanıt vermemesi durumunda, komutun zaman aşımına uğramasını sağlar. Bu ayar, uzun süreli beklemeleri önleyerek performansı artırır.</li><li><strong>shutdownTimeout(Duration.ofMillis(1000))</strong>: Redis istemcisinin kapanma zaman aşımını 1 saniye olarak ayarlar. Bu, istemcinin kapanması sırasında maksimum 1 saniye bekleyeceği anlamına gelir.</li><li><strong>ClientOptions.builder()</strong>: Redis istemcisi için ek yapılandırma seçeneklerini sağlar:</li><li><strong>autoReconnect(true)</strong>: İstemcinin bağlantısı kesildiğinde otomatik olarak yeniden bağlanmasını sağlar. Bu, bağlantı sorunlarının uygulamanız üzerinde minimum etkiyle çözülmesini sağlar.</li><li><strong>pingBeforeActivateConnection(true)</strong>: Bağlantı etkinleştirilmeden önce istemcinin Redis sunucusuna ping atmasını sağlar. Bu, bağlantının aktif olup olmadığını kontrol eder ve bağlantı sorunlarını önler.</li><li><strong>socketOptions(SocketOptions.builder().connectTimeout(Duration.ofSeconds(1)).build())</strong>: Socket bağlantı ayarlarını yapılandırır. Bu ayar, Redis sunucusuna bağlanırken maksimum 1 saniye bekleme süresi tanımlar. Bağlantı süresi 1 saniyeyi aşarsa, bağlantı zaman aşımına uğrar.</li></ul><h3>3. Redis Keyspace Notifications Dinleyicisi</h3><p>Redis’teki değişiklikleri dinlemek için bir dinleyici oluşturacağız.</p><h4>RedisConfigListener.java</h4><pre>package com.sample.backbone.redis.listener;<br><br>import org.springframework.context.annotation.Bean;<br>import org.springframework.context.annotation.Configuration;<br>import org.springframework.data.redis.connection.RedisConnectionFactory;<br>import org.springframework.data.redis.listener.PatternTopic;<br>import org.springframework.data.redis.listener.RedisMessageListenerContainer;<br>import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;<br><br>@Configuration<br>public class RedisConfigListener {<br><br>    @Bean<br>    public RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter) {<br>        RedisMessageListenerContainer container = new RedisMessageListenerContainer();<br>        container.setConnectionFactory(connectionFactory);<br>        container.addMessageListener(listenerAdapter, new PatternTopic(&quot;__keyevent@*__:set&quot;));<br>        container.addMessageListener(listenerAdapter, new PatternTopic(&quot;__keyevent@*__:expired&quot;));<br>        container.addMessageListener(listenerAdapter, new PatternTopic(&quot;__keyevent@*__:del&quot;));<br>        return container;<br>    }<br><br>    @Bean<br>    public MessageListenerAdapter listenerAdapter(RedisKeyspaceListener listener) {<br>        return new MessageListenerAdapter(listener, &quot;onMessage&quot;);<br>    }<br>}</pre><h4>RedisConfigListener.java’nın Detayları</h4><p>Bu sınıf, Redis keyspace notifications ile ilgili yapılandırmaları içerir.</p><ul><li><strong>RedisMessageListenerContainer</strong>: Redis mesaj dinleyici konteyneridir.<br><strong>setConnectionFactory(connectionFactory)</strong> ile Redis bağlantı fabrikası ayarlanır, <strong>addMessageListener(listenerAdapter, new PatternTopic(&quot;__keyevent@*__:set&quot;)), </strong><strong>addMessageListener(listenerAdapter, new PatternTopic(&quot;__keyevent@*__:expired&quot;)) </strong>ve<strong> </strong><strong>addMessageListener(listenerAdapter, new PatternTopic(&quot;__keyevent@*__:del&quot;)) </strong>ifadeleri, belirli keyspace event’lerini dinlemek için dinleyicileri ekler. Bu ayarlar, Redis&#39;teki <strong>set, </strong><strong>expired</strong> ve <strong>del </strong>olaylarını dinlememizi sağlar.</li><li><strong>MessageListenerAdapter</strong>: RedisKeyspaceListener sınıfını bir mesaj dinleyici olarak adapte eder. <strong>new MessageListenerAdapter(listener, &quot;onMessage&quot;)</strong> ifadesi, RedisKeyspaceListener sınıfının <strong>onMessage </strong>metodunu mesajları işlemek için kullanır.</li></ul><p><strong>RedisKeyspaceListener.java</strong></p><pre>package com.sample.backbone.redis.listener;<br><br>import com.sample.backbone.redis.service.RedisCacheService;<br>import org.springframework.beans.factory.annotation.Autowired;<br>import org.springframework.data.redis.connection.Message;<br>import org.springframework.data.redis.connection.MessageListener;<br>import org.springframework.stereotype.Component;<br><br>import java.util.Date;<br><br>@Component<br>public class RedisKeyspaceListener implements MessageListener {<br><br>    @Autowired<br>    private RedisCacheService redisCacheService;<br><br>    @Override<br>    public void onMessage(Message message, byte[] pattern) {<br>        String event = new String(pattern);<br>        String key = new String(message.getBody());<br>        System.out.println(new Date(System.currentTimeMillis()) + &quot; - Keyspace event received. Event: &quot; + event + &quot; Key: &quot; + key);<br><br>        if (event.contains(&quot;:set&quot;) || event.contains(&quot;:del&quot;) || event.contains(&quot;:expired&quot;)) <br>            redisCacheService.invalidateLocalCache(key);<br>        }<br>    }<br>}</pre><h4>RedisKeyspaceListener.java’nın Detayları</h4><p>Bu sınıf, Redis’ten gelen mesajları dinler ve işleyen sınıftır. <strong>RedisKeyspaceListener</strong>, Redis keyspace notifications&#39;ı dinler ve bu bildirimleri işler. Şimdi bu sınıfın detaylarına bakalım:</p><ul><li><strong>onMessage Metodu</strong>: Bu metod, Redis’ten gelen mesajları işleyen temel fonksiyondur. <strong>message </strong>parametresi, Redis tarafından gönderilen mesajı içerir ve <strong>pattern </strong>parametresi, mesajın desenini belirtir. <strong>onMessage </strong>metodu, Redis&#39;ten gelen mesajları işlerken olayın türünü (örneğin, set, del, expired) belirler ve bu olaylara göre yerel cache&#39;i günceller.</li><li><strong>Event ve Key Değişkenleri</strong>: <strong>event </strong>değişkeni, mesajın desenini tutar (örneğin, <strong>__keyevent@*__:set</strong>). <strong>key </strong>değişkeni ise mesajın içeriğini (anahtar adını) içerir.</li><li><strong>Olay Türünü Belirleme</strong>: <strong>if (event.contains(&quot;:set&quot;) || event.contains(&quot;:del&quot;) || event.contains(&quot;:expired&quot;))</strong> kontrolü, mesajın hangi türde bir olay olduğunu belirler. Bu kontroller, <strong>set, </strong><strong>del </strong>ve <strong>expired</strong> olaylarını tanımlar.</li><li><strong>Yerel Cache’in Güncellenmesi</strong>: Belirli bir olay gerçekleştiğinde (örneğin, bir anahtarın değeri değiştirildiğinde, silindiğinde veya süresi dolduğunda), <strong>redisCacheService.invalidateLocalCache(key)</strong> metodu çağrılır ve ilgili anahtar yerel cache&#39;den kaldırılır. Bu, yerel cache&#39;in güncel kalmasını sağlar.</li></ul><h3>Redis Cache Servisi</h3><p>Yerel cache yönetimi için gerekli servisleri oluşturacağız.</p><h4>RedisCacheService.java</h4><pre>package com.sample.backbone.redis.service;<br><br>import org.springframework.beans.factory.annotation.Autowired;<br>import org.springframework.data.redis.core.RedisTemplate;<br>import org.springframework.stereotype.Service;<br><br>import java.util.concurrent.ConcurrentHashMap;<br>import java.util.concurrent.TimeUnit;<br><br>@Service<br>public class RedisCacheService {<br><br>    private final ConcurrentHashMap&lt;String, String&gt; localCache = new ConcurrentHashMap&lt;&gt;();<br><br>    @Autowired<br>    private RedisTemplate&lt;String, String&gt; redisTemplate;<br><br>    public String getValue(String key) {<br>        if (localCache.containsKey(key)) {<br>            System.out.println(key + &quot; - &quot; + localCache.get(key) + &quot; - get from local cache&quot;);<br>            return localCache.get(key);<br>        }<br><br>        String value = redisTemplate.opsForValue().get(key);<br>        System.out.println(key + &quot; - &quot; + value + &quot; - get from REDIS&quot;);<br><br>        if (value != null) {<br>            localCache.put(key, value);<br>        }<br><br>        return value;<br>    }<br><br>    public void setValue(String key, String value) {<br>        redisTemplate.opsForValue().set(key, value);<br>        localCache.put(key, value);<br>    }<br><br>    public void setValueWithTTL(String key, String value, long timeout, TimeUnit unit) {<br>        redisTemplate.opsForValue().set(key, value, timeout, unit);<br>        localCache.put(key, value);<br>    }<br><br>    public void invalidateLocalCache(String key) {<br>        System.out.println(&quot;Local cache invalidated&quot;);<br>        localCache.remove(key);<br>    }<br>}</pre><h4>RedisCacheService.java’nın Detayları</h4><p>Bu sınıf, Redis ve yerel cache yönetimi için servis sınıfıdır. <strong>localCache</strong>, yerel cache&#39;i saklar. <strong>getValue</strong>, <strong>setValue</strong>, <strong>setValueWithTTL </strong>ve <strong>invalidateLocalCache </strong>metodları, Redis ve yerel cache üzerinde işlemler yapar.</p><ul><li><strong>getValue</strong> metodu, öncelikle yerel cache’i kontrol eder ve eğer yerel cache’de yoksa Redis’ten değer alır. Bu metod, performansı artırmak için veriyi öncelikle yerel cache’den almayı dener.</li><li><strong>setValue</strong> ve <strong>setValueWithTTL</strong> metodları, hem Redis’e hem de yerel cache’e veri yazar. Bu metodlar, veriyi hem Redis’te hem de yerel cache’de senkronize tutar.</li><li><strong>invalidateLocalCache</strong> metodu ise belirli bir anahtarı yerel cache’den siler. Bu metod, belirli bir anahtarın yerel cache’den kaldırılmasını sağlar ve böylece cache’in güncel kalmasını sağlar.</li></ul><h3>Redis Cache Kontrolcüsü</h3><p>Son olarak, yerel cache servisimiz ile etkileşimde bulunmak için bir kontrolcü oluşturacağız.</p><p><strong>RedisCacheController.java</strong></p><pre>package com.sample.backbone.redis.controller;<br><br>import com.sample.backbone.redis.service.RedisCacheService;<br>import org.springframework.beans.factory.annotation.Autowired;<br>import org.springframework.web.bind.annotation.*;<br><br>@RestController<br>@RequestMapping(&quot;/api/cache&quot;)<br>public class RedisCacheController {<br><br>    @Autowired<br>    private RedisCacheService redisCacheService;<br><br>    @PostMapping(&quot;/set&quot;)<br>    public void setValue(@RequestParam String key, @RequestParam String value) {<br>        redisCacheService.setValue(key, value);<br>    }<br><br>    @PostMapping(&quot;/setWithTTL&quot;)<br>    public void setValueWithTTL(@RequestParam String key, @RequestParam String value, @RequestParam long timeout) {<br>        redisCacheService.setValueWithTTL(key, value, timeout, TimeUnit.SECONDS);<br>    }<br><br>    @GetMapping(&quot;/get&quot;)<br>    public String getValue(@RequestParam String key) {<br>        return redisCacheService.getValue(key);<br>    }<br><br>    @DeleteMapping(&quot;/invalidate&quot;)<br>    public void invalidateCache(@RequestParam String key) {<br>        redisCacheService.invalidateLocalCache(key);<br>    }<br>}</pre><h4>RedisCacheController.java’nın Detayları</h4><p>Bu sınıf, RedisCacheService ile etkileşimde bulunan kontrolcü sınıftır. <strong>setValue</strong>, <strong>setValueWithTTL</strong>, <strong>getValue </strong>ve <strong>invalidateCache </strong>metodları, HTTP istekleri ile RedisCacheService metodlarını çağırır.</p><ul><li><strong>setValue</strong> ve <strong>setValueWithTTL</strong> metodları, anahtar-değer çiftlerini Redis ve yerel cache’e yazar. Bu metodlar, veriyi hem Redis’te hem de yerel cache’de senkronize tutar.</li><li><strong>getValue</strong> metodu, belirli bir anahtar için değeri getirir. Bu metod, öncelikle yerel cache’i kontrol eder ve eğer yerel cache’de yoksa Redis’ten değer alır.</li><li><strong>invalidateCache</strong> metodu ise belirli bir anahtarı yerel cache’den siler. Bu metod, belirli bir anahtarın yerel cache’den kaldırılmasını sağlar ve böylece cache’in güncel kalmasını sağlar.</li></ul><h3>Performans ve Optimizasyon</h3><p>Bu yapı, performansı artırmak ve sistemin verimliliğini maksimize etmek için birkaç önemli avantaj sunar:</p><ol><li><strong>Yerel Cache Kullanımı</strong>: Verilere hızlı erişim sağlamak için yerel cache kullanılır. Bu, özellikle sık kullanılan verilerin yerel cache’den hızlı bir şekilde alınmasını sağlar.</li><li><strong>Redis Keyspace Notifications</strong>: Redis’teki değişiklikleri dinleyerek yerel cache’in güncel kalmasını sağlar. Bu, cache tutarlılığını korur ve eski verilerin kullanılmasını önler.</li><li><strong>Redis Sentinel</strong>: Yüksek kullanılabilirlik ve otomatik failover sağlar. Bu, sistemin kesintisiz çalışmasını ve herhangi bir sunucu arızasında hızlı bir şekilde yeni bir master sunucu seçilmesini sağlar</li></ol><h3>Optimizasyon İpuçları</h3><ol><li><strong>Veri Erişim Modellerini Analiz Edin</strong>: Hangi verilerin daha sık erişildiğini analiz edin ve bu verilerin yerel cache’de tutulduğundan emin olun.</li><li><strong>Cache Boyutunu Ayarlayın</strong>: Yerel cache’in boyutunu ihtiyaçlarınıza göre ayarlayın. Çok büyük bir cache bellek kullanımını artırabilir, çok küçük bir cache ise performansı düşürebilir.</li><li><strong>Time-to-Live (TTL) Ayarlarını Kullanın</strong>: Verilerin geçerlilik sürelerini ayarlamak için TTL kullanın. Bu, eski verilerin cache’de kalmasını önler ve güncel verilerin kullanılmasını sağlar.</li><li><strong>Monitor ve Analiz Edin</strong>: Sistem performansını düzenli olarak izleyin ve analiz edin. Performans sorunları tespit ettiğinizde, cache yapılandırmalarınızı ve veri erişim modellerinizi gözden geçirin.</li></ol><h3>Sonuç</h3><p>Bu makalede, Redis Sentinel ve Redis Keyspace Notifications kullanarak gelişmiş bir yerel cache yönetimi ve failover mekanizması nasıl oluşturabileceğimizi adım adım ele aldık. Redis Sentinel, yüksek kullanılabilirlik ve otomatik failover sağlarken, Redis Keyspace Notifications ile yerel cache’i güncel tutarak sistemin performansını ve verimliliğini artırabiliriz. Bu yapı, özellikle büyük ölçekli ve yüksek trafikli uygulamalarda önemli avantajlar sağlayacaktır. Redis’in bu güçlü özelliklerinden yararlanarak, uygulamalarınızın daha güvenilir ve hızlı çalışmasını sağlayabilirsiniz.</p><p>Bu çözümle, Redis’in sunduğu yüksek performanslı veri yönetimi imkanlarından tam anlamıyla yararlanabilir ve sisteminizin her zaman en iyi performansta çalışmasını sağlayabilirsiniz. Redis Sentinel ve Redis Keyspace Notifications’ın güçlü yönlerini bir araya getirerek, uygulamanızın güvenilirliğini ve verimliliğini artırabilirsiniz. Bu rehberi takip ederek, siz de kendi projelerinizde bu ileri seviye Redis özelliklerini kullanarak daha etkili ve verimli çözümler geliştirebilirsiniz.</p><p>Bir sonraki yazımızda görüşmek üzere…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2f016e770bf4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/akbank-teknoloji/redis-sentinel-ile-y%C3%BCksek-eri%C5%9Filebilirlik-ve-redis-keyspace-notifications-ile-yerel-cache-y%C3%B6netimi-2f016e770bf4">Redis Sentinel ile Yüksek Erişilebilirlik ve Redis Keyspace Notifications ile Yerel Cache Yönetimi…</a> was originally published in <a href="https://medium.com/akbank-teknoloji">Akbank Teknoloji</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot ile Apache Kafka’da Mesaj İletim Semantikleri ; At Most Once, At Least Once, Exactly…]]></title>
            <link>https://medium.com/akbank-teknoloji/spring-boot-ile-apache-kafkada-mesaj-i%CC%87letim-semantikleri-at-most-once-at-least-once-exactly-b3ac5558a210?source=rss-c7f310c37748------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3ac5558a210</guid>
            <dc:creator><![CDATA[Ziya Orujaliyev]]></dc:creator>
            <pubDate>Wed, 09 Aug 2023 08:13:23 GMT</pubDate>
            <atom:updated>2023-08-09T08:13:23.530Z</atom:updated>
            <content:encoded><![CDATA[<h3>Spring Boot ile Apache Kafka’da Mesaj İletim Semantikleri ; <strong>At Most Once, At Least Once, Exactly Once</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GQ6PLA9nIOOKjucDjhQ8vw.jpeg" /></figure><h3>Genel Bakış</h3><p>Bu makale, Spring Boot ve Apache Kafka teknolojilerini kullanarak message delivery semantics (mesaj iletim semantikleri) konusunu derinlemesine incelemeyi hedefler. Message delivery semantics, bir mesajın nasıl ve ne zaman gönderildiğini ve ayrıca bu süreçte hangi garanti seçeneklerinin sunulduğunu belirler. Bu garantiler, mesajların doğru şekilde iletilip iletilmediğini belirlemenin kritik bir parçasıdır.</p><p>Apache Kafka’da üç ana message delivery semantic vardır: “At Most Once” (En Fazla Bir Kez), “At Least Once” (En Az Bir Kez) ve “Exactly Once” (Tam Bir Kez). Bu semantikler, mesajların kaybolmaması, çift teslim edilmemesi veya her ikisini birden önleme garantilerini sunar. Ancak her birinin uygulanması farklı teknikler gerektirir ve belirli bir durum için hangi garanti seçeneğinin en uygun olduğuna dikkatlice karar verilmesi gerekir.</p><p>Bu makalede, bu semantiklerin her birinin nasıl uygulandığına ve hangi durumlar için en uygun olduklarına geniş bir bakış sunacağız. Özellikle “Exactly Once” (Tam Bir Kez) semantiği üzerinde duracağız ve Spring Boot kullanarak bir Kafka uygulamasında nasıl uygulanacağını detaylı bir şekilde göstereceğiz.</p><p>Java ve Spring Boot bilgisine sahip okuyucular, bu makaleden Apache Kafka’nın smesaj iletim garantilerini nasıl kullandığını daha iyi anlayacak ve kendi uygulamalarında nasıl uygulanabileceğine dair pratik bilgi edinecekler.</p><h3>Apache Kafka ve Mesaj İletim Semantikleri</h3><p>Apache Kafka, LinkedIn tarafından geliştirilmiş ve şimdi Apache Software Foundation altında açık kaynak olarak geliştirilen büyük ölçekli, dağıtık ve yayıncı-abone modeline dayalı bir mesajlaşma sistemi olarak bilinir. Kafka, veriyi hızlı bir şekilde işlemek ve büyük veri kümelerini depolamak ve işlemek için tasarlanmıştır. Yüksek hızlı veri akışlarını çok sayıda tüketiciye aynı anda sağlama yeteneği, Kafka’nın popüler bir seçim olmasını sağlamıştır.</p><p>Mesaj iletim semantikleri, Kafka’da bir mesajın nasıl ve ne zaman iletilmesi gerektiğini belirler. Üç ana semantik vardır: “At Most Once” (En Fazla Bir Kez), “At Least Once” (En Az Bir Kez) ve “Exactly Once” (Tam Bir Kez). Bu semantikler, Kafka’nın farklı uygulama gereksinimlerini karşılamak için çeşitli garanti seçenekleri sunmasını sağlar.</p><ul><li><strong>“At Most Once” </strong>semantiği, bir mesajın bir kere veya hiç iletilmemesi gerektiğini belirtir. Bu, bir mesajın kaybolmasının kabul edilebilir olduğu durumlarda kullanılır.</li><li><strong>“At Least Once”</strong> semantiği, bir mesajın en az bir kez iletilmesi gerektiğini belirtir. Bu, bir mesajın kaybolmasının kabul edilemez olduğu, ancak çift iletimin kabul edilebilir olduğu durumlarda kullanılır.</li><li><strong>“Exactly Once”</strong> semantiği, bir mesajın tam olarak bir kez iletilmesi gerektiğini belirtir. Bu, bir mesajın hem kaybolmasının hem de çift teslimatının kabul edilemez olduğu durumlarda kullanılır.</li></ul><p>Bu semantiklerin hangisinin kullanılacağı, uygulamanın gereksinimlerine ve verinin doğasına bağlıdır. Örneğin, günlük dosyalarını yedekleme veya loglama amaçlı bir uygulama “At Least Once” semantiğini kullanabilir, çünkü her mesajın en az bir kez teslim edilmesi kritiktir ve aynı mesajın birden fazla kez teslim edilmesi genellikle kabul edilebilir. Öte yandan, bir bankacılık işlemi uygulaması “Exactly Once” semantiğini kullanabilir, çünkü her işlem sadece bir kez gerçekleştirilmeli ve hiçbir işlem kaybolmamalıdır.</p><p>Sonraki bölümlerde, bu semantiklerin her birini Spring Boot ile nasıl uygulayabileceğimizi ayrıntılı olarak inceleyeceğiz.</p><h3>At Most Once</h3><p>Mesajların bir kez ya da hiç iletilmemesi garantisi sağlar. Bu, verinin kaybolabileceği durumların kabul edilebilir olduğu senaryolarda kullanışlıdır. Örneğin, bir log veya hızlı değişen bir veri akışının takibi gibi durumlarda, tüm verilerin tamamen doğru bir şekilde yakalanmasına gerek olmayabilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/766/1*WIqKBMTU9DVwARS2a911aQ.png" /></figure><p>Spring Boot ile bir Kafka uygulamasında “At Most Once” semantiğini uygulamak için Kafka’nın otomatik commit özelliğini kullanabiliriz. Bu, Kafka’nın bir mesajı okuduktan sonra ilerlemeyi otomatik olarak commit etmesi anlamına gelir. Yani, bir mesaj okunduğunda, Kafka bu mesajın zaten işlendiğini varsayar ve bir sonraki mesaja geçer. Bu, bir hata durumunda bile bu mesajın bir daha okunmayacağı anlamına gelir, böylece “At Most Once” garantisini sağlar.</p><p>Java ve Spring Boot kullanarak “At Most Once” semantiği aşağıdaki gibi uygulanabilir:</p><p><strong>1.Apache Kafka’nın kurulumu ve konfigürasyonu:</strong></p><p>Kafka’nın kurulumu ve konfigürasyonu hakkında detaylı bilgi, <a href="https://kafka.apache.org/quickstart">Apache Kafka’nın resmi dokümantasyonunda</a> bulunabilir.</p><p><strong>2. Spring Boot uygulamasının oluşturulması ve Kafka bağımlılıklarının eklenmesi (Dependencies):</strong></p><p>Yeni bir Spring Boot uygulaması oluşturun ve Kafka bağımlılıklarını ekleyin. Maven projesi için pom.xml dosyasına aşağıdaki bağımlılıkları ekleyin:</p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;org.springframework.kafka&lt;/groupId&gt;<br>    &lt;artifactId&gt;spring-kafka&lt;/artifactId&gt;<br>&lt;/dependency&gt;</pre><p><strong>3. Kafka yapılandırmasının (Configuration) ayarlanması:</strong></p><p>Kafka’ya bağlanmak için application.properties dosyasına aşağıdaki yapılandırmayı ekleyin:</p><pre>spring.kafka.consumer.bootstrap-servers=localhost:9092<br>spring.kafka.consumer.group-id=group_id<br>spring.kafka.consumer.auto-offset-reset=earliest<br>spring.kafka.consumer.enable-auto-commit=true<br>spring.kafka.consumer.auto-commit-interval=1000</pre><p>Bu ayarlar, Kafka sunucusunun localhost:9092 adresinde çalıştığını, tüketici (consumer) grup id&#39;sinin group_id olduğunu, offset&#39;in earliest konumdan başladığını, auto-commit’in etkin olduğunu ve auto-commit aralığının 1000ms olduğunu belirtir.</p><p><strong>4.Kafka üretici (producer) ve tüketici (consumer) kodlarının yazılması:</strong></p><p>Kafka’ya mesaj göndermek için bir üretici (producer) oluşturun. KafkaTemplate kullanarak mesajı belirli bir topic’e gönderebilirsiniz.</p><pre>@Autowired<br>private KafkaTemplate&lt;String, String&gt; kafkaTemplate;<br><br>public void sendMessage(String msg, String topicName){<br>    kafkaTemplate.send(topicName, msg);<br>}</pre><p>Mesajları tüketmek için bir tüketici (consumer) oluşturun. @KafkaListener anotasyonunu kullanarak belirli bir topic’ten mesajları dinleyebilirsiniz.</p><pre>@KafkaListener(topics = &quot;testTopic&quot;, groupId = &quot;group_id&quot;)<br>public void consume(String message) {<br>    System.out.println(&quot;Consumed message: &quot; + message);<br>}</pre><p>Bu kod örnekleri, Kafka’ya bir mesaj göndermek ve tüketmek için kullanılır. Bu kodda, “At Most Once” (En Fazla Bir Kez) semantiği kullanılır çünkü enable.auto.commit özelliği true olarak ayarlanmıştır ve auto.commit.interval.ms özelliği 1000 olarak ayarlanmıştır. Bu, tüketici&#39;nin (consumer) belirli bir aralıkla otomatik olarak commit yapacağı ve bir mesajın en fazla bir kez işleneceği anlamına gelir. Bu yaklaşım, bir hata durumunda bile bir mesajın bir daha okunmayacağını garanti eder.</p><h3>At Least Once</h3><p>Bu semantik, bir mesajın en az bir kez işleneceğini garanti eder. Bu, verinin kaybolmasının kabul edilemez olduğu, ancak çift işlemenin toleranslı olduğu durumlar için uygundur. Bu semantik, her bir mesajın işlendiği ve hatasız bir şekilde tükendiği durumlar için mükemmeldir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/772/1*-HNn46RI-MKUbOREYxVwMw.png" /></figure><p>Spring Boot ve Kafka ile bir uygulamada “At Least Once” semantiğini uygulamak için, Kafka’nın otomatik commit özelliğini devre dışı bırakabiliriz. Bu, Kafka’nın bir mesajı okuduktan sonra ilerlemeyi otomatik olarak commit etmeyeceği anlamına gelir. Bunun yerine, mesajın işlendiği ve tüketildiği açıkça belirtilene kadar offset ilerletilmez. Bu yaklaşım, bir hata durumunda işlenmemiş bir mesajın tekrar okunmasını garanti eder. Bu durum, “At Least Once” garantisi sağlar. Bununla birlikte, hatalı durumlarda aynı mesajın birden fazla kez işlenebileceğini unutmayın, bu yüzden uygulamanın çift işlemi tolere edebilecek şekilde tasarlanması önemlidir.</p><p>Java ve Spring Boot kullanarak “At Most Once” semantiği aşağıdaki gibi uygulanabilir:</p><p><strong>1.Kafka yapılandırmasının (Configuration) ayarlanması:</strong></p><p>Kafka’ya bağlanmak için application.properties dosyasına aşağıdaki yapılandırmayı ekleyin:</p><pre>spring.kafka.consumer.bootstrap-servers=localhost:9092<br>spring.kafka.consumer.group-id=group_id<br>spring.kafka.consumer.auto-offset-reset=earliest<br>spring.kafka.consumer.enable-auto-commit=false</pre><p>Bu ayarlar, Kafka sunucusunun localhost:9092 adresinde çalıştığını, tüketici (consumer) grup id&#39;sinin group_id olduğunu, offset&#39;in earliest konumdan başladığını ve auto-commit&#39;in etkin olmadığını belirtir.</p><p><strong>2. Kafka üretici (producer) ve tüketici (consumer) kodlarının yazılması:</strong></p><p>Kafka’ya mesaj göndermek için bir üretici (producer) oluşturun. KafkaTemplate kullanarak mesajı belirli bir topic’e gönderebilirsiniz</p><pre>@Autowired<br>private KafkaTemplate&lt;String, String&gt; kafkaTemplate;<br><br>public void sendMessage(String msg, String topicName){<br>    kafkaTemplate.send(topicName, msg);<br>}</pre><p>Mesajları tüketmek için bir tüketici (consumer) oluşturun. @KafkaListener anotasyonunu kullanarak belirli bir topic’den mesajları dinleyebilirsiniz.</p><pre>@KafkaListener(topics = &quot;testTopic&quot;, groupId = &quot;group_id&quot;)<br>public void consume(ConsumerRecord&lt;String, String&gt; record, Acknowledgment acknowledgment) {<br>    System.out.println(&quot;Consumed message: &quot; + record.value());<br>    acknowledgment.acknowledge();<br>}</pre><p>Bu kod örnekleri, Kafka’ya bir mesaj göndermek ve tüketmek için kullanılır. Bu kodda, “At Least Once” (En Az Bir Kez) semantiği kullanılır çünkü enable.auto.commit özelliği false olarak ayarlanmıştır. Bu, tüketici&#39;nin (consumer) bir mesajın işlenmesinin tamamlandığını açıkça belirtene kadar offset&#39;i ilerletmeyeceği anlamına gelir. Bu yaklaşım, bir hata durumunda bile işlenmemiş bir mesajın tekrar okunmasını garanti eder.</p><p>Bu yaklaşım, her bir işlemi tamamlayıp tamamlamadığınızı belirlemek için her bir kaydın (record) belirli bir durumunu takip etmenizi sağlar. Bir hata durumunda, Kafka&#39;nın bir sonraki okuma için mevcut offset&#39;i değiştirmediğini ve işlem tamamlanana kadar aynı mesajın tekrar okunduğunu belirtmek önemlidir.</p><p>Yukarıda bahsedilen adımların her biri, belirli bir durumda daha uygun olan farklı ileti semantiklerini kullanmak üzere düzenlenebilir. Bu örnek, bir uygulamanın “At Least Once” (En Az Bir Kez) semantiğiyle nasıl yapılandırılabileceğini gösterir.</p><h3>Exactly Once</h3><p>Bu semantik, bir mesajın tam olarak bir kez işlenmesini garanti eder. Bu, verinin kaybolmasının ya da çift işlemenin kabul edilemez olduğu durumlar için en ideal semantiktir. Ancak, bu semantiği uygulamak teknik olarak diğerlerinden daha karmaşıktır ve genellikle daha fazla işlemci ve ağ yükü gerektirir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*eKRf5zSeHLckwZ8d9eZ2GQ.png" /></figure><p>Spring Boot ve Kafka ile bir uygulamada “Exactly Once” semantiğini uygulamak için, Kafka’nın transactional API’sini kullanabiliriz. Bu, Kafka’nın bir grup mesajı bir transaction (işlem) olarak işleyeceği ve ya tüm mesajların başarılı bir şekilde işleneceği ya da hiçbirinin işlenmeyeceği anlamına gelir. Bu, bir hata durumunda, tamamlanmamış bir işlemin tekrar işleneceğini ve dolayısıyla her mesajın tam olarak bir kez işleneceğini garanti eder. Bununla birlikte, bu yaklaşımın, diğer semantiklere göre daha fazla sistem ve ağ kaynağı tüketeceğini unutmamak önemlidir.</p><p>“Exactly Once” semantiği genellikle, tüm işlemlerin tam olarak bir kez tamamlanması gereken senaryolarda kullanılır. Örneğin, bir banka transferi gibi durumlarda, bir işlemin hiç uygulanmaması veya iki kez uygulanması kabul edilemez. Bu durumda, “Exactly Once” semantiği ideal bir çözüm sunar.</p><p>“Exactly Once” semantiğini uygulamak için Kafka’nın işlem (transaction) API’sini kullanabiliriz. İşlem API’si, Kafka’nın bir grup mesajı bir işlem olarak işlemesine ve ya tüm mesajların başarılı bir şekilde işlemesi ya da hiçbirinin işlememesi anlamına gelir.</p><p>Aşağıdaki örnekte, bir Kafka işlemi başlatıldı, ardından bir mesaj gönderildi ve işlem commit edildi (tamamlandı). Eğer herhangi bir hata oluşursa, işlem geri alınır (rollback) ve mesaj tekrar gönderilir.</p><pre>// KafkaTemplate configuration for transactional producer<br>@Bean<br>public KafkaTemplate&lt;String, String&gt; kafkaTemplate(ProducerFactory&lt;String, String&gt; producerFactory) {<br>    return new KafkaTemplate&lt;&gt;(producerFactory);<br>}<br><br>@Bean<br>public ProducerFactory&lt;String, String&gt; producerFactory() {<br>    Map&lt;String, Object&gt; configProps = new HashMap&lt;&gt;();<br>    configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, &quot;localhost:9092&quot;);<br>    configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);<br>    configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);<br>    configProps.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, &quot;prod-1&quot;);<br>    configProps.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true);<br>    return new DefaultKafkaProducerFactory&lt;&gt;(configProps);<br>}<br><br>// Usage in service method<br>@Service<br>public class MyService {<br><br>    private final KafkaTemplate&lt;String, String&gt; kafkaTemplate;<br><br>    public MyService(KafkaTemplate&lt;String, String&gt; kafkaTemplate) {<br>        this.kafkaTemplate = kafkaTemplate;<br>    }<br><br>    public void sendMessage(String topic, String key, String data) {<br>        kafkaTemplate.executeInTransaction(kafkaTemplate -&gt; {<br>            ProducerRecord&lt;String, String&gt; record = new ProducerRecord&lt;&gt;(topic, key, data);<br>            return kafkaTemplate.send(record);<br>        });<br>    }<br>}</pre><p>Bu örnekte, KafkaTemplate&#39;in transactional özelliklerini kullanıyoruz. İlk olarak, ProducerFactory&#39;yi transactional producer için yapılandırıyoruz. Daha sonra executeInTransaction metodunu kullanarak bir işlem başlatıyoruz, bir ProducerRecord gönderiyoruz ve işlemi tamamlıyoruz (commit).</p><p>Bu kod örneği, “Exactly Once” semantiğini sağlar, çünkü bir mesaj yalnızca işlem başarıyla tamamlandığında Kafka’ya commit edilir. Eğer bir hata oluşursa, işlem geri alınır ve mesaj tekrar gönderilir. Bu sayede, her mesaj tam olarak bir kez işlenmiş olur.</p><p>Daha ayrıntılı bir örnek için Kafka’nın idempotent ve transactional özelliklerini birleştirebiliriz.</p><p>Aşağıdaki örnekte, bir Kafka işlemi başlatılıyor, birkaç mesaj gönderiliyor ve işlem sonlandırılıyor. Eğer herhangi bir hata oluşursa, işlem geri alınıyor (rollback) ve mesajlar tekrar gönderiliyor.</p><pre>@Configuration<br>public class KafkaProducerConfig {<br>    <br>    @Value(&quot;${kafka.bootstrap-servers}&quot;)<br>    private String bootstrapServers;<br><br>    @Bean<br>    public Map&lt;String, Object&gt; producerConfigs() {<br>        Map&lt;String, Object&gt; props = new HashMap&lt;&gt;();<br>        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);<br>        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);<br>        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);<br>        props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true);<br>        props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, &quot;transac_prod_1&quot;);<br>        return props;<br>    }<br><br>    @Bean<br>    public ProducerFactory&lt;String, String&gt; producerFactory() {<br>        return new DefaultKafkaProducerFactory&lt;&gt;(producerConfigs());<br>    }<br><br>    @Bean<br>    public KafkaTemplate&lt;String, String&gt; kafkaTemplate() {<br>        return new KafkaTemplate&lt;&gt;(producerFactory());<br>    }<br>}<br><br>@Service<br>public class KafkaSender {<br>    <br>    @Autowired<br>    private KafkaTemplate&lt;String, String&gt; kafkaTemplate;<br><br>    public ListenableFuture&lt;SendResult&lt;String, String&gt;&gt; sendMessage(String topic, String key, String data) {<br>        return kafkaTemplate.send(topic, key, data);<br>    }<br><br>    public void sendMessagesTransactional(String topic, List&lt;KeyValue&lt;String, String&gt;&gt; messages) {<br>        kafkaTemplate.executeInTransaction(kafkaTemplate -&gt; {<br>            messages.forEach(kv -&gt; kafkaTemplate.send(topic, kv.key, kv.value));<br>            return null;<br>        });<br>    }<br>}</pre><p>Bu kodda KafkaProducerConfig sınıfı, Kafka producer&#39;ı için yapılandırmaları sağlar. Kafka producer&#39;ı, idempotence&#39;ı ve transactional özelliği aktif hale getirerek ENABLE_IDEMPOTENCE_CONFIG ve TRANSACTIONAL_ID_CONFIG ayarlarıyla birlikte oluşturulur.</p><p>KafkaSender sınıfı, mesajları göndermek için kullanılır. Tek bir mesajı göndermek için sendMessage fonksiyonu ve birden çok mesajı transactional olarak göndermek için sendMessagesTransactional fonksiyonu bulunur.</p><p>sendMessagesTransactional içerisinde, executeInTransaction fonksiyonu ile bir transaction başlatılır. Bu transaction içerisinde, liste halindeki tüm mesajlar gönderilir. Eğer transaction sırasında herhangi bir hata oluşursa, Kafka transaction&#39;ı rollback eder ve mesajlar işlenmez. Bu durumda, aynı mesajlar tekrar gönderilir.</p><p>Bu uygulama, “Exactly Once” semantiğini uygulayan daha karmaşık bir örnektir. Bu senaryoda, bir grup mesajın tam olarak bir kez işlenmesini garanti etmek için Kafka’nın transactional özellikleri kullanılır.</p><p>Apache Kafka’da “Exactly Once” (Tam Bir Kez) semantiği sağlamak için işlem API’si hem producer tarafında hem de consumer tarafında kullanılmalıdır. Consumer tarafında, KafkaListener&#39;ın transactional olarak kullanılması gerekmektedir.</p><p>Aşağıda, Kafka consumer için Spring Boot ile bir yapılandırma örneği bulunmaktadır:</p><pre>@Configuration<br>public class KafkaConsumerConfig {<br><br>    @Value(&quot;${kafka.bootstrap-servers}&quot;)<br>    private String bootstrapServers;<br><br>    @Value(&quot;${kafka.group-id}&quot;)<br>    private String groupId;<br><br>    @Bean<br>    public Map&lt;String, Object&gt; consumerConfigs() {<br>        Map&lt;String, Object&gt; props = new HashMap&lt;&gt;();<br>        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);<br>        props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);<br>        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);<br>        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);<br>        props.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG, &quot;read_committed&quot;);<br>        return props;<br>    }<br><br>    @Bean<br>    public ConcurrentKafkaListenerContainerFactory&lt;String, String&gt; kafkaListenerContainerFactory(ConsumerFactory&lt;String, String&gt; consumerFactory) {<br>        ConcurrentKafkaListenerContainerFactory&lt;String, String&gt; factory = new ConcurrentKafkaListenerContainerFactory&lt;&gt;();<br>        factory.setConsumerFactory(consumerFactory);<br>        factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.RECORD);<br>        factory.setConcurrency(3);<br>        factory.getContainerProperties().setTransactionManager(kafkaTransactionManager());<br>        return factory;<br>    }<br><br>    @Bean<br>    public KafkaTransactionManager&lt;String, String&gt; kafkaTransactionManager() {<br>        KafkaTransactionManager&lt;String, String&gt; ktm = new KafkaTransactionManager&lt;&gt;(producerFactory());<br>        ktm.setTransactionSynchronization(AbstractPlatformTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);<br>        return ktm;<br>    }<br>}</pre><p>Bu yapılandırmada, consumer özelliklerine “read_committed” (commit edilenleri oku) seçeneği eklenmiştir. Bu, consumer’ın yalnızca commit edilmiş transaction’lardaki mesajları okuyacağı anlamına gelir.</p><p>kafkaListenerContainerFactory bean&#39;inde, transaction manager olarak kafkaTransactionManager atanır. Bu, Kafka consumer&#39;ın işlem içerisinde çalışmasını sağlar.</p><p>Aşağıda bir @KafkaListener anotasyonu ile transactional bir Kafka consumer örneği bulunmaktadır:</p><pre>@Service<br>public class KafkaReceiver {<br><br>    @Autowired<br>    private KafkaTemplate&lt;String, String&gt; kafkaTemplate;<br><br>    @KafkaListener(topics = &quot;${kafka.topic}&quot;)<br>    @Transactional<br>    public void receive(String payload) {<br>        // handle message here<br>    }<br>}</pre><p>Bu kodda, receive metodu @Transactional anotasyonu ile işaretlenmiştir. Bu, Kafka consumer&#39;ın transaction içerisinde çalışacağını belirtir. Eğer işleme sırasında herhangi bir hata oluşursa, Spring transaction yöneticisi (transaction manager), işlemi geri alır ve offset commit edilmez. Bu durumda, aynı mesaj bir sonraki poll&#39;de tekrar işlenir.</p><p>Böylece, hem Kafka producer hem de consumer’ın transactional olması ve “Exactly Once” semantiği sağlanmış olur.</p><p>Bir sonraki yazımızda görüşmek üzere…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3ac5558a210" width="1" height="1" alt=""><hr><p><a href="https://medium.com/akbank-teknoloji/spring-boot-ile-apache-kafkada-mesaj-i%CC%87letim-semantikleri-at-most-once-at-least-once-exactly-b3ac5558a210">Spring Boot ile Apache Kafka’da Mesaj İletim Semantikleri ; At Most Once, At Least Once, Exactly…</a> was originally published in <a href="https://medium.com/akbank-teknoloji">Akbank Teknoloji</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Framework’de Transaction Yönetimi ve İzolasyon Seviyeleri]]></title>
            <link>https://medium.com/akbank-teknoloji/spring-transactionsa-genel-bak%C4%B1%C5%9F-a576ba18dab4?source=rss-c7f310c37748------2</link>
            <guid isPermaLink="false">https://medium.com/p/a576ba18dab4</guid>
            <dc:creator><![CDATA[Ziya Orujaliyev]]></dc:creator>
            <pubDate>Tue, 06 Jun 2023 12:04:52 GMT</pubDate>
            <atom:updated>2023-06-06T12:07:04.264Z</atom:updated>
            <content:encoded><![CDATA[<h3>Spring Transactions’a Genel Bakış</h3><p>Bu yazıda, @Transactional’ın yayılım (Propagation) özelliğini ayrıntılı bir şekilde ele alacağız. Ardından izolasyon düzeyleri (Isolation levels) hakkında bilgi sahibi olacağız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J8ALs1KDR5HkHS-z58gTQg.jpeg" /></figure><p>Spring Framework, Java tabanlı bir yazılım geliştirme platformudur. Geliştiricilere geniş bir araç ve kütüphane seti sunarak uygulama geliştirmeyi kolaylaştırır. Spring, hafif ve esnek yapısıyla ölçeklenebilir, test edilebilir ve sürdürülebilir uygulamalar oluşturmak için kullanılır.</p><p>Spring Framework’de @Transactional anotasyonu, Java’da transaction’ların yönetimini kolaylaştırmak için kullanılır. @Transactional anotasyonu, transaction’ın başlangıcı ve bitişi arasındaki bir transaction sürecini tanımlar ve transaction ile ilgili belirli özellikleri belirtir. Bu özellikler genellikle transaction’ın yayılması (Propagation) ve izolasyon (Isolation) seviyesiyle ilgilidir.</p><h4><strong>1. @Transactional nedir?</strong></h4><p>Transaction’lar, bir grup operasyonun birlikte çalıştığı süreci temsil eder. Bu grup operasyonlar, ya hep birlikte tamamlanır (Commit) ya da başarısız (Rollback) olurlar.</p><p>Örneğin, bir bankacılık uygulamasında bir hesaptan diğerine para transferi gerçekleştiğinde, bu bir transaction olarak kabul edilir. Bu transaction, para çekme ve para yatırma operasyonlarından oluşur. Bu iki operasyon ya birlikte başarılı olmalı ya da başarısız olmalıdır. Çünkü sadece birinin gerçekleşmesi (Para çekme ama yatırmama veya tam tersi) veri bütünlüğünü bozar ve hatalı bir duruma yol açar.</p><p>@Transactional anotasyonu bu süreci yönetmeye yardımcı olur. Anotasyon, bir metodun veya sınıfın transaction sınırlarını belirler. Transaction, anotasyonla belirtilen metoda girildiğinde başlar ve metottan çıkıldığında sona erer.</p><p>Ayrıca, @Transactional anotasyonu, belirli transaction özelliklerini de belirtir. Bu özellikler genellikle transaction’ın yayılımı (Propagation — başka bir işlemde nasıl davranacağı) ve izolasyonu (Isolation — işlemler arasındaki görünürlük) ile ilgilidir.</p><p>İşte basit bir @Transactional anotasyonunun kullanımı:</p><pre>@Service<br>public class BankService {<br>    @Autowired<br>    private BankRepository bankRepository;<br><br>    @Transactional<br>    public void transfer(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        Account fromAccount = bankRepository.findById(fromAccountId);<br>        fromAccount.setBalance(fromAccount.getBalance().subtract(amount));<br><br>        Account toAccount = bankRepository.findById(toAccountId);<br>        toAccount.setBalance(toAccount.getBalance().add(amount));<br><br>        bankRepository.save(fromAccount);<br>        bankRepository.save(toAccount);<br>    }<br>}</pre><p>Bu örnekte, transfer metodunun başında bir transaction başlar ve metottan çıkıldığında transaction sona erer. Eğer herhangi bir hata oluşursa (Örneğin, bakiye yetersizse), Spring otomatik olarak transaction’ı geri alır (Rollback). Bu, veri bütünlüğünü sağlar ve transaction atomikliğini (Tüm işlemin ya tamamen gerçekleşmesi ya da hiç gerçekleşmemesi) korur.</p><h4><strong>2. Transaction Yayılımı (Transaction Propagation)</strong></h4><p>Transaction Propagation, mevcut bir transaction bağlamında bir metot çağrıldığında ne olacağını belirler. Yani, bir transaction içerisinde başka bir transaction çağrıldığında bu yeni transaction’ın ne yapacağına karar verir. Spring, çeşitli transaction propagation stratejileri sunar ve bu stratejileri @Transactional anotasyonunun propagation parametresi ile belirlenir.</p><p>İşte Spring tarafından sunulan propogation stratejileri:</p><h4><strong>2.1 PROPAGATION_REQUIRED</strong></h4><p>Bu, varsayılan propagation stratejisi olup mevcut bir transaction’ı kullanır. Eğer mevcut bir transaction yoksa, yeni bir transaction oluşturur.</p><p>Spring Framework’teki en sık kullanılan propogation türüdür ve varsayılan değerdir. Bu tür, çağrılan metoda mevcut bir transaction’ı kullanmasını veya mevcut bir transaction yoksa yeni bir transaction oluşturmasını söyler.</p><p>Bir bankacılık uygulamasında para transferini düşünün. Transfer transaction’ı, para çekme ve para yatırma transaction’larını içerir. Her iki transaction da başarılı olmalıdır, yoksa tüm işlem geri alınmalıdır (Rollback).</p><p>Bu durumda, her bir metodu @Transactional anotasyonuyla işaretleyebilir, propagation = Propagation.REQUIRED kullanabiliriz. Bu, her bir metodun mevcut bir transaction’ı kullanmasını veya mevcut bir transaction yoksa yeni bir transaction oluşturmasını sağlar.</p><pre>@Service<br>public class BankService {<br>    @Autowired<br>    private BankRepository bankRepository;<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void transfer(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        debit(fromAccountId, amount);<br>        credit(toAccountId, amount);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void debit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().subtract(amount));<br>        bankRepository.save(account);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void credit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().add(amount));<br>        bankRepository.save(account);<br>    }<br>}</pre><p>Bu durumda, transfer metodu çağrıldığında yeni bir transaction başlar. Bu transaction, debit ve credit metotları tarafından da kullanılır. Çünkü her iki metotta PROPAGATION_REQUIRED kullanılmıştır. Eğer herhangi bir hata oluşursa (Örneğin, bakiye yetersizse), Spring otomatik olarak transaction’ı geri alır (Rollback).</p><p>Bu şekilde, PROPAGATION_REQUIRED mevcut bir transaction’ı kullanır veya gerekirse yeni bir transaction oluşturur. Bu özellik, transaction’ların doğru bir şekilde yayılmasını ve bütünlüğünün korunmasını sağlar.</p><h4><strong>2.2 PROPAGATION_REQUIRES_NEW</strong></h4><p>Her zaman yeni bir transaction başlatmayı tercih eder. Mevcut bir transaction varsa, bu mevcut transaction askıya alınır ve yeni bir transaction başlatılır.</p><p>Bu durumu anlamak için, yine bankacılık örneğine bakalım. Ancak bu sefer, transfer işlemi sırasında banka tarafından belirli bir işlem ücreti de alındığını düşünelim. Bu işlem ücreti her zaman alınmalı, transfer işlemi başarısız olsa bile. İşte bu tür bir durumda PROPAGATION_REQUIRES_NEW kullanılır.</p><pre>@Service<br>public class BankService {<br>    @Autowired<br>    private BankRepository bankRepository;<br><br>    @Transactional(propagation = Propagation.REQUIRES_NEW)<br>    public void transferWithFee(Long fromAccountId, Long toAccountId, BigDecimal amount, BigDecimal fee) {<br>        try {<br>            transfer(fromAccountId, toAccountId, amount);<br>        } catch (Exception e) {<br>            // Transfer failed. Handle exception...<br>        }<br>        chargeFee(fromAccountId, fee);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void transfer(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        debit(fromAccountId, amount);<br>        credit(toAccountId, amount);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void debit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().subtract(amount));<br>        bankRepository.save(account);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void credit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().add(amount));<br>        bankRepository.save(account);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRES_NEW)<br>    public void chargeFee(Long accountId, BigDecimal fee) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().subtract(fee));<br>        bankRepository.save(account);<br>    }<br>}</pre><p>Bu örnekte, transferWithFee metodu, PROPAGATION_REQUIRES_NEW <br> kullanarak yeni bir transaction başlatır. Bu metot, transfer metodunu çağırır ki bu da kendi içinde bir transaction’dır (PROPAGATION_REQUIRED kullanır). transfer metodunun başarısız olması durumunda, chargeFee metodu çalışmaya devam eder. Çünkü PROPAGATION_REQUIRES_NEW kullanarak kendi transaction’ını başlatmıştır. Yani chargeFee metodunun transaction’ı, transfer metodunun transaction’ından bağımsızdır.</p><p>Bu durumda, PROPAGATION_REQUIRES_NEW yeni bir transaction oluşturur ve bu çağıran transaction’dan bağımsız bir şekilde çalışır. Bu özellik, belirli durumlarda çok önemli olabilir. Özellikle de farklı transaction’ların birbirinden bağımsız olarak çalışması gerektiği durumlarda.</p><h4><strong>2.3 PROPAGATION_SUPPORTS</strong></h4><p>Mevcut bir transaction içerisinde çalışmayı tercih eder. Eğer mevcut bir transaction yoksa, transaction olmadan devam eder. Bu durum, transaction gerekmeyen durumlarda veya işlem maliyetini düşürmek için transaction kullanmayı tercih etmeyen durumlarda kullanılır.</p><p>Örneğin, bankacılık uygulamamızda, bir hesap bakiyesini kontrol etmek isteyebiliriz. Bu operasyon, transaction gerektirmeyebilir çünkü veriyi değiştirmez, sadece okur. Bu durumda, PROPAGATION_SUPPORTS kullanabiliriz.</p><pre>@Service<br>public class BankService {<br>    @Autowired<br>    private BankRepository bankRepository;<br><br>    @Transactional(propagation = Propagation.REQUIRES_NEW)<br>    public void transfer(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        debit(fromAccountId, amount);<br>        credit(toAccountId, amount);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void debit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().subtract(amount));<br>        bankRepository.save(account);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void credit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().add(amount));<br>        bankRepository.save(account);<br>    }<br><br>    @Transactional(propagation = Propagation.SUPPORTS)<br>    public BigDecimal checkBalance(Long accountId) {<br>        Account account = bankRepository.findById(accountId);<br>        return account.getBalance();<br>    }<br>}</pre><p>Bu örnekte, checkBalance metodu PROPAGATION_SUPPORTS kullanır. Bu metot, eğer mevcut bir transaction varsa, bu transaction içerisinde çalışır. Ancak, mevcut bir transaction yoksa, transaction olmadan da çalışabilir. Bu durum, özellikle okuma gibi transaction gerektirmeyen işlemler için kullanışlıdır.</p><p>Bu durumda, PROPAGATION_SUPPORTS mevcut bir transaction içerisinde çalışmayı tercih eder, ancak transaction olmadan da çalışabilir. Bu özellik, işlem maliyetini düşürmek için veya transaction gerektirmeyen işlemler için kullanışlıdır.</p><h4><strong>2.4 PROPAGATION_NOT_SUPPORTED</strong></h4><p>Transaction olmadan devam etmeyi tercih eder. Eğer mevcut bir transaction varsa, bu mevcut transaction askıya alınır ve metodun çalıştığı süre boyunca transaction olmadan devam edilir.</p><p>Örneğin, bankacılık uygulamamızda, belirli bir hesabın işlem geçmişini log’lamak isteyebiliriz. Bu operasyon, transaction gerektirmeyebilir; çünkü işlem geçmişi her durumda log’lanmalıdır ve bu işlem mevcut transaction’ı etkilememelidir. Bu durumda, PROPAGATION_NOT_SUPPORTED kullanabiliriz.</p><pre>@Service<br>public class BankService {<br>    @Autowired<br>    private BankRepository bankRepository;<br><br>    @Autowired<br>    private LogRepository logRepository;<br><br>    @Transactional(propagation = Propagation.REQUIRES_NEW)<br>    public void transfer(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        debit(fromAccountId, amount);<br>        credit(toAccountId, amount);<br>        logTransaction(fromAccountId, toAccountId, amount);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void debit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().subtract(amount));<br>        bankRepository.save(account);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void credit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().add(amount));<br>        bankRepository.save(account);<br>    }<br><br>    @Transactional(propagation = Propagation.NOT_SUPPORTED)<br>    public void logTransaction(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        Log log = new Log();<br>        log.setFromAccountId(fromAccountId);<br>        log.setToAccountId(toAccountId);<br>        log.setAmount(amount);<br>        logRepository.save(log);<br>    }<br>}</pre><p>Bu örnekte, logTransaction metodu PROPAGATION_NOT_SUPPORTED kullanır. Bu metot, mevcut bir transaction varsa, bu transaction’ı askıya alır ve transaction olmadan devam eder. Bu durum, özellikle okuma gibi transaction gerektirmeyen işlemler veya mevcut transaction’ı etkilememesi gereken işlemler için kullanışlıdır.</p><p>Sonuç olarak, PROPAGATION_NOT_SUPPORTED mevcut bir transaction varsa bu transaction’ı askıya alır ve transaction olmadan devam eder.</p><h4><strong>2.5 PROPAGATION_NEVER</strong></h4><p>Transaction olmadan devam etmeyi tercih eder. Eğer mevcut bir transaction varsa, bu bir hata durumu oluşturur ve metot çalışmayı durdurur.</p><p>Örneğin, bankacılık uygulamamızda, bir hesabın işlem geçmişini log’lamak isteyebiliriz. Bu operasyon, transaction gerektirmeyebilir; çünkü işlem geçmişi her durumda log’lanmalıdır ve bu işlem mevcut transaction’ı etkilememelidir. Ancak bu sefer, bu işlemi yalnızca mevcut bir transaction yokken gerçekleştirmek istiyoruz. Bu durumda, PROPAGATION_NEVER kullanabiliriz.</p><pre>@Service<br>public class BankService {<br>    @Autowired<br>    private BankRepository bankRepository;<br><br>    @Autowired<br>    private LogRepository logRepository;<br><br>    @Transactional(propagation = Propagation.REQUIRES_NEW)<br>    public void transfer(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        debit(fromAccountId, amount);<br>        credit(toAccountId, amount);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void debit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().subtract(amount));<br>        bankRepository.save(account);<br>        logTransaction(fromAccountId, toAccountId, amount);<br>    }<br><br>    @Transactional(propagation = Propagation.REQUIRED)<br>    public void credit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().add(amount));<br>        bankRepository.save(account);<br>    }<br><br>    @Transactional(propagation = Propagation.NEVER)<br>    public void logTransaction(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        Log log = new Log();<br>        log.setFromAccountId(fromAccountId);<br>        log.setToAccountId(toAccountId);<br>        log.setAmount(amount);<br>        logRepository.save(log);<br>    }<br>}</pre><p>Bu örnekte, logTransaction metodu PROPAGATION_NEVER kullanır. Bu metot, mevcut bir transaction varsa, hata oluşturur ve transaction olmadan devam etmeyi tercih eder. Bu durum, özellikle okuma gibi transaction gerektirmeyen işlemler veya mevcut bir transaction olmadan çalışması gereken işlemler için kullanışlıdır.</p><p>Bu durumda, PROPAGATION_NEVER mevcut bir transaction varsa hata oluşturur ve transaction olmadan devam eder. Bu özellik, transaction’ın kesinlikle gerekli olmadığı veya mevcut bir transaction olmaması gerektiği durumlar için kullanışlıdır.</p><h4><strong>2.6 PROPAGATION_MANDATORY</strong></h4><p>Yalnızca mevcut bir transaction varsa devam etmeyi tercih eder. Eğer mevcut bir transaction yoksa, bu bir hata durumu oluşturur ve metot çalışmayı durdurur.</p><p>Örneğin, bankacılık uygulamamızda, bir hesaptan başka bir hesaba para transfer etmek isteyebiliriz. Bu operasyon, bir transaction gerektirir; çünkü iki ayrı işlemi (Para çekme ve para yatırma) bir arada gerçekleştirmemiz gerekiyor. Eğer bu işlemlerden biri başarısız olursa, diğerinin de iptal edilmesi gerekiyor. Bu durumda, PROPAGATION_MANDATORY kullanabiliriz.</p><pre>@Service<br>public class BankService {<br>    @Autowired<br>    private BankRepository bankRepository;<br><br>    @Transactional(propagation = Propagation.REQUIRES_NEW)<br>    public void transfer(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        debit(fromAccountId, amount);<br>        credit(toAccountId, amount);<br>    }<br><br>    @Transactional(propagation = Propagation.MANDATORY)<br>    public void debit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().subtract(amount));<br>        bankRepository.save(account);<br>    }<br><br>    @Transactional(propagation = Propagation.MANDATORY)<br>    public void credit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().add(amount));<br>        bankRepository.save(account);<br>    }<br>}</pre><p>Bu örnekte, debit ve credit metodları PROPAGATION_MANDATORY kullanır. Bu metotlar, yalnızca mevcut bir transaction varsa çalışır. Eğer mevcut bir transaction yoksa, hata oluştururlar ve çalışmayı durdururlar. Bu durum, bir transaction gerektiren işlemler için kullanışlıdır.</p><p>Bu durumda, PROPAGATION_MANDATORY yalnızca mevcut bir transaction varsa çalışır ve eğer mevcut bir transaction yoksa hata oluşturur. Bu özellik, bir transaction gerektiren ve mevcut bir transaction’ın mutlaka olması gereken durumlar için kullanışlıdır.</p><h4><strong>2.7 PROPAGATION_NESTED</strong></h4><p>Yeni bir transaction’ın mevcut bir transaction’ın içine yerleştirilmesini tercih eder, yani nested (İç içe) bir transaction oluşturulur. Eğer mevcut bir transaction yoksa, bu PROPAGATION_REQUIRED stratejisi gibi çalışır ve yeni bir transaction oluşturur.</p><p>Nested transaction’lar, her bir alt işlemin (Nested transaction) kendi içinde başarıyla tamamlanmasını veya başarısız olması durumunda, üst transaction’ın kendi işlemlerine devam edebilmesini sağlar. Bu, mevcut transaction’ın bir kısmının başarısız olması durumunda bile, başarılı olan kısmın geri alınmaması için kullanışlıdır.</p><p>Örneğin, bankacılık uygulamamızda, bir hesaptan başka bir hesaba para transfer etmek isteyebiliriz. Bu operasyon, bir transaction gerektirir çünkü iki ayrı işlemi (Para çekme ve para yatırma) bir arada gerçekleştirmemiz gerekiyor. Ancak, para çekme işlemi başarısız olursa, para yatırma işleminin geri alınmasını istemeyebiliriz. Bu durumda, PROPAGATION_NESTED kullanabiliriz.</p><pre>@Service<br>public class BankService {<br>    @Autowired<br>    private BankRepository bankRepository;<br><br>    @Transactional(propagation = Propagation.REQUIRES_NEW)<br>    public void transfer(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        debit(fromAccountId, amount);<br>        credit(toAccountId, amount);<br>    }<br><br>    @Transactional(propagation = Propagation.NESTED)<br>    public void debit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().subtract(amount));<br>        bankRepository.save(account);<br>    }<br><br>    @Transactional(propagation = Propagation.NESTED)<br>    public void credit(Long accountId, BigDecimal amount) {<br>        Account account = bankRepository.findById(accountId);<br>        account.setBalance(account.getBalance().add(amount));<br>        bankRepository.save(account);<br>    }<br>}</pre><p>Bu örnekte, debit ve credit metodları PROPAGATION_NESTED kullanır. Bu metotlar, mevcut bir transaction varsa, bu transaction’ın içine nested bir transaction oluşturur. Eğer mevcut bir transaction yoksa, yeni bir transaction oluştururlar. Bu durum, transaction’ın bir kısmının başarısız olması durumunda bile, başarılı olan kısmının geri alınmamasını istediğimiz durumlar için kullanışlıdır.</p><p>Bu durumda, PROPAGATION_NESTED mevcut bir transaction varsa, bu transaction’ın içine yeni bir transaction oluşturur. Eğer mevcut bir transaction yoksa, yeni bir transaction oluşturur. Bu özellik, transaction’ın bir kısmının başarısız olması durumunda bile, başarılı olan kısmının geri alınmamasını istediğimiz durumlar için kullanışlıdır. Ancak, nested transaction’ları desteklemek için transaction manager’ın bu özelliği desteklemesi gerekmektedir.</p><h4><strong>3. Transaction İzolasyonu (Transaction Isolation)</strong></h4><p>Veritabanı transaction’ları ile ilgili olarak, izolasyon (Isolation), farklı transaction’ların birbirinden ne kadar “izole” olduğunu belirtir. Bu, birden çok transaction’ın aynı veriye erişimini ve onu değiştirmesini kontrol eder.</p><p>Veritabanı izolasyon seviyeleri, farklı transaction’ların birbirleriyle nasıl etkileşime girebileceğini belirler. Dört temel izolasyon seviyesi vardır:</p><p>1. <em>Read Uncommitted:</em> Bu izolasyon seviyesi, en düşük izolasyon seviyesidir. Bir transaction, diğer transaction’ların henüz commit edilmemiş (Tamamlanmamış) verilerini okuyabilir. Bu, “dirty reads” denilen duruma izin verir; yani bir transaction’ın tamamlanmamış bir başka transaction’ın sonuçlarını görebilmesi.</p><p>2. <em>Read Committed:</em> Bu izolasyon seviyesi, bir transaction’ın yalnızca tamamlanmış (Commit edilmiş) diğer transaction’ların verilerini okumasına izin verir. Bu, “dirty reads” durumunu engeller.</p><p>3. <em>Repeatable Read: </em>Bu izolasyon seviyesi, bir transaction içerisindeki birden çok okuma işleminin, her seferinde aynı verileri getireceğini garanti eder. Başka bir deyişle, bir transaction sırasında okunan veri, transaction süresince başka hiçbir transaction tarafından değiştirilemez.</p><p>4. <em>Serializable</em>: Bu, en yüksek izolasyon seviyesidir ve transaction’ların tamamen izole olduğunu belirtir. Bu seviye, bir transaction’ın tamamlanana kadar ilgili veri üzerinde kilit (Lock) uygulanacağı anlamına gelir.</p><p>Bu izolasyon seviyeleri, transaction’ların veri bütünlüğünü korurken veritabanı performansını ve çok kullanıcılı erişimi dengeler. Spring @Transactional anotasyonu, isolation özelliği kullanılarak bir transaction için izolasyon seviyesini belirlememize olanak sağlar.</p><h4><strong>4. Spring’de Izolasyon Yönetimi (Isolation Management in Spring)</strong></h4><p>Spring Framework’te, varsayılan izolasyon seviyesi DEFAULT olarak ayarlanmıştır. Spring bir yeni transaction oluşturduğunda, izolasyon seviyesi, kullandığınız ilişkisel veritabanı yönetim sisteminin (RDBMS) varsayılan izolasyon seviyesine göre belirlenir.</p><p>Veritabanınızın varsayılan izolasyon seviyesini bilmek önemlidir; çünkü bu transaction’ların davranışını etkiler. Farklı veritabanları farklı varsayılan izolasyon seviyelerine sahip olabilir. Bu yüzden veritabanınızı değiştirirseniz varsayılan izolasyon seviyesi de değişebilir.</p><p>Farklı izolasyon seviyelerine sahip bir metot zinciri çağırdığımızda, izolasyon seviyesi genellikle yalnızca yeni bir transaction oluşturulduğunda uygulanır. Bu, zincirdeki her metodun mevcut transaction’ın izolasyon seviyesini devralacağı anlamına gelir. Ancak bir metot içinde açıkça yeni bir transaction başlatılmadığı sürece.</p><p>Eğer metot zinciri boyunca tutarlı bir izolasyon seviyesi sağlamak isterseniz, mevcut transaction’ın izolasyon seviyesine bakılmaksızın, her metodun aynı izolasyon seviyesinde çalışmasını sağlamak için TransactionManager::setValidateExistingTransaction değerini true olarak ayarlayabilirsiniz. Bu, zincirdeki herhangi bir metodun farklı bir izolasyon seviyesiyle çalışmasını engeller ve istenmeyen durumlara karşı güvence sağlar.</p><p>İşte TransactionManager’ın setValidateExistingTransaction özelliğini etkinleştiren bir yapılandırma örneği:</p><pre>@Configuration<br>@EnableTransactionManagement<br>public class TransactionConfig {<br><br>    @Autowired<br>    private PlatformTransactionManager transactionManager;<br><br>    @PostConstruct<br>    public void configureTransactionManager() {<br>        ((AbstractPlatformTransactionManager) transactionManager).setValidateExistingTransaction(true);<br>    }<br>}</pre><p>Bu yapılandırmayı gerçekleştirerek, zincirdeki herhangi bir metodun farklı bir izolasyon seviyesiyle çalışmasını engellemiş olursunuz ve tutarlı bir izolasyon sağlarsınız.</p><h4><strong>4.1 READ_UNCOMMITTED İzolasyonu</strong></h4><p>Bu izolasyon seviyesi, en düşük seviyedir ve en çok hata durumuna (Dirty read, non-repeatable read, phantom read) izin verir. Bir transaction, diğer transaction’lar tarafından henüz commit edilmemiş verileri okuyabilir.</p><p>Spring Framework’te bir transaction’ı ISOLATION_READ_UNCOMMITTED izolasyon seviyesinde başlatmak için aşağıdaki gibi @Transactional anotasyonunu kullanabilirsiniz:</p><pre>import org.springframework.transaction.annotation.Transactional;<br>import org.springframework.transaction.annotation.Isolation;<br><br>...<br><br>@Service<br>public class BankService {<br>    <br>    private final BankAccountRepository bankAccountRepository;<br>    <br>    public BankService(BankAccountRepository bankAccountRepository) {<br>        this.bankAccountRepository = bankAccountRepository;<br>    }<br><br>    @Transactional(isolation = Isolation.READ_UNCOMMITTED)<br>    public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        BankAccount fromAccount = bankAccountRepository.findById(fromAccountId).orElseThrow(() -&gt; new RuntimeException(&quot;Account not found&quot;));<br>        BankAccount toAccount = bankAccountRepository.findById(toAccountId).orElseThrow(() -&gt; new RuntimeException(&quot;Account not found&quot;));<br><br>        fromAccount.setBalance(fromAccount.getBalance().subtract(amount));<br>        toAccount.setBalance(toAccount.getBalance().add(amount));<br><br>        bankAccountRepository.save(fromAccount);<br>        bankAccountRepository.save(toAccount);<br>    }<br>}</pre><p>Bu örnekte, transferMoney() metodu her çağrıldığında, Spring Framework READ_UNCOMMITTED izolasyon seviyesinde yeni bir transaction başlatır. Bu, mevcut transaction sırasında, fromAccount veya toAccount tarafından yapılan ve henüz commit edilmemiş değişikliklerin diğer transaction’lar tarafından okunabileceği anlamına gelir.</p><p>Yine de READ_UNCOMMITTED izolasyon seviyesini kullanmanın riskli olabileceğini unutmayın. Genellikle bu izolasyon seviyesi, performansın tutarlılıktan daha önemli olduğu belirli senaryolar dışında kullanılmamalıdır. Bu tür senaryolar genellikle ender görülür ve genelde daha yüksek bir izolasyon seviyesi kullanmak daha iyidir.</p><h4><strong>4.2 READ_COMMITTED İzolasyonu</strong></h4><p>Bir transaction’ın sadece commit edilmiş verileri okumasına izin verir. Bu, bir transaction’ın başka bir transaction tarafından henüz commit edilmemiş verileri okuyamayacağı anlamına gelir. Bu, genellikle bir veritabanındaki tutarsızlıkları önlemek için kullanılır.</p><p>Spring Framework’te bir işlemi ISOLATION_READ_COMMITTED izolasyon seviyesinde başlatmak için aşağıdaki gibi @Transactional anotasyonunu kullanabilirsiniz:</p><pre>import org.springframework.transaction.annotation.Transactional;<br>import org.springframework.transaction.annotation.Isolation;<br><br>...<br><br>@Service<br>public class BankService {<br>    <br>    private final BankAccountRepository bankAccountRepository;<br>    <br>    public BankService(BankAccountRepository bankAccountRepository) {<br>        this.bankAccountRepository = bankAccountRepository;<br>    }<br><br>    @Transactional(isolation = Isolation.READ_COMMITTED)<br>    public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        BankAccount fromAccount = bankAccountRepository.findById(fromAccountId).orElseThrow(() -&gt; new RuntimeException(&quot;Account not found&quot;));<br>        BankAccount toAccount = bankAccountRepository.findById(toAccountId).orElseThrow(() -&gt; new RuntimeException(&quot;Account not found&quot;));<br><br>        fromAccount.setBalance(fromAccount.getBalance().subtract(amount));<br>        toAccount.setBalance(toAccount.getBalance().add(amount));<br><br>        bankAccountRepository.save(fromAccount);<br>        bankAccountRepository.save(toAccount);<br>    }<br>}</pre><p>Bu örnekte, transferMoney() metodu her çağrıldığında, Spring Framework READ_COMMITTED izolasyon seviyesinde yeni bir transaction başlatır. Yani bu transaction, yalnızca diğer transaction’lar tarafından commit edilmiş verileri okuyabilir.</p><p>Bu şekilde, transferMoney() transaction’ı sırasında fromAccount veya toAccount’ta yapılan değişiklikler, bu transaction commit edilene kadar diğer transaction’lar tarafından görülmez. Bu, diğer transaction’ların “kirli” veri okumasını (Diğer bir deyişle, henüz commit edilmemiş veri) engeller ve genellikle veritabanı tutarsızlıklarını önlemeye yardımcı olur.</p><h4><strong>4.3 REPEATABLE_READ İzolasyonu</strong></h4><p>Bir transaction sırasında aynı verinin tekrar okunması durumunda, transaction süresince verinin değişmemesini garanti eder. Yani, bir transaction sırasında bir kayıt ilk okunduğu anda hangi değere sahipse, transaction süresince bu değer korunur ve diğer transaction’lar tarafından bu süreçte yapılan değişiklikler bu transaction tarafından görülmez.</p><p>Spring Framework’te REPEATABLE_READ izolasyon seviyesinde bir transaction başlatmak için @Transactional anotasyonunu kullanabilirsiniz:</p><pre>import org.springframework.transaction.annotation.Transactional;<br>import org.springframework.transaction.annotation.Isolation;<br><br>...<br><br>@Service<br>public class BankService {<br>    <br>    private final BankAccountRepository bankAccountRepository;<br>    <br>    public BankService(BankAccountRepository bankAccountRepository) {<br>        this.bankAccountRepository = bankAccountRepository;<br>    }<br><br>    @Transactional(isolation = Isolation.REPEATABLE_READ)<br>    public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        BankAccount fromAccount = bankAccountRepository.findById(fromAccountId).orElseThrow(() -&gt; new RuntimeException(&quot;Account not found&quot;));<br>        BankAccount toAccount = bankAccountRepository.findById(toAccountId).orElseThrow(() -&gt; new RuntimeException(&quot;Account not found&quot;));<br><br>        fromAccount.setBalance(fromAccount.getBalance().subtract(amount));<br>        toAccount.setBalance(toAccount.getBalance().add(amount));<br><br>        bankAccountRepository.save(fromAccount);<br>        bankAccountRepository.save(toAccount);<br>    }<br>}</pre><p>Bu örnekte, transferMoney() metodu her çağrıldığında, Spring Framework REPEATABLE_READ izolasyon seviyesinde yeni bir transaction başlatır. Yani bu transaction’da, aynı veriyi transaction süresince birden çok kez okuduğunuzda da verinin değeri her zaman aynı olacaktır. Bu değerler diğer transaction’lar tarafından transaction süresince değiştirilmiş olsa bile.</p><p>Ancak, unutmayın ki REPEATABLE_READ izolasyon seviyesi ‘phantom reads’ sorununu önlemez. ‘Phantom reads’, bir transaction sırasında aynı sorgunun iki kez çalıştırılması durumunda ekstra satırların görünebileceği bir durumdur. Bu tür bir durumu önlemek için genellikle SERIALIZABLE izolasyon seviyesi kullanılır.</p><h4><strong>4.4 SERIALIZABLE İzolasyonu</strong></h4><p>Veritabanındaki en yüksek izolasyon seviyesidir. Bu seviye, bir transaction sırasında herhangi bir kaynağın (Örneğin, bir tablonun tamamı) tamamen kilitlenmesine neden olabilir. Bu seviye, birden çok transaction’ın aynı kaynağı eşzamanlı olarak değiştirmeye çalışmasında meydana gelebilecek tüm sorunları (Kirli okuma, tekrarlanabilir okuma, phantom okuma) önler.</p><p>Spring Framework’te SERIALIZABLE izolasyon seviyesinde bir transaction başlatmak için @Transactional anotasyonunu kullanabilirsiniz:</p><pre>import org.springframework.transaction.annotation.Transactional;<br>import org.springframework.transaction.annotation.Isolation;<br><br>...<br><br>@Service<br>public class BankService {<br>    <br>    private final BankAccountRepository bankAccountRepository;<br>    <br>    public BankService(BankAccountRepository bankAccountRepository) {<br>        this.bankAccountRepository = bankAccountRepository;<br>    }<br><br>    @Transactional(isolation = Isolation.SERIALIZABLE)<br>    public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {<br>        BankAccount fromAccount = bankAccountRepository.findById(fromAccountId).orElseThrow(() -&gt; new RuntimeException(&quot;Account not found&quot;));<br>        BankAccount toAccount = bankAccountRepository.findById(toAccountId).orElseThrow(() -&gt; new RuntimeException(&quot;Account not found&quot;));<br><br>        fromAccount.setBalance(fromAccount.getBalance().subtract(amount));<br>        toAccount.setBalance(toAccount.getBalance().add(amount));<br><br>        bankAccountRepository.save(fromAccount);<br>        bankAccountRepository.save(toAccount);<br>    }<br>}</pre><p>Bu örnekte, transferMoney() metodu her çağrıldığında, Spring Framework SERIALIZABLE izolasyon seviyesinde yeni bir transaction başlatır. Bu seviye, bu transaction sırasında gerçekleşen tüm okumaların ve yazmaların tamamen izole edildiği anlamına gelir. Diğer transaction’lar, bu transaction commit edilene kadar fromAccount veya toAccount üzerindeki herhangi bir değişikliği göremezler.</p><p>Ancak, SERIALIZABLE izolasyon seviyesini kullanmanın performans üzerinde önemli bir etkisi olabilir; çünkü bir transaction’ın başka bir transaction’ın tamamlanmasını beklemesi gerekebilir. Bu, veritabanı kaynaklarının kullanımını sınırlar ve genellikle daha düşük bir izolasyon seviyesinin kullanılmasına neden olur. Ancak bu, uygulamanın gereksinimlerine ve veritabanının genel yüküne bağlıdır.</p><h4>Sonuç</h4><p>Propagation stratejileri ve izolasyon seviyeleri transaction yönetiminde önemli bir rol oynar ve işlemlerin doğru bir şekilde yapılmasını sağlar. Doğru propagation stratejisi seçimi, işlemlerin bütünlüğünün korunmasını ve beklenen sonuçların elde edilmesini sağlar.<br> <br> Bir sonraki yazımızda görüşmek üzere…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a576ba18dab4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/akbank-teknoloji/spring-transactionsa-genel-bak%C4%B1%C5%9F-a576ba18dab4">Spring Framework’de Transaction Yönetimi ve İzolasyon Seviyeleri</a> was originally published in <a href="https://medium.com/akbank-teknoloji">Akbank Teknoloji</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>