データベースアクセス

// (1)
@Bean
public BasicDataSource adminDataSource(@Value("${admin.h2.jdbc.driver}") String driverClassName,
                                       @Value("${admin.h2.jdbc.url}") String url,
                                       @Value("${admin.h2.jdbc.username}") String username,
                                       @Value("${admin.h2.jdbc.password}") String password) {
    final BasicDataSource dataSource = new BasicDataSource();
    dataSource.setDriverClassName(driverClassName);
    dataSource.setUrl(url);
    dataSource.setUsername(username);
    dataSource.setPassword(password);
    dataSource.setMaxTotal(10);
    dataSource.setMinIdle(1);
    dataSource.setMaxWaitMillis(5000);
    dataSource.setDefaultAutoCommit(false);
    return dataSource;
}

// (2)
@Bean
public BasicDataSource jobDataSource(@Value("${jdbc.driver}") String driverClassName,
                                     @Value("${jdbc.url}") String url,
                                     @Value("${jdbc.username}") String username,
                                     @Value("${jdbc.password}") String password) {
    final BasicDataSource basicDataSource = new BasicDataSource();
    basicDataSource.setDriverClassName(driverClassName);
    basicDataSource.setUrl(url);
    basicDataSource.setUsername(username);
    basicDataSource.setPassword(password);
    basicDataSource.setMaxTotal(10);
    basicDataSource.setMinIdle(1);
    basicDataSource.setMaxWaitMillis(5000);
    basicDataSource.setDefaultAutoCommit(false);
    return basicDataSource;
}

<!-- (1) -->
<bean id="adminDataSource" class="org.apache.commons.dbcp2.BasicDataSource"
      destroy-method="close"
      p:driverClassName="${admin.h2.jdbc.driver}"
      p:url="${admin.h2.jdbc.url}"
      p:username="${admin.h2.jdbc.username}"
      p:password="${admin.h2.jdbc.password}"
      p:maxTotal="10"
      p:minIdle="1"
      p:maxWaitMillis="5000"
      p:defaultAutoCommit="false"/>

<!-- (2) -->
<bean id="jobDataSource" class="org.apache.commons.dbcp2.BasicDataSource"　
      destroy-method="close"
      p:driverClassName="${jdbc.driver}"
      p:url="${jdbc.url}"
      p:username="${jdbc.username}"
      p:password="${jdbc.password}"
      p:maxTotal="10"
      p:minIdle="1"
      p:maxWaitMillis="5000"
      p:defaultAutoCommit="false" />

// (1)
@Bean
public SqlSessionFactory jobSqlSessionFactory(@Qualifier("jobDataSource") DataSource jobDataSource) throws Exception {
    final SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
    sqlSessionFactoryBean.setDataSource(jobDataSource);

    final org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
    configuration.setLocalCacheScope(LocalCacheScope.STATEMENT);
    configuration.setLazyLoadingEnabled(true);
    configuration.setAggressiveLazyLoading(false);
    configuration.setDefaultFetchSize(1000);
    configuration.setDefaultExecutorType(ExecutorType.REUSE);
     sqlSessionFactoryBean.setConfiguration(configuration);
    return sqlSessionFactoryBean.getObject();
}

// (2)
@Bean
public SqlSessionTemplate batchModeSqlSessionTemplate(@Qualifier("jobSqlSessionFactory") SqlSessionFactory jobSqlSessionFactory) {
    return new SqlSessionTemplate(jobSqlSessionFactory, ExecutorType.BATCH);
}

<bean id="jobSqlSessionFactory"
      class="org.mybatis.spring.SqlSessionFactoryBean"
      p:dataSource-ref="jobDataSource">
    <!-- (1) -->
    <property name="configuration">
        <bean class="org.apache.ibatis.session.Configuration"
              p:localCacheScope="STATEMENT"
              p:lazyLoadingEnabled="true"
              p:aggressiveLazyLoading="false"
              p:defaultFetchSize="1000"
              p:defaultExecutorType="REUSE"/>
    </property>
</bean>

<!-- (2) -->
<bean id="batchModeSqlSessionTemplate"
      class="org.mybatis.spring.SqlSessionTemplate"
      c:sqlSessionFactory-ref="jobSqlSessionFactory"
      c:executorType="BATCH"/>

@MapperScan(value = "org.terasoluna.batch.functionaltest.app.repository.plan", sqlSessionFactoryRef = "jobSqlSessionFactory")

<!-- (1) -->
<mybatis:scan
    base-package="jp.co.ntt.fw.macchinetta.batch.functionaltest.app.repository.plan"
    factory-ref="jobSqlSessionFactory"/>

@Configuration
@Import(JobBaseContextConfig.class)
@ComponentScan(value = {"org.terasoluna.batch.functionaltest.app.common",
    "org.terasoluna.batch.functionaltest.ch05.transaction.component",
    "org.terasoluna.batch.functionaltest.ch05.transaction.listener"}, scopedProxy = ScopedProxyMode.TARGET_CLASS)
@MapperScan(basePackages = "org.terasoluna.batch.functionaltest.ch05.transaction.repository.admin", sqlSessionFactoryRef = "adminSqlSessionFactory")
@MapperScan(basePackages = "org.terasoluna.batch.functionaltest.app.repository.mst", sqlSessionFactoryRef = "jobSqlSessionFactory") // (1)
public class OutputAllCustomerList01Config {

    // (2)
    @Bean
    @StepScope
    public MyBatisCursorItemReader<Customer> reader(
            @Qualifier("jobSqlSessionFactory") SqlSessionFactory jobSqlSessionFactory) {
        return new MyBatisCursorItemReaderBuilder<Customer>()
                .sqlSessionFactory(jobSqlSessionFactory) // (4)
                .queryId(
                        "org.terasoluna.batch.functionaltest.app.repository.mst.CustomerRepository.findAll") // (3)
                .build();
    }
    // omitted
    @Bean
    public Step step01(JobRepository jobRepository,
                       @Qualifier("jobTransactionManager") PlatformTransactionManager transactionManager,
                       ItemReader<Customer> reader,
                       ItemWriter<Customer> writer,
                       RetrieveBranchFromContextItemProcessor processor,
                       BranchMasterReadStepListener listener) {
        return new StepBuilder("outputAllCustomerList01.step01",
                jobRepository)
                .<Customer, Customer> chunk(10, transactionManager)
                .reader(reader) // (5)
                .processor(processor)
                .listener(listener)
                .writer(writer)
                .build();
    }

    @Bean
    public Job outputAllCustomerList01(JobRepository jobRepository,
                                            Step step01) {
        return new JobBuilder("outputAllCustomerList01",jobRepository)
                .start(step01)
                .build();
    }
}

<!-- (1) -->
<mybatis:scan
    base-package="jp.co.ntt.fw.macchinetta.batch.functionaltest.app.repository.mst"
    factory-ref="jobSqlSessionFactory"/>

<!-- (2) (3) (4) -->
<bean id="reader" class="org.mybatis.spring.batch.MyBatisCursorItemReader"
      p:queryId="jp.co.ntt.fw.macchinetta.batch.functionaltest.app.repository.mst.CustomerRepository.findAll"
      p:sqlSessionFactory-ref="jobSqlSessionFactory"/>

<batch:job id="outputAllCustomerList01" job-repository="jobRepository">
    <batch:step id="outputAllCustomerList01.step01">
        <batch:tasklet transaction-manager="jobTransactionManager">
            <!-- (5) -->
            <batch:chunk reader="reader"
                         processor="retrieveBranchFromContextItemProcessor"
                         writer="writer" commit-interval="10"/>
            <!-- omitted -->
        </batch:tasklet>
    </batch:step>
</batch:job>

@Configuration
@Import(JobBaseContextConfig.class)
@ComponentScan(value = {"org.terasoluna.batch.functionaltest.app.common",
    "org.terasoluna.batch.functionaltest.ch07.jobmanagement"}, scopedProxy = ScopedProxyMode.TARGET_CLASS)
@MapperScan(basePackages = "org.terasoluna.batch.functionaltest.app.repository.plan", sqlSessionFactoryRef = "jobSqlSessionFactory") // (1)
public class CustomizedJobExitCodeTaskletJobConfig {

    // (2)
    @Bean
    public MyBatisCursorItemReader<SalesPlanSummary> summarizeDetails(
            @Qualifier("jobSqlSessionFactory") SqlSessionFactory jobSqlSessionFactory) {
        return new MyBatisCursorItemReaderBuilder<SalesPlanSummary>()
                .sqlSessionFactory(jobSqlSessionFactory) // (4)
                .queryId(
                        "org.terasoluna.batch.functionaltest.app.repository.plan.SalesPlanDetailRepository.summarizeDetails") // (3)
                .build();
    }
    // omitted
    @Bean
    public Step step01(JobRepository jobRepository,
                       @Qualifier("jobTransactionManager") PlatformTransactionManager transactionManager,
                       CheckAmountTasklet tasklet) {
        return new StepBuilder("customizedJobExitCodeTaskletJob.step01",
                jobRepository)
                .tasklet(tasklet, transactionManager)
                .build();
    }

    @Bean
    public Job customizedJobExitCodeTaskletJob(JobRepository jobRepository,
                                                 Step step01,
                                                 JobExitCodeChangeListener jobExitCodeChangeListener) {
        return new JobBuilder("customizedJobExitCodeTaskletJob",
                jobRepository)
                .start(step01)
                .listener(jobExitCodeChangeListener)
                .build();
    }
    // omitted
}

<!-- (1) -->
<mybatis:scan
    base-package="jp.co.ntt.fw.macchinetta.batch.functionaltest.app.repository.plan"
    factory-ref="jobSqlSessionFactory"/>

<!-- (2) (3) (4) -->
<bean id="summarizeDetails" class="org.mybatis.spring.batch.MyBatisCursorItemReader"
          p:queryId="jp.co.ntt.fw.macchinetta.batch.functionaltest.app.repository.plan.SalesPlanDetailRepository.summarizeDetails"
          p:sqlSessionFactory-ref="jobSqlSessionFactory"/>

<batch:job id="customizedJobExitCodeTaskletJob" job-repository="jobRepository">
    <batch:step id="customizedJobExitCodeTaskletJob.step01">
        <batch:tasklet transaction-manager="jobTransactionManager" ref="checkAmountTasklet"/>
    </batch:step>
    <!-- omitted -->
</batch:job>

// omitted
// (2)
@Bean
@StepScope
public MyBatisCursorItemReader<SalesPerformanceSummary> reader(
        @Qualifier("jobSqlSessionFactory") SqlSessionFactory jobSqlSessionFactory,
        @Value("#{jobParameters['year']}") Integer year,
        @Value("#{jobParameters['month']}") Integer month,
        @Value("#{stepExecutionContext['dataSize']}") Integer dataSize,
        @Value("#{stepExecutionContext['offset']}") Integer offset) {
    Map<String, Object> parameterValues = new HashMap<>();
    parameterValues.put("year", year); // (4)
    parameterValues.put("month", month); // (4)
    // omitted
    return new MyBatisCursorItemReaderBuilder<SalesPerformanceSummary>()
            .sqlSessionFactory(jobSqlSessionFactory)
            .queryId(
                    "org.terasoluna.batch.functionaltest.ch08.parallelandmultiple.repository.SalesSummaryRepository.findByYearAndMonth")
            .parameterValues(parameterValues) // (3)
            .build();
}
// omited

<!-- omitted -->

<!-- (2) -->
<bean id="reader"
      class="org.mybatis.spring.batch.MyBatisCursorItemReader" scope="step"
      p:queryId="jp.co.ntt.fw.macchinetta.batch.functionaltest.ch08.parallelandmultiple.repository.SalesSummaryRepository.findByYearAndMonth"
      p:sqlSessionFactory-ref="jobSqlSessionFactory">
    <property name="parameterValues"> <!-- (3) -->
        <map>
            <!-- (4) -->
            <entry key="year" value="#{jobParameters['year']}" value-type="java.lang.Integer"/>
            <entry key="month" value="#{jobParameters['month']}" value-type="java.lang.Integer"/>

            <!-- omitted -->
        </map>
    </property>
</bean>

<!-- omitted -->

@Configuration
@Import(JobBaseContextConfig.class)
@ComponentScan({ "org.terasoluna.batch.functionaltest.app.common",
        "org.terasoluna.batch.functionaltest.ch05.dbaccess" })
@MapperScan(basePackages = {
        "org.terasoluna.batch.functionaltest.app.repository",
        "org.terasoluna.batch.functionaltest.ch05.dbaccess.repository" }, sqlSessionTemplateRef = "batchModeSqlSessionTemplate") // (3)
public class DBAccessByItemProcessorConfig {

    // (4)
    @Bean
    public MyBatisCursorItemReader<SalesPerformanceDetail> reader(
            @Qualifier("jobSqlSessionFactory") SqlSessionFactory jobSqlSessionFactory) {
        return new MyBatisCursorItemReaderBuilder<SalesPerformanceDetail>()
                .sqlSessionFactory(jobSqlSessionFactory)
                .queryId(
                        "org.terasoluna.batch.functionaltest.app.repository.performance.SalesPerformanceDetailRepository.findAll")
                .build();
    }
    // omitted

<!-- (3) -->
<mybatis:scan
base-package="org.terasoluna.batch.functionaltest.app.repository"
template-ref="batchModeSqlSessionTemplate"/>

<!-- (4) -->
<bean id="reader" class="org.mybatis.spring.batch.MyBatisCursorItemReader"
p:queryId="org.terasoluna.batch.functionaltest.app.repository.performance.SalesPerformanceDetailRepository.findAll"
p:sqlSessionFactory-ref="jobSqlSessionFactory"/>

<!-- omitted job definition -->

@Configuration
@Import(JobBaseContextConfig.class)
@ComponentScan({ "org.terasoluna.batch.functionaltest.app.common",
        "org.terasoluna.batch.functionaltest.ch05.dbaccess" })
@MapperScan(basePackages = {
        "org.terasoluna.batch.functionaltest.ch05.dbaccess.repository",
        "org.terasoluna.batch.functionaltest.app.repository" }, sqlSessionFactoryRef = "jobSqlSessionFactory") // (1)
public class JobSalesPlanCursorTaskletConfig {

    @Bean
    public Step step01(JobRepository jobRepository,
                       SalesPlanCursorTasklet tasklet,
                       @Qualifier("jobTransactionManager") PlatformTransactionManager transactionManager) {
        return new StepBuilder("jobSalesPlanCursorTasklet.step01",
                jobRepository)
                .tasklet(tasklet, transactionManager)
                .build();
    }

    @Bean
    public Job jobSalesPlanCursorTasklet(JobRepository jobRepository,
                                         Step step01) {
        return new JobBuilder("jobSalesPlanCursorTasklet", jobRepository)
                .start(step01)
                .build();
    }
}

<!-- (1) -->
<mybatis:scan
        base-package="jp.co.ntt.fw.macchinetta.batch.functionaltest.ch05.dbaccess.repository;jp.co.ntt.fw.macchinetta.batch.functionaltest.app.repository"
        factory-ref="jobSqlSessionFactory"/>

    <batch:job id="jobSalesPlanCursorTasklet" job-repository="jobRepository">
        <batch:step id="jobSalesPlanCursorTasklet.step01">
            <batch:tasklet transaction-manager="jobTransactionManager" ref="salesPlanCursorTasklet"/>
        </batch:step>
    </batch:job>

@Configuration
@Import(JobBaseContextConfig.class)
@ComponentScan("org.terasoluna.batch.functionaltest.app.common")
@MapperScan(basePackages = "org.terasoluna.batch.functionaltest.app.repository.performance",
                            sqlSessionFactoryRef = "jobSqlSessionFactory") // (1)
public class DBAccessByMaybatisScanConfig {
    // omitted
    // (2)
    @Bean
    public MyBatisBatchItemWriter<SalesPerformanceSummary> writer(
            @Qualifier("jobSqlSessionFactory") SqlSessionFactory jobSqlSessionFactory,
            SqlSessionTemplate batchModeSqlSessionTemplate) {
        return new MyBatisBatchItemWriterBuilder<SalesPerformanceSummary>()
                .sqlSessionFactory(jobSqlSessionFactory) // (4)
                .statementId(
                        "org.terasoluna.batch.functionaltest.app.repository.performance.SalesPerformanceSummaryRepository.create") // (3)
                .sqlSessionTemplate(batchModeSqlSessionTemplate)
                .build();
    }

    @Bean
    public Step step01(JobRepository jobRepository,
                       @Qualifier("jobTransactionManager") PlatformTransactionManager transactionManager,
                       ItemReader<SalesPerformanceSummary> reader,
                       ItemWriter<SalesPerformanceSummary> writer) {
        return new StepBuilder("DBAccessByMaybatisScan.step01",
                jobRepository)
                .<SalesPerformanceSummary, SalesPerformanceSummary> chunk(10, transactionManager)
                .reader(reader)
                .writer(writer) // (5)
                .build();
    }

    @Bean
    public Job DBAccessByMaybatisScan(JobRepository jobRepository,
                                            Step step01,
                                            JobExecutionLoggingListener listener) {
        return new JobBuilder("DBAccessByMaybatisScan",
                jobRepository).start(step01).listener(listener).build();
    }
}

<!-- (1) -->
<mybatis:scan base-package="jp.co.ntt.fw.macchinetta.batch.functionaltest.app.repository.performance"
                  factory-ref="jobSqlSessionFactory"/>

<!-- omitted -->

<!-- (2) (3) (4) -->
<bean id="writer" class="org.mybatis.spring.batch.MyBatisBatchItemWriter"
      p:statementId="jp.co.ntt.fw.macchinetta.batch.functionaltest.app.repository.performance.SalesPerformanceSummaryRepository.create"
      p:sqlSessionTemplate-ref="batchModeSqlSessionTemplate"/>

<batch:job id="DBAccessByMaybatisScan" job-repository="jobRepository">
    <batch:step id="DBAccessByMaybatisScan.step01">
        <batch:tasklet transaction-manager="jobTransactionManager">
            <batch:chunk reader="reader"
                         writer="writer" commit-interval="10"/> <!-- (5) -->
        </batch:tasklet>
    </batch:step>
    <!-- omitted -->
</batch:job>

@Configuration
@Import(JobBaseContextConfig.class)
@ComponentScan(value = {"org.terasoluna.batch.functionaltest.app.plan",
    "org.terasoluna.batch.functionaltest.ch04.listener"}, scopedProxy = ScopedProxyMode.TARGET_CLASS)
@MapperScan(basePackages = "org.terasoluna.batch.functionaltest.app.repository.plan", sqlSessionFactoryRef = "jobSqlSessionFactory") // (1)
public class TaskletJobWithListenerConfig {
    // omitted

    // (2)
    @Bean
    public MyBatisBatchItemWriter<SalesPlanDetail> writer(
            @Qualifier("jobSqlSessionFactory") SqlSessionFactory jobSqlSessionFactory,
            SqlSessionTemplate batchModeSqlSessionTemplate) {
        return new MyBatisBatchItemWriterBuilder<SalesPlanDetail>()
                .sqlSessionFactory(jobSqlSessionFactory) // (4)
                .statementId(
                        "org.terasoluna.batch.functionaltest.app.repository.plan.SalesPlanDetailRepository.create") // (3)
                .sqlSessionTemplate(batchModeSqlSessionTemplate)
                .build();
    }

    @Bean
    public Step jobScopeStep01(JobRepository jobRepository,
                       @Qualifier("jobTransactionManager") PlatformTransactionManager transactionManager,
                       SalesPlanDetailRegisterTasklet salesPlanDetailRegisterTasklet) {
        return new StepBuilder("taskletJobWithListenerWithinJobScope.step01",
                jobRepository)
                .tasklet(salesPlanDetailRegisterTasklet, transactionManager)
                .build();
    }

    @Bean
    public Job taskletJobWithListenerWithinJobScope(JobRepository jobRepository,
                                            Step jobScopeStep01,
                                            @Qualifier("allProcessListener") JobExecutionListener listener) {
        return new JobBuilder("taskletJobWithListenerWithinJobScope",
                jobRepository)
                .start(jobScopeStep01)
                .listener(listener)
                .build();
    }

    // omitted
}

<!-- (1) -->
<mybatis:scan base-package="jp.co.ntt.fw.macchinetta.batch.functionaltest.app.repository.plan"
            factory-ref="jobSqlSessionFactory"/>

<!-- (2) (3) (4) -->
<bean id="writer" class="org.mybatis.spring.batch.MyBatisBatchItemWriter"
          p:statementId="jp.co.ntt.fw.macchinetta.batch.functionaltest.app.repository.plan.SalesPlanDetailRepository.create"
          p:sqlSessionTemplate-ref="batchModeSqlSessionTemplate"/>

<batch:job id="taskletJobWithListenerWithinJobScope" job-repository="jobRepository">
    <batch:step id="taskletJobWithListenerWithinJobScope.step01">
        <batch:tasklet transaction-manager="jobTransactionManager" ref="salesPlanDetailRegisterTasklet"/>
    </batch:step>
    <!-- omitted. -->
</batch:job>

@Configuration
@Import(JobBaseContextConfig.class)
@ComponentScan(value = { "org.terasoluna.batch.functionaltest.app.common",
        "org.terasoluna.batch.functionaltest.ch05.exclusivecontrol"}, scopedProxy = ScopedProxyMode.TARGET_CLASS)
@MapperScan(basePackages = "org.terasoluna.batch.functionaltest.ch05.exclusivecontrol.repository", sqlSessionFactoryRef = "jobSqlSessionFactory") // (4)
public class TaskletOptimisticLockCheckJobConfig {

    @Bean
    public Step step01(JobRepository jobRepository,
                       @Qualifier("jobTransactionManager") PlatformTransactionManager transactionManager,
                       OptimisticLockTasklet optimisticLockTasklet) {
        return new StepBuilder("taskletOptimisticLockCheckJob.step01",
                jobRepository)
                .tasklet(optimisticLockTasklet, transactionManager) // (5)
                .build();
    }

    @Bean
    public Job taskletOptimisticLockCheckJob(JobRepository jobRepository,
                                            Step step01,
                                            JobExecutionLoggingListener listener) {
        return new JobBuilder("taskletOptimisticLockCheckJob",jobRepository)
                .start(step01)
                .listener(listener)
                .build();
    }
}

<!-- (4) -->
<mybatis:scan
        base-package="jp.co.ntt.fw.macchinetta.batch.functionaltest.ch05.exclusivecontrol.repository"
        factory-ref="jobSqlSessionFactory"/>

<batch:job id="taskletOptimisticLockCheckJob" job-repository="jobRepository">
    <batch:step id="taskletOptimisticLockCheckJob.step01">
        <batch:tasklet transaction-manager="jobTransactionManager"
                       ref="optimisticLockTasklet"> <!-- (5) -->
        </batch:tasklet>
    </batch:step>
</batch:job>