Überblick über das Java-Ökosystem

Inhaltsverzeichnis

1. Einführung
2. JVM (Java Virtual Machine)
   • Architektur der JVM
     • Klassenlader
     • JVM-Speicher
       • Methodenbereich
       • Haufen
       • Stapelbereich
       • Programmzähler (PC) registrieren
       • Native Method Stack
     • Ausführungs-Engine
       • Dolmetscher
       • Just-In-Time (JIT)-Compiler
       • Müllsammler
3. JRE (Java Runtime Environment)
   • Schlüsselkomponenten der JRE
     • Ausführungsaufgaben
     • Klassenbibliotheken
     • Java Native Interface (JNI)
     • Sicherheitsmanager
4. JDK (Java Development Kit)
   • Kernfunktionen des JDK
     • javac (Java-Compiler)
     • Java (Java Application Launcher)
     • jdb (Java Debugger)
     • jar (Java Archive Tool)
     • javadoc (Java Documentation Generator)
5. JVM vs. JRE vs. JDK: Was ist der Unterschied?
6. JDK-, JRE-, JVM-Hierarchie

Einführung

Das Java-Ökosystem ist die breite Palette von Tools, Technologien, Bibliotheken und Frameworks, die die Programmiersprache Java umgeben und unterstützen. Es umfasst alles, was zum Entwickeln, Bereitstellen und Verwalten von Java-Anwendungen erforderlich ist. Es dreht sich um JDK, JRE, JVM

JVM (Java Development Kit)

Die JVM fungiert wie ein Übersetzer, der es Ihrem Computer ermöglicht, Java-Programme und andere Sprachen auszuführen, die in Java-Bytecode kompiliert sind. Es übersetzt den Code in etwas, das die Hardware Ihres Computers verstehen und ausführen kann.

Architektur der JVM

Klassenlader

1. Ladung wird geladen
   Laden Sie .class-Dateien in den Speicher. Sucht, lädt und verknüpft Klassendateien (Java-Bytecode) zur Ausführung.

2. Verlinkung

   • Überprüfung: Überprüft den Bytecode.
   • Vorbereitung: Reserviert Speicher für statische Variablen und initialisiert den Speicher auf Standardwerte.
   • Lösung: Löst symbolische Verweise in direkte Verweise auf.

3. Initialisierung
   Die Initialisierung ist der letzte Schritt, bei dem die JVM eine Klasse oder Schnittstelle für die Verwendung vorbereitet. Dieser Schritt erfolgt, nachdem die Klasse geladen (in den Speicher) und verknüpft wurde.

JVM-Speicher

1. Methodenbereich
   Methodenbereich Speichert Daten auf Klassenebene wie Methoden und Variablen, den Laufzeitkonstantenpool und Code für Methoden.
   

   public class Person {
       private String name;
   
       public void setName(String name) {
           this.name = name;
       }
   }
   

   Wenn Sie eine Klasse Person definieren, speichert der Methodenbereich die Struktur der Person-Klasse, einschließlich ihrer Methoden (setName) und Felder (name), sowie den Laufzeitkonstantenpool, der Referenzen wie Methodennamen und Konstantenwerte enthält.

2. Haufen
   Im Heap werden die Laufzeitspeicherobjekte zugewiesen. Der Heap wird von allen Threads gemeinsam genutzt und ist der Ort, an dem der Speicherbereinigungsprozess stattfindet.
   

   Person p = new Person();
   

   Wenn Sie ein neues Personenobjekt erstellen, wird es auf dem Heap zugewiesen.

3. Stapelbereich
   Im Stapelbereich werden Frames gespeichert, die lokale Variablen, Operandenstapel und Verweise auf den Laufzeitkonstantenpool der ausgeführten Klasse enthalten. Jeder Thread hat seinen eigenen Stapel.
   

   public void someMethod() {
       int a = 10;
       int b = 20;
       int sum = a + b;
   }
   

   Jedes Mal, wenn someMethod aufgerufen wird, wird ein neuer Frame auf den Stapelbereich verschoben. Dieser Rahmen enthält lokale Variablen (a, b und sum), einen Operandenstapel für Zwischenberechnungen und einen Verweis auf die Klasse der Methode im Runtime Constant Pool.

4. Programmzähler (PC) registrieren
   PC enthält die Adresse des aktuell ausgeführten JVM-Befehls. Jeder Thread verfügt über ein eigenes PC-Register.

5. Native Method Stack
   Ähnlich dem Java-Stack, wird jedoch für native Methoden verwendet.

Ausführungs-Engine

1. Dolmetscher
   Der Interpreter liest den Java-Bytecode und führt ihn Zeile für Zeile aus, wobei er jede Bytecode-Anweisung in eine Folge von Anweisungen auf Maschinenebene umwandelt, die von der CPU ausgeführt werden können.

2. Just-In-Time (JIT) Compiler
   Konvertiert Bytecode zur Laufzeit in nativen Maschinencode, um die Leistung zu verbessern.

3. Müllsammler
   Der Garbage Collector ist für die automatische Speicherverwaltung in der JVM verantwortlich. Es identifiziert und gibt Speicher frei, der nicht mehr verwendet wird, und macht ihn für neue Objekte frei.

JRE

JRE ist ein Softwarepaket, das die notwendige Umgebung zum Ausführen von Java-Anwendungen bereitstellt. Es wurde entwickelt, um Java-Bytecode auf einer Maschine auszuführen, und ist damit ein wesentlicher Bestandteil des WORA-Prinzips (Write Once, Run Anywhere) von Java.

public class Person {
    private String name;

    public void setName(String name) {
        this.name = name;
    }
}

Person p = new Person();

public void someMethod() {
    int a = 10;
    int b = 20;
    int sum = a + b;
}

JDK (Java Development Kit)
│
├── JRE (Java Runtime Environment)
│   │
│   ├── JVM (Java Virtual Machine)
│   │   ├── Class Loader
│   │   ├── Bytecode Verifier
│   │   ├── Execution Engine
│   │   │   ├── Interpreter
│   │   │   ├── Just-In-Time (JIT) Compiler
│   │   │   └── Garbage Collector
│   │   └── Runtime Libraries (core libraries like java.lang, java.util, etc.)
│   │
│   └── Java APIs (Core libraries and additional libraries)
│
├── Development Tools (like javac, jdb, jar, javadoc, etc.)
└── Documentation (API docs, guides)

<🎝><🎝>Schlüssel<🎝>Komponenten<🎝>der<🎝>JRE

1. Ausführung<🎝>Aufgaben
   Die<🎝>JRE<🎝>erleichtert<🎝>die<🎝>Ausführung<🎝>von<🎝>Java<🎝>Anwendungen<🎝>durch<🎝>Bereitstellung<🎝>der<🎝>JVM<🎝>und< 🎝>die<🎝>notwendigen<🎝>Bibliotheken<🎝>und<🎝>Ressourcen.<🎝>JRE<🎝>stellt sicher,<🎝>dass<🎝>die<🎝>JVM<🎝>über<🎝>alles verfügt<🎝 >es<🎝>muss<🎝>diese<🎝>Aufgaben<🎝>auf<🎝>jeder<🎝>Plattform ausführen.<🎝>Denken<🎝>an<🎝>die<🎝> JRE<🎝>als<🎝>das<🎝>komplette<🎝>Paket<🎝>das<🎝>die<🎝>JVM<🎝>enthält,<🎝>die<🎝>das<🎝>Schwere erledigt <🎝>Heben<🎝>und<🎝>andere<🎝>Komponenten<🎝>die<🎝>die<🎝>Ausführung<🎝>von<🎝>Java<🎝>Anwendungen unterstützen.

2. Klasse<🎝>Bibliotheken
   JRE<🎝>enthält<🎝>einen<🎝>Satz<🎝>Standard<🎝>Java<🎝>Klassen<🎝>Bibliotheken,<🎝>die<🎝>wiederverwendbaren<🎝>Code bereitstellen <🎝>zur<🎝>Ausführung<🎝>allgemeiner<🎝>Aufgaben,<🎝>wie<🎝>Daten<🎝>Strukturen,<🎝>E/A,<🎝>Netzwerk,<🎝>Parallelität,<🎝> und<🎝>mehr.

3. Java<🎝>Native<🎝>Schnittstelle<🎝>(JNI)
   JNI<🎝>ermöglicht<🎝>Java<🎝>Anwendungen<🎝>die<🎝>Interaktion<🎝>mit<🎝>nativem<🎝>Code<🎝>geschrieben<🎝>in<🎝>Sprachen<🎝>wie< 🎝>C<🎝>oder<🎝>C++.<🎝>Diese<🎝>Funktion<🎝>ist<🎝>wesentlich<🎝>für<🎝>die Integration<🎝>plattformspezifischer<🎝>Funktionen<🎝>oder <🎝>Verwendung<🎝>vorhandener<🎝>native<🎝>Bibliotheken.

4. Sicherheit<🎝>Manager<🎝>
   Der<🎝>Sicherheitsmanager<🎝>erzwingt<🎝>Sicherheitsrichtlinien<🎝>für<🎝>Java<🎝>Anwendungen<🎝>und schränkt<🎝>Aktionen<🎝>wie<🎝>wie ein <🎝>Datei<🎝>Zugriff,<🎝>Netzwerk<🎝>Verbindungen<🎝>und<🎝>die<🎝>Ausführung<🎝>von<🎝>potenziell<🎝>unsicherem<🎝>Code.

<🎝><🎝> <🎝><🎝> <🎝><🎝>JDK<🎝>(Java<🎝>Entwicklung<🎝>Kit)

JDK<🎝>ist<🎝>ein<🎝>Tool<🎝>das<🎝>Entwicklern<🎝>das<🎝>Schreiben,<🎝>Kompilieren,<🎝>Debuggen,<🎝> ermöglicht und<🎝>Java<🎝>Anwendungen ausführen.<🎝>Es<🎝>ist<🎝>eine<🎝>Obermenge<🎝>von<🎝>JRE<🎝>und<🎝>enthält<🎝>zusätzliche <🎝>Tools<🎝>für<🎝>Java<🎝>Entwicklung.

<🎝><🎝> <🎝><🎝> <🎝><🎝>Kernfunktionen<🎝>des<🎝>JDK

• javac<🎝>(Java<🎝>Compiler)
  javac<🎝>wird<🎝>zum<🎝>zum<🎝>Konvertieren von<🎝>Java<🎝>Quellcode<🎝>(.java<🎝>Dateien)<🎝>in<🎝 verwendet >Bytecode<🎝>(.class<🎝>Dateien).<🎝>Dieser<🎝>Bytecode<🎝>wird<🎝>dann<🎝>von<🎝>dem<🎝>Java<🎝>Virtuell<🎝>ausgeführt <🎝>Maschine<🎝>(JVM).

• Java<🎝>(Java<🎝>Anwendung<🎝>Launcher)
  java<🎝>Befehl<🎝>startet<🎝>eine<🎝>Java<🎝>Anwendung.<🎝>Es<🎝>lädt<🎝>die<🎝>erforderlichen<🎝>Klassen<🎝>Dateien,<🎝> interpretiert<🎝>den<🎝>Bytecode<🎝>und<🎝>startet<🎝>die<🎝>Anwendung.

• jdb<🎝>(Java<🎝>Debugger)
  jdb<🎝>ist<🎝>der<🎝>Befehlszeilen-<🎝>Debugger<🎝>für<🎝>Java<🎝>Programme.<🎝>Es<🎝>ermöglicht<🎝>Ihnen<🎝>das<🎝 >Inspizieren<🎝>und<🎝>Debuggen<🎝>Java<🎝>Anwendungen<🎝>zur<🎝>Laufzeit.

• jar<🎝>(Java<🎝>Archive<🎝>Tool)
  jar<🎝>tool<🎝>Pakete<🎝>mehrere<🎝>Dateien<🎝>in<🎝>eine<🎝>einzelne<🎝>Archiv<🎝>Datei,<🎝>typischerweise<🎝>mit<🎝>a <🎝>.jar<🎝>Erweiterung.<🎝>Diese<🎝>JAR<🎝>Dateien<🎝>werden<🎝>verwendet<🎝>zum<🎝>Verteilen<🎝>Java<🎝>Anwendungen<🎝>und <🎝>Bibliotheken.

• javadoc<🎝>(Java<🎝>Dokumentation<🎝>Generator)
  javadoc<🎝>generiert<🎝>HTML<🎝>Dokumentation<🎝>aus<🎝>Java<🎝>Quellcode<🎝>unter Verwendung<🎝>des<🎝>speziellen<🎝>/**<🎝 >*/<🎝>Kommentare<🎝>bekannt<🎝>als<🎝>Dokument<🎝>Kommentare.

JVM vs JVE vs JDK, what's the difference?

Feature/Aspect	JVM	JRE	JDK
Purpose	Executes Java bytecode	Provides the environment to run Java applications	Provides tools to develop, compile, debug, and run Java applications
Includes	JVM itself, which includes class loader, bytecode verifier, and execution engine	JVM + Core libraries (like java.lang, java.util, etc.), and other runtime components	JRE + Development tools (like javac, jdb, jar, etc.), documentation
Components	- Class Loader - Bytecode Verifier - Execution Engine (Interpreter, JIT)	- JVM - Core Java libraries - Java Plug-in - Java Web Start	- JRE - Java Compiler (javac) - JAR Tool (jar) - Debugger (jdb) - Documentation Generator (javadoc) - Other development tools
Main Functionality	Executes Java bytecode, enabling platform independence	Provides the minimum requirements to run Java applications	Allows developers to write, compile, and debug Java code
Who Uses It?	End-users running Java applications	End-users running Java applications	Java developers writing and compiling Java applications
Installation Size	Smallest	Larger than JVM but smaller than JDK	Largest (includes JRE and development tools)
Developer Tools	No	No	Yes (includes compiler, debugger, profiler, etc.)
Required to Run Java Programs	Yes	Yes	No (but needed to create Java programs)
Platform Independence	Provides platform independence by abstracting the underlying hardware	Yes, because it includes the JVM	Yes, it includes everything from JRE
Examples of Usage	- Running any Java application (e.g., desktop applications, servers)	- Running Java applications in production or end-user environments	- Writing and compiling Java code - Packaging applications - Debugging
Availability	Part of JRE and JDK	Standalone or part of JDK	Standalone package

JDK, JRE, JVM hierarchy

JDK (Java Development Kit)
│
├── JRE (Java Runtime Environment)
│   │
│   ├── JVM (Java Virtual Machine)
│   │   ├── Class Loader
│   │   ├── Bytecode Verifier
│   │   ├── Execution Engine
│   │   │   ├── Interpreter
│   │   │   ├── Just-In-Time (JIT) Compiler
│   │   │   └── Garbage Collector
│   │   └── Runtime Libraries (core libraries like java.lang, java.util, etc.)
│   │
│   └── Java APIs (Core libraries and additional libraries)
│
├── Development Tools (like javac, jdb, jar, javadoc, etc.)
└── Documentation (API docs, guides)

Das obige ist der detaillierte Inhalt vonÜberblick über das Java-Ökosystem. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!