Java a-t-il une instruction using?

Java a-t-il une instruction using qui peut être utilisée lors de l'ouverture d'une session en veille prolongée?

En C #, c'est quelque chose comme:

using (var session = new Session())
{


}

Ainsi, l'objet sort de sa portée et se ferme automatiquement.

Java 7 a introduit la gestion automatique des blocs de ressources qui apporte cette fonctionnalité à la plate-forme Java. Les versions précédentes de Java n'avaient rien de semblable using.

À titre d'exemple, vous pouvez utiliser n'importe quelle variable implémentée java.lang.AutoCloseablede la manière suivante:

try(ClassImplementingAutoCloseable obj = new ClassImplementingAutoCloseable())
{
    ...
}

L' java.io.Closeableinterface de Java , implémentée par des flux, s'étend automatiquement AutoCloseable, de sorte que vous pouvez déjà utiliser les flux dans un trybloc de la même manière que vous les utiliseriez dans un usingbloc C # . Ceci est équivalent à C #using .

Depuis la version 5.0, les sessions Hibernate sont implémentéesAutoCloseable et peuvent être fermées automatiquement dans les blocs ARM. Dans les versions précédentes de Hibernate Session ne mettait pas en œuvreAutoCloseable . Vous devrez donc être sur Hibernate> = 5.0 pour utiliser cette fonctionnalité.

Avant Java 7 , une telle fonctionnalité n'existait pas en Java (pour Java 7 et plus, voir la réponse d' Asaph concernant ARM ).

Vous deviez le faire manuellement et c'était pénible :

AwesomeClass hooray = null;
try {
  hooray = new AwesomeClass();
  // Great code
} finally {
  if (hooray!=null) {
    hooray.close();
  }
}

Et c'est juste le code quand ni // Great codenihooray.close() ne peut lever d'exceptions.

Si vous voulez vraiment limiter la portée d'une variable, un simple bloc de code fait le travail:

{
  AwesomeClass hooray = new AwesomeClass();
  // Great code
}

Mais ce n'est probablement pas ce que vous vouliez dire.

Depuis Java 7, il fait: http://blogs.oracle.com/darcy/entry/project_coin_updated_arm_spec

La syntaxe du code de la question serait:

try (Session session = new Session())
{
  // do stuff
}

Notez qu'il Sessionfaut implémenter AutoClosableou l'une de ses (nombreuses) sous-interfaces.

Techniquement:

DisposableObject d = null;
try {
    d = new DisposableObject(); 
}
finally {
    if (d != null) {
        d.Dispose();
    }
}

L'équivalent java le plus proche est

AwesomeClass hooray = new AwesomeClass();
try{
    // Great code
} finally {
    hooray.dispose(); // or .close(), etc.
}

Non, Java n'a pas d' usingéquivalent d'instruction.

A partir de maintenant, non.

Cependant, il existe une proposition d' ARM pour Java 7.

Si vous êtes intéressé par la gestion des ressources, Project Lombok propose l' @Cleanupannotation. Tiré directement de leur site:

Vous pouvez utiliser @Cleanuppour vous assurer qu'une ressource donnée est automatiquement nettoyée avant que le chemin d'exécution du code ne quitte votre étendue actuelle. Pour ce faire, annotez toute déclaration de variable locale avec l' @Cleanup annotation comme suit:

@Cleanup InputStream in = new FileInputStream("some/file");

En conséquence, à la fin de la portée dans laquelle vous vous trouvez, in.close() est appelée. Cet appel est garanti de s'exécuter par le biais d'une construction try / finally. Regardez l'exemple ci-dessous pour voir comment cela fonctionne.

Si le type d'objet que vous souhaitez nettoyer n'a pas de close() méthode, mais une autre méthode sans argument, vous pouvez spécifier le nom de cette méthode comme suit:

@Cleanup("dispose") org.eclipse.swt.widgets.CoolBar bar = new CoolBar(parent, 0);

Par défaut, la méthode de nettoyage est présumée être close(). Une méthode de nettoyage qui prend un argument ne peut pas être appelée via @Cleanup.

Vanille Java

import java.io.*;

public class CleanupExample {
  public static void main(String[] args) throws IOException {
    InputStream in = new FileInputStream(args[0]);
    try {
      OutputStream out = new FileOutputStream(args[1]);
      try {
        byte[] b = new byte[10000];
        while (true) {
          int r = in.read(b);
          if (r == -1) break;
          out.write(b, 0, r);
        }
      } finally {
        out.close();
      }
    } finally {
      in.close();
    }
  }
}

Avec Lombok

import lombok.Cleanup;
import java.io.*;

public class CleanupExample {
  public static void main(String[] args) throws IOException {
    @Cleanup InputStream in = new FileInputStream(args[0]);
    @Cleanup OutputStream out = new FileOutputStream(args[1]);
    byte[] b = new byte[10000];
    while (true) {
      int r = in.read(b);
      if (r == -1) break;
      out.write(b, 0, r);
    }
  }
}

Dans java 8, vous pouvez utiliser try. Veuillez vous référer à la page suivante. http://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html

Veuillez consulter cette liste de mots-clés Java .

1. Le usingmot-clé ne fait malheureusement pas partie de la liste.
2. Et il n'y a pas non plus d'équivalence du usingmot-clé C # avec un autre mot-clé comme pour l'instant en Java.

Pour imiter un tel "using"comportement, vous devrez utiliser un try...catch...finallybloc dans lequel vous disposerez des ressources qu'il contient finally.

Les blocs ARM , de la pièce du projet, seront en Java 7. Cette fonctionnalité est destinée à apporter à Java des fonctionnalités similaires à celles du .Net en utilisant la syntaxe.

Pour répondre à la question concernant la limitation de la portée d'une variable, au lieu de parler de la fermeture / suppression automatique des variables.

En Java, vous pouvez définir des étendues fermées et anonymes en utilisant des accolades. C'est extrêmement simple.

{
   AwesomeClass hooray = new AwesomeClass()
   // Great code
}

La variable hoorayn'est disponible que dans cette étendue, et non en dehors.

Cela peut être utile si vous avez des variables répétitives qui ne sont que temporaires.

Par exemple, chacun avec index. Tout comme la itemvariable est fermée sur la boucle for (c'est-à-dire qu'elle n'est disponible qu'à l'intérieur), la indexvariable est fermée sur la portée anonyme.

// first loop
{
    Integer index = -1;
    for (Object item : things) {index += 1;
        // ... item, index
    }
}

// second loop
{
    Integer index = -1;
    for (Object item : stuff) {index += 1;
        // ... item, index
    }
}

J'utilise également cela parfois si vous n'avez pas de boucle for pour fournir une portée de variable, mais que vous souhaitez utiliser des noms de variables génériques.

{
    User user = new User();
    user.setId(0);
    user.setName("Andy Green");
    user.setEmail("andygreen@gmail.com");
    users.add(user);
}

{
    User user = new User();
    user.setId(1);
    user.setName("Rachel Blue");
    user.setEmail("rachelblue@gmail.com");
    users.add(user);
}