À proximité de la ressource tranquillement utilisation de try-with-resources

Est-il possible d'ignorer l'exception levée lorsqu'une ressource est fermée à l'aide d'un try-with-resources déclaration?

Exemple:

class MyResource implements AutoCloseable{
  @Override
  public void close() throws Exception {
    throw new Exception("Could not close");
  }  
  public void read() throws Exception{      
  }
}

//this method prints an exception "Could not close"
//I want to ignore it
public static void test(){
  try(MyResource r = new MyResource()){
    r.read();
  } catch (Exception e) {
    System.out.println("Exception: " + e.getMessage());
  }
}

Ou devrais-je continuer à se refermer dans un finally à la place?

public static void test2(){
  MyResource r = null;
  try {
     r.read();
  }
  finally{
    if(r!=null){
      try {
        r.close();
      } catch (Exception ignore) {
      }
    }
  }
}

InformationsquelleAutor dogbane | 2011-07-31

25

J'ai trouvé cette réponse sur la pièce-dev mailing list:
http://mail.openjdk.java.net/pipermail/coin-dev/2009-April/001503.html

5. Certains échecs de la méthode de fermeture peut être ignoré en toute sécurité (p. ex.,
fermeture d'un fichier qui a été ouvert pour la lecture). La construction fournir pour
cette?

Pas. Même si cette fonctionnalité semble attrayant, il n'est pas clair que
il vaut la peine de la complexité ajoutée. En pratique, ces “inoffensif
les exceptions” rarement, sinon jamais se produire, si un programme ne sera pas plus solide
si ces exceptions sont ignorés. Si vous sentez que vous devez les ignorer,
il y a une solution, mais il n'est pas assez:
```
static void copy(String src, String dest) throws IOException {
    boolean done = false;
    try (InputStream in = new FileInputStream(src)) {
        try(OutputStream out = new FileOutputStream(dest)) {
            byte[] buf = new byte[8192];
            int n;
            while ((n = in.read(buf)) >= 0)
                out.write(buf, 0, n);
        }
        done = true;
    } catch(IOException e) {
        if (!done)
            throw e;
    }
}
```
- il n'est pas assez. une autre idée maintenant?
InformationsquelleAutor dogbane

Vous pouvez utiliser un décorateur patron ici pour fermer la ressource tranquillement:

public class QuietResource<T extends AutoCloseable> implements AutoCloseable{
    T resource;
    public QuietResource(T resource){
        this.resource = resource;
    }
    public T get(){
        return resource;
    }
    @Override
    public void close() {
        try {
            resource.close();
        }catch(Exception e){
            //suppress exception
        }
    }  
}

Je ne suis pas personnellement fan de la syntaxe, mais peut-être ce qui fonctionne pour vous:

public static void test(){
    try(QuietResource<MyResource> qr = new QuietResource<>(new MyResource())){
        MyResource r = qr.get();
        r.read();
    } catch (Exception e) {
        System.out.println("Exception: " + e.getMessage());
    }
}

Vous pouvez faire mieux, si vous êtes prêt à vous limiter à traiter avec des interfaces et de l'effet de levier d'une Dynamique de la Classe Proxy:

public class QuietResource<T> implements InvocationHandler {

    private T resource;

    @SuppressWarnings("unchecked")
    public static <V extends AutoCloseable> V asQuiet(V resource){
        return (V) Proxy.newProxyInstance(
                resource.getClass().getClassLoader(),
                resource.getClass().getInterfaces(),
                new QuietResource<V>(resource));
    }

    public QuietResource(T resource){
        this.resource = resource;
    }

    @Override
    public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
        if(m.getName().equals("close")){
            try {
                return m.invoke(resource, args);
            }catch(Exception e){
                System.out.println("Suppressed exception with message: " + e.getCause().getMessage());
                //suppress exception
                return null;
            }
        }
        return m.invoke(resource, args);
    }
}

Ensuite, en supposant que vous avez:

public interface MyReader extends AutoCloseable{
    int read();
}

Avec une véritable ressource de classe:

public class MyResource implements MyReader {

    public void close() throws Exception{
        throw new Exception("ha!");
    }

    public int read(){
        return 0;
    }
}

Syntaxe d'appel ressemblerait à:

public static void test(){
    try(MyReader r = QuietResource.asQuiet(new MyResource())){
        r.read();
    } catch (Exception e) {
        System.out.println("Exception: " + e.getMessage());
    }
}

Vous pouvez faire mieux que ça si vous voulez commencer à y compris les bibliothèques, comme les AOP catalyseurs. Ces solutions, cependant, sera de travailler hors de la boîte avec JDK7 et pas d'autres dépendances.

Vous devez supprimer throws Exception de close() de document de la prirent d'exception et de simplifier l'utilisation.
Elliot Vous peut mettre en œuvre la méthode de l'interface déclarée avec jette avec la méthode d'une classe non déclarée lancers.

InformationsquelleAutor Mark Elliot

4

C'est une solution:
```
    boolean ok=false;
    try(MyResource r = new MyResource())
    {
        r.read();
        ok=true;
    }
    catch (Exception e)
    {
        if(ok)
            ; //ignore
        else
            //e.printStackTrace();
            throw e;
    }
```
Si ok==true et nous avons eu une exception, il vient définitivement de close().

Si ok==false, e vient de read() ou d'un constructeur. close() sera toujours appelé et peut jeter e2, mais e2 sera supprimé de toute façon.

Le code est lisible sans l'intermédiaire d'une telle analyse. Intuitivement, il est dit, si ok==true, notre vrai travail est fait, et nous n'avons pas vraiment attention à ce que les erreurs viennent après que le sujet de la ressource.

InformationsquelleAutor irreputable

Vous devez vous connecter pour publier un commentaire.