0Pricing
Scala for Backend Engineering & Functional Programming · บทเรียน

การจัดการการพึ่งพาและปลั๊กอิน

จัดการไลบรารีภายนอก ประกาศการพึ่งพา และใช้ปลั๊กอิน SBT เพื่อขยายความสามารถในการสร้าง

การจัดการการพึ่งพาและปลั๊กอิน เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน

เหตุใดจึงต้องใช้ไลบรารีภายนอก

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

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

การเพิ่มไลบรารีลงใน build.sbt

SBT ช่วยให้เพิ่มไลบรารีภายนอกเหล่านี้ได้ง่าย คุณประกาศไลบรารีเหล่านี้ในไฟล์ build.sbt โดยใช้การตั้งค่า libraryDependencies

ไวยากรณ์พื้นฐานมีดังนี้:

  • "org.group": รหัสองค์กรหรือกลุ่ม
  • % "artifact": รหัสสิ่งประดิษฐ์ (ชื่อไลบรารี) ใช้ %% สำหรับไลบรารี Scala เพื่อให้ตรงกับรุ่น Scala ของคุณโดยอัตโนมัติ
  • % "version": รุ่นเฉพาะของไลบรารีที่คุณต้องการ

ตัวอย่าง:

libraryDependencies += "org.slf4j" % "slf4j-simple" % "1.7.32"

ขอบเขตของสิ่งที่ต้องพึ่งพา: คอมไพล์และการทดสอบ

ไลบรารีอาจจำเป็นเฉพาะกับบางส่วนของโครงการ SBT ใช้ขอบเขตเพื่อจัดการเรื่องนี้

  • compile (ค่าเริ่มต้น): จำเป็นสำหรับการคอมไพล์และเรียกใช้โค้ดหลัก
  • test: จำเป็นเฉพาะสำหรับการคอมไพล์และเรียกใช้โค้ดการทดสอบ เช่น กรอบการทำงานสำหรับการทดสอบอย่าง ScalaTest
  • runtime: ไม่จำเป็นในระหว่างการคอมไพล์ แต่จำเป็นเมื่อแอปพลิเคชันทำงาน

คุณระบุขอบเขตได้ดังนี้:

libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.16" % "test"

การดึงสิ่งที่ต้องพึ่งพาโดยอัตโนมัติ

ลองนึกภาพว่าไลบรารีที่คุณใช้ เช่น กรอบการทำงานเว็บ ก็ใช้ไลบรารีอื่นด้วยเช่นกัน สิ่งเหล่านี้เรียกว่าสิ่งที่ต้องพึ่งพาแบบส่งต่อ

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

วิธีนี้ช่วยให้คุณไม่ต้องติดตามไลบรารีจำนวนมากด้วยตนเอง

การบันทึกข้อมูลการทำงานด้วย SLF4J

มาใช้ไลบรารีสำหรับการบันทึกข้อมูลการทำงานที่พบได้ทั่วไปอย่าง SLF4J (ส่วนเชื่อมต่อการบันทึกข้อมูลอย่างง่ายสำหรับ Java) พร้อมการใช้งานแบบง่ายกัน ขั้นแรก เพิ่มไลบรารีนี้ลงใน build.sbt:

libraryDependencies += "org.slf4j" % "slf4j-simple" % "1.7.32"

จากนั้นเรียกใช้โค้ด Scala ด้านล่างเพื่อดูการทำงาน สังเกตว่าเรานำเข้า org.slf4j.LoggerFactory ซึ่งมาจากสิ่งที่ต้องพึ่งพาใหม่ของเรา

import org.slf4j.LoggerFactory

object Main {
  private val logger = LoggerFactory.getLogger(getClass.getName)

  def main(args: Array[String]): Unit = {
    logger.info("Hello from a logged message!")
    println("This is a standard print output.")
  }
}

การขยาย SBT ด้วยปลั๊กอิน

นอกจากการจัดการไลบรารีแล้ว ยังสามารถขยาย SBT ได้ด้วยปลั๊กอิน ปลั๊กอินคือไฟล์ JAR พิเศษที่เพิ่มคำสั่งหรือการตั้งค่าใหม่ให้กับ SBT

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

ปลั๊กอินช่วยทำให้งานทั่วไปเป็นอัตโนมัติและทำให้กระบวนการพัฒนาของคุณคล่องตัวยิ่งขึ้น

การประกาศปลั๊กอินใน plugins.sbt

ต่างจากสิ่งที่ต้องพึ่งพาทั่วไปซึ่งอยู่ใน build.sbt ปลั๊กอิน SBT จะประกาศไว้ในไฟล์พิเศษคือ project/plugins.sbt ไฟล์นี้อยู่ภายในไดเรกทอรี project ที่รากของโครงการ SBT

ไวยากรณ์คล้ายกับสิ่งที่ต้องพึ่งพา แต่คุณจะใช้ addSbtPlugin:

addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.1.1")

คำสั่งนี้บอกให้ SBT ดาวน์โหลดและเปิดใช้งานปลั๊กอินที่ระบุสำหรับโครงการของคุณ

การสร้าง JAR รวมด้วย sbt-assembly

ปลั๊กอินยอดนิยมตัวหนึ่งคือ sbt-assembly ซึ่งสร้าง "JAR รวม" ที่เรียกใช้งานได้ไฟล์เดียว โดยบรรจุโค้ดของแอปพลิเคชันและสิ่งที่ต้องพึ่งพาทั้งหมดไว้ด้วยกัน

ขั้นแรก เพิ่มปลั๊กอินลงใน project/plugins.sbt:

addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.1.1")

หลังจากเพิ่มแล้ว คุณสามารถเรียกใช้ sbt assembly จากเทอร์มินัลเพื่อสร้าง JAR ได้ โค้ด Scala ด้านล่างคือสิ่งที่ sbt-assembly จะนำไปจัดแพ็กเกจ

object Main {
  def main(args: Array[String]): Unit = {
    println("This is a simple application.")
    println("sbt-assembly would package this along with its dependencies into a single JAR.")
  }
}

การจัดการรุ่นและตัวแก้ไขแหล่งข้อมูล

เมื่อโครงการของคุณเติบโตขึ้น การจัดการสิ่งที่ต้องพึ่งพาจำนวนมากอาจเป็นเรื่องยุ่งยาก ต่อไปนี้คือเคล็ดลับบางประการ:

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

โดยค่าเริ่มต้น SBT จะใช้คลังเก็บสาธารณะมาตรฐาน หากเป็นไลบรารีส่วนตัว คุณต้องระบุตัวแก้แหล่งเก็บแบบกำหนดเองใน build.sbt

จัดลำดับขั้นตอน

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

สรุปบทเรียน

ทำได้ดีมาก! คุณได้เรียนรู้วิธีจัดการโค้ดภายนอกในโครงการ Scala แล้ว

  • สิ่งที่ต้องพึ่งพา (ไลบรารี) จะถูกเพิ่มลงใน build.sbt โดยใช้ libraryDependencies
  • SBT จัดการ สิ่งที่ต้องพึ่งพาแบบถ่ายทอด และรองรับ ขอบเขต ที่แตกต่างกัน (เช่น compile และ test)
  • ปลั๊กอินช่วยเพิ่มความสามารถให้ SBT และประกาศไว้ใน project/plugins.sbt โดยใช้ addSbtPlugin

การเชี่ยวชาญด้านการจัดการสิ่งที่ต้องพึ่งพาและปลั๊กอินเป็นกุญแจสำคัญในการสร้างแอปพลิเคชัน Scala ที่ซับซ้อนและมีความทนทานได้อย่างมีประสิทธิภาพ!

คำถามที่พบบ่อย

บทเรียน “การจัดการการพึ่งพาและปลั๊กอิน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การจัดการการพึ่งพาและปลั๊กอิน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การจัดการการพึ่งพาและปลั๊กอิน”

จัดการไลบรารีภายนอก ประกาศการพึ่งพา และใช้ปลั๊กอิน SBT เพื่อขยายความสามารถในการสร้าง คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน

บทเรียน “การจัดการการพึ่งพาและปลั๊กอิน” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การตั้งค่าโครงการ SBT และพื้นฐาน
  2. การจัดการการพึ่งพาและปลั๊กอิน
  3. การสร้างและนำไปใช้งานหลายโครงการ
← กลับไปที่ Scala for Backend Engineering & Functional Programming