public static String execute()

in java/src/main/java/org/apache/zeppelin/java/StaticRepl.java [50:165]


  public static String execute(String generatedClassName, String code) throws Exception {

    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();

    // Java parasing
    JavaProjectBuilder builder = new JavaProjectBuilder();
    JavaSource src = builder.addSource(new StringReader(code));

    // get all classes in code (paragraph)
    List<JavaClass> classes = src.getClasses();
    String mainClassName = null;

    // Searching for class containing Main method
    for (int i = 0; i < classes.size(); i++) {
      boolean hasMain = false;

      for (int j = 0; j < classes.get(i).getMethods().size(); j++) {
        if (classes.get(i).getMethods().get(j).getName().equals("main") && classes.get(i)
            .getMethods().get(j).isStatic()) {
          mainClassName = classes.get(i).getName();
          hasMain = true;
          break;
        }
      }
      if (hasMain == true) {
        break;
      }

    }

    // if there isn't Main method, will retuen error
    if (mainClassName == null) {
      LOGGER.error("Exception for Main method", "There isn't any class "
          + "containing static main method.");
      throw new Exception("There isn't any class containing static main method.");
    }

    // replace name of class containing Main method with generated name
    code = code.replace(mainClassName, generatedClassName);

    JavaFileObject file = new JavaSourceFromString(generatedClassName, code.toString());
    Iterable<? extends JavaFileObject> compilationUnits = Arrays.asList(file);

    ByteArrayOutputStream baosOut = new ByteArrayOutputStream();
    ByteArrayOutputStream baosErr = new ByteArrayOutputStream();

    // Creating new stream to get the output data
    PrintStream newOut = new PrintStream(baosOut);
    PrintStream newErr = new PrintStream(baosErr);
    // Save the old System.out!
    PrintStream oldOut = System.out;
    PrintStream oldErr = System.err;
    // Tell Java to use your special stream
    System.setOut(newOut);
    System.setErr(newErr);

    CompilationTask task = compiler.getTask(null, null, diagnostics, null, null, compilationUnits);

    // executing the compilation process
    boolean success = task.call();

    // if success is false will get error
    if (!success) {
      for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
        if (diagnostic.getLineNumber() == -1) {
          continue;
        }
        System.err.println("line " + diagnostic.getLineNumber() + " : "
            + diagnostic.getMessage(null));
      }
      System.out.flush();
      System.err.flush();

      System.setOut(oldOut);
      System.setErr(oldErr);
      LOGGER.error("Exception in Interpreter while compilation", baosErr.toString());
      throw new Exception(baosErr.toString());
    } else {
      try {

        // creating new class loader
        URLClassLoader classLoader = URLClassLoader.newInstance(new URL[]{new File("").toURI()
            .toURL()});
        // execute the Main method
        Class.forName(generatedClassName, true, classLoader)
            .getDeclaredMethod("main", new Class[]{String[].class})
            .invoke(null, new Object[]{null});

        System.out.flush();
        System.err.flush();

        // set the stream to old stream
        System.setOut(oldOut);
        System.setErr(oldErr);

        return baosOut.toString();

      } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException
          | InvocationTargetException e) {
        LOGGER.error("Exception in Interpreter while execution", e);
        System.err.println(e);
        e.printStackTrace(newErr);
        throw new Exception(baosErr.toString(), e);

      } finally {

        System.out.flush();
        System.err.flush();

        System.setOut(oldOut);
        System.setErr(oldErr);
      }
    }

  }