最佳实践：Spring Boot后端和jQuery前端

Question

I'm currently working on a project with a Spring Boot 2 Backend and a jQuery Frontend. Thus the frontend sends Ajax request to spring REST controllers to operate with database entities.

When it comes to create entities with foreign linked entities via those ajax calls (eg creating a person with multiple addresses), I'm asking myself what the best practice would be, while considering transactional operations and reducing redundant code.

I've thought about these possibilities yet:

1. Several ajax calls Creating the linked entities with one ajax call per entity and check if they fail. If one fails, delete all the created entities with ajax calls for each, like a manual rollback. Seems like a very bad concept.

2. One Ajax call sending all parameters Having one ajax call sending all necessary parameters for the entities that have to be created. Then creating all the entities via the entity services server sided. But how to operate transactional here? And how to reduce redundant code?

Thanks in advance

Answer 1

First, I need to know which database you are using. If you are using MongoDB, then forget about the transactional part (unless you are using the version 4.0 and the transactional support). So I guess you go for an SQL database.

The answer to your question may depend on how the frontend treats the data. For me, the 1st option makes no sense anyway. It seems like you either want to include all the addresses or no addresses at all, so I will just make one request with all the addresses because the whole data is treated like an indivisible set.

The transaction part can be easily solved using Hibernate and the transaction manager (Just annotate the method which saves the addresses as @Transactional and that's all)

I would implement it like this:

The controller:

@RestController
@RequestMapping("/users")
public class UserController {

  @Autowired
  private UserService userService;

  @PostMapping("/{userId}/address")
  public List<Address> addAddress(@PathVariable String userId,
      @RequestBody AddressInsertRequest request){

    return userService.updateAddresses(userId, request.getAddresses());
  }

  //Externalize to oter class
  public class AddressInsertRequest {

    private List<Address> addresses;

    public List<Address> getAddresses() {
      return addresses;
    }

    public void setAddresses(List<Address> addresses) {
      this.addresses = addresses;
    }
  }
}

The service:

public class UserService {

  //TODO Implement with hibernate
  private UserRepository userRepository;

  @Transactional
  public List<Address> updateAddresses(String userId, List<Address> addressList){
    User user = userRepository.findById(userId);
    user.setAddressList(addressList);
    userRepository.save(user);
    return user.getAddressList();
  }
}

Answer 2

You're right to consider transactionality. As you already indicate option 1 is a bad approach as it requires manual rollbabck. Option 2 seems the most legit, but it requires your backend to handle the rollback. Which should be easy enough if a proper TransactionManager is configured.