В чем разница между синглтоном в Spring и синглтоном в Java?

Разница между синглтоном в Spring и синглтоном в Java

Это две совершенно разные концепции, хотя часто их путают. Синглтон Java — это паттерн проектирования, а синглтон Spring — это scope управления жизненным циклом компонентов.

Синглтон в Java: паттерн проектирования

В Java синглтон — это класс, который гарантирует, что будет существовать только один экземпляр на протяжении всего жизненного цикла приложения. Это достигается через приватный конструктор.

// Классический паттерн Singleton в Java (ленивая инициализация)
public class DatabaseConnection {
    private static DatabaseConnection instance;
    
    // Приватный конструктор — не можно создать new
    private DatabaseConnection() {
        System.out.println("DatabaseConnection created");
    }
    
    // Единственный способ получить экземпляр
    public static synchronized DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
    
    public void execute(String sql) {
        System.out.println("Executing: " + sql);
    }
}

// Использование
DatabaseConnection db1 = DatabaseConnection.getInstance();
DatabaseConnection db2 = DatabaseConnection.getInstance();

System.out.println(db1 == db2); // true! Один и тот же объект
db1.execute("SELECT * FROM users"); // Executing: SELECT * FROM users

Проблемы классического подхода:

• Синхронизация замораживает производительность
• Не потокобезопасно при одновременном доступе
• Сложно тестировать

Лучший способ: Eager initialization + final

public class DatabaseConnection {
    // Создаём экземпляр сразу при загрузке класса
    public static final DatabaseConnection INSTANCE = new DatabaseConnection();
    
    private DatabaseConnection() {
        System.out.println("DatabaseConnection created");
    }
    
    public void execute(String sql) {
        System.out.println("Executing: " + sql);
    }
}

// Использование
DatabaseConnection.INSTANCE.execute("SELECT * FROM users");

Или через enum (самый безопасный способ):

public enum DatabaseConnection {
    INSTANCE;  // Единственный экземпляр
    
    DatabaseConnection() {
        System.out.println("DatabaseConnection created");
    }
    
    public void execute(String sql) {
        System.out.println("Executing: " + sql);
    }
}

// Использование
DatabaseConnection.INSTANCE.execute("SELECT * FROM users");

// Почему enum безопаснее:
// - Потокобезопасен по умолчанию
// - Защищён от рефлексии
// - Защищён от клонирования
// - Сериализуется корректно

Синглтон в Spring: Scope управления

В Spring синглтон — это область видимости (scope) компонента, которую определяет Spring Container. По умолчанию все @Component, @Service, @Repository существуют как синглтоны в контексте Spring, но это управляется фреймворком.

// Spring Service — автоматически синглтон
@Service
public class UserService {
    private final UserRepository userRepository;
    
    // Инъекция зависимостей — Spring управляет
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
        System.out.println("UserService created");
    }
    
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

// Spring Repository — автоматически синглтон
@Repository
public class UserRepository {
    // Spring автоматически создаёт один экземпляр и переиспользует его
}

// Использование
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class);
        
        // Получаем два "экземпляра" из контекста
        UserService service1 = context.getBean(UserService.class);
        UserService service2 = context.getBean(UserService.class);
        
        System.out.println(service1 == service2); // true! Один синглтон
    }
}

Разные Scopes в Spring

В Spring есть разные scopes, а не только синглтон:

// 1. Singleton (по умолчанию)
@Service
public class UserService {
    // Создаётся один раз при запуске приложения
    // Все запросы используют один и тот же экземпляр
}

// 2. Prototype — новый экземпляр каждый раз
@Service
@Scope("prototype")
public class RequestProcessor {
    // Новый экземпляр при каждом getBean()
}

// 3. Request — новый на каждый HTTP запрос
@Controller
@Scope("request")
public class UserController {
    // Один экземпляр на HTTP request
}

// 4. Session — один на сессию пользователя
@Component
@Scope("session")
public class UserSession {
    // Один экземпляр на HTTP сессию
}

// Пример
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class);
        
        // Singleton — один на всех
        UserService s1 = context.getBean(UserService.class);
        UserService s2 = context.getBean(UserService.class);
        System.out.println(s1 == s2); // true
        
        // Prototype — разные
        RequestProcessor p1 = context.getBean(RequestProcessor.class);
        RequestProcessor p2 = context.getBean(RequestProcessor.class);
        System.out.println(p1 == p2); // false
    }
}

Ключевые отличия

Когда использовать синглтон Java

// Утилита без состояния
public class StringUtils {
    public static String capitalize(String str) {
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }
}

// Pooling ресурсов (коннекшены к БД)
public class ConnectionPool {
    private static final ConnectionPool INSTANCE = new ConnectionPool();
    private List<Connection> connections = new ArrayList<>();
    
    private ConnectionPool() {
        // Инициализируем пул
    }
    
    public static ConnectionPool getInstance() {
        return INSTANCE;
    }
    
    public Connection borrowConnection() {
        // Логика пула
        return null;
    }
}

// Логирование
public enum Logger {
    INSTANCE;
    
    public void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

Когда использовать Spring синглтон

// Сервисы (бизнес-логика)
@Service
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    
    public OrderService(OrderRepository orderRepository, 
                       PaymentService paymentService) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
    }
    
    public Order placeOrder(CreateOrderRequest request) {
        // Бизнес-логика
        return orderRepository.save(new Order());
    }
}

// Контроллеры
@RestController
public class OrderController {
    private final OrderService orderService;
    
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }
    
    @PostMapping("/orders")
    public Order createOrder(@RequestBody CreateOrderRequest request) {
        return orderService.placeOrder(request);
    }
}

// Repositories
@Repository
public class UserRepository extends JpaRepository<User, Long> {
    // Spring автоматически создаёт синглтон
}

Проблема: Синглтон Java в Spring приложении

// ❌ ПЛОХО: смешивание паттернов
@Service
public class ConfigurationManager {
    public static ConfigurationManager getInstance() {
        return INSTANCE; // Java singleton паттерн
    }
}

// ✅ ХОРОШО: использовать только Spring
@Service
public class ConfigurationManager {
    // Spring управляет синглтоном, просто инъектим
}

// И в других классах
@Service
public class SomeOtherService {
    private final ConfigurationManager config;
    
    public SomeOtherService(ConfigurationManager config) {
        this.config = config;  // Инъекция вместо getInstance()
    }
}

Итоговый ответ

Синглтон в Java — паттерн проектирования, гарантирующий один экземпляр класса через приватный конструктор. Разработчик явно контролирует создание и доступ.

Синглтон в Spring — это scope управления, где Spring Container автоматически создаёт один экземпляр компонента и переиспользует его. Это часть большей системы управления жизненным циклом с другими scopes (prototype, request, session).

В Spring приложениях: Используй Spring scopes, избегай Java singleton паттерна. Spring даёт больше гибкости, тестируемости и контроля.