public Optional<Customer> deleteCustomer(Customer customer) {
    Customer customerToDelete = customerRepoMap.get(customer.getEmail());
    if (customerToDelete != null && customerToDelete.getId() == customer.getId()) {
        customerRepoMap.remove(customer.getEmail());
    }

   return Optional.ofNullable(customerToDelete);
}

3.3. 實現第二個 Spring 服務

我們還將實現另一個服務，用於從倉庫中檢索和創建地址數據。

首先，我們定義 Address 類：

public class Address implements Serializable {
    private int id;
    private String street;
    private String city;
    //標準 getter 和 setter
}

然後，我們實現 AddressService 類，並提供一個 createAddress() 方法：

public Address createAddress(Address address) {
    Address createdAddress = null;
    String addressUniqueKey = address.getStreet().concat(address.getCity());
    if (!addressRepoMap.containsKey(addressUniqueKey)) {
        createdAddress = new Address(addressRepoMap.size() + 1, 
          address.getStreet(), address.getCity());
        addressRepoMap.put(addressUniqueKey, createdAddress);
    }
    return createdAddress;
}

4. 實現使用現有端點的批量 API

現在，讓我們創建一個 API 以支持批量和單件創建操作。

4.1. 實現批量控制器

我們將實現一個 BulkController 類，其中包含一個用於創建單個或多個客户的端點。

首先，我們將批量請求表示為 JSON 格式：

[
    {
        "name": "<name>",
        "email": "<email>",
        "address": "<address>"
    }
]

通過這種方法，我們可以使用自定義 HTTP 標頭 – X-ActionType – 來處理批量操作，以區分批量或單件操作。

然後，我們將實現 bulkCreateCustomers() 方法在 BulkController 類中，並使用上述 CustomerService 的方法：

@PostMapping(path = "/customers/bulk")
public ResponseEntity<List<Customer>> bulkCreateCustomers(
  @RequestHeader(value="X-ActionType") String actionType, 
  @RequestBody @Valid @Size(min = 1, max = 20) List<Customer> customers) {
    List<Customer> customerList = actionType.equals("bulk") ? 
      customerService.createCustomers(customers) :
      singletonList(customerService.createCustomer(customers.get(0)).orElse(null));

    return new ResponseEntity<>(customerList, HttpStatus.CREATED);
}

在上述代碼中，我們正在使用 X-ActionType 標頭來接受任何批量請求。 此外，我們添加了使用 @Size 註解的輸入請求大小驗證。 代碼決定是否將整個列表傳遞給 createCustomers() 或僅將元素 0 傳遞給 createCustomer()。

不同的創建函數返回一個列表或單個 Optional，因此我們將後者轉換為 List 以使 HTTP 響應在兩種情況下都相同。

4.2. 驗證批量 API

我們將運行應用程序並通過執行上述端點來驗證批量操作：

$ curl -i --request POST 'http://localhost:8080/api/customers/bulk' \
--header 'X-ActionType: bulk' \
--header 'Content-Type: application/json' \
--data-raw '[
    {
        "name": "test1",
        "email": "[email protected]",
        "address": "address1"
    },
    {
        "name": "test2",
        "email": "[email protected]",
        "address": "address2"
    }
]'

我們將獲得一個成功的響應，其中客户已創建：

HTTP/1.1 201 
[{"id":1,"name":"test1","email":"[email protected]","address":"address1"},
{"id":1,"name":"test2","email":"[email protected]","address":"address2"},
...

接下來，我們將實現批量操作的另一種方法。

5. Implement a Bulk API Using a Different Endpoint

It’s not that common to have different actions on the same resource in a bulk API. However, let’s look at the most flexible approach possible to see how it can be done.

We might implement an atomic bulk operation, where the whole request succeeds or fails within a single transaction. Or, we can allow the updates that succeed to happen independently of those that fail, with a response that indicates whether it was a full or partial success. We’ll implement the second of these.

5.1. Define the Request and Response Model

Let’s consider a use case of creating, updating, and deleting multiple customers in a single call.

We’ll define the bulk request as a JSON format:

[
    {
        "bulkActionType": "<CREATE OR UPDATE OR DELETE>",
        "customers": [
            {
                "name": "<name>",
                "email": "<email>",
                "address": "<address>"
            }
        ]
    }
]

First, we’ll model the above JSON format into the CustomerBulkRequest class:

public class CustomerBulkRequest {
    private BulkActionType bulkActionType;
    private List<Customer> customers;
    //standard getters and setters
}

Next, we’ll implement the BulkActionType enum:

public enum BulkActionType {
    CREATE, UPDATE, DELETE
}

Then, let’s define the CustomerBulkResponse class as the HTTP response object:

public class CustomerBulkResponse {
    private BulkActionType bulkActionType;
    private List<Customer> customers;
    private BulkStatus status;
    //standard getters and setters
}

Finally, we’ll define the BulkStatus enum to specify each operation’s return status:

public enum BulkStatus {
    PROCESSED, PARTIALLY_PROCESSED, NOT_PROCESSED
}

5.2. Implement the Bulk Controller

We’ll implement a bulk API that takes the bulk requests and processes based on the bulkActionType enum and then returns the bulk status and customer data together.

First, we’ll create an EnumMap in the BulkController class and map the BulkActionType enum to its own CustomerService’s Function:

@RestController
@RequestMapping("/api")
@Validated
public class BulkController {
    private final CustomerService customerService;
    private final EnumMap<BulkActionType, Function<Customer, Optional<Customer>>> bulkActionFuncMap = 
      new EnumMap<>(BulkActionType.class);

    public BulkController(CustomerService customerService) {
        this.customerService = customerService;
        bulkActionFuncMap.put(BulkActionType.CREATE, customerService::createCustomer);
        bulkActionFuncMap.put(BulkActionType.UPDATE, customerService::updateCustomer);
        bulkActionFuncMap.put(BulkActionType.DELETE, customerService::deleteCustomer);
    }
}

This EnumMap provides a binding between the request type and the method on the CustomerService that we need to satisfy it. It helps us avoid lengthy switch or if statements.

We can pass the Function returned from the EnumMap against the action type to the map() method on a stream of Customer objects:

List<Customer> customers = customerBulkRequest.getCustomers().stream()
   .map(bulkActionFuncMap.get(customerBulkRequest.getBulkActionType()))
   ...

As all our Function objects map from Customer to Optional<Customer>, this essentially uses the map() operation in the stream to execute the bulk request, leaving the resulting Customer in the stream (if available).

Let’s put this together in the full controller method:

@PostMapping(path = "/customers/bulk")
public ResponseEntity<List<CustomerBulkResponse>> bulkProcessCustomers(
  @RequestBody @Valid @Size(min = 1, max = 20) 
  List<CustomerBulkRequest> customerBulkRequests) {
    List<CustomerBulkResponse> customerBulkResponseList = new ArrayList<>();

    customerBulkRequests.forEach(customerBulkRequest -> {
        List<Customer> customers = customerBulkRequest.getCustomers().stream()
          .map(bulkActionFuncMap.get(customerBulkRequest.getBulkActionType()))
          .filter(Optional::isPresent)
          .map(Optional::get)
          .collect(toList());
        
        BulkStatus bulkStatus = getBulkStatus(customerBulkRequest.getCustomers(), 
          customers);     
        customerBulkResponseList.add(CustomerBulkResponse.getCustomerBulkResponse(customers, 
          customerbulkRequest.getBulkActionType(), bulkStatus));
    });

    return new ResponseEntity<>(customerBulkResponseList, HttpStatus.Multi_Status);
}

Also, we’ll complete the getBulkStatus method to return a specific bulkStatus enum based on the number of customers created:

private BulkStatus getBulkStatus(List<Customer> customersInRequest, 
  List<Customer> customersProcessed) {
    if (!customersProcessed.isEmpty()) {
        return customersProcessed.size() == customersInRequest.size() ?
          BulkStatus.PROCESSED : 
          BulkStatus.PARTIALLY_PROCESSED;
    }

    return BulkStatus.NOT_PROCESSED;
}

We should note that adding the input validations for any conflicts between each operation can also be considered.

$ curl -i --request POST 'http://localhost:8080/api/customers/bulk' \
--header 'Content-Type: application/json' \
--data-raw '[
    {
        "bulkActionType": "CREATE",
        "customers": [
            {
                "name": "test4",
                "email": "[email protected]",
                ...
            }
        ]
    },
    {
        "bulkActionType": "UPDATE",
        "customers": [
            ...
        ]
    },
    {
        "bulkActionType": "DELETE",
        "customers": [
            ...
        ]
    }
]

HTTP/1.1 207 
[{"customers":[{"id":4,"name":"test4","email":"[email protected]","address":"address4"}],"status":"PROCESSED","bulkType":"CREATE"},
...
]

[
    {
        "method": "POST",
        "relativeUrl": "/address",
        "data": {
            "street": "<street>",
            "city": "<city>"
        }
    },
    {
        "method": "PATCH",
        "relativeUrl": "/customer",
        "data": {
            "id": "<id>",
            "name": "<name>",
            "email": "<email>",
            "address": "<address>"
        }
    }
]

public class BatchRequest {
    private HttpMethod method;
    private String relativeUrl;
    private JsonNode data;
    //standard getters and setters
}

@PostMapping(path = "/batch")
public String batchUpdateCustomerWithAddress(
  @RequestBody @Valid @Size(min = 1, max = 20) List<BatchRequest> batchRequests) {
    batchRequests.forEach(batchRequest -> {
        if (batchRequest.getMethod().equals(HttpMethod.POST) &&
          batchRequest.getRelativeUrl().equals("/address")) {
            addressService.createAddress(objectMapper.convertValue(batchRequest.getData(), 
              Address.class));
        } else if (batchRequest.getMethod().equals(HttpMethod.PATCH) &&
            batchRequest.getRelativeUrl().equals("/customer")) {
            customerService.updateCustomer(objectMapper.convertValue(batchRequest.getData(), 
              Customer.class));
        }
    });

    return "Batch update is processed";
}

$ curl -i --request POST 'http://localhost:8080/api/batch' \
--header 'Content-Type: application/json' \
--data-raw '[
    {
        "method": "POST",
        "relativeUrl": "/address",
        "data": {
            "street": "test1",
            "city": "test"
        }
    },
    {
        "method": "PATCH",
        "relativeUrl": "/customer",
        "data": {
            "id": "1",
            "name": "test1",
            "email": "[email protected]",
            "address": "address2"
        }
    }
]'

HTTP/1.1 200
Batch update is processed