Schnittstellen

class: center, middle, first

# Software-Entwicklung 3

## Schnittstellen

---

# Agenda

1. Recap
2. Synchrone Schnittstellen
3. Asynchrone Schnittstellen

---

# Recap: Was haben wir in der letzten Vorlesung besprochen?

* SQL
* NoSQL

> Blick ins [Repository](https://gitlab.mi.hdm-stuttgart.de/jordine/se3sose2023projekt)

---
class: center, middle
# Welche Formen der Kommunikationsbeziehungen kennen Sie in der (objektorientierten) Programmierung?

---
# Kommunikationsbeziehungen

Beispiele:

* lokale Schnittstellen
    * API (lokal)
* Remote Schnittstellen
  * RPC
  * RESTful-APIs
  * SOAP-APIs
  * Messaging-APIs/Event-based APIs

---
# Gruppierung der Schnittstellenarten

## Synchrone Schnittstellen

## Asynchrone Schnittstellen

---
# Definition synchrone Schnittstelle

> Der Sender **blockiert** bis vom Empfänger eine Antwort geschickt wurde.

## Beispiele für synchrone Kommunikation

* HTTP
* SOAP
* GraphQL
* RPC (z.B. RMI, gRPC)
* REST

---

# Ablauf synchrone Schnittstelle (vereinfacht)

## Sender
1. Verfassen einer Nachricht
2. Verpacken der Nachricht (_Marshalling_)
3. Absenden der Nachricht
4. _Warten auf Antwort_
5. Empfangen der Antwort-Nachricht
6. Auspacken der Antwort-Nachricht
7. Verarbeiten der Antwort-Nachricht

---
# Ablauf synchrone Schnittstelle (vereinfacht)

## Empfänger
1. _Warten auf eingehende Nachrichten_
2. Empfangen der Nachricht
3. Auspacken der Nachricht
4. Verarbeiten der Nachricht
5. Verfassen der Antwort-Nachricht
6. Verpacken der Antwort-Nachricht
7. Verschicken der Antwort-Nachricht

---
# Ablauf synchrone Schnittstelle

> Blick ins [Vorlesungs-Repository](https://gitlab.mi.hdm-stuttgart.de/jordine/se3sose2023vorlesung)

---
# Was ist REST?

> REST: Representational State Transfer

Softwarearchitekturstil

---
# Grundprinzipien

_nach [Wikipedia, 2022](https://de.wikipedia.org/wiki/Representational_State_Transfer)_

* Client/Server
* Zustandslosigkeit
* Caching
* Einheitliche Schnittstelle
  * Adressierbarkeit von Ressourcen
  * Repräsentationen zur Veränderung von Ressourcen
  * Selbstbeschreibende Nachrichten
  * „_Hypermedia as the Engine of Application State_“ (HATEOAS): Endpoint verlinkt auf weitere Endpoints
* Mehrschichtige Systeme
* Code on Demand (optional)
---
# REST-URIs

> URI: Uniform Resource Identifier

Mögliche URI-Muster:
* `<protocol>://<service-name>/<resource-type>/<resource-id>`
* `<resource-type>/<resource-id>`
* `<protocol>://<service-name>/<resource-type>/<resource-id>/<resource-details>`
* `<protocol>://<service-name>/<api-version>/<resource-type>/<resource-id>`

Beispiele:
* `https://music-mamager.app/songs/112233`
* `https://music-mamager.app/songs/112233/play`
* `https://music-mamager.app/songs/112233/artist`
* `/v3/songs/112233/artist/json`

---
# REST im Einsatz

* Verwendung auf Basis von HTTP/HTTPS
* Nutzen der [HTTP-Verben](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods)
  * `POST`
  * `GET`
  * `DELETE`
  * `PUT` (entspricht einem Update)
  * ...
* Nutzen der HTTP-Status-Codes für Antworten
  * [Übersicht der HTTP-Status-Codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)

---
# REST-APIs mit OpenAPI 3/Swagger

* API-Spezifikation 
* API-Dokumentation
* API-Generierung
* Testumgebung

[Petstore Demo Projekt](https://petstore.swagger.io/)

---
# REST mit Spring Boot (I)

* Alternative zu `JAX-WS`
* Maven-Dependency hinzufügen (`spring-boot-starter-web`)

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>3.0.0</version>
    
</dependency>
```
* Erstellen einer Klasse, die mit `@RestController` annotiert wird
* Annotieren der Methoden mit geeigneter HTTP-Verb Annotation (z.B. `@GetMapping`) und zuweisen des Resource-Pfads (z.B. `/songs`)
* Mapping der URL-Parameter zu Java-Parametern mit der `@RequestParam(value = "name", defaultValue = "Song 2")`

---
# REST mit Spring Boot (II)

Start der Anwendung:

```java
@SpringBootApplication
public class RestServiceApplication {

public static void main(String[] args) {
		SpringApplication.run(RestServiceApplication.class, args);
	}

}
```
---
# REST mit Spring Boot (III)

_Quelle: ["Building a RESTful Web Service", spring.io, 2022](https://spring.io/guides/gs/rest-service/)_

```java
package com.example.restservice;

public class Greeting {

private final long id;
	private final String content;

public Greeting(long id, String content) {
		this.id = id;
		this.content = content;
	}

public long getId() {
		return id;
	}

public String getContent() {
		return content;
	}
}
```

---
# REST mit Spring Boot (IV)

```java
package com.example.restservice;

import java.util.concurrent.atomic.AtomicLong;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

private static final String template = "Hello, %s!";
	private final AtomicLong counter = new AtomicLong();

@GetMapping("/greeting")
	public Greeting greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
		return new Greeting(counter.incrementAndGet(), String.format(template, name));
	}
}
```
---
# REST-Demo im Projekt

> Blick ins [Repository](https://gitlab.mi.hdm-stuttgart.de/jordine/se3sose2023projekt)

---
class: center, middle

# Asynchrone Kommunikationsbeziehungen

---
# Definition asynchrone Schnittstelle

> Sender **blockiert nicht** bis vom Empfänger eine Antwort geschickt wurde.

## Beispiele asynchrone Kommunikation

* Chats
* E-Mail
* Message Broker/Queues (implementierungsabhängig)

---
# Message Broker

_nach: "Learn Microservices with Spring Boot", Moisés Macero García, apress, 2020, S. 216_

---
# Ablauf asynchrone Schnittstelle (vereinfacht)

## Sender
1. Verfassen einer Nachricht
2. Verpacken der Nachricht (_Marshalling_)
3. Absenden der Nachricht
4. _Weiter im Programmfluss_
5. _Ggf. Empfangen der Antwort-Nachricht (nach Zeitraum X)_
6. _Ggf. Auspacken der Antwort-Nachricht_
7. _Ggf. Verarbeiten der Antwort-Nachricht_

---
# Ablauf asynchrone Schnittstelle (vereinfacht)

## Empfänger
1. _Warten auf eingehende Nachrichten_
2. Empfangen der Nachricht
3. Auspacken der Nachricht
4. Verarbeiten der Nachricht
5. _Ggf. Verfassen der Antwort-Nachricht_
6. _Ggf. Verpacken der Antwort-Nachricht_
7. _Ggf. Verschicken der Antwort-Nachricht_

---
# Backup Themen: Software im Betrieb

* Eventual consistency
* Monitoring
* Logging
* Security
* Patching
* Releaseplanung
* Downtimes
* Dokumentation/Schulungen