Non-standard interfaces must be server-side before de-serializing?

Question

Classes which implement non-standard interfaces are a problem for de-serialization? In the below code SomeInterface is the problem. If the "SomeInterface.class" is not server-side when the de-serialization starts then the de-serialization can't happen? Please look at this test code:
client
public class Main {
  public static void main(String[] args) {
    try {
      Socket sok = new Socket("192.168.2.2", 1638);
      MyOOS moos = new MyOOS(sok.getOutputStream());
      moos.writeObject(new ClassA(222));
      try { Thread.sleep(3000); } catch(InterruptedException e) { }
      sok.close();
    } catch(Exception e) { e.printStackTrace() ; }
  private static byte[] getClassImage() throws Exception {
    InputStream in = new FileInputStream(new File("/dev/ClassA.class"));
    List<Byte> objClassImage = new ArrayList<Byte>();
    int b = in.read();
    while(b != -1) {
      objClassImage.add(Byte.valueOf((byte) b));
      b = in.read();
    byte[] classImage = new byte[objClassImage.size()];
    for(int i = 0; i < classImage.length; i++) {
      classImage[i] = ((Byte) objClassImage.get(i)).byteValue();
    in.close();
    return classImage;
        static class MyOOS extends ObjectOutputStream {
          MyOOS() throws Exception { super(); }
          MyOOS(OutputStream out) throws Exception { super(out); }
          protected void annotateClass(Class<?> cl) throws IOException {
            try {
              byte[] classImage = getClassImage();
              writeInt(classImage.length);
              write(classImage);
            } catch(Exception e) { e.printStackTrace(); }
// public class ClassA implements Serializable, SomeInterface  {  // <-- bad
public class ClassA implements Serializable  { // <-- good
  int id;
  ClassA(int i) { id = i; }
  public void foo() {
    System.out.println("ClassA::foo--> id = " + id);
public Interface SomeInterface { public void foo(); }
server
public class Hello {
  static MyClassLoader myLoader = new MyClassLoader();
  public static void main(String[] args) { new Hello().run(); }
  void run() {
    try {
      ServerSocket servSok = new ServerSocket(1638);
      Socket sok = servSok.accept();
      MyOIS mois = new MyOIS(sok.getInputStream());
      Object obj = (Object) mois.readObject();
      Method m = obj.getClass().getMethod("foo", null);
      m.invoke(obj, null);
    } catch (Exception e) { e.printStackTrace(); }
      static class MyClassLoader extends ClassLoader {
        byte[] classImage;
        // is this a normal way to program Java? Because I am unsure about how to handle the byte[] in
        // resolveClass(), I am jamming them in here. Would a good programmer do stuff like this?
        public Class<?> loadClass(String name, byte[] classImage) throws Exception {
          this.classImage = classImage;
          return loadClass(name);
        protected Class<?> findClass(String name) throws ClassNotFoundException {
          return defineClass(name, classImage, 0, classImage.length);
      static class MyOIS extends ObjectInputStream {
        private MyClassLoader myLoader = new MyClassLoader();
        MyOIS() throws IOException { super(); }
        MyOIS(InputStream in) throws IOException { super(in); }
        protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
          try {
            int classImageSize = readInt();
            byte[] classImage = new byte[classImageSize];
            read(classImage);
            return myLoader.loadClass(desc.getName(), classImage);
          } catch (Exception e) { e.printStackTrace(); }
          return null;
}If a serialized object implements an interface that is not already on the de-serializing jvm end, then serialization is not possible? Am I suppose to put the SomeInterface object on the server (somehow) before de-serializing an object that actually implements SomeInterface .
I have heard of object graphs. So, would not the implemented interfaces be part of an object's object graph? Thanks.

Answer 1

ejp wrote:
I have no idea what any of that means, if anything, but RMI comes with a dynamic codebase facility if that's what you're looking for.I successfully moved an object with a non-standard pure abstract class to a remote jvm:
client
public class Main {
  public static void main(String[] args) {
    try {
      Socket sok = new Socket("192.168.2.2", 1638);
      MyOOS moos = new MyOOS(sok.getOutputStream());
      DataOutputStream dos = new DataOutputStream(sok.getOutputStream());
      byte[] classImage = getClassImage("/dev/PureAbstractClass.class");
      dos.writeInt(classImage.length);
      dos.write(classImage, 0, classImage.length);
      moos.writeObject(new ClassA(5));
      try { Thread.sleep(3000); } catch(InterruptedException e) { }
      sok.close();
    } catch(Exception e) { e.printStackTrace() ; }
  private static byte[] getClassImage(String path) throws Exception {
    InputStream in = new FileInputStream(new File(path));
    List<Byte> objClassImage = new ArrayList<Byte>();
    int b = in.read();
    while(b != -1) {
      objClassImage.add(Byte.valueOf((byte) b));
      b = in.read();
    byte[] classImage = new byte[objClassImage.size()];
    for(int i = 0; i < classImage.length; i++) {
      classImage[i] = ((Byte) objClassImage.get(i)).byteValue();
    in.close();
    return classImage;
        static class MyOOS extends ObjectOutputStream {
          MyOOS() throws Exception { super(); }
          MyOOS(OutputStream out) throws Exception { super(out); }
          protected void annotateClass(Class<?> cl) throws IOException {
            try {
              byte[] classImage = getClassImage("/dev/ClassA.class");
              writeInt(classImage.length);
              write(classImage);
            } catch(Exception e) { e.printStackTrace(); }
public abstract class PureAbstractClass {
  public abstract void foo();
  public abstract void bar();
public class ClassA extends PureAbstractClass implements Serializable {
  int id;
  ClassA(int i) { id = i; }
  public void foo() { System.out.println("PureAbstractClass::ClassA::foo id = " + id); }
  public void bar() { System.out.println("PureAbstractClass::ClassA::bar id = " + id); }
server
public class Hello {
  static MyClassLoader myLoader = new MyClassLoader();
  public static void main(String[] args) { new Hello().run(); }
  void run() {
    try {
      ServerSocket servSok = new ServerSocket(1638);
      Socket sok = servSok.accept();
      MyOIS mois = new MyOIS(sok.getInputStream());
      DataInputStream dis = new DataInputStream(sok.getInputStream());
      int classImageSize = dis.readInt();
      byte[] classImage = new byte[classImageSize];
      dis.read(classImage, 0, classImageSize);
      myLoader.myDefineClass("PureAbstractClass", classImage, 0, classImage.length);
      Object obj = (Object) mois.readObject();
      Method m = obj.getClass().getMethod("bar", null);
      m.invoke(obj, null);
    } catch (Exception e) { e.printStackTrace(); }
        static class MyClassLoader extends ClassLoader {
          byte[] classImage;
          public Class<?> loadClass(String name, byte[] classImage) throws Exception {
            this.classImage = classImage;
            return loadClass(name);
          protected Class<?> findClass(String name) throws ClassNotFoundException {
            return defineClass(name, classImage, 0, classImage.length);
          public Class<?> myDefineClass(String name, byte[] classImage, int x, int y) {
            return defineClass(name, classImage, x, y);
        static class MyOIS extends ObjectInputStream {
          MyOIS() throws IOException { super(); }
          MyOIS(InputStream in) throws IOException { super(in); }
          protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
            try {
              int classImageSize = readInt();
              byte[] classImage = new byte[classImageSize];
              read(classImage);
              return myLoader.loadClass(desc.getName(), classImage);
            } catch (Exception e) { e.printStackTrace(); }
            return null;
}I hope this relates to understanding RMI. Moving objects that extend non-standard classes and implementing non-standard interfaces is not easy. Or, maybe there is an easier way. Anyway, thanks ejp. Yesterday I was extremely confused. Now, I am just a little confused but think I have basic understanding. I feel big progress was made.