Servlet İstisnaları ve Hata Yönetimi: Kapsamlı Bir Rehber ve Örnek Uygulama

Giriş

Web uygulamaları günümüz dijital dünyasının temel taşlarından biridir ve bu uygulamaların kararlı, güvenilir ve kullanıcı dostu olması büyük önem taşır. Java tabanlı web uygulamaları geliştirmede Servlet’ler, sunucu tarafı mantığını uygulamak için güçlü bir API sunar. Ancak, her yazılımda olduğu gibi, Servlet tabanlı uygulamalarda da çalışma zamanı hataları ve istisnalar kaçınılmazdır. Bu istisnaların doğru bir şekilde yönetilmesi, uygulamanın çökmesini engellemek, kullanıcıya anlamlı geri bildirimler sunmak ve geliştiricilerin sorunları daha kolay teşhis etmesini sağlamak için kritik öneme sahiptir. Bu makale, Servlet istisna ve hata yönetiminin temel prensiplerini, çeşitli mekanizmalarını ve pratik bir örnek uygulama üzerinden nasıl hayata geçirileceğini detaylı bir şekilde ele alacaktır. Amacımız, geliştiricilere sağlam ve hataya dayanıklı Servlet uygulamaları oluşturmaları için kapsamlı bir rehber sunmaktır.

Servlet İstisna Yönetiminin Önemi

Bir web uygulamasında istisna yönetimi, sadece kodun “çalışmasını sağlamak”tan çok daha fazlasını ifade eder. Kapsamlı ve iyi düşünülmüş bir hata yönetim stratejisi, uygulamanın genel kalitesini ve sürdürülebilirliğini doğrudan etkiler.

Uygulama Kararlılığı ve Güvenilirliği

Doğru istisna yönetimi, bir hatanın tüm uygulamayı veya sunucuyu çökertmesini engeller. Beklenmedik durumlar ortaya çıktığında, uygulama gracefully bir şekilde bu durumu ele alarak çalışmaya devam edebilir veya en azından kontrollü bir şekilde hata mesajı sunarak kapanabilir. Bu, kullanıcıların kesintisiz bir deneyim yaşamasını sağlar.

Kullanıcı Deneyimi

Son kullanıcının bir hata ile karşılaştığında ne gördüğü, uygulamanın algılanan kalitesini doğrudan etkiler. Sunucu tarafından üretilen ham yığın izleri (stack traces) veya anlamsız hata kodları yerine, kullanıcı dostu ve açıklayıcı hata sayfaları sunmak, kullanıcının hayal kırıklığını azaltır ve uygulamanıza olan güvenini artırır.

Hata Teşhisi ve Bakım Kolaylığı

Geliştiriciler için, istisnaların doğru bir şekilde loglanması ve anlamlı hata mesajları üretilmesi, sorunları hızlı bir şekilde teşhis etme ve giderme sürecini büyük ölçüde hızlandırır. Üretim ortamında ortaya çıkan hataların kök nedenini bulmak, iyi bir hata yönetimi stratejisi olmadan son derece zor olabilir.

Güvenlik

Hata mesajları bazen uygulamanın iç yapısı, veritabanı şeması veya sunucu yolu gibi hassas bilgileri ifşa edebilir. Kapsamlı hata yönetimi, bu tür bilgilerin son kullanıcıya veya potansiyel kötü niyetli aktörlere sızmasını engelleyerek uygulamanın güvenlik duruşunu güçlendirir.

Servlet’lerde İstisna Türleri

Java’da olduğu gibi Servlet ortamında da istisnalar temel olarak iki ana kategoriye ayrılır: kontrol edilen (checked) ve çalışma zamanı (runtime) istisnaları. Servlet API’si ayrıca kendi özel istisna sınıflarını da tanımlar.

Çalışma Zamanı İstisnaları (Runtime Exceptions)

java.lang.RuntimeException sınıfından türeyen istisnalardır. Bunlar genellikle programlama hatalarını veya mantıksal kusurları gösterir ve derleyici tarafından kontrol edilmezler. Yani, bu istisnaları yakalamak veya bildirmek zorunlu değildir, ancak iyi bir pratik olarak yakalanmaları önerilir.
Örnekler: NullPointerException, ArrayIndexOutOfBoundsException, IllegalArgumentException, ArithmeticException (örneğin, sıfıra bölme).

Kontrol Edilen İstisnalar (Checked Exceptions)

java.lang.Exception sınıfından türeyen ancak RuntimeException olmayan istisnalardır. Bu istisnaların derleyici tarafından yakalanması (try-catch bloğu ile) veya çağrı yapan metoda bildirilmesi (throws anahtar kelimesi ile) zorunludur. Genellikle dış kaynaklarla (dosya G/Ç, veritabanı erişimi, ağ iletişimi) etkileşimde bulunurken ortaya çıkarlar.
Örnekler: IOException, SQLException, FileNotFoundException.

Servlet API İstisnaları

Servlet API, Servlet’lere özgü bazı istisna sınıfları tanımlar:

ServletException

Servlet’in işlenmesi sırasında genel bir hata oluştuğunu gösteren temel istisna sınıfıdır. Genellikle, bir Servlet içinde meydana gelen diğer istisnaları sarmalamak (wrap) için kullanılır ve bu istisnaları Servlet kapsayıcısına (container) bildirir.

UnavailableException

Bir Servlet’in geçici veya kalıcı olarak kullanılamaz hale geldiğini belirtir. Bu istisna fırlatıldığında, Servlet kapsayıcısı bu Servlet’e yapılan sonraki istekleri belirli bir süre veya süresiz olarak reddeder.

İstisna Yönetimi Mekanizmaları

Servlet uygulamalarında istisnaları yönetmek için çeşitli mekanizmalar mevcuttur. Bu mekanizmalar, istisnanın nerede oluştuğuna ve nasıl ele alınması gerektiğine bağlı olarak birlikte veya ayrı ayrı kullanılabilir.

`try-catch-finally` Blokları

Java’daki en temel istisna yönetim mekanizmasıdır. Bir Servlet’in doGet(), doPost() veya diğer metotları içinde, hata potansiyeli olan kod bloklarını try bloğuna alarak, oluşabilecek istisnaları catch bloklarında yakalayabilir ve işleyebilirsiniz. finally bloğu ise istisna oluşsa da oluşmasa da her zaman çalıştırılması gereken kodlar (örneğin kaynakları kapatma) için kullanılır.

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/tryCatchExample")
public class TryCatchExampleServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("");

        try {
            String param = request.getParameter("sayi");
            int sayi = Integer.parseInt(param); // NumberFormatException fırlatabilir
            int sonuc = 100 / sayi; // ArithmeticException fırlatabilir (sayi=0 ise)
            out.println("Sonuç: " + sonuc);
        } catch (NumberFormatException e) {
            out.println("Hata: Geçersiz sayı formatı! Lütfen bir tamsayı girin.");
            // Loglama yapılabilir: Logger.getLogger(getClass().getName()).log(Level.WARNING, "Geçersiz sayı formatı", e);
        } catch (ArithmeticException e) {
            out.println("Hata: Sıfıra bölme hatası!");
            // Loglama yapılabilir
        } catch (Exception e) { // Genel hata yakalayıcı
            out.println("Beklenmeyen bir hata oluştu: " + e.getMessage() + "");
            throw new ServletException("Servlet içinde bir hata oluştu", e); // Kapsayıcıya bildir
        } finally {
            out.println("İşlem tamamlandı.");
            out.println("");
            out.close();
        }
    }
}

`throws` Bildirimi

Bir metot içinde kontrol edilen bir istisna oluştuğunda ve bu istisna metot içinde yakalanmak istenmediğinde, istisna metot imzasında throws anahtar kelimesi ile bildirilir. Bu, istisnayı metodu çağıran üst seviyedeki koda bırakır. Servlet’lerde doGet() ve doPost() metotları varsayılan olarak ServletException ve IOException fırlatabilir olarak tanımlanır, bu da bu istisnaların kapsayıcı tarafından ele alınabileceği anlamına gelir.

protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    // Burada fırlatılan ServletException veya IOException
    // kapsayıcı tarafından ele alınacaktır.
    // Örneğin, bir dosya okuma işlemi IOException fırlatabilir.
    // Veya özel bir durum oluştuğunda ServletException fırlatılabilir.
    // throw new ServletException("Özel bir Servlet hatası oluştu.");
}

Özel Hata Sayfaları (Error Pages)

Uygulama genelinde meydana gelen ve belirli bir try-catch bloğu tarafından yakalanmayan istisnalar için, Servlet kapsayıcısı varsayılan olarak bir hata sayfası (genellikle bir yığın izi içeren beyaz bir sayfa) gösterir. Bu, hem güvenlik hem de kullanıcı deneyimi açısından istenmeyen bir durumdur. Özel hata sayfaları, bu tür durumlar için kullanıcı dostu ve bilgilendirici sayfalar sunmak amacıyla kullanılır.

`web.xml` ile Hata Sayfası Tanımlama

Servlet API, web.xml dağıtım tanımlayıcısı aracılığıyla özel hata sayfalarını yapılandırma imkanı sunar. Bu, belirli HTTP durum kodları (örneğin 404 Not Found, 500 Internal Server Error) veya belirli istisna türleri için özel hata sayfaları tanımlamanıza olanak tanır.




    
        404
        /hataSayfasi.jsp
    
    
        500
        /hataSayfasi.jsp
    
    
        java.lang.Exception
        /hataSayfasi.jsp
    
    
        javax.servlet.ServletException
        /hataSayfasi.jsp
    
    
        java.lang.ArithmeticException
        /hataSayfasi.jsp

Yukarıdaki yapılandırmada, herhangi bir java.lang.Exception (veya ondan türeyen herhangi bir istisna) veya belirli bir HTTP durum kodu (404, 500) oluştuğunda, isteğin /hataSayfasi.jsp sayfasına yönlendirileceği belirtilmiştir. Bu hata sayfasında, isteğe eklenen özel nitelikler (attributes) aracılığıyla hata hakkında detaylı bilgilere erişilebilir:
* javax.servlet.error.status_code: HTTP durum kodu (örneğin, 500).
* javax.servlet.error.exception_type: İstisna sınıfının tam adı (örneğin, java.lang.NullPointerException).
* javax.servlet.error.message: İstisna mesajı.
* javax.servlet.error.exception: İstisna nesnesinin kendisi.
* javax.servlet.error.request_uri: Hataya neden olan isteğin URI’si.
* javax.servlet.error.servlet_name: Hataya neden olan Servlet’in adı.

Programatik Hata Yönetimi (`RequestDispatcher`)

Bazı durumlarda, bir hata oluştuğunda programatik olarak bir hata sayfasına yönlendirme yapmak isteyebilirsiniz. Bu, RequestDispatcher arayüzü kullanılarak yapılabilir. Bu yaklaşım, özellikle belirli bir istisna türü için farklı hata sayfaları göstermek veya hata sayfasına özel veriler eklemek istediğinizde faydalıdır.

import javax.servlet.RequestDispatcher;

// ... doGet metodu içinde
try {
    // Hata potansiyeli olan kod
} catch (SpecificException e) {
    request.setAttribute("errorMessage", "Özel bir hata oluştu: " + e.getMessage());
    request.setAttribute("errorType", e.getClass().getName());
    RequestDispatcher dispatcher = request.getRequestDispatcher("/ozelHataSayfasi.jsp");
    dispatcher.forward(request, response);
}

`@WebServlet` ve İstisnalar

@WebServlet anonsu, Servlet’leri web.xml kullanmadan yapılandırmanın modern bir yoludur. Ancak, bu anons istisna yönetim mekanizmalarını doğrudan etkilemez. try-catch blokları, throws bildirimleri ve web.xml tabanlı hata sayfaları @WebServlet ile tanımlanmış Servlet’ler için de geçerlidir. Anonslar sadece Servlet’in URL eşlemesini ve başlatma parametrelerini tanımlar.

Örnek Uygulama: İstisna Yönetimini Gösteren Bir Servlet

Şimdi, yukarıda bahsedilen mekanizmaları bir araya getiren basit bir örnek uygulama geliştirelim. Bu uygulama, farklı senaryolarda istisnaları nasıl yöneteceğimizi gösterecektir.

Proje Kurulumu

* Proje Tipi: Maven Web Projesi
* IDE: Eclipse veya IntelliJ IDEA
* Web Sunucusu: Apache Tomcat (9.x veya üzeri)

pom.xml (Gerekli Bağımlılıklar):


    4.0.0
    com.example
    servlet-error-handling
    war
    1.0-SNAPSHOT
    servlet-error-handling Maven Webapp

    
        11
        11
        UTF-8
    

    
        
            javax.servlet
            javax.servlet-api
            4.0.1
            provided
        
    

    
        servlet-error-handling
        
            
                org.apache.maven.plugins
                maven-war-plugin
                3.3.2

`web.xml` Yapılandırması

src/main/webapp/WEB-INF/web.xml dosyasına aşağıdaki yapılandırmayı ekleyin. Bu, farklı istisna türleri ve HTTP durum kodları için /hataSayfasi.jsp adresine yönlendirme yapacaktır.




    Servlet Error Handling Example

    
    
        java.lang.Throwable 
        /hataSayfasi.jsp
    
    
        500 
        /hataSayfasi.jsp
    
    
        404 
        /hataSayfasi.jsp
    
    
        java.lang.NullPointerException
        /hataSayfasi.jsp
    
    
        java.lang.ArithmeticException
        /hataSayfasi.jsp

`HataYonetimiServlet.java`

src/main/java/com/example/HataYonetimiServlet.java dosyasını oluşturun. Bu Servlet, URL parametrelerine göre farklı istisnalar fırlatacaktır.

// src/main/java/com/example/HataYonetimiServlet.java
package com.example;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/hataTesti")
public class HataYonetimiServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();

        String hataTipi = request.getParameter("tip");
        String sayiStr = request.getParameter("sayi");

        out.println("Hata Yönetimi Testi");
        out.println("");

        try {
            if (hataTipi == null) {
                out.println("Lütfen bir hata tipi belirtin (örn: ?tip=null, ?tip=aritmetik, ?tip=servlet, ?tip=io, ?tip=sayi&sayi=0).");
            } else if (hataTipi.equals("null")) {
                String s = null;
                s.length(); // NullPointerException fırlatır
            } else if (hataTipi.equals("aritmetik")) {
                int bolen = 0;
                int sonuc = 100 / bolen; // ArithmeticException fırlatır
            } else if (hataTipi.equals("sayi")) {
                int sayi = Integer.parseInt(sayiStr); // NumberFormatException fırlatabilir
                out.println("Girilen sayı: " + sayi + "");
            } else if (hataTipi.equals("servlet")) {
                throw new ServletException("Özel bir ServletException oluştu!");
            } else if (hataTipi.equals("io")) {
                throw new IOException("Dosya okuma/yazma hatası simülasyonu.");
            } else if (hataTipi.equals("genel")) {
                throw new Exception("Genel bir hata oluştu.");
            } else {
                out.println("Geçersiz hata tipi belirtildi.");
            }
        } catch (NumberFormatException e) {
            // Bu istisnayı burada yakalıyoruz, böylece özel bir mesaj gösterebiliriz.
            // Diğer istisnalar web.xml tarafından yakalanacaktır.
            out.println("Uyarı: Geçersiz sayı formatı! Lütfen geçerli bir tamsayı girin.");
            out.println("Detay: " + e.getMessage() + "");
            // İsteği yine de hata sayfasına yönlendirebiliriz, ancak burada basit bir çıktı verdik.
        } catch (IOException e) {
            // IOException'ı burada yakalayıp ServletException olarak sarmalayıp fırlatıyoruz.
            // Böylece web.xml'deki java.lang.Throwable veya
            // javax.servlet.ServletException tarafından yakalanabilir.
            throw new ServletException("G/Ç hatası oluştu.", e);
        } catch (Exception e) {
            // Diğer tüm beklenmeyen istisnaları ServletException olarak sarmalayıp fırlatıyoruz.
            // Bu, web.xml'deki yapılandırmanın devreye girmesini sağlar.
            throw new ServletException("Beklenmeyen bir hata oluştu.", e);
        } finally {
            out.println("Servlet işleme denemesi tamamlandı.");
            out.println("");
            out.close();
        }
    }
}

`hataSayfasi.jsp`

src/main/webapp/hataSayfasi.jsp dosyasını oluşturun. Bu sayfa, web.xml‘de tanımlanan tüm hata durumları için görüntülenecektir.

<%-- src/main/webapp/hataSayfasi.jsp --%>
<%@ page isErrorPage="true" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>



    
    Bir Hata Oluştu!
    


    
        
        İsteğiniz işlenirken beklenmeyen bir hata meydana geldi. Lütfen daha sonra tekrar deneyin veya sistem yöneticinizle iletişime geçin.

        Hata Detayları
        
            HTTP Durum Kodu: <%= request.getAttribute("javax.servlet.error.status_code") %>
            Hata Mesajı: <%= request.getAttribute("javax.servlet.error.message") %>
            İstek URI: <%= request.getAttribute("javax.servlet.error.request_uri") %>
            Servlet Adı: <%= request.getAttribute("javax.servlet.error.servlet_name") %>
            İstisna Tipi: <%= request.getAttribute("javax.servlet.error.exception_type") %>
            İstisna Nesnesi: <%= request.getAttribute("javax.servlet.error.exception") %>
            
            <%
                Throwable exception = (Throwable) request.getAttribute("javax.servlet.error.exception");
                if (exception != null) {
            %>
                Yığın İzlemesi:
                                    <%
                        java.io.StringWriter sw = new java.io.StringWriter();
                        java.io.PrintWriter pw = new java.io.PrintWriter(sw);
                        exception.printStackTrace(pw);
                        out.print(sw.toString());
                    %>
                
            <%
                }
            %>
        
Ana Sayfaya Dön





Not: Üretim ortamında, Yığın İzlemesi gibi detaylı bilgilerin son kullanıcıya gösterilmemesi önemlidir. Bu örnek, eğitim amaçlıdır.
Uygulamanın Çalıştırılması ve Test Edilmesi
1.  Projeyi Maven ile derleyin (mvn clean install).

2.  Oluşan .war dosyasını Tomcat’in webapps dizinine kopyalayın veya IDE’niz üzerinden Tomcat’e deploy edin.

3.  Web tarayıcınızı açın ve aşağıdaki URL’leri deneyin:

    *   Başarılı İşlem (Hata Yok): http://localhost:8080/servlet-error-handling/hataTesti (genel mesaj gösterir)

    *   NullPointerException: http://localhost:8080/servlet-error-handling/hataTesti?tip=null

        *   web.xml‘deki java.lang.NullPointerException veya java.lang.Throwable kuralı devreye girecek ve hataSayfasi.jsp gösterilecektir.

    *   ArithmeticException (Sıfıra Bölme): http://localhost:8080/servlet-error-handling/hataTesti?tip=aritmetik

        *   web.xml‘deki java.lang.ArithmeticException veya java.lang.Throwable kuralı devreye girecek ve hataSayfasi.jsp gösterilecektir.

    *   NumberFormatException (Servlet İçinde Yakalanan): http://localhost:8080/servlet-error-handling/hataTesti?tip=sayi&sayi=abc

        *   Bu istisna Servlet içindeki try-catch bloğu tarafından yakalanacak ve özel bir uyarı mesajı doğrudan Servlet çıktısında gösterilecektir, hataSayfasi.jsp‘ye yönlendirme yapılmayacaktır.

    *   ServletException: http://localhost:8080/servlet-error-handling/hataTesti?tip=servlet

        *   web.xml‘deki java.lang.Throwable kuralı devreye girecek ve hataSayfasi.jsp gösterilecektir.

    *   IOException (Servlet İçinde Sarmalanan): http://localhost:8080/servlet-error-handling/hataTesti?tip=io

        *   Servlet içinde yakalanıp ServletException olarak sarmalandığı için yine hataSayfasi.jsp gösterilecektir.

    *   Olmayan Bir Sayfa (404 Hatası): http://localhost:8080/servlet-error-handling/olmayanbiradres

        *   web.xml‘deki 404 hata kodu kuralı devreye girecek ve hataSayfasi.jsp gösterilecektir.
Gelişmiş Hata Yönetimi Konuları
Basit try-catch blokları ve web.xml yapılandırmasının ötesinde, daha karmaşık ve büyük ölçekli uygulamalar için gelişmiş hata yönetimi stratejileri uygulanabilir.
Loglama (Logging)
Hata yönetimi, sadece kullanıcıya güzel bir sayfa göstermekle kalmaz, aynı zamanda geliştiricilerin sorunları tespit etmesini ve gidermesini sağlamak için detaylı bilgileri kaydetmeyi de içerir. Loglama çerçeveleri (örneğin Log4j, SLF4j, Java Util Logging – JUL) bu amaç için vazgeçilmezdir. Bir istisna yakalandığında, tam yığın izi ve ilgili bağlam bilgileri (kullanıcı ID’si, istek parametreleri vb.) loglanmalıdır.
import java.util.logging.Level;
import java.util.logging.Logger;

// ...
private static final Logger LOGGER = Logger.getLogger(HataYonetimiServlet.class.getName());
// ...

try {
    // Hata potansiyeli olan kod
} catch (Exception e) {
    LOGGER.log(Level.SEVERE, "HataYonetimiServlet içinde beklenmeyen bir hata oluştu.", e);
    throw new ServletException("Uygulama hatası.", e);
}
Özel İstisna Sınıfları
Uygulamanıza özgü iş mantığı hatalarını temsil etmek için kendi özel istisna sınıflarınızı oluşturmak iyi bir pratiktir. Bu, kodunuzu daha okunabilir hale getirir ve hata türlerini daha spesifik olarak ele almanızı sağlar. Örneğin, bir kullanıcı kayıt sisteminde KullaniciMevcutException veya GecersizSifreException gibi istisnalar tanımlanabilir.
public class UygulamaIsHatasi extends Exception {
    public UygulamaIsHatasi(String message) {
        super(message);
    }
    public UygulamaIsHatasi(String message, Throwable cause) {
        super(message, cause);
    }
}
Filtreler (Filters) ile Global Hata Yönetimi
Servlet filtreleri, bir isteğin Servlet’e ulaşmadan önce veya Servlet’ten ayrıldıktan sonra işlenmesini sağlayan güçlü bileşenlerdir. Bir filtre, tüm isteklere (ve dolayısıyla tüm Servlet’lere) uygulanan global bir hata yakalayıcı olarak kullanılabilir. Bu, web.xml‘deki genel  yapılandırmasına benzer bir işlevsellik sağlar, ancak daha fazla programatik kontrol sunar.
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebFilter("/*") // Tüm URL'ler için
public class GlobalErrorHandlingFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // Başlatma işlemleri
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        try {
            chain.doFilter(request, response);
        } catch (Throwable ex) {
            // Loglama yap
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "Global filtrede yakalanan hata!", ex);

            HttpServletRequest httpRequest = (HttpServletRequest) request;
            HttpServletResponse httpResponse = (HttpServletResponse) response;

            // Hata detaylarını request niteliği olarak ekle
            httpRequest.setAttribute("javax.servlet.error.exception", ex);
            httpRequest.setAttribute("javax.servlet.error.message", ex.getMessage());
            httpRequest.setAttribute("javax.servlet.error.status_code", HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
            httpRequest.setAttribute("javax.servlet.error.request_uri", httpRequest.getRequestURI());
            
            // Hata sayfasına yönlendir
            httpRequest.getRequestDispatcher("/hataSayfasi.jsp").forward(httpRequest, httpResponse);
        }
    }

    @Override
    public void destroy() {
        // Temizleme işlemleri
    }
}
Bu filtre, chain.doFilter() çağrısı sırasında fırlatılan herhangi bir Throwable (istisna veya hata) yakalar, loglar ve isteği özel hata sayfasına yönlendirir.
Asenkron Servlet’lerde Hata Yönetimi
Servlet 3.0 ile tanıtılan asenkron işleme, uzun süren işlemleri engellemeden gerçekleştirmeye olanak tanır. Asenkron Servlet’lerde hata yönetimi, standart senkron Servlet’lerden biraz farklıdır. AsyncContext nesnesi üzerinden hataları yönetmek için AsyncListener arayüzü kullanılabilir.

AsyncListener arayüzü onComplete, onError, onStartAsync ve onTimeout metotlarını içerir. Özellikle onError metodu, asenkron işlem sırasında bir hata oluştuğunda devreye girer.
import javax.servlet.AsyncContext;
import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.logging.Level;
import java.util.logging.Logger;

@WebServlet(urlPatterns = "/asyncError", asyncSupported = true)
public class AsyncErrorServlet extends HttpServlet {
    private static final Logger LOGGER = Logger.getLogger(AsyncErrorServlet.class.getName());

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.println("");

        AsyncContext asyncContext = request.startAsync();
        asyncContext.setTimeout(5000); // 5 saniye zaman aşımı

        asyncContext.addListener(new AsyncListener() {
            @Override
            public void onComplete(AsyncEvent event) throws IOException {
                LOGGER.info("Asenkron işlem tamamlandı.");
                // asyncContext.getResponse().getWriter().println("Asenkron işlem başarıyla tamamlandı.");
                // event.getAsyncContext().complete(); // Zaten complete edildi
            }

            @Override
            public void onError(AsyncEvent event) throws IOException {
                Throwable throwable = event.getThrowable();
                LOGGER.log(Level.SEVERE, "Asenkron işlemde hata oluştu!", throwable);
                HttpServletResponse resp = (HttpServletResponse) event.getAsyncContext().getResponse();
                resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                resp.getWriter().println("Asenkron işlem sırasında bir hata oluştu: " + throwable.getMessage() + "");
                event.getAsyncContext().complete(); // Hata sonrası işlemi tamamla
            }

            @Override
            public void onStartAsync(AsyncEvent event) throws IOException {
                LOGGER.info("Asenkron işlem başladı.");
            }

            @Override
            public void onTimeout(AsyncEvent event) throws IOException {
                LOGGER.warning("Asenkron işlem zaman aşımına uğradı.");
                HttpServletResponse resp = (HttpServletResponse) event.getAsyncContext().getResponse();
                resp.setStatus(HttpServletResponse.SC_REQUEST_TIMEOUT);
                resp.getWriter().println("Asenkron işlem zaman aşımına uğradı!");
                event.getAsyncContext().complete(); // Zaman aşımı sonrası işlemi tamamla
            }
        });

        // Asenkron işlemi başka bir thread'de başlat
        asyncContext.start(() -> {
            try {
                Thread.sleep(2000); // 2 saniye beklet
                String triggerError = request.getParameter("triggerError");
                if ("true".equals(triggerError)) {
                    throw new RuntimeException("Asenkron iş parçacığında kasıtlı hata!");
                }
                asyncContext.getResponse().getWriter().println("Asenkron işlem başarıyla tamamlandı.");
            } catch (Exception e) {
                // Burada yakalanan istisnalar onError metodunu tetikleyecektir.
                // Eğer burada yakalanmazsa ve fırlatılırsa da onError tetiklenir.
                // Örneğin: throw new RuntimeException(e);
                LOGGER.log(Level.SEVERE, "Asenkron iş parçacığı hatası", e);
                // Hata oluştuğunda onError tetiklenmesi için özel olarak bir şey yapmaya gerek yok,
                // fırlatılan istisna otomatik olarak AsyncListener.onError'ı çağırır.
            } finally {
                // Eğer hata oluşmazsa veya onError'da complete edilmezse, burada complete edebiliriz.
                // Ancak onError veya onTimeout içinde complete edildiği için burada gerekli değil.
                // asyncContext.complete();
            }
        });

        out.println("Asenkron işlem başlatıldı...");
        out.println("");
        // out.close(); // Asenkron işlemlerde response'u burada kapatmayın
    }
}
Bu örnekte, /asyncError?triggerError=true çağrıldığında onError metodu devreye girerek kullanıcıya hata mesajı gösterecektir.
En İyi Uygulamalar ve Öneriler
Sağlam bir hata yönetim stratejisi oluştururken göz önünde bulundurulması gereken bazı en iyi uygulamalar:
Hata Mesajlarını Kullanıcıya Özel Hale Getirme
Son kullanıcının göreceği hata mesajları sade, anlaşılır ve eyleme dönüştürülebilir olmalıdır. Teknik detaylardan kaçınılmalı, kullanıcıya ne olduğunu ve ne yapması gerektiğini bildiren nazik bir dil kullanılmalıdır. Geliştiriciler için ise loglarda detaylı teknik bilgiler bulunmalıdır.
Güvenlik Konuları
Hata mesajları asla hassas bilgileri (veritabanı bağlantı dizeleri, API anahtarları, sunucu yolları, tam yığın izleri) ifşa etmemelidir. Bu tür bilgiler potansiyel güvenlik açıklarına yol açabilir. Üretim ortamında yığın izlerinin gösterilmesi kesinlikle önerilmez.
Performans Etkileri
İstisna fırlatma ve yakalama işlemleri, özellikle yüksek hacimli uygulamalarda performans üzerinde bir miktar yük oluşturabilir. İstisnalar, uygulamanın normal akışının bir parçası olmamalı, yalnızca olağanüstü durumlar için kullanılmalıdır. Mantıksal kontrollerle önlenebilecek durumlar için istisna fırlatmak yerine, if-else blokları kullanmak daha performanslı olabilir.
Tutarlılık
Uygulamanızın genelinde tutarlı bir hata yönetim stratejisi benimseyin. Hata sayfalarının görünümü, loglama formatı ve istisna işleme yaklaşımları tutarlı olmalıdır. Bu, hem geliştirme hem de bakım süreçlerini kolaylaştırır.
Hata Sayfası İçeriği
Hata sayfaları sadece hata mesajını göstermemelidir. Kullanıcıya ana sayfaya dönüş bağlantısı, yardım bölümüne yönlendirme veya iletişim bilgileri gibi faydalı seçenekler sunmalıdır.
Sonuç
Servlet tabanlı web uygulamalarında istisna ve hata yönetimi, uygulamanın kararlılığı, güvenilirliği, güvenliği ve kullanıcı deneyimi açısından hayati öneme sahiptir. Bu makalede, try-catch-finally bloklarından web.xml tabanlı özel hata sayfalarına, filtrelerden asenkron Servlet’lere kadar çeşitli istisna yönetim mekanizmalarını ve bunların pratik bir örnek üzerinden nasıl uygulanacağını ele aldık.
Unutulmamalıdır ki, iyi bir hata yönetimi stratejisi, sadece kodun çalışmasını sağlamakla kalmaz, aynı zamanda uygulamanın yaşam döngüsü boyunca sürdürülebilirliğini ve geliştirici verimliliğini de artırır. Geliştiricilerin, potansiyel hata senaryolarını öngörmesi, uygun yönetim mekanizmalarını seçmesi ve kullanıcıya yönelik bilgilendirici, geliştiriciye yönelik detaylı hata geri bildirimleri sağlaması, başarılı bir web uygulaması geliştirmenin anahtarıdır. Bu rehberin, Servlet uygulamalarınızda daha sağlam ve hataya dayanıklı çözümler geliştirmenize yardımcı olmasını umuyoruz.

Servlet İstisnaları ve Hata Yönetimi: Kapsamlı Bir Rehber ve Örnek Uygulama