Inyección por constructor frente a inyección por campos
Elija el estilo de inyección adecuado
Inyección por constructor frente a inyección por campos es una lección gratuita de Spring Boot 4 Microservices & REST APIs en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Spring Boot 4 Microservices & REST APIs, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Spring Boot 4 Microservices & REST APIs incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
Three Ways to Inject
Spring can inject dependencies three ways: through the constructor, into fields, or via setters. They all work, but they are not equal in quality.
The Spring team and community strongly recommend constructor injection. This lesson explains why.
Field Injection
Field injection places @Autowired directly on a field. It looks compact, but hides the dependency and complicates testing.
@Service
public class OrderService {
@Autowired
private OrderRepository repo;
@Autowired
private PricingService pricing;
}Constructor Injection
Constructor injection declares dependencies as constructor parameters. Spring supplies them when building the bean. Fields can be final, signaling true immutability.
@Service
public class OrderService {
private final OrderRepository repo;
private final PricingService pricing;
public OrderService(OrderRepository repo, PricingService pricing) {
this.repo = repo;
this.pricing = pricing;
}
}No @Autowired Needed
Since Spring 4.3, if a bean has a single constructor, @Autowired is optional. This keeps constructor-injected classes clean and annotation-light.
@Service
public class OrderService {
private final OrderRepository repo;
// single constructor: no @Autowired required
public OrderService(OrderRepository repo) {
this.repo = repo;
}
}Immutability and final
Constructor injection lets every dependency be final. The object is fully initialized once and never changes its collaborators, which prevents accidental reassignment and aids thread safety.
Field injection cannot use final, so the object can exist in a partially built state.
Testability Without Spring
A constructor makes dependencies explicit, so unit tests can build the object directly with mocks — no Spring context, no reflection.
@Test
void placesOrder() {
OrderRepository repo = mock(OrderRepository.class);
PricingService pricing = mock(PricingService.class);
OrderService svc = new OrderService(repo, pricing);
// ... arrange and assert
}Detecting Too Many Dependencies
A bloated constructor is a visible code smell. If a class needs eight collaborators, the long parameter list screams that it does too much. Field injection hides this and lets god-classes grow unnoticed.
Avoiding Circular Dependencies
Constructor injection surfaces circular dependencies at startup with a clear error, because two beans cannot both be constructed first. Field injection can mask the cycle until runtime, leading to subtle bugs.
A startup failure is the right time to discover and fix a design cycle.
Setter Injection
Setter injection suits genuinely optional dependencies that can change after construction. It is rarely needed; prefer constructor injection for required collaborators.
@Service
public class ReportService {
private Formatter formatter = new PlainFormatter();
@Autowired(required = false)
public void setFormatter(Formatter formatter) {
this.formatter = formatter;
}
}Less Boilerplate with Lombok
If constructors feel verbose, Lombok’s @RequiredArgsConstructor generates one from all final fields, giving constructor injection’s benefits with minimal code.
@Service
@RequiredArgsConstructor
public class OrderService {
private final OrderRepository repo;
private final PricingService pricing;
}Why the Recommendation Stands
Constructor injection wins on every axis:
- Immutable, fully initialized objects
- Trivial unit testing without a container
- Cycles and over-dependency become visible
- No reflection-only access for tests
Quick Check
Test your understanding of injection styles.
Recap
Prefer constructor injection.
- Enables
final, immutable dependencies - Single constructor needs no
@Autowired - Unit-testable without the Spring context
- Exposes circular dependencies and over-large classes
- Use setters only for optional, mutable collaborators
Preguntas frecuentes
¿La lección «Inyección por constructor frente a inyección por campos» es gratis?
Sí — el texto completo de «Inyección por constructor frente a inyección por campos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Spring Boot 4 Microservices & REST APIs, actualiza a CoddyKit PRO. El curso de Spring Boot 4 Microservices & REST APIs incluye 4 lecciones en total.
¿Qué aprenderé en «Inyección por constructor frente a inyección por campos»?
Elija el estilo de inyección adecuado Practicas Spring Boot 4 Microservices & REST APIs con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Spring Boot 4 Microservices & REST APIs?
No se requiere experiencia previa. Spring Boot 4 Microservices & REST APIs en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Inyección por constructor frente a inyección por campos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Spring Boot 4 Microservices & REST APIs?
Sí. Cada lección de Spring Boot 4 Microservices & REST APIs incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- El contenedor IoC de Spring
- Inyección por constructor frente a inyección por campos
- Ámbitos de los beans
- Callbacks del ciclo de vida