com.ikanow.infinit.e.data_model.store.BaseDbPojo.java Source code

Java tutorial

Introduction

Here is the source code for com.ikanow.infinit.e.data_model.store.BaseDbPojo.java

Source

/*******************************************************************************
 * Copyright 2012 The Infinit.e Open Source Project
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/
package com.ikanow.infinit.e.data_model.store;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.SimpleTimeZone;

import org.bson.types.ObjectId;

import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import com.google.gson.reflect.TypeToken;
import com.ikanow.infinit.e.data_model.utils.ThreadSafeSimpleDateFormat;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;

public class BaseDbPojo {
    // Every Pojo should "override" this static function (stick the actual class in the 2x <>s) for readability
    static public <S> TypeToken<List<S>> listType() {
        return new TypeToken<List<S>>() {
        };
    }

    // Override this function to perform custom serialization (see BasePojoApiMap)
    public GsonBuilder extendBuilder(GsonBuilder gp) {
        return extendBuilder_internal(gp);
    }

    // Allows API owner to enforce some custom serializations
    final public static GsonBuilder getDefaultBuilder() {
        return new GsonBuilder().registerTypeAdapter(ObjectId.class, new ObjectIdDeserializer())
                .registerTypeAdapter(Date.class, new DateDeserializer())
                .registerTypeAdapter(Long.class, new LongDeserializer())
                .registerTypeAdapter(Integer.class, new IntegerDeserializer())
                .registerTypeAdapter(ObjectId.class, new ObjectIdSerializer())
                .registerTypeAdapter(Date.class, new DateSerializer());
    }

    private static GsonBuilder extendBuilder_internal(GsonBuilder gp) {
        return gp;
    }
    //________________________________________________________________________________________________

    // Won't normally override these (but can)
    // DB format conversion

    // For BaseDbPojos
    // 2 versions, 1 where you need dynamic mapping (eg runtime-specific)
    // (in both cases for single objects, you can use the nicer class<X> or 
    //  the nastier Google TypeToken, the latter has 2 advantages:
    //  a. consisntency with list types, where you have to use the TypeToken
    //  b. the class<X> doesn't work where X is generic)
    //
    // Note - the code is a bit unpleasant in places....

    /////////////////////////////////////////////////////////////////////////////////////
    // To the API JSON From a single Object
    public static <S extends BaseDbPojo> DBObject toDb(S s) {
        return toDb(s, null);
    }

    // (Nicer version of the static "toApi")   
    public DBObject toDb() {
        return toDb(this);
    }

    public static <S extends BaseDbPojo> DBObject toDb(S s, BasePojoDbMap<S> dynamicMap) {
        GsonBuilder gb = s.extendBuilder(BaseDbPojo.getDefaultBuilder());
        if (null != dynamicMap) {
            gb = dynamicMap.extendBuilder(gb);
        }
        return (DBObject) MongoDbUtil.encode(gb.create().toJsonTree(s).getAsJsonObject());
    }

    /////////////////////////////////////////////////////////////////////////////////////
    // From the API JSON To a single Object
    public static <S extends BaseDbPojo> S fromDb(DBObject s, Class<S> type) {
        return fromDb(s, type, null);
    }

    public static <S extends BaseDbPojo> S fromDb(DBObject s, TypeToken<S> type) {
        return fromDb(s, type, null);
    }

    public static <S extends BaseDbPojo> S fromDb(DBObject s, Class<S> type, BasePojoDbMap<S> dynamicMap) {
        if (null == s)
            return null;

        // Create a new instance of the class in order to override it
        GsonBuilder gb = null;
        try {
            gb = type.newInstance().extendBuilder(BaseDbPojo.getDefaultBuilder());
        } catch (Exception e) {
            return null;
        }
        if (null != dynamicMap) {
            gb = dynamicMap.extendBuilder(gb);
        }
        return gb.create().fromJson(MongoDbUtil.encode(s), type);
    }

    @SuppressWarnings("unchecked")
    public static <S extends BaseDbPojo> S fromDb(DBObject s, TypeToken<S> type, BasePojoDbMap<S> dynamicMap) {
        if (null == s)
            return null;

        GsonBuilder gb = null;
        try {
            Class<S> clazz = (Class<S>) type.getType();
            gb = ((S) clazz.newInstance()).extendBuilder(BaseDbPojo.getDefaultBuilder());
        } catch (Exception e) {
            return null;
        }
        if (null != dynamicMap) {
            gb = dynamicMap.extendBuilder(gb);
        }
        return (S) gb.create().fromJson(MongoDbUtil.encode(s), type.getType());
    }

    /////////////////////////////////////////////////////////////////////////////////////
    // To the API JSON From a list of objects
    public static <S extends BaseDbPojo> DBObject listToDb(Collection<S> list,
            TypeToken<? extends Collection<S>> listType) {
        return listToDb(list, listType, null);
    }

    public static <S extends BaseDbPojo> DBObject listToDb(Collection<S> list,
            TypeToken<? extends Collection<S>> listType, BasePojoDbMap<S> dynamicMap) {
        GsonBuilder gb = null;
        try {
            if (!list.isEmpty()) {
                gb = list.iterator().next().extendBuilder(BaseDbPojo.getDefaultBuilder());
            }
        } catch (Exception e) {
            return null;
        }
        return (DBObject) MongoDbUtil
                .encodeArray(gb.create().toJsonTree(list, listType.getType()).getAsJsonArray());
    }

    /////////////////////////////////////////////////////////////////////////////////////
    // From the API JSON to a list of objects
    public static <S extends BaseDbPojo, L extends Collection<S>> L listFromDb(DBCursor bson,
            TypeToken<? extends L> listType) {
        return listFromDb(bson, listType, null);
    }

    @SuppressWarnings("unchecked")
    public static <S extends BaseDbPojo, L extends Collection<S>> L listFromDb(DBCursor bson,
            TypeToken<? extends L> listType, BasePojoDbMap<S> dynamicMap) {
        GsonBuilder gb = null;
        try {
            Class<S> clazz = (Class<S>) ((ParameterizedType) listType.getType()).getActualTypeArguments()[0];
            // (know this works because of construction of listType)
            gb = (clazz.newInstance()).extendBuilder(BaseDbPojo.getDefaultBuilder());
        } catch (Exception e) {
            return null;
        }
        if (null != dynamicMap) {
            gb = dynamicMap.extendBuilder(gb);
        }
        return (L) gb.create().fromJson(MongoDbUtil.encode(bson), listType.getType());
    }

    //___________________________________________________________________

    // Default MongoDB serialization/deserialization rules:

    // 1. Object Ids
    protected static class ObjectIdSerializer implements JsonSerializer<ObjectId> {
        @Override
        public JsonElement serialize(ObjectId id, Type typeOfT, JsonSerializationContext context) {
            JsonObject jo = new JsonObject();
            jo.addProperty("$oid", id.toStringMongod());
            return jo;
        }
    }

    protected static class ObjectIdDeserializer implements JsonDeserializer<ObjectId> {
        @Override
        public ObjectId deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
                throws JsonParseException {
            if (json.isJsonPrimitive()) {
                return new ObjectId(json.getAsString());
            } else {
                try {
                    return new ObjectId(json.getAsJsonObject().get("$oid").getAsString());
                } catch (Exception e) {
                    return null;
                }
            }
        }
    }

    // Dates:
    protected static class DateDeserializer implements JsonDeserializer<Date> {
        private static ThreadSafeSimpleDateFormat _format = new ThreadSafeSimpleDateFormat(
                "yyyy-MM-dd'T'HH:mm:ss'Z'");
        private static ThreadSafeSimpleDateFormat _format2 = new ThreadSafeSimpleDateFormat(
                "MMM d, yyyy hh:mm:ss a");

        @Override
        public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
                throws JsonParseException {
            Date d = null;
            if (json.isJsonPrimitive()) {
                try {
                    d = _format2.parse(json.getAsString());
                } catch (Exception e) {
                    try {
                        d = _format.parse(json.getAsString());
                    } catch (Exception e2) {
                        d = null;
                    }
                }
            } else {
                try {
                    d = _format.parse(json.getAsJsonObject().get("$date").getAsString());
                } catch (Exception e) {
                    d = null;
                }
            }
            return d;
        }
    }

    protected static class DateSerializer implements JsonSerializer<Date> {
        private static ThreadSafeSimpleDateFormat _format = null;

        @Override
        public JsonElement serialize(Date date, Type typeOfT, JsonSerializationContext context) {
            Date d = (Date) date;
            if (null == _format) {
                _format = new ThreadSafeSimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
                _format.setCalendar(new GregorianCalendar(new SimpleTimeZone(0, "UTC")));
            }
            JsonObject jo = new JsonObject();
            jo.addProperty("$date", _format.format(d));
            return jo;
        }
    }

    // OK MongoDB is very keen on turning Long/Integer into doubles (eg from the console) - these converts them back 
    protected static class LongDeserializer implements JsonDeserializer<Long> {
        @Override
        public Long deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
                throws JsonParseException {
            try {
                return json.getAsLong();
            } catch (Exception e) {
                return (long) json.getAsNumber().doubleValue();
            }
        }
    }

    protected static class IntegerDeserializer implements JsonDeserializer<Integer> {
        @Override
        public Integer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
                throws JsonParseException {
            try {
                return json.getAsInt();
            } catch (Exception e) {
                return (int) json.getAsNumber().doubleValue();
            }
        }
    }
}