Module 7: Mastering Functional and Reactive Patterns in .NET and Java: A Comprehensive Guide for Beginners to Advanced Developers

 

Table of Contents

1. Introduction to Functional and Reactive Patterns

   • 1.1 What Are Functional and Reactive Patterns?

   • 1.2 Why Functional and Reactive Patterns Matter

   • 1.3 Scope of Module 7

2. Functional Interfaces and Lambda Patterns

   • 2.1 Understanding Functional Interfaces

   • 2.2 Lambda Expressions in Java and .NET

   • 2.3 Real-World Example: Data Validation with Functional Interfaces

   • 2.4 Best Practices for Functional Interfaces

   • 2.5 Exception Handling in Lambda Patterns

   • 2.6 Pros, Cons, and Alternatives

3. Event-Driven Architecture Patterns

   • 3.1 Introduction to Event-Driven Architecture

   • 3.2 Key Components of Event-Driven Systems

   • 3.3 Real-World Example: Real-Time Order Processing with ASP.NET and SQL Server

   • 3.4 Best Practices for Event-Driven Architecture

   • 3.5 Exception Handling in Event-Driven Systems

   • 3.6 Pros, Cons, and Alternatives

4. Reactive Streams with RxJava and Rx.NET

   • 4.1 What Are Reactive Streams?

   • 4.2 RxJava: Reactive Programming in Java

   • 4.3 Rx.NET: Reactive Programming in .NET

   • 4.4 Real-World Example: Real-Time Dashboard with Rx.NET and ASP.NET

   • 4.5 Best Practices for Reactive Streams

   • 4.6 Exception Handling in Reactive Streams

   • 4.7 Pros, Cons, and Alternatives

5. Observer and Publisher-Subscriber Patterns

   • 5.1 Understanding the Observer Pattern

   • 5.2 Publisher-Subscriber in Reactive Programming

   • 5.3 Real-World Example: Notification System with RxJava

   • 5.4 Best Practices for Observer and Publisher-Subscriber

   • 5.5 Exception Handling in Observer Patterns

   • 5.6 Pros, Cons, and Alternatives

6. Modern Patterns with Java 21 Flow API and .NET System.Reactive

   • 6.1 Java 21 Flow API: A Modern Approach to Reactive Programming

   • 6.2 .NET System.Reactive: Advanced Reactive Extensions

   • 6.3 Real-World Example: Inventory Management System with Java 21 Flow API

   • 6.4 Best Practices for Modern Reactive Patterns

   • 6.5 Exception Handling in Modern Patterns

   • 6.6 Pros, Cons, and Alternatives

7. Conclusion

   • 7.1 Key Takeaways

   • 7.2 Next Steps in Your Design Patterns Journey

8. References

---

1. Introduction to Functional and Reactive Patterns

1.1 What Are Functional and Reactive Patterns?

Functional and reactive patterns represent a paradigm shift in software development, focusing on asynchronous, non-blocking, and event-driven programming. Functional patterns leverage immutable data, pure functions, and higher-order functions, often using lambda expressions and functional interfaces. Reactive patterns, rooted in the Reactive Manifesto, emphasize responsiveness, resilience, elasticity, and message-driven communication, handling data streams efficiently.

• Functional Patterns: Build software by composing pure functions, avoiding shared state and side effects. Examples include functional interfaces and lambda expressions in Java and C#.

• Reactive Patterns: Focus on asynchronous data streams, enabling non-blocking operations. Libraries like RxJava and Rx.NET, along with Java 21’s Flow API, are key enablers.

1.2 Why Functional and Reactive Patterns Matter

In modern applications, scalability and responsiveness are critical. Functional patterns simplify code by reducing side effects, while reactive patterns handle high-concurrency scenarios, such as real-time dashboards or IoT systems. These patterns are essential for:

• Building scalable web applications.

• Processing real-time data streams (e.g., stock prices, user interactions).

• Enhancing system resilience and fault tolerance.

1.3 Scope of Module 7

This module covers functional interfaces, lambda patterns, event-driven architecture, reactive streams (RxJava, Rx.NET), and modern reactive patterns using Java 21 Flow API and .NET System.Reactive. Each section includes real-world examples, best practices, exception handling, and a discussion of pros, cons, and alternatives, tailored for .NET (C#, ASP.NET, SQL Server) and Java developers.

---

2. Functional Interfaces and Lambda Patterns

2.1 Understanding Functional Interfaces

A functional interface is an interface with a single abstract method (SAM), enabling lambda expressions for concise, functional-style programming. In Java, functional interfaces are annotated with @FunctionalInterface, while in C#, delegates like Func and Action serve similar purposes.

• Java Example: The Predicate<T> interface has a single method test(T t).

• C# Example: The Func<T, TResult> delegate allows passing functions as arguments.

2.2 Lambda Expressions in Java and .NET

Lambda expressions provide a concise way to implement functional interfaces or delegates, enabling functional programming paradigms.

Java Lambda Example

import java.util.function.Predicate;

public class LambdaExample {
    public static void main(String[] args) {
        Predicate<String> isLongEnough = s -> s.length() > 5;
        System.out.println(isLongEnough.test("Hello")); // false
        System.out.println(isLongEnough.test("HelloWorld")); // true
    }
}

C# Lambda Example

using System;

class Program {
    static void Main() {
        Func<string, bool> isLongEnough = s => s.Length > 5;
        Console.WriteLine(isLongEnough("Hello")); // false
        Console.WriteLine(isLongEnough("HelloWorld")); // true
    }
}

2.3 Real-World Example: Data Validation with Functional Interfaces

Let’s build a data validation system for an ASP.NET application that checks user input (e.g., email, password) using functional interfaces and lambda expressions, storing valid data in SQL Server.

C# Code: Data Validation with ASP.NET and SQL Server

using System;
using System.Data.SqlClient;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;

public class UserController : ControllerBase {
    private readonly string _connectionString = "Server=localhost;Database=UserDb;Trusted_Connection=True;";

    // Functional delegate for validation
    private readonly Func<string, bool> _isValidEmail = email =>
        !string.IsNullOrEmpty(email) && email.Contains("@") && email.Length > 5;

    private readonly Func<string, bool> _isValidPassword = password =>
        !string.IsNullOrEmpty(password) && password.Length >= 8;

    [HttpPost("register")]
    public async Task<IActionResult> Register([FromBody] User user) {
        try {
            if (!_isValidEmail(user.Email)) {
                return BadRequest("Invalid email format.");
            }
            if (!_isValidPassword(user.Password)) {
                return BadRequest("Password must be at least 8 characters.");
            }

            using (var connection = new SqlConnection(_connectionString)) {
                await connection.OpenAsync();
                var command = new SqlCommand(
                    "INSERT INTO Users (Email, Password) VALUES (@Email, @Password)",
                    connection);
                command.Parameters.AddWithValue("@Email", user.Email);
                command.Parameters.AddWithValue("@Password", user.Password);
                await command.ExecuteNonQueryAsync();
            }
            return Ok("User registered successfully.");
        } catch (SqlException ex) {
            return StatusCode(500, $"Database error: {ex.Message}");
        } catch (Exception ex) {
            return StatusCode(500, $"Unexpected error: {ex.Message}");
        }
    }
}

public class User {
    public string Email { get; set; }
    public string Password { get; set; }
}

Explanation

• Functional Delegates: _isValidEmail and _isValidPassword use lambda expressions for concise validation logic.

• ASP.NET Integration: The Register endpoint validates user input and stores it in SQL Server.

• SQL Server: Stores user data in a Users table with columns Email and Password.

2.4 Best Practices for Functional Interfaces

• Use Descriptive Names: Name functional interfaces and delegates clearly (e.g., IsValidEmail).

• Keep Lambdas Concise: Avoid complex logic in lambda expressions; delegate to methods if needed.

• Leverage Built-in Interfaces: Use Java’s Predicate, Consumer, or C#’s Func, Action to reduce boilerplate.

• Ensure Immutability: Avoid modifying shared state in lambda expressions to prevent side effects.

2.5 Exception Handling in Lambda Patterns

Lambdas don’t directly support try-catch blocks, so wrap them in methods or use higher-order functions.

C# Example: Exception Handling in Lambda

using System;

class Program {
    static void Main() {
        Func<string, bool> safeParse = input => {
            try {
                int.Parse(input);
                return true;
            } catch (FormatException) {
                Console.WriteLine("Invalid number format.");
                return false;
            }
        };

        Console.WriteLine(safeParse("123")); // true
        Console.WriteLine(safeParse("abc")); // false
    }
}

2.6 Pros, Cons, and Alternatives

• Pros:

  • Concise, readable code.

  • Encourages functional programming principles (immutability, no side effects).

  • Reusable validation logic.

• Cons:

  • Limited debugging support for complex lambdas.

  • Learning curve for beginners.

• Alternatives:

  • Traditional methods for complex logic.

  • Annotations (e.g., Java’s @Valid, .NET’s DataAnnotations) for validation.

---

3. Event-Driven Architecture Patterns

3.1 Introduction to Event-Driven Architecture

Event-driven architecture (EDA) enables systems to respond to events (e.g., user actions, system changes) asynchronously. Components communicate via events, promoting loose coupling and scalability.

3.2 Key Components of Event-Driven Systems

• Event Producers: Generate events (e.g., user clicks, database updates).

• Event Consumers: Process events (e.g., update UI, log data).

• Event Bus: Mediates event distribution (e.g., RabbitMQ, Kafka).

3.3 Real-World Example: Real-Time Order Processing with ASP.NET and SQL Server

Let’s build an event-driven system for processing e-commerce orders, using ASP.NET for the API, SignalR for real-time updates, and SQL Server for persistence.

C# Code: Event-Driven Order Processing

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using System;
using System.Data.SqlClient;
using System.Threading.Tasks;

public class OrderHub : Hub {
    public async Task SendOrderUpdate(string orderId, string status) {
        await Clients.All.SendAsync("ReceiveOrderUpdate", orderId, status);
    }
}

[Route("api/[controller]")]
[ApiController]
public class OrderController : ControllerBase {
    private readonly IHubContext<OrderHub> _hubContext;
    private readonly string _connectionString = "Server=localhost;Database=OrderDb;Trusted_Connection=True;";

    public OrderController(IHubContext<OrderHub> hubContext) {
        _hubContext = hubContext;
    }

    [HttpPost("create")]
    public async Task<IActionResult> CreateOrder([FromBody] Order order) {
        try {
            using (var connection = new SqlConnection(_connectionString)) {
                await connection.OpenAsync();
                var command = new SqlCommand(
                    "INSERT INTO Orders (OrderId, Product, Status) VALUES (@OrderId, @Product, @Status)",
                    connection);
                command.Parameters.AddWithValue("@OrderId", order.OrderId);
                command.Parameters.AddWithValue("@Product", order.Product);
                command.Parameters.AddWithValue("@Status", "Pending");
                await command.ExecuteNonQueryAsync();
            }

            // Notify clients via SignalR
            await _hubContext.Clients.All.SendAsync("ReceiveOrderUpdate", order.OrderId, "Pending");
            return Ok("Order created.");
        } catch (SqlException ex) {
            return StatusCode(500, $"Database error: {ex.Message}");
        } catch (Exception ex) {
            return StatusCode(500, $"Unexpected error: {ex.Message}");
        }
    }
}

public class Order {
    public string OrderId { get; set; }
    public string Product { get; set; }
    public string Status { get; set; }
}

Client-Side JavaScript (SignalR)

const connection = new signalR.HubConnectionBuilder()
    .withUrl("/orderHub")
    .build();

connection.on("ReceiveOrderUpdate", (orderId, status) => {
    console.log(`Order ${orderId} updated to ${status}`);
});

connection.start().catch(err => console.error(err));

Explanation

• ASP.NET and SignalR: The OrderController handles order creation, storing data in SQL Server, and broadcasts updates via SignalR.

• SQL Server: Stores order details in an Orders table.

• Event-Driven: Clients receive real-time updates when orders are created.

3.4 Best Practices for Event-Driven Architecture

• Decouple Components: Use message brokers (e.g., RabbitMQ) for loose coupling.

• Idempotency: Ensure consumers can handle duplicate events.

• Monitor Events: Log events for debugging and auditing.

• Scalability: Use scalable brokers like Kafka for high-throughput systems.

3.5 Exception Handling in Event-Driven Systems

Handle exceptions at the producer, consumer, and broker levels.

C# Example: Exception Handling in Event-Driven System

public async Task CreateOrder([FromBody] Order order) {
    try {
        // Validate order
        if (string.IsNullOrEmpty(order.OrderId)) {
            throw new ArgumentException("Order ID cannot be empty.");
        }

        using (var connection = new SqlConnection(_connectionString)) {
            await connection.OpenAsync();
            var command = new SqlCommand(
                "INSERT INTO Orders (OrderId, Product, Status) VALUES (@OrderId, @Product, @Status)",
                connection);
            command.Parameters.AddWithValue("@OrderId", order.OrderId);
            command.Parameters.AddWithValue("@Product", order.Product);
            command.Parameters.AddWithValue("@Status", "Pending");
            await command.ExecuteNonQueryAsync();
        }

        await _hubContext.Clients.All.SendAsync("ReceiveOrderUpdate", order.OrderId, "Pending");
        return Ok("Order created.");
    } catch (ArgumentException ex) {
        return BadRequest(ex.Message);
    } catch (SqlException ex) {
        // Log error and retry
        Console.WriteLine($"Database error: {ex.Message}");
        return StatusCode(500, "Failed to create order. Please try again.");
    } catch (Exception ex) {
        Console.WriteLine($"Unexpected error: {ex.Message}");
        return StatusCode(500, "An unexpected error occurred.");
    }
}

3.6 Pros, Cons, and Alternatives

• Pros:

  • Loose coupling enhances maintainability.

  • Scalable for high-throughput systems.

  • Real-time responsiveness.

• Cons:

  • Complex event management and debugging.

  • Potential for event loss without proper brokers.

• Alternatives:

  • Polling-based systems (less responsive but simpler).

  • Synchronous APIs for low-latency requirements.

---

4. Reactive Streams with RxJava and Rx.NET

4.1 What Are Reactive Streams?

Reactive Streams is a specification for asynchronous stream processing with non-blocking backpressure. It defines interfaces like Publisher, Subscriber, and Subscription to handle data streams efficiently. RxJava and Rx.NET implement this specification.

4.2 RxJava: Reactive Programming in Java

RxJava extends the Observer pattern, using Observable, Flowable, and operators like map, filter, and flatMap to process asynchronous data streams.

Java Code: RxJava Example

import io.reactivex.rxjava3.core.Observable;

public class RxJavaExample {
    public static void main(String[] args) {
        Observable<String> source = Observable.just("Apple", "Banana", "Orange");
        source
            .map(String::toUpperCase)
            .filter(s -> s.startsWith("A"))
            .subscribe(
                System.out::println, // onNext
                Throwable::printStackTrace, // onError
                () -> System.out.println("Completed") // onComplete
            );
    }
}

4.3 Rx.NET: Reactive Programming in .NET

Rx.NET (System.Reactive) provides similar functionality for .NET, using IObservable<T> and IObserver<T>.

C# Code: Rx.NET Example

using System;
using System.Reactive.Linq;

class Program {
    static void Main() {
        var source = Observable.FromArray(new[] { "Apple", "Banana", "Orange" });
        source
            .Select(s => s.ToUpper())
            .Where(s => s.StartsWith("A"))
            .Subscribe(
                Console.WriteLine, // onNext
                ex => Console.WriteLine($"Error: {ex.Message}"), // onError
                () => Console.WriteLine("Completed") // onComplete
            );
    }
}

4.4 Real-World Example: Real-Time Dashboard with Rx.NET and ASP.NET

Let’s build a real-time dashboard displaying stock prices, using Rx.NET for data streams, ASP.NET for the API, and SQL Server for persistence.

C# Code: Real-Time Dashboard

using Microsoft.AspNetCore.Mvc;
using System;
using System.Data.SqlClient;
using System.Reactive.Linq;
using System.Threading.Tasks;

[Route("api/[controller]")]
[ApiController]
public class StockController : ControllerBase {
    private readonly string _connectionString = "Server=localhost;Database=StockDb;Trusted_Connection=True;";

    [HttpGet("prices")]
    public IActionResult GetStockPrices() {
        try {
            var stockPrices = Observable
                .Interval(TimeSpan.FromSeconds(2))
                .Select(_ => GenerateRandomPrice())
                .Take(10);

            stockPrices.Subscribe(
                async price => await SavePriceToDatabase(price),
                ex => Console.WriteLine($"Error: {ex.Message}"),
                () => Console.WriteLine("Price stream completed")
            );

            return Ok("Streaming stock prices...");
        } catch (Exception ex) {
            return StatusCode(500, $"Unexpected error: {ex.Message}");
        }
    }

    private double GenerateRandomPrice() {
        return new Random().NextDouble() * 100;
    }

    private async Task SavePriceToDatabase(double price) {
        try {
            using (var connection = new SqlConnection(_connectionString)) {
                await connection.OpenAsync();
                var command = new SqlCommand(
                    "INSERT INTO StockPrices (Price, Timestamp) VALUES (@Price, @Timestamp)",
                    connection);
                command.Parameters.AddWithValue("@Price", price);
                command.Parameters.AddWithValue("@Timestamp", DateTime.UtcNow);
                await command.ExecuteNonQueryAsync();
            }
        } catch (SqlException ex) {
            Console.WriteLine($"Database error: {ex.Message}");
        }
    }
}

Explanation

• Rx.NET: Generates a stream of random stock prices every 2 seconds.

• ASP.NET: Exposes an endpoint to trigger the stream.

• SQL Server: Stores prices in a StockPrices table.

4.5 Best Practices for Reactive Streams

• Manage Backpressure: Use Flowable (RxJava) or IObservable with buffering for large datasets.

• Use Operators Wisely: Chain operators like map, filter, and flatMap for clear data transformations.

• Dispose Subscriptions: Prevent memory leaks by disposing of subscriptions.

• Test Streams: Use unit tests to verify stream behavior.

4.6 Exception Handling in Reactive Streams

Handle errors using onError callbacks or operators like onErrorReturn.

C# Code: Exception Handling in Rx.NET

using System;
using System.Reactive.Linq;

class Program {
    static void Main() {
        var source = Observable.Range(1, 5)
            .Select(x => {
                if (x == 3) throw new Exception("Invalid value");
                return x * 10;
            });

        source
            .OnErrorResumeNext(Observable.Return(-1))
            .Subscribe(
                Console.WriteLine,
                ex => Console.WriteLine($"Error: {ex.Message}"),
                () => Console.WriteLine("Completed")
            );
    }
}

4.7 Pros, Cons, and Alternatives

• Pros:

  • Handles asynchronous data streams efficiently.

  • Supports backpressure for large datasets.

  • Integrates with modern frameworks (Spring WebFlux, ASP.NET).

• Cons:

  • Steep learning curve for beginners.

  • Debugging asynchronous streams is challenging.

• Alternatives:

  • Java Streams API for simpler, synchronous processing.

  • Task-based asynchronous programming (TAP) in .NET.

---

5. Observer and Publisher-Subscriber Patterns

5.1 Understanding the Observer Pattern

The Observer pattern defines a one-to-many dependency where a subject notifies observers of state changes. It’s foundational to reactive programming.

5.2 Publisher-Subscriber in Reactive Programming

The Publisher-Subscriber pattern extends Observer, using a Publisher to emit events and a Subscriber to consume them, often with a mediator (e.g., message broker).

5.3 Real-World Example: Notification System with RxJava

Let’s build a notification system for an e-commerce platform, sending alerts to users when order status changes, using RxJava and a REST API.

Java Code: Notification System

import io.reactivex.rxjava3.core.Observable;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class NotificationSystem {
    public static void main(String[] args) {
        Observable<String> orderUpdates = Observable.just(
            "Order 1: Shipped",
            "Order 2: Delivered",
            "Order 3: Cancelled"
        );

        orderUpdates
            .subscribe(
                update -> sendNotification(update),
                Throwable::printStackTrace,
                () -> System.out.println("Notification stream completed")
            );
    }

    private static void sendNotification(String update) {
        try {
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.notification-service.com/send"))
                .POST(HttpRequest.BodyPublishers.ofString(update))
                .build();
            client.send(request, HttpResponse.BodyHandlers.ofString());
            System.out.println("Sent notification: " + update);
        } catch (Exception ex) {
            System.err.println("Failed to send notification: " + ex.getMessage());
        }
    }
}

5.4 Best Practices for Observer and Publisher-Subscriber

• Decouple Observers: Use mediators (e.g., message brokers) to avoid tight coupling.

• Handle Backpressure: Implement backpressure for high-frequency events.

• Ensure Thread Safety: Use schedulers (RxJava) or tasks (Rx.NET) for thread management.

• Monitor Subscriptions: Track active subscriptions to prevent leaks.

5.5 Exception Handling in Observer Patterns

Use onError handlers to manage exceptions gracefully.

Java Code: Exception Handling in RxJava

import io.reactivex.rxjava3.core.Observable;

public class NotificationSystem {
    public static void main(String[] args) {
        Observable<String> orderUpdates = Observable.create(emitter -> {
            emitter.onNext("Order 1: Shipped");
            emitter.onNext("Order 2: Delivered");
            throw new RuntimeException("Failed to process order");
        });

        orderUpdates
            .onErrorReturnItem("Error occurred, resuming with default message")
            .subscribe(
                System.out::println,
                Throwable::printStackTrace,
                () -> System.out.println("Completed")
            );
    }
}

5.6 Pros, Cons, and Alternatives

• Pros:

  • Enables real-time updates.

  • Supports loose coupling.

  • Scalable for event-driven systems.

• Cons:

  • Complex subscription management.

  • Potential for memory leaks if subscriptions aren’t disposed.

• Alternatives:

  • Event Sourcing for persistent event storage.

  • Simple callbacks for lightweight scenarios.

---

6. Modern Patterns with Java 21 Flow API and .NET System.Reactive

6.1 Java 21 Flow API: A Modern Approach to Reactive Programming

Java 21’s Flow API provides a standardized way to implement reactive streams, with interfaces like Flow.Publisher, Flow.Subscriber, and Flow.Subscription.

6.2 .NET System.Reactive: Advanced Reactive Extensions

System.Reactive builds on the Observer pattern, offering robust tools for handling asynchronous streams in .NET.

6.3 Real-World Example: Inventory Management System with Java 21 Flow API

Let’s build an inventory management system that processes stock updates reactively, using Java 21 Flow API and a REST API.

Java Code: Inventory Management

import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;

public class InventorySystem {
    public static void main(String[] args) {
        SubmissionPublisher<String> publisher = new SubmissionPublisher<>();
        InventorySubscriber subscriber = new InventorySubscriber();
        publisher.subscribe(subscriber);

        publisher.submit("Item 1: 100 units");
        publisher.submit("Item 2: 50 units");
        publisher.close();
    }
}

class InventorySubscriber implements Flow.Subscriber<String> {
    private Flow.Subscription subscription;

    @Override
    public void onSubscribe(Flow.Subscription subscription) {
        this.subscription = subscription;
        subscription.request(1);
    }

    @Override
    public void onNext(String item) {
        try {
            System.out.println("Processing: " + item);
            // Simulate database save
            saveToDatabase(item);
            subscription.request(1);
        } catch (Exception ex) {
            System.err.println("Error processing item: " + ex.getMessage());
        }
    }

    @Override
    public void onError(Throwable throwable) {
        System.err.println("Error: " + throwable.getMessage());
    }

    @Override
    public void onComplete() {
        System.out.println("Inventory updates completed.");
    }

    private void saveToDatabase(String item) {
        // Simulate database operation
        System.out.println("Saved to database: " + item);
    }
}

6.4 Best Practices for Modern Reactive Patterns

• Use Standard APIs: Leverage Java 21 Flow API or System.Reactive for compatibility.

• Implement Backpressure: Control data flow to prevent overwhelming subscribers.

• Optimize Resource Usage: Dispose of subscriptions and close publishers.

• Integrate with Frameworks: Use Spring WebFlux or ASP.NET for seamless integration.

6.5 Exception Handling in Modern Patterns

Handle errors in onError methods or use fallback mechanisms.

Java Code: Exception Handling in Flow API

class InventorySubscriber implements Flow.Subscriber<String> {
    private Flow.Subscription subscription;

    @Override
    public void onSubscribe(Flow.Subscription subscription) {
        this.subscription = subscription;
        subscription.request(1);
    }

    @Override
    public void onNext(String item) {
        try {
            if (item == null) throw new IllegalArgumentException("Item cannot be null");
            System.out.println("Processing: " + item);
            subscription.request(1);
        } catch (Exception ex) {
            onError(ex);
        }
    }

    @Override
    public void onError(Throwable throwable) {
        System.err.println("Error: " + throwable.getMessage());
        subscription.cancel();
    }

    @Override
    public void onComplete() {
        System.out.println("Completed.");
    }
}

6.6 Pros, Cons, and Alternatives

• Pros:

  • Standardized APIs ensure portability.

  • Robust support for reactive programming.

  • Integrates with modern frameworks.

• Cons:

  • Requires understanding of reactive concepts.

  • Limited adoption in legacy systems.

• Alternatives:

  • RxJava/Rx.NET for more mature ecosystems.

  • Akka Streams for advanced reactive systems.

---

7. Conclusion

7.1 Key Takeaways

Module 7 introduced functional and reactive patterns, covering:

• Functional interfaces and lambda expressions for concise, reusable code.

• Event-driven architecture for responsive, decoupled systems.

• Reactive streams with RxJava and Rx.NET for asynchronous data processing.

• Observer and Publisher-Subscriber patterns for event handling.

• Modern reactive patterns using Java 21 Flow API and .NET System.Reactive.

7.2 Next Steps in Your Design Patterns Journey

• Explore advanced patterns like CQRS and Event Sourcing.

• Experiment with frameworks like Spring WebFlux or ASP.NET SignalR.

• Build real-world projects to solidify your understanding.

---

8. References

• Reactive Manifesto: https://www.reactivemanifesto.org/

• RxJava Documentation: https://github.com/ReactiveX/RxJava

• System.Reactive Documentation: https://github.com/dotnet/reactive

• Java 21 Flow API: https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/concurrent/Flow.html

• Baeldung: Reactive Systems in Java

• GeeksforGeeks: Reactive Programming in Java

🚀 Expand Your Learning Journey

📘 Master Software Design Patterns: Complete Course Outline (.NET & Java)   |   🎯 Free Learning Zone

📘 Master Software Design Patterns: Complete Course Outline (.NET & Java) 🎯 Visit Free Learning Zone