Search for a command to run...
Travel | Movies | History | Nature
I am a software developer. Started my career as a Java developer, but later switched to Scala. I wish to write Scala articles which are easier for newbies to follow. I love to travel, prefer to be alone or in very small group. Love to watch movies/series.
No comments yet. Be the first to comment.
Implementing Continuous Data Flows with FS2 Streaming
Building Resumable Data Pipelines with Redis-backed Offset Tracking and Batch Processing
Creating Flexible Data Integration Patterns for Cross-System Data Movement
How to leverage Scala 3 Mirrors to generically parse CSV files into case classes, making data handling more flexible and type-safe.
Introduction Recently, at work, there was a requirement to list out the direct dependencies of the our SBT project, something like Bill Of Materials. SBT itself provides the dependencies as list or tree or searchable HTML page using the built-in comm...
Learn how to use Json4s, a widely-used JSON parsing library in Scala that can work with various existing json libraries including Jackson and Play-Json. Discover how to optimize Json4s with Jackson as the foundation, develop custom serializers for intricate data types, and append fields that do not belong to a case class body.
Json4s is one of the most popular JSON parsing libraries in Scala. Json4s support the usage of multiple existing json libraries, like Jackson, Play-Json etc. In this short article, I want to show how we can implement JSON parsing, with custom serializers. I will be json4s with Jackson as the base.
To use Json4s, we need to add the below statement to build.sbt:
"org.json4s" %% "json4s-jackson" % "3.6.9"
Now, let’s see how we can write the methods for converting from and to json.
import org.json4s.jackson.Serialization._
import org.json4s._
trait JsonParser {
implicit lazy val serializationFormats: Formats = DefaultFormats
def fromJson[T](json: String)(implicit mf: Manifest[T]) = {
read[T](json)
}
def toJson(obj: AnyRef): String = {
write(obj)
}
}
With the above code, now we can convert a case class to JSON String and vice versa. But if the case class has a non-primitive field, say LocalDate then the above code will fail. In such case, we need to provide a custom serializer to the Formats.
implicit lazy val serializationFormats: Formats = new DefaultFormats {} ++ customSerializers
where, customSerializers can be implemented as below:
object CustomSerializers {
private val dateFormatter = DateTimeFormatter.ofPattern("dd-MM-yyyy")
private val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss")
case object LocalDateSerializer extends CustomSerializer[LocalDate](format => ( {
case JString(date) => LocalDate.parse(date, dateFormatter)
case JNull => null
}, {
case date: LocalDate => JString(date.format(dateFormatter))
}))
case object LocalDateTimeSerializer extends CustomSerializer[LocalDateTime](format => ( {
case JString(dt) => LocalDateTime.parse(dt, dateTimeFormatter)
case JNull => null
}, {
case dt: LocalDateTime => JString(dt.format(dateTimeFormatter))
}))
}
This above serializers will allow the serialization/deserialization of java.time.LocalDate and java.time.LocalDateTime fields.
Similarly, custom serializers can be created for case objects as well. For e.g: If there is an Enum implementation using sealed trait, and it is required to be serialized/deserialized to json format, then a CustomSerializer can be added for it, as shown below:
case object PeriodSerializer extends CustomSerializer[Period](format => ( {
case JString(dt) => {
dt match {
case "Day" => Period.Day
case "Week" => Period.Week
case "Month" => Period.Month
}
}
case JNull => null
}, {
case p: Period => JString(p.name)
}))
Now, let’s see how we can bring a field which is NOT part of a Case Class body. For e.g:
trait BaseEntity {
def desc: String
}
case class Item(itemCode: String, qty: Int, purchaseDate: LocalDate) extends BaseEntity {
override val desc: String = itemCode + ":" + qty
}
If the above case class Item is converted into json, the field desc, which is in the body of case class will not be available in the json string. To get such fields, we need to define a FieldSerializer and add to the DefaultFormats.
implicit lazy val serializationFormats: Formats = new DefaultFormats {} ++ customSerializers + FieldSerializer[BaseEntity]()
So, in this article we have seen how to use json4s to parse json strings, and how to write Custom Serializers for complex data types. The complete source code for the demo project is available in GitHub.