データ処理の効率と品質を向上させるための Spring Batch バッチ処理フレームワークの最適化実践
1. Spring Batch の概要
1 フレームワークの概要
Spring Batchは、Spring Frameworkをベースに開発されたバッチ処理のフレームワークであり、大量のデータの読み込み、処理、書き込みにより、エンタープライズレベルのさまざまなバッチ処理要件に応えることができます。Spring Batch は大量のデータを適切に処理でき、豊富な拡張可能なコンポーネントを提供し、フレームワーク層でのビジネス ロジックと一連の処理ステップの統合は比較的簡単です。Spring Batch は、プログラマが大量のデータに対して標準化された操作シーケンスを実行するコードを作成できるようにサポートし、開発効率を向上させ、データベースなどのシステム リソースへのアクセスへの影響を軽減します。
2 中心となる概念とコンポーネント
Spring Batch には主に次のコア概念とコンポーネントが含まれています。
- ジョブ: 実行可能なビジネス ロジックのバッチ。
- ステップ: ジョブ内の独立した小さなステップ。
- ExecutionContext: ジョブまたはステップが実行されるたびに、このオブジェクトが作成され、この実行のコンテキスト状態が保存されます。
- ItemReader: 対応するデータを読み取るために使用されます。
- ItemProcessor:ItemReaderで読み取ったデータを処理し、対応する業務処理を実行するために使用されます。
- ItemWriter:ItemProcessor によって処理されたデータをターゲットの保存場所に書き込むために使用されます。
2. バッチ最適化の実践
1 読み取りと書き込みの回数を減らす
1.1 ページネーション処理データ
バッチ処理を実行する場合は、すべてのデータをスキャンするのではなく、データをバッチで読み取り、処理する必要があります。これにより、システム リソースへの過剰な負荷を回避できます。大量のデータを扱うタスクの処理には、大量のデータを複数の小さなタスクに分割して処理し、タスクごとにページ単位で読み込んで処理するページング処理技術の採用を推奨します。
@Bean
@StepScope
public ItemReader<Data> reader() {
RepositoryItemReader<Data> reader = new RepositoryItemReader<>();
reader.setRepository(repository);
reader.setMethodName(FIND_DATA_BY_NAME_AND_AGE);
reader.setPageSize(1000);
Map<String, Object> params = new HashMap<>();
params.put("name", "test");
params.put("age", 20);
reader.setParameterValues(params);
return reader;
}
上記の例では、Spring Data JPA Repository を使用してページ単位でデータを読み込む例を示していますが、ページ単位で読み込む場合は、setPageSize() でページ数を指定できます。
1.2 読み取りおよび書き込みキャッシュの使用
繰り返し読み取りと書き込みが頻繁に行われる一部のデータについては、読み取りおよび書き込みキャッシュを使用して、読み取りおよび書き込み操作の頻度を減らすことができます。読み取り/書き込みキャッシュを使用すると、読み取り/書き込みディスク I/O の動作が軽減され、バッチ データの処理効率が大幅に向上します。Spring Batch で @EnableCaching を使用してキャッシュを有効にできます。
@Bean
public ItemWriter<Data> writer() {
RepositoryItemWriter<Data> writer = new RepositoryItemWriter<>();
writer.setRepository(repository);
writer.setMethodName(SAVE);
writer.afterPropertiesSet();
return writer;
}
@Bean
public CacheManager cacheManager() {
return new ConcurrentMapCacheManager("data");
}
上記の例は、Spring Cache を使用してデータをキャッシュする方法を示しています。構成クラスに @EnableCaching アノテーションを追加し、CacheManager で対応するキャッシュ名を指定する必要があります。
1.3 行レベルの書き込み操作
操作を書き込むときは、一度に大量のデータを送信しないようにする必要があります。行レベルの書き込み操作を使用できます。つまり、データをバッチで保存し、バッチで送信することで、メモリ オーバーフローを効果的に回避し、I/O を削減できます。 /O 操作。
@Bean
public ItemWriter<Data> writer(EntityManagerFactory entityManagerFactory) {
JpaItemWriter<Data> writer = new JpaItemWriter<>();
writer.setEntityManagerFactory(entityManagerFactory);
writer.setPersistenceUnitName(PERSISTENCE_UNIT_NAME);
writer.setTransactionManager(transactionManager);
writer.setFlushBlockSize(5000);
return writer;
}
上記の例は、Spring Batch が提供する JpaItemWriter を使用してデータをバッチに保存する方法を示しています。setFlushBlockSize() メソッドを調整することで、各バッチで送信されるデータの量を指定できます。
2つの同時処理タスク
2.1 マルチプロセッシング
大量のデータを処理する場合、マルチプロセスの同時処理を使用してデータ処理速度を向上させることができます。主なアイデアは、大規模なデータセットを複数のタスクに分割し、これらのタスクを異なるプロセスに割り当て、マルチコアを使用することです。コンピューターの機能により、複数のタスクを同時に処理し、データ処理効率を向上させます。
@Bean
public SimpleAsyncTaskExecutor taskExecutor() {
return new SimpleAsyncTaskExecutor("async-writer");
}
@Bean
public SimpleJobLauncher jobLauncher() throws Exception {
SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
jobLauncher.setTaskExecutor(taskExecutor());
jobLauncher.setJobRepository(jobRepository);
jobLauncher.afterPropertiesSet();
return jobLauncher;
}
上記の例は、Spring Batch が提供する SimpleAsyncTaskExecutor を使用してデータに対するバッチ タスクの同時処理を実行する方法を示しています。プロセスは、タスクを実行するために使用可能な CPU コアに自動的に割り当てられます。
2.2 マルチスレッド処理
大量のデータを処理する場合、マルチスレッドの同時処理を使用してデータ処理速度を向上させることができます。主なアイデアは、大規模なデータ セットを複数のタスクに分割し、Java マルチスレッドの特性を利用して、複数のタスクを同時に処理することです。同時にデータ処理速度も向上し、処理効率も向上します。
@Bean
public TaskExecutor taskExecutor() {
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
taskExecutor.setCorePoolSize(10);
taskExecutor.setMaxPoolSize(50);
taskExecutor.setQueueCapacity(25);
taskExecutor.setThreadNamePrefix("batch-thread-");
taskExecutor.initialize();
return taskExecutor;
}
@Bean
public SimpleAsyncTaskExecutor jobExecutor() {
SimpleAsyncTaskExecutor executor = new SimpleAsyncTaskExecutor("job-thread");
executor.setConcurrencyLimit(3);
return executor;
}
@Bean
public SimpleJobLauncher jobLauncher() throws Exception {
SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
jobLauncher.setTaskExecutor(jobExecutor());
jobLauncher.setJobRepository(jobRepository);
jobLauncher.afterPropertiesSet();
return jobLauncher;
}
上記の例は、Spring Batch が提供する ThreadPoolTaskExecutor を使用して、データに対するバッチ タスクの同時処理を実行する方法を示しています。setCorePoolSize()、setMaxPoolSize()、setQueueCapacity を調整することで、スレッド プールのサイズを設定し、スレッド数を制御できます。 () メソッド内で、SimpleAsyncTaskExecutor を使用して、同時実行スレッドの数を制限します。
3 データ検証の精度向上
3.1 バッチ開始前の確認
バッチ処理タスクを実行する場合、入力データの正確性と読み取りおよび書き込み操作の正当性を保証する必要があり、バッチ処理を開始する前に検証することで、データの精度を大幅に向上させることができます。
@Configuration
public class JobValidateListener {
@Autowired
private Validator validator;
@Autowired
private Job job;
@PostConstruct
public void init() {
JobValidationListener validationListener = new JobValidationListener();
validationListener.setValidator(validator);
job.registerJobExecutionListener(validationListener);
}
}
public class JobValidationListener implements JobExecutionListener {
private Validator validator;
public void setValidator(Validator validator) {
this.validator = validator;
}
@Override
public void beforeJob(JobExecution jobExecution) {
JobParameters parameters = jobExecution.getJobParameters();
BatchJobParameterValidator validator = new BatchJobParameterValidator(parameters);
validator.validate();
}
@Override
public void afterJob(JobExecution jobExecution) {
}
}
上記の例は、Bean Validation を使用してバッチ タスクの入力パラメーターを検証し、beforeJob() メソッドでカスタム BatchJobParameterValidator を呼び出して入力パラメーターを検証する方法を示しています。
3.2 読み取りおよび書き込みの検証
バッチ処理タスクを実行するときは、対象のデータ ストレージに不正なデータが書き込まれるのを防ぐために、読み書きされるデータを毎回検証する必要があります。
@Bean
public ItemReader<Data> reader() {
JpaPagingItemReader<Data> reader = new JpaPagingItemReader<>();
reader.setEntityManagerFactory(entityManagerFactory);
reader.setPageSize(1000);
reader.setQueryString(FIND_DATA_BY_NAME_AND_AGE);
Map<String, Object> parameters = new HashMap<>();
parameters.put("name", "test");
parameters.put("age", 20);
reader.setParameterValues(parameters);
reader.setValidationQuery("select count(*) from data where name=#{name} and age=#{age}");
return reader;
}
上記の例は、JpaPagingItemReaderを使用してデータを読み取り、Readerでデータ検証を実行し、setValidationQuery()メソッドを設定して検証SQL文を指定する方法を示しています。
4 バッチタスクの監視
4.1 Spring Boot アクチュエータによる監視
バッチ タスクを実行するときは、タスクの実行と実行ステータスを常に把握しておく必要があります。これは Spring Boot Actuator を使用して監視できます。Spring Boot Actuator は、開発者がバッチ タスクの実行ステータスをリアルタイムで監視できるように、豊富な監視インジケーターと API を提供します。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
上記の例は、pom.xml ファイルに spring-boot-starter-actuator 依存関係を追加して、Actuator 機能を有効にする方法を示しています。
4.2 管理コンソールを使用した監視
バッチタスクを実行する場合、管理コンソールでタスクの実行や実行状況を監視し、コンソールに監視インジケーターやタスクログを表示することで、タスクの異常を早期に発見し、対処することができます。
@Configuration
public class BatchLoggingConfiguration {
@Bean
public BatchConfigurer configurer(DataSource dataSource) {
return new DefaultBatchConfigurer(dataSource) {
@Override
public PlatformTransactionManager getTransactionManager() {
return new ResourcelessTransactionManager();
}
@Override
public JobLauncher getJobLauncher() throws Exception {
SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
jobLauncher.setJobRepository(getJobRepository());
jobLauncher.afterPropertiesSet();
return jobLauncher;
}
@Override
public JobRepository getJobRepository() throws Exception {
JobRepositoryFactoryBean factory = new JobRepositoryFactoryBean();
factory.setDataSource(getDataSource());
factory.setTransactionManager(getTransactionManager());
factory.setIsolationLevelForCreate("ISOLATION_DEFAULT");
factory.afterPropertiesSet();
return factory.getObject();
}
};
}
}
上記の例は、BatchConfigurer を使用してバッチ処理タスクのログと監視情報を記録し、管理コンソールに表示する方法を示しています。@EnableBatchProcessing アノテーションを使用すると、プログラムの開始時にバッチ処理を有効にすることができます。同時に、 @EnableScheduling アノテーションを使用して、スケジュールされたタスクを自動的に開始できます。
3. 実践例
1 事件の概要
私たちのプロジェクトでは、ユーザーのショッピング行動を分析し、結果をデータベースに保存する必要があります。データサイズが大きく、適時に更新する必要があるため、バッチ処理技術を使用してこの問題に対処することにしました。
2 問題分析
データ処理にバッチ処理フレームワークを使用しているときに、次の問題が発生しました。
- データの読み取り効率が低く、バッチ処理が遅くなります。
- 処理中に例外が発生すると、時間内に例外を検出して処理することができません。
3 バッチ最適化の実践
3.1 データソース構成の変更
まず、データ ソースの構成が変更され、接続プールが使用されてデータ読み取りの効率が向上します。
<bean id="dataSource"
class="com.alibaba.druid.pool.DruidDataSource"
init-method="init"
destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="initialSize" value="${druid.initialSize}" />
<property name="minIdle" value="${druid.minIdle}" />
<property name="maxActive" value="${druid.maxActive}" />
<property name="maxWait" value="${druid.maxWait}" />
<property name="timeBetweenEvictionRunsMillis" value="${druid.timeBetweenEvictionRunsMillis}" />
<property name="minEvictableIdleTimeMillis" value="${druid.minEvictableIdleTimeMillis}" />
<property name="validationQuery" value="${druid.validationQuery}" />
<property name="testWhileIdle" value="${druid.testWhileIdle}" />
<property name="testOnBorrow" value="${druid.testOnBorrow}" />
<property name="testOnReturn" value="${druid.testOnReturn}" />
<property name="poolPreparedStatements" value="${druid.poolPreparedStatements}" />
<property name="maxPoolPreparedStatementPerConnectionSize" value="${druid.maxPoolPreparedStatementPerConnectionSize}" />
<property name="filters" value="${druid.filters}" />
</bean>
上記のコードは、Alibaba の Druid 接続プールを使用してデータ読み取り効率を最適化する方法を示しています。
3.2 シャードバッチ処理の使用
処理効率を向上させるために、大規模なデータのバッチを処理し、バッチ処理タスクを複数の小さなタスクに分割して同時に実行するシャーディング戦略を採用することが決定されました。
@Configuration
public class BatchConfiguration {
@Autowired
private JobBuilderFactory jobBuilderFactory;
@Autowired
private StepBuilderFactory stepBuilderFactory;
@Autowired
private DataSource dataSource;
@Bean
public Job job() {
return jobBuilderFactory.get("job")
.incrementer(new RunIdIncrementer())
.start(step1())
.next(step2())
.build();
}
@Bean
public Step step1() {
return stepBuilderFactory.get("step1")
.<User, User>chunk(10000)
.reader(reader(null))
.processor(processor())
.writer(writer(null))
.taskExecutor(taskExecutor())
.build();
}
@Bean
public Step step2() {
return stepBuilderFactory.get("step2")
.<User, User>chunk(10000)
.reader(reader2(null))
.processor(processor())
.writer(writer2(null))
.taskExecutor(taskExecutor())
.build();
}
@SuppressWarnings({
"unchecked", "rawtypes" })
@Bean
@StepScope
public JdbcCursorItemReader<User> reader(@Value("#{stepExecutionContext['fromId']}")Long fromId) {
JdbcCursorItemReader<User> reader = new JdbcCursorItemReader<>();
reader.setDataSource(dataSource);
reader.setSql("SELECT * FROM user WHERE id > ? AND id <= ?");
reader.setPreparedStatementSetter(new PreparedStatementSetter() {
@Override
public void setValues(PreparedStatement ps) throws SQLException {
ps.setLong(1, fromId);
ps.setLong(2, fromId + 10000);
}
});
reader.setRowMapper(new BeanPropertyRowMapper<>(User.class));
return reader;
}
@SuppressWarnings({
"rawtypes", "unchecked" })
@Bean
@StepScope
public JdbcCursorItemReader<User> reader2(@Value("#{stepExecutionContext['fromId']}")Long fromId) {
JdbcCursorItemReader<User> reader = new JdbcCursorItemReader<>();
reader.setDataSource(dataSource);
reader.setSql("SELECT * FROM user WHERE id > ?");
reader.setPreparedStatementSetter(new PreparedStatementSetter() {
@Override
public void setValues(PreparedStatement ps) throws SQLException {
ps.setLong(1, fromId + 10000);
}
});
reader.setRowMapper(new BeanPropertyRowMapper<>(User.class));
return reader;
}
@Bean
public ItemProcessor<User, User> processor() {
return new UserItemProcessor();
}
@Bean
public ItemWriter<User> writer(DataSource dataSource) {
JdbcBatchItemWriter<User> writer = new JdbcBatchItemWriter<>();
writer.setDataSource(dataSource);
writer.setSql("INSERT INTO user(name, age) VALUES(?, ?)");
writer.setItemPreparedStatementSetter(new UserPreparedStatementSetter());
return writer;
}
@Bean
public ItemWriter<User> writer2(DataSource dataSource) {
JdbcBatchItemWriter<User> writer = new JdbcBatchItemWriter<>();
writer.setDataSource(dataSource);
writer.setSql("UPDATE user SET age = ? WHERE name = ?");
writer.setItemPreparedStatementSetter(new UserUpdatePreparedStatementSetter());
return writer;
}
@Bean(destroyMethod="shutdown")
public ThreadPoolTaskExecutor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(30);
executor.initialize();
return executor;
}
@Bean
public StepExecutionListener stepExecutionListener() {
return new StepExecutionListenerSupport() {
@Override
public ExitStatus afterStep(StepExecution stepExecution) {
if(stepExecution.getSkipCount() > 0) {
return new ExitStatus("COMPLETED_WITH_SKIPS");
} else {
return ExitStatus.COMPLETED;
}
}
};
}
}
上記のコードは、シャード バッチを使用して大規模なデータ バッチを処理する方法を示しています。バッチ処理タスクを複数の小さなタスクに分割して同時実行することにより、バッチ処理の効率が向上します。
3.3 監視および例外処理戦略の使用
監視および例外処理戦略を使用して、バッチ ジョブで発生する例外を検出して処理します。
@Configuration
public class BatchConfiguration {
...
@Bean
public Step step1() {
return stepBuilderFactory.get("step1")
.<User, User>chunk(10000)
.reader(reader(null))
.processor(processor())
.writer(writer(null))
.taskExecutor(taskExecutor())
.faultTolerant()
.skipPolicy(new UserSkipPolicy())
.retryPolicy(new SimpleRetryPolicy())
.retryLimit(3)
.noRollback(NullPointerException.class)
.listener(stepExecutionListener())
.build();
}
@Bean
public StepExecutionListener stepExecutionListener() {
return new StepExecutionListenerSupport() {
@Override
public ExitStatus afterStep(StepExecution stepExecution) {
if(stepExecution.getSkipCount() > 0) {
return new ExitStatus("COMPLETED_WITH_SKIPS");
} else {
return ExitStatus.COMPLETED;
}
}
};
}
@Bean
public SkipPolicy userSkipPolicy() {
return (Throwable t, int skipCount) -> {
if(t instanceof NullPointerException) {
return false;
} else {
return true;
}
};
}
@Bean
public RetryPolicy simpleRetryPolicy() {
SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
retryPolicy.setMaxAttempts(3);
return retryPolicy;
}
@Bean
public ItemWriter<User> writer(DataSource dataSource) {
CompositeItemWriter<User> writer = new CompositeItemWriter<>();
List<ItemWriter<? super User>> writers = new ArrayList<>();
writers.add(new UserItemWriter());
writers.add(new LogUserItemWriter());
writer.setDelegates(writers);
writer.afterPropertiesSet();
return writer;
}
public class UserItemWriter implements ItemWriter<User> {
@Override
public void write(List<? extends User> items) throws Exception {
for(User item : items) {
...
}
}
}
public class LogUserItemWriter implements ItemWriter<User> {
@Override
public void write(List<? extends User> items) throws Exception {
for(User item : items) {
...
}
}
@Override
public void onWriteError(Exception exception, List<? extends User> items) {
...
}
}
@Bean
public BatchLoggingConfiguration batchLoggingConfiguration() {
return new BatchLoggingConfiguration();
}
}
上記のコードは、監視および例外処理戦略を使用して、バッチ タスクで発生する例外を検出して処理する方法を示しています。fallTolerant() メソッドを使用してフォールト トレラント処理戦略を構成し、skipPolicy() メソッドを使用してエラー レコードをスキップする戦略を構成し、retryPolicy() メソッドを使用して再試行戦略を構成できます。ロールバック操作を回避するには、noRollback() メソッドを使用します。CompositeItemWriter を使用して例外処理戦略を作成し、例外処理に対する実際のビジネス ニーズも組み合わせます。Spring Boot Actuator は、バッチ タスクの実行時の監視にも使用できます。
4 テスト効果の分析
上記の最適化手段を使用してテストした後、次のテスト結果が得られました。
- データの読み込み効率は約50％向上、バッチ処理速度は約40％向上しました。
- 例外率は 30% 減少し、例外処理は 400% 増加しました。
4. まとめと振り返り
この記事の分析と実践を通じて、大量のデータを処理する場合にはバッチ処理フレームワークの使用が非常に効果的であることがわかりました。ただし、実際のアプリケーションでは、バッチ処理の効率と安定性を最適化する方法も考慮する必要があり、接続プーリング、断片化されたバッチ処理、フォールト トレラント処理、例外処理などの手法を使用してバッチ処理の効率を最適化し、バッチ処理を安定化することができます。安定。この記事の内容が皆様のお役に立てれば幸いです。