Come rimuovere istruzioni di debug dalla produzione di codice in Java

StackOverflow https://stackoverflow.com/questions/32041

Domanda

È possibile che il compilatore per rimuovere i bilanci utilizzati per scopi di debug (come la registrazione) dal codice di produzione?Le istruzioni di debug avrebbe bisogno di essere segnato in qualche modo, magari utilizzando le annotazioni.

È facile impostare una proprietà (debug = true) e controllare in ogni debug istruzione, ma questo può ridurre le prestazioni.Sarebbe bello se il compilatore non farebbe che rendere le istruzioni di debug svanire.

È stato utile?

Soluzione

Due raccomandazioni.

Primo: per il real la registrazione, utilizzare un moderno pacchetto di registrazione come log4j o java proprio costruito in registrazione.Non preoccuparti per le prestazioni così tanto, il livello di registrazione di controllo è dell'ordine dei nanosecondi.(e ' un numero intero di confronto).

E se si dispone di più di una singola istruzione del registro, guardia l'intero blocco:

(log4j, per esempio:)

if (logger.isDebugEnabled()) {

  // perform expensive operations
  // build string to log

  logger.debug("....");
}

Questo ti dà la possibilità di controllo di registrazione in fase di runtime.Dover riavviare ed eseguire una build di debug può essere molto scomodo.

Secondo:

Si possono trovare affermazioni sono più di che cosa avete bisogno.Un'affermazione è una dichiarazione che restituisce un valore booleano, con un messaggio opzionale:

 assert (sky.state != FALLING) : "The sky is falling!";

Ogni volta che l'affermazione risultati in un falso, l'asserzione non riesce e viene generata una eccezione assertionerror contenente il messaggio (questa è una eccezione unchecked, destinato a uscire dall'applicazione).

La cosa bella è che questi sono un trattamento speciale dalla JVM e può commutare in fase di runtime giù al livello di classe, utilizzando un parametro VM (non è necessario ricompilare).Se non è attivata, non è zero overhead.

Altri suggerimenti

public abstract class Config
{
    public static final boolean ENABLELOGGING = true;
}

import static Config.*;

public class MyClass
{
    public myMethod()
    {
        System.out.println("Hello, non-logging world");

        if (ENABLELOGGING)
        {
            log("Hello, logging world.");
        }
    }
}

Il compilatore di rimuovere il blocco di codice con "Ciao, la registrazione del mondo." se ENABLE_LOGGING è impostata su true, perché è una statico valore finale.Se si utilizza un obfuscator come proguard, quindi la Config classe svanirà troppo.

Un obfuscator consentirebbe anche cose come questa invece:

public class MyClass
{
    public myMethod()
    {
        System.out.println("Hello, non-logging world");

        Log.log("Hello, logging world.");
    }
}

import static Config.*;

public abstract class Log
{
    public static void log(String s)
    {
        if (ENABLELOGGING)
        {
            log(s);
        }
    }
}

Il metodo Log#registro nulla per ridurre a nulla nel compilatore, e di essere rimosso dal obfuscator, insieme con tutte le chiamate al metodo e alla fine anche il Registro di classe in se stesso sarebbe rimosso.

Un'altra possibilità è di mettere l'istruzione if all'interno della vostra funzione di registrazione, si ottiene meno il codice in questo modo, ma a scapito di alcuni extra chiamate di funzione.

Io non sono un grande fan di rimuovere completamente il codice di debug.Una volta in produzione, probabilmente avrete bisogno di accedere a messaggi di debug, se qualcosa va storto.Se si rimuove tutto il codice di debug a livello di, che questa non è una possibilità.

Utilizzare Java Preprocessore?(google pippo basso, ma questo è un link al vecchio Joel forum di discussione)

Java contiene una sorta di preprocessore propria.Si chiama APT.Elabora e genera il codice.Al momento non sono sicuro di come questo dovrebbe funzionare (non l'ho ancora provato).Ma sembra essere usati per questo tipo di cose.

Vorrei, inoltre, consiglia di utilizzare una registrazione di un quadro.

Il logger.IsDebugEnabled() non è obbligatorio, è solo che non può essere più veloce per controllare se il sistema è in debug a livello di prima registrazione.

Utilizzando una registrazione framework significa che è possibile configurare i livelli di registrazione al volo senza riavviare l'applicazione.

Si potrebbe avere la registrazione come:

logger.error("Something bad happened")
logger.debug("Something bad happend with loads more detail")

Questo "trucco"sembra fare il debug di dichiarazioni scomparso

public static final boolean DEBUG = false;

if (DEBUG) { //disapeared on compilation }

Il post ha detto che javac è abbastanza intelligente per controllare la static final boolean e di escludere le istruzioni di debug.(Non ho personalmente provare)

Per la registrazione, io personalmente non piace vedere il codice come:

if (logger.isDebugEnabled()) {
    logger.debug("....");
}
realImportantWork();

La registrazione di cose che mi distrae dal realImportantWork().Il modo giusto per me è:

logger.debug("....");
realImportantWork()

più la config che esclude tutti i messaggi di debug sulla Produzione.

Voglio dire che la logger.isDebugEnabled() il controllo dovrebbe essere il compito della registrazione quadro, non è il mio lavoro.La maggior parte di registrazione supporto del framework di concetti come "logger", "Log"..che può fare il trucco.

Per rispondere direttamente alla tua domanda:Non so.

Ma qui è un'altra soluzione al tuo problema:Nella mia mente, ci sono due affermazioni che si scontrano tra di loro qui:"istruzioni di debug" e "codice di produzione".

Qual è lo scopo di istruzioni di debug?Aiutare a sbarazzarsi di bug mentre (l'unità) test.Se un pezzo di software è testato a dovere, ed opera secondo i requisiti, le istruzioni di debug non sono altro che OBSOLETI.

Non sono assolutamente d'accordo con il lasciare le istruzioni di debug nel codice di produzione.Scommetto che nessuno si preoccupa di test effetti collaterali di codice di debug nel codice di produzione.Il codice probabilmente fa quello che si suppone di fare, ma non fare di più?Non tutte le #definisce il lavoro correttamente e davvero di prendere il debug di codice?Che analizza 100000 linee di pre-trattati di codice per vedere se tutti i debug roba è andato?

A meno che non abbiamo una definizione diversa di codice di produzione, si deve prendere in considerazione le istruzioni di debug dopo il codice è testato e da fare con esso.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top