[关闭]
@snail-lb 2017-02-28T15:22:38.000000Z 字数 13003 阅读 1594

JavaOJ 判题核心系统（使用沙盒实现）

java进阶

一、加载系统中的Class文件并执行其中的方法

(使用多线程来执行系统中的Class文件，这个类中的方法有参数，有返回值)

1.自定义类加载器

  1. package com.cn.oj_java_my;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  6. public class MyClassLoader extends ClassLoader {
  7.     /** 默认classPath */
  8.     private String classPath;
  9.     /** class的实例 **/
  10.     private Class<?> cla;
  12.     /**
  13.      * 构造函数
  14.      * @param classPath
  15.      */
  16.     public MyClassLoader(String classPath) {
  17.         this.classPath = classPath;
  18.     }
  20.     /**
  21.      * @param className  类的名称，不支持带有包名的类
  22.      */
  23.     @Override
  24.     protected Class<?> findClass(String className) throws ClassNotFoundException {
  25.         return loadClass(classPath, className);
  26.     }
  28.     /**
  29.      * 更改类加载器加载类的classpath,在指定路径下加载制定的类class文件
  30.      * 
  31.      * @param classPath
  32.      *            要加载的类路径
  33.      * @param className
  34.      *            要加载的类名 只能加载不含包的类.
  35.      * @throws ClassNotFoundException
  36.      * @throws IllegalAccessException
  37.      * @throws InstantiationException
  38.      */
  39.     public Class<?> loadClass(String classPath, String className)
  40.             throws ClassNotFoundException{
  42.         File classFile = new File(classPath + "\\" + className + ".class");
  43.         byte[] mainClass = new byte[(int) classFile.length()];
  44.         try {
  45.             FileInputStream in = new FileInputStream(classFile);
  46.             in.read(mainClass);
  47.             in.close();
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.             throw new ClassNotFoundException(className);
  51.         }
  52.         Class<?> cla = super.defineClass(className, mainClass, 0, mainClass.length);
  54.         this.cla = cla;
  56.         return cla;
  57.     }
  59.     /**
  60.      * 获取classPath
  61.      * 
  62.      * @return String classPath
  63.      */
  64.     public String getClassPath() {
  65.         return classPath;
  66.     }
  68.     /**
  69.      * 实例化当前类 此方法必须在类加载之后执行
  70.      * @param className
  71.      * @return
  72.      * @throws InstantiationException
  73.      * @throws IllegalAccessException
  74.      * @throws ClassNotFoundException
  75.      */
  76.     public Object newInstance(String className)
  77.             throws InstantiationException, IllegalAccessException, ClassNotFoundException {
  78.         if(this.cla == null){
  79.             throw new RuntimeException("类" + className + "没有加载");
  80.         }
  81.         return this.cla.newInstance();
  82.     }
  84. }

2.MyObject

  1. package com.cn.oj_java_my;
  3. import java.lang.reflect.Method;
  5. /**
  6.  * 通过反射获取类中响应的方法属性
  7.  * 
  8.  * @author lvbiao
  9.  *
  10.  */
  11. public class MyObject {
  12.     private String classPath;
  14.     private String className;
  17.     /**自定义类加载器**/
  18.     private MyClassLoader mcl;
  21.     //类初始化
  22.     public void init(String classPath,String className){
  23.         this.classPath = classPath;
  24.         this.className = className;
  25.         mcl = new MyClassLoader(classPath);
  26.     }
  28.     public Method getMethod(String methodName) throws Exception {
  29.         if(mcl == null){
  30.             throw new RuntimeException(this.className + "没有初始化");
  31.         }
  33.         Class<?> cla = mcl.findClass(className);
  34.         Method method = cla.getMethod(methodName, String.class);
  35.         method.setAccessible(true);
  36.         return method;
  37.     }
  39.     public Object newInstance() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
  40.         return mcl.newInstance(className);
  41.     }
  42. }

3.MyTask

  1. package com.cn.oj_java_my;
  3. import java.lang.reflect.Method;
  4. import java.util.concurrent.Callable;
  6. public class MyTask implements Callable<Object> {
  7.     private String parameters;
  9.     private String classPath;
  11.     private String className;
  13.     public MyTask(String parameters) {
  14.         this.parameters = parameters;
  15.     }
  17.     @Override
  18.     public Object call() throws Exception {
  19.         // 这里使用反射获取main函数
  20.         MyObject mo = new MyObject();
  21.         if(classPath.equals(null)){
  22.             throw new RuntimeException("没有设置类路径");
  23.         }
  24.         if(className.equals(null)){
  25.             throw new RuntimeException("没有设置类名称");
  26.         }
  28.         mo.init(classPath, className);
  30.         //要获取的方法名称
  31.         String methodName = "test";
  32.         Method mainMethod = mo.getMethod(methodName);
  33.         //获取实例化的类
  34.         Object obj = mainMethod.invoke(mo.newInstance(), parameters);
  35.         return obj;
  36.     }
  38.     public String getClassPath() {
  39.         return classPath;
  40.     }
  42.     public void setClassPath(String classPath) {
  43.         this.classPath = classPath;
  44.     }
  46.     public String getClassName() {
  47.         return className;
  48.     }
  50.     public void setClassName(String className) {
  51.         this.className = className;
  52.     }
  55. }

4.MyOjCore.java

  1. package com.cn.oj_java_my;
  3. import java.util.concurrent.ExecutionException;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.Future;
  7. import java.util.concurrent.TimeUnit;
  9. public class MyOjCore {
  10.     public static void main(String[] args) {
  11.         //设置线程池
  12.         ExecutorService executor = Executors.newCachedThreadPool();
  13.         //设置方法参数
  14.         String parameters = "asdf";
  15.         MyTask task = new MyTask(parameters);
  16.         task.setClassPath("F:\\Test");
  17.         task.setClassName("Test");
  19.         Future<Object> result = executor.submit(task);
  21.         executor.shutdown();
  23.         try {
  24.             TimeUnit.MILLISECONDS.sleep(3000);
  25.         } catch (InterruptedException e1) {
  26.             e1.printStackTrace();
  27.         }
  29.         System.out.println("主线程在执行任务");
  31.         try {
  32.             System.out.println("task运行结果" + result.get().toString());
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         } catch (ExecutionException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  39. }

5.系统中F:\Test\Test.java文件

  1. public class Test {
  2.     public String test(String str){
  3.         System.out.println("+++"+str+"+++");
  4.         return new String("aaaaaaaaaaa");
  5.     }
  6. }

二、完成了对java文件的编译，加载，运行及接管控制台输入功能，

1.编译模块

  1. package com.cn.ojcore.common;
  3. import java.io.BufferedReader;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  7. /**
  8.  * 编译java文件
  9.  * @author lvbiao
  10.  *
  11.  */
  12. public class MyCompiler {
  13.     /**
  14.      * 批处理文件路径
  15.      * @param path
  16.      */
  17.     public static void command(String path){
  18.         try {
  20.             Runtime run = Runtime.getRuntime();
  21.             //String path = "F:\\Test\\my1.bat";
  22.             //String path = "F:\\Test\\my1.bat";
  24.             Process process = run.exec("cmd.exe /c  " + path);
  26.             InputStream in = process.getInputStream();
  27.             InputStream inError = process.getErrorStream();
  29.             BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in));
  30.             BufferedReader brError = new BufferedReader(new InputStreamReader(inError, "GBK"));
  32.             String error;//错误信息
  33.             while ((error = brError.readLine()) != null) {
  34.                 System.out.println(error);
  35.             }
  37.             String s;
  38.             while ((s = bufferedReader.readLine()) != null) {
  39.                 System.out.println(s);
  40.             }
  42.             in.close();
  43.             bufferedReader.close();
  44.             System.out.println("返回值：" + process.waitFor());
  45.             System.out.println("========================");
  46.         } catch (Exception e) {
  47.             e.printStackTrace();
  48.         }
  49.     }
  50. }

2.自定义加载模块

  1. package com.cn.ojcore.common;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  6. public class MyClassLoader extends ClassLoader {
  7.     /** 默认classPath */
  8.     private String classPath;
  9.     /** class的实例 **/
  10.     private Class<?> cla;
  12.     /**
  13.      * 构造函数
  14.      * @param classPath
  15.      */
  16.     public MyClassLoader(String classPath) {
  17.         this.classPath = classPath;
  18.     }
  20.     /**
  21.      * @param className  类的名称，不支持带有包名的类
  22.      */
  23.     @Override
  24.     protected Class<?> findClass(String className) throws ClassNotFoundException {
  25.         return loadClass(classPath, className);
  26.     }
  28.     /**
  29.      * 更改类加载器加载类的classpath,在指定路径下加载制定的类class文件
  30.      * 
  31.      * @param classPath
  32.      *            要加载的类路径
  33.      * @param className
  34.      *            要加载的类名 只能加载不含包的类.
  35.      * @throws ClassNotFoundException
  36.      * @throws IllegalAccessException
  37.      * @throws InstantiationException
  38.      */
  39.     public Class<?> loadClass(String classPath, String className)
  40.             throws ClassNotFoundException{
  42.         File classFile = new File(classPath + "\\" + className + ".class");
  43.         byte[] mainClass = new byte[(int) classFile.length()];
  44.         try {
  45.             FileInputStream in = new FileInputStream(classFile);
  46.             in.read(mainClass);
  47.             in.close();
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.             throw new ClassNotFoundException(className);
  51.         }
  52.         Class<?> cla = super.defineClass(className, mainClass, 0, mainClass.length);
  54.         this.cla = cla;
  56.         return cla;
  57.     }
  59.     /**
  60.      * 获取classPath
  61.      * 
  62.      * @return String classPath
  63.      */
  64.     public String getClassPath() {
  65.         return classPath;
  66.     }
  68.     /**
  69.      * 实例化当前类 此方法必须在类加载之后执行
  70.      * @param className
  71.      * @return
  72.      * @throws InstantiationException
  73.      * @throws IllegalAccessException
  74.      * @throws ClassNotFoundException
  75.      */
  76.     public Object newInstance(String className)
  77.             throws InstantiationException, IllegalAccessException, ClassNotFoundException {
  78.         if(this.cla == null){
  79.             throw new RuntimeException("类" + className + "没有加载");
  80.         }
  81.         return this.cla.newInstance();
  82.     }
  84. }

3.MyObject

  1. package com.cn.ojcore.common;
  3. import java.lang.reflect.Method;
  5. /**
  6.  * 通过反射获取类中响应的方法属性
  7.  * 
  8.  * @author lvbiao
  9.  *
  10.  */
  11. public class MyObject {
  12.     private String classPath;
  14.     private String className;
  17.     /**自定义类加载器**/
  18.     private MyClassLoader mcl;
  21.     //类初始化
  22.     public void init(String classPath,String className){
  23.         this.classPath = classPath;
  24.         this.className = className;
  25.         mcl = new MyClassLoader(classPath);
  26.     }
  28.     public Method getMethod(String methodName) throws Exception {
  29.         if(mcl == null){
  30.             throw new RuntimeException(this.className + "没有初始化");
  31.         }
  33.         Class<?> cla = mcl.findClass(className);
  34. //      Method method = cla.getMethod(methodName, (new Object[0]).getClass());
  35.         Method method = cla.getMethod(methodName, String[].class);
  36.         method.setAccessible(true);
  37.         return method;
  38.     }
  40.     public Object newInstance() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
  41.         return mcl.newInstance(className);
  42.     }
  43. }

4.MyTask.java

  1. package com.cn.ojcore.common;
  3. import java.io.BufferedInputStream;
  4. import java.io.ByteArrayInputStream;
  5. import java.io.Console;
  6. import java.io.DataInputStream;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.io.ObjectInputStream;
  10. import java.io.OutputStream;
  11. import java.io.PrintStream;
  12. import java.lang.reflect.Method;
  13. import java.lang.reflect.Modifier;
  14. import java.util.Scanner;
  15. import java.util.concurrent.Callable;
  17. public class MyTask implements Callable<Object> {
  18.     private String[] parameters;
  20.     private String classPath;
  22.     private String className;
  24.     private String methodName;
  26.     public MyTask(String classPath, String className, String methodName) {
  27.         this.classPath = classPath;
  28.         this.className = className;
  29.         this.methodName = methodName;
  30.     }
  32.     // 设置参数
  33.     public void setParameter(String[] parameters) {
  34.         this.parameters = parameters;
  35.     }
  37.     public Object call() throws Exception{
  38.         return this.invoke();
  39.     }
  41.     // 有参数的方法
  42.     public Object invoke() throws Exception {
  43.         // 这里使用反射获取函数
  44.         MyObject mo = new MyObject();
  46.         //初始化，设置类路径及类名称
  47.         mo.init(classPath, className);
  49.         Method mainMethod = mo.getMethod(methodName);
  51.         Object obj;
  52.         //调用方法，获取返回值
  53.         if(Modifier.isStatic(mainMethod.getModifiers())) {
  54.             //静态方法的调用
  55. //          obj = mainMethod.invoke(null, new Object[] { parameters });
  56.             //输入重定向
  57.             System.setIn(new BufferedInputStream(new ByteArrayInputStream("abc aaa".getBytes())));  
  58.             obj = mainMethod.invoke(null, (Object)parameters);
  59.         }else{
  60.             //非静态方法的调用
  61. //          obj = mainMethod.invoke(mo.newInstance(), new Object[] { parameters });
  62.             obj = mainMethod.invoke(mo.newInstance(), (Object)parameters);
  63.         }
  65.         return obj;
  66.     }
  68. }

5.MyOjCore.java

  1. package com.cn.ojcore;
  3. import java.util.concurrent.ExecutionException;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.Future;
  8. import com.cn.ojcore.common.MyCompiler;
  9. import com.cn.ojcore.common.MyTask;
  11. public class MyOjCore {
  12.     /**类路径**/
  13.     private static String classPath = "F:\\mavenProject\\MyOjCore\\Test";
  15.     /**类名称**/
  16.     private static String className = "Test2";
  18.     /**调用方法名称**/
  19.     private static String methodName = "main";
  21.     /**批操作文件文件名**/
  22.     private static String batName = "mytest.bat";
  25.     public static void main(String[] args) {
  26.         //设置线程池
  27.         ExecutorService executor = Executors.newCachedThreadPool();
  28.         //编译java文件
  29.         MyCompiler.command(classPath + "\\" + batName);
  32.         //设置方法参数
  33.         String[] parameters = {"Bob","Tom"};
  35.         MyTask task = new MyTask(classPath, className, methodName);
  36.         task.setParameter(parameters);
  38.         Future<Object> result = executor.submit(task);
  39.         executor.shutdown();
  40.         try {
  41.             Object obj = result.get();
  42.             if(obj == null){
  43.                 System.out.println("返回值为空，没有返回值");
  44.             }else{
  45.                 System.out.println("task运行结果" + result.get().toString());
  46.             }
  47.         } catch (InterruptedException e) {
  48.             e.printStackTrace();
  49.         } catch (ExecutionException e) {
  50.             e.printStackTrace();
  51.         }
  52.     }
  53. }

6.Test.java

  1. public class Test2 {
  2.     public static void main(String[] args){
  3.         java.util.Scanner ac = new java.util.Scanner(System.in);
  4.         String str1 = ac.nextLine();
  5.         System.out.println(str1);
  6.     }
  7. }

7.mytest.bat

  1. F:
  2. cd F:\mavenProject\MyOjCore\Test
  3. javac Test2.java

8.运行结果

F:\mavenProject\MyOjCore>F:
F:\mavenProject\MyOjCore>cd F:\mavenProject\MyOjCore\Test
F:\mavenProject\MyOjCore\Test>javac Test2.java
返回值：0
++++++++++++++++++++
abc aaa
返回值为空，没有返回值

三、后续

后续代码较多，欢迎访问
我的ｇｉｔ

四、个人总结

在整个java判题内核的编写过程中，主要有以下几个技术难点，现在对这些做一个总结，以便以后进行查阅。
1.获取系统的输入输出。
比如现在我要运行一个用户提交的程序，平常我们都是在Eclipse中直接运行，如果有运行中的输入输出，我们可以直接在控制台进行输入输出，但是现在这个程序托管给了我们，需要我们自己进行运行，这就需要我们在程序中提前将输入设置好，在运行之前将其输入。这就需要用到System.setIn(),System.setOut()等方法，具体用法见文档。

  1. System.setIn(new BufferedInputStream(new ByteArrayInputStream(normInputBuffer.toString().getBytes())));
  3. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  4. System.setOut(new PrintStream(baos));

2.执行cmd命令
java文件的编译工作需要cmd控制台中执行javac命令进行，执行cmd命令方式：

  1. Runtime run = Runtime.getRuntime();
  2. Process process = run.exec("cmd.exe /c  " + order);

3.class文件的导入
由于我们的class文件是在程序执行过程中生成的，所以需要我们手动的将class文件导入到jvm中，导入方法：
我们的导入类继承ClassLoader类，然后调用父类中defineClass方法

  1. public class MyClassLoader extends ClassLoader {
  2.     public Class<?> loadClass(byte[] classFile, String className) {
  3.         Class<?> cla = super.defineClass(className, classFile, 0, classFile.length);
  4.         return cla;
  5.     }
  6. }

另外还需要注意，不同进程中的类是不可以通用的，就是说Class对象是不能通过socket传送的。

4.安全
在执行用户代码的时候，我们需要将其放入到沙箱中进行执行，并给与最低权限，以防发生安全事故。设置安全管理器：

  1. security = System.getSecurityManager();
  2. if (security == null) {
  3.         System.setSecurityManager(new MySecurityManager());
  4. }

自定义安全策略：

  1. public class MySecurityManager extends SecurityManager{
  2.         /** 
  3.          * 重写强行退出检测 
  4.          * 防止用户自行终止虚拟机的运行,但是调用程序端可以执行退出 
  5.          * */  
  6.         public void checkExit(int status) {  
  7.              throw new SecurityException("Exit On Client Is Not Allowed!");  
  8.         } 
  10.         /** 
  11.          *  策略权限查看 
  12.          * 当执行操作时调用,如果操作允许则返回,操作不允许抛出SecurityException 
  13.          * */  
  14.         private void sandboxCheck(Permission perm) throws SecurityException {  
  15.             // 设置只读属性  
  16.             if (perm instanceof SecurityPermission) { 
  17.                 //安全性
  18.                 if (perm.getName().startsWith("getProperty")) {  
  19.                     return;  
  20.                 }  
  21.             } else if (perm instanceof PropertyPermission) {  
  22.                 //属性
  23.                 if (perm.getActions().equals("read")) {  
  24.                     return;  
  25.                 } else{
  26.                     throw new SecurityException(perm.toString()); 
  27.                 }
  28.             } else if (perm instanceof FilePermission) {  
  29.                 //文件操作
  30.                 if (perm.getActions().equals("read") || perm.getActions().equals("execute")) {  
  31.                     return;  
  32.                 }else{
  33.                     throw new SecurityException(perm.toString()); 
  34.                 }
  35.             } else if (perm instanceof ReflectPermission){  
  36.                 //反射
  37.                return;  
  38.             }else if(perm instanceof RuntimePermission){
  39.                 //运行时安全
  40.                 return;
  41.             }
  42.             else if(perm instanceof SocketPermission){
  43.                 //Socket权限
  44.                 if (perm.getActions().equals("accept") || 
  45.                         perm.getActions().equals("connect") ||
  46.                         perm.getActions().equals("listen") ||
  47.                         perm.getActions().equals("resolve")
  48.                         ) {  
  49.                     return;  
  50.                 } 
  51.             }else if(perm instanceof NetPermission){
  52.                 //网络
  53.                 if(perm.implies(new NetPermission("specifyStreamHandler"))){
  54.                     //在构造 URL 时指定流处理程序的能力
  55.                     return;
  56.                 }else{
  57.                     throw new SecurityException(perm.toString());  
  58.                 }
  59.             }else{
  60.                 throw new SecurityException(perm.toString());  
  61.             }
  62.         }  
  63.         @Override  
  64.         public void checkPermission(Permission perm) {  
  65.             this.sandboxCheck(perm);  
  66.         }  
  68.         @Override  
  69.         public void checkPermission(Permission perm, Object context) {  
  70.             this.sandboxCheck(perm);  
  71.         }
  72. }

5.定时任务
用户程序执行需要有时间限制，所以就有的定时任务，定时任务一般使用FutureTask实现，FutureTask是可取消的异步计算。FutureTask需要放入到Thread中然后Thread进行开始。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注