Что такое Stateless в REST API?

Stateless в REST API

Stateless — это фундаментальный принцип архитектуры REST (Representational State Transfer), который означает, что каждый HTTP запрос содержит всю информацию, необходимую серверу для его обработки, без опоры на предыдущие взаимодействия или состояние, сохранённое на сервере. Сервер не хранит контекст клиента между запросами.

Основной принцип

Стателесс архитектура требует, чтобы каждый запрос был полностью независимым. Сервер не должен рассчитывать на то, что помнит что-либо о предыдущих запросах от клиента.

// ПЛОХО: Stateful (нарушает REST)
@RestController
@RequestMapping("/api/users")
public class UserController {
    private User currentUser; // состояние на сервере!
    
    @PostMapping("/login")
    public ResponseEntity<User> login(@RequestBody LoginRequest req) {
        currentUser = userService.authenticate(req); // сохранили состояние
        return ResponseEntity.ok(currentUser);
    }
    
    @GetMapping("/profile")
    public ResponseEntity<User> getProfile() {
        // Зависит от currentUser из login!
        return ResponseEntity.ok(currentUser);
    }
}

// ХОРОШО: Stateless (REST compliant)
@RestController
@RequestMapping("/api/users")
public class UserController {
    @PostMapping("/login")
    public ResponseEntity<LoginResponse> login(@RequestBody LoginRequest req) {
        User user = userService.authenticate(req);
        String token = jwtService.generateToken(user);
        return ResponseEntity.ok(new LoginResponse(token, user));
    }
    
    @GetMapping("/profile")
    public ResponseEntity<User> getProfile(@RequestHeader("Authorization") String token) {
        // Берём информацию из токена, а не из сохранённого состояния
        User user = jwtService.validateAndGetUser(token);
        return ResponseEntity.ok(user);
    }
}

Характеристики Stateless архитектуры

1. Полнота информации в запросе

Каждый запрос должен включать всю необходимую информацию:

@GetMapping("/orders/{id}")
public ResponseEntity<Order> getOrder(
    @PathVariable Long id,
    @RequestHeader("Authorization") String token,  // Все данные в запросе
    @RequestHeader("X-User-Id") Long userId       // Никаких предположений
) {
    User user = userService.validateToken(token);
    Order order = orderService.getOrder(id, userId);
    return ResponseEntity.ok(order);
}

2. Идентичные результаты для идентичных запросов

@GetMapping("/products/{id}")
public ResponseEntity<Product> getProduct(@PathVariable Long id) {
    // Всегда возвращает одно и то же для одного id
    Product product = productService.getProduct(id);
    return ResponseEntity.ok(product);
}

3. Аутентификация через токены

Вместо сессий на сервере используются токены (JWT):

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .authorizeRequests()
            .antMatchers("/api/auth/login").permitAll()
            .antMatchers("/api/**").authenticated()
            .and()
            .addFilter(new JwtAuthenticationFilter(authenticationManager()))
            .addFilter(new JwtAuthorizationFilter(authenticationManager()));
        return http.build();
    }
}

@Component
public class JwtTokenProvider {
    private final String secretKey = "your-secret-key";
    private final long expirationMs = 86400000; // 24 часа
    
    public String generateToken(User user) {
        return Jwts.builder()
            .setSubject(user.getId().toString())
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + expirationMs))
            .signWith(SignatureAlgorithm.HS512, secretKey)
            .compact();
    }
    
    public Long getUserIdFromToken(String token) {
        try {
            Claims claims = Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(token)
                .getBody();
            return Long.parseLong(claims.getSubject());
        } catch (JwtException | IllegalArgumentException e) {
            throw new InvalidTokenException("Invalid or expired token");
        }
    }
}

Преимущества Stateless архитектуры

Масштабируемость:

// Можно добавлять серверы без синхронизации состояния
// Load Balancer может направлять любой запрос на любой сервер
Server 1 ← 
          ← Load Balancer
Server 2 ←
Server 3 ←

// Каждый сервер обработает запрос независимо
@GetMapping("/api/data")
public ResponseEntity<Data> getData(@RequestHeader("Authorization") String token) {
    // Работает на любом сервере благодаря токену в запросе
    User user = tokenService.validate(token);
    return ResponseEntity.ok(dataService.getData(user.getId()));
}

Простота кэширования:

@GetMapping("/api/products/{id}")
@Cacheable(value = "products", key = "#id")
public ResponseEntity<Product> getProduct(@PathVariable Long id) {
    return ResponseEntity.ok(productService.getProduct(id));
}

Надёжность:

// Если сервер упал, клиент просто повторяет запрос на другом сервере
public class ResilientClient {
    @CircuitBreaker(name = "api", fallbackMethod = "fallback")
    public Product getProduct(Long id, String token) {
        return restTemplate.getForObject(
            "/api/products/" + id,
            Product.class,
            Collections.singletonMap("Authorization", token)
        );
    }
    
    public Product fallback(Long id, String token, Exception e) {
        return new Product(); // или дефолтное значение
    }
}

Недостатки Stateless архитектуры

Объём данных в каждом запросе:

// Приходится отправлять всё каждый раз
@PostMapping("/api/orders")
public ResponseEntity<Order> createOrder(
    @RequestBody OrderRequest req,
    @RequestHeader("Authorization") String token,  // Токен в каждом запросе
    @RequestHeader("X-Request-Id") String requestId // ID для идемпотентности
) {
    User user = userService.validateToken(token);
    return ResponseEntity.ok(orderService.create(req, user));
}

Сложность реального времени:

// Сложно отслеживать состояние в реальном времени
// Используют WebSockets или polling вместо состояния
@RestController
@RequestMapping("/api/notifications")
public class NotificationController {
    @GetMapping
    public ResponseEntity<List<Notification>> getNotifications(
        @RequestHeader("Authorization") String token
    ) {
        User user = userService.validateToken(token);
        // Каждый запрос получает актуальные уведомления из БД
        return ResponseEntity.ok(notificationService.getForUser(user.getId()));
    }
}

Best Practices

1. Используй JWT или OAuth2:

@Configuration
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
public class SecurityConfig {
    @Bean
    public JwtAuthenticationConverter jwtAuthenticationConverter() {
        return new JwtAuthenticationConverter();
    }
}

2. Включай идемпотентный ключ для безопасных операций:

@PostMapping("/api/payments")
public ResponseEntity<Payment> createPayment(
    @RequestBody PaymentRequest req,
    @RequestHeader("X-Idempotency-Key") String idempotencyKey,
    @RequestHeader("Authorization") String token
) {
    User user = userService.validateToken(token);
    Payment payment = paymentService.createIdempotent(req, idempotencyKey, user.getId());
    return ResponseEntity.created(URI.create("/api/payments/" + payment.getId()))
        .body(payment);
}

3. Минимизируй размер токена:

public String generateToken(User user) {
    return Jwts.builder()
        .setSubject(user.getId().toString()) // минимум информации
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + 3600000))
        .signWith(SignatureAlgorithm.HS512, secretKey)
        .compact(); // не добавляй все данные юзера в токен
}

Заключение

Stateless архитектура REST API — это не просто рекомендация, а требование для масштабируемых распределённых систем. Она обеспечивает простоту развёртывания, кэширования и отказоустойчивости. Использование JWT токенов и OAuth2 позволяет реализовать надёжную аутентификацию без сохранения состояния на сервере.