แอปพลิเคชัน Java ทำงานบนฐานข้อมูล Google Drive: 8 ขั้นตอน

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:07

คุณเคยต้องการสร้างแอปพลิเคชันที่ทำงานบนฐานข้อมูลไดนามิกที่ใช้งานง่าย ให้ผู้ใช้ที่ไม่เข้าใจเทคโนโลยีสามารถป้อนข้อมูลเข้าไป และไม่สิ้นเปลืองทรัพยากรของบริษัทหรือไม่? งั้นฉันมีทางออกให้คุณ วันนี้ เราจะสร้างแอปพลิเคชันที่ทำงานบน Google ไดรฟ์ (โดยเฉพาะ Google ชีต) และสามารถใช้งานได้หลากหลายวัตถุประสงค์ แม้ว่าบทช่วยสอนนี้จะเน้นที่การสร้างแอปตามเหตุการณ์เพื่อแสดงรายการเหตุการณ์ที่เกิดขึ้นรอบวิทยาเขตของวิทยาลัย แต่โครงการนี้สามารถเขียนใหม่ได้อย่างง่ายดายเพื่อให้ทำงานได้หลากหลายวิธี ไม่ว่าจะเป็นแอปเครื่องคิดเลขสำหรับแอปที่ตรวจสอบ หุ้นสำหรับผลิตภัณฑ์ ฉันได้แนบสำเนาใบสมัครของฉันมาด้วย หากคุณต้องการดูว่าเราจะดำเนินการอย่างไร แตกไฟล์ zip และเรียกใช้ JAR ข้างใน และตอนนี้โดยไม่ต้องกังวลใจต่อไป มาเริ่มกันเลย!

ขั้นตอนที่ 1: สิ่งที่คุณต้องการ

ในการเริ่มต้นโปรเจ็กต์นี้ คุณจะต้องมีแหล่งข้อมูลต่อไปนี้:

• เน็ตบีนส์

  ฉันแนะนำให้ดาวน์โหลด Java EE เนื่องจากให้การสนับสนุนเซิร์ฟเวอร์ แต่ถ้าคุณไม่ต้องการไฟล์ที่ไม่จำเป็นหรือพื้นที่ดิสก์เพิ่มเติม Java SE ก็ใช้งานได้เช่นกัน Netbeans จะทำหน้าที่เป็น IDE สำหรับการเข้ารหัสและรวบรวมแอปพลิเคชันของเรา

• ซุป

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

• Java SDK (V8)

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

• Visual Studio (ไม่บังคับ)

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

• รหัสเริ่มต้น

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

คนอื่น:

ความรู้พื้นฐานเกี่ยวกับจาวา จะเป็นประโยชน์หากมีความรู้ในภาษา Java เช่น การเขียนฟังก์ชัน การสร้างอ็อบเจ็กต์ ฯลฯ

ขั้นตอนที่ 2: การตั้งค่าฐานข้อมูลของคุณ

ในการเริ่มต้นโครงการ อันดับแรกเราต้องไปที่ Google Drive และสร้างชีตที่เราจะใช้เพื่อเรียกใช้แอปพลิเคชันของเรา ตรงไปที่ drive.google.com แล้วคลิกไอคอน "ใหม่" ที่มุมซ้ายบน แล้วเลือก "ชีต" ด้านล่าง

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

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

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

ขั้นตอนที่ 3: การตั้งค่า NetBeans

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

ก่อนที่เราจะเริ่มต้นเขียนโค้ด เราจะต้องตรวจสอบให้แน่ใจว่า NetBeans มีไลบรารี JSoup ซึ่งจะต้องแยกวิเคราะห์สเปรดชีตของเรา ใน NetBeans ให้คลิกขวาที่ไอคอน "Libraries" ใต้ไดเร็กทอรีของโปรเจ็กต์ของคุณ ใต้เมนูป๊อปอัป ให้เลือกปุ่มเพื่อเพิ่มไฟล์.jar ตอนนี้ นำทางไปยังทุกที่ที่คุณวางการดาวน์โหลด jsoup ของคุณ (ส่วนใหญ่มักจะเป็นโฟลเดอร์ดาวน์โหลดของคุณ เว้นแต่คุณจะระบุไว้ที่อื่น) เลือกไฟล์นี้และเพิ่มลงในไลบรารี หากคุณขยายโฟลเดอร์ Libraries ใน NetBeans คุณควรเห็น jsoup.jar ในพื้นที่นี้ เมื่อทำเช่นนั้นแล้ว เราสามารถเริ่มเขียนโค้ดแอปของเราได้แล้ว

ขั้นตอนที่ 4: การเข้ารหัสคลาสหลักของเรา

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

นำเข้า java.util. Collections;

นำเข้า java.util. List;

นำเข้า java.util. ArrayList;

นำเข้า java.util. Date;

นำเข้า java.util.stream. Stream;

นำเข้า java.util.stream. Collectors;

นำเข้า java.text. SimpleDateFormat;

นำเข้า java.text. ParseException;

นำเข้า org.jsoup. Jsoup;

นำเข้า org.jsoup.nodes. Document;

นำเข้า org.jsoup.nodes. Element;

นำเข้า org.jsoup.select. Elements;

นำเข้า javafx.beans.property. SimpleStringProperty;

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

เมื่อได้รับคำสั่งนำเข้าแล้ว ไปประกาศชั้นเรียนของเรากัน หากคุณวางแผนที่จะใช้ Dates หรืออ็อบเจกต์ที่ไม่ใช่พื้นฐานใดๆ ในการพัฒนาอ็อบเจ็กต์เฉพาะคลาสของคุณ ฉันแนะนำให้เพิ่ม "implements Comparable" ในการประกาศคลาสของคุณ ซึ่งจะทำให้คุณสามารถเปรียบเทียบ Objects ได้ ซึ่งจะช่วยให้คุณสามารถเรียงลำดับ List of ClassObjects ได้ในภายหลัง หลังจากทำเช่นนี้ ไปข้างหน้าและประกาศตัวแปรอินสแตนซ์ทั้งหมดที่คุณต้องการ สำหรับทุกสตริงสาธารณะที่คุณสร้าง คุณจะต้องสร้าง SimpleStringProperty สำหรับสตริงนั้นด้วย นี่คือวัตถุ JavaFX ที่จะให้เราทำงานกับวัตถุคลาสหลักของเราในภายหลัง

ตอนนี้ ไปข้างหน้าและประกาศให้คุณเข้าถึงฟังก์ชันต่างๆ เท่าที่ตัวแปรพื้นฐานของคุณมีอยู่ คุณสามารถตั้งชื่อฟังก์ชันของคุณตามที่คุณเลือกได้ อย่างไรก็ตาม สำหรับฟังก์ชันการเข้าถึง SSP คุณต้องใช้รูปแบบ getFunctionNameHere() เนื่องจากในภายหลังเราจะใช้ JavaFX เพื่อเชื่อมต่อกับฟังก์ชันเหล่านี้ และฟังก์ชันที่เราจะใช้กำหนดให้เราต้องเริ่มฟังก์ชัน SSP ด้วย get คุณสามารถดูตัวอย่างด้านบน

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

ขั้นตอนที่ 5: กำหนดวิธีการสร้าง () ของเรา

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

เหตุการณ์เหตุการณ์ = ใหม่ ArrayList())

ตอนนี้ ไปหา URL ที่คุณคัดลอกไว้ก่อนหน้านี้ไปยังสเปรดชีตที่เผยแพร่ ประกาศลิงค์นี้เป็นสตริงใน Java และเรียกมันว่าอะไรก็ได้ที่คุณต้องการ ตอนนี้ ไปข้างหน้าและประกาศเอกสาร Jsoup ใหม่ คุณสามารถทำได้โดยการสร้างวัตถุเอกสารใหม่ เช่น

เอกสาร doc = เอกสารใหม่ ();

ตอนนี้ ไปข้างหน้าและตั้งค่าเอกสารของคุณเพื่อเชื่อมต่อกับ URL ของเราและรับข้อมูล โดยให้ลอง:

เอกสาร doc = Jsoup.connect(url).get();

ตอนนี้ เราต้องรับเนื้อความของเอกสารของเรา ซึ่งเป็นที่เก็บข้อมูลจริง

ตัวสตริง = doc.body().text();

ตอนนี้ เราต้องเริ่มดึงข้อมูลออกจากร่างกาย เนื่องจากข้อมูลของเราอยู่ในตาราง (เนื่องจากเป็นสเปรดชีต) เราจึงต้องดึงตารางออกจากเนื้อหา มาลองกัน

ตารางองค์ประกอบ = doc.select("table").get(0);

นี่เป็นการเลือกตารางแรก ในกรณีนี้มีเพียงหนึ่งเดียว ตอนนี้พิมพ์

แถวองค์ประกอบ = table.select("tr");

นี่ทำให้เราได้แถวทั้งหมดในตารางดังกล่าว

ตอนนี้ ข้อมูลทั้งหมดของเราอยู่ในตัวแปรแถวนี้ นั่นเป็นสิ่งที่ดีและทั้งหมด แต่ประเด็นทั้งหมดในการเขียนฟังก์ชันนี้ในคลาสนี้คือเพื่อให้เราสามารถสร้างวัตถุจากมันได้ ดังนั้น ก่อนที่เราจะสามารถส่งคืนได้ เราต้องสร้าง List จากแถวของเราก่อน เมื่อต้องการทำเช่นนี้ เราสามารถใช้ for loop ฉันต้องสังเกตว่าสิ่งนี้ทำให้ฉันต้องทดลองและข้อผิดพลาดเล็กน้อยเพื่อให้ถูกต้อง ฉันรู้ว่าเมื่อดึงข้อมูลจากแถว ข้อมูลบางส่วนของเราไม่มีประโยชน์สำหรับสถานการณ์นี้ เนื่องจากมีข้อมูลต่างๆ เช่น ชื่อชีตแต่ละรายการ แถวแรกที่มีแนวคิดข้อมูลของเรา ฯลฯ ในท้ายที่สุด ฉันตั้งค่าเริ่มต้น ป้อนหมายเลขสำหรับลูปเป็น 2 ดังนั้นจึงข้ามรายการเหล่านี้และสร้างรายการของเราได้ ในที่สุดฉันก็พัฒนารูปลักษณ์ด้วยรหัส

สำหรับ (int i = 2; i < rows.size(); i++) {

แถวองค์ประกอบ = rows.get(i);

องค์ประกอบ cols = row.select("td");

ทีนี้ ในการสร้างวัตถุ ให้ทำบางอย่างเช่น

ชื่อวัตถุ = วัตถุใหม่ (cols.get(0).text());

โดยพื้นฐานแล้ว cols.get(0) จะได้รับข้อมูลจากแถว (i) คอลัมน์ (0) และเปลี่ยนเป็นสตริงซึ่งสามารถส่งผ่านไปยังตัวสร้างของวัตถุได้

หลังจากตั้งค่าการก่อสร้างของคุณแล้ว ให้เพิ่มลงในรายการที่เราสร้างไว้ก่อนหน้านี้ด้วย list.add() เช่น

events.add(ชื่อ);

ตอนนี้ ปิด for loop ของคุณและเรียกใช้ฟังก์ชันใดๆ ที่คุณอาจต้องการตอนนี้ ตัวอย่างเช่น ฉันเรียกใช้ฟังก์ชัน sort เพื่อรับเหตุการณ์ตามลำดับวันที่ หลังจากทำเช่นนั้น ให้คืนรายการของคุณ แล้วคุณจะเสร็จสิ้นในส่วนนี้!

ขั้นตอนที่ 6: การเข้ารหัสแอปพลิเคชันของเรา

สร้างไฟล์ใหม่และตั้งชื่อตามที่คุณเลือก คุณจะต้องนำเข้าต่อไปนี้:

นำเข้า java.util. List;

นำเข้า java.util. ArrayList;

นำเข้า java.util. Date;

นำเข้า javafx.geometry. Pos;

นำเข้า javafx.scene.layout. HBox;

นำเข้า javafx.application. Application;

นำเข้า javafx.collections.transformation. FilteredList;

นำเข้า javafx.scene.text. Font; นำเข้า javafx.scene.control.*;

นำเข้า javafx.collections. FXCollections;

นำเข้า javafx.collections. ObservableList;

นำเข้า javafx.geometry. Insets;

นำเข้า javafx.scene. Group;

นำเข้า javafx.scene. Scene;

นำเข้า javafx.scene.control. Label;

นำเข้า javafx.scene.control.cell. PropertyValueFactory;

นำเข้า javafx.scene.layout. VBox;

นำเข้า javafx.stage. Stage;

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

ตาราง TableView ส่วนตัว = TableView ใหม่ ();

ประกาศวิธีการหลักที่เราจะใช้เพื่อเปิดแอป โดยพื้นฐานแล้วควรมีลักษณะเหมือนภาพด้านบน

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

ข้อมูล ObservableList = FXCollections.observableArrayList();

ตอนนี้ สร้างฉากใหม่ด้วย:

ฉากฉาก = ฉากใหม่ (กลุ่มใหม่ ());

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

TableColumn eventCol = TableColumn ใหม่ ("ชื่อเหตุการณ์");eventCol.setMinWidth (100); eventCol.setCellValueFactory(ใหม่ PropertyValueFactory("sName"));

พารามิเตอร์ "sName" ควรเติมด้วยชื่อของฟังก์ชันการเข้าถึง SSP ของคุณ ดังนั้นจึงสามารถรับค่าที่คุณต้องการสำหรับอ็อบเจ็กต์ที่กำหนด สร้างคอลัมน์ได้มากเท่าที่คุณต้องการ แล้วเพิ่มลงในตารางด้วย

FilteredList flEvent = ใหม่ FilteredList(data, p -> true);

table.setItems(flEvent);

table.getColumns().addAll(eventCol, statCol, groupCol, datingCol, descCol, locationCol);

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

HBox hBox = HBox ใหม่ (choiceBox, textField);

hBox.setAlignment(Pos. CENTER);

คุณจะต้องเพิ่ม hBox ลงในเมธอด.addAll() ด้านล่าง

มิฉะนั้น เพียงแค่สร้าง vBox ใหม่เพื่อเก็บข้อมูลของเราโดยทำ

สุดท้าย VBox vbox = VBox ใหม่ ();

vbox.getChildren().addAll(ป้ายกำกับ, ตาราง);

((กลุ่ม) scene.getRoot()).getChildren().addAll(vbox);

stage.setScene (ฉาก); stage.show();

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

หลังจากเขียนโค้ดเสร็จแล้ว ฉันจะแนะนำให้สร้าง Javadoc ของโค้ดเพื่อให้คนอื่นเห็นว่าโค้ดของคุณทำอะไรได้บ้าง ในการทำเช่นนั้น ภายใต้ปุ่ม "เรียกใช้" ที่ด้านบนของหน้าจอ เพียงแค่กด "สร้าง Javadoc" คุณสามารถค้นหาสำเนา Javadoc ของฉันได้โดยดูในไฟล์ zip ในหน้าแรกและเลือกไฟล์ index.html

ขั้นตอนที่ 7: รวบรวมและบรรจุไฟล์ Jar ของเรา

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

ก่อนรวบรวมแอพของคุณ ตรวจสอบให้แน่ใจว่าทุกอย่างเสร็จสิ้น หากคุณต้องการเพิ่มเอกสารและสร้าง JavaDoc ให้ดำเนินการดังกล่าว หากคุณมีคำสั่ง System.out ที่พิมพ์ไปยังคอนโซลของคุณ ให้ลบออก โดยพื้นฐานแล้ว ตรวจสอบให้แน่ใจว่าแอปของคุณไม่มีคำสั่งหรือฟังก์ชันที่ไม่ต้องการ และมีทุกอย่างที่จำเป็นในการจัดแพ็คเกจ

หลังจากทำเช่นนั้น ให้คลิกขวาที่ชื่อโครงการใน NetBeans มันควรจะปรากฏขึ้นเมนู ตีคุณสมบัติ (ที่ด้านล่างสุดของเมนู) จากนั้นกด "บรรจุภัณฑ์" ที่ด้านซ้ายของเมนูป๊อปอัปใหม่ ตอนนี้ ตรวจสอบให้แน่ใจว่าได้ทำเครื่องหมายที่ช่องทำเครื่องหมายทั้งหมดแล้ว หน้าจอของคุณควรมีลักษณะเหมือนด้านบน

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

ขั้นตอนที่ 8: ขอแสดงความยินดี

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

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