Scala JsonCodec类代码示例

//设置package包名称以及导入依赖的类
package xyz.ariwaranosai.leancloud.LeanModel

import io.circe.generic.JsonCodec


@JsonCodec case class LeanUser(
                      username: String, password: String,
                      phone: Option[String] = None, mobilePhoneVerified: Option[Boolean] = None,
                      email: Option[String] = None, emailVerified: Option[Boolean] = None,
                      sessionToken: Option[String] = None, salt: Option[String] = None
                    )


@JsonCodec case class UserCreateResponse(
                         sessionToken: String,
                         createdAt: String,
                         objectId: String
                         ) 

//设置package包名称以及导入依赖的类
package com.example.model

import java.time.LocalDateTime
import java.util.UUID

import io.circe.generic.JsonCodec
import io.circe.java8.time._

@JsonCodec case class User (
   id: UUID = UUID.randomUUID,
   name: String,
   email: String,
   pass: String,
   deleted: Boolean = false,
   created: LocalDateTime = LocalDateTime.now(),
   modified: LocalDateTime = LocalDateTime.now()
 )  extends BaseModel {
  def delete: User = copy(deleted = true)
}

object User {
  def apply(
             name: String,
             email: String,
             pass: String
           ): User = new User(name = name, email = email, pass = pass)
} 

//设置package包名称以及导入依赖的类
package aecor.example

import aecor.example.MonixSupport._
import aecor.example.domain.account.{ AccountAggregate, AccountId }
import akka.http.scaladsl.model.StatusCodes
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.server.Route
import cats.implicits._
import de.heikoseeberger.akkahttpcirce.FailFastCirceSupport._
import io.circe.generic.JsonCodec
import monix.eval.Task
import AnyValCirceEncoding._
import aecor.example.AccountEndpoint.AccountApiRequest.OpenAccountRequest

class AccountEndpoint(account: AccountAggregate[Task]) {

  def openAccount(accountId: AccountId): Task[String Either Unit] =
    account
      .openAccount(accountId)
      .map(_.leftMap(_.toString))
}

object AccountEndpoint {

  sealed abstract class AccountApiRequest
  object AccountApiRequest {
    @JsonCodec final case class OpenAccountRequest(accountId: AccountId) extends AccountApiRequest
  }

  def route(api: AccountEndpoint): Route =
    pathPrefix("account") {
      post {
        (path("open") & entity(as[AccountApiRequest.OpenAccountRequest])) {
          case OpenAccountRequest(accountId) =>
            complete {
              api.openAccount(accountId).map {
                case Left(e) => StatusCodes.BadRequest -> e.toString
                case Right(result) => StatusCodes.OK -> ""
              }
            }
        }
      }
    }
} 

//设置package包名称以及导入依赖的类
package com.msilb.scalandav20.model

import com.msilb.scalandav20.model.pricing.PriceValue
import com.msilb.scalandav20.model.primitives.{AccountUnits, DecimalNumber, InstrumentName}
import com.msilb.scalandav20.model.trades.TradeID
import io.circe.generic.JsonCodec

package object positions {

  @JsonCodec
  case class PositionSide(units: DecimalNumber,
                          averagePrice: Option[PriceValue],
                          tradeIDs: Option[Seq[TradeID]],
                          pl: AccountUnits,
                          unrealizedPL: Option[AccountUnits],
                          resettablePL: AccountUnits)

  @JsonCodec
  case class Position(instrument: InstrumentName,
                      pl: AccountUnits,
                      unrealizedPL: Option[AccountUnits],
                      resettablePL: AccountUnits,
                      long: PositionSide,
                      short: PositionSide)

  @JsonCodec
  case class CalculatedPositionState(instrument: InstrumentName,
                                     netUnrealizedPL: AccountUnits,
                                     longUnrealizedPL: AccountUnits,
                                     shortUnrealizedPL: AccountUnits)

} 

//设置package包名称以及导入依赖的类
package com.msilb.scalandav20.client

import com.msilb.scalandav20.model.orders.OrderRequest
import com.msilb.scalandav20.model.trades.ClientExtensions
import com.msilb.scalandav20.model.transactions.{StopLossDetails, TakeProfitDetails, TrailingStopLossDetails}
import io.circe.generic.JsonCodec

sealed trait Request

object Request {

  @JsonCodec
  case class AccountConfigChangeRequest(alias: Option[String] = None,
                                        marginRate: Option[String] = None) extends Request

  @JsonCodec
  case class CreateOrderRequest(order: OrderRequest) extends Request

  @JsonCodec
  case class ReplaceOrderRequest(order: OrderRequest) extends Request

  @JsonCodec
  case class OrderClientExtensionsModifyRequest(clientExtensions: Option[ClientExtensions] = None,
                                                tradeClientExtensions: Option[ClientExtensions] = None) extends Request

  @JsonCodec
  case class CloseTradeRequest(units: String = "ALL") extends Request

  @JsonCodec
  case class TradeClientExtensionsModifyRequest(clientExtensions: ClientExtensions) extends Request

  @JsonCodec
  case class TradesDependentOrdersModifyRequest(takeProfit: Option[TakeProfitDetails] = None,
                                                stopLoss: Option[StopLossDetails] = None,
                                                trailingStopLoss: Option[TrailingStopLossDetails] = None) extends Request

  @JsonCodec
  case class ClosePositionRequest(longUnits: Option[String] = None,
                                  longClientExtensions: Option[ClientExtensions] = None,
                                  shortUnits: Option[String] = None,
                                  shortClientExtensions: Option[ClientExtensions] = None) extends Request

} 

//设置package包名称以及导入依赖的类
// Copyright 2016 flat authors

package flat.examples.json

import flat._
import io.circe.generic.JsonCodec
import io.circe.syntax._

object Json extends App with FlatApp {
  @JsonCodec case class Point(x: Double, y: Double)
  app.get("/point") { request =>
    val point = Point(0, 0)
    Ok(point.asJson)
  }

  @JsonCodec case class Circle(label: String, radius: Double, point: Point)
  app.get("/circle") { request =>
    val circle = Circle("unit", 1, Point(0, 0))
    Ok(circle.asJson)
  }

  @JsonCodec case class Polygon(points: List[Point])
  app.get("/square") { request =>
    val square = Polygon(List(
      Point(1, 1),
      Point(1, -1),
      Point(-1, -1),
      Point(-1, 1)
    ))
    Ok(square.asJson)
  }

  app.start
} 

//设置package包名称以及导入依赖的类
package maml.ast.metadata

import maml.ast.codec._
import maml.ast.utility._

import io.circe.generic.JsonCodec


@JsonCodec
case class NodeMetadata(
  label: Option[String] = None,
  description: Option[String] = None,
  histogram: Option[Histogram] = None,
  colorRamp: Option[Vector[Int]] = None,
  classMap: Option[ClassMap] = None,
  breaks: Option[Vector[Double]] = None
) {

  
  def fallbackTo(that: NodeMetadata): NodeMetadata = {
    NodeMetadata(
      this.label.orElse(that.label),
      this.description.orElse(that.description),
      this.histogram.orElse(that.histogram),
      this.colorRamp.orElse(that.colorRamp),
      this.classMap.orElse(that.classMap)
    )
  }
} 

//设置package包名称以及导入依赖的类
package sample.algebra

import endpoints.documented.algebra.{BasicAuthentication, Endpoints, CirceEntities, OptionalResponses}
import io.circe.generic.JsonCodec

trait DocumentedApi
  extends Endpoints
    with OptionalResponses
    with BasicAuthentication
    with CirceEntities {

  val items =
    endpoint(
      get(path / "items" / segment[String]("category") /? optQs[Int]("page")),
      jsonResponse[List[Item]]("List all the items of the given category")
    )

  val itemId = segment[String]("id")

  val item =
    endpoint(
      get(path / "item" / itemId),
      option(jsonResponse[Item]("The item identified by 'id'"), "Item not found")
    )

  val admin =
    authenticatedEndpoint(
      Get,
      path / "admin",
      emptyRequest,
      emptyResponse("Administration page"),
      "Authentication error"
    )

}

@JsonCodec
case class Item(name: String)