Serializing Java objects using Golang's gob encoding

July 16, 2016

A while ago while working with Terraform, I started reading up on Go's RPC library, and the encoding format it uses by default, which is gob. Then I found out there was no Java implementation for it. Which is a shame, because there are a few Go programs that might be nice to interface with from the software we're building at work. However, at work we use Java.

So I started working on an implementation, called jgobs. If you can think of a better name, please let me know.. this one isn't very original. Anyway, I'm not even sure this is going to be useful to us, let alone anyone else, but hey, it's a nice exercise.

Last week jgobs was able to serialize a simple (primitive fields only) object to a byte array which was deserialized by Go's gob library. This morning jgobs succesfully serialized an object that contains nested objects, which I think is pretty cool, so time for a small demo!

What we'll do is serialize a simple Person object that has a name and an Address object associated with it. Then we'll deserialize it using Go.

package xyz.vanduuren.jgobs.demo;

public class Address {
    public String streetName;
    public int houseNumber;
    public String city;
package xyz.vanduuren.jgobs.demo;

public class Person {
    public String name;
    public Address address;
package xyz.vanduuren.jgobs.demo;

import xyz.vanduuren.jgobs.lib.Encoder;


public class App
    public static void main(String[] args) throws IOException {
        // Encode to a file
        FileOutputStream fileOutputStream = new FileOutputStream("/tmp/");
        // Create the encoder with the file outputstream
        Encoder encoder = new Encoder(fileOutputStream);

        // Create the person and address objects we want to encode
        Person person = new Person();
        Address address = new Address();

        // Give them some data
        address.streetName = "Kerksteeg"; = "Leiden";
        address.houseNumber = 1; = "Jan Klaassen";
        person.address = address;

        // Encode, and close the stream

Running the above program will result in a Person named Jan Klaassen that will be serialized to /tmp/ We should be able to decode that with a simple Go program. Let's try.

// decode.go
package main

import (

func main() {
    type Address struct {
    StreetName  string
    HouseNumber int8
    City        string

    type Person struct {
    Name    string
    Address Address

    f, err := os.Open("/tmp/")
    if err != nil {
    fmt.Printf("open: %v\n", err)

    dec := gob.NewDecoder(f)
    var person Person
    err = dec.Decode(&person)
    if err != nil {
    fmt.Printf("decode: %v\n", err)

    fmt.Printf("decoded person: %v\n", person)

Let's compile and run it.

$ go build decode.go && ./decode

decoded person: {Jan Klaassen {Kerksteeg 1 Leiden}}

And it worked! There's still a lot more stuff to do for the encoder, and then I need to start work on the decoder. But I thought this was already pretty cool! 😄