คอฟฟี่เบรค #109. ทักษะที่เป็นที่ต้องการมากที่สุดในการพัฒนา Java ในขณะนี้ 7 เคล็ดลับเสริม Java เพื่อกำจัดความยุ่งเหยิงของโค้ด

ทักษะที่เป็นที่ต้องการมากที่สุดในการพัฒนา Java ในขณะนี้

ที่มา: Medium Java ยังคงเป็นหนึ่งในภาษาการเขียนโปรแกรมที่ได้รับความนิยมและเป็นที่ต้องการมากที่สุด แม้ว่าจะมีอายุเกือบหนึ่งในสี่ของศตวรรษก็ตาม ดังนั้นจึงสมเหตุสมผลที่จะสรุปได้ว่าความนิยมของ Java จะยังคงเติบโตต่อไป และนักพัฒนา Java จะเห็นความต้องการที่เพิ่มมากขึ้นจากผู้จ้างงานในอนาคต ในการสร้างผลิตภัณฑ์ที่มีคุณภาพ นักพัฒนาจำเป็นต้องติดตามเครื่องมือ Java ล่าสุดและพัฒนาทักษะและความรู้ด้านเทคนิคของตน ด้านล่างนี้เรานำเสนอหกทักษะที่จำเป็นสำหรับนักพัฒนา Java

1. ความรู้ที่ยอดเยี่ยมเกี่ยวกับ Java 8

แม้ว่า Java เวอร์ชันใหม่จะใช้กันอย่างแพร่หลายอยู่แล้ว แต่นักพัฒนา Java ทุกคนที่ต้องการความรู้เชิงลึกและประสบการณ์เกี่ยวกับ Java 8 คุณสมบัติที่มีประโยชน์ที่สุดบางประการของ Java 8 ได้แก่:

• วิธีการมาตรฐานและแบบคงที่สำหรับการสร้างส่วนต่อประสานกับการนำวิธีการไปใช้
• อินเทอร์เฟซการทำงานที่มีวิธีนามธรรมเพียงวิธีเดียวและช่วยให้นักพัฒนาหลีกเลี่ยงการเพิ่มวิธีนามธรรมอื่นๆ
• นิพจน์ Lambda ที่ช่วยสร้างอินเทอร์เฟซการทำงาน
• Java Stream API เพื่อเปิดใช้งานการดำเนินการแบบขนานและต่อเนื่อง
• วิธีการใหม่ใน Collection API

คุณสมบัติทั้งหมดนี้ทำให้ Java 8 เป็นสิ่งที่ขาดไม่ได้สำหรับการเขียนโปรแกรมเชิงฟังก์ชัน การเขียนโปรแกรมเชิงฟังก์ชันช่วยให้เกิดการทำงานพร้อมกันและมีความสั้นของโค้ด และช่วยสร้างแอปพลิเคชันที่มีโหลดสูงด้วยโค้ดที่ปรับให้เหมาะสม Java 8 ยังกลายเป็นพื้นฐานสำหรับการเพิ่มประสิทธิภาพโค้ดเนทีฟ ทำให้สามารถเพิ่มประสิทธิภาพการพัฒนาในภาษาอื่น ๆ เช่น Scala, Kotlin และ Grails

2.มีประสบการณ์การทดสอบ

การทดสอบหน่วยใน Java เป็นหัวข้อที่ค่อนข้างขัดแย้ง นักพัฒนาบางคนโต้แย้งว่าการเขียนการทดสอบหน่วยเป็นการเสียเวลา แต่เราเชื่อมั่นว่าทักษะการทดสอบหน่วยเป็นสิ่งจำเป็นสำหรับนักพัฒนา Java มืออาชีพ การทดสอบหน่วยช่วยให้คุณสามารถทดสอบโค้ดแต่ละบล็อกและรับรองว่าผลิตภัณฑ์ขั้นสุดท้ายทำงานได้โดยไม่มีข้อผิดพลาด ดังนั้น หากนักพัฒนาต้องการพัฒนาทักษะและความรู้ของเขา เขาจำเป็นต้องเรียนรู้วิธีใช้เครื่องมือทดสอบที่ได้รับความนิยมและมีประสิทธิภาพที่สุด กรอบการทดสอบหลักที่คุณต้องคุ้นเคยคือไลบรารี JUnit 5 เครื่องมืออื่นๆ ได้แก่:

• กรอบการทำงานของหุ่นยนต์
• ม็อกคิโต
• พาวเวอร์ม็อค

นอกเหนือจากการทดสอบหน่วยแล้ว นักพัฒนา Java ไม่ควรลืมเกี่ยวกับวิธีการทดสอบอื่นๆ (การทดสอบระบบ การทดสอบการยอมรับ และการทดสอบการรวม) สิ่งนี้ช่วยให้คุณสามารถทำการทดสอบซอฟต์แวร์อย่างครอบคลุม และตรวจสอบให้แน่ใจว่าไม่มีข้อผิดพลาด จุดบกพร่อง หรือความล้มเหลวที่สำคัญ สิ่งสำคัญที่ต้องจำเกี่ยวกับการทดสอบคือการเปลี่ยนแปลงเล็กๆ น้อยๆ จะนำไปสู่ผลลัพธ์ที่ยิ่งใหญ่ หากคุณไม่ลังเลที่จะสละเวลาและความพยายามในการทดสอบหน่วย คุณจะประหลาดใจกับการปรับปรุงคุณภาพงานของคุณ

3. การพัฒนาซอฟต์แวร์

แม้ว่าจะไม่จำเป็น แต่การเรียนรู้เกี่ยวกับ DevOps และหลักการของ DevOps จะเป็นประโยชน์สำหรับคุณในฐานะนักพัฒนาและบริษัทที่คุณทำงานด้วย ความยืดหยุ่นและการจัดระเบียบของกระบวนการ DevOps ช่วยให้บริษัทต่างๆ สามารถปรับคุณภาพผลิตภัณฑ์ของตนให้เหมาะสมและปรับปรุงการดำเนินงานได้ และยังเพิ่มความโปร่งใสของกระบวนการอีกด้วย DevOps ใน Java นั้นเป็นแอปพลิเคชั่นของ DevOps เพื่อการพัฒนา Java ซึ่งรวมถึง:

• การส่งมอบและการบูรณาการอย่างต่อเนื่อง
• การทำงานกับไมโครเซอร์วิสแทนที่จะเป็นเสาหิน
• โครงสร้างพื้นฐานเป็นรหัส
• การทดสอบอัตโนมัติ

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

4. ความรู้เกี่ยวกับไลบรารี Java และ API

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

• Gradle (เครื่องมือสำหรับการสร้างแอปพลิเคชัน);
• Maven (ล้าสมัยเล็กน้อยแต่ยังคงได้รับความนิยม ใช้ในการสร้างแอปพลิเคชันด้วย);
• แพ็คเกจมาตรฐาน Java 8;
• กรอบสปริง;
• JPA ORM (ไฮเบอร์เนต, ท็อปลิงค์);
• ฐานข้อมูล NoSQL (MongoDB, Cassandra)

สำหรับ API เพื่อทำงานร่วมกับ Java API หลัก นักพัฒนาจำเป็นต้องมีความรู้เกี่ยวกับ OpenJDK, Android, Oracle และ IS2T เป็นอย่างดี ข้อได้เปรียบที่สำคัญของเครื่องมือเหล่านี้คือทั้งหมดมาพร้อมกับเอกสารที่มีรายละเอียดและให้ข้อมูล นอกจากนี้ นักพัฒนายังสามารถรับการสนับสนุนจากชุมชนได้ตลอดเวลา ซึ่งเป็นข้อได้เปรียบที่ยิ่งใหญ่เช่นกัน

5. มีความรู้อย่างมั่นใจเกี่ยวกับ Spring และ Spring Boot

Spring Framework เป็นเฟรมเวิร์กที่ใช้กันมากที่สุดสำหรับการพัฒนาแอปพลิเคชันที่ใช้ Java ดังนั้นจึงเป็นสิ่งสำคัญที่นักพัฒนาจะต้องรู้วิธีการทำงาน ข้อดีหลักประการหนึ่งของ Spring คือการพึ่งพาการฉีดซึ่งช่วยให้คุณสามารถสร้างแอปพลิเคชันคู่ที่หลวมและให้นักพัฒนามีความยืดหยุ่นมากขึ้น Spring นั้นมีน้ำหนักเบามาก รองรับการกำหนดค่า XML คำอธิบายประกอบ และการเขียนโปรแกรมแบบประกาศ ดังนั้นหากคุณต้องการเชี่ยวชาญทักษะการพัฒนา Java คุณควรเชี่ยวชาญ Spring Deployment ด้วย Spring Boot เป็นการทำซ้ำของ Spring ที่ให้เครื่องมือที่สะดวกสำหรับการปรับใช้แอปพลิเคชันอย่างรวดเร็ว พูดได้อย่างปลอดภัยว่า Spring Boot ใช้ Spring เป็นฐานและสร้างคุณลักษณะของตัวเองขึ้นมาด้านบน ในขณะที่ Spring มุ่งเน้นไปที่ความยืดหยุ่น Spring Boot จะช่วยลดโค้ดและทำให้กระบวนการพัฒนาง่ายขึ้น โดยนำเสนอฟีเจอร์ที่พร้อมใช้งานทันทีสำหรับนักพัฒนา ช่วยสร้างแอปแบบสแตนด์อโลน และโดยรวมแล้วเปิดและจัดการได้ง่ายขึ้น Spring Boot เหมาะอย่างยิ่งสำหรับไมโครเซอร์วิสและแอปพลิเคชันที่ต้องสร้างอย่างรวดเร็ว เนื่องจากช่วยให้ตั้งค่าและรันแอปพลิเคชันสำหรับสภาพแวดล้อมที่หลากหลายได้รวดเร็วและง่ายดาย (การผลิต การทดสอบ คุณภาพ CI/CD) ทั้ง Spring และ Spring Boot ได้ขยายขีดความสามารถในการเขียนโปรแกรม React ซึ่งเป็นอีกหนึ่งเทรนด์ที่กำลังมาแรงในชุมชนนักพัฒนา ตัวอย่างเช่น Spring 5 มี WebFlux เพื่อใช้แนวทางเชิงโต้ตอบในการเขียนโปรแกรมและแก้ไขระบบแบบกระจายที่ซับซ้อน

6. มีประสบการณ์กับ Big Data

Big Data เป็นเทรนด์ที่กำลังเติบโตที่นักพัฒนาต้องติดตามและนำไปใช้เพื่อตอบสนองความต้องการของตลาด เครื่องมือหลักที่นักพัฒนา Java มืออาชีพสามารถคุ้นเคยได้คือ:

• อาปาเช่ สปาร์ค
• อาปาเช่ คาฟคา
• Hadoop (สำหรับการประมวลผลเป็นชุด)

Apache Spark เป็นแพลตฟอร์มการประมวลผล Big Data แบบกระจายที่ให้การเชื่อมโยงดั้งเดิมสำหรับ Java เฟรมเวิร์กนี้ได้รับความนิยมอย่างมากเนื่องจากคุณสมบัติและประสิทธิภาพ และปัจจุบันเป็นเครื่องมือ Big Data ที่เป็นที่ต้องการมากที่สุดในชุมชน Java Apache Spark สามารถทำงานในโหมดสแตนด์อโลนของคลัสเตอร์ได้ และด้วยเหตุนี้ คุณจำเป็นต้องมีสภาพแวดล้อม Apache Spark และ JVM เท่านั้น (สำหรับแต่ละเครื่องในคลัสเตอร์) Spark ยังทำงานเร็วอย่างไม่น่าเชื่อและมี Spark API ที่ใช้งานง่ายมาก Hadoop เป็นแพลตฟอร์มจัดเก็บข้อมูลที่เป็นที่รู้จักกันดีของนักพัฒนา Java แม้ว่า Hadoop จะไม่เร็วเท่า Spark แต่ก็ยังคงเป็นหนึ่งในเครื่องมือยอดนิยมที่สุดสำหรับการทำงานกับข้อมูลขนาดใหญ่ นี่เป็นเพราะความจริงที่ว่า Hadoop (และโซลูชันที่คล้ายกัน) มีปลั๊กอินจำนวนมากที่ช่วยให้คุณสามารถแก้ไขปัญหาการประมวลผล Big Data ได้อย่างมีประสิทธิภาพ และเพิ่มประสิทธิภาพการทำงานของ Hadoop โดยทั่วไป (รวมถึงการรองรับการประมวลผลสตรีมแบบเรียลไทม์)

7 เคล็ดลับเสริม Java เพื่อกำจัดความยุ่งเหยิงของโค้ด

ที่มา: สื่อ “ฉันมีเพื่อนร่วมงานที่ไม่รู้เกี่ยวกับการมีอยู่ของ Optional” นักพัฒนา Java คนหนึ่งเขียนบน Reddit เราสามารถพิจารณาได้ว่า Optional ช่วยปรับปรุง "ความสามารถในการอ่าน" ของโค้ดได้หรือไม่ มันคุ้มค่าที่จะใช้มันตลอดเวลาหรือไม่? การใช้ Optional ไม่จำเป็นเลยตรงไหน? เนื่องจากนักพัฒนาจำนวนมากยังไม่ทราบวิธีใช้ Optional อย่างถูกต้อง ฉันจะยกตัวอย่างการละเมิดเพิ่มเติม 7 ตัวอย่างและวิธีดำเนินการกับสิ่งเหล่านี้

1. อย่าใช้ตัวเลือกสำหรับการตรวจสอบค่าว่าง

การใช้ทางเลือกแทนการตรวจสอบค่าว่างจะเพิ่มความยุ่งเหยิง ไม่มีประโยชน์ใด ๆ จากสิ่งนี้ การใช้ Optional และisPresentและรับ วิธีการ ก็ ถือเป็นความผิดพลาดเช่นกัน นักพัฒนาเชื่อว่าgetควรทำงานได้ตามที่คาดไว้ จากนั้นพวกเขาเพิ่มisPresentและกลับสู่การตรวจสอบค่าว่าง โปรดจำไว้ว่าทางเลือกไม่ได้แก้ไขการตรวจสอบที่เป็นโมฆะของคุณ ครั้งต่อไปที่คุณเห็นisPresentและรับ (หรือElseThrow ) เปลี่ยนโค้ดส่วนนี้ ใช้การแมปและorElseเพื่อลบการตรวจสอบค่าว่างมาตรฐาน และใช้ตัวเลือกเพิ่มเติมโดยเลือกมากขึ้น นี่เป็นตัวอย่างที่ดีประการหนึ่ง:

var user = userService.getCurrentUser();
if(user == null) {
    return "(unknown)";
}
var username = user.getUsername();
if (username == null) {
    return "(unknown)";
}
return username;
vs

var user = userService.getCurrentUser();
if(user.isEmpty()) {
    return "(unknown)";
}
var username = user.orElseThrow().getUsername();
if (username == null) {
    return "(unknown)";
}
return username;
vs

return userService.getCurrentUser()
                  .map(User::getUsername)
                  .orElse("(unknown)");

คุณสามารถเริ่มต้นด้วยเป้าหมายทางเลือก วัตถุประสงค์ของ Optional คือเพื่อแสดงค่าเผื่อเลือกที่ขาดหายไป จากนั้นกลับไปที่ปัญหาของคุณและดูว่าเหมาะกับคุณหรือไม่ อีกวิธีในการจัดการกับการตรวจสอบค่าว่างคือการใช้คำอธิบายประกอบ NullableหรือNotNullควรทำงานได้ดี จริงอยู่ พวกมันอาจทำให้โค้ดของคุณเสียหายได้ และพวกมันจะป้องกันเฉพาะในเวลาคอมไพล์เท่านั้น หากต้องการตรวจ สอบ รันไทม์ให้ใช้Objects.requireNonNull

2. จัดการข้อผิดพลาดอย่างเหมาะสม

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

public Optional<MyObject> getMyObject(final String jql) {
    try {
        return Optional.ofNullable(get(sql));
    } catch (final JqlParseException e) {
        return Optional.empty();
    }
}

เหตุใดmyObject จึง ว่างเปล่า นี่เป็นข้อผิดพลาดหรือค่าว่าง ดังนั้นคุณจะได้รับผลลัพธ์ที่ไม่ชัดเจนอีกครั้ง และลบคุณประโยชน์ของตัวเลือกเสริมออกไป รหัสนี้มีอยู่เนื่องจากผู้คนพยายามใช้ตัวเลือกสำหรับโฟลว์การควบคุม ตัวเลือกเสริมจะลบเลขศูนย์บางตัวออกจากโค้ดเบสของคุณ แต่คุณยังต้องใช้โครงสร้าง try-catch เพื่อจัดการกับข้อยกเว้น ใช้ try-catch เพื่อจัดการข้อยกเว้นอย่างถูกต้อง อย่าลบ Optional เมื่อจัดการกับข้อผิดพลาด เพียงแค่รอและมันจะทำงานได้อย่างสมบูรณ์ แต่มีข้อยกเว้นประการหนึ่งที่นี่ - การจับที่ว่างเปล่า เมื่อคุณไม่รู้ว่าจะต้องส่งคืนอะไรเมื่อว่าง ตัวเลือกว่างก็ควรจะทำงานได้ดี

private int readExpirationAsInt(Milk milk)
{
  String expiration = milk.getExpiration();
  try {
    return Integer.parseInt(expiration);
  }
  catch(NumberFormatException ignored) {}

  return 0;
}


private OptionalInt readExpirationAsInt(Milk milk)
{
  String expiration = milk.getExpiration();

  try {
    return Optional.of(Integer.parseInt(expiration));
  }
  catch(NumberFormatException e) {
    return OptionalInt.empty();
  }
}

3. อย่าคืนค่า null จากวิธีทางเลือก

public static Optional<POSType> getPOSType(String posName) {
    if (StringUtils.isNotBlank(posName)) {
        return Arrays.stream(POSType.values())
                .filter(type -> type.toString().equalsIgnoreCase(posName))
                .findFirst();
    }
    return null;
}

สิ่งนี้ขัดต่อวัตถุประสงค์ของทางเลือก นี่เป็นอีกตัวอย่างหนึ่งของการทดสอบที่ไม่ดี เนื่องจากอินพุตว่างเปล่า นั่นหมายความว่าเราจำเป็นต้องมีไฟล์IllegalArgumentException นี่เป็นข้อผิดพลาดด้วย ไม่มีใครต้องตรวจสอบวิธีการโทรเสริม ส่งคืนองค์ประกอบ Optional ที่ว่างเปล่า และอย่าตรวจสอบองค์ประกอบ Optional ว่าเป็นโมฆะ

4. อย่าใช้ทางเลือกกับคอลเลกชัน

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

5. อย่าล่ามโซ่เพื่อประโยชน์ในการล่ามโซ่

Optional.ofNullable(foo).ifPresent(value -> {
  //do something
})

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

6. ใช้ wrapper ค่าดั้งเดิม

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

7. คุณควรรู้เกี่ยวกับ ofNullable

if (a==null){
  return Optional.empty();
} else {
  return Optional.of(a);
}

โค้ดประเภทนี้มักจะเขียนโดยนัก พัฒนา ที่ไม่มีความรู้เกี่ยวกับOptional#ofNullable นักพัฒนาส่วนใหญ่ไม่เข้าใจด้วยซ้ำถึงความแตกต่างระหว่างofNullableและของ . พวกเขาไม่เข้าใจว่าOptional#ofสามารถย้อนกลับมาได้ อย่างไร ส่วนใหญ่จะหันไปใช้ofNullableเพราะกลัวว่าจะมีการโยนNullPointerExceptionในOptional# of นี่เป็นการเอาชนะจุดประสงค์ของทั้งสองวิธีนี้อีกครั้ง หากเราใช้เพียงofNullableทำไมเราถึงต้องการOptional#of เลย ? Optional#ofพ่น NPE เมื่อคุณส่งผ่านเป็นโมฆะ สิ่งนี้เกิดขึ้นด้วยเหตุผล ควรใช้วิธีนี้เมื่อคุณคาดหวังว่าจะมีค่าอยู่ หากไม่มีก็จะล้มเหลวอย่างรวดเร็ว Optional#ofNullableแปลงค่า null ให้เป็นค่าว่าง วิธีการนี้รับค่าว่างเป็นอาร์กิวเมนต์ ซึ่งตรงกับค่าว่างหรือไม่ก็ได้