import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private void enterMethod(ProceedingJoinPoint joinPoint) {

        CodeSignature signature = (CodeSignature) joinPoint.getSignature();
        Class<?> clz = signature.getDeclaringType();
        String methodName = signature.getName();
        String[] paramNames = signature.getParameterNames();
        Object[] paramValues = joinPoint.getArgs();

        StringBuilder builder = new StringBuilder("\[email protected] Enter---------------------------------\n");
        if (Looper.getMainLooper() != Looper.myLooper()) {
            //非主线程，打印线程信息
            builder.append("[").append(Thread.currentThread().getName()).append("] ");
        }
        builder.append(methodName).append(":\n");
        for (int i = 0; i < paramValues.length; i++) {
            //此处可以对类型进行判断，读出更有意义的信息
            builder.append(paramNames[i])
                    .append("=")
                    .append(paramValues[i])
                    .append("\n");
        }
        builder.append("\[email protected] Enter end---------------------------------\n");
        Log.d(clz.getSimpleName(), builder.toString());
    }
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private StageId getStageId(MethodProfiling annotation, ProceedingJoinPoint joinPoint) {
    if (!annotation.enabled()) {
        return null;
    }
    ProfilerId profilerId = new ProfilerId(annotation.profilerName(), annotation.runsCounter());
    String stageName = annotation.stageName();
    if (stageName.isEmpty()) {

        CodeSignature codeSignature = (CodeSignature) joinPoint.getSignature();

        String className = codeSignature.getDeclaringType().getSimpleName();
        String methodName = codeSignature.getName();

        stageName = className + "." + methodName;
    }

    return new StageId(profilerId, stageName, annotation.stageOrder());
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private void enter(JoinPoint joinPoint, StringBuilder builder) {
  int line = addThread(joinPoint, builder);
  int tab = lineSet.headSet(line).size();
  for (int i = 0; i < tab; i++) {
    builder.append("\t\u21E3  ");
  }
  CodeSignature codeSignature = (CodeSignature) joinPoint.getSignature();
  Object[] parameterValues = joinPoint.getArgs();
  String[] parameterNames = codeSignature.getParameterNames();
  for (int i = 0; i < parameterValues.length; i++) {
    if (i > 0) {
      builder.append(", ");
    }
    builder.append(parameterNames[i]).append('=');
    builder.append(Strings.toString(parameterValues[i]));
  }
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
public static Map<String, Object> getJoinPointContextMap(JoinPoint jp) {
	Map<String, Object> context = new HashMap<String, Object>();
	context.put("_jp", jp);
	// convenience binding
	context.put("_this", jp.getThis());
	context.put("_target", jp.getTarget());
	context.put("_args", jp.getArgs());
	Signature sig = jp.getSignature();
	if (sig instanceof CodeSignature) {
		CodeSignature codeSig = (CodeSignature) sig;
		String[] paramNames = codeSig.getParameterNames();
		Object[] args = jp.getArgs();
		for (int i = 0; i < paramNames.length; i++) {
			context.put(paramNames[i], args[i]);
		}
	}
	return context;
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
/**
 * Logs the start of method calls with the specified direction for end-to-end purposes.
 * 
 * @param jp
 *            the join point during the execution of the method.
 * @param direction
 *            the direction of the message being logged.
 */
protected void enter(JoinPoint jp, String direction) {
    Logger logger = Logger.getLogger(getLoggerName(jp.getStaticPart()));
    if (isLoggingEnabled(logger)) {
        CodeSignature signature = (CodeSignature) jp.getSignature();
        String threadName = Thread.currentThread().getName();
        String declaringTypeName = signature.getDeclaringTypeName();
        Class<?>[] argTypes = signature.getParameterTypes();
        Object[] args = jp.getArgs();
        // search for a byte array type in argTypes
        // if it contains 1 or more byteArrays replace the content of the
        // array args at the appropriate index
        // with "byte[size]"
        processArgs(argTypes, args);
        String argsString = Arrays.deepToString(args);
        String signName = signature.getName();
        logger.info(String.format("%s: START %s: %s.%s(%s)", threadName, direction, declaringTypeName, signName, argsString));
    }
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private void execute(JoinPoint joinPoint) {
    CodeSignature codeSignature = (CodeSignature) joinPoint.getSignature();
    Class<?> cls = codeSignature.getDeclaringType();
    String methodName = codeSignature.getName();

    Log.v(getTag(cls), "\u21E2 " + methodName);
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private HashMap<String, String> buildParameterList(
		ProceedingJoinPoint method) {
	String[] parameterNames = ((CodeSignature) method.getSignature())
			.getParameterNames();
	Object[] parameterValues = method.getArgs();
	HashMap<String, String> result = new HashMap<String, String>();
	for (int i = 0; i < parameterNames.length; i++) {
		if(parameterValues[i] != null){
			result.put(parameterNames[i], parameterValues[i].toString());
		}
		
	}
	return result;
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private static void enterMethod(JoinPoint joinPoint) {
  if (!enabled) return;

  CodeSignature codeSignature = (CodeSignature) joinPoint.getSignature();

  Class<?> cls = codeSignature.getDeclaringType();
  String methodName = codeSignature.getName();
  String[] parameterNames = codeSignature.getParameterNames();
  Object[] parameterValues = joinPoint.getArgs();

  StringBuilder builder = new StringBuilder("\u21E2 ");
  builder.append(methodName).append('(');
  for (int i = 0; i < parameterValues.length; i++) {
    if (i > 0) {
      builder.append(", ");
    }
    builder.append(parameterNames[i]).append('=');
    builder.append(Strings.toString(parameterValues[i]));
  }
  builder.append(')');

  /*// Log when current thread is not the main thread
  if (Looper.myLooper() != Looper.getMainLooper()) {
    builder.append(" [Thread:\"").append(Thread.currentThread().getName()).append("\"]");
  }*/

  // TODO : use a real Logger
  System.out.println(asTag(cls) + " : " + builder.toString());
  
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
@Around("method() || constructor()")
public Object sendTrack(ProceedingJoinPoint joinPoint) throws Throwable {
    CodeSignature codeSignature = (CodeSignature) joinPoint.getSignature();
    MethodSignature methodSignature = (MethodSignature) codeSignature;
    Annotation[] annotations = methodSignature.getMethod().getAnnotations();

    TrackScreen myAnnotation = ((MethodSignature) joinPoint.getSignature()).getMethod().getAnnotation(TrackScreen.class);
    String trackerId = myAnnotation.trackerId();

    AnalyticsManager.getInstance().trackScreen(myAnnotation.trackerId(), myAnnotation.name());
    return joinPoint.proceed();
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
@Around("execution(public * de.helfenkannjeder.come2help.server.rest.*Controller.*(..))")
public Object logRequest(ProceedingJoinPoint joinPoint) throws Throwable {
    CodeSignature signature = (CodeSignature) joinPoint.getSignature();

    logMethodParams(joinPoint, signature);

    Object result = joinPoint.proceed();
    logMethodExit(signature, result);

    return result;
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private void logMethodParams(ProceedingJoinPoint joinPoint, CodeSignature signature) {
    String[] parameterNames = signature.getParameterNames();
    Object[] args = joinPoint.getArgs();
    try {
        for (int i = 0; i < parameterNames.length; i++) {
            LogSession.log("request-param-" + parameterNames[i], args[i] != null ? args[i].toString() : "null");
        }
    } catch (Exception ex) {
        LogSession.log("request-param-log-error", "true");
    }
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private void logMethodExit(CodeSignature signature, Object result) {
    if(result != null) {
        try {
            LogSession.log("response", objectMapper.writeValueAsString(result));
        } catch (Exception ex) {
            LogSession.log("response", "response object can not be parsed");
        }
    }
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private static String string(ProceedingJoinPoint joinPoint, long start, long stop) {
    CodeSignature signature = (CodeSignature) joinPoint.getSignature();
    String className = signature.getDeclaringType().getSimpleName();
    String methodName = signature.getName();
    return new StringBuilder(className)
            .append("#").append(methodName).append(" :: ")
            .append("[").append(TimeUnit.NANOSECONDS.toMillis(stop - start)).append(" ms]").toString();
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private static Object[] getParameterNames(Object[] argValues, JoinPoint jp) {
    Signature signature = jp.getSignature();
    if (signature instanceof CodeSignature) {
        return ((CodeSignature) signature).getParameterNames();
    } else {
        return new Object[argValues.length];
    }
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
@Test
public void testArgNameValuePairs_ArgValueAndArgName() throws Exception {
    JoinPoint jp = mock(JoinPoint.class);
    CodeSignature signature = mock(CodeSignature.class);
    when(jp.getSignature()).thenReturn(signature);
    when(signature.getParameterNames()).thenReturn(new String[]{"firstName"});
    when(jp.getArgs()).thenReturn(new Object[]{"Steve"});
    assertThat(Utils.getArgNameValuePairs(jp)).containsExactly("firstName: Steve");
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
@Test
public void testArgNameValuePairs_ArgValueAndArgName_multiple() throws Exception {
    JoinPoint jp = mock(JoinPoint.class);
    CodeSignature signature = mock(CodeSignature.class);
    when(jp.getSignature()).thenReturn(signature);
    when(signature.getParameterNames()).thenReturn(new String[]{"firstName", "number"});
    when(jp.getArgs()).thenReturn(new Object[]{"Steve", 20});
    assertThat(Utils.getArgNameValuePairs(jp)).containsExactly("firstName: Steve", "number: 20");
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
private static void enterMethod(JoinPoint joinPoint) {
  if (!enabled) return;

  CodeSignature codeSignature = (CodeSignature) joinPoint.getSignature();

  Class<?> cls = codeSignature.getDeclaringType();
  String methodName = codeSignature.getName();
  String[] parameterNames = codeSignature.getParameterNames();
  Object[] parameterValues = joinPoint.getArgs();

  StringBuilder builder = new StringBuilder("\u21E2 ");
  builder.append(methodName).append('(');
  for (int i = 0; i < parameterValues.length; i++) {
    if (i > 0) {
      builder.append(", ");
    }
    builder.append(parameterNames[i]).append('=');
    builder.append(Strings.toString(parameterValues[i]));
  }
  builder.append(')');

  if (Looper.myLooper() != Looper.getMainLooper()) {
    builder.append(" [Thread:\"").append(Thread.currentThread().getName()).append("\"]");
  }

  Log.v(asTag(cls), builder.toString());

  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
    final String section = builder.toString().substring(2);
    Trace.beginSection(section);
  }
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
/**
 * Logs the end of method calls with the specified direction for end-to-end purposes.
 * 
 * @param sjp
 *            the static part of the join point during the execution of the method.
 * @param direction
 *            the direction of the message being logged.
 * @param start
 *            the start time of the method execution in nanoseconds.
 * @param end
 *            the end time of the method execution in nanoseconds.
 */
protected void exit(JoinPoint.StaticPart sjp, String direction, long start, long end, Object result) {
    long tenthmillis = (end - start + FIFTY_THOUSAND_NANOSECONDS) / HUNDRED_THOUSAND_NANOSECONDS;
    Logger logger = Logger.getLogger(getLoggerName(sjp));
    if (isLoggingEnabled(logger)) {
        CodeSignature signature = (CodeSignature) sjp.getSignature();
        logger.info(String.format("%s: END %s: %s.%s: Time: %d.%d ms, Result: %s", Thread.currentThread().getName(), direction, signature.getDeclaringTypeName(), signature.getName(), tenthmillis / TEN, tenthmillis % TEN, result));
    }
}
 

import org.aspectj.lang.reflect.CodeSignature; //导入依赖的package包/类
/**
 * Logs the end of method calls with the specified direction and throwable for end-to-end purposes.
 * 
 * @param sjp
 *            the static part of the join point during the execution of the method.
 * @param t
 *            the throwable.
 * @param direction
 *            the direction of the message being logged.
 * @param start
 *            the start time of the method execution in nanoseconds.
 * @param end
 *            the end time of the method execution in nanoseconds.
 */
protected void exception(JoinPoint.StaticPart sjp, Throwable t, String direction, long start, long end) {
    long tenthmillis = (end - start + FIFTY_THOUSAND_NANOSECONDS) / HUNDRED_THOUSAND_NANOSECONDS;
    Logger logger = Logger.getLogger(getLoggerName(sjp));
    if (isLoggingEnabled(logger)) {
        CodeSignature signature = (CodeSignature) sjp.getSignature();
        logger.info(String.format("%s: END %s with Exception: %s.%s: Time: %d.%d ms", Thread.currentThread().getName(), direction, signature.getDeclaringTypeName(), signature.getName(), tenthmillis / TEN, tenthmillis % TEN), t);
    }
}