Scala for Backend Engineering & Functional Programming · Ders

Source, Flow ve Sink

Akış işlemenin yapı taşları.

1. ders / 413 adım

Source, Flow ve Sink, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Scala for Backend Engineering & Functional Programming öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Scala for Backend Engineering & Functional Programming kursu toplamda 4 dersten oluşur.

Üç Temel Yapı Taşı

Akka Streams, bir veri işlem hattını işleme aşamalarından oluşan bir grafik olarak modeller. Üç temel doğrusal aşama şunlardır: Source (öğe üretir), Flow (öğeleri dönüştürür) ve Sink (öğeleri tüketir).

Bir Source'un bir çıkışı, bir Sink'in bir girişi, bir Flow'un ise tam olarak bir girişi ve bir çıkışı vardır. Bunları birbirine bağlamak, ne olması gerektiğini açıklar; ne zaman olacağını değil.

Bir Source Tanımlama

Bir Source[Out, Mat], Out türünde öğeler üretir ve Mat türünde gerçekleştirilmiş bir değer sunar. En basit kaynaklar bellek içi koleksiyonlardan veya aralıklardan oluşturulur.

Akış çalıştırılana kadar Source, serbestçe yeniden kullanılabilen değişmez bir taslaktan ibarettir.

import akka.stream.scaladsl.Source

val numbers: Source[Int, akka.NotUsed] =
  Source(1 to 100)

val single: Source[String, akka.NotUsed] =
  Source.single("hello")

Bir Sink Tanımlama

Bir Sink[In, Mat], In türündeki öğeleri tüketir. Gerçekleştirilmiş değer çoğu zaman tüketimin sonucunu içerir; örneğin akış sona erdiğinde tamamlanan bir Future.

Sink.foreach her öğe için bir yan etki çalıştırır; Sink.fold ise tek bir sonuç biriktirir.

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

val printSink: Sink[Int, Future[akka.Done]] =
  Sink.foreach(println)

val sumSink: Sink[Int, Future[Int]] =
  Sink.fold(0)(_ + _)

Bir Flow Tanımlama

Bir Flow[In, Out, Mat], bir Source ile Sink arasında yer alır ve her öğeyi dönüştürür. Flow'lar tek başlarına yeniden kullanılabilir ve herhangi bir uç noktaya bağlanmadan önce birleştirilebilir.

Burada bir Flow, tam sayıları ikiyle çarpar ve dizelere dönüştürür.

import akka.stream.scaladsl.Flow

val doubleToString: Flow[Int, String, akka.NotUsed] =
  Flow[Int]
    .map(_ * 2)
    .map(n => s"value=$n")

Source'u Sink'e Bağlama

via işleci bir Flow'u Source'a bağlar, to ise bir Sink bağlar. Bir Source'u doğrudan to ile bir Sink'e bağlamak, kapalı ve çalıştırılabilir bir taslak olan RunnableGraph üretir.

Henüz hiçbir öğe hareket etmez; bu işlem yalnızca topolojiyi tanımlar.

import akka.stream.scaladsl.{Source, Sink, RunnableGraph}

val graph: RunnableGraph[akka.NotUsed] =
  Source(1 to 10).to(Sink.foreach(println))

via: Bir Flow Ekleme

İşlem hattına bir Flow eklemek için via kullanın. Bir Source.via(flow), çıktı türü Flow'un çıktı türüyle eşleşen yeni bir Source üretir.

via çağrılarını zincirlemek, küçük ve test edilebilir Flow parçalarından uzun dönüşüm işlem hatları oluşturmanızı sağlar.

val pipeline =
  Source(1 to 10)
    .via(Flow[Int].filter(_ % 2 == 0))
    .via(Flow[Int].map(_ * 10))
    .to(Sink.foreach(println))

Aşamalar Arasında Tür Güvenliği

Derleyici, her aşamanın çıktı türünün bir sonraki aşamanın girdi türüyle eşleşmesini zorunlu kılar. Türü dönüştüren araya eklenmiş bir Flow olmadan Source[Int], Sink[String] ile bağlanamaz.

Bu statik denetim, işlem hattının bağlantı hatalarını çalışma zamanından önce yakalar.

// Source[Int] -> Flow[Int, String] -> Sink[String]
val ok =
  Source(1 to 3)
    .via(Flow[Int].map(_.toString))
    .to(Sink.foreach[String](println))

Somutlaştırılmış Değerler

Her taslak bir somutlaştırılmış değer taşır: akış çalıştırıldığında üretilen bir başvuru. Bir Sink.fold, sonucun Future'ını somutlaştırır. Varsayılan olarak aşamaları birleştirmek, en soldaki somutlaştırılmış değeri korur (yalın kaynaklar için NotUsed).

Hangi tarafın değerini istediğinizi seçmek için toMat ve Keep kullanın.

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

val g: RunnableGraph[Future[Int]] =
  Source(1 to 100)
    .toMat(Sink.fold(0)(_ + _))(Keep.right)

Yeniden Kullanılabilir Bileşenler

Source'lar, Flow'lar ve Sink'ler değiştirilemez değerler olduğundan, bunları bir kez tanımlayıp birçok işlem hattında yeniden kullanabilirsiniz. Bu yaklaşım, küçük ve adlandırılmış işleme aşamalarından oluşan bir kütüphane oluşturmayı teşvik eder.

Ayrıştırma için tanımlanan bir Flow, hem bir dosya işlem hattına hem de bir HTTP işlem hattına eklenebilir.

val parse: Flow[String, Int, akka.NotUsed] =
  Flow[String].map(_.trim.toInt)

val fromFile  = lines.via(parse)
val fromHttp  = requestBody.via(parse)

Yaygın Source Oluşturucuları

Akka Streams birçok Source fabrikasıyla birlikte gelir: zamanlanmış yayım için Source.single, Source.repeat ve Source.tick; bir Future'dan oluşturmak için Source.future ve Source.empty.

Doğru oluşturucuyu seçmek, veri üreticisinin amacını açıkça ifade eder.

import scala.concurrent.duration._

val ticks  = Source.tick(0.seconds, 1.second, "tick")
val onceF  = Source.future(scala.concurrent.Future.successful(42))
val forever = Source.repeat("x")

Yaygın Sink Oluşturucuları

Benzer şekilde Sink'ler arasında Sink.head (ilk öğeyi Future olarak döndürür), Sink.seq (tüm öğeleri bir Seq içinde toplar), Sink.ignore (tüketip atar) ve Sink.last bulunur.

Sonucu kodunuza geri aktaran işlem hatlarında en sık Sink.seq ve Sink.fold kullanılır.

import scala.concurrent.Future

val collect: Sink[Int, Future[Seq[Int]]] = Sink.seq
val firstOne: Sink[Int, Future[Int]]    = Sink.head
val drain: Sink[Int, Future[akka.Done]] = Sink.ignore

Hızlı Kontrol

Doğrusal aşama türlerini anlayıp anlamadığınızı sınayın.

Özet

Üç doğrusal yapı taşını öğrendiniz: Source üretir, Flow dönüştürür ve Sink tüketir. Bunlar via ve to ile birbirine bağlanan, değiştirilemez ve yeniden kullanılabilir taslaklardır.

Bir Source'u bir Sink'e bağlamak, somutlaştırılmış bir değer taşıyan ancak run çağrılana kadar hiçbir veriyi taşımayan bir RunnableGraph üretir. Sırada, akışları daha zengin işleçlerle dönüştüreceksiniz.

Başlamak ücretsiz

Yapay zeka eğitmeniyle Scala öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar
39
Dersler
143

Sıkça Sorulan Sorular

“Source, Flow ve Sink” dersi ücretsiz mi?

Evet — “Source, Flow ve Sink” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Scala for Backend Engineering & Functional Programming kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Scala for Backend Engineering & Functional Programming kursu toplamda 4 dersten oluşur.

“Source, Flow ve Sink” dersinde ne öğreneceğim?

Akış işlemenin yapı taşları. Scala for Backend Engineering & Functional Programming ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Scala for Backend Engineering & Functional Programming öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Scala for Backend Engineering & Functional Programming, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Source, Flow ve Sink” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Scala for Backend Engineering & Functional Programming dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Scala for Backend Engineering & Functional Programming dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Source, Flow ve Sink
  2. Akışları Dönüştürme
  3. Geri Basınç
  4. Bir İşlem Hattı Çalıştırma
← Scala for Backend Engineering & Functional Programming Sayfasına Dön