Spring Batch Architecture Agent (SBA)

https://github.com/zakariahere/sba
Admin
SBA (Spring Batch Architecture Agent) is an AI agent system for Claude Code that guides developers...
Tokens:102,594
Snippets:641
Trust Score:6.3
License:Apache-2.0
Update:8 months ago
Show doc for...
Tokens:
Raw
### Install and Initialize SBA Agent Globally

Source: https://github.com/zakariahere/sba/blob/master/sba-init/README.md

This section shows how to install the SBA agent globally using npm and then run the initialization command. This is an alternative to using npx for direct execution.

```bash
npm install -g sba-init
sba-init
```

--------------------------------

### Run SBA Batch Job from Command Line

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/4-implementation.md

These bash commands show how to execute an sba batch job from the command line. It includes examples for running a job by its name and for running a job with specific parameters like a date.

```bash
# Command line
java -jar app.jar --spring.batch.job.name={jobName}

# With parameters
java -jar app.jar --spring.batch.job.name={jobName} date=2024-01-01
```

--------------------------------

### ExecutionContext Content Example (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/decisions/restartability-strategy.md

Shows an example of the content within a Spring Batch ExecutionContext after a job has run and potentially failed. This demonstrates how the framework tracks progress, such as the number of records read.

```java
{
  "spring.batch.item.database.jdbc.JdbcCursorItemReader.readCount": 47001000,
  "_long": 47001000
}
```

--------------------------------

### Partitioned Table Query Example (SQL)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/databases/postgresql.md

Illustrates querying a partitioned table in PostgreSQL. The example shows how to select data within a specific date range, which PostgreSQL automatically routes to the relevant partition. This approach significantly improves query performance by reducing the amount of data that needs to be scanned, especially for time-series data.

```sql
-- Query specific partition
SELECT * FROM source_table
WHERE created_at >= '2024-01-01' AND created_at < '2024-02-01'
ORDER BY id;

-- PostgreSQL will automatically route to correct partition

```

--------------------------------

### Spring Batch Job Configuration Example

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/5-review.md

Illustrates the basic configuration of a Spring Batch job using JobBuilderFactory and StepBuilderFactory. It assumes necessary dependencies like DataSource and PlatformTransactionManager are available.

```java
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableBatchProcessing
public class BatchConfiguration {

    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;

    public BatchConfiguration(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory) {
        this.jobBuilderFactory = jobBuilderFactory;
        this.stepBuilderFactory = stepBuilderFactory;
    }

    @Bean
    public Step processDataStep() {
        // Configuration for a sample step
        return stepBuilderFactory.get("processDataStep")
                .<String, String>chunk(10)
                .reader(itemReader())
                .processor(itemProcessor())
                .writer(itemWriter())
                .build();
    }

    @Bean
    public Job importUserJob() {
        return jobBuilderFactory.get("importUserJob")
                .start(processDataStep())
                .build();
    }

    // Placeholder methods for reader, processor, and writer
    // These would be actual Spring Beans implementing ItemReader, ItemProcessor, ItemWriter
    private org.springframework.batch.item.ItemReader<String> itemReader() {
        // return new MyItemReader();
        return null; // Replace with actual implementation
    }

    private org.springframework.batch.item.ItemProcessor<String, String> itemProcessor() {
        // return new MyItemProcessor();
        return null; // Replace with actual implementation
    }

    private org.springframework.batch.item.ItemWriter<String> itemWriter() {
        // return new MyItemWriter();
        return null; // Replace with actual implementation
    }
}
```

--------------------------------

### Track SBA Artifacts with YAML

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/4-implementation.md

This YAML snippet demonstrates how to track generated artifacts for the sba project. It includes the path, type, and a description for each artifact, such as configuration files and processors.

```yaml
sba_state.artifacts:
  - path: "src/main/java/.../BatchConfig.java"
    type: config
    description: "Main job configuration"
  - path: "src/main/java/.../ItemProcessor.java"
    type: processor
    description: "Data transformation processor"
```

--------------------------------

### Start SBA Agent Session in Claude Code

Source: https://context7.com/zakariahere/sba/llms.txt

Instructions for invoking the SBA agent within the Claude Code environment to commence the Spring Batch job design process. This involves either starting Claude Code and using natural language prompts or explicitly selecting the SBA agent.

```bash
# Start Claude Code in your project
claude

# Then invoke SBA using natural language:
"Help me design a Spring Batch job for customer data migration"

# Or explicitly:
"Use the sba agent to create an ETL batch job"

# Or use the agents command and select sba:
/agents
```

--------------------------------

### Oracle JDBC URL Variants

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/databases/oracle.md

Provides examples of different JDBC URL formats for connecting to an Oracle database. Includes basic, SID-based, TNS, and failover configurations.

```text
# Basic connection
jdbc:oracle:thin:@//host:1521/service

# With SID (legacy)
jdbc:oracle:thin:@host:1521:SID

# TNS connection
jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=host)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=service)))

# With failover
jdbc:oracle:thin:@(DESCRIPTION=
  (ADDRESS_LIST=
    (ADDRESS=(PROTOCOL=TCP)(HOST=primary)(PORT=1521))
    (ADDRESS=(PROTOCOL=TCP)(HOST=secondary)(PORT=1521))
  )
  (CONNECT_DATA=(SERVICE_NAME=service))
  (FAILOVER=ON)
)
```

--------------------------------

### Initialize SBA Agent with npx

Source: https://github.com/zakariahere/sba/blob/master/sba-init/README.md

These commands demonstrate how to run the SBA initialization script directly using npx without global installation. You can specify the project directory, choose the agent type (claude or github), force overwrite existing files, and enable verbose output.

```bash
npx sba-init
npx sba-init ./my-batch-project
npx sba-init --type claude
npx sba-init --type github
npx sba-init --force
npx sba-init -v
```

--------------------------------

### CompositeItemProcessor Configuration (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/4-implementation.md

Demonstrates how to configure a `CompositeItemProcessor` in Spring Batch using Java. This allows chaining multiple processors together to create a complex processing pipeline, including validation, transformation, and enrichment steps.

```java
@Bean
public CompositeItemProcessor<Input, Output> processor() {
    return new CompositeItemProcessorBuilder<Input, Output>()
        .delegates(
            validatingProcessor(),
            transformingProcessor(),
            enrichingProcessor()
        )
        .build();
}
```

--------------------------------

### ExecutionContext Example (YAML)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/decisions/restartability-strategy.md

Illustrates the structure and purpose of Spring Batch's ExecutionContext, a key-value store persisted in the JobRepository to track state across job runs. It shows example key-value pairs for tracking progress.

```yaml
ExecutionContext:
  What: Key-value store per StepExecution
  Scope: Persisted in JobRepository (database)
  Purpose: Track state across job runs

  Example:
    {
      "lastProcessedId": 47000000,
      "rowsWritten": 47000000,
      "currentChunkStart": 46999000,
      "resumePoint": "customer_id=47000001"
    }

  On restart:
    JobLauncher loads previous ExecutionContext
    Reader resumes from lastProcessedId
    Writer knows rowsWritten already
```

--------------------------------

### Spring Batch Skip Policy Configuration Example

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/5-review.md

Demonstrates how to configure a skip policy for a Spring Batch step. This allows the job to skip items that cause specific exceptions, preventing the entire batch from failing. It requires defining which exceptions to skip and setting a skip limit.

```java
import org.springframework.batch.core.SkipListener;
import org.springframework.batch.core.SkipListenerSupport;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.skip.SkipPolicy;
import org.springframework.batch.core.skip. નેSkipLimitExceededException;
import org.springframework.batch.core.step.skip.AlwaysSkipItemSkipPolicy;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SkipPolicyConfig {

    private final StepBuilderFactory stepBuilderFactory;

    public SkipPolicyConfig(StepBuilderFactory stepBuilderFactory) {
        this.stepBuilderFactory = stepBuilderFactory;
    }

    @Bean
    public Step processWithSkipPolicyStep() {
        SkipPolicy skipPolicy = new AlwaysSkipItemSkipPolicy(); // Example: Always skip
        int skipLimit = 100; // Example: Allow up to 100 skips

        return stepBuilderFactory.get("processWithSkipPolicyStep")
                .<String, String>chunk(10)
                .reader(itemReader())
                .processor(itemProcessor())
                .writer(itemWriter())
                .faultTolerant() // Enable fault tolerance
                .skipPolicy(skipPolicy)
                .skipLimit(skipLimit)
                .listener(skipListener())
                .build();
    }

    private SkipListener<? super Object, ? super Throwable> skipListener() {
        return new SkipListenerSupport<Object, Throwable>() {
            @Override
            public void onSkipInProcess(Object item, Throwable t) {
                System.err.println("Skipped item during processing: " + item + ", Exception: " + t.getMessage());
            }

            @Override
            public void onSkipInWrite(Throwable t, Object item) {
                System.err.println("Skipped item during writing: " + item + ", Exception: " + t.getMessage());
            }
        };
    }

    // Placeholder methods for reader, processor, and writer
    private org.springframework.batch.item.ItemReader<String> itemReader() {
        return null; // Replace with actual implementation
    }

    private org.springframework.batch.item.ItemProcessor<String, String> itemProcessor() {
        return null; // Replace with actual implementation
    }

    private org.springframework.batch.item.ItemWriter<String> itemWriter() {
        return null; // Replace with actual implementation
    }
}
```

--------------------------------

### ADR Format - Markdown Example

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/2-architecture.md

This markdown snippet illustrates the standard format for Architecture Decision Records (ADRs), including sections for Status, Context, Decision, Consequences, and Alternatives Considered.

```markdown
### ADR-NNN: {Title}

**Status**: Accepted

**Context**: {Why this decision matters}

**Decision**: {What we decided}

**Consequences**:
- Positive: {benefit}
- Trade-off: {negative}
- Mitigation: {how to address negative}

**Alternatives Considered**:
- Alternative: {Why rejected}
```

--------------------------------

### Spring Batch Project Structure

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/4-implementation.md

Illustrates the standard directory and file structure for a Spring Batch project. This includes organizing configuration, entities, DTOs, readers, processors, writers, listeners, mappers, validators, resources, and tests.

```java
src/main/java/{package}/
├── config/
│   └── {JobName}BatchConfig.java
├── entity/
│   ├── {Source}Entity.java (if JPA) 
│   └── {Target}Entity.java (if JPA)
├── dto/
│   ├── {Source}Input.java
│   └── {Target}Output.java
├── reader/
│   └── {Custom}ItemReader.java (if custom)
├── processor/
│   └── {Name}ItemProcessor.java
├── writer/
│   └── {Custom}ItemWriter.java (if custom)
├── listener/
│   ├── JobCompletionListener.java
│   └── StepExecutionListener.java
├── mapper/
│   └── {Name}RowMapper.java (if JDBC/MyBatis)
└── validator/
    └── {Name}Validator.java (if needed)

src/main/resources/
├── application.yml
├── application-{profile}.yml
└── db/migration/ (if using Flyway)

src/test/java/{package}/
├── config/
│   └── {JobName}BatchConfigTest.java
├── processor/
│   └── {Name}ItemProcessorTest.java
└── integration/
    └── {JobName}IntegrationTest.java
```

--------------------------------

### Spring Batch ExecutionContext Usage Example

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/5-review.md

Illustrates how to use the `ExecutionContext` in Spring Batch to persist and retrieve state between job restarts. This is crucial for restartability, allowing the job to resume from where it left off.

```java
import org.springframework.batch.core.ExitStatus;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.StepExecutionListener;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobExecutionListener;
import org.springframework.batch.core.Step;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.ExecutionContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ExecutionContextConfig {

    private static final String LAST_PROCESSED_ID_KEY = "lastProcessedId";

    private final StepBuilderFactory stepBuilderFactory;

    public ExecutionContextConfig(StepBuilderFactory stepBuilderFactory) {
        this.stepBuilderFactory = stepBuilderFactory;
    }

    @Bean
    public Step processWithExecutionContextStep() {
        return stepBuilderFactory.get("processWithExecutionContextStep")
                .<Long, String>chunk(10)
                .reader(itemReader())
                .processor(itemProcessor())
                .writer(itemWriter())
                .listener(stepExecutionListener())
                .build();
    }

    @Bean
    public StepExecutionListener stepExecutionListener() {
        return new StepExecutionListener() {
            @Override
            public void beforeStep(StepExecution stepExecution) {
                // Retrieve state from ExecutionContext if available
                ExecutionContext executionContext = stepExecution.getExecutionContext();
                if (executionContext.containsKey(LAST_PROCESSED_ID_KEY)) {
                    long lastId = executionContext.getLong(LAST_PROCESSED_ID_KEY);
                    System.out.println("Resuming from last processed ID: " + lastId);
                    // Configure reader to start after lastId
                    // ((MyItemReader) itemReader()).setStartId(lastId + 1);
                }
            }

            @Override
            public ExitStatus afterStep(StepExecution stepExecution) {
                // Persist state to ExecutionContext
                ExecutionContext executionContext = stepExecution.getExecutionContext();
                // Assuming itemWriter returns the ID of the last successfully written item
                // long lastWrittenId = ((MyItemWriter) itemWriter()).getLastWrittenId();
                long lastWrittenId = 100; // Placeholder
                executionContext.put(LAST_PROCESSED_ID_KEY, lastWrittenId);
                System.out.println("Persisted last processed ID: " + lastWrittenId);
                return stepExecution.getExitStatus();
            }
        };
    }

    // Placeholder methods for reader, processor, and writer
    private ItemReader<Long> itemReader() {
        return null; // Replace with actual implementation
    }

    private ItemProcessor<Long, String> itemProcessor() {
        return null; // Replace with actual implementation
    }

    private ItemWriter<String> itemWriter() {
        return null; // Replace with actual implementation
    }
}

```

--------------------------------

### Spring Batch Retry Policy Configuration Example

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/5-review.md

Shows how to configure a retry policy for a Spring Batch step. This allows the job to retry operations that fail due to transient issues, improving robustness. It involves defining retryable exceptions, retry limits, and backoff policies.

```java
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.retry.RetryPolicy;
import org.springframework.batch.core.retry.policy.SimpleRetryPolicy;
import org.springframework.batch.core.retry.backoff.FixedBackOffPolicy;
import org.springframework.batch.core.retry.backoff.BackOffPolicy;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Value;

@Configuration
public class RetryPolicyConfig {

    private final StepBuilderFactory stepBuilderFactory;

    public RetryPolicyConfig(StepBuilderFactory stepBuilderFactory) {
        this.stepBuilderFactory = stepBuilderFactory;
    }

    @Bean
    public Step processWithRetryPolicyStep() {
        // Configure Retry Policy
        RetryPolicy retryPolicy = new SimpleRetryPolicy();
        ((SimpleRetryPolicy) retryPolicy).setMaxAttempts(5); // Max 5 retries
        // You can configure which exceptions are retryable here if needed

        // Configure BackOff Policy
        BackOffPolicy backOffPolicy = new FixedBackOffPolicy();
        ((FixedBackOffPolicy) backOffPolicy).setBackOffPeriod(1000); // 1 second delay between retries

        return stepBuilderFactory.get("processWithRetryPolicyStep")
                .<String, String>chunk(10)
                .reader(itemReader())
                .processor(itemProcessor())
                .writer(itemWriter())
                .faultTolerant() // Enable fault tolerance
                .retryPolicy(retryPolicy)
                .backOffPolicy(backOffPolicy)
                .build();
    }

    // Placeholder methods for reader, processor, and writer
    private org.springframework.batch.item.ItemReader<String> itemReader() {
        return null; // Replace with actual implementation
    }

    private org.springframework.batch.item.ItemProcessor<String, String> itemProcessor() {
        return null; // Replace with actual implementation
    }

    private org.springframework.batch.item.ItemWriter<String> itemWriter() {
        return null; // Replace with actual implementation
    }
}
```

--------------------------------

### Spring Batch Chunk Size Optimization Example

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/5-review.md

Demonstrates how to configure and adjust the chunk size for a Spring Batch step. The chunk size determines how many items are processed together in a single transaction. Proper tuning is crucial for performance.

```java
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ChunkSizeConfig {

    private final StepBuilderFactory stepBuilderFactory;

    public ChunkSizeConfig(StepBuilderFactory stepBuilderFactory) {
        this.stepBuilderFactory = stepBuilderFactory;
    }

    @Bean
    public Step processWithOptimizedChunkSizeStep() {
        int optimizedChunkSize = 500; // Example: Set an optimized chunk size

        return stepBuilderFactory.get("processWithOptimizedChunkSizeStep")
                .<String, String>chunk(optimizedChunkSize) // Use the optimized chunk size here
                .reader(itemReader())
                .processor(itemProcessor())
                .writer(itemWriter())
                .build();
    }

    // Placeholder methods for reader, processor, and writer
    private org.springframework.batch.item.ItemReader<String> itemReader() {
        return null; // Replace with actual implementation
    }

    private org.springframework.batch.item.ItemProcessor<String, String> itemProcessor() {
        return null; // Replace with actual implementation
    }

    private org.springframework.batch.item.ItemWriter<String> itemWriter() {
        return null; // Replace with actual implementation
    }
}
```

--------------------------------

### JDBC Batch Statements Rewrite Example (MySQL)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/5-review.md

Illustrates the configuration for enabling batch statement rewriting for MySQL JDBC connections. Setting `rewriteBatchedStatements=true` allows the JDBC driver to optimize multiple statements into a single batch, improving performance.

```properties
# application.properties or application.yml
sprung.datasource.url=jdbc:mysql://localhost:3306/mydb?rewriteBatchedStatements=true

```

--------------------------------

### Update SBA Phase Transition Command

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/4-implementation.md

This command updates the sba project's current phase and artifacts list. It sets the current phase to 5 and assigns the generated files to the artifacts property, then directs to the next phase's documentation.

```bash
sba_state.current_phase = 5
sba_state.artifacts = [generated_files]
→ Read {{AGENT_DIR}}/sba/phases/5-review.md
```

--------------------------------

### Testing MyBatis Mappers with Cursor (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/persistence/mybatis.md

Provides an example of testing a MyBatis `SourceMapper` using Spring Boot's `@MybatisTest` and `@AutoConfigureTestDatabase`. It demonstrates how to use `@Sql` to load test data and `Cursor` to efficiently iterate over query results without loading them all into memory at once.

```java
@MybatisTest
@AutoConfigureTestDatabase(replace = Replace.NONE)
class SourceMapperTest {

    @Autowired
    private SourceMapper mapper;

    @Test
    @Sql("/test-data.sql")
    void shouldFindPendingRecords() {
        Cursor<SourceRecord> cursor = mapper.findPendingRecords(LocalDate.now());

        List<SourceRecord> records = new ArrayList<>();
        cursor.forEach(records::add);

        assertThat(records).hasSize(10);
    }
}
```

--------------------------------

### Java: Testcontainers PostgreSQL Setup for Spring Batch

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/templates/testing-templates.md

Configuration class to set up a PostgreSQL container for testing Spring Batch applications using Testcontainers. It defines a PostgreSQL container bean with specific database name, username, password, and initialization script.

```java
package {{package}}.config;

import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.boot.testcontainers.service.connection.ServiceConnection;
import org.springframework.context.annotation.Bean;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.utility.DockerImageName;

@TestConfiguration(proxyBeanMethods = false)
public class TestcontainersConfig {

    @Bean
    @ServiceConnection
    public PostgreSQLContainer<?> postgresContainer() {
        return new PostgreSQLContainer<>(DockerImageName.parse("postgres:15-alpine"))
            .withDatabaseName("batch_test")
            .withUsername("test")
            .withPassword("test")
            .withInitScript("schema.sql");
    }
}

```

--------------------------------

### Control Step Restartability in Spring Batch

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/patterns/fault-tolerance.md

Configures a Spring Batch step with specific restart controls. This example limits the number of times a step can be started (`startLimit`) and prevents it from running again if it has already completed successfully (`allowStartIfComplete`).

```java
@Bean
public Step limitedRestartStep() {
    return new StepBuilder("limitedRestart", jobRepository)
        .<Input, Output>chunk(100, txManager)
        .reader(reader())
        .writer(writer())
        .startLimit(3)  // Max 3 start attempts
        .allowStartIfComplete(false)  // Don't re-run if completed
        .build();
}
```

--------------------------------

### Spring Batch Configuration Class Example

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/rules/sba-conventions.md

Demonstrates a typical Spring Batch job configuration class using Java. It shows how to define a Job, Steps, and inject dependencies using constructor injection. It also illustrates the use of @Bean annotations and common Spring Batch builders like JobBuilder and StepBuilder.

```java
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.StepScope;
import org.springframework.batch.core.job.builder.JobBuilder;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.database.JdbcCursorItemReader;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

@Configuration
@RequiredArgsConstructor
public class CustomerMigrationBatchConfig {

    // Inject dependencies via constructor
    private final JobRepository jobRepository;
    private final PlatformTransactionManager transactionManager;
    private final DataSource dataSource;

    // Job definition at top
    @Bean
    public Job customerMigrationJob(Step extractStep, Step transformStep) {
        return new JobBuilder("customerMigrationJob", jobRepository)
            .listener(jobCompletionListener())
            .start(extractStep)
            .next(transformStep)
            .build();
    }

    // Steps follow job
    @Bean
    public Step extractStep(ItemReader<CustomerInput> reader,
                            ItemProcessor<CustomerInput, CustomerOutput> processor,
                            ItemWriter<CustomerOutput> writer) {
        return new StepBuilder("extractStep", jobRepository)
            .<CustomerInput, CustomerOutput>chunk(1000, transactionManager)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .build();
    }

    // Component beans at bottom
    @Bean
    @StepScope
    public JdbcCursorItemReader<CustomerInput> customerReader() {
        // ...
        return null; // Placeholder for actual implementation
    }

    // Placeholder for JobCompletionListener
    private Object jobCompletionListener() {
        return null;
    }

    // Placeholder classes for types
    static class CustomerInput {}
    static class CustomerOutput {}
}
```

--------------------------------

### Date Range Partitioner for Spring Batch

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/patterns/partitioning.md

Partitions data based on a specified date range. It divides the total duration between a start and end date into a number of partitions determined by gridSize. Each partition is assigned a start and end date.

```java
@Component
public class DateRangePartitioner implements Partitioner {

    @Value("${batch.partition.start-date}")
    private LocalDate startDate;

    @Value("${batch.partition.end-date}")
    private LocalDate endDate;

    @Override
    public Map<String, ExecutionContext> partition(int gridSize) {
        Map<String, ExecutionContext> partitions = new HashMap<>();

        long totalDays = ChronoUnit.DAYS.between(startDate, endDate);
        long daysPerPartition = totalDays / gridSize + 1;

        for (int i = 0; i < gridSize; i++) {
            ExecutionContext context = new ExecutionContext();
            LocalDate partitionStart = startDate.plusDays(i * daysPerPartition);
            LocalDate partitionEnd = startDate.plusDays((i + 1) * daysPerPartition - 1);

            if (partitionStart.isAfter(endDate)) break;
            if (partitionEnd.isAfter(endDate)) partitionEnd = endDate;

            context.putString("startDate", partitionStart.toString());
            context.putString("endDate", partitionEnd.toString());

            partitions.put("partition_" + i, context);
        }

        return partitions;
    }
}
```

--------------------------------

### Address Non-Thread-Safe Reader in Batch Processing (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/advanced/multi-threaded.md

Demonstrates how to handle non-thread-safe readers in a multi-threaded Spring Batch environment. The 'wrong' example shows a standard `JdbcCursorItemReader` which is not safe for concurrent access. The 'right' example wraps the delegate reader within a `SynchronizedItemStreamReader` to ensure thread safety.

```java
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.support.SynchronizedItemStreamReader;
import org.springframework.batch.item.database.JdbcCursorItemReader;
import org.springframework.batch.item.database.builder.JdbcCursorItemReaderBuilder;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;

// Assuming Input class and DataSource are defined elsewhere

public class ReaderConfig {

    // WRONG: Standard reader without synchronization
    @Bean
    public JdbcCursorItemReader<Input> unsafeReader(DataSource dataSource) {
        return new JdbcCursorItemReaderBuilder<Input>()
            .name("unsafeReader")
            .dataSource(dataSource)
            .sql("SELECT * FROM input_table")
            // .rowMapper(...) // Define your row mapper
            .build();
    }

    // RIGHT: Wrapped in synchronized reader
    @Bean
    public SynchronizedItemStreamReader<Input> safeReader(DataSource dataSource) {
        JdbcCursorItemReader<Input> delegateReader = new JdbcCursorItemReaderBuilder<Input>()
            .name("delegateReader")
            .dataSource(dataSource)
            .sql("SELECT * FROM input_table")
            // .rowMapper(...) // Define your row mapper
            .build();

        SynchronizedItemStreamReader<Input> reader = new SynchronizedItemStreamReader<>();
        reader.setDelegate(delegateReader);
        return reader;
    }

    // Dummy Input class for compilation
    static class Input {}
}
```

--------------------------------

### Use Thread-Safe Collections for Shared State (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/advanced/multi-threaded.md

Illustrates the correct way to manage shared mutable state in a multi-threaded context. The 'wrong' example uses a standard `ArrayList`, which is not thread-safe and can lead to `ConcurrentModificationException` or data corruption. The 'right' example utilizes `ConcurrentHashMap.newKeySet()`, a thread-safe collection suitable for concurrent environments.

```java
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class SharedState {

    // WRONG: Shared mutable state - Not thread-safe!
    private List<String> processedIdsWrong = new ArrayList<>();

    // RIGHT: Thread-safe collection
    private final Set<String> processedIdsRight = ConcurrentHashMap.newKeySet();

    public void addProcessedIdWrong(String id) {
        // This can cause issues in a multi-threaded environment
        processedIdsWrong.add(id);
    }

    public void addProcessedIdRight(String id) {
        // This is thread-safe
        processedIdsRight.add(id);
    }
}
```

--------------------------------

### Transition Command for SBA Phase Change

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/1-discovery.md

A command to update the SBA state and transition to the next phase. This command sets the current_phase to 2 and provides a link to the documentation for Phase 2.

```shell
sba_state.current_phase = 2
→ Read {{AGENT_DIR}}/sba/phases/2-architecture.md
```

--------------------------------

### Implement Thread Monitoring Listener for Batch Chunks (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/advanced/multi-threaded.md

A Spring Batch `ChunkListener` that monitors the execution time of each thread processing a chunk. It logs the start and end times of threads, helping to identify performance bottlenecks in multi-threaded batch jobs. Uses `ConcurrentHashMap` for thread-safe storage of start times.

```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.core.ChunkListener;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.stereotype.Component;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

@Component
public class ThreadMonitorListener implements ChunkListener {

    private static final Logger log = LoggerFactory.getLogger(ThreadMonitorListener.class);
    private final ConcurrentMap<String, Long> threadStartTimes = new ConcurrentHashMap<>();

    @Override
    public void beforeChunk(ChunkContext context) {
        String threadName = Thread.currentThread().getName();
        threadStartTimes.put(threadName, System.currentTimeMillis());
        log.debug("Thread {} starting chunk", threadName);
    }

    @Override
    public void afterChunk(ChunkContext context) {
        String threadName = Thread.currentThread().getName();
        Long startTime = threadStartTimes.remove(threadName);
        if (startTime != null) {
            long duration = System.currentTimeMillis() - startTime;
            log.debug("Thread {} completed chunk in {}ms", threadName, duration);
        }
    }

    // beforeChunk and afterChunk are the only required methods for ChunkListener
    // Other methods like afterChunkError are optional.
    @Override
    public void afterChunkError(ChunkContext context) {
        // Optional: Handle errors during chunk processing
        String threadName = Thread.currentThread().getName();
        log.error("Error processing chunk in thread {}", threadName);
    }
}
```

--------------------------------

### Control SBA Workflow with Quick Commands

Source: https://context7.com/zakariahere/sba/llms.txt

Provides essential commands for managing the SBA agent's workflow during an active session in Claude Code. These commands allow users to check the current status, navigate between phases, load specific skills, or skip to different stages of the process.

```bash
# Show current state and phase
sba status

# Move to next phase
sba next

# Return to previous phase
sba back

# Load a specific skill on-demand
sba load skill partitioning

# Skip to a specific phase (use carefully)
sba skip to 3
```

--------------------------------

### Configure saveState for Multi-Threaded Paging Readers (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/advanced/multi-threaded.md

Explains a crucial configuration for multi-threaded Spring Batch steps using paging readers. The 'wrong' example implies using a default paging reader where `saveState` is true, which can cause problems during job restarts in a multi-threaded context. The 'right' example explicitly sets `saveState(false)` on the `PagingItemReaderBuilder` to ensure proper restartability.

```java
import org.springframework.batch.item.database.builder.JpaPagingItemReaderBuilder;
import org.springframework.batch.item.database.builder.JdbcPagingItemReaderBuilder;
import org.springframework.batch.item.database.JpaPagingItemReader;
import org.springframework.batch.item.database.JdbcPagingItemReader;
import jakarta.persistence.EntityManagerFactory;
import javax.sql.DataSource;

// Assuming Input class, EntityManagerFactory, DataSource are defined elsewhere

public class PagingReaderConfig {

    // WRONG: saveState=true with multi-threading (causes issues on restart)
    // .reader(pagingReader()) // Default saveState=true

    // RIGHT: Disable saveState for multi-threaded steps
    public JpaPagingItemReader<Input> safeJpaPagingReader(EntityManagerFactory entityManagerFactory) {
        return new JpaPagingItemReaderBuilder<Input>()
            .name("safeJpaPagingReader")
            .entityManagerFactory(entityManagerFactory)
            .query("SELECT i FROM Input i")
            .pageSize(100)
            .saveState(false) // Crucial for multi-threading
            .build();
    }

    public JdbcPagingItemReader<Input> safeJdbcPagingReader(DataSource dataSource) {
        return new JdbcPagingItemReaderBuilder<Input>()
            .name("safeJdbcPagingReader")
            .dataSource(dataSource)
            .sql("SELECT * FROM input_table")
            .pageSize(100)
            // .rowMapper(...) // Define your row mapper
            .saveState(false) // Crucial for multi-threading
            .build();
    }

    // Dummy Input class for compilation
    static class Input {}
}
```

--------------------------------

### PostgreSQL Index Creation for Batch Processing (SQL)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/databases/postgresql.md

Provides SQL examples for creating effective indexes in PostgreSQL to optimize batch processing. It includes recommendations for status-based processing (`idx_status_id`), date-based partitioning (`idx_process_date`), and covering indexes (`idx_covering`) that include frequently accessed columns to avoid table lookups. Using `CREATE INDEX CONCURRENTLY` allows index creation without blocking write operations.

```sql
-- Status-based processing
CREATE INDEX CONCURRENTLY idx_status_id
ON source_table (status, id)
WHERE status = 'PENDING';

-- Date-based partitioning
CREATE INDEX CONCURRENTLY idx_process_date
ON source_table (process_date, id);

-- Covering index (avoid table lookup)
CREATE INDEX CONCURRENTLY idx_covering
ON source_table (status, id)
INCLUDE (field1, field2);

```

--------------------------------

### SBA State Commands (Shell)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/context/state-schema.md

Lists the command-line interface commands available for interacting with and managing the SBA state, including displaying the full or compact state, specific sections, or resetting the state.

```shell
sba state - Display full state
sba state compact - Display compact state
sba state {section} - Display specific section
sba state reset - Reset to initial state
```

--------------------------------

### Parallel Split Flow Configuration (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/advanced/conditional-flow.md

Configures a Spring Batch job to execute multiple flows in parallel. It starts with a common step, splits into two independent branches, and then joins them before proceeding to a merge step.

```java
@Bean
public Job parallelJob(JobRepository jobRepository,
                       Step commonStep,
                       Step branch1Step,
                       Step branch2Step,
                       Step mergeStep) {

    Flow branch1 = new FlowBuilder<SimpleFlow>("branch1")
        .start(branch1Step)
        .build();

    Flow branch2 = new FlowBuilder<SimpleFlow>("branch2")
        .start(branch2Step)
        .build();

    return new JobBuilder("parallelJob", jobRepository)
        .start(commonStep)
        .split(new SimpleAsyncTaskExecutor())
            .add(branch1, branch2)
        .next(mergeStep)  // After both branches complete
        .build();
}
```

--------------------------------

### Common Oracle SQL Hints for Optimization

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/databases/oracle.md

Presents various Oracle SQL hints used to influence the optimizer's execution plan. Examples include forcing index usage, parallel query execution, prioritizing first rows, full table scans, and disabling result caching.

```sql
-- Force index use
SELECT /*+ INDEX(t idx_status) */ * FROM source_table t

-- Parallel query
SELECT /*+ PARALLEL(4) */ * FROM source_table

-- First rows optimization (batch-friendly)
SELECT /*+ FIRST_ROWS(1000) */ * FROM source_table

-- Full table scan (when reading most data)
SELECT /*+ FULL(t) */ * FROM source_table t

-- Disable result cache
SELECT /*+ NO_RESULT_CACHE */ * FROM source_table
```

--------------------------------

### SBA Discovery Summary Template (Markdown)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/1-discovery.md

A Markdown template for presenting the findings of the discovery phase. It summarizes the project type, volume, data flow, key requirements, and constraints, along with suggested next steps for Phase 2.

```markdown
## Discovery Summary

### Project: {name}
**Type**: {type} | **Volume**: {volume}

### Data Flow
```
{source_description} → [Batch Job] → {target_description}
```

### Key Requirements
1. {requirement_1}
2. {requirement_2}

### Constraints
- {constraint_1}
- {constraint_2}

### Next Steps
Ready to proceed to Phase 2: Architecture where we'll decide on:
- Processing pattern (chunk vs tasklet)
- Parallelization strategy
- Technology choices (persistence, database)
```

--------------------------------

### Route by Type with ClassifierCompositeItemWriter

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/templates/writer-templates.md

Utilizes a ClassifierCompositeItemWriter to route items to different writers based on a classification logic. This example routes items to either a success writer or an error writer depending on their validity. It requires a Classifier implementation.

```java
package {{package}}.writer;

import org.springframework.batch.item.support.ClassifierCompositeItemWriter;
import org.springframework.classify.Classifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Classifier{{Output}}WriterConfig {

    @Bean
    public ClassifierCompositeItemWriter<{{Output}}> classifier{{Output}}Writer(
            JdbcBatchItemWriter<{{Output}}> successWriter,
            JdbcBatchItemWriter<{{Output}}> errorWriter) {

        ClassifierCompositeItemWriter<{{Output}}> writer = 
            new ClassifierCompositeItemWriter<>();

        writer.setClassifier(
            (Classifier<{{Output}}, ItemWriter<? super {{Output}}>>) item -> {
                return item.isValid() ? successWriter : errorWriter;
            }
        );

        return writer;
    }
}
```

--------------------------------

### Partitioned FlatFileItemWriter Configuration (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/decisions/itemwriter-strategy.md

Configures a FlatFileItemWriter to write to separate files for each partition in a parallel batch job. It uses a step execution context to determine the partition ID and dynamically sets the output resource. A header callback ensures the header is written only once for the first partition.

```java
import org.springframework.batch.core.configuration.annotation.StepScope;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.batch.item.file.FlatFileItemWriter;
import org.springframework.batch.item.file.builder.FlatFileItemWriterBuilder;
import org.springframework.core.io.FileSystemResource;

// ... other imports

@Bean
@StepScope
public FlatFileItemWriter<CustomerOutput> csvWriter(
        @Value("#{stepExecutionContext['partitionId']}") String partitionId) {
    return new FlatFileItemWriterBuilder<CustomerOutput>()
        .name("csvWriter")
        .resource(new FileSystemResource("partition_" + partitionId + ".csv"))
        .delimited()
        .delimiter(',')
        .names("customerId", "customerName", "email", "address", "city", "orderCount", "totalSpent")
        .headerCallback(writer -> {
            // Only write header for partition 1
            if ("1".equals(partitionId)) {
                writer.write("customerId,customerName,email,address,city,orderCount,totalSpent");
            }
        })
        .build();
}
```

--------------------------------

### JPA Batch Operations Configuration Example

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/5-review.md

Shows how to configure JPA properties in Spring Batch for optimized batch inserts and updates. Setting `hibernate.jdbc.batch_size`, `hibernate.order_inserts`, and `hibernate.order_updates` can significantly improve database write performance.

```properties
# application.properties or application.yml
spring.jpa.properties.hibernate.jdbc.batch_size=50
spring.jpa.properties.hibernate.order_inserts=true
spring.jpa.properties.hibernate.order_updates=true

```

--------------------------------

### Java: Spring Batch Test Configuration

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/templates/testing-templates.md

Configuration class for enabling and configuring Spring Batch processing in a test environment. It imports necessary configuration classes, including Testcontainers setup and the specific job configuration.

```java
package {{package}}.config;

import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@EnableAutoConfiguration
@EnableBatchProcessing
@Import({
    TestcontainersConfig.class,
    {{JobName}}BatchConfig.class
})
public class BatchTestConfig {

    // Test-specific beans or overrides
}

```

--------------------------------

### Design Job Flow with Mermaid

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/3-design.md

Demonstrates how to visually represent the job execution flow using Mermaid syntax. It outlines a typical batch job structure with stages like initialization, validation, processing, verification, and cleanup, including paths for success, failure, and abortion. This aids in understanding the overall job orchestration.

```mermaid
graph TD
    subgraph "Job: {job_name}"
        Start([Start]) --> Init[Initialize]
        Init --> Validate{Validate Source}
        Validate -->|Valid| Process[Process Data]
        Validate -->|Invalid| Abort[Abort Job]
        Process --> Verify{Verify Output}
        Verify -->|Success| Cleanup[Cleanup]
        Verify -->|Failure| Rollback[Rollback]
        Cleanup --> End([Complete])
        Rollback --> Failed([Failed])
        Abort --> Failed
    end
```

--------------------------------

### Configure Batch Step in YAML

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/3-design.md

Provides a comprehensive example of configuring a single step within a batch job using YAML. It covers both chunk-based and tasklet-based steps, detailing reader, processor, writer configurations, and fault tolerance settings. This is crucial for defining job execution logic.

```yaml
step_name:
  type: chunk|tasklet

  # If chunk:
  chunk_size: {size based on volume}
  reader:
    type: {JdbcCursorItemReader|JpaPagingItemReader|FlatFileItemReader|...}
    config: {reader-specific config}
  processor:
    type: {custom|composite|validator|...}
    logic: {transformation description}
  writer:
    type: {JdbcBatchItemWriter|JpaItemWriter|FlatFileItemWriter|...}
    config: {writer-specific config}

  # If tasklet:
  tasklet_class: {class name}
  logic: {what it does}

  # Common:
  fault_tolerance:
    skip_limit: {n}
    skip_exceptions: [...]
    retry_limit: {n}
    retry_exceptions: [...]
  listeners:
    - {StepExecutionListener}
    - {ItemReadListener}
```

--------------------------------

### Spring Batch JobCompletionListener (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/4-implementation.md

A standard listener for Spring Batch jobs that provides notification after a job completes. It logs whether the job was successful or failed, including any failure exceptions, aiding in job monitoring and debugging.

```java
// Job completion notification
@Component
public class JobCompletionListener implements JobExecutionListener {
    @Override
    public void afterJob(JobExecution jobExecution) {
        if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
            log.info("Job completed successfully");
        } else if (jobExecution.getStatus() == BatchStatus.FAILED) {
            log.error("Job failed: {}", jobExecution.getAllFailureExceptions());
        }
    }
}
```

--------------------------------

### Technology Stack Confirmation - YAML

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/2-architecture.md

This YAML snippet confirms the technology stack for the project, including details on the processing pattern, persistence, database, CSV library, parallelization, chunk size, partition count, and dependency versions.

```yaml
tech_stack:
  processing_pattern: "Chunk Processing with Partitioning"
  persistence: "JDBC"
  database: "PostgreSQL"
  csv_library: "OpenCSV"
  parallelization: "ThreadPoolTaskExecutor (8 threads)"
  chunk_size: 1000
  partition_count: 8
  database_pool_size: 20
  jvm_heap: "2GB"
  spring_boot: "3.2.x"
  java_version: "17"

dependencies:
  - spring-batch-core: 5.x
  - spring-batch-infrastructure: 5.x
  - postgresql-driver: 42.7.x
  - opencsv: 5.9.x
  - spring-retry: 2.0.x
```

--------------------------------

### Spring Batch Template Loading Strategy (YAML)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/phases/4-implementation.md

Defines the order in which Spring Batch templates should be loaded during the implementation phase. This strategy ensures that templates are loaded only when needed for generating specific artifacts, optimizing resource usage.

```yaml
template_loading_order:
  1. job-config.md      # Always needed first
  2. reader-templates.md  # When implementing readers
  3. processor-templates.md  # When implementing processors
  4. writer-templates.md  # When implementing writers
  5. testing-templates.md  # After main code complete
```

--------------------------------

### Test JPA Batch Job with Testcontainers (Java)

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/persistence/jpa.md

Demonstrates how to test a Spring Batch job that uses JPA with `Testcontainers` and `SpringBatchTest`. This setup allows for integration testing against a real database instance spun up by Testcontainers.

```java
@SpringBatchTest
@SpringBootTest
@AutoConfigureTestDatabase(replace = Replace.NONE)
@Testcontainers
class JpaBatchJobTest {

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15");

    @Autowired
    private JobLauncherTestUtils jobLauncherTestUtils;

    @Autowired
    private TestEntityManager entityManager;

    @Test
    void shouldProcessAllRecords() throws Exception {
        // Given
        entityManager.persist(new SourceEntity(...));
        entityManager.flush();

        // When
        JobExecution execution = jobLauncherTestUtils.launchJob();

        // Then
        assertThat(execution.getStatus()).isEqualTo(BatchStatus.COMPLETED);
    }
}
```

--------------------------------

### Invoke SBA Agent Commands

Source: https://github.com/zakariahere/sba/blob/master/sba-init/README.md

Once the SBA agent is initialized and active within an LLM session, these commands can be used to manage the agent's state and workflow. They allow checking the status, navigating phases, and loading specific skills.

```bash
sba status
sba next
sba back
sba load skill {name}
```

--------------------------------

### Oracle Sequence Creation

Source: https://github.com/zakariahere/sba/blob/master/sba-init/templates/sba/skills/databases/oracle.md

Defines an Oracle sequence named 'batch_data_seq' with specific parameters for batch processing. It starts at 1, increments by 50 (matching a typical batch size), caches 100 sequences, and cycles are disabled.

```sql
CREATE SEQUENCE batch_data_seq
    START WITH 1
    INCREMENT BY 50  -- Match batch size
    CACHE 100
    NOCYCLE;
```

--------------------------------

### Scheduled Job Launcher with Cron and Parameters (Java)

Source: https://context7.com/zakariahere/sba/llms.txt

Launches a Spring Batch job on a schedule defined by a cron expression. It includes setting job parameters like runtime and process date. This requires Spring Batch core and scheduler dependencies.

```java
package com.company.batch.scheduler;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.LocalDate;

@Component
public class CustomerMigrationScheduler {

    private final JobLauncher jobLauncher;
    private final Job customerMigrationJob;

    public CustomerMigrationScheduler(JobLauncher jobLauncher,
                                      @Qualifier("customerMigrationJob") Job job) {
        this.jobLauncher = jobLauncher;
        this.customerMigrationJob = job;
    }

    @Scheduled(cron = "${batch.customerMigration.cron:0 0 2 * * ?}")
    public void runJob() throws Exception {
        JobParameters params = new JobParametersBuilder()
            .addLocalDateTime("runTime", LocalDateTime.now())
            .addString("processDate", LocalDate.now().toString())
            .toJobParameters();

        jobLauncher.run(customerMigrationJob, params);
    }
}
```
Tokens:
Raw