ควรจะมีการประกาศ“ ตัวบันทึกสุดท้ายแบบคงที่” ใน UPPER-CASE หรือไม่?

ใน Java ตัวแปรสแตติกสุดท้ายเป็นค่าคงที่และการประชุมคือว่าพวกเขาควรจะเป็นตัวพิมพ์ใหญ่ แต่ผมได้เห็นว่าคนส่วนใหญ่ประกาศตัดไม้ในกรณีที่ต่ำกว่าซึ่งขึ้นมาเป็นการละเมิดในPMD

เช่น:

private static final Logger logger = Logger.getLogger(MyClass.class);

เพียงค้นหาgoogleหรือSOเพื่อ "static final logger" และคุณจะเห็นสิ่งนี้ด้วยตัวคุณเอง

เราควรใช้ LOGGER แทนหรือไม่

การอ้างอิงตัวบันทึกไม่ใช่ค่าคงที่ แต่เป็นการอ้างอิงขั้นสุดท้ายและไม่ควรเป็นตัวพิมพ์ใหญ่ VALUE คงที่ควรเป็นตัวพิมพ์ใหญ่

private static final Logger logger = Logger.getLogger(MyClass.class);

private static final double MY_CONSTANT = 0.0;

เพื่อเพิ่มคุณค่าให้กับคำตอบของ crunchdog, คู่มือการเขียนโค้ดสไตล์ Javaระบุสิ่งนี้ในวรรค 3.3 การตั้งชื่อฟิลด์

ชื่อของเขตข้อมูลที่ใช้เป็นค่าคงที่ควรเป็นตัวพิมพ์ใหญ่ทั้งหมดโดยใช้เครื่องหมายขีดล่างเพื่อแยกคำ ต่อไปนี้จะถือว่าเป็นค่าคงที่:

1. static finalชนิดดั้งเดิมทั้งหมด(โปรดจำไว้ว่าเขตข้อมูลอินเทอร์เฟซทั้งหมดมีอยู่ในตัวstatic final)
2. static finalประเภทการอ้างอิงวัตถุทั้งหมดที่ไม่ตามด้วย " ." (จุด)
3. static finalอาร์เรย์ทั้งหมดที่ไม่เคยตามด้วย " [" (เปิดวงเล็บเหลี่ยม)

ตัวอย่าง:

MIN_VALUE, MAX_BUFFER_SIZE, OPTIONS_FILE_NAME

การปฏิบัติตามอนุสัญญาloggerนี้เป็นการstatic finalอ้างอิงวัตถุตามที่ระบุไว้ในจุดที่ 2 แต่เนื่องจากมีการติดตาม.ทุกครั้งที่คุณใช้ "" จึงไม่สามารถถือว่าเป็นค่าคงที่ได้ดังนั้นจึงควรเป็นตัวพิมพ์เล็ก

จากจาวาที่มีประสิทธิภาพ, 2nd ed.,

ข้อยกเว้นเพียงอย่างเดียวของกฎก่อนหน้านี้เกี่ยวข้องกับ "เขตข้อมูลคงที่" ซึ่งชื่อควรประกอบด้วยคำที่เป็นตัวพิมพ์ใหญ่หนึ่งคำหรือมากกว่าโดยคั่นด้วยอักขระขีดล่างเช่นค่าหรือ NEGATIVE_INFINITY เขตข้อมูลคงเป็นสนามสุดท้ายที่มีค่าคงที่จะไม่เปลี่ยนรูป หากฟิลด์สุดท้ายคงที่มีประเภทดั้งเดิมหรือประเภทอ้างอิงไม่เปลี่ยนรูป (รายการ 15) แสดงว่าเป็นฟิลด์คงที่ ตัวอย่างเช่นค่าคง enum เป็นเขตข้อมูลคงที่ ถ้าเขตข้อมูลสุดท้ายคงที่มีประเภทการอ้างอิงที่ไม่แน่นอนมันยังสามารถเป็นเขตคงที่ถ้าวัตถุอ้างอิงไม่เปลี่ยนรูป

โดยสรุปค่าคงที่ == เป็นค่าคงที่สุดท้ายบวกหากเป็นการอ้างอิง (เทียบกับประเภทแบบง่าย) ความไม่สามารถเปลี่ยนได้

กำลังดูตัวบันทึก slf4j, http://www.slf4j.org/api/org/slf4j/Logger.html

มันไม่เปลี่ยนรูป ในทางกลับกันตัวบันทึก JUL นั้นไม่แน่นอน ตัวบันทึก log4j นั้นยังไม่แน่นอน ดังนั้นเพื่อให้ถูกต้องหากคุณใช้ log4j หรือ JUL ควรเป็น "logger" และหากคุณใช้ slf4j ก็ควรเป็น LOGGER

โปรดทราบว่าหน้า slf4j javadocs ที่ลิงก์ด้านบนมีตัวอย่างที่ใช้ "logger" ไม่ใช่ "LOGGER"

หลักสูตรเหล่านี้เป็นเพียงการประชุมและไม่ใช่กฎ หากคุณกำลังใช้งาน slf4j และคุณต้องการใช้ "logger" เพราะคุณคุ้นเคยกับสิ่งนี้จากเฟรมเวิร์กอื่น ๆ หรือถ้าพิมพ์ได้ง่ายกว่าหรืออ่านง่ายกว่า

ฉันชอบสิ่งที่ Google ทำ ( Google Java Style )

ค่าคงที่ทุกค่าเป็นเขตข้อมูลสุดท้ายคงที่ แต่ไม่ใช่เขตข้อมูลสุดท้ายคงที่ทั้งหมดเป็นค่าคงที่ ก่อนเลือกกรณีคงที่พิจารณาว่าสนามรู้สึกเหมือนเป็นค่าคงที่หรือไม่ ตัวอย่างเช่นหากสถานะใด ๆ ที่สังเกตได้ของอินสแตนซ์นั้นสามารถเปลี่ยนแปลงได้มันก็แทบจะไม่แน่นอน ตั้งใจจะไม่กลายพันธุ์วัตถุโดยทั่วไปไม่เพียงพอ

ตัวอย่าง:

// Constants
static final int NUMBER = 5;
static final ImmutableList<String> NAMES = ImmutableList.of("Ed", "Ann");
static final Joiner COMMA_JOINER = Joiner.on(',');  // because Joiner is immutable
static final SomeMutableType[] EMPTY_ARRAY = {};
enum SomeEnum { ENUM_CONSTANT }

// Not constants
static String nonFinal = "non-final";
final String nonStatic = "non-static";
static final Set<String> mutableCollection = new HashSet<String>();
static final ImmutableSet<SomeMutableType> mutableElements = ImmutableSet.of(mutable);
static final Logger logger = Logger.getLogger(MyClass.getName());
static final String[] nonEmptyArray = {"these", "can", "change"};

หากคุณใช้เครื่องมืออัตโนมัติเพื่อตรวจสอบมาตรฐานการเข้ารหัสของคุณและมันละเมิดมาตรฐานดังกล่าวคุณควรแก้ไขหรือกำหนดมาตรฐาน หากคุณใช้มาตรฐานภายนอกแก้ไขรหัส

การประชุมใน Sun Java เป็นตัวพิมพ์ใหญ่สำหรับค่าคงที่สาธารณะ เห็นได้ชัดว่าคนตัดไม้ไม่คงที่ แต่หมายถึงสิ่งที่ไม่แน่นอน (มิฉะนั้นจะไม่มีวิธีการเรียกจุดด้วยความหวังว่าสิ่งที่จะเกิดขึ้น); ไม่มีมาตรฐานเฉพาะสำหรับฟิลด์สุดท้ายที่ไม่คงที่

หากคุณทำสิ่งนี้กับ Google คุณอาจพบว่าในบางกรณีตัวบันทึกไม่ได้ถูกกำหนดให้เป็นแบบสแตติก เพิ่ม copy-n-paste แบบย่อลงในส่วนนี้และสิ่งนี้อาจอธิบายได้

เราใช้ LOGGERในทุกรหัสของเราและสิ่งนี้สอดคล้องกับแบบแผนการตั้งชื่อของเรา (และ CheckStyle ของเรามีความสุขกับมัน)

เรายิ่งไปกว่านั้นใช้ประโยชน์จากระเบียบการตั้งชื่อที่เข้มงวดใน Eclipse เราสร้างคลาสใหม่ด้วยเทมเพลตรหัสของ:

    // private static final Logger LOGGER = Logger.getLogger(${enclosing_type}.class);

คนตัดไม้ออกความเห็นเป็นครั้งแรกที่เราไม่ต้องการมัน แต่ถ้าเราต้องการมันในภายหลังเราแค่ไม่ใส่คอมมัน

จากนั้นในรหัสเราใช้เทมเพลตรหัสที่คาดว่าจะมีคนตัดไม้นี้ ตัวอย่างที่มีเทมเพลต try-catch:

    try {
      ${cursor} or some other template
    } catch (Exception t) {
      LOGGER.error("${methodName} ${method parameters}", t);
    }

เรามีเทมเพลตอีกเล็กน้อยที่ใช้งาน

การประชุมที่เข้มงวดทำให้เรามีประสิทธิผลและเชื่อมโยงกับเทมเพลตโค้ดมากขึ้น

โดยส่วนตัวฉันคิดว่ามันดูใหญ่มากในตัวพิมพ์ใหญ่ นอกจากนี้เนื่องจากเป็นระดับที่มันไม่ได้เกี่ยวข้องโดยตรงกับพฤติกรรมการเรียนที่ผมไม่เห็นเป็นปัญหาสำคัญในการใช้แทนlogger แต่ถ้าคุณจะไปได้อวดความรู้อย่างเคร่งครัดการใช้งานแล้วLOGGERLOGGER

อย่าลืมว่า PMD จะเคารพความคิดเห็นด้วย

// NOPMD

ในนั้น. นี่จะทำให้ PMD ข้ามสายจากการตรวจสอบซึ่งจะช่วยให้คุณสามารถเลือกรูปแบบที่คุณต้องการ

ค่าคงที่มักจะเป็นตัวพิมพ์ใหญ่

อย่างไรก็ตาม Loggers ไม่ควรอยู่นิ่ง ๆ แต่มองหา "ใหม่" ของคลาสที่มีอยู่ทุกครั้งหากใช้ซุ้ม slf4j วิธีนี้จะช่วยหลีกเลี่ยงปัญหา classloader ที่น่ารังเกียจในเว็บคอนเทนเนอร์โดยเฉพาะและอนุญาตให้เฟรมเวิร์กตัวบันทึกทำสิ่งพิเศษขึ้นอยู่กับบริบทการเรียกใช้

ฉันชอบ 'คนตัดไม้' เช่นตัวพิมพ์เล็ก เหตุผลไม่ใช่ว่าเป็นค่าคงที่หรือไม่คงที่ (ไม่แน่นอนหรือไม่เปลี่ยนรูป) ถ้าเราใช้เหตุผลนั้นเราต้องเปลี่ยนชื่อตัวแปรถ้าเราเปลี่ยนเฟรมเวิร์กการบันทึก (หรือถ้าเฟรมเวิร์กเปลี่ยนความไม่แน่นอนของตัวบันทึก)

สำหรับฉันเหตุผลอื่นมีความสำคัญมากกว่า

1. คนตัดไม้เป็นวัตถุเงาในชั้นเรียนและไม่ควรโดดเด่นมากเพราะไม่ได้ใช้ตรรกะหลัก ถ้าเราใช้ 'LOGGER' มันเป็นสิ่งที่ดึงดูดสายตาในโค้ดที่ดึงดูดความสนใจมากเกินไป

2. บางครั้งตัวบันทึกจะถูกประกาศในระดับอินสแตนซ์ (เช่นไม่ใช่แบบคงที่) และแม้กระทั่งถูกฉีดเป็นการพึ่งพา ฉันไม่ต้องการเปลี่ยนรหัสของฉันถ้าฉันตัดสินใจที่จะเปลี่ยนวิธีที่ฉันได้รับคนตัดไม้ ความเสถียรของรหัส wrt การเปลี่ยนแปลงนี้ (สมมุติในหลาย ๆ กรณี) เป็นอีกเหตุผลหนึ่งที่ฉันชอบตัวพิมพ์เล็ก

หากมาตรฐานการเข้ารหัสของคุณ - ถ้าคุณมี - บอกว่าควรเป็นตัวพิมพ์ใหญ่ใช่แล้ว

ฉันไม่เห็นเหตุผลที่เข้มงวดในทางใดทางหนึ่ง ฉันคิดว่ามันขึ้นอยู่กับความชอบส่วนตัวของคุณ มาตรฐานการเข้ารหัส บริษัท ของคุณ

BTW: ฉันชอบ "LOGGER" ;-)