Configuration Properties

/**
 * Configuration properties for Spring Batch under spring.batch prefix
 */
@ConfigurationProperties("spring.batch")
public class BatchProperties {

    /**
     * Gets job-related configuration properties
     */
    public Job getJob();
    
    /**
     * Gets JDBC-related configuration properties  
     */
    public Jdbc getJdbc();
}

@Component
public class BatchConfigurationService {
    
    @Autowired
    private BatchProperties batchProperties;
    
    public void logConfiguration() {
        String jobName = batchProperties.getJob().getName();
        String tablePrefix = batchProperties.getJdbc().getTablePrefix();
        System.out.println("Job: " + jobName + ", Tables: " + tablePrefix);
    }
}

/**
 * Job-related configuration properties under spring.batch.job prefix
 */
public static class Job {
    
    /**
     * Job name to execute on startup. Must be specified if multiple Jobs are found in the context.
     * Default: empty string (runs any single job found, fails if multiple jobs exist)
     */
    public String getName();
    
    /**
     * Sets the specific job name to execute on application startup
     */
    public void setName(String name);
}

# Specify which job to run on startup (required if multiple jobs exist)
spring.batch.job.name=dailyReportJob

# Disable automatic job execution on startup  
spring.batch.job.enabled=false

@SpringBootApplication
public class MultiJobApplication {
    
    @Bean
    public Job dailyReportJob(JobRepository jobRepository, Step reportStep) {
        return new JobBuilder("dailyReportJob", jobRepository)
                .start(reportStep)
                .build();
    }
    
    @Bean  
    public Job weeklyCleanupJob(JobRepository jobRepository, Step cleanupStep) {
        return new JobBuilder("weeklyCleanupJob", jobRepository)
                .start(cleanupStep)
                .build();
    }
}

# application.properties
spring.batch.job.name=dailyReportJob  # Only this job will run on startup

/**
 * JDBC-related configuration properties under spring.batch.jdbc prefix
 */
public static class Jdbc {
    
    /**
     * Default schema location with platform placeholder
     */
    public static final String DEFAULT_SCHEMA_LOCATION = 
        "classpath:org/springframework/batch/core/schema-@@platform@@.sql";
    
    /**
     * Whether to validate the transaction state before job execution
     * Default: true
     */
    public boolean isValidateTransactionState();
    public void setValidateTransactionState(boolean validateTransactionState);
    
    /**
     * Transaction isolation level to use when creating job meta-data for new jobs
     * Default: null (uses database default)
     */
    public Isolation getIsolationLevelForCreate();
    public void setIsolationLevelForCreate(Isolation isolationLevelForCreate);
    
    /**
     * Path to the SQL file to use to initialize the database schema
     * Default: "classpath:org/springframework/batch/core/schema-@@platform@@.sql"
     */
    public String getSchema();
    public void setSchema(String schema);
    
    /**
     * Platform to use in initialization scripts if the @@platform@@ placeholder is used
     * Auto-detected by default based on DataSource
     */
    public String getPlatform();
    public void setPlatform(String platform);
    
    /**
     * Table prefix for all the batch meta-data tables
     * Default: null (uses Spring Batch default prefix)
     */
    public String getTablePrefix();
    public void setTablePrefix(String tablePrefix);
    
    /**
     * Database schema initialization mode
     * Default: EMBEDDED (initialize only for embedded databases)
     */
    public DatabaseInitializationMode getInitializeSchema();
    public void setInitializeSchema(DatabaseInitializationMode initializeSchema);
}

# Database schema initialization
spring.batch.jdbc.initialize-schema=always
spring.batch.jdbc.platform=postgresql
spring.batch.jdbc.schema=classpath:custom-batch-schema.sql

# Table customization
spring.batch.jdbc.table-prefix=CUSTOM_BATCH_

# Transaction settings
spring.batch.jdbc.validate-transaction-state=true
spring.batch.jdbc.isolation-level-for-create=read_committed

// Custom database configuration
@Configuration
public class BatchDatabaseConfiguration {
    
    @Bean
    @BatchDataSource
    @ConfigurationProperties("batch.datasource")
    public DataSource batchDataSource() {
        return DataSourceBuilder.create().build();
    }
}

# application.yml
batch:
  datasource:
    url: jdbc:postgresql://localhost:5432/batch_db
    username: batch_user  
    password: batch_pass
    
spring:
  batch:
    jdbc:
      initialize-schema: always
      table-prefix: CUSTOM_BATCH_
      platform: postgresql

/**
 * Database initialization modes for batch schema creation
 */
public enum DatabaseInitializationMode {
    /**
     * Never initialize the database schema
     */
    NEVER,
    
    /**
     * Initialize only embedded databases (H2, HSQL, Derby)
     */
    EMBEDDED,
    
    /**
     * Always initialize the database schema on startup
     */
    ALWAYS
}

/**
 * Transaction isolation levels for batch operations
 */
public enum Isolation {
    DEFAULT,           // Use database default
    READ_UNCOMMITTED,  // Lowest isolation, highest performance
    READ_COMMITTED,    // Most common isolation level
    REPEATABLE_READ,   // Prevents non-repeatable reads
    SERIALIZABLE       // Highest isolation, lowest performance
}

# Job execution properties
spring.batch.job.enabled=true                    # Enable automatic job execution
spring.batch.job.name=                          # Specific job name to execute

# JDBC configuration properties  
spring.batch.jdbc.initialize-schema=embedded     # Schema initialization mode
spring.batch.jdbc.schema=classpath:org/springframework/batch/core/schema-@@platform@@.sql
spring.batch.jdbc.platform=                     # Database platform (auto-detected)
spring.batch.jdbc.table-prefix=                 # Custom table prefix
spring.batch.jdbc.validate-transaction-state=true   # Enable transaction validation
spring.batch.jdbc.isolation-level-for-create=default # Transaction isolation level

# application-dev.yml
spring:
  batch:
    jdbc:
      initialize-schema: always
      table-prefix: DEV_BATCH_
    job:
      enabled: true

---
# application-prod.yml  
spring:
  batch:
    jdbc:
      initialize-schema: never  # Schema managed externally in production
      table-prefix: PROD_BATCH_
      validate-transaction-state: true
      isolation-level-for-create: read_committed
    job:
      enabled: false  # Jobs triggered externally in production

# Database connection (works with batch DataSource)
spring.datasource.url=jdbc:h2:mem:batchdb
spring.datasource.driver-class-name=org.h2.Driver

# JPA settings (batch uses separate tables)
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true

# Actuator endpoints for monitoring
management.endpoints.web.exposure.include=health,info,metrics
management.endpoint.health.show-details=always