Spring Boot

Setter Injection

Setter injection provides dependencies through setter methods after the bean is constructed. It is the appropriate choice for optional dependencies — ones that have a reasonable default behavior when absent. Understanding when setter injection is correct, and when constructor injection is better, prevents common design mistakes.

What Is Setter Injection?

Setter injection injects dependencies through setter methods annotated with @Autowired. The bean is first created with its default (no-arg) constructor, then Spring calls each annotated setter to inject the corresponding dependency. The object is in a partially initialized state between construction and the last setter call — all dependencies are only available after all setters have been called. Setter injection was the recommended style in early Spring (before Spring 4), primarily because it allowed re-injection after construction — useful for testing. Modern Spring recommends constructor injection for mandatory dependencies and setter injection specifically for optional dependencies. An optional dependency is one where the class has a meaningful default behavior when the dependency is absent — a service that logs to a metrics system when available but works fine without it, or a notification service that uses SMS if an SMS provider is configured but functions with email alone otherwise.

Basic Setter Injection

Setter injection uses @Autowired on setter methods. By default, @Autowired is required — Spring throws if no matching bean exists. Set required=false for optional dependencies.

Java

// Basic setter injection — required dependency (prefer constructor for this):
@Service
public class UserService {

    private UserRepository userRepository;

    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // Note: field cannot be final with setter injection
    // The bean is created with default constructor, then setUserRepository() is called
}

// Optional setter injection — use required=false:
@Service
public class NotificationService {

    private EmailService emailService;      // primary delivery method
    private SmsService smsService;          // optional — may not be configured
    private PushNotificationService push;   // optional — may not be available

    // Required — must have at least email:
    @Autowired
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }

    // Optional — SMS works only if SmsService bean exists:
    @Autowired(required = false)
    public void setSmsService(SmsService smsService) {
        this.smsService = smsService;
    }

    // Optional — push notifications if available:
    @Autowired(required = false)
    public void setPushNotificationService(PushNotificationService push) {
        this.push = push;
    }

    public void notify(String userId, String message) {
        // Email always sent — required:
        emailService.send(userId, message);

        // SMS only if configured:
        if (smsService != null) {
            smsService.send(userId, message);
        }

        // Push only if configured:
        if (push != null) {
            push.send(userId, message);
        }
    }
}

Optional Dependencies — The Right Use Case

Setter injection with required=false is the clearest way to express that a dependency is optional. The class has documented behavior with and without the dependency, and null checks make the optionality explicit in the code.

Java

// Well-designed optional dependency pattern:
@Service
public class AuditableOrderService {

    // Required — must have these to function:
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;

    // Optional — metrics are nice to have but orders work without them:
    private MetricsCollector metricsCollector;

    // Optional — external audit log, may not be configured in all environments:
    private ExternalAuditService externalAuditService;

    // Constructor for required dependencies:
    public AuditableOrderService(OrderRepository orderRepository,
                                  PaymentService paymentService) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
    }

    // Setters for optional dependencies:
    @Autowired(required = false)
    public void setMetricsCollector(MetricsCollector metricsCollector) {
        this.metricsCollector = metricsCollector;
    }

    @Autowired(required = false)
    public void setExternalAuditService(ExternalAuditService externalAuditService) {
        this.externalAuditService = externalAuditService;
    }

    public Order createOrder(CreateOrderRequest request) {
        PaymentResult payment = paymentService.charge(
            request.customerId(), request.totalAmount()
        );
        Order order = orderRepository.save(new Order(request, payment));

        // Optional behavior — runs only when beans are configured:
        if (metricsCollector != null) {
            metricsCollector.increment("orders.created");
            metricsCollector.record("orders.amount", request.totalAmount().doubleValue());
        }

        if (externalAuditService != null) {
            externalAuditService.logOrderCreation(order);
        }

        return order;
    }
}

// In production (application.properties):
// metrics.enabled=true  → MetricsCollector bean created → injected
// audit.external.enabled=false → ExternalAuditService not created → null

// In development:
// Neither optional bean is configured — service works fine without them

Combining Constructor and Setter Injection

The most common and correct pattern is to use constructor injection for mandatory dependencies and setter injection for optional ones. This clearly documents which dependencies are required and which are optional at the API level.

Java

@Service
public class ReportingService {

    // ── REQUIRED — injected via constructor ──────────────────────────
    private final ReportRepository reportRepository;
    private final UserRepository userRepository;
    private final PdfGenerator pdfGenerator;

    public ReportingService(ReportRepository reportRepository,
                             UserRepository userRepository,
                             PdfGenerator pdfGenerator) {
        this.reportRepository = reportRepository;
        this.userRepository = userRepository;
        this.pdfGenerator = pdfGenerator;
        // Service is usable immediately after constructor completes
    }

    // ── OPTIONAL — injected via setter if bean exists ────────────────
    private EmailDeliveryService emailDeliveryService;
    private S3StorageService s3StorageService;
    private ReportCacheService cacheService;

    @Autowired(required = false)
    public void setEmailDeliveryService(EmailDeliveryService emailDeliveryService) {
        this.emailDeliveryService = emailDeliveryService;
    }

    @Autowired(required = false)
    public void setS3StorageService(S3StorageService s3StorageService) {
        this.s3StorageService = s3StorageService;
    }

    @Autowired(required = false)
    public void setCacheService(ReportCacheService cacheService) {
        this.cacheService = cacheService;
    }

    // ── Business logic ───────────────────────────────────────────────
    public Report generateReport(Long userId, ReportType type) {
        // Check cache first if available:
        if (cacheService != null) {
            Optional<Report> cached = cacheService.get(userId, type);
            if (cached.isPresent()) return cached.get();
        }

        User user = userRepository.findById(userId).orElseThrow();
        byte[] pdf = pdfGenerator.generate(user, type);
        Report report = reportRepository.save(new Report(userId, type, pdf));

        // Store in S3 if configured:
        if (s3StorageService != null) {
            String url = s3StorageService.upload("reports/" + report.getId() + ".pdf", pdf);
            report.setStorageUrl(url);
            reportRepository.save(report);
        }

        // Email if configured:
        if (emailDeliveryService != null) {
            emailDeliveryService.deliver(user.getEmail(), report);
        }

        // Cache for next request:
        if (cacheService != null) {
            cacheService.put(userId, type, report);
        }

        return report;
    }
}