উদাহরণ সহ Observable এবং Observer তৈরি

RxJava-তে Observable এবং Observer হল দুইটি প্রধান component। নিচে উদাহরণসহ এই দুটি component কীভাবে তৈরি এবং ব্যবহার করা হয় তা দেখানো হলো।

1. Observable এবং Observer তৈরি:

Observable এমন একটি entity যা ডেটা ইমিট করে। Observer সেই ডেটা consume করে। Observable এবং Observer এর মধ্যে subscription এর মাধ্যমে ডেটা পাঠানো হয়।

উদাহরণ: Observable এবং Observer তৈরি

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class RxJavaExample {
    public static void main(String[] args) {

        // 1. Create an Observable
        Observable<String> observable = Observable.create(emitter -> {
            try {
                emitter.onNext("Item 1"); // Emit first item
                emitter.onNext("Item 2"); // Emit second item
                emitter.onNext("Item 3"); // Emit third item
                emitter.onComplete();     // Signal completion
            } catch (Exception e) {
                emitter.onError(e);      // Signal an error if any
            }
        });

        // 2. Create an Observer
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("Subscribed to Observable");
            }

            @Override
            public void onNext(String item) {
                System.out.println("Received: " + item);
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("Error occurred: " + e.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("All items are received!");
            }
        };

        // 3. Subscribe the Observer to the Observable
        observable.subscribe(observer);
    }
}

কোড বিশ্লেষণ:

1. Observable তৈরি:

   Observable<String> observable = Observable.create(emitter -> { ... });
   

   • create() মেথড ব্যবহার করে Observable তৈরি করা হয়েছে।
   • onNext() মেথড ডেটা ইমিট করে।
   • onComplete() ইভেন্ট শেষ হওয়ার সংকেত দেয়।
   • onError() কোনো ত্রুটি হলে তা সংকেত দেয়।

2. Observer তৈরি:

   Observer<String> observer = new Observer<String>() { ... };
   

   • onSubscribe(): subscription শুরু হলে ডাকা হয়।
   • onNext() ডেটা রিসিভ হলে ডাকা হয়।
   • onError() ত্রুটি থাকলে ডাকা হয়।
   • onComplete() সব ডেটা পাওয়া শেষ হলে ডাকা হয়।

3. Subscribe করা:

   observable.subscribe(observer);
   

   • Observer কে Observable এর সাথে সংযুক্ত করা হয়েছে।

2. সংক্ষিপ্ত উদাহরণ (Lambda Expressions):

RxJava এর সাথে Lambda expressions ব্যবহার করে কোডকে আরো সহজ করা যায়।

import io.reactivex.Observable;

public class RxJavaLambdaExample {
    public static void main(String[] args) {

        // Create an Observable
        Observable<String> observable = Observable.just("Hello", "RxJava", "World");

        // Subscribe to the Observable using Lambda
        observable.subscribe(
            item -> System.out.println("Received: " + item),  // onNext
            error -> System.out.println("Error: " + error),   // onError
            () -> System.out.println("Completed!")            // onComplete
        );
    }
}

Lambda কোড বিশ্লেষণ:

1. Observable.just() একটি Observable তৈরি করে যা ডেটা ইমিট করে।
2. subscribe() এর ভিতরে তিনটি lambda function ব্যবহার করা হয়েছে:
   • প্রথমটি ডেটা (onNext) প্রক্রিয়াকরণে,
   • দ্বিতীয়টি ত্রুটি (onError) হ্যান্ডেল করতে,
   • তৃতীয়টি সম্পন্ন হলে (onComplete) একটি সংকেত পাঠাতে।

আউটপুট:

উদাহরণ 1:

Subscribed to Observable
Received: Item 1
Received: Item 2
Received: Item 3
All items are received!

উদাহরণ 2:

Received: Hello
Received: RxJava
Received: World
Completed!

লক্ষ্য:

1. Observable এবং Observer এর কাজ asynchronous এবং event-driven হওয়ায় এটি বড় ডেটা বা real-time ইভেন্ট পরিচালনার জন্য উপযুক্ত।
2. RxJava এর Lambda expressions কোডকে concise এবং সহজ করে তোলে।