คำแนะนำสำหรับนักพัฒนา Java ในอนาคต องค์กร - ตอนที่ 1

“อย่าภูมิใจกับความสำเร็จทางเทคโนโลยีที่คุณสร้างขึ้นมากเกินไป ความสามารถในการทำลายดาวเคราะห์นั้นเทียบไม่ได้กับพลังแห่งพลัง" - ดาร์ธ เวเดอร์ บนดาวมรณะ

บทนำ

อาจเป็นไปได้ว่าบทความสองส่วนถัดไปของซีรีส์นี้เป็นบทความที่หลาย ๆ คนคาดหวังมากที่สุดและด้วยเหตุผลที่ดี มีอะไรนอกเหนือจากขอบฟ้า นอกเหนือจาก Java บริสุทธิ์? นักพัฒนา Java หายใจอะไรในทุกโครงการ? ลองพิจารณาคู่มือนี้เพื่อศึกษาด้วยตนเองฉบับสมบูรณ์สำหรับวิศวกรแบ็คเอนด์ทั่วไป ที่มีภาษาโปรแกรมหลักคือ Java ฉันตั้งใจที่จะครอบคลุมค่าเฉลี่ยของโรงพยาบาลให้มากที่สุดเท่าที่จะเป็นไปได้ และไม่เพียงแต่อธิบายกรอบการทำงานที่ได้รับความนิยมมากที่สุดเท่านั้น แต่ยังรวมถึงโซลูชันที่ถือว่ามีความเกี่ยวข้องในขณะนี้ด้วย แน่นอนว่ามีเครื่องมือมากมาย และการทำความเข้าใจสิ่งที่สำคัญที่สุดและดีที่สุดก็คือหนทางสู่ความไม่มีที่ไหนเลย พวกคุณแต่ละคนดูที่ส่วน "งาน"ใน DOU และพบกองเทคโนโลยีที่มีการทำซ้ำอย่างต่อเนื่องจากตำแหน่งที่ว่างไปยังตำแหน่งที่ว่าง ฉันเข้าใจว่ามันเป็นไปไม่ได้ที่จะอธิบายทุกอย่าง แต่การคิดกรอบการทำงานทั่วไปก็เป็นเรื่องปกติ ดังนั้นเรามาลองทำตามคำแนะนำนี้กัน ในอดีตในโครงการใดโครงการหนึ่งมีความลำบากใจค่อนข้างน่าสนใจเกิดขึ้นซึ่งฉันคิดว่าเกิดขึ้นและเกิดขึ้นซ้ำแล้วซ้ำอีกสำหรับหลาย ๆ คนในพื้นที่ใดพื้นที่หนึ่ง งานได้รับการตั้งค่าให้แนบการเรนเดอร์หน้า HTML หนึ่งหน้าเข้ากับฟังก์ชันการทำงานที่เสร็จสมบูรณ์เพียงเพื่อแสดงสถานะของเอนทิตีแต่ละรายการ ด้วยเหตุนี้ เพื่อนร่วมงานของฉันจึงตัดสินใจแนบ Spring thymeleaf ซึ่งดึงส่วนหนึ่งของการพึ่งพาหลักของ Spring เอง เมื่อไม่มีใครใช้ Spring และทั้งหมดนี้เป็นเพียงเพจปกติหน้าเดียวซึ่งแสดงสถานะของเอนทิตี 2-3 รายการ "ฉันไม่เคยเห็นประโยชน์มากนักในการใช้ไลท์เซเบอร์สองอัน...มันเป็นการแสดงความเห็นในความคิดของฉัน" - โอบีวัน เคโนบี ในแง่หนึ่ง นักพัฒนาแก้ไขปัญหาได้โดยเร็วที่สุด ติดตั้งเฟรมเวิร์กที่เขามีประสบการณ์ใช้และรวมเข้ากับโปรเจ็กต์ภายในเวลาไม่กี่ชั่วโมง แต่ในทางกลับกัน โปรแกรมของเรามีขนาดใหญ่ขึ้น ดังนั้นคำถามง่ายๆ จึงกลายเป็น: เขาทำสิ่งที่ถูกต้องหรือไม่? สำหรับงานอะตอมมิก เมื่อคุณรู้แน่นอนว่า thymeleaf/Spring MVC ฯลฯ นี้ใหญ่กว่า จะไม่ใช้ที่ไหนเลยอย่าใช้เลยจะดีกว่า ฉันมักจะประหลาดใจกับวลีเช่น “โอ้! ใช่ เราใช้ Hibernate ที่นี่! ดูสิ ทุกอย่างเยี่ยมเลย ORM!” และเมื่อถามคำถามเชิงตรรกะว่า JDBC ปกติจะผ่านที่นี่ไปได้หรือเปล่า พวกเขาก็ยักไหล่ มีสถาปัตยกรรมธรรมดาซึ่งควรจะเรียบง่ายซึ่งควรได้รับการปฏิบัติด้วยความกังวลใจไม่เกะกะด้วยกรอบที่ทันสมัยและทันสมัยสุด ๆ ดังที่ Obi-Wan กล่าวข้างต้น นี่ไม่ใช่อะไรมากไปกว่าการอวดอ้าง แม้ว่าจะจำเป็นต้องรู้วิธีใช้งานก็ตาม ในความคิดของฉัน Javaist รุ่นเยาว์เป็นคนที่โชคร้ายที่สุด - มีข้อกำหนดมากมายและมีห้องสมุดมากมายที่ต้องศึกษา Java EE เพียงอย่างเดียวมีเอกสารประกอบผ่านหลังคา คำถามเกิดขึ้น ผู้เริ่มต้นควรทำอะไร เขาควรเรียนรู้อะไรต่อไป เขาควรทำอะไรหลังจาก Horstmann? คำตอบง่ายๆ น่าเสียดาย พบปะผู้คนมากมาย และเราจะไม่เริ่มต้นด้วยกรอบทางธุรกิจ แต่ด้วยสิ่งที่จำเป็นทางโลกมากกว่า

ระบบปฏิบัติการ

ลินุกซ์

นอกจาก Windows และ/หรือ Yosemite ที่สะดวกสบายแล้ว คุณยังต้องยกมือขึ้นสู่ Linux ด้วยรอยยิ้ม สำหรับบางโครงการ แค่เป็นผู้ใช้และรู้วิธีใช้บรรทัดคำสั่งก็เพียงพอแล้วสำหรับโครงการอื่น ๆ อีกมากมาย วิธีไหนดีที่สุด? มีหนังสือ/บทช่วยสอนมากมายบนอินเทอร์เน็ต เริ่มต้นด้วยการติดตั้งUbuntuหรือการแจกจ่ายอื่น ๆ ที่คุณต้องการและลองใช้เป็นระบบปฏิบัติการหลักของคุณในเดือนหรือสองเดือนถัดไป จะดีกว่ามากหากคุณเริ่มเรียนรู้ Java ภายใน Linux โดยการคอมไพล์และจัดการไฟล์โดยใช้เทอร์มินัล บรรทัดคำสั่ง Linux โดย William Shotts อ่านหนังสือเล่มนี้ไม่ใช่ในรูปแบบนวนิยาย "50 Shades of Grey" แต่เป็นหลักสูตรเชิงโต้ตอบเต็มรูปแบบ - เปิดเทอร์มินัลแล้วทำซ้ำตามผู้เขียน คุณต้องการพื้นฐานและ Linux ทำงานอย่างไร? เราจะไม่เรียนหลักสูตรวิทยาการคอมพิวเตอร์และระบบปฏิบัติการอีกต่อไป - ที่อยู่ในส่วนถัดไป ไปที่edx.orgและลองใช้ หลักสูตร Introduction to Linuxแบบ ง่ายๆ นอกจากนี้ยังมีหนังสือจากซีรีส์ที่กล่าวถึงข้างต้นว่าLinux ทำงานอย่างไร: สิ่งที่ผู้ใช้ระดับสูงทุกคนควรรู้ โดย Brian Ward สิ่งพิมพ์ที่มีภาพประกอบค่อนข้างชัดเจนซึ่งให้ความสำคัญกับระบบเครือข่าย อุปกรณ์ และการจัดการทรัพยากร ไปข้างหน้า? มีหนังสือดีๆ เล่มหนึ่ง ซึ่งฉันมีอยู่ที่ไหนสักแห่งที่นี่... ใช่แล้ว (ฝุ่นผง)... นี่ไง! Unix และ Linux: คู่มือผู้ดูแลระบบ เอวี เนเมธ. คู่มือค่อนข้างใหญ่ แปลได้ดี พูดตามตรง โดยส่วนตัวแล้วฉันไม่เชี่ยวชาญเรื่องนี้ แต่ฉันชอบพื้นฐานของการบริหารงานมาก (ส่วนแรก) โดยปกติแล้ว คุณไม่สามารถละเลยสคริปต์เชลล์ได้ จะดีกว่าถ้าลองทั้งหมดนี้ในทางปฏิบัติ แต่จากหนังสือคุณสามารถดูการเรียนรู้ bash Shell: การเขียนโปรแกรม Unix Shell โดย Cameron Newham บทความจำนวนมากบน Linux/Unix ไม่สามารถครอบคลุมได้ทั้งหมด โดยเฉพาะในบทความนี้ ซึ่งมี Linux อยู่เบื้องหลัง เพื่อนร่วมงานของฉันในที่ทำงานซึ่งกินสุนัขในเรื่องนี้แนะนำสิ่งที่ค่อนข้างใช้งานได้จริง: ดาวน์โหลด ArchLinux และลองเริ่มต้นใช้งาน ในกระบวนการนี้คุณจะได้เรียนรู้สิ่งที่ฉันไม่ต้องการมากที่สุด!

หน้าต่าง

ในประวัติย่อของโปรแกรมเมอร์มีคอลัมน์: “ประสบการณ์ Windows มากกว่า 10 ปี” แน่นอน ฉันขอแสดงความยินดีกับคุณที่คุณเล่นเคาน์เตอร์ตั้งแต่อายุ 10 ขวบบน Windows แต่ฉันขอให้คุณอย่าขุดหลุมล่วงหน้าในการสัมภาษณ์ เพราะในโครงการที่คุณทำงานอย่างใกล้ชิดด้วย IIS, แบทช์/พาวเวอร์เชลล์, พระเจ้าห้าม, การลงทะเบียน, การสัมภาษณ์จะไม่ใช่เรื่องยากจริงๆ และนอกจากรอยยิ้มตรงข้ามกับคนที่นั่งอยู่ ลิดาคุณยังจะได้รับความอัปยศอดสูอีกด้วย คุณต้องการสิ่งนี้หรือไม่? คำตอบนั้นบ่งบอกตัวมันเอง เก็บ Windows ที่ละเมิดลิขสิทธิ์ของคุณออกจากทอร์เรนต์แล้วลองติดตั้งบนเครื่องเสมือน Windows Server บางประเภท ไม่เพียงศึกษาจากฝั่งผู้ใช้และการติดตั้ง JAVA_HOME เท่านั้น ในเรื่องนี้มีคำ แนะนำ ที่เกือบจะสมบูรณ์อยู่ในรูปแบบของหนังสือMastering Windows Server 2012 R2 โดย Mark Minasi ตัวอย่างเช่น หากคุณใช้ PowerShell ลองดูหนังสือที่ยอดเยี่ยมWindows PowerShell in ActionโดยManning โดย Bruce Payette ฉันเข้าใจว่าเป็นไปไม่ได้ที่จะอ่านเกิน 1,000 หน้า แต่อย่างน้อยคุณก็สามารถเก็บไว้เป็นข้อมูลอ้างอิงได้ ฉันคิดว่าไม่มีอะไรจำเป็นอีกแล้ว ด้วยเหตุนี้ ให้ใส่ใจกับช่องว่างในความรู้เกี่ยวกับการใช้ Windows และค้นหาข้อมูลที่คุณสนใจบนอินเทอร์เน็ต

สร้างเครื่องมือ

มาเวน

สิ่งที่สำคัญที่สุดที่ต้องเข้าใจใน Maven คืออะไร? นี่คือขั้นตอนแรกและงาน:

1. เรียนรู้สิ่งที่ Maven ทำในแต่ละช่วง คุณยังสามารถจดจำได้ นี่เป็นความสำเร็จเกือบ 80% และจะทำให้คุณเห็นภาพที่ชัดเจน
2. สร้างโปรเจ็กต์แซนด์บ็อกซ์ของคุณเองภายในเครื่องด้วยระบบหลายโมดูล พร้อมการจัดการการขึ้นต่อกันที่ชัดเจน ลองแนบไลบรารีของบุคคลที่สามลองสร้างบางสิ่งโดยใช้ไลบรารีเหล่านั้น
3. เล่นกับโปรไฟล์
4. ทำความเข้าใจการจัดการปลั๊กอินและศึกษารายการปลั๊กอินยอดนิยมบนเว็บไซต์อย่างเป็นทางการ
5. สำรวจว่าคุณสามารถใช้ Maven ในโปรเจ็กต์ของคุณให้เกิดประโยชน์สูงสุดได้อย่างไร ตัวอย่างเช่น การสร้างแบบขนานสามารถลดเวลาในการสร้างได้อย่างมาก

หากต้องการเจาะลึกอย่างรวดเร็ว ให้ไปที่เว็บไซต์ Apache Mavenเวอร์ชันภาษารัสเซียค้นหาบทช่วยสอนสองสามรายการบน Google อย่างไรก็ตาม หนังสือเล่มหลักเล่มหนึ่งใน Maven ฉบับที่สามจะยังไม่มีการเปิดตัว จนถึงตอนนี้ นี่ เป็นฉบับที่สองของMaven: The Definitive Guide ของ Sonatype สำหรับระดับสูง การสร้างปลั๊กอินของคุณเองก็เหมาะสม ไม่ต้องกังวลว่าคุณต้องสร้างปลั๊กอินประเภทใด เนื่องจากมีอยู่แล้วหลายปลั๊กอิน! พยายามสร้างอะนาล็อกบางประเภท ศึกษาขั้นตอนเป็นสองและสอง

มด

เครื่องมือนี้ดูง่ายกว่ามาก ดังนั้นจึงไม่มีอะไรต้องเรียนรู้มากนักที่นี่ ยังมีโปรเจ็กต์ที่ ANT เป็นเครื่องมือสร้างเพียงตัวเดียว นี่เป็นเรื่องปกติอย่างยิ่ง: ANT ได้พิสูจน์ตัวเองแล้วว่าเป็นเครื่องมือสร้างที่เรียบง่ายและตรงไปตรงมาในบริบทของการจัดการงานปรมาณูขนาดเล็ก (งานมด) แน่นอนว่ามีปลั๊กอินมากมายที่นี่ เช่นเดียวกับ Maven ในการเริ่มต้นใช้งาน ANT ให้ทำดังต่อไปนี้:

• ลองจัดการไฟล์และโฟลเดอร์
• ใช้คำสั่งต่าง ๆ เพื่อดำเนินงาน จากสิ่งนี้ เรียนรู้การพึ่งพาและลำดับความสำคัญของงานใน ANT
• แตกไฟล์และ/หรือไฟล์ zip ในงานลองเล่นกับเนื้อหาของไฟล์เก็บถาวรเป็นต้น

ไม่จำเป็นต้องเสนอแหล่งข้อมูลมากมายสำหรับการเรียนรู้ ANT หากต้องการเจาะลึกไม่มากก็น้อย หน้า Apache Ant อย่างเป็นทางการก็เพียงพอแล้ว ( ant.apache.org ) และหนังสือAnt in Action โดย Steve Loughran

เกรเดิล

สำหรับฉัน Gradle นั้นใกล้ชิดกับ ANT มากกว่า Maven แต่ก็สามารถเรียกได้ว่าเป็นน้องชายต่างแม่ของทั้งสองคนนี้เลย มีวงจรชีวิตคล้ายกับ Maven และมีความยืดหยุ่นของงานเดียวกันกับที่ ANT มี สิ่งที่สำคัญที่สุดคือ Gradle ไม่ได้ใช้ XML และยิ่งไปกว่านั้น คุณสามารถทำทุกอย่างที่คุณต้องการได้หากคุณคุ้นเคยกับ Groovy ไม่มากก็น้อย โดยทั่วไปแล้วค่อนข้างอร่อย อย่ากลัวที่จะใช้ Ant/Maven/Gradle ในบริบทของ IDE ของคุณ เครื่องมือเหล่านี้ผสานรวมเข้ากับ Eclipse/IDEA อย่างแน่นหนา และการใช้เครื่องมือเหล่านี้ในบริบทของ IDE ก็ค่อนข้างสะดวกสบาย

การบูรณาการอย่างต่อเนื่อง

ทฤษฎี

นี่คือโปรแกรมเทวดาที่ปกป้องคุณจากการถูกไล่ออก กล่าวโดยสรุป นี่คือซอฟต์แวร์ที่ติดตามการเปลี่ยนแปลงในโค้ด สร้างและรันการทดสอบที่เขียนขึ้นสำหรับคุณ หากทุกอย่างเรียบร้อยดีหลังจากการคอมมิต/ผสานแต่ละครั้ง โครงสร้างจะเรืองแสงเป็นแสงสีเขียว/สีน้ำเงินที่น่าพึงพอใจ ทันทีที่คุณทำสิ่งของเสียหาย ระบบ CI จะรายงานทันที อย่างไรก็ตาม มีทฤษฎีเล็กน้อย - นี่มันคลาสสิก! การบูรณาการอย่างต่อเนื่อง: การปรับปรุง คุณภาพซอฟต์แวร์และการลดความเสี่ยง โดย Paul Duvall (หรือที่รู้จักในชื่อ “Continuous Integration” ในภาษารัสเซีย) หนังสือเล่มนี้กล่าวถึงการสร้างระบบ CI ของคุณเองด้วย ลองดูโซลูชันยอดนิยมสองรายการในพื้นที่นี้

เจนกินส์

เจนกินส์ หรือที่รู้จักในชื่อ ฮัดสัน แอปพลิเคชั่นที่เปิดกว้าง เป็นมิตร ใช้งานง่าย หากต้องการทำความคุ้นเคยกับ Jenkins ให้มากขึ้น ให้ลองทำดังนี้:

1. ดาวน์โหลดลงในคอมพิวเตอร์ของคุณ ติดตั้งและกำหนดค่า JDK, Maven, ANT และทุกสิ่งที่คุณต้องการสำหรับโปรเจ็กต์
2. สร้างงานแรกและระบุตำแหน่งของโปรเจ็กต์ของคุณ เช่น main pom.xml เรียกใช้ตรวจสอบให้แน่ใจว่าคุณมีการทดสอบบางอย่างเพื่อให้มองเห็นได้ชัดเจน
3. เรียนรู้วิธีดำเนินโครงการของคุณด้วยการตั้งค่าและตัวเลือกต่างๆ
4. แนบปลั๊กอินต่างๆ และดูวิธีการทำงานร่วมกับโปรเจ็กต์ของคุณ
5. สร้างทริกเกอร์สำหรับงานต่างๆ สร้างไปป์ไลน์ขนาดเล็ก
6. สำรวจ DSL และลองรวมเข้ากับ Jenkins
7. ตั้งค่าทาสจากคอมพิวเตอร์เครื่องอื่นและ/หรือทำให้เป็นเครื่องปกติสำหรับการรันบิลด์
8. สร้างงานสร้างยามค่ำคืน

จากหนังสือ แค่อ่านJenkins: The Definite Guide โดย John Ferguson Smart คำแนะนำที่ชัดเจนพร้อมภาพหน้าจอมากมาย

ทีมซิตี้

ใช่ TeamCity ไม่ใช่บริการฟรี แต่ดูว่า TeamCity สามารถรวมเข้ากับระบบนิเวศของผลิตภัณฑ์ JetBrains ได้ดีเพียงใด Intellij Idea และ TeamCity เป็นสหภาพที่ยอดเยี่ยม โดยทั่วไปแล้ว หากคุณคุ้นเคยกับ Jenkins อยู่แล้ว TeamCity จะไม่เป็นป่ามืดมนสำหรับคุณ และในทางกลับกัน แทนที่จะเป็นทาส - ตัวแทนทริกเกอร์เดียวกันเป็นต้น แต่ TeamCity ต่างจาก Jenkins ตรงที่มีฟีเจอร์ที่น่าทึ่งมากมาย เช่น การวิ่งระยะไกล หรือที่เรียกว่าการคอมมิตที่ทดสอบล่วงหน้า สถิติเชิงภาพอีกมากมาย และอื่นๆ อีกมากมาย ฉันชอบคู่มือผู้ใช้บน YouTube ซึ่ง JetBrains สร้างขึ้นเองมาก ( คู่มือผู้ใช้ TeamCity (ตอนที่ 1 จาก 9) - บทนำ ) ฉันพบว่า TeamCity นั้นใช้งานง่ายและเอกสารประกอบก็มีมาตรฐานระดับสูง แต่ถ้าคุณคิดว่ามีหนังสือเล่มไหนน่าอ่านก็ฝากไว้ในความคิดเห็นได้นะครับ แน่นอนว่าฉันได้ระบุเพียงส่วนเล็กๆ ของระบบ CI เหล่านี้ แต่เรามีทุกอย่างที่จำกัดในขอบเขต แนวทางการเรียนรู้ที่ดีที่สุดน่าจะเป็นการฝึกฝน ฉันติดตั้งมันบนคอมพิวเตอร์ของฉัน เปิดใช้งานมัน ขัดข้อง/กู้คืนบิลด์และเข้านอน จากนั้นคุณสามารถนำสมุดบันทึกมาให้ฉันได้อย่างปลอดภัย (ถ้าคุณต้องการ :)

ระบบควบคุมเวอร์ชัน

ไม่มีประโยชน์ที่จะพูดถึง VCS มากนัก มันเป็นเพียงสิ่งที่ควรจะเป็น และหากไม่มีการจัดการโครงการใดก็จะเป็นเหมือนยุคมีโซโซอิก เช่นเดียวกับระบบ CI เรามาดูโซลูชันยอดนิยมสองรายการกัน: Git และ SVN

คอมไพล์

Git ของเราได้พิสูจน์ตัวเองแล้วว่าเป็นระบบควบคุมเวอร์ชันแบบกระจายที่มีความเสถียร เริ่มเรียนรู้จากที่นี่และอ่านบททั้งหมดด้วย Git ที่กำหนดค่าไว้แล้ว นอกจากนี้ยังมีชุดบทช่วยสอนแบบโต้ตอบที่ยอดเยี่ยมจาก Code School นอกจากนี้ยังมีคำแนะนำสั้นๆ จากพวกเขาที่เรียกว่า Try Git: Code School จากหนังสือฉันสามารถแนะนำVersion Control with Git โดย Jon Loeliger หากคุณคุ้นเคยกับเต่ามาก (TortoiseSVN บันทึกของผู้เขียน) และกลัวคอนโซล คุณสามารถดาวน์โหลด TortoiseGit แบบอะนาล็อกได้แน่นอน แต่ในความคิดของฉัน น่าพึงพอใจและสวยงามยิ่งขึ้น โซลูชันนี้เป็นผลิตภัณฑ์จาก Atlassian - SourceTreeApp คุณสามารถฝึกฝนกับพื้นที่เก็บข้อมูลระยะไกลได้ เนื่องจากมีบริการโฮสต์เพียงพอบนอินเทอร์เน็ต หากคุณต้องการฝึกอบรมในพื้นที่ เลขที่? จากนั้นสร้างบัญชีบน GitHub และทำงานในโหมดเต็ม: สร้างการคอมมิต 2-3 โปรเจ็กต์โอเพ่นซอร์ส ทำการผสานระหว่างสาขา และอื่นๆ

เอสวีเอ็น

VCS อีกตัวที่ได้รับความนิยมไม่แพ้กันคือ SVN ระบบนี้ไม่สามารถอวดอ้างการกระจายได้ แต่ละคนมีแนวทางของตัวเองข้อดีและข้อเสียของตัวเอง อย่าลืมอ่านบทสนทนาที่น่าสนใจระหว่างมือใหม่และผู้ใช้ SVN มีหนังสือฟรีจาก read-bean.comพร้อมคำแปลภาษารัสเซีย หลักสูตรสั้นๆ จาก TutorialsPointก็มีประโยชน์อย่างยิ่งเช่นกัน อย่าพลาดเว็บไซต์อย่างเป็นทางการของApache subversion.apache.org ลูกค้าที่น่าสนใจที่สุดสำหรับฉันคือ TortoiseSVN ที่กล่าวมาข้างต้น ในบรรดาหนังสือมีไฮไลท์อยู่: Version Control with Subversion โดย Michael Pilato ฉันชอบมันเพราะมันใส่ใจกับการดูแลระบบเซิร์ฟเวอร์ SVN เอง ฉันหวังว่าฉันจะไม่พลาดประเด็นหลัก

เครื่องมือทดสอบ

เป็นความคิดที่ดีที่จะทำความเข้าใจในโครงการแซนด์บ็อกซ์ขนาดเล็กของคุณว่าการทดสอบหน่วย การบูรณาการ และการทดสอบการถดถอยคืออะไร JUnit ทฤษฎีการทดสอบหน่วยมีการอธิบายไว้อย่างดีในหนังสือจากบทความที่แล้ว โดยเฉพาะอย่างยิ่ง Clean Code ยังอธิบายว่า Junit เป็นหนึ่งในไลบรารียอดนิยมในพื้นที่นี้ แต่เมื่อพูดถึง JUnit โดยเฉพาะ มีหนังสือเล่มเล็กๆ ดีๆ เล่มหนึ่งชื่อ Practical Unit Testing with JUnit และ Mockito โดย Tomek Kaszanowski แน่นอนว่า มีอะไรมากกว่านั้นมากกว่า JUnit และ Mockito ที่นี่ผู้เขียนจะแนะนำ Matchers เสนอตัวอย่างการทดสอบแบบกำหนดพารามิเตอร์ และอธิบาย TDD สั้นๆ มีหนังสือเล่มหนึ่งที่เพิ่งออกไม่นานนี้ด้วย นี่คือPragmatic Unit Testing ใน Java 8 โดย Jeff Langr ผู้เขียนแนะนำ Hamcrest อธิบาย Best Practices และแน่นอนว่า Java 8 คุณสามารถอ่านหนังสือของ Tomek ได้อย่างปลอดภัย ว่าด้วยเรื่อง TDD ฉันไม่อยากจะพูดถึงว่ามันคุ้มค่าที่จะใช้มัน ดีหรือไม่ดี ไม่ว่าลูกค้าต้องการมันก็ตาม เพียงจำไว้ว่า: การทำงานใน TDD ไม่ใช่เรื่องแปลกใหม่ และหลายโครงการใช้วิธีการนี้ และสำหรับหลาย ๆ คน นี่เป็นกฎเดียวที่เถียงไม่ได้ ตามทฤษฎีแล้ว คุณสามารถอ่านหนังสือคลาสสิกได้ Kent Beck - การพัฒนาแบบทดสอบ: ตามตัวอย่าง สิ่งที่ฉันชอบมากที่สุดคือส่วนที่เกี่ยวกับรูปแบบ TDD น่าแปลกที่มีหลักสูตรมุมมองบุคคลที่หนึ่งที่ดี - มาเล่น TDD (200 วิดีโอ!) บน Youtube กันดีกว่า สิ่งที่น่าสนใจไม่น้อยคือการอภิปรายของ Fowlerเกี่ยวกับว่าการใช้ TDD คุ้มค่าหรือไม่ ไม่ว่าการออกแบบจะเสียหรือไม่ และอื่นๆ ที่คล้ายกัน เพียงจำไว้ครั้งหนึ่งและตลอดไป: TDD ไม่ได้สร้างการออกแบบที่ไม่ดี คุณสร้างมันขึ้นมา หากคุณใช้ BDD มากกว่า (อันหนึ่งไม่รบกวนอีกอัน) และตัวอย่างเช่น ใช้ Cucumber ในโปรเจ็กต์ นี่จะเป็นระนาบที่แตกต่างออกไปเล็กน้อย หนังสือที่ดีเกี่ยวกับเรื่องนี้คือManning BDD in Action: การพัฒนาที่ขับเคลื่อนด้วยพฤติกรรมสำหรับวงจรชีวิตซอฟต์แวร์ทั้งหมด โดย John Ferguson Smart อย่างไรก็ตาม John Ferguson Smart กำลังส่งเสริมหัวข้อนี้ต่อสาธารณชนอย่างแข็งขัน หากคุณเป็น Scrum Master หรือ PM ที่ไม่ทำให้เสียสายตาในที่สุด แต่สนุกกับการดูการทดสอบเมื่อ-ถ้า-แล้ว อย่าลืมติดตามJohn บน Twitter เกี่ยวกับ Cucumber ดูที่การใช้งาน Java บนเว็บไซต์อย่างเป็นทางการและอ่านหนังสือThe Cucumber Book: Behavior-Driven Development โดย Matt Wayne

ห้องสมุดบุคคลที่สาม

สิ่งสำคัญคือต้องสามารถใช้ไลบรารี่ยอดนิยมได้เมื่อจำเป็น - ทำให้ชีวิตประจำวันของ Java Developer ทุกคนง่ายขึ้น โซลูชันยอดนิยมมีดังต่อไปนี้: Joda Time เสนอให้แทนที่วันที่และเวลาดั้งเดิมที่ไม่สะดวกอย่างสมบูรณ์ด้วย JodaTime ที่สะดวกยิ่งขึ้น นี่เป็นข้อมูลอ้างอิงที่ดีอย่าง หนึ่ง โปรดทราบว่าหากคุณใช้ Java 8 อยู่แล้ว JodaTime จะไม่ช่วยอะไรได้มากนัก ความจริงก็คือ DateTime API ใหม่ได้เข้ามาแทนที่ไลบรารีนี้โดยสิ้นเชิง และในบางที่ก็คัดลอกและวางอย่างชาญฉลาดด้วยซ้ำ ตามบทความของผู้เขียนเองทุกคลาส Joda สามารถแทนที่ด้วยอะนาล็อกจาก java.time ได้อย่างสะดวก กูเกิล ฝรั่ง. ในหลาย ๆ ด้าน Java 8 ยังมาแทนที่ Guava อีกด้วย Objects, Stream API, Java Predicate และอื่นๆ อีกมากมายที่เหมือนกัน แนะนำให้แทนที่และไม่ใช้เลย ฉันขอย้ำอีกครั้งหากคุณไม่มี Java 8 ไม่มีอะไรดีไปกว่าคู่มือนี้และมือโดยตรงของคุณ

อาปาเช่คอมมอนส์

สัตว์ประหลาดตัวนี้ไม่ใช่เรื่องง่ายที่จะจัดการ: ประมาณ 40 ไลบรารี่สำหรับทุกโอกาส ตั้งแต่การตรวจสอบ commons.lang ที่รู้จักกันดีไปจนถึง xml จาก DBUtils ไปจนถึง commons.io โดยปกติแล้ว คุณไม่จำเป็นต้องทำความคุ้นเคยกับทุกสิ่ง แต่หนังสือตำราอาหารและแบบฝึกหัดจะมีประโยชน์ในการพกติดตัวไปด้วย ตัวอย่างเช่น เพื่อทำความเข้าใจว่า Apache Commons คืออะไร คุณสามารถดูจากJakarta Commons Cookbook โดย Timothy O'Brein

บทสรุป

Enterprise มีขนาดใหญ่มากจนเป็นเรื่องโง่ที่จะเริ่มพูดคุยเกี่ยวกับ JavaEE และเฟรมเวิร์กอื่น ๆ โดยไม่มีทุกสิ่งที่อยู่รอบ ๆ Enterprise นี้ ดังนั้นในส่วนที่สอง เราจะมุ่งเน้นไปที่แต่ละเลเยอร์ของสถาปัตยกรรมหลายระดับ พิจารณาบริการและอื่นๆ ขอบคุณมากสำหรับความสนใจของคุณ จบภาคแรก. ส่วนก่อนหน้าของซีรีส์:

1. คำแนะนำสำหรับนักพัฒนา Java ในอนาคต พื้นฐานจาวา
2. คำแนะนำสำหรับนักพัฒนา Java ในอนาคต รหัสที่หรูหรา

ต้นฉบับกับ DOU