Cacher is the code snippet organizer for pro developers

package advicedeepdive;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class BeforeAdvice {

  Logger logger = LoggerFactory.getLogger(BeforeAdvice.class);

  private boolean beforeCalled = false;

  public void reset() {
    beforeCalled = false;
  }

  public boolean isBeforeCalled() {
    return beforeCalled;
  }

  @Before("execution(void doSomething())")
  public void entering(JoinPoint joinPoint) {
    beforeCalled = true;
    logger.trace("entering "
        + joinPoint.getStaticPart().getSignature().toString());
  }

}

package advicedeepdive;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class AroundAdvice {
	
	Logger logger = LoggerFactory.getLogger(AroundAdvice.class);
	private boolean called;
	
	public void reset() {
		called=false;
	}

	@Around("execution(* *(..))")
	public Object trace(ProceedingJoinPoint proceedingJP ) throws Throwable {
		String methodInformation = 
				proceedingJP.getStaticPart().getSignature().toString();
		logger.trace("Entering "+methodInformation);
		called=true;
		try {
			return proceedingJP.proceed();
		} catch (Throwable ex) {
			logger.error("Exception in "+methodInformation, ex);
			throw ex;
		} finally {
			logger.trace("Exiting "+methodInformation);
		}
	}

	public boolean isCalled() {
		return called;
	}

	

}

package advicedeepdive;

import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class AfterThrowingAdvice {

  Logger logger = LoggerFactory.getLogger(AfterThrowingAdvice.class);

  private boolean afterThrowingCalled = false;

  public void reset() {
    afterThrowingCalled = false;
  }

  public boolean isAfterThrowingCalled() {
    return afterThrowingCalled;
  }

  @AfterThrowing(pointcut = "execution(void throwsRuntimeException())", throwing = "ex")
  public void logException(RuntimeException ex) {
    afterThrowingCalled = true;
    logger.error("Exception ", ex);
  }

}

package advicedeepdive;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class AfterReturningAdvice {

	Logger logger = LoggerFactory.getLogger(AfterReturningAdvice.class);

	private boolean afterReturningCalled = false;

	public void reset() {
		afterReturningCalled = false;
	}

  public boolean isAfterReturningCalled() {
    return afterReturningCalled;
  }

  @AfterReturning(pointcut = "execution(* *(..))", returning = "string")
	public void logResult(String string) {
		afterReturningCalled = true;
		logger.trace("result " + string);
	}

}

package advicedeepdive;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class AfterAdvice {

  Logger logger = LoggerFactory.getLogger(AfterAdvice.class);

  private boolean afterCalled = false;

  public void reset() {
    afterCalled = false;
  }

  public boolean isAfterCalled() {
    return afterCalled;
  }

  @After("execution(* *(..))")
	public void exiting(JoinPoint joinPoint) {
		afterCalled = true;
		logger.trace("exiting "
				+ joinPoint.getSignature());
		for (Object arg : joinPoint.getArgs()) {
			logger.trace("Arg : " + arg);
		}
	}
}