Ich nehme derzeit an einer Akademie zum Java Fullstack Software Engineer teil. In den kommenden Wochen möchte ich hier meine Mitschrift, so gut es geht, aufzeichnen und mitteilen. Hier ist das, was ich vom ersten Tag in Block 7 gelernt und behalten habe:

Spring Boot

Auf folgender Seite kann man sich sein Java-Spring Boot Web-Server mit wenigen Klicks zusammen stellen:

URL: https://start.spring.io

Wähle ich "War", muss ich selber den Webserver zur Verfügung stellen.

Bei "Jar", erhalte ich eine Applikation + Server

Dependencies beinhaltet zusätzliche Pakete. Wir haben unseren Server wie folgt konfiguriert:

Das erstellte Zipfile downloaden wir und packen es an eine uns angenehme Stelle aus. Dann öffnene wir es mit IntelliJ.

Main startet SpringbootApllication und übergibt die Klasse Ueb00-firstproj an Spring. Der SpringApplicationscontroller wird gestartet. An das run wird die Methode übergeben. Wir brauchen keine spring.xml mehr. Auch keine persistence.xml.

Wir starten beherzt und das Ergebnis sieht so aus:

Man kann auch Properties benutzen:

Oder man verwendet eine application.yaml Datei (normalerweise nimmt man nur eine Config-Datei. Die application.properties hat aber Vorrang):

Viel mehr macht diese "leere" Applikation nicht.

Ueb01

Wir bauen einen neuen Spring Applikation. Diesmal nehmen wir Dependencies mit dazu.

Basis-Paket: Spring Boot Starter

Erweitertes Paket: Java-JPA + Java WebServer + HSQL-DB:

(Sollte man etwas vergessen haben, kann man die pom.xml um die entsprechende Dependency erweitern. )

Die pom.xml unterscheidet sich mit ueb001 zu Ueb00 darin, dass jetzt die ausgewählten Dependencies mit drin sind und das Basispaket nicht mehr spring-boot-starter, sondern spring-boot-starter-web ist:

Wir starten die main-Applikation:

Ich war der Schnellste ;-) und daher hat es bei mir geklappt. Meine Kollegen, die auf dem selben Schulungsserver arbeiten, haben eine Fehlermeldung erhalten, dass der Port 8080 schon belegt sei (hehe).

Man kann es aber einfach ändern, indem man in die application.properties server.port=8099 einträgt.

Da wir aber noch keine Webseite hinterlegt haben, erscheint zwar eine Fehlermeldung, aber immerhin eine Antwort vom Tomcat-Server:

Wir sehen im Log, was die beiden Starter aus der pom.xml Datei getan haben:

Wir erstellen eine neue Klasse "HelloController".

Jetzt brauchen (und bauen) wir einen Controller (also Schnittstelle zum Web). Wir erinnern uns:

Der Classloader weiß, dass die Komponente "@Controller" zum Tomcat gehört.

Sringboot Tomcat Server ohne Eclipse laufen lassen

Um das Ganze autark laufen zu lassen, tun wir folgendes:

Wir öffnen Maven (ganz rechts in Eclipse)
Wir klicken auf Lifecycle
Package/Run Maven Build

4. Target Ordner öffnen
5. Ueb01-First Project kopieren oder Ordner merken

6. CMD öffnen und zum Ort der jar Datei gehen:

cd D:\Benutzerdaten\Mertens_Achim\my-workspace\Block07\ueb01-firstproject\target

7. Java -jar Dateiname ausführen:

java -jar ueb01-firstproject-0.0.1-SNAPSHOT.jar

8. Das Ergebnis im Log und im Browser genießen ;-)

Auf dem lokalen Rechner haben wir Java 8 installiert. Dort läuft es so nicht. Aber wir haben auch Java 11 (Zulu) in einen Ordner entpackt. Diesen können wir (hier im Beispiel aus der Git-Bash) wie folgt starten (Achtung: port 8080 ist wohl schon belegt):

$ '/c/Program Files/zulu11.52.13-ca-jdk11.0.13-win_x64/bin/java' -jar ueb01-firstproject-0.0.1-SNAPSHOT.jar

Der Tomcatserver wird komplett aus den Java-bibliotheken abgebildet. Er ist sehr stark komprimiert und Optimiert, da er nur die mitgebrachten Java-Applikationen ansprechen muss.

Folgende Webservice Pakete können wir installieren:

String Boot-Starter
Spring-BootStarter web
Spring boot Starter data jpa
Spring boot starter thymeLeaF (abgespeckte Web-Version)

GET, POST, PUT, DELETE

Es geht auch mit unterschiedlichen Methoden. Dann muss das GetMapping natürlich auch eine andere URL bekommen:

Wir brauchen jetzt zwei Tools: Curl und Postman.

https://www.postman.com/downloads/

Mit Curl kann man die URL via Console aufrufen:

curl http://localhost:8099/helloController/sayMoin

Gibt man was Nichterlaubtes ein, gibt es eine Fehlermeldung:

In RFC2616 stehen die Fehlermeldungen des http-Protokolls drin:

(Entnommen aus: https://datatracker.ietf.org/doc/html/rfc2616)

Es sei denn, man ändert auch die entsprechende Methode:

Mit GET holt man den Inhalt von Datenbanken.
Mit Post werden Daten hochgeladen
PUT - Ändern
Delete - Löschen

Restful http-Methods:

Bei einem PUT wird der komplette Datensatz hochgeladen und geupdated. Bei einem Pach schicke ich nur die ID und das zu ändernde Feld.

Kommentare helfen:

Hier übergeben wir einen Parameter "Achim", eine so genannte Pfadvariable. Das Programm liefert dann den Namen wieder zurück:

Bzw. als curl-Command:

Werden Daten via GET übertragen, ist man auf das Environment des Servers angewiesen. Eine POST Anfrage geht über den Body und ist stabiler:
Der Dispatcher nimmt die URL auseinander.
Leerzeile = /n/n
In beide Richtungen werden Header und Body mitgeschickt:

Der Header entspricht dem, was ich in den Bierflaschen haben will (Etikette). Der Body entspricht den Bierflaschen in der Kiste. Ich gehe mit der Kiste zum Server, äh Bierhändler und er gibt mir die volle Kiste zurück. Der Content-Type auf der Etikette wäre dann z.B. Bitburger. Im Body wäre dann das Bier (Payload).
Der Header ist quasi das Handgepäck und der Body ist der Koffer.
Curl -v zeigt nur den Header an. Wir sehen aber, das 31 Zeichen im Body sind. MoinMoin ist der Body vom Response:

curl --help all zeigt alle Parameter an:

Man kann auch Daten über Requestparameter übergeben:

    @GetMapping("/sayHelloPerson") // Registriere URL /sayHelloPerson?username=NAME
    public String syaHelloPerson(@RequestParam(name="username") String name){
        return "Hello " + name;
    }

Zusammenfassung

https://www.baeldung.com/spring-boot-change-port

Soap-WebService (JAX-WS)
XML (Daten)
SOAP (Datenaustausch)

RestFul-WebService (JAX-RS)
JSON, XML, TEXT, CSV, HTML (Daten)
HTTP (Datenaustausch)
Resourcen (Objekte "Entitys")
https://datatracker.ietf.org/doc/html/rfc2616 RFC 2616
https://datatracker.ietf.org/doc/html/rfc3875 RFC 3875
https://jcp.org/en/jsr/detail?id=370 JSR 370: JavaTM API for RESTful Web Services (JAX-RS 2.1) Specification

Tools:
curl - Shell bassierter Browser (https://curl.se/download.html)
postman - GUI-Tool um damit Aufrufe gegen einen Server zu fahren (https://www.postman.com/downloads/)

curl URL

Parameter:
-v verbose -> HTTP-Header (
Request > (Client)
Response < (Server)
)

-X HTTP-Methode (GET, POST, PUT, DELETE) Nutzung:
- curl http://localhost:8080/hellocontroller/saymoin
  
  Parameter:
  @RequestParam -> curl -X GET http://localhost:8080/hellocontroller/sayhelloperson?username=Homer
  @PathVariable -> curl -X GET http://localhost:8080/hellocontroller/sayhellouser/Homer
https://apidocs.tempo.io/

Fun:
https://swapi.dev/
https://som-research.uoc.edu/tools/emf-rest/example.html
https://github.com/btaps/simpsons-api
https://rebrickable.com/downloads/
https://developers.hive.io/apidefinitions/#broadcast_ops_account_update2

Disclaimer

Alles was ich mitschrieb und verstanden habe ist ohne Gewähr. Die Bilder stammen teilweise aus dem Internet und wir haben keine Urheberansprüche darauf.

Besten Dank an unseren sehr empfehlenswerten

Trainer: Hans-Joachim Blanke blanke@4point.de

In den nächsten Tagen und Wochen geht’s weiter, so: stay tuned!

Gruß, Achim Mertens

Topics