Util GsonFactory - Gson that works on ItemStack/PotionEffect/Location objects

Introduction

For anyone that doesn't know what gson is, it is Google's open source Java library to serialize and deserialize Java objects to and from JSON. JSON is arguably much better than YAML and gson makes things pretty sweet to work with.

Now for anyone who has used gson, they know that not all things can be serialized without custom TypeAdapters that help gson serialize and deserialize objects that it is unable to automatically do.

Unfortunately for us, gson is unable to serialize/deserialize objects like ItemStack, PortionEffect, along with Location. Fortunately for you however, I've created a class that will require no work from what you would normally do but it supports those objects.

GsonFactory

Normally when you use gson, you simply do "new Gson().to/fromJson(...)". With this utility you will use the gson instances that are created in the class rather than making your own instance. These instances are lazily initialized so you can throw this util in any project and it won't use up much of anything when it is not used.

The util contains two main instances of Gson that you will use. The two differences are the pretty vs compact gson instances. The difference between pretty and compact when printing to console or saving is the following:

Pretty vs Compact
getPrettyGson: (Prints in several easy to read lines with indentation)

Code:json

 
{
  "TIME_ZONE_ID": "EST",
  "TIME_FORMAT": "MMMMM d, yyyy",
  "SQL_USER": "root",
  "SQL_PASS": "exmpass",
  "SQL_PORT": "3306",
  "SQL_HOST": "localhost",
  "SQL_DATABASE": "example"
}
 

getCompactGson (Prints in one line)

Code:json

 
{"TIME_ZONE_ID": "EST","TIME_FORMAT": "MMMMM d, yyyy","SQL_USER": "root","SQL_PASS": "exmpass","SQL_PORT": "3306","SQL_HOST": "localhost","SQL_DATABASE": "example"}
 

Serialization and Deserialization
To serialize using GsonFactory you simply call:

Code:java

 
GsonFactory.getPrettyGson().toJson(yourObjectHere);
// or
GsonFactory.getCompactGson().toJson(yourObjectHere);
 

And to deserialize it is:

Code:java

 
YourObjectClass yourObjectHere = GsonFactory.getCompactGson().fromJson(/*the json string*/, YourObjectClass)
 

(for deserialization it doesn't matter if you use pretty or compact)

Exclusion Strategy
If you want a field in your class to be ignored, there is an exclusion strategy included in GsonFactory and it is annotation based. Inside of the class you want a field ignored, simply add @GsonIgnore before the field and GsonFactory will not serialize/deserialize that field.

Example:
The player object will not get serialized by GsonFactory, but the ItemStack array will.

Code:java

 
@GsonIgnore
private final Player player;
private ItemStack[] arrayOfItems;
 

Util Code

To use GsonFactory simply copy and paste it to your project and call GsonFactory.getPretty/CompactGson() from anywhere!

Note: GsonFactory disables html escaping, in most cases this is to your benefit as it will make strings more readable for your end users, if you remove this option then your json will be safe in html, but things like the '&' and section characters turn into the ugly unicode codes that look like '\u0026".

Gist for code

Code:java

 
//TODO add your package name here
 
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.TypeAdapter;
import com.google.gson.annotations.Expose;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import net.minecraft.server.v1_8_R3.MojangsonParseException;
import net.minecraft.server.v1_8_R3.MojangsonParser;
import net.minecraft.server.v1_8_R3.NBTBase;
import net.minecraft.server.v1_8_R3.NBTTagCompound;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import org.bukkit.configuration.serialization.ConfigurationSerialization;
import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftItemStack;
import org.bukkit.craftbukkit.v1_8_R3.util.CraftMagicNumbers;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
 
/* *
* Created by Joshua Bell (RingOfStorms)
*
* Post explaining here: [URL]http://bukkit.org/threads/gsonfactory-gson-that-works-on-itemstack-potioneffect-location-objects.331161/[/URL]
* */
public class GsonFactory {
 
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.FIELD})
    public static @interface Ignore {}
 
    /*
    - I want to not use Bukkit parsing for most objects... it's kind of clunky
    - Instead... I want to start using any of Mojang's tags
    - They're really well documented + built into MC, and handled by them.
    - Rather than kill your old code, I'm going to write TypeAdapaters using Mojang's stuff.
     */
 
    private static Gson g = new Gson();
 
    private final static String CLASS_KEY = "SERIAL-ADAPTER-CLASS-KEY";
 
    private static Gson prettyGson;
    private static Gson compactGson;
 
    /**
     * Returns a Gson instance for use anywhere with new line pretty printing
     * <p>
     *    Use @GsonIgnore in order to skip serialization and deserialization
     * </p>
     * @return a Gson instance
     */
    public static Gson getPrettyGson () {
        if (prettyGson == null)
            prettyGson = new GsonBuilder().addSerializationExclusionStrategy(new ExposeExlusion())
                    .addDeserializationExclusionStrategy(new ExposeExlusion())
                    .registerTypeHierarchyAdapter(ItemStack.class, new ItemStackGsonAdapter())
                    .registerTypeAdapter(PotionEffect.class, new PotionEffectGsonAdapter())
                    .registerTypeAdapter(Location.class, new LocationGsonAdapter())
                    .registerTypeAdapter(Date.class, new DateGsonAdapter())
                    .setPrettyPrinting()
                    .disableHtmlEscaping()
                    .create();
        return prettyGson;
    }
 
    /**
     * Returns a Gson instance for use anywhere with one line strings
     * <p>
     *    Use @GsonIgnore in order to skip serialization and deserialization
     * </p>
     * @return a Gson instance
     */
    public static Gson getCompactGson () {
        if(compactGson == null)
            compactGson = new GsonBuilder().addSerializationExclusionStrategy(new ExposeExlusion())
                    .addDeserializationExclusionStrategy(new ExposeExlusion())
                    .registerTypeHierarchyAdapter(ItemStack.class, new ItemStackGsonAdapter())
                    .registerTypeAdapter(PotionEffect.class, new PotionEffectGsonAdapter())
                    .registerTypeAdapter(Location.class, new LocationGsonAdapter())
                    .registerTypeAdapter(Date.class, new DateGsonAdapter())
                    .disableHtmlEscaping()
                    .create();
        return compactGson;
    }
 
    /**
     * Creates a new instance of Gson for use anywhere
     * <p>
     *    Use @GsonIgnore in order to skip serialization and deserialization
     * </p>
     * @return a Gson instance
     */
    public static Gson getNewGson(boolean prettyPrinting) {
        GsonBuilder builder = new GsonBuilder().addSerializationExclusionStrategy(new ExposeExlusion())
                .addDeserializationExclusionStrategy(new ExposeExlusion())
                .registerTypeHierarchyAdapter(ItemStack.class, new NewItemStackAdapter())
                .disableHtmlEscaping();
        if (prettyPrinting)
            builder.setPrettyPrinting();
        return builder.create();
    }
 
    private static Map<String, Object> recursiveSerialization (ConfigurationSerializable o) {
        Map<String, Object> originalMap = o.serialize();
        Map<String, Object> map = new HashMap<String, Object>();
        for(Entry<String, Object> entry : originalMap.entrySet()) {
            Object o2 = entry.getValue();
            if(o2 instanceof ConfigurationSerializable) {
                ConfigurationSerializable serializable = (ConfigurationSerializable) o2;
                Map<String, Object> newMap = recursiveSerialization(serializable);
                newMap.put(CLASS_KEY, ConfigurationSerialization.getAlias(serializable.getClass()));
                map.put(entry.getKey(), newMap);
            }
        }
        map.put(CLASS_KEY, ConfigurationSerialization.getAlias(o.getClass()));
        return map;
    }
 
    private static Map<String, Object> recursiveDoubleToInteger (Map<String, Object> originalMap) {
        Map<String, Object> map = new HashMap<String, Object>();
        for(Entry<String, Object> entry : originalMap.entrySet()) {
            Object o = entry.getValue();
            if(o instanceof Double) {
                Double d = (Double) o;
                Integer i = d.intValue();
                map.put(entry.getKey(), i);
            }else if(o instanceof Map) {
                Map<String, Object> subMap = (Map<String, Object>) o;
                map.put(entry.getKey(), recursiveDoubleToInteger(subMap));
            }else{
                map.put(entry.getKey(), o);
            }
        }
        return map;
    }
 
    private static class ExposeExlusion implements ExclusionStrategy {
        @Override
        public boolean shouldSkipField(FieldAttributes fieldAttributes) {
            final Ignore ignore = fieldAttributes.getAnnotation(Ignore.class);
            if(ignore != null)
                return true;
            final Expose expose = fieldAttributes.getAnnotation(Expose.class);
            return expose != null && (!expose.serialize() || !expose.deserialize());
        }
 
        @Override
        public boolean shouldSkipClass(Class<?> aClass) {
            return false;
        }
    }
 
    private static String nbtToString(NBTBase base) {
        return base.toString().replace(",}", "}").replace(",]", "]").replaceAll("[0-9]+\\:", "");
    }
 
    private static net.minecraft.server.v1_8_R3.ItemStack removeSlot(ItemStack item) {
        if (item == null)
            return null;
        net.minecraft.server.v1_8_R3.ItemStack nmsi = CraftItemStack.asNMSCopy(item);
        if (nmsi == null)
            return null;
        NBTTagCompound nbtt = nmsi.getTag();
        if (nbtt != null) {
            nbtt.remove("Slot");
            nmsi.setTag(nbtt);
        }
        return nmsi;
    }
 
    private static ItemStack removeSlotNBT (ItemStack item) {
        if (item == null)
            return null;
        net.minecraft.server.v1_8_R3.ItemStack nmsi = CraftItemStack.asNMSCopy(item);
        if (nmsi == null)
            return null;
        NBTTagCompound nbtt = nmsi.getTag();
        if(nbtt != null) {
            nbtt.remove("Slot");
            nmsi.setTag(nbtt);
        }
        return CraftItemStack.asBukkitCopy(nmsi);
    }
 
    private static class NewItemStackAdapter extends TypeAdapter<ItemStack> {
        @Override
        public void write(JsonWriter jsonWriter, ItemStack itemStack) throws IOException {
            if (itemStack == null) {
                jsonWriter.nullValue();
                return;
            }
            net.minecraft.server.v1_8_R3.ItemStack item = removeSlot(itemStack);
            if (item == null) {
                jsonWriter.nullValue();
                return;
            }
            try {
                jsonWriter.beginObject();
                jsonWriter.name("type");
 
                jsonWriter.value(itemStack.getType().toString()); //I hate using this - but
                jsonWriter.name("amount");
 
                jsonWriter.value(itemStack.getAmount());
                jsonWriter.name("data");
 
 
                jsonWriter.value(itemStack.getDurability());
                jsonWriter.name("tag");
 
                if (item != null && item.getTag() != null) {
                    jsonWriter.value(nbtToString(item.getTag()));
                } else
                    jsonWriter.value("");
                jsonWriter.endObject();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
 
        @Override
        public ItemStack read(JsonReader jsonReader) throws IOException {
            if (jsonReader.peek() == JsonToken.NULL) {
                return null;
            }
            jsonReader.beginObject();
            jsonReader.nextName();
            Material type = Material.getMaterial(jsonReader.nextString());
            jsonReader.nextName();
            int amount = jsonReader.nextInt();
            jsonReader.nextName();
            int data = jsonReader.nextInt();
            net.minecraft.server.v1_8_R3.ItemStack item = new net.minecraft.server.v1_8_R3.ItemStack(CraftMagicNumbers.getItem(type), amount, data);
            jsonReader.nextName();
            String next = jsonReader.nextString();
            if (next.startsWith("{")) {
                NBTTagCompound compound = null;
                try {
                    compound = MojangsonParser.parse(ChatColor.translateAlternateColorCodes('&', next));
                } catch (MojangsonParseException e) {
                    e.printStackTrace();
                }
                item.setTag(compound);
            }
            jsonReader.endObject();
            return CraftItemStack.asBukkitCopy(item);
        }
    }
 
    private static class ItemStackGsonAdapter extends TypeAdapter<ItemStack> {
 
        private static Type seriType = new TypeToken<Map<String, Object>>(){}.getType();
 
        @Override
        public void write(JsonWriter jsonWriter, ItemStack itemStack) throws IOException {
            if(itemStack == null) {
                jsonWriter.nullValue();
                return;
            }
            jsonWriter.value(getRaw(removeSlotNBT(itemStack)));
        }
 
        @Override
        public ItemStack read(JsonReader jsonReader) throws IOException {
            if(jsonReader.peek() == JsonToken.NULL) {
                jsonReader.nextNull();
                return null;
            }
            return fromRaw(jsonReader.nextString());
        }
 
        private String getRaw (ItemStack item) {
            Map<String, Object> serial = item.serialize();
 
            if(serial.get("meta") != null) {
                ItemMeta itemMeta = item.getItemMeta();
 
                Map<String, Object> originalMeta = itemMeta.serialize();
                Map<String, Object> meta = new HashMap<String, Object>();
                for(Entry<String, Object> entry : originalMeta.entrySet())
                    meta.put(entry.getKey(), entry.getValue());
                Object o;
                for(Entry<String, Object> entry : meta.entrySet()) {
                    o = entry.getValue();
                    if(o instanceof ConfigurationSerializable) {
                        ConfigurationSerializable serializable = (ConfigurationSerializable) o;
                        Map<String, Object> serialized = recursiveSerialization(serializable);
                        meta.put(entry.getKey(), serialized);
                    }
                }
                serial.put("meta", meta);
            }
 
            return g.toJson(serial);
        }
 
        private ItemStack fromRaw (String raw) {
            Map<String, Object> keys = g.fromJson(raw, seriType);
 
            if(keys.get("amount") != null) {
                Double d = (Double) keys.get("amount");
                Integer i = d.intValue();
                keys.put("amount", i);
            }
 
            ItemStack item;
            try {
                item = ItemStack.deserialize(keys);
            }catch(Exception e) {
                return null;
            }
 
            if(item == null)
                return null;
 
            if(keys.containsKey("meta")) {
                Map<String, Object> itemmeta = (Map<String, Object>) keys.get("meta");
                itemmeta = recursiveDoubleToInteger(itemmeta);
                ItemMeta meta = (ItemMeta) ConfigurationSerialization.deserializeObject(itemmeta, ConfigurationSerialization.getClassByAlias("ItemMeta"));
                item.setItemMeta(meta);
            }
 
            return item;
        }
    }
 
    private static class PotionEffectGsonAdapter extends TypeAdapter<PotionEffect> {
 
        private static Type seriType = new TypeToken<Map<String, Object>>(){}.getType();
 
        private static String TYPE = "effect";
        private static String DURATION = "duration";
        private static String AMPLIFIER = "amplifier";
        private static String AMBIENT = "ambient";
 
        @Override
        public void write(JsonWriter jsonWriter, PotionEffect potionEffect) throws IOException {
            if(potionEffect == null) {
                jsonWriter.nullValue();
                return;
            }
            jsonWriter.value(getRaw(potionEffect));
        }
 
        @Override
        public PotionEffect read(JsonReader jsonReader) throws IOException {
            if(jsonReader.peek() == JsonToken.NULL) {
                jsonReader.nextNull();
                return null;
            }
            return fromRaw(jsonReader.nextString());
        }
 
        private String getRaw (PotionEffect potion) {
            Map<String, Object> serial = potion.serialize();
 
            return g.toJson(serial);
        }
 
        private PotionEffect fromRaw (String raw) {
            Map<String, Object> keys = g.fromJson(raw, seriType);
            return new PotionEffect(PotionEffectType.getById(((Double) keys.get(TYPE)).intValue()), ((Double) keys.get(DURATION)).intValue(), ((Double) keys.get(AMPLIFIER)).intValue(),  (Boolean) keys.get(AMBIENT));
        }
    }
 
    private static class LocationGsonAdapter extends TypeAdapter<Location> {
 
        private static Type seriType = new TypeToken<Map<String, Object>>(){}.getType();
 
        private static String UUID = "uuid";
        private static String X = "x";
        private static String Y = "y";
        private static String Z = "z";
        private static String YAW = "yaw";
        private static String PITCH = "pitch";
 
        @Override
        public void write(JsonWriter jsonWriter, Location location) throws IOException {
            if(location == null) {
                jsonWriter.nullValue();
                return;
            }
            jsonWriter.value(getRaw(location));
        }
 
        @Override
        public Location read(JsonReader jsonReader) throws IOException {
            if(jsonReader.peek() == JsonToken.NULL) {
                jsonReader.nextNull();
                return null;
            }
            return fromRaw(jsonReader.nextString());
        }
 
        private String getRaw (Location location) {
            Map<String, Object> serial = new HashMap<String, Object>();
            serial.put(UUID, location.getWorld().getUID().toString());
            serial.put(X, Double.toString(location.getX()));
            serial.put(Y, Double.toString(location.getY()));
            serial.put(Z, Double.toString(location.getZ()));
            serial.put(YAW, Float.toString(location.getYaw()));
            serial.put(PITCH, Float.toString(location.getPitch()));
            return g.toJson(serial);
        }
 
        private Location fromRaw (String raw) {
            Map<String, Object> keys = g.fromJson(raw, seriType);
            World w = Bukkit.getWorld(java.util.UUID.fromString((String) keys.get(UUID)));
            return new Location(w, Double.parseDouble((String) keys.get(X)), Double.parseDouble((String) keys.get(Y)), Double.parseDouble((String) keys.get(Z)),
                    Float.parseFloat((String) keys.get(YAW)), Float.parseFloat((String) keys.get(PITCH)));
        }
    }
 
    private static class DateGsonAdapter extends TypeAdapter<Date> {
        @Override
        public void write(JsonWriter jsonWriter, Date date) throws IOException {
            if(date == null) {
                jsonWriter.nullValue();
                return;
            }
            jsonWriter.value(date.getTime());
        }
 
        @Override
        public Date read(JsonReader jsonReader) throws IOException {
            if(jsonReader.peek() == JsonToken.NULL) {
                jsonReader.nextNull();
                return null;
            }
            return new Date(jsonReader.nextLong());
        }
    }
}
 
 

 

This is pretty neat! Comes out very handy for my own API

 

Updated code to fix a reference to a class called ItemStackUtil that obviously isn't there

 

@RingOfStorms Update for 1.8_r3?
Has an issue with some of the imports and when reimporting them there is still one error.

 

Bump.

Would also like to see this updated to v1_8_R3

 

Updated the code to R3, let me know if it is missing anything.

@BillyGalbreath
@callum2904

 

I'm in the process of using json.simple and Gson to make a full Database API for bukkit instead of constantly loading slow YAML files.

 

ok... and what does that have to do with this resource ?

 

Same API, same idea.

 

I'm having a problem creating json from player's inventory.

Code:

GsonFactory.getCompactJson().toJson(player.getInventory().getContents());

Code:

Caused by: java.lang.IllegalArgumentException: class net.minecraft.server.v1_8_R3.EntityItemFrame declares multiple JSON fields named c

 

@BillyGalbreath After a few hours of frustrating wtf's at GSON I realized that the registering of the TypeAdapter is concrete to the top level, in this case it was ItemStack.class, so GSON was not using the Adapter for CraftItemStack, which is what is should of been doing. So alternatively we can switch it to a hierarchy which will apply the adapter to work on extending classes.

I updated the code above with that one line change, at this point my current GsonFactory is very different from the one I have here, and I do realize there is bloat and weird comments on this version but I don't have time to clean it up.

But you can just change the registerTypeAdapter for the itemstack class to registerTypeHierarchyAdapter in the current one you are using

 

@RingOfStorms Absolutely amazing resource, but what is this licensed under?