Что такое Stateful операция?

Stateful операция: Операции, зависящие от состояния

Stateful операция (операция, зависящая от состояния) — это операция в программировании, которая зависит от или изменяет состояние объекта/системы. Результат такой операции зависит от предыдущих действий и текущего состояния, в отличие от stateless операций, которые всегда дают одинаковый результат для одних и тех же входных параметров.

Определение: Stateful vs Stateless

Stateless (без состояния)

// Stateless функция: результат зависит только от параметров
public class MathUtil {
    public static int add(int a, int b) {
        return a + b;  // f(x) = x, всегда одинаковый результат
    }
    
    // add(2, 3) = 5
    // add(2, 3) = 5
    // add(2, 3) = 5  <- ВСЕГДА одинаково
}

Stateful (с состоянием)

// Stateful класс: результат зависит от состояния объекта
public class BankAccount {
    private double balance = 0;  // СОСТОЯНИЕ
    
    public void deposit(double amount) {
        balance += amount;  // Изменяет состояние
    }
    
    public double withdraw(double amount) {
        balance -= amount;  // Зависит от состояния И изменяет его
        return amount;
    }
    
    public double getBalance() {
        return balance;  // Возвращает текущее состояние
    }
}

BankAccount account = new BankAccount();
account.deposit(100);  // Состояние: 100
account.withdraw(30);  // Состояние: 70
account.withdraw(30);  // Состояние: 40
// Одна и та же операция withdraw(30) дает разные результаты!

Основные характеристики Stateful операций

1. Зависимость от предыстории

public class Order {
    private OrderStatus status;  // СОСТОЯНИЕ
    private List<OrderItem> items;
    
    // Stateful операция
    public void processPayment(PaymentMethod method) {
        // Результат зависит от текущего статуса
        if (status == OrderStatus.PENDING) {
            status = OrderStatus.PROCESSING;
            processPaymentInternal(method);
        } else if (status == OrderStatus.PROCESSING) {
            throw new IllegalStateException("Already being processed");
        } else if (status == OrderStatus.COMPLETED) {
            throw new IllegalStateException("Already completed");
        }
    }
}

2. Побочные эффекты

public class FileWriter {
    private File file;
    private boolean isOpen = false;  // СОСТОЯНИЕ
    
    public void open() {
        this.isOpen = true;
    }
    
    // Stateful операция: зависит от состояния isOpen
    public void write(String text) {
        if (!isOpen) {
            throw new IllegalStateException("File not open");
        }
        // Побочный эффект: изменяет файл на диске
        writeToFile(text);
    }
    
    public void close() {
        this.isOpen = false;
    }
}

FileWriter writer = new FileWriter();
writer.write("hello");  // Исключение! isOpen = false
writer.open();
writer.write("hello");  // OK, записывает в файл
writer.write("hello");  // OK, добавляет в файл
writer.close();
writer.write("hello");  // Исключение! isOpen = false

Stateful операции в базах данных

Транзакции как Stateful операции

@Transactional
public void transferMoney(Long fromId, Long toId, BigDecimal amount) {
    // Статус транзакции: BEGIN
    
    Account from = accountRepository.findById(fromId);
    Account to = accountRepository.findById(toId);
    
    // Промежуточное состояние: данные изменены, но не committed
    from.withdraw(amount);
    to.deposit(amount);
    
    if (to.getBalance() < 0) {
        // Статус транзакции: ROLLBACK
        throw new InsufficientFundsException();
    }
    
    // Статус транзакции: COMMIT
    accountRepository.save(from);
    accountRepository.save(to);
}

Session-based операции

@Repository
public class UserRepository {
    private final SessionFactory sessionFactory;
    
    public User findById(Long id) {
        // Session имеет состояние
        Session session = sessionFactory.openSession();
        session.beginTransaction();  // СОСТОЯНИЕ: открыта транзакция
        
        User user = session.get(User.class, id);
        
        // Session отслеживает изменения
        user.setEmail("newemail@example.com");
        
        session.getTransaction().commit();  // СОСТОЯНИЕ: commit
        session.close();  // СОСТОЯНИЕ: закрыта
        
        return user;
    }
}

Stateful операции в HTTP и REST

Stateless HTTP (REST принцип)

@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        // Stateless операция: каждый запрос независим
        User user = userService.findById(id);
        return ResponseEntity.ok(user);
    }
    // GET /api/users/1 -> всегда возвращает одного пользователя
}

Stateful HTTP (Session-based)

@RestController
@RequestMapping("/api/shopping")
public class ShoppingController {
    // Shopping cart хранится в session
    @PostMapping("/add-to-cart")
    public ResponseEntity<?> addToCart(
        @RequestParam Long productId,
        @RequestParam int quantity,
        HttpSession session) {
        
        // Состояние хранится в session
        @SuppressWarnings("unchecked")
        Map<Long, Integer> cart = (Map<Long, Integer>) session.getAttribute("cart");
        
        if (cart == null) {
            cart = new HashMap<>();
            session.setAttribute("cart", cart);
        }
        
        // Stateful операция: зависит от текущего содержимого cart
        cart.put(productId, quantity);
        
        return ResponseEntity.ok("Item added");
    }
    
    @GetMapping("/cart")
    public ResponseEntity<Map<Long, Integer>> getCart(HttpSession session) {
        Map<Long, Integer> cart = (Map<Long, Integer>) session.getAttribute("cart");
        return ResponseEntity.ok(cart);
    }
}

Stateful операции в многопоточности

Небезопасное stateful состояние

public class Counter {
    private int count = 0;  // СОСТОЯНИЕ
    
    // Stateful операция: race condition!
    public void increment() {
        count++;  // НЕ атомарна!
    }
    
    public int getCount() {
        return count;
    }
}

// Проблема:
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
    for (int i = 0; i < 1000; i++) {
        counter.increment();
    }
});
Thread t2 = new Thread(() -> {
    for (int i = 0; i < 1000; i++) {
        counter.increment();
    }
});

t1.start();
t2.start();
t1.join();
t2.join();

System.out.println(counter.getCount());  // Может быть меньше 2000!

Безопасное stateful состояние

public class ThreadSafeCounter {
    private int count = 0;
    
    // Синхронизированная stateful операция
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

// Или с использованием AtomicInteger
public class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();  // Атомарна
    }
    
    public int getCount() {
        return count.get();
    }
}

Stateful операции в Java Collections

Iterator — пример stateful операции

List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> iterator = list.iterator();  // Создали stateful объект

// СОСТОЯНИЕ: позиция на начале списка
if (iterator.hasNext()) {  // Зависит от состояния
    String first = iterator.next();  // Изменяет состояние
    System.out.println(first);  // "A"
}

// СОСТОЯНИЕ: позиция сдвинулась
if (iterator.hasNext()) {
    String second = iterator.next();
    System.out.println(second);  // "B"
}

// СОСТОЯНИЕ: позиция сдвинулась
if (iterator.hasNext()) {
    String third = iterator.next();
    System.out.println(third);  // "C"
}

// СОСТОЯНИЕ: нет больше элементов
if (iterator.hasNext()) {  // false
    // Этот блок не выполнится
}

Stateful операции в паттернах проектирования

State Pattern

public interface PaymentState {
    void processPayment(Payment payment);
}

public class PendingPaymentState implements PaymentState {
    public void processPayment(Payment payment) {
        System.out.println("Processing payment");
        payment.setState(new ProcessingPaymentState());
    }
}

public class ProcessingPaymentState implements PaymentState {
    public void processPayment(Payment payment) {
        System.out.println("Payment already being processed");
        // Stateful: поведение зависит от состояния
    }
}

public class Payment {
    private PaymentState state = new PendingPaymentState();
    
    public void processPayment() {
        state.processPayment(this);  // Поведение зависит от состояния
    }
    
    public void setState(PaymentState state) {
        this.state = state;
    }
}

Observer Pattern — Stateful подписка

public interface Observer {
    void update(Subject subject);
}

public class Subject {
    private List<Observer> observers = new ArrayList<>();  // СОСТОЯНИЕ
    private int state = 0;
    
    public void attach(Observer observer) {
        observers.add(observer);  // Stateful: изменяет состояние
    }
    
    public void setState(int newState) {
        this.state = newState;
        notifyObservers();  // Stateful: зависит от состояния observers
    }
    
    private void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(this);
        }
    }
}

Лучшие практики работы с Stateful операциями

1. Минимизируйте видимость состояния

// Плохо: состояние публично
public class BadExample {
    public int counter = 0;  // Опасно!
    public List items = new ArrayList();  // Опасно!
}

// Хорошо: состояние приватно
public class GoodExample {
    private int counter = 0;
    private List<Item> items = new ArrayList<>();
    
    public int getCounter() {
        return counter;
    }
    
    public void addItem(Item item) {
        items.add(item);
    }
}

2. Используйте immutable объекты где возможно

// Stateful (мутабельный)
public class MutableUser {
    public String name;
    public String email;
}

// Stateless (immutable)
public class ImmutableUser {
    private final String name;
    private final String email;
    
    public ImmutableUser(String name, String email) {
        this.name = name;
        this.email = email;
    }
    
    // Вместо setName создаем новый объект
    public ImmutableUser withName(String newName) {
        return new ImmutableUser(newName, this.email);
    }
}

3. Документируйте состояние и переходы

/**
 * Представляет заказ с следующими состояниями:
 * PENDING -> PROCESSING -> COMPLETED
 * PENDING -> CANCELLED (в любой момент)
 */
public class Order {
    private OrderStatus status;  // СОСТОЯНИЕ
    
    /**
     * Обработать заказ. 
     * Требует состояние: PENDING
     * Переходит в: PROCESSING
     * Выбросит исключение если уже PROCESSING или COMPLETED
     */
    public void process() {
        if (status == OrderStatus.PENDING) {
            status = OrderStatus.PROCESSING;
        } else {
            throw new IllegalStateException(
                "Cannot process order in state: " + status
            );
        }
    }
}

4. Используйте потокобезопасность для stateful объектов

public class ThreadSafeRegistry<T> {
    private final Map<String, T> registry = new ConcurrentHashMap<>();
    
    public void register(String name, T value) {
        registry.put(name, value);  // Потокобезопасно
    }
    
    public T get(String name) {
        return registry.get(name);
    }
    
    public void remove(String name) {
        registry.remove(name);
    }
}

Stateful операции в Kubernetes

В контексте контейнеризации:

apiVersion: apps/v1
kind: StatefulSet  # Для stateful приложений
metadata:
  name: database
spec:
  serviceName: "database"
  replicas: 3
  selector:
    matchLabels:
      app: database
  template:
    metadata:
      labels:
        app: database
    spec:
      containers:
      - name: db
        image: postgres:13
        volumeMounts:
        - name: data
          mountPath: /var/lib/postgresql
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 10Gi

Заключение

Stateful операция — это фундаментальный концепт в программировании:

1. Зависит от состояния — результат зависит от предыдущих действий
2. Имеет побочные эффекты — изменяет состояние системы
3. Требует управления — нужно отслеживать и синхронизировать состояние
4. Сложнее в тестировании — нужно учитывать исходное состояние
5. Нужна потокобезопасность — в многопоточной среде

Понимание различия между stateful и stateless операциями критично для написания надежного и масштабируемого Java кода.