Hotelbuchungen

Kurz gesagt: Ein Projekt für Hotelbuchungen: Ein Server und viele Clients buchen, prüfen und stornieren gleichzeitig Zimmer, und wenn zwei im selben Moment dasselbe Zimmer wollen, bekommt es nur einer.

Problem

Ein Zimmer, zwei Bestätigungen

Ein kleines Hotel hat vier Zimmer. Buchungen kommen von überall: von der Website, von der Rezeption, von Reisebüros. An einem Freitagabend buchen zwei Agenturen in derselben Sekunde das letzte Doppelzimmer. Beide bekommen eine Bestätigung. Am Samstag stehen zwei Familien vor dem Zimmer.

Wir bauen ein System, in dem der Server die Zimmer und die Buchungen verwaltet und die Clients Anfragen über das Netz schicken. Ein Client kann:

• die freien Zimmer sehen;
• ein Zimmer prüfen;
• ein Zimmer auf seinen Namen buchen;
• seine eigene Buchung stornieren.

Und wenn zwei Clients gleichzeitig dasselbe Zimmer buchen, hat nur einer Erfolg. Das beweisen wir mit einem Programm, das bei jedem Lauf dieselbe Ausgabe liefert.

Wir bauen von unten nach oben: das Modell ohne Netz, die Regeln und die Fehler, das Protokoll, der Server und der Client, die gleichzeitigen Anfragen und am Ende alles in einem Programm.

Genauer, für Neugierige

Das Modell ist in Java und C# gleich. In Java schicken die Clients Textzeilen über einen Socket, und jeder Client hat seinen eigenen Thread. In C# ist der Server ein Webdienst mit ASP.NET Core, und der Client ruft ihn mit HttpClient auf. In beiden Sprachen schützt dieselbe Grundidee die Zimmer: synchronized.

Die Idee

Das Zimmer

Ein Zimmer hat eine Nummer, einen Typ, einen Preis pro Nacht und einen Zustand: frei oder belegt.

Java

class Room {
    private final int number;
    private final String type;
    private final int price;
    private boolean free = true;

    public Room(int number, String type, int price) {
        this.number = number;
        this.type = type;
        this.price = price;
    }

    public int getNumber() {
        return number;
    }

    public String getType() {
        return type;
    }

    public int getPrice() {
        return price;
    }

    public boolean isFree() {
        return free;
    }

    public void occupy() {
        free = false;
    }

    public void release() {
        free = true;
    }

    @Override
    public String toString() {
        return number + ", " + type + ", " + price + " € pro Nacht, " + (free ? "frei" : "belegt");
    }
}

C#

public class Room
{
    public int Number { get; }
    public string Type { get; }
    public int Price { get; }
    public bool IsFree { get; set; } = true;

    public Room(int number, string type, int price)
    {
        Number = number;
        Type = type;
        Price = price;
    }

    public void Occupy()
    {
        IsFree = false;
    }

    public void Release()
    {
        IsFree = true;
    }

    public override string ToString()
    {
        return Number + ", " + Type + ", " + Price + " € pro Nacht, " + (IsFree ? "frei" : "belegt");
    }
}

Python

class Room:
    def __init__(self, number, kind, price):
        self._number = number
        self._kind = kind
        self._price = price
        self._free = True

    @property
    def number(self):
        return self._number

    @property
    def kind(self):
        return self._kind

    @property
    def price(self):
        return self._price

    @property
    def is_free(self):
        return self._free

    def occupy(self):
        self._free = False

    def release(self):
        self._free = True

    def __str__(self):
        state = "frei" if self._free else "belegt"
        return f"{self._number}, {self._kind}, {self._price} € pro Nacht, {state}"

JavaScript

class Room {
  #number;
  #type;
  #price;
  #free = true;

  constructor(number, type, price) {
    this.#number = number;
    this.#type = type;
    this.#price = price;
  }

  get number() {
    return this.#number;
  }

  get type() {
    return this.#type;
  }

  get price() {
    return this.#price;
  }

  get isFree() {
    return this.#free;
  }

  occupy() {
    this.#free = false;
  }

  release() {
    this.#free = true;
  }

  toString() {
    const state = this.#free ? "frei" : "belegt";
    return `${this.#number}, ${this.#type}, ${this.#price} € pro Nacht, ${state}`;
  }
}

• Nummer, Typ und Preis ändern sich nicht. Nur der Zustand ändert sich, und zwar nur über zwei Methoden mit klaren Namen: occupy und release.
• Das Zimmer weiß nicht, wer darin wohnt. Das Zimmer geht an jeden Client, der fragt, und der Name des Gastes soll das Hotel nicht verlassen.

Genauer, für Neugierige

Der Zustand ist boolean free. Er könnte auch Text sein („frei“, „belegt“, „in Renovierung“), aber dann ist jeder Vergleich ein Vergleich mit einem String, und ein Tippfehler ist ein Fehler im Programm. Für mehr als zwei Zustände nimmt man eine Aufzählung (Enum): enum RoomState { FREE, TAKEN, REPAIR }.

Sieh es dir an

Das Hotel und die Buchung

Das Hotel hält die Zimmer in einer Liste und die Gäste in einem Dictionary „Zimmernummer → Name“:

Java

private final List<Room> rooms = new ArrayList<>();
private final Map<Integer, String> guests = new HashMap<>();

C#

private readonly List<Room> rooms = new List<Room>();
private readonly Dictionary<int, string> guests = new Dictionary<int, string>();

Python

def __init__(self):
    self._rooms = []
    self._guests = {}

JavaScript

#rooms = [];
#guests = new Map();

Java

public void add(Room room) {
    rooms.add(room);
}

public List<Room> freeRooms() {
    return rooms.stream().filter(Room::isFree).toList();
}

public Room check(int number) {
    return find(number);
}

C#

public void Add(Room room)
{
    rooms.Add(room);
}

public List<Room> FreeRooms()
{
    return rooms.Where(room => room.IsFree).ToList();
}

public Room Check(int number)
{
    return Find(number);
}

Python

def add(self, room):
    self._rooms.append(room)

def free_rooms(self):
    return [room for room in self._rooms if room.is_free]

def check(self, number):
    return self._find(number)

JavaScript

add(room) {
  this.#rooms.push(room);
}

freeRooms() {
  return this.#rooms.filter((room) => room.isFree);
}

check(number) {
  return this.#find(number);
}

find ist privat: Sie sucht das Zimmer nach Nummer oder wirft eine Exception. So kann niemand von außen ein Zimmer nehmen und es an den Regeln vorbei belegen:

Java

private Room find(int number) {
    for (Room room : rooms) {
        if (room.getNumber() == number) {
            return room;
        }
    }
    throw new RoomNotFoundException("Es gibt kein Zimmer " + number + ".");
}

C#

private Room Find(int number)
{
    Room room = rooms.FirstOrDefault(r => r.Number == number);
    if (room == null)
    {
        throw new RoomNotFoundException("Es gibt kein Zimmer " + number + ".");
    }
    return room;
}

Python

def _find(self, number):
    for room in self._rooms:
        if room.number == number:
            return room
    raise RoomNotFoundError(f"Es gibt kein Zimmer {number}.")

JavaScript

#find(number) {
  const room = this.#rooms.find((r) => r.number === number);
  if (room === undefined) {
    throw new RoomNotFoundError(`Es gibt kein Zimmer ${number}.`);
  }
  return room;
}

Die Buchung prüft den Namen, findet das Zimmer und prüft, ob es frei ist. Erst dann belegt sie es:

Java

public void reserve(int number, String guest) {
    if (guest.isBlank()) {
        throw new HotelException("Der Name des Gastes ist Pflicht.");
    }
    Room room = find(number);
    if (!room.isFree()) {
        throw new RoomTakenException("Zimmer " + number + " ist schon belegt.");
    }
    room.occupy();
    guests.put(number, guest);
}

C#

public void Reserve(int number, string guest)
{
    if (string.IsNullOrWhiteSpace(guest))
    {
        throw new HotelException("Der Name des Gastes ist Pflicht.");
    }
    Room room = Find(number);
    if (!room.IsFree)
    {
        throw new RoomTakenException("Zimmer " + number + " ist schon belegt.");
    }
    room.Occupy();
    guests[number] = guest;
}

Python

def reserve(self, number, guest):
    if not guest.strip():
        raise HotelError("Der Name des Gastes ist Pflicht.")
    room = self._find(number)
    if not room.is_free:
        raise RoomTakenError(f"Zimmer {number} ist schon belegt.")
    room.occupy()
    self._guests[number] = guest

JavaScript

reserve(number, guest) {
  if (guest.trim() === "") {
    throw new HotelError("Der Name des Gastes ist Pflicht.");
  }
  const room = this.#find(number);
  if (!room.isFree) {
    throw new RoomTakenError(`Zimmer ${number} ist schon belegt.`);
  }
  room.occupy();
  this.#guests.set(number, guest);
}

Java

Hotel hotel = new Hotel();
hotel.add(new Room(101, "Einzelzimmer", 60));
hotel.add(new Room(102, "Doppelzimmer", 85));
hotel.add(new Room(201, "Doppelzimmer", 95));
hotel.add(new Room(202, "Suite", 140));

for (Room room : hotel.freeRooms()) {
    System.out.println(room);
}
hotel.reserve(102, "Anna Petrova");
System.out.println("Nach der Buchung: " + hotel.check(102));
System.out.println("Freie Zimmer: " + hotel.freeRooms().size());

Ausgabe

101, Einzelzimmer, 60 € pro Nacht, frei
102, Doppelzimmer, 85 € pro Nacht, frei
201, Doppelzimmer, 95 € pro Nacht, frei
202, Suite, 140 € pro Nacht, frei
Nach der Buchung: 102, Doppelzimmer, 85 € pro Nacht, belegt
Freie Zimmer: 3

C#

Hotel hotel = new Hotel();
hotel.Add(new Room(101, "Einzelzimmer", 60));
hotel.Add(new Room(102, "Doppelzimmer", 85));
hotel.Add(new Room(201, "Doppelzimmer", 95));
hotel.Add(new Room(202, "Suite", 140));

foreach (Room room in hotel.FreeRooms())
{
    Console.WriteLine(room);
}
hotel.Reserve(102, "Anna Petrova");
Console.WriteLine("Nach der Buchung: " + hotel.Check(102));
Console.WriteLine("Freie Zimmer: " + hotel.FreeRooms().Count);

Ausgabe

101, Einzelzimmer, 60 € pro Nacht, frei
102, Doppelzimmer, 85 € pro Nacht, frei
201, Doppelzimmer, 95 € pro Nacht, frei
202, Suite, 140 € pro Nacht, frei
Nach der Buchung: 102, Doppelzimmer, 85 € pro Nacht, belegt
Freie Zimmer: 3

Python

hotel = Hotel()
hotel.add(Room(101, "Einzelzimmer", 60))
hotel.add(Room(102, "Doppelzimmer", 85))
hotel.add(Room(201, "Doppelzimmer", 95))
hotel.add(Room(202, "Suite", 140))

for room in hotel.free_rooms():
    print(room)
hotel.reserve(102, "Anna Petrova")
print(f"Nach der Buchung: {hotel.check(102)}")
print(f"Freie Zimmer: {len(hotel.free_rooms())}")

Ausgabe

101, Einzelzimmer, 60 € pro Nacht, frei
102, Doppelzimmer, 85 € pro Nacht, frei
201, Doppelzimmer, 95 € pro Nacht, frei
202, Suite, 140 € pro Nacht, frei
Nach der Buchung: 102, Doppelzimmer, 85 € pro Nacht, belegt
Freie Zimmer: 3

JavaScript

const hotel = new Hotel();
hotel.add(new Room(101, "Einzelzimmer", 60));
hotel.add(new Room(102, "Doppelzimmer", 85));
hotel.add(new Room(201, "Doppelzimmer", 95));
hotel.add(new Room(202, "Suite", 140));

for (const room of hotel.freeRooms()) {
  console.log(String(room));
}
hotel.reserve(102, "Anna Petrova");
console.log(`Nach der Buchung: ${hotel.check(102)}`);
console.log(`Freie Zimmer: ${hotel.freeRooms().length}`);

Ausgabe

101, Einzelzimmer, 60 € pro Nacht, frei
102, Doppelzimmer, 85 € pro Nacht, frei
201, Doppelzimmer, 95 € pro Nacht, frei
202, Suite, 140 € pro Nacht, frei
Nach der Buchung: 102, Doppelzimmer, 85 € pro Nacht, belegt
Freie Zimmer: 3

Die Idee

Stornieren und die Regeln

Nicht jede Anfrage lässt sich ausführen: Das Zimmer ist belegt, es gibt kein Zimmer 305, ein Gast storniert die Buchung eines anderen. Das sind Absagen nach den Regeln, deshalb sind es eigene Exceptions mit einer gemeinsamen Basisklasse:

Java

class HotelException extends RuntimeException {
    public HotelException(String message) {
        super(message);
    }
}

class RoomNotFoundException extends HotelException {
    public RoomNotFoundException(String message) {
        super(message);
    }
}

class RoomTakenException extends HotelException {
    public RoomTakenException(String message) {
        super(message);
    }
}

C#

public class HotelException : Exception
{
    public HotelException(string message) : base(message)
    {
    }
}

public class RoomNotFoundException : HotelException
{
    public RoomNotFoundException(string message) : base(message)
    {
    }
}

public class RoomTakenException : HotelException
{
    public RoomTakenException(string message) : base(message)
    {
    }
}

Python

class HotelError(Exception):
    pass


class RoomNotFoundError(HotelError):
    pass


class RoomTakenError(HotelError):
    pass

JavaScript

class HotelError extends Error {
  constructor(message) {
    super(message);
    this.name = "HotelError";
  }
}

class RoomNotFoundError extends HotelError {
  constructor(message) {
    super(message);
    this.name = "RoomNotFoundError";
  }
}

class RoomTakenError extends HotelError {
  constructor(message) {
    super(message);
    this.name = "RoomTakenError";
  }
}

Das Stornieren prüft, dass das Zimmer belegt ist und dass derselbe Gast es storniert:

Java

public void cancel(int number, String guest) {
    Room room = find(number);
    if (room.isFree()) {
        throw new HotelException("Zimmer " + number + " ist nicht gebucht.");
    }
    if (!guests.get(number).equals(guest)) {
        throw new HotelException("Zimmer " + number + " ist von einem anderen Gast gebucht.");
    }
    room.release();
    guests.remove(number);
}

C#

public void Cancel(int number, string guest)
{
    Room room = Find(number);
    if (room.IsFree)
    {
        throw new HotelException("Zimmer " + number + " ist nicht gebucht.");
    }
    if (guests[number] != guest)
    {
        throw new HotelException("Zimmer " + number + " ist von einem anderen Gast gebucht.");
    }
    room.Release();
    guests.Remove(number);
}

Python

def cancel(self, number, guest):
    room = self._find(number)
    if room.is_free:
        raise HotelError(f"Zimmer {number} ist nicht gebucht.")
    if self._guests[number] != guest:
        raise HotelError(f"Zimmer {number} ist von einem anderen Gast gebucht.")
    room.release()
    del self._guests[number]

JavaScript

cancel(number, guest) {
  const room = this.#find(number);
  if (room.isFree) {
    throw new HotelError(`Zimmer ${number} ist nicht gebucht.`);
  }
  if (this.#guests.get(number) !== guest) {
    throw new HotelError(`Zimmer ${number} ist von einem anderen Gast gebucht.`);
  }
  room.release();
  this.#guests.delete(number);
}

Die Projektaufgabe verlangt, das System in verschiedenen Szenarien zu prüfen: buchen, prüfen und stornieren, sowohl wenn alles gültig ist als auch wenn nicht. Jedes Szenario ist eine Zeile in der Ausgabe:

Java

Hotel hotel = new Hotel();
hotel.add(new Room(101, "Einzelzimmer", 60));
hotel.add(new Room(102, "Doppelzimmer", 85));
hotel.add(new Room(201, "Doppelzimmer", 95));
hotel.add(new Room(202, "Suite", 140));

hotel.reserve(102, "Anna Petrova");
System.out.println("1. Freies Zimmer: " + hotel.check(102));
try {
    hotel.reserve(102, "Boris Iliev");
} catch (RoomTakenException e) {
    System.out.println("2. Belegtes Zimmer: " + e.getMessage());
}
try {
    hotel.cancel(102, "Boris Iliev");
} catch (HotelException e) {
    System.out.println("3. Fremde Buchung: " + e.getMessage());
}
hotel.cancel(102, "Anna Petrova");
System.out.println("4. Stornierung: " + hotel.check(102));
try {
    hotel.cancel(102, "Anna Petrova");
} catch (HotelException e) {
    System.out.println("5. Zweite Stornierung: " + e.getMessage());
}
try {
    hotel.reserve(305, "Anna Petrova");
} catch (RoomNotFoundException e) {
    System.out.println("6. Kein solches Zimmer: " + e.getMessage());
}
try {
    hotel.reserve(201, " ");
} catch (HotelException e) {
    System.out.println("7. Ohne Namen: " + e.getMessage());
}

Ausgabe

1. Freies Zimmer: 102, Doppelzimmer, 85 € pro Nacht, belegt
2. Belegtes Zimmer: Zimmer 102 ist schon belegt.
3. Fremde Buchung: Zimmer 102 ist von einem anderen Gast gebucht.
4. Stornierung: 102, Doppelzimmer, 85 € pro Nacht, frei
5. Zweite Stornierung: Zimmer 102 ist nicht gebucht.
6. Kein solches Zimmer: Es gibt kein Zimmer 305.
7. Ohne Namen: Der Name des Gastes ist Pflicht.

C#

Hotel hotel = new Hotel();
hotel.Add(new Room(101, "Einzelzimmer", 60));
hotel.Add(new Room(102, "Doppelzimmer", 85));
hotel.Add(new Room(201, "Doppelzimmer", 95));
hotel.Add(new Room(202, "Suite", 140));

hotel.Reserve(102, "Anna Petrova");
Console.WriteLine("1. Freies Zimmer: " + hotel.Check(102));
try
{
    hotel.Reserve(102, "Boris Iliev");
}
catch (RoomTakenException e)
{
    Console.WriteLine("2. Belegtes Zimmer: " + e.Message);
}
try
{
    hotel.Cancel(102, "Boris Iliev");
}
catch (HotelException e)
{
    Console.WriteLine("3. Fremde Buchung: " + e.Message);
}
hotel.Cancel(102, "Anna Petrova");
Console.WriteLine("4. Stornierung: " + hotel.Check(102));
try
{
    hotel.Cancel(102, "Anna Petrova");
}
catch (HotelException e)
{
    Console.WriteLine("5. Zweite Stornierung: " + e.Message);
}
try
{
    hotel.Reserve(305, "Anna Petrova");
}
catch (RoomNotFoundException e)
{
    Console.WriteLine("6. Kein solches Zimmer: " + e.Message);
}
try
{
    hotel.Reserve(201, " ");
}
catch (HotelException e)
{
    Console.WriteLine("7. Ohne Namen: " + e.Message);
}

Ausgabe

1. Freies Zimmer: 102, Doppelzimmer, 85 € pro Nacht, belegt
2. Belegtes Zimmer: Zimmer 102 ist schon belegt.
3. Fremde Buchung: Zimmer 102 ist von einem anderen Gast gebucht.
4. Stornierung: 102, Doppelzimmer, 85 € pro Nacht, frei
5. Zweite Stornierung: Zimmer 102 ist nicht gebucht.
6. Kein solches Zimmer: Es gibt kein Zimmer 305.
7. Ohne Namen: Der Name des Gastes ist Pflicht.

Python

hotel = Hotel()
hotel.add(Room(101, "Einzelzimmer", 60))
hotel.add(Room(102, "Doppelzimmer", 85))
hotel.add(Room(201, "Doppelzimmer", 95))
hotel.add(Room(202, "Suite", 140))

hotel.reserve(102, "Anna Petrova")
print(f"1. Freies Zimmer: {hotel.check(102)}")
try:
    hotel.reserve(102, "Boris Iliev")
except RoomTakenError as e:
    print(f"2. Belegtes Zimmer: {e}")
try:
    hotel.cancel(102, "Boris Iliev")
except HotelError as e:
    print(f"3. Fremde Buchung: {e}")
hotel.cancel(102, "Anna Petrova")
print(f"4. Stornierung: {hotel.check(102)}")
try:
    hotel.cancel(102, "Anna Petrova")
except HotelError as e:
    print(f"5. Zweite Stornierung: {e}")
try:
    hotel.reserve(305, "Anna Petrova")
except RoomNotFoundError as e:
    print(f"6. Kein solches Zimmer: {e}")
try:
    hotel.reserve(201, " ")
except HotelError as e:
    print(f"7. Ohne Namen: {e}")

Ausgabe

1. Freies Zimmer: 102, Doppelzimmer, 85 € pro Nacht, belegt
2. Belegtes Zimmer: Zimmer 102 ist schon belegt.
3. Fremde Buchung: Zimmer 102 ist von einem anderen Gast gebucht.
4. Stornierung: 102, Doppelzimmer, 85 € pro Nacht, frei
5. Zweite Stornierung: Zimmer 102 ist nicht gebucht.
6. Kein solches Zimmer: Es gibt kein Zimmer 305.
7. Ohne Namen: Der Name des Gastes ist Pflicht.

JavaScript

const hotel = new Hotel();
hotel.add(new Room(101, "Einzelzimmer", 60));
hotel.add(new Room(102, "Doppelzimmer", 85));
hotel.add(new Room(201, "Doppelzimmer", 95));
hotel.add(new Room(202, "Suite", 140));

hotel.reserve(102, "Anna Petrova");
console.log(`1. Freies Zimmer: ${hotel.check(102)}`);
try {
  hotel.reserve(102, "Boris Iliev");
} catch (e) {
  if (!(e instanceof RoomTakenError)) throw e;
  console.log(`2. Belegtes Zimmer: ${e.message}`);
}
try {
  hotel.cancel(102, "Boris Iliev");
} catch (e) {
  if (!(e instanceof HotelError)) throw e;
  console.log(`3. Fremde Buchung: ${e.message}`);
}
hotel.cancel(102, "Anna Petrova");
console.log(`4. Stornierung: ${hotel.check(102)}`);
try {
  hotel.cancel(102, "Anna Petrova");
} catch (e) {
  if (!(e instanceof HotelError)) throw e;
  console.log(`5. Zweite Stornierung: ${e.message}`);
}
try {
  hotel.reserve(305, "Anna Petrova");
} catch (e) {
  if (!(e instanceof RoomNotFoundError)) throw e;
  console.log(`6. Kein solches Zimmer: ${e.message}`);
}
try {
  hotel.reserve(201, " ");
} catch (e) {
  if (!(e instanceof HotelError)) throw e;
  console.log(`7. Ohne Namen: ${e.message}`);
}

Ausgabe

1. Freies Zimmer: 102, Doppelzimmer, 85 € pro Nacht, belegt
2. Belegtes Zimmer: Zimmer 102 ist schon belegt.
3. Fremde Buchung: Zimmer 102 ist von einem anderen Gast gebucht.
4. Stornierung: 102, Doppelzimmer, 85 € pro Nacht, frei
5. Zweite Stornierung: Zimmer 102 ist nicht gebucht.
6. Kein solches Zimmer: Es gibt kein Zimmer 305.
7. Ohne Namen: Der Name des Gastes ist Pflicht.

Die konkrete Exception sagt, was das Problem ist. HotelException fängt alle Absagen auf einmal: Der Server wird nur sie fangen und in eine Antwort für den Client verwandeln.

Genauer, für Neugierige

• Die Exceptions erben von RuntimeException, deshalb schreiben die Methoden kein throws. Das run() eines Threads und Lambdas können keine Checked Exceptions werfen.
• Szenarien wie diese sind natürliche Tests. Mit JUnit wird jedes zu einer Methode mit @Test und assertThrows(RoomTakenException.class, () -> hotel.reserve(102, "Boris Iliev")).

Probier es aus

Wer ist in 201

Was gibt das Programm aus?

Hotel hotel = new Hotel();
hotel.add(new Room(101, "Einzelzimmer", 60));
hotel.add(new Room(102, "Doppelzimmer", 85));
hotel.add(new Room(201, "Doppelzimmer", 95));
hotel.add(new Room(202, "Suite", 140));

hotel.reserve(101, "Anna Petrova");
hotel.reserve(201, "Boris Iliev");
hotel.cancel(101, "Anna Petrova");
try {
    hotel.reserve(201, "Vera Koleva");
    System.out.println("Vera ist in 201");
} catch (RoomTakenException e) {
    System.out.println("Absage für Vera");
}
System.out.println(hotel.freeRooms().size());

Antwort

Absage für Vera
3

Absage für Vera
2

Vera ist in 201
3

Vera ist in 201
2

Prüfen

Die Idee

Das Protokoll: eine Zeile „BEFEHL:Text“

Jede Nachricht ist eine Zeile BEFEHL:Text, und der Server antwortet mit einer Zeile:

Der Client schickt	Der Server antwortet
FREI	OK: und die freien Zimmer, getrennt durch ;
PRÜFEN:102	OK:102, Doppelzimmer, 85 € pro Nacht, belegt
BUCHEN:102;Anna Petrova	OK:Zimmer 102 gehört dir, Anna Petrova. oder FEHLER: und der Grund
STORNIEREN:102;Anna Petrova	OK:Die Buchung für Zimmer 102 ist storniert. oder FEHLER: und der Grund
ENDE	TSCHÜSS, und der Server schließt die Verbindung

Die Wörter des Protokolls sind Konstanten an einer Stelle:

class Protocol {
    public static final String FREE = "FREI";
    public static final String CHECK = "PRÜFEN";
    public static final String RESERVE = "BUCHEN";
    public static final String CANCEL = "STORNIEREN";
    public static final String EXIT = "ENDE";

    public static final String OK = "OK";
    public static final String ERROR = "FEHLER";
    public static final String BYE = "TSCHÜSS";
}

Die Rezeption übersetzt eine Zeile des Protokolls in einen Aufruf des Hotels und zurück:

class Reception {
    private final Hotel hotel;

    public Reception(Hotel hotel) {
        this.hotel = hotel;
    }
    ...
}

public String handle(String line) {
    int colon = line.indexOf(':');
    String command = colon < 0 ? line : line.substring(0, colon);
    String text = colon < 0 ? "" : line.substring(colon + 1);
    try {
        switch (command) {
            case Protocol.FREE:
                return Protocol.OK + ":" + join(hotel.freeRooms());
            case Protocol.CHECK:
                return Protocol.OK + ":" + hotel.check(number(text));
            case Protocol.RESERVE:
                return reserve(text);
            case Protocol.CANCEL:
                return cancel(text);
            default:
                throw new HotelException("Unbekannter Befehl " + command + ".");
        }
    } catch (HotelException e) {
        return Protocol.ERROR + ":" + e.getMessage();
    }
}

private String reserve(String text) {
    String[] parts = numberAndGuest(text);
    int number = number(parts[0]);
    hotel.reserve(number, parts[1]);
    return Protocol.OK + ":Zimmer " + number + " gehört dir, " + parts[1] + ".";
}

private String cancel(String text) {
    String[] parts = numberAndGuest(text);
    int number = number(parts[0]);
    hotel.cancel(number, parts[1]);
    return Protocol.OK + ":Die Buchung für Zimmer " + number + " ist storniert.";
}

private static String[] numberAndGuest(String text) {
    String[] parts = text.split(";", 2);
    if (parts.length != 2) {
        throw new HotelException("Schreib eine Nummer und einen Namen, zum Beispiel „102;Anna Petrova“.");
    }
    return parts;
}

private static int number(String text) {
    try {
        return Integer.parseInt(text.trim());
    } catch (NumberFormatException e) {
        throw new HotelException("Die Zimmernummer ist eine ganze Zahl.");
    }
}

private static String join(List<Room> rooms) {
    if (rooms.isEmpty()) {
        return "Es gibt keine freien Zimmer.";
    }
    return String.join("; ", rooms.stream().map(Room::toString).toList());
}

Die Rezeption merkt sich nichts über den Client: Jede Zeile trägt alles, was nötig ist, sogar den Namen des Gastes. Deshalb reicht eine Rezeption für alle Clients. Das lässt sich ohne Netz prüfen:

Hotel hotel = new Hotel();
hotel.add(new Room(101, "Einzelzimmer", 60));
hotel.add(new Room(102, "Doppelzimmer", 85));
hotel.add(new Room(201, "Doppelzimmer", 95));
hotel.add(new Room(202, "Suite", 140));

Reception reception = new Reception(hotel);
String[] lines = {
    "BUCHEN:102;Anna Petrova",
    "PRÜFEN:102",
    "BUCHEN:102;Boris Iliev",
    "STORNIEREN:102",
    "PRÜFEN:einhundertzwei",
    "ZEIGEN"
};
for (String line : lines) {
    System.out.println("> " + line);
    System.out.println(reception.handle(line));
}

Ausgabe

> BUCHEN:102;Anna Petrova
OK:Zimmer 102 gehört dir, Anna Petrova.
> PRÜFEN:102
OK:102, Doppelzimmer, 85 € pro Nacht, belegt
> BUCHEN:102;Boris Iliev
FEHLER:Zimmer 102 ist schon belegt.
> STORNIEREN:102
FEHLER:Schreib eine Nummer und einen Namen, zum Beispiel „102;Anna Petrova“.
> PRÜFEN:einhundertzwei
FEHLER:Die Zimmernummer ist eine ganze Zahl.
> ZEIGEN
FEHLER:Unbekannter Befehl ZEIGEN.

Genauer, für Neugierige

• Die Befehle könnten eine Aufzählung (Enum) sein: enum Command { FREE, CHECK, RESERVE, CANCEL, EXIT }. Dann sind sie ein eigener Typ mit einer geschlossenen Liste von Werten. Im Kurs sind es Konstanten, weil wir Enums nicht behandelt haben.
• Das Protokoll ist zustandslos: Jede Zeile steht für sich. Das macht es leicht zu prüfen und leicht, mehr Clients zu bedienen. Müsste der Client zuerst sagen „ich bin Anna“, bräuchte jeder Client seine eigene Rezeption, wie die Sitzung im Autohaus.

Sieh es dir an

Der Server

Jeder verbundene Client bekommt seinen eigenen ClientHandler, und die Rezeption ist gemeinsam:

class ClientHandler implements Runnable {
    private final Socket socket;
    private final Reception reception;

    public ClientHandler(Socket socket, Reception reception) {
        this.socket = socket;
        this.reception = reception;
    }

    @Override
    public void run() {
        try (socket;
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
            String line;
            while ((line = in.readLine()) != null && !line.equals(Protocol.EXIT)) {
                out.println(reception.handle(line));
            }
            out.println(Protocol.BYE);
        } catch (IOException e) {
            System.out.println("Die Verbindung zum Client ist abgebrochen: " + e.getMessage());
        }
    }
}

HotelServer nimmt die Clients in einem eigenen Thread an und gibt jeden an einen Pool von 10 Threads weiter:

class HotelServer {
    private final ServerSocket serverSocket;
    private final ExecutorService pool = Executors.newFixedThreadPool(10);
    private final Reception reception;

    public HotelServer(int port, Hotel hotel) throws IOException {
        this.serverSocket = new ServerSocket(port);
        this.reception = new Reception(hotel);
    }

    public void start() {
        Thread acceptor = new Thread(() -> acceptAll());
        acceptor.setDaemon(true);
        acceptor.start();
    }

    private void acceptAll() {
        while (true) {
            try {
                Socket client = serverSocket.accept();
                pool.execute(new ClientHandler(client, reception));
            } catch (IOException e) {
                return;
            }
        }
    }

    public void stop() throws IOException {
        serverSocket.close();
        pool.shutdown();
    }
}

• Zehn Clients werden gleichzeitig bedient. Der elfte wird angenommen und wartet in der Warteschlange des Pools, bis jemand geht.
• Alle zehn Threads rufen dasselbe Hotel auf. Deshalb muss das Hotel seine Zimmer schützen. Wie, gleich.

Sieh es dir an

Der Client

Der Client schickt eine Zeile und liest die Antwort. close() sagt ENDE und schließt die Verbindung:

class HotelClient {
    private final Socket socket;
    private final BufferedReader in;
    private final PrintWriter out;

    public HotelClient(String host, int port) throws IOException {
        socket = new Socket(host, port);
        in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        out = new PrintWriter(socket.getOutputStream(), true);
    }

    public String send(String command, String text) throws IOException {
        out.println(command + ":" + text);
        return in.readLine();
    }

    public String send(String command) throws IOException {
        out.println(command);
        return in.readLine();
    }

    public void close() throws IOException {
        send(Protocol.EXIT);
        socket.close();
    }
}

Server und Client in einem Programm:

Hotel hotel = new Hotel();
hotel.add(new Room(101, "Einzelzimmer", 60));
hotel.add(new Room(102, "Doppelzimmer", 85));
hotel.add(new Room(201, "Doppelzimmer", 95));
hotel.add(new Room(202, "Suite", 140));
HotelServer server = new HotelServer(5341, hotel);
server.start();

HotelClient client = new HotelClient("localhost", 5341);
System.out.println(client.send(Protocol.RESERVE, "102;Anna Petrova"));
System.out.println(client.send(Protocol.CHECK, "102"));
System.out.println(client.send(Protocol.FREE));
System.out.println(client.send(Protocol.CANCEL, "102;Anna Petrova"));
System.out.println(client.send(Protocol.CHECK, "305"));
client.close();
server.stop();

Ausgabe

OK:Zimmer 102 gehört dir, Anna Petrova.
OK:102, Doppelzimmer, 85 € pro Nacht, belegt
OK:101, Einzelzimmer, 60 € pro Nacht, frei; 201, Doppelzimmer, 95 € pro Nacht, frei; 202, Suite, 140 € pro Nacht, frei
OK:Die Buchung für Zimmer 102 ist storniert.
FEHLER:Es gibt kein Zimmer 305.

Die Idee

Zwei für ein Zimmer

Eine Buchung sind zwei Schritte: prüfen, dass das Zimmer frei ist, dann es belegen. Laufen zwei Anfragen gleichzeitig, kann Folgendes passieren:

	Agentur A	Agentur B
1	prüft: 102 ist frei
2		prüft: 102 ist frei
3	belegt 102 für ihren Gast
4		belegt 102 für ihren Gast und trägt ihn ein

Beide bekommen eine Bestätigung. In keiner einzelnen Codezeile steckt ein Fehler. Der Fehler ist, dass sich die Schritte der beiden Anfragen verschränken.

Die Lösung: Ins Hotel kommt immer nur eine Anfrage auf einmal. Dann ist „prüfen und belegen“ unteilbar (atomar): Niemand kann zwischen die Prüfung und das Belegen kommen. In Java macht das synchronized an jeder öffentlichen Methode von Hotel:

public synchronized void reserve(int number, String guest) {
    if (guest.isBlank()) {
        throw new HotelException("Der Name des Gastes ist Pflicht.");
    }
    Room room = find(number);
    if (!room.isFree()) {
        throw new RoomTakenException("Zimmer " + number + " ist schon belegt.");
    }
    room.occupy();
    guests.put(number, guest);
}

public synchronized void reserve(int number, String guest) {
    if (guest.isBlank()) {
        throw new HotelException("Der Name des Gastes ist Pflicht.");
    }
    Room room = find(number);
    if (!room.isFree()) {
        throw new RoomTakenException("Zimmer " + number + " ist schon belegt.");
    }
    room.occupy();
    guests.put(number, guest);
}

Schritt für Schritt, in Worten

1. Zimmer 102 ist frei. Anna Petrova und Boris Iliev buchen es im selben Moment.
2. Zuerst ohne synchronized. Das ist eine mögliche Reihenfolge: Annas Anfrage prüft und sieht „frei“.
3. Boris’ Anfrage prüft, bevor Anna das Zimmer belegt hat: Auch sie sieht „frei“.
4. Anna belegt das Zimmer und trägt ihren Namen ein.
5. Boris belegt das Zimmer auch und trägt seinen Namen ein. Beide haben eine Bestätigung für dasselbe Zimmer.
6. Von vorn, mit synchronized: Nur ein Thread auf einmal kommt ins Hotel.
7. Sagen wir, Anna ist zuerst dran: Sie nimmt den Lock. Prüfen und Belegen sind ein Schritt, und niemand kommt dazwischen.
8. Boris kommt beim Hotel an und wartet, bis der Lock frei ist.
9. Boris hat den Lock. Jetzt sieht die Prüfung „belegt“.
10. RoomTakenException. Die Rezeption schickt sie als Fehlerzeile zurück, und Boris kann nach einem anderen Zimmer fragen.
11. Das Programm aus der Lektion zählt die Erfolgreichen: 1 pro Zimmer. Wer zuerst dran war, ist bei jedem Lauf anders.

Der Beweis: Zwei Clients buchen 102 gleichzeitig, dann buchen zwanzig Agenturen 201 gleichzeitig. Die Antworten werden gesammelt, und das Programm gibt aus, wie viele Erfolg hatten:

static String reserve(int port, int room, String guest) {
    try {
        HotelClient client = new HotelClient("localhost", port);
        String reply = client.send(Protocol.RESERVE, room + ";" + guest);
        client.close();
        return reply;
    } catch (IOException e) {
        return Protocol.ERROR + ":" + e.getMessage();
    }
}

static int race(int port, int room, String[] guests) throws InterruptedException {
    String[] replies = new String[guests.length];
    List<Thread> clients = new ArrayList<>();
    for (int i = 0; i < guests.length; i++) {
        int n = i;
        Thread client = new Thread(() -> replies[n] = reserve(port, room, guests[n]));
        clients.add(client);
        client.start();
    }
    for (Thread client : clients) {
        client.join();
    }
    int reserved = 0;
    for (String reply : replies) {
        if (reply.startsWith(Protocol.OK)) {
            reserved++;
        }
    }
    return reserved;
}

Hotel hotel = new Hotel();
hotel.add(new Room(101, "Einzelzimmer", 60));
hotel.add(new Room(102, "Doppelzimmer", 85));
hotel.add(new Room(201, "Doppelzimmer", 95));
hotel.add(new Room(202, "Suite", 140));
HotelServer server = new HotelServer(5342, hotel);
server.start();

String[] two = { "Anna Petrova", "Boris Iliev" };
System.out.println("Zwei für Zimmer 102, erfolgreich: " + race(5342, 102, two));

String[] agencies = new String[20];
for (int i = 0; i < agencies.length; i++) {
    agencies[i] = "Agentur " + (i + 1);
}
System.out.println("Zwanzig für Zimmer 201, erfolgreich: " + race(5342, 201, agencies));

HotelClient desk = new HotelClient("localhost", 5342);
System.out.println(desk.send(Protocol.FREE));
desk.close();
server.stop();

Ausgabe

Zwei für Zimmer 102, erfolgreich: 1
Zwanzig für Zimmer 201, erfolgreich: 1
OK:101, Einzelzimmer, 60 € pro Nacht, frei; 202, Suite, 140 € pro Nacht, frei

Jeder Client hat seinen eigenen Thread und schreibt seine Antwort an seinen eigenen Platz im Array. main wartet mit join auf alle und zählt die Erfolgreichen.

Wer das Zimmer bekommen hat, ist bei jedem Lauf anders, deshalb gibt das Programm es nicht aus. Wie viele Erfolg hatten, ist immer gleich: einer pro Zimmer.

Genauer, für Neugierige

• Ohne das Sperren würde das Programm trotzdem fast immer 1 sagen: Das Fenster zwischen Prüfen und Belegen ist klein. Aber „fast immer“ heißt, dass einmal in Tausenden Buchungen zwei Gäste vor dem Zimmer stehen. So einen Fehler findest du nicht durch Ausführen, sondern durch Nachdenken: Welche Daten sind gemeinsam, und wer ändert sie gleichzeitig.
• synchronized an einer Methode sperrt das ganze Objekt Hotel. Während ein Thread 102 bucht, wartet ein anderer sogar für 201. Bei vier Zimmern ist das in Ordnung. Bei Tausenden Zimmern sperrt man pro Zimmer, zum Beispiel synchronized (room) { ... }.
• In einem echten System liegen die Zimmer in einer Datenbank, und der Schutz passiert dort: eine Transaktion oder eine Bedingung in der Abfrage selbst (UPDATE rooms SET free = false WHERE number = 102 AND free = true). Dann gilt er auch bei mehreren Servern, nicht nur in einem Programm.

Probier es aus

Gesperrt, aber nicht ganz

Ein Kollege hat die Buchung in zwei Methoden aufgeteilt, beide synchronized. Die Rezeption ruft zuerst die Prüfung auf, dann das Belegen. Bei vielen Anfragen gleichzeitig bekommen manchmal trotzdem zwei dasselbe Zimmer. In welcher Zeile steckt der Fehler?

Wähle die Zeile mit dem Fehler.

1public synchronized boolean isFree(int number) {2 return find(number).isFree();3}45public synchronized void occupy(int number, String guest) {6 find(number).occupy();7 guests.put(number, guest);8}910// in Reception:11if (hotel.isFree(number)) {12 hotel.occupy(number, guest);13}

Prüfen

Sieh es dir an

Das ganze Hotel

Die Testszenarien aus der Aufgabe, diesmal über das Netz, mit zwei gleichzeitig verbundenen Clients. Am Ende buchen zwei im selben Moment 201:

static void say(String who, HotelClient client, String command, String text) throws IOException {
    String reply = text.isEmpty() ? client.send(command) : client.send(command, text);
    System.out.println(who + " > " + command + (text.isEmpty() ? "" : ":" + text));
    System.out.println(who + " < " + reply);
}

Hotel hotel = new Hotel();
hotel.add(new Room(101, "Einzelzimmer", 60));
hotel.add(new Room(102, "Doppelzimmer", 85));
hotel.add(new Room(201, "Doppelzimmer", 95));
hotel.add(new Room(202, "Suite", 140));
HotelServer server = new HotelServer(5343, hotel);
server.start();

HotelClient anna = new HotelClient("localhost", 5343);
HotelClient boris = new HotelClient("localhost", 5343);
say("Anna", anna, Protocol.RESERVE, "102;Anna Petrova");
say("Boris", boris, Protocol.RESERVE, "102;Boris Iliev");
say("Boris", boris, Protocol.CHECK, "102");
say("Boris", boris, Protocol.CANCEL, "102;Boris Iliev");
say("Anna", anna, Protocol.CANCEL, "102;Anna Petrova");
say("Boris", boris, Protocol.RESERVE, "102;Boris Iliev");
say("Anna", anna, Protocol.CHECK, "305");
anna.close();
boris.close();

String[] two = { "Anna Petrova", "Vera Koleva" };
System.out.println("Zwei gleichzeitig für Zimmer 201, erfolgreich: " + race(5343, 201, two));
HotelClient desk = new HotelClient("localhost", 5343);
System.out.println(desk.send(Protocol.FREE));
desk.close();
server.stop();

Ausgabe

Anna > BUCHEN:102;Anna Petrova
Anna < OK:Zimmer 102 gehört dir, Anna Petrova.
Boris > BUCHEN:102;Boris Iliev
Boris < FEHLER:Zimmer 102 ist schon belegt.
Boris > PRÜFEN:102
Boris < OK:102, Doppelzimmer, 85 € pro Nacht, belegt
Boris > STORNIEREN:102;Boris Iliev
Boris < FEHLER:Zimmer 102 ist von einem anderen Gast gebucht.
Anna > STORNIEREN:102;Anna Petrova
Anna < OK:Die Buchung für Zimmer 102 ist storniert.
Boris > BUCHEN:102;Boris Iliev
Boris < OK:Zimmer 102 gehört dir, Boris Iliev.
Anna > PRÜFEN:305
Anna < FEHLER:Es gibt kein Zimmer 305.
Zwei gleichzeitig für Zimmer 201, erfolgreich: 1
OK:101, Einzelzimmer, 60 € pro Nacht, frei; 202, Suite, 140 € pro Nacht, frei

Genauer, für Neugierige

Das ganze Programm, von Anfang bis Ende:

Main.java

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.*;

class Room {
    private final int number;
    private final String type;
    private final int price;
    private boolean free = true;

    public Room(int number, String type, int price) {
        this.number = number;
        this.type = type;
        this.price = price;
    }

    public int getNumber() {
        return number;
    }

    public String getType() {
        return type;
    }

    public int getPrice() {
        return price;
    }

    public boolean isFree() {
        return free;
    }

    public void occupy() {
        free = false;
    }

    public void release() {
        free = true;
    }

    @Override
    public String toString() {
        return number + ", " + type + ", " + price + " € pro Nacht, " + (free ? "frei" : "belegt");
    }
}

class Hotel {
    private final List<Room> rooms = new ArrayList<>();
    private final Map<Integer, String> guests = new HashMap<>();

    public synchronized void add(Room room) {
        rooms.add(room);
    }

    public synchronized List<Room> freeRooms() {
        return rooms.stream().filter(Room::isFree).toList();
    }

    public synchronized Room check(int number) {
        return find(number);
    }

    public synchronized void reserve(int number, String guest) {
        if (guest.isBlank()) {
            throw new HotelException("Der Name des Gastes ist Pflicht.");
        }
        Room room = find(number);
        if (!room.isFree()) {
            throw new RoomTakenException("Zimmer " + number + " ist schon belegt.");
        }
        room.occupy();
        guests.put(number, guest);
    }

    public synchronized void cancel(int number, String guest) {
        Room room = find(number);
        if (room.isFree()) {
            throw new HotelException("Zimmer " + number + " ist nicht gebucht.");
        }
        if (!guests.get(number).equals(guest)) {
            throw new HotelException("Zimmer " + number + " ist von einem anderen Gast gebucht.");
        }
        room.release();
        guests.remove(number);
    }

    private Room find(int number) {
        for (Room room : rooms) {
            if (room.getNumber() == number) {
                return room;
            }
        }
        throw new RoomNotFoundException("Es gibt kein Zimmer " + number + ".");
    }
}

class HotelException extends RuntimeException {
    public HotelException(String message) {
        super(message);
    }
}

class RoomNotFoundException extends HotelException {
    public RoomNotFoundException(String message) {
        super(message);
    }
}

class RoomTakenException extends HotelException {
    public RoomTakenException(String message) {
        super(message);
    }
}

class Protocol {
    public static final String FREE = "FREI";
    public static final String CHECK = "PRÜFEN";
    public static final String RESERVE = "BUCHEN";
    public static final String CANCEL = "STORNIEREN";
    public static final String EXIT = "ENDE";

    public static final String OK = "OK";
    public static final String ERROR = "FEHLER";
    public static final String BYE = "TSCHÜSS";
}

class Reception {
    private final Hotel hotel;

    public Reception(Hotel hotel) {
        this.hotel = hotel;
    }

    public String handle(String line) {
        int colon = line.indexOf(':');
        String command = colon < 0 ? line : line.substring(0, colon);
        String text = colon < 0 ? "" : line.substring(colon + 1);
        try {
            switch (command) {
                case Protocol.FREE:
                    return Protocol.OK + ":" + join(hotel.freeRooms());
                case Protocol.CHECK:
                    return Protocol.OK + ":" + hotel.check(number(text));
                case Protocol.RESERVE:
                    return reserve(text);
                case Protocol.CANCEL:
                    return cancel(text);
                default:
                    throw new HotelException("Unbekannter Befehl " + command + ".");
            }
        } catch (HotelException e) {
            return Protocol.ERROR + ":" + e.getMessage();
        }
    }

    private String reserve(String text) {
        String[] parts = numberAndGuest(text);
        int number = number(parts[0]);
        hotel.reserve(number, parts[1]);
        return Protocol.OK + ":Zimmer " + number + " gehört dir, " + parts[1] + ".";
    }

    private String cancel(String text) {
        String[] parts = numberAndGuest(text);
        int number = number(parts[0]);
        hotel.cancel(number, parts[1]);
        return Protocol.OK + ":Die Buchung für Zimmer " + number + " ist storniert.";
    }

    private static String[] numberAndGuest(String text) {
        String[] parts = text.split(";", 2);
        if (parts.length != 2) {
            throw new HotelException("Schreib eine Nummer und einen Namen, zum Beispiel „102;Anna Petrova“.");
        }
        return parts;
    }

    private static int number(String text) {
        try {
            return Integer.parseInt(text.trim());
        } catch (NumberFormatException e) {
            throw new HotelException("Die Zimmernummer ist eine ganze Zahl.");
        }
    }

    private static String join(List<Room> rooms) {
        if (rooms.isEmpty()) {
            return "Es gibt keine freien Zimmer.";
        }
        return String.join("; ", rooms.stream().map(Room::toString).toList());
    }
}

class ClientHandler implements Runnable {
    private final Socket socket;
    private final Reception reception;

    public ClientHandler(Socket socket, Reception reception) {
        this.socket = socket;
        this.reception = reception;
    }

    @Override
    public void run() {
        try (socket;
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
            String line;
            while ((line = in.readLine()) != null && !line.equals(Protocol.EXIT)) {
                out.println(reception.handle(line));
            }
            out.println(Protocol.BYE);
        } catch (IOException e) {
            System.out.println("Die Verbindung zum Client ist abgebrochen: " + e.getMessage());
        }
    }
}

class HotelServer {
    private final ServerSocket serverSocket;
    private final ExecutorService pool = Executors.newFixedThreadPool(10);
    private final Reception reception;

    public HotelServer(int port, Hotel hotel) throws IOException {
        this.serverSocket = new ServerSocket(port);
        this.reception = new Reception(hotel);
    }

    public void start() {
        Thread acceptor = new Thread(() -> acceptAll());
        acceptor.setDaemon(true);
        acceptor.start();
    }

    private void acceptAll() {
        while (true) {
            try {
                Socket client = serverSocket.accept();
                pool.execute(new ClientHandler(client, reception));
            } catch (IOException e) {
                return;
            }
        }
    }

    public void stop() throws IOException {
        serverSocket.close();
        pool.shutdown();
    }
}

class HotelClient {
    private final Socket socket;
    private final BufferedReader in;
    private final PrintWriter out;

    public HotelClient(String host, int port) throws IOException {
        socket = new Socket(host, port);
        in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        out = new PrintWriter(socket.getOutputStream(), true);
    }

    public String send(String command, String text) throws IOException {
        out.println(command + ":" + text);
        return in.readLine();
    }

    public String send(String command) throws IOException {
        out.println(command);
        return in.readLine();
    }

    public void close() throws IOException {
        send(Protocol.EXIT);
        socket.close();
    }
}

public class Main {
    static void say(String who, HotelClient client, String command, String text) throws IOException {
        String reply = text.isEmpty() ? client.send(command) : client.send(command, text);
        System.out.println(who + " > " + command + (text.isEmpty() ? "" : ":" + text));
        System.out.println(who + " < " + reply);
    }

    static String reserve(int port, int room, String guest) {
        try {
            HotelClient client = new HotelClient("localhost", port);
            String reply = client.send(Protocol.RESERVE, room + ";" + guest);
            client.close();
            return reply;
        } catch (IOException e) {
            return Protocol.ERROR + ":" + e.getMessage();
        }
    }

    static int race(int port, int room, String[] guests) throws InterruptedException {
        String[] replies = new String[guests.length];
        List<Thread> clients = new ArrayList<>();
        for (int i = 0; i < guests.length; i++) {
            int n = i;
            Thread client = new Thread(() -> replies[n] = reserve(port, room, guests[n]));
            clients.add(client);
            client.start();
        }
        for (Thread client : clients) {
            client.join();
        }
        int reserved = 0;
        for (String reply : replies) {
            if (reply.startsWith(Protocol.OK)) {
                reserved++;
            }
        }
        return reserved;
    }

    public static void main(String[] args) throws Exception {
        Hotel hotel = new Hotel();
        hotel.add(new Room(101, "Einzelzimmer", 60));
        hotel.add(new Room(102, "Doppelzimmer", 85));
        hotel.add(new Room(201, "Doppelzimmer", 95));
        hotel.add(new Room(202, "Suite", 140));
        HotelServer server = new HotelServer(5343, hotel);
        server.start();

        HotelClient anna = new HotelClient("localhost", 5343);
        HotelClient boris = new HotelClient("localhost", 5343);
        say("Anna", anna, Protocol.RESERVE, "102;Anna Petrova");
        say("Boris", boris, Protocol.RESERVE, "102;Boris Iliev");
        say("Boris", boris, Protocol.CHECK, "102");
        say("Boris", boris, Protocol.CANCEL, "102;Boris Iliev");
        say("Anna", anna, Protocol.CANCEL, "102;Anna Petrova");
        say("Boris", boris, Protocol.RESERVE, "102;Boris Iliev");
        say("Anna", anna, Protocol.CHECK, "305");
        anna.close();
        boris.close();

        String[] two = { "Anna Petrova", "Vera Koleva" };
        System.out.println("Zwei gleichzeitig für Zimmer 201, erfolgreich: " + race(5343, 201, two));
        HotelClient desk = new HotelClient("localhost", 5343);
        System.out.println(desk.send(Protocol.FREE));
        desk.close();
        server.stop();
    }
}

Übung

Mach allein weiter

Arbeite mit dem ganzen Programm aus der vorigen Karte.

1. Zimmerwechsel. Der Gast zieht von einem Zimmer in ein anderes mit VERLEGEN:102;202;Anna Petrova. Die Antwort ist OK:Anna Petrova ist in Zimmer 202. Ist das neue Zimmer belegt, bleibt der Gast im alten. Der Wechsel ist eine Methode in Hotel, synchronized: Niemand darf das neue Zimmer zwischen dem Freigeben des alten und dem Belegen des neuen nehmen.

Ausgabe

OK:Zimmer 102 gehört dir, Anna Petrova.
OK:Zimmer 201 gehört dir, Boris Iliev.
FEHLER:Zimmer 201 ist schon belegt.
OK:Anna Petrova ist in Zimmer 202.
OK:101, Einzelzimmer, 60 € pro Nacht, frei; 102, Doppelzimmer, 85 € pro Nacht, frei

Weitere Ideen

• Nächte und Summe. Eine Buchung gilt für eine Anzahl Nächte, und die Bestätigung nennt die Summe: „3 Nächte, 255 €“.
• Daten. Ein Zimmer wird für Tage gebucht, zum Beispiel vom 14. bis 16. Dezember. Zwei Buchungen für dasselbe Zimmer dürfen sich nicht überschneiden. Ob das Zimmer frei ist, hängt von den Daten ab.
• Meine Buchungen. MEINE:Anna Petrova sagt, welche Zimmer zu diesem Gast gehören.
• Warteliste. Ist das Zimmer belegt, trägt sich der Gast zum Warten ein. Wird es storniert, geht es an den Ersten auf der Liste.
• Ein Client über die Tastatur. Ein zweites Programm liest Befehle von der Tastatur mit Scanner und schickt sie an den Server, der in einem anderen Terminal läuft.

Test

Teste dich

1. Zwei Agenturen buchen Zimmer 102 im selben Moment, und die Buchung ist nicht synchronisiert. Was kann passieren?

Nichts, die zweite bekommt immer eine AbsageDas Programm bricht mit einer Exception abBeide prüfen „frei“, beide bekommen eine Bestätigung, und im Zimmer stehen zwei Gäste

2. Die Prüfung „ist es frei“ und das Belegen des Zimmers stehen in zwei getrennten synchronisierten Methoden. Reicht das?

Nein. Zwischen den beiden Aufrufen ist der Lock frei, und ein anderer Client kann das Zimmer belegenJa, wenn die Methoden im Code nebeneinander stehenJa, jede Methode ist gesperrt

3. Zimmer 102 ist belegt. Was bekommt der Client, der BUCHEN:102;Boris Iliev schickt?

Die Verbindung wird geschlossenNichts, der Server hält anDie Zeile „FEHLER:Zimmer 102 ist schon belegt.“, und die Verbindung bleibt offen, damit er noch einmal fragen kann

4. Warum gibt das Programm aus, wie viele Buchungen erfolgreich waren, und nicht, wer das Zimmer bekommen hat?

Weil der Server nicht sagt, wer gewonnen hatWer zuerst kommt, ist Zufall und bei jedem Lauf anders. Die Zahl der Erfolgreichen ist immer 1, wenn das Sperren richtig istWeil der Name nicht wichtig ist

5. Warum stehen die Namen der Gäste in einem Dictionary im Hotel und nicht im Zimmer?

Weil ein Zimmer kein Textfeld haben kannDas ist schnellerDas Zimmer geht an jeden Client (als Text oder JSON), und der Name des Gastes soll den Server nicht verlassen

Prüfen

Lektion von vorn beginnen

Verwandte Lektionen

• Baut auf: Lambdas · Streams · Threads · Netzwerkprogrammierung
• Aufgaben zum Thema: Projekt