Spring RestTemplate Örnekleri ve Detaylı Kullanımı

Spring RestTemplate Örnekleri ve Detaylı Kullanımı

Giriş

Modern yazılım mimarilerinde, özellikle mikroservisler ve dağıtık sistemler çağında, farklı servislerin birbiriyle iletişim kurması temel bir gerekliliktir. Bu iletişim genellikle RESTful API’ler aracılığıyla gerçekleştirilir. Spring Framework, Java ekosisteminde RESTful servisleri tüketmek için çeşitli araçlar sunar ve bunlardan biri de uzun yıllardır yaygın olarak kullanılan RestTemplate‘tir.

RestTemplate, Spring Framework’ün HTTP istemcisi olarak görev yapan, senkron ve bloklayıcı bir yapıdır. RESTful API’lere HTTP istekleri göndermek, yanıtları almak ve bu yanıtları Java nesnelerine dönüştürmek için basit ve güçlü bir API sağlar. Her ne kadar Spring 5 ile birlikte asenkron ve non-bloklayıcı bir alternatif olan WebClient öne çıkmış olsa da, mevcut projelerde RestTemplate kullanımı hala oldukça yaygındır ve birçok senaryo için yeterli, anlaşılır bir çözüm sunar. Bu makalede, RestTemplate‘in ne olduğunu, nasıl kullanıldığını, temel HTTP metotlarıyla örneklerini, hata yönetimini, özelleştirme seçeneklerini ve dikkat edilmesi gereken noktaları detaylı bir şekilde inceleyeceğiz.

RestTemplate Nedir?

RestTemplate, Spring Framework’ün org.springframework.web.client paketi altında bulunan bir sınıftır. Temel amacı, RESTful servislerle etkileşim kurmak için bir arayüz sağlamaktır. Adından da anlaşılacağı gibi, bir “REST şablonu” görevi görür; yani standart HTTP metodlarını (GET, POST, PUT, DELETE vb.) kullanarak uzak sunuculara istekler göndermenizi ve alınan yanıtları kolayca işlemenizi sağlar.

RestTemplate, dahili olarak çeşitli HTTP istemci kütüphaneleriyle (örneğin, JDK’nın HttpURLConnection, Apache HttpClient, OkHttp) entegre olabilir. Varsayılan olarak JDK’nın HttpURLConnection‘ını kullanır, ancak ihtiyaca göre farklı bir istemciye geçiş yapmak mümkündür.

En önemli özelliklerinden biri, JSON veya XML gibi veri formatlarını Java nesneleri arasında otomatik olarak dönüştürme yeteneğidir. Bu, geliştiricilerin veri serileştirme ve seri durumdan çıkarma (marshalling/unmarshalling) gibi karmaşık detaylarla uğraşmak zorunda kalmadan doğrudan Java nesneleriyle çalışmasına olanak tanır. Örneğin, bir REST API’den gelen JSON yanıtını doğrudan bir User nesnesine dönüştürebilir veya bir Product nesnesini JSON formatında bir POST isteğiyle gönderebilirsiniz.

RestTemplate’in Temel Özellikleri ve Avantajları

RestTemplate‘in başlıca özellikleri ve avantajları şunlardır:

* Basit API: Kullanımı kolay ve anlaşılır bir API sunar. Her HTTP metodu için özel metotlar (örn. getForObject, postForEntity) bulunur.
* Otomatik Mesaj Dönüştürme: JSON (Jackson, GSON), XML (JAXB), String ve Form verileri gibi çeşitli formatları Java nesnelerine ve Java nesnelerinden otomatik olarak dönüştürebilir. Bu, HttpMessageConverter arayüzü sayesinde gerçekleşir.
* Hata Yönetimi: HTTP durum kodlarına (4xx istemci hataları, 5xx sunucu hataları) göre özel istisnalar fırlatarak hata yönetimini kolaylaştırır. ResponseErrorHandler arayüzü ile özelleştirilebilir hata işleme mekanizmaları sunar.
* Interceptor Desteği: ClientHttpRequestInterceptor arayüzü sayesinde, tüm giden isteklere genel işlemler (örneğin, kimlik doğrulama başlığı ekleme, loglama, yeniden deneme mekanizmaları) uygulamanıza olanak tanır.
* URL Şablonları ve Parametreler: URL’lerdeki değişkenleri (path variables) ve sorgu parametrelerini (query parameters) kolayca yönetmenizi sağlar.
* HTTP Başlıkları ve Varlık Yönetimi: HttpHeaders ve HttpEntity sınıfları aracılığıyla istek başlıklarını ve gövdesini (request body) esnek bir şekilde yapılandırmanıza imkan tanır.
* Esneklik: exchange() metodu ile tüm HTTP metodları, başlıkları ve gövde yapılandırmaları üzerinde tam kontrol sağlar.

Ortam Kurulumu

RestTemplate‘i kullanmak için temel bir Spring Boot projesine ihtiyacımız var. Eğer hali hazırda bir Spring Boot projeniz yoksa, Spring Initializr (start.spring.io) üzerinden kolayca oluşturabilirsiniz. Projenize eklemeniz gereken bağımlılıklar genellikle spring-boot-starter-web ile birlikte gelir. Bu starter, spring-web modülünü içerir ve bu da RestTemplate sınıfını barındırır. Ayrıca JSON dönüşümleri için Jackson kütüphanesi de bu starter ile otomatik olarak gelir.

Maven Bağımlılığı (pom.xml):

    org.springframework.boot
    spring-boot-starter-web

Gradle Bağımlılığı (build.gradle):

implementation 'org.springframework.boot:spring-boot-starter-web'

Bu bağımlılıkları ekledikten sonra, RestTemplate‘i kullanmaya başlayabiliriz.

RestTemplate Kullanımına Giriş

RestTemplate sınıfının bir örneğini oluşturarak HTTP istekleri göndermeye başlayabiliriz. Genellikle, RestTemplate nesnesini Spring Context’e bir @Bean olarak tanımlamak ve daha sonra ihtiyaç duyulan bileşenlere enjekte etmek (dependency injection) en iyi uygulamadır. Bu, RestTemplate‘in yaşam döngüsünü Spring’in yönetmesini sağlar ve konfigürasyonunu merkezi bir yerden yapmaya olanak tanır.

RestTemplate Konfigürasyonu:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Şimdi bu RestTemplate bean’ini herhangi bir Spring bileşenine enjekte edebilir ve kullanabiliriz. Örneğin, bir servis sınıfında:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class MyServiceClient {

    private final RestTemplate restTemplate;
    private final String API_BASE_URL = "http://localhost:8080/api"; // Örnek API URL'si

    @Autowired
    public MyServiceClient(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    // ... RestTemplate kullanım örnekleri burada olacak
}

Bu makaledeki örnekler için, basit bir REST API’si simüle eden bir Controller sınıfı da oluşturalım. Bu sayede kendi içimizde test yapabiliriz.

Örnek Model Sınıfı (User.java):

public class User {
    private Long id;
    private String name;
    private String email;

    // Constructor
    public User() {}

    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    @Override
    public String toString() {
        return "User{" +
               "id=" + id +
               ", name='" + name + '\'' +
               ", email='" + email + '\'' +
               '}';
    }
}

Örnek REST Controller (UserController.java):

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final List users = new ArrayList<>();
    private final AtomicLong counter = new AtomicLong();

    public UserController() {
        users.add(new User(counter.incrementAndGet(), "Alice", "alice@example.com"));
        users.add(new User(counter.incrementAndGet(), "Bob", "bob@example.com"));
    }

    @GetMapping
    public List getAllUsers() {
        return users;
    }

    @GetMapping("/{id}")
    public ResponseEntity getUserById(@PathVariable Long id) {
        Optional user = users.stream().filter(u -> u.getId().equals(id)).findFirst();
        return user.map(ResponseEntity::ok)
                   .orElseGet(() -> ResponseEntity.notFound().build());
    }

    @PostMapping
    public ResponseEntity createUser(@RequestBody User user) {
        user.setId(counter.incrementAndGet());
        users.add(user);
        return new ResponseEntity<>(user, HttpStatus.CREATED);
    }

    @PutMapping("/{id}")
    public ResponseEntity updateUser(@PathVariable Long id, @RequestBody User userDetails) {
        Optional userOptional = users.stream().filter(u -> u.getId().equals(id)).findFirst();
        if (userOptional.isPresent()) {
            User user = userOptional.get();
            user.setName(userDetails.getName());
            user.setEmail(userDetails.getEmail());
            return ResponseEntity.ok(user);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity deleteUser(@PathVariable Long id) {
        boolean removed = users.removeIf(user -> user.getId().equals(id));
        return removed ? ResponseEntity.noContent().build() : ResponseEntity.notFound().build();
    }
}

Temel HTTP Metotları ile Kullanım Örnekleri

RestTemplate, her bir HTTP metodu için özel olarak tasarlanmış metotlar sunar.

GET İstekleri

Veri almak için kullanılır.

* getForObject(url, responseType): Belirtilen URL’ye bir GET isteği gönderir ve yanıtı doğrudan belirtilen türdeki bir nesneye dönüştürür. Hata durumunda istisna fırlatır. HTTP başlıkları veya durum kodu gibi ek bilgilere erişim sağlamaz.

// MyServiceClient içinde
    public User getUserById(Long id) {
        String url = API_BASE_URL + "/users/{id}";
        return restTemplate.getForObject(url, User.class, id); // {id} yerine id değeri geçer
    }

    public List getAllUsers() {
        String url = API_BASE_URL + "/users";
        // List direkt olarak alınamaz, çünkü getForObject tek bir nesne bekler.
        // Bunun yerine, bir diziye dönüştürüp sonra listeye çevirmek veya ParameterizedTypeReference kullanmak gerekir.
        User[] usersArray = restTemplate.getForObject(url, User[].class);
        return usersArray != null ? List.of(usersArray) : List.of();
    }

* getForEntity(url, responseType): getForObject ile aynı işi yapar ancak yanıtı bir ResponseEntity nesnesi içinde döndürür. Bu, HTTP durum koduna, başlıklara ve yanıt gövdesine erişim sağlar.

// MyServiceClient içinde
    public ResponseEntity getUserEntityById(Long id) {
        String url = API_BASE_URL + "/users/{id}";
        return restTemplate.getForEntity(url, User.class, id);
    }

    public ResponseEntity> getAllUserEntities() {
        String url = API_BASE_URL + "/users";
        // List için ParameterizedTypeReference kullanılır.
        // exchange metodu daha uygun olsa da, getForEntity ile de yapılabilir:
        ResponseEntity response = restTemplate.getForEntity(url, User[].class);
        if (response.getStatusCode().is2xxSuccessful() && response.getBody() != null) {
            return new ResponseEntity<>(List.of(response.getBody()), response.getStatusCode());
        }
        return new ResponseEntity<>(List.of(), response.getStatusCode());
    }

URL Değişkenleri ve Sorgu Parametreleri:

// Path Variables (URL değişkenleri)
    String urlWithPathVariable = API_BASE_URL + "/users/{id}";
    User user = restTemplate.getForObject(urlWithPathVariable, User.class, 1L); // 1L, {id} yerine geçer

    // Query Parameters (Sorgu parametreleri)
    // Örnek: /api/users?name=Alice
    String urlWithQueryParam = API_BASE_URL + "/users?name={name}";
    // Not: UserController'da name ile filtreleme yok, bu sadece kullanım örneği
    User[] usersFiltered = restTemplate.getForObject(urlWithQueryParam, User[].class, "Alice");

    // Birden fazla path variable veya query parameter için Map kullanmak daha okunaklıdır.
    Map params = new HashMap<>();
    params.put("id", "1");
    User userFromMap = restTemplate.getForObject(API_BASE_URL + "/users/{id}", User.class, params);

POST İstekleri

Yeni bir kaynak oluşturmak için kullanılır.

* postForObject(url, request, responseType): Belirtilen URL’ye bir POST isteği gönderir, istek gövdesini request nesnesinden alır ve yanıtı belirtilen responseType türündeki bir nesneye dönüştürür.

// MyServiceClient içinde
    public User createUser(User newUser) {
        String url = API_BASE_URL + "/users";
        return restTemplate.postForObject(url, newUser, User.class);
    }

* postForEntity(url, request, responseType): postForObject ile aynıdır ancak yanıtı bir ResponseEntity içinde döndürür.

// MyServiceClient içinde
    public ResponseEntity createUserEntity(User newUser) {
        String url = API_BASE_URL + "/users";
        return restTemplate.postForEntity(url, newUser, User.class);
    }

* postForLocation(url, request): Bir POST isteği gönderir ve yanıt başlıklarındaki Location alanının URL’sini döndürür. Bu genellikle yeni oluşturulan kaynağın URI’sidir.

// MyServiceClient içinde
    public URI createUserAndGetLocation(User newUser) {
        String url = API_BASE_URL + "/users";
        return restTemplate.postForLocation(url, newUser);
    }

PUT İstekleri

Mevcut bir kaynağı güncellemek için kullanılır. RestTemplate‘in put metotları genellikle void döner çünkü başarılı bir güncelleme genellikle yanıt gövdesi içermez (HTTP 200 OK veya 204 No Content).

// MyServiceClient içinde
public void updateUser(Long id, User updatedUser) {
    String url = API_BASE_URL + "/users/{id}";
    restTemplate.put(url, updatedUser, id);
}

DELETE İstekleri

Bir kaynağı silmek için kullanılır. delete metotları da genellikle void döner.

// MyServiceClient içinde
public void deleteUser(Long id) {
    String url = API_BASE_URL + "/users/{id}";
    restTemplate.delete(url, id);
}

exchange() Metodu: En Esnek Seçenek

exchange() metodu, RestTemplate‘in en genel ve esnek metodudur. Her türlü HTTP metodunu, başlıkları ve istek gövdesini özelleştirmenize olanak tanır. Özellikle karmaşık senaryolar, özel başlıklar veya ResponseEntity içinde jenerik tipler (örneğin List) ile çalışırken kullanışlıdır.

exchange() metodu genellikle aşağıdaki parametreleri alır:
* url: İstek gönderilecek URL.
* method: HTTP metodu (GET, POST, PUT, DELETE vb.). HttpMethod enum’ı kullanılır.
* requestEntity: İstek başlıklarını ve/veya gövdesini içeren bir HttpEntity nesnesi.
* responseType: Yanıtın dönüştürüleceği sınıf. Jenerik tipler için ParameterizedTypeReference kullanılır.

Örnek: PUT isteğini exchange ile yapmak ve ResponseEntity almak:

// MyServiceClient içinde
public ResponseEntity updateUserWithExchange(Long id, User updatedUser) {
    String url = API_BASE_URL + "/users/{id}";
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON); // İstek içeriği JSON
    HttpEntity requestEntity = new HttpEntity<>(updatedUser, headers);

    return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, User.class, id);
}

Örnek: Jenerik tipte liste almak (List):

// MyServiceClient içinde
public ResponseEntity> getAllUsersWithExchange() {
    String url = API_BASE_URL + "/users";
    HttpHeaders headers = new HttpHeaders();
    headers.setAccept(List.of(MediaType.APPLICATION_JSON)); // JSON kabul ettiğimizi belirtiyoruz
    HttpEntity requestEntity = new HttpEntity<>(headers); // Gövde boş, sadece başlıklar

    // List gibi jenerik tipler için ParameterizedTypeReference kullanılır
    return restTemplate.exchange(
        url,
        HttpMethod.GET,
        requestEntity,
        new ParameterizedTypeReference>() {}
    );
}

ParameterizedTypeReference anonim bir iç sınıf olarak tanımlanır ve Java’nın tip silme (type erasure) özelliğini aşarak çalışma zamanında jenerik tip bilgisini korumayı sağlar.

Hata Yönetimi (Error Handling)

RestTemplate, HTTP yanıt durum kodlarına göre çeşitli istisnalar fırlatarak hata yönetimini kolaylaştırır:
* HttpClientErrorException: 4xx serisi istemci hataları (örn. 400 Bad Request, 401 Unauthorized, 404 Not Found).
* HttpServerErrorException: 5xx serisi sunucu hataları (örn. 500 Internal Server Error, 503 Service Unavailable).
* RestClientException: Diğer tüm RestTemplate ile ilgili hataların temel sınıfı (örn. bağlantı sorunları).

Varsayılan olarak, RestTemplate bir HTTP yanıtı 4xx veya 5xx durum kodu içerdiğinde bir istisna fırlatır. Bu istisnaları try-catch blokları kullanarak yakalayabilir ve uygun şekilde işleyebilirsiniz.

import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.HttpServerErrorException;
import org.springframework.web.client.ResourceAccessException; // Bağlantı hataları için

// MyServiceClient içinde
public User getUserSafely(Long id) {
    String url = API_BASE_URL + "/users/{id}";
    try {
        return restTemplate.getForObject(url, User.class, id);
    } catch (HttpClientErrorException e) {
        if (e.getStatusCode().is4xxClientError()) {
            System.err.println("Client error: " + e.getResponseBodyAsString());
            // Belirli bir 404 hatasını işleyebiliriz
            if (e.getStatusCode() == HttpStatus.NOT_FOUND) {
                System.out.println("User with ID " + id + " not found.");
                return null; // Veya özel bir hata nesnesi döndür
            }
        }
        throw e; // Diğer client hatalarını yeniden fırlat
    } catch (HttpServerErrorException e) {
        System.err.println("Server error: " + e.getResponseBodyAsString());
        throw e; // Sunucu hatalarını yeniden fırlat
    } catch (ResourceAccessException e) {
        System.err.println("Network or connection error: " + e.getMessage());
        throw e; // Ağ hatalarını yeniden fırlat
    }
}

ResponseErrorHandler ile Özelleştirilmiş Hata Yönetimi:
Varsayılan hata işleme davranışını değiştirmek isterseniz, ResponseErrorHandler arayüzünü implemente edebilir ve RestTemplate‘e set edebilirsiniz. Bu, örneğin belirli durum kodlarını hata olarak kabul etmemek veya özel hata yanıtlarını ayrıştırmak için kullanılabilir.

import org.springframework.http.client.ClientHttpResponse;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.ResponseErrorHandler;

import java.io.IOException;

public class CustomResponseErrorHandler extends DefaultResponseErrorHandler {
    @Override
    public void handleError(ClientHttpResponse response) throws IOException {
        // Eğer 404 hatası ise istisna fırlatma
        if (response.getStatusCode().series() == HttpStatus.Series.CLIENT_ERROR
            && response.getStatusCode() == HttpStatus.NOT_FOUND) {
            System.out.println("Ignoring 404 Not Found error.");
            return; // Hata olarak işlemeyi durdur
        }
        // Diğer hataları varsayılan şekilde işle
        super.handleError(response);
    }
}

// RestTemplateConfig içinde
@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.setErrorHandler(new CustomResponseErrorHandler()); // Özel hata işleyiciyi ayarla
        return restTemplate;
    }
}

HTTP Başlıkları ve İstek Gövdesi

HttpHeaders ve HttpEntity sınıfları, istek başlıklarını ve gövdesini manipüle etmek için kullanılır.

* HttpHeaders: İstek veya yanıt başlıklarını temsil eder. add(), set(), setContentType(), setAccept() gibi metotları vardır.

HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON); // İstek gövdesinin JSON olduğunu belirtir
    headers.set("Authorization", "Bearer my_jwt_token"); // Yetkilendirme başlığı ekler
    headers.setAccept(List.of(MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON)); // Hangi formatları kabul ettiğini belirtir

* HttpEntity: HTTP isteğinin veya yanıtının başlıklarını ve gövdesini bir arada tutan bir kapsayıcıdır.

// Sadece başlıkları olan bir istek varlığı
    HttpEntity entityWithHeadersOnly = new HttpEntity<>(headers);

    // Başlıkları ve gövdesi olan bir istek varlığı
    User newUser = new User(null, "Charlie", "charlie@example.com");
    HttpEntity entityWithBodyAndHeaders = new HttpEntity<>(newUser, headers);

    // Bu entity'ler postForEntity, exchange gibi metotlarda kullanılır.
    ResponseEntity response = restTemplate.exchange(
        API_BASE_URL + "/users",
        HttpMethod.POST,
        entityWithBodyAndHeaders,
        User.class
    );

Kimlik Doğrulama (Authentication):
Basic Auth veya Bearer Token gibi kimlik doğrulama mekanizmaları genellikle HttpHeaders aracılığıyla yönetilir.

// Basic Authentication
public HttpHeaders createBasicAuthHeaders(String username, String password) {
    HttpHeaders headers = new HttpHeaders();
    String auth = username + ":" + password;
    byte[] encodedAuth = Base64.getEncoder().encode(auth.getBytes(Charset.forName("US-ASCII")));
    String authHeader = "Basic " + new String(encodedAuth);
    headers.set("Authorization", authHeader);
    return headers;
}

// Bearer Token Authentication
public HttpHeaders createBearerAuthHeaders(String token) {
    HttpHeaders headers = new HttpHeaders();
    headers.set("Authorization", "Bearer " + token);
    return headers;
}

Mesaj Dönüştürücüler (Message Converters)

RestTemplate, HTTP istek ve yanıt gövdelerini Java nesneleri arasında dönüştürmek için HttpMessageConverter arayüzünü kullanır. Spring Boot, varsayılan olarak birçok yaygın dönüştürücüyü (örneğin JSON için MappingJackson2HttpMessageConverter, String için StringHttpMessageConverter) otomatik olarak kaydeder.

Özel bir dönüştürücü eklemeniz veya varsayılanları değiştirmeniz gerekirse, RestTemplate‘in getMessageConverters() metodunu kullanarak dönüştürücü listesine erişebilirsiniz.

// RestTemplateConfig içinde
@Bean
public RestTemplate restTemplate() {
    RestTemplate restTemplate = new RestTemplate();
    // Varsayılan dönüştürücüleri koru ve yeni bir tane ekle (örneğin, XML için JAXB)
    // Eğer pom.xml'de spring-boot-starter-web zaten varsa, Jackson ve String dönüştürücüler zaten olacaktır.
    // JAXB için ayrı bir bağımlılık gerekebilir:
    //  jakarta.xml.bind jakarta.xml.bind-api 
    //  org.glassfish.jaxb jaxb-runtime 

    // restTemplate.getMessageConverters().add(new MappingJackson2XmlHttpMessageConverter());
    // veya mevcut dönüştürücüleri temizleyip kendi listenizi oluşturabilirsiniz:
    // restTemplate.setMessageConverters(List.of(new StringHttpMessageConverter(), new MappingJackson2HttpMessageConverter()));
    return restTemplate;
}

Interceptor’lar (RestTemplate Interceptors)

ClientHttpRequestInterceptor arayüzü, RestTemplate‘in giden isteklerini ve gelen yanıtlarını yakalamak ve işlemek için güçlü bir mekanizma sunar. Bu, isteklere ortak başlıklar eklemek, loglama yapmak, yeniden deneme mantığı uygulamak veya istekleri değiştirmek gibi senaryolar için idealdir.

Bir interceptor oluşturmak için ClientHttpRequestInterceptor arayüzünü implemente etmeniz gerekir:

import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;

import java.io.IOException;

public class LoggingInterceptor implements ClientHttpRequestInterceptor {
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        System.out.println("Request URL: " + request.getURI());
        System.out.println("Request Method: " + request.getMethod());
        System.out.println("Request Headers: " + request.getHeaders());
        System.out.println("Request Body: " + new String(body, java.nio.charset.StandardCharsets.UTF_8));

        ClientHttpResponse response = execution.execute(request, body); // İsteği devam ettir

        System.out.println("Response Status Code: " + response.getStatusCode());
        System.out.println("Response Headers: " + response.getHeaders());
        // Yanıt gövdesini okumak biraz daha karmaşık olabilir, çünkü akış sadece bir kez okunabilir.
        // Genellikle yanıt gövdesini loglamak için özel bir ClientHttpResponse wrapper'ı kullanılır.
        return response;
    }
}

Interceptor’ı RestTemplate‘e eklemek:

// RestTemplateConfig içinde
import java.util.Collections;

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        // Bir veya daha fazla interceptor ekleyebilirsiniz
        restTemplate.setInterceptors(Collections.singletonList(new LoggingInterceptor()));
        // restTemplate.getInterceptors().add(new AnotherInterceptor()); // Mevcutlara eklemek için
        return restTemplate;
    }
}

Bu şekilde, restTemplate ile yapılan her istek ve yanıt LoggingInterceptor tarafından işlenecektir.

RestTemplate ve WebClient Karşılaştırması (Kısaca)

Spring 5 ile birlikte tanıtılan WebClient, RestTemplate‘e modern, reaktif ve non-bloklayıcı bir alternatif sunar. Her ikisi de HTTP istemcisi olmasına rağmen, temel mimarileri ve kullanım senaryoları farklıdır:

* RestTemplate:
* Senkron ve Bloklayıcı: İstek gönderildiğinde, yanıt gelene kadar mevcut iş parçacığı (thread) bloke olur.
* Basitlik: Doğrudan ve anlaşılır bir API sunar, özellikle basit istekler ve yanıtlar için kolaydır.
* Eski Projeler: Mevcut birçok Spring projesinde hala yaygın olarak kullanılmaktadır.
* Bakım Modunda: Spring ekibi tarafından yeni özellikler eklenmeyeceği ve sadece hata düzeltmeleri alacağı belirtilmiştir. Yeni projeler için önerilmez.

* WebClient:
* Asenkron ve Non-Bloklayıcı: İstek gönderildikten sonra iş parçacığı bloke olmaz, diğer işlemlere devam edebilir. Yanıt geldiğinde bir geri çağırma (callback) veya reaktif akış (Flux/Mono) ile işlenir.
* Reaktif Programlama: Spring WebFlux ile uyumlu, ölçeklenebilirlik ve performans açısından avantajlıdır.
* Modern Uygulamalar: Mikroservis mimarileri, yüksek performanslı API ağ geçitleri ve olay tabanlı sistemler için daha uygundur.
* Gelecek: Spring ekibi tarafından yeni projeler için önerilen HTTP istemcisidir.

Ne Zaman Hangisi Kullanılmalı?
* Eğer mevcut bir projeniz varsa ve RestTemplate zaten kullanılıyorsa, küçük değişiklikler için RestTemplate kullanmaya devam etmek mantıklı olabilir.
* Eğer projeniz Spring Boot 2.x veya öncesi bir versiyondaysa ve reaktif programlama paradigma geçmeyi düşünmüyorsanız, RestTemplate hala işinizi görebilir.
* Ancak, yeni bir proje geliştiriyorsanız veya mevcut bir projenin performansını ve ölçeklenebilirliğini artırmak istiyorsanız, kesinlikle WebClient‘ı tercih etmelisiniz. WebClient, daha az kaynakla daha fazla eşzamanlı bağlantıyı yönetebilir.

Sonuç

Spring RestTemplate, Spring Framework’ün RESTful servislerle iletişim kurmak için sunduğu köklü ve güvenilir bir araçtır. Bu makalede, RestTemplate‘in temel konfigürasyonundan başlayarak, GET, POST, PUT, DELETE gibi temel HTTP metotlarının nasıl kullanılacağına, exchange() metodu ile esnek istekler oluşturmaya, hata yönetimine, HTTP başlıkları ve gövdesiyle çalışmaya, mesaj dönüştürücülerine ve interceptor’lar aracılığıyla istekleri özelleştirmeye kadar geniş bir yelpazede örnekler sunduk.

RestTemplate‘in basit ve sezgisel API’si, birçok geliştirici için REST API entegrasyonlarını hızlı ve etkili bir şekilde gerçekleştirmeyi kolaylaştırmıştır. Özellikle senkron ve bloklayıcı operasyonların yeterli olduğu, performansın ultra kritik olmadığı veya reaktif bir mimariye geçişin planlanmadığı durumlarda hala geçerli bir seçenektir.

Ancak, Spring ekibinin RestTemplate‘i bakım moduna alıp WebClient‘ı yeni projeler için önermesi, gelecekteki geliştirme stratejilerinde dikkate alınması gereken önemli bir noktadır. Modern, yüksek performanslı ve reaktif uygulamalar geliştiriyorsanız, WebClient‘ın sunduğu asenkron ve non-bloklayıcı yetenekleri değerlendirmeniz şiddetle tavsiye edilir. Yine de, RestTemplate‘i anlamak ve kullanabilmek, mevcut projelerle çalışırken veya eski sistemlerle entegrasyon yaparken değerli bir beceridir. Bu makale, RestTemplate‘in güçlü yönlerini ve kullanım detaylarını anlamanız için kapsamlı bir rehber sağlamıştır.