Tagged articles
RestTemplate
66 articles · Page 1 of 1
Spring Boot 4.2.0-M1 milestone release deprecates RestTemplate in favor of RestClient, adds AMQP 1.0 support, introduces Buildpacks image-layer caching, removes deprecated APIs, fixes numerous bugs including structured logging and Kafka consumer security, and upgrades 20+ dependencies including Hibernate, Kafka, Kotlin, and Tomcat.
AMQP 1.0BuildpacksDependency Upgrades
0 likes · 7 min read

Spring Boot 4.2 deprecates RestTemplate and its related auto‑configuration, prompting a migration to the new synchronous RestClient; the author details the reasons, code transformations, incremental migration strategy, handling of HTTP errors, and the emerging Spring HTTP Service Client as a modern replacement.
HTTP ClientJavaRestClient
0 likes · 11 min read

This guide details production-grade HTTP client tuning in Spring Boot, covering RestTemplate pitfalls, HttpClient 5 configuration, connection pool sizing via Little's Law, timeout layering, HTTP/2 trade-offs, business isolation patterns, interceptor chains, graceful shutdown, and metrics-driven troubleshooting for connection leaks.
HTTP/2HttpClient 5RestTemplate
0 likes · 18 min read

The article identifies seven common performance killers in Spring Boot production—N+1 queries, unbounded thread pools, excessive logging, oversized response bodies, missing indexes, synchronous external API calls, and serial API invocations—and provides concrete code‑level solutions such as eager fetching, custom thread pools, lazy logging, DTOs, index creation, timeout configuration, and CompletableFuture parallelism.
CompletableFutureDTOLogging
0 likes · 10 min read

This guide walks through configuring comprehensive logging in Spring Boot 3.5 for eight common scenarios—including JPA SQL, transaction flow, JDBC operations, RestTemplate, RestClient, WebClient, controller requests, and Feign calls—providing concrete code samples, YAML settings, and sample output to help developers troubleshoot and monitor applications effectively.
FeignJPAJava
0 likes · 12 min read

This article walks through Spring Boot 3.5.0’s URI building tools—including UriComponents, UriBuilderFactory, encoding options, ServletUriComponentsBuilder, and MVC link generation—showing how to construct correct, automatically‑encoded URLs for RestTemplate, WebClient, and controller methods with concrete code examples and outputs.
JavaRestTemplateSpring Boot
0 likes · 8 min read

This article walks through integrating Spring Boot with Elasticsearch to enable fuzzy search, keyword highlighting, tokenized queries, and real‑time data sync, covering environment setup, Maven dependencies, application.yml configuration, entity annotations, CRUD via Repository, advanced queries with RestTemplate, IK analyzer usage, common pitfalls, and synchronization strategies.
ElasticsearchIK AnalyzerRepository
0 likes · 10 min read

The article examines the evolution from the synchronous, blocking RestTemplate to the reactive, non‑blocking WebClient in Spring Boot, detailing their design principles, code examples, performance characteristics, and guidance on when to choose each for modern microservice and high‑concurrency applications.
HTTP ClientReactive ProgrammingRestTemplate
0 likes · 10 min read

This article explains how to connect Spring Boot to external services by choosing the appropriate HTTP client (RestTemplate, Feign, WebClient), configuring beans, implementing service methods, and applying various data‑synchronization techniques such as full sync, UPSERT, incremental sync, webhook callbacks, and message‑queue based replication.
FeignIncremental SyncMessage Queue
0 likes · 20 min read

This article explains how to invoke external services from a Spring Boot application using three approaches—raw HttpClient, Spring's RestTemplate, and Feign—providing code examples, configuration steps, and tips for handling headers and tokens.
BackendFeignHttpClient
0 likes · 11 min read


java1234Jan 2, 2026 · Backend Development
This guide walks through integrating Spring Boot with external services using RestTemplate, Feign, and WebClient, then compares full, incremental, and real‑time data‑synchronization approaches, providing step‑by‑step code examples, configuration details, and practical trade‑off analysis.
FeignJavaRestTemplate
0 likes · 22 min read

This article explains Netflix's open‑source Ribbon client‑side load balancer, detailing how it intercepts @LoadBalanced RestTemplate calls, resolves service names to IPs using various algorithms, and forwards requests via HttpClient, while highlighting its key features such as in‑process balancing, multiple strategies, fault‑tolerance, and protocol support.
JavaRestTemplateRibbon
0 likes · 4 min read

Spring’s team announced that RestTemplate will be deprecated in Spring Framework 7.0 and removed later, outlining its limitations and presenting the new RestClient as a modern, fluent alternative, while also recommending WebClient for reactive scenarios and offering migration strategies for existing projects.
HTTP ClientJavaRestClient
0 likes · 6 min read

Spring announced that RestTemplate will be deprecated in Spring Framework 7.0 and removed later, outlining a migration path to the newer RestClient for synchronous use and WebClient for reactive scenarios, while providing a timeline and practical guidance for developers.
BackendJavaRestClient
0 likes · 6 min read

Spring Framework 7 will deprecate RestTemplate, outlining a migration timeline, the shortcomings of the classic HTTP client, and introducing RestClient and WebClient as modern alternatives for synchronous and reactive applications, while providing guidance for both new and legacy projects.
JavaRestClientRestTemplate
0 likes · 6 min read

This article demonstrates three methods for invoking external services in Spring Boot applications—using raw HttpClient, the RestTemplate utility, and Feign clients—providing code examples, configuration steps, and tips for handling headers and tokens to simplify integration without Dubbo.
API IntegrationFeignHttpClient
0 likes · 9 min read

Upgrading Spring Boot's RestTemplate to the NIO‑based WebClient improves concurrency and performance, but can trigger a java.lang.OutOfMemoryError: Direct buffer memory; this article explains the cause, diagnostic steps using yCrash, and how adjusting -XX:MaxDirectMemorySize resolves the issue.
Java NIOOutOfMemoryErrorRestTemplate
0 likes · 10 min read

This article explores the hierarchy of Spring Boot interception mechanisms—Filter, HandlerInterceptor, AOP, RestTemplate, Feign, and WebFilter—detailing their typical use cases, implementation code, pitfalls, and best‑practice ordering, while providing practical tips and performance monitoring advice for robust backend development.
AOPFeignInterceptor
0 likes · 8 min read

Spring WebClient, the reactive replacement for the deprecated RestTemplate in Spring 5+, offers non‑blocking I/O, functional style, streaming support, and improved error handling; this article explains its benefits, demonstrates synchronous and asynchronous request patterns, timeout configuration, and comprehensive error processing with code examples.
ErrorHandlingHTTPJava
0 likes · 12 min read

This article explains why RestTemplate is deprecated in Spring Framework 5+, outlines the advantages of the reactive WebClient such as non‑blocking I/O, functional style, streaming and improved error handling, and provides complete Java code examples for creating, configuring, and using WebClient synchronously and asynchronously, including timeout and error management.
ErrorHandlingHTTPJava
0 likes · 13 min read

Spring offers multiple HTTP clients—RestTemplate, WebClient, and the newer RestClient—each with distinct features, performance characteristics, and suitability for different scenarios, and this guide compares their core capabilities, advantages, drawbacks, and best-use cases to help developers select the optimal client for their projects.
BackendHTTP ClientJava
0 likes · 15 min read

This article demonstrates three methods for invoking external services in a Spring Boot application—using raw HttpClient, the RestTemplate utility, and Feign clients—providing code examples, configuration steps, and tips for handling headers and tokens.
APIFeignHttpClient
0 likes · 11 min read

This article reviews ten practical methods for invoking third-party HTTP services in Spring Boot 3.3, covering plain JDK URL, HttpClient, Apache HttpClient, OkHttp, RestTemplate, WebClient, RestClient, Http Interface, OpenFeign, and Gateway proxy, each with code samples and key advantages.
API IntegrationFeignHTTP Client
0 likes · 13 min read

This article demonstrates three approaches for invoking external services in Spring Boot applications—using raw HttpClient, the RestTemplate utility, and Feign clients—providing code samples, configuration steps, and tips for handling headers and tokens.
BackendFeignHttpClient
0 likes · 10 min read

This article demonstrates three practical approaches for invoking external services in a Spring Boot application—using a raw HttpClient, the RestTemplate utility, and the Feign declarative client—complete with code examples, configuration steps, and tips for handling headers and tokens.
API IntegrationFeignHttpClient
0 likes · 11 min read


IT NiukeApr 19, 2024 · Backend Development
The article explains that RestTemplate is deprecated in Spring 5+, outlines WebClient’s non‑blocking I/O, functional style, streaming support and improved error handling, and provides step‑by‑step code examples for synchronous and asynchronous requests, timeout configuration, and error processing.
JavaRestTemplateSpring
0 likes · 13 min read

This article explains why and how to replace OpenFeign with native Spring HttpInterface alternatives such as Apache HttpClient, OkHttp, and RestTemplate, covering security motivations, configuration details, code examples, and practical recommendations for microservice remote calls.
HttpClientJavaOkHttp
0 likes · 12 min read

Spring developers should replace the deprecated RestTemplate with the reactive WebClient, which offers non‑blocking I/O, a fluent functional API, streaming support, richer error handling and configurable timeouts, while still allowing synchronous calls via block(), as demonstrated by practical Spring Boot 3 code examples.
HTTPJavaRestTemplate
0 likes · 11 min read

Spring 6 offers four powerful ways to perform remote HTTP calls—WebClient, RestTemplate, HTTP Interface, and RestClient—each with distinct APIs, configuration options, and usage patterns, and this guide walks through their setup, method signatures, request handling, and error management for Java developers.
JavaRESTRestClient
0 likes · 12 min read

This article introduces multiple Java approaches for sending HTTP GET and POST requests, covering the built‑in HttpURLConnection class, Apache HttpClient, Square's OkHttp, and Spring's RestTemplate, with step‑by‑step explanations and complete code examples for each method.
BackendHTTPHttpClient
0 likes · 8 min read

This article demonstrates how to invoke external services from a Spring Boot application by using raw HttpClient, the RestTemplate utility, and Feign client, providing complete code examples, configuration steps, and tips for handling headers and tokens.
APIBackendFeign
0 likes · 9 min read

This article explains why Spring's RestTemplate has been deprecated, outlines the advantages of the non‑blocking WebClient, and provides detailed migration examples—including GET, POST, error handling, streaming, retries, custom configurations, and best‑practice guidelines for using WebClient in backend development.
JavaReactive ProgrammingRestTemplate
0 likes · 16 min read

This article explains why Spring's RestTemplate is deprecated in favor of WebClient, highlighting benefits such as non‑blocking I/O, a functional programming style, streaming support, improved error handling, and how to configure timeouts, with full code examples for synchronous and asynchronous requests.
HTTPJavaRestTemplate
0 likes · 13 min read

This article explains why RestTemplate is deprecated in Spring 5+, introduces the reactive WebClient as its replacement, outlines its advantages such as non‑blocking I/O and functional style, and provides detailed code examples for creating a client, performing synchronous and asynchronous requests, handling errors, and configuring timeouts.
HTTPJavaRestTemplate
0 likes · 10 min read

This article explains microservice service‑splitting principles, demonstrates a demo project with separate order and user services, and shows how to implement remote calls between them using Spring Boot's RestTemplate, including code examples and provider‑consumer concepts.
JavaRemote CallRestTemplate
0 likes · 9 min read

This article explains how to invoke external services from a Spring Boot application using three approaches—raw HttpClient, Spring's RestTemplate, and Feign—providing detailed code examples, configuration steps, and tips for handling headers and tokens.
HttpClientJavaRestTemplate
0 likes · 12 min read

Learn how to integrate external HTTP services in Spring Boot by using raw HttpClient, the RestTemplate utility, and declarative Feign clients, with detailed code examples, token handling, and configuration tips for each approach.
API IntegrationFeignHttpClient
0 likes · 10 min read

This article demonstrates three methods for invoking external services in Spring Boot applications—using raw HttpClient, the RestTemplate utility, and Feign clients—providing code examples, configuration steps, and usage details for each approach in production.
API IntegrationHttpClientRestTemplate
0 likes · 11 min read

This article explains how to invoke external services from a Spring Boot application using three approaches—raw HttpClient requests, Spring's RestTemplate utilities, and Feign clients—providing code examples, configuration steps, and tips for handling headers and tokens.
API IntegrationFeignHttpClient
0 likes · 9 min read

This article demonstrates three practical approaches—native HttpClient, Spring's RestTemplate, and Feign client—to invoke external services from a Spring Boot application, providing code examples, configuration details, and tips for handling authentication tokens.
API IntegrationFeignHttpClient
0 likes · 11 min read

This article explains how to invoke external APIs in a SpringBoot application using three approaches—raw HttpClient, RestTemplate, and Feign—detailing configuration, code examples for GET and POST requests, token handling, and header interception.
BackendHttpClientJava
0 likes · 9 min read

This article explains how to invoke external services from a Spring Boot application using three approaches—raw HttpClient, Spring's RestTemplate, and Feign client—providing detailed code examples, configuration steps, and tips for handling headers and tokens.
FeignHttpClientJava
0 likes · 10 min read

This article explains three methods for invoking external services in Spring Boot applications—using a raw HttpClient, the RestTemplate utility, and Feign clients—providing code examples, configuration steps, and tips for handling headers and tokens.
FeignHttpClientJava
0 likes · 8 min read

This article explains how to invoke external services from a Spring Boot application using three approaches—raw HttpClient, RestTemplate, and Feign—providing code examples, configuration steps, and tips for handling headers and tokens to ensure successful API communication.
APIFeignHttpClient
0 likes · 12 min read

This article explains microservice service‑splitting guidelines, demonstrates a small demo project with separate order‑service and user‑service modules, shows how to define independent databases, and provides step‑by‑step code for registering a RestTemplate bean and performing remote calls between services using Spring Boot.
Remote CallRestTemplateSpring Boot
0 likes · 10 min read

Learn how Spring Boot 2.6.14 simplifies calling remote REST services using RestTemplate and WebClient, including automatic configuration with RestTemplateBuilder, customization options via RestTemplateCustomizer and WebClient.Builder, and detailed code examples for building, customizing, and selecting appropriate HTTP connectors.
BackendHTTPJava
0 likes · 9 min read

This article explains microservice service‑splitting principles, demonstrates a small demo with separate order‑service and user‑service modules, shows how to define independent databases, and provides step‑by‑step code for registering a RestTemplate bean and performing remote calls between services using Spring Boot.
Remote CallRestTemplateSpring Boot
0 likes · 9 min read

Learn how to use Spring's RestTemplate and WebClient for calling REST endpoints, explore their core methods, initialization options, URI handling, header and body processing, multipart support, and underlying HttpMessageConverters, with practical code examples and migration guidance for modern Spring applications.
HTTPJavaREST
0 likes · 13 min read

This article explains multiple approaches for invoking third‑party HTTP APIs in Java, covering JDK HttpURLConnection, Apache HttpClient, CloseableHttpClient, SpringBoot RestTemplate, and OkHttp, with detailed code examples, configuration steps, and usage patterns for GET and POST requests.
APIHTTPHttpClient
0 likes · 27 min read

This tutorial demonstrates how to implement inter‑service communication in Spring Cloud using RestTemplate and Feign, covering project setup, bean configuration, three RestTemplate invocation patterns, load‑balancing with Ribbon, and switching strategies via code or configuration files.
FeignRestTemplateSpring Cloud
0 likes · 19 min read

This tutorial walks through replacing Ribbon with Spring Cloud LoadBalancer, showing how to configure dependencies, set up RestTemplate and OpenFeign clients, customize caching and request transformation, and verify load‑balanced calls using Nacos as the service registry.
LoadBalancerNacosOpenFeign
0 likes · 10 min read

This article explains what Eureka is, describes its core concepts such as registration, renewal, fetching registries, cancellation and eviction, and provides step‑by‑step instructions with code to set up a Eureka server, a service provider and a consumer using Spring Cloud, illustrating load‑balancing and cache‑refresh behavior.
EurekaRestTemplateService Discovery
0 likes · 12 min read

This article introduces Spring's RestTemplate as a simple and convenient HTTP client, compares it with java.net.URLConnection, shows how to add the required dependency, configure the bean, and demonstrates GET and POST request usage with complete code samples and explanations.
APIHTTPRestTemplate
0 likes · 10 min read

This article provides a detailed tutorial on Spring's RestTemplate class, covering its overview, setup, and extensive examples of GET, POST, file download, header handling, dynamic URL parameters, and integration with HttpClient and OkHttp, along with complete code snippets and best‑practice recommendations for backend Java development.
APIBackendHTTP
0 likes · 25 min read

This article explains the concept of load balancing, demonstrates how to register multiple Spring Cloud services, use DiscoveryClient and Feign for service calls, configure RestTemplate with @LoadBalanced, and dive into the source code of LoadBalancerInterceptor and RibbonLoadBalancerClient to customize load‑balancing strategies.
RestTemplateRibbonService Discovery
0 likes · 13 min read

This article explains how to achieve gray release routing in a Spring Cloud microservice architecture by customizing Ribbon's load‑balancing rule, using Eureka metadata, adding version information via Zuul and Feign/RestTemplate interceptors, and configuring thread‑local propagation for consistent service selection.
EurekaFeignGray Release
0 likes · 15 min read

This article explains how Nacos provides service discovery via its open API, how Spring Cloud Ribbon implements client‑side load balancing, and walks through the key source code of Ribbon, LoadBalancerInterceptor, RibbonLoadBalancerClient, ZoneAwareLoadBalancer, and Nacos server‑side handling, offering practical usage tips.
NacosRestTemplateRibbon
0 likes · 21 min read

This guide walks you through installing the Sentinel dashboard, configuring flow‑control rules, and integrating Sentinel with Spring Cloud's RestTemplate and OpenFeign to protect microservice endpoints using QPS limits and fallback strategies.
Flow ControlJavaRestTemplate
0 likes · 13 min read

This article explains how to use Spring's RestTemplate to perform GET, POST, PUT, and DELETE HTTP calls, compares getForObject with getForEntity, demonstrates parameter passing styles, and shows how to handle redirects with postForLocation, providing complete code examples for each operation.
BackendHTTPJava
0 likes · 10 min read

This article explains how to write integration tests for Spring services that call external APIs by using WireMock to mock HTTP responses, handle dynamic ports, simulate error and timeout scenarios, and adjust exception handling in RestTemplate calls.
JavaRestTemplateSpring
0 likes · 10 min read

This article compares Spring's traditional RestTemplate blocking client with the newer reactive WebClient non‑blocking client, explaining their underlying mechanisms, performance differences under concurrency, and provides complete code examples for both approaches, helping developers choose the appropriate tool for efficient HTTP calls.
HTTPJavaRestTemplate
0 likes · 8 min read

This tutorial explains how to use Spring's RestTemplate to download large files without exhausting memory, covering pitfalls of default methods, implementing a custom ResponseExtractor to stream data to disk, and adding support for resumable downloads via Range headers.
HTTPJavaLarge File Download
0 likes · 5 min read

This article demonstrates how to use Nacos for service registration and discovery in Spring Cloud and shows three convenient client consumption methods—enhanced RestTemplate, reactive WebClient, and declarative Feign—complete with configuration, code examples, and the underlying load‑balancing mechanism.
FeignRestTemplateService Discovery
0 likes · 9 min read

This tutorial explains how to implement a custom ResponseErrorHandler for Spring's RestTemplate, inject it via RestTemplateBuilder, and test it with a mock server to gracefully convert HTTP errors into meaningful application exceptions.
BackendJavaRestTemplate
0 likes · 5 min read

This guide shows how to enable Spring Cloud Sleuth in a Spring Boot microservice setup, configure Eureka discovery, add tracing dependencies, implement two simple REST services, set up application properties, run the services, and interpret the generated trace and span IDs from the console logs.
EurekaRestTemplate
0 likes · 10 min read

This guide explains how to configure Spring Cloud Ribbon with @LoadBalanced RestTemplate to add client‑side load balancing and a robust retry mechanism that automatically re‑issues failed requests across service instances.
LoadBalancingRestTemplateRetry
0 likes · 4 min read
