Comment vérifier si un fichier est lisible?

Je suis en train d'écrire la version 6 de Java application et je dois vérifier si un fichier est lisible. Toutefois, sur Windows canRead() retourne toujours true. Donc, je vois que probablement, la seule solution pourrait être une solution native basée sur WINAPI et à l'écrit dans JNA/JNI.

Mais, il y a un autre problème, car il est difficile de trouver une fonction simple en WINAPI qui permettrait le retour d'informations sur l'accès à un fichier. J'ai trouvé GetNamedSecurityInfo ou GetSecurityInfo mais je ne suis pas une avancée WINAPI programmeur et ils sont trop compliqués pour moi dans le cadre de JNA/JNI. Toutes les idées sur la façon de traiter ce problème?

Vous pouvez essayer de lire le fichier et voir si vous obtenez un message d'erreur.
Connexes: bugs.sun.com/bugdatabase/view_bug.do?bug_id=6203387
L'exactitude est plus importante que la vitesse. 😉 Vous n'avez pas besoin de lire le fichier en entier, il suffit de l'ouvrir et de le fermer.
En termes d'opérations sur le disque dur, le travail nécessaire pour ouvrir et fermer un fichier qui est un peu la même chose que le travail requis pour lire le descripteur de sécurité associées au fichier. Je serais surpris si la performance n'était pas similaire.
Au contraire. Il est d'essayer de prédire l'avenir, comme ce qui n'est pas la "meilleure pratique".

OriginalL'auteur peter | 2012-08-10

  1. 8

    Essayez d'utiliser le code suivant

    public boolean checkFileCanRead(File file){
    try {
        FileReader fileReader = new FileReader(file.getAbsolutePath());
        fileReader.read();
        fileReader.close();
    } catch (Exception e) {
        LOGGER.debug("Exception when checking if file could be read with message:"+e.getMessage(), e);
        return false;
    }
    return true;
}
    Je n'aime pas exception pour l'utilisation à la place de structure de contrôle, mais pas mal la solution de contournement dans ce cas ...
    L'existence et la lisibilité vérifier ici sont tout simplement redondants frais généraux. De toute évidence, ils ont lieu de toute façon lorsque vous essayez d'ouvrir le fichier: il est inutile d'en faire tout ce qui est deux fois.

    OriginalL'auteur Roman C

  2. 5

    Vous pouvez utiliser FilePermission et AccessController plus difficile de cette façon : 

    FilePermission fp = new FilePermission("file.txt", "read");
AccessController.checkPermission(fp);

    Si un accès demandé est autorisé, checkPermission revient tranquillement. Si
    refusé, une AccessControlException est levée.

    C'est que par rapport à la Sécurité ou à l'environnement de système d'exploitation ? Si cela est pertinent pour le dernier c'est plutôt sympa.
    Il jette toujours exception à la règle.
    Cela signifie qui n'est pas lisible.
    Toujours moyen = pour les lisible et pas de fichiers lisibles. Quelqu'un a eu le même problème: stackoverflow.com/questions/11739183/...
    Cela ne permet pas de vérifier si un fichier est lisible. Il vérifie si le cours d'exécution du code Java est a un .la politique de fichier d'entrée qui permet au Gestionnaire de Sécurité Java octroi d'une autorisation de essayer pour lire le fichier: il réussira toujours si il n'y a pas de Gestionnaire de Sécurité installé, qui pourrait bien être le cas ici. Si le système d'exploitation va permettre de l'ouvrir est complètement distincte de la matière. Pas de réponse.

    OriginalL'auteur aleroot

  3. 4

    Java 7 a introduit le Files.isReadable méthode statique, il accepte un fichier Path et renvoie vrai si fichier existe et est lisible, sinon faux.

    À partir de la documentation

    Teste si un fichier est lisible. Cette méthode vérifie qu'un fichier existe
    et que cette machine virtuelle Java a les privilèges appropriés qui permettraient de
    lui permettre d'ouvrir le fichier pour le lire. En fonction de la mise en œuvre, ce
    la méthode peut exiger de lire le fichier des autorisations, des listes de contrôle d'accès, ou
    d'autres attributs de fichier afin de vérifier l'effectivité de l'accès au fichier.
    Par conséquent, cette méthode ne peut pas être atomique à l'égard des autres fichiers
    les opérations du système.

    À noter que le résultat de cette méthode est immédiatement à jour, il est
    pas de garantie qu'une nouvelle tentative d'ouvrir le fichier pour la lecture
    réussir (ou même qu'il permettra d'accéder au même fichier). Les soins doivent être prises
    lors de l'utilisation de cette méthode dans la sécurité des applications sensibles.

    Exemple:

    File file = new File("/path/to/file");
Files.isReadable(file.toPath()); //true if `/path/to/file` is readable
    +1 pour en indiquant clairement la réponse est immédiatement inutile. Pour tous ceux qui veulent faire quelque chose comme ça, comme tous les autres "j'ai besoin de vérifier si je peux lire le fichier avant que je l'ai lu" les réponses, cette réponse est un TOCTOU bug.
    va utiliser pour aider à s'assurer que l'utilisateur a entré un résultat valide chemin, C'est différent et une vision fondamentalement différente but que de vérifier pour voir si le fichier est lisible (accessible en écriture dans votre cas?). Vous êtes à la validation d'un chemin d'accès.
    Vous avez raison, je ne vois pas mon commentaire comme utile donc je l'ai supprimé.
    Je pensais que c'était un très utile commentaire - vous ont été à l'aide de isReadable() de manière innovante pour valider un nom de chemin d'accès, où la "lisible" le cadre était vraiment hors de propos.

    OriginalL'auteur svarog

  4. 3

    Vous avez seulement besoin de savoir si c'est lisible si vous vous apprêtez à lire. Donc, il suffit d'essayer de le lire, quand vous en avez besoin, et de traiter avec elle si vous ne pouvez pas. La meilleure façon de tester la disponibilité des ressources est juste pour essayer de l'utiliser et de le traiter avec des exceptions ou des erreurs à mesure qu'ils surviennent. Ne pas essayer de prédire l'avenir.

    Donc, la meilleure façon est de ne pas essayer de lire le fichier d'attribut, est d'essayer de le lire et si vous obtenez une exception le fichier n'est pas lisible ... Il ne me semble pas la meilleure solution
    Il ne me semble pas la meilleure solution, pourquoi? Par rapport à quoi?
    C'est juste pas de sens dogme, d'autant que vous avez clairement aucune idée de ce que la "meilleure solution" est en fait: sinon vous ne seriez pas poser ici. Si l'interception d'une exception offre à l'état que vous cherchez, c'est ce que vous utilisez. Ce que j'ai recommandé ici n'est pas une "solution de contournement", c'est la technique correcte. Tout le reste est répétitif et redondant, ou autre chose incorrecte, et certainement une solution de contournement.
    Alors, quel est votre "meilleures pratiques" alternatives? De quoi êtes-vous le comparant ? Pourquoi continuez-vous à éluder la question? Et quelle est votre alternative à la capture de dire EOFException lors de l'appel de dire DataInputStream.readUTF()?` ou ObjectInputStrream.readObject()?
    Qui souffre de tous les problèmes que j'ai déjà signalé ci-dessus: en résumé, les fenêtres de synchronisation et de redondance, c'est à dire l'inefficacité. Et vous n'avez pas répondu à mes autres questions. Il semble que ces discussions ont toujours gio de la même façon: motivée de cas pris en charge par les faits est rejeté comme de simples "opinions", tandis qu'un non pris en charge aveugle application de la réception d'un dogme est présenté comme la "meilleure pratique". Ne pas investir trop lourdement dans la programmation de la mode. Lorsque vous avez été autour d'un peu plus de temps que vous vous rendrez compte qu'il y en aura un autre dans une minute, et ils sont souvent incompatibles.

    OriginalL'auteur user207421

  5. 0

    Il peut être tout à fait raisonnables pour vérifier l'accessibilité de la ressource (lisibilité d'un fichier dans ce cas) longtemps avant l'utilisation de cette ressource.

    Imaginer une application serveur qui va utiliser un sous-composant qui va lire un fichier en particulier, dans certaines circonstances, quelques temps plus tard. Il peut être utile de vérifier la lisibilité du fichier au démarrage du serveur et de les AVERTIR si elle n'est pas lisible. Alors quelqu'un peut corriger la situation (rendre le fichier lisible, n'importe quoi) avant que les circonstances de la cause de la sous-composant pour essayer de lire ce fichier.

    Bien sûr, cette avance n'est pas un substitut à une bonne gestion des exceptions dans le sous-composant (il est très possible que le fichier est lisible au début, mais devient illisible plus tard).

    De sorte que la question sur la pré-vérification est parfaitement valable je pense.

    Comme pour la méthode de vérification de la ressource, essayez de faire quelque chose d'aussi semblable que possible à l'utilisation réelle. Si plus tard, le fichier sera lu, puis essayez de le lire!

    Comme pour les Fichiers.isReadable(...): il n'y a aucune garantie que le fournisseur de système de fichiers sous Fichiers.isReadable(...) n'est pas buggé. Il peut renvoyer la valeur true, puis lever une exception si le fichier est lu.

    Bien sûr, si vous écrivez une application gestionnaire de fichiers, puis utiliser des Fichiers.isReadable(...), mais je suppose que ce n'est pas le cas.

    OriginalL'auteur riskop