IoC & Dependency Injection

public class OrderService {
  private final OrderRepository repository = new JdbcOrderRepository();

  public Order findById(long id) {
    return repository.findById(id).orElseThrow();
  }
}

@Service
public class OrderService {
  private final OrderRepository repository;

  public OrderService(OrderRepository repository) {
    this.repository = repository;
  }

  public Order findById(long id) {
    return repository.findById(id).orElseThrow();
  }
}

// Unit test — no Spring context required
@Test
void findById_returnsOrder() {
  var repo = mock(OrderRepository.class);
  when(repo.findById(1L)).thenReturn(Optional.of(new Order(1L)));
  var service = new OrderService(repo);
  assertThat(service.findById(1L).id()).isEqualTo(1L);
}

@RestController
@RequestMapping("/api/orders")
class OrderController {
  private final OrderService orderService;
  OrderController(OrderService orderService) { this.orderService = orderService; }

  @GetMapping("/{id}")
  OrderDto get(@PathVariable long id) { return orderService.findDto(id); }
}

@Service
class OrderService {
  private final OrderRepository repository;
  OrderService(OrderRepository repository) { this.repository = repository; }
  // @Transactional here — not on @Repository
}

@Repository
interface OrderRepository extends JpaRepository<Order, Long> {}

@Configuration
public class AppConfig {

  @Bean
  public ObjectMapper objectMapper() {
    return JsonMapper.builder()
        .serializationInclusion(JsonInclude.Include.NON_NULL)
        .build();
  }

  @Bean
  public RestTemplate restTemplate(RestTemplateBuilder builder) {
    return builder
        .setConnectTimeout(Duration.ofSeconds(3))
        .setReadTimeout(Duration.ofSeconds(10))
        .build();
  }
}

@Configuration  // FULL — serviceA() and serviceB() share one DataSource
class FullConfig {
  @Bean DataSource dataSource() { return new HikariDataSource(); }
  @Bean ServiceA serviceA() { return new ServiceA(dataSource()); }
  @Bean ServiceB serviceB() { return new ServiceB(dataSource()); }
}

@Configuration(proxyBeanMethods = false)  // LITE — two DataSource instances!
class LiteConfig {
  @Bean DataSource dataSource() { return new HikariDataSource(); }
  @Bean ServiceA serviceA() { return new ServiceA(dataSource()); }
  @Bean ServiceB serviceB() { return new ServiceB(dataSource()); }
}

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="...">

  <context:component-scan base-package="com.acme"/>

  <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
    <property name="jdbcUrl" value="${db.url}"/>
  </bean>
</beans>

@Configuration
@ComponentScan(
    basePackages = "com.acme.orders",
    excludeFilters = @ComponentScan.Filter(
        type = FilterType.ANNOTATION,
        classes = Experimental.class
    )
)
class ScanConfig {}

@Service
public class PaymentService {
  private final PaymentGateway gateway;
  private final MeterRegistry metrics;

  public PaymentService(PaymentGateway gateway, MeterRegistry metrics) {
    this.gateway = gateway;
    this.metrics = metrics;
  }
}

@Component
public class AlertNotifier {
  private SmsClient smsClient;

  @Autowired(required = false)
  public void setSmsClient(SmsClient smsClient) {
    this.smsClient = smsClient;
  }
}

@Service
public class BadOrderService {
  @Autowired
  private OrderRepository repository;  // hard to test without Spring / reflection
}

public interface NotificationSender { void send(String message); }

@Component("emailSender")
class EmailNotificationSender implements NotificationSender { /* ... */ }

@Component("smsSender")
class SmsNotificationSender implements NotificationSender { /* ... */ }

@Component
@Primary  // default when type alone is injected
class SlackNotificationSender implements NotificationSender { /* ... */ }

@Service
class AlertService {
  private final NotificationSender defaultSender;
  private final NotificationSender smsSender;

  AlertService(
      NotificationSender defaultSender,  // Slack — @Primary wins
      @Qualifier("smsSender") NotificationSender smsSender
  ) {
    this.defaultSender = defaultSender;
    this.smsSender = smsSender;
  }
}

@Service
class ReportService {
  private final Optional<MetricsExporter> exporter;

  ReportService(Optional<MetricsExporter> exporter) {
    this.exporter = exporter;
  }

  void publish() {
    exporter.ifPresent(MetricsExporter::flush);
  }
}

@Service
class JobRunner {
  private final ObjectProvider<WorkerTask> taskProvider;

  JobRunner(ObjectProvider<WorkerTask> taskProvider) {
    this.taskProvider = taskProvider;
  }

  void run() {
    WorkerTask task = taskProvider.getObject();  // new prototype instance per call
    task.execute();
  }
}

@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE,
       proxyMode = ScopedProxyMode.TARGET_CLASS)
class AuditContext {
  private final Instant created = Instant.now();
  Instant getCreated() { return created; }
}

@Service
class AuditService {
  private final AuditContext context;  // proxy — each method call hits new instance
  AuditService(AuditContext context) { this.context = context; }
}

@Configuration
class ScopeConfig implements BeanFactoryAware {
  @Override
  public void setBeanFactory(BeanFactory beanFactory) {
    ((ConfigurableBeanFactory) beanFactory)
        .registerScope("tenant", new TenantScope());
  }
}

@Component
@Scope(value = "tenant", proxyMode = ScopedProxyMode.TARGET_CLASS)
class TenantPreferences { /* resolved per TenantContext */ }

@Component
class CacheWarmer {
  private final RedisTemplate<String, String> redis;

  CacheWarmer(RedisTemplate<String, String> redis) {
    this.redis = redis;
  }

  @PostConstruct
  void warm() {
    redis.opsForValue().set("status", "ready");
  }

  @PreDestroy
  void shutdown() {
    // flush connections, deregister listeners
  }
}

@Component
class FeatureFlagPostProcessor implements BeanFactoryPostProcessor {
  @Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) {
    if (!Boolean.parseBoolean(System.getenv("FEATURE_X_ENABLED"))) {
      if (factory.containsBeanDefinition("featureXService")) {
        factory.removeBeanDefinition("featureXService");
      }
    }
  }
}

@Service
class ServiceA {
  ServiceA(ServiceB b) {}
}

@Service
class ServiceB {
  ServiceB(ServiceA a) {}  // BeanCurrentlyInCreationException at startup
}

@Service
class ServiceA {
  private final ServiceB b;
  ServiceA(@Lazy ServiceB b) { this.b = b; }  // proxy injected — resolved on first use
}

public interface PaymentGateway { PaymentResult charge(Money amount); }

@Component
@Profile("prod")
class StripePaymentGateway implements PaymentGateway { /* real API */ }

@Component
@Profile("dev | local")
class FakePaymentGateway implements PaymentGateway {
  public PaymentResult charge(Money amount) {
    return PaymentResult.approved("fake-" + UUID.randomUUID());
  }
}

class OnKubernetesCondition implements Condition {
  @Override
  public boolean matches(ConditionContext ctx, AnnotatedTypeMetadata meta) {
    return ctx.getEnvironment().containsProperty("KUBERNETES_SERVICE_HOST");
  }
}

@Configuration
@Conditional(OnKubernetesCondition.class)
class KubernetesConfig {
  @Bean K8sLeaderElection leaderElection() { return new K8sLeaderElection(); }
}

@Configuration
@ConditionalOnClass(DataSource.class)
@ConditionalOnMissingBean(DataSource.class)
class DataSourceAutoConfiguration {
  @Bean
  @ConfigurationProperties("spring.datasource")
  DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }
}

// Your app — this wins, auto-config backs off
@Configuration
class MyDataSourceConfig {
  @Bean DataSource dataSource() { return new HikariDataSource(/* ... */); }
}