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, também quero imprimir o número da linha em que essa saída está no código-fonte. Como podemos ver no rastreamento da pilha, ele exibe o número da linha em que a exceção ocorreu. O rastreamento de pilha está disponível no objeto de exceção.

Outra alternativa pode ser como incluir 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 classe 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 como isto:

com.example.mytest.MyClass/myMethod:103

Sou obrigado a responder por não responder à sua pergunta. Suponho que você esteja procurando o número da linha apenas para oferecer suporte à depuração. Existem maneiras melhores. Existem maneiras hackeadas de obter a linha atual. Tudo que eu vi é lento. É melhor usar uma estrutura de log como a do pacote java.util.logging ou log4j . Usando esses pacotes, você pode configurar suas informações de log para incluir o contexto até o nome da classe. 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 por

logger.debug("a really descriptive message")

ao invés de

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

O Log4J permite incluir 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 funcionará ...

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

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

Eu recomendaria o uso de um kit de ferramentas de log, como o log4j . O log é configurável por meio de arquivos de propriedades em tempo de execução, e você pode ativar / desativar recursos como log de número de linha / nome de arquivo.

Examinar o javadoc para o PatternLayout fornece uma lista completa de opções - o que você procura é% L.

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

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

Clique duas vezes na saída para ir para a linha de código-fonte!

Pode ser necessário 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] + " " );
}

Você não pode garantir a consistência do número da linha com o código, especialmente se ele for compilado para liberação. Eu não recomendaria o uso de números de linha para esse fim, seria melhor fornecer uma carga útil do local em que a exceção foi gerada (o método trivial é definir a mensagem para incluir os detalhes da chamada do método).

Você pode considerar o aprimoramento de exceção 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 procurar algo como o Log4J, que fornecerá automaticamente informações suficientes para determinar de perto onde o código registrado ocorreu.

primeiro o método geral (em uma classe de utilitário, no código java1.4 antigo e simples, talvez seja necessário reescrevê-lo para java1.5 e mais)

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

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

Aqui está o logger que usamos.

envolve o Android Logger e exibe o nome da classe, 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();
}

Tudo isso fornece os números de linha do seu segmento e método atuais, que funcionam muito bem se você usar uma tentativa de tentar onde espera uma exceção. Mas se você deseja capturar qualquer exceção não tratada, está usando o manipulador de exceção não capturado padrão e o thread atual retornará o número da linha da função do manipulador, não o método de classe que lançou a exceção. Em vez de usar Thread.currentThread (), basta usar o Throwable transmitido 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 exemplo acima, use e.getStackTrace () [0] em sua função de manipulador (fShowUncaughtMessage) para obter o agressor.

O código abaixo é um código testado para a linha de log, nenhum nome de classe e nome do método de onde o método de log é 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;
}
}

O stackLeveldepende de profundidade que você chamar esse método. Você pode tentar de 0 a um número grande para ver a diferença.

Se stackLevelfor legal, você receberá uma string comojava.lang.Thread.getStackTrace(Thread.java:1536)

public static String getCodeLocationInfo(int stackLevel) {
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        if (stackLevel < 0 || stackLevel >= stackTraceElements.length) {
            return "Stack Level Out Of StackTrace Bounds";
        }
        StackTraceElement stackTraceElement = stackTraceElements[stackLevel];
        String fullClassName = stackTraceElement.getClassName();
        String methodName = stackTraceElement.getMethodName();
        String fileName = stackTraceElement.getFileName();
        int lineNumber = stackTraceElement.getLineNumber();

        return String.format("%s.%s(%s:%s)", fullClassName, methodName, fileName, lineNumber);
}

Esse é exatamente o recurso que implementei nesta lib XDDLib . (Mas, é para android)

Lg.d("int array:", intArrayOf(1, 2, 3), "int list:", listOf(4, 5, 6))

Um clique no texto sublinhado para navegar para onde o comando log está

Isso StackTraceElementé determinado pelo primeiro elemento fora desta biblioteca. Assim, em qualquer lugar fora deste lib vai ser legal, incluindo lambda expression, static initialization block, etc.

Meu jeito que 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 ("");