java -jar app.jar

TRADITIONAL SPRING (Pre-Boot):
Developer → Build .war file → Deploy to separate Tomcat installation
                                ├── Tomcat versions mismatches
                                ├── Configuration drift between servers
                                ├── Slow startup times
                                ├── DevOps burden

SPRING BOOT (Modern):
Developer → Build .jar file → java -jar app.jar
                                ├── Self-contained
                                ├── Identical behavior everywhere
                                ├── Fast startup
                                ├── No deployment complexity

Project Structure:
myapp/
└── src/main/webapp/  ← Web content goes here
    ├── WEB-INF/
    │   └── web.xml   ← Servlet configuration
    └── index.jsp

Build:
Maven → .war file (Web Archive)

Deployment:
1. Install Tomcat on server
2. Copy .war to tomcat/webapps/
3. Restart Tomcat
4. Tomcat extracts .war and serves it
5. Hope the Tomcat version matches your development environment!

Problems:
❌ Separate server installation
❌ Version mismatches
❌ Manual deployment steps
❌ Multiple projects fight for resources
❌ Configuration drift

Project Structure:
myapp/
└── src/main/resources/
    ├── application.yml
    └── static/
        └── index.html

Build:
Maven → Executable .jar file (contains Tomcat!)

Deployment:
1. Copy .jar to server
2. java -jar myapp.jar
3. Tomcat starts automatically
4. Application ready immediately

Benefits:
✅ Self-contained executable
✅ Same version everywhere
✅ No external configuration needed
✅ Multiple instances can coexist
✅ Identical behavior in dev/test/prod
✅ Container-friendly (Docker)

Traditional Deployment:
Tomcat (External Process)
├── webapp1.war
├── webapp2.war
└── webapp3.war

Problems:
- One Tomcat controls all apps
- App crash doesn't isolate
- Resource contention
- Shared configuration issues

Spring Boot Embedded:
Process 1: java -jar webapp1.jar (includes Tomcat)
Process 2: java -jar webapp2.jar (includes Tomcat)
Process 3: java -jar webapp3.jar (includes Tomcat)

Benefits:
- Each app runs independently
- One app crash doesn't affect others
- Each has its own resources
- Easy to scale horizontally

Tomcat: Apache's classic servlet container
- Most popular
- Well-tested
- Excellent performance
- Default for spring-boot-starter-web

<!-- Automatically included with spring-boot-starter-web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!-- Brings in: spring-boot-starter-tomcat -->
</dependency>

<!-- Configuration -->
server:
  port: 8080
  tomcat:
    threads:
      max: 200
      min-spare: 10
    max-connections: 10000
    connection-timeout: 20000
    accept-count: 100

Jetty: Lightweight, embeddable servlet container
- Smaller memory footprint
- Faster startup
- Good for microservices
- Good for constrained environments

<!-- Exclude Tomcat, add Jetty -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

<!-- Configuration -->
server:
  port: 8080
  jetty:
    threads:
      max: 200
      min: 10

Undertow: High-performance servlet container
- Built by Red Hat
- Excellent performance
- Low memory usage
- Recommended for high-throughput scenarios

<!-- Exclude Tomcat, add Undertow -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

<!-- Configuration -->
server:
  port: 8080
  undertow:
    threads:
      io: 4
      worker: 32
    buffer-size: 1024
    direct-buffers: true

TOMCAT:
- Default (no changes needed)
- Best community support
- Great documentation
- Use when: Most projects
- Performance: Good
- Memory: Medium
- Startup: Medium

JETTY:
- Lightweight
- Good for microservices
- Low memory footprint
- Use when: Memory-constrained, lightweight containers
- Performance: Good
- Memory: Low
- Startup: Fast

UNDERTOW:
- Highest performance
- Built by enterprise vendor (Red Hat)
- Modern architecture
- Use when: High-throughput systems
- Performance: Excellent
- Memory: Low
- Startup: Very Fast

/**
 * spring-boot-starter-webflux
 * Doesn't use traditional servlet containers!
 * Uses Reactor Netty or Undertow in reactive mode
 */
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

// No servlet = different execution model
// Non-blocking I/O by default
// Better resource utilization
// Better for I/O-bound operations

server:
  # Port and context
  port: 8080
  servlet:
    context-path: /api/v1

  # SSL/HTTPS
  ssl:
    enabled: true
    key-store: classpath:keystore.jks
    key-store-password: ${KEYSTORE_PASSWORD}
    key-store-type: JKS

  # Timeout
  tomcat:
    connection-timeout: 20000
    accept-count: 100

  # Error handling
  error:
    include-message: always
    include-stacktrace: always

/**
 * Customize embedded Tomcat programmatically
 */
@Configuration
public class TomcatConfig {

    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory>
            containerCustomizer() {

        return factory -> {
            // Thread pool configuration
            factory.getTomcatProtocolHandler()
                .setMaxThreads(200);
            factory.getTomcatProtocolHandler()
                .setMinSpareThreads(10);

            // Connection pool
            factory.getTomcatProtocolHandler()
                .setMaxConnections(10000);
            factory.getTomcatProtocolHandler()
                .setConnectionTimeout(20000);

            // Custom error pages
            factory.addErrorPages(
                new ErrorPage(HttpStatus.NOT_FOUND, "/error/404"),
                new ErrorPage(HttpStatus.INTERNAL_SERVER_ERROR, "/error/500")
            );

            // Additional properties
            factory.getTomcatProtocolHandler()
                .setAttribute("acceptCount", 100);

            // Custom connectors
            Connector httpConnector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
            httpConnector.setPort(8080);
            httpConnector.setRedirectPort(8443);
            factory.addAdditionalTomcatConnectors(httpConnector);
        };
    }
}

/**
 * Run application on multiple ports
 * (useful for management port separate from app port)
 */
@Configuration
public class MultiPortConfig {

    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory>
            multiPortCustomizer() {

        return factory -> {
            // Main connector (8080)
            Connector httpConnector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
            httpConnector.setPort(8080);
            factory.addAdditionalTomcatConnectors(httpConnector);

            // Management connector (9000) - separate from main app
            Connector managementConnector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
            managementConnector.setPort(9000);
            factory.addAdditionalTomcatConnectors(managementConnector);
        };
    }
}

// Usage:
// App traffic: localhost:8080
// Management/health: localhost:9000

server:
  port: 8443
  ssl:
    enabled: true

    # Self-signed certificate (development)
    key-store: classpath:dev-keystore.jks
    key-store-password: devpassword
    key-store-type: JKS
    key-alias: tomcat

    # Production certificate (let's encrypt, DigiCert, etc.)
    # key-store: /etc/ssl/keystore.p12
    # key-store-password: ${SSL_KEYSTORE_PASSWORD}
    # key-store-type: PKCS12

    key-password: ${KEY_PASSWORD}

server:
  servlet:
    session:
      timeout: 30m # 30 minutes
      persistent: true
      store-dir: /tmp/sessions

  tomcat:
    basedir: /tmp/tomcat

/**
 * Stop accepting requests but finish processing existing ones
 */
@Configuration
public class GracefulShutdownConfig {

    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory>
            gracefulShutdown() {

        return factory -> {
            factory.getTomcatProtocolHandler()
                .setProcessorCache(100);

            // Wait up to 30 seconds for existing requests to complete
            factory.shutdownGracefully(Duration.ofSeconds(30));
        };
    }
}

// Spring Boot 2.3+ configuration:
server:
  shutdown: graceful
  shutdown-timeout: 30s

/**
 * Separate health check port (common in Kubernetes)
 */
@Configuration
public class ManagementConfig {

    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory>
            healthcheckCustomizer() {

        return factory -> {
            // Health checks on separate port (internal only)
            Connector healthConnector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
            healthConnector.setPort(9090);  // Kubernetes probes here

            Context context = new StandardContext();
            context.setPath("/healthz");

            factory.addAdditionalTomcatConnectors(healthConnector);
        };
    }
}

/**
 * Optimize for high throughput
 */
@Configuration
public class PerformanceConfig {

    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory>
            performanceTuning() {

        return factory -> {
            factory.getTomcatProtocolHandler().setMaxThreads(500);
            factory.getTomcatProtocolHandler().setMinSpareThreads(50);
            factory.getTomcatProtocolHandler().setMaxConnections(50000);
            factory.getTomcatProtocolHandler().setConnectionTimeout(60000);
            factory.getTomcatProtocolHandler().setKeepAliveTimeout(60000);

            // Buffer settings
            factory.getTomcatProtocolHandler()
                .setAttribute("maxHttpHeaderSize", 8192);

            // Disable unnecessary features
            factory.getTomcatProtocolHandler()
                .setAttribute("sendfileSize", 0);
        };
    }
}

// ✅ Good - Tomcat is battle-tested
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

// Use alternatives only if:
// - Memory is extremely constrained → Jetty
// - Very high throughput required → Undertow
// - Specific requirements dictate → Ask security team first

# Development (application-dev.yml)
server:
  port: 8080
  error:
    include-stacktrace: always

# Production (application-prod.yml)
server:
  port: 8443
  ssl:
    enabled: true
    key-store: /etc/ssl/keystore.p12
  error:
    include-stacktrace: never
  tomcat:
    threads:
      max: 200
    max-connections: 10000

// ❌ Bad - Hardcoded port
server.port=8080

// ✅ Good - Configurable
server:
  port: ${SERVER_PORT:8080}  # Default 8080 if not set

// ✅ Good - Random port for testing
server:
  port: 0  # Finds random available port

// Add Actuator for production monitoring
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

// Provides:
// GET /actuator/health - liveness probe
// GET /actuator/health/readiness - readiness probe
// GET /actuator/health/liveness - is app alive

# Spring Boot 2.3+
server:
  shutdown: graceful
  shutdown-timeout: 60s
# Allows time for in-flight requests to complete
# Before terminating

my-app.jar:
├── com/example/MyController.class
├── org/apache/catalina/Tomcat.class        ← Tomcat classes!
├── org/apache/coyote/http11/...            ← HTTP protocol handler!
├── META-INF/MANIFEST.MF
│   └── Main-Class: org.springframework.boot.loader.JarLauncher
└── lib/
    ├── spring-core-6.0.0.jar
    ├── tomcat-embed-core-10.0.0.jar
    └── ... other jars

java -jar my-app.jar

# .jar deployment
java -jar myapp.jar

# .war deployment (old way)
cp myapp.war $TOMCAT_HOME/webapps/
$TOMCAT_HOME/bin/catalina.sh start

<!-- Step 1: Exclude Tomcat -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<!-- Step 2: Add Jetty -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

<!-- Step 3: mvn clean package -->
<!-- Step 4: java -jar myapp.jar (now using Jetty) -->