Example usage for java.io ObjectOutputStream writeObject

Introduction

In this page you can find the example usage for java.io ObjectOutputStream writeObject.

Prototype

public final void writeObject(Object obj) throws IOException 

Source Link

Document

Write the specified object to the ObjectOutputStream.

Usage

From source file:gov.nasa.ensemble.common.CommonUtils.java

/**
 * Copy an object via Externalizable. Copying a set of interconnected objects this way will maintain all the connections. This method will also properly copy and connect loops.
 * //from  w w  w .ja  v a  2  s .com
 * @param object
 * @return not supplied
 */
public static <T extends Externalizable> T copy(T object) {
    ClassLoaderObjectInputStream objectInputStream = null;
    try {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(object);
        byte[] byteArray = byteArrayOutputStream.toByteArray();
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArray);
        objectInputStream = new ClassLoaderObjectInputStream(object.getClass().getClassLoader(),
                byteArrayInputStream);
        // ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        @SuppressWarnings("unchecked")
        T copy = (T) objectInputStream.readObject();
        return copy;
    } catch (IOException e) {
        Logger.getLogger(CommonUtils.class).error("copy failed", e);
    } catch (ClassNotFoundException e) {
        Logger.getLogger(CommonUtils.class).error("copy failed", e);
    } finally {
        if (objectInputStream != null) {
            try {
                objectInputStream.close();
            } catch (IOException e) {
                LogUtil.error(e);
            }
        }
    }
    return null;
}

---

From source file:Main.java

/**
 * Serialises an <code>AttributedString</code> object.
 *
 * @param as  the attributed string object (<code>null</code> permitted).
 * @param stream  the output stream (<code>null</code> not permitted).
 *
 * @throws IOException if there is an I/O error.
 *//*from  www  . ja va 2 s. co  m*/
public static void writeAttributedString(AttributedString as, ObjectOutputStream stream) throws IOException {

    if (stream == null) {
        throw new IllegalArgumentException("Null 'stream' argument.");
    }
    if (as != null) {
        stream.writeBoolean(false);
        AttributedCharacterIterator aci = as.getIterator();
        // build a plain string from aci
        // then write the string
        StringBuffer plainStr = new StringBuffer();
        char current = aci.first();
        while (current != CharacterIterator.DONE) {
            plainStr = plainStr.append(current);
            current = aci.next();
        }
        stream.writeObject(plainStr.toString());

        // then write the attributes and limits for each run
        current = aci.first();
        int begin = aci.getBeginIndex();
        while (current != CharacterIterator.DONE) {
            // write the current character - when the reader sees that this
            // is not CharacterIterator.DONE, it will know to read the
            // run limits and attributes
            stream.writeChar(current);

            // now write the limit, adjusted as if beginIndex is zero
            int limit = aci.getRunLimit();
            stream.writeInt(limit - begin);

            // now write the attribute set
            Map atts = new HashMap(aci.getAttributes());
            stream.writeObject(atts);
            current = aci.setIndex(limit);
        }
        // write a character that signals to the reader that all runs
        // are done...
        stream.writeChar(CharacterIterator.DONE);
    } else {
        // write a flag that indicates a null
        stream.writeBoolean(true);
    }

}

---

From source file:com.linkedin.sample.test.java

public static void main1(String[] args) {

    /*/*from  ww  w . j  av  a2  s  .  c  o m*/
    we need a OAuthService to handle authentication and the subsequent calls.
    Since we are going to use the REST APIs we need to generate a request token as the first step in the call.
    Once we get an access toke we can continue to use that until the API key changes or auth is revoked.
    Therefore, to make this sample easier to re-use we serialize the AuthHandler (which stores the access token) to
    disk and then reuse it.
            
    When you first run this code please insure that you fill in the API_KEY and API_SECRET above with your own
    credentials and if there is a service.dat file in the code please delete it.
            
     */

    //The Access Token is used in all Data calls to the APIs - it basically says our application has been given access
    //to the approved information in LinkedIn
    Token accessToken = null;

    //Using the Scribe library we enter the information needed to begin the chain of Oauth2 calls.
    OAuthService service = new ServiceBuilder().provider(LinkedInApi.class).apiKey(API_KEY)
            .apiSecret(API_SECRET).build();

    /*************************************
     * This first piece of code handles all the pieces needed to be granted access to make a data call
     */

    try {
        File file = new File("service.dat");

        if (file.exists()) {
            //if the file exists we assume it has the AuthHandler in it - which in turn contains the Access Token
            ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(file));
            AuthHandler authHandler = (AuthHandler) inputStream.readObject();
            accessToken = authHandler.getAccessToken();
        } else {
            System.out.println("There is no stored Access token we need to make one");
            //In the constructor the AuthHandler goes through the chain of calls to create an Access Token
            AuthHandler authHandler = new AuthHandler(service);
            ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("service.dat"));
            outputStream.writeObject(authHandler);
            outputStream.close();
            accessToken = authHandler.getAccessToken();
        }

    } catch (Exception e) {
        System.out.println("Threw an exception when serializing: " + e.getClass() + " :: " + e.getMessage());
    }

    /*
     * We are all done getting access - time to get busy getting data
     *************************************/

    /**************************
     *
     * Querying the LinkedIn API
     *
     **************************/

    System.out.println();
    System.out.println("********A basic user profile call********");
    //The ~ means yourself - so this should return the basic default information for your profile in XML format
    //https://developer.linkedin.com/documents/profile-api
    String url = "http://api.linkedin.com/v1/people/~";
    OAuthRequest request = new OAuthRequest(Verb.GET, url);
    service.signRequest(accessToken, request);
    Response response = request.send();
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    System.out.println("********Get the profile in JSON********");
    //This basic call profile in JSON format
    //You can read more about JSON here http://json.org
    url = "http://api.linkedin.com/v1/people/~";
    request = new OAuthRequest(Verb.GET, url);
    request.addHeader("x-li-format", "json");
    service.signRequest(accessToken, request);
    response = request.send();
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    System.out.println("********Get the profile in JSON using query parameter********");
    //This basic call profile in JSON format. Please note the call above is the preferred method.
    //You can read more about JSON here http://json.org
    url = "http://api.linkedin.com/v1/people/~";
    request = new OAuthRequest(Verb.GET, url);
    request.addQuerystringParameter("format", "json");
    service.signRequest(accessToken, request);
    response = request.send();
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    System.out.println("********Get my connections - going into a resource********");
    //This basic call gets all your connections each one will be in a person tag with some profile information
    //https://developer.linkedin.com/documents/connections-api
    url = "http://api.linkedin.com/v1/people/~/connections";
    request = new OAuthRequest(Verb.GET, url);
    service.signRequest(accessToken, request);
    response = request.send();
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    System.out.println("********Get only 10 connections - using parameters********");
    //This basic call gets only 10 connections  - each one will be in a person tag with some profile information
    //https://developer.linkedin.com/documents/connections-api
    //more basic about query strings in a URL here http://en.wikipedia.org/wiki/Query_string
    url = "http://api.linkedin.com/v1/people/~/connections";
    request = new OAuthRequest(Verb.GET, url);
    request.addQuerystringParameter("count", "10");
    service.signRequest(accessToken, request);
    response = request.send();
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    System.out.println("********GET network updates that are CONN and SHAR********");
    //This basic call get connection updates from your connections
    //https://developer.linkedin.com/documents/get-network-updates-and-statistics-api
    //specifics on updates  https://developer.linkedin.com/documents/network-update-types

    url = "http://api.linkedin.com/v1/people/~/network/updates";
    request = new OAuthRequest(Verb.GET, url);
    request.addQuerystringParameter("type", "SHAR");
    request.addQuerystringParameter("type", "CONN");
    service.signRequest(accessToken, request);
    response = request.send();
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    System.out.println("********People Search using facets and Encoding input parameters i.e. UTF8********");
    //This basic call get connection updates from your connections
    //https://developer.linkedin.com/documents/people-search-api#Facets
    //Why doesn't this look like
    //people-search?title=developer&location=fr&industry=4

    //url = "http://api.linkedin.com/v1/people-search?title=D%C3%A9veloppeur&facets=location,industry&facet=location,fr,0";
    url = "http://api.linkedin.com/v1/people-search:(people:(first-name,last-name,headline),facets:(code,buckets))";
    request = new OAuthRequest(Verb.GET, url);
    request.addQuerystringParameter("title", "Dveloppeur");
    request.addQuerystringParameter("facet", "industry,4");
    request.addQuerystringParameter("facets", "location,industry");
    System.out.println(request.getUrl());
    service.signRequest(accessToken, request);
    response = request.send();
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    /////////////////field selectors
    System.out.println("********A basic user profile call with field selectors********");
    //The ~ means yourself - so this should return the basic default information for your profile in XML format
    //https://developer.linkedin.com/documents/field-selectors
    url = "http://api.linkedin.com/v1/people/~:(first-name,last-name,positions)";
    request = new OAuthRequest(Verb.GET, url);
    service.signRequest(accessToken, request);
    response = request.send();
    System.out.println(response.getHeaders().toString());
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    System.out
            .println("********A basic user profile call with field selectors going into a subresource********");
    //The ~ means yourself - so this should return the basic default information for your profile in XML format
    //https://developer.linkedin.com/documents/field-selectors
    url = "http://api.linkedin.com/v1/people/~:(first-name,last-name,positions:(company:(name)))";
    request = new OAuthRequest(Verb.GET, url);
    service.signRequest(accessToken, request);
    response = request.send();
    System.out.println(response.getHeaders().toString());
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    System.out.println("********A basic user profile call into a subresource return data in JSON********");
    //The ~ means yourself - so this should return the basic default information for your profile
    //https://developer.linkedin.com/documents/field-selectors
    url = "https://api.linkedin.com/v1/people/~/connections:(first-name,last-name,headline)?format=json";
    request = new OAuthRequest(Verb.GET, url);
    service.signRequest(accessToken, request);
    response = request.send();
    System.out.println(response.getHeaders().toString());
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    System.out.println("********A more complicated example using postings into groups********");
    //https://developer.linkedin.com/documents/field-selectors
    //https://developer.linkedin.com/documents/groups-api
    url = "http://api.linkedin.com/v1/groups/3297124/posts:(id,category,creator:(id,first-name,last-name),title,summary,creation-timestamp,site-group-post-url,comments,likes)";
    request = new OAuthRequest(Verb.GET, url);
    service.signRequest(accessToken, request);
    response = request.send();
    System.out.println(response.getHeaders().toString());
    System.out.println(response.getBody());
    System.out.println();
    System.out.println();

    /**************************
     *
     * Wrting to the LinkedIn API
     *
     **************************/

    /*
     * Commented out so we don't write into your LinkedIn/Twitter feed while you are just testing out
     * some code. Uncomment if you'd like to see writes in action.
     * 
     * 
            System.out.println("********Write to the  share - using XML********");
            //This basic shares some basic information on the users activity stream
            //https://developer.linkedin.com/documents/share-api
            url = "http://api.linkedin.com/v1/people/~/shares";
            request = new OAuthRequest(Verb.POST, url);
            request.addHeader("Content-Type", "text/xml");
            //Make an XML document
            Document doc = DocumentHelper.createDocument();
            Element share = doc.addElement("share");
            share.addElement("comment").addText("Guess who is testing the LinkedIn REST APIs");
            Element content = share.addElement("content");
            content.addElement("title").addText("A title for your share");
            content.addElement("submitted-url").addText("http://developer.linkedin.com");
            share.addElement("visibility").addElement("code").addText("anyone");
            request.addPayload(doc.asXML());
            service.signRequest(accessToken, request);
            response = request.send();
            //there is no body just a header
            System.out.println(response.getBody());
            System.out.println(response.getHeaders().toString());
            System.out.println();System.out.println();
            
            
            System.out.println("********Write to the  share and to Twitter - using XML********");
            //This basic shares some basic information on the users activity stream
            //https://developer.linkedin.com/documents/share-api
            url = "http://api.linkedin.com/v1/people/~/shares";
            request = new OAuthRequest(Verb.POST, url);
            request.addQuerystringParameter("twitter-post","true");
            request.addHeader("Content-Type", "text/xml");
            //Make an XML document
            doc = DocumentHelper.createDocument();
            share = doc.addElement("share");
            share.addElement("comment").addText("Guess who is testing the LinkedIn REST APIs and sending to twitter");
            content = share.addElement("content");
            content.addElement("title").addText("A title for your share");
            content.addElement("submitted-url").addText("http://developer.linkedin.com");
            share.addElement("visibility").addElement("code").addText("anyone");
            request.addPayload(doc.asXML());
            service.signRequest(accessToken, request);
            response = request.send();
            //there is no body just a header
            System.out.println(response.getBody());
            System.out.println(response.getHeaders().toString());
            System.out.println();System.out.println();
            
            
            
            
            
            System.out.println("********Write to the  share and to twitter - using JSON ********");
            //This basic shares some basic information on the users activity stream
            //https://developer.linkedin.com/documents/share-api
            //NOTE - a good troubleshooting step is to validate your JSON on jsonlint.org
            url = "http://api.linkedin.com/v1/people/~/shares";
            request = new OAuthRequest(Verb.POST, url);
            //set the headers to the server knows what we are sending
            request.addHeader("Content-Type", "application/json");
            request.addHeader("x-li-format", "json");
            //make the json payload using json-simple
            Map<String, Object> jsonMap = new HashMap<String, Object>();
            jsonMap.put("comment", "Posting from the API using JSON");
            JSONObject contentObject = new JSONObject();
            contentObject.put("title", "This is a another test post");
            contentObject.put("submitted-url","http://www.linkedin.com");
            contentObject.put("submitted-image-url", "http://press.linkedin.com/sites/all/themes/presslinkedin/images/LinkedIn_WebLogo_LowResExample.jpg");
            jsonMap.put("content", contentObject);
            JSONObject visibilityObject = new JSONObject();
            visibilityObject.put("code", "anyone");
            jsonMap.put("visibility", visibilityObject);
            request.addPayload(JSONValue.toJSONString(jsonMap));
            service.signRequest(accessToken, request);
            response = request.send();
            //again no body - just headers
            System.out.println(response.getBody());
            System.out.println(response.getHeaders().toString());
            System.out.println();System.out.println();
    */

    /**************************
     *
     * Understanding the response, creating logging, request and response headers
     *
     **************************/

    System.out.println();
    System.out.println("********A basic user profile call and response dissected********");
    //This sample is mostly to help you debug and understand some of the scaffolding around the request-response cycle
    //https://developer.linkedin.com/documents/debugging-api-calls
    url = "https://api.linkedin.com/v1/people/~";
    request = new OAuthRequest(Verb.GET, url);
    service.signRequest(accessToken, request);
    response = request.send();
    //get all the headers
    System.out.println("Request headers: " + request.getHeaders().toString());
    System.out.println("Response headers: " + response.getHeaders().toString());
    //url requested
    System.out.println("Original location is: " + request.getHeaders().get("content-location"));
    //Date of response
    System.out.println("The datetime of the response is: " + response.getHeader("Date"));
    //the format of the response
    System.out.println("Format is: " + response.getHeader("x-li-format"));
    //Content-type of the response
    System.out.println("Content type is: " + response.getHeader("Content-Type") + "\n\n");

    //get the HTTP response code - such as 200 or 404
    int responseNumber = response.getCode();

    if (responseNumber >= 199 && responseNumber < 300) {
        System.out.println("HOORAY IT WORKED!!");
        System.out.println(response.getBody());
    } else if (responseNumber >= 500 && responseNumber < 600) {
        //you could actually raise an exception here in your own code
        System.out.println("Ruh Roh application error of type 500: " + responseNumber);
        System.out.println(response.getBody());
    } else if (responseNumber == 403) {
        System.out.println("A 403 was returned which usually means you have reached a throttle limit");
    } else if (responseNumber == 401) {
        System.out.println("A 401 was returned which is a Oauth signature error");
        System.out.println(response.getBody());
    } else if (responseNumber == 405) {
        System.out.println(
                "A 405 response was received. Usually this means you used the wrong HTTP method (GET when you should POST, etc).");
    } else {
        System.out.println("We got a different response that we should add to the list: " + responseNumber
                + " and report it in the forums");
        System.out.println(response.getBody());
    }
    System.out.println();
    System.out.println();

    System.out.println("********A basic error logging function********");
    // Now demonstrate how to make a logging function which provides us the info we need to
    // properly help debug issues. Please use the logged block from here when requesting
    // help in the forums.
    url = "https://api.linkedin.com/v1/people/FOOBARBAZ";
    request = new OAuthRequest(Verb.GET, url);
    service.signRequest(accessToken, request);
    response = request.send();

    responseNumber = response.getCode();

    if (responseNumber < 200 || responseNumber >= 300) {
        logDiagnostics(request, response);
    } else {
        System.out.println("You were supposed to submit a bad request");
    }

    System.out.println("******Finished******");

}

---

From source file:net.librec.util.FileUtil.java

public static void serialize(Object obj, String filePath) throws Exception {
    FileOutputStream fos = new FileOutputStream(filePath);
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    oos.writeObject(obj);
    oos.flush();//from w  w  w.j  ava 2  s.  c  om
    oos.close();
    fos.close();
}

---

From source file:com.exalttech.trex.util.Util.java

/**
 * Serialize object to string//from   w ww . j  ava 2s  . c o  m
 *
 * @param objectToSer
 * @return
 * @throws IOException
 */
public static String serializeObjectToString(Serializable objectToSer) throws IOException {
    try {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(objectToSer);
        oos.close();
        return Base64.getEncoder().encodeToString(baos.toByteArray());
    } catch (IOException ex) {
        LOG.error("Error serializing object", ex);
        return "";
    }
}

---

From source file:backtype.storm.utils.Utils.java

public static byte[] javaSerialize(Object obj) {
    if (obj instanceof byte[]) {
        return (byte[]) obj;
    }//from  w  w w.ja v a  2 s  .  c  o m
    try {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        oos.close();
        return bos.toByteArray();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

---

From source file:gov.nih.nci.caarray.util.CaArrayUtils.java

/**
 * Serializes the given object (zipped) to a byte array.
 * // w  w w  . j a v  a 2  s . c o m
 * @param serializable object to serialize
 * @return the serialized object as a byte array.
 */
public static byte[] serialize(Serializable serializable) {
    final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    GZIPOutputStream gZipOutputStream = null;
    ObjectOutputStream objectOutputStream = null;
    try {
        gZipOutputStream = new GZIPOutputStream(byteArrayOutputStream);
        objectOutputStream = new ObjectOutputStream(gZipOutputStream);
        objectOutputStream.writeObject(serializable);
        objectOutputStream.flush();
        gZipOutputStream.finish();
        gZipOutputStream.flush();
        byteArrayOutputStream.flush();
    } catch (final IOException e) {
        throw new IllegalStateException("Couldn't serialize object", e);
    } finally {
        IOUtils.closeQuietly(objectOutputStream);
        IOUtils.closeQuietly(gZipOutputStream);
        IOUtils.closeQuietly(byteArrayOutputStream);
    }
    return byteArrayOutputStream.toByteArray();
}

---

From source file:me.StevenLawson.TotalFreedomMod.TFM_Util.java

public static void setSavedFlag(String flag, boolean value) {
    Map<String, Boolean> flags = TFM_Util.getSavedFlags();

    if (flags == null) {
        flags = new HashMap<String, Boolean>();
    }/*from  w w w  .  jav  a 2  s .c  om*/

    flags.put(flag, value);

    try {
        final FileOutputStream fos = new FileOutputStream(
                new File(TotalFreedomMod.plugin.getDataFolder(), TotalFreedomMod.SAVED_FLAGS_FILENAME));
        final ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(flags);
        oos.close();
        fos.close();
    } catch (Exception ex) {
        TFM_Log.severe(ex);
    }
}

---

From source file:com.heliosapm.tsdblite.json.JSON.java

private static byte[] jserialize(final Serializable ser) {
    if (ser == null)
        return new byte[0];
    ByteArrayOutputStream baos = null;
    ObjectOutputStream oos = null;
    try {//from  ww  w. ja  va  2 s . c o m
        baos = new ByteArrayOutputStream(1024);
        oos = new ObjectOutputStream(baos);
        oos.writeObject(ser);
        oos.flush();
        baos.flush();
        return baos.toByteArray();
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    } finally {
        if (oos != null)
            try {
                oos.close();
            } catch (Exception x) {
                /* No Op */}
        if (baos != null)
            try {
                baos.close();
            } catch (Exception x) {
                /* No Op */}
    }
}

---

From source file:Base64.java

/**
 * Serializes an object and returns the Base64-encoded
 * version of that serialized object. If the object
 * cannot be serialized or there is another error,
 * the method will return <tt>null</tt>.
 *
 * @param serializableObject The object to encode
 * @return The Base64-encoded object/*from ww  w  .  j  a v  a 2 s .  c  o m*/
 * @since 1.4
 */
public static String encodeObject(java.io.Serializable serializableObject) {

    java.io.ByteArrayOutputStream baos = null;
    java.io.OutputStream b64os = null;
    java.io.ObjectOutputStream oos = null;

    try {
        baos = new java.io.ByteArrayOutputStream();
        b64os = new OutputStream(baos, Base64.ENCODE);
        oos = new java.io.ObjectOutputStream(b64os);

        oos.writeObject(serializableObject);
    } // end try
    catch (java.io.IOException e) {

        e.printStackTrace();
        return null;
    } // end catch
    finally {
        try {
            oos.close();
            b64os.close();
            baos.close();
        } catch (Exception e) {
        }
    } // end finally

    return new String(baos.toByteArray());
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »