Het implementeren van het Chain of Responsibility-ontwerppatroon in je REST API voor beheer van gebruikersaccounts en profielen is een goede aanpak om verschillende verwerkingen flexibel en losgekoppeld te organiseren. Hieronder beschrijf ik hoe je je eindpunten kunt structureren en de stroom van verzoeken door de keten kunt beheren, inclusief voorbeeld-classes en endpoint-configuraties. 1. Structuur van de eindpunten - Gebruik een enkele basis-URL, bijvoorbeeld `/api/users` of `/api/profiles`. - Definieer verschillende HTTP-methoden en paden voor specifieke acties, zoals: - `POST /api/users` voor het aanmaken van een gebruiker. - `PUT /api/users/{id}` voor het bijwerken. - `GET /api/users/{id}` voor het ophalen. - `DELETE /api/users/{id}` voor het verwijderen. - Voor complexe bewerkingen of validaties kun je een algemene endpoint gebruiken, bijvoorbeeld `/api/users/operation`, die het verzoek door de keten laat lopen. 2. Beheer van de stroom van verzoeken door de keten - Elke handler vertegenwoordigt een specifiek aspect van verwerking, zoals validatie, authenticatie, autorisatie, logging, of specifieke bedrijfsregels. - Wanneer een verzoek binnenkomt, wordt het doorgegeven aan de eerste handler in de keten. - Elke handler beslist of hij het verzoek verder doorgeeft of afhandelt (bijvoorbeeld door een foutmelding te retourneren of door te gaan). - De keten wordt doorgaans opgezet bij de start van de applicatie, bijvoorbeeld via dependency injection of configuratie. 3. Voorbeeld van handler-classes ```java // Abstract Handler public abstract class UserRequestHandler { protected UserRequestHandler next; public UserRequestHandler linkWith(UserRequestHandler next) { this.next = next; return next; } public void handle(RequestContext context) { if (process(context) && next != null) { next.handle(context); } } protected abstract boolean process(RequestContext context); } // Validatie Handler public class ValidationHandler extends UserRequestHandler { @Override protected boolean process(RequestContext context) { // Validatie logica if (context.getRequest().getBody() == null) { // Fout afhandelen context.setResponse(new ErrorResponse("Geen gegevens ontvangen.")); return false; // Stop keten } return true; // Doorgaan } } // Authenticatie Handler public class AuthenticationHandler extends UserRequestHandler { @Override protected boolean process(RequestContext context) { // Authenticatie logica if (!context.getHeaders().containsKey("Authorization")) { context.setResponse(new ErrorResponse("Authenticatie vereist.")); return false; } // Authenticatie geslaagd return true; } } // Bedrijfsregel Handler public class BusinessRuleHandler extends UserRequestHandler { @Override protected boolean process(RequestContext context) { // Specifieke bedrijfsregels // Bijvoorbeeld: controle of gebruikersnaam al bestaat return true; } } ``` 4. Voorbeeld van endpoint-configuratie en gebruik ```java // In je controller of endpoint handler @PostMapping("/api/users") public ResponseEntity<?> createUser(@RequestBody UserRequest request, @RequestHeader Map<String, String> headers) { // Opzetten van de keten UserRequestHandler validation = new ValidationHandler(); UserRequestHandler auth = new AuthenticationHandler(); UserRequestHandler businessRules = new BusinessRuleHandler(); validation.linkWith(auth).linkWith(businessRules); // Context met request en headers RequestContext context = new RequestContext(request, headers); // Verwerken door de keten validation.handle(context); // Controleer resultaat if (context.getResponse() != null && context.getResponse() instanceof ErrorResponse) { return ResponseEntity.badRequest().body(context.getResponse()); } // Als alles goed gaat, voer de daadwerkelijke creatie uit User createdUser = userService.createUser(request); return ResponseEntity.ok(createdUser); } ``` 5. Samenvatting - Structuur je API met consistente eindpunten en gebruik één of meerdere eindpunten om verzoeken door de keten te sturen. - Bouw een keten van handlers die elke een specifiek aspect afhandelen. - Verwerk het verzoek door de keten in je controller/endpoints. - Zorg dat elke handler beslissen of het verzoek verder gaat of wordt afgehandeld. Zo krijg je een flexibele, uitbreidbare en goed gestructureerde manier om verschillende verwerkingsstappen te beheren, zonder dat de verzoekverzender strak gekoppeld is aan de handlers.

Zeker, ik zal je helpen het Chain of Responsibility-patroon te implementeren voor je REST API voor gebruikersaccountbeheer. Hier is een complete uitwerking: ## Basisstructuur ### 1. Handler Interface ```java public interface UserRequestHandler { void setNextHandler(UserRequestHandler nextHandler); boolean handle(UserRequest request); } ``` ### 2. Abstracte Basis Handler ```java public abstract class AbstractUserHandler implements UserRequestHandler { private UserRequestHandler nextHandler; @Override public void setNextHandler(UserRequestHandler nextHandler) { this.nextHandler = nextHandler; } protected boolean passToNext(UserRequest request) { if (nextHandler != null) { return nextHandler.handle(request); } return true; // Einde keten bereikt } } ``` ## Concrete Handlers ### 3. Authenticatie Handler ```java @Component public class AuthenticationHandler extends AbstractUserHandler { @Override public boolean handle(UserRequest request) { if (request.getAuthToken() == null || request.getAuthToken().isEmpty()) { request.setResponse(new ErrorResponse("Authenticatie vereist", 401)); return false; } // Valideer token (vereenvoudigd) User user = validateToken(request.getAuthToken()); if (user == null) { request.setResponse(new ErrorResponse("Ongeldig token", 401)); return false; } request.setAuthenticatedUser(user); return passToNext(request); } private User validateToken(String token) { // Token validatie logica return userRepository.findByToken(token); } } ``` ### 4. Autorizatie Handler ```java @Component public class AuthorizationHandler extends AbstractUserHandler { @Override public boolean handle(UserRequest request) { User user = request.getAuthenticatedUser(); String requiredRole = getRequiredRole(request.getOperation()); if (!user.hasRole(requiredRole)) { request.setResponse(new ErrorResponse("Onvoldoende rechten", 403)); return false; } return passToNext(request); } private String getRequiredRole(String operation) { return switch (operation) { case "DELETE_USER", "UPDATE_USER_ROLE" -> "ADMIN"; case "UPDATE_PROFILE" -> "USER"; default -> "GUEST"; }; } } ``` ### 5. Validatie Handler ```java @Component public class ValidationHandler extends AbstractUserHandler { @Override public boolean handle(UserRequest request) { if (request.getOperation().equals("CREATE_USER")) { if (!isValidUserData(request.getUserData())) { request.setResponse(new ErrorResponse("Ongeldige gebruikersdata", 400)); return false; } } if (request.getOperation().equals("UPDATE_PROFILE")) { if (!isValidProfileData(request.getProfileData())) { request.setResponse(new ErrorResponse("Ongeldige profieldata", 400)); return false; } } return passToNext(request); } private boolean isValidUserData(UserData data) { return data != null && data.getEmail() != null && data.getPassword() != null && data.getEmail().contains("@"); } } ``` ### 6. Business Logic Handler ```java @Component public class BusinessLogicHandler extends AbstractUserHandler { @Autowired private UserService userService; @Autowired private ProfileService profileService; @Override public boolean handle(UserRequest request) { try { Object result = switch (request.getOperation()) { case "CREATE_USER" -> userService.createUser(request.getUserData()); case "GET_USER" -> userService.getUser(request.getUserId()); case "UPDATE_PROFILE" -> profileService.updateProfile( request.getUserId(), request.getProfileData()); case "DELETE_USER" -> userService.deleteUser(request.getUserId()); default -> throw new IllegalArgumentException("Onbekende operatie"); }; request.setResponse(new SuccessResponse(result)); return true; } catch (Exception e) { request.setResponse(new ErrorResponse("Verwerkingsfout: " + e.getMessage(), 500)); return false; } } } ``` ## Request en Response Objects ### 7. UserRequest Class ```java public class UserRequest { private String operation; private String authToken; private Long userId; private UserData userData; private ProfileData profileData; private User authenticatedUser; private Object response; // Constructors, getters en setters public UserRequest(String operation, String authToken) { this.operation = operation; this.authToken = authToken; } } ``` ## Chain Configuration ### 8. Chain Builder ```java @Component public class UserRequestChainBuilder { @Autowired private AuthenticationHandler authenticationHandler; @Autowired private AuthorizationHandler authorizationHandler; @Autowired private ValidationHandler validationHandler; @Autowired private BusinessLogicHandler businessLogicHandler; public UserRequestHandler buildChain() { authenticationHandler.setNextHandler(authorizationHandler); authorizationHandler.setNextHandler(validationHandler); validationHandler.setNextHandler(businessLogicHandler); return authenticationHandler; } } ``` ## REST Endpoints ### 9. User Controller ```java @RestController @RequestMapping("/api/users") public class UserController { @Autowired private UserRequestChainBuilder chainBuilder; @PostMapping public ResponseEntity<?> createUser( @RequestHeader("Authorization") String authToken, @RequestBody UserData userData) { UserRequest request = new UserRequest("CREATE_USER", authToken); request.setUserData(userData); UserRequestHandler chain = chainBuilder.buildChain(); chain.handle(request); return buildResponse(request.getResponse()); } @GetMapping("/{userId}") public ResponseEntity<?> getUser( @RequestHeader("Authorization") String authToken, @PathVariable Long userId) { UserRequest request = new UserRequest("GET_USER", authToken); request.setUserId(userId); UserRequestHandler chain = chainBuilder.buildChain(); chain.handle(request); return buildResponse(request.getResponse()); } @PutMapping("/{userId}/profile") public ResponseEntity<?> updateProfile( @RequestHeader("Authorization") String authToken, @PathVariable Long userId, @RequestBody ProfileData profileData) { UserRequest request = new UserRequest("UPDATE_PROFILE", authToken); request.setUserId(userId); request.setProfileData(profileData); UserRequestHandler chain = chainBuilder.buildChain(); chain.handle(request); return buildResponse(request.getResponse()); } @DeleteMapping("/{userId}") public ResponseEntity<?> deleteUser( @RequestHeader("Authorization") String authToken, @PathVariable Long userId) { UserRequest request = new UserRequest("DELETE_USER", authToken); request.setUserId(userId); UserRequestHandler chain = chainBuilder.buildChain(); chain.handle(request); return buildResponse(request.getResponse()); } private ResponseEntity<?> buildResponse(Object response) { if (response instanceof SuccessResponse success) { return ResponseEntity.ok(success.getData()); } else if (response instanceof ErrorResponse error) { return ResponseEntity.status(error.getStatusCode()) .body(Map.of("error", error.getMessage())); } return ResponseEntity.internalServerError().build(); } } ``` ## Voordelen van deze implementatie: 1. **Losse koppeling**: Controllers weten niet welke handlers worden uitgevoerd 2. **Flexibiliteit**: Eenvoudig handlers toevoegen/verwijderen 3. **Hergebruik**: Handlers kunnen voor verschillende endpoints worden gebruikt 4. **Onderhoudbaarheid**: Elke handler heeft één verantwoordelijkheid 5. **Uitbreidbaarheid**: Nieuwe operaties eenvoudig toe te voegen ## Request Flow: ``` Client → Controller → Authentication → Authorization → Validation → Business Logic → Response ``` Elke handler kan de keten onderbreken bij fouten, waardoor je early return krijgt voor ongeldige verzoeken zonder de business logic te bereiken.