La gestion des exceptions par spring AOP + Aspectj

Dans mon projet j'ai une couche domaine qui est essentiellement POJO et un Printemps contrôleur /couche de service qui est assis sur le dessus de la couche domaine. J'ai aussi un AOP de la couche qui est assis entre le service et le domaine.

Mon domaine de couche est en train de jeter des affaires exceptions qui sont maintenant traitées dans la couche de service.

Mais je tiens à le modifier de sorte que l'exception générée à partir de la couche domaine seront traitées dans l'AOP couche. AOP couche sera une sorte de réponse à l'erreur et de l'envoyer à ressort contrôleur/web de la couche de service.

Je peux créer un IBizResponse et de faire deux sous-classes/interfaces de il peut-être un SuccessResponse et un ErrorResponse et faire ma couche domaine des méthodes de retour IBizResponse. Cependant, je ne suis pas en mesure de comprendre comment faire de l'AOP retour de la ErrorResponse objet de la couche de service.

OriginalL'auteur Nitish Raj | 2014-07-17

  1. 3

    Je suis tombé sur le même scénario, où j'ai dû retourner une réponse d'erreur DTO en cas de gestion des exceptions. À l'intérieur de @Aspect de la classe,

    @Aspect
@Component
public class MyAspect{
private static final Logger LOGGER = LoggerFactory.getLogger(MyAspect.class);
@Pointcut("execution(* com.linda.dao.strategy.*.*(..))")
public void strategyMethods() { }
@Pointcut("execution(* com.linda.controller.*.*(..)) || execution(* com.linda.Manager.*(..))")
public void controllerMethods(){  }
@Around("strategyMethods()")
public Object profileStrategyMethods(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
Object output = null;
LOGGER.info("Class:"+pjp.getTarget().getClass()+" entry -> method ->"+pjp.getSignature().getName());
try{
output = pjp.proceed();
long elapsedTime = System.currentTimeMillis() - start;
LOGGER.info("Method execution time: " + elapsedTime + " milliseconds.");
LOGGER.info("Class:"+pjp.getTarget().getClass()+" exit -> method ->"+pjp.getSignature().getName());
}catch(Throwable t){
throw new InternalServerException(t.getMessage());  
}
return output;
}
@AfterThrowing(pointcut="execution(* com.linda.dao.strategy.*.*(..)) || execution(* com.linda.controller.*.*(..)) || execution(* com.linda.Manager.*(..))",throwing = "ex")
public void doRecoveryActions(JoinPoint joinPoint, Throwable ex) {
Signature signature = joinPoint.getSignature();
String methodName = signature.getName();
String stuff = signature.toString();
String arguments = Arrays.toString(joinPoint.getArgs());
LOGGER.error("Write something in the log... We have caught exception in method: "
+ methodName + " with arguments "
+ arguments + "\nand the full toString: " + stuff + "\nthe exception is: "
+ ex.getMessage());
}
}

    Défini une autre classe pour la gestion des exceptions, comme ci-dessous:

    @ControllerAdvice
public class ExceptionLogAdvice {
@ExceptionHandler(InternalServerException.class)
@ResponseStatus(HttpStatus.BAD_GATEWAY)
@ResponseBody
public ResponseEntity<Object> handleValidationException(final InternalServerException internalServerException){
ErrorResponseDTO dto = constructErrorResponse(internalServerException);
return ResponseEntity.status(HttpStatus.BAD_GATEWAY).body(dto);
}
}

    Tweeté un peu le code que je ne peux pas partager le code. Espère que j'ai fait le concept clair.

    OriginalL'auteur Linz

  2. 7

    Voir Après avoir lancé des avis de la section de https://docs.spring.io/spring/docs/4.1.0.RELEASE/spring-framework-reference/htmlsingle/#aop-introduction-defn

    Après avoir jeté des conseils s'exécute lorsqu'un correspondant l'exécution de la méthode sort par la levée d'une exception. Elle est déclarée à l'aide de @AfterThrowing annotation:

    Exemples

    import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;
@Aspect
public class AfterThrowingExample {
@AfterThrowing("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
public void doRecoveryActions() {
//...
}
}
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;
@Aspect
public class AfterThrowingExample {
@AfterThrowing(
pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
throwing="ex")
public void doRecoveryActions(DataAccessException ex) {
//...
}
}

    OriginalL'auteur vinayknl

  3. 1

    Considérant com.sc.bs.impl.* est entreprise/domaine paquetage de couche et intercepté en AOP calque à l'aide de @Autour de l'annotation. Extrait de Code:

    @Around("execution(* com.sc.bs.impl..*.*(..))")
public Object exceptionHandlerWithReturnType(ProceedingJoinPoint joinPoint) throws Throwable{
try {
obj = joinPoint.proceed();
} catch(Exception ex) {
throw ex;
}
}
    Votre try catch est un peu inutile, n'est-ce pas?
    Ouais, mais j'ai utilisé à d'autres fins, comme l'audit et de validation de transaction et de faire reculer.

    OriginalL'auteur Nitish Raj