[2026-02-13] poprawki

Author: sirtekyt

…innismy-wstrzykiwac-przez-konstruktor.md …innismy-wstrzykiwac-przez-konstruktor.md_posts/pl/2026-03-06-czy-wiesz-ze-zaleznosci-w-springu-powinnismy-wstrzykiwac-przez-konstruktor.md renamed to _posts/pl/2026-03-12-czy-wiesz-ze-zaleznosci-w-springu-powinnismy-wstrzykiwac-przez-konstruktor.md _posts/pl/2026-03-06-czy-wiesz-ze-zaleznosci-w-springu-powinnismy-wstrzykiwac-przez-konstruktor.md renamed to _posts/pl/2026-03-12-czy-wiesz-ze-zaleznosci-w-springu-powinnismy-wstrzykiwac-przez-konstruktor.md

@@ -1,20 +1,20 @@
 ---
 layout:    post
 title:     "Czy wiesz, że zależności w Springu powinniśmy wstrzykiwać przez konstruktor?"
-date:      2026-02-12T08:00:00+01:00
+date:      2026-03-12T08:00:00+01:00
 published: true
 didyouknow: false
 lang: pl
 author: bpietrowiak
-image: /assets/img/posts/2026-03-06-czy-wiesz-ze-zaleznosci-w-springu-powinnismy-wstrzykiwac-przez-konstruktor/thumbnail.webp
+image: /assets/img/posts/2026-03-12-czy-wiesz-ze-zaleznosci-w-springu-powinnismy-wstrzykiwac-przez-konstruktor/thumbnail.webp
 description: "Poznaj zalety tego podejścia, przykłady kodu i wskazówki dotyczące testowania oraz bezpieczeństwa aplikacji."
 tags:
 - spring boot
 - java
 ---
 
 Czy wiesz, że sposób wstrzykiwania zależności w Springu może mieć ogromny wpływ na jakość Twojego kodu, jego bezpieczeństwo i łatwość testowania? 
-Jeśli chcesz pisać lepsze aplikacje, warto poznać najważniejsze techniki i wybrać tę, która naprawdę robi różnicę.
+Jeśli chcesz pisać lepsze aplikacje, warto poznać najważniejsze techniki i wybrać tę, która przynosi najlepsze efekty.
 
 ## Czym jest wstrzykiwanie zależności?
 
@@ -28,14 +28,14 @@ w którym zarządzanie tworzeniem obiektów i ich zależnościami przekazywane j
 Możemy wyróżnić kilka sposobów wstrzykiwania zależności, z których każdy ma swoje zalety i ograniczenia. 
 Poniżej przedstawiam najpopularniejsze techniki DI:
 
-- Wstrzykiwanie przez konstruktor z jawnie zdefiniowanym konstruktorem
+- Wstrzykiwanie jawnie zdefiniowanym konstruktorem
 ```java
 @Component
-public class ServiceA {
-    private final ServiceB serviceB;
+public class OrderService {
+    private final PaymentService paymentService;
 
-    public ServiceA(final ServiceB serviceB) {
-        this.serviceB = serviceB;
+    public OrderService(final PaymentService paymentService) {
+        this.paymentService = paymentService;
     }
 }
 ```
@@ -44,68 +44,111 @@ public class ServiceA {
 ```java
 @Component
 @RequiredArgsConstructor
-public class ServiceA {
-    private final ServiceB serviceB;
+public class OrderService {
+    private final PaymentService paymentService;
 }
 ```
 *Adnotacja `@RequiredArgsConstructor` pochodzi z biblioteki Lombok i automatycznie generuje konstruktor przyjmujący wszystkie pola oznaczone jako `final` 
 lub z adnotacją `@NonNull`.*
+- Wstrzykiwanie przez pola
+```java
+@Component
+public class OrderService {
+    @Autowired
+    private PaymentService paymentService;
+}
+```
+*Wstrzykiwanie przez pola jest najmniej zalecanym podejściem, ponieważ utrudnia testowanie i nie pozwala na oznaczenie zależności jako finalne. 
+Może być stosowane w wyjątkowych przypadkach, np. w bardzo prostych klasach lub kodzie legacy.*
+
+
+### @Qualifier - kiedy i jak używać?
+
+Adnotacja `@Qualifier` służy do wskazania konkretnego beana, gdy w kontekście Springa istnieje wiele beanów tego samego typu.
+Technicznie działa w każdym stylu wstrzykiwania, ale podejścia różnią się czytelnością i łatwością testowania.
+
+Najbardziej czytelnie: `@Qualifier` w konstruktorze
+```java
+@Component
+public class OrderService {
+    private final PaymentService paymentService;
+
+    public OrderService(@Qualifier("paymentService") PaymentService paymentService) {
+        this.paymentService = paymentService;
+    }
+}
+```
+
+Gdy zależność jest opcjonalna: `@Qualifier` w setterze
+```java
+@Component
+public class OrderService {
+    private PaymentService paymentService;
+
+    @Autowired
+    public void setPaymentService(
+            @Qualifier("paymentService") PaymentService paymentService) {
+        this.paymentService = paymentService;
+    }
+}
+```
+
+Najmniej zalecane: `@Qualifier` na polu
+```java
+@Component
+public class OrderService {
+    @Autowired
+    @Qualifier("paymentService")
+    private PaymentService paymentService;
+}
+```
+
+Jeśli używasz Lombok (`@RequiredArgsConstructor`), możesz pozostać przy stylu konstruktorowym i jednocześnie oznaczyć pole adnotacją `@Qualifier`:
 
-- Wstrzykiwanie przez konstruktor z wykorzystaniem adnotacji `@RequiredArgsConstructor` oraz `@Qualifier`
 ```java
 @Component
 @RequiredArgsConstructor
-public class ServiceA {
-    @Qualifier("serviceB")
-    private final ServiceB serviceB;
+public class OrderService {
+    @Qualifier("paymentService")
+    private final PaymentService paymentService;
 }
 ```
-*Adnotacja `@Qualifier` jest przydatna, gdy w kontekście Springa istnieje wiele beanów tego samego typu i chcemy wskazać, 
-który z nich ma zostać wstrzyknięty.*
 
-W pliku `lombok.config` należy dodać wpis:
+W takim wariancie dodaj w pliku `lombok.config`:
 
 ```
 lombok.copyableAnnotations += org.springframework.beans.factory.annotation.Qualifier
 ```
 
+Dzięki temu Lombok przeniesie `@Qualifier` z pola do parametru wygenerowanego konstruktora.
+
 - Wstrzykiwanie przez settery (metody ustawiające)
 ```java
 @Component
-public class ServiceA {
-    private ServiceB serviceB;
+public class OrderService {
+    private PaymentService paymentService;
 
     @Autowired
-    public void setServiceB(ServiceB serviceB) {
-        this.serviceB = serviceB;
+    public void setPaymentService(PaymentService paymentService) {
+        this.paymentService = paymentService;
     }
 }
 ```
 *Wstrzykiwanie przez settery może być uzasadnione, gdy zależność jest opcjonalna lub gdy pracujemy z kodem legacy, gdzie nie możemy zmienić konstruktora.*
 
-- Wstrzykiwanie przez pola
-```java
-@Component
-public class ServiceA {
-    @Autowired
-    private ServiceB serviceB;
-}
-```
-*Wstrzykiwanie przez pola jest najmniej zalecane, ponieważ utrudnia testowanie i nie pozwala na oznaczenie zależności jako finalne. 
-Może być stosowane w wyjątkowych przypadkach, np. w bardzo prostych klasach lub kodzie legacy.*
 
 ## Którą metodę powinniśmy wykorzystywać i dlaczego?
 
 Rekomendowanym podejściem jest wykorzystywanie wstrzykiwania przez konstruktor. Oto powody, dla których to podejście jest preferowane:
 
 - **Wymuszenie przekazania zależności podczas tworzenia obiektu** – wstrzykiwanie przez konstruktor gwarantuje, 
 że wszystkie wymagane zależności zostaną dostarczone w momencie tworzenia instancji obiektu. Dzięki temu unikamy sytuacji, 
-w której klasa może być używana bez pełnych zależności, co mogłoby prowadzić do błędów w czasie działania.
+w której klasa może być używana bez pełnych zależności, co mogłoby prowadzić do błędów w runtime.
 - **Niezmienność obiektu** – przypisanie zależności poprzez konstruktor oznacza, że pola te mogą być oznaczone jako `final`,
 co zapewnia ich niezmienność i chroni przed niepożądanymi modyfikacjami w trakcie cyklu życia obiektu. Taka konstrukcja promuje czystszy i bardziej bezpieczny kod.
 - **Testy jednostkowe** – wstrzykiwanie przez konstruktor ułatwia testowanie, 
-ponieważ możemy ręcznie dostarczać zależności (np. mocki) bez potrzeby używania narzędzi wspomagających, jak refleksja. 
-To pozwala na łatwiejsze pisanie testów jednostkowych i zachowanie pełnej kontroli nad zależnościami podczas testowania.
+ponieważ możemy ręcznie dostarczać zależności (np. mocki) bez potrzeby używania takich narzędzi wspomagających, jak refleksja.
+To ułatwia pisanie testów jednostkowych i pozwala na zachowanie pełnej kontroli nad zależnościami podczas testowania.
 
 
 Wstrzykiwanie przez konstruktor wspiera zasady **SOLID**, w szczególności:
@@ -121,12 +164,12 @@ Programista, przeglądając kod, natychmiast widzi, jakie komponenty są wymagan
 W przypadku wstrzykiwania przez konstruktor łatwiej jest zidentyfikować brakujące zależności lub problemy z ich konfiguracją podczas uruchamiania aplikacji, 
 ponieważ Spring od razu poinformuje nas o braku zależności, której nie można dostarczyć.
 
-Konstruktor pozwala lepiej unikać problemów z cyklicznymi zależnościami, które mogą występować w innych formach wstrzykiwania (np. wstrzykiwanie przez pola). 
+Konstruktor pomaga w szybszym wykrywaniu problemów z cyklicznymi zależnościami, które mogą występować w innych formach wstrzykiwania (np. wstrzykiwanie przez pola). 
 Spring będzie w stanie zidentyfikować takie sytuacje już na etapie konfigurowania obiektów, co ułatwia ich eliminację.
 
 ## Podsumowanie
 
 Wstrzykiwanie zależności przez konstruktor to najlepsza praktyka w aplikacjach Spring. 
-Zapewnia bezpieczeństwo, czytelność kodu, łatwość testowania i zgodność z zasadami SOLID. 
-Warto stosować to podejście zawsze, gdy to możliwe, a inne metody rezerwować dla szczególnych przypadków (opcjonalne zależności, legacy code). 
+Zapewnia bezpieczeństwo, czytelność kodu, łatwość testowania i zgodność z zasadami SOLID.
+Warto przyjąć to podejście jako domyślny standard w każdym projekcie, a inne metody rezerwować dla szczególnych przypadków (opcjonalne zależności, legacy code). 
 Dzięki temu Twój kod będzie bardziej niezawodny i łatwiejszy w utrzymaniu.