Einführung in RAML - Die RESTful API-Modellierungssprache

Dieser Artikel ist Teil einer Reihe: • Einführung in RAML - Die RESTful API-Modellierungssprache (aktueller Artikel) • Beseitigen Sie Redundanzen in RAML mit Ressourcentypen und -merkmalen

• Modulare RAML mit Includes, Bibliotheken, Overlays und Erweiterungen

• Definieren Sie benutzerdefinierte RAML-Eigenschaften mithilfe von Anmerkungen

1. Übersicht

In diesem Artikel stellen wir die RESTful API Modeling Language (RAML) vor, eine herstellerneutrale Sprache mit offenen Spezifikationen, die auf YAML 1.2 und JSON zur Beschreibung von RESTful APIs basiert.

Wir werden die grundlegende RAML 1.0-Syntax und Dateistruktur behandeln, während wir zeigen, wie eine einfache JSON-basierte API definiert wird. Wir werden auch zeigen, wie die Wartung von RAML-Dateien durch die Verwendung von Includes vereinfacht wird . Wenn Sie über ältere APIs verfügen, die ein JSON-Schema verwenden, zeigen wir Ihnen, wie Sie Schemas in RAML integrieren.

Anschließend stellen wir eine Handvoll Tools vor, die Ihre Reise in RAML verbessern können, darunter Authoring-Tools, Dokumentationsgeneratoren und andere.

Abschließend beschreiben wir den aktuellen Status der RAML-Spezifikation.

2. Definieren Sie Ihre API (Erstellen der .raml- Datei)

Die API, die wir definieren, ist ziemlich einfach: Definieren Sie angesichts der Entitätstypen Foo grundlegende CRUD-Operationen und einige Abfrageoperationen. Hier sind die Ressourcen, die wir für unsere API definieren werden:

  • GET / api / v1 / foos
  • POST / api / v1 / foos
  • GET / api / v1 / foos / {id}
  • PUT / api / v1 / foos / {id}
  • LÖSCHEN / api / v1 / foos / {id}
  • GET / api / v1 / foos / name / {name}
  • GET / api / v1 / foos? Name = {name} & ownerName = {ownerName}

Definieren wir unsere API so, dass sie mithilfe der HTTP Basic-Authentifizierung zustandslos ist und verschlüsselt über HTTPS bereitgestellt wird. Schließlich wählen wir JSON für unser Datentransportformat (XML wird ebenfalls unterstützt).

2.1. Einstellungen auf Stammebene

Wir beginnen mit der Erstellung einer einfachen Textdatei mit dem Namen api.raml (das Präfix .raml wird empfohlen; der Name ist beliebig) und fügen den RAML-Versionsheader in Zeile 1 hinzu. Auf der Stammebene der Datei definieren wir Einstellungen, die für die gesamte API gelten:

#%RAML 1.0 title: Baeldung Foo REST Services API using Data Types version: v1 protocols: [ HTTPS ] baseUri: //myapi.mysite.com/api/{version} mediaType: application/json 

Beachten Sie in Zeile 3 die Verwendung von Klammern {} um das Wort „ Version “. Auf diese Weise teilen wir RAML mit, dass sich „ Version“ auf eine Eigenschaft bezieht und erweitert werden soll. Daher lautet die tatsächliche baseUri : //myapi.mysite.com/v1

[Hinweis: Die Versionseigenschaft ist optional und muss nicht Teil der baseUri sein .]

2.2. Sicherheit

Sicherheit wird auch auf der Stammebene der .raml- Datei definiert. Fügen wir also unsere grundlegende Definition des HTTP-Sicherheitsschemas hinzu:

securitySchemes: basicAuth: description: Each request must contain the headers necessary for basic authentication type: Basic Authentication describedBy: headers: Authorization: description: Used to send the Base64-encoded "username:password" credentials type: string responses: 401: description: | Unauthorized. Either the provided username and password combination is invalid, or the user is not allowed to access the content provided by the requested URL.

2.3. Datentypen

Als Nächstes definieren wir die Datentypen, die unsere API verwenden wird:

types: Foo: type: object properties: id: required: true type: integer name: required: true type: string ownerName: required: false type: string

Das obige Beispiel verwendet eine erweiterte Syntax zum Definieren unserer Datentypen. RAML bietet einige syntaktische Verknüpfungen, um unsere Typdefinitionen weniger ausführlich zu gestalten. Hier ist der Abschnitt mit den entsprechenden Datentypen, der diese Verknüpfungen verwendet:

types: Foo: properties: id: integer name: string ownerName?: string Error: properties: code: integer message: string

Das '?' Ein Zeichen nach einem Eigenschaftsnamen erklärt, dass die Eigenschaft nicht erforderlich ist.

2.4. Ressourcen

Jetzt definieren wir die Top-Level-Ressource (URI) unserer API:

/foos:

2.5. URI-Parameter

Als Nächstes erweitern wir die Liste der Ressourcen und bauen auf unserer Ressource der obersten Ebene auf:

/foos: /{id}: /name/{name}: 

Hier definieren die geschweiften Klammern {} um Eigenschaftsnamen URI-Parameter. Sie stellen Platzhalter in jedem URI dar und verweisen nicht auf RAML-Dateieigenschaften auf Stammebene, wie wir oben in der baseUri- Deklaration gesehen haben. Die hinzugefügten Zeilen repräsentieren die Ressourcen / foos / {id} und / foos / name / {name} .

2.6. Methoden

Der nächste Schritt besteht darin, die HTTP-Methoden zu definieren, die für jede Ressource gelten:

/foos: get: post: /{id}: get: put: delete: /name/{name}: get:

2.7. Abfrageparameter

Jetzt definieren wir eine Möglichkeit, die foos- Sammlung mithilfe von Abfrageparametern abzufragen. Beachten Sie, dass Abfrageparameter mit derselben Syntax definiert werden, die wir oben für Datentypen verwendet haben:

/foos: get: description: List all Foos matching query criteria, if provided; otherwise list all Foos queryParameters: name?: string ownerName?: string

2.8. Antworten

Now that we've defined all of the resources for our API, including URI parameters, HTTP methods, and query parameters, it is time to define the expected responses and status codes. Response formats are typically defined regarding data types and examples.

JSON schema can be used instead of data types for backward compatibility with an earlier version of RAML. We'll introduce JSON schema in section 3.

[Note: In the code snippets below, a line containing only three dots (…) indicates that some lines are being skipped for brevity.]

Let's start with the simple GET operation on /foos/{id}:

/foos: ... /{id}: get: description: Get a Foo by id responses: 200: body: application/json: type: Foo example: { "id" : 1, "name" : "First Foo" } 

This example shows that by performing a GET request on the resource /foos/{id}, we should get back the matching Foo in the form of a JSON object and an HTTP status code of 200.

Here is how we'd define the GET request on the /foos resource:

/foos: get: description: List all Foos matching query criteria, if provided; otherwise list all Foos queryParameters: name?: string ownerName?: string responses: 200: body: application/json: type: Foo[] example: | [ { "id" : 1, "name" : "First Foo" }, { "id" : 2, "name" : "Second Foo" } ] 

Note the use of square brackets [] appended to the Foo type. This demonstrates how we would define a response body containing an array of Foo objects, with the example being an array of JSON objects.

2.9. Request Body

Next, we'll define the request bodies that correspond to each POST and PUT request. Let's begin with creating a new Foo object:

/foos: ... post: description: Create a new Foo body: application/json: type: Foo example: { "id" : 5, "name" : "Another foo" } responses: 201: body: application/json: type: Foo example: { "id" : 5, "name" : "Another foo" } 

2.10. Status Codes

Note in the above example that when creating a new object, we return an HTTP status of 201. The PUT operation for updating an object will return an HTTP status of 200, utilizing the same request and response bodies as the POST operation.

In addition to the expected responses and status codes that we return when a request is successful, we can define the kind of response and a status code to expect when an error occurs.

Let's see how we would define the expected response for the GET request on the /foos/{id} resource when no resource is found with the given id:

 404: body: application/json: type: Error example: { "message" : "Not found", "code" : 1001 } 

3. RAML With JSON Schema

Before data types were introduced in RAML 1.0, objects, request bodies, and response bodies were defined using JSON Schema.

Using data types can be very powerful, but there are cases where you still want to use JSON Schema. In RAML 0.8 you defined your schemas using the root level schemas section.

That is still valid, but it is recommended to use the types section instead since the use of schemas may be deprecated in a future version. Both types and schemas, as well as type and schema, are synonymous.

Here is how you would define the Foo object type at the root level of the .raml file using JSON schema:

types: foo: | { "$schema": "//json-schema.org/schema", "type": "object", "description": "Foo details", "properties": { "id": { "type": integer }, "name": { "type": "string" }, "ownerName": { "type": "string" } }, "required": [ "id", "name" ] }

And here is how you would reference the schema in the GET /foos/{id} resource definition:

/foos: ... /{id}: get: description: Get a Foo by its id responses: 200: body: application/json: type: foo ...

4. Refactoring With Includes

As we can see from the above sections, our API is getting rather verbose and repetitive.

The RAML specification provides an include mechanism that allows us to externalize repeated and lengthy sections of code.

We can refactor our API definition using includes, making it more concise and less likely to contain the types of errors that result from the “copy/paste/fix everywhere” methodology.

For example, we can put the data type for a Foo object in the file types/Foo.raml and the type for an Error object in types/Error.raml. Then our types section would look like this:

types: Foo: !include types/Foo.raml Error: !include types/Error.raml

And if we use JSON schema instead, our types section might look like this:

types: foo: !include schemas/foo.json error: !include schemas/error.json

5. Completing the API

After externalizing all of the data types and examples to their files, we can refactor our API using the include facility:

#%RAML 1.0 title: Baeldung Foo REST Services API version: v1 protocols: [ HTTPS ] baseUri: //rest-api.baeldung.com/api/{version} mediaType: application/json securedBy: basicAuth securitySchemes: basicAuth: description: Each request must contain the headers necessary for basic authentication type: Basic Authentication describedBy: headers: Authorization: description: Used to send the Base64 encoded "username:password" credentials type: string responses: 401: description: | Unauthorized. Either the provided username and password combination is invalid, or the user is not allowed to access the content provided by the requested URL. types: Foo: !include types/Foo.raml Error: !include types/Error.raml /foos: get: description: List all Foos matching query criteria, if provided; otherwise list all Foos queryParameters: name?: string ownerName?: string responses: 200: body: application/json: type: Foo[] example: !include examples/Foos.json post: description: Create a new Foo body: application/json: type: Foo example: !include examples/Foo.json responses: 201: body: application/json: type: Foo example: !include examples/Foo.json /{id}: get: description: Get a Foo by id responses: 200: body: application/json: type: Foo example: !include examples/Foo.json 404: body: application/json: type: Error example: !include examples/Error.json put: description: Update a Foo by id body: application/json: type: Foo example: !include examples/Foo.json responses: 200: body: application/json: type: Foo example: !include examples/Foo.json 404: body: application/json: type: Error example: !include examples/Error.json delete: description: Delete a Foo by id responses: 204: 404: body: application/json: type: Error example: !include examples/Error.json /name/{name}: get: description: List all Foos with a certain name responses: 200: body: application/json: type: Foo[] example: !include examples/Foos.json 

6. RAML Tools

One of the great things about RAML is the tool support.

There are tools for parsing, validating, and authoring RAML APIs; tools for client code generation; tools for generating API documentation in HTML and PDF formats; and tools that assist us with testing against a RAML API specification.

There is even a tool that will convert a Swagger JSON API into RAML.

Here is a sampling of available tools:

  • API Designer – a web-based tool geared towards rapid and efficient API design
  • API Workbench – an IDE for designing, building, testing, and documenting RESTful APIs that supports both RAML 0.8 and 1.0
  • RAML Cop – a tool for validating RAML files
  • RAML for JAX-RS – a set of tools for generating a skeleton of Java + JAX-RS application code from a RAML spec, or for generating a RAML spec from an existing JAX-RS application
  • RAML Sublime Plugin – a syntax highlighter plugin for the Sublime text editor
  • RAML to HTML – a tool for generating HTML documentation from RAML
  • raml2pdf – a tool for generating PDF documentation from RAML
  • RAML2Wiki – a tool for generating Wiki documentation (using Confluence/JIRA markup)
  • SoapUI RAML Plugin – a RAML plugin for the popular SoapUI functional API testing suite
  • Vigia – an integration test suite capable of generating test cases based on a RAML definition

For a complete listing of RAML tools and related projects, visit the RAML Projects page.

7. The Current State of RAML

The RAML 1.0 (RC) specification gained release-candidate status on November 3, 2015, and at the time of this writing, version 1.0 was expected to be finalized within the month.

Its predecessor, RAML 0.8 was originally released in the Fall of 2014 and is still supported by a myriad of tools.

8. Further Reading

Here are some links that we may find useful along our journey with RAML.

  • RAML.org – the official site of the RAML specification
  • json-schema.org – the home of JSON schema
  • Understanding JSON Schema
  • JSON Schema Generator
  • Wikipedia RAML Page

9. Conclusion

This article introduced the RESTful API Modeling Language (RAML). We demonstrated some basic syntax for writing a simple API specification using the RAML 1.0 (RC) spec.

And we saw ways to make our definitions more concise by using syntactical shortcuts and externalizing examples, data types, and schemas into ‘include' files.

Then we introduced a collection of powerful tools that work with the RAML spec to assist with everyday API design, development, testing, and documentation tasks.

Mit der bevorstehenden offiziellen Veröffentlichung von Version 1.0 der Spezifikation und der überwältigenden Unterstützung durch Tool-Entwickler scheint RAML hier zu bleiben.

Weiter » Beseitigen Sie Redundanzen in RAML mit Ressourcentypen und -merkmalen