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:
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
- curl http://localhost:8080/hellocontroller/saymoin
- 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