Java Logging With Abstract Classes

Question

Pracuję nad projektem i obecnie pracuję nad implementacją niektórych logów z log4j i byłem ciekawy, jak powinienem wdrożyć dzienniki. Obie implementacje jestem kopanie wokół są następujące:

Pierwsza opcja

Zastosowanie pojedynczego dziennika z super klasy dla tej klasy i wszystkie klasy podrzędne:

public abstract class AbstractFoo { 
    protected static Log LOG = LogFactory.getLog(AbstractFoo.class); 

    ... 
} 

public class Foo extends AbstractFoo { 
    public void someMethod() { 
     LOG.info("Using abstract log"); 
    } 
} 

Druga opcja

Stosuj indywidualne dzienniki dla każdej klasy, super i sub:

public abstract class AbstractFoo { 
    private static Log LOG = LogFactory.getLog(AbstractFoo.class); 

    ... 
} 

public class Foo extends AbstractFoo { 
    private static Log LOG = LogFactory.getLog(Foo.class);   

    public void someMethod() { 
     LOG.info("Using own log"); 
    } 
} 

Co ma większy sens i dlaczego?

Answer 1

Ja też bym nie zrobił. Zamiast tego sprawiłbym, że użyłaby odpowiedniej klasy w obu przypadkach.

public abstract class AbstractFoo { 
    protected final Log log = LogFactory.getLog(getClass()); 

    ... 
} 

public class Foo extends AbstractFoo { 
    public void someMethod() { 
     log.info("Using abstract log"); 
    } 
} 

Jeśli nie robisz dużo rejestrowania (i tak jest dobry pomysł), możesz zamiast tego użyć metody.

public abstract class AbstractFoo { 
    protected Log log() { return LogFactory.getLog(getClass()); } 

    ... 
} 

Jeśli istnieje klasa, która nazywa to dużo, można ją przesłonić, aby uzyskać instancję z pamięci podręcznej.

Answer 2

Oba mają sens. To zależy od twojej aplikacji.

Myślę, że częściej stosowaną praktyką jest posiadanie prywatnego rejestratora dla każdej klasy. Pozwala to skonfigurować logowanie zarówno w klasie, jak i w pakiecie. Pamiętaj, że AbstractFoo i Foo mogą należeć do różnych pakietów i prawdopodobnie chcesz zobaczyć tylko dzienniki z Foo.

Ponadto zawsze dwa razy pomyśleć, jeśli chcesz napisać pole protected. Nie jest to całkowicie zabronione, ale dobrze znana zła praktyka. Dzięki temu twój kod jest mniej czytelny i trudny do utrzymania.

Answer 3

Jeśli utworzysz program rejestrujący w klasie abstrakcyjnej, wszystkie dzienniki będą oznaczane jako pochodzące z AbstractFoo. Jeśli chcesz/potrzebujesz zobaczyć dzienniki otagowane klasą potomną, z której powstał log, utwórz rejestratory dla klas dzieci.

Answer 4

To jest moje rozwiązanie (końcowe rejestratora statyczny):

public abstract class AbstractFoo { 
    protected Log getLogger(); 
    public doSomething() { 
      getLogger().info("log something"); 
    } 
} 

public class Foo extends AbstractFoo { 
    private static final Log log = Log.getLogger(Foo.class); 

    protected Log getLogger() { 
     return log; 
    } 
    public doSomethingElse() { 
      log.info("log somethingElse"); 
    } 
} 

Answer 5

To samo można osiągnąć grając z konstruktorów. Dodaj rejestrator na poziomie klasy i ustaw go z każdej klasy za pomocą super(). Jest kod:

public abstract class AbstractFoo { 

    protected Log log; // base abstract class has a Log object. 

    public AbstractFoo(Log logger) { // parameterized constructor for logger, to be used by the derived class. 
     this.log = logger; 
    } 

    public doSomething() {  // common method for all the derived classes. 
     log.info("log something"); 
    } 
    // rest of business logic. 
} 

public class Foo extends AbstractFoo { 

    public Foo(){ 
     super(LogFactory.getLog(AbstractFoo.class)); 
    } 

    public void someMethod() { 
     log.info("Using own log");  // this uses its own logger. 
    } 
}