Otoczenie systemowe Java

Czasem zachodzi potrzeba przekazania informacji do programu w momencie jego uruchomienia (linia poleceń), bądź sięgnięcia z programu do zasobów środowiska systemu operacyjnego celem sprawdzenia np.: gdzie znajduje się katalog użytkownika, bądź w jakim systemie operacyjnym uruchomiony jest program. Tutaj przydaje się poniżej zamieszczona wiedza.

Pobieranie wartości zmiennych środowiskowych

Celem pobrania zmiennych środowiskowych możemy zastosować metodę .getProperty() obiektu System tak jak w poniższym przykładzie:

public class PoleceniaSystemowe {

    
    public static void main(String[] args) {
        System.out.println(System.getProperty("user.dir"));   
        System.out.println(System.getProperty("user.home"));
        System.out.println(System.getProperty("os.version"));
        System.out.println(System.getProperty("os.name"));
    }
    
}

Jak widać po efektach działania wyświetla informacje o systemie, które możemy wykorzystać w naszym programie celem dostosowania go do konkretnego środowiska.

Lista ciągów (kluczy) dla metody getProperty wygląda następująco:

• os.version : wersja systemu operacyjnego
• os.name : nazwa systemu operacyjnego
• os.arch : architektura systemu operacyjnego
• java.compiler : nazwa używanego kompilatora
• java.ext.dirs : dostępne ścieżki rozszerzeń
• java.library.path : ścieżki dostępu do bibliotek
• path.separator : separator ścieżki (w Windows to zazwyczaj “;”)
• file.separator : separator ścieżki dostępu do pliku (w Windows to zazwyczaj “\”)
• user.dir : aktywna ścieżka (aktywny katalog)
• user.name : nazwa konta użytkownika
• java.vm.version : wersja implementacji JVM
• java.vm.name : nazwa implementacji JVM
• java.home : katalog w którym zainstalowano Java
• java.runtime.version : wersja JVM

Przekazywanie parametrów do programu

Czasem chcielibyśmy uruchomić program i od razu w sposób nie interaktywny (odpytywany), a wsadowy (batch) podać dane na których program mógłby pracować i wykonać niezbędne operacje.

Inicjując pracę naszego programu z linii poleceń moglibyśmy go uruchomić wpisując:

java.exe -jar PoleceniaSystemowe.jar Ala="Ala" ma=true kota=1

Pracując jednakże w środowisku programistycznym NetBeans musimy zasymulować taki sposób uruchamiania w konfiguracji.

Następnie, upewniając się, że mamy wybrany właściwy plik z “Main Class” wpisujemy argumenty z jakimi ma być uruchamiany:

Użycie tego w programie jest już banalnie proste. Pewnie zauważyliście konstrukcję metody main, gdzie w jej argumentach jest umieszczona tablica Stringów?! Jeśli tak, to możecie się już domyślić, że w tej tablicy umieszczone są wszystkie argumenty podane w linii uruchomienia naszego programu rozdzielone delimiterem w postaci spacji ” “. Przykład takiego programu sprawdzającego argumenty z linii poleceń i jego działania jest umieszczony poniżej:

Listing zawartości katalogu plików

Często także potrzeba sprawdzić jakie pliki istnieją w bieżącym katalogu roboczym np. w celu wybrania jednego z nich do odczytu. Można skorzystać z metody .list() klasy File aby zbudować tablicę Stringów zawierającą nazwy plików.

void listuj(String nazwa)  {
   String[] pliki;
   File file = new File(nazwa);
   pliki = file.list();
   for(String s:pliki)  System.out.println(s);
                           }

Czasem jednak ta informacja jest niewystarczająca. Wtedy dobrze jest wiedzieć w jaki sposób można uruchomić polecenie systemowe. Taka operacja wymaga powiązania kilku procesów ze sobą, ale nie jest niczym szczególnym. Przykład programu uruchamiającego polecenie systemowe dir jest zamieszczony poniżej:

import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
public class PoleceniaSystemowe {

    public static void main(String[] tabA) {        
        
        
        Runtime t=Runtime.getRuntime();   // <-- przypisujemy uchwyt egzekucyjny 
                                          // obecnego procesu (działania programu)
       
        try {
            InputStream is=t.exec("cmd /c dir").getInputStream();  // <-- przechwytujemy wynik 
                                                                   // wykonania komendy (exec)
                                                                   // jako strumień wejściowy
            Scanner sc=new Scanner(is);   // <-- strumień wejściowy terminujemy 
                                          //  w obiekcie klasy Scanner
            while (sc.hasNextLine()) System.out.println(sc.nextLine());  // <-- czytamy całą 
                                                                         // (i wypisujemy)
                                                                         // zawartość bufora           
            }
        catch (IOException ex) { System.err.println("Wystąpił błąd operacji...");}
    }   
}

W wyniku działania powyższego programu uzyskujemy:

W ten sam sposób możemy uruchamiać inne polecenia systemowe, a wynik ich działania odbierać jak wyżej.

Kod wyjścia z programu

Standardowo, po linii polityki twórców języka Java, kodem wyjścia z programu jest kod “0” – czyli wyjście bez błędu. Tym niemniej czasem (szczególnie przy przetwarzaniu typu łańcuchowego¹kiedy jeden program uruchamia kolejny, a status jego zakończenia zwracany jest właśnie za pomocą kodu wyjścia) jest ważne, aby program pomimo, że zakończy się bez błędu, zwrócił oczekiwaną wartość wyjścia. Można tego dokonać na dwa sposoby:

import java.lang.Runtime;
public class KodWyjscia {

    public static void main(String[] args) {        
        //Korzystając z klasy Runtime
        Runtime t=Runtime.getRuntime();
        t.exit(201);
    }   
}

public class KodWyjscia {

    public static void main(String[] args) {        
        //Korzystając z metody exit() obiektu System
        System.exit(203);
    }   
}

Wtedy program zakończy się z sztucznie zgłoszonym błędem, którego kod może nieść ważną informację do programu nadrzędnego z którego uprzednio nasz program został uruchomiony.