title: How to send JSONobject over TCP?
body: <p>i am trying to unterstand how to send my custom Object &quot;Paper&quot; which is serialized with JSON over TCP.</p>
  <p>The Client:</p>
  <pre><code>import org.json.JSONObject;
  
  import java.io.*;
  import java.net.ConnectException;
  import java.net.NoRouteToHostException;
  import java.net.Socket;
  import java.net.UnknownHostException;
  import java.util.Scanner;
  
  import model.*;
  import view.*;
  
  /**
  
   */
  public class JSONClient {
  
      private String host;
      private int port;
      private Socket socket;
      private final String DEFAULT_HOST = &quot;localhost&quot;;
  
  
      public void connect(String host, int port) throws IOException {
          this.host = host;
          this.port = port;
          socket = new Socket(host, port);
          System.out.println(&quot;Client has been connected..&quot;);
      }
  
  
      /**
       * use the JSON Protocol to receive a json object as
       *  from the client and reconstructs that object
       *
       * @return JSONObejct with the same state (data) as
       * the JSONObject the client sent as a String msg.
       * @throws IOException
       */
      public JSONObject receiveJSON() throws IOException {
          InputStream in = socket.getInputStream();
          ObjectInputStream i = new ObjectInputStream(in);
          JSONObject line = null;
          try {
              line = (JSONObject) i.readObject();
              
          } catch (ClassNotFoundException e) {
              // TODO Auto-generated catch block
               e.printStackTrace();
          
          }
          
          
          return line;
  
      }
  
  
      public void sendJSON(JSONObject jsonObject) throws IOException {
             JSONObject jsonObject2 = new JSONObject();
          jsonObject2.put(&quot;key&quot;, new Paper(250,333));
          
           
           OutputStream out = socket.getOutputStream();
          ObjectOutputStream o = new ObjectOutputStream(out);
           o.writeObject(jsonObject2);
          out.flush();
          System.out.println(&quot;Sent to server: &quot; + &quot; &quot; + jsonObject2.get(&quot;key&quot;).toString());
      }
  
  
      public static void main(String[] args) {
          JSONClient client = new JSONClient();
          try{
  
              client.connect(&quot;localhost&quot;, 7777);
              // For JSON call sendJSON(JSON json) &amp; receiveJSON();
              JSONObject jsonObject2 = new JSONObject();
              jsonObject2.put(&quot;key&quot;, new Paper(250,333));
  
              client.sendJSON(jsonObject2);
              client.receiveJSON();
          }
  
          catch (ConnectException e) {
              System.err.println(client.host + &quot; connect refused&quot;);
              return;
          }
  
          catch(UnknownHostException e){
              System.err.println(client.host + &quot; Unknown host&quot;);
              client.host = client.DEFAULT_HOST;
              return;
          }
  
          catch (NoRouteToHostException e) {
              System.err.println(client.host + &quot; Unreachable&quot;);
              return;
  
          }
  
          catch (IllegalArgumentException e){
              System.err.println(client.host + &quot; wrong port&quot;);
              return;
          }
  
          catch(IOException e){
              System.err.println(client.host + ' ' + e.getMessage());
              System.err.println(e);
          }
          finally {
              try {
                  client.socket.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
  
      }
  }
  </code></pre>
  <p>The Server :</p>
  <pre><code>import model.*;
  
  import org.json.JSONObject;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.net.ServerSocket;
  import java.net.Socket;
  
  /**
   */
  public class JSONServer {
  
  
      private ServerSocket serverSocket;
      private int port;
      public static int clients = 0;
  
  
      public void establish(int port) throws IOException {
          this.port = port;
          serverSocket = new ServerSocket(port);
          System.out.println(&quot;JSONServer has been established on port &quot; + port);
  
      }
  
  
      public void accept() throws IOException {
          while (true) {
              Socket socket = serverSocket.accept();
              Runnable r = new MyThreadHandler(socket);
              Thread t = new Thread(r);
              t.start();
          }
      }
  
      private static class MyThreadHandler implements Runnable {
          private Socket socket;
  
          MyThreadHandler(Socket socket) {
              this.socket = socket;
          }
  
          @Override
          public void run() {
              clients++;
              System.out.println(clients + &quot; JSONClient(s) connected on port: &quot; + socket.getPort());
  
              try {
                  // For JSON Protocol
                  JSONObject jsonObject = receiveJSON();
                  sendJSON(jsonObject);
  
              } catch (IOException e) {
  
              } finally {
                  try {
                      closeSocket();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
  
          public void closeSocket() throws IOException {
              socket.close();
          }
  
  
          /**
           * use the JSON Protocol to receive a json object as
           * String from the client and reconstructs that object
           * @return JSONObejct with the same state (data) as
           * the JSONObject the client sent as a String msg.
           * @throws IOException
           */
          public JSONObject receiveJSON() throws IOException {
              InputStream in = socket.getInputStream();
              ObjectInputStream i = new ObjectInputStream(in);
              JSONObject line = null;
              try {
                  line = (JSONObject) i.readObject();
                  
              } catch (ClassNotFoundException e) {
                  // TODO Auto-generated catch block
                   e.printStackTrace();
              
              }
              
              JSONObject jsonObject = new JSONObject(line);
              System.out.println(&quot;Got from client on port &quot; + socket.getPort() + &quot; &quot; + jsonObject.get(&quot;key&quot;).toString());
              return jsonObject;
          }
  
  
          public void sendJSON(JSONObject jsonObject) throws IOException {
                 JSONObject jsonObject2 = new JSONObject();
               jsonObject2.put(&quot;key&quot;, new Paper(250,369));
               
               OutputStream out = socket.getOutputStream();
                ObjectOutputStream o = new ObjectOutputStream(out);
               o.writeObject(jsonObject2);
                out.flush();
                System.out.println(&quot;Sent to server: &quot; + &quot; &quot; + jsonObject2.get(&quot;key&quot;).toString());
      }
      }
  
      public void start(int port) throws IOException{
          establish(port);
          accept();
      }
  
      public static void main(String[] args) {
          JSONServer server = new JSONServer();
  
          try {
              server.start(7777);
  
          } catch (IOException e) {
              System.err.println(e.getMessage());
              System.err.println(e);
          }
      }
  }
  </code></pre>
  <p>Although the Class Paper is serialize i get error:</p>
  <blockquote>
  <p>localhost org.json.JSONObject</p>
  <p>java.io.NotSerializableException: org.json.JSONObject</p>
  </blockquote>