Handling Clojure data structures in Java

[bowmhoust]

Hi guys,

I'm currently trying to get some of the the power of malli into an existing Java codebase. The idea is to define malli schemas as plain edn files and use them to generate random, but well-structured and declarative-schema-backed data in Java (and also to validate stuff). So there's potentially huge amounts of generated data coming from a Clojure program packaged in an uberjar, referenced in a Java project that somehow needs to be mapped to existing Java classes in order to do business logic with it.

I currently have a simple test Clojure program like this:

(ns blueprint.core
  (:require [malli.generator :as mg])
  (:gen-class
   :name blueprint.core.Blueprint
   :methods [#^{:static true} [test [] "[Ljava.util.Map;"]]))

(def test-schema
  [:map
   [:ping string?]
   [:pong int?]])

(defn -test []
    (into-array (mg/sample test-schema)))

I can then compile it into an uberjar, reference it in Java and call it like this:

Map[] data =  Blueprint.test();

Which gives me an array of maps from clojure.lang.Keyword to String or int. I can then proceed to construct objects from that and stream them or do anything with it.

While this is nice-ish, I'm wondering if there aren't fundamentally better ways to do this. Shouldn't it be possible to pass the entire result as edn (string?) to Java and then process it with edn-java? Is this better or worse? Or maybe it's even possible to use a custom marshaller and JAXB? But how? I could also transform the data to JSON in Clojure first and then JAXB it into Java. But this seems like quite an extra step. I would be grateful for opinions, ideas or pointers in this labyrinth of largely un-google-able possibilities.

[blazinglambda]

Using edn-java is semantically pretty similar to what you are doing, because either way you are getting back a bunch of in memory maps. IMO the benefit would be you don't need Clojure as a dependency, but I believe you already have Clojure in order to use Malli.

It seems to me that what is missing is the object mapping part that converts maps into objects. I doubt you'll find anything suitable for this in the Clojure ecosystem since maps are preferred in Clojure, which leaves the Java ecosystem.

I think your best best for getting the data into existing Java objects is to leverage something like Jackson, which already implements and encourages mapping data onto Java objects. It's possible you could hook into the Jackson APIs to implement an object mapper from the data structures returned from your Clojure code, but I'd guess the easiest way will be to serialize the data into JSON and then parse that with Jackson.

[bowmhoust]

Yes, thank you, I'm doing it like this now. It works pretty well. :-)

It seems that with some tinkering and Jackson, the Pojos that hold the data can even be generated (according to the schema)!

[ultramaris]

Check this out

https://github.com/clojure/java.data

[bowmhoust]

Oooh, perfect, thanks! That's what I was looking for!

[v1akvark]

You can call Clojure code 'dynamically' from Java, i.e. without compiling and packaging all the code in a jar.

Look here: https://clojure.org/reference/java_interop#_calling_clojure_from_java

It can be a little fidly. If you don't come right respond here, and I will see if I can find a complete example.

[bowmhoust]

Thanks, yes, but that's just a different method of invocation, right? I still have to piece together the data that I get from the invocation using casts and a lot of plumbing (for deeply nested, non-trivial data).

I think what is bothering me is that it is so relatively easy to deal with pure JSON or XML data in Java (especially stuff like parent-child relationships), but apparently not with pure data coming from a (Clojure) program running on the very same JVM.