Как отличить Framework от библиотеки

# Разница между Framework и библиотекой

Краткий ответ

Основное отличие в контроле потока выполнения:

• Библиотека — ты вызываешь её функции, когда нужно
• Framework — фреймворк вызывает твой код по своим правилам (инверсия управления)

Библиотека — инструмент, фреймворк — каркас, на котором строится приложение.

Инверсия управления (IoC) — главное отличие

Библиотека (ты управляешь потоком)

public class OrderProcessor {
    public void processOrder(Order order) {
        // 1. ТЫ решаешь, когда вызвать логирование
        logger.info("Начали обработку заказа");
        
        // 2. ТЫ решаешь, когда валидировать
        validator.validate(order);
        
        // 3. ТЫ решаешь, когда сохранить
        database.save(order);
        
        // 4. ТЫ решаешь, когда отправить
        emailService.sendConfirmation(order);
        
        logger.info("Заказ обработан");
    }
}

// Использование
OrderProcessor processor = new OrderProcessor();
processor.processOrder(myOrder);  // ТЫ вызываешь

Характеристики:

• Ты контролируешь последовательность
• Ты вызываешь нужные функции
• Простая логика

Framework (фреймворк управляет потоком)

// Ты только определяешь обработчик
@RestController
@RequestMapping("/api/orders")
public class OrderController {
    
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(@RequestBody OrderRequest request) {
        // ФРЕЙМВОРК уже:
        // - Получил HTTP запрос
        // - Распарсил JSON
        // - Вызвал твой метод
        // - Сериализует ответ обратно в JSON
        
        Order order = orderService.createOrder(request);
        return ResponseEntity.ok(new OrderResponse(order));
    }
}

// Использование
// ФРЕЙМВОРК (Spring) автоматически:
// 1. Регистрирует этот контроллер
// 2. Слушает HTTP запросы
// 3. Маршрутизирует на нужный метод
// 4. Вызывает твой код в нужный момент

Характеристики:

• Фреймворк контролирует поток
• Ты определяешь компоненты и их поведение
• Фреймворк решает, когда их вызвать

Аналогия из реальной жизни

Библиотека — инструменты в мастерской

Ты строишь дом:
┌─────────────────────────────────────┐
│ Молоток  │ Пила  │ Дрель │ Уровень │
└─────────────────────────────────────┘

Ты решаешь:
- Когда использовать молоток
- Когда использовать пилу
- Последовательность работ
- Общий план

Библиотека просто помогает, но план ТВОЙ

Framework — готовый проект дома

Фреймворк предоставляет:
┌──────────────────────────────────┐
│ Фундамент  │ Стены  │ Крыша    │
│ Электрика  │ Трубы  │ Двери    │
└──────────────────────────────────┘

Ты только:
- Размещаешь мебель (в нужные комнаты)
- Красишь стены (в свои цвета)
- Вешаешь картины (в нужных местах)

Фреймворк уже определил основную структуру

Примеры из Java мира

Библиотеки

// Jackson — JSON библиотека
ObjectMapper mapper = new ObjectMapper();
User user = mapper.readValue(jsonString, User.class);  // ТЫ решаешь когда

// Apache Commons — утилиты
String uppercased = StringUtils.upperCase("hello");  // ТЫ вызываешь

// Logback — логирование
logger.info("Сообщение");  // ТЫ решаешь что логировать

// JUnit — тестирование
@Test
public void testSomething() {  // ТЫ пишешь тест
    assertEquals(2, 1 + 1);
}

Frameworks

// Spring Framework
@Service
public class UserService {
    @Autowired  // Spring внедрит зависимость
    private UserRepository repository;
    
    @Transactional  // Spring управляет транзакцией
    public User saveUser(User user) {
        return repository.save(user);
        // Spring автоматически:
        // - Начнёт транзакцию
        // - Вызовет твой метод
        // - Закоммитит или откатит
    }
}

// Hibernate ORM — даже это фреймворк!
// Он управляет сессией, кешем, ленивой загрузкой

// Spring Security
// Перехватывает запросы, проверяет права
// Потом вызывает твой контроллер

Сравнительная таблица

Callback — мостик между библиотекой и фреймворком

Библиотеки используют callbacks для частичной инверсии управления:

// Библиотека для асинхронных операций
public interface Callback<T> {
    void onSuccess(T result);
    void onError(Exception error);
}

public class AsyncLibrary {
    public void fetchData(String url, Callback<String> callback) {
        // Библиотека делает работу
        try {
            String result = httpClient.get(url);
            // Библиотека вызывает ТВЕ обработчик
            callback.onSuccess(result);
        } catch (Exception e) {
            callback.onError(e);
        }
    }
}

// Использование
AsyncLibrary lib = new AsyncLibrary();
lib.fetchData("https://api.example.com", new Callback<String>() {
    @Override
    public void onSuccess(String result) {
        // Твой код вызывается библиотекой
        System.out.println("Результат: " + result);
    }
    
    @Override
    public void onError(Exception error) {
        System.err.println("Ошибка: " + error);
    }
});

Lifecycle — как фреймворк управляет

Spring Example:

@Component
public class MyService implements InitializingBean, DisposableBean {
    
    // ФРЕЙМВОРК вызывает эти методы автоматически
    
    @PostConstruct  // Фреймворк вызовет после создания
    public void init() {
        System.out.println("Сервис инициализирован");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Все свойства установлены");
    }
    
    public void doWork() {
        // Твой код
    }
    
    @PreDestroy  // Фреймворк вызовет при завершении
    public void cleanup() {
        System.out.println("Очистка ресурсов");
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("Сервис уничтожен");
    }
}

// Жизненный цикл контролирует ФРЕЙМВОРК, не ты!

Dependency Injection — признак Framework

// Фреймворк сам создаёт объекты и связывает их

@Service
public class OrderService {
    private final UserRepository userRepository;  // Не new!
    private final EmailService emailService;      // Не new!
    
    @Autowired  // Фреймворк внедрит автоматически
    public OrderService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

// Ты не пишешь:
// OrderService service = new OrderService(new UserRepository(), new EmailService());
// Фреймворк это сделает за тебя!

Практическое различие в разработке

Использование библиотеки

public class MyApp {
    public static void main(String[] args) {
        // ТЫ создаёшь объекты
        Logger logger = LoggerFactory.getLogger(MyApp.class);
        ConfigParser parser = new ConfigParser();
        DatabaseConnector db = new DatabaseConnector();
        
        // ТЫ решаешь последовательность
        Map<String, String> config = parser.parse("config.properties");
        db.connect(config.get("db.url"));
        
        logger.info("Приложение запущено");
        
        // ТЫ вызываешь методы
        db.query("SELECT * FROM users");
    }
}

Использование Framework

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        // ФРЕЙМВОРК делает всё
        SpringApplication.run(MyApp.class, args);
    }
}

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    
    @GetMapping("/users")
    public List<User> getUsers() {
        // ФРЕЙМВОРК уже:
        // - Создал объекты
        // - Связал зависимости
        // - Прослушивает HTTP
        // - Распарсил параметры
        // - Вызвал твой метод
        // - Сериализует ответ
        return userService.getAllUsers();
    }
}

Когда выбирать

Выбираю библиотеку когда:

// ✅ Нужна конкретная функция
ObjectMapper mapper = new ObjectMapper();  // Jackson

// ✅ Хочу полный контроль
public void processData() {
    validate(data);
    transform(data);
    save(data);
}

// ✅ Строю свою архитектуру
public class MyFramework {
    // Сам определяю структуру
}

Выбираю Framework когда:

// ✅ Нужна полная система
Spring для веб-приложений
Hibernate для БД
SpringSecurity для авторизации

// ✅ Хочу следовать конвенциям
// (convention over configuration)

// ✅ Нужно быстро запустить приложение

Итоги

1. Библиотека — ты вызываешь её функции (вызываешь ты)
2. Framework — фреймворк вызывает твой код (вызывает фреймворк)
3. IoC (Inversion of Control) — главное отличие фреймворка
4. Callbacks — библиотеки используют их для частичной IoC
5. Lifecycle — фреймворк управляет жизненным циклом объектов
6. Dependency Injection — типичный признак Framework
7. На практике — часто используем и библиотеки, и фреймворки вместе (Spring + Jackson + JUnit)