package cs.classloader;
/**
 * 任务类接口 ,任何实现了此接口的类，都可以在服务端简单任务执行器中执行
 * */
public interface TaskIntf {

	void execute();
}

package cs.classloader;

public class TaskIntfImp implements TaskIntf {
	
	static {
		System.out.println("我被加载了");
	}

	@Override
	public void execute() {
		System.out.println("我被执行了   我被"+this.getClass().getClassLoader()+"加载");
	}

}

package cs.classloader;

import java.io.File;
import java.io.FileInputStream;
/**
 * 自定义类加载器
 * */
public class NewClassLoader extends ClassLoader {
	private String currentRoot = null;

	public NewClassLoader(String userdir) {
		this.currentRoot = userdir;
	}

	public NewClassLoader() {
	}
	//根据类名从文件中读取类字节码
	public byte[] findClassBytes(String className) {
		if (currentRoot == null) {
			currentRoot = "";
		}
		try {
			String pathName = currentRoot + File.separatorChar
					+ className.replace('.', File.separatorChar) + ".class";
			FileInputStream inFile = new FileInputStream(pathName);
			byte[] classBytes = new byte[inFile.available()];
			inFile.read(classBytes);
			return classBytes;
		} catch (java.io.IOException ioEx) {
			return null;
		}
	}
	
	@SuppressWarnings("unchecked")
	public Class findClass(String name) throws ClassNotFoundException {

		byte[] classBytes = findClassBytes(name);
		if (classBytes == null) {
			throw new ClassNotFoundException();
		} else {
			return defineClass(name, classBytes, 0, classBytes.length);
		}
	}
	//根据传入的字节码 返回class信息
	@SuppressWarnings("unchecked")
	public Class findClass(String name, byte[] classBytes)
			throws ClassNotFoundException {

		if (classBytes == null) {
			throw new ClassNotFoundException("(classBytes==null)");
		} else {
			return defineClass(name, classBytes, 0, classBytes.length);
		}
	}
	//执行 实现了TaskIntf 接口的 任务类
	@SuppressWarnings("unchecked")
	public void execute(String codeName, byte[] code) {

		Class klass = null;
		try {
			klass = findClass(codeName, code);
			TaskIntf task = (TaskIntf) klass.newInstance();
			task.execute();
		} catch (Exception exception) {
			exception.printStackTrace();
		}
	}
}

package cs.classloader;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 服务端类，实现监听客户端请求
 * */
public class Server {

	private ServerSocket ss = null;
	private int port = 8067;
	private Socket sc = null;

	public Server() {
		try {
			ss = new ServerSocket(port);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void listener() {
		while (true) {
			try {
				sc = ss.accept();
				Thread t = new Thread(new TaskDo(sc));//交给任务处理线程处理
				t.start();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		Server s = new Server();
		s.listener();
	}
}
/**
 * 此类主要是读取客户端传来的字节码，并实现任务执行
 * */
class TaskDo implements Runnable {
	Socket s;
	InputStream is;
	OutputStream os;
	BufferedInputStream bis;
	byte[] b = null;

	public TaskDo(Socket s) {
		this.s = s;
		try {
			os = s.getOutputStream();
			is = s.getInputStream();
			bis = new BufferedInputStream(is);
			b = new byte[bis.available()];
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void run() {
		try {
			read(b);
			execute(null, b);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bis.close();
				is.close();
				s.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

	private void read(byte[] b) throws Exception {
		bis.read(b);
	}

	private void execute(String codeName, byte[] code) {

		NewClassLoader fileSystemClassLoader = null;

		try {
			fileSystemClassLoader = new NewClassLoader();
			fileSystemClassLoader.execute(codeName, code);
		} catch (Exception exception) {
		}
	}
}

package cs.classloader;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
/**
 * 客户端类，负责读取实现了TaskIntf接口的类的字节码，并发送给服务端
 * */
public class Client {
	public static void main(String[] args) {

		try {
			for (int i = 0; i < 2; i++) {
				byte[] code = getClassDefinition("cs.classloader.TaskIntfImp");
				send(code);
			}
		} catch (Exception ex) {
		}
	}

	private static byte[] getClassDefinition(String codeName) {
		String userDir = System.getProperty("user.dir") + "\\bin";
		NewClassLoader fscl1 = null;

		try {
			fscl1 = new NewClassLoader(userDir);
		} catch (Exception fileNotFoundException) {
			fileNotFoundException.printStackTrace();
		}
		return fscl1.findClassBytes(codeName);
	}

	private static void send(byte[] b) {
		OutputStream os = null;
		Socket s = null;
		try {
			s = new Socket("127.0.0.1", 8067);
			os = s.getOutputStream();
			os.write(b);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				os.close();
				s.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}