Можно ли сделать поле нестатическим и нефинальным в обработчике сервлета?

Нестатические нефинальные поля в сервлетах

Прямой ответ

Нет, нельзя. Сервлет — это синглтон, общий для всех запросов. Нестатические нефинальные поля вызовут race conditions и потерю данных.

Почему это опасно?

Сервлеты работают в многопоточной среде:

@WebServlet("/order")
public class OrderServlet extends HttpServlet {
    
    private String orderData; // ❌ ОПАСНО!
    private int quantity; // ❌ ОПАСНО!
    
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        String customerId = req.getParameter("customer_id");
        
        this.orderData = customerId; // ← Два потока конкурируют за одно поле
        Thread.sleep(1000); // Эмуляция обработки
        
        // Какие данные здесь? Свои или другого пользователя?
        processOrder(this.orderData); // ❌ DATA RACE!
    }
}

Сценарий:

1. Поток A: this.orderData = "user123"
2. Поток B: this.orderData = "user456" ← Перезапись!
3. Поток A: processOrder("user456") ← Обработал чужие данные!

Результат: пользователи получают заказы друг друга.

Как работают сервлеты

@WebServlet("/example")
public class ExampleServlet extends HttpServlet {
    // ↓ Один экземпляр на все запросы
    private String sharedData; // ← Общее для всех потоков
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        // ↑ Много потоков вызывают этот метод одновременно
    }
}

// В контейнере Tomcat:
ExampleServlet servlet = new ExampleServlet(); // Один раз при инициализации
servlet.doGet(request1, response1); // Поток 1
servlet.doGet(request2, response2); // Поток 2
servlet.doGet(request3, response3); // Поток 3
// Все используют ТОТ ЖЕ ОБЪЕКТ servlet!

Правильный подход

1. Используй локальные переменные (thread-safe)

@WebServlet("/order")
public class OrderServlet extends HttpServlet {
    
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        
        // Локальные переменные — у каждого потока своя копия в стеке
        String customerId = req.getParameter("customer_id"); // ✅ SAFE
        int quantity = Integer.parseInt(req.getParameter("qty")); // ✅ SAFE
        LocalDateTime orderTime = LocalDateTime.now(); // ✅ SAFE
        
        // Обработка
        Order order = new Order(customerId, quantity, orderTime);
        processOrder(order);
    }
}

2. Финальные static поля для константных данных

@WebServlet("/config")
public class ConfigServlet extends HttpServlet {
    
    // Константные данные — thread-safe
    private static final String APP_VERSION = "2.1.0"; // ✅ SAFE
    private static final Logger logger = LoggerFactory.getLogger(ConfigServlet.class); // ✅ SAFE
    private static final int MAX_UPLOAD_SIZE = 10 * 1024 * 1024; // ✅ SAFE
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        resp.getWriter().println("Version: " + APP_VERSION);
    }
}

3. Immutable объекты в полях (если очень нужно)

@WebServlet("/service")
public class ServiceServlet extends HttpServlet {
    
    // Immutable объект можно делить между потоками
    private final SimpleDateFormat dateFormatter = 
        new SimpleDateFormat("yyyy-MM-dd"); // ⚠️ SimpleDateFormat НЕ thread-safe!
    
    private final DateTimeFormatter formatter = 
        DateTimeFormatter.ofPattern("yyyy-MM-dd"); // ✅ SAFE, immutable
    
    private final UserService userService = new UserService(); // ✅ SAFE если thread-safe
}

4. ThreadLocal для per-thread данных (редко)

@WebServlet("/context")
public class ContextServlet extends HttpServlet {
    
    // Каждый поток имеет свою копию значения
    private static final ThreadLocal<User> currentUser = new ThreadLocal<>();
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        try {
            // Установка для этого потока
            currentUser.set(loadUser(req));
            
            // Использование
            User user = currentUser.get();
            processRequest(user);
        } finally {
            // ВАЖНО: очистка, иначе утечка памяти
            currentUser.remove();
        }
    }
}

Плохие примеры

Ошибка 1: Mutable state в поле

@WebServlet("/bad1")
public class BadServlet1 extends HttpServlet {
    private List<String> items = new ArrayList<>(); // ❌ Race condition
    
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        String item = req.getParameter("item");
        items.add(item); // Одновременные добавления от разных потоков
        // items может быть в несогласованном состоянии
    }
}

Ошибка 2: Изменяемый state в static поле

@WebServlet("/bad2")
public class BadServlet2 extends HttpServlet {
    private static List<User> users = new ArrayList<>(); // ❌ Race condition
    
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        User user = new User(req.getParameter("name"));
        users.add(user); // Потокобезопасно требует синхронизации
    }
}

Ошибка 3: SimpleDateFormat в поле

@WebServlet("/bad3")
public class BadServlet3 extends HttpServlet {
    // SimpleDateFormat НЕ потокобезопасен!
    private SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy"); // ❌
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        String date = sdf.format(new Date()); // Race condition
    }
}

Правильный пример

@WebServlet("/products")
public class ProductServlet extends HttpServlet {
    
    // ✅ Только неизменяемые/безопасные данные
    private static final Logger logger = LoggerFactory.getLogger(ProductServlet.class);
    private static final DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE;
    private final ProductService productService = new ProductService(); // Injection
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {
        
        // ✅ Локальные переменные
        String productId = req.getParameter("id");
        int quantity = Integer.parseInt(req.getParameter("qty"));
        String userAgent = req.getHeader("User-Agent");
        
        try {
            // Обработка
            Product product = productService.getProduct(productId);
            
            // Ответ
            resp.setContentType("application/json");
            resp.getWriter().write(product.toJson());
        } catch (Exception e) {
            logger.error("Error processing request", e);
            resp.setStatus(500);
        }
    }
}

Решение для инъекции зависимостей

@WebServlet("/orders")
public class OrderServlet extends HttpServlet {
    
    // ✅ final поля для инъекции
    private final OrderService orderService;
    private final OrderValidator validator;
    
    public OrderServlet(OrderService orderService, OrderValidator validator) {
        this.orderService = orderService;
        this.validator = validator;
    }
    
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        // Локальные переменные для данных запроса
        String customerId = req.getParameter("customer_id");
        
        // Использование сервисов
        if (validator.isValid(customerId)) {
            orderService.createOrder(customerId);
        }
    }
}

Выводы

• Сервлеты — это синглтоны, один объект на все запросы
• Нестатические нефинальные поля вызывают race conditions
• Используй локальные переменные для данных из запроса
• Финальные статические поля для константных данных
• Внедряй зависимости через конструктор (final поля)
• Избегай SimpleDateFormat в полях — используй DateTimeFormatter
• ThreadLocal очень редко, и только если действительно нужно
• Всегда удаляй ThreadLocal в finally блоке