aswi2020horky-gitlab/demo_jh/Deserializer_tests/src/app/App.java @ f783f25c

package app;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.ObjectWriter;
import org.unsynchronized.jdeserialize;

public class App {

    /**
     * When the Serialized and deserialized classes are same, but placed in diff packages, the
     * deserialization does not work. When they are
     **/
    public static void main(String[] args) throws Exception {
        App app = new App();

        app.standartSerializationDeserialization();
        String res = app.objectToJSON(new samples.ok.Simple());
        System.out.println(res);
        
        //test with calling the name of original jd project
        //app.jdCallMain();

        // test directly through code call
        //app.jdCallLib("serialized/simple.out", true, "deserializedResults/simple.json");
        //System.out.println("Vše OK, díky.");
    }

    /**
     * Calls the jdeserialize through library approach.
     * 
     * SHOULD NOT BE HERE
     * **/
    private void jdCallLib(String filename, boolean dump, String outputFileJSON)
    {
        try
        {
            //FileInputStream as usual
            FileInputStream fis = null;
            fis = new FileInputStream(filename);
            
            //creating an instance of jdeserialize with given filename
            jdeserialize jd = new jdeserialize(filename);
            //running the main process of deserialization
            jd.run(fis, false);
            
            //gets the "contents" into an array - returnes the deserialization of all
            // 'writes' into serialized object via objectOutputStream
            List cntnts = jd.getContent();
            String classname = cntnts.get(0).getClass().getName();
            
            //testing with only first of the contents
            String json = objectToJSON(cntnts.get(0));

            if(dump) 
            {
                System.out.println(json);
            }
            if(outputFileJSON != null && !outputFileJSON.isEmpty())
            {
                File toWrite = new File(outputFileJSON);
                toWrite.createNewFile();

                FileOutputStream fos = new FileOutputStream(toWrite, false);
                ObjectOutputStream oos = new ObjectOutputStream(fos);

                oos.writeObject(json);
                oos.flush();
                oos.close();
                System.out.println("Soubor " + outputFileJSON + " s deserializovaným objektem vytvořen.");
            }

        }
        catch (IOException e) 
        {

        }
    }

    /**
     * Parses any object into String in JSON format
     * 
     * SHOULD NOT BE HERE
     * **/
    private String objectToJSON(Object in)
    {
        ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
        String json = "";
        try 
        {
            json = ow.writeValueAsString(in);
        } 
        catch (IOException e) 
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return json;
    }

    /**
     * Basically, does the dump of deserialized object
     * Just to check if everything works well
     * and well, it does
     * 
     * SHOULD NOT BE HERE
     * NOT NEEDED
     * **/
    private void jdCallMain(String filename)
    {
        String[] myArgs= new String[1];
        myArgs[0] = filename;
        jdeserialize.main(myArgs); //testing call without any options. Outputs the deserialized data into console.
    }

    /**
     * Serializes and deserializes when the object remains untouched.
     * The package names used in this example shows the result (nearly clear)
     * 
     * SHOULD NOT BE HERE
     * NOT NEEDED
     * **/
    private void standartSerializationDeserialization() {
        try {
            System.out.println("Starting...");

            this.serialize(new samples.ok.Simple(), "serialized/simple.out");

            //samples.ok.SimpleChild test1 = this.deserialize("serialized/simple.out");

        } catch (Exception e) {
            System.out.println(e.toString());
            System.out.println(e.getMessage());
        }
    }

    /**
     * Standard way of deserializing objects with java.
     * 
     * Taken from example method, doc
     * 
     * SHOULD NOT BE HERE
     * NOT NEEDED
     **/
    private <T> T deserialize(String inputFilePath) {
        try {
            FileInputStream fis = new FileInputStream(inputFilePath);
            ObjectInputStream ois = new ObjectInputStream(fis);
            T deserialized = (T) ois.readObject();
            System.out.println(deserialized.toString());
            ois.close();

            return deserialized;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Standard way of serializing objects with java.
     * 
     * Taken from example method, doc
     * 
     * SHOULD NOT BE HERE
     **/
    private void serialize(Object obj, String outputPath) {
        try {
            File toWrite = new File(outputPath);
            toWrite.createNewFile();

            FileOutputStream fos = new FileOutputStream(toWrite, false);
            ObjectOutputStream oos = new ObjectOutputStream(fos);

            oos.writeObject(obj);
            oos.flush();
            oos.close();
            System.out.println("serialized.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}