Decodificando em classes de caso
Mapeie JSON para seus tipos.
Decodificando em classes de caso é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
Decodificadores mapeiam JSON para tipos
Um Decoder[A] sabe ler um valor Json e convertê-lo para um tipo Scala A.
O Circe fornece decodificadores para tipos primitivos e coleções desde o início, além de poder criar automaticamente decodificadores para suas próprias classes de caso.
Uma classe de caso de destino
Suponha que sua API retorne registros de usuários. Modele essa estrutura com uma classe de caso cujos nomes de campos correspondam às chaves JSON.
Essa correspondência permite que o Circe derive um decodificador sem nenhuma ligação manual.
case class User(name: String, age: Int, admin: Boolean)Derivação automática
Importe io.circe.generic.auto._ para que o Circe derive implicitamente um Decoder[User], sob demanda, sempre que um for necessário.
Depois, basta chamar decode[User], sem código adicional desnecessário.
import io.circe.generic.auto._
import io.circe.parser.decode
val json = "{\"name\":\"Ada\",\"age\":36,\"admin\":true}"
val user = decode[User](json)
println(user) // Right(User(Ada,36,true))Derivação semiautomática
Para obter tempos de compilação melhores e controle explícito, use io.circe.generic.semiauto.deriveDecoder.
Você define o decodificador uma vez, geralmente no objeto acompanhante, e reutiliza essa única instância em todos os lugares.
import io.circe.Decoder
import io.circe.generic.semiauto._
object User {
implicit val dec: Decoder[User] = deriveDecoder[User]
}Falhas de decodificação
Se um campo obrigatório estiver ausente ou tiver o tipo incorreto, a decodificação falhará com um DecodingFailure.
A falha contém um histórico das operações do cursor, indicando exatamente qual campo causou o problema.
val bad = decode[User]("{\"name\":\"Ada\"}")
println(bad)
// Left(DecodingFailure at .age: Missing required field)Campos opcionais em classes
Defina um campo como Option[A] quando a chave JSON puder estar ausente ou nula.
O Circe decodifica automaticamente uma chave ausente como None, portanto você não precisa de um decodificador personalizado apenas para lidar com a opcionalidade.
case class Account(id: Long, nickname: Option[String])
val a = decode[Account]("{\"id\":7}")
println(a) // Right(Account(7,None))Valores padrão
Os valores padrão de uma classe de caso podem preencher chaves JSON ausentes, mas somente quando você usa uma derivação configurada que habilite valores padrão.
O módulo circe-generic-extras fornece esse recurso por meio de Configuration.default.withDefaults.
import io.circe.generic.extras._
implicit val cfg: Configuration =
Configuration.default.withDefaults
@ConfiguredJsonCodec
case class Settings(theme: String = "dark")Classes de caso aninhadas
A decodificação é composicional: se o Circe consegue decodificar o tipo de cada campo, ele consegue decodificar uma classe que aninha outras classes de caso.
A derivação é aplicada recursivamente de forma automática, portanto uma única importação trata estruturas profundamente aninhadas.
case class Address(city: String)
case class Person(name: String, address: Address)
val p = decode[Person](
"{\"name\":\"Ada\",\"address\":{\"city\":\"London\"}}")
println(p)Renomeando campos
Quando as chaves JSON diferem dos nomes Scala (por exemplo, snake_case), use a derivação configurada com Configuration.default.withSnakeCaseMemberNames.
Isso mapeia created_at para um campo Scala createdAt sem um decodificador escrito manualmente.
import io.circe.generic.extras._
implicit val cfg: Configuration =
Configuration.default.withSnakeCaseMemberNames
@ConfiguredJsonCodec
case class Event(createdAt: String)Acumulando erros
Por padrão, a decodificação falha rapidamente no primeiro erro. Já decodeAccumulating reúne todas as falhas em um ValidatedNel.
Isso é útil para validar formulários quando você quer informar todos os problemas de uma só vez.
import io.circe.Decoder
val result = Decoder[User]
.decodeAccumulating(json.hcursor)
// Validated[NonEmptyList[DecodingFailure], User]Escolhendo um estilo de derivação
Use auto para protótipos rápidos e semiauto para código de produção em que você queira instâncias fixas e compilações mais rápidas.
Use generic-extras quando precisar de renomeação, valores padrão ou discriminadores.
Verificação rápida
Teste sua compreensão da decodificação para classes de caso.
Recapitulação
Um Decoder[A] transforma JSON em valores tipados. Use generic.auto ou semiauto.deriveDecoder para classes de caso cujos nomes correspondam às chaves.
Chaves ausentes fazem com que campos Option sejam decodificados como None; generic-extras adiciona valores padrão e renomeação; decodeAccumulating reúne todos os erros.
Perguntas Frequentes
A aula “Decodificando em classes de caso” é grátis?
Sim — o texto completo de “Decodificando em classes de caso” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
O que vou aprender em “Decodificando em classes de caso”?
Mapeie JSON para seus tipos. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?
Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Decodificando em classes de caso”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?
Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Analisando JSON
- Decodificando em classes de caso
- Codificando para JSON
- Codecs personalizados