Java avec Groovy de la manipulation de fermetures de lever des Exceptions

Nous avons un système qui est possible de personnaliser à l'aide de scripts groovy et j'ai repéré un très étrange effet sur le type d'exceptions lancer à partir de ces scripts.

Nous avons un script groovy avec les éléments suivants:

process {
   throw new Exception("weeee")
}

Processus est défini comme une Fermeture de la classe de base du script:

public abstract class ScriptBaseClass extends Script {
   Closure process;

   public void process( Closure code ) {
      process = (Closure) code.clone();
   } 
}

Dans le classe Java qui exécute les scripts, nous avons la méthode suivante (omis de tous la mise en place de code comme il ne semble pas pertinent):

public void process() {
   try {
      script.process.call();
   } catch (Exception e) {
      logger.debug("exception thrown from groovy script", e);
      throw e;
   }
}

Remarque le processus de la méthode ici n'est pas déclaré, il jette tout de même des exceptions. Cependant très clairement re-lève l'Exception e qu'il a attrapé. Ce code est valide, il compile et fonctionne tout à fait heureux. Il lève l'Exception que je le voulais.

Ce que quelqu'un sait comment cela est code juridique? En théorie je ne devrais pas être en mesure de jeter un checked exception d'une méthode qui n'a pas à déclarer qu'il se jette sur elle.

oui, c'est légal en groovy. ne trouve aucune mention dans les docs btw, mais il était toujours en train de travailler
En effet, je sais que c'est légal en groovy, cependant, le processus de la méthode ci-dessus, qui re-lève l'exception est dans une classe Java. Normalement, si vous jetez un checked exception, vous devez le déclarer. Cela semble être un cas particulier autour de l'interface de ces deux langues.
oh, désolé, première partie sur groovy a été source de confusion, donc j'ai raté la partie java

OriginalL'auteur Wil Selwood | 2015-08-13

  1. 7

    Cela fonctionne parce que le compilateur Java (départ depuis Java 7) peut déterminer re-levée d'une exception. Pour catch (Exception e) il pense qu'il est RuntimeException parce qu'il n'y avait pas d'autres (vérifié) exception déclaré dans call().

    Vous pouvez lire à ce sujet là, par exemple: https://docs.oracle.com/javase/7/docs/technotes/guides/language/catch-multiple.html

    Donc ce code compile parfaitement:

    public void xxxxx() {
    try {
        System.out.println('Hi!'); //or anything else w/o declared exceptions
    } catch (Exception e) {
        throw e;
    }
}

    Java compilé voit que seuls les RuntimeException est peut-être coincé ici, afin de ne pas vous demander de ne rien déclarer.

    Mais pour cela:

    public void xxxxx() {
    try {
        throw new IOException(); //or anything that have declared checked exception
    } catch (Exception e) {
        throw e;
    }
}

    il ne pourra pas compiler, parce que IOException peut être attrapé et re-jeté

    Grande réponse. Sans autres langues mélangées dans la JVM c'est raisonnable (si un peu déroutant) de chose à faire. Cependant, nous devons être très prudent lors de l'interfaçage avec groovy code.

    OriginalL'auteur Igor Artamonov

  2. 1

    Groovy et la JVM n'avez pas vraiment à une exception près: un cochée ou pas. Seul le compilateur Java soucis à ce sujet ici. En fait, vous pouvez utiliser le catch sur toute RuntimeException ou de ses classes parentes (dont Exception est un), sans qu'il être déclaré comme jeté de quelque chose appelé dans le try-bloc. C'est donc bien par le compilateur à l'Exception de catch ou Throwable même. Bien sûr, à partir d'une logique de programme en vue, c'est une question entièrement différente.

    Je sais groovy et la jvm ne se soucient pas vérifié vs décoché exceptions cependant la méthode de traitement est dans une classe Java, donc exécuté par le Compilateur de Java qui est pourquoi je suis confus comment il est valable code.
    "Seul le compilateur Java se soucie de ce ici" a été pensé comme phrase pour faire clair, je parle du compilateur Java à partir d'ici maintenant.

    OriginalL'auteur blackdrag

  3. 1

    L'introduction de fermetures ou de quelque chose de Groovy liée à la complexité inutile. Ce qui suit est valable de code Java:

    public class Demo {
    public void someMethod() {
        try {
            System.out.println("Hello");
        } catch (Exception e) {
            throw e;
        }
    }
}

    Noter que le suivant n'est pas valide et ne compile pas:

    import java.sql.*;

public class Demo {
    public void someMethod() {
        try {
            Connection c = DriverManager.getConnection("", "", "");
        } catch (SQLException e) {
            throw e;
        }
    }
}

    OriginalL'auteur Jeff Scott Brown