topic Re: Desirialization of JPA process variables via REST in Alfresco Archive

Desirialization of JPA process variables via REST

kaihuener — Mon, 01 Jul 2013 11:43:07 GMT

Hey – I am trying to deserialize a JPA process variable via the new REST API (amazing work, by the way). I am using Hibernate for JPA and Jersey for deserialization.import com.sun.jersey.api.client.Client;import com.sun.jersey.api.client.ClientResponse;import com.sun.jersey.api.client.WebResource;im

Re: Desirialization of JPA process variables via REST

augustus — Tue, 02 Jul 2013 18:58:22 GMT

There are few things that I needed to do to make it work.
First use this artifact:
<code>
               <dependency>
   <groupId>com.sun.jersey</groupId>
   <artifactId>jersey-bundle</artifactId>
   <version>1.8</version><!– 1.17.1 –>
</dependency>
</code>

Second, I'm using jackson lib for this (it worked better for me)
<code>
<dependency>
   <groupId>org.codehaus.jackson</groupId>
   <artifactId>jackson-core-asl</artifactId>
   <version>1.9.4</version> //or newer
</dependency>
</code>

Your BusinessPartner must have @XmlRootElement annotation but I'm not sure if you can send this object to activiti as a variable (unless you did something I dont know about ).

Re: Desirialization of JPA process variables via REST

kaihuener — Tue, 02 Jul 2013 20:27:06 GMT

Hey mojsilo,
First of all: Thank you for your comment – it is great to get some community support.
In the meantime, I tried various things to better understand what actually is provided by the REST API (including several media types, self-written message body writer), without success.
Finally I realized – and of course it is also written in the User Guide – that the variables are just serialized, not in JSON or XML or something, just "raw" serialization.
So, finally, both the following solutions work in my case (by the way, both without any annotation in the serialized bean, maybe I am wrong, but "@XmlRootElement" or something is not required, except for dedicated XML serialization):

<java>
import java.io.InputStream;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.lang.SerializationUtils;

HttpClient client = new HttpClient();
GetMethod get = new GetMethod(uri);
client.executeMethod(get);
InputStream stream = get.getResponseBodyAsStream();
BusinessPartner bp = (BusinessPartner)SerializationUtils.deserialize(stream);
</java>

<java>
import java.io.InputStream;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.api.client.filter.HTTPBasicAuthFilter;

Client client = Client.create();
WebResource r = client .resource(uri);
InputStream response= r.get(InputStream.class);
BusinessPartner bp = (BusinessPartner)SerializationUtils.deserialize(response);
</java>

But I am not sure, if this is the intended way for process variable deserialization, because I would expect this solution to be heavily implementation dependent (i.e. how java serializes objects). So maybe the Activiti team can clarify the intended way? I also wonder why variables (except binary ones) are not provided as json, because coming from the REST API implementation, I would have expected a json response.

Thank you guys,
best,
Kai

Re: Desirialization of JPA process variables via REST

augustus — Wed, 03 Jul 2013 10:46:56 GMT

What do you mean by "not provided as json" ?

Re: Desirialization of JPA process variables via REST

frederikherema1 — Wed, 03 Jul 2013 10:49:06 GMT

See the user guide, to use custom representation of certain objects:

It's possible to support additional variable-types with a custom JSON representation (either simple value or complex/nested JSON object). By extending the initializeVariableConverters() method on org.activiti.rest.api.RestResponseFactory, you can add additional org.activiti.rest.api.engine.variable.RestVariableConverter classes to support converting your POJO's to a format suitable for transerring through REST and converting the REST-value back to your POJO. The actual transformation to JSON is done by Jackson.

So if you add a org.activiti.rest.api.engine.variable.RestVariableConverter for the JPA-type, that returns a Jackson-serializable POJO (which by default, are all of them). Alternatively, you can return a map<String, Object> of key-values where key is the resulting JSON-key and value the -no shit- value If you want to have sub-json-objects, use another Map as value.

Or stick with the default "serializable" that is being used now, off course…

I was planning on writing a blog on this subject, so any feedback on my "theory" is appreciated

Re: Desirialization of JPA process variables via REST

gregdavisfromnj — Fri, 24 Oct 2014 13:10:45 GMT

Using the custom RestVariableConverter approach works pretty well for simple types. And, being able to send a serializable object directly to Jackson when serializing (a one-liner in the convertVariableValue implementation) is fantastic.

However, I have some pretty deeply nested datatypes I would like deserialize from JSON sent to the REST service. Deserializing by iterating over all the Maps of Maps of Maps in getVariableValue just feels wrong and is resulting in a lot of converter code. Jackson is probably already able to deserialize without the helper converter code, if it only know about the object type corresponding to the JSON stream.

Is there a way to instruct the Jackson mapper in the REST service to DE-serialize a JsonNode into a specific type (which could be provided with all sorts of Jackson helper annotations)? Is there a place in the REST webapp code where I can look to see how to shim that in?

There seems to be something called a CustomVariableType, but it sounds like that is for storing variables in a custom manner into the database, and after the REST service deserialization I just want to use the default database process variable serialization.

Thanks,
gd

Re: Desirialization of JPA process variables via REST

jbarrez — Mon, 27 Oct 2014 11:08:44 GMT

VariableType is for the engine only, not for REST.

Your remark makes a lot of sense. I was wondering (haven't tried it), but couldn't you simply write the jackson code in a custom implementation of the RestVariableConverter already now? Eg by calling the readValue() method from Jackson?