Overview

// => Manual configuration: explicit servlet container, dispatcher servlet, view resolver
@Configuration
@EnableWebMvc  // => Enables Spring MVC support manually
@ComponentScan(basePackages = "com.example")  // => Explicitly specify packages to scan
public class WebConfig implements WebMvcConfigurer {

    // => Must manually configure view resolver for template rendering
    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");  // => Hard-coded view location
        resolver.setSuffix(".jsp");  // => Hard-coded template engine
        return resolver;
    }

    // => Must configure servlet container manually (Tomcat)
    @Bean
    public ServletWebServerFactory servletContainer() {
        TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory();
        tomcat.setPort(8080);  // => Hard-coded port
        tomcat.setContextPath("/app");  // => Hard-coded context path
        return tomcat;
    }

    // => Must enable static resource handling explicitly
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**")
                .addResourceLocations("/static/");  // => Map static resources manually
    }
}

// => Application entry point: manual servlet container initialization
public class Application {
    public static void main(String[] args) {
        // => Create Spring context manually
        AnnotationConfigApplicationContext context =
            new AnnotationConfigApplicationContext(WebConfig.class);

        // => Start embedded Tomcat manually
        ServletWebServerFactory factory = context.getBean(ServletWebServerFactory.class);
        WebServer webServer = factory.getWebServer();
        webServer.start();  // => Blocks until shutdown
    }
}

// => Spring Boot: @SpringBootApplication combines three annotations
@SpringBootApplication  // => @Configuration + @EnableAutoConfiguration + @ComponentScan
                        // => Auto-configures web server, MVC, view resolver, static resources
public class Application {

    // => Single method: Spring Boot handles everything
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);  // => Starts embedded Tomcat automatically
                                                          // => Scans for components automatically
                                                          // => Configures beans automatically
    }
}

// => application.properties: externalized configuration
// server.port=8080                    # Port configuration (default)
// server.servlet.context-path=/app   # Context path (overrides default /)
// spring.mvc.view.prefix=/WEB-INF/views/   # View prefix (convention)
// spring.mvc.view.suffix=.jsp              # View suffix (convention)

// => Controller: same as manual Spring
@RestController
public class ZakatController {

    @GetMapping("/api/zakat")  // => Spring Boot auto-configures JSON serialization
                               // => Returns JSON without manual ObjectMapper configuration
    public ZakatResponse calculateZakat(@RequestParam BigDecimal gold) {
        return new ZakatResponse(gold.multiply(new BigDecimal("0.025")));
    }
}

@SpringBootApplication
public class Application {

    // => Override auto-configured DataSource for production connection pooling
    @Bean
    @ConfigurationProperties("app.datasource")  // => Loads properties prefixed with app.datasource
    public DataSource dataSource() {
        // => Spring Boot would auto-configure HikariCP, but we customize for production
        HikariConfig config = new HikariConfig();
        config.setMaximumPoolSize(50);  // => Production: higher connection pool
        config.setMinimumIdle(10);  // => Keep 10 connections ready
        config.setConnectionTimeout(30000);  // => 30 second timeout
        return new HikariDataSource(config);  // => Replaces Boot's auto-configured DataSource
    }

    // => Add custom health indicator for business logic
    @Bean
    public HealthIndicator zakatServiceHealthIndicator(ZakatService zakatService) {
        // => Spring Boot Actuator exposes this at /actuator/health
        return () -> {
            boolean isHealthy = zakatService.checkDatabaseConnection();
            return isHealthy
                ? Health.up().withDetail("zakat-service", "operational").build()
                : Health.down().withDetail("zakat-service", "database unavailable").build();
        };
    }

    // => Override Boot's error handling for API-specific responses
    @ControllerAdvice
    public class GlobalExceptionHandler {

        @ExceptionHandler(ZakatValidationException.class)  // => Business-specific exception
        public ResponseEntity<ErrorResponse> handleValidation(ZakatValidationException ex) {
            // => Custom error format for API consumers
            ErrorResponse error = new ErrorResponse("VALIDATION_ERROR", ex.getMessage());
            return ResponseEntity.badRequest().body(error);
        }
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// => application-prod.properties: production-specific config
// server.port=8080
// server.tomcat.threads.max=200           # Production threading
// server.tomcat.accept-count=100          # Queue size for requests
// spring.jpa.hibernate.ddl-auto=validate  # Production: no auto-DDL
// management.endpoints.web.exposure.include=health,metrics,info  # Expose Actuator endpoints
// management.endpoint.health.show-details=when-authorized        # Security

@SpringBootApplication  // => Combines @Configuration, @EnableAutoConfiguration, @ComponentScan
                        // => Triggers auto-configuration based on classpath
                        // => Scans current package and sub-packages for components
public class Application {

    public static void main(String[] args) {
        // => SpringApplication.run() starts embedded server, configures beans, enables Actuator
        // => args passed to configure via command-line properties: --server.port=9000
        SpringApplication.run(Application.class, args);
    }

    @Bean  // => Overrides Boot's auto-configured DataSource
           // => Boot detects custom bean, disables auto-configuration for DataSource
    public DataSource dataSource() {
        return new HikariDataSource(config);  // => Custom configuration replaces Boot's default
    }
}