Spring WebMVC vs WebFlux – Które wybrać w 2020?

Spring Framework 5.0 wprowadził rewolucyjną zmianę – obok klasycznego Spring WebMVC otrzymaliśmy Spring WebFlux, całkowicie nowy reactive web stack. Po dwóch latach doświadczeń produkcyjnych nadszedł czas na szczere porównanie obu podejść.

## Dlaczego to ważne?

Wybór między WebMVC a WebFlux to decyzja architektoniczna, która wpłynie na cały projekt. Błędny wybór może oznaczać problemy z wydajnością, skomplikowane debugowanie lub konieczność przepisania aplikacji. W 2019 roku wiele firm przeszło przez bolesne migracje między tymi technologiami.

## Spring WebMVC – Sprawdzony klasyk

Spring WebMVC to synchroniczny, servlet-based web framework działający na tradycyjnym modelu „one thread per request”. Każde żądanie HTTP obsługiwane jest przez dedykowany wątek z puli.

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/{id}")
    public ResponseEntity getUser(@PathVariable Long id) {
        // Synchroniczne wywołanie - blokuje wątek
        User user = userService.findById(id);
        return ResponseEntity.ok(user);
    }
    
    @PostMapping
    public ResponseEntity createUser(@RequestBody CreateUserRequest request) {
        // Tradycyjne, imperatywne programowanie
        User user = userService.create(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
}

### Zalety WebMVC:

– **Mature ecosystem:** Ogromna baza wiedzy, dokumentacji i przykładów
– **Predictable debugging:** Stack traces są czytelne, debugging straightforward
– **Thread-local storage:** Możliwość używania ThreadLocal, security context
– **Blocking I/O:** Prosty model programowania, łatwy do zrozumienia
– **Servlet filters:** Pełna kompatybilność z servlet API

## Spring WebFlux – Reactive revolution

WebFlux oparty jest na Project Reactor i non-blocking I/O. Używa event loop model z małą liczbą wątków do obsługi tysięcy równoczesnych połączeń.

@RestController
@RequestMapping("/api/users")
public class ReactiveUserController {
    
    @Autowired
    private ReactiveUserService userService;
    
    @GetMapping("/{id}")
    public Mono> getUser(@PathVariable Long id) {
        // Non-blocking - zwraca Mono (reactive stream)
        return userService.findById(id)
            .map(user -> ResponseEntity.ok(user))
            .defaultIfEmpty(ResponseEntity.notFound().build());
    }
    
    @GetMapping
    public Flux getAllUsers() {
        // Streaming response - dane wysyłane na bieżąco
        return userService.findAll()
            .delayElements(Duration.ofMillis(100)); // Symulacja delay
    }
    
    @PostMapping
    public Mono> createUser(@RequestBody Mono request) {
        return request
            .flatMap(userService::create)
            .map(user -> ResponseEntity.status(HttpStatus.CREATED).body(user));
    }
}

### Reactive Service Layer:

@Service
public class ReactiveUserService {
    
    @Autowired
    private ReactiveUserRepository userRepository;
    
    @Autowired
    private WebClient externalApiClient;
    
    public Mono findById(Long id) {
        return userRepository.findById(id)
            .switchIfEmpty(Mono.error(new UserNotFoundException(id)));
    }
    
    public Mono create(CreateUserRequest request) {
        // Composition of multiple reactive operations
        return validateUser(request)
            .then(checkUserExists(request.getEmail()))
            .then(userRepository.save(User.from(request)))
            .flatMap(this::enrichUserData);
    }
    
    private Mono enrichUserData(User user) {
        // Non-blocking external API call
        return externalApiClient
            .get()
            .uri("/profile/{email}", user.getEmail())
            .retrieve()
            .bodyToMono(UserProfile.class)
            .map(profile -> user.withProfile(profile))
            .onErrorReturn(user); // Graceful degradation
    }
}

## Performance porównanie

### Kiedy WebFlux osiąga przewagę:

## Practical decision matrix

### Wybierz WebMVC gdy:

– **Zespół bez doświadczenia reactive** – learning curve jest significant
– **Aplikacja CRUD-heavy** – typowe operacje bazodanowe
– **Prostota ważniejsza od performance** – easier debugging and maintenance
– **Blocking dependencies** – JDBC drivers, legacy libraries
– **Thread-local requirements** – security context, audit trails

### Wybierz WebFlux gdy:

– **High-concurrency requirements** – tysięce równoczesnych połączeń
– **I/O intensive operations** – dużo external API calls
– **Streaming data** – real-time feeds, server-sent events
– **Microservices communication** – service-to-service calls
– **Team ma reactive experience** – znają Reactor, RxJava

## Integration considerations

### Database access:

// WebMVC - traditional JPA
@Repository
public interface UserRepository extends JpaRepository {
    Optional findByEmail(String email);
}

// WebFlux - reactive repository
@Repository
public interface ReactiveUserRepository extends ReactiveCrudRepository {
    Mono findByEmail(String email);
    Flux findByStatus(UserStatus status);
}

### Testing approaches:

// WebMVC testing
@SpringBootTest
@AutoConfigureTestDatabase
class UserControllerTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    void shouldReturnUserById() {
        ResponseEntity response = restTemplate
            .getForEntity("/api/users/1", User.class);
        
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody().getId()).isEqualTo(1L);
    }
}

// WebFlux testing  
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ReactiveUserControllerTest {
    
    @Autowired
    private WebTestClient webTestClient;
    
    @Test
    void shouldReturnUserById() {
        webTestClient
            .get()
            .uri("/api/users/1")
            .accept(MediaType.APPLICATION_JSON)
            .exchange()
            .expectStatus().isOk()
            .expectBody(User.class)
            .value(user -> assertThat(user.getId()).isEqualTo(1L));
    }
}

## Migration strategies

### Stopniowa migracja WebMVC → WebFlux:

1. **Zaczynaj od nowych features** – nie ruszaj działającego kodu
2. **WebClient zamiast RestTemplate** – wprowadź reactive HTTP client
3. **Reactive repositories** – R2DBC lub reactive MongoDB
4. **Separate reactive modules** – izoluj reactive code
5. **Testing strategy** – WebTestClient vs MockMvc

## Common pitfalls

### WebFlux mistakes:

// ❌ BŁĄD - blocking w reactive chain
public Mono getUserWithProfile(Long id) {
    return userRepository.findById(id)
        .map(user -> {
            // To blokuje cały reactive pipeline!
            Profile profile = externalClient.getProfile(user.getId()).block();
            return user.withProfile(profile);
        });
}

// ✅ POPRAWNIE - compose reactive operations  
public Mono getUserWithProfile(Long id) {
    return userRepository.findById(id)
        .flatMap(user -> externalClient.getProfile(user.getId())
            .map(user::withProfile));
}

### WebMVC performance traps:

// ❌ BŁĄD - synchronous calls w loop
@GetMapping("/users-with-profiles")
public List getUsersWithProfiles() {
    List users = userService.findAll();
    return users.stream()
        .map(user -> {
            // N+1 problem - każde wywołanie blokuje wątek
            Profile profile = profileService.getProfile(user.getId());
            return new UserWithProfile(user, profile);
        })
        .collect(toList());
}

// ✅ POPRAWNIE - batch operations
@GetMapping("/users-with-profiles")  
public List getUsersWithProfiles() {
    List users = userService.findAll();
    List userIds = users.stream().map(User::getId).collect(toList());
    Map profiles = profileService.getProfilesBatch(userIds);
    
    return users.stream()
        .map(user -> new UserWithProfile(user, profiles.get(user.getId())))
        .collect(toList());
}

## Przydatne zasoby

– [Spring WebFlux Documentation](https://docs.spring.io/spring-framework/docs/current/reference/html/web-reactive.html)
– [Project Reactor Reference Guide](https://projectreactor.io/docs/core/release/reference/)
– [R2DBC Specification](https://r2dbc.io/spec/0.8.1.RELEASE/spec/html/)
– [Reactive Streams Specification](http://www.reactive-streams.org/)
– [WebFlux Performance Benchmarks](https://github.com/reactor/reactor-benchmark)

Która technologia sprawdzi się lepiej w Twoim następnym projekcie? Podziel się swoimi doświadczeniami w komentarzach!