Maak een symbolische link met Java
1. Overzicht
In deze zelfstudie onderzoeken we verschillende manieren om een symbolische koppeling in Java te maken met behulp van de NIO.2 API, en onderzoeken we de verschillen tussen harde en zachte bestandskoppelingen.
2. Harde versus zachte / symbolische koppelingen
Laten we eerst definiëren wat bestandskoppelingen zijn en wat hun verwachte gedrag is. Een bestandslink is een pointer die transparant verwijst naar een bestand dat is opgeslagen in het bestandssysteem.
Een veelvoorkomend misverstand is te denken dat een bestandslink een snelkoppeling is, dus laten we hun gedrag controleren:
- Een snelkoppeling is een gewoon bestand dat naar een doelbestand verwijst
- Zachte / symbolische link is een bestandsaanwijzer die zich gedraagt als het bestand waarnaar wordt gelinkt - als het doelbestand wordt verwijderd, is de link onbruikbaar
- Een harde koppeling is een bestandsaanwijzer die het bestand weerspiegelt waarnaar het verwijst, dus het is eigenlijk net een kloon. Als het doelbestand wordt verwijderd, is het linkbestand nog steeds geldig
De meeste besturingssystemen (Linux, Windows, Mac) ondersteunen al zachte / harde bestandskoppelingen, dus het zou geen probleem moeten zijn om erover te werken met behulp van de NIO API.
3. Links maken
Eerst moeten we een doelbestand maken om naar te linken, dus laten we wat gegevens in een bestand rangschikken:
openbaar pad createTextFile () genereert IOException {byte [] content = IntStream.range (0, 10000) .mapToObj (i -> i + System.lineSeparator ()) .reduce ("", String :: concat) .getBytes (StandardCharsets .UTF_8); Pad filePath = Paths.get ("", "target_link.txt"); Files.write (filePath, content, CREATE, TRUNCATE_EXISTING); return filePath; } Laten we een symbolische link naar een bestaand bestand maken en ervoor zorgen dat het gemaakte bestand een symbolische link is:
public void createSymbolicLink () gooit IOException {Path target = createTextFile (); Path link = Paths.get (".", "Symbolic_link.txt"); if (Files.exists (link)) {Files.delete (link); } Files.createSymbolicLink (link, doel); } Laten we vervolgens eens kijken naar het maken van een harde link:
public void createHardLink () gooit IOException {Path target = createTextFile (); Padlink = Paths.get (".", "Hard_link.txt"); if (Files.exists (link)) {Files.delete (link); } Files.createLink (link, doel); } Door de bestanden met hun verschillen op te sommen, kunnen we zien dat de bestandsgrootte van de zachte / symbolische link klein is, terwijl de harde link dezelfde ruimte gebruikt als het gekoppelde bestand:
48K doel_link.txt 48K harde_link.txt 4,0K symbolische_link.txt Om duidelijk te begrijpen wat de mogelijke uitzonderingen zijn die kunnen worden gegenereerd, laten we de gecontroleerde uitzonderingen op de bewerkingen bekijken:
- UnsupportedOperationException - wanneer de JVM geen bestandskoppelingen in een specifiek systeem ondersteunt
- FileAlreadyExistsException - als het linkbestand al bestaat, wordt de overschrijving standaard niet ondersteund
- IOException - wanneer er een IO-fout optreedt, bijv. ongeldig bestandspad
- Beveiligingsuitzondering - wanneer het linkbestand niet kan worden gemaakt of het doelbestand niet toegankelijk is vanwege beperkte bestandsrechten
4. Bewerkingen met koppelingen
Als we nu een bepaald bestandssysteem hebben met bestaande bestandskoppelingen, is het mogelijk om ze te identificeren en hun doelbestanden te tonen:
public void printLinkFiles (padpad) gooit IOException {try (DirectoryStream stream = Files.newDirectoryStream (pad)) {voor (padbestand: stream) {if (Files.isDirectory (bestand)) {printLinkFiles (bestand); } else if (Files.isSymbolicLink (bestand)) {System.out.format ("Bestandslink '% s' met doel '% s'% n", bestand, Files.readSymbolicLink (bestand)); }}}} Als we het uitvoeren in ons huidige pad:
printLinkFiles (Paths.get (".")); We zouden de output krijgen:
Bestandslink 'symbolic_link.txt' met als doel 'target_link.txt' Merk op dat hardlink-bestanden niet eenvoudig kunnen worden geïdentificeerd met NIO's APIzijn bewerkingen op laag niveau vereist om met dat soort bestanden te werken.
5. Conclusie
Dit artikel beschrijft de verschillende soorten bestandskoppelingen, hun verschil met snelkoppelingen en hoe u deze kunt maken en gebruiken met behulp van een pure Java API die werkt via de reguliere bestandssystemen op de markt.
De implementatie van deze voorbeelden en codefragmenten is te vinden op GitHub.
