Różnice między bibliotekami a starterami w Spring Boot

Biblioteki Spring Boot Starter to specjalne, predefiniowane pakiety w ekosystemie Spring, które mają na celu uproszczenie zarządzania zależnościami i konfiguracją dla różnych funkcjonalności. Ich zadaniem jest zapewnienie gotowej paczki zależności i podstawowej konfiguracji dla konkretnych scenariuszy, takich jak dostęp do bazy danych, obsługa aplikacji webowych czy logowanie.

Różnica między starterami a zwykłymi bibliotekami, takimi jak ta, którą przedstawiłem w poprzednim przykładzie, polega głównie na celu i strukturze. Wyjaśnię to bardziej szczegółowo:

1. Co to są biblioteki typu "starter"?

Startery Spring Boot to specjalne pakiety, które zawierają predefiniowane zestawy zależności niezbędne do implementacji określonej funkcji. Są to głównie paczki ułatwiające życie programistom, pozwalając na szybkie dodanie odpowiednich bibliotek do projektu i eliminując potrzebę ręcznego zarządzania wieloma zależnościami.

Na przykład:

• spring-boot-starter-web to starter odpowiedzialny za aplikacje webowe. Zawiera wszystkie niezbędne zależności, takie jak Spring MVC, Tomcat jako domyślny kontener aplikacji, oraz inne kluczowe biblioteki do tworzenia aplikacji webowych.
• spring-boot-starter-data-jpa to starter do obsługi JPA (Java Persistence API), który automatycznie dodaje zależności do Hibernate, Spring Data JPA oraz baz danych.

W porównaniu do zwykłej biblioteki, starter:

• Nie oferuje bezpośrednio logiki biznesowej lub narzędzi, ale dostarcza zestaw zależności, które są typowo potrzebne dla konkretnego rodzaju aplikacji.
• Startery mają na celu ułatwienie konfiguracji oraz szybszy start w pracy z różnymi komponentami Spring Boot.

2. Różnica między starterami a zwykłą biblioteką

Podana wcześniej biblioteka (np. StringUtils) była prostą biblioteką narzędziową, która dostarczała konkretne funkcje (metody) do pracy z ciągami znaków. W przeciwieństwie do tego, startery Spring Boot są bardziej zestawami zależności i konfiguracji, a nie konkretnymi implementacjami logiki.

Kluczowe różnice:

• Cel:

  • Zwykła biblioteka (jak nasz przykład StringUtils) dostarcza pewne narzędzia lub logikę biznesową do użycia w aplikacjach.
  • Starter dostarcza zestaw zależności i konfiguracji, potrzebnych do korzystania z określonej technologii lub komponentu Spring Boot.

• Zarządzanie zależnościami:

  • W przypadku zwykłej biblioteki sam definiujesz jej zależności i konfigurację.
  • Starter automatycznie dodaje wszystkie niezbędne zależności oraz domyślne konfiguracje, eliminując konieczność ręcznego zarządzania nimi.

• Użyteczność:

  • Biblioteka dostarcza konkretne funkcje lub klasy do użycia w kodzie (np. StringUtils).
  • Starter dostarcza komponenty, konfiguracje i zależności, które są używane przez Spring Boot do automatycznego zarządzania komponentami aplikacji (np. konfiguracja bazy danych, systemu logowania).

3. Jak stworzyć własny starter?

Możesz stworzyć własny starter Spring Boot, który będzie działał podobnie jak oficjalne startery. Taki starter będzie zawierał gotową paczkę zależności i może dodać domyślną konfigurację dla innych projektów.

Przykład tworzenia własnego startera:

Załóżmy, że chcemy stworzyć starter, który automatycznie dodaje naszą klasę StringUtils oraz pewne domyślne zależności. Poniżej pokazuję, jak to zrobić.

Krok 1: Struktura projektu

Struktura projektu wygląda podobnie jak w przypadku zwykłej biblioteki, ale z tą różnicą, że starter będzie zawierał domyślną konfigurację.

Krok 2: Konfiguracja build.gradle

plugins {
    id 'java'
    id 'maven-publish'
}

group = 'com.example'
version = '1.0.0'
sourceCompatibility = '22'

repositories {
    mavenCentral()
}

dependencies {
    // Domyślne zależności, które będą dodane automatycznie
    implementation 'org.springframework.boot:spring-boot-starter:3.3.4'
    implementation 'org.springframework.boot:spring-boot-starter-logging'

    // Możesz dodać więcej zależności, np. do baz danych, logowania itp.
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
        }
    }
}

Krok 3: Automatyczna konfiguracja

W Spring Boot startery mogą również automatycznie konfigurować różne komponenty przy uruchomieniu aplikacji. Stwórz klasę konfiguracyjną w swoim starterze.

package com.example.common;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CommonLibraryAutoConfiguration {

    @Bean
    public StringUtils stringUtils() {
        return new StringUtils();
    }
}

Klasa CommonLibraryAutoConfiguration jest oznaczona adnotacją @Configuration, co oznacza, że Spring Boot automatycznie wykryje i skonfiguruje komponenty (w tym wypadku klasę StringUtils) w aplikacji, która będzie używać tego startera.

Krok 4: Plik spring.factories

Aby Spring Boot wiedział, że Twoja konfiguracja powinna być automatycznie załadowana, musisz dodać plik spring.factories do katalogu resources/META-INF/.

resources/
└── META-INF/
    └── spring.factories

W pliku spring.factories wpisz:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.common.CommonLibraryAutoConfiguration

Dzięki temu Spring Boot będzie wiedział, że klasa CommonLibraryAutoConfiguration powinna być automatycznie załadowana przy starcie aplikacji.

Krok 5: Publikacja startera

Podobnie jak w przypadku zwykłej biblioteki, opublikuj swój starter, korzystając z polecenia:

./gradlew publishToMavenLocal

Krok 6: Użycie startera

Aby użyć tego startera w innym projekcie, wystarczy dodać jego zależność w pliku build.gradle:

dependencies {
    implementation 'com.example:my-starter:1.0.0'
}

Spring Boot automatycznie załaduje konfigurację i zarejestruje komponent StringUtils bez potrzeby ręcznej konfiguracji.

4. Podsumowanie różnic

• Starter:

  • Zawiera zestaw zależności.
  • Może dodawać domyślną konfigurację i automatycznie rejestrować komponenty Spring Boot.
  • Upraszcza pracę poprzez automatyczne zarządzanie konfiguracją i komponentami.

• Zwykła biblioteka:

  • Zawiera konkretne funkcje lub narzędzia, ale nie zarządza zależnościami czy konfiguracją automatycznie.
  • Użytkownik musi sam dodać zależności i odpowiednio skonfigurować komponenty.

Startery są więc bardziej "plug-and-play", a zwykłe biblioteki wymagają więcej ręcznego zarządzania zależnościami i konfiguracją.