คำถามติดแท็ก java

ฉันทำงานเกี่ยวกับการออกแบบ แต่กดปุ่มสิ่งกีดขวางบนถนนต่อไป ฉันมีคลาสเฉพาะ (ModelDef) ที่เป็นหลักเจ้าของต้นไม้โหนดซับซ้อนที่สร้างขึ้นโดยการแยก XML schema (คิด DOM) ฉันต้องการปฏิบัติตามหลักการออกแบบที่ดี (SOLID) และตรวจสอบให้แน่ใจว่าระบบผลลัพธ์นั้นสามารถทดสอบได้ง่าย ฉันมีความตั้งใจที่จะใช้ DI เพื่อส่งผ่านการพึ่งพาในตัวสร้างของ ModelDef (เพื่อให้สามารถสลับสิ่งเหล่านี้ได้อย่างง่ายดายถ้าจำเป็นระหว่างการทดสอบ) แม้ว่าสิ่งที่ฉันกำลังดิ้นรนคือการสร้างทรีโหนด ต้นไม้นี้จะถูกสร้างขึ้นด้วยวัตถุ "ค่า" อย่างง่ายซึ่งไม่จำเป็นต้องทำการทดสอบอย่างอิสระ (อย่างไรก็ตามฉันยังอาจส่ง Abstract Factory ไปยัง ModelDef เพื่อช่วยในการสร้างวัตถุเหล่านี้) แต่ฉันอ่านต่อไปว่าคอนสตรัคเตอร์ไม่ควรทำงานจริงใด ๆ (เช่นFlaw: Constructor ทำงานจริง ) นี่เป็นเหตุผลที่เหมาะสมสำหรับฉันหาก "งานจริง" หมายถึงการสร้างวัตถุที่ต้องอาศัยน้ำหนักมากซึ่งในภายหลังอาจต้องการเริ่มต้นการทดสอบ (สิ่งเหล่านั้นควรถูกส่งผ่านทาง DI) แต่สิ่งที่เกี่ยวกับวัตถุค่าน้ำหนักเบาเช่นต้นไม้โหนดนี้ ต้องสร้างต้นไม้ที่ไหนสักแห่งใช่มั้ย ทำไมไม่สร้างผ่าน ModelDef (ใช้, พูด, buildNodeTree () วิธี)? ฉันไม่ต้องการสร้างทรีโหนดด้านนอกของ ModelDef แล้วผ่านมันใน …

23 java  design  design-patterns  dependency-injection  constructors 

คำถามนี้ถูกโยกย้ายจาก Code Exchange Stack Stack เพราะสามารถตอบได้ใน Software Engineering Stack Exchange อพยพ 5 ปีที่ผ่านมา ฉันรู้ว่าผลลัพธ์ไปยังคอนโซลเป็นการดำเนินการที่มีราคาแพง ในความสนใจของการอ่านรหัสบางครั้งมันก็ดีที่จะเรียกฟังก์ชั่นเพื่อส่งออกข้อความสองครั้งแทนที่จะมีสตริงข้อความยาวเป็นอาร์กิวเมนต์ ตัวอย่างเช่นมีประสิทธิภาพน้อยกว่าที่จะมี System.out.println("Good morning."); System.out.println("Please enter your name"); เมื่อเทียบกับ System.out.println("Good morning.\nPlease enter your name"); ในตัวอย่างความแตกต่างเป็นเพียงการโทรหนึ่งครั้งprintln()แต่จะเกิดอะไรขึ้นถ้ามีมากกว่านั้น ในหมายเหตุที่เกี่ยวข้องคำแถลงเกี่ยวกับการพิมพ์ข้อความอาจดูแปลกในขณะที่ดูซอร์สโค้ดหากข้อความที่จะพิมพ์ยาว ถ้าตัวอักษรไม่สามารถทำให้สั้นลงได้สิ่งที่สามารถทำได้? ควรเป็นกรณีที่มีการprintln()โทรหลายสายหรือไม่? มีคนเคยบอกฉันว่าบรรทัดของรหัสไม่ควรเกิน 80 อักขระ (IIRC) ดังนั้นคุณจะทำอย่างไร System.out.println("Good morning everyone. I am here today to present you with a very, …

23 java  c++  performance  c  io 

ไม่แน่ใจว่าจะไปเกี่ยวกับวิธีการนี้เพื่อลดความซับซ้อนของวัฏจักร โซนาร์รายงาน 13 ขณะที่ 10 คาดว่าจะเป็น ฉันแน่ใจว่าไม่มีอะไรเป็นอันตรายต่อการออกจากวิธีการนี้เหมือนเดิมอย่างไรก็ตามเพียงแค่ท้าทายฉันว่าจะทำตามกฎของ Sonar อย่างไร ความคิดใด ๆ ที่จะได้รับการชื่นชมอย่างมาก public static long parseTimeValue(String sValue) { if (sValue == null) { return 0; } try { long millis; if (sValue.endsWith("S")) { millis = new ExtractSecond(sValue).invoke(); } else if (sValue.endsWith("ms")) { millis = new ExtractMillisecond(sValue).invoke(); } else if (sValue.endsWith("s")) …

23 java  code-quality  refactoring  coding-standards  cyclomatic-complexity 

ปรากฏเป็นภาษาเดียวที่ไม่สามารถซ้อนความคิดเห็นได้ คุณมีทางออกที่ดีสำหรับปัญหานี้หรือไม่? วิธีแก้ปัญหาหนึ่งใน C / C ++ และ Java คือการใช้ความคิดเห็นบรรทัดเดียวเท่านั้น แต่มันเป็นไปไม่ได้ที่จะแสดงความคิดเห็นบล็อกขนาดใหญ่ ฉันกำลังเผชิญกับสิ่งนี้: </li><!-- <li><!-- Save --> ดังนั้นฉันต้องผ่านและแก้ไขความคิดเห็นด้วยตนเอง คุณช่วยแนะนำได้ไหมว่าเราควรจัดการเรื่องนี้ในหลาย ๆ ภาษา? ฉันไม่แน่ใจ แต่หลามอาจมีวิธีแก้ปัญหานี้ด้วย'''วิธีที่อาจรวมถึง#ความคิดเห็นในหลาม? `

23 java  c++  python  c  comments 

คำถามนี้ถูกโยกย้ายจาก Stack Overflow เพราะสามารถตอบได้ใน Software Engineering Stack Exchange อพยพ 7 ปีที่ผ่านมา ฉันเคยเห็นวัตถุที่สร้างขึ้นในรหัส Java โดยไม่ต้องจัดเก็บการอ้างอิงถึงวัตถุ ตัวอย่างเช่นในปลั๊กอิน eclipse ฉันเห็น SWT Shell ที่สร้างขึ้นเช่น: new Shell(); วัตถุเชลล์ใหม่นี้ไม่ได้เก็บไว้ในตัวแปร แต่จะยังคงอ้างอิงจนกว่าจะมีการกำจัดหน้าต่างซึ่ง [ฉันเชื่อว่า?] จะเกิดขึ้นตามค่าเริ่มต้นเมื่อปิดหน้าต่าง มันเป็นการปฏิบัติที่ไม่ถูกต้องหรือไม่ในการสร้างวัตถุเช่นนี้ หรือว่าห้องสมุดออกแบบมาไม่ดี? ถ้าฉันไม่ต้องการการอ้างอิง แต่ต้องการเพียง "ผลข้างเคียง" ของวัตถุ? ฉันควรจะเก็บข้อมูลอ้างอิงไว้หรือไม่? UPDATE: ชื่นชมตัวอย่างข้างต้นของฉันไม่ดี ในขณะที่ฉันได้เห็นองค์ประกอบ UI ที่สร้างขึ้นเช่นนี้การสร้าง SWT Shell แบบนี้อาจไม่มีจุดหมายเพราะคุณจำเป็นต้องเรียกใช้วิธีการเปิดบนอินสแตนซ์เชลล์ มีตัวอย่างที่ดีขึ้นโดย aixเช่นต่อไปนี้จากการสอนพร้อมกัน Java : (new HelloThread()).start(); การฝึกฝนนี้มีให้เห็นในหลายบริบทดังนั้นคำถามยังคงอยู่ เป็นการปฏิบัติที่ดีหรือไม่?

23 java 

ฉันทำงานเป็นเวลาสองปีในวาณิชธนกิจที่ยิ่งใหญ่ ฉันทำโครงการด้านเทคนิคบางอย่างด้วยความปรารถนาที่จะสร้างโค้ดที่มีประสิทธิภาพสูงสุดโดยคำนึงถึงรูปแบบการออกแบบที่ดีที่ปรับได้หลักการ SOLID กฎหมายของ demeter และหลีกเลี่ยงรหัสที่ซ้ำกันทุกประเภท ... เมื่อส่งมอบในการผลิต => ศูนย์ข้อบกพร่องทั้งหมดเกิดขึ้นตามที่คาดไว้ แต่นักพัฒนาส่วนใหญ่มาหาฉันเพื่อที่จะแม่นยำว่ารหัสของฉันทั้งหมดนั้นซับซ้อนเกินไปสำหรับการอ่านเพื่อความเข้าใจ ฉันฟังตัวอย่างเช่น: "ทำบางอย่างถ้าและอินสแตนซ์ของลืมความหลากหลายเพื่อที่จะแก้ไขข้อบกพร่องการผลิตฉุกเฉินได้อย่างง่ายดาย" ฉันไม่ชอบตอบ ...... การรู้ว่านักพัฒนาเหล่านี้ไม่อยากรู้อยากเห็นเลยปฏิเสธความพยายามที่จะเข้าใจการออกแบบที่ดี (ตัวอย่างเช่น 90% ของผู้พัฒนาไม่รู้ว่าอะไรคือรูปแบบกลยุทธ์และสร้างรหัสขั้นตอนและไม่เคยออกแบบเพราะพวกเขาต้องการ ) ผู้จัดการโครงการของฉันบอกว่าฉันผิดจริง ๆ และเป็นนักอุดมคติในโลกของธนาคาร คุณจะแนะนำอะไรให้ฉัน ฉันควรรักษาความปรารถนาของรหัสที่ดีจริง ๆ หรือปรับให้ฉันเป็นนักพัฒนาส่วนใหญ่ที่ฉันทำซ้ำไม่น่าสนใจจริงๆโดยการออกแบบรหัสตามที่ฉันความงามทั้งหมดของงานนักพัฒนาของเรา หรือในทางตรงกันข้ามพวกเขาควรเรียนรู้หลักการ OO ขั้นพื้นฐานและแนวปฏิบัติที่ดีที่สุดเพื่อปรับตัวให้เข้ากับรหัสของฉันหรือไม่?

23 java  design  design-patterns  solid 

ทีมมากกว่าที่ LMAX มีการนำเสนอเกี่ยวกับวิธีการที่พวกเขาสามารถที่จะทำ100k TPS ที่น้อยกว่า 1 มิลลิวินาทีแฝง พวกเขาได้รับการสนับสนุนขึ้นนำเสนอที่มีบล็อก , กระดาษทางเทคนิค (PDF)และรหัสที่มาของตัวเอง เมื่อเร็ว ๆ นี้มาร์ตินฟาวเลอร์ได้ตีพิมพ์บทความที่ยอดเยี่ยมเกี่ยวกับสถาปัตยกรรม LMAXและระบุว่าตอนนี้พวกเขาสามารถจัดการคำสั่งได้หกล้านคำสั่งต่อวินาทีและเน้นขั้นตอนบางอย่างที่ทีมทำเพื่อเพิ่มขนาดของประสิทธิภาพ จนถึงตอนนี้ฉันได้อธิบายแล้วว่ากุญแจสู่ความเร็วของ Business Logic Processor กำลังทำทุกอย่างตามลำดับในหน่วยความจำ เพียงแค่ทำสิ่งนี้ (และไม่มีอะไรโง่จริงๆ) ให้นักพัฒนาสามารถเขียนโค้ดที่สามารถประมวลผล 10K TPS จากนั้นพวกเขาพบว่าการมุ่งเน้นไปที่องค์ประกอบง่ายๆของรหัสที่ดีสามารถนำสิ่งนี้มาสู่ช่วง 100K TPS สิ่งนี้ต้องการเพียงรหัสที่ได้รับการรับรองและวิธีการเล็ก ๆ เท่านั้นซึ่งสิ่งนี้จะช่วยให้ฮอตสปอตทำงานได้ดีขึ้นในการเพิ่มประสิทธิภาพและเพื่อให้ซีพียูมีประสิทธิภาพมากขึ้นในการแคชโค้ดขณะที่ทำงานอยู่ ความฉลาดเพิ่มขึ้นอีกเล็กน้อยเพื่อให้ได้ลำดับความสำคัญมากขึ้น มีหลายสิ่งที่ทีม LMAX พบว่าเป็นประโยชน์ในการเดินทาง หนึ่งคือการเขียนการใช้งานที่กำหนดเองของคอลเลกชัน Java ที่ได้รับการออกแบบให้เป็นมิตรกับแคชและระมัดระวังกับขยะ อีกเทคนิคในการเข้าถึงระดับสูงสุดของประสิทธิภาพคือให้ความสนใจในการทดสอบประสิทธิภาพ ฉันสังเกตเห็นมานานแล้วว่าผู้คนพูดถึงเทคนิคต่าง ๆ มากมายเพื่อปรับปรุงประสิทธิภาพ แต่สิ่งหนึ่งที่สร้างความแตกต่างได้จริงๆคือการทดสอบ ฟาวเลอร์กล่าวว่ามีหลายสิ่งที่พบ แต่เขาพูดถึงเพียงคู่ มีสถาปัตยกรรมห้องสมุดเทคนิคหรือ "สิ่ง" อื่น ๆ ที่มีประโยชน์ในการเข้าถึงระดับประสิทธิภาพดังกล่าวหรือไม่

23 java  architecture  performance 

ในขณะที่มีโอเปอเรเตอร์ดังกล่าว - **ใน Python ฉันสงสัยว่าทำไม Java และ C ++ จึงไม่มีตัวนี้เช่นกัน มันง่ายที่จะสร้างคลาสที่คุณกำหนดใน C ++ พร้อมกับโอเปอเรเตอร์การบรรทุกเกินพิกัด (และฉันเชื่อว่ามันเป็นไปได้ใน Java) แต่เมื่อพูดถึงประเภทดั้งเดิมเช่น int, double และอื่น ๆ คุณจะต้องใช้ไลบรารี่ ฟังก์ชั่นเช่นMath.power(และมักจะต้องร่ายทั้งสองครั้ง) ดังนั้น - ทำไมไม่กำหนดผู้ประกอบการดังกล่าวสำหรับประเภทดั้งเดิม?

23 java  c++  python 

วันนี้ฉันได้พูดคุยกับเพื่อนร่วมงานเกี่ยวกับการตั้งชื่อfinalฟิลด์ในคลาส Java ในfinalฟิลด์โอปี้ของเขาควรได้รับการพิจารณาว่าเป็นค่าคงที่เนื่องจากค่าของมันจะไม่เปลี่ยนแปลงหลังจากการสร้างอินสแตนซ์ สิ่งนี้จะนำไปสู่หลักการตั้งชื่อต่อไปนี้สำหรับfinalฟิลด์: public class Foo { private static final String BLA_BLA = "bla"; private final String BAR_BATZ; ... } ในความเห็นของฉันstatic finalควรพิจารณาเฉพาะเขตข้อมูลในขณะที่เขตข้อมูลที่finalควรปฏิบัติตามหลักการตั้งชื่อ camelCase ตามปกติเท่านั้น public class Foo { private static final String BLA = "bla"; private final String barBatz; ... } ตอนนี้ฉันค่อนข้างไม่แน่ใจเพราะเขาเป็นโปรแกรมเมอร์ที่มีประสบการณ์มากกว่าฉันและฉันมักจะเห็นด้วยกับความคิดเห็นของเขาและถือว่าเขาเป็นนักพัฒนาที่ดีมาก ข้อมูลใด ๆ เกี่ยวกับเรื่องนี้?

23 java  naming  final 

รูปแบบโรงงาน (หรืออย่างน้อยใช้FactoryFactory..) เป็นก้นของตลกจำนวนมากเช่นที่นี่ นอกเหนือจากการมี verbose และชื่อ "สร้างสรรค์" เช่น RequestProcessorFactoryFactory.RequestProcessorFactoryแล้วมีอะไรผิดปกติกับรูปแบบของโรงงานถ้าคุณต้องโปรแกรมใน Java / C ++ และมี usecase สำหรับAbstract_factory_pattern ? ภาษายอดนิยมอื่นจะทำอย่างไร (เช่นRubyหรือScala ) จะหลีกเลี่ยงการใช้ภาษาในขณะที่จัดการความซับซ้อนที่คล้ายกันได้อย่างไร เหตุผลที่ฉันถามคือฉันเห็นคำวิจารณ์ส่วนใหญ่ของโรงงานที่กล่าวถึงในบริบทของระบบนิเวศJava / Java EEแต่พวกเขาไม่เคยอธิบายว่าภาษา / กรอบอื่น ๆ แก้ปัญหาได้อย่างไร

23 java  design-patterns 

ฉันกำลังทำงานกับแอปพลิเคชัน Spring-MVC ที่เราใช้ Maven สำหรับการจัดการการพึ่งพา เนื่องจากโครงการมีขนาดใหญ่เราจึงคิดแยกโครงการออกเป็นหลายส่วน ฉันมีข้อสงสัยบางอย่างซึ่งฉันหวังว่าจะได้รับคำตอบที่นี่ ขณะนี้เรากำลังปรับใช้ไฟล์ WAR ไฟล์เดียวเช่นเดียวROOT.warกับ Apache tomcat บนเซิร์ฟเวอร์ของเรา เนื่องจากโครงการมีขนาดใหญ่จึงมีบางส่วนในเว็บแอปเช่นการแจ้งเตือนและอีเมลบริการของบุคคลที่สาม PUSH (Cometd) REST API และอื่น ๆ ปัจจุบันทั้งหมดของพวกเขาอยู่ในสโมสรและขึ้นอยู่กับกันและกัน ตัวอย่างเช่นNotificationวัตถุยังขึ้นอยู่กับPersonวัตถุเนื่องจากการแจ้งเตือนนั้นได้รับการปรับแต่งสำหรับผู้ใช้ จุดประสงค์หลักของการแยกโครงการขนาดใหญ่คือการสามารถทำงานกับแต่ละโมดูลเพื่อแก้ไขข้อผิดพลาดการเพิ่มคุณสมบัติการทดสอบ ฯลฯ และเมื่อพอใจแล้วโมดูลนี้เท่านั้นที่สามารถถูกแทนที่บนเซิร์ฟเวอร์แทนแอปพลิเคชันทั้งหมด เป็นไปได้ไหม อย่างที่ฉันได้พูดไปแล้วก่อนหน้านี้มีการพึ่งพาและการจับคู่ระหว่างวัตถุ สิ่งเหล่านั้นจะได้รับการจัดการในโมดูลย่อยที่แตกต่างกันอย่างไรหรือเพียงแค่งบการนำเข้าจะเปลี่ยนเพื่อรวมโครงการอื่น ๆ ดังที่ฉันได้กล่าวไว้ความตั้งใจคือการทำงานกับแต่ละโมดูลและสามารถปรับใช้ (ดีกว่าร้อนกว่า) ปัจจุบันเรามีไฟล์ WAR ไฟล์เดียวROOT.warเท่านั้น การแยกจะสร้างไฟล์ war หลายไฟล์ซึ่งจะถูกเรียกโดย URL ว่าdomain-name.com/module_name/some_mapping? ขณะนี้ฉันกำลังตรวจสอบเอกสาร แต่นี่คือวัตถุประสงค์หลักที่เราต้องการบรรลุด้วยโมดูลที่จัดทำโดย Maven และสนใจที่จะรู้ว่าสิ่งนี้เป็นไปได้หรือไม่ หากมีข้อมูลเพิ่มเติมใด ๆ ที่จำเป็นโปรดแจ้งให้เราทราบ ขณะนี้ฉันกำลังใช้ POM ผู้ปกครองจากฤดูใบไม้ผลิดังนี้: <parent> …

23 java  design  architecture  web-development  maven 

ฉันเรียน Java แล้ว และหลังจากนั้นไม่นานฉันก็ไม่รู้ว่าทำไมชื่อโฟลเดอร์จึงเป็น "ถังขยะ"ซึ่งมีเครื่องมือสำหรับการค้นหาจาวาทั้งหมด มีเหตุผลใดที่เป็นเหตุผลอยู่เบื้องหลัง ฉันยังสังเกตเห็นเหมือนกันใน. Net framework ด้วย

23 java  terminology 

ฉันกำลังสร้าง API ซึ่งเป็นฟังก์ชันที่อัปโหลดไฟล์ ฟังก์ชั่นนี้จะไม่ส่งคืน / เป็นโมฆะหากไฟล์ถูกอัปโหลดอย่างถูกต้องและส่งข้อยกเว้นเมื่อเกิดปัญหา ทำไมมีข้อยกเว้นและไม่ใช่แค่ของเท็จ? เพราะภายในข้อยกเว้นฉันสามารถระบุสาเหตุของความล้มเหลว (ไม่มีการเชื่อมต่อชื่อไฟล์หายไปรหัสผ่านผิดรายละเอียดไฟล์หายไป ฯลฯ ) ฉันต้องการสร้างข้อยกเว้นที่กำหนดเอง (ด้วย enum บางอย่างเพื่อช่วยผู้ใช้ API ในการจัดการข้อผิดพลาดทั้งหมด) นี่เป็นวิธีปฏิบัติที่ดีหรือเป็นการส่งคืนวัตถุที่ดีกว่า (ภายในบูลีนข้อความแสดงข้อผิดพลาดเพิ่มเติมและ enum สำหรับข้อผิดพลาด) หรือไม่?

22 java  api-design  exceptions  functions  architectural-patterns 

มามีคลาส C # นี้ (มันจะเหมือนกันใน Java) public class MyClass { public string A {get; set;} public string B {get; set;} public override bool Equals(object obj) { var item = obj as MyClass; if (item == null || this.A == null || item.A == null) { return false; } return this.A.equals(item.A); …

22 java  c#  design  language-design  collections 

ที่ทำงานหนึ่งในโครงการของฉันส่วนใหญ่เกี่ยวกับการรับส่งข้อมูลจากไคลเอนต์ภายนอกและเก็บไว้ในฐานข้อมูล มันเป็นแอพพลิเคชั่นขององค์กร Java ที่ใช้ JPA และตรรกะส่วนใหญ่ของเราหมุนรอบการดำเนินการ CRUD ข้อบกพร่องส่วนใหญ่ของเราเกี่ยวข้องกับ JPA ไม่ทางใดก็ทางหนึ่ง ตัวอย่างที่ 1: ถ้าคุณคลิกปุ่มบันทึกสองครั้ง JPA อาจลองแทรกเอนทิตีเดียวกันในฐานข้อมูลเป็นครั้งที่สองทำให้เกิดการละเมิดคีย์หลัก ตัวอย่างที่ 2: คุณดึงเอนทิตีจากฐานข้อมูลแก้ไขและลองอัปเดตข้อมูล JPA อาจพยายามสร้างอินสแตนซ์ใหม่แทนการอัปเดตเก่า บ่อยครั้งที่โซลูชันต้องการเพิ่ม / ลบ / เปลี่ยนคำอธิบายประกอบ JPA บางครั้งก็เกี่ยวข้องกับการปรับเปลี่ยนตรรกะ DAO ฉันไม่สามารถหาวิธีที่จะมั่นใจในโค้ดของเราโดยใช้การทดสอบหน่วยและ TDD ฉันไม่แน่ใจว่าเป็นเพราะการทดสอบหน่วยและ TDD นั้นไม่เหมาะสมหรือถ้าฉันเข้าใกล้ปัญหาผิด การทดสอบหน่วยดูเหมือนจะไม่เหมาะสมเพราะฉันสามารถค้นพบปัญหาเหล่านี้ที่รันไทม์เท่านั้นและฉันจำเป็นต้องปรับใช้กับเซิร์ฟเวอร์แอปเพื่อสร้างปัญหาขึ้นมาใหม่ โดยปกติฐานข้อมูลจะต้องเกี่ยวข้องซึ่งฉันคิดว่าอยู่นอกนิยามของการทดสอบหน่วย: นี่คือการทดสอบการรวม TDD ดูเหมือนว่าไม่เหมาะสมเพราะการปรับใช้ + ข้อเสนอแนะการทดสอบช้ามากทำให้ฉันไม่ได้ผลมาก การปรับใช้ + ข้อเสนอแนะการทดสอบวนใช้เวลา 3 นาทีและนั่นก็ต่อเมื่อฉันรันการทดสอบเฉพาะเกี่ยวกับรหัสที่ฉันเขียน ในการรันการทดสอบการรวมระบบทั้งหมดจะใช้เวลา 30+ นาที มีรหัสอยู่นอกแม่พิมพ์นี้และฉันมักจะทดสอบหน่วยทุกครั้งที่ทำได้ แต่ข้อบกพร่องส่วนใหญ่ของเราและช่วงเวลาที่ยิ่งใหญ่ที่สุดมักเกี่ยวข้องกับ …

22 java  unit-testing  tdd  jpa