Microsoft สำหรับนักพัฒนา Java: คู่มือฉบับสมบูรณ์เกี่ยวกับเครื่องมือและ Azure

คู่มืออัลฟ่า » เกมส์ » Microsoft สำหรับนักพัฒนา Java: คู่มือฉบับสมบูรณ์เกี่ยวกับเครื่องมือและ Azure

หากคุณเขียนโปรแกรมด้วยภาษา Java และสงสัยว่าระบบนิเวศของ Microsoft ทั้งหมดจะเข้ากันได้กับแอปพลิเคชัน Java ของคุณ ได้อย่างไร คุณมาถูกที่แล้ว Azure, GitHub, Visual Studio Code, Spring, Maven, Gradle… แคตตาล็อกนั้นใหญ่มากและอาจทำให้รู้สึกสับสนเล็กน้อยในตอนแรก โดยเฉพาะอย่างยิ่งหากคุณเคยใช้งานเซิร์ฟเวอร์ภายในองค์กรหรือสภาพแวดล้อมคลาวด์อื่นๆ มาก่อน

ข่าวดีก็คือ ปัจจุบันคุณสามารถพัฒนา แก้ไขข้อบกพร่อง และใช้งาน Java บน Microsoft ได้โดยใช้เครื่องมือแทบจะเหมือนเดิม: IDE ที่คุณชื่นชอบ ไปป์ไลน์ CI/CD และเฟรมเวิร์กที่คุณไว้วางใจ เช่น Spring หรือ Jakarta EE Microsoft ได้ปรับปรุงแพลตฟอร์มของตนเพื่อรองรับ Java อย่างเต็มรูปแบบ: มี JVM นับล้านเครื่องใช้งานจริง มี OpenJDK เวอร์ชันของตนเอง และบริการเฉพาะที่มุ่งเน้นไปที่ภาษา Java

ไมโครซอฟต์และระบบนิเวศของ Java: ภาพรวม

ภายในบริษัท Microsoft นั้น Java ไม่ใช่ผลิตภัณฑ์เฉพาะกลุ่ม: วิศวกรหลายพันคนทำงานกับ Java ทุกวันและมี Java Virtual Machine (JVM) หลายล้านเครื่องที่ทำงานเพื่อรองรับผลิตภัณฑ์ที่ใช้กันอย่างแพร่หลาย ด้วยเหตุนี้ บริษัทจึงลงทุนอย่างมากในเครื่องมือและบริการที่ออกแบบมาโดยเฉพาะสำหรับนักพัฒนา Java

ส่วนประกอบสำคัญคือMicrosoft Build of OpenJDKซึ่งเป็นชุดโปรแกรม OpenJDK ที่ใช้งานได้จริง ครอบคลุมหลายแพลตฟอร์ม และพร้อมใช้งานจริง โดยได้รับการปรับแต่งให้ทำงานบน Azure ได้อย่างมีประสิทธิภาพ ชุดโปรแกรมนี้ให้บริการฟรีโดยไม่มีค่าใช้จ่ายเพิ่มเติม และเป็นพื้นฐานสำหรับการสนับสนุนอย่างเป็นทางการของ Java 11, 17 และ 21 ในบริการจัดการต่างๆ มากมาย รวมถึง Azure Functions ด้วย

นอกจากนี้ ไมโครซอฟต์ยังมุ่งมั่นอย่างชัดเจนต่อJava เวอร์ชันใหม่ (Java 17, 21 และเวอร์ชัน LTS ต่อๆ ไป)โดยนำเสนอความเข้ากันได้ที่ได้รับการอัปเดตในรันไทม์ การสนับสนุนในเครื่องมือพัฒนา และคู่มือเฉพาะสำหรับการย้ายจากเวอร์ชันเก่า เช่น Java 8

ในทางปฏิบัติในชีวิตประจำวัน นั่นหมายความว่าคุณยังคงสามารถใช้งานSpring, Tomcat, WildFly, JBoss, WebLogic, WebSphere, Maven, Gradle, IntelliJ, Eclipse หรือ Jenkinsและปรับใช้ได้อย่างราบรื่นบน Azure รวมถึงใช้ประโยชน์จาก Terraform และเครื่องมือโครงสร้างพื้นฐานแบบโค้ดอื่นๆ ได้หากจำเป็น

IDE, เครื่องมือ และ CI/CD สำหรับ Java ที่ Microsoft

ประสบการณ์การพัฒนาเริ่มต้นในสภาพแวดล้อมภายในเครื่องของคุณ และ Microsoft มุ่งเน้นที่จะช่วยให้คุณสามารถคอมไพล์ ดีบัก และปรับใช้แอปพลิเคชัน Java ไปยัง Azureโดยใช้เครื่องมือที่คุณคุ้นเคยอยู่แล้ว คุณสามารถทำงานได้จาก Eclipse, IntelliJ IDEA หรือVisual Studio สำหรับการพัฒนาซอฟต์แวร์ด้วยส่วนขยาย Java อย่างเป็นทางการ

หากคุณใช้ Visual Studio Code ส่วนขยาย Java สำหรับ VS Code และ Azureจะช่วยให้คุณดีบักแอปพลิเคชัน จัดการการพึ่งพาของ Maven หรือ Gradle และปรับใช้กับบริการ Azure ได้ด้วยการคลิกเพียงไม่กี่ครั้ง นอกจากนี้ GitHub Copilot ยังผสานรวมโดยตรง ทำให้คุณได้รับคำแนะนำการเติมข้อความอัตโนมัติอัจฉริยะและคำแนะนำโค้ดที่ขับเคลื่อนด้วย AI ในโปรเจ็กต์ Java ของคุณ

สำหรับการทำงานแบบอัตโนมัติ Microsoft ใช้ระบบนิเวศมาตรฐาน ได้แก่GitHub Actions, Maven, Gradle และ Jenkinsคุณสามารถกำหนดไปป์ไลน์ CI/CD ที่คอมไพล์โปรเจ็กต์ของคุณด้วย Maven หรือ Gradle รันการทดสอบ บรรจุอาร์ติแฟกต์ และปรับใช้ไปยัง Azure Functions, Web Apps, คอนเทนเนอร์ หรือที่ใดก็ตามที่คุณต้องการ

แนวคิด "ใช้สิ่งที่คุณใช้อยู่แล้ว" เป็นกุญแจสำคัญ: ไพพ์ไลน์ที่มีอยู่ของคุณใน Jenkins หรือ GitHub Actionsแทบจะไม่จำเป็นต้องเขียนใหม่ทั้งหมด โดยปกติแล้ว การเพิ่มขั้นตอนเฉพาะเพื่อตรวจสอบสิทธิ์กับ Azure หรือเรียกใช้ CLI เพื่อปรับใช้ก็เพียงพอแล้ว

เมื่อพูดถึงการพัฒนาฟังก์ชันแบบไร้เซิร์ฟเวอร์ในภาษา Java ปลั๊กอินazure-functions-maven-plugin จะเข้ามามีบทบาท โดยจะผสานรวมกับ Maven เพื่อสร้างโครงร่างโปรเจ็กต์ สร้างการกำหนดค่าการเชื่อมโยง และทำให้การบรรจุและการเผยแพร่ไปยัง Azure Functions เป็นไปโดยอัตโนมัติ

Azure Functions กับ Java: หลักการพื้นฐานและแบบจำลองการเขียนโปรแกรม

Azure Functions ช่วยให้คุณเขียนโค้ดได้ ฟังก์ชันไร้เซิร์ฟเวอร์ใน Java ซึ่งทำงานตามความต้องการ โดยถูกกระตุ้นด้วยเหตุการณ์ต่างๆ เช่น คำขอ HTTP คิว ข้อมูลดิบ หรือตัวจับเวลา แต่ละฟังก์ชันจะถูกกำหนดเป็นเมธอด public บันทึกไว้ด้วย @FunctionNameและวิธีการนั้นถือเป็นจุดเริ่มต้นหลักของฟังก์ชัน

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

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

ความสัมพันธ์เหล่านี้ถูกกำหนดโดยใช้คำอธิบายประกอบ Java จากแพ็กเกจ com.microsoft.azure.functions.annotation และสะท้อนให้เห็นในไฟล์ function.json โดยทั่วไปไฟล์เหล่านี้จะถูกสร้างขึ้นโดยปลั๊กอิน Maven หรือ Gradle ด้วยวิธีนี้ โค้ด Java ของคุณจะยังคงสะอาดตา ในขณะที่คำจำกัดความของการผสานรวมกับบริการ Azure จะถูกจัดเก็บไว้ในเมตาเดต้า

การสร้างโปรเจ็กต์และโครงสร้างโฟลเดอร์ใน Azure Functions Java

เพื่อให้คุณเริ่มต้นใช้งานได้อย่างราบรื่น ไมโครซอฟต์จึงนำเสนอสิ่งต่อไปนี้ ต้นแบบ Maven เฉพาะสำหรับ Azure Functionsต้นแบบเหล่านี้จะสร้างโปรเจ็กต์ Java ที่กำหนดค่าไว้ล่วงหน้าพร้อมประเภททริกเกอร์ที่คุณเลือก (HTTP, ตัวจับเวลา, บล็อกข้อมูล, คิว ฯลฯ) com.microsoft.azure:azure-functions-archetype.

ด้วยคำสั่ง Maven เพียงคำสั่งเดียว คุณก็สามารถทำได้ สร้างโครงสร้างรองรับโครงการรวมถึงตัวอย่างคลาสและการกำหนดค่าต่างๆ pom.xmlโฟลเดอร์โค้ดและไดเร็กทอรีเอาต์พุต หากคุณต้องการทำงานในโหมดเทอร์มินัล นี่เป็นวิธีที่เร็วที่สุดและเป็นมาตรฐานที่สุดในการเริ่มต้น

โครงสร้างทั่วไปของโปรเจ็กต์ Azure Functions ในภาษา Java ประกอบด้วย: โมดูลที่มีซอร์สโค้ด Java อยู่ใน src/main/java, ไฟล์ pom.xml ในรูทและไดเร็กทอรี target/azure-functions โดยจะสร้างไฟล์ที่พร้อมใช้งาน (ไฟล์ JAR และไฟล์การกำหนดค่า) ขึ้นมา

ภายในไดเร็กทอรีปลายทางนั้น คุณจะพบ... ไฟล์ JAR ของแอปพลิเคชัน ไฟล์ host.json ที่ใช้ร่วมกัน โฟลเดอร์สำหรับแต่ละฟังก์ชัน พร้อมไฟล์ function.json ของแต่ละฟังก์ชัน และไดเร็กทอรีย่อย bin y lib สำหรับส่วนประกอบเพิ่มเติม โฟลเดอร์ทั้งหมดนี้คือสิ่งที่ถูกอัปโหลดและเรียกใช้งานในฐานะ Function App ใน Azure

สิ่งสำคัญที่ควรทราบคือ แม้ว่าคุณจะสามารถมีฟังก์ชันหลายฟังก์ชันในโปรเจกต์เดียวกันได้แต่ระบบไม่รองรับการบรรจุฟังก์ชันแต่ละฟังก์ชันไว้ในไฟล์ JAR แยกต่างหากภายใน Function App เดียวกัน รันไทม์ต้องการเพียงไฟล์ JAR หลักเพียงไฟล์เดียวต่อ Function App เท่านั้น

การตั้งค่าทริกเกอร์ คำอธิบายประกอบ และการผูกข้อมูล

ฟังก์ชันเหล่านี้จะทำงานเมื่อเกิดเหตุการณ์ใดเหตุการณ์หนึ่งขึ้น: ก. คำขอ HTTP, งานที่กำหนดเวลาไว้, การเปลี่ยนแปลงข้อมูลในพื้นที่จัดเก็บข้อมูล, เหตุการณ์ใน Event Hubs และอื่นๆ อีกมากมาย เหตุการณ์นั้นจะถูกรับเป็นพารามิเตอร์ในเมธอดที่ระบุด้วย @FunctionName พร้อมกับประเภทการผูกมัดที่เกี่ยวข้อง

สำหรับพารามิเตอร์อินพุตหรือเอาต์พุตแต่ละตัว จะใช้สิ่งต่อไปนี้: คำอธิบายประกอบ เช่น @HttpTrigger, @BlobTrigger, @QueueOutput, @TableInputทั้งหมดนี้รวมอยู่ในร้านหนังสือ azure-functions-java-libraryคุณสามารถระบุเส้นทางไปยังทรัพยากร วิธีการ HTTP ที่อนุญาต ระดับการตรวจสอบสิทธิ์ ฯลฯ ผ่านคุณลักษณะของคำอธิบายประกอบเหล่านี้ได้

ไฟล์ function.json โดยปกติแล้ว ข้อมูลที่เกี่ยวข้องจะถูกสร้างขึ้นจากคำอธิบายประกอบเหล่านี้โดยใช้ปลั๊กอิน Maven เพื่อให้ คุณไม่จำเป็นต้องเขียน JSON ด้วยมือเองที่นั่นคุณจะพบประเภทการผูกข้อมูล ทิศทาง (เข้า/ออก) ชื่อเส้นทางหรือคิว และพารามิเตอร์เพิ่มเติม

นอกจากประเภทพื้นฐานแล้ว เช่น String o byte[]คุณสามารถเลือกที่จะ POJO สำหรับการแมปข้อมูลอินพุต...หรือแม้แต่ SDK ประเภทเฉพาะเพื่อการเข้าถึงบริการต่างๆ เช่น Blob Storage ได้อย่างมีประสิทธิภาพยิ่งขึ้น ในทุกกรณี การกำหนดค่าการเชื่อมโยงจะเป็นตัวกำหนดว่า Azure Functions จะแปลงและส่งข้อมูลไปยังโค้ดของคุณอย่างไร

เวอร์ชัน Java และการกำหนดค่ารันไทม์

เวอร์ชัน Java ที่ฟังก์ชันของคุณทำงานนั้นถูกควบคุมโดยไฟล์ pom.xml ของโปรเจ็กต์และการกำหนดค่ารันไทม์ โดยค่าเริ่มต้น Maven archetype จะสร้างโปรเจ็กต์ Java 8 แต่คุณสามารถเปลี่ยนได้ง่ายๆ ก่อนที่จะทำการปรับใช้

ปัจจุบัน Azure Functions รองรับJava 8, 11, 17 และ 21ในรันไทม์เวอร์ชัน 4.x ทั้งบน Windows และ Linux รันไทม์เวอร์ชันก่อนหน้าจะรองรับเวอร์ชันที่น้อยกว่า (ตัวอย่างเช่น เวอร์ชัน 3.x รองรับ Java 8 และ 11 และเวอร์ชัน 2.x รองรับเฉพาะ Java 8 บน Windows เท่านั้น)

หากคุณไม่ได้ระบุอะไรเลย ปลั๊กอิน Maven มักจะถือว่า... เลือกใช้ Java 8 เป็นเวอร์ชันเป้าหมายในการใช้งานคุณสามารถใช้พารามิเตอร์เพื่อปรับค่านี้ได้ -DjavaVersion เมื่อสร้างโปรเจ็กต์หรือแก้ไขคุณสมบัติด้วยตนเอง java.version y javaVersion ในของคุณ pom.xml.

โดยเฉพาะอย่างยิ่ง มูลค่าของ java.version มันถูกใช้งานโดย maven-compiler-plugin เพื่อคอมไพล์โค้ด ในขณะที่องค์ประกอบ javaVersion ภายในบล็อก <runtime> ระบุเวอร์ชันของ Java ที่ควรใช้ในสภาพแวดล้อมรันไทม์ให้กับบริการ Azure Functions

การเลือกใช้ระบบปฏิบัติการและ JDK ใน Azure Functions

Maven ยังให้คุณเลือกได้อีกด้วยว่าอะไร แอปฟังก์ชันของคุณจะทำงานบนระบบปฏิบัติการ. ในส่วน <runtime> เดล pom.xml คุณสามารถตั้งค่าองค์ประกอบได้ <os> ในขณะที่ windows, linux o dockerขึ้นอยู่กับว่าคุณต้องการแผนการใช้งานบนระบบ Windows, ระบบ Linux หรืออิมเมจคอนเทนเนอร์แบบกำหนดเอง

ในส่วนของ JDK นั้น ปัจจุบัน Azure Functions ใช้OpenJDK เวอร์ชันของ Microsoft และ OpenJDK เวอร์ชันของ Adoptiumสำหรับ Java 8, 11, 17 และ 21 ซึ่งใช้งานได้ฟรี พร้อมใช้งานในระดับการผลิต และได้รับการสนับสนุนภายใต้แผนการสนับสนุนของ Azure

สำหรับสภาพแวดล้อมการพัฒนาและการทดสอบในเครื่อง คุณสามารถดาวน์โหลดOpenJDK ของ Microsoft หรือไบนารีของ Adoptium Temurin ได้อย่างง่ายดาย เพื่อให้มั่นใจว่าสภาพแวดล้อมการพัฒนาของคุณตรงกับสิ่งที่จะทำงานบนคลาวด์ ซึ่งจะช่วยลดปัญหาที่อาจเกิดขึ้นจากความไม่สอดคล้องกันของ JDK ระหว่างสภาพแวดล้อมในเครื่องและสภาพแวดล้อมการใช้งานจริง

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

การปรับแต่ง JVM และการกำหนดค่าขั้นสูง

Azure Functions อนุญาตให้คุณปรับแต่งได้ Java Virtual Machine (JVM) ที่ฟังก์ชันของคุณใช้งานตัวเลือกต่างๆ เช่น -XX:+TieredCompilation, -XX:TieredStopAtLevel=1, -noverify o -Djava.net.preferIPv4Stack=trueได้รับการปรับให้เหมาะสมเพื่อลดเวลาในการเริ่มต้นระบบและปรับให้เข้ากับโมเดลแบบไร้เซิร์ฟเวอร์

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

ตัวเลือกเหล่านี้สามารถจัดการได้จาก พอร์ทัล Azure โดยใช้แท็บการตั้งค่าแอปพลิเคชันเช่น จาก Azure CLI โดยใช้คำสั่งต่างๆ เช่น az functionapp config appsettings setตัวอย่างเช่น คุณสามารถเปิดใช้งานโหมดไร้หน้าจอได้ด้วย -Djava.awt.headless=true หรือแฟล็กอื่นๆ ของ JVM

ควรทราบว่า การเพิ่มตัวเลือกหรือการตั้งค่าที่ซับซ้อนจำนวนมาก อาจทำให้เวลาในการบูตเครื่อง (cold boot)ของฟีเจอร์ต่างๆ เพิ่มขึ้น โดยเฉพาะอย่างยิ่งในแผนการใช้งานแบบคิดค่าบริการตามการใช้งาน (Consumption plan) ซึ่งจะมีการสร้างอินสแตนซ์ตามความต้องการ

การพึ่งพา ไลบรารีของบุคคลที่สาม และประเภทข้อมูล

Azure Functions ในภาษา Java รองรับการใช้งานได้อย่างราบรื่น ไลบรารีของบุคคลที่สามที่ถูกกำหนดเป็น dependency ในไฟล์ pom.xml ของคุณในระหว่างขั้นตอนดังกล่าว mvn packageโดยระบบจะรวมการพึ่งพาของโปรเจ็กต์ทั้งหมดไว้ในไฟล์ที่นำไปใช้งานโดยอัตโนมัติ

หากคุณจำเป็นต้องใช้ไลบรารีที่ไม่ได้อยู่ในรายการ pom.xmlคุณสามารถวางพวกมันไว้ใน ไดเร็กทอรี lib ภายในรูทของฟังก์ชันไฟล์ JAR ใดๆ ที่มีอยู่จะถูกเพิ่มเข้าไปในคลาสโหลดเดอร์ของระบบเพื่อให้ฟังก์ชันของคุณสามารถใช้งานได้

การพึ่งพา com.microsoft.azure.functions:azure-functions-java-library เขากำลังมาแล้ว รวมอยู่ใน classpath โดยค่าเริ่มต้น อยู่ในสภาพแวดล้อมการทำงานของ Azure ดังนั้นคุณจึงไม่จำเป็นต้องคัดลอกไปยังไดเร็กทอรีด้วยตนเอง libในทางกลับกัน azure-functions-java-worker จะเพิ่มการพึ่งพาภายในเพิ่มเติมจำนวนหนึ่งโดยอัตโนมัติ

สำหรับประเภทข้อมูลที่รองรับ ฟังก์ชันต่างๆ สามารถใช้งานได้ POJO สาธารณะ, ประเภทข้อมูลพื้นฐาน เช่น String หรือ Integer และประเภทที่กำหนดไว้ใน azure-functions-java-library เพื่อเชื่อมโยงกับการผูกอินพุตและเอาต์พุตต่างๆ ซึ่งให้ความยืดหยุ่นอย่างมาก

POJO, ข้อมูลไบนารี และประเภท SDK

เมื่อคุณผูกข้อมูลอินพุตเข้ากับ POJO นั้น Java worker จะใช้Gson ในการแปลงเนื้อหาให้เป็นคลาสของคุณ โดยมีเงื่อนไขว่าคลาสนั้นต้องเป็นแบบ public และมีโครงสร้างตามที่ต้องการ วิธีนี้มีประโยชน์สำหรับข้อมูล JSON จากคิว, HTTP หรือ Event Hubs

หากคุณจำเป็นต้องทำงานกับข้อมูลไบนารีล้วนๆ ก็แค่... ใช้ไบต์อาร์เรย์ (byte[]และกำหนดฟิลด์ dataType เป็น binary ในไฟล์ function.json หรือในแอตทริบิวต์คำอธิบายประกอบที่เกี่ยวข้อง นี่เป็นวิธีการทั่วไปเมื่อประมวลผลข้อมูลไบนารี

นอกจากนี้ ยังรองรับโหมดขั้นสูงที่ช่วยให้คุณสามารถเชื่อมโยงโดยตรงกับประเภท SDK ของ Azure Storage เช่น BlobClient หรือ BlobContainerClientซึ่งจะช่วยให้ฟังก์ชันของคุณสามารถเข้าถึง SDK ได้โดยตรงเพื่ออ่านหรือเขียนบล็อบ สอบถามเมตาเดต้า จัดการ ACL หรือจัดการข้อมูลปริมาณมากโดยไม่มีข้อจำกัดด้านขนาดที่เข้มงวด

หากต้องการเปิดใช้งาน SDK ประเภทเหล่านี้ คุณต้องเปิดใช้งานการตั้งค่า JAVA_ENABLE_SDK_TYPES ความจริง และใช้ปลั๊กอินเวอร์ชันล่าสุด (azure-functions-maven-plugin หรือเทียบเท่าใน Gradle ตั้งแต่เวอร์ชัน 1.38.0 เป็นต้นไป จากนั้น การเชื่อมโยงจะจัดการการฉีดไคลเอ็นต์ที่เหมาะสมเข้าไปในเมธอด

ข้อผิดพลาดทั่วไปเกี่ยวกับประเภทข้อมูล SDK และวิธีการตีความข้อผิดพลาดเหล่านั้น

เมื่อทำงานกับประเภท SDK คุณอาจพบข้อยกเว้นเฉพาะของมิดเดิลแวร์ เช่นSdkAnalysisException, SdkRegistryException, SdkHydrationException หรือ SdkTypeCreationException ซึ่งแต่ละข้อบ่งชี้ถึงปัญหาในขั้นตอนต่างๆ ของไปป์ไลน์

ตัวอย่างเช่น ข้อผิดพลาด SdkAnalysisException มักชี้ไปที่ประเภทที่ซ้ำกันหรือพารามิเตอร์ที่ไม่รองรับในคำจำกัดความของฟังก์ชัน ในขณะที่ข้อผิดพลาด SdkRegistryException โดยทั่วไปจะบ่งชี้ว่ารันไทม์ไม่รู้จักคลาสที่ลงทะเบียนไว้ ซึ่งมักเกิดจากความไม่ตรงกันของเวอร์ชันในไลบรารี

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

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

การเชื่อมโยงขาเข้าและขาออก: การผสานรวมแบบประกาศกับบริการ

การผูกค่าอินพุตและเอาต์พุตช่วยให้สามารถโต้ตอบกับบริการต่างๆ เช่น Table Storage, Blob Storage, คิว, Event Hubs หรือ HTTP ได้จากภายในฟังก์ชัน Java ของคุณ แต่ละฟังก์ชันสามารถรวมการผูกค่าอินพุตหลายรายการเข้ากับการผูกค่าเอาต์พุตหลายรายการได้

ในตัวอย่างทั่วไป ฟังก์ชัน HTTP อาจรับเนื้อหาของคำขอเป็น String และในขณะเดียวกันก็มี การผูกข้อมูลอินพุตกับ Azure Table Storageซึ่งจะดึงข้อมูลแถวที่ระบุและแมปไปยัง POJO รวมถึงการผูกเอาต์พุตที่จะแทรกองค์ประกอบอื่นลงในตารางหรือคิวเมื่อเสร็จสิ้น

เมื่อคุณต้องการประมวลผลข้อมูลเป็นชุด เช่น ชุดข้อความจาก Event Hubs คุณสามารถเชื่อมโยงไปยัง... อาร์เรย์หรือลิสต์ของสตริงหรือ POJO โดยใช้แอตทริบิวต์จำนวนสมาชิกที่เหมาะสม (Cardinality.MANYระบบจะแปลงชุดเหตุการณ์ให้เป็นคอลเลกชันที่เกี่ยวข้องในระหว่างการทำงาน

ในกรณีที่มีเอาต์พุตหลายรายการ คุณสามารถใช้ทั้งสองแบบได้ ค่าส่งคืนของฟังก์ชันสำหรับการผูกเอาต์พุตเดียว (ทำเครื่องหมายไว้ว่า) $return) เหมือนกับประเภท OutputBinding<T> จากไลบรารีเพื่อส่งคอลเลกชันหรือเขียนไปยังคิวหรือตารางหลายรายการพร้อมกัน

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

ประเภทข้อมูลเฉพาะสำหรับ HTTP: HttpRequestMessage และ HttpResponseMessage

สำหรับฟังก์ชันที่เรียกใช้งานผ่าน HTTP ไลบรารี Azure Functions สำหรับ Java มีประเภทข้อมูลเฉพาะ เช่น HttpRequestMessage<T> และ HttpResponseMessageซึ่งช่วยให้เข้าถึงส่วนหัว HTTP พารามิเตอร์การค้นหา และเมธอดต่างๆ ได้มากกว่าสตริงธรรมดา

กับ HttpRequestMessage<T> คุณสามารถอ่านได้ ส่วนเนื้อหาเป็นตัวเลือกเสริม การเข้าถึงสตริงคำค้นหา และส่วนหัว และสร้างการตอบกลับแบบกำหนดเองด้วยรหัสสถานะและเนื้อหาการตอบกลับที่แตกต่างกัน ซึ่งมีประโยชน์มากสำหรับการสร้าง REST API ที่ซับซ้อนยิ่งขึ้น

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

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

ExecutionContext, การบันทึกข้อมูล และการตรวจสอบ

แต่ละฟังก์ชันใน Java จะได้รับพารามิเตอร์ ExecutionContext ซึ่งกำหนดไว้ในไลบรารี azure-functions-java-libraryโดยมีเครื่องมืออำนวยความสะดวกในการโต้ตอบกับรันไทม์ของฟังก์ชัน และที่สำคัญที่สุดคือมีตัวบันทึกข้อมูลในตัว

กับ context.getLogger() คุณสามารถเขียน ข้อความบันทึกในระดับข้อมูล คำเตือน หรือข้อผิดพลาด จากโค้ดฟังก์ชันของคุณ รวมถึงข้อมูลที่เป็นประโยชน์ เช่น ชื่อฟังก์ชันหรือตัวระบุการเรียกใช้ เพื่อเชื่อมโยงเหตุการณ์ต่างๆ เข้าด้วยกัน

สำหรับการแสดงผลข้อมูลบันทึก (log visualization) นั้น Azure CLI มีคำสั่งดังต่อไปนี้ az webapp log tail สำหรับ แสดงผลบันทึกข้อมูลแบบเรียลไทม์สามารถกรองตามผู้ให้บริการได้ด้วยตัวเลือกดังกล่าว --providerนอกจากนี้ คุณยังสามารถดาวน์โหลดไฟล์บันทึกทั้งหมดที่บีบอัดอยู่ในไฟล์ ZIP ได้ด้วย az webapp log download.

อย่างไรก็ตาม ก่อนที่คุณจะสามารถใช้ความสามารถเหล่านี้ได้ คุณต้องเปิดใช้งานการบันทึกข้อมูลระบบไฟล์ในพอร์ทัล Azure หรือผ่านทาง CLIก่อน เมื่อเปิดใช้งานแล้ว คุณจะมีทั้งบันทึก stdout และ stderr ของ Java รวมถึงบันทึกแอปพลิเคชันอื่นๆ สำหรับการวินิจฉัยปัญหา

ตัวแปรสภาพแวดล้อมและการกำหนดค่าแอปพลิเคชัน

ใน Azure Functions การกำหนดค่าแอปพลิเคชัน (สตริงการเชื่อมต่อ คีย์ การตั้งค่าแบบกำหนดเอง) จะถูกเปิดเผยในรูปแบบ ตัวแปรสภาพแวดล้อมขณะรันไทม์ในภาษา Java คุณสามารถเข้าถึงพวกมันได้โดยใช้ System.getenv("NOMBRE_VARIABLE").

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

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

เพื่อความปลอดภัยสูงสุด รูปแบบนี้มักถูกนำไปใช้ร่วมกับบริการต่างๆ เช่น Azure Key Vault เพื่อรวมศูนย์ข้อมูลลับ แต่จากมุมมองของ Java Functions ทุกอย่างจะถูกส่งมาในรูปแบบตัวแปรสภาพแวดล้อมมาตรฐาน

การกลับด้านการควบคุมและการฉีดการพึ่งพาใน Azure Functions Java

หากคุณใช้งานเฟรมเวิร์กอย่าง Spring, Quarkus, Guice หรือ Dagger เป็นประจำ คุณอาจต้องการใช้Inversion of Control (IoC) และ Dependency Injection (DI)กับฟังก์ชันแบบ Serverless ของคุณด้วยเช่นกัน Azure Functions for Java มีกลไกสำหรับเรื่องนี้ผ่านทาง Serverless Protection Interface (SPI)

บรรจุภัณฑ์ azure-function-java-spi รวมถึงอินเทอร์เฟซ ฟังก์ชันอินสเตนเตอร์ซึ่งทำหน้าที่เป็นโรงงานสร้างอินสแตนซ์สำหรับคลาสฟังก์ชัน โดยการใช้งานอินเทอร์เฟซนี้ เฟรมเวิร์ก DI ของคุณจะสามารถจัดการการสร้างอ็อบเจ็กต์ที่มีฟังก์ชันต่างๆ ได้

สัญญานั้นเรียบง่าย: วิธีการ getInstance(Class<T> functionClass) รับคลาสที่มีฟังก์ชันและต้อง ส่งคืนอินสแตนซ์ที่สร้างโดยคอนเทนเนอร์ IoCจากนั้น Azure Java worker จะเรียกใช้เมธอดที่ระบุไว้ใน annotation ของอินสแตนซ์นั้น แทนที่จะสร้างอินสแตนซ์โดยตรง

แนวทางนี้ทำให้ฟังก์ชันต่างๆ สามารถจัดการได้ด้วย Spring bean, Quarkus component หรือ Guice-injectedช่วยให้คุณสามารถนำโครงสร้างพื้นฐานทั้งหมดของบริการ ที่เก็บข้อมูล และตรรกะทางธุรกิจกลับมาใช้ใหม่ได้โดยไม่ต้องทำซ้ำหรือใช้เทคนิคแปลกๆ

Java และเฟรมเวิร์ก Spring ภายในระบบนิเวศของ Microsoft

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

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

Spring ถือกำเนิดขึ้นเพื่อแก้ปัญหาความซับซ้อนของการพัฒนาแอปพลิเคชันด้วยภาษา Java แบบดั้งเดิมในช่วงต้นทศวรรษ 2000 เมื่อเวลาผ่านไป โครงการในตระกูล Spring (Spring Framework, Spring Boot, Spring Cloud เป็นต้น) ได้กลายเป็นมาตรฐานที่ใช้กันอย่างแพร่หลายในการสร้างแอปพลิเคชันและไมโครเซอร์วิสด้วยภาษา Java

ภายในระบบนิเวศนี้Spring Boot คือโมดูลที่ช่วยลดความซับซ้อนและเร่งการพัฒนาเว็บแอปพลิเคชันและไมโครเซอร์วิส โดยมีคุณสมบัติการกำหนดค่าอัตโนมัติ เซิร์ฟเวอร์แบบฝังตัว รูปแบบการกำหนดค่าที่สม่ำเสมอ และการเริ่มต้นทำงานที่รวดเร็วมาก

แม้ว่าบางครั้งคุณอาจได้ยินคำว่า "Java Spring Boot" หรือ "Java Spring Framework" ถูกใช้สลับกันไปมา แต่การแยกแยะระหว่าง Spring ในฐานะเฟรมเวิร์กโดยรวม และ Spring Boot ในฐานะส่วนขยายสำหรับทำให้การเริ่มต้นระบบง่ายขึ้นนั้น ถูกต้องกว่า Microsoft ให้การสนับสนุนสแต็กนี้อย่างชัดเจน โดยมีบริการ Azure ที่ออกแบบมาเพื่อการปรับใช้แอปพลิเคชัน Spring (เช่น บริการจัดการสำหรับ Spring Apps) และเครื่องมือใน IDE

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

แหล่งข้อมูลเพิ่มเติมและจุดเริ่มต้นใน Azure

หากคุณต้องการศึกษาให้ลึกซึ้งยิ่งขึ้น ไมโครซอฟต์มีเส้นทางการเรียนรู้เฉพาะด้าน Java ใน Azureซึ่งอธิบายทีละขั้นตอนถึงวิธีการสร้าง ย้าย และปรับขนาดแอปพลิเคชัน Java โดยใช้บริการต่างๆ เช่น App Service, Azure Kubernetes Service, Azure Functions หรือฐานข้อมูลแบบจัดการ

เส้นทางเหล่านี้แสดงให้เห็นถึงวิธีการใช้งานSpring, Tomcat, WildFly, JBoss, WebLogic, WebSphere, Maven, Gradle, IntelliJ, Eclipse, Jenkins หรือ Terraform ร่วมกัน ในสถานการณ์จริงของการย้ายและปรับปรุงแอปพลิเคชัน Java ที่มีอยู่ให้ทันสมัยยิ่งขึ้น

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

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

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