Skip to content

22. Anhänge

Hier wird beschrieben, wie die in diesem Dokument verwendeten Tools auf Windows 7- oder Windows 8-Rechnern installiert werden. Die Screenshots beziehen sich in der Regel auf die 64-Bit-Versionen der installierten SGBD und Tools. Der Leser sollte die Angaben an seine eigene Umgebung anpassen.

22.1. Installation eines JDK

Im URL findet man das [http://www.oracle.com/technetwork/java/javase/downloads/index.html] (Oktober 2014), das JDK ist die aktuellste Version. Im Folgenden wird der Installationsordner des JDK als <jdk-install> bezeichnet.

 

22.2. Installation von Maven

Maven ist ein Tool zur Verwaltung der Abhängigkeiten eines Java-Projekts und vieles mehr. Es ist (Stand: Oktober 2014) unter den Versionsnummern URL und [http://maven.apache.org/download.cgi] verfügbar.

 

Laden Sie das Archiv herunter und entpacken Sie es. Wir bezeichnen den Installationsordner von Maven als <maven-install>.

  • In [1] konfiguriert die Datei [conf / settings.xml] Maven;

Darin finden sich die folgenden Zeilen:


  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
-->

Der Standardwert in Zeile 4 kann bei einigen Programmen, die Maven verwenden, zu Problemen führen, wenn Ihr {user.home} wie bei mir ein Leerzeichen im Pfad enthält (z. B. [C:\Users\Serge Tahé]). Wir legen daher (in Zeile 7) einen anderen Ordner für das lokale Maven-Repository fest:


  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
<localRepository>D:\Programs\devjava\maven\.m2\repository</localRepository>

Vermeiden Sie in Zeile 7 einen Pfad, der Leerzeichen enthält.

22.3. Installation von STS (Spring Tool Suite)

Wir werden die SpringSource Tool Suite [http://www.springsource.com/developer/sts] (Oktober 2014) installieren, eine Eclipse-Umgebung, die bereits mit zahlreichen Plugins zum Spring-Framework sowie einer vorinstallierten Maven-Konfiguration ausgestattet ist.

  • Rufen Sie die Website der SpringSource Tool Suite auf (STS) [1] aufrufen, um die aktuelle Version von STS [2A] [2B] herunterzuladen,
  • Die heruntergeladene Datei ist ein Installationsprogramm, das die Dateistruktur von [3A] und [3B] erstellt. In [4] wird die ausführbare Datei gestartet,
  • in [5] wird das Arbeitsfenster von IDE angezeigt, nachdem das Begrüßungsfenster geschlossen wurde. In [6] wird das Fenster mit den Anwendungsservern angezeigt,
  • in [7] das Serverfenster. Ein Server ist registriert. Es handelt sich um einen Tomcat-kompatiblen Server VMware.

In STS muss der Installationsordner von Maven angegeben werden:

  • In [1-2] wird STS konfiguriert;
  • in [3-4] wird eine neue Maven-Installation hinzugefügt;
  • In [5] geben Sie den Installationsordner für Maven an;
  • In [6] schließen wir den Assistenten ab;
  • in [7] wird die neue Maven-Installation als Standardinstallation festgelegt;
  • In [8-9] wird das lokale Maven-Repository überprüft, also der Ordner, in dem die heruntergeladenen Abhängigkeiten abgelegt werden und in dem STS die erstellten Artefakte ablegen wird;

Außerdem muss ein JDK (Java Development Kit) ausgewählt werden, um sowohl Eclipse-Projekte ohne als auch mit Maven [1-5] ausführen zu können.

Mit [4] können JDK (Java Development Kit) oder JRE (Java Runtime Environment) hinzugefügt werden. Letzteres kann .class-Dateien ausführen, aber keine .java-Dateien kompilieren, um diese zu erzeugen. Das JDK kann beides. Man wählt ein JDK, da bestimmte Maven-Operationen ein JDK erfordern.

Um ein Eclipse-Projekt zu erstellen, gehen Sie wie folgt vor:

  • in [3], geben Sie dem Projekt einen Namen;
  • unter [4] wählen Sie einen vorhandenen, leeren Ordner aus;
  • in [5] das erstellte Projekt;
  • in [5-8], erstellen Sie ein Paket. Ein Paket ist ein Ordner, der Java-Code enthält. Zwei Klassen können denselben Namen tragen, wenn sie zu unterschiedlichen Paketen gehören. In einem Projekt darf es keine zwei Pakete mit demselben Namen geben. Daher kann kein Paketname verwendet werden, der bereits in einer der Abhängigkeiten des Projekts existiert. Ein Unternehmen verwendet als Paketnamen einen Namen, der das Unternehmen, das Projekt und dessen verschiedene Zweige angibt;
  • in [9], geben Sie dem Paket einen Namen;
  • in [10] das erstellte Paket;
  • in [11-13] wird eine Klasse in dem erstellten Paket angelegt;
  • in [14]: Geben Sie der Klasse einen Namen (muss der Norm CamelCase entsprechen – jedes Wort des Namens muss mit einem Großbuchstaben beginnen, gefolgt von Kleinbuchstaben);
  • in [15]: Überprüfen Sie das Paket;
  • In [16] aktivieren Sie das Kontrollkästchen. Damit wird die statische Methode [main] generiert. Diese Methode macht eine Klasse ausführbar, d. h. sie ist die erste Klasse, die in einem Projekt ausgeführt wird;
  • in [17] die so erstellte Klasse;

Geben Sie in der Methode [main] den folgenden Code ein, der einen Text auf der Konsole anzeigt:


package st.istia;

public class Test01 {

    public static void main(String[] args) {
        System.out.println("test01");
    }

}
  • Führen Sie in [18-20] die Klasse aus. Die Methode [main] wird daraufhin ausgeführt;
  • in [21-22], das Ergebnis der Anwendung;

Wenn die Ansicht [Console] nicht vorhanden ist, gehen Sie wie folgt vor: [1-4]:

Es kann vorkommen, dass beim Import eines Eclipse-Projekts Fehler auftreten. Dies kann an einer fehlerhaften Projektkonfiguration liegen. Um den Fehler (falls vorhanden) zu beheben, gehen Sie wie folgt vor:

  • Ändern Sie in [1] die Datei [Build Path] des Projekts;
  • in [2]: Das Projekt ist so konfiguriert, dass es eine JVM 1.5 verwendet;
  • in [3], entfernen Sie diese Abhängigkeit;
  • in [4]: Fügen Sie eine neue Abhängigkeit hinzu;
  • In [5] wird ein JVM hinzugefügt;
  • In [6] wählen Sie die JVM der Position aus;

Anschließend bestätigt man das Ganze und wechselt zur Eigenschaft [Java compiler] des Projekts [7]:

  • In [8] weisen wir den Compiler an, alle Merkmale der Java-Sprache bis einschließlich Version 1.7 (oder 1.8) zu akzeptieren;
  • in [9] wird die Validierung durchgeführt;
  • Bei [10] sollte das so neu konfigurierte Projekt keine Fehler mehr aufweisen;

Außerdem kann das importierte Projekt eine UTF-8-Zeichenkodierung verwenden. Gehen Sie wie folgt vor, um diese Kodierung im importierten Projekt [1-4] festzulegen:

Außerdem kann es sinnvoll sein, die Rechtschreibprüfung im Projekt zu deaktivieren, um zu vermeiden, dass Kommentare auf Französisch fälschlicherweise als fehlerhaft markiert werden. Befolgen Sie die folgenden Schritte:

22.4. Installation von NetBeans

NetBeans ist unter URL [http://netbeans.org/downloads/] verfügbar.

 

Man kann die oben genannte Java-Version SE (Standard Edition) verwenden.

22.5. Installation des Chrome-Plugins [Advanced Rest Client]

In dieser Anleitung wird der Chrome-Browser von Google (http://www.google.fr/intl/fr/chrome/browser/) verwendet. Wir fügen ihm die Erweiterung [Advanced Rest Client] hinzu. Gehen Sie dazu wie folgt vor:

 
  • Die Anwendung steht dann zum Download bereit:
  • Um sie zu erhalten, müssen Sie ein Google-Konto erstellen. [Google Web Store] fordert anschließend eine Bestätigung an: [1]:
  • Unter [2] ist die hinzugefügte Erweiterung in der Option [Applications] [3] verfügbar. Diese Option wird auf jedem neuen Tab angezeigt, den Sie im Browser erstellen (CTRL-T).

22.6. Verwaltung von jSON in Java

Auf für den Entwickler trans nsparente Weise nutzt das Framework [Spring MVC] die Bibliothek jSON [Jackson]. Um zu veranschaulichen, was jSON (JavaScript-Objektnotation) ist, stellen wir hier ein Programm vor, das Objekte in jSON serialisiert und umgekehrt die erzeugten jSON-Zeichenketten deserialisiert, um die ursprünglichen Objekte wiederherzustellen.

Mit der Bibliothek „Jackson“ lässt sich Folgendes erstellen:

  • die Zeichenkette jSON eines Objekts: new ObjectMapper().writeValueAsString(object);
  • ein Objekt aus einer Zeichenkette jSON: new ObjectMapper().readValue(jsonString, Object.class).

Beide Methoden können ein IOException auslösen. Hier ein Beispiel.

Das oben genannte Projekt ist ein Maven-Projekt mit der folgenden Datei „[pom.xml]“:


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>istia.st.pam</groupId>
  <artifactId>json</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.3.3</version>
    </dependency>
  </dependencies>
</project>
  • Zeilen 12–16: Die Abhängigkeit, die die Bibliothek „Jackson“ einbindet;

Die Klasse [Personne] sieht wie folgt aus:


package istia.st.json;

public class Personne {
    // Daten
    private String nom;
    private String prenom;
    private int age;

    // Hersteller
    public Personne() {

    }

    public Personne(String nom, String prénom, int âge) {
        this.nom = nom;
        this.prenom = prénom;
        this.age = âge;
    }

    // Signatur
    public String toString() {
        return String.format("Personne[%s, %s, %d]", nom, prenom, age);
    }

    // Getter und Setter
...
}

Die Klasse [Main] lautet wie folgt:


package istia.st.json;

import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class Main {
  // das Tool zur Serialisierung/Deserialisierung
  static ObjectMapper mapper = new ObjectMapper();

  public static void main(String[] args) throws IOException {
    // Anlegen einer Person
    Personne paul = new Personne("Denis", "Paul", 40);
    // Anzeige jSON
    String json = mapper.writeValueAsString(paul);
    System.out.println("Json=" + json);
    // Instanziierung einer Person aus JSON
    Personne p = mapper.readValue(json, Personne.class);
    // Anzeige einer Person
    System.out.println("Personne=" + p);
    // ein Array
    Personne virginie = new Personne("Radot", "Virginie", 20);
    Personne[] personnes = new Personne[]{paul, virginie};
    // JSON-Anzeige
    json = mapper.writeValueAsString(personnes);
    System.out.println("Json personnes=" + json);
    // Wörterbuch
    Map<String, Personne> hpersonnes = new HashMap<String, Personne>();
    hpersonnes.put("1", paul);
    hpersonnes.put("2", virginie);
    // JSON-Anzeige
    json = mapper.writeValueAsString(hpersonnes);
    System.out.println("Json hpersonnes=" + json);
  }
}

Die Ausführung dieser Klasse erzeugt folgende Bildschirmausgabe:

1
2
3
4
Json={"nom":"Denis","prenom":"Paul","age":40}
Personne=Personne[Denis, Paul, 40]
Json personnes=[{"nom":"Denis","prenom":"Paul","age":40},{"nom":"Radot","prenom":"Virginie","age":20}]
Json hpersonnes={"2":{"nom":"Radot","prenom":"Virginie","age":20},"1":{"nom":"Denis","prenom":"Paul","age":40}}

Aus dem Beispiel ist Folgendes zu entnehmen:

  • das Objekt [ObjectMapper], das für die Transformationen jSON / Objekt erforderlich ist: Zeile 11;
  • die Transformation [Personne] --> jSON: Zeile 17;
  • die Transformation jSON → [Personne]: Zeile 20;
  • die von beiden Methoden ausgelöste Ausnahme [IOException]: Zeile 13.

22.7. Installation von [WampServer]

[WampServer] ist „ “, ein Softwarepaket zur Entwicklung von PHP / MySQL / Apache auf einem Windows-Rechner. Wir werden es ausschließlich für SGBD und MySQL verwenden.

  • auf der Website von [WampServer] [1] die passende Version auswählen ([2]),
  • Die heruntergeladene ausführbare Datei ist ein Installationsprogramm. Während der Installation werden verschiedene Informationen abgefragt. Diese betreffen MySQL nicht. Sie können daher ignoriert werden. Am Ende der Installation wird das Fenster [3] angezeigt. Starten Sie [WampServer],
  • in [4], das Symbol von [WampServer] wird in der Taskleiste unten rechts auf dem Bildschirm installiert, [4],
  • Wenn man darauf klickt, wird das Menü [5] angezeigt. Es ermöglicht die Verwaltung des Apache-Servers sowie von SGBD und MySQL. Um diesen zu verwalten, verwendet man die Option [PhpPmyAdmin],
  • daraufhin erscheint das untenstehende Fenster,

Image

Wir gehen nur kurz auf die Verwendung von [PhpMyAdmin] ein. In Abschnitt 6.4.2 zeigen wir, wie man damit aus einem Skript SQL eine Datenbank erstellt.

https://stahe.github.io
Dieses Tutorial, verfasst von Serge Tahé, wird der Öffentlichkeit unter den Bedingungen der Creative Commons Namensnennung – Nicht kommerziell – Weitergabe unter gleichen Bedingungen 3.0 Unported.