Custom Starters, BeanPostProcessor & BeanFactoryPostProcessor

@ConfigurationProperties(prefix = "notification")
public class NotificationProperties {

    /** Enable/disable the notification starter */
    private boolean enabled = true;

    /** Provider: smtp, sns, twilio */
    private String provider = "smtp";

    /** Default sender address */
    private String from = "noreply@myapp.com";

    /** Max retry attempts on failure */
    private int retryAttempts = 3;

    /** Connection timeout */
    private Duration timeout = Duration.ofSeconds(5);

    // getters and setters...
}

public class NotificationTemplate {
    private final String provider;
    private final String from;
    private final int retryAttempts;

    public NotificationTemplate(String provider, String from, int retryAttempts) {
        this.provider = provider;
        this.from = from;
        this.retryAttempts = retryAttempts;
    }

    public void send(String to, String subject, String body) {
        // Delegate to provider (SMTP, SNS, Twilio)
        // Built-in retry logic using retryAttempts
    }
}

public class NotificationService {
    private final NotificationTemplate template;

    public NotificationService(NotificationTemplate template) {
        this.template = template;
    }

    public void notifyUser(String userId, String message) {
        String email = lookupEmail(userId);
        template.send(email, "Notification", message);
    }
}

@AutoConfiguration
@ConditionalOnClass(NotificationTemplate.class)
@EnableConfigurationProperties(NotificationProperties.class)
@ConditionalOnProperty(prefix = "notification", name = "enabled",
                       havingValue = "true", matchIfMissing = true)
public class NotificationAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public NotificationTemplate notificationTemplate(NotificationProperties props) {
        return new NotificationTemplate(
            props.getProvider(),
            props.getFrom(),
            props.getRetryAttempts()
        );
    }

    @Bean
    @ConditionalOnMissingBean
    public NotificationService notificationService(NotificationTemplate template) {
        return new NotificationService(template);
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnClass(name = "io.micrometer.core.instrument.MeterRegistry")
    public NotificationMetrics notificationMetrics(MeterRegistry registry) {
        return new NotificationMetrics(registry);
    }
}

@RestController
public class OrderController {
    private final NotificationService notifications; // auto-injected!

    @PostMapping("/orders")
    public Order placeOrder(@RequestBody OrderRequest req) {
        Order order = orderService.create(req);
        notifications.notifyUser(order.getUserId(), "Order placed: " + order.getId());
        return order;
    }
}

public interface BeanPostProcessor {

    // Called AFTER dependency injection, BEFORE @PostConstruct / init-method
    default Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        return bean;
    }

    // Called AFTER @PostConstruct / init-method
    // This is where AOP proxies are created
    default Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        return bean;
    }
}

@Component
public class AuditAnnotationBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        // Scan for custom @Auditable annotation
        for (Method method : bean.getClass().getDeclaredMethods()) {
            if (method.isAnnotationPresent(Auditable.class)) {
                AuditRegistry.register(beanName, method.getName());
            }
        }
        return bean;
    }
}

@Component
public class RetryBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        Class<?> beanClass = bean.getClass();
        // Only proxy beans annotated with @Retryable
        if (beanClass.isAnnotationPresent(Retryable.class)) {
            return createRetryProxy(bean, beanClass);
        }
        return bean;
    }

    private Object createRetryProxy(Object target, Class<?> targetClass) {
        return Proxy.newProxyInstance(
            targetClass.getClassLoader(),
            targetClass.getInterfaces(),
            new RetryInvocationHandler(target, 3)
        );
    }
}

@Component
public class ValidationBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        for (Field field : bean.getClass().getDeclaredFields()) {
            if (field.isAnnotationPresent(ValidatedConfig.class)) {
                field.setAccessible(true);
                Object value = ReflectionUtils.getField(field, bean);
                if (value == null) {
                    throw new BeanCreationException(
                        "Field " + field.getName() + " in " + beanName + " must not be null");
                }
            }
        }
        return bean;
    }
}

@FunctionalInterface
public interface BeanFactoryPostProcessor {

    // Called ONCE, BEFORE any bean is instantiated
    // You receive the entire bean factory — all definitions are loaded but NO beans exist yet
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
            throws BeansException;
}

@Component
public class TimeoutBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Change all RestTemplate beans to have a custom timeout
        for (String name : beanFactory.getBeanDefinitionNames()) {
            BeanDefinition def = beanFactory.getBeanDefinition(name);
            if ("org.springframework.web.client.RestTemplate".equals(def.getBeanClassName())) {
                MutablePropertyValues props = def.getPropertyValues();
                props.addPropertyValue("connectTimeout", 5000);
                props.addPropertyValue("readTimeout", 10000);
            }
        }
    }
}

@Component
public class DynamicRepositoryRegistrar implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

        // Scan for @Repository interfaces and register implementations
        for (Class<?> repoInterface : scanRepositoryInterfaces()) {
            GenericBeanDefinition definition = new GenericBeanDefinition();
            definition.setBeanClass(DynamicRepositoryProxy.class);
            definition.getConstructorArgumentValues()
                      .addGenericArgumentValue(repoInterface);
            registry.registerBeanDefinition(
                repoInterface.getSimpleName(), definition);
        }
    }
}

// This is the BFPP that resolves ${...} placeholders in bean definitions
// It runs BEFORE beans are created, so @Value("${db.url}") works
@Bean
public static PropertySourcesPlaceholderConfigurer propertyConfigurer() {
    // MUST be static! Otherwise Spring can't invoke it early enough
    PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
    configurer.setLocation(new ClassPathResource("custom.properties"));
    return configurer;
}