Spring Setter Injection: Optional Dependencies, @Autowired(required = false) and When to Use It

@Component
public class LifecycleDemo {

    private Dependency dependency;

    public LifecycleDemo() {
        System.out.println("1. constructor, dependency = " + dependency);   // null
    }

    @Autowired
    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
        System.out.println("2. setter called");
    }

    @PostConstruct
    public void init() {
        System.out.println("3. @PostConstruct, dependency = " + dependency);   // injected
    }
}

// Works, but a constructor is better for a mandatory dependency
@Service
public class UserService {

    private UserRepository userRepository;      // cannot be final

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

// Preferred: required via constructor, optional via setter
@Service
public class NotificationService {

    private final EmailService emailService;     // required, final
    private SmsService smsService;               // optional, may stay null

    public NotificationService(EmailService emailService) {
        this.emailService = emailService;
    }

    @Autowired(required = false)
    public void setSmsService(SmsService smsService) {
        this.smsService = smsService;
    }

    public void notify(String userId, String message) {
        emailService.send(userId, message);
        if (smsService != null) {
            smsService.send(userId, message);
        }
    }
}

@Service
public class OrderNotifier {

    private SmsService sms = new NoOpSmsService();   // default when no bean exists

    // Option 1: required = false (setter skipped when absent, default stays)
    @Autowired(required = false)
    public void setSms(SmsService sms) {
        this.sms = sms;
    }

    // Option 2: Optional<T>
    @Autowired
    public void setSmsOptional(Optional<SmsService> sms) {
        this.sms = sms.orElse(new NoOpSmsService());
    }

    // Option 3: @Nullable (setter IS called, with null)
    @Autowired
    public void setSmsNullable(@Nullable SmsService sms) {
        if (sms != null) {
            this.sms = sms;
        }
    }
}

// Option 4: ObjectProvider in a constructor, so the field can be final
@Service
public class OrderNotifierV2 {

    private final SmsService sms;

    public OrderNotifierV2(ObjectProvider<SmsService> smsProvider) {
        this.sms = smsProvider.getIfAvailable(NoOpSmsService::new);
    }
}
// Use only ONE option per dependency. They are shown together for comparison.

@Configuration
public class MetricsConfig {

    @Bean
    @ConditionalOnProperty(name = "metrics.enabled", havingValue = "true")
    public MetricsCollector metricsCollector(MeterRegistry registry) {
        return new MicrometerMetricsCollector(registry);
    }
}

// application-prod.yml
//   metrics.enabled: true      -> MetricsCollector bean exists -> setter called
// application-dev.yml
//   metrics.enabled: false     -> no bean -> setter skipped -> default no-op stays

@Service
public class AuditableOrderService {

    private final OrderRepository orderRepository;
    private final PaymentService paymentService;

    private MetricsCollector metrics = MetricsCollector.NOOP;    // null-object default

    public AuditableOrderService(OrderRepository orderRepository, PaymentService paymentService) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
    }

    @Autowired(required = false)
    public void setMetrics(MetricsCollector metrics) {
        this.metrics = metrics;
    }

    public Order createOrder(CreateOrderRequest request) {
        PaymentResult payment = paymentService.charge(request.customerId(), request.totalAmount());
        Order order = orderRepository.save(new Order(request, payment));
        metrics.increment("orders.created");          // no null check needed
        return order;
    }
}

@Service
public class ReportingService {

    // REQUIRED: constructor
    private final ReportRepository reportRepository;
    private final UserRepository userRepository;
    private final PdfGenerator pdfGenerator;

    // OPTIONAL: setters, each with a safe default
    private ReportCache cache = ReportCache.NOOP;
    private ReportStorage storage = ReportStorage.NOOP;

    public ReportingService(ReportRepository reportRepository,
                            UserRepository userRepository,
                            PdfGenerator pdfGenerator) {
        this.reportRepository = reportRepository;
        this.userRepository = userRepository;
        this.pdfGenerator = pdfGenerator;
    }

    @Autowired(required = false)
    public void setCache(ReportCache cache) { this.cache = cache; }

    @Autowired(required = false)
    public void setStorage(ReportStorage storage) { this.storage = storage; }

    public Report generateReport(Long userId, ReportType type) {
        return cache.get(userId, type).orElseGet(() -> {
            User user = userRepository.findById(userId).orElseThrow();
            byte[] pdf = pdfGenerator.generate(user, type);
            Report report = reportRepository.save(new Report(userId, type, pdf));
            storage.store(report, pdf);
            cache.put(userId, type, report);
            return report;
        });
    }
}

@Service
public class NotificationDispatcher {

    private List<NotificationChannel> channels = List.of();     // default: none

    @Autowired(required = false)
    public void setChannels(List<NotificationChannel> channels) {
        this.channels = channels;
    }

    public void dispatch(String userId, String message) {
        channels.forEach(channel -> channel.send(userId, message));
    }
}

@Component @Order(1)
class EmailChannel implements NotificationChannel { /* ... */ }

@Component @Order(2)
class SmsChannel implements NotificationChannel { /* ... */ }

// Fails at startup on Spring Boot 2.6+ unless circular references are allowed
@Service
public class ServiceA {
    private ServiceB serviceB;
    @Autowired
    public void setServiceB(ServiceB serviceB) { this.serviceB = serviceB; }
}

@Service
public class ServiceB {
    private ServiceA serviceA;
    @Autowired
    public void setServiceA(ServiceA serviceA) { this.serviceA = serviceA; }
}

# Re-enables the old behaviour (not recommended)
spring.main.allow-circular-references=true

// Last-resort alternative: break the cycle with a lazy proxy
@Autowired
public void setServiceA(@Lazy ServiceA serviceA) { this.serviceA = serviceA; }

@ExtendWith(MockitoExtension.class)
class SearchServiceTest {

    @Mock
    private ProductRepository productRepository;

    private SearchService searchService;

    @BeforeEach
    void setUp() {
        searchService = new SearchService(productRepository);   // no search client
    }

    @Test
    void search_withoutSearchClient_queriesDatabase() {
        when(productRepository.findByNameContaining("laptop"))
            .thenReturn(List.of(new Product(1L, "Gaming Laptop")));

        assertThat(searchService.search("laptop")).hasSize(1);
        verify(productRepository).findByNameContaining("laptop");
    }

    @Test
    void search_withSearchClient_usesIndex() {
        SearchIndexClient client = mock(SearchIndexClient.class);
        searchService.setSearchClient(client);                  // optional dependency via setter
        when(client.search("laptop")).thenReturn(List.of(new Product(2L, "Laptop Pro")));

        assertThat(searchService.search("laptop")).hasSize(1);
        verifyNoInteractions(productRepository);
    }
}

// Integration test: replace a bean, or switch the optional bean off
@SpringBootTest(properties = "metrics.enabled=false")
class OrderServiceWithoutMetricsTest {

    @MockitoBean            // @MockBean on Boot < 3.4
    private PaymentService paymentService;

    @Autowired
    private AuditableOrderService orderService;
    // runs with the no-op metrics default
}

<bean id="emailService" class="com.example.service.SmtpEmailService">
    <property name="host" value="smtp.example.com"/>
    <property name="port" value="587"/>
</bean>

@Bean
public SmtpEmailService emailService() {
    SmtpEmailService service = new SmtpEmailService();
    service.setHost("smtp.example.com");
    service.setPort(587);
    return service;
}