Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

Menjalankan Saluran Paip

Jadikan bahan dan laksanakan graf.

Pelajaran 4 daripada 413 langkah

Menjalankan Saluran Paip ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.

Daripada Pelan kepada Pelaksanaan

Setakat ini, saluran paip hanyalah pelan tulen. Pewujudan ialah proses yang menukar pelan itu menjadi aktor yang sedang berjalan dan benar-benar memindahkan data.

Tiada apa-apa berlaku sehingga Anda menjalankan graf secara jelas, dan inilah yang menjadikan Akka Streams boleh digubah serta digunakan semula.

ActorSystem

Pewujudan memerlukan ActorSystem, yang menyediakan utas dan penghantar yang menyokong peringkat aliran. Dalam Akka moden, sistem ini juga bertindak sebagai materializer tersirat.

Satu ActorSystem biasanya melayani seluruh aplikasi dan banyak aliran serentak.

import akka.actor.ActorSystem

implicit val system: ActorSystem =
  ActorSystem("data-pipeline")
import system.dispatcher // ExecutionContext

runWith

Cara paling langsung untuk menjalankan Sumber ialah runWith, yang melampirkan Sink dan mewujudkannya dalam satu langkah, lalu mengembalikan nilai terwujud Sink tersebut.

Di sini, hasilnya ialah Future[Int] yang selesai dengan jumlah apabila aliran tamat.

import akka.stream.scaladsl.{Source, Sink}
import scala.concurrent.Future

val total: Future[Int] =
  Source(1 to 100).runWith(Sink.fold(0)(_ + _))

run pada RunnableGraph

Jika Anda telah membina RunnableGraph tertutup dengan to atau toMat, panggil run() untuk mewujudkannya. Nilai yang dikembalikan ialah apa jua nilai terwujud yang dikekalkan oleh graf.

Ini memisahkan pembinaan saluran paip daripada pelaksanaan dengan jelas.

import akka.stream.scaladsl.Keep
import scala.concurrent.Future

val graph =
  Source(1 to 100)
    .toMat(Sink.fold(0)(_ + _))(Keep.right)

val result: Future[Int] = graph.run()

Operator run Mudah

Sumber menyediakan pintasan: runForeach, runFold dan runReduce masing-masing melampirkan Sink yang sepadan dan berjalan serta-merta.

Operator ini ringkas untuk operasi terminal biasa pada Sumber.

import scala.concurrent.Future

val printed: Future[akka.Done] =
  Source(1 to 10).runForeach(println)

val sum: Future[Int] =
  Source(1 to 10).runFold(0)(_ + _)

Bekerja dengan Future Hasil

Sink terminal mengembalikan Future yang selesai apabila aliran tamat atau gagal. Daftarkan panggil balik dengan onComplete untuk bertindak balas terhadap kejayaan atau ralat.

Gunakan penghantar ActorSystem sebagai ExecutionContext tersirat untuk panggil balik ini.

import scala.util.{Success, Failure}

total.onComplete {
  case Success(value) => println(s"Sum = $value")
  case Failure(ex)    => println(s"Failed: ${ex.getMessage}")
}

Saluran Paip Realistik

Saluran paip data yang biasa membaca daripada Sumber, mengubah data dengan Aliran, menjalankan I/O tak segerak dengan mapAsync, mengumpulkan data secara kelompok dengan grouped, kemudian menulisnya ke Destinasi.

Setiap peringkat adalah kecil, dan keseluruhan saluran paip dapat dijalankan dengan satu run.

val done =
  lineSource
    .map(parse)
    .mapAsync(4)(validate)
    .grouped(500)
    .runWith(bulkWriteSink)

Memulakan Semula Aliran yang Gagal

Untuk meningkatkan ketahanan, bungkus Sumber atau Aliran dengan RestartSource.withBackoff supaya kegagalan sementara (seperti sambungan terputus) mencetuskan mula semula automatik dengan penangguhan eksponen.

Dengan cara ini, saluran paip pengambilan data yang berjalan lama dapat terus beroperasi tanpa penyeliaan manual.

import akka.stream.scaladsl.RestartSource
import akka.stream.RestartSettings
import scala.concurrent.duration._

val resilient = RestartSource.withBackoff(
  RestartSettings(1.second, 30.seconds, 0.2))(() => flakySource)

Penutupan Lancar dengan KillSwitch

KillSwitch membolehkan kod luaran menghentikan aliran yang sedang berjalan dengan bersih. Masukkan KillSwitches.single melalui viaMat dan simpan nilai terhasilnya untuk memanggil shutdown() kemudian.

Hal ini penting untuk aliran yang berjalan lama dan perlu dihentikan apabila aplikasi ditutup.

import akka.stream.{KillSwitches, KillSwitch}
import akka.stream.scaladsl.Keep

val (switch, done) =
  source
    .viaMat(KillSwitches.single)(Keep.right)
    .toMat(Sink.ignore)(Keep.both)
    .run()
// later: switch.shutdown()

Melepaskan Sumber

Apabila aplikasi keluar, gunakan terminate pada ActorSystem untuk membebaskan utasnya. Rantaikan panggilan terminate selepas Future penyelesaian aliran supaya shutdown berlaku dengan teratur.

ActorSystem yang dibiarkan tanpa ditutup akan memastikan JVM terus hidup dan sumber terus terbuka.

done.onComplete { _ =>
  system.terminate()
}

Menggunakan Semula Materializer

Memproses pelan cetak yang sama beberapa kali untuk menghasilkan aliran mencipta aliran berjalan yang berasingan dan berkongsi sumber ActorSystem. Pelan cetak itu sendiri kekal tidak boleh diubah dan tanpa kesan sampingan.

Hal ini menjadikannya selamat untuk mentakrifkan saluran paip sekali sahaja dan menjalankannya apabila diperlukan bagi setiap tugas yang masuk.

val blueprint =
  Source(1 to 5).toMat(Sink.seq)(Keep.right)

val run1 = blueprint.run()
val run2 = blueprint.run() // independent execution

Semakan Pantas

Fikirkan perkara yang diperlukan supaya aliran benar-benar memproses unsur.

Jawab dalam pelajaran interaktif

Imbas Kembali

Menjalankan saluran paip bermaksud menghasilkan pelan cetak dengan ActorSystem melalui run, runWith atau operator kemudahan, yang setiap satunya mengembalikan hasil Future.

Anda telah melihat saluran paip berbilang peringkat yang realistik, mula semula automatik dengan penangguhan, penutupan lancar melalui KillSwitch, pembersihan sumber dengan system.terminate(), serta penggunaan semula pelan cetak tidak boleh diubah yang selamat merentas proses berjalan yang berasingan.

Percuma untuk bermula

Pelajari Scala dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 143

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Menjalankan Saluran Paip” percuma?

Ya — teks penuh “Menjalankan Saluran Paip” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Menjalankan Saluran Paip”?

Jadikan bahan dan laksanakan graf. Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “Menjalankan Saluran Paip” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?

Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian