Entrevista Spring Batch 5: Particionamento, Chunks e Tolerância
Domine as entrevistas de Spring Batch 5: 15 perguntas essenciais sobre particionamento, processamento por chunks e tolerância a falhas com exemplos em Java 21.
O Spring Batch 5 representa um pilar do processamento de dados em massa no ecossistema Spring. As entrevistas técnicas avaliam a capacidade de projetar jobs robustos, escaláveis e tolerantes a falhas. Dominar particionamento, processamento por chunks e mecanismos de tolerância a falhas distingue os desenvolvedores sênior.
Ponto-chave para a entrevista
Os recrutadores testam o entendimento profundo: por que escolher partitioning em vez de remote chunking? Como dimensionar corretamente os chunks? Essas decisões arquiteturais revelam experiência real em produção.
Arquitetura fundamental do Spring Batch 5
Pergunta 1: Quais são os componentes principais do Spring Batch?
A arquitetura do Spring Batch baseia-se em três camadas distintas: a aplicação (jobs e código de negócio), o Batch Core (classes runtime para iniciar e controlar os jobs) e a infraestrutura (readers, writers e serviços comuns como RetryTemplate).
BatchJobConfig.javajava
// Configuração de um job Spring Batch 5 com Java 21
@Configuration
public class BatchJobConfig {
// JobRepository armazena os metadados de execução
// Permite o restart e o monitoramento dos jobs
private final JobRepository jobRepository;
private final PlatformTransactionManager transactionManager;
public BatchJobConfig(JobRepository jobRepository,
PlatformTransactionManager transactionManager) {
this.jobRepository = jobRepository;
this.transactionManager = transactionManager;
}
// Um Job encapsula o processo batch completo
// Composto por um ou mais Steps executados sequencialmente
@Bean
public Job importUserJob(Step processUsersStep, Step cleanupStep) {
return new JobBuilder("importUserJob", jobRepository)
.start(processUsersStep) // Step principal de processamento
.next(cleanupStep) // Step de limpeza
.build();
}
// Um Step representa uma unidade de trabalho independente
// Dois modelos: Tasklet (tarefa única) ou Chunk (processamento iterativo)
@Bean
public Step processUsersStep(ItemReader<UserRecord> reader,
ItemProcessor<UserRecord, User> processor,
ItemWriter<User> writer) {
return new StepBuilder("processUsersStep", jobRepository)
.<UserRecord, User>chunk(100, transactionManager) // Commit a cada 100 itens
.reader(reader) // Lê os dados da fonte
.processor(processor) // Transforma cada item
.writer(writer) // Escreve em lotes de 100
.build();
}
}O JobRepository persiste o estado das execuções no banco de dados. Essa persistência permite reiniciar um job que falhou exatamente onde ele parou, sem reprocessar os dados já confirmados.
Pergunta 2: Qual a diferença entre Tasklet e processamento por Chunk?
Tasklet executa uma ação discreta e não repetitiva: exclusão de arquivos, chamada a uma stored procedure, envio de e-mail de notificação. Chunk processa volumes massivos dividindo os dados em lotes gerenciáveis.
CleanupTasklet.javajava
// Tasklet: ação única sem iteração
@Component
public class CleanupTasklet implements Tasklet {
private final Path tempDirectory = Path.of("/tmp/batch-work");
@Override
public RepeatStatus execute(StepContribution contribution,
ChunkContext chunkContext) throws Exception {
// Exclui todos os arquivos temporários do processamento
try (var files = Files.walk(tempDirectory)) {
files.filter(Files::isRegularFile)
.forEach(this::deleteQuietly);
}
// FINISHED indica que o tasklet concluiu seu trabalho
// CONTINUABLE reiniciaria a execução (útil para polling)
return RepeatStatus.FINISHED;
}
private void deleteQuietly(Path file) {
try {
Files.delete(file);
} catch (IOException e) {
// Loga e continua - não falha o job por um arquivo
}
}
}ChunkProcessingConfig.javajava
// Processamento por chunks: tratamento de alto volume
@Configuration
public class ChunkProcessingConfig {
@Bean
public Step processOrdersStep(JobRepository jobRepository,
PlatformTransactionManager transactionManager,
ItemReader<OrderRecord> reader,
ItemProcessor<OrderRecord, ProcessedOrder> processor,
ItemWriter<ProcessedOrder> writer) {
return new StepBuilder("processOrdersStep", jobRepository)
// Chunk de 500: lê 500 itens, processa, escreve, depois faz commit
.<OrderRecord, ProcessedOrder>chunk(500, transactionManager)
.reader(reader)
.processor(processor)
.writer(writer)
// Listener para monitorar o progresso
.listener(new ChunkProgressListener())
.build();
}
}O processamento orientado a chunks traz benefícios críticos: gestão otimizada de memória (apenas o chunk atual em memória), transações granulares (commit por chunk) e recuperação de falhas no último chunk confirmado.
Aprofundamento no processamento por Chunks
Pergunta 3: Como funciona o ciclo de vida de um chunk?
Cada chunk segue um ciclo preciso: leitura dos itens um a um até atingir o tamanho configurado, processamento individual de cada item, depois escrita do grupo. Uma transação envolve todo o chunk.
OrderItemReader.javajava
// ItemReader: lê um item por vez
@StepScope
@Component
public class OrderItemReader implements ItemReader<OrderRecord> {
// @StepScope: nova instância por execução do step
// Permite injetar parâmetros dinâmicos do job
@Value("#{jobParameters['startDate']}")
private LocalDate startDate;
private Iterator<OrderRecord> orderIterator;
@BeforeStep
public void initializeReader(StepExecution stepExecution) {
// Carrega os dados no início do step
List<OrderRecord> orders = fetchOrdersFromDate(startDate);
this.orderIterator = orders.iterator();
}
@Override
public OrderRecord read() {
// Retorna null para sinalizar o fim dos dados
// Spring Batch chama read() até receber null
if (orderIterator.hasNext()) {
return orderIterator.next();
}
return null; // Fim do dataset
}
private List<OrderRecord> fetchOrdersFromDate(LocalDate date) {
// Recupera da fonte de dados
return List.of(); // Implementação real
}
}OrderItemProcessor.javajava
// ItemProcessor: transforma cada item individualmente
@Component
public class OrderItemProcessor implements ItemProcessor<OrderRecord, ProcessedOrder> {
private final PricingService pricingService;
private final ValidationService validationService;
public OrderItemProcessor(PricingService pricingService,
ValidationService validationService) {
this.pricingService = pricingService;
this.validationService = validationService;
}
@Override
public ProcessedOrder process(OrderRecord item) {
// Retornar null filtra o item (não será escrito)
if (!validationService.isValid(item)) {
return null; // Item filtrado
}
// Transformação de negócio
BigDecimal finalPrice = pricingService.calculatePrice(item);
return new ProcessedOrder(
item.orderId(),
item.customerId(),
finalPrice,
LocalDateTime.now()
);
}
}OrderItemWriter.javajava
// ItemWriter: escreve o chunk completo em uma única operação
@Component
public class OrderItemWriter implements ItemWriter<ProcessedOrder> {
private final JdbcTemplate jdbcTemplate;
public OrderItemWriter(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public void write(Chunk<? extends ProcessedOrder> chunk) {
// O chunk contém todos os itens processados
// Escrita em lote para desempenho otimizado
List<? extends ProcessedOrder> items = chunk.getItems();
jdbcTemplate.batchUpdate(
"INSERT INTO processed_orders (order_id, customer_id, final_price, processed_at) VALUES (?, ?, ?, ?)",
items,
items.size(),
(ps, order) -> {
ps.setLong(1, order.orderId());
ps.setLong(2, order.customerId());
ps.setBigDecimal(3, order.finalPrice());
ps.setTimestamp(4, Timestamp.valueOf(order.processedAt()));
}
);
}
}Se ocorrer uma exceção durante o processamento do chunk, a transação é revertida. O job pode então retomar a partir desse chunk usando os metadados armazenados no JobRepository.
Pergunta 4: Como escolher o tamanho ideal do chunk?
O tamanho do chunk impacta diretamente o desempenho e o consumo de memória. Um chunk pequeno demais multiplica os commits (overhead). Um chunk grande demais consome memória excessiva e prolonga os rollbacks em caso de falha.
ChunkSizingConfig.javajava
// Configuração dinâmica do tamanho do chunk
@Configuration
public class ChunkSizingConfig {
// Valor padrão razoável para a maioria dos casos
private static final int DEFAULT_CHUNK_SIZE = 100;
// Para itens leves (poucos campos)
private static final int LIGHT_ITEMS_CHUNK_SIZE = 500;
// Para itens pesados (blobs, documentos)
private static final int HEAVY_ITEMS_CHUNK_SIZE = 25;
@Bean
public Step processLightDataStep(JobRepository jobRepository,
PlatformTransactionManager txManager,
ItemReader<LightRecord> reader,
ItemWriter<LightRecord> writer) {
return new StepBuilder("processLightDataStep", jobRepository)
// Itens leves: chunks maiores para menos commits
.<LightRecord, LightRecord>chunk(LIGHT_ITEMS_CHUNK_SIZE, txManager)
.reader(reader)
.writer(writer)
.build();
}
@Bean
public Step processDocumentsStep(JobRepository jobRepository,
PlatformTransactionManager txManager,
ItemReader<Document> reader,
ItemProcessor<Document, ProcessedDocument> processor,
ItemWriter<ProcessedDocument> writer) {
return new StepBuilder("processDocumentsStep", jobRepository)
// Documentos pesados: chunks menores para limitar memória
.<Document, ProcessedDocument>chunk(HEAVY_ITEMS_CHUNK_SIZE, txManager)
.reader(reader)
.processor(processor)
.writer(writer)
.build();
}
}Regra prática
Começar com 100 itens por chunk e ajustar conforme métricas: tempo de commit, uso de memória e duração do rollback. Usar listeners para monitorar e identificar o ponto ideal.
Particionamento para processamento paralelo
Pergunta 5: O que é particionamento e quando usar?
O particionamento divide um dataset em partições independentes processadas em paralelo. Cada partição é executada em sua própria thread (local) ou em um worker remoto. Essa abordagem multiplica o throughput sem sacrificar a capacidade de restart.
PartitionedJobConfig.javajava
// Configuração de um job particionado
@Configuration
public class PartitionedJobConfig {
private final JobRepository jobRepository;
private final PlatformTransactionManager transactionManager;
public PartitionedJobConfig(JobRepository jobRepository,
PlatformTransactionManager transactionManager) {
this.jobRepository = jobRepository;
this.transactionManager = transactionManager;
}
@Bean
public Job partitionedImportJob(Step partitionedStep) {
return new JobBuilder("partitionedImportJob", jobRepository)
.start(partitionedStep)
.build();
}
// Step manager: orquestra as partições
@Bean
public Step partitionedStep(Partitioner partitioner,
Step workerStep,
TaskExecutor taskExecutor) {
return new StepBuilder("partitionedStep", jobRepository)
// Divide o trabalho via Partitioner
.partitioner("workerStep", partitioner)
// Step executado para cada partição
.step(workerStep)
// 8 threads paralelas
.taskExecutor(taskExecutor)
// Número de partições a criar
.gridSize(8)
.build();
}
// TaskExecutor para execução paralela
@Bean
public TaskExecutor batchTaskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(8);
executor.setMaxPoolSize(16);
executor.setQueueCapacity(50);
executor.setThreadNamePrefix("batch-partition-");
executor.initialize();
return executor;
}
}RangePartitioner.javajava
// Partitioner baseado em intervalos de ID
@Component
public class RangePartitioner implements Partitioner {
private final JdbcTemplate jdbcTemplate;
public RangePartitioner(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public Map<String, ExecutionContext> partition(int gridSize) {
// Recupera os limites do dataset
Long minId = jdbcTemplate.queryForObject(
"SELECT MIN(id) FROM orders WHERE status = 'PENDING'", Long.class);
Long maxId = jdbcTemplate.queryForObject(
"SELECT MAX(id) FROM orders WHERE status = 'PENDING'", Long.class);
if (minId == null || maxId == null) {
return Map.of(); // Sem dados a processar
}
// Calcula o tamanho de cada partição
long range = (maxId - minId) / gridSize + 1;
Map<String, ExecutionContext> partitions = new HashMap<>();
for (int i = 0; i < gridSize; i++) {
ExecutionContext context = new ExecutionContext();
long start = minId + (i * range);
long end = Math.min(start + range - 1, maxId);
// Cada partição recebe seus limites
context.putLong("minId", start);
context.putLong("maxId", end);
context.putInt("partitionNumber", i);
partitions.put("partition" + i, context);
}
return partitions;
}
}O particionamento é adequado para datasets grandes onde os itens são independentes. As partições devem estar balanceadas para evitar que uma partição lenta atrase todo o job.
Pergunta 6: Qual a diferença entre particionamento local e remoto?
O particionamento local executa todas as partições na mesma JVM com um pool de threads. O particionamento remoto distribui as partições entre várias JVMs (workers) por meio de middleware de mensageria.
RemotePartitioningConfig.javajava
// Configuração de particionamento remoto com mensageria
@Configuration
public class RemotePartitioningConfig {
@Bean
public Step managerStep(JobRepository jobRepository,
Partitioner partitioner,
MessageChannelPartitionHandler partitionHandler) {
return new StepBuilder("managerStep", jobRepository)
.partitioner("workerStep", partitioner)
// Handler que se comunica com os workers remotos
.partitionHandler(partitionHandler)
.build();
}
// PartitionHandler envia os ExecutionContexts aos workers
@Bean
public MessageChannelPartitionHandler partitionHandler(
MessagingTemplate messagingTemplate,
JobExplorer jobExplorer) {
MessageChannelPartitionHandler handler = new MessageChannelPartitionHandler();
handler.setStepName("workerStep");
handler.setGridSize(4);
handler.setMessagingOperations(messagingTemplate);
handler.setJobExplorer(jobExplorer);
// Timeout de espera para os workers terminarem
handler.setPollInterval(5000L);
return handler;
}
}WorkerConfiguration.javajava
// Configuração no lado worker
@Configuration
public class WorkerConfiguration {
private final JobRepository jobRepository;
private final PlatformTransactionManager transactionManager;
public WorkerConfiguration(JobRepository jobRepository,
PlatformTransactionManager transactionManager) {
this.jobRepository = jobRepository;
this.transactionManager = transactionManager;
}
// O worker recebe partições e executa o step
@Bean
public Step workerStep(ItemReader<OrderRecord> reader,
ItemProcessor<OrderRecord, ProcessedOrder> processor,
ItemWriter<ProcessedOrder> writer) {
return new StepBuilder("workerStep", jobRepository)
.<OrderRecord, ProcessedOrder>chunk(100, transactionManager)
// Reader configurado com @StepScope para receber parâmetros da partição
.reader(reader)
.processor(processor)
.writer(writer)
.build();
}
// Reader que usa os limites da partição
@Bean
@StepScope
public JdbcCursorItemReader<OrderRecord> partitionedReader(
DataSource dataSource,
@Value("#{stepExecutionContext['minId']}") Long minId,
@Value("#{stepExecutionContext['maxId']}") Long maxId) {
return new JdbcCursorItemReaderBuilder<OrderRecord>()
.name("partitionedOrderReader")
.dataSource(dataSource)
.sql("SELECT * FROM orders WHERE id BETWEEN ? AND ? AND status = 'PENDING'")
.preparedStatementSetter(ps -> {
ps.setLong(1, minId);
ps.setLong(2, maxId);
})
.rowMapper(new OrderRecordRowMapper())
.build();
}
}Pronto para mandar bem nas entrevistas de Spring Boot?
Pratique com nossos simuladores interativos, flashcards e testes tecnicos.
Tolerância a falhas e recuperação de erros
Pergunta 7: Quais mecanismos de tolerância a falhas o Spring Batch oferece?
O Spring Batch oferece três mecanismos complementares: skip (ignorar itens com falha), retry (tentar novamente automaticamente) e restart (retomar um job que falhou). Esses mecanismos são configurados no nível do step.
FaultTolerantStepConfig.javajava
// Configuração completa de tolerância a falhas
@Configuration
public class FaultTolerantStepConfig {
@Bean
public Step faultTolerantStep(JobRepository jobRepository,
PlatformTransactionManager transactionManager,
ItemReader<DataRecord> reader,
ItemProcessor<DataRecord, ProcessedRecord> processor,
ItemWriter<ProcessedRecord> writer,
SkipPolicy customSkipPolicy) {
return new StepBuilder("faultTolerantStep", jobRepository)
.<DataRecord, ProcessedRecord>chunk(100, transactionManager)
.reader(reader)
.processor(processor)
.writer(writer)
// Ativa o modo tolerante a falhas
.faultTolerant()
// SKIP: ignora até 10 erros de validação
.skipLimit(10)
.skip(ValidationException.class)
.skip(DataIntegrityViolationException.class)
// Alguns erros nunca devem ser ignorados
.noSkip(FatalBatchException.class)
// RETRY: tenta novamente erros transitórios
.retryLimit(3)
.retry(TransientDataAccessException.class)
.retry(DeadlockLoserDataAccessException.class)
// Backoff exponencial entre tentativas
.backOffPolicy(exponentialBackOffPolicy())
// Listener para registrar os skips
.listener(skipListener())
.build();
}
@Bean
public BackOffPolicy exponentialBackOffPolicy() {
ExponentialBackOffPolicy policy = new ExponentialBackOffPolicy();
policy.setInitialInterval(1000); // 1 segundo
policy.setMultiplier(2.0); // Dobra a cada tentativa
policy.setMaxInterval(10000); // Máximo de 10 segundos
return policy;
}
@Bean
public SkipListener<DataRecord, ProcessedRecord> skipListener() {
return new SkipListener<>() {
@Override
public void onSkipInRead(Throwable t) {
// Loga item ilegível
}
@Override
public void onSkipInProcess(DataRecord item, Throwable t) {
// Loga item que falhou no processamento
}
@Override
public void onSkipInWrite(ProcessedRecord item, Throwable t) {
// Loga item que falhou na escrita
}
};
}
}Retry é adequado para erros transitórios (timeout de rede, deadlock de banco). Skip é adequado para erros de dados individuais que não devem bloquear o processamento global.
Pergunta 8: Como implementar um SkipPolicy customizado?
Um SkipPolicy customizado permite uma lógica de decisão refinada: ignorar conforme o tipo de exceção, número de erros ou critérios específicos de negócio.
AdaptiveSkipPolicy.javajava
// SkipPolicy com lógica de negócio avançada
@Component
public class AdaptiveSkipPolicy implements SkipPolicy {
private static final int MAX_SKIP_COUNT = 100;
private static final double MAX_SKIP_PERCENTAGE = 0.05; // 5% máximo
private final AtomicInteger totalProcessed = new AtomicInteger(0);
private final AtomicInteger skipCount = new AtomicInteger(0);
@Override
public boolean shouldSkip(Throwable exception, long skipCountSoFar) {
// Nunca ignorar erros fatais
if (exception instanceof FatalBatchException
|| exception instanceof OutOfMemoryError) {
return false;
}
// Limite absoluto de skips
if (skipCountSoFar >= MAX_SKIP_COUNT) {
return false; // Para o job
}
// Limite percentual
int total = totalProcessed.get();
if (total > 1000) { // Aplicar somente após o warmup
double skipPercentage = (double) skipCountSoFar / total;
if (skipPercentage > MAX_SKIP_PERCENTAGE) {
return false; // Erros demais proporcionalmente
}
}
// Ignora erros de validação e dados
return exception instanceof ValidationException
|| exception instanceof DataFormatException
|| exception instanceof IllegalArgumentException;
}
// Chamado por um listener para acompanhar o progresso
public void incrementProcessed() {
totalProcessed.incrementAndGet();
}
}Pergunta 9: Como funciona o restart de um job que falhou?
O JobRepository armazena o estado de cada execução. Ao reiniciar, o Spring Batch identifica o último chunk confirmado e retoma a partir desse ponto. Os itens processados com sucesso não são reprocessados.
JobRestartService.javajava
// Serviço de gerenciamento de restart de jobs
@Service
public class JobRestartService {
private final JobLauncher jobLauncher;
private final JobExplorer jobExplorer;
private final JobRepository jobRepository;
private final Job importJob;
public JobRestartService(JobLauncher jobLauncher,
JobExplorer jobExplorer,
JobRepository jobRepository,
@Qualifier("importJob") Job importJob) {
this.jobLauncher = jobLauncher;
this.jobExplorer = jobExplorer;
this.jobRepository = jobRepository;
this.importJob = importJob;
}
public JobExecution restartFailedJob(Long jobExecutionId) throws Exception {
// Recupera a execução que falhou
JobExecution failedExecution = jobExplorer.getJobExecution(jobExecutionId);
if (failedExecution == null) {
throw new IllegalArgumentException("Job execution not found: " + jobExecutionId);
}
// Verifica se o job pode ser reiniciado
if (!failedExecution.getStatus().equals(BatchStatus.FAILED)) {
throw new IllegalStateException("Only FAILED jobs can be restarted");
}
// Usa os mesmos parâmetros da execução original
JobParameters originalParams = failedExecution.getJobParameters();
// Relança o job - retoma automaticamente do último checkpoint
return jobLauncher.run(importJob, originalParams);
}
public List<JobExecution> findRestartableJobs() {
// Lista todas as execuções FAILED ainda não reiniciadas
return jobExplorer.findJobInstancesByJobName(importJob.getName(), 0, 100)
.stream()
.flatMap(instance -> jobExplorer.getJobExecutions(instance).stream())
.filter(exec -> exec.getStatus() == BatchStatus.FAILED)
.filter(this::isRestartable)
.toList();
}
private boolean isRestartable(JobExecution execution) {
// Verifica que não há execução bem-sucedida mais recente
JobInstance instance = execution.getJobInstance();
return jobExplorer.getJobExecutions(instance).stream()
.noneMatch(exec -> exec.getStatus() == BatchStatus.COMPLETED);
}
}Armadilha de entrevista
Um job só pode ser reiniciado se os JobParameters forem idênticos. Modificar um parâmetro cria uma nova instância de job, perdendo o histórico de progresso.
Escalabilidade e otimização
Pergunta 10: Quais estratégias de escalabilidade estão disponíveis?
O Spring Batch oferece quatro estratégias: multi-threaded step (múltiplas threads leem em paralelo), parallel steps (steps independentes em paralelo), remote chunking (processamento distribuído) e partitioning (dados distribuídos).
MultiThreadedStepConfig.javajava
// Step multi-thread: várias threads processam o mesmo dataset
@Configuration
public class MultiThreadedStepConfig {
@Bean
public Step multiThreadedStep(JobRepository jobRepository,
PlatformTransactionManager transactionManager,
ItemReader<Record> reader,
ItemProcessor<Record, ProcessedRecord> processor,
ItemWriter<ProcessedRecord> writer,
TaskExecutor taskExecutor) {
return new StepBuilder("multiThreadedStep", jobRepository)
.<Record, ProcessedRecord>chunk(100, transactionManager)
// ATENÇÃO: o reader deve ser thread-safe
.reader(synchronizedReader(reader))
.processor(processor)
.writer(writer)
// 4 threads processam chunks em paralelo
.taskExecutor(taskExecutor)
.throttleLimit(4)
.build();
}
// Wrapper para tornar o reader thread-safe
private ItemReader<Record> synchronizedReader(ItemReader<Record> reader) {
SynchronizedItemStreamReader<Record> syncReader = new SynchronizedItemStreamReader<>();
syncReader.setDelegate((ItemStreamReader<Record>) reader);
return syncReader;
}
}ParallelStepsConfig.javajava
// Execução de steps independentes em paralelo
@Configuration
public class ParallelStepsConfig {
@Bean
public Job parallelJob(JobRepository jobRepository,
Step loadCustomersStep,
Step loadProductsStep,
Step loadOrdersStep,
Step processDataStep) {
// Fluxo paralelo: customers e products carregados simultaneamente
Flow loadCustomersFlow = new FlowBuilder<Flow>("loadCustomersFlow")
.start(loadCustomersStep)
.build();
Flow loadProductsFlow = new FlowBuilder<Flow>("loadProductsFlow")
.start(loadProductsStep)
.build();
Flow loadOrdersFlow = new FlowBuilder<Flow>("loadOrdersFlow")
.start(loadOrdersStep)
.build();
// Split executa os fluxos em paralelo
return new JobBuilder("parallelJob", jobRepository)
.start(new FlowBuilder<Flow>("parallelLoadFlow")
.split(new SimpleAsyncTaskExecutor())
.add(loadCustomersFlow, loadProductsFlow, loadOrdersFlow)
.build())
// Após o carregamento paralelo, processamento sequencial
.next(processDataStep)
.build()
.build();
}
}O multi-threading é adequado quando o reader pode ser sincronizado. O particionamento é preferível para grandes volumes pois cada partição tem seu próprio reader sem contenção.
Pergunta 11: Como monitorar o desempenho de um job?
O Spring Batch expõe métricas via listeners e JobRepository. A integração com Micrometer permite exportação para Prometheus, Grafana ou outros sistemas de monitoramento.
BatchMetricsConfig.javajava
// Configuração de monitoramento com Micrometer
@Configuration
public class BatchMetricsConfig {
private final MeterRegistry meterRegistry;
public BatchMetricsConfig(MeterRegistry meterRegistry) {
this.meterRegistry = meterRegistry;
}
@Bean
public JobExecutionListener metricsJobListener() {
return new JobExecutionListener() {
private Timer.Sample jobTimer;
@Override
public void beforeJob(JobExecution jobExecution) {
// Inicia o timer de duração do job
jobTimer = Timer.start(meterRegistry);
Counter.builder("batch.job.started")
.tag("job", jobExecution.getJobInstance().getJobName())
.register(meterRegistry)
.increment();
}
@Override
public void afterJob(JobExecution jobExecution) {
// Registra a duração total
jobTimer.stop(Timer.builder("batch.job.duration")
.tag("job", jobExecution.getJobInstance().getJobName())
.tag("status", jobExecution.getStatus().toString())
.register(meterRegistry));
// Contador de jobs por status
Counter.builder("batch.job.completed")
.tag("job", jobExecution.getJobInstance().getJobName())
.tag("status", jobExecution.getStatus().toString())
.register(meterRegistry)
.increment();
}
};
}
@Bean
public StepExecutionListener metricsStepListener() {
return new StepExecutionListener() {
@Override
public void afterStep(StepExecution stepExecution) {
String jobName = stepExecution.getJobExecution().getJobInstance().getJobName();
String stepName = stepExecution.getStepName();
// Métricas de throughput
Gauge.builder("batch.step.read.count", stepExecution, StepExecution::getReadCount)
.tag("job", jobName)
.tag("step", stepName)
.register(meterRegistry);
Gauge.builder("batch.step.write.count", stepExecution, StepExecution::getWriteCount)
.tag("job", jobName)
.tag("step", stepName)
.register(meterRegistry);
Gauge.builder("batch.step.skip.count", stepExecution, StepExecution::getSkipCount)
.tag("job", jobName)
.tag("step", stepName)
.register(meterRegistry);
return null;
}
};
}
}Pergunta 12: Quais são as armadilhas comuns no particionamento?
Erros frequentes incluem: partições desbalanceadas (uma partição contém 90% dos dados), readers não thread-safe e gerenciamento incorreto do estado entre partições.
BalancedPartitioner.javajava
// Partitioner que realmente equilibra a carga
@Component
public class BalancedPartitioner implements Partitioner {
private final JdbcTemplate jdbcTemplate;
public BalancedPartitioner(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public Map<String, ExecutionContext> partition(int gridSize) {
// Conta total de itens a processar
Integer totalCount = jdbcTemplate.queryForObject(
"SELECT COUNT(*) FROM orders WHERE status = 'PENDING'", Integer.class);
if (totalCount == null || totalCount == 0) {
return Map.of();
}
// Calcula o tamanho-alvo por partição
int itemsPerPartition = (int) Math.ceil((double) totalCount / gridSize);
Map<String, ExecutionContext> partitions = new HashMap<>();
// Usa OFFSET/LIMIT para partições balanceadas
// Mais caro que ranges mas garante o equilíbrio
for (int i = 0; i < gridSize; i++) {
ExecutionContext context = new ExecutionContext();
context.putInt("offset", i * itemsPerPartition);
context.putInt("limit", itemsPerPartition);
context.putInt("partitionNumber", i);
partitions.put("partition" + i, context);
}
return partitions;
}
}
// OffsetBasedReader.java
// Reader compatível com particionamento por offset
@StepScope
@Component
public class OffsetBasedReader implements ItemReader<OrderRecord>, ItemStream {
private final JdbcTemplate jdbcTemplate;
private Iterator<OrderRecord> iterator;
@Value("#{stepExecutionContext['offset']}")
private int offset;
@Value("#{stepExecutionContext['limit']}")
private int limit;
public OffsetBasedReader(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public void open(ExecutionContext executionContext) {
// Carrega exatamente a porção atribuída a esta partição
List<OrderRecord> records = jdbcTemplate.query(
"SELECT * FROM orders WHERE status = 'PENDING' ORDER BY id LIMIT ? OFFSET ?",
new OrderRecordRowMapper(),
limit, offset
);
this.iterator = records.iterator();
}
@Override
public OrderRecord read() {
return iterator.hasNext() ? iterator.next() : null;
}
@Override
public void update(ExecutionContext executionContext) {
// Salvamento de estado para restart se necessário
}
@Override
public void close() {
// Limpeza
}
}Perguntas avançadas para sêniores
Pergunta 13: Como gerenciar dependências entre jobs?
O Spring Batch não gerencia nativamente dependências entre jobs. Soluções incluem: orquestradores externos (Airflow, Kubernetes CronJob) ou implementação customizada com JobExplorer.
JobDependencyService.javajava
// Gerenciamento de dependências entre jobs
@Service
public class JobDependencyService {
private final JobExplorer jobExplorer;
private final JobLauncher jobLauncher;
private final Map<String, Job> jobs;
public JobDependencyService(JobExplorer jobExplorer,
JobLauncher jobLauncher,
Map<String, Job> jobs) {
this.jobExplorer = jobExplorer;
this.jobLauncher = jobLauncher;
this.jobs = jobs;
}
public JobExecution runWithDependencies(String jobName,
JobParameters params,
List<String> dependsOn) throws Exception {
// Verifica se todas as dependências foram bem-sucedidas
for (String dependency : dependsOn) {
if (!hasSuccessfulExecution(dependency, params)) {
throw new JobExecutionException(
"Dependency not satisfied: " + dependency);
}
}
Job job = jobs.get(jobName);
if (job == null) {
throw new IllegalArgumentException("Unknown job: " + jobName);
}
return jobLauncher.run(job, params);
}
private boolean hasSuccessfulExecution(String jobName, JobParameters params) {
// Procura uma execução COMPLETED com os mesmos parâmetros de negócio
return jobExplorer.findJobInstancesByJobName(jobName, 0, 1)
.stream()
.flatMap(instance -> jobExplorer.getJobExecutions(instance).stream())
.filter(exec -> exec.getStatus() == BatchStatus.COMPLETED)
.anyMatch(exec -> matchesBusinessParams(exec.getJobParameters(), params));
}
private boolean matchesBusinessParams(JobParameters actual, JobParameters expected) {
// Compara parâmetros de negócio (ignora timestamps de execução)
String actualDate = actual.getString("businessDate");
String expectedDate = expected.getString("businessDate");
return Objects.equals(actualDate, expectedDate);
}
}Pergunta 14: Como testar eficazmente um job Spring Batch?
Testar jobs Spring Batch exige uma abordagem em camadas: testes unitários dos componentes (reader, processor, writer), testes de integração dos steps e testes end-to-end de jobs completos.
OrderProcessorTest.javajava
// Teste unitário do processor
@ExtendWith(MockitoExtension.class)
class OrderProcessorTest {
@Mock
private PricingService pricingService;
@Mock
private ValidationService validationService;
@InjectMocks
private OrderItemProcessor processor;
@Test
void shouldProcessValidOrder() {
// Given
OrderRecord input = new OrderRecord(1L, 100L, BigDecimal.TEN);
when(validationService.isValid(input)).thenReturn(true);
when(pricingService.calculatePrice(input)).thenReturn(new BigDecimal("12.50"));
// When
ProcessedOrder result = processor.process(input);
// Then
assertThat(result).isNotNull();
assertThat(result.finalPrice()).isEqualTo(new BigDecimal("12.50"));
}
@Test
void shouldFilterInvalidOrder() {
// Given
OrderRecord input = new OrderRecord(1L, 100L, BigDecimal.TEN);
when(validationService.isValid(input)).thenReturn(false);
// When
ProcessedOrder result = processor.process(input);
// Then - null significa filtrado
assertThat(result).isNull();
verify(pricingService, never()).calculatePrice(any());
}
}ImportJobIntegrationTest.javajava
// Teste de integração do job completo
@SpringBatchTest
@SpringBootTest
@ActiveProfiles("test")
class ImportJobIntegrationTest {
@Autowired
private JobLauncherTestUtils jobLauncherTestUtils;
@Autowired
private JobRepositoryTestUtils jobRepositoryTestUtils;
@Autowired
private JdbcTemplate jdbcTemplate;
@BeforeEach
void setup() {
// Limpa metadados entre testes
jobRepositoryTestUtils.removeJobExecutions();
// Reseta dados de teste
jdbcTemplate.execute("DELETE FROM processed_orders");
jdbcTemplate.execute("DELETE FROM orders");
}
@Test
void shouldCompleteJobSuccessfully() throws Exception {
// Given - dados de teste
insertTestOrders(100);
// When
JobParameters params = new JobParametersBuilder()
.addLocalDate("businessDate", LocalDate.now())
.addLong("run.id", System.currentTimeMillis())
.toJobParameters();
JobExecution execution = jobLauncherTestUtils.launchJob(params);
// Then
assertThat(execution.getStatus()).isEqualTo(BatchStatus.COMPLETED);
assertThat(countProcessedOrders()).isEqualTo(100);
}
@Test
void shouldHandleEmptyDataset() throws Exception {
// Given - sem dados
// When
JobExecution execution = jobLauncherTestUtils.launchJob();
// Then - job tem sucesso mesmo sem dados
assertThat(execution.getStatus()).isEqualTo(BatchStatus.COMPLETED);
}
@Test
void shouldRestartFromFailurePoint() throws Exception {
// Given - simula erro no meio do processamento
insertTestOrders(100);
insertPoisonOrder(50); // Causa um erro
// When - primeira execução falha
JobExecution firstExecution = jobLauncherTestUtils.launchJob();
assertThat(firstExecution.getStatus()).isEqualTo(BatchStatus.FAILED);
// Corrige os dados
removePoisonOrder(50);
// When - restart
JobExecution restartExecution = jobLauncherTestUtils.launchJob(
firstExecution.getJobParameters());
// Then - retoma a partir do ponto de falha
assertThat(restartExecution.getStatus()).isEqualTo(BatchStatus.COMPLETED);
}
private void insertTestOrders(int count) {
for (int i = 1; i <= count; i++) {
jdbcTemplate.update(
"INSERT INTO orders (id, customer_id, amount, status) VALUES (?, ?, ?, 'PENDING')",
i, i * 10, BigDecimal.valueOf(i * 10));
}
}
private int countProcessedOrders() {
return jdbcTemplate.queryForObject(
"SELECT COUNT(*) FROM processed_orders", Integer.class);
}
}Pergunta 15: Como otimizar o desempenho de gravações no banco de dados?
A gravação geralmente se torna o gargalo. Otimizações incluem: batch inserts JDBC, desativação de constraints durante a carga e uso de tabelas de staging.
OptimizedJdbcWriter.javajava
// Writer otimizado para grandes volumes
@Component
public class OptimizedJdbcWriter implements ItemWriter<ProcessedOrder> {
private final JdbcTemplate jdbcTemplate;
private final DataSource dataSource;
public OptimizedJdbcWriter(JdbcTemplate jdbcTemplate, DataSource dataSource) {
this.jdbcTemplate = jdbcTemplate;
this.dataSource = dataSource;
}
@Override
public void write(Chunk<? extends ProcessedOrder> chunk) throws Exception {
List<? extends ProcessedOrder> items = chunk.getItems();
if (items.isEmpty()) {
return;
}
// Usa PreparedStatement com batch
try (Connection connection = dataSource.getConnection();
PreparedStatement ps = connection.prepareStatement(
"INSERT INTO processed_orders (order_id, customer_id, final_price, processed_at) " +
"VALUES (?, ?, ?, ?)")) {
for (ProcessedOrder order : items) {
ps.setLong(1, order.orderId());
ps.setLong(2, order.customerId());
ps.setBigDecimal(3, order.finalPrice());
ps.setTimestamp(4, Timestamp.valueOf(order.processedAt()));
ps.addBatch();
}
// Executa todos os inserts em uma única operação de rede
ps.executeBatch();
}
}
}
// StagingTableWriter.java
// Padrão staging table para volumes muito grandes
@Component
public class StagingTableWriter implements ItemWriter<ProcessedOrder>, StepExecutionListener {
private final JdbcTemplate jdbcTemplate;
private String stagingTable;
public StagingTableWriter(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public void beforeStep(StepExecution stepExecution) {
// Cria tabela temporária para este step
stagingTable = "staging_orders_" + stepExecution.getId();
jdbcTemplate.execute(
"CREATE TEMP TABLE " + stagingTable + " (LIKE processed_orders INCLUDING ALL)");
}
@Override
public void write(Chunk<? extends ProcessedOrder> chunk) {
// Escreve na tabela de staging (sem constraints FK)
String sql = "INSERT INTO " + stagingTable +
" (order_id, customer_id, final_price, processed_at) VALUES (?, ?, ?, ?)";
jdbcTemplate.batchUpdate(sql, chunk.getItems(), chunk.size(),
(ps, order) -> {
ps.setLong(1, order.orderId());
ps.setLong(2, order.customerId());
ps.setBigDecimal(3, order.finalPrice());
ps.setTimestamp(4, Timestamp.valueOf(order.processedAt()));
});
}
@Override
public ExitStatus afterStep(StepExecution stepExecution) {
if (stepExecution.getStatus() == BatchStatus.COMPLETED) {
// Bulk copy para a tabela final
jdbcTemplate.execute(
"INSERT INTO processed_orders SELECT * FROM " + stagingTable);
}
// Limpa tabela de staging
jdbcTemplate.execute("DROP TABLE IF EXISTS " + stagingTable);
return stepExecution.getExitStatus();
}
}Conclusão
Dominar o Spring Batch 5 em entrevistas técnicas baseia-se na compreensão profunda dos mecanismos internos:
✅ Arquitetura: Job → Step → Chunk (Reader, Processor, Writer)
✅ Processamento por chunks: dimensionamento, ciclo de vida, transações
✅ Particionamento: local vs remoto, equilíbrio das partições
✅ Tolerância a falhas: skip, retry, restart com política adequada
✅ Escalabilidade: multi-threading, parallel steps, remote chunking
✅ Testes: unitários, integração, end-to-end
✅ Otimização: batch writes, staging tables, monitoramento
Perguntas avançadas avaliam a capacidade de justificar decisões arquiteturais conforme o contexto: volume de dados, restrições de tempo, tolerância a erros e infraestrutura disponível.
Comece a praticar!
Teste seus conhecimentos com nossos simuladores de entrevista e testes tecnicos.
Tags
#spring batch
#spring boot
#java
#batch processing
#interview questions
Compartilhar
Artigos relacionados
Spring Modulith: Arquitetura de Monólito Modular Explicada
Aprenda Spring Modulith para construir monólitos modulares em Java. Arquitetura, módulos, eventos assíncronos e testes com exemplos em Spring Boot 3.
Entrevista Spring Boot: Propagação de Transações
Domine a propagação de transações no Spring Boot: REQUIRED, REQUIRES_NEW, NESTED e mais. 12 perguntas de entrevista com código e armadilhas comuns.
Spring Security 6: Autenticação JWT Completa
Guia prático para implementar autenticação JWT com Spring Security 6. Configuração, geração de tokens, validação e boas práticas de segurança.