Conception de workflow personnalisé en JAVA et Spring
Je travaille sur un spring 2.0.1.VERSION de l'application.
Mémoire d'application:
1. I have separate Transformer beans that transforms my DTO to Domain
and vice versa.
2. I have separate Validator beans that validate my domain object being passed.
3. I have Service classes that takes care of the applying rules and calling persistence layer.
Maintenant, je veux construire une Workflow dans mon application: où je vais simplement appeler le début du flux de travail et les étapes mentionnées ci-dessous seront exécutées dans l'ordre et la gestion des exceptions sera effectuée selon l'étape:
1.First-Transformtion - transformToDomain() method will be called for that object type.
2.Second-Validator - class valid() method will be called for that object.
3.Third-Service - class save() method will be called for that object.
4.Fourth- Transformation - transformToDTO() method will be called for that object type.
Après cela, mon flux de travail se termine et je retournerai l'objet DTO en tant que réponse de mon REPOS API.
La partie de gestion des exceptions est celle dont je veux également m'occuper, comme si un gestionnaire d'exceptions particulier existe pour cette étape, appelez-le, sinon appelez le gestionnaire d'exceptions global.
J'ai conçu un prototype de même, mais je cherche des conseils d'experts et comment cela peut être réalisé avec une meilleure conception en java.
Explication avec exemple considérant le cas d'utilisation ci-dessus est très appréciable.
2 answers
Je ne suis pas si sûr si ce que vous décrivez est un système de flux de travail dans son vrai sens, peut-être une Chaîne de responsabilité est plus de ce dont vous parlez?
Suite à ce que vous avez décrit comme une séquence d'exécution, voici un exemple simplifié de la façon dont j'implémenterais la chaîne:
Transformateur.java
public interface Transformer<IN, OUT> {
OUT transformToDomain(IN dto);
IN transformToDTO(OUT domainObject);
}
Validateur.java
public interface Validator<T> {
boolean isValid(T object);
}
Service.java
public interface Service {
void save(Object object);
}
Et l'implémentation qui lie tout: ProcessChain.java
public class ProcessChain {
private Transformer transformer;
private Service service;
private Validator validator;
Object process(Object dto) throws MyValidationException {
Object domainObject = transformer.transformToDomain(dto);
boolean isValid = validator.isValid(domainObject);
if(!isValid){
throw new MyValidationException("Validation message here");
}
service.save(domainObject);
return transformer.transformToDTO(domainObject);
}
}
Je n'ai spécifié aucune chose liée au printemps ici parce que votre question semble être une question de conception plutôt qu'une question de technologie.
J'espère que cela aide
Bref de ce que j'ai implémenté d'une manière sans beaucoup d'agitation:
Voici comment j'ai créé un flux de gestionnaires:
Stream.<Supplier<RequestHandler>>of(
TransformToDomainRequestHandler::new,
ValidateRequestHandler::new,
PersistenceHandler::new,
TransformToDTORequestHandler::new)
.sequential()
.map(c -> c.get()) /* Create the handler instance */
.reduce((processed, unProcessed) -> { /* chains all handlers together */
RequestHandler previous = processed;
RequestHandler target = previous.getNextRequestHandler();
while (target != null && previous != null) {
previous = target;
target = target.getNextRequestHandler();
}
previous.setNextRequestHandler(unProcessed);
return processed;
}).get();
C'est mon gestionnaire de requête que tous les autres gestionnaires étendent
