Для чего нужно разделять на слои MVC?

# Разделение на слои MVC (Model-View-Controller)

Определение MVC

MVC — это архитектурный паттерн, который разделяет приложение на три слоя:

• Model — бизнес-логика и данные
• View — представление (интерфейс пользователя)
• Controller — управление и взаимодействие между Model и View

Основные причины разделения на слои MVC

1. Разделение ответственности (Separation of Concerns)

Каждый слой отвечает за одну задачу:

// ❌ Плохо - все в одном классе
public class UserScreen {
    public void handleClick() {
        // Логика UI
        System.out.println("Button clicked");
        
        // Бизнес-логика
        User user = new User("John");
        user.validate();
        
        // Логика БД
        Connection conn = DriverManager.getConnection("jdbc:mysql://...");
        // SQL запрос...
        
        // Логика отправки
        sendEmail(user.getEmail());
    }
}

// ✅ Хорошо - каждый слой отдельно
// Model
public class User {
    private String name;
    private String email;
    
    public void validate() {
        // Бизнес-логика валидации
    }
}

public class UserService {
    public User createUser(String name) {
        // Логика создания пользователя
        User user = new User(name);
        user.validate();
        return user;
    }
}

// View
@Component
public class UserView {
    public void displayUser(User user) {
        System.out.println("User: " + user.getName());
    }
}

// Controller
@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;
    @Autowired
    private UserView userView;
    
    @PostMapping
    public void createUser(@RequestBody String name) {
        User user = userService.createUser(name);
        userView.displayUser(user);
    }
}

2. Повторное использование кода (Reusability)

Бизнес-логика (Model) может использоваться для разных UI (View):

// Один Model
public class UserService {
    public List<User> getActiveUsers() {
        // Сложная бизнес-логика
        return userRepository.findActiveUsers();
    }
}

// Разные View
// Веб-интерфейс
@Controller
public class WebController {
    @Autowired
    private UserService userService;
    
    @GetMapping("/users")
    public String getUsers(Model model) {
        model.addAttribute("users", userService.getActiveUsers());
        return "users";
    }
}

// REST API
@RestController
public class ApiController {
    @Autowired
    private UserService userService;
    
    @GetMapping("/api/users")
    public List<User> getUsers() {
        return userService.getActiveUsers();
    }
}

// Мобильное приложение (отдельный сервис)
public class MobileService {
    @Autowired
    private UserService userService;
    
    public void loadUsers() {
        List<User> users = userService.getActiveUsers();
        // Отправляем в мобильное приложение
    }
}

3. Тестируемость

Каждый слой можно тестировать независимо:

// Тестирование Model
@Test
public void testUserValidation() {
    User user = new User("");
    assertFalse(user.isValid());  // Не требует UI или БД
}

// Тестирование Service (Model layer)
@Test
public void testUserCreation() {
    UserService service = new UserService();
    User user = service.createUser("John");
    assertNotNull(user);
    assertEquals("John", user.getName());
}

// Тестирование Controller (без реального UI)
@Test
public void testUserEndpoint() {
    // Mock
    UserService userService = mock(UserService.class);
    User mockUser = new User("John");
    when(userService.createUser("John")).thenReturn(mockUser);
    
    // Test
    UserController controller = new UserController(userService);
    controller.createUser("John");  // Не требует браузера
}

// Тестирование View
@Test
public void testUserDisplay() {
    UserView view = new UserView();
    User user = new User("John");
    // Проверяем, что view правильно отображает данные
    view.displayUser(user);
}

4. Одновременная разработка

Разные команды могут работать параллельно:

Фронтенд команда     →  View (HTML, CSS, JavaScript)
      ↕
  Бэкенд команда     →  Controller + Service + Model
      ↕
Датабаза команда    →  Model, Repository

Фронтенд команда может работать с mock-данными, пока бэкенд не готов.

5. Упрощение поддержки и улучшения

Изменение в одном слое минимально влияет на другие:

// Если нужно изменить БД, меняем только Model
public class UserRepository {
    // Раньше использовали JDBC
    // Теперь используем JPA
    @Autowired
    private JpaRepository<User> repository;
}

// Service не нужно менять
public class UserService {
    @Autowired
    private UserRepository userRepository;
    // Код не меняется
}

// Controller не нужно менять
// View не нужно менять

6. Удобство для новых разработчиков

Новый разработчик понимает структуру:

src/
├── models/              # Бизнес-логика и классы данных
│   ├── User.java
│   └── Product.java
├── services/            # Бизнес-логика высокого уровня
│   ├── UserService.java
│   └── ProductService.java
├── controllers/         # REST endpoints, обработка запросов
│   ├── UserController.java
│   └── ProductController.java
├── repositories/        # Доступ к БД
│   ├── UserRepository.java
│   └── ProductRepository.java
└── views/             # Представление
    ├── user-list.html
    └── user-detail.html

Структура MVC в Spring Boot

// 1. Model - бизнес-логика
@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    public Order createOrder(CreateOrderRequest request) {
        Order order = new Order();
        order.setCustomer(request.getCustomer());
        order.setTotal(calculateTotal(request.getItems()));
        order.setStatus(OrderStatus.PENDING);
        
        return orderRepository.save(order);
    }
    
    private BigDecimal calculateTotal(List<OrderItem> items) {
        return items.stream()
            .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

// 2. Controller - обработка запросов
@RestController
@RequestMapping("/api/orders")
public class OrderController {
    @Autowired
    private OrderService orderService;
    
    @PostMapping
    public ResponseEntity<OrderDTO> createOrder(@RequestBody CreateOrderRequest request) {
        Order order = orderService.createOrder(request);
        return ResponseEntity.ok(convertToDTO(order));
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<OrderDTO> getOrder(@PathVariable Long id) {
        Order order = orderService.getOrder(id);
        return ResponseEntity.ok(convertToDTO(order));
    }
    
    private OrderDTO convertToDTO(Order order) {
        return new OrderDTO(
            order.getId(),
            order.getCustomer(),
            order.getTotal(),
            order.getStatus()
        );
    }
}

// 3. View - данные для отображения
public class OrderDTO {
    private Long id;
    private String customer;
    private BigDecimal total;
    private OrderStatus status;
    
    // Getters, Setters
}

Преимущества MVC

1. Масштабируемость — легко добавлять новые функции
2. Гибкость — легко менять UI без изменения логики
3. Качество — легче отловить баги в отдельном слое
4. Командная работа — параллельная разработка
5. Поддержка — понятная структура кода
6. Тестирование — легче писать юнит-тесты

Недостатки MVC

1. Сложность — больше файлов и классов для простых приложений
2. Оверхед — больше абстракций может замедлить разработку
3. Кривая обучения — новичкам нужно время на понимание

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

✅ Используй MVC для:

• Средних и крупных приложений
• Приложений с командной разработкой
• Проектов с долгосрочной поддержкой
• Систем с разными UI (веб, мобильное, API)

❌ Не используй для:

• Очень простых скриптов
• Экспериментальных проектов
• Конкурсов и хакатонов (если требуется скорость)