Returning single or multiple response in loop operations?-CodePudding

In my Java app, I have the following service method that calls another method and accumulate responses. Then returns these responses as a list. If there is not any exception, it works properly. However, it is possible to encounter exception for one of the call in the loop. In that case, it cannot return the previous responses retrieved until exception (if there are 10 process in the loop and there is an exception for the 6th process, then it cannot return the previous 5 responses added to the response list).

public List<CommandResponse> process(final UUID uuid) {
    final Site site = siteRepository.findByUuid(uuid)
            .orElseThrow(() -> new EntityNotFoundException(SITE_ENTITY_NAME));

    // code omitted for brevity

    for (Type providerType : providerTypeList) {
        
        // operations
        
        responses.add(demoService.demoMethod());
    }
    return responses;
}

Under these conditions, I am wondering if I should use a try-catch mechanism or should I return response in the loop and finally return null. What would you suggest for this situations?

public CommandResponse operation(final UUID uuid) {
    final Site site = siteRepository.findByUuid(uuid)
            .orElseThrow(() -> new EntityNotFoundException(SITE_ENTITY_NAME));

    // code omitted for brevity

    for (Type providerType : providerTypeList) {
        
        // operations
        
        return demoService.demoMethod();
    }
    return null;
}

CodePudding user response：

Well, following the best practices the method demoMethod() should not throw exception, instead capture the exception and send it as response. This implies either CommandResponse can hold exception response. Following this the code looks as follows:

class CommandResponse<T>{ 
public T errorResponse();
public T successResponse();
public boolean isSucces();
}

And then later while rendering response you can handle failures/exceptions as per use case.

OR another way to handle this is having an interface Response with two implementations one for Success & another for failure. Thus making method process to return List<Response>.

CodePudding user response：

It all depends on the requirements, the contract between your process() method and its callers.

I can imagine two different styles of contract:

All Or Nothing: the caller needs the complete responses list, and can't sensibly proceed if some partial response is missing. I'd recommend to throw an exception in case of an error. Typically, this is the straightforward approach, and applies to many real-world situations (and the reason why the concept of exceptions was introduced).
Partial Results: the caller wants to get as much of the complete results list as currently possible (plus the information which parts are missing?). Return a data structure consisting of partial results plus error descriptions. This places an additional burden on the caller (extracting reults from a structure instead of directly getting them, having to explicitly deal with error messages etc.), so I'd only go that way if there is a convincing use case.

Both contracts can be valid. Only you know which one matches your situation. So, choose the right one, and document the decision.