Como podemos imprimir números de linha para o log em java

Como imprimir números de linha no log. Digamos que ao enviar algumas informações para o log, eu também quero imprimir o número da linha onde a saída está no código-fonte. Como podemos ver no rastreamento de pilha, ele exibe o número da linha onde ocorreu a exceção. O rastreamento de pilha está disponível no object de exceção.

Outra alternativa poderia ser como include manualmente o número da linha ao imprimir no log. Existe alguma outra maneira?

De Angsuman Chakraborty :

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

Acabamos usando uma class personalizada como esta para o nosso trabalho 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); } } } 

Maneira rápida e suja:

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

Com mais alguns detalhes:

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

Isso produzirá algo assim:

 com.example.mytest.MyClass/myMethod:103 

Sou obrigado a responder por não responder à sua pergunta. Eu estou supondo que você está procurando o número de linha apenas para apoiar a debugging. Existem maneiras melhores. Existem maneiras de obter a linha atual. Tudo que eu vi é lento. É melhor usar uma estrutura de log como aquela no pacote java.util.logging ou log4j . Usando esses pacotes, você pode configurar suas informações de registro para include o contexto até o nome da class. Então, cada mensagem de log seria única o suficiente para saber de onde veio. Como resultado, seu código terá uma variável ‘logger’ que você chama via

logger.debug("a really descriptive message")

ao invés de

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

O Log4J permite include o número da linha como parte de seu padrão de saída. Consulte http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html para obter detalhes sobre como fazer isso (o elemento-chave no padrão de conversão é “L”). No entanto, o Javadoc inclui o seguinte:

AVISO A geração de informações de localização do chamador é extremamente lenta. Seu uso deve ser evitado, a menos que a velocidade de execução não seja um problema.

O código postado por @ simon.buchan vai funcionar …

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

Mas se você chamá-lo em um método, ele sempre retornará o número de linha da linha no método, então use o código in-snippet inline.

Eu uso esse pequeno método que gera o rastreamento e o número da linha do método que o chamou.

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

Dê um duplo clique na saída para ir para essa linha de código-fonte!

Você pode precisar ajustar o valor do nível dependendo de onde você colocou seu código.

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

Eu recomendaria usar um kit de ferramentas de registro, como log4j . A criação de log é configurável por meio de arquivos de propriedades no tempo de execução e você pode ativar / desativar resources, como registro de número de linha / nome de arquivo.

Observar o javadoc para o PatternLayout fornece a lista completa de opções – o que você está procurando é% L.

Você não pode garantir a consistência do número de linha com o código, especialmente se ele for compilado para lançamento. Eu não recomendaria usar números de linha para essa finalidade de qualquer maneira, seria melhor dar uma carga útil do local onde a exceção foi levantada (o método trivial é definir a mensagem para include os detalhes da chamada do método).

Você pode gostar de ver o enriquecimento de exceções como uma técnica para melhorar o tratamento de exceções http://tutorials.jenkov.com/java-exception-handling/exception-enrichment.html

Se foi compilado para lançamento, isso não é possível. Você pode querer olhar para algo como Log4J, que lhe dará automaticamente informações suficientes para determinar bem de perto onde ocorreu o código registrado.

primeiro o método geral (em uma class utility, no código java1.4 antigo, você pode ter que reescrevê-lo para java1.5 e mais)

 /** * Returns the first "[class#method(line)]: " of the first class not equal to "StackTraceUtils" and aclass. 
* 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; }

Em seguida, o método utilitário específico para obter o stackElement correto:

 /** * Returns the first stack trace element of the first class not equal to "StackTraceUtils" or "LogUtils" and aClass. 
* Stored in array of the callstack.
* 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; }

Aqui está o logger que usamos.

Ele envolve o Android Logger e exibe o nome da class, o nome do método e o número da linha.

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

Veja este link . Nesse método, você pode pular para o seu código de linha quando clicar duas vezes na linha do LogCat.

Além disso, você pode usar este código para obter o número da linha:

 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(); } 

Estes todos obtêm os números de linha do seu segmento atual e método que funcionam muito bem se você usar um try catch onde você está esperando uma exceção. Mas se você quiser pegar qualquer exceção não tratada, então você está usando o manipulador de exceção não-capturado padrão e o segmento atual retornará o número da linha da function do manipulador, não o método da class que emitiu a exceção. Em vez de usar Thread.currentThread (), basta usar o Throwable passado pelo manipulador de exceções:

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

No acima, use e.getStackTrace () [0] em sua function de manipulador (fShowUncaughtMessage) para obter o ofensor.

Abaixo do código é testado o código para a linha de registro sem nome de class e nome do método de onde o método de registro é chamado

 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; } } 

Do meu jeito, funciona para mim

 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; } 

você pode usar -> Reporter.log (“”);