WebClient হলো Spring Framework-এর একটি আধুনিক এবং উন্নত HTTP ক্লায়েন্ট, যা Spring WebFlux মডিউলের অংশ। এটি নন-ব্লকিং (Non-blocking) এবং রিঅ্যাকটিভ (Reactive) পদ্ধতিতে কাজ করে। WebClient মূলত Spring-এর পুরনো RestTemplate-এর বিকল্প হিসেবে ডিজাইন করা হয়েছে, এবং এটি HTTP/HTTPS প্রোটোকলের মাধ্যমে API কল করার জন্য ব্যবহৃত হয়।

WebClient-এর বৈশিষ্ট্য

1. Non-Blocking I/O:
   WebClient সম্পূর্ণ নন-ব্লকিং পদ্ধতিতে কাজ করে, যা একাধিক HTTP রিকোয়েস্ট একই সময়ে প্রক্রিয়া করতে সক্ষম।
2. Reactive Programming Support:
   এটি Spring WebFlux এবং Project Reactor-এর সাথে রিঅ্যাকটিভ প্রোগ্রামিং সমর্থন করে।
3. Functional Style API:
   WebClient একটি ফাংশনাল API প্রদান করে, যা ক্লিন এবং সহজবোধ্য কোড লেখার সুযোগ দেয়।
4. Customizable:
   WebClient কাস্টম হেডার, কুকি, এবং টাইমআউট সেট করার সুবিধা দেয়।
5. Full HTTP Method Support:
   WebClient সমস্ত HTTP মেথড যেমন GET, POST, PUT, DELETE, এবং আরও অন্যান্য সমর্থন করে।
6. Streaming Support:
   এটি বড় ডেটা স্ট্রিমিং এবং Server-Sent Events (SSE) সমর্থন করে।

WebClient-এর ডিপেন্ডেন্সি

Spring Boot-এ WebClient ব্যবহার করতে নিচের ডিপেন্ডেন্সি যুক্ত করতে হবে:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

WebClient তৈরি পদ্ধতি

WebClient তৈরি করার জন্য তিনটি প্রধান পদ্ধতি রয়েছে:

1. Default WebClient:
   WebClient.create() ব্যবহার করে একটি সাধারণ WebClient ইনস্ট্যান্স তৈরি করা যায়।

   WebClient webClient = WebClient.create();
   

2. Base URL সহ WebClient:
   একটি নির্দিষ্ট বেস URL সেট করে WebClient তৈরি করা।

   WebClient webClient = WebClient.create("https://jsonplaceholder.typicode.com");
   

3. Customized WebClient:
   WebClient.Builder ব্যবহার করে কাস্টম হেডার, টাইমআউট, এবং অন্যান্য কনফিগারেশন যুক্ত করা।

   WebClient webClient = WebClient.builder()
           .baseUrl("https://jsonplaceholder.typicode.com")
           .defaultHeader("Authorization", "Bearer token")
           .build();
   

WebClient ব্যবহারের উদাহরণ

1. GET রিকোয়েস্ট:

import org.springframework.web.reactive.function.client.WebClient;

public class WebClientExample {
    public static void main(String[] args) {
        WebClient webClient = WebClient.create("https://jsonplaceholder.typicode.com");

        String response = webClient.get()
                .uri("/posts/1")
                .retrieve()
                .bodyToMono(String.class)
                .block(); // Blocking for demonstration (not recommended in production)

        System.out.println(response);
    }
}

2. POST রিকোয়েস্ট:

import org.springframework.web.reactive.function.client.WebClient;
import java.util.HashMap;
import java.util.Map;

public class WebClientPostExample {
    public static void main(String[] args) {
        WebClient webClient = WebClient.create("https://jsonplaceholder.typicode.com");

        Map<String, String> requestBody = new HashMap<>();
        requestBody.put("title", "foo");
        requestBody.put("body", "bar");
        requestBody.put("userId", "1");

        String response = webClient.post()
                .uri("/posts")
                .bodyValue(requestBody)
                .retrieve()
                .bodyToMono(String.class)
                .block();

        System.out.println(response);
    }
}

3. Error Handling:

import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.WebClientResponseException;

public class WebClientErrorHandlingExample {
    public static void main(String[] args) {
        WebClient webClient = WebClient.create("https://jsonplaceholder.typicode.com");

        try {
            String response = webClient.get()
                    .uri("/invalid-endpoint")
                    .retrieve()
                    .bodyToMono(String.class)
                    .block();

            System.out.println(response);
        } catch (WebClientResponseException e) {
            System.err.println("Error: " + e.getStatusCode() + " - " + e.getMessage());
        }
    }
}

WebClient এর সুবিধা

1. উচ্চ কার্যক্ষমতা: নন-ব্লকিং প্রক্রিয়া দ্রুত রেসপন্স টাইম প্রদান করে।
2. স্কেলেবিলিটি: রিঅ্যাকটিভ পদ্ধতিতে কাজ করার কারণে বড় অ্যাপ্লিকেশনেও কার্যকর।
3. সহজ কাস্টমাইজেশন: হেডার, টাইমআউট, এবং অন্যান্য সেটিংস সহজেই কাস্টমাইজ করা যায়।
4. স্ট্রিমিং এবং SSE সমর্থন: বড় ডেটা স্ট্রিমিং সহজ এবং কার্যকর।

WebClient এর সীমাবদ্ধতা

1. জটিলতা: RestTemplate-এর তুলনায় WebClient কিছুটা জটিল।
2. ব্লকিং অপারেশনের ক্ষেত্রে অকার্যকর: যদি ব্লকিং অপারেশন প্রয়োজন হয়, WebClient কম কার্যকর।
3. Dependency on WebFlux: এটি Spring WebFlux মডিউল নির্ভরশীল।

WebClient কবে ব্যবহার করবেন?

• রিঅ্যাকটিভ এবং নন-ব্লকিং অপারেশনের প্রয়োজন হলে।
• মাল্টি-থ্রেডেড পরিবেশে একাধিক API কল করতে হলে।
• স্ট্রিমিং ডেটা বা Server-Sent Events (SSE) এর জন্য।
• মাইক্রোসার্ভিস আর্কিটেকচারে একাধিক সার্ভিসের মধ্যে যোগাযোগের জন্য।

WebClient হল Spring Boot-এর আধুনিক এবং শক্তিশালী HTTP ক্লায়েন্ট। এটি মূলত উচ্চ কার্যক্ষম এবং রিঅ্যাকটিভ অ্যাপ্লিকেশন তৈরির জন্য ডিজাইন করা হয়েছে। প্রয়োজনে আরও উদাহরণ বা নির্দিষ্ট কনফিগারেশন নিয়ে আলোচনা করা যেতে পারে।

WebClient হলো Spring WebFlux-এর অংশ এবং এটি একটি আধুনিক, নন-ব্লকিং, এবং রিঅ্যাক্টিভ HTTP ক্লায়েন্ট। এটি RESTful Web Services-এর সাথে যোগাযোগ করতে ব্যবহৃত হয়। WebClient পুরোপুরি asynchronous এবং reactive স্ট্রিম সমর্থন করে। এটি ব্লকিং এবং নন-ব্লকিং উভয় প্রক্রিয়াতেই কাজ করতে পারে।

মূল বৈশিষ্ট্য:

• নন-ব্লকিং এবং asynchronous কাজের জন্য উপযোগী।
• Mono এবং Flux API সমর্থন করে, যা রিঅ্যাক্টিভ স্ট্রিমের অংশ।
• HTTP/1.1 এবং HTTP/2 প্রোটোকল সমর্থন।
• হেডার, কুকি, এবং প্রক্সি কনফিগারেশনের জন্য আরও উন্নত টুলিং।

RestTemplate কি?

RestTemplate হলো Spring Framework-এর একটি ক্লাস যা RESTful Web Services-এর সাথে যোগাযোগ করার জন্য ব্যবহৃত হয়। এটি মূলত blocking I/O-র ওপর ভিত্তি করে কাজ করে, অর্থাৎ এটি synchronous পদ্ধতিতে কাজ করে।

মূল বৈশিষ্ট্য:

• সিম্পল এবং স্ট্রেটফরোয়ার্ড।
• ব্লকিং অপারেশন করে, যা প্রতিটি HTTP কল সম্পন্ন হওয়া পর্যন্ত থ্রেডকে আটকে রাখে।
• ছোট এবং সহজ RESTful ক্লায়েন্ট তৈরি করার জন্য কার্যকর।

WebClient এবং RestTemplate-এর মধ্যে পার্থক্য

উদাহরণসমূহ

RestTemplate ব্যবহার:

@RestController
public class RestTemplateController {

    private final RestTemplate restTemplate;

    public RestTemplateController(RestTemplateBuilder builder) {
        this.restTemplate = builder.build();
    }

    @GetMapping("/fetch-data")
    public String fetchData() {
        String url = "https://jsonplaceholder.typicode.com/posts/1";
        return restTemplate.getForObject(url, String.class);
    }
}

WebClient ব্যবহার:

@RestController
public class WebClientController {

    private final WebClient webClient;

    public WebClientController(WebClient.Builder builder) {
        this.webClient = builder.baseUrl("https://jsonplaceholder.typicode.com").build();
    }

    @GetMapping("/fetch-data")
    public Mono<String> fetchData() {
        return webClient.get()
                        .uri("/posts/1")
                        .retrieve()
                        .bodyToMono(String.class);
    }
}

কোনটি কখন ব্যবহার করবেন?

উপসংহার

• WebClient হলো স্প্রিং-এর আধুনিক HTTP ক্লায়েন্ট, যা Reactive Programming এবং নন-ব্লকিং অপারেশন সমর্থন করে।
• RestTemplate সহজ এবং ব্লকিং পদ্ধতিতে কাজ করে, তবে Spring 5 থেকে এটি অবসরের পথে।
• নতুন প্রজেক্ট বা মাইক্রোসার্ভিস আর্কিটেকচারের জন্য WebClient ব্যবহার করা উচিত। তবে লিগ্যাসি প্রজেক্টে যেখানে ব্লকিং I/O যথেষ্ট, সেখানে RestTemplate এখনও উপযোগী হতে পারে।

Spring 5 থেকে WebClient ইন্ট্রোডিউস করা হয়েছে, যা Spring WebFlux-এর অংশ। এটি একটি নন-ব্লকিং, রিয়াক্টিভ HTTP ক্লায়েন্ট এবং RestTemplate-এর আধুনিক বিকল্প হিসেবে ব্যবহৃত হয়। WebClient Spring 5 থেকে শুরু করে রিয়াক্টিভ এবং ব্লকিং উভয় ধরনের API কলের জন্য ব্যবহার করা যায়।

WebClient কেন ব্যবহার করবেন?

1. নন-ব্লকিং এবং রিয়াক্টিভ প্রকৃতি:
   • WebClient সম্পূর্ণরূপে নন-ব্লকিং I/O ব্যবহার করে, যা উচ্চ কর্মক্ষমতা প্রদান করে।
   • এটি Reactive Streams-এর উপর ভিত্তি করে কাজ করে।
2. RestTemplate-এর বিকল্প:
   • RestTemplate একটি ব্লকিং ক্লায়েন্ট, যেখানে WebClient নন-ব্লকিং ও আরও দক্ষ।
3. সার্ভিস-টু-সার্ভিস কমিউনিকেশন:
   • মাইক্রোসার্ভিস আর্কিটেকচারে উচ্চ-দক্ষ HTTP ক্লায়েন্ট।
4. আধুনিক API:
   • JSON, XML, এবং অন্যান্য ডেটা ফরম্যাটের জন্য সহজ হ্যান্ডলিং।

WebClient যোগ করার জন্য Dependency

pom.xml এ নিচের নির্ভরতা যোগ করুন:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

WebClient-এর বেসিক ব্যবহার

১. WebClient তৈরি:

WebClient তৈরি করার দুটি প্রধান পদ্ধতি আছে:

• ১.১ Default Instance: সরাসরি WebClient তৈরি করা।

WebClient webClient = WebClient.create();

• ১.২ Base URL সহ তৈরি করা:

WebClient webClient = WebClient.builder()
                                .baseUrl("https://api.example.com")
                                .build();

২. API কল করার পদ্ধতি:

২.১ GET Request:

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class ApiClient {
    private final WebClient webClient;

    public ApiClient(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl("https://api.example.com").build();
    }

    public String getData(String endpoint) {
        return this.webClient.get()
                .uri(endpoint) // "/data"
                .retrieve()
                .bodyToMono(String.class) // Reactive Type
                .block(); // Blocking call
    }
}

২.২ POST Request:

public String postData(String endpoint, Object requestBody) {
    return this.webClient.post()
            .uri(endpoint)
            .bodyValue(requestBody) // Request Body
            .retrieve()
            .bodyToMono(String.class)
            .block();
}

৩. নন-ব্লকিং রিয়াক্টিভ কল (Reactive API):

নন-ব্লকিং পদ্ধতিতে block() না করে Reactive Streams ব্যবহার করা হয়।

public Mono<String> getReactiveData(String endpoint) {
    return this.webClient.get()
            .uri(endpoint)
            .retrieve()
            .bodyToMono(String.class); // Returns Mono<String>
}

WebClient কনফিগারেশন

Timeout কনফিগার করা:

WebClient webClient = WebClient.builder()
    .baseUrl("https://api.example.com")
    .clientConnector(new ReactorClientHttpConnector(
        HttpClient.create().responseTimeout(Duration.ofSeconds(5))
    ))
    .build();

Header যোগ করা:

public String getDataWithHeaders(String endpoint) {
    return this.webClient.get()
            .uri(endpoint)
            .header("Authorization", "Bearer some-token")
            .header("Custom-Header", "value")
            .retrieve()
            .bodyToMono(String.class)
            .block();
}

Error Handling:

public String getDataWithErrorHandling(String endpoint) {
    return this.webClient.get()
            .uri(endpoint)
            .retrieve()
            .onStatus(HttpStatus::is4xxClientError, clientResponse -> {
                return Mono.error(new RuntimeException("4xx Error"));
            })
            .onStatus(HttpStatus::is5xxServerError, clientResponse -> {
                return Mono.error(new RuntimeException("5xx Error"));
            })
            .bodyToMono(String.class)
            .block();
}

Reactive API Response Types

• Mono: একটি অবজেক্ট রিটার্ন করে।
• Flux: একাধিক অবজেক্ট রিটার্ন করে।

উদাহরণ:

public Flux<String> getMultipleData(String endpoint) {
    return this.webClient.get()
            .uri(endpoint)
            .retrieve()
            .bodyToFlux(String.class); // Reactive Flux
}

WebClient-এর সাহায্যে ফাইল ডাউনলোড:

public Mono<Void> downloadFile(String fileUrl, String destination) {
    return this.webClient.get()
            .uri(fileUrl)
            .retrieve()
            .bodyToMono(byte[].class)
            .doOnNext(bytes -> {
                try {
                    Files.write(Paths.get(destination), bytes);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            })
            .then();
}

WebClient-এর সুবিধা

1. নন-ব্লকিং ও পারফরম্যান্স:
   • নন-ব্লকিং I/O ব্যবহারে কর্মক্ষমতা বৃদ্ধি।
2. Reactive Streams সাপোর্ট:
   • Mono এবং Flux-এর মাধ্যমে স্ট্রিমিং ডেটা ম্যানেজমেন্ট।
3. ব্যবহার সহজ:
   • RestTemplate থেকে আরও ফিচার-সমৃদ্ধ এবং সহজ API।
4. Header এবং Authorization সহজ হ্যান্ডলিং:
   • OAuth2, JWT, এবং অন্যান্য নিরাপত্তা ফিচার সহজে ইন্টিগ্রেট করা যায়।

Spring WebFlux-এর WebClient একটি আধুনিক HTTP ক্লায়েন্ট যা RestTemplate-এর তুলনায় আরও দক্ষ এবং রিয়াক্টিভ মডেলের জন্য আদর্শ। এটি মাইক্রোসার্ভিস এবং ক্লাউড-নেটিভ অ্যাপ্লিকেশনের জন্য বিশেষভাবে উপযোগী।

WebClient হলো Spring WebFlux-এর একটি অংশ, যা Spring Framework 5.0-এ প্রবর্তিত হয়। এটি Spring Boot অ্যাপ্লিকেশনে asynchronous এবং non-blocking HTTP কল করার জন্য ব্যবহার করা হয়। WebClient RestTemplate-এর একটি আধুনিক বিকল্প এবং এটি রিয়্যাক্টিভ প্রোগ্রামিং এর ধারণা অনুসরণ করে।

WebClient এর বৈশিষ্ট্য

1. Non-blocking এবং Asynchronous:
   • HTTP কল করার সময় থ্রেড ব্লক না করে অন্যান্য কাজ চালিয়ে যেতে পারে।
2. Reactive Streams API:
   • এটি Mono এবং Flux ব্যবহার করে ডেটা প্রসেসিং করে।
3. High Performance:
   • বিশেষ করে মাইক্রোসার্ভিস আর্কিটেকচারে উচ্চতর পারফরমেন্স সরবরাহ করে।
4. Customizable:
   • সহজে হেডার, টাইমআউট, এবং অন্যান্য সেটিংস কনফিগার করা যায়।

WebClient সেটআপ এবং কনফিগারেশন

Dependency যোগ করা

আপনার pom.xml ফাইলে নিচের ডিপেন্ডেন্সি যোগ করুন:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

WebClient Bean কনফিগার করা

WebClient-এর জন্য একটি Bean তৈরি করতে পারেন:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class WebClientConfig {

    @Bean
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}

WebClient ব্যবহার: উদাহরণ

১. GET কল (Asynchronous)

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@Service
public class UserClient {

    private final WebClient webClient;

    public UserClient(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl("https://jsonplaceholder.typicode.com").build();
    }

    public Mono<String> getUserDetails() {
        return webClient.get()
                .uri("/users/1")
                .retrieve()
                .bodyToMono(String.class);
    }
}

ব্যাখ্যা:

• retrieve(): রেসপন্স রিসিভ করে।
• bodyToMono(String.class): রেসপন্সকে Mono টাইপে রূপান্তর করে, যা একক ডেটা ধারণ করে।

ক্লায়েন্ট কল করার সময়:

userClient.getUserDetails().subscribe(System.out::println);

২. POST কল (Asynchronous)

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@Service
public class UserClient {

    private final WebClient webClient;

    public UserClient(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl("https://jsonplaceholder.typicode.com").build();
    }

    public Mono<String> createUser(String name, String email) {
        return webClient.post()
                .uri("/users")
                .bodyValue(new User(name, email))
                .retrieve()
                .bodyToMono(String.class);
    }
}

ব্যবহার:

userClient.createUser("John Doe", "johndoe@example.com")
    .subscribe(System.out::println);

৩. Error Handling

WebClient-এর রেসপন্সে ত্রুটি হ্যান্ডেল করার জন্য .onStatus() ব্যবহার করা হয়।

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@Service
public class UserClient {

    private final WebClient webClient;

    public UserClient(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl("https://api.example.com").build();
    }

    public Mono<String> getUserDetailsWithErrorHandling() {
        return webClient.get()
                .uri("/users/1")
                .retrieve()
                .onStatus(
                    status -> status.is4xxClientError(),
                    response -> Mono.error(new RuntimeException("Client Error"))
                )
                .onStatus(
                    status -> status.is5xxServerError(),
                    response -> Mono.error(new RuntimeException("Server Error"))
                )
                .bodyToMono(String.class);
    }
}

৪. Custom Headers যোগ করা

public Mono<String> getUserDetailsWithHeaders() {
    return webClient.get()
            .uri("/users/1")
            .header("Authorization", "Bearer token_value")
            .retrieve()
            .bodyToMono(String.class);
}

৫. টাইমআউট কনফিগার করা

import java.time.Duration;

public Mono<String> getUserDetailsWithTimeout() {
    return webClient.get()
            .uri("/users/1")
            .retrieve()
            .bodyToMono(String.class)
            .timeout(Duration.ofSeconds(5));
}

WebClient এবং Reactive Streams

WebClient Mono এবং Flux ব্যবহার করে কাজ করে:

1. Mono:
   • একক ডেটা রিটার্ন করতে ব্যবহৃত হয়।
   • উদাহরণ: Mono<String>
2. Flux:
   • একাধিক ডেটা রিটার্ন করতে ব্যবহৃত হয়।
   • উদাহরণ: Flux<String>

WebClient vs RestTemplate

উপসংহার

WebClient Spring Boot অ্যাপ্লিকেশনে REST API কল করার জন্য একটি আধুনিক, শক্তিশালী এবং উচ্চ কার্যক্ষম টুল। এটি বিশেষ করে রিয়্যাক্টিভ প্রোগ্রামিং এবং মাইক্রোসার্ভিস আর্কিটেকচারের জন্য উপযোগী। Asynchronous এবং Non-blocking বৈশিষ্ট্যের কারণে এটি পারফরমেন্স বৃদ্ধির ক্ষেত্রে খুবই কার্যকর।

Spring Boot WebClient একটি অত্যাধুনিক HTTP ক্লায়েন্ট, যা Spring WebFlux ফ্রেমওয়ার্কের অংশ। এটি অ্যাসিনক্রোনাস এবং রিঅ্যাকটিভ প্রোগ্রামিংয়ের জন্য উপযুক্ত। নিচে উদাহরণসহ WebClient ব্যবহার সম্পর্কে বিস্তারিত আলোচনা করা হয়েছে।

১. WebClient কনফিগার করা

Spring Boot প্রজেক্টে WebClient ব্যবহার করতে চাইলে আগে spring-boot-starter-webflux ডিপেন্ডেন্সি যুক্ত করুন।

Maven Dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

WebClient Bean Configuration:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class WebClientConfig {

    @Bean
    public WebClient webClient(WebClient.Builder builder) {
        return builder
                .baseUrl("https://api.example.com")
                .build();
    }
}

২. WebClient দিয়ে HTTP কল

২.১. GET রিকোয়েস্ট উদাহরণ:

import org.springframework.web.reactive.function.client.WebClient;

public class WebClientGetExample {
    private final WebClient webClient;

    public WebClientGetExample(WebClient webClient) {
        this.webClient = webClient;
    }

    public String fetchData() {
        return webClient.get()
                .uri("/data")
                .retrieve()
                .bodyToMono(String.class) // Response body as String
                .block(); // Blocking call (for synchronous)
    }

    public static void main(String[] args) {
        WebClient webClient = WebClient.builder().baseUrl("https://api.example.com").build();
        WebClientGetExample example = new WebClientGetExample(webClient);
        String response = example.fetchData();
        System.out.println("Response: " + response);
    }
}

২.২. POST রিকোয়েস্ট উদাহরণ:

import org.springframework.web.reactive.function.client.WebClient;

public class WebClientPostExample {
    private final WebClient webClient;

    public WebClientPostExample(WebClient webClient) {
        this.webClient = webClient;
    }

    public String sendData(MyRequestBody requestBody) {
        return webClient.post()
                .uri("/data")
                .bodyValue(requestBody)
                .retrieve()
                .bodyToMono(String.class)
                .block();
    }

    public static void main(String[] args) {
        WebClient webClient = WebClient.builder().baseUrl("https://api.example.com").build();
        WebClientPostExample example = new WebClientPostExample(webClient);
        MyRequestBody requestBody = new MyRequestBody("value1", "value2");
        String response = example.sendData(requestBody);
        System.out.println("Response: " + response);
    }
}

class MyRequestBody {
    private String field1;
    private String field2;

    // Constructors, Getters, and Setters
    public MyRequestBody(String field1, String field2) {
        this.field1 = field1;
        this.field2 = field2;
    }

    public String getField1() {
        return field1;
    }

    public void setField1(String field1) {
        this.field1 = field1;
    }

    public String getField2() {
        return field2;
    }

    public void setField2(String field2) {
        this.field2 = field2;
    }
}

২.৩. PUT এবং DELETE রিকোয়েস্ট:

PUT রিকোয়েস্ট:

webClient.put()
        .uri("/data/123")
        .bodyValue(new MyRequestBody("updatedValue1", "updatedValue2"))
        .retrieve()
        .bodyToMono(Void.class)
        .block();

DELETE রিকোয়েস্ট:

webClient.delete()
        .uri("/data/123")
        .retrieve()
        .bodyToMono(Void.class)
        .block();

৩. Error Handling

WebClient-এ কাস্টম এরর হ্যান্ডলিং:

webClient.get()
        .uri("/data")
        .retrieve()
        .onStatus(status -> status.is4xxClientError(), 
                  clientResponse -> Mono.error(new RuntimeException("Client Error!")))
        .onStatus(status -> status.is5xxServerError(), 
                  clientResponse -> Mono.error(new RuntimeException("Server Error!")))
        .bodyToMono(String.class)
        .block();

৪. Token বা Header যোগ করা (Authorization)

WebClient webClient = WebClient.builder()
        .baseUrl("https://api.example.com")
        .defaultHeader("Authorization", "Bearer your-token-here")
        .build();

String response = webClient.get()
        .uri("/protected-resource")
        .retrieve()
        .bodyToMono(String.class)
        .block();
System.out.println("Response: " + response);

৫. Reactive Programming Example

Flux ব্যবহার করে ডেটার স্ট্রিম ফ্লো পরিচালনা:

import reactor.core.publisher.Flux;

public void fetchDataStream() {
    Flux<String> dataStream = webClient.get()
            .uri("/stream")
            .retrieve()
            .bodyToFlux(String.class);

    dataStream.subscribe(data -> System.out.println("Received: " + data));
}

৬. Configuration in application.properties

Default Timeout সেটআপ:

webclient.default.read-timeout=5000
webclient.default.connect-timeout=3000

৭. Sample Controller Integration

Spring Boot Controller-এ WebClient ব্যবহারের উদাহরণ:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class WebClientController {
    private final WebClient webClient;

    public WebClientController(WebClient webClient) {
        this.webClient = webClient;
    }

    @GetMapping("/fetch-data")
    public String fetchData() {
        return webClient.get()
                .uri("/data")
                .retrieve()
                .bodyToMono(String.class)
                .block();
    }
}

সংক্ষেপে WebClient ব্যবহার:

• সিনক্রোনাস (block) এবং অ্যাসিনক্রোনাস (reactive) উভয় প্রোগ্রামিং মডেল সাপোর্ট করে।
• রিঅ্যাকটিভ প্রোগ্রামিংয়ের জন্য Flux এবং Mono ব্যবহার।
• কাস্টম হেডার, টাইমআউট, এবং এরর হ্যান্ডলিং সহজে কনফিগার করা যায়।
• RestTemplate-এর তুলনায় আরও আধুনিক এবং ফিচার-সমৃদ্ধ।