Comment puis-je connecter chaque méthode appelée dans une classe automatiquement avec log4j

J'ai une classe avec des appels de base de données, et en général, je veux ouvrir une session chaque méthode appelée (avec des arguments) dans cette classe avec log4j:

logger.debug("foo(id="+id+") initiated");

Est-il possible de faire cela automatiquement? Peut-être en utilisant une sorte d'annotation en début de chaque méthode, au lieu d'écrire chaque enregistreur.debug?

Aujourd'hui, je dois mettre à jour mon enregistrement.debug chaque fois que je change d'arguments ou le nom de la méthode.

source d'informationauteur Peeer

  1. 6

    Essayer @exploitables d'ici d'annotation et d'un aspect AspectJ de jcabi-aspects (je suis développeur):

    @Loggable(Loggable.INFO)
public String load(URL url) {
  return url.openConnection().getContent();
}

    Tous les appels de méthode sont enregistrés par le biais de SLF4J.

    Ce blog, il explique étape par étape: Java de la Méthode d'ouverture de session avec AOP et les Annotations

  2. 5

    Une solution possible serait d'utiliser aspectj. L'idée serait d'associer à l'aspect de chaque méthode que vous souhaitez enregistrer et effectuer la journalisation est d'aspect, au lieu d'une méthode. Un exemple d'aspectj la journalisation est ici, dans stackoverflow.

  3. 5

    Si vous avez des interfaces de déclarer les méthodes que vous voulez journal des appels, vous pouvez utiliser le Proxy standard API pour réaliser ce que vous voulez.

    Le Proxy de l'API vous permet d'envelopper votre réelle mise en œuvre d'une nouvelle classe de proxy, qui pourrait ouvrir une session à l'appel, et de les transférer l'appel à la mise en œuvre. Vous avez juste à le mettre en œuvre un InvocationHandler que le fait de la journalisation et de la transmission.

    Par exemple,

    interface Calculator {
  int add(int a, int b);
}

class CalculatorImpl implements Calculator {
  @Override public int add(int a, int b) { return a+b; }
}

class LoggingInvocationHandler implements InvocationHandler {
  private final Object delegate;
  public LoggingInvocationHandler(final Object delegate) {
    this.delegate = delegate;
  }
  @Override invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("method: " + method + ", args: " + args);
    return method.invoke(delegate, args);
  }
}

class X {
  public static void main(String... args) {
    final Calculator calc = new CalculatorImpl();
    final Calculator loggingCalc =
      (Calculator) Proxy.newProxyInstance(X.class.getClassLoader(),
                                          new Class[] {Calculator.class},
                                          new LoggingInvocationHandler (calc));
    loggingCalc.add(2, 3); //shall print to the screen
  }
}

    Vous pouvez également facilement enregistrer les valeurs de retour et les exceptions levées par les méthodes, simplement en changeant le code de la InvocationHandler. Aussi, vous pouvez utiliser toutes les fonctionnalités de journalisation vous aimez au lieu de System.out.println comme dans l'exemple.

    Connecter les valeurs de retour et les exceptions, vous pourriez faire quelque chose comme:

      @Override invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("method: " + method + ", args: " + args);
    try {
      final Object ret = method.invoke(delegate, args);
      System.out.println("return: " + ret);
      return ret;
    } catch (Throwable t) {
      System.out.println("thrown: " + t);
      throw t;
    }
  }