類加載，相關代碼

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;


public class PathClassLoader extends ClassLoader {
        protected final ClassLoader parent;
        
        private final Hashtable<String,Class<?>> definedClass = new Hashtable<String,Class<?>>();
        
        public PathClassLoader(){
                this(PathClassLoader.class.getClassLoader());
        }
        
        public PathClassLoader(ClassLoader parent){
                this.parent = parent;
        }
        
        protected synchronized Class loaderClass(String name,boolean resolve)throws ClassNotFoundException{
                
                Class<?> cls = findLoadedClass(name);
                if(cls == null && parent != null){
                        try{
                                cls = parent.loadClass(name);
                        }catch(ClassNotFoundException e){
                                
                        }
                }
                
                if(cls == null){
                        cls = findClass(name);
                }
                
                if(resolve){
                        resolveClass(cls);
                }
                return cls;
        }
        
        
        public Class<?> loadClass(File file) throws ClassNotFoundException,IOException{
                
                return loadClass(new FileInputStream(file));
                
        }
        
public Class<?> loadClass(InputStream in) throws ClassNotFoundException,IOException{
                
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                byte[] buf = new byte[1024];
                int l;
                for(;;){
                        l= in.read(buf);
                        if(l <= 0){
                                break;
                        }
                        out.write(buf, 0, l);
                        
                }
                in.close();
                return loadClass(out.toByteArray());
        }


        public Class<?> loadClass(byte[] b) throws ClassNotFoundException{
                return loadClass(b,0,b.length);
        }
        
        public Class<?> loadClass(byte[] b,int off, int len) throws ClassNotFoundException{
                Class<?> cls = defineClass(null,b,off,len);
                definedClass.put(cls.getName(), cls);
                return loadClass(cls.getName());
        }
        
        protected Class<?> findClass(String name) throws ClassNotFoundException{
                Class<?> cls = definedClass.get(name);
                if(cls == null){
                        throw new ClassNotFoundException(name);
                }else{
                        return cls;
                }
                
        }
        
        public void loadDirectory(File dir) throws ClassNotFoundException ,IOException{
                if(dir.isFile()){
                        if(dir.getName().endsWith("class")){
                                loadClass(dir);
                        }
                        return;
                }else{
                        for(File file: dir.listFiles()){
                                if(file.isDirectory()){
                                        loadDirectory(file);
                                }else{
                                        if(file.getName().endsWith("class")){
                                                loadClass(file);
                                        }
                                }
                        }
                }
                
        }
        
        public static Method[] findClassAllMethod(Class<?> want){
                Method[] lookup = want.getDeclaredMethods();
                System.out.println("類："+want.getName()+"的方法共有"+lookup.length+".");
                StringBuffer methodName = new StringBuffer();
                for (int i = 0; i < lookup.length; i++) {
                        System.out.println(getMethodName(i,methodName,lookup[i]));
                        methodName.delete(0, methodName.length());
                }
                return lookup;
        }
        
        public static String getMethodName(int i,StringBuffer methodName,Method currentMethod){
                methodName.append("方法")
                        .append(i)
                        .append(":")
                        .append(currentMethod.getReturnType().toString())
                        .append(" ")
                        .append(currentMethod.getName())
                        .append("(");
                Class<?>[] parameterTypes = currentMethod.getParameterTypes();
                if(parameterTypes.length != 0){
                        for (int j = 0; ; j++) {
                                methodName.append(parameterTypes[j].toString());
                                if(j == parameterTypes.length -1){
                                        break;
                                }
                                methodName.append(",");
                        }
                }else{
                        methodName.append(")");
                        return methodName.toString();
                }
                methodName.append(")");
                return methodName.toString();
        }
        
        public static Boolean doAction(String className,PathClassLoader dc){
                Boolean flag = true;
                Class<?> want;
                try{
                        want = dc.findClass(className);
                        if(want == null){
                                flag = false;
                        }
                        else{
                                Method[] lookup = findClassAllMethod(want);
                                doWhatMethod(lookup,want);
                        }
                }catch(ClassNotFoundException e){
                        e.printStackTrace();
                }
                /*
                 * Object my = want.newInstance(); 
                 * Method action = want.getDeclaredMethod("moveRight",int.class);
                 * action.invoke(my,2);
                 * if(want != null){
                 *                 System.out.println("I want nobody but you");
                 * }
                 */
                return flag;
        }
        
        public static void doWhatClassMessage(){
                System.out.println("*******************");
                System.out.println("提示：");
                System.out.println("請輸入操作的類的名字：");
                System.out.println("輸入bye退出");
        }
        
        public static void doWhatClass(PathClassLoader dc){
                doWhatClassMessage();
                Scanner sc = new Scanner(System.in);
                do{
                        try{
                                if(sc.hasNext()){
                                        String className = sc.next();
                                        if(className.equals("bye")){
                                                break;
                                        }else{
                                                if(!doAction(className,dc)){
                                                        System.out.println("沒有找到該類"+className);
                                                        
                                                }
                                                continue;
                                        }
                                }
                        }catch(Exception e){
                                System.out.println("你輸入的類的信息有誤");
                                e.printStackTrace();
                                continue;
                        }
                }while(true);
                
        }
        
        public static int getIntParameter(){
                int parameter = 0;
                Scanner sc = new Scanner(System.in);
                do{
                        if(sc.hasNextInt()){
                                parameter = sc.nextInt();
                                System.out.println("int的parameter爲:"+parameter);
                                break;
                        }else{
                                System.out.println("你輸入的參數數據有問題，請重新輸入");
                        }
                }while(true);
                return parameter;
        }
        public static String getStringParameter(){
                String parameter = null;
                Scanner sc = new Scanner(System.in);
                parameter = sc.next();
                return parameter;
        }
        
        public static void doWhatMethodMessage(){
                System.out.println("***********************************");
                System.out.println("提示（目前只能執行基本數據類型的參數的方法):");
                System.out.println("請輸入調用方法的序號：");
                System.out.println("輸入back返回");
                System.out.println("***********************************");
        }
        public static void doWhatMethod(Method[] lookup,Class<?> want){
                
                do{
                        doWhatMethodMessage();
                        Scanner sc = new Scanner(System.in);
                        try{
                                if(sc.hasNextInt()){
                                        int i = sc.nextInt();
                                        System.out.println("獲取方法");
                                        System.out.println(getMethodName(i,new StringBuffer(),lookup[i]));
                                        Class<?>[] parameterTypes = lookup[i].getParameterTypes();
                                        Object myObject = want.newInstance();
                                        Object[] parameter = new Object[parameterTypes.length];
                                        for (int j = 0; j < parameter.length; j++) {
                                                System.out.println("請輸入參數"+j);
                                                System.out.println("參數類型："+parameterTypes[j].getName());
                                                if(parameterTypes[j].getName().equals("int")){
                                                        parameter[j] = getIntParameter();
                                                }
                                                if(parameterTypes[j].getName().equals("String")){
                                                        parameter[j] = getStringParameter();
                                                }
                                                
                                        }
                                        System.out.println("開始執行方法*******");
                                        lookup[i].invoke(myObject, parameter);
                                        System.out.println("執行方法完畢*******");
                                }
                                if(sc.hasNext()){
                                        String bye = sc.next();
                                        if(bye.equals("back")){
                                                break;
                                        }
                                }
                        }catch(Exception e){
                                System.out.println("你輸入的數據有誤");
                                e.printStackTrace();
                                continue;
                        }
                }while(true);
        }
        public static void printClassName(Object obj){
                System.out.println("The Class of " + obj + "is" + obj.getClass().getName());
        }
        public static void main(String[] args) {
                PathClassLoader dc = new PathClassLoader();
                //URL[] urls;
                try{
                        dc.loadDirectory(new File("C:\\eclipseWork\\Proxy\\bin"));
                        Set<String> key = dc.definedClass.keySet();
                        Iterator<String> it = key.iterator();
                        String className;
                        while(it.hasNext()){
                                className = it.next();
                                System.out.println(className);
                        }
                        doWhatClass(dc);
                }catch(Exception err){
                        System.err.println(err);
                }
        }
}