सार कक्षाओं के साथ जावा लॉगिंग

Question

मैं एक परियोजना पर काम कर रहा हूं, और वर्तमान में लॉग 4j के साथ कुछ लॉगिंग लागू करने पर काम कर रहा हूं और मैं इस बारे में उत्सुक था कि मुझे लॉग को लागू करने के बारे में कैसे जाना चाहिए।

उपयोग उस वर्ग के लिए सुपर क्लास से एकल प्रवेश और सभी उप वर्गों

पहला विकल्प:

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

दूसरा ऑप्शन

दो कार्यान्वयन मैं चारों ओर लात हूँ इस प्रकार हैं

प्रत्येक वर्ग, सुपर और सबस के लिए अलग-अलग लॉग का उपयोग करें:

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

क्या अधिक समझ में आता है और क्यों?

Answer 1

मैं या तो नहीं करूँगा। इसके बजाय मैं इसे दोनों मामलों में सही वर्ग का उपयोग कर दूंगा।

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

    ... 
} 

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

यदि आप बहुत सारे लॉगिंग नहीं कर रहे हैं (जो कि एक अच्छा विचार है) तो आप इसके बजाय एक विधि का उपयोग कर सकते हैं।

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

    ... 
} 

यदि कोई कक्षा है जो इसे बहुत कहती है तो आप इसे कैश किए गए उदाहरण देने के लिए ओवरराइड कर सकते हैं।

Answer 2

दोनों समझ में आते हैं। यह आपके आवेदन पर निर्भर करता है।

मुझे लगता है कि अधिकतर प्रयुक्त अभ्यास प्रत्येक वर्ग के लिए निजी लॉगर होना है। यह आपको प्रति वर्ग और प्रति पैकेज दोनों लॉगिंग कॉन्फ़िगर करने की अनुमति देता है। याद रखें, AbstractFoo और Foo विभिन्न पैकेजों से संबंधित हो सकता है और शायद आप केवल Foo से लॉग देखना चाहते हैं।

अगर आप protected फ़ील्ड लिखना चाहते हैं तो हमेशा दो बार सोचें। यह पूरी तरह से प्रतिबंधित नहीं है लेकिन एक प्रसिद्ध बुरी प्रथा है। यह आपके कोड को कम पठनीय और बनाए रखने में मुश्किल बनाता है।

Answer 3

यदि आप अमूर्त वर्ग में लॉगर बनाते हैं, तो लॉग सभी सारणीफू से उत्पन्न होने के रूप में टैग किए जाएंगे। यदि आप चाहते हैं कि बच्चे वर्ग के साथ टैग किए गए लॉग को देखना है, जिसमें लॉग आया है, तो बच्चों के वर्गों के लिए लॉगर्स बनाएं।

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 4

यह मेरा समाधान (अंतिम स्थिर लकड़हारा) है। बेस श्रेणी स्तर पर लकड़हारा जोड़े और हर व्युत्पन्न वर्ग का उपयोग कर सुपर से यह सेट()। कोड है:

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

Answer 5

ही कंस्ट्रक्टर्स के साथ खेल के द्वारा प्राप्त किया जा सकता है: