Spring Batch批處理框架操作指南

簡介

Spring Batch 是 Spring 提供的一個數據處理框架。企業域中的許多應用程序需要批量處理才能在關鍵任務環境中執行業務操作。

這些業務運營包括：

• 無需用戶交互即可最有效地處理大量信息的自動化，復雜處理。這些操作通常包括基於時間的事件（例如月末計算，通知或通信）。

• 在非常大的數據集中重復處理復雜業務規則的定期應用（例如，保險利益確定或費率調整）。

• 集成從內部和外部系統接收的信息，這些信息通常需要以事務方式格式化，驗證和處理到記錄系統中。批處理用於每天為企業處理數十億的交易。

Spring Batch 是一個輕量級，全面的批處理框架，旨在開發對企業系統日常運營至關重要的強大批處理應用程序。

Spring Batch 構建瞭人們期望的 Spring Framework 特性（生產力，基於 POJO 的開發方法和一般易用性），同時使開發人員可以在必要時輕松訪問和利用更高級的企業服務。Spring Batch 不是一個 schuedling 的框架。

Spring Batch 提供瞭可重用的功能，這些功能對於處理大量的數據至關重要，包括記錄/跟蹤，事務管理，作業處理統計，作業重啟，跳過和資源管理。

它還提供更高級的技術服務和功能，通過優化和分區技術實現極高容量和高性能的批處理作業。

Spring Batch 可用於兩種簡單的用例（例如將文件讀入數據庫或運行存儲過程）以及復雜的大量用例（例如在數據庫之間移動大量數據，轉換它等等） 上）。大批量批處理作業可以高度可擴展的方式利用該框架來處理大量信息。

Spring Batch 架構

一個典型的批處理應用程序大致如下：

• 從數據庫，文件或隊列中讀取大量記錄。

• 以某種方式處理數據。

• 以修改之後的形式寫回數據。

其對應的示意圖如下：

Spring Batch 的一個總體的架構如下：

在 Spring Batch 中一個 job 可以定義很多的步驟 step，在每一個 step 裡面可以定義其專屬的 ItemReader 用於讀取數據。

ItemProcesseor 用於處理數據，ItemWriter 用於寫數據，而每一個定義的 job 則都在 JobRepository 裡面，我們可以通過 JobLauncher 來啟動某一個 job。

Spring Batch 核心概念

下面是一些概念是 Spring Batch 框架中的核心概念。

什麼是 Job

Job 和 Step 是 Spring Batch 執行批處理任務最為核心的兩個概念。

其中 Job 是一個封裝整個批處理過程的一個概念。Job 在 Spring Batch 的體系當中隻是一個最頂層的一個抽象概念，體現在代碼當中則它隻是一個最上層的接口。

其代碼如下：

/**
 * Batch domain object representing a job. Job is an explicit abstraction
 * representing the configuration of a job specified by a developer. It should
 * be noted that restart policy is applied to the job as a whole and not to a
 * step.
 */
public interface Job {
 String getName();
 boolean isRestartable();
 void execute(JobExecution execution);
 JobParametersIncrementer getJobParametersIncrementer();
 JobParametersValidator getJobParametersValidator();
}

在 Job 這個接口當中定義瞭五個方法，它的實現類主要有兩種類型的 job，一個是 simplejob，另一個是 flowjob。

在 Spring Batch 當中，job 是最頂層的抽象，除 job 之外我們還有 JobInstance 以及 JobExecution 這兩個更加底層的抽象。

一個 job 是我們運行的基本單位，它內部由 step 組成。job 本質上可以看成 step 的一個容器。

一個 job 可以按照指定的邏輯順序組合 step，並提供瞭我們給所有 step 設置相同屬性的方法，例如一些事件監聽，跳過策略。

Spring Batch 以 SimpleJob 類的形式提供瞭 Job 接口的默認簡單實現，它在 Job 之上創建瞭一些標準功能。

一個使用 java config 的例子代碼如下：

@Bean
public Job footballJob() {
    return this.jobBuilderFactory.get("footballJob")
                     .start(playerLoad())
                     .next(gameLoad())
                     .next(playerSummarization())
                     .end()
                     .build();
}

這個配置的意思是：首先給這個 job 起瞭一個名字叫 footballJob，接著指定瞭這個 job 的三個 step，他們分別由方法 playerLoad，gameLoad，playerSummarization 實現。

什麼是 JobInstance

我們在上文已經提到瞭 JobInstance，他是 Job 的更加底層的一個抽象，他的定義如下：

public interface JobInstance {
 /**
  * Get unique id for this JobInstance.
  * @return instance id
  */
 public long getInstanceId();
 /**
  * Get job name.
  * @return value of 'id' attribute from <job>
  */
 public String getJobName(); 
}

他的方法很簡單，一個是返回 Job 的 id，另一個是返回 Job 的名字。

JobInstance 指的是 job 運行當中，作業執行過程當中的概念。Instance 本就是實例的意思。

比如說現在有一個批處理的 job，它的功能是在一天結束時執行行一次。我們假定這個批處理 job 的名字為 'EndOfDay'。

在這個情況下，那麼每天就會有一個邏輯意義上的 JobInstance，而我們必須記錄 job 的每次運行的情況。

什麼是 JobParameters

在上文當中我們提到瞭，同一個 job 每天運行一次的話，那麼每天都有一個 jobIntsance，但他們的 job 定義都是一樣的，那麼我們怎麼來區別一個 job 的不同 jobinstance 瞭。

不妨先做個猜想，雖然 jobinstance 的 job 定義一樣，但是他們有的東西就不一樣，例如運行時間。

Spring Batch 中提供的用來標識一個 jobinstance 的東西是：JobParameters。

JobParameters 對象包含一組用於啟動批處理作業的參數，它可以在運行期間用於識別或甚至用作參考數據。我們假設的運行時間，就可以作為一個 JobParameters。

例如，我們前面的 'EndOfDay' 的 job 現在已經有瞭兩個實例，一個產生於 1 月 1 日，另一個產生於 1 月 2 日，那麼我們就可以定義兩個 JobParameter 對象：一個的參數是 01-01，, 另一個的參數是 01-02。

因此，識別一個 JobInstance 的方法可以定義為：

因此，我麼可以通過 Jobparameter 來操作正確的 JobInstance。

什麼是 JobExecution

JobExecution 指的是單次嘗試運行一個我們定義好的 Job 的代碼層面的概念。job 的一次執行可能以失敗也可能成功。隻有當執行成功完成時，給定的與執行相對應的 JobInstance 才也被視為完成。

還是以前面描述的 EndOfDay 的 job 作為示例，假設第一次運行 01-01-2019 的 JobInstance 結果是失敗。

那麼此時如果使用與第一次運行相同的 Jobparameter 參數（即 01-01-2019）作業參數再次運行，那麼就會創建一個對應於之前 jobInstance 的一個新的 JobExecution 實例，JobInstance 仍然隻有一個。

JobExecution 的接口定義如下：

public interface JobExecution {
 /**
  * Get unique id for this JobExecution.
  * @return execution id
  */
 public long getExecutionId();
 /**
  * Get job name.
  * @return value of 'id' attribute from <job>
  */
 public String getJobName(); 
 /**
  * Get batch status of this execution.
  * @return batch status value.
  */
 public BatchStatus getBatchStatus();
 /**
  * Get time execution entered STARTED status. 
  * @return date (time)
  */
 public Date getStartTime();
 /**
  * Get time execution entered end status: COMPLETED, STOPPED, FAILED 
  * @return date (time)
  */
 public Date getEndTime();
 /**
  * Get execution exit status.
  * @return exit status.
  */
 public String getExitStatus();
 /**
  * Get time execution was created.
  * @return date (time)
  */
 public Date getCreateTime();
 /**
  * Get time execution was last updated updated.
  * @return date (time)
  */
 public Date getLastUpdatedTime();
 /**
  * Get job parameters for this execution.
  * @return job parameters  
  */
 public Properties getJobParameters();

}

每一個方法的註釋已經解釋的很清楚，這裡不再多做解釋。隻提一下 BatchStatus，JobExecution 當中提供瞭一個方法 getBatchStatus 用於獲取一個 job 某一次特地執行的一個狀態。

BatchStatus 是一個代表 job 狀態的枚舉類，其定義如下：

public enum BatchStatus {STARTING, STARTED, STOPPING, 
   STOPPED, FAILED, COMPLETED, ABANDONED }

這些屬性對於一個 job 的執行來說是非常關鍵的信息，並且 Spring Batch 會將他們持久到數據庫當中。

在使用 Spring Batch 的過程當中 Spring Batch 會自動創建一些表用於存儲一些 job 相關的信息，用於存儲 JobExecution 的表為 batch_job_execution。

下面是一個從數據庫當中截圖的實例：

什麼是 Step

每一個 Step 對象都封裝瞭批處理作業的一個獨立的階段。事實上，每一個 Job 本質上都是由一個或多個步驟組成。每一個 step 包含定義和控制實際批處理所需的所有信息。

任何特定的內容都由編寫 Job 的開發人員自行決定。一個 step 可以非常簡單也可以非常復雜。

例如，一個 step 的功能是將文件中的數據加載到數據庫中，那麼基於現在 Spring Batch 的支持則幾乎不需要寫代碼。更復雜的 step 可能具有復雜的業務邏輯，這些邏輯作為處理的一部分。

與 Job 一樣，Step 具有與 JobExecution 類似的 StepExecution，如下圖所示：

什麼是 StepExecution

StepExecution 表示一次執行 Step，每次運行一個 Step 時都會創建一個新的 StepExecution，類似於 JobExecution。

但是，某個步驟可能由於其之前的步驟失敗而無法執行。且僅當 Step 實際啟動時才會創建 StepExecution。

一次 step 執行的實例由 StepExecution 類的對象表示。每個 StepExecution 都包含對其相應步驟的引用以及 JobExecution 和事務相關的數據，例如提交和回滾計數以及開始和結束時間。

此外，每個步驟執行都包含一個 ExecutionContext，其中包含開發人員需要在批處理運行中保留的任何數據，例如重新啟動所需的統計信息或狀態信息。

下面是一個從數據庫當中截圖的實例：

什麼是 ExecutionContext

ExecutionContext 即每一個 StepExecution 的執行環境。它包含一系列的鍵值對。

我們可以用如下代碼獲取 ExecutionContext：

ExecutionContext ecStep = stepExecution.getExecutionContext();
ExecutionContext ecJob = jobExecution.getExecutionContext();

什麼是 JobRepository

JobRepository 是一個用於將上述 job，step 等概念進行持久化的一個類。它同時給 Job 和 Step 以及下文會提到的 JobLauncher 實現提供 CRUD 操作。

首次啟動 Job 時，將從 repository 中獲取 JobExecution，並且在執行批處理的過程中，StepExecution 和 JobExecution 將被存儲到 repository 當中。

@EnableBatchProcessing 註解可以為 JobRepository 提供自動配置。

什麼是 JobLauncher

JobLauncher 這個接口的功能非常簡單，它是用於啟動指定瞭 JobParameters 的 Job，為什麼這裡要強調指定瞭 JobParameter，原因其實我們在前面已經提到瞭，jobparameter 和 job 一起才能組成一次 job 的執行。

下面是代碼實例：

public interface JobLauncher {
public JobExecution run(Job job, JobParameters jobParameters)
            throws JobExecutionAlreadyRunningException, JobRestartException,
                   JobInstanceAlreadyCompleteException, JobParametersInvalidException;
}

上面 run 方法實現的功能是根據傳入的 job 以及 jobparamaters 從 JobRepository 獲取一個 JobExecution 並執行 Job。

什麼是 Item Reader

ItemReader 是一個讀數據的抽象，它的功能是為每一個 Step 提供數據輸入。當 ItemReader 以及讀完所有數據時，它會返回 null 來告訴後續操作數據已經讀完。

Spring Batch 為 ItemReader 提供瞭非常多的有用的實現類，比如 JdbcPagingItemReader，JdbcCursorItemReader 等等。

ItemReader 支持的讀入的數據源也是非常豐富的，包括各種類型的數據庫，文件，數據流，等等。幾乎涵蓋瞭我們的所有場景。

下面是一個 JdbcPagingItemReader 的例子代碼：

@Bean
public JdbcPagingItemReader itemReader(DataSource dataSource, PagingQueryProvider queryProvider) {
        Map<String, Object> parameterValues = new HashMap<>();
        parameterValues.put("status", "NEW");

        return new JdbcPagingItemReaderBuilder<CustomerCredit>()
               .name("creditReader")
               .dataSource(dataSource)
               .queryProvider(queryProvider)
               .parameterValues(parameterValues)
               .rowMapper(customerCreditMapper())
               .pageSize(1000)
               .build();
}

@Bean
public SqlPagingQueryProviderFactoryBean queryProvider() {
        SqlPagingQueryProviderFactoryBean provider = new SqlPagingQueryProviderFactoryBean();

        provider.setSelectClause("select id, name, credit");
        provider.setFromClause("from customer");
        provider.setWhereClause("where status=:status");
        provider.setSortKey("id");

        return provider;
}

JdbcPagingItemReader 必須指定一個 PagingQueryProvider，負責提供 SQL 查詢語句來按分頁返回數據。

下面是一個 JdbcCursorItemReader 的例子代碼：

private JdbcCursorItemReader<Map<String, Object>> buildItemReader(final DataSource dataSource, String tableName,
            String tenant) {

        JdbcCursorItemReader<Map<String, Object>> itemReader = new JdbcCursorItemReader<>();
        itemReader.setDataSource(dataSource);
        itemReader.setSql("sql here");
        itemReader.setRowMapper(new RowMapper());
        return itemReader;
    }

什麼是 Item Writer

既然 ItemReader 是讀數據的一個抽象，那麼 ItemWriter 自然就是一個寫數據的抽象，它是為每一個 step 提供數據寫出的功能。

寫的單位是可以配置的，我們可以一次寫一條數據，也可以一次寫一個 chunk 的數據，關於 chunk 下文會有專門的介紹。ItemWriter 對於讀入的數據是不能做任何操作的。

Spring Batch 為 ItemWriter 也提供瞭非常多的有用的實現類，當然我們也可以去實現自己的 writer 功能。

什麼是 Item Processor

ItemProcessor 對項目的業務邏輯處理的一個抽象，當 ItemReader 讀取到一條記錄之後，ItemWriter 還未寫入這條記錄之前，I 我們可以借助 temProcessor 提供一個處理業務邏輯的功能，並對數據進行相應操作。

如果我們在 ItemProcessor 發現一條數據不應該被寫入，可以通過返回 null 來表示。

ItemProcessor 和 ItemReader 以及 ItemWriter 可以非常好的結合在一起工作，他們之間的數據傳輸也非常方便。我們直接使用即可。

chunk 處理流程

Spring Batch 提供瞭讓我們按照 chunk 處理數據的能力，一個 chunk 的示意圖如下：

它的意思就和圖示的一樣，由於我們一次batch的任務可能會有很多的數據讀寫操作，因此一條一條的處理並向數據庫提交的話效率不會很高。

因此 Spring Batch 提供瞭 chunk 這個概念，我們可以設定一個 chunk size，spring batch 將一條一條處理數據，但不提交到數據庫，隻有當處理的數據數量達到 chunk size 設定的值得時候，才一起去 commit。

java 的實例定義代碼如下：

在上面這個 step 裡面，chunk size 被設為瞭 10，當 ItemReader 讀的數據數量達到 10 的時候，這一批次的數據就一起被傳到 itemWriter，同時 transaction 被提交。

skip 策略和失敗處理

一個 batch 的 job 的 step，可能會處理非常大數量的數據，難免會遇到出錯的情況，出錯的情況雖出現的概率較小，但是我們不得不考慮這些情況，因為我們做數據遷移最重要的是要保證數據的最終一致性。

Spring Batch 當然也考慮到瞭這種情況，並且為我們提供瞭相關的技術支持，請看如下 bean 的配置：

我們需要留意這三個方法，分別是 skipLimit()，skip()，noSkip()。

skipLimit 方法的意思是我們可以設定一個我們允許的這個 step 可以跳過的異常數量，假如我們設定為 10，則當這個 step 運行時，隻要出現的異常數目不超過 10，整個 step 都不會 fail。

註意，若不設定 skipLimit，則其默認值是 0。

skip 方法我們可以指定我們可以跳過的異常，因為有些異常的出現，我們是可以忽略的。

noSkip 方法的意思則是指出現這個異常我們不想跳過，也就是從 skip 的所以 exception 當中排除這個 exception。

從上面的例子來說，也就是跳過所有除 FileNotFoundException 的 exception。

那麼對於這個 step 來說，FileNotFoundException 就是一個 fatal 的 exception，拋出這個 exception 的時候 step 就會直接 fail。

批處理操作指南

本部分是一些使用 Spring Batch 時的值得註意的點。

批處理原則

在構建批處理解決方案時，應考慮以下關鍵原則和註意事項：

• 批處理體系結構通常會影響體系結構

• 盡可能簡化並避免在單批應用程序中構建復雜的邏輯結構

• 保持數據的處理和存儲在物理上靠得很近（換句話說，將數據保存在處理過程中）。

• 最大限度地減少系統資源的使用，尤其是 I/O。在 internal memory 中執行盡可能多的操作。

• 查看應用程序 I/O（分析 SQL 語句）以確保避免不必要的物理 I/O。特別是，需要尋找以下四個常見缺陷：當數據可以被讀取一次並緩存或保存在工作存儲中時，讀取每個事務的數據；重新讀取先前在同一事務中讀取數據的事務的數據；導致不必要的表或索引掃描；未在 SQL 語句的 WHERE 子句中指定鍵值。

• 在批處理運行中不要做兩次一樣的事情。例如，如果需要數據匯總以用於報告目的，則應該（如果可能）在最初處理數據時遞增存儲的總計，因此您的報告應用程序不必重新處理相同的數據。

• 在批處理應用程序開始時分配足夠的內存，以避免在此過程中進行耗時的重新分配。

• 總是假設數據完整性最差。插入適當的檢查和記錄驗證以維護數據完整性。

• 盡可能實施校驗和以進行內部驗證。例如，對於一個文件裡的數據應該有一個數據條數紀錄，告訴文件中的記錄總數以及關鍵字段的匯總。

• 在具有真實數據量的類似生產環境中盡早計劃和執行壓力測試。

• 在大批量系統中，數據備份可能具有挑戰性，特別是如果系統以 24-7 在線的情況運行。數據庫備份通常在在線設計中得到很好的處理，但文件備份應該被視為同樣重要。如果系統依賴於文件，則文件備份過程不僅應該到位並記錄在案，還應定期進行測試。

如何默認不啟動 job

在使用 java config 使用 Spring Batch 的 job 時，如果不做任何配置，項目在啟動時就會默認去跑我們定義好的批處理 job。那麼如何讓項目在啟動時不自動去跑 job 呢？

Spring Batch 的 job 會在項目啟動時自動 run，如果我們不想讓他在啟動時 run 的話，可以在 application.properties 中添加如下屬性：

spring.batch.job.enabled=false

在讀數據時內存不夠

在使用 Spring Batch 做數據遷移時，發現在 job 啟動後，執行到一定時間點時就卡在一個地方不動瞭，且 log 也不再打印，等待一段時間之後，得到如下錯誤：

紅字的信息為：Resource exhaustion event：the JVM was unable to allocate memory from the heap.

翻譯過來的意思就是項目發出瞭一個資源耗盡的事件，告訴我們 java 虛擬機無法再為堆分配內存。

造成這個錯誤的原因是：這個項目裡的 batch job 的 reader 是一次性拿回瞭數據庫裡的所有數據，並沒有進行分頁，當這個數據量太大時，就會導致內存不夠用。

解決的辦法有兩個：

• 調整 reader 讀數據邏輯，按分頁讀取，但實現上會麻煩一些，且運行效率會下降

• 增大 service 內存

到此這篇關於Spring Batch批處理框架操作指南的文章就介紹到這瞭,更多相關Spring Batch批處理內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：

• Spring Batch輕量級批處理框架實戰
• Spring Batch 如何自定義ItemReader
• Spring Batch 入門示例
• SpringBoot+SpringBatch+Quartz整合定時批量任務方式
• SpringBatch跳過異常和限制方式