Jak wydrukować numery wierszy w dzienniku. Powiedz, wypisując pewne informacje do dziennika, chcę również wydrukować numer wiersza, w którym te dane wyjściowe znajdują się w kodzie źródłowym. Jak widać w śladzie stosu, wyświetla numer linii, w której wystąpił wyjątek. W obiekcie wyjątku dostępne jest śledzenie stosu.
Inną alternatywą może być ręczne dodawanie numeru linii podczas drukowania do dziennika. Czy jest inny sposób?
Odpowiedzi:
/** Get the current line number.
* @return int - Current line number.
*/
public static int getLineNumber() {
return Thread.currentThread().getStackTrace()[2].getLineNumber();
}
Skończyło się na tym, że użyliśmy niestandardowej klasy, takiej jak ta do naszej pracy na Androida:
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);
}
}
}
getStackTrace()[3]zamiastgetStackTrace()[2]
Szybki i brudny sposób:
System.out.println("I'm in line #" +
new Exception().getStackTrace()[0].getLineNumber());
Więcej szczegółów:
StackTraceElement l = new Exception().getStackTrace()[0];
System.out.println(
l.getClassName()+"/"+l.getMethodName()+":"+l.getLineNumber());
To wyświetli coś takiego:
com.example.mytest.MyClass/myMethod:103
System.out.println("i am here: " + new Exception().getStackTrace()[0]);podaje mi wszystkie szczegóły, których potrzebuję :)
Jestem zmuszony odpowiedzieć, nie odpowiadając na twoje pytanie. Zakładam, że szukasz numeru linii wyłącznie do obsługi debugowania. Są lepsze sposoby. Istnieją hakerskie sposoby na uzyskanie aktualnej linii. Wszystko, co widziałem, jest powolne. Lepiej jest używać struktury rejestrowania, takiej jak w pakiecie java.util.logging lub log4j . Korzystając z tych pakietów, możesz skonfigurować informacje logowania, aby uwzględnić kontekst aż do nazwy klasy. Wtedy każdy komunikat dziennika byłby na tyle unikalny, aby wiedzieć, skąd pochodzi. W rezultacie Twój kod będzie zawierał zmienną „logger”, którą wywołujesz
logger.debug("a really descriptive message")
zamiast
System.out.println("a really descriptive message")
Log4J umożliwia dołączenie numeru linii jako części wzoru wyjściowego. Zobacz http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html, aby dowiedzieć się, jak to zrobić (kluczowym elementem we wzorcu konwersji jest „L”). Jednak Javadoc zawiera następujące elementy:
OSTRZEŻENIE Generowanie informacji o lokalizacji dzwoniącego jest bardzo wolne. Jego użycia należy unikać, chyba że szybkość wykonywania nie jest problemem.
Kod wysłany przez @ simon.buchan zadziała ...
Thread.currentThread().getStackTrace()[2].getLineNumber()
Ale jeśli wywołasz go w metodzie, zawsze zwróci numer wiersza w metodzie, więc raczej użyj wbudowanego fragmentu kodu.
Polecam użycie zestawu narzędzi do rejestrowania, takiego jak log4j . Rejestrowanie można konfigurować za pomocą plików właściwości w czasie wykonywania i można włączać / wyłączać takie funkcje, jak rejestrowanie numeru linii / nazwy pliku.
Spojrzenie na javadoc dla PatternLayout daje Ci pełną listę opcji - szukasz% L.
Używam tej małej metody, która wyświetla ślad i numer wiersza metody, która ją wywołała.
Log.d(TAG, "Where did i put this debug code again? " + Utils.lineOut());
Kliknij dwukrotnie dane wyjściowe, aby przejść do tej linii kodu źródłowego!
Może zajść potrzeba dostosowania wartości poziomu w zależności od tego, gdzie umieściłeś kod.
public static String lineOut() {
int level = 3;
StackTraceElement[] traces;
traces = Thread.currentThread().getStackTrace();
return (" at " + traces[level] + " " );
}
Utilbierze?
Nie możesz zagwarantować spójności numeru wiersza z kodem, zwłaszcza jeśli jest on kompilowany do wydania. I tak nie polecałbym używania w tym celu numerów linii, lepiej byłoby podać ładunek miejsca, w którym wystąpił wyjątek (trywialną metodą jest ustawienie komunikatu tak, aby zawierał szczegóły wywołania metody).
Możesz spojrzeć na wzbogacanie wyjątków jako technikę poprawy obsługi wyjątków http://tutorials.jenkov.com/java-exception-handling/exception-enrichment.html
najpierw ogólna metoda (w klasie narzędziowej, chociaż w zwykłym starym kodzie java1.4 może być konieczne przepisanie go na java1.5 i więcej)
/**
* 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;
}
Następnie konkretna metoda narzędziowa, aby uzyskać odpowiedni 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;
}
Oto rejestrator, którego używamy.
otacza Android Logger i wyświetla nazwę klasy, nazwę metody i numer linii.
Spójrz na ten link . W tej metodzie możesz przeskoczyć do kodu linii, klikając dwukrotnie wiersz LogCat.
Możesz również użyć tego kodu, aby uzyskać numer linii:
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();
}
To wszystko daje ci numery wierszy twojego aktualnego wątku i metody, która działa świetnie, jeśli używasz try catch tam, gdzie spodziewasz się wyjątku. Ale jeśli chcesz przechwycić jakikolwiek nieobsługiwany wyjątek, używasz domyślnej procedury obsługi nieprzechwyconego wyjątku, a bieżący wątek zwróci numer wiersza funkcji obsługi, a nie metodę klasy, która spowodowała wyrzucenie wyjątku. Zamiast używać Thread.currentThread () po prostu użyj Throwable przekazanego przez procedurę obsługi wyjątków:
Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
public void uncaughtException(Thread t, Throwable e) {
if(fShowUncaughtMessage(e,t))
System.exit(1);
}
});
W powyższym przykładzie użyj e.getStackTrace () [0] w swojej funkcji obsługi (fShowUncaughtMessage), aby pobrać sprawcę.
Poniższy kod jest testowanym kodem dla linii logowania bez nazwy klasy i nazwy metody, z której jest wywoływana metoda logowania
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;
}
}
stackLevelZależy od głębokości wywołać tę metodę. Możesz spróbować od 0 do dużej liczby, aby zobaczyć, jaka jest różnica.
Jeśli stackLeveljest to legalne, otrzymasz ciąg podobny dojava.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);
}
To jest dokładnie ta funkcja, którą zaimplementowałem w tej bibliotece XDDLib . (Ale to dla Androida)
Lg.d("int array:", intArrayOf(1, 2, 3), "int list:", listOf(4, 5, 6))
Jedno kliknięcie podkreślonego tekstu, aby przejść do miejsca, w którym znajduje się polecenie dziennika
Która StackTraceElementjest określana przez pierwszy element spoza tej biblioteki. Tak więc, gdziekolwiek poza tym lib będzie prawnym, w tym lambda expression, static initialization blockitp
Dla każdego, kto się zastanawia, indeks w getStackTrace()[3]metodzie sygnalizuje liczbę wątków pokonywanych przez linię wyzwalającą, aż do faktycznej metody .getStackTrace () z wyłączeniem linii wykonawczej.
Oznacza to, że jeśli Thread.currentThread().getStackTrace()[X].getLineNumber();wiersz jest wykonywany z 3 metod zagnieżdżonych powyżej , numer indeksu musi wynosić 3 .
Przykład:
Pierwsza warstwa
private static String message(String TAG, String msg) {
int lineNumber = Thread.currentThread().getStackTrace()[3].getLineNumber();
return ".(" + TAG + ".java:"+ lineNumber +")" + " " + msg;
}
Druga warstwa
private static void print(String s) {
System.out.println(s);
}
Trzecia warstwa
public static void normal(
String TAG,
String message
) {
print(
message(
TAG,
message
)
);
}
Wykonywanie linii:
Print.normal(TAG, "StatelessDispatcher");
Jako osoba, która nie otrzymała żadnego formalnego wykształcenia w zakresie IT, otworzyła umysł na temat działania kompilatorów.
Mój sposób to działa dla mnie
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;
}
możesz użyć -> Reporter.log ("");