FastjsonManualCodec.java

package com.alibaba.json.test.codec;

import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.List;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.DefaultJSONParser;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.ObjectSerializer;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializeWriter;
import com.alibaba.fastjson.serializer.SerializerFeature;

import data.media.Image;
import data.media.Media;
import data.media.MediaContent;

public class FastjsonManualCodec implements Codec {

    private ParserConfig    config = new ParserConfig();
    private SerializeConfig serializeConfig = new SerializeConfig();

    public FastjsonManualCodec(){
        System.out.println("fastjson-" + JSON.VERSION);    
        
        serializeConfig.put(MediaContent.class, new MediaContentSerializer());
    }

    public String getName() {
        return "fastjson-manual";
    }

    public <T> T decodeObject(String text, Class<T> clazz) {
        DefaultJSONParser parser = new DefaultJSONParser(text, config);
        parser.config(Feature.DisableCircularReferenceDetect, true);
        return parser.parseObject(clazz);
    }

    public <T> Collection<T> decodeArray(String text, Class<T> clazz) throws Exception {
        DefaultJSONParser parser = new DefaultJSONParser(text, config);
        parser.config(Feature.DisableCircularReferenceDetect, true);
        return parser.parseArray(clazz);
    }

    public final Object decodeObject(String text) {
        DefaultJSONParser parser = new DefaultJSONParser(text, config);
        parser.config(Feature.DisableCircularReferenceDetect, true);
        return parser.parse();
    }

    public final Object decode(String text) {
        DefaultJSONParser parser = new DefaultJSONParser(text, config);
        parser.config(Feature.DisableCircularReferenceDetect, true);
        return parser.parse();
    }

    // private JavaBeanSerializer serializer = new JavaBeanSerializer(Long_100_Entity.class);

    public String encode(Object object) throws Exception {
        SerializeWriter out = new SerializeWriter();
        out.config(SerializerFeature.DisableCircularReferenceDetect, true);

        JSONSerializer serializer = new JSONSerializer(out, serializeConfig);
        serializer.write(object);

        String text = out.toString();

        out.close();

        return text;
    }

    @SuppressWarnings("unchecked")
    public <T> T decodeObject(byte[] input, Class<T> clazz) throws Exception {
        return (T) JSON.parseObject(input, clazz, Feature.DisableCircularReferenceDetect);
    }

    public static class ImageSerializer implements ObjectSerializer {

        @Override
        public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType,
                          int features) throws IOException {
            Image image = (Image) object;
            
            SerializeWriter out = serializer.out;
            
            out.writeFieldValue('{', "height", image.getHeight());
            out.writeFieldValueStringWithDoubleQuote(',', "size", image.getSize().name());
            
            String tile = image.getTitle();
            out.writeFieldValueStringWithDoubleQuoteCheck(',', "title", tile);
            out.writeFieldValueStringWithDoubleQuoteCheck(',', "uri", image.getUri());
            out.writeFieldValue(',', "width", image.getWidth());

            out.write('}');
            // TODO
        }
        
    }

    public static class MediaSerializer implements ObjectSerializer {

        @Override
        public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType,
                          int features) throws IOException {
            Media image = (Media) object;
            
            SerializeWriter out = serializer.out;
            out.writeFieldValue('{', "bitrate", image.getBitrate());
            out.writeFieldValue(',', "duration", image.getDuration());
            out.writeFieldValue(',', "height", image.getHeight());
            
            String format = image.getFormat();
            out.writeFieldValueStringWithDoubleQuoteCheck(',', "format", format);
            
            out.writeFieldValue(',', "size", image.getSize());
            out.writeFieldValue(',', "height", image.getHeight());
            
            List<String> persons = image.getPersons();
            out.writeFieldName("persons");
            out.write(persons);
            out.writeFieldValueStringWithDoubleQuote(',', "player", image.getPlayer().name());
            out.writeFieldValue(',', "size", image.getSize());
            
            String title = image.getTitle();
            out.writeFieldValue(',', "title", title);
            
            String uri = image.getUri();
            out.writeFieldValueStringWithDoubleQuoteCheck(',', "uri", uri);
            
            out.writeFieldValue(',', "width", image.getWidth());
            
            out.write('}');
        }
        
    }
    
    public static class MediaContentSerializer implements ObjectSerializer {
        MediaSerializer mediaSer = new MediaSerializer();
        ImageSerializer imageSer = new ImageSerializer();

        @Override
        public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType,
                          int features) throws IOException {
            MediaContent mediaContent = (MediaContent) object;
            
            SerializeWriter out = serializer.out;
            
            out.write('{');
            
            out.writeFieldName("image", false);
            List<Image> images = mediaContent.images;
            
            out.write('[');
            for (int i = 0, size = images.size(); i < size; ++i) {
                if (i != 0) {
                    out.write(',');
                }
                Image image = images.get(i);
                imageSer.write(serializer, image, Integer.valueOf(i), Image.class, features);
            }
            out.write(']');
            out.write(',');
            
            out.writeFieldName("media", false);
            mediaSer.write(serializer, mediaContent.media, "media", Media.class, features);
            
            out.write('}');
        }
        
    }

    @Override
    public byte[] encodeToBytes(Object object) throws Exception {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void encode(OutputStream out, Object object) throws Exception {
        out.write(encodeToBytes(object));        
    }
}