Где может потребоваться доступ к классу в обход Spring?

# Доступ к Классу в Обход Spring

Когда Нужен Обход Spring?

Хотя Spring — мощный DI контейнер, есть ситуации, когда нужен доступ к классам без Spring, используя конструктор напрямую.

Случай 1: Простые Data Transfer Objects (DTO)

// DTO — примитивный объект, не требует Spring
public class UserDTO {
    private String name;
    private String email;
    private int age;
    
    public UserDTO(String name, String email, int age) {
        this.name = name;
        this.email = email;
        this.age = age;
    }
}

// Использование
public class UserService {
    public UserDTO mapToDTO(User user) {
        // Создаём DTO БЕЗ Spring (просто new)
        return new UserDTO(user.getName(), user.getEmail(), user.getAge());
    }
}

Почему? DTO — это простой контейнер данных, он не имеет зависимостей и не требует управления жизненным циклом.

Случай 2: Утилиты и Helper Классы

// Утилита — нет зависимостей, нет состояния
public class DateUtils {
    
    // Статический метод лучше чем bean
    public static LocalDate parseDate(String dateString) {
        return LocalDate.parse(dateString, DateTimeFormatter.ISO_DATE);
    }
    
    public static String formatDate(LocalDate date) {
        return date.format(DateTimeFormatter.ISO_DATE);
    }
}

// Использование
public class OrderService {
    public void processOrder(Order order) {
        // Не нужно инжектировать, просто используем
        order.setCreatedAt(DateUtils.parseDate("2024-01-15"));
    }
}

Почему? Утилиты stateless, не нужно создавать бин для каждого метода.

Случай 3: Исключения (Exception Classes)

// Исключения создаются без Spring
public class InvalidUserException extends RuntimeException {
    public InvalidUserException(String message) {
        super(message);
    }
    
    public InvalidUserException(String message, Throwable cause) {
        super(message, cause);
    }
}

// Использование
public class UserValidator {
    public void validate(User user) {
        if (user.getEmail() == null || user.getEmail().isEmpty()) {
            // Создаём исключение БЕЗ Spring
            throw new InvalidUserException("Email cannot be empty");
        }
    }
}

Почему? Исключения — это условия, не объекты бизнес-логики.

Случай 4: Entity/Model Классы

// Entity — наше доменное модель
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String email;
    
    @Column(nullable = false)
    private String name;
    
    // Конструктор БЕЗ Spring
    public User(String email, String name) {
        this.email = email;
        this.name = name;
    }
}

// Использование
public class UserService {
    public User createUser(String email, String name) {
        // Создаём entity БЕЗ Spring (просто new)
        User user = new User(email, name);
        return userRepository.save(user);
    }
}

Почему? Entity — это наша доменная модель, создаётся как обычный класс.

Случай 5: Enum Значения

// Enum — всегда БЕЗ Spring
public enum UserStatus {
    ACTIVE("active"),
    INACTIVE("inactive"),
    BANNED("banned");
    
    private final String displayName;
    
    UserStatus(String displayName) {
        this.displayName = displayName;
    }
    
    public String getDisplayName() {
        return displayName;
    }
}

// Использование
public class User {
    private UserStatus status;
    
    public void activate() {
        // Используем enum БЕЗ Spring
        this.status = UserStatus.ACTIVE;
    }
}

Почему? Enum — это тип, управляется Java, не Spring.

Случай 6: Event Objects и Messages

// Event — это data transfer object
public class UserCreatedEvent {
    private String userId;
    private String email;
    private LocalDateTime createdAt;
    
    public UserCreatedEvent(String userId, String email) {
        this.userId = userId;
        this.email = email;
        this.createdAt = LocalDateTime.now();
    }
}

// Использование
@Service
public class UserService {
    
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    public void createUser(String email) {
        User user = new User(email);
        // ...
        
        // Создаём event БЕЗ Spring (просто new)
        UserCreatedEvent event = new UserCreatedEvent(user.getId(), user.getEmail());
        eventPublisher.publishEvent(event);
    }
}

Почему? Event — это data, а не бизнес-сервис.

Случай 7: Временные Объекты в Методах

@Service
public class ReportService {
    
    public ReportData generateReport(List<Order> orders) {
        // Временный helper объект
        class OrderAggregator {
            private BigDecimal totalAmount = BigDecimal.ZERO;
            private int count = 0;
            
            void add(Order order) {
                totalAmount = totalAmount.add(order.getAmount());
                count++;
            }
        }
        
        OrderAggregator aggregator = new OrderAggregator();
        orders.forEach(aggregator::add);
        
        return new ReportData(aggregator.getTotal(), aggregator.getCount());
    }
}

Почему? Временные helper объекты не нужно регистрировать в Spring.

Случай 8: Тестирование (Mock Объекты)

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {
    
    @Test
    public void testUserCreation() {
        // Создаём mock БЕЗ Spring Mockito
        UserRepository mockRepo = Mockito.mock(UserRepository.class);
        
        // Создаём сервис с mock'ом напрямую (не через Spring)
        UserService service = new UserService(mockRepo);
        
        User user = new User("John", "john@mail.com");
        service.save(user);
        
        verify(mockRepo).save(user);
    }
}

Почему? В тестах часто нужны конкретные конфигурации, не из Spring context.

Рекомендация: Когда Использовать new vs Autowired

Антипаттерн: НЕ делай так

// ❌ ПЛОХО: Регистрируем простой DTO как bean
@Configuration
public class BadConfig {
    @Bean
    public UserDTO userDTO() {
        return new UserDTO("John", "john@mail.com", 30);
    }
}

// ❌ ПЛОХО: Инжектируем утилиту вместо статического метода
@Component
public class DateUtilityBean {
    public LocalDate parseDate(String date) {
        return LocalDate.parse(date);
    }
}

@Service
public class BadService {
    @Autowired
    private DateUtilityBean dateUtil;  // Зачем?
}

// ✅ ХОРОШО: Используем new для простых объектов
public class GoodService {
    public void processOrder(Order order) {
        OrderDTO dto = new OrderDTO(order);  // Просто new, без Spring
        order.setCreatedAt(DateUtils.parseDate("2024-01-15"));
    }
}

Заключение

Доступ в обход Spring нужен для:

• Data Transfer Objects (DTO)
• Утилиты и вспомогательные классы
• Исключения
• Entity/Model классы
• Enum значения
• Event объекты
• Временные объекты
• Тестирование

Правило: Если объект не требует управления жизненным циклом и зависимостей — создавай его с new, не усложняй Spring контейнер.