/* From http://java.sun.com/docs/books/tutorial/index.html */
 
 
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.JarURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.jar.Attributes;
 
/**
 * Runs a jar application from any url. Usage is 'java JarRunner url [args..]'
 * where url is the url of the jar file and args is optional arguments to be
 * passed to the application's main method.
 */
public class JarRunner {
  public static void main(String[] args) {
    if (args.length < 1) {
      usage();
    }
    URL url = null;
    try {
      url = new URL(args[0]);
    } catch (MalformedURLException e) {
      fatal("Invalid URL: " + args[0]);
    }
    // Create the class loader for the application jar file
    JarClassLoader cl = new JarClassLoader(url);
    // Get the application's main class name
    String name = null;
    try {
      name = cl.getMainClassName();
    } catch (IOException e) {
      System.err.println("I/O error while loading JAR file:");
      e.printStackTrace();
      System.exit(1);
    }
    if (name == null) {
      fatal("Specified jar file does not contain a 'Main-Class'"
          + " manifest attribute");
    }
    // Get arguments for the application
    String[] newArgs = new String[args.length - 1];
    System.arraycopy(args, 1, newArgs, 0, newArgs.length);
    // Invoke application's main class
    try {
      cl.invokeClass(name, newArgs);
    } catch (ClassNotFoundException e) {
      fatal("Class not found: " + name);
    } catch (NoSuchMethodException e) {
      fatal("Class does not define a 'main' method: " + name);
    } catch (InvocationTargetException e) {
      e.getTargetException().printStackTrace();
      System.exit(1);
    }
  }
 
  private static void fatal(String s) {
    System.err.println(s);
    System.exit(1);
  }
 
  private static void usage() {
    fatal("Usage: java JarRunner url [args..]");
  }
}
 
/**
 * A class loader for loading jar files, both local and remote.
 */
 
class JarClassLoader extends URLClassLoader {
  private URL url;
 
  /**
   * Creates a new JarClassLoader for the specified url.
   * 
   * @param url
   *            the url of the jar file
   */
  public JarClassLoader(URL url) {
    super(new URL[] { url });
    this.url = url;
  }
 
  /**
   * Returns the name of the jar file main class, or null if no "Main-Class"
   * manifest attributes was defined.
   */
  public String getMainClassName() throws IOException {
    URL u = new URL("jar", "", url + "!/");
    JarURLConnection uc = (JarURLConnection) u.openConnection();
    Attributes attr = uc.getMainAttributes();
    return attr != null ? attr.getValue(Attributes.Name.MAIN_CLASS) : null;
  }
 
  /**
   * Invokes the application in this jar file given the name of the main class
   * and an array of arguments. The class must define a static method "main"
   * which takes an array of String arguemtns and is of return type "void".
   * 
   * @param name
   *            the name of the main class
   * @param args
   *            the arguments for the application
   * @exception ClassNotFoundException
   *                if the specified class could not be found
   * @exception NoSuchMethodException
   *                if the specified class does not contain a "main" method
   * @exception InvocationTargetException
   *                if the application raised an exception
   */
  public void invokeClass(String name, String[] args)
      throws ClassNotFoundException, NoSuchMethodException,
      InvocationTargetException {
    Class c = loadClass(name);
    Method m = c.getMethod("main", new Class[] { args.getClass() });
    m.setAccessible(true);
    int mods = m.getModifiers();
    if (m.getReturnType() != void.class || !Modifier.isStatic(mods)
        || !Modifier.isPublic(mods)) {
      throw new NoSuchMethodException("main");
    }
    try {
      m.invoke(null, new Object[] { args });
    } catch (IllegalAccessException e) {
      // This should not happen, as we have disabled access checks
    }
  }
 
}

import java.applet.Applet;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.Hashtable;
 
import javax.swing.JFrame;
 
public class MainClass {
 
  public static void main(String args[]) {
    String name = "http://urlWithClassName";
    try {
      if (!name.endsWith(".class")) {
        System.err.println("That doesn't look like a byte code file!");
        return;
      }
      URL u = new URL(name);
      URLClassLoader ucl = new URLClassLoader(u);
 
      // parse out the name of the class from the URL
      String s = u.getFile();
      String classname = s.substring(s.lastIndexOf('/'), s.lastIndexOf(".class"));
      Class AppletClass = ucl.loadClass(classname, true);
      Applet apl = (Applet) AppletClass.newInstance();
      JFrame f = new JFrame();
      f.setSize(200, 200);
      f.add("Center", apl);
      apl.init();
      apl.start();
      f.setVisible(true);
    } catch (Exception e) {
      System.err.println(e);
    }
  }
}
 
class URLClassLoader extends ClassLoader {
  Hashtable cache = new Hashtable();
  URL url;
 
  public URLClassLoader(URL u) {
    this.url = u;
  }
 
  public synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
    Class cls = (Class) cache.get(name);
    if (cls == null) {
      try {
        cls = findSystemClass(name);
      } catch (ClassNotFoundException e) {
      }
    }
    if (cls == null) {
      byte classData[] = loadClassData(name);
      cls = defineClass(classData, 0, classData.length);
      cache.put(name, cls);
    }
    if (resolve) {
      resolveClass(cls);
    }
    return cls;
  }
  private byte[] loadClassData(String name) throws ClassNotFoundException {
    byte[] buffer;
    InputStream theClassInputStream = null;
    int bufferLength = 128;
    try {
      URL classURL = new URL(url, name + ".class");
      URLConnection uc = classURL.openConnection();
      uc.setAllowUserInteraction(false);
 
      try {
        theClassInputStream = uc.getInputStream();
      } catch (NullPointerException e) {
        System.err.println(e);
        throw new ClassNotFoundException(name + " input stream problem");
      }
      int contentLength = uc.getContentLength();
 
      // A lot of web servers don't send content-lengths
      // for .class files
      if (contentLength == -1) {
        buffer = new byte[bufferLength * 16];
      } else {
        buffer = new byte[contentLength];
      }
 
      int bytesRead = 0;
      int offset = 0;
 
      while (bytesRead >= 0) {
        bytesRead = theClassInputStream.read(buffer, offset, bufferLength);
        if (bytesRead == -1)
          break;
        offset += bytesRead;
        if (contentLength == -1 && offset == buffer.length) { // grow the array
          byte temp[] = new byte[offset * 2];
          System.arraycopy(buffer, 0, temp, 0, offset);
          buffer = temp;
        } else if (offset > buffer.length) {
          throw new ClassNotFoundException(name + " error reading data into the array");
        }
      }
 
      if (offset < buffer.length) { // shrink the array
        byte temp[] = new byte[offset];
        System.arraycopy(buffer, 0, temp, 0, offset);
        buffer = temp;
      }
 
      // Make sure all the bytes were received
      if (contentLength != -1 && offset != contentLength) {
        throw new ClassNotFoundException("Only " + offset + " bytes received for " + name
            + "\n Expected " + contentLength + " bytes");
      }
    } catch (Exception e) {
      throw new ClassNotFoundException(name + " " + e);
    } finally {
      try {
        if (theClassInputStream != null)
          theClassInputStream.close();
      } catch (IOException e) {
      }
    }
    return buffer;
  }
}