How to design "delete user flow" in monolith application with Spring Boot? - spring

Question

I have a monolith spring boot application and I have a user for the program. I want to make an endpoint to delete user, but my problem is there are so many entities and Jpa repository interfaces related to the user. When I want to delete a user, I need to inject so many repository interface into the related deletion service like:
#Service
public class DeletionService {
private static final int S3_DELETION_KEY_LIMIT = 1000;
private final OfficeRepository officeRepository;
private final AdvertRepository advertRepository;
private final UserRepository userRepository;
private final AdvertSearchRepository advertSearchRepository;
private final AdvertPricesRepository advertPricesRepository;
private final AdvertFacilityRepository advertFacilityRepository;
private final AdvertVirtualPackagesRepository advertVirtualPackagesRepository;
private final BookingRepository bookingRepository;
private final AdvertMediasRepository advertMediasRepository;
private final MediaRepository mediaRepository;
private final AmazonS3Service amazonS3Service;
private final OfficeBuildingSecurityRepository officeBuildingSecurityRepository;
private final OfficeCyberSecurityRepository officeCyberSecurityRepository;
private final OfficeFacilityRepository officeFacilityRepository;
private final OfficeMediasRepository officeMediasRepository;
private final OfficeNotificationsRepository officeNotificationsRepository;
private final OfficePropertiesRepository officePropertiesRepository;
private final OfficeRoomsRepository officeRoomsRepository;
private final OfficeViewsRepository officeViewsRepository;
private final OwnerCompanyRepository ownerCompanyRepository;
private final PushNotificationTokenRepository pushNotificationTokenRepository;
... and so many other repositories and
//CONSTRUCTOR etc.
Everything in the program is related to the user and If I delete the user then everything goes off. I am not sure it is correct style or flow, how can I do this with a better approach if there is any other option in monolith app? Do I have to inject all related repository interfaces into the current service ?
Note: I am not using any queue service like Kafka, Sqs, RabbitMq etc.

Answer 1

That does not really matter what is you architecture, monolithic or microservices - patterns remain the same.
Basic idea: decompose that large delete operation into individual steps, for example:
public interface DeleteStep<E> {
void delete(E entity);
}
#Component
public class DeleteFiles implements DeleteStep<User> {
#Autowired
AmazonS3Service amazonS3Service
#Override
public void delete(User user) {
amazonS3Service.deleteUserFiles(user);
}
}
#Component
public class DeleteNotifications implements DeleteStep<User> {
#Autowired
OfficeNotificationsRepository officeNotificationsRepository;
#Override
public void delete(DmUser user) {
officeNotificationsRepository.deleteUserNotifications(user);
}
}
Now the body of our DeletionService would look like:
#Autowired
ObjectProvider<DeleteStep<User>> userDeletionSteps;
public void deleteUser(User user) {
userDeletionSteps.forEach(s -> s.delete(user));
}
Now we may actually improve that basic idea via taking advantage of application events, for example:
public class UserDeleteEvent {
private final User user;
public UserDeleteEvent(User user) {
this.user = user;
}
public User getUser() {
return user;
}
}
interface OfficeNotificationsRepository extends ... {
#EventListener(UserDeleteEvent.class)
default void onUserDeleted(UserDeleteEvent event) {
deleteUserNotifications(event.getUser());
}
}
class AmazonS3Service ... {
#EventListener(UserDeleteEvent.class)
void onUserDeleted(UserDeleteEvent event) {
deteteUserFiles(event.getUser());
}
}
and now our DeletionService turns into:
#Autowired
ApplicationEventPublisher eventPublisher;
public void deleteUser(User user) {
eventPublisher.publishEvent(new UserDeleteEvent(user));
}
Moreover, we may take advantage of #DomainEvents and get rid of DeletionService - UserRepository may dispatch application events.