Obtenir les arguments d'une méthode en utilisant Spring AOP ?

Question

J'utilise Spring AOP et j'ai l'aspect suivant :

@Aspect
public class LoggingAspect {

    @Before("execution(* com.mkyong.customer.bo.CustomerBo.addCustomer(..))")
    public void logBefore(JoinPoint joinPoint) {

        System.out.println("logBefore() is running!");
        System.out.println("hijacked : " + joinPoint.getSignature().getName());
        System.out.println("******");
    }

}

Intercepts d'aspect supérieur addCustomer l'exécution de la méthode. addCustomer prend une chaîne de caractères en entrée. Mais j'ai besoin d'enregistrer l'entrée passée à addCustomer méthode à l'intérieur logBefore méthode.
Est-il possible de le faire ?

Answer 1

Vous pouvez obtenir le paramètre de la méthode et sa valeur et si annoté avec une annotation avec le code suivant :

Map<String, Object> annotatedParameterValue = getAnnotatedParameterValue(MethodSignature.class.cast(jp.getSignature()).getMethod(), jp.getArgs()); ....

private Map<String, Object> getAnnotatedParameterValue(Method method, Object[] args) {
        Map<String, Object> annotatedParameters = new HashMap<>();
        Annotation[][] parameterAnnotations = method.getParameterAnnotations();
        Parameter[] parameters = method.getParameters();

        int i = 0;
        for (Annotation[] annotations : parameterAnnotations) {
            Object arg = args[i];
            String name = parameters[i++].getDeclaringExecutable().getName();
            for (Annotation annotation : annotations) {
                if (annotation instanceof AuditExpose) {
                    annotatedParameters.put(name, arg);
                }
            }
        }
        return annotatedParameters;
    }

Answer 2

S'il s'agit d'un seul argument de type String, faites-le : joinPoint.getArgs()[0];

Answer 3

Si vous utilisez @Aspect, vous pouvez ajouter cette méthode dans votre Aspect et envoyer le JoinPoint et le nom du paramètre dont vous avez besoin.

private Object getParameter(ProceedingJoinPoint joinPoint, String parameterName) {
    Object valueParameter = null;
    if (Objects.nonNull(joinPoint) && joinPoint.getSignature() instanceof MethodSignature
            && Objects.nonNull(parameterName) ) {
        MethodSignature method = (MethodSignature)joinPoint.getSignature();
        String[] parameters = method.getParameterNames();
        for (int t = 0; t< parameters.length; t++) {
            if( Objects.nonNull(parameters[t]) && parameters[t].equals(parameterName)) {
                Object[] obj = joinPoint.getArgs();
                valueParameter = obj[t];
            }
        }
    }
    return valueParameter;
}

et l'exemple d'appel :

Object parameterObject = getParameter(joinPoint, "nameClient");
if ( Objects.nonNull(parameterObject) ) {
    String parametro = String.valueOf(parameterObject);
}

Il suffit de connaître le type d'objet pour convertir