<?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 Nijat Aghayev on Medium]]></title>
        <description><![CDATA[Stories by Nijat Aghayev on Medium]]></description>
        <link>https://medium.com/@nicat.agayev.536?source=rss-8920c4b451da------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*kO-fsiMa8rFBqt75EUQCsw.jpeg</url>
            <title>Stories by Nijat Aghayev on Medium</title>
            <link>https://medium.com/@nicat.agayev.536?source=rss-8920c4b451da------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:52:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nicat.agayev.536/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[Spring AOP: Aspect-Oriented Programming Explained]]></title>
            <link>https://medium.com/@nicat.agayev.536/spring-aop-aspect-oriented-programming-explained-f91f8c9bd0d7?source=rss-8920c4b451da------2</link>
            <guid isPermaLink="false">https://medium.com/p/f91f8c9bd0d7</guid>
            <category><![CDATA[spring-aop]]></category>
            <dc:creator><![CDATA[Nijat Aghayev]]></dc:creator>
            <pubDate>Sat, 26 Sep 2026 18:33:34 GMT</pubDate>
            <atom:updated>2026-09-26T18:33:34.276Z</atom:updated>
            <content:encoded><![CDATA[<p>Spring Boot layihələrində bəzi funksionallıqlar var ki, demək olar ki, tətbiqin bütün hissələrində təkrarlanır.</p><p>Məsələn:</p><ul><li>Logging</li><li>Security</li><li>Transaction Management</li><li>Performance Monitoring</li><li>Auditing</li><li>Exception Handling</li></ul><p>Bunlar əsas biznes məntiqinin özü deyil, lakin müxtəlif servis və metodlarda davamlı olaraq istifadə olunur.</p><p>Əgər bu kodları hər metodun daxilində ayrıca yazsaq, nəticədə <strong>Code Duplication</strong>, <strong>Tight Coupling</strong> və daha çətin maintain olunan kod ortaya çıxır.</p><p>Məhz burada <strong>Spring AOP (Aspect-Oriented Programming)</strong> köməyə gəlir.</p><h3>AOP nədir?</h3><p><strong>Aspect-Oriented Programming</strong> proqramın müxtəlif hissələrində təkrarlanan <strong>Cross-Cutting Concerns</strong>-ləri əsas biznes məntiqindən ayırmağa imkan verən proqramlaşdırma yanaşmasıdır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJ_g2jSF7KDaAIvscrofnQ.png" /></figure><p>Məsələn, belə bir servis metodumuz olsun:</p><pre>public void transferMoney(Long from, Long to, BigDecimal amount) {<br><br>    // logging<br>    // security check<br>    // transaction handling<br>    // performance measurement<br>    // actual business logic<br>}</pre><p>Burada əsl biznes məntiqi yalnız pul köçürməkdir.</p><p>Digər funksionallıqlar isə metodun ətrafında tətbiq olunan əlavə davranışlardır.</p><p>AOP həmin davranışları ayrıca modul halına gətirməyə imkan verir:</p><pre>              Cross-Cutting Concerns<br>                         │<br>          ┌──────────────┼──────────────┐<br>          │              │              │<br>       Logging        Security      Monitoring<br>          │              │              │<br>          └──────────────┼──────────────┘<br>                         │<br>                         ▼<br>                  Business Logic</pre><h3>Cross-Cutting Concerns nədir?</h3><p><strong>Cross-Cutting Concern</strong> bir tətbiqin bir çox hissəsində lazım olan, lakin əsas biznes məntiqinə birbaşa aid olmayan funksionallıqdır.</p><p>Ən çox rast gəlinən nümunələr:</p><h3>Logging</h3><pre>Kim çağırdı?<br>Nə vaxt çağırdı?<br>Hansı metod çağırıldı?<br>Nəticə nə oldu?</pre><h3>Security</h3><pre>Bu istifadəçinin bu əməliyyatı etməyə icazəsi varmı?</pre><h3>Transaction Management</h3><pre>Transaction başlat<br>     ↓<br>Business Logic<br>     ↓<br>Success → Commit<br>Failure → Rollback</pre><h3>Performance Monitoring</h3><pre>Method başladı<br>     ↓<br>Business Logic<br>     ↓<br>Method bitdi</pre><pre>Execution Time: 127 ms</pre><p>Bütün bunları hər metodda təkrar yazmaq əvəzinə AOP vasitəsilə mərkəzləşdirmək mümkündür.</p><h3>Spring AOP necə işləyir?</h3><p>Spring AOP-un arxasındakı əsas ideyalardan biri <strong>Proxy Pattern</strong>-dir.</p><p>Spring bean üçün proxy yaradır və metod çağırışını əvvəlcə həmin proxy qarşılayır.</p><p>Sadələşdirilmiş şəkildə:</p><pre>Client<br>  │<br>  ▼<br>AOP Proxy<br>  │<br>  ├── Before Advice<br>  │<br>  ▼<br>Target Method<br>  │<br>  ├── AfterReturning / AfterThrowing<br>  │<br>  ▼<br>Client</pre><p>Məsələn:</p><pre>service.calculate();</pre><p>çağırışında əslində çağırış Spring tərəfindən yaradılmış proxy üzərindən keçə bilər:</p><pre>Client<br>  ↓<br>Proxy<br>  ↓<br>Aspect<br>  ↓<br>Real Service</pre><h3>Spring AOP-da 6 əsas termin</h3><p>Spring AOP-u başa düşmək üçün aşağıdakı terminləri yaxşı bilmək lazımdır.</p><h3>1. Aspect</h3><p><strong>Aspect</strong> müəyyən Cross-Cutting Concern-i özündə birləşdirən class-dır.</p><p>Məsələn:</p><pre>@Aspect<br>@Component<br>public class LoggingAspect {<br><br>}</pre><p>Burada LoggingAspect logging ilə bağlı davranışı mərkəzləşdirir.</p><h3>2. Join Point</h3><p><strong>Join Point</strong> AOP müdaxiləsinin tətbiq oluna biləcəyi icra nöqtəsidir.</p><p>Burada vacib məqam:</p><blockquote><em>Spring AOP-da Join Point praktik olaraq metod execution-dır. Məsələn:</em></blockquote><pre>public void createUser() {<br>}</pre><p>Bu metodun icrası Spring AOP üçün Join Point ola bilər.</p><h3>3. Advice</h3><p><strong>Advice</strong> Join Point zamanı icra ediləcək konkret davranışdır.</p><p>Spring AOP əsasən 5 Advice növü təqdim edir.</p><h3>@Before</h3><p>Metoddan əvvəl işləyir.</p><pre>@Before<br>   ↓<br>Method</pre><p>İstifadə:</p><ul><li>Logging</li><li>Authorization check</li><li>Validation</li></ul><h3>@After</h3><p>Metod tamamlandıqdan sonra işləyir.</p><p>Exception baş versə belə icra olunur.finally məntiqinə bənzəyir.</p><pre>Method<br>  ↓<br>@After</pre><h3>@AfterReturning</h3><p>Metod uğurla tamamlandıqdan sonra işləyir.</p><pre>Method<br>  ↓<br>Success<br>  ↓<br>@AfterReturning</pre><p>Məsələn, uğurlu əməliyyatı loglamaq üçün istifadə edilə bilər.</p><h3>@AfterThrowing</h3><p>Metod exception ilə tamamlandıqda işləyir.</p><pre>Method<br>  ↓<br>Exception<br>  ↓<br>@AfterThrowing</pre><p>Error logging və monitoring üçün faydalıdır.</p><h3>@Around</h3><p>Ən güclü Advice növüdür.</p><p>Metodun icrasını tamamilə əhatə edir.</p><pre>@Around<br>   │<br>   ├── Before<br>   │<br>   ├── Target Method<br>   │<br>   └── After</pre><p>ProceedingJoinPoint vasitəsilə əsas metodun icrasına nəzarət etmək mümkündür.</p><p>Məsələn:</p><pre>@Around(&quot;execution(* com.example.service.*.*(..))&quot;)<br>public Object measureExecutionTime(<br>        ProceedingJoinPoint joinPoint) throws Throwable {<br><br>long start = System.currentTimeMillis();<br>    Object result = joinPoint.proceed();<br>    long executionTime =<br>            System.currentTimeMillis() - start;<br>    log.info(<br>        &quot;{} executed in {} ms&quot;,<br>        joinPoint.getSignature().getName(),<br>        executionTime<br>    );<br>    return result;<br>}</pre><p>Burada:</p><pre>joinPoint.proceed();</pre><p>əsas target metodunu icra edir. Bu sətri çağırmasaq, metod ümumiyyətlə icra olunmaya bilər. Bu səbəbdən @Around digər Advice-lərə nisbətən daha çox nəzarət imkanı verir.</p><h3>4. Pointcut</h3><p><strong>Pointcut</strong> Advice-ın hansı metodlara tətbiq olunacağını müəyyən edən expression-dır. Məsələn:</p><pre>execution(* com.example.service.*.*(..))</pre><p>Bu expression təxminən belə oxunur:</p><pre>com.example.service<br>        ↓<br>bütün class-lar<br>        ↓<br>bütün metodlar<br>        ↓<br>istənilən parametr</pre><p>Pointcut expression-ları AOP-un ən vacib hissələrindən biridir.</p><h3>5. Target Object</h3><p><strong>Target Object</strong> AOP-un tətbiq edildiyi real biznes obyektidir. Məsələn:</p><pre>@Service<br>public class UserService {<br><br>    public User getUser(Long id) {<br>        ...<br>    }<br>}</pre><p>Burada UserService target object ola bilər.</p><h3>6. AOP Proxy</h3><p>Spring target bean-in ətrafında proxy yaradır.</p><p>Spring AOP əsasən iki mexanizmdən istifadə edə bilər:</p><ul><li><strong>JDK Dynamic Proxy</strong></li><li><strong>CGLIB</strong></li></ul><p>Sadələşdirilmiş şəkildə:</p><pre>             Spring Container<br>                    │<br>                    ▼<br>              AOP Proxy<br>                    │<br>                    ▼<br>              Target Bean</pre><p>JDK Dynamic Proxy interface-lər üzərindən işləyir. CGLIB isə class-ı subclass edərək proxy yarada bilir.</p><h3>Praktiki nümunə: Performance Monitoring</h3><p>İndi real bir PerformanceAspect yaradaq.</p><blockquote>Məqsədimiz: <em>Service metodunun neçə millisaniyəyə icra olunduğunu avtomatik loglamaq.</em></blockquote><h3>Addım 1 — Dependency</h3><p>pom.xml:</p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>    &lt;artifactId&gt;spring-boot-starter-aop&lt;/artifactId&gt;<br>&lt;/dependency&gt;</pre><p>Spring Boot bu dependency vasitəsilə AOP üçün lazımi komponentləri layihəyə əlavə edir.</p><h3>Addım 2 — PerformanceAspect</h3><pre>@Aspect<br>@Component<br>@Slf4j<br>public class PerformanceAspect {<br><br>    @Around(&quot;execution(* com.example.service.*.*(..))&quot;)<br>    public Object measureExecutionTime(<br>            ProceedingJoinPoint joinPoint) throws Throwable {<br>        long start = System.currentTimeMillis();<br>        Object result = joinPoint.proceed();<br>        long executionTime =<br>                System.currentTimeMillis() - start;<br>        log.info(<br>                &quot;Method {} executed in {} ms&quot;,<br>                joinPoint.getSignature().getName(),<br>                executionTime<br>        );<br>        return result;<br>    }<br>}</pre><p>Artıq com.example.service package-indəki metodlara əlavə kod yazmadan execution time ölçülür.</p><p>Məsələn:</p><pre>@Service<br>public class UserService {<br><br>    public UserDto getUser(Long id) {<br>        // business logic<br>        return ...;<br>    }<br>}<br></pre><p>Çağırış zamanı:</p><pre>Client<br>   ↓<br>AOP Proxy<br>   ↓<br>PerformanceAspect<br>   ↓<br>UserService.getUser()<br>   ↓<br>PerformanceAspect<br>   ↓<br>Response</pre><p>Log:</p><pre>Method getUser executed in 127 ms</pre><h3>Custom Annotation ilə AOP</h3><p>Bəzən bütün service metodlarını intercept etmək istəmirik. Məsələn, yalnız seçdiyimiz metodların execution time-ını ölçmək istəyirik. Bunun üçün <strong>Custom Annotation</strong> yarada bilərik.</p><h3>Addım 1 — Annotation yaratmaq</h3><pre>@Target(ElementType.METHOD)<br>@Retention(RetentionPolicy.RUNTIME)<br>public @interface LogExecutionTime {<br>}</pre><p>Burada:</p><ul><li>@Target(ElementType.METHOD) → annotation yalnız metodlarda istifadə edilə bilər.</li><li>@Retention(RetentionPolicy.RUNTIME) → annotation runtime zamanı əlçatan olur.</li></ul><h3>Addım 2 — Annotation-u Pointcut kimi istifadə etmək</h3><pre>@Aspect<br>@Component<br>@Slf4j<br>public class PerformanceAspect {<br><br>    @Around(&quot;@annotation(LogExecutionTime)&quot;)<br>    public Object measureExecutionTime(<br>            ProceedingJoinPoint joinPoint) throws Throwable {<br>        long start = System.currentTimeMillis();<br>        Object result = joinPoint.proceed();<br>        long executionTime =<br>                System.currentTimeMillis() - start;<br>        log.info(<br>                &quot;{} executed in {} ms&quot;,<br>                joinPoint.getSignature().getName(),<br>                executionTime<br>        );<br>        return result;<br>    }<br>}</pre><p>Artıq Pointcut bütün metodlara yox, yalnız @LogExecutionTime annotasiyası olan metodlara tətbiq olunur.</p><h3>Addım 3 — Biznes metodunda istifadə</h3><pre>@Service<br>public class ProductService {<br><br>    @LogExecutionTime<br>    public ProductDto getProduct(Long id) {<br>        // business logic<br>        return ...;<br>    }<br>}</pre><p>Beləliklə yalnız bu metod AOP tərəfindən intercept edilir. Bu yanaşma real layihələrdə çox rahatdır.</p><p>Məsələn:</p><pre>@LogExecutionTime<br>    ↓<br>Slow operation<br><br>@Audit<br>    ↓<br>Sensitive operation<br>@Cacheable<br>    ↓<br>Cacheable operation</pre><h3>Ən vacib problem: Self-Invocation</h3><p>Spring AOP-da ən çox soruşulan və müsahibələrdə tez-tez qarşıya çıxan mövzulardan biri <strong>Self-Invocation</strong>-dır. Təsəvvür edək:</p><pre>@Service<br>public class UserService {<br><br>public void methodA() {<br>        methodB();<br>    }<br>    @LogExecutionTime<br>    public void methodB() {<br>        // business logic<br>    }<br>}</pre><p>İlk baxışdan düşünə bilərik ki, methodB() AOP tərəfindən intercept olunacaq. Lakin bu halda:</p><pre>methodB();</pre><p>əslində:</p><pre>this.methodB();</pre><p>deməkdir. Yəni çağırış Spring Proxy-dən keçmir.</p><h3>Niyə AOP işləməyəcək?</h3><p>Spring AOP proxy əsaslı işləyir. Xaricdən:</p><pre>Client<br>  ↓<br>Proxy<br>  ↓<br>Aspect<br>  ↓<br>Target</pre><p>Amma target obyektin daxilindən:</p><pre>this.methodB();</pre><p>çağırıldıqda:</p><pre>Target<br>  │<br>  └── this.methodB()<br>          ↓<br>      Target method</pre><p>Proxy bypass edilir.</p><p>Nəticədə @LogExecutionTime, @Transactional, @Cacheable kimi proxy əsaslı Spring mexanizmləri gözlədiyiniz kimi tətbiq olunmaya bilər.</p><h3>Self-Invocation problemini necə həll etmək olar?</h3><p>Ən düzgün yanaşmalardan biri AOP tətbiq olunan metodu ayrıca bean-ə çıxarmaqdır.</p><p>Məsələn:</p><pre>UserService<br>     │<br>     ▼<br>UserCalculationService</pre><p>və çağırış:</p><pre>userCalculationService.methodB();</pre><p>şəklində başqa Spring bean üzərindən həyata keçirilir. Beləliklə çağırış proxy-dən keçə bilər.</p><p>Digər yanaşmalar mövcud olsa da, business logic-i düzgün bean-lərə bölmək adətən daha təmiz dizayndır.</p><h3>AOP və @Transactional arasındakı əlaqə</h3><p>Burada maraqlı bir məqam var.</p><p>Spring-də:</p><pre>@Transactional<br>public void transferMoney() {<br>    ...<br>}</pre><p>yazdığımız zaman transaction mexanizmi də proxy/interceptor infrastrukturu üzərindən tətbiq olunur.</p><p>Sadələşdirilmiş şəkildə:</p><pre>Client<br>   ↓<br>Spring Proxy<br>   ↓<br>Transaction Interceptor<br>   ↓<br>Target Method<br>   ↓<br>Commit / Rollback</pre><p>Bu səbəbdən @Transactional ilə bağlı <strong>self-invocation</strong> problemi də yarana bilər.</p><p>AOP-un işləmə mexanizmini başa düşmək @Transactional, @Cacheable, @Async və digər Spring annotation-larının davranışını anlamağı da asanlaşdırır.</p><h3>Spring AOP nə zaman istifadə edilməlidir?</h3><p>AOP xüsusilə aşağıdakı hallarda faydalıdır:</p><ul><li>Logging</li><li>Performance Monitoring</li><li>Auditing</li><li>Security checks</li><li>Transaction management</li><li>Metrics</li><li>Tracing</li></ul><p>Lakin bütün business logic-i AOP-a köçürmək düzgün yanaşma deyil.</p><p>AOP əsasən <strong>cross-cutting concern</strong> üçün istifadə edilməlidir.</p><h3>AOP-un əsas üstünlükləri</h3><h3>Separation of Concerns</h3><p>Cross-cutting logic business logic-dən ayrılır.</p><h3>Code Reusability</h3><p>Eyni logging və ya monitoring kodunu yüzlərlə metodda təkrar yazmağa ehtiyac qalmır.</p><h3>Maintainability</h3><p>Bir davranışı dəyişmək üçün bir neçə class-a toxunmaq əvəzinə Aspect-i dəyişmək kifayət edə bilər.</p><h3>Cleaner Business Logic</h3><p>Service metodları yalnız öz əsas biznes məsuliyyətinə fokuslana bilir.</p><h3>Diqqət edilməli məqamlar</h3><p>AOP çox güclü mexanizmdir, lakin həddindən artıq istifadə edildikdə kodun davranışını başa düşməyi çətinləşdirə bilər.</p><p>Əsasən bunlara diqqət etmək lazımdır:</p><ul><li>Proxy mexanizmini başa düşmək</li><li>Self-invocation problemini bilmək</li><li>Pointcut expression-larını düzgün yazmaq</li><li>@Around istifadə edərkən proceed() çağırışını unutmaq</li><li>AOP-u business logic-i gizlətmək üçün həddindən artıq istifadə etməmək</li></ul><h3>Nəticə</h3><p><strong>Spring AOP</strong> kodun müxtəlif hissələrində təkrarlanan Cross-Cutting Concern-ləri əsas biznes məntiqindən ayırmaq üçün güclü mexanizmdir.</p><p>Onun əsasını:</p><pre>Aspect<br>Join Point<br>Advice<br>Pointcut<br>Target Object<br>Proxy</pre><p>anlayışları təşkil edir.</p><p>Spring AOP-un ən vacib tərəflərindən biri isə onun <strong>Proxy-based</strong> işləməsidir. Bu mexanizmi başa düşdükdə:</p><pre>@Aspect<br>@Transactional<br>@Cacheable<br>@Async</pre><p>kimi bir çox Spring xüsusiyyətinin arxasında baş verən prosesləri daha rahat anlamaq mümkün olur.</p><p>Xüsusilə <strong>Self-Invocation</strong> problemi isə Spring AOP-u öyrənərkən mütləq bilinməli mövzulardan biridir.</p><p>AOP-u sadəcə annotation-lar toplusu kimi deyil, <strong>Proxy + Pointcut + Advice + Method Invocation</strong> mexanizmi kimi başa düşmək Spring-in daxili iş prinsipini daha dərindən anlamağa imkan verir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f91f8c9bd0d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CompletableFuture in Java: Asynchronous and Non-Blocking Programming]]></title>
            <link>https://medium.com/@nicat.agayev.536/completablefuture-in-java-asynchronous-and-non-blocking-programming-565c586d4dfd?source=rss-8920c4b451da------2</link>
            <guid isPermaLink="false">https://medium.com/p/565c586d4dfd</guid>
            <category><![CDATA[completablefuture]]></category>
            <dc:creator><![CDATA[Nijat Aghayev]]></dc:creator>
            <pubDate>Fri, 21 Aug 2026 18:17:57 GMT</pubDate>
            <atom:updated>2026-08-21T18:17:57.319Z</atom:updated>
            <content:encoded><![CDATA[<p>Müasir backend sistemlərində performansın artırılması üçün ən vacib yanaşmalardan biri <strong>asynchronous programming</strong>-dir.</p><p>Xüsusilə mikroservis arxitekturasında bir request zamanı bir neçə fərqli servisdən məlumat almaq lazım gəldikdə, həmin çağırışları ardıcıl şəkildə etmək ciddi latency yarada bilər.</p><p>Məsələn:</p><pre>Product Service  →  1 sec<br>Price Service    →  1 sec<br>Stock Service    →  1 sec</pre><pre>Total = 3 seconds</pre><p>Əgər bu üç əməliyyat bir-birindən asılı deyilsə, onları paralel icra etməklə ümumi gözləmə müddətini əhəmiyyətli dərəcədə azaltmaq mümkündür.</p><p>Java 8 ilə birlikdə təqdim olunan <strong>CompletableFuture</strong> məhz belə asinxron proseslərin idarə edilməsi üçün ən vacib API-lərdən biridir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_IQ6_ZXdhxsYTTUYvCCmiQ.jpeg" /></figure><h3>CompletableFuture nədir?</h3><p>CompletableFuture Java 8-də təqdim olunan və asinxron əməliyyatların nəticəsini təmsil edən bir class-dır.</p><p>Əvvəllər əsasən Future istifadə olunurdu:</p><pre>Future&lt;String&gt; future = executor.submit(() -&gt; {<br>    return &quot;Hello&quot;;<br>});</pre><pre>String result = future.get();</pre><p>Buradakı əsas problem get() metodunun cari thread-i nəticə hazır olana qədər bloklamasıdır.</p><p>CompletableFuture isə bizə:</p><ul><li>Asinxron task başlatmaq</li><li>Task-ları chain etmək</li><li>Bir neçə async task-ı birləşdirmək</li><li>Nəticələri transform etmək</li><li>Exception-ları idarə etmək</li><li>Timeout tətbiq etmək</li><li>Callback-lər qurmaq imkanı verir.</li></ul><h3>CompletableFuture necə işləyir?</h3><p>Sadə şəkildə belə düşünə bilərik:</p><pre>CompletableFuture<br>                       │<br>          ┌────────────┼────────────┐<br>          │            │            │<br>       Async        Chaining     Combining<br>          │            │            │<br>      supplyAsync   thenApply    allOf<br>      runAsync      thenCompose  anyOf<br>                    thenAccept   thenCombine</pre><h3>1. Asinxron Task Başlatmaq</h3><h3>supplyAsync()</h3><p>Əgər task nəticə qaytarırsa, supplyAsync() istifadə olunur.</p><pre>CompletableFuture&lt;String&gt; future =<br>        CompletableFuture.supplyAsync(() -&gt; {<br>            return &quot;Hello CompletableFuture&quot;;<br>        });</pre><p>Burada nəticə CompletableFuture&lt;String&gt; olacaq.</p><h3>runAsync()</h3><p>Əgər task heç bir nəticə qaytarmırsa:</p><pre>CompletableFuture&lt;Void&gt; future =<br>        CompletableFuture.runAsync(() -&gt; {<br>            System.out.println(&quot;Task is running...&quot;);<br>        });</pre><p>runAsync() Runnable qəbul edir və nəticə qaytarmır.</p><h3>Default Thread Pool</h3><p>Əgər supplyAsync() və ya runAsync() metoduna ayrıca Executor verməsək, task-lar default olaraq:</p><pre>ForkJoinPool.commonPool()</pre><p>üzərində icra olunur.</p><p>Məsələn:</p><pre>CompletableFuture.supplyAsync(() -&gt; {<br>    return getProduct();<br>});</pre><p>təxminən belə işləyir:</p><pre>Application<br>     │<br>     ▼<br>CompletableFuture<br>     │<br>     ▼<br>ForkJoinPool.commonPool()<br>     │<br>     ▼<br>Async Task</pre><p>Bu detal production sistemlərində çox vacibdir.</p><h3>2. Chaining</h3><p>CompletableFuture-in ən güclü xüsusiyyətlərindən biri task-ları bir-birinə bağlamaqdır.</p><h3>thenApply()</h3><p>Əvvəlki task-ın nəticəsini götürür, transformasiya edir və yeni nəticə qaytarır.</p><pre>CompletableFuture&lt;String&gt; future =<br>        CompletableFuture<br>                .supplyAsync(() -&gt; &quot;hello&quot;)<br>                .thenApply(String::toUpperCase);</pre><p>Nəticə:</p><pre>hello<br>  ↓<br>HELLO</pre><p>Bunu Stream API-dəki map() əməliyyatına bənzətmək olar.</p><h3>thenAccept()</h3><p>Əvvəlki nəticəni istifadə edir, amma yeni nəticə qaytarmır.</p><pre>CompletableFuture<br>        .supplyAsync(() -&gt; getProduct())<br>        .thenAccept(product -&gt; {<br>            System.out.println(product);<br>        });</pre><p>Nəticə:</p><pre>CompletableFuture&lt;Void&gt;</pre><h3>thenCompose()</h3><p>Burada vacib fərq var.</p><p>Təsəvvür edək ki:</p><ol><li>Əvvəl user-i tapmalıyıq.</li><li>Daha sonra həmin user-in order-lərini tapmalıyıq.</li></ol><p>İkinci əməliyyat birincidən asılıdır.</p><pre>CompletableFuture&lt;User&gt; userFuture =<br>        getUserAsync(userId);</pre><pre>CompletableFuture&lt;List&lt;Order&gt;&gt; ordersFuture =<br>        userFuture.thenCompose(user -&gt;<br>                getOrdersAsync(user.getId()));</pre><p>Burada thenCompose() nested CompletableFuture yaranmasının qarşısını alır. Bunu flatMap() məntiqinə bənzətmək olar.</p><h3>thenApply vs thenCompose</h3><p>Bu iki metod tez-tez qarışdırılır.</p><h3>thenApply</h3><p>Bir nəticəni başqa nəticəyə çevirir:</p><pre>Future&lt;A&gt;<br>   ↓<br>Future&lt;B&gt;</pre><h3>thenCompose</h3><p>Bir CompletableFuture nəticəsindən başqa CompletableFuture yaradır:</p><pre>Future&lt;A&gt;<br>   ↓<br>Future&lt;B&gt;</pre><p>Əsas fərq daxildə yaranan nested future-ın flatten edilməsidir.</p><h3>3. CompletableFuture-ları Birləşdirmək</h3><p>Ən maraqlı hissələrdən biri budur.</p><p>Təsəvvür edək ki, Product Details səhifəsində üç servisdən məlumat almalıyıq:</p><pre>Product Service → 1 sec<br>Price Service   → 1 sec<br>Stock Service   → 1 sec</pre><p>Bu əməliyyatlar bir-birindən asılı deyil.</p><p>Ardıcıl çağırış:</p><pre>Product<br>   ↓<br>Price<br>   ↓<br>Stock</pre><pre>≈ 3 seconds</pre><p>Paralel çağırış:</p><pre>┌→ Product ─┐<br>Request ├→ Price ───┼→ Response<br>        └→ Stock ───┘</pre><pre>≈ 1 second</pre><p>Bu, CompletableFuture-in ən real istifadə ssenarilərindən biridir.</p><h3>thenCombine()</h3><p>İki müstəqil CompletableFuture-un nəticəsini birləşdirmək üçün istifadə olunur.</p><pre>CompletableFuture&lt;Product&gt; productFuture =<br>        getProductAsync();</pre><pre>CompletableFuture&lt;Price&gt; priceFuture =<br>        getPriceAsync();</pre><pre>CompletableFuture&lt;ProductDetails&gt; result =<br>        productFuture.thenCombine(<br>                priceFuture,<br>                ProductDetails::new<br>        );</pre><p>Burada productFuture və priceFuture müstəqil olduğu üçün paralel başlaya bilər.</p><p>thenCombine() isə hər ikisinin nəticəsi hazır olduqdan sonra işləyir.</p><h3>CompletableFuture.allOf()</h3><p>Çoxlu sayda task-ın hamısının tamamlanmasını gözləmək üçün allOf() istifadə olunur.</p><pre>CompletableFuture&lt;Void&gt; all =<br>        CompletableFuture.allOf(<br>                productFuture,<br>                priceFuture,<br>                stockFuture<br>        );</pre><p>Vacib məqam:</p><p>allOf() nəticə olaraq CompletableFuture&lt;Void&gt; qaytarır.</p><p>Yəni task-ların nəticələrini avtomatik olaraq List şəklində vermir.</p><p>Nəticələri ayrıca əldə etmək lazımdır:</p><pre>CompletableFuture&lt;List&lt;Object&gt;&gt; result =<br>        all.thenApply(v -&gt; List.of(<br>                productFuture.join(),<br>                priceFuture.join(),<br>                stockFuture.join()<br>        ));</pre><h3>CompletableFuture.anyOf()</h3><p>Bir neçə task-dan <strong>ilk tamamlanan</strong> task-ın nəticəsini əldə etmək üçün istifadə olunur.</p><pre>CompletableFuture&lt;Object&gt; fastest =<br>        CompletableFuture.anyOf(<br>                service1,<br>                service2,<br>                service3<br>        );</pre><p>Məsələn:</p><pre>Service 1 → 1200 ms<br>Service 2 → 400 ms   ✅<br>Service 3 → 900 ms</pre><pre>anyOf() → Service 2</pre><p>Burada diqqət edilməli məqam odur ki, “ilk tamamlanan” nəticə uğurlu olmaq məcburiyyətində deyil. İlk tamamlanan future exceptional completion ilə bitsə, anyOf() də həmin nəticəni exception kimi daşıya bilər.</p><h3>4. Exception Handling</h3><p>Asinxron proqramlaşdırmada error handling xüsusilə vacibdir.</p><h3>exceptionally()</h3><p>Əgər chain-in əvvəlki hissəsində exception yaranarsa fallback nəticə qaytarmaq mümkündür.</p><pre>CompletableFuture&lt;String&gt; result =<br>        CompletableFuture<br>                .supplyAsync(() -&gt; {<br>                    throw new RuntimeException(&quot;Something went wrong&quot;);<br>                })<br>                .exceptionally(ex -&gt; {<br>                    return &quot;Fallback value&quot;;<br>                });</pre><p>Nəticə:</p><pre>Exception<br>   ↓<br>exceptionally()<br>   ↓<br>Fallback</pre><h3>handle()</h3><p>handle() həm uğurlu nəticəni, həm də exception-ı eyni yerdə idarə etməyə imkan verir.</p><pre>CompletableFuture&lt;String&gt; result =<br>        future.handle((value, exception) -&gt; {</pre><pre>            if (exception != null) {<br>                return &quot;Fallback&quot;;<br>            }</pre><pre>            return value;<br>        });</pre><p>Bu yanaşma həm success, həm də failure vəziyyətinə eyni anda nəzarət etmək lazım olduqda faydalıdır.</p><h3>exceptionally vs handle</h3><p>Sadə qayda:</p><p><strong>exceptionally()</strong></p><p>Yalnız exception olduqda fallback üçün:</p><pre>Success → davam et<br>Failure → fallback</pre><p><strong>handle()</strong></p><p>Hər iki vəziyyəti idarə etmək üçün:</p><pre>Success → handle()<br>Failure → handle()</pre><h3>get() vs join()</h3><p>Bu iki metod çox oxşar görünsə də, exception handling baxımından fərqlənir.</p><h3>get()</h3><pre>future.get();</pre><p>get() checked exception-lar ata bilər:</p><pre>InterruptedException<br>ExecutionException</pre><p>Buna görə try-catch və ya throws tələb olunur.</p><h3>join()</h3><pre>future.join();</pre><p>join() checked exception əvəzinə:</p><pre>CompletionException</pre><p>kimi unchecked exception istifadə edir.</p><p>Bu səbəbdən lambda və Stream API daxilində istifadə etmək daha rahatdır.</p><h3>Vacib qeyd</h3><p>join() daha rahat olsa da, <strong>non-blocking deyil</strong>.</p><p>Future tamamlanmayıbsa, join() çağıran thread nəticə hazır olana qədər gözləyə bilər.</p><h3>Custom Executor</h3><p>Production tətbiqlərində ən vacib məsələlərdən biri istifadə olunan thread pool-un düzgün seçilməsidir.</p><p>Sadə şəkildə:</p><pre>CompletableFuture.supplyAsync(() -&gt; {<br>    return callExternalService();<br>});</pre><p>yazdıqda ForkJoinPool.commonPool() istifadə olunur.</p><p>Lakin application daxilində:</p><ul><li>parallelStream()</li><li>digər CompletableFuture task-ları</li><li>müxtəlif async əməliyyatlar</li></ul><p>eyni common pool-u paylaşa bilər.</p><p>Xüsusilə <strong>blocking I/O</strong> əməliyyatlarında ayrıca executor istifadə etmək daha təhlükəsiz yanaşmadır.</p><pre>ExecutorService executor =<br>        Executors.newFixedThreadPool(20);</pre><pre>CompletableFuture.supplyAsync(<br>        () -&gt; callExternalService(),<br>        executor<br>);</pre><p>Beləliklə thread resurslarına daha yaxşı nəzarət edə bilərik.</p><h3>I/O Bound vs CPU Bound</h3><p>Thread pool seçərkən əməliyyatın xarakterini nəzərə almaq lazımdır.</p><h3>I/O Bound</h3><p>Məsələn:</p><ul><li>HTTP request</li><li>Database query</li><li>Redis request</li><li>File I/O</li></ul><p>Thread çox vaxt xarici resursun cavabını gözləyir.</p><p>Bu halda ayrıca idarə olunan executor faydalı ola bilər.</p><h3>CPU Bound</h3><p>Məsələn:</p><ul><li>Encryption</li><li>Compression</li><li>Complex calculations</li><li>Image processing</li></ul><p>Burada əsas limit CPU və processor core-lardır.</p><p>Bu əməliyyatlarda həddindən artıq thread yaratmaq performansı yaxşılaşdırmaya, əksinə pisləşdirə bilər.</p><h3>Timeout</h3><p>Distributed sistemlərdə timeout mütləq nəzərə alınmalıdır.</p><p>Java 9-dan etibarən CompletableFuture timeout üçün əlavə metodlar təqdim edir.</p><h3>orTimeout()</h3><pre>future.orTimeout(<br>        1,<br>        TimeUnit.SECONDS<br>);</pre><p>Əgər future müəyyən edilmiş müddətdə tamamlanmazsa, TimeoutException ilə exceptional completion baş verir.</p><p>Vacib məqam: orTimeout() underlying əməliyyatı mütləq dayandırmır; CompletableFuture-ın özünü timeout vəziyyətində tamamlayır.</p><h3>completeOnTimeout()</h3><p>Bəzən exception əvəzinə default nəticə qaytarmaq istəyirik.</p><pre>future.completeOnTimeout(<br>        defaultValue,<br>        1,<br>        TimeUnit.SECONDS<br>);</pre><p>Beləliklə timeout zamanı fallback dəyər əldə etmək mümkündür.</p><h3>CompletableFuture + Microservices</h3><p>Mikroservis sistemində real ssenariyə baxaq.</p><pre>Product Details<br>                        │<br>           ┌────────────┼────────────┐<br>           │            │            │<br>           ▼            ▼            ▼<br>       Product       Pricing       Stock<br>       Service       Service       Service<br>           │            │            │<br>           └────────────┼────────────┘<br>                        │<br>                        ▼<br>                  Combined Response</pre><p>Əgər üç servis müstəqildirsə, onları paralel çağırmaq mümkündür.</p><pre>CompletableFuture&lt;Product&gt; product =<br>        getProductAsync();</pre><pre>CompletableFuture&lt;Price&gt; price =<br>        getPriceAsync();</pre><pre>CompletableFuture&lt;Stock&gt; stock =<br>        getStockAsync();</pre><pre>CompletableFuture&lt;Void&gt; all =<br>        CompletableFuture.allOf(<br>                product,<br>                price,<br>                stock<br>        );</pre><p>Bu yanaşma düzgün tətbiq edildikdə endpoint-in ümumi latency-sini əhəmiyyətli dərəcədə azalda bilər.</p><h3>Common Mistakes</h3><h3>1. Hər şeyi CompletableFuture etmək</h3><p>Asinxronluq həmişə daha sürətli demək deyil.</p><p>Əməliyyatlar bir-birindən asılıdırsa, lazımsız async chain kodu mürəkkəbləşdirə bilər.</p><h3>2. Hər yerdə join() istifadə etmək</h3><p>Əgər bütün chain-i async qurub sonda:</p><pre>future.join();</pre><p>ilə nəticəni gözləyirsinizsə, həmin nöqtədə thread yenidən bloklana bilər.</p><h3>3. Common Pool-dan nəzarətsiz istifadə</h3><p>Xüsusilə blocking I/O əməliyyatlarını ForkJoinPool.commonPool() üzərinə nəzarətsiz yükləmək digər async işlərə də təsir göstərə bilər.</p><h3>4. Timeout təyin etməmək</h3><p>Uzaq servis cavab vermirsə, request-in sonsuza qədər gözləməsi düzgün deyil.</p><p>Distributed sistemlərdə:</p><pre>Timeout<br>+<br>Retry<br>+<br>Circuit Breaker</pre><p>çox vacib kombinasiyadır.</p><h3>Best Practices</h3><h3>1. Custom Executor istifadə edin</h3><p>Xüsusilə blocking I/O əməliyyatlarında thread pool-u özünüz idarə edin.</p><h3>2. Exception handling əlavə edin</h3><p>exceptionally(), handle() və ya uyğun digər mexanizmlərlə failure path-i əvvəlcədən düşünün.</p><h3>3. Timeout təyin edin</h3><p>Uzaq servisə gedən async çağırışların sonsuz gözləməsinə imkan verməyin.</p><h3>4. Müstəqil əməliyyatları paralelləşdirin</h3><p>Əgər üç servis bir-birindən asılı deyilsə, onları ardıcıl çağırmaq əvəzinə paralel icra etməyi düşünün.</p><h3>5. Thread Pool ölçüsünü düzgün seçin</h3><p>Executor-un ölçüsü workload-a uyğun müəyyən edilməlidir. Daha çox thread həmişə daha çox performans demək deyil.</p><h3>6. Cancellation və lifecycle məsələlərini nəzərə alın</h3><p>Async task-ların timeout və application shutdown zamanı necə davranacağı əvvəlcədən müəyyən edilməlidir.</p><h3>Nəticə</h3><p>CompletableFuture Java-da sadəcə &quot;async task işlətmək&quot; üçün istifadə olunan API deyil.</p><p>O, bizə:</p><ul><li>Asynchronous execution</li><li>Task chaining</li><li>Parallel execution</li><li>Result composition</li><li>Exception handling</li><li>Timeout management</li></ul><p>kimi imkanlar təqdim edir.</p><p>Xüsusilə Spring Boot və Microservices layihələrində bir request zamanı bir neçə müstəqil servisdən məlumat toplamaq lazım gəldikdə CompletableFuture düzgün istifadə olunarsa ciddi latency qazancı verə bilər.</p><p>Amma əsas prinsip budur:</p><blockquote><strong><em>Asynchronous programming məqsəd deyil, düzgün istifadə edildikdə performans və scalability üçün bir vasitədir.</em></strong></blockquote><p>CompletableFuture-ı yaxşı bilmək isə Java backend developer üçün xüsusilə <strong>Senior səviyyəsində</strong> vacib bacarıqlardan biridir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=565c586d4dfd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Resilience4j in Spring Boot: Building Fault-Tolerant Microservices]]></title>
            <link>https://medium.com/@nicat.agayev.536/resilience4j-in-spring-boot-building-fault-tolerant-microservices-029eed67a32a?source=rss-8920c4b451da------2</link>
            <guid isPermaLink="false">https://medium.com/p/029eed67a32a</guid>
            <category><![CDATA[resilience4j]]></category>
            <dc:creator><![CDATA[Nijat Aghayev]]></dc:creator>
            <pubDate>Mon, 20 Jul 2026 17:44:07 GMT</pubDate>
            <atom:updated>2026-07-20T17:44:07.285Z</atom:updated>
            <content:encoded><![CDATA[<p>Mikroservis memarlığında sistemlər bir-biri ilə davamlı əlaqə saxlayır. Bir servis digər servisi çağırır, o isə növbəti servislə əlaqə yaradır. Bu çeviklik böyük üstünlük olsa da, eyni zamanda ciddi risklər də yaradır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OwEsGIde_spzxttP_AYGrA.png" /></figure><p>Təsəvvür edin:</p><ul><li><strong>Order Service</strong> → <strong>Payment Service</strong></li><li><strong>Payment Service</strong> → <strong>Notification Service</strong></li><li><strong>Notification Service</strong> müvəqqəti olaraq əlçatmazdır.</li></ul><p>Əgər bu vəziyyət düzgün idarə olunmazsa, problem zəncirvari şəkildə bütün sistemi təsir edə bilər. Bu hadisə <strong>Cascading Failure</strong> adlanır.</p><p>Məhz bu kimi problemlərin qarşısını almaq üçün <strong>Resilience4j</strong> yaradılıb.</p><h3>Resilience4j nədir?</h3><p><strong>Resilience4j</strong> Java və xüsusilə Spring Boot tətbiqləri üçün hazırlanmış yüngül (<strong>Lightweight</strong>) Fault Tolerance kitabxanasıdır.</p><p>Netflix <strong>Hystrix</strong> layihəsinin inkişafı dayandırıldıqdan sonra Spring ekosistemində əsas seçim Resilience4j oldu.</p><p>Onun məqsədi sadəcə xətanı tutmaq deyil, tətbiqin çətin vəziyyətlərdə də işləməyə davam etməsini təmin etməkdir.</p><h3>Fault Tolerance nədir?</h3><p>Fault Tolerance sistemin müəyyən hissəsində problem yaransa belə xidmət göstərməyə davam etməsidir.</p><p>Məsələn:</p><pre>Client<br>   │<br>Order Service<br>   │<br>Payment Service ❌<br>   │<br>Fallback Response ✅</pre><p>İstifadəçi sistemin tam çökdüyünü hiss etmir.</p><h3>Resilience4j-in əsas modulları</h3><p>Resilience4j beş əsas dizayn nümunəsini təqdim edir.</p><h3>1. Circuit Breaker</h3><p>Ən məşhur moduldur.</p><p>Əgər müəyyən sayda sorğu uğursuz olarsa, Circuit Breaker həmin servisi müvəqqəti olaraq “ayırır”.</p><p>Bu yanaşma problemli servisin daha da yüklənməsinin qarşısını alır.</p><h3>Circuit Breaker vəziyyətləri</h3><h3>Closed</h3><p>Normal vəziyyətdir.</p><p>Bütün sorğular hədəf servisə göndərilir.</p><pre>Request<br>   │<br>Service</pre><h3>Open</h3><p>Failure Rate müəyyən həddi keçdikdə Circuit Breaker açılır.</p><p>Artıq sorğular servisi çağırmır.</p><p>Birbaşa <strong>Fallback</strong> metoduna yönləndirilir.</p><pre>Request<br><br>Circuit Breaker<br><br>Fallback</pre><h3>Half-Open</h3><p>Müəyyən müddət sonra bir neçə test sorğusu göndərilir.</p><p>Əgər onlar uğurlu olarsa:</p><pre>Open<br> ↓<br>Half Open<br> ↓<br>Closed</pre><p>Əks halda yenidən <strong>Open</strong> vəziyyətinə qayıdır.</p><h3>2. Retry</h3><p>Bəzi problemlər müvəqqətidir.</p><p>Məsələn:</p><ul><li>Network glitch</li><li>Temporary timeout</li><li>Connection reset</li></ul><p>Belə hallarda ilk uğursuzluqdan sonra dərhal xəta vermək əvəzinə sorğunu yenidən göndərmək daha məqsədəuyğundur.</p><pre>Attempt 1 ❌<br><br>Attempt 2 ❌<br><br>Attempt 3 ✅</pre><p>Retry məhz bunu həyata keçirir.</p><h3>3. Rate Limiter</h3><p>Hər istifadəçiyə və ya API-yə müəyyən sayda sorğu limiti tətbiq edir.</p><p>Məsələn:</p><pre>20 request / second</pre><p>Əsas istifadə sahələri:</p><ul><li>Public API</li><li>Login endpoint</li><li>OTP servisləri</li><li>DDoS qorunması</li></ul><h3>4. Time Limiter</h3><p>Bəzən uzaq servis ümumiyyətlə cavab vermir.</p><p>Bu halda thread-lər sonsuz gözləməməlidir.</p><pre>Request</pre><pre>3 seconds</pre><pre>Timeout</pre><p>TimeLimiter təyin olunan vaxt keçdikdə sorğunu dayandırır.</p><h3>5. Bulkhead</h3><p>Bulkhead gəmidəki arakəsmələrdən ilhamlanmış dizayn nümunəsidir.</p><p>Əgər gəminin bir hissəsinə su dolarsa, digər hissələr işləməyə davam edir.</p><p>Mikroservislərdə də eyni prinsip tətbiq olunur.</p><pre>Payment Threads</pre><pre>Inventory Threads</pre><pre>Notification Threads</pre><p>Payment servisi bütün thread-ləri istifadə etsə belə digər servislər işləməyə davam edir.</p><h3>Spring Boot inteqrasiyası</h3><h3>Dependency</h3><p>İlk olaraq aşağıdakı dependency-lər əlavə edilir.</p><pre>resilience4j-spring-boot3</pre><pre>spring-boot-starter-aop</pre><pre>spring-boot-starter-actuator</pre><p>Actuator vasitəsilə bütün statistikaları izləmək mümkündür.</p><h3>Circuit Breaker Konfiqurasiyası</h3><p>Resilience4j YAML vasitəsilə tam konfiqurasiya oluna bilir.</p><p>Ən vacib parametrlər:</p><ul><li>sliding-window-type</li><li>sliding-window-size</li><li>failure-rate-threshold</li><li>slow-call-rate-threshold</li><li>wait-duration-in-open-state</li><li>minimum-number-of-calls</li></ul><p>Burada iki əsas Sliding Window növü mövcuddur.</p><h3>COUNT_BASED</h3><p>Son N sorğuya baxır.</p><p>Məsələn:</p><pre>Last 10 Requests</pre><p>Əgər onların 50%-i uğursuzdursa Circuit Breaker açılır.</p><h3>TIME_BASED</h3><p>Son N saniyəyə baxır.</p><p>Məsələn:</p><pre>Last 30 Seconds</pre><p>Bu yanaşma yüksək trafikli sistemlərdə daha effektivdir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/672/1*WI50JYXZ6NNdHFgrmoD0Aw.png" /></figure><h3>Rate Limiter</h3><p>Misal:</p><pre>20 Request / Second</pre><p>Bu limit keçildikdə yeni sorğular qəbul edilmir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/566/1*WTY_W8xTIeWDNKyqqM8ytw.png" /></figure><p>Resilience4j istifadəçi və ya endpoint üzrə ayrıca limitlər tətbiq etməyə də imkan verir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/585/1*CBz4D6szazwARMedY6sH1A.png" /></figure><h3>Bulkhead</h3><p>Resilience4j iki Bulkhead təqdim edir.</p><h3>SemaphoreBulkhead</h3><p>Ən sadə variantdır.</p><p>Sadəcə eyni anda neçə request icra olunacağını məhdudlaşdırır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/1*gEngjBkcvZzT31EByafGEw.png" /></figure><h3>ThreadPoolBulkhead</h3><p>Asinxron əməliyyatlar üçün nəzərdə tutulub.</p><p>Öz Thread Pool-unu yaradır.</p><p>Bu, xüsusilə CompletableFuture istifadə olunan tətbiqlərdə faydalıdır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/537/1*IoXVr2zJLKNJdegkRem5Ig.png" /></figure><h3>TimeLimiter</h3><p>Timeout təyin edir.</p><pre>3 Seconds</pre><pre>↓</pre><pre>Timeout Exception</pre><p>Beləliklə uzun müddət cavab verməyən servislər thread-ləri bloklamır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/557/1*MGwgRNvyMshhYcAKH2ZwoQ.png" /></figure><h3>Retry</h3><p>Retry yalnız müəyyən exception-lar üçün tətbiq edilə bilər.</p><p>Məsələn:</p><ul><li>ConnectException</li><li>TimeoutException</li><li>HttpServerErrorException</li></ul><p>Validation kimi biznes xətaları isə Retry edilməməlidir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/1*85QsQ4omkk7MVkrSDpmJZw.png" /></figure><h3>Decorator Pattern</h3><p>Resilience4j bütün modulları birlikdə istifadə etməyə imkan verir.</p><p>Məsələn:</p><pre>Retry</pre><pre>↓</pre><pre>Circuit Breaker</pre><pre>↓</pre><pre>Rate Limiter</pre><pre>↓</pre><pre>Time Limiter</pre><pre>↓</pre><pre>Bulkhead</pre><pre>↓</pre><pre>Remote Service</pre><p>Bu yanaşma Decorator Pattern adlanır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*hv60a1R--D-Jngx4OJMbcA.png" /></figure><h3>Best Practices</h3><p>✔ Circuit Breaker və Retry birlikdə istifadə edilə bilər.</p><p>✔ Retry sayını çox artırmaq düzgün deyil.</p><p>✔ Timeout həmişə təyin edilməlidir.</p><p>✔ Rate Limiter Public API-lərdə mütləq istifadə olunmalıdır.</p><p>✔ Bulkhead mikroservis memarlığında kritik əhəmiyyət daşıyır.</p><p>✔ Actuator və Micrometer ilə metrikləri izləmək tövsiyə olunur.</p><h3>Real-Life İstifadə Nümunələri</h3><p>Resilience4j aşağıdakı sistemlərdə geniş istifadə olunur:</p><ul><li>Payment Gateway</li><li>Banking Applications</li><li>E-commerce Platformaları</li><li>Booking Systems</li><li>Logistics Services</li><li>Notification Services</li><li>Cloud Native Applications</li></ul><h3>Nəticə</h3><p>Resilience4j yalnız xətaları idarə edən kitabxana deyil, mikroservis memarlığında sistemlərin dayanıqlığını təmin edən əsas komponentlərdən biridir.</p><p>Circuit Breaker, Retry, Rate Limiter, Bulkhead və TimeLimiter birlikdə istifadə edildikdə tətbiqlər daha sabit, daha etibarlı və yüksək yüklənmə altında daha davamlı işləyir.</p><p>Spring Boot ekosistemində fault-tolerant mikroservislər qurmaq istəyən hər bir Java developer üçün Resilience4j öyrənilməsi vacib texnologiyalardan biridir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=029eed67a32a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Cache (Redis) in Spring Boot]]></title>
            <link>https://medium.com/@nicat.agayev.536/spring-cache-redis-in-spring-boot-873676a95704?source=rss-8920c4b451da------2</link>
            <guid isPermaLink="false">https://medium.com/p/873676a95704</guid>
            <category><![CDATA[spring-cache]]></category>
            <dc:creator><![CDATA[Nijat Aghayev]]></dc:creator>
            <pubDate>Mon, 13 Jul 2026 20:02:24 GMT</pubDate>
            <atom:updated>2026-07-13T20:02:24.160Z</atom:updated>
            <content:encoded><![CDATA[<p>Verilənlər bazasına (Database) tez-tez və ya böyük həcmdə müraciət etmək tətbiqin performansını aşağı salan əsas səbəblərdən biridir. Hər sorğu üçün eyni məlumatın yenidən bazadan oxunması həm gecikmələrə (Latency), həm də CPU və Database resurslarının lazımsız istifadəsinə səbəb olur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lq-ta8qIc4rf4xifPCDkHQ.jpeg" /></figure><p>Bu problemin ən effektiv həll yollarından biri <strong>Caching</strong>-dir.</p><p>Spring Framework bizə bu işi <strong>Spring Cache Abstraction</strong> vasitəsilə çox sadə şəkildə həyata keçirməyə imkan verir. Redis ilə birlikdə istifadə etdikdə isə tətbiqimiz yüksək performanslı və paylanmış (Distributed) cache sisteminə çevrilir.</p><p>Bu məqalədə Spring Boot və Redis inteqrasiyasını nəzəriyyədən başlayaraq praktik nümunələrə qədər ətraflı araşdıracağıq.</p><h3>Cache Nədir?</h3><p>Cache tez-tez istifadə olunan məlumatların RAM-da müvəqqəti saxlanılmasıdır.</p><p>Əgər istifadəçi eyni məlumatı təkrar tələb edərsə:</p><p>❌ Database-ə sorğu göndərilmir.</p><p>✅ Məlumat birbaşa RAM-dan oxunur.</p><p>Bu yanaşma tətbiqin cavab müddətini millisaniyələr səviyyəsinə endirə bilir.</p><h3>Niyə Redis?</h3><p>Redis (<strong>Remote Dictionary Server</strong>) yüksək performanslı, in-memory NoSQL verilənlər bazasıdır.</p><p>Ən böyük üstünlüklərindən biri isə <strong>Distributed Cache</strong> dəstəyidir.</p><p>Təsəvvür edin ki, tətbiqiniz Kubernetes və ya Docker mühitində 5 fərqli instance üzərində işləyir.</p><pre>Client<br>             │<br> ┌───────────┼───────────┐<br> │           │           │<br>App-1      App-2      App-3<br> │           │           │<br> └───────────┼───────────┘<br>             │<br>          Redis Cache<br>             │<br>         PostgreSQL</pre><p>Bu halda bütün instance-lar eyni Redis serverindən istifadə edir və məlumatlar sinxron qalır.</p><h3>Spring Cache Abstraction</h3><p>Spring Cache bir abstraction qatıdır.</p><p>Bu o deməkdir ki, kod dəyişmədən yalnız konfiqurasiyanı dəyişərək müxtəlif cache provider-lərindən istifadə edə bilərik.</p><p>Məsələn:</p><ul><li>Redis</li><li>Caffeine</li><li>EhCache</li><li>Hazelcast</li><li>Infinispan</li></ul><p>Kod isə eyni qalır.</p><h3>Əsas Annotasiyalar</h3><h3>@Cacheable</h3><p>Ən çox istifadə olunan annotasiyadır.</p><p>İlk sorğuda metod icra olunur və nəticə Redis-də saxlanılır.</p><p>Sonrakı sorğularda metod ümumiyyətlə işləmir.</p><p>Data birbaşa cache-dən qaytarılır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/1*rfR3pxfRWlD_kIPDs9bVZA.png" /></figure><p>İş prinsipi:</p><pre>Request<br>   │<br>Cache-də varmı?<br>   │<br> ├── YES → Cache-dən qaytar<br> │<br> └── NO<br>      │<br> Database<br>      │<br> Cache-ə yaz<br>      │<br> Response</pre><h3>@CachePut</h3><p>Bu annotasiya həmişə metodu icra edir.</p><p>Lakin metod bitdikdən sonra cache-i yeniləyir.</p><p>Adətən Update əməliyyatlarında istifadə olunur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*6OZiZsvZFDkAlnSZFJjzjQ.png" /></figure><h3>@CacheEvict</h3><p>Delete və ya məlumat dəyişdikdən sonra köhnə cache-i silmək üçün istifadə edilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/719/1*Ty4bj1Rj0skcxBa0JfA6sw.png" /></figure><p>Əgər cache təmizlənməzsə istifadəçi köhnə məlumatı görməyə davam edəcək.</p><h3>@Caching</h3><p>Bəzən eyni metod bir neçə cache üzərində işləməlidir.</p><p>Bu zaman @Caching istifadə olunur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/731/1*UHzhhJDAvk1avEIhOMqV0A.png" /></figure><h3>Spring Boot + Redis Qurulumu</h3><h3>Addım 1 — Dependency-lər</h3><p>pom.xml</p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>    &lt;artifactId&gt;spring-boot-starter-cache&lt;/artifactId&gt;<br>&lt;/dependency&gt;</pre><pre>&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;</pre><h3>Addım 2 — Redis Konfiqurasiyası</h3><p>application.properties</p><p>Burada Redis host, port və cache TTL müddəti təyin edilir.</p><p>TTL (<strong>Time To Live</strong>) cache məlumatının nə qədər yaşayacağını müəyyən edir.</p><p>Məsələn:</p><ul><li>5 dəqiqə</li><li>30 dəqiqə</li><li>1 saat</li></ul><p>TTL bitdikdən sonra məlumat avtomatik silinir.</p><h3>Addım 3 — RedisCacheManager</h3><p>Spring Boot standart olaraq Java Serialization istifadə edir.</p><p>Bu isə Redis-də oxunması çətin olan binar məlumat saxlayır.</p><p>Daha düzgün yanaşma isə məlumatları JSON formatında saxlamaqdır.</p><p>Bunun üçün RedisCacheManager və Jackson2JsonRedisSerializer istifadə olunur.</p><p>Beləliklə Redis daxilində məlumatlar daha oxunaqlı və daha az həcmli olur.</p><h3>RedisTemplate — Manual Cache</h3><p>Bəzi hallarda annotation-lar kifayət etmir.</p><p>Məsələn:</p><ul><li>Dinamik Key</li><li>Müxtəlif TTL-lər</li><li>Hash</li><li>Set</li><li>List</li><li>Counter</li><li>Pub/Sub</li></ul><p>Bu zaman RedisTemplate istifadə edilir.</p><pre>redisTemplate.opsForValue().set(key, value);<br>redisTemplate.opsForValue().get(key);</pre><p>RedisTemplate bizə Redis-in bütün imkanlarından istifadə etməyə şərait yaradır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/874/1*gQGBUON7VGznaNMQdr1ONg.png" /></figure><h3>Distributed Lock</h3><p>Mikroservis memarlığında eyni anda iki instance eyni əməliyyatı yerinə yetirə bilər.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/739/1*3oZV5M5wtJOxY-yhKzX0EQ.png" /></figure><p>Məsələn:</p><ul><li>Stock azalması</li><li>Payment</li><li>Order Creation</li></ul><p>Belə hallarda Redis Distributed Lock istifadə olunur.</p><pre>Thread A<br>      │<br> Redis Lock<br>      │<br>Thread B gözləyir</pre><p>Beləliklə eyni məlumat üzərində paralel dəyişikliklərin qarşısı alınır.</p><h3>Spring Cache-də Diqqət Edilməli Məqamlar</h3><p>✔ Cache yalnız tez-tez oxunan məlumatlar üçün istifadə olunmalıdır.</p><p>✔ Tez dəyişən məlumatları uzun müddət cache-də saxlamaq düzgün deyil.</p><p>✔ Cache invalidation (keşin təmizlənməsi) düzgün qurulmalıdır.</p><p>✔ TTL biznes tələblərinə uyğun seçilməlidir.</p><p>✔ Böyük obyektləri cache etmək RAM istifadəsini artıra bilər.</p><p>✔ Cache məlumatı Database-in əvəzedicisi deyil, yalnız sürətləndiricisidir.</p><h3>Nəticə</h3><p>Spring Cache və Redis birlikdə istifadə edildikdə Spring Boot tətbiqlərinin performansını əhəmiyyətli dərəcədə artırır.</p><p>Spring Cache kodun sadə qalmasını təmin edir, Redis isə yüksək sürətli və paylanmış cache infrastrukturu təqdim edir.</p><p>Kiçik layihələrdən tutmuş milyonlarla istifadəçisi olan mikroservis sistemlərinə qədər Redis bu gün sənayedə ən geniş istifadə olunan cache həllərindən biridir.</p><p>Əgər Spring Boot tətbiqlərində performansı artırmaq istəyirsinizsə, Spring Cache + Redis kombinasiyası ən yaxşı seçimlərdən biridir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=873676a95704" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Z-Xing ilə Spring Boot-da QR Kodların Yaradılması və Oxunması]]></title>
            <link>https://medium.com/@nicat.agayev.536/z-xing-il%C9%99-spring-boot-da-qr-kodlar%C4%B1n-yarad%C4%B1lmas%C4%B1-v%C9%99-oxunmas%C4%B1-2316b25bc8c8?source=rss-8920c4b451da------2</link>
            <guid isPermaLink="false">https://medium.com/p/2316b25bc8c8</guid>
            <category><![CDATA[zxing]]></category>
            <dc:creator><![CDATA[Nijat Aghayev]]></dc:creator>
            <pubDate>Sat, 20 Jun 2026 16:23:55 GMT</pubDate>
            <atom:updated>2026-06-20T16:23:55.277Z</atom:updated>
            <content:encoded><![CDATA[<p>QR kodlar və barkodlar artıq gündəlik həyatımızın ayrılmaz hissəsinə çevrilib. Onlardan ödəniş sistemlərində, elektron biletlərdə, məhsul izləmə proseslərində və bir çox digər sahələrdə istifadə olunur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HKP5md9h84d3dpB47bKkmA.png" /></figure><p>Java ekosistemində QR kod və barkodlarla işləmək üçün ən məşhur kitabxanalardan biri <strong>Z-Xing (Zebra Crossing)</strong> hesab olunur.</p><h3>Z-Xing Nədir?</h3><p>Z-Xing (tam adı ilə <em>Zebra Crossing</em>) Java dünyasında barkod və QR kodların yaradılması (Generate) və oxunması (Decode) üçün istifadə olunan açıq mənbəli (Open Source) kitabxanadır.</p><p>İlk olaraq Google tərəfindən hazırlanmış bu kitabxana, bu gün bir çox mobil tətbiqlərdə və backend sistemlərində geniş şəkildə istifadə edilir.</p><h3>Dəstəklənən Formatlar</h3><p>Z-Xing yalnız QR kodlarla məhdudlaşmır. O, həm 1D, həm də 2D barkod formatlarını dəstəkləyir.</p><h3>1D Barkodlar</h3><ul><li>UPC-A</li><li>UPC-E</li><li>EAN-8</li><li>EAN-13</li><li>Code 39</li><li>Code 128</li><li>ITF</li></ul><p>Bu barkod növləri əsasən marketlərdə, logistika və kargo sistemlərində istifadə olunur.</p><h3>2D Barkodlar</h3><ul><li>QR Code</li><li>Data Matrix</li><li>Aztec</li><li>PDF417</li></ul><p>Bu formatlar daha böyük həcmdə məlumat saxlamaq imkanına malikdir.</p><h3>Z-Xing Necə İşləyir?</h3><h3>1. QR Kodun Yaradılması (Generate)</h3><p>Sistemə mətn, URL və ya hər hansı identifikator göndərilir. Z-Xing həmin məlumatı <strong>BitMatrix</strong> obyektinə çevirərək PNG və ya JPG formatında şəkil yaradır.</p><h3>2. QR Kodun Oxunması (Decode)</h3><p>Şəkil faylı kitabxanaya ötürülür. Z-Xing şəkli analiz edir və kodun daxilindəki məlumatı çıxararaq geri qaytarır.</p><h3>Spring Boot Layihəsində QR Kodun Yaradılması</h3><p>Gəlin sadə bir nümunə üzərində QR kod generasiya edən servis yaradaq.</p><h3>Addım 1: Dependency-lərin əlavə olunması</h3><p>pom.xml faylına aşağıdakı dependency-ləri əlavə edirik:</p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;com.google.zxing&lt;/groupId&gt;<br>    &lt;artifactId&gt;core&lt;/artifactId&gt;<br>    &lt;version&gt;3.5.3&lt;/version&gt;<br>&lt;/dependency&gt;</pre><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;com.google.zxing&lt;/groupId&gt;<br>    &lt;artifactId&gt;javase&lt;/artifactId&gt;<br>    &lt;version&gt;3.5.3&lt;/version&gt;<br>&lt;/dependency&gt;</pre><p>Burada:</p><ul><li><strong>core</strong> → QR və barkodların yaradılması və oxunması üçün əsas funksionallığı təmin edir.</li><li><strong>javase</strong> → Java-nın qrafik komponentləri ilə işləmək üçün əlavə imkanlar təqdim edir.</li></ul><h3>Addım 2: QR Kod Generator Servisinin Hazırlanması</h3><p>Bu mərhələdə QRCodeWriter sinfindən istifadə edərək mətni PNG şəklinə çevirən servis yazılır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*lW7HzDPvwaJL7PjLYg70EA.png" /></figure><p>Bu servisə göndərilən mətn QR kod şəklində generasiya olunur.</p><h3>Addım 3: REST API ilə QR Kodun Göstərilməsi</h3><p>Spring Boot Controller vasitəsilə QR kodu birbaşa brauzerdə göstərmək mümkündür.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*hKyGtYMv1YEbw-jciU38nw.png" /></figure><p>Beləliklə istifadəçi URL vasitəsilə QR kod əldə edə bilər.</p><h3>QR Kodun Oxunması (Decode)</h3><p>Bəzən isə əks prosesə ehtiyac yaranır — yəni istifadəçi tərəfindən yüklənmiş QR kodun daxilindəki məlumatı əldə etmək.</p><p>Z-Xing bu məqsəd üçün MultiFormatReader sinfini təqdim edir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*07LgTZnUbHWvPWZxToNo4g.png" /></figure><p>Bu metod şəkli analiz edir və QR kodun daxilindəki mətni geri qaytarır.</p><h3>Z-Xing-in Üstünlükləri və Çatışmazlıqları</h3><h3>Üstünlükləri</h3><h3><strong><em>Tamamilə Pulsuzdur</em></strong></h3><p>Apache 2.0 lisenziyası ilə təqdim olunur və kommersiya layihələrində rahatlıqla istifadə edilə bilər.</p><h3>Yüngül Kitabxanadır</h3><p>Əlavə ağır framework-lər və ya xüsusi serverlər tələb etmir.</p><h3>Çoxsaylı Format Dəstəyi</h3><p>Təkcə QR kod deyil, sənayedə istifadə olunan əksər barkod standartlarını dəstəkləyir.</p><h3>Çatışmazlıqları</h3><h3>Android Kamera İnteqrasiyası</h3><p>Z-Xing əsasən məlumat emalı kitabxanasıdır. Android tətbiqlərində canlı kamera ilə skan funksionallığı qurmaq üçün əlavə inteqrasiyalar tələb oluna bilər.</p><h3>Dizayn Məhdudiyyətləri</h3><p>Loqolu, rəngli və xüsusi dizayn edilmiş QR kodlar yaratmaq üçün əlavə qrafik emalına ehtiyac yaranır.</p><h3>Nəticə</h3><p>Z-Xing Java ekosistemində QR kod və barkodlarla işləmək üçün ən etibarlı və geniş istifadə olunan kitabxanalardan biridir.</p><p>Əgər Spring Boot layihənizdə:</p><ul><li>QR kod yaratmaq,</li><li>QR kod oxumaq,</li><li>Barkod generasiya etmək,</li><li>Məhsul izləmə və ya bilet sistemləri qurmaq</li></ul><p>istəyirsinizsə, Z-Xing çox yaxşı seçimdir.</p><p>Məhz buna görə də marketinq platformalarında, elektron bilet sistemlərində və anbar idarəetmə (WMS) həllərində Z-Xing sənayedə faktiki standart həllərdən biri hesab olunur.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2316b25bc8c8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Retry: Mikroservislərdə Müvəqqəti Xətalara Qarşı Müdafiə Mexanizmi]]></title>
            <link>https://medium.com/@nicat.agayev.536/spring-retry-mikroservisl%C9%99rd%C9%99-m%C3%BCv%C9%99qq%C9%99ti-x%C9%99talara-qar%C5%9F%C4%B1-m%C3%BCdafi%C9%99-mexanizmi-1bcdea802403?source=rss-8920c4b451da------2</link>
            <guid isPermaLink="false">https://medium.com/p/1bcdea802403</guid>
            <category><![CDATA[spring-retry]]></category>
            <dc:creator><![CDATA[Nijat Aghayev]]></dc:creator>
            <pubDate>Thu, 11 Jun 2026 17:43:55 GMT</pubDate>
            <atom:updated>2026-06-11T17:43:55.391Z</atom:updated>
            <content:encoded><![CDATA[<h3>Spring Retry: Mikroservislərdə Müvəqqəti Xətalara Qarşı Müdafiə Mexanizmi</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YxTiErVwXbK2Y5M26kjudQ.png" /></figure><p>Mikroservis memarlığında və ya üçüncü tərəf (third-party) API-lərlə işləyən tətbiqlərdə şəbəkə kəsintiləri, timeout-lar və müvəqqəti xətalar qaçılmazdır. Belə hallarda sistemin dərhal xəta verməsi istifadəçi təcrübəsinə və biznes proseslərinə mənfi təsir göstərə bilər.</p><p>Bu problemi həll etmək üçün Spring ekosistemi bizə <strong>Spring Retry</strong> kitabxanasını təqdim edir.</p><p>Təsəvvür edin ki, bir ödəniş servisinə sorğu göndərirsiniz və həmin an qarşı tərəfdə qısa müddətli şəbəkə problemi yaranır. Əgər heç bir əlavə mexanizm tətbiq edilməyibsə, tətbiqiniz dərhal exception atacaq. Spring Retry isə bu xətanı tutaraq əvvəlcədən müəyyən edilmiş qaydalara əsasən əməliyyatı avtomatik şəkildə yenidən icra etməyə çalışır.</p><p>Bu məqalədə Spring Retry-ın həm nəzəri əsaslarını, həm də Spring Boot layihəsində praktik istifadəsini nəzərdən keçirəcəyik.</p><h3>Spring Retry-ın Əsas Anlayışları</h3><p>Spring Retry istifadə edərkən aşağıdakı üç anlayışı bilmək vacibdir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oAen4RfrFpQHCOycyAtk0g.png" /></figure><h3>BackOff</h3><p>Retry cəhdləri arasında nə qədər gözləmə olacağını müəyyən edir.</p><p>Məsələn:</p><blockquote><em>Xəta baş veribsə, 2 saniyə gözlə və daha sonra yenidən cəhd et.</em></blockquote><p>Bu yanaşma qarşı tərəf servisinə ardıcıl və nəzarətsiz sorğular göndərilməsinin qarşısını alır.</p><h3>Multiplier (Eksponensial Gözləmə)</h3><p>Hər uğursuz retry cəhdindən sonra gözləmə müddətini artırmağa imkan verir.</p><p>Məsələn:</p><ul><li>1-ci cəhd uğursuz oldu → 2 saniyə gözlə</li><li>2-ci cəhd uğursuz oldu → 4 saniyə gözlə</li><li>3-cü cəhd uğursuz oldu → 8 saniyə gözlə</li></ul><p>Bu yanaşma “Exponential Backoff” adlanır və müasir mikroservis sistemlərində geniş istifadə olunur.</p><h3>Recover</h3><p>Bütün retry cəhdləri uğursuz olduqda işə düşən ehtiyat (fallback) mexanizmidir.</p><p>Başqa sözlə, bu metod sistemin tamamilə çökməsinin qarşısını alan “B Planı” rolunu oynayır.</p><h3>Spring Boot Layihəsində Praktiki Tətbiq</h3><p>Nümunə olaraq sadə bir bank servisinə müraciət ssenarisini nəzərdən keçirək.</p><h3>Addım 1: Dependency-lərin əlavə edilməsi</h3><p>Spring Retry istifadə etmək üçün aşağıdakı dependency-ləri əlavə etməliyik:</p><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;org.springframework.retry&lt;/groupId&gt;<br>    &lt;artifactId&gt;spring-retry&lt;/artifactId&gt;<br>&lt;/dependency&gt;</pre><pre>&lt;dependency&gt;<br>    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>    &lt;artifactId&gt;spring-boot-starter-aop&lt;/artifactId&gt;<br>&lt;/dependency&gt;</pre><h3>Addım 2: Retry Mexanizmini Aktivləşdirmək</h3><p>Spring Retry annotasiyalarının işləməsi üçün tətbiq səviyyəsində @EnableRetry annotasiyasını aktivləşdiririk.</p><pre>@SpringBootApplication<br>@EnableRetry<br>public class Application {<br>}</pre><h3>Addım 3: @Retryable və @Recover İstifadəsi</h3><p>İndi isə biznes məntiqində retry mexanizmini tətbiq edə bilərik.</p><p>Bank servisinə müraciət edən bir metod təsəvvür edək:</p><pre>@Retryable(<br>        value = RemoteAccessException.class,<br>        maxAttempts = 3,<br>        backoff = @Backoff(<br>                delay = 2000,<br>                multiplier = 2<br>        )<br>)<br>public String getBalance() {<br>    ...<br>}</pre><pre>@Recover<br>public String recover(RemoteAccessException ex) {<br>    return &quot;Servis hazırda əlçatan deyil.&quot;;<br>}</pre><h3>Bu proses necə işləyir?</h3><ol><li>Metod ilk dəfə çağırılır və RemoteAccessException atılır.</li><li>Spring Retry xətanı tutur və 2 saniyə gözləyir.</li><li>Metod ikinci dəfə çağırılır.</li><li>Yenidən xəta baş verərsə, bu dəfə 4 saniyə gözlənilir.</li><li>Üçüncü cəhd həyata keçirilir.</li><li>Əgər əməliyyat uğurla tamamlanarsa, nəticə qaytarılır.</li><li>Əgər bütün cəhdlər uğursuz olarsa, @Recover metodu işə düşür.</li></ol><p>Beləliklə, istifadəçi texniki exception əvəzinə idarə olunan və daha mənalı cavab əldə edir.</p><h3>RetryTemplate ilə Proqrammatik Yanaşma</h3><p>Bəzən annotasiyalar kifayət etmir və retry davranışını kod səviyyəsində idarə etmək lazım olur.</p><p>Bu məqsədlə Spring Retry bizə RetryTemplate təqdim edir.</p><p>Əvvəlcə Bean yaradırıq:</p><pre>@Bean<br>public RetryTemplate retryTemplate() {<br>    return RetryTemplate.builder()<br>            .maxAttempts(3)<br>            .fixedBackoff(2000)<br>            .build();<br>}</pre><p>Daha sonra onu istifadə edə bilərik:</p><pre>retryTemplate.execute(context -&gt; {<br>    return bankClient.getBalance();<br>});</pre><p>Bu yanaşma retry davranışına daha çevik nəzarət etməyə imkan verir.</p><h3>Best Practices və Diqqət Edilməli Məqamlar</h3><h3>1. İdempotentlik</h3><p>Retry mexanizmini yalnız idempotent əməliyyatlarda tətbiq etmək tövsiyə olunur.</p><h3>Təhlükəsiz nümunələr</h3><ul><li>GET sorğuları</li><li>Məlumat oxuma əməliyyatları</li><li>Cache yenilənməsi</li></ul><h3>Riskli nümunələr</h3><ul><li>Pul köçürmələri</li><li>Ödəniş əməliyyatları</li><li>Sifariş yaradılması</li></ul><p>Məsələn, ödəniş servisi cavabı göndərməzdən əvvəl şəbəkə kəsilərsə, əməliyyat əslində uğurla icra olunmuş ola bilər. Retry nəticəsində eyni ödəniş ikinci dəfə həyata keçirilə bilər.</p><h3>2. Thread Bloklanması</h3><p>@Retryable standart olaraq cari thread-i gözlədir.</p><p>Əgər retry müddətləri çox uzun seçilərsə:</p><ul><li>Thread-lər uzun müddət məşğul qalacaq</li><li>Sistem resursları daha çox istifadə olunacaq</li><li>Performans aşağı düşə bilər</li></ul><p>Bu səbəbdən retry parametrlərini seçərkən balanslı yanaşmaq vacibdir.</p><h3>Nəticə</h3><p>Spring Retry mikroservis və inteqrasiya əsaslı tətbiqlərdə müvəqqəti xətalara qarşı dözümlülük (resilience) təmin edən vacib vasitələrdən biridir.</p><p>Düzgün konfiqurasiya edilmiş retry mexanizmi:</p><p>✅ Müvəqqəti şəbəkə problemlərini avtomatik həll edir</p><p>✅ İstifadəçi təcrübəsini yaxşılaşdırır</p><p>✅ Sistemlərin dayanıqlığını artırır</p><p>✅ Xarici servislərlə inteqrasiyaları daha etibarlı edir</p><p>Lakin retry istifadə edərkən idempotentlik, gözləmə strategiyaları və performans təsirləri mütləq nəzərə alınmalıdır.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1bcdea802403" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Comparable vs Comparator]]></title>
            <link>https://medium.com/@nicat.agayev.536/comparable-vs-comparator-8150370729e7?source=rss-8920c4b451da------2</link>
            <guid isPermaLink="false">https://medium.com/p/8150370729e7</guid>
            <category><![CDATA[comparable-vs-comparator]]></category>
            <dc:creator><![CDATA[Nijat Aghayev]]></dc:creator>
            <pubDate>Sun, 24 May 2026 18:04:50 GMT</pubDate>
            <atom:updated>2026-05-24T18:04:50.229Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qRF8-K9OIAeceX0v7AJ7XQ.png" /></figure><p><strong>Comparable</strong> <strong>vs</strong> <strong>Comparator</strong></p><p>Java-da obyektləri çeşidləmək (sort etmək) istədiyimiz zaman qarşımıza çıxan iki ən vacib interfeys <strong>Comparable</strong> və <strong>Comparator</strong>-dur. Hər ikisi də sıralama məqsədi daşıyır, lakin yanaşmaları və istifadə ssenariləri tamamilə fərqlidir. Aralarındakı fərqə birlikdə həm nəzəri olaraq, həm də praktik olaraq baxaq:</p><p>o <strong>Comparable (Təbii Sıralama — Natural Ordering):</strong> Class-ın öz daxilində reallaşdırılır. “Bu obyektin təbii olaraq sıralanma forması budur” dediyimiz zaman istifadə olunur. Məsələn, saylar kiçikdən böyüyə, sözlər isə əlifba sırası ilə düzülür.</p><p>o <strong>Comparator (Alternativ Sıralama — Custom Ordering):</strong> Class-dan kənarda (ayrı bir class və ya lambda funksiyası olaraq) yazılır. “Mən bu obyektləri standarta görə yox, fərqli bir məntiqlə sıralamaq istəyirəm” dediyimiz zaman istifadə olunur. Məsələn, işçiləri həm ID-yə, həm maaşa, həm də ada görə ayrı-ayrı sıralamaq istəyiriksə, bizə Comparator lazımdır.</p><p>Sıralama alqoritmləri iki obyekti müqayisə edərkən riyazi olaraq 3 nəticədən birini gözləyir: Mənfi, Sıfır, və ya Müsbət rəqəm.</p><p>A) Comparable: compareTo(T o)</p><p>Comparable interfeysini implement etdiyimiz zaman tək bir obyekt qəbul edən compareTo metodunu yazmalı oluruq. Burada cari obyekt (this) ilə gələn obyekt (o) müqayisə edilir:</p><p>· this &lt; o à Mənfi bir rəqəm (məsələn, -1) qaytarır.</p><p>· this == o à 0 qaytarır.</p><p>· this &gt; o à Müsbət bir rəqəm (məsələn, 1) qaytarır.</p><p>B) Comparator: compare(T o1, T o2)</p><p>Comparator xaricdən iki fərqli obyekti (o1 və o2) qəbul edir:</p><p>· o1 &lt; o2 à Mənfi rəqəm qaytarır.</p><p>· o1 == o2 à 0 qaytarır.</p><p>· o1 &gt; o2 à Müsbət rəqəm qaytarır.</p><p><strong><em>Comparable — Natural Ordering</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/933/1*EjZNZsDE_o1IbzKhIYAGuw.png" /></figure><p><strong><em>Comparator — Custom Ordering</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/933/1*FxKl7tqBlYi-WL34mfzQtA.png" /></figure><p><strong><em>Comparator — Zəngin API (Java 8+)</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/935/1*MFgFVfIjSbEYgFE2OiydbQ.png" /></figure><p><strong><em>compareTo — düzgün implementasiya</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/913/1*o0KomL6b7HARqOoqu4cYcQ.png" /></figure><p><strong><em>TreeMap / TreeSet ilə istifadə</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/914/1*cNxFgO19cft3Tbp8yw0pfQ.png" /></figure><p><strong><em>Stream ilə Comparator</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/884/1*zEVlAicYHzNIW-T6tlfAEQ.png" /></figure><p><strong><em>Klassik tələ: String müqayisəsi</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/883/1*ffL5GSuKoqjRGXz0CLtrog.png" /></figure><p><strong><em>Müqayisəli Xülasə</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/758/1*GTQgTFnfnpq5haoG2rKo0g.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8150370729e7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[gRPC nədir? Spring Boot Mikroservislərində gRPC İstifadəsi]]></title>
            <link>https://medium.com/@nicat.agayev.536/grpc-n%C9%99dir-spring-boot-mikroservisl%C9%99rind%C9%99-grpc-i%CC%87stifad%C9%99si-f07a8185458a?source=rss-8920c4b451da------2</link>
            <guid isPermaLink="false">https://medium.com/p/f07a8185458a</guid>
            <category><![CDATA[grpc]]></category>
            <dc:creator><![CDATA[Nijat Aghayev]]></dc:creator>
            <pubDate>Sun, 17 May 2026 10:46:40 GMT</pubDate>
            <atom:updated>2026-05-17T10:46:40.905Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1PaDca-v6ILc4YJuVTmYVw.png" /></figure><p>Mikroservis arxitekturasında servislərarası kommunikasiya performansı sistemin ümumi sürətinə birbaşa təsir edir. Ənənəvi REST API-lər bu iş üçün geniş istifadə olunsa da, yüksək performans və aşağı gecikmə (low latency) tələb edən sistemlərdə gRPC daha effektiv yanaşma təqdim edir.</p><h3>gRPC nədir?</h3><p>gRPC — Google tərəfindən hazırlanmış, yüksək performanslı RPC (Remote Procedure Call) framework-üdür və Protocol Buffers (Protobuf) üzərində işləyir.</p><p>REST API əsasən HTTP/1.1 və JSON formatından istifadə edir. JSON oxunaqlı format olsa da:</p><ul><li>Şəbəkədə daha çox yer tutur</li><li>Serialization prosesi daha ağırdır</li><li>Performans baxımından limitləri var</li></ul><p>gRPC isə bu problemləri minimuma endirir.</p><h3>gRPC-nin Əsas Üstünlükləri</h3><h3>1. Protocol Buffers (Protobuf)</h3><p>gRPC məlumat ötürülməsi üçün JSON yox, binary format istifadə edir.</p><p>Bu isə:</p><ul><li>Daha kiçik payload</li><li>Daha sürətli serialization</li><li>Daha az bandwidth istifadəsi</li></ul><p>deməkdir.</p><h3>2. HTTP/2 Dəstəyi</h3><p>gRPC məcburi olaraq HTTP/2 üzərində işləyir.</p><p>HTTP/2 bizə aşağıdakı imkanları verir:</p><ul><li>Multiplexing</li><li>Header Compression</li><li>Bi-directional Streaming</li><li>Persistent Connection</li></ul><p>Bu xüsusiyyətlər performansı ciddi şəkildə artırır.</p><h3>gRPC Kommunikasiya Modelləri</h3><h3>1. Unary RPC</h3><p>Ənənəvi REST kimidir.</p><p>Client bir request göndərir, server isə bir response qaytarır.</p><h3>2. Server Streaming RPC</h3><p>Client bir request göndərir və server davamlı data stream qaytarır.</p><p>Məsələn:</p><ul><li>Birja qiymətləri</li><li>Real-time monitoring</li></ul><h3>3. Client Streaming RPC</h3><p>Client hissə-hissə məlumat göndərir, server isə sonda cavab qaytarır.</p><p>Məsələn:</p><ul><li>Böyük fayl upload-ları</li></ul><h3>4. Bi-directional Streaming RPC</h3><p>Həm client, həm də server eyni anda stream göndərə bilir.</p><p>Məsələn:</p><ul><li>Chat tətbiqləri</li><li>Real-time oyun serverləri</li></ul><h3>Praktiki olaraq gRPC tətbiq etmək üçün bizə 3 modul (və ya 3 fərqli layihə) lazımdır:</h3><ol><li><strong>Shared/Common (Proto):</strong> .proto fayllarını və generat olunacaq Java klasslarını saxlayan hissə.</li><li><strong>gRPC Server:</strong> Xidməti göstərən və məntiqləri icra edən Spring Boot tətbiqi.</li><li><strong>gRPC Client:</strong> Serverə sorğu atan digər bir Spring Boot tətbiqi (məsələn, bir REST Controller vasitəsilə).</li></ol><p>Gəl, sadə bir <strong>İstifadəçi Xidməti (UserService)</strong> yaradaq. Müştəri bizə userId göndərəcək, server isə ona istifadəçi məlumatlarını qaytaracaq (<strong>Unary RPC</strong>).</p><p><strong>Addım 1: .proto Faylının Yazılması (Common Modul)</strong></p><p>İlk öncə kontratımızı (müqaviləmizi) təyin edirik. src/main/proto/user.proto faylını yaradırıq:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/849/1*ib-yWNdzUDe5JVtYLlhdag.png" /></figure><p><em>Qeyd: Buradakı = 1, = 2 rəqəmləri dəyərlər deyil, binary formatda datanın sırasını təyin edən unikal tag-lərdir (sahə nömrələridir).</em></p><p>Bu .proto faylından Java klasslarını generat etmək üçün Maven və ya Gradle plugin-lərindən (protobuf-maven-plugin) istifadə olunur. Layihəni mvn clean compile etdikdə, lazım olan bütün Stub klassları avtomatik yaranacaq.</p><p><strong>Addım 2: gRPC Server-in Qurulması</strong></p><p>Server layihəmizin pom.xml faylına gRPC üçün xüsusi başladıcı dependency-ni əlavə edirik (ən populyar olan grpc-spring-boot-starter istifadə edəcəyik):</p><blockquote>&lt;dependency&gt;</blockquote><blockquote>&lt;groupId&gt;net.devh&lt;/groupId&gt;</blockquote><blockquote>&lt;artifactId&gt;grpc-server-spring-boot-starter&lt;/artifactId&gt;</blockquote><blockquote>&lt;version&gt;2.15.0.RELEASE&lt;/version&gt;</blockquote><blockquote>&lt;/dependency&gt;</blockquote><p>İndi isə .proto faylından generat olunmuş baza klassını (UserServiceImplBase) extend edərək real biznes məntiqimizi yazaq:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/903/1*NiCri7UtYihyXzl1BtY80w.png" /></figure><p>application.properties faylında serverin hansı portda işləyəcəyini qeyd edirik (Standart gRPC portu adətən 9090-dır):</p><p>grpc.server.port=9090</p><p><strong>Addım 3: gRPC Client-in Qurulması</strong></p><p>Client layihəmizin pom.xml faylına client dependency-ni əlavə edirik:</p><blockquote>&lt;dependency&gt;</blockquote><blockquote>&lt;groupId&gt;net.devh&lt;/groupId&gt;</blockquote><blockquote>&lt;artifactId&gt;grpc-client-spring-boot-starter&lt;/artifactId&gt;</blockquote><blockquote>&lt;version&gt;2.15.0.RELEASE&lt;/version&gt;</blockquote><blockquote>&lt;/dependency&gt;</blockquote><p>application.properties daxilində gRPC serverimizin hara müraciət edəcəyini tanıadırıq:</p><blockquote># ‘user-service’ adlı bir gRPC kanalı təyin edirik</blockquote><blockquote>grpc.client.user-service.address=static://localhost:9090</blockquote><blockquote>grpc.client.user-service.negotiationType=plaintext</blockquote><p><em>Qeyd: Real mühitdə negotiationType TLS (təhlükəsiz) olmalıdır, local inkişaf üçün plaintext istifadə edirik.</em></p><p>İndi isə bu gRPC servisini çağırmaq üçün bir REST Controller yazaq. Beləliklə, biz brauzerdən REST sorğu göndərəcəyik, bizim Client tətbiqimiz isə arxa fonda Server tətbiqi ilə gRPC (HTTP/2) vasitəsilə danışacaq.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/879/1*7Xe6H8zUIw-RvqjoA1SkCw.png" /></figure><p><strong>REST və gRPC: Hansını harda seçməli?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/813/1*lNbfm7hUyxuRF8MWISyIGQ.png" /></figure><p>gRPC, xüsusilə Spring Boot mikroservislərinin bir-biri ilə çox sürətli və aşağı gecikmə (low latency) ilə xəbərləşməsi üçün mükəmməldir. Lakin brauzerlər birbaşa HTTP/2 və Protobuf-ı tam nativ dəstəkləmədiyi üçün, Frontend (React, Angular, mobil və s.) ilə əlaqədə hələ də REST və ya GraphQL istifadə etmək daha məqsədəuyğundur. Layihə daxili (backend-to-backend) kommunikasiyada isə gRPC performansı maksimuma çatdırır.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f07a8185458a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ Java-da Garbage Collection necə işləyir?]]></title>
            <link>https://medium.com/@nicat.agayev.536/java-da-garbage-collection-nec%C9%99-i%C5%9Fl%C9%99yir-693d71e8f63e?source=rss-8920c4b451da------2</link>
            <guid isPermaLink="false">https://medium.com/p/693d71e8f63e</guid>
            <category><![CDATA[garbage-collection]]></category>
            <dc:creator><![CDATA[Nijat Aghayev]]></dc:creator>
            <pubDate>Mon, 11 May 2026 17:52:18 GMT</pubDate>
            <atom:updated>2026-05-11T17:52:18.725Z</atom:updated>
            <content:encoded><![CDATA[<p>💡 Java-da Garbage Collection necə işləyir?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jBdF0_RTsdCYWbLlWvkZlw.png" /></figure><p>Java developer olaraq yazdığımız kodun arxa tərəfində görünməyən, amma performansa ciddi təsir edən ən vacib mexanizmlərdən biri Garbage Collection (GC)-dir.</p><p>Garbage Collection — JVM-in avtomatik yaddaş idarəetmə sistemidir.</p><p>Əsas məqsədi artıq istifadə olunmayan obyektləri heap yaddaşdan silərək memory leak və yaddaş israfının qarşısını almaqdır. GC-nin əsas işləmə prinsipi: Mark and Sweep</p><p>Bunu real həyatda böyük ev təmizliyi kimi düşünün:</p><p>🟢 Əvvəl lazımlı əşyaları işarələyirsiniz</p><p>🔴 Sonra işarələnməyən hər şeyi atırsınız</p><p>JVM də tam eyni prinsiplə işləyir.</p><p>━━━━━━━━━━━━━━━━━━</p><p>🔍 Mark Phase</p><p>━━━━━━━━━━━━━━━━━━</p><p>GC Roots-dan (stack reference-lər, static field-lər və s.) başlayaraq əlçatan olan bütün obyektlər işarələnir.</p><p>Bu proses əslində graph traversal məntiqidir.</p><p>━━━━━━━━━━━━━━━━━━</p><p>🧹 Sweep Phase</p><p>━━━━━━━━━━━━━━━━━━</p><p>İşarələnməyən obyektlər “artıq istifadə olunmur” hesab edilir və heap-dən silinir.</p><p>Beləliklə yaddaş yenidən azad olunur.</p><p>✅ Üstünlükləri:</p><p>• Sadə və effektiv mexanizm</p><p>• Cyclic reference problemlərini həll edə bilir</p><p>❌ Çatışmazlığı:</p><p>• GC işləyərkən tətbiqi qısa müddətlik dayandıra bilər</p><p>(STW — Stop The World Pause)</p><p>━━━━━━━━━━━━━━━━━━</p><p>🧠 Heap Memory Structure</p><p>━━━━━━━━━━━━━━━━━━</p><p>Heap əsasən 2 hissəyə bölünür:</p><p>1️⃣ Young Generation</p><p>• Eden Space</p><p>• Survivor Space S0</p><p>• Survivor Space S1</p><p>Yeni obyektlər ilk olaraq burada yaranır.</p><p>2️⃣ Old Generation</p><p>Uzunömürlü obyektlər burada saxlanılır və daha az yoxlanılır.</p><p>━━━━━━━━━━━━━━━━━━</p><p>⚡ Minor GC</p><p>━━━━━━━━━━━━━━━━━━</p><p>Minor GC yalnız Young Generation üzərində işləyir.</p><p>📌 Necə baş verir?</p><p>• Yeni obyektlər Eden sahəsinə düşür</p><p>• Eden dolduqda Minor GC tetiklenir</p><p>• Yaşayan obyektlər Survivor Space-ə köçürülür</p><p>• Lazımsız obyektlər silinir</p><p>• Bir neçə dəfə sağ qalan obyektlər Old Generation-a promote olunur</p><p>✅ Xüsusiyyətləri:</p><p>• Çox sürətlidir</p><p>• Tez-tez baş verir</p><p>• Kiçik pause-lar yaradır</p><p>• Performansa təsiri nisbətən azdır</p><p>━━━━━━━━━━━━━━━━━━</p><p>🔥 Major GC</p><p>━━━━━━━━━━━━━━━━━━</p><p>Major GC isə Old Generation-u təmizləyir.</p><p>📌 Necə işləyir?</p><p>• Uzun müddət yaşayan obyektlər Old Gen-ə keçir</p><p>• Old Gen dolduqda Major GC başlayır</p><p>• İstifadə olunmayan obyektlər silinir</p><p>⚠️ Problem nədir?</p><p>Old Generation daha böyük olduğuna görə:</p><p>• Daha ağır prosesdir</p><p>• Daha uzun STW pause yaradır</p><p>• Performansa ciddi təsir edə bilər</p><p>🚀 Java-da əsas GC növləri</p><p>1️⃣ Serial GC</p><p>Single-thread işləyir. Kiçik tətbiqlər üçün uyğundur.</p><p>2️⃣ Parallel GC</p><p>High throughput üçün optimizasiya olunub.</p><p>3️⃣ CMS (Concurrent Mark Sweep)</p><p>Pause time azaltmağa fokuslanır.</p><p>4️⃣ G1 GC (Garbage First)</p><p>Java 9+ ilə default GC oldu.</p><p>Throughput və low pause balansını qorumağa çalışır.</p><p>Garbage Collection sadəcə “memory təmizləyən sistem” deyil.</p><p>Yaxşı GC anlayışı:</p><p>✔ performans problemlərini analiz etməyə</p><p>✔ memory leak-ləri tapmağa</p><p>✔ high-load sistemləri optimizasiya etməyə</p><p>✔ JVM tuning etməyə ciddi kömək edir.</p><p>Java developer üçün GC mövzusu “sadəcə nəzəriyyə” deyil — production sistemlərdə performansın əsas hissələrindən biridir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=693d71e8f63e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Security Principles in Java]]></title>
            <link>https://medium.com/@nicat.agayev.536/security-principles-in-java-66ad388c329d?source=rss-8920c4b451da------2</link>
            <guid isPermaLink="false">https://medium.com/p/66ad388c329d</guid>
            <category><![CDATA[security-principles]]></category>
            <dc:creator><![CDATA[Nijat Aghayev]]></dc:creator>
            <pubDate>Thu, 11 Dec 2025 18:16:48 GMT</pubDate>
            <atom:updated>2025-12-11T18:16:48.183Z</atom:updated>
            <content:encoded><![CDATA[<p>Java-da ən əsas 12 Təhlükəsizlik prinsipi mövcuddur ki, bunlar haqqında qısa məlumatlar verək:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JvCBpePUVO4DEkbUMTil9Q.png" /></figure><ol><li><strong>CIA Triad</strong> — Java təhlükəsizliyinin təməl prinsipləridir.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UNKWIISapWFxmJ6adIkJwQ.png" /></figure><p>C (Confidentiality-məxfilik) — məlumatı yalnız icazəsi olan şəxslər görə bilər. Java vasitələri: Encryption (AES), Hashing (BCrypt), Spring Security.</p><p>I (İntegrity-bütövlük) — məlumat dəyişdirilməməlidir. Java vasitələri: MessageDigest, JWT signature, HMAC.</p><p>A (Availability-əlçatanlıq) — sistem 7/24 işləmələdir. Java vasitələri: Rate limiting, DDOS qoruması, caching.</p><p>2. <strong>Principle of Least Privilege</strong> — hər bir istifadəçi, servic və proses yalnız minimum hüquqlarla işləməlidir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1g0pk1xL4rrs0pwi8vG-gQ.jpeg" /></figure><p>⚫Database user yalnız SELECT/INSERT/UPDATE görsün, DROP, ALTER yox.</p><p>⚫Spring Security-də rollar granular olsun.</p><p>⚫API-lara role-based access control (@PreAuthorize) tətbiqi.</p><p>3. <strong>Defens in Depth (Çoxqatlı müdafiə)</strong> — bir qoruma qatı sındıqda digəri sistemi qorusun. Java-da qatlar:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OGfKPgII9W3hVMxXdyPBQg.jpeg" /></figure><ul><li>Authentication → Authorization → Validation</li><li>Exception handling → Logging → Audit</li><li>WAF → Firewall → Security Filters → Cryptography</li></ul><p>4. <strong>Fail Secure/Secure by Default</strong> — sistem səhv olsa belə təhlükəsiz davranmalıdır. Java nümunəsi:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*3r6noyjZua8NwytLG3Cskg.jpeg" /></figure><ul><li>Exception zamanı <em>stack trace</em> return etməməli.</li><li>Authentication/authorization uğursuzluqlarında <em>detallı mesaj verməmək.</em></li><li>Default olaraq CSRF aktiv olmalıdır.</li></ul><p>5. <strong>İnput validation and Sanitization</strong> — istifadəçinin daxil etdiyi məlumat heç vaxt güvənilir olmamalıdır. Java üsulları:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VJdzlMyRKOw-pT4puz956w.png" /></figure><ul><li>Bean Validation (@NotBlank, @Email, @Pattern)</li><li>Whitelisting (yalnız düzgün formatı qəbul etmək)</li><li>XSS filter (Spring Security + HTML escaping)</li><li>SQL Injection qoruması (PreparedStatement/JPA parameters)</li></ul><p>6. <strong>Secure Password Handling</strong> — Javada parollar heç vaxt plain-text saxlanmamalıdır.</p><ul><li>Hashing → <strong>BCrypt</strong>, <strong>Argon2</strong>, <strong>PBKDF2</strong></li><li>Salt → BCrypt öz-özünə salt əlavə edir</li><li>Password strength validation → minimum length, special chars</li></ul><p>Qeyd: Spring Security avtomatik BCryptPasswordEncoder istifadə edir.</p><p>7.<strong> Authentication and Authorization Separation</strong> — bu iki anlayış səhv salındıqda ciddi boşluqlar yaranır:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kO-6A6PGXk-YckM9vCddRg.webp" /></figure><ul><li><strong>Authentication</strong> → kimdir? (login, token)</li><li><strong>Authorization</strong> → nə edə bilər? (roles, permissions)</li></ul><p>8. <strong>Secure Session Management</strong> — session-lar qorunmalıdır, çünki token-in oğurlanması = hesabın oğurlanması. Java-da:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eN9HztANCYj88cOe-lhJiA.avif" /></figure><ul><li>HttpOnly cookies</li><li>Secure cookies (HTTPS)</li><li>Session fixation protection</li><li>Timeout expiry</li><li>JWT expiry &amp; refresh tokens</li></ul><p>9. <strong>Cryptography Best Practies</strong> — Javada əsas qaydalar:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kZhaJQnMeCQApHwvgzGfcw.webp" /></figure><ul><li>AES-256 istifadə et</li><li>RSA 2048+ uzunluğu</li><li>SHA256 və yuxarı hashing (amma parol üçün <em>heç vaxt</em> SHA yox, yalnız BCrypt/Argon2)</li><li>Random generator → SecureRandom</li><li>Özün yazdığın crypto alqoritmi <em>qəti olmaz</em></li></ul><p>10. <strong>Secure Storage</strong> — sensitive məlumatlar heç vaxt plain saxlanmamalıdır. Java kontekstində:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*pp03wPBw-2n3SeGwWHHp_A.png" /></figure><ul><li>Password → hashing</li><li>Credit card → encryption</li><li>API keys → .env | Vault | AWS Secrets</li><li>Logs → PII data anonymization</li></ul><p>11. <strong>Loging and Auditing</strong> — sistem kritik hadisələri loglamalıdır, amma sensitive məlumat göstərməməlidir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*8GNFX0r_14_ckRQF2eblLA.webp" /></figure><p>12. <strong>Secure API Design</strong> — Java microservislərdə ən kritik hissə API dizaynıdır. Bu səbəbdən aşağıdakıları tətbiq etmək lazımdır:</p><p>· HTTPS məcburi</p><p>· Rate limiting (Bucket4J , Resilience4J)</p><p>· CORS düzgün konfiqurasiya</p><p>· API versioning</p><p>· Error standardization</p><p>· Swagger UI security</p><p>· JWT ilə stateless security aktivasiyası</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66ad388c329d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>