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批次處理內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！