Introdução

Neste tutorial, vamos explorar como utilizar o Akka e o Play Framework em aplicações Scala para construir sistemas reativos e responsivos. Sistemas reativos são projetados para responder a eventos em tempo real, sendo importantes em um contexto onde a escalabilidade e a resiliência são cruciais. Aprenderemos como configurar um projeto Scala que implementa a arquitetura reativa, utilizando o Akka para gerenciar a concorrência e o Play Framework para criar APIs Web eficientes. Este guia destina-se a desenvolvedores familiarizados com Scala que desejam aprofundar seus conhecimentos em desenvolvimento de sistemas reativos e responsivos.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter o JDK (Java Development Kit) e o SBT (Scala Build Tool) instalados em sua máquina. Verifique as versões instaladas usando os comandos `java -version` e `sbt about`. Caso não os tenha instalados, siga as instruções oficiais nos sites das respectivas ferramentas.

    commands
    # Verificar versões instaladas
    java -version
    sbt about

  2. Criação do Projeto Scala com SBT

    Use o SBT para criar um novo projeto Scala. Crie uma pasta para o seu projeto e dentro dessa pasta, inicialize um novo projeto SBT usando o comando: `sbt new scala/scala-seed.g8`. Escolha o nome do projeto e as opções desejadas.

    commands
    # Criar novo projeto SBT
    mkdir meu-projeto-reactivo
    cd meu-projeto-reactivo
    sbt new scala/scala-seed.g8

  3. Adicionando Dependências do Akka e Play Framework

    Edite o arquivo `build.sbt` para incluir as dependências do Akka e do Play Framework. Adicione as seguintes linhas ao arquivo:

    build.sbt
    name := "meu-projeto-reactivo"
version := "0.1"
scalaVersion := "2.13.6"
libraryDependencies ++= Seq(
  "com.typesafe.akka" %% "akka-actor" % "2.6.14",
  "com.typesafe.akka" %% "akka-stream" % "2.6.14",
  "com.typesafe.play" %% "play" % "2.8.8"
)

  4. Implementação de um Ator Akka

    Crie uma classe que representa um ator. Este ator será responsável por processar mensagens de forma assíncrona. Crie um diretório chamado `src/main/scala/com/example/actors` e adicione o seguinte código:

    GreetingActor.scala
    package com.example.actors

import akka.actor.{Actor, ActorSystem, Props}

class GreetingActor extends Actor {
  def receive: Receive = {
    case "saudar" => sender() ! "Olá, Mundo!"
  }
}

object GreetingActor {
  def props: Props = Props[GreetingActor]
}

  5. Configuração do Play Framework

    Crie um controlador Play que utilize o ator para processar solicitações HTTP. Crie um pacote chamado `controllers` e adicione a seguinte classe:

    GreetingController.scala
    package controllers

import akka.actor.ActorSystem
import akka.pattern.ask
import akka.util.Timeout
import javax.inject.Inject
import play.api.mvc.{AbstractController, ControllerComponents}
import scala.concurrent.ExecutionContext
import scala.concurrent.duration._n
class GreetingController @Inject() (cc: ControllerComponents, actorSystem: ActorSystem)(implicit ec: ExecutionContext) extends AbstractController(cc) {
  private val greetingActor = actorSystem.actorOf(GreetingActor.props)
  implicit val timeout: Timeout = Timeout(5.seconds)

  def greet() = Action.async { request =>
    (greetingActor ? "saudar").mapTo[String].map { greeting =>
      Ok(greeting)
    }
  }
}

  6. Configuração da Rota HTTP

    Edite o arquivo `conf/routes` para definir a rota que mapeia a requisição HTTP ao controlador de saudação:

    routes
    GET     /greet                  controllers.GreetingController.greet()

  7. Executando a Aplicação

    Use o SBT para compilar e executar a aplicação. No terminal, execute os seguintes comandos:

    commands
    # Compilar e executar a aplicação
    sbt run

  8. Testando a Aplicação

    Utilize o Postman ou cURL para testar os endpoints da API. Para fazer uma requisição ao endpoint que retorna a saudação, use o comando:

    curl_example
    curl -X GET http://localhost:9000/greet

  9. Implementação de Testes Unitários

    Crie uma classe de testes que valida a funcionalidade do controlador. Adicione o seguinte código ao pacote de testes:

    GreetingControllerSpec.scala
    import org.scalatestplus.play.
import play.api.test.Helpers._
import play.api.test._

class GreetingControllerSpec extends PlaySpec { 
  "GreetingController" should { 
    "return greeting" in { 
      val controller = new GreetingController(...
      val result = controller.greet().apply(FakeRequest())
      status(result) mustBe OK 
      contentAsString(result) mustBe "Olá, Mundo!" 
    } 
  } 
}

Conclusão

Neste tutorial, você aprendeu a utilizar o Akka e o Play Framework para criar uma aplicação Scala reativa e responsiva. Passamos por todas as etapas, desde a configuração do ambiente de desenvolvimento até a implementação de um ator e um controlador Play que processa requisições HTTP. Além disso, cobrimos como testar a aplicação usando cURL. Com essa base, você pode explorar mais sobre a criação de sistemas reativos utilizando Scala, Akka e o Play Framework.

Hashtags

#Scala #Akka #PlayFramework #SistemasReativos #ProgramacaoReativa