Java 3D Desktop Environment旨在使用Java 3D来创建一个3D桌面环境。功能包括：分布式的应用程序

				package org.j3de.server;       
				    
				import java.io.IOException;
				import java.io.StreamTokenizer;
				import java.io.StringReader;
				import java.lang.reflect.Constructor;
				import java.lang.reflect.InvocationTargetException;
				import java.net.SocketPermission;
				import java.security.PermissionCollection;
				import java.security.Permissions;   
				import java.security.Permission;
				import java.util.jar.JarFile;
				
				import org.w3c.dom.NamedNodeMap;
				import org.w3c.dom.Node;       
				import org.w3c.dom.NodeList;
				import org.w3c.dom.Document;
				
				import org.j3de.exception.ExceptionHandler;
				import org.j3de.util.AbstractComponent;
				import org.j3de.util.ConfigurationException;
				import org.j3de.util.Configurable;
				
				public abstract class WrapperComponent extends AbstractComponent {               
				  private final static String JARFILE   = "jarfile";
				  private final static String JARURL    = "jarurl";
				  private final static int    QUOTE     = 39;
				  private final static int    COMMA     = 44;
				  private final static int    SEMICOLON = 59;
				  
				  private String      jarFile;
				  private String      jarURL;
				
				  protected abstract void setComponent(Object component);
				  
				  public void configure(Node node, Document nodeFactory)  throws ConfigurationException {  
				    super.configure(node, nodeFactory); 
				                                                             
				    jarURL   = helper.getPropertyValue(JARURL);               
				    ClassLoader loader = getJarFiles(node);     
				    setComponent(helper.getComponent("wrappedComponent", null, null, null, loader));      
				  }                                                   
				
				  private ClassLoader getJarFiles(Node root) throws ConfigurationException { 
				    JarClassLoader loader = JarClassLoader.getClassLoader();
				    
				    NodeList childNodes = root.getChildNodes();   
				    
				    for (int i=0; i				      Node node = childNodes.item(i);
				      if (node.getNodeName().equals("jarfile")) {
				        NamedNodeMap attributes = node.getAttributes();  
				        Node attrib = attributes.getNamedItem("name");
				        
				        String name        = null;
				        String permissions = null;
				        
				        try {
				          name        = attributes.getNamedItem("name").getNodeValue();   
				          permissions = attributes.getNamedItem("permissions").getNodeValue();   
				        } catch (NullPointerException e) {
				        }
				        
				        if (name != null) {  
				          PermissionCollection pc = getPermissionCollection(permissions);   
				          loader.addJarFile(name, pc);  
				        }
				      }
				    }           
				    
				    return loader;
				  }            
				  
				  private PermissionCollection getPermissionCollection(String permissions) throws ConfigurationException {
				    PermissionCollection pc = new Permissions();
				    
				    // Add Default Permission : Every Class loaded locally is allowed to connect to any client.
				    // This should be moved to the Configuration-File !
				    pc.add(new SocketPermission("*", "listen,connect,resolve"));    
				    
				    if (permissions == null)
				      return pc;
				     
				    try {
				      StreamTokenizer st = new StreamTokenizer(new StringReader(permissions));
				      st.nextToken();
				      
				      String permissionName = null;
				      String param1         = null;
				      String param2         = null;
				      
				      // Format of Permisions :
				      // classname ['param1'] [, 'param2'] ; nextpermission 
				      
				      while (st.ttype != StreamTokenizer.TT_EOF) {
				        if (st.ttype == StreamTokenizer.TT_WORD) {
				          permissionName = st.sval;   
				        } else
				          throw new ConfigurationException("Error Parsing Permissions : Permissions-Classname expected"); 
				 
				        st.nextToken();
				         
				        if (st.ttype == QUOTE) {
				          param1 = st.sval;   
				     
				          st.nextToken();
				          
				          if (st.ttype == COMMA) { 
				            st.nextToken();     
				            
				            if (st.ttype == QUOTE) {
				              param2 = st.sval;      
				              addPermission(pc, permissionName, param1, param2);
				              
				              st.nextToken();           
				              
				              if (st.ttype != SEMICOLON)
				                throw new ConfigurationException("Error Parsing Permissions : Semicolon Expected");
				            
				            } else 
				              throw new ConfigurationException("Error Parsing Permissions : Parameter Expected");
				        
				          } else if (st.ttype == SEMICOLON) {
				            addPermission(pc, permissionName, param1, param2);
				          } else
				            throw new ConfigurationException("Error Parsing Permissions : Parameter or Semicolon Expected");
				        
				        } else if (st.ttype == SEMICOLON) {
				          addPermission(pc, permissionName, param1, param2);
				        } else
				          throw new ConfigurationException("Error Parsing Permissions : Parameter or Semicolon Expected");
				        
				        st.nextToken();
				      
				      }
				    } catch (IOException e) {
				      ExceptionHandler.handleException(e);
				    }
				      
				    return pc;
				  }       
				  
				  private void  addPermission(PermissionCollection pc, 
				                              String classname, 
				                              String param1,
				                              String param2) throws ConfigurationException {
				    try {                                 
				      Class permissionClass = Class.forName(classname);
				      if (!Permission.class.isAssignableFrom(permissionClass))
				        throw new ConfigurationException(classname + " is not of type Permission");
				        
				      Constructor constructor;
				      Class[]     params;
				      Object[]    paramValues;
				      
				      if (param1 == null) {
				        params         = new Class[0];                               
				        paramValues    = new Object[0];
				        constructor    = permissionClass.getConstructor(params);
				      } else if (param2 == null) {
				        params         = new Class[1];                               
				        params[0]      = String.class;
				        paramValues    = new Object[1];  
				        paramValues[0] = param1;
				        constructor    = permissionClass.getConstructor(params);
				      } else {
				        params = new Class[2];                               
				        params[0]      = String.class;
				        params[1]      = String.class;
				        paramValues    = new Object[2];  
				        paramValues[0] = param1;
				        paramValues[1] = param2;
				        constructor = permissionClass.getConstructor(params);
				      }
				      
				      pc.add((Permission)constructor.newInstance(paramValues));
				      
				    } catch (Exception e) {
				      ExceptionHandler.handleException(e);
				    }
				  }
				    
				  public String getJarURL() {
				    return jarURL;
				  }
				
				}