O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

API-Design, 1st Edition

Book Description

Mit Schnittstellen zum Zwecke der Arbeitsteilung, Wiederverwendung oder beispielsweise zur Bildung einer modularen Architektur haben Entwickler täglich zu tun. Häufig werden hierbei jedoch nur unbewusst durch Erfahrung erlernte Konzepte und Best-Practices genutzt.Dieses Buch schärft den Blick für APIs und erläutert, welche Eigenschaften effektive APIs haben sollten. Das Thema API-Design, das in anderen Büchern über Softwaredesign und Architektur als Querschnittsthema auftaucht, wird in diesem Buch umfassend behandelt.Nach der erfolgreichen Lektüre kennt der Leser die Grundlagenprinzipien von APIs und ist in der Lage, in professionellen Projekten APIs für Softwarekomponenten und Webservices zu entwerfen, zu dokumentieren und je nach Kompatibilitätsziel zu verändern.

Table of Contents

  1. Cover
  2. Titel
  3. Impressum
  4. Hingabe
  5. Vorwort
  6. Inhaltsübersicht
  7. Inhaltsverzeichnis
  8. Teil I Grundlagen
    1. 1 Application Programming Interfaces – eine Einführung
      1. 1.1 Eine kurze Geschichte der APIs
      2. 1.2 Web-APIs ab dem Jahr 2000
      3. 1.3 API-Definition
      4. 1.4 Vorteile einer API
      5. 1.5 Nachteile einer API
      6. 1.6 API als Produkt
      7. 1.7 Welche Strategien verfolgen Unternehmen mit APIs?
      8. 1.8 Zusammenfassung
    2. 2 Qualitätsmerkmale
      1. 2.1 Allgemeine Qualitätsmerkmale
      2. 2.2 Benutzbarkeit
        1. 2.2.1 Konsistent
        2. 2.2.2 Intuitiv verständlich
        3. 2.2.3 Dokumentiert
        4. 2.2.4 Einprägsam und leicht zu lernen
        5. 2.2.5 Lesbaren Code fördernd
        6. 2.2.6 Schwer falsch zu benutzen
        7. 2.2.7 Minimal
        8. 2.2.8 Stabil
        9. 2.2.9 Einfach erweiterbar
      3. 2.3 Zusammenfassung
    3. 3 Allgemeines Vorgehen beim API-Design
      1. 3.1 Überblick
      2. 3.2 Heuristiken und Trade-offs
      3. 3.3 Anforderungen herausarbeiten
      4. 3.4 Wenn Use Cases nicht ausreichen
      5. 3.5 Entwurf mit Szenarien und Codebeispielen
      6. 3.6 Spezifikation erstellen
      7. 3.7 Reviews und Feedback
      8. 3.8 Wiederverwendung
      9. 3.9 Zusammenfassung
  9. Teil II Java-APIs
    1. 4 Ausprägungen
      1. 4.1 Implizite Objekt-API
      2. 4.2 Utility-Bibliothek
      3. 4.3 Service
      4. 4.4 Framework
      5. 4.5 Eine Frage der Priorität
      6. 4.6 Zusammenfassung
    2. 5 Grundlagen für Java-APIs
      1. 5.1 Auswahl passender Namen
        1. 5.1.1 Klassennamen
        2. 5.1.2 Methodennamen
        3. 5.1.3 Parameternamen
        4. 5.1.4 Ubiquitäre Sprache
        5. 5.1.5 Fazit
      2. 5.2 Effektiver Einsatz von Typen
        1. 5.2.1 Semantischen Vertrag minimieren
        2. 5.2.2 Semantische Verletzung der Datenkapselung vermeiden
        3. 5.2.3 Werden Namen überschätzt?
        4. 5.2.4 Fazit
      3. 5.3 Techniken für Objektkollaboration
        1. 5.3.1 Tell, Don’t Ask
        2. 5.3.2 Command/Query Separation
        3. 5.3.3 Law of Demeter
        4. 5.3.4 Platzierung von Methoden
        5. 5.3.5 Fazit
      4. 5.4 Minimale Sichtbarkeit
        1. 5.4.1 Packages
        2. 5.4.2 Klassen
        3. 5.4.3 Methoden
        4. 5.4.4 Felder
        5. 5.4.5 Fazit
      5. 5.5 Optionale Hilfsmethoden
        1. 5.5.1 Komfort
        2. 5.5.2 Utility-Klassen
        3. 5.5.3 Fazit
      6. 5.6 Optionale Rückgabewerte
        1. 5.6.1 Ad-hoc-Fehlerbehandlung
        2. 5.6.2 Null-Objekte
        3. 5.6.3 Ergebnisobjekte
        4. 5.6.4 Fazit
      7. 5.7 Exceptions
        1. 5.7.1 Ausnahmesituationen
        2. 5.7.2 Checked Exception versus Unchecked Exception
        3. 5.7.3 Passende Abstraktionen
        4. 5.7.4 Dokumentation von Exceptions
        5. 5.7.5 Vermeidung von Exceptions
        6. 5.7.6 Fazit
      8. 5.8 Objekterzeugung
        1. 5.8.1 Erzeugungsmuster der GoF
        2. 5.8.2 Statische Factory-Methode
        3. 5.8.3 Builder mit Fluent Interface
        4. 5.8.4 Praktische Anwendung der Erzeugungsmuster
        5. 5.8.5 Fazit
      9. 5.9 Vererbung
        1. 5.9.1 Ansätze zum Einsatz von Vererbung
        2. 5.9.2 Stolperfallen bei Vererbung
        3. 5.9.3 Bedeutung für API-Design
        4. 5.9.4 Fazit
      10. 5.10 Interfaces
        1. 5.10.1 Typen nachrüsten
        2. 5.10.2 Unterstützung für nicht triviale Interfaces
        3. 5.10.3 Markierungsschnittstellen
        4. 5.10.4 Funktionale Interfaces
        5. 5.10.5 Fazit
      11. 5.11 Zusammenfassung
    3. 6 Fortgeschrittene Techniken für Java-APIs
      1. 6.1 Fluent Interface
        1. 6.1.1 DSL-Grammatik
        2. 6.1.2 Schachteln versus Verketten
        3. 6.1.3 Fluent Interface von jOOQ
        4. 6.1.4 Ist der Aufwand gerechtfertigt?
        5. 6.1.5 Fazit
      2. 6.2 Template-Methoden
        1. 6.2.1 API versus SPI
        2. 6.2.2 Erweiterbare Parameter
        3. 6.2.3 Fazit
      3. 6.3 Callbacks
        1. 6.3.1 Synchrone Callbacks
        2. 6.3.2 Asynchrone Callbacks
        3. 6.3.3 Fazit
      4. 6.4 Annotationen
        1. 6.4.1 Auswertung zum Kompilierzeitpunkt
        2. 6.4.2 Auswertung zur Laufzeit
        3. 6.4.3 Fazit
      5. 6.5 Wrapper-Interfaces
        1. 6.5.1 Proxy
        2. 6.5.2 Adapter
        3. 6.5.3 Fassade
        4. 6.5.4 Fazit
      6. 6.6 Immutability
        1. 6.6.1 Wiederverwendung
        2. 6.6.2 Thread-Sicherheit
        3. 6.6.3 Einfachheit
        4. 6.6.4 Umsetzung
        5. 6.6.5 Automatische Überprüfung mit dem Mutability Detector
        6. 6.6.6 Codegenerierung mit Immutables
        7. 6.6.7 Fazit
      7. 6.7 Thread-sichere APIs
        1. 6.7.1 Vorteile
        2. 6.7.2 Nachteile
        3. 6.7.3 Was bedeutet Thread-Sicherheit?
        4. 6.7.4 Fazit
      8. 6.8 Zusammenfassung
    4. 7 Kompatibilität von Java-APIs
      1. 7.1 Kompatibilitätsstufen
        1. 7.1.1 Code-Kompatibilität
        2. 7.1.2 Binäre Kompatibilität
        3. 7.1.3 Funktionale Kompatibilität
      2. 7.2 Verwandtschaftsbeziehungen
      3. 7.3 Design by Contract
      4. 7.4 Codeänderungen
        1. 7.4.1 Package-Änderungen
        2. 7.4.2 Interface-Änderungen
        3. 7.4.3 Klassenänderungen
        4. 7.4.4 Spezialisierung von Rückgabetypen
        5. 7.4.5 Generalisierung von Parametertypen
        6. 7.4.6 Generics
        7. 7.4.7 Ausnahmen
        8. 7.4.8 Statische Methoden und Konstanten
      5. 7.5 Praktische Techniken für API-Änderungen
      6. 7.6 Test Compatibility Kit
      7. 7.7 Zusammenfassung
  10. Teil III Remote-APIs
    1. 8 Grundlagen RESTful HTTP
      1. 8.1 REST versus HTTP
      2. 8.2 REST-Grundprinzipien
      3. 8.3 Ressourcen – die zentralen Bausteine
      4. 8.4 HTTP-Methoden
      5. 8.5 HATEOAS
      6. 8.6 Zusammenfassung
    2. 9 Techniken für Web-APIs
      1. 9.1 Anwendungsbeispiel: Onlineshop
      2. 9.2 URI-Design
      3. 9.3 Medientypen
      4. 9.4 Fehlerbehandlung
      5. 9.5 Versionierung
        1. 9.5.1 Versionsidentifikation
      6. 9.6 Sicherheitsmechanismen
      7. 9.7 Partielle Rückgaben
      8. 9.8 Zusammenfassung
    3. 10 SOAP-Webservices
      1. 10.1 SOAP-Grundlagen
      2. 10.2 WSDL-Grundlagen
      3. 10.3 Entwurfsansätze und -muster
      4. 10.4 Versionierung
      5. 10.5 SOAP versus REST
      6. 10.6 Zusammenfassung
    4. 11 Messaging
      1. 11.1 Routenplanung für Lkw-Transporte (Teil 1)
      2. 11.2 Message Broker
      3. 11.3 Produkte
      4. 11.4 Standards und Protokolle
      5. 11.5 Routenplanung für Lkw-Transporte (Teil 2)
      6. 11.6 Transaktionen und garantierte Nachrichtenzustellung
      7. 11.7 Asynchrone Verarbeitung und REST
      8. 11.8 Push Notifications
      9. 11.9 Zusammenfassung
  11. Teil IV Übergreifende Themen
    1. 12 Dokumentation
      1. 12.1 Motivation
      2. 12.2 Zielgruppen unterscheiden
      3. 12.3 Allgemeiner Aufbau
      4. 12.4 Beispiele
      5. 12.5 Dokumentation von Java-APIs
      6. 12.6 Dokumentation von Web-APIs
      7. 12.7 Zusammenfassung
    2. 13 Caching
      1. 13.1 Anwendungsfälle
      2. 13.2 Performance-Vorteil
      3. 13.3 Verdrängungsstrategien
      4. 13.4 Cache-Strategien für Schreibzugriffe
      5. 13.5 Cache-Topologien für Webanwendungen
      6. 13.6 HTTP-Caching
      7. 13.7 Zusammenfassung
    3. 14 Skalierbarkeit
      1. 14.1 Anwendungsfall
      2. 14.2 Grundlagen
      3. 14.3 Load Balancing
      4. 14.4 Statuslose Kommunikation
      5. 14.5 Skalierung von Datenbanken
      6. 14.6 Skalierung von Messaging-Systemen
      7. 14.7 Architekturvarianten
      8. 14.8 Zusammenfassung
    4. 15 Erweiterte Architekturthemen
      1. 15.1 Consumer-Driven Contracts
      2. 15.2 Backends for Frontends
      3. 15.3 Vernachlässigte Frontend-Architektur
      4. 15.4 Netflix-APIs
      5. 15.5 Zusammenfassung
    5. 16 API-Management
      1. 16.1 Überblick
      2. 16.2 Funktionen einer API-Management-Plattform
      3. 16.3 API-Management-Architektur
      4. 16.4 Open-Source-Gateways
      5. 16.5 Zusammenfassung
  12. Anhang
    1. A Literaturverzeichnis
  13. Index