Scala for Backend Engineering & Functional Programming · Lekcja

Kompilacje wieloprojektowe i wdrażanie

Skonfiguruj i zarządzaj wieloprojektowymi kompilacjami SBT dla większych aplikacji oraz przygotuj je do wdrożenia.

Lekcja 3 z 311 kroki

Kompilacje wieloprojektowe i wdrażanie to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.

Dlaczego kompilacje wieloprojektowe?

W miarę rozrastania się aplikacji Scala zarządzanie całym kodem w jednym projekcie może stać się trudne. Kompilacje wieloprojektowe pomagają uporządkować bazę kodu.

Pozwalają one:

rozdzielić różne moduły (np. logikę podstawową, API i narzędzia),
jasno zarządzać zależnościami między tymi modułami,
stosować określone ustawienia do poszczególnych części aplikacji.

Takie podejście poprawia modularność i łatwość utrzymania kodu.

Definiowanie wielu projektów

W SBT definiuje się wiele projektów w głównym pliku build.sbt. Każdy projekt jest zazwyczaj wartością lazy val.

Projekt główny zwykle agreguje podprojekty lub od nich zależy.

Oto podstawowa konfiguracja projektu głównego i dwóch podprojektów:

lazy val root = project
  .in(file("."))
  .aggregate(core, api)

lazy val core = project
  .in(file("core"))

lazy val api = project
  .in(file("api"))

Struktura katalogów podprojektów

W kompilacji wieloprojektowej każdy podprojekt zwykle znajduje się we własnym katalogu na poziomie głównym projektu.

Standardowa struktura wygląda następująco:

my-app/ (katalog projektu głównego)
- build.sbt (główny plik kompilacji)
- project/ (pliki definicji kompilacji SBT)
- core/ (katalog podprojektu „core”)
  - src/ (kod źródłowy podprojektu „core”)
- api/ (katalog podprojektu „api”)
  - src/ (kod źródłowy podprojektu „api”)

Przykładowy kod podprojektu

Każdy podprojekt może zawierać własne pliki źródłowe Scala. Na przykład nasz projekt core może zawierać proste narzędzie.

Spróbuj uruchomić ten przykład z poziomu projektu core:

package com.coddykit.core

object Greeter {
  def greet(name: String): String = s"Hello, $name!"
}

object CoreApp {
  def main(args: Array[String]): Unit = {
    println(Greeter.greet("CoddyKit"))
  }
}

Zależności między projektami

Często jeden podprojekt musi korzystać z kodu innego podprojektu. Na przykład projekt api może potrzebować elementu Greeter z projektu core.

Takie zależności deklaruje się za pomocą .dependsOn() w pliku build.sbt.

lazy val root = project
  .in(file("."))
  .aggregate(core, api)

lazy val core = project
  .in(file("core"))

lazy val api = project
  .in(file("api"))
  .dependsOn(core)

Współdzielenie wspólnych ustawień

Wiele ustawień, takich jak wersja Scali czy wspólne zależności, może być takich samych we wszystkich podprojektach.

Aby uniknąć powtórzeń, można zdefiniować blok commonSettings i zastosować go do każdego projektu.

lazy val commonSettings = Seq(
  scalaVersion := "2.13.8",
  organization := "com.coddykit"
)

lazy val root = project
  .in(file("."))
  .aggregate(core, api)
  .settings(commonSettings)

lazy val core = project
  .in(file("core"))
  .settings(commonSettings)

lazy val api = project
  .in(file("api"))
  .dependsOn(core)
  .settings(commonSettings)

Agregowanie zadań

Jeśli projekt główny agreguje podprojekty, uruchomienie zadania takiego jak compile w projekcie głównym automatycznie uruchomi je we wszystkich agregowanych podprojektach.

Na przykład wpisanie sbt compile w katalogu głównym spowoduje skompilowanie zarówno projektu core, jak i api.

Kluczową rolę w tym działaniu odgrywa metoda .aggregate().

Pakowanie do wdrożenia

Po zbudowaniu aplikacji należy ją spakować do wdrożenia. Zwykle oznacza to utworzenie wykonywalnego pliku JAR (Java Archive).

W przypadku kompilacji wieloprojektowych często potrzebny jest jeden plik JAR zawierający cały kod projektu i jego zależności. Nazywa się go „fat JAR” lub „uber JAR”.

SBT domyślnie nie tworzy plików fat JAR, ale mogą w tym pomóc wtyczki.

Wtyczka SBT Assembly do tworzenia plików fat JAR

Wtyczka sbt-assembly jest powszechnie używana do tworzenia plików fat JAR. Łączy wszystkie skompilowane klasy i zależności w jeden wykonywalny plik JAR.

Najpierw dodaj wtyczkę do pliku project/plugins.sbt:

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

Pakowanie projektu wieloprojektowego

Które z poniższych stwierdzeń dotyczących pakowania wieloprojektowej aplikacji Scala do wdrożenia jest PRAWDZIWE?

Odpowiedz w interaktywnej lekcji

Powtórzenie i kolejne kroki

Nauczyłeś się, jak organizować i zarządzać kompilacjami wieloprojektowymi w SBT!

Omówiliśmy definiowanie podprojektów w pliku build.sbt.
Zobaczyłeś, jak organizować katalogi i zarządzać zależnościami między projektami za pomocą .dependsOn().
Omówiliśmy współdzielenie wspólnych ustawień i agregowanie zadań.
Na koniec poznaliśmy pakowanie do wdrożenia, w szczególności użycie wtyczki sbt-assembly do tworzenia plików fat JAR.

Biegłość w pracy z kompilacjami wieloprojektowymi ma kluczowe znaczenie w przypadku większych i bardziej złożonych aplikacji Scala, ponieważ zapewnia modularność i wydajny przebieg prac programistycznych.

Bezpłatny start

Ucz się Scala dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 39
Lekcje: 143

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Kompilacje wieloprojektowe i wdrażanie” jest bezpłatna?

Tak — pełny tekst „Kompilacje wieloprojektowe i wdrażanie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.

Co nauczysz się w „Kompilacje wieloprojektowe i wdrażanie”?

Skonfiguruj i zarządzaj wieloprojektowymi kompilacjami SBT dla większych aplikacji oraz przygotuj je do wdrożenia. Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.

Ile czasu zajmuje lekcja „Kompilacje wieloprojektowe i wdrażanie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Scala for Backend Engineering & Functional Programming