Comment pouvons-nous imprimer des numéros de ligne dans le journal en java

À Partir De Angsuman Chakraborty:

/** Get the current line number.
 * @return int - Current line number.
 */
public static int getLineNumber() {
    return Thread.currentThread().getStackTrace()[2].getLineNumber();
}

Nous avons fini par utiliser une classe personnalisée comme celle-ci pour notre travail Android:

import android.util.Log;    
public class DebugLog {
 public final static boolean DEBUG = true;    
 public static void log(String message) {
  if (DEBUG) {
    String fullClassName = Thread.currentThread().getStackTrace()[2].getClassName();
    String className = fullClassName.substring(fullClassName.lastIndexOf(".") + 1);
    String methodName = Thread.currentThread().getStackTrace()[2].getMethodName();
    int lineNumber = Thread.currentThread().getStackTrace()[2].getLineNumber();

    Log.d(className + "." + methodName + "():" + lineNumber, message);
  }
 }
}

Voie rapide et sale:

System.out.println("I'm in line #" + 
    new Exception().getStackTrace()[0].getLineNumber());

Avec quelques détails supplémentaires:

StackTraceElement l = new Exception().getStackTrace()[0];
System.out.println(
    l.getClassName()+"/"+l.getMethodName()+":"+l.getLineNumber());

Qui produira quelque chose comme ceci:

com.example.mytest.MyClass/myMethod:103

Je suis obligé de répondre en ne répondant pas à votre question. Je suppose que vous recherchez le numéro de ligne uniquement pour prendre en charge le débogage. Il existe de meilleures façons. Il existe des moyens hackish pour obtenir la ligne actuelle. Tout ce que j'ai vu sont lents. Vous feriez mieux d'utiliser un framework de journalisation comme celui en java.util.la journalisation des colis ou log4j. En utilisant ces packages, vous pouvez configurer vos informations de journalisation pour inclure le contexte jusqu'au nom de la classe. Ensuite chaque message de journal serait unique assez pour savoir d'où il vient. En conséquence, votre code aura une variable 'logger' que vous appelez via

logger.debug("a really descriptive message")

Au Lieu de

System.out.println("a really descriptive message")

Log4J vous permet d'inclure le numéro de ligne dans son modèle de sortie. Voir http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html pour plus de détails sur la façon de procéder (l'élément clé dans le modèle de conversion est "L"). Cependant, le Javadoc inclut les éléments suivants:

AVERTISSEMENT Générant l'emplacement de l'appelant l'information est extrêmement lente. C'est l'utilisation doit être évitée à moins que l'exécution la vitesse n'est pas un problème.

Le code posté par @simon.buchan va travailler...

Thread.currentThread().getStackTrace()[2].getLineNumber()

, Mais si vous l'appelez dans une méthode, il retournera toujours la numéro de la ligne dans la méthode, donc plutôt utiliser l'extrait de code en ligne.

J'utilise cette petite méthode qui génère le numéro de trace et de ligne de la méthode qui l'a appelée.

 Log.d(TAG, "Where did i put this debug code again?   " + Utils.lineOut());

Double-cliquez sur la sortie pour accéder à cette ligne de code source!

Vous devrez peut-être ajuster la valeur de niveau en fonction de l'endroit où vous placez votre code.

public static String lineOut() {
    int level = 3;
    StackTraceElement[] traces;
    traces = Thread.currentThread().getStackTrace();
    return (" at "  + traces[level] + " " );
}

Je recommanderais d'utiliser une boîte à outils de journalisation telle que log4j. La journalisation est configurable via les fichiers de propriétés lors de l'exécution, et vous pouvez activer / désactiver des fonctionnalités telles que la journalisation du numéro de ligne / nom de fichier.

En regardant le javadoc pour le PatternLayout vous donne la liste complète des options - ce que vous recherchez est %L.

Vous ne pouvez pas garantir la cohérence du numéro de ligne avec le code, surtout s'il est compilé pour la publication. Je ne recommanderais pas d'utiliser des numéros de ligne à cette fin de toute façon, il serait préférable de donner une charge utile de l'endroit où l'exception a été levée (la méthode triviale étant de définir le message pour inclure les détails de l'appel de méthode).

Vous voudrez peut-être considérer l'enrichissement des exceptions comme une technique pour améliorer la gestion des exceptions http://tutorials.jenkov.com/java-exception-handling/exception-enrichment.html

S'il a été compilé pour la publication, ce n'est pas possible. Vous voudrez peut-être examiner quelque chose comme Log4J qui vous donnera automatiquement suffisamment d'informations pour déterminer de près où le code enregistré s'est produit.

D'abord la méthode générale (dans une classe utilitaire, dans le vieux code java1.4, vous devrez peut-être le réécrire pour java1.5 et plus)

/**
 * Returns the first "[class#method(line)]: " of the first class not equal to "StackTraceUtils" and aclass. <br />
 * Allows to get past a certain class.
 * @param aclass class to get pass in the stack trace. If null, only try to get past StackTraceUtils. 
 * @return "[class#method(line)]: " (never empty, because if aclass is not found, returns first class past StackTraceUtils)
 */
public static String getClassMethodLine(final Class aclass)  {
    final StackTraceElement st = getCallingStackTraceElement(aclass);
    final String amsg = "[" + st.getClassName() + "#" + st.getMethodName() + "(" + st.getLineNumber()
    +")] <" + Thread.currentThread().getName() + ">: ";
    return amsg;
}

Puis la méthode utilitaire spécifique pour obtenir le bon stackElement:

/**
   * Returns the first stack trace element of the first class not equal to "StackTraceUtils" or "LogUtils" and aClass. <br />
   * Stored in array of the callstack. <br />
   * Allows to get past a certain class.
   * @param aclass class to get pass in the stack trace. If null, only try to get past StackTraceUtils. 
   * @return stackTraceElement (never null, because if aClass is not found, returns first class past StackTraceUtils)
   * @throws AssertionFailedException if resulting statckTrace is null (RuntimeException)
   */
  public static StackTraceElement getCallingStackTraceElement(final Class aclass) {
    final Throwable           t         = new Throwable();
    final StackTraceElement[] ste       = t.getStackTrace();
    int index = 1;
    final int limit = ste.length;
    StackTraceElement   st        = ste[index];
    String              className = st.getClassName();
    boolean aclassfound = false;
    if(aclass == null) {
        aclassfound = true;
    }
    StackTraceElement   resst = null;
    while(index < limit) {
        if(shouldExamine(className, aclass) == true) {
            if(resst == null) {
                resst = st;
            }
            if(aclassfound == true) {
                final StackTraceElement ast = onClassfound(aclass, className, st);
                if(ast != null) {
                    resst = ast;
                    break;
                }
            }
            else
            {
                if(aclass != null && aclass.getName().equals(className) == true) {
                    aclassfound = true;
                }
            }
        }
        index = index + 1;
        st        = ste[index];
        className = st.getClassName();
    }
    if(isNull(resst))  {
        throw new AssertionFailedException(StackTraceUtils.getClassMethodLine() + " null argument:" + "stack trace should null"); //$NON-NLS-1$
    }
    return resst;
  }

  static private boolean shouldExamine(String className, Class aclass) {
      final boolean res = StackTraceUtils.class.getName().equals(className) == false && (className.endsWith(LOG_UTILS
        ) == false || (aclass !=null && aclass.getName().endsWith(LOG_UTILS)));
      return res;
  }

  static private StackTraceElement onClassfound(Class aclass, String className, StackTraceElement st) {
      StackTraceElement   resst = null;
      if(aclass != null && aclass.getName().equals(className) == false)
      {
          resst = st;
      }
      if(aclass == null)
      {
          resst = st;
      }
      return resst;
  }

Voici l'enregistreur que nous utilisons.

Il entoure Android Logger et affiche le nom de la classe, le nom de la méthode et le numéro de ligne.

Http://www.hautelooktech.com/2011/08/15/android-logging/

Regardez ce lien. Dans cette méthode, vous pouvez accéder à votre code de ligne lorsque vous double-cliquez sur la ligne de LogCat.

Vous pouvez également utiliser ce code pour obtenir le numéro de ligne:

public static int getLineNumber()
{
    int lineNumber = 0;
    StackTraceElement[] stackTraceElement = Thread.currentThread()
            .getStackTrace();
    int currentIndex = -1;
    for (int i = 0; i < stackTraceElement.length; i++) {
        if (stackTraceElement[i].getMethodName().compareTo("getLineNumber") == 0)
        {
            currentIndex = i + 1;
            break;
        }
    }

    lineNumber = stackTraceElement[currentIndex].getLineNumber();

    return lineNumber;
}

private static final int CLIENT_CODE_STACK_INDEX;

static {
    // Finds out the index of "this code" in the returned stack Trace - funny but it differs in JDK 1.5 and 1.6
    int i = 0;
    for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
        i++;
        if (ste.getClassName().equals(Trace.class.getName())) {
            break;
        }
    }
    CLIENT_CODE_STACK_INDEX = i;
}

private String methodName() {
    StackTraceElement ste=Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX+1];
    return ste.getMethodName()+":"+ste.getLineNumber();
}

Tout cela vous donne les numéros de ligne de votre thread et de votre méthode actuels qui fonctionnent très bien si vous utilisez un try catch où vous attendez une exception. Mais si vous voulez attraper une exception non gérée, vous utilisez le gestionnaire d'exceptions non capturées par défaut et le thread actuel renverra le numéro de ligne de la fonction de gestionnaire, pas la méthode de classe qui a lancé l'exception. Au lieu d'utiliser du Fil.currentThread () utilise simplement le Throwable transmis par l'exception gestionnaire:

Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            public void uncaughtException(Thread t, Throwable e) {              
                if(fShowUncaughtMessage(e,t))               
                    System.exit(1);
            }
        });

Dans ce qui précède, utilisez e. getStackTrace()[0] dans votre fonction de gestionnaire (fShowUncaughtMessage) pour obtenir le délinquant.

Le code ci-dessous est le code testé pour la ligne de journalisation no nom de classe et nom de méthode à partir duquel la méthode de journalisation est appelée

public class Utils {
/*
 * debug variable enables/disables all log messages to logcat
 * Useful to disable prior to app store submission
 */
public static final boolean debug = true;

/*
 * l method used to log passed string and returns the
 * calling file as the tag, method and line number prior
 * to the string's message
 */
public static void l(String s) {
    if (debug) {
        String[] msg = trace(Thread.currentThread().getStackTrace(), 3);
        Log.i(msg[0], msg[1] + s);
    } else {
        return;
    }
}

/*
 * l (tag, string)
 * used to pass logging messages as normal but can be disabled
 * when debug == false
 */
public static void l(String t, String s) {
    if (debug) {
        Log.i(t, s);
    } else {
        return;
    }
}

/*
 * trace
 * Gathers the calling file, method, and line from the stack
 * returns a string array with element 0 as file name and 
 * element 1 as method[line]
 */
public static String[] trace(final StackTraceElement e[], final int level) {
    if (e != null && e.length >= level) {
        final StackTraceElement s = e[level];
        if (s != null) { return new String[] {
                e[level].getFileName(), e[level].getMethodName() + "[" + e[level].getLineNumber() + "]"
        };}
    }
    return null;
}
}

Ma façon de travailler pour moi

String str = "select os.name from os where os.idos="+nameid;  try {
        PreparedStatement stmt = conn.prepareStatement(str);
        ResultSet rs = stmt.executeQuery();
        if (rs.next()) {
            a = rs.getString("os.n1ame");//<<<----Here is the ERROR          
        }
        stmt.close();
  } catch (SQLException e) {
        System.out.println("error line : " + e.getStackTrace()[2].getLineNumber());            
        return a;
  }

Vous pouvez utiliser -> Journaliste.log ("");