🚀 Jak zainstalować Javę z apt-get na Ubuntu 20.04

Java stanowi fundamentalną technologię dla wielu aplikacji serwerowych, narzędzi programistycznych i systemów enterprise. Instalacja odpowiedniej wersji Javy w systemie Ubuntu 20.04 to często jeden z pierwszych kroków przy konfiguracji środowiska deweloperskiego lub hostingowego. Ten przewodnik przeprowadzi Cię przez proces instalacji różnych implementacji Javy z wykorzystaniem systemowego menedżera pakietów apt-get.

⚡ Ekspresowe Podsumowanie:

  1. Dostępne opcje: OpenJDK (domyślna, open source) i Oracle Java (komercyjna) z wieloma wersjami do wyboru
  2. Podstawowa instalacja OpenJDK 11: sudo apt update && sudo apt install openjdk-11-jdk
  3. Weryfikacja instalacji: java -version i javac -version potwierdzą poprawność instalacji
  4. Zarządzanie wersjami: Narzędzie update-alternatives umożliwia łatwe przełączanie między zainstalowanymi wersjami

🗺️ Spis Treści - Twoja Mapa Drogowa

📚 Wprowadzenie do Javy i dostępnych implementacji

Przed przystąpieniem do instalacji, warto zrozumieć podstawowe pojęcia związane z Javą oraz dostępne warianty i implementacje tej technologii.

Czym jest Java?

Java to:

  • Język programowania - obiektowy język o szerokiej gamie zastosowań
  • Platforma uruchomieniowa - środowisko umożliwiające uruchamianie aplikacji napisanych w Javie
  • Ekosystem narzędzi i bibliotek - bogaty zbiór frameworków, bibliotek i rozwiązań

Kluczową zaletą Javy jest jej przenośność - programy napisane w tym języku mogą być uruchamiane na dowolnym systemie operacyjnym posiadającym maszynę wirtualną Javy (JVM).

Komponenty Javy

Instalując Javę, możesz wybrać między dwoma głównymi komponentami:

  • JRE (Java Runtime Environment) - Środowisko uruchomieniowe wymagane do uruchamiania aplikacji Java

    • Zawiera maszynę wirtualną Javy (JVM)
    • Zawiera biblioteki standardowe
    • Nie zawiera narzędzi programistycznych

  • JDK (Java Development Kit) - Pełne środowisko programistyczne

    • Zawiera wszystko, co JRE
    • Dodatkowo zawiera kompilator (javac), debugger i inne narzędzia deweloperskie
    • Niezbędne, jeśli zamierzasz tworzyć aplikacje w Javie

✨ Pro Tip: Jeśli planujesz tylko uruchamiać aplikacje Java, wystarczy JRE. Jeśli jednak będziesz programować lub kompilować kod, wybierz JDK, który zawiera również JRE.

Dostępne implementacje

Na Ubuntu 20.04 możesz zainstalować różne implementacje Javy:

Implementacja Licencja Zalety Wady
OpenJDK Open Source (GPLv2 + Classpath) Darmowa, dobrze zintegrowana z systemem, regularnie aktualizowana Może mieć niewielkie różnice w porównaniu do Oracle Java
Oracle Java Komercyjna (bezpłatna dla użytku osobistego) Oficjalna implementacja, pełna zgodność Ograniczenia licencyjne dla zastosowań komercyjnych
Eclipse Adoptium (dawniej AdoptOpenJDK) Open Source Wysokiej jakości buildy OpenJDK, długoterminowe wsparcie Wymaga dodatkowego repozytorium
Amazon Corretto Open Source Optymalizacja pod kątem chmury AWS Wymaga manualnej instalacji

✨ Pro Tip: Dla większości zastosowań OpenJDK jest rekomendowanym wyborem ze względu na łatwość instalacji, kompatybilność z Ubuntu i brak ograniczeń licencyjnych dla zastosowań komercyjnych.

Wersje Javy

Java ewoluowała przez lata, a każda wersja wprowadzała nowe funkcje:

  • Java 8 (LTS) - Wprowadzenie wyrażeń lambda, strumieni, nowa data/czas API
  • Java 11 (LTS) - Usprawnienia w zarządzaniu pamięcią, nowe API HTTP
  • Java 17 (LTS) - Sealed classes, pattern matching, ulepszone zarządzanie pamięcią
  • Java 21 (LTS) - Virtual threads, pattern matching dla switch, sequential collections

Uwaga: Wersje LTS (Long Term Support) to wydania z długoterminowym wsparciem, zalecane dla zastosowań produkcyjnych. Na Ubuntu 20.04, OpenJDK 11 jest domyślną wersją, ale możesz zainstalować również inne, w tym OpenJDK 8 i nowsze wersje.

💡 Instalacja OpenJDK za pomocą apt-get

OpenJDK to najprostsza i zalecana implementacja Javy dla większości użytkowników Ubuntu. Jest dostępna bezpośrednio w oficjalnych repozytoriach i oferuje kilka wersji do wyboru.

Sprawdzenie dostępnych wersji

Przed instalacją warto sprawdzić, jakie wersje OpenJDK są dostępne w repozytoriach:

apt search openjdk

Wynik tego polecenia zawiera listę dostępnych pakietów, w tym różne wersje JDK i JRE.

Instalacja OpenJDK 11 (domyślna dla Ubuntu 20.04)

Aby zainstalować OpenJDK 11 JDK (zawierające narzędzia deweloperskie):

sudo apt update
sudo apt install openjdk-11-jdk

Jeśli potrzebujesz tylko środowiska uruchomieniowego (JRE):

sudo apt update
sudo apt install openjdk-11-jre

Instalacja alternatywnych wersji OpenJDK

OpenJDK 8

sudo apt update
sudo apt install openjdk-8-jdk

OpenJDK 17 (z dodatkowego repozytorium)

OpenJDK 17 nie jest domyślnie dostępne w Ubuntu 20.04, ale można je zainstalować dodając odpowiednie repozytorium:

sudo add-apt-repository ppa:openjdk-r/ppa
sudo apt update
sudo apt install openjdk-17-jdk

✨ Pro Tip: Możesz zainstalować równolegle kilka wersji Javy i przełączać się między nimi w zależności od potrzeb konkretnych aplikacji. Ubuntu posiada wbudowany system zarządzania alternatywnymi wersjami, który omówimy w dalszej części artykułu.

Weryfikacja instalacji

Po instalacji warto zweryfikować, czy Java została poprawnie zainstalowana:

java -version

Przykładowy wynik dla OpenJDK 11:

openjdk version "11.0.11" 2021-04-20
OpenJDK Runtime Environment (build 11.0.11+9-Ubuntu-0ubuntu2.20.04)
OpenJDK 64-Bit Server VM (build 11.0.11+9-Ubuntu-0ubuntu2.20.04, mixed mode, sharing)

Sprawdź także wersję kompilatora (jeśli zainstalowałeś JDK):

javac -version

🛠️ Konfiguracja zmiennych środowiskowych

Po instalacji warto skonfigurować zmienne środowiskowe, które są używane przez Javę i aplikacje bazujące na tej technologii.

Zmienna JAVA_HOME

Wiele aplikacji korzysta ze zmiennej środowiskowej JAVA_HOME, która wskazuje na katalog instalacyjny Javy. Aby ją skonfigurować:

  1. Najpierw zlokalizuj katalog instalacyjny Javy:
update-alternatives --config java

To polecenie pokaże ścieżkę do zainstalowanej Javy, np. /usr/lib/jvm/java-11-openjdk-amd64/bin/java. Ścieżką do JAVA_HOME będzie katalog nadrzędny dla /bin/java, czyli w tym przypadku: /usr/lib/jvm/java-11-openjdk-amd64.

  1. Dodaj zmienną JAVA_HOME do pliku /etc/environment:
sudo echo "JAVA_HOME=\"/usr/lib/jvm/java-11-openjdk-amd64\"" >> /etc/environment
  1. Załaduj nową zmienną do bieżącej sesji:
source /etc/environment
  1. Sprawdź, czy zmienna została poprawnie ustawiona:
echo $JAVA_HOME

Dodatkowe zmienne środowiskowe

Dla niektórych zastosowań przydatne mogą być również inne zmienne:

  • JRE_HOME - wskazująca na katalog JRE (zazwyczaj $JAVA_HOME/jre)
  • PATH - powinna zawierać ścieżkę do katalogu z binariami Javy ($JAVA_HOME/bin)

Uwaga: W Ubuntu zmienne środowiskowe dla wszystkich użytkowników najlepiej definiować w pliku /etc/environment lub w skryptach w katalogu /etc/profile.d/. Dla pojedynczego użytkownika można je zdefiniować w pliku ~/.bashrc lub ~/.profile.

🔀 Zarządzanie wieloma wersjami Javy

Jedną z zalet systemu Ubuntu jest łatwość zarządzania wieloma zainstalowanymi wersjami Javy i przełączania się między nimi.

System alternatyw w Ubuntu

Ubuntu używa mechanizmu update-alternatives do zarządzania wieloma wersjami tego samego oprogramowania. Pozwala to na łatwe przełączanie między różnymi implementacjami Javy.

Przełączanie między wersjami Javy

Aby przełączyć domyślną wersję Javy:

sudo update-alternatives --config java

System wyświetli listę zainstalowanych wersji Javy i poprosi o wybór domyślnej:

There are 2 choices for the alternative java (providing /usr/bin/java).

  Selection    Path                                            Priority   Status
------------------------------------------------------------
  0            /usr/lib/jvm/java-11-openjdk-amd64/bin/java      1111      auto mode
  1            /usr/lib/jvm/java-11-openjdk-amd64/bin/java      1111      manual mode
* 2            /usr/lib/jvm/java-8-openjdk-amd64/bin/java       1081      manual mode

Press <enter> to keep the current choice[*], or type selection number:

Podobnie możesz skonfigurować domyślny kompilator Java:

sudo update-alternatives --config javac

Oraz inne narzędzia Java, takie jak javadoc, jar, itd.

✨ Pro Tip: W skryptach lub poleceniach można jawnie określić, której wersji Javy chcemy użyć, podając pełną ścieżkę do binariów, np. /usr/lib/jvm/java-8-openjdk-amd64/bin/java -jar aplikacja.jar.

Automatyczne przełączanie dla konkretnych projektów

Dla deweloperów pracujących z wieloma projektami wymagającymi różnych wersji Javy, przydatne mogą być narzędzia takie jak:

  • SDKMAN! - narzędzie do zarządzania równoległymi wersjami SDK dla JVM
  • jEnv - lżejsze narzędzie do zarządzania wersjami Javy na poziomie katalogu

Instalacja SDKMAN!:

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

Z SDKMAN! możesz łatwo instalować i przełączać się między różnymi wersjami Javy:

sdk list java               # lista dostępnych wersji
sdk install java 11.0.11.hs-adpt  # instalacja konkretnej wersji
sdk use java 11.0.11.hs-adpt      # tymczasowe przełączenie
sdk default java 11.0.11.hs-adpt  # ustawienie domyślnej wersji

🔒 Instalacja Oracle Java (alternatywne podejście)

Oracle Java jest oficjalną implementacją od twórców języka. W przeciwieństwie do OpenJDK, nie jest dostępna bezpośrednio w repozytoriach Ubuntu ze względu na ograniczenia licencyjne.

Uwaga: Od Java 11, Oracle wprowadził nowy model licencjonowania. Oracle JDK jest darmowy do użytku osobistego, deweloperskiego i do prototypowania, ale komercyjne zastosowania produkcyjne mogą wymagać płatnej licencji. Zawsze sprawdź aktualne warunki licencji na stronie Oracle przed wdrożeniem produkcyjnym.

Instalacja manualna

  1. Pobierz pakiet instalacyjny z oficjalnej strony Oracle: https://www.oracle.com/java/technologies/javase-downloads.html

  2. Rozpakuj pobrany archiwum do wybranej lokalizacji, np. /opt:

sudo mkdir -p /opt/java
sudo tar -zxf jdk-11.0.11_linux-x64_bin.tar.gz -C /opt/java
  1. Dodaj nową wersję Javy do systemu alternatyw:
sudo update-alternatives --install /usr/bin/java java /opt/java/jdk-11.0.11/bin/java 1
sudo update-alternatives --install /usr/bin/javac javac /opt/java/jdk-11.0.11/bin/javac 1
  1. Wybierz nową wersję jako domyślną:
sudo update-alternatives --config java
  1. Skonfiguruj zmienną JAVA_HOME:
echo 'JAVA_HOME="/opt/java/jdk-11.0.11"' | sudo tee -a /etc/environment
source /etc/environment

Alternatywne podejście: repozytorium zewnętrzne

Istnieją również nieoficjalne repozytoria zawierające Oracle Java. Jednak ze względu na politykę licencyjną Oracle, ich użycie może być problematyczne i nie jest oficjalnie rekomendowane.

🚫 Rozwiązywanie typowych problemów

Podczas instalacji i konfiguracji Javy mogą pojawić się różne problemy. Oto rozwiązania najczęstszych z nich.

Problem: Brak Javy po instalacji

Jeśli po instalacji polecenie java -version nie działa lub pokazuje błąd:

  1. Sprawdź, czy pakiet został poprawnie zainstalowany:
dpkg -l | grep openjdk
  1. Jeśli pakiet jest zainstalowany, sprawdź konfigurację alternatyw:
sudo update-alternatives --config java
  1. Upewnij się, że katalog z binariami Javy jest w zmiennej PATH:
echo $PATH

Problem: Błędy kompilacji związane z wersją Javy

Jeśli projekt wymaga konkretnej wersji Javy, a kompilacja kończy się błędami:

  1. Sprawdź wymaganą wersję Javy dla projektu
  2. Zainstaluj odpowiednią wersję
  3. Przełącz się na tę wersję za pomocą update-alternatives lub SDKMAN!
  4. Ustaw odpowiednią zmienną JAVA_HOME

Problem: Aplikacja zgłasza błąd "JAVA_HOME is not set"

Gdy aplikacja wymaga zmiennej JAVA_HOME, a nie jest ona ustawiona:

  1. Ustaw zmienną ręcznie:
export JAVA_HOME=$(readlink -f /usr/bin/java | sed "s:/bin/java::")
  1. Dodaj powyższą linię do pliku ~/.bashrc, aby była dostępna przy każdym logowaniu
  2. Zweryfikuj ustawienie:
echo $JAVA_HOME
ls -la $JAVA_HOME

Problem: Konflikt wersji Javy

Gdy różne aplikacje wymagają różnych wersji Javy:

  1. Zainstaluj wszystkie wymagane wersje
  2. Używaj skryptów opakowujących, które ustawiają odpowiednie zmienne środowiskowe przed uruchomieniem konkretnej aplikacji
  3. Rozważ użycie narzędzi takich jak Docker do izolacji aplikacji wymagających różnych środowisk

🧹 Odinstalowanie Javy

Jeśli potrzebujesz usunąć zainstalowaną wersję Javy, możesz to zrobić za pomocą apt:

Odinstalowanie OpenJDK

# Sprawdź zainstalowane pakiety OpenJDK
dpkg --list | grep -i openjdk

# Usuń konkretny pakiet
sudo apt-get remove --purge openjdk-11-jdk
sudo apt-get remove --purge openjdk-11-jre

# Usuń osierocone pakiety
sudo apt-get autoremove

# Usuń pozostałe pliki konfiguracyjne
sudo apt-get clean

Usunięcie ręcznie zainstalowanej Javy

Jeśli Java została zainstalowana ręcznie:

  1. Usuń wpisy z systemu alternatyw:
sudo update-alternatives --remove java /opt/java/jdk-11.0.11/bin/java
sudo update-alternatives --remove javac /opt/java/jdk-11.0.11/bin/javac
  1. Usuń katalog instalacyjny:
sudo rm -rf /opt/java/jdk-11.0.11
  1. Usuń lub zaktualizuj zmienne środowiskowe w /etc/environment lub innych plikach konfiguracyjnych.

📈 Najlepsze praktyki i zalecenia

Na zakończenie warto podsumować kilka najlepszych praktyk dotyczących instalacji i zarządzania Javą w systemie Ubuntu.

Zalecenia dotyczące wyboru wersji

  • Dla aplikacji produkcyjnych - wybieraj wersje LTS (8, 11, 17, 21)
  • Dla nowych projektów - używaj najnowszej dostępnej wersji LTS
  • Dla projektów legacy - dostosuj wersję Javy do wymagań projektu

Strategie aktualizacji

  • Regularnie instaluj aktualizacje bezpieczeństwa:
sudo apt update && sudo apt upgrade
  • Przed aktualizacją do nowej głównej wersji Javy:
    • Przetestuj aplikację z nową wersją w środowisku testowym
    • Sprawdź kompatybilność wszystkich używanych bibliotek
    • Przygotuj plan powrotu w przypadku problemów

Zarządzanie pamięcią

Java VM oferuje różne opcje konfiguracji pamięci, które mogą być dostosowane do konkretnych potrzeb:

# Przykład ustawienia maksymalnej wielkości sterty
java -Xmx2G -jar aplikacja.jar

# Przykład ustawienia początkowej i maksymalnej wielkości sterty
java -Xms1G -Xmx2G -jar aplikacja.jar

Dostosowanie tych parametrów może znacząco wpłynąć na wydajność aplikacji, szczególnie na serwerach z ograniczonymi zasobami.

Narzędzia monitorowania

Warto zapoznać się z narzędziami do monitorowania aplikacji Java:

  • jconsole - graficzne narzędzie do monitorowania i zarządzania aplikacjami Java
  • jstat - narzędzie do monitorowania statystyk JVM
  • jmap - narzędzie do tworzenia zrzutów pamięci
  • VisualVM - zaawansowane narzędzie do analizy wydajności i diagnostyki

🏁 Podsumowanie - Gotowy na programowanie w Javie

Instalacja Javy na Ubuntu 20.04 za pomocą apt-get jest prostym procesem, który daje dostęp do potężnego ekosystemu aplikacji i narzędzi programistycznych. Wybór między OpenJDK a Oracle Java zależy od Twoich konkretnych potrzeb, ale dla większości zastosowań OpenJDK będzie wystarczającym i bezproblemowym rozwiązaniem.

Kluczowe punkty:

  • OpenJDK jest rekomendowaną implementacją dla większości zastosowań
  • Możesz łatwo instalować i zarządzać wieloma wersjami Javy za pomocą system alternatyw Ubuntu
  • Poprawna konfiguracja zmiennych środowiskowych, szczególnie JAVA_HOME, jest istotna dla wielu aplikacji
  • Narzędzia takie jak SDKMAN! mogą ułatwić pracę z wieloma wersjami Javy

Dzięki Javie masz dostęp do ogromnego ekosystemu bibliotek, frameworków i narzędzi, które mogą być wykorzystane do tworzenia wszechstronnych aplikacji - od prostych programów konsolowych po rozbudowane systemy enterprise.

🚀 Potrzebujesz hostingu gotowego na Javę?

Sprawdź nasze rozwiązania hostingowe zoptymalizowane pod aplikacje Java

Nasza infrastruktura serwerowa jest idealna dla aplikacji Java, oferując wysoką wydajność, stabilność i wsparcie dla różnych wersji środowiska uruchomieniowego.

❓ FAQ - Odpowiedzi na Twoje Pytania

Która wersja Javy jest najlepsza dla Ubuntu 20.04?
OpenJDK 11 jest domyślnie wspierana w Ubuntu 20.04 i jest rekomendowana dla większości zastosowań. Jeśli Twoja aplikacja wymaga konkretnej wersji, możesz zainstalować również OpenJDK 8 lub nowsze wersje.

Czy mogę zainstalować zarówno OpenJDK, jak i Oracle Java?
Tak, możesz zainstalować obie implementacje równolegle i przełączać się między nimi za pomocą systemu alternatyw Ubuntu (update-alternatives).

Jak sprawdzić, która wersja Javy jest aktualnie używana?
Użyj polecenia java -version, aby sprawdzić aktualnie używaną wersję środowiska uruchomieniowego, i javac -version, aby sprawdzić wersję kompilatora.

Czy JRE zawiera JDK, czy na odwrót?
JDK (Java Development Kit) zawiera JRE (Java Runtime Environment) oraz dodatkowe narzędzia deweloperskie. JRE samo w sobie nie zawiera tych narzędzi i służy tylko do uruchamiania aplikacji Java.

Jak rozwiązać problem "Could not create the Java virtual machine"?
Ten błąd często wynika z niewystarczającej ilości pamięci lub niewłaściwych parametrów JVM. Spróbuj dostosować parametry -Xmx (maksymalna wielkość sterty) i -Xms (początkowa wielkość sterty) do dostępnych zasobów systemowych.

Kategorie i tagi

Programowanie Linux

Czy ten artykuł był pomocny?

Wróć do listy wpisów

Twoja strona WordPress działa wolno?

Sprawdź nasz hosting WordPress z ultraszybkimi dyskami NVMe i konfiguracją serwera zoptymalizowaną pod kątem wydajności. Doświadcz różnicy już dziś!

Sprawdź ofertę hostingu
30-dniowa gwarancja zwrotu pieniędzy