Java/Development Class/Applet Loader

Applet Loader Demo

 
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;
  }
}

Dummy Applet Context

   
/**
 * Copyright(c) 1996 DTAI, Incorporated (http://www.dtai.ru)
 *
 *                        All rights reserved
 *
 * Permission to use, copy, modify and distribute this material for
 * any purpose and without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all
 * copies, and that the name of DTAI, Incorporated not be used in
 * advertising or publicity pertaining to this material without the
 * specific, prior written permission of an authorized representative of
 * DTAI, Incorporated.
 *
 * DTAI, INCORPORATED MAKES NO REPRESENTATIONS AND EXTENDS NO WARRANTIES,
 * EXPRESS OR IMPLIED, WITH RESPECT TO THE SOFTWARE, INCLUDING, BUT
 * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR ANY PARTICULAR PURPOSE, AND THE WARRANTY AGAINST
 * INFRINGEMENT OF PATENTS OR OTHER INTELLECTUAL PROPERTY RIGHTS.  THE
 * SOFTWARE IS PROVIDED "AS IS", AND IN NO EVENT SHALL DTAI, INCORPORATED OR
 * ANY OF ITS AFFILIATES BE LIABLE FOR ANY DAMAGES, INCLUDING ANY
 * LOST PROFITS OR OTHER INCIDENTAL OR CONSEQUENTIAL DAMAGES RELATING
 * TO THE SOFTWARE.
 */
import java.awt.*;
import java.applet.*;
import java.net.*;
import java.util.*;
import java.io.*;
/**
 * DummyAppletContext - implements AppletContext and AppletStub to allow any
 * applet to easily run as an application.  The only thing it can"t do is
 * access URL"s.  Applet parameters are entered on the command line with
 * name as one word and value as the next.
 *
 * @version 1.1
 * @author  DTAI, Incorporated
 *
 * $Id: DummyAppletContext.java,v 1.5 1996/10/08 21:15:09 kadel Exp $
 *
 * $Source: /cvs/java/classes/COM/dtai/gui/DummyAppletContext.java,v $
 */
public class DummyAppletContext
    extends Frame
    implements AppletStub, AppletContext, URLStreamHandlerFactory {
    private TextField status;
    private Hashtable params = new Hashtable();
    private Vector applets = new Vector();
    private int initial_width;
    private int initial_height;
  /**
   * Entry point into the standalone program.
   *
   * @param args  the command line arguments
   */
    public static void main ( String args[] ) {
        new DummyAppletContext( args );
    }
  /**
   * Constructor for the main class, given an existing applet object.
   *
   * @param applet            the applet embedded in this AppletContext
   * @param args              the command line arguments.  Contains possibly
   *                          height and width, and any applet parameters
   */
    public DummyAppletContext( Applet applet, String args[] ) {
        this( applet, 640, 480, args );
    }
  /**
   * Constructor for the main class, given an existing applet object and a default
   * frame (window) width and height.
   *
   * @param applet            the applet embedded in this AppletContext
   * @param default_width     the default width of the window
   * @param default_height    the default width of the window
   * @param args              the command line arguments.  Contains possibly
   *                          height and width, and any applet parameters
   */
    public DummyAppletContext( Applet applet, int default_width, int default_height,
                               String args[] ) {
        super ( applet.getClass().getName() );
        init( applet, default_width, default_height, args, 0 );
    }
  /**
   * Constructor for the main class, from the command line arguments.
   *
   * @param args  the command line arguments.  Contains the name of the applet
   *              class, possibly height and width, and any applet parameters.
   */
    public DummyAppletContext( String args[] ) {
        super ( args[0] );
        try {
            Applet applet = (Applet)Class.forName( args[0] ).newInstance();
            init( applet, 640, 480, args, 1 );
        }
        catch ( Exception e ) {
            e.printStackTrace();
            System.exit( 1 );
        }
    }
  /*
   * PRIVATE initialization function.
   *
   * @param applet            the applet embedded in this AppletContext
   * @param default_width     the default width of the window
   * @param default_height    the default width of the window
   * @param args              the command line arguments.  Contains possibly
   *                          height and width, and any applet parameters
   * @param startidx          index in the args array at which to start parsing
   */
    private void init( Applet applet, int default_width, int default_height,
                       String args[], int startidx ) {
        URL.setURLStreamHandlerFactory( this );
        applets.addElement( applet );
        applet.setStub(this);
        initial_width = default_width;
        initial_height = default_height;
        parseArgs( args, startidx );
        status = new TextField();
        status.setEditable( false );
        add( "Center", applet );
        add( "South", status );
        appletResize( initial_width, initial_height );
        show();
        applet.init();
        applet.start();
    }
  /**
   * Parse the command line arguments.  Get the initial width and height of
   * the window if specified (-width [value] -height [value]), and the
   * applet parameters (name value pairs).
   *
   * @param args              the command line arguments.  Contains possibly
   *                          height and width, and any applet parameters
   * @param startidx          index in the args array at which to start parsing
   */
    public void parseArgs( String args[], int startidx ) {
        for ( int idx = startidx; idx < ( args.length - startidx ); idx+=2 ) {
            try {
                if ( args[idx].equals( "-width" ) ) {
                    initial_width = Integer.parseInt( args[idx+1] );
                }
                else if ( args[idx].equals( "-height" ) ) {
                    initial_height = Integer.parseInt( args[idx+1] );
                }
                else {
                    params.put( args[idx], args[idx+1] );
                }
            }
            catch ( NumberFormatException nfe ) {
                System.err.println("Warning: command line argument "+args[idx]+
                                   " is not a valid number." );
            }
        }
    }
  /**
   * Event handler to catch the Frame (window) close action,
   * and exit the program.
   *
   * @param evt   The event that occurred
   * @return      false if the event was not handled by this object.
   */
    public boolean handleEvent( Event evt ) {
        if ( evt.id == Event.WINDOW_DESTROY ) {
            System.exit(0);
        }
        return super.handleEvent(evt);
    }
/************ AppletStub methods *************/
    /**
     * Returns true if the applet is active.
     *
     * @return  always true
     */
    public boolean isActive() { return true; }
    /**
     * Gets the document URL.
     *
   * @return      a "file:" URL for the current directory
     */
    public URL getDocumentBase() {
        URL url = null;
        try {
            File dummy = new File( "dummy.html" );
            String path = dummy.getAbsolutePath();
            if ( ! File.separator.equals( "/" ) ) {
                StringBuffer buffer = new StringBuffer();
                if ( path.charAt(0) != File.separator.charAt(0) ) {
                    buffer.append( "/" );
                }
                StringTokenizer st = new StringTokenizer( path, File.separator );
                while ( st.hasMoreTokens() ) {
                    buffer.append( st.nextToken() + "/" );
                }
                if ( File.separator.equals( "\\" ) &&
                     ( buffer.charAt(2) == ":" ) ) {
                    buffer.setCharAt( 2, "|" );
                }
                else {
                }
                path = buffer.toString();
                path = path.substring( 0, path.length()-1 );
            }
            url = new URL( "file", "", -1, path );
        }
        catch ( MalformedURLException mue ) {
            mue.printStackTrace();
        }
        return url;
    }
    /**
     * Gets the codebase URL.
     *
   * @return      in this case, the same value as getDocumentBase()
     */
    public final URL getCodeBase() { return getDocumentBase(); }
    /**
     * Gets a parameter of the applet.
     *
   * @param name  the name of the parameter
   * @return      the value, or null if not defined
   */
    public final String getParameter( String name ) {
        return (String)params.get( name );
    }
  /**
   * Gets a handler to the applet"s context.
   *
   * @return  this object
   */
    public final AppletContext getAppletContext() { return this; }
  /**
   * Called when the applet wants to be resized.  This causes the
   * Frame (window) to be resized to accomodate the new Applet size.
   *
   * @param width     the new width of the applet
   * @param height    the new height of the applet
   */
    public void appletResize( int width, int height ) {
        Insets insets = insets();
        resize( ( width + insets.left + insets.right ),
                ( height + status.preferredSize().height +
                  insets.top + insets.bottom ) );
    }
/************ AppletContext methods *************/
  /**
     * Gets an audio clip.  (There doesn"t seem to be a "Toolkit" for
     * audio clips in my JDK, so this always returns null.  You could
     * implement this differently, returning a dummy AudioClip object
     * for which the class could be defined at the bottom of this file.)
   *
   * @param url   URL of the AudioClip to load
   * @return      the AudioClip object if it exists (in our case,
   *              this is always null
   */
    public final AudioClip getAudioClip( URL url ) { return null; }
  /**
     * Gets an image. This usually involves downloading it
     * over the net. However, the environment may decide to
     * cache images. This method takes an array of URLs,
     * each of which will be tried until the image is found.
   *
   * @param url   URL of the Image to load
   * @return      the Image object
   */
    public final Image getImage( URL url ) {
        return Toolkit.getDefaultToolkit().getImage( filenameFromURL( url ) );
    }
  /*
     * PRIVATE utility function.  Ignores the protocol, and returns a
     * filename for a file on the local filesystem (which may or may
     * not exist, of course).
   *
   * @param url   URL to be converted to a filename on the local
   *              filesystem.
   * @return      the filename
   */
    private String filenameFromURL( URL url ) {
        String filename = url.getFile();
        if ( filename.charAt(1) == "|" ) {
            StringBuffer buf = new StringBuffer( filename );
            buf.setCharAt( 1, ":" );
            filename = buf.toString();
        }
        else if ( filename.charAt(2) == "|" ) {
            StringBuffer buf = new StringBuffer( filename );
            buf.setCharAt( 2, ":" );
            filename = buf.toString();
        }
        return filename;
    }
  /**
     * Gets an applet by name.
     *
   * @param name  the name of the applet
     * @return      null if the applet does not exist, and it never
     *              does since we never name the applet.
   */
    public final Applet getApplet( String name ) { return null; }
  /**
     * Enumerates the applets in this context. Only applets
     * that are accessible will be returned. This list always
     * includes the applet itself.
   *
   * @return  the Enumeration -- contains ONLY the applet created with
   *          this DummyAppletContext
   */
    public final Enumeration getApplets() { return applets.elements(); }
  /**
     * Shows a new document. This may be ignored by
     * the applet context (and in our case, it is, but we"ll show the
     * user, in the status area, that the document was requested and
     * WOULD be loaded if in a browser).
   *
   * @param url   URL to load
   */
    public void showDocument( URL url ) {
        status.setText( "AppletContext request to show URL " +
                        url.toString() );
    }
  /**
     * Show a new document in a target window or frame. This may be ignored by
     * the applet context.  (Again, it is ignored, but we"ll show the
     * request information to the user in the status area.)
     *
     * This method accepts the target strings:
     *   _self    show in current frame
     *   _parent  show in parent frame
     *   _top   show in top-most frame
     *   _blank   show in new unnamed top-level window
     *   <other>  show in new top-level window named <other>
   *
   * @param url       URL to load
   * @param target    the target string
   */
    public void showDocument( URL url, String target ) {
        status.setText( "AppletContext request to show URL " +
                        url.toString() +
                        " in target: " + target );
    }
  /**
     * Show a status string in the status area (the Text object at the bottom
     * of the window.
   *
   * @param text  the text to display
   */
    public void showStatus( String text ) { status.setText( text ); }
/************ URLStreamHandlerFactory methods *************/
  /**
     * Creates a new URLStreamHandler instance with the specified protocol.
     *
     * @param protocol  the protocol to use (ftp, http, nntp, etc.).
     *                  THIS PROTOCOL IS IGNORED BY THIS APPLET CONTEXT
     */
    public URLStreamHandler createURLStreamHandler( String protocol ) {
        return new DummyURLStreamHandler();
    }
}
/*
 * A URL stream handler for all protocols, used to return our
 * dummy implementation of URLConnection to open up a local
 * file when called upon.
 */
class DummyURLStreamHandler extends URLStreamHandler {
    protected final URLConnection openConnection( URL u ) throws IOException {
        return new DummyURLConnection( u );
    }
}
/*
 * Our dummy implementation of URLConnection used to open up a local
 * file when called upon with a given URL of ANY protocol type.  This
 * allows the applet to easily use the "getInputStream()" function.
 */
class DummyURLConnection extends URLConnection {
    boolean connected = false;
    InputStream instream;
    /*
     * Constructor for the DummyURLConnection
     */
    protected DummyURLConnection( URL url ) {
        super( url );
    }
    /*
     * open the local file
     */
    public void connect() throws IOException {
        if ( ! connected ) {
            String filename = url.getFile();
            if ( filename.charAt(1) == "|" ) {
                StringBuffer buf = new StringBuffer( filename );
                buf.setCharAt( 1, ":" );
                filename = buf.toString();
            }
            else if ( filename.charAt(2) == "|" ) {
                StringBuffer buf = new StringBuffer( filename );
                buf.setCharAt( 2, ":" );
                filename = buf.toString();
            }
            instream = new FileInputStream( filename );
        }
    }
    /*
     * return the open stream to the local file (open if necessary).
     */
    public InputStream getInputStream() throws IOException {
        if ( ! connected ) {
            connect();
        }
        if ( instream == null ) {
            throw new IOException();
        }
        return instream;
    }
}