1. Einführung

1.1. Hintergrund

Das PDF des Dokuments finden Sie |HIER|.

Die Beispiele im Dokument sind |HIER| verfügbar.

Dieses Dokument dient sowohl als Vorlesungsunterlage als auch als Tutorienunterlage (TD). Es richtet sich an Anfänger. Es stützt sich auf folgende Quellen:

Literaturhinweise:

Wir bezeichnen diese Quellen als [ref1] bzw. [ref2]. Quelle [ref1] ist veraltet (2002), reicht für dieses Dokument jedoch aus, da sie hier nur zur Darstellung der Syntax und der grundlegenden Operationen der Java-Sprache herangezogen wird. Das übrige Material, das zur Erledigung der Aufgabe benötigt wird, wird in diesem Dokument in den Kapiteln mit dem Titel [Kurs] vorgestellt. Diese Kapitel stammen direkt aus [ref2] (2015) und wurden in einigen Fällen vereinfacht.

Das Ziel dieses Dokuments ist es, die Sprache Java aus einer professionellen Perspektive zu vermitteln. Aus diesem Grund stützen wir uns stark auf das Spring-Framework [http://spring.io/], das in der JEE-Entwicklung (Java Enterprise Edition) weit verbreitet ist. Logischerweise sollte auf diesen Kurs ein JEE-Kurs folgen. Dies ist an der Istia (Universität Angers) der Fall. JEE ist derzeit (November 2015) die wichtigste Beschäftigungsquelle für junge Entwickler mit Master-Abschluss. Neben Spring gibt es in der JEE-Welt viele andere Technologien. Spring hat den Vorteil, dass es leicht zu verstehen ist und vor allem Best Practices für die Programmierung bietet, die auch außerhalb des Spring-Ökosystems wiederverwendet werden können. Dies erklärt, warum es hier ausgewählt wurde.

Dieses Labor wird seit über 10 Jahren genutzt und hat sich mit den Technologien weiterentwickelt. Es wird (an der IstiA) von einem JEE-Labor [Einführung in Java EE] gefolgt. Dieses zweite Labor stammt aus dem Jahr 2012 (wir schreiben mittlerweile das Jahr 2015) und könnte eine Aktualisierung vertragen. Es stellt den JEE-Standard anhand des JSF2-Web-Frameworks (Java Server Faces) und von EJB3 (Enterprise Java Bean) vor. Zusammen haben diese beiden Tutorials vielen Studierenden ermöglicht, JEE-Praktika bei Digitaldienstleistungsunternehmen (ESN) zu absolvieren und dort unmittelbar danach eingestellt zu werden.

In diesem Dokument finden Sie keine formale Darstellung aller Aspekte von Java. Im Laufe der Jahre hat sich die Art und Weise, wie junge Entwickler an ein Problem herangehen, erheblich verändert. Heutzutage greifen sie fast immer auf das Internet zurück, um Code-Schnipsel zu finden, die, wenn man sie zusammenfügt, ein Programm ergeben. Wenn wir ihnen einen Kurs anbieten, nutzen sie diesen nur sehr wenig und ziehen es vor, wieder ins Internet zu gehen. Obwohl ich diesem Ansatz anfangs skeptisch gegenüberstand, war ich dennoch von den Ergebnissen überrascht. Schwächere Studierende waren in der Lage, funktionierende Programme zu erstellen, während sie dies ohne die Hilfe des Internets wahrscheinlich nicht geschafft hätten. Ich setze nun auf diesen Ansatz.

Codeausschnitte vermitteln keinen Überblick über die Architektur einer Lösung, und eines der Ziele dieses Dokuments ist es, genau diesen Überblick zu bieten. Die Studierenden absolvieren dieses Tutorial als Laborübung und arbeiten dabei selbstständig. Es gibt keine Vorlesung. Es gibt einen Zeitplan, der den von ihnen im Laufe der Sitzungen erwarteten Fortschritt umreißt. Sie können hinter diesem Zeitplan zurückliegen oder ihm voraus sein. Ihr Fortschritt wird durch eine Reihe von Kontrollpunkten überprüft, die sie dem Dozenten vorlegen müssen. Der Dozent ist sowohl anwesend, um auf Anfrage Erklärungen zu geben, als auch um ihre Arbeit zu validieren. Jeder arbeitet in seinem eigenen Tempo. Am Ende der 36 Stunden, die für dieses Labor vorgesehen sind, werden einige 50 % mehr Validierungen abgeschlossen haben als andere, aber jeder – zumindest ist das das Ziel – wird verstanden haben, was er selbst getan hat. Dieses Labor kann ohne Anleitung durch einen Lehrer absolviert werden. Deshalb ist es unter [https://stahe.github.io] verfügbar.

Dieses Dokument ist nicht für diejenigen geeignet, die einen akademischen Kurs zu Java suchen – also etwas, das Java Schritt für Schritt und strukturiert erklärt, wobei jedes Detail der Syntax erläutert und begründet wird. Vielmehr wird hier ein experimenteller Ansatz vorgeschlagen. Es ist wahrscheinlich, dass die Lernenden nicht alles verstehen werden, was in diesem Dokument vorgestellt wird, aber sie werden den Inhalt wahrscheinlich gut nutzen können, und das Verständnis der Details wird mit der Erfahrung kommen.

Dieses Dokument ist auch kein Kurs über Algorithmen. Der Algorithmus in der Übung ist einfach und kann von jedem Anfänger gelöst werden, der gerade seine ersten Algorithmuskurse besucht. Das Dokument konzentriert sich auf die professionelle Java-Entwicklungsumgebung mit ihren zahlreichen Bibliotheken und Frameworks sowie auf die Code-Architektur. Die meisten Studierenden, die ich sehe, haben Schwächen im Bereich der Algorithmen, was später von ihren Praktikumsbetreuern bestätigt wird. Ja, die Beherrschung von Algorithmen ist wichtig, aber sie steht nicht im Mittelpunkt dieses Tutorials.

Schließlich behandelt dieses Dokument (Dezember 2015) nicht die neuesten Java-Funktionen, insbesondere Streams und Lambda-Funktionen. Es verwendet jedoch einige Elemente des neuesten JDK, JDK 1.8, und der folgende Code muss mit diesem JDK kompiliert werden.

1.2. Inhalt

Kapitel 2 führt in das Thema des Tutorials ein: die Berechnung von Wahlergebnissen. Das Problem ist unkompliziert. In Kapitel 2 werden Sie gebeten, die Lösung mit zwei sehr ähnlichen Sprachen, C# und Java, zu implementieren. Die Implementierung erfolgt ohne Klassen. Ziel ist es, die Java-Syntax, ihre grundlegenden Anweisungen und die Eclipse-IDE (Integrated Development Environment) vorzustellen, die zum Erstellen von Java-Projekten verwendet wird.

In Kapitel 3 sollen Sie die Lösung der Aufgabe in Java unter Verwendung von Klassen implementieren. Ziel ist es, die Konzepte von Klassen, Vererbung, Schnittstellen und generischen Klassen vorzustellen. Das Konzept der JUnit-Unit-Tests wird eingeführt.

Kapitel 4 stellt die Konzepte vor, die den folgenden Kapiteln zugrunde liegen:

geschichtete Architekturen;
Programmierung über Schnittstellen;
die Verwendung von Spring zur Umsetzung der beiden vorangegangenen Konzepte;

Kapitel 5 stellt das Spring-Framework anhand von vier Projekten vor.

Kapitel 6 stellt die JDBC-API vor, eine Schnittstelle für den Datenbankzugriff.

Kapitel 7 implementiert die [DAO]-Schicht (Data Access Object) des Kursprojekts unter Verwendung der JDBC-API und von Spring.

Kapitel 8 implementiert die [Business]-Schicht des Kursprojekts:

Kapitel 9 implementiert die [UI]-Schicht der TD mithilfe einer Konsolenanwendung:

Kapitel 10 implementiert die [UI]-Schicht des Tutorials mithilfe einer grafischen Anwendung, die die Swing-Komponentenbibliothek nutzt:

Kapitel 11 behandelt die Datenbankverwaltung unter Verwendung des [Spring Data]-Frameworks, einer Komponente des Spring-Ökosystems. Es stellt die JPA-Spezifikation (Java Persistence API) vor, die es der [DAO]-Schicht ermöglicht, Objekte anstelle von SQL (Structured Query Language) zu manipulieren. Die Schichtenarchitektur entwickelt sich wie folgt:

Kapitel 12 wendet die Konzepte aus Kapitel 11 an, indem der Datenbankzugriff für das Tutorial unter Verwendung von [Spring Data] implementiert wird.

Kapitel 13 zeigt, wie man eine Datenbank mithilfe von [Spring MVC], einem weiteren Zweig des Spring-Ökosystems, im Web verfügbar macht. Die Architektur entwickelt sich zu einer Client-Server-Architektur:

In den Kapiteln 14 und 15 wird die Tutorial-Anwendung in eine Client-Server-Anwendung umgewandelt:

Kapitel 16 zeigt, wie man den Zugriff auf eine Webanwendung mit [Spring Security], einem weiteren Zweig des Spring-Ökosystems, absichert.

Kapitel 17 greift das Tutorial wieder auf und sichert den Wahl-Webdienst.

Kapitel 18 befasst sich mit dem Thema domänenübergreifende Anfragen:

In [1] stellt eine Webanwendung HTML-/JavaScript-Seiten bereit;
in [2] führt der Browser das in die HTML-Seiten eingebettete JavaScript aus, um den sicheren Webdienst abzufragen [3-4];

Sei D1 = http://machine1:port1 die Domäne von Server [1] und D4 = http://machine4:port4 die Domäne von Server [4]. Wenn sich die Server [1] und [4] nicht in derselben Domäne befinden [D1≠D4], werden Anfragen von [3] an [4] als domänenübergreifende Anfragen bezeichnet. Aufgrund von Sicherheitsbeschränkungen, die von Browsern implementiert werden, kann deren Einrichtung problematisch sein. Wir werden eine Lösung untersuchen.

Kapitel 19 implementiert domänenübergreifende Anfragen unter Verwendung der Wahlen-Anwendung.

1.3. Verwendete Tools

Die folgenden Beispiele wurden in der folgenden Umgebung getestet:

Windows 10 Pro 64-Bit-Rechner;
JDK 1.8 (Abschnitt 22.1);
Spring Tool Suite 3.6.3 IDE (Abschnitt 1);
NetBeans 8.1 (Abschnitt 22.4);
Chrome-Browser (andere Browser wurden nicht verwendet);
Chrome-Erweiterung [Advanced Rest Client] (Abschnitt 1);
WampServer, der das MySQL-DBMS und das Tool [PhpMyAdmin] zu dessen Verwaltung enthält (Abschnitt 22.7);

Es ist wichtig, JDK 1.8 zu verwenden. Einige Beispiele nutzen Komponenten aus diesem JDK. Die meisten Beispiele sind Maven-Projekte, die mit einer der folgenden IDEs geöffnet werden können: Eclipse [https://www.eclipse.org/], IntelliJ IDEA Community Edition [https://www.jetbrains.com/idea/download/] und NetBeans [https://netbeans.org/]. Im Folgenden stammen die Screenshots aus der Spring Tool Suite IDE, einer Variante von Eclipse.

1.4. Support

Die Eclipse-Projekte in diesem Dokument sind unter [Einführung in die Programmiersprache Java und das Spring-Ökosystem anhand einer Fallstudie (2015)] verfügbar.

Um die Projekte für ein Kapitel zu importieren, gehen Sie in Eclipse wie unter [1-8] beschrieben vor:

Die meisten Projekte sind Maven-Projekte. Sollten nach dem Laden Fehler auftreten, drücken Sie [Alt-F5] und befolgen Sie die Anweisungen unter [9-10]. Die ausgewählten Maven-Projekte werden neu erstellt.