บทที่ 1 สวัสดี นิพจน์แลมบ์ดา!
โค้ด Java ของเราพร้อมสำหรับการเปลี่ยนแปลงที่น่าทึ่ง งานประจำวันที่เราทำจะง่ายขึ้น ง่ายขึ้น และแสดงออกได้มากขึ้น วิธีใหม่ในการเขียนโปรแกรม Java ถูกนำมาใช้มานานหลายทศวรรษในภาษาอื่น ด้วยการเปลี่ยนแปลง Java เหล่านี้ เราสามารถเขียนโค้ดที่กระชับ สวยงาม และแสดงออกได้ชัดเจนและมีข้อผิดพลาดน้อยลง เราสามารถใช้สิ่งนี้เพื่อใช้มาตรฐานได้อย่างง่ายดาย และใช้รูปแบบการออกแบบทั่วไปโดยใช้โค้ดน้อยลง ในหนังสือเล่มนี้ เราจะสำรวจรูปแบบการทำงานของการเขียนโปรแกรมโดยใช้ตัวอย่างปัญหาที่เราทำทุกวัน ก่อนที่เราจะเจาะลึกสไตล์ที่หรูหรานี้และวิธีการพัฒนาซอฟต์แวร์ใหม่นี้ เรามาดูกันว่าเหตุใดจึงดีกว่านี้เปลี่ยนความคิดของคุณ
สไตล์ที่จำเป็นคือสิ่งที่ Java มอบให้เราตั้งแต่เริ่มก่อตั้งภาษา สไตล์นี้แนะนำให้เราอธิบายให้ Java ฟังทุกขั้นตอนของสิ่งที่เราต้องการให้ภาษาทำ และจากนั้นเราก็ตรวจสอบให้แน่ใจว่าได้ปฏิบัติตามขั้นตอนเหล่านั้นอย่างซื่อสัตย์ มันใช้งานได้ดี แต่ก็ยังอยู่ในระดับต่ำ โค้ดมีรายละเอียดมากเกินไป และเรามักต้องการภาษาที่ฉลาดกว่านี้เล็กน้อย จากนั้นเราก็สามารถพูดได้อย่างเปิดเผย - สิ่งที่เราต้องการ และไม่เจาะลึกว่าต้องทำ อย่างไร ต้องขอบคุณนักพัฒนาที่ทำให้ Java สามารถช่วยเราทำสิ่งนี้ได้ ลองดูตัวอย่างเล็กๆ น้อยๆ เพื่อทำความเข้าใจถึงประโยชน์และความแตกต่างระหว่างแนวทางเหล่านี้วิธีปกติ
เริ่มต้นด้วยพื้นฐานที่คุ้นเคยเพื่อดูกระบวนทัศน์ทั้งสองในทางปฏิบัติ วิธีนี้ใช้วิธีการที่จำเป็นในการค้นหาเมืองชิคาโกในคอลเล็กชันเมือง - รายชื่อในหนังสือเล่มนี้จะแสดงเฉพาะข้อมูลโค้ดเท่านั้นboolean found = false; for(String city : cities) { if(city.equals("Chicago")) { found = true; break; } } System.out.println("Found chicago?:" + found); โค้ดเวอร์ชันที่จำเป็นนั้นมีสัญญาณรบกวน (คำนี้เกี่ยวอะไรกับมัน?) และระดับต่ำมีหลายส่วนที่ไม่แน่นอน ขั้นแรกเราสร้างแฟล็กบูลีนที่มีกลิ่นเหม็นที่เรียกว่า
foundจากนั้นเราจะวนซ้ำแต่ละองค์ประกอบในคอลเลกชัน หากเราพบเมืองที่เราต้องการ เราจะตั้งค่าสถานะให้
เป็นจริงและทำลายวงจรนั้น ในที่สุดเราก็พิมพ์ผลลัพธ์การค้นหาของเราไปยังคอนโซล
มีวิธีที่ดีกว่า
ในฐานะโปรแกรมเมอร์ Java ผู้สังเกตการณ์ การดูโค้ดนี้เพียงชั่วครู่สามารถเปลี่ยนโค้ดให้มีความหมายมากขึ้นและอ่านง่ายขึ้นได้ เช่น นี่System.out.println("Found chicago?:" + cities.contains("Chicago")); คือตัวอย่างของรูปแบบการประกาศ - เมธอด contains() ช่วยให้เราเข้าถึงสิ่งที่เราต้องการได้โดยตรง
การเปลี่ยนแปลงที่เกิดขึ้นจริง
การเปลี่ยนแปลงเหล่านี้จะนำมาซึ่งการปรับปรุงโค้ดของเราในปริมาณที่เหมาะสม:- ไม่ยุ่งยากกับตัวแปรที่ไม่แน่นอน
- การวนซ้ำจะถูกซ่อนไว้ภายใต้ประทุน
- ความยุ่งเหยิงของโค้ดน้อยลง
- ความชัดเจนของโค้ดที่มากขึ้น เน้นความสนใจ
- ความต้านทานน้อยลง รหัสติดตามจุดประสงค์ทางธุรกิจอย่างใกล้ชิด
- โอกาสที่จะเกิดข้อผิดพลาดน้อยลง
- เข้าใจและสนับสนุนได้ง่ายขึ้น
นอกเหนือจากกรณีง่ายๆ
นี่เป็นตัวอย่างง่ายๆ ของฟังก์ชันการประกาศที่ตรวจสอบการมีอยู่ขององค์ประกอบในคอลเลกชัน ซึ่งถูกใช้มาเป็นเวลานานใน Java ตอนนี้ ลองนึกภาพว่าไม่ต้องเขียนโค้ดที่จำเป็นสำหรับการดำเนินการขั้นสูง เช่น การแยกวิเคราะห์ไฟล์ การทำงานกับฐานข้อมูล การร้องขอบริการเว็บ การสร้างมัลติเธรด ฯลฯ ตอนนี้ Java ทำให้สามารถเขียนโค้ดที่กระชับและสวยงามได้ ซึ่งทำให้ยากขึ้นที่จะทำผิดพลาด ไม่ใช่แค่ในการดำเนินการง่ายๆ แต่ตลอดทั้งแอปพลิเคชันของเราทางเก่า
ลองดูอีกตัวอย่างหนึ่ง เรากำลังสร้างคอลเลกชันที่มีราคาและจะลองหลายวิธีในการคำนวณผลรวมของราคาที่ลดแล้วทั้งหมด สมมติว่าเราถูกขอให้สรุปราคาทั้งหมดที่มีมูลค่าเกิน $20 พร้อมส่วนลด 10% ขั้นแรกเรามาทำสิ่งนี้ด้วยวิธี Java ปกติกันก่อน โค้ดนี้น่าจะคุ้นเคยกับเราเป็นอย่างดี ขั้นแรกเราสร้างตัวแปรที่เปลี่ยนแปลงได้ TotalOfDiscountedPricesซึ่งเราจะเก็บค่าผลลัพธ์ไว้ จากนั้นเราจะวนรอบการรวบรวมราคา เลือก ราคาที่สูงกว่า $20 รับราคาที่มีส่วนลด และเพิ่มมูลค่านั้นลงใน TotalOfDiscountedPrices ในตอนท้ายเราจะแสดงผลรวมของราคาทั้งหมดโดยคำนึงถึงส่วนลดด้วย ด้านล่างนี้คือสิ่งที่ส่งออกไปยังคอนโซลfinal List
prices = Arrays.asList( new BigDecimal("10"), new BigDecimal("30"), new BigDecimal("17"), new BigDecimal("20"), new BigDecimal("15"), new BigDecimal("18"), new BigDecimal("45"), new BigDecimal("12"));
BigDecimal totalOfDiscountedPrices = BigDecimal.ZERO; for(BigDecimal price : prices) { if(price.compareTo(BigDecimal.valueOf(20)) > 0) totalOfDiscountedPrices = totalOfDiscountedPrices.add(price.multiply(BigDecimal.valueOf(0.9))); } System.out.println("Total of discounted prices: " + totalOfDiscountedPrices);
ราคาลดรวม : 67.5มันใช้งานได้ แต่โค้ดดูยุ่งเหยิง แต่ไม่ใช่ความผิดของเรา เราใช้สิ่งที่มีอยู่ รหัสอยู่ในระดับค่อนข้างต่ำ - มันทนทุกข์ทรมานจากการหมกมุ่นอยู่กับสิ่งดั้งเดิม (google it สิ่งที่น่าสนใจ) และมันบินไปเผชิญกับหลักการ ความรับผิดชอบเดียว พวกเราที่ทำงานที่บ้านควรเก็บโค้ดดังกล่าวให้ห่างจากสายตาของเด็ก ๆ ที่ต้องการเป็นโปรแกรมเมอร์ ซึ่งอาจเตือนจิตใจที่เปราะบางของพวกเขา ให้เตรียมพร้อมสำหรับคำถามที่ว่า "นี่คือสิ่งที่คุณต้องทำเพื่อความอยู่รอด"
มีวิธีที่ดีกว่าอีกวิธีหนึ่ง
ตอนนี้เราสามารถทำได้ดีขึ้น ดีขึ้นมาก รหัสของเราอาจมีลักษณะคล้ายกับข้อกำหนดเฉพาะ ซึ่งจะช่วยให้เราลดช่องว่างระหว่างความต้องการทางธุรกิจและโค้ดที่นำไปใช้ และลดโอกาสที่ความต้องการจะถูกตีความผิดอีกด้วย แทนที่จะสร้างตัวแปรแล้วเปลี่ยนแปลงซ้ำๆ เรามาทำงานในระดับนามธรรมที่สูงกว่ากัน เช่นในรายการต่อไปนี้final BigDecimal totalOfDiscountedPrices = prices.stream() .filter(price -> price.compareTo(BigDecimal.valueOf(20)) > 0) .map(price -> price.multiply(BigDecimal.valueOf(0.9))) .reduce(BigDecimal.ZERO, BigDecimal::add); System.out.println("Total of discounted prices: " + totalOfDiscountedPrices); มาอ่านออกเสียงกัน - ตัวกรองราคามีค่ามากกว่า 20 แมป (สร้างคู่ "คีย์" "มูลค่า") โดยใช้คีย์ "ราคา" ราคารวมส่วนลดแล้วเพิ่มเข้าไป
- ความคิดเห็นของนักแปล หมายถึง คำที่ปรากฏในหัวของคุณขณะอ่านโค้ด .filter(price -> price.compareTo(BigDecimal.valueOf(20)) > 0)รหัสถูกดำเนินการร่วมกันในลำดับตรรกะเดียวกันกับที่เราได้อ่าน โค้ดถูกทำให้สั้นลง แต่เราใช้สิ่งใหม่ๆ มากมายจาก Java 8 อันดับแรก เราเรียกเมธอด stream() ในรายการ ราคา นี่เป็นการเปิดประตูสู่ตัววนซ้ำแบบกำหนดเองพร้อมชุดฟีเจอร์อำนวยความสะดวกมากมายที่เราจะกล่าวถึงในภายหลัง แทนที่จะวนซ้ำค่าทั้งหมดใน รายการ ราคา โดยตรง เราใช้วิธีการพิเศษหลายวิธี เช่น filter()และ map( ) ต่างจากวิธีที่เราใช้ใน Java และ JDK วิธีการเหล่านี้ใช้ฟังก์ชันที่ไม่ระบุชื่อ - นิพจน์แลมบ์ดา - เป็นพารามิเตอร์ในวงเล็บ เราจะศึกษารายละเอียดเพิ่มเติมในภายหลัง โดยการเรียก เมธอด ลด()เราจะคำนวณผลรวมของค่า (ราคาลด) ที่ได้รับในเมธอด map() การวนซ้ำจะถูกซ่อนในลักษณะเดียวกับเมื่อใช้ เมธอด contains( ) อย่างไรก็ตามวิธีการ filter()และ map() นั้นมีความซับซ้อนมากยิ่งขึ้น สำหรับแต่ละราคาใน รายการ ราคาจะเรียกฟังก์ชัน lambda ที่ส่งผ่านแล้วบันทึกลงในคอลเลกชันใหม่ วิธี การลด ()ถูกเรียกใช้ในคอลเลกชันนี้เพื่อสร้างผลลัพธ์สุดท้าย ด้านล่างนี้คือสิ่งที่ส่งออกไปยังคอนโซล
ราคาลดรวม : 67.5
การเปลี่ยนแปลง
ด้านล่างนี้คือการเปลี่ยนแปลงที่เกี่ยวข้องกับวิธีการปกติ:- รหัสก็สบายตาและไม่เกะกะ
- ไม่มีการดำเนินการระดับต่ำ
- ง่ายต่อการปรับปรุงหรือเปลี่ยนแปลงตรรกะ
- การวนซ้ำถูกควบคุมโดยไลบรารีของวิธีการ
- การประเมิน แบบ Lazy Loop ที่มีประสิทธิภาพ
- ขนานกันได้ง่ายขึ้นตามต้องการ
แลมบ์ดาเพื่อช่วยเหลือ :)
Lambda เป็นกุญแจสำคัญในการช่วยให้เราพ้นจากความยุ่งยากในการเขียนโปรแกรมที่จำเป็น ด้วยการเปลี่ยนวิธีการเขียนโปรแกรมด้วยคุณสมบัติล่าสุดของ Java เราจึงสามารถเขียนโค้ดที่ไม่เพียงแต่สวยงามและกระชับเท่านั้น แต่ยังเกิดข้อผิดพลาดน้อยลง มีประสิทธิภาพมากขึ้น และง่ายต่อการเพิ่มประสิทธิภาพ ปรับปรุง และสร้างมัลติเธรดรับรางวัลใหญ่จาก Functional Programming
รูปแบบการเขียนโปรแกรมเชิงฟังก์ชันมี อัตราส่วนสัญญาณต่อเสียงรบกวนที่ สูงกว่า เราเขียนโค้ดน้อยลง แต่แต่ละบรรทัดหรือนิพจน์มีฟังก์ชันการทำงานมากกว่า เราได้รับเพียงเล็กน้อยจากโค้ดเวอร์ชันที่ใช้งานได้เมื่อเปรียบเทียบกับความจำเป็น:- เราหลีกเลี่ยงการเปลี่ยนแปลงหรือการกำหนดตัวแปรที่ไม่ต้องการ ซึ่งเป็นสาเหตุของข้อผิดพลาด และทำให้ยากต่อการประมวลผลโค้ดจากเธรดต่างๆ ในเวลาเดียวกัน ในเวอร์ชันที่จำเป็น เราตั้งค่าที่แตกต่าง กัน สำหรับตัวแปร TotalOfDiscountedPricesตลอดทั้งลูป ในเวอร์ชันการทำงาน ไม่มีการเปลี่ยนแปลงที่ชัดเจนในตัวแปรในโค้ด การเปลี่ยนแปลงน้อยลงทำให้เกิดข้อบกพร่องในโค้ดน้อยลง
- เวอร์ชันที่ใช้งานได้ของโค้ดนั้นง่ายต่อการขนานกัน แม้ว่าการคำนวณในเมธอด map() จะมีความยาว แต่เราก็สามารถคำนวณแบบคู่ขนานได้โดยไม่ต้องกลัวสิ่งใดเลย หากเราเข้าถึงโค้ด รูปแบบความจำเป็นจากเธรดต่างๆ เราจะต้องกังวลเกี่ยวกับการเปลี่ยนแปลง ตัวแปร TotalOfDiscountedPrices ในเวลาเดียวกัน ในเวอร์ชันการทำงาน เราจะเข้าถึงตัวแปรหลังจากทำการเปลี่ยนแปลงทั้งหมดแล้วเท่านั้น ซึ่งทำให้เราไม่ต้องกังวลเกี่ยวกับความปลอดภัยของเธรดของโค้ด
- รหัสมีความหมายมากขึ้น แทนที่จะดำเนินการโค้ดในหลายขั้นตอน เช่น การสร้างและเริ่มต้นตัวแปรด้วยค่าจำลอง การวนซ้ำรายการราคา การบวกราคาส่วนลดให้กับตัวแปร และอื่นๆ เราเพียงแค่ขอให้เมธอด map() ของรายการส่งคืนรายการอื่น ของราคาที่ลดแล้วบวกเพิ่ม
- รูปแบบการทำงานมีความกระชับมากขึ้น: ต้องใช้โค้ดน้อยกว่าเวอร์ชันที่จำเป็น โค้ดที่กะทัดรัดยิ่งขึ้นหมายถึงเขียนน้อยลง อ่านน้อยลง และบำรุงรักษาง่ายขึ้น
- โค้ดเวอร์ชันใช้งานได้นั้นใช้งานง่ายและเข้าใจง่าย เมื่อคุณทราบไวยากรณ์แล้ว เมธอดmap()ใช้ฟังก์ชันที่ส่งผ่าน (ซึ่งคำนวณราคาลด) กับแต่ละองค์ประกอบของคอลเลกชัน และสร้างคอลเลกชันพร้อมผลลัพธ์ ดังที่เราเห็นในภาพด้านล่าง
รูปภาพ รูปที่ 1 - วิธีการแผนที่ใช้ฟังก์ชันที่ส่งผ่านไปยังแต่ละองค์ประกอบของคอลเลกชัน
ด้วยการรองรับนิพจน์ lambda เราจึงสามารถควบคุมพลังของรูปแบบการทำงานของการเขียนโปรแกรมใน Java ได้อย่างเต็มที่ หากเราเชี่ยวชาญสไตล์นี้ เราก็สามารถสร้างโค้ดที่กระชับและแสดงออกได้มากขึ้น โดยมีการเปลี่ยนแปลงและข้อผิดพลาดน้อยลง ก่อนหน้านี้ หนึ่งในข้อได้เปรียบที่สำคัญของ Java คือการรองรับกระบวนทัศน์เชิงวัตถุ และรูปแบบการใช้งานไม่ขัดแย้งกับ OOP ความเป็นเลิศอย่างแท้จริงในการย้ายจากการเขียนโปรแกรมที่จำเป็นไปสู่การเขียนโปรแกรมแบบประกาศ ด้วย Java 8 เราสามารถรวมการเขียนโปรแกรมเชิงฟังก์ชันเข้ากับสไตล์เชิงวัตถุได้อย่างมีประสิทธิภาพ เราสามารถใช้สไตล์ OO กับออบเจ็กต์ ขอบเขต สถานะ และความสัมพันธ์ได้ต่อไป นอกจากนี้ เราสามารถสร้างแบบจำลองพฤติกรรมและสถานะของการเปลี่ยนแปลง กระบวนการทางธุรกิจ และการประมวลผลข้อมูลเป็นชุดของชุดฟังก์ชันได้
ทำไมต้องเขียนโค้ดในรูปแบบการใช้งาน?
เราได้เห็นประโยชน์โดยรวมของรูปแบบการทำงานของการเขียนโปรแกรมแล้ว แต่รูปแบบใหม่นี้คุ้มค่าที่จะเรียนรู้หรือไม่? นี่จะเป็นการเปลี่ยนแปลงเล็กน้อยในภาษาหรือจะเปลี่ยนชีวิตเราหรือไม่? เราต้องได้รับคำตอบสำหรับคำถามเหล่านี้ก่อนที่เราจะเสียเวลาและพลังงานไป การเขียนโค้ด Java ไม่ใช่เรื่องยาก รูปแบบภาษานั้นเรียบง่าย เราพอใจกับไลบรารีและ API ที่คุ้นเคย สิ่งที่ต้องการให้เราใช้ความพยายามในการเขียนและบำรุงรักษาโค้ดคือแอปพลิเคชันระดับองค์กรทั่วไปที่เราใช้ Java เพื่อการพัฒนา เราจำเป็นต้องตรวจสอบให้แน่ใจว่าเพื่อนโปรแกรมเมอร์ปิดการเชื่อมต่อกับฐานข้อมูลในเวลาที่ถูกต้อง พวกเขาไม่ได้ระงับหรือทำธุรกรรมนานเกินความจำเป็น ตรวจพบข้อยกเว้นอย่างสมบูรณ์และในระดับที่ถูกต้อง ที่พวกเขาใช้และปลดล็อค อย่างถูกต้อง ...แผ่นนี้สามารถต่อยอดได้ยาวนานมาก ข้อโต้แย้งแต่ละข้อข้างต้นเพียงอย่างเดียวไม่มีน้ำหนัก แต่เมื่อรวมเข้ากับความซับซ้อนในการดำเนินการโดยธรรมชาติแล้ว ข้อโต้แย้งดังกล่าวจะล้นหลาม ใช้เวลานาน และยากต่อการนำไปปฏิบัติ จะเป็นอย่างไรถ้าเราสามารถสรุปความซับซ้อนเหล่านี้ให้เป็นโค้ดชิ้นเล็กๆ ที่สามารถจัดการมันได้ดีเช่นกัน จากนั้นเราจะไม่ใช้พลังงานอย่างต่อเนื่องไปกับการปฏิบัติตามมาตรฐาน นี่จะให้ข้อได้เปรียบอย่างมาก ดังนั้นเรามาดูกันว่าสไตล์การใช้งานสามารถช่วยได้อย่างไรโจถาม
รหัสสั้น* หมายถึงตัวอักษรรหัสน้อยลงใช่หรือไม่
* เรากำลังพูดถึงคำว่ากระชับซึ่งเป็นลักษณะการทำงานของโค้ดโดยใช้นิพจน์แลมบ์ดา
ในบริบทนี้ โค้ดควรมีความกระชับ ไม่มีการจีบ และลดผลกระทบโดยตรงเพื่อถ่ายทอดเจตนาได้อย่างมีประสิทธิภาพมากขึ้น สิ่งเหล่านี้เป็นประโยชน์อันกว้างขวาง การเขียนโค้ดก็เหมือนกับการนำส่วนผสมต่างๆ มารวมกัน ทำให้กระชับก็เหมือนกับการเติมซอสลงไป บางครั้งการเขียนโค้ดดังกล่าวต้องใช้ความพยายามมากขึ้น อ่านโค้ดน้อยลง แต่ทำให้โค้ดโปร่งใสมากขึ้น สิ่งสำคัญคือต้องรักษาโค้ดให้ชัดเจนเมื่อย่อให้สั้นลง รหัสที่กระชับนั้นคล้ายกับเทคนิคการออกแบบ รหัสนี้ต้องการการเต้นรำกับแทมบูรีนน้อยลง ซึ่งหมายความว่าเราสามารถนำแนวคิดของเราไปใช้ได้อย่างรวดเร็วและเดินหน้าต่อไปหากแนวคิดนั้นได้ผล และละทิ้งแนวคิดเหล่านั้นหากไม่เป็นไปตามความคาดหวัง
การทำซ้ำบนสเตียรอยด์
เราใช้ตัววนซ้ำเพื่อประมวลผลรายการออบเจ็กต์ ตลอดจนทำงานกับชุดและแผนที่ ตัววนซ้ำที่เราใช้ใน Java นั้นคุ้นเคยสำหรับเรา แม้ว่าจะเป็นแบบดั้งเดิม แต่ก็ไม่ง่าย ไม่เพียงแต่ใช้โค้ดหลายบรรทัดเท่านั้น แต่ยังเขียนยากอีกด้วย เราจะวนซ้ำองค์ประกอบทั้งหมดของคอลเลกชันได้อย่างไร เราสามารถใช้ for loop ได้ เราจะเลือกองค์ประกอบบางอย่างจากคอลเลกชันได้อย่างไร? ใช้ for loop แบบเดียวกัน แต่ใช้ตัวแปรที่ไม่แน่นอนเพิ่มเติมบางตัวซึ่งจำเป็นต้องเปรียบเทียบกับบางสิ่งจากคอลเลกชัน จากนั้น หลังจากเลือกค่าเฉพาะแล้ว เราจะดำเนินการกับค่าเดียว เช่น ค่าต่ำสุด ค่าสูงสุด หรือค่าเฉลี่ยบางส่วนได้อย่างไร วนซ้ำอีกครั้ง ตัวแปรใหม่อีกครั้ง สิ่งนี้ชวนให้นึกถึงสุภาษิตที่ว่าคุณไม่สามารถมองเห็นต้นไม้ได้เพราะป่าไม้ (ต้นฉบับใช้การเล่นคำที่เกี่ยวข้องกับการวนซ้ำและหมายความว่า "ทุกสิ่งเกิดขึ้น แต่ไม่ใช่ทุกสิ่งที่ประสบความสำเร็จ" - บันทึกของนักแปล) ตอนนี้ jdk จัดเตรียมตัววนซ้ำภายในสำหรับคำสั่งต่างๆ: ตัวหนึ่งเพื่อทำให้การวนซ้ำง่ายขึ้น ตัวหนึ่งเพื่อผูกการพึ่งพาผลลัพธ์ที่ต้องการ ตัวหนึ่งเพื่อกรองค่าเอาต์พุต ตัวหนึ่งเพื่อส่งคืนค่า และฟังก์ชันอำนวยความสะดวกหลายอย่างสำหรับการรับค่าต่ำสุด สูงสุด ค่าเฉลี่ย ฯลฯ นอกจากนี้ ฟังก์ชันการทำงานของการดำเนินการเหล่านี้สามารถรวมเข้าด้วยกันได้อย่างง่ายดายมาก เพื่อให้เราสามารถรวมชุดต่างๆ เข้าด้วยกันเพื่อใช้ตรรกะทางธุรกิจได้อย่างง่ายดายยิ่งขึ้นและใช้โค้ดน้อยลง เมื่อเราทำเสร็จแล้ว โค้ดจะเข้าใจได้ง่ายขึ้น เนื่องจากจะสร้างโซลูชันเชิงตรรกะตามลำดับที่ปัญหาต้องการ เราจะดูตัวอย่างโค้ดดังกล่าวในบทที่ 2 และต่อไปในหนังสือเล่มนี้การประยุกต์อัลกอริธึม
อัลกอริธึมขับเคลื่อนแอปพลิเคชันระดับองค์กร ตัวอย่างเช่น เราจำเป็นต้องจัดเตรียมการดำเนินการที่ต้องมีการตรวจสอบสิทธิ์ เราจะต้องตรวจสอบให้แน่ใจว่าการทำธุรกรรมเสร็จสิ้นอย่างรวดเร็วและการตรวจสอบเสร็จสมบูรณ์อย่างถูกต้อง งานดังกล่าวมักจะถูกลดให้เหลือเพียงวิธีการธรรมดา ดังในรายการด้านล่าง:Transaction transaction = getFromTransactionFactory(); //... Операция выполняющаяся во время транзакции... checkProgressAndCommitOrRollbackTransaction(); UpdateAuditTrail(); แนวทางนี้มีปัญหาสองประการ ประการแรก สิ่งนี้มักจะนำไปสู่ความพยายามในการพัฒนาเพิ่มขึ้นเป็นสองเท่า ซึ่งจะนำไปสู่การเพิ่มค่าใช้จ่ายในการบำรุงรักษาแอปพลิเคชัน ประการที่สอง มันง่ายมากที่จะพลาดข้อยกเว้นที่อาจเกิดขึ้นในโค้ดของแอปพลิเคชันนี้ ซึ่งเป็นอันตรายต่อการดำเนินการธุรกรรมและการส่งเช็ค เราสามารถใช้บล็อก try-finally ที่เหมาะสมได้ แต่ทุกครั้งที่มีคนแตะโค้ดนี้ เราจะต้องตรวจสอบอีกครั้งว่าตรรกะของโค้ดนั้นไม่ได้เสียหาย มิฉะนั้น เราอาจจะละทิ้งโรงงานและโยนรหัสทั้งหมดทิ้งไป แทนที่จะรับธุรกรรม เราสามารถส่งโค้ดประมวลผลไปยังฟังก์ชันที่ได้รับการจัดการอย่างดี เช่น โค้ดด้านล่าง
runWithinTransaction((Transaction transaction) -> { //... Операция выполняющаяся во время транзакции... }); การเปลี่ยนแปลงเล็กๆ น้อยๆ เหล่านี้ช่วยประหยัดเงินได้มาก อัลกอริธึมสำหรับการตรวจสอบ สถานะและการตรวจสอบแอปพลิเคชันได้รับการกำหนดระดับใหม่ของนามธรรม และถูกห่อหุ้มไว้โดยใช้ เมธอด
runWithinTransaction() ในวิธีนี้ เราวางโค้ดที่ควรดำเนินการในบริบทของธุรกรรม เราไม่ต้องกังวลกับการลืมทำบางสิ่งบางอย่างอีกต่อไปหรือว่าเราจะได้รับข้อยกเว้นในตำแหน่งที่ถูกต้องอีกต่อไป ฟังก์ชันอัลกอริทึมจะดูแลเรื่องนี้ ประเด็นนี้จะกล่าวถึงรายละเอียดเพิ่มเติมในบทที่ 5
GO TO FULL VERSION