Bagaimana anda boleh membina Hello World API dengan Scala dan Akka HTTP

Ya, ia tetap menjadi perkara.

Akka adalah toolkit berasaskan pelakon yang popular untuk membina aplikasi serentak dan diedarkan di JVM. Aplikasi ini kebanyakannya menggunakan Scala atau Java.

Ia mempunyai beberapa modul yang membantu membina aplikasi seperti itu, dan Akka HTTP adalah salah satu daripadanya.

Akka HTTP mempunyai utiliti sisi pelanggan dan pelayan. Kami akan memberi tumpuan kepada pelayan dalam tutorial ini.

Anda semestinya sudah biasa dengan Scala, dan anda harus memasang dan memasang SBT dan IntelliJ. Sekiranya tidak demikian, periksa dokumen rasmi.

Tanpa basa-basi lagi, mari kita membina API dunia hello menggunakan Scala dan Akka HTTP!

Penyediaan projek

Jangan ragu untuk mengklon repo, pastikan anda menggunakan cawangan 2.1-review-project.

Sekiranya tidak, kami akan menggunakan sbt 1.1.6dan Scala 2.12.6. Periksa fail build.propertiesdan build.sbtfail anda untuk memastikan versi di sana sesuai dengan versi ini.

Mari mulakan dengan menambahkan kebergantungan yang diperlukan. Kerana Akka HTTP bergantung pada pelakon dan aliran, kami juga perlu menambahkan perpustakaan tersebut.

Tambahkan coretan berikut di akhir build.sbtfail anda :

libraryDependencies ++= Seq( "com.typesafe.akka" %% "akka-actor" % "2.5.13", "com.typesafe.akka" %% "akka-stream" % "2.5.13", "com.typesafe.akka" %% "akka-http" % "10.1.3",)

Sekiranya anda diminta untuk mengaktifkan import automatik, lakukanlah. Jika tidak, anda boleh membuka terminal dan cdke direktori root projek anda. Kemudian jalankan sbt updateuntuk mendapatkan kebergantungan.

Auto-import akan memastikan untuk mengemas kini projek anda setiap kali fail tertentu dikemas kini, termasuk build.sbtfail tersebut.

Pergantungan segera

Mari buat objek Scala dengan nama "src / main / scala" Server. Kami akan memulakan dengan memberi pergantungan yang diperlukan untuk membuat pelayan dengan Akka HTTP.

Pertama, objek akan memanjangkan Appsifat:

object Server extends App {}

Ini akan membolehkan Serverobjek kita dapat dijalankan.

Kami memerlukan host dan port untuk mengikat pelayan, jadi mari tambahkan mereka sekarang:

val host = "0.0.0.0"val port = 9000

Kerana Akka HTTP menggunakan pelakon dan aliran Akka di bawahnya, kami juga perlu menyediakan pergantungan mereka:

implicit val system: ActorSystem = ActorSystem("helloworld")implicit val executor: ExecutionContext = system.dispatcherimplicit val materializer: ActorMaterializer = ActorMaterializer()

Walaupun anda tidak perlu tahu apa yang mereka lakukan untuk mula mengembangkan aplikasi HTTP Akka, selalu baik untuk mengetahui apa yang mereka gunakan.

An ActorSystemdigunakan untuk menguruskan pelakon. Ia digunakan untuk membuat dan mencari mereka. Pelakon dalam sistem yang sama biasanya berkongsi konfigurasi yang sama.

Yang ExecutionContextbertanggungjawab melaksanakan Futures. Ia tahu di mana dan bagaimana cara melaksanakannya, contohnya di kumpulan utas.

Dan akhirnya, seorang ActorMaterializeryang bertanggungjawab menjalankan aliran.

Dengan itu, kami dapat membuat laluan hello kami!

Buat laluan

Untuk membuat laluan kami, kami akan menggunakan DSL penghalaan Akka HTTP. Ini didasarkan pada "lapisan" dari apa yang disebut arahan. Untuk gambaran keseluruhan, sila lihat dokumen rasmi mereka.

Tambahkan laluan di bawah pergantungan:

def route = path("hello") { get { complete("Hello, World!") }}

Kami memiliki lapisan pertama, di mana kami berusaha untuk mencocokkan jalur permintaan masuk sebagai "/ halo". Sekiranya tidak sepadan, ia akan ditolak.

Sekiranya sesuai, ia akan sesuai dengan "arahan" dalaman. Dalam kes kami, kami memadankan permintaan GET. Kami menyelesaikan kitaran permintaan / respons dengan mesej "Hello, World".

Mulakan pelayan

Dengan laluan yang dibuat, yang perlu kita lakukan ialah memulakan pelayan:

Http().bindAndHandle(route, host, port)

Kami mengikat laluan kami ke host dan port yang diberikan menggunakan Httpobjek HTTP Akka .

Untuk menjalankan Serverobjek kami , anda boleh mengklik kanannya dan tekan Run 'Server' .

Beri masa beberapa saat untuk disusun, kemudian pergi ke penyemak imbas. Navigasi ke //localhost:9000/hellodan anda akan melihat "Hello, World!" mesej.

Hebat, bukan?

Pembalakan

Sebelum menyelesaikan tutorial ini, kami akan menambahkan pembalakan asas ke pelayan kami.

Anda mungkin menyedari bahawa tidak ada maklum balas ketika kami menjalankan Serverobjek kami . Kami tidak tahu sama ada berjaya atau gagal.

Kami hanya boleh menganggap ia berfungsi kerana aplikasi tidak rosak.

Mari tambah beberapa log masuk ke dalamnya.

If you look into the bindAndHandle function from the Http object, it returns a future of ServerBinding . We can hook some logs into the future’s onComplete function.

Let’s do that:

val bindingFuture = Http().bindAndHandle(route, host, port)bindingFuture.onComplete { case Success(serverBinding) => println(s"listening to ${serverBinding.localAddress}") case Failure(error) => println(s"error: ${error.getMessage}")}

Run the Server again, and this time you should see:

listening to /0:0:0:0:0:0:0:0:9000

Wrapping up

While using Scala and Akka HTTP is not the fastest way to develop APIs, it allows you to integrate other Akka modules, such as actors, streams, clusters, and more, making it easier to develop resilient and scalable systems.

Having said that, it’s good to keep in mind that developing an application using Scala and/or Akka doesn’t necessarily mean that it will be resilient and scalable. You’ll still need to perform work to accomplish that, but it’s easier than with other technologies.

If you liked Akka HTTP, we’ve got a free course that’ll quickstart your way into developing APIs with it. You’ll build an API for a Todo application, explained step by step. Check it out! ??

Akka HTTP Quickstart

Learn how to create web applications and APIs with Akka HTTP in this free course!link.codemunity.io