Wollten Sie schon immer eine Webanwendung oder einen Microservice mit Java erstellen, fühlten sich aber von der Komplexität und Konfiguration überfordert? Wenn ja, sind Sie nicht allein. Viele Entwickler kämpfen mit den Herausforderungen der Webentwicklung, wie z. B. dem Einrichten des Servers, dem Verwalten der Abhängigkeiten, dem Umgang mit der Datenbank und mehr.
Deshalb ist Spring Boot ein Game-Changer. Spring Boot ist ein Framework, das die Webentwicklung mit Java vereinfacht. Es bietet Funktionen wie Auto-Konfiguration, eingebettete Server, Starter-Abhängigkeiten und mehr. Mit Spring Boot können Sie sich auf das Schreiben Ihrer Geschäftslogik konzentrieren, anstatt sich mit dem Boilerplate-Code zu befassen.
Aber die Erstellung einer Webanwendung oder eines Microservices reicht nicht aus. Sie müssen es auch testen. Tests sind entscheidend, um die Qualität und Zuverlässigkeit Ihrer Software sicherzustellen. Sie helfen Ihnen, Fehler zu finden und zu beheben, die Leistung zu verbessern und Fehler zu vermeiden.
Hier kommt Apidog ins Spiel.
In diesem Blogbeitrag erfahren Sie, wie Sie eine Spring Boot API mit Apidog erstellen und testen. Sie erstellen eine einfache RESTful API mit Spring Boot und testen sie mit Apidog .
Was ist Spring Boot und warum sollte man es verwenden?
Spring Boot ist ein Framework, das die Entwicklung von Spring-Anwendungen vereinfacht. Es bietet viele Funktionen und Konventionen, die es einfacher machen, Spring-Anwendungen zu erstellen, zu konfigurieren, auszuführen und bereitzustellen. Einige der Vorteile der Verwendung von Spring Boot sind:
- Es verfügt über ein Starter-Abhängigkeitsverwaltungssystem, das automatisch die erforderlichen Bibliotheken und Versionen für Ihr Projekt hinzufügt.
- Es verfügt über einen eingebetteten Webserver, mit dem Sie Ihre Anwendung ohne zusätzliche Konfiguration oder Installation ausführen können.
- Es verfügt über einen Auto-Konfigurationsmechanismus, der die optimalen Einstellungen für Ihre Anwendung basierend auf den Abhängigkeiten und der Umgebung erkennt und anwendet.
- Es verfügt über eine produktionsbereite Unterstützung, die Funktionen wie Gesundheitschecks, Metriken, Protokollierung und Sicherheit umfasst.
Mit Spring Boot können Sie sich auf das Schreiben Ihrer Geschäftslogik konzentrieren und den Rest dem Framework überlassen.
Was ist Apidog und wie kann es Ihnen helfen, Ihre API zu testen?
Apidog ist ein Tool, mit dem Sie Ihre APIs auf einfache und intuitive Weise testen können. Es ermöglicht Ihnen, sich mit Ihrer API zu verbinden, die Endpunkte zu erkunden und Testfälle für Ihre API zu erstellen und auszuführen. Einige der Funktionen von APIdog sind:
- Es verfügt über eine grafische Benutzeroberfläche, die die Interaktion mit Ihrer API und die Anzeige der Ergebnisse erleichtert.
- Es verfügt über einen Code-Editor, mit dem Sie Ihre Testfälle mit JavaScript und Chai-Assertions schreiben und bearbeiten können.
- Es verfügt über einen Test-Runner, der Ihre Testfälle ausführt und Ihnen den Status, die Ausgabe und die Fehler jedes Tests anzeigt.
- Es verfügt über einen Berichtsgenerator, der einen umfassenden und anpassbaren Bericht über Ihre Testergebnisse erstellt.
Mit Apidog können Sie Ihre API schnell und zuverlässig testen und deren Qualität und Funktionalität sicherstellen.
Einrichten des Projekts
Der erste Schritt ist die Erstellung eines Spring Boot-Projekts mit Spring Initializr. Spring Initializr ist ein Webtool, das eine grundlegende Projektstruktur und -konfiguration für Sie basierend auf Ihren Präferenzen generiert. Um Spring Initializr zu verwenden, gehen Sie wie folgt vor:
Gehen Sie zu https://start.spring.io/ und geben Sie die Details Ihres Projekts ein. Für dieses Beispiel verwende ich die folgenden Einstellungen:
- Projekt: Maven Project
- Sprache: Java
- Spring Boot: 3.2.3
- Projektmetadaten:
- Gruppe: com.example
- Artefakt: apidog-demo
- Name: apidog-demo
- Beschreibung: Demo-Projekt für Spring Boot
- Paketname: com.example.apidog-demo
- Paketierung: Jar
- Java: 17
- Abhängigkeiten: Spring Web, Spring Data JPA, H2 Database
Klicken Sie auf die Schaltfläche GENERATE und laden Sie die Zip-Datei Ihres Projekts herunter.
Entpacken Sie die Zip-Datei und öffnen Sie das Projekt in Ihrer bevorzugten IDE.
Hinzufügen der Abhängigkeiten für Spring Web und Spring Data JPA
Der nächste Schritt ist das Hinzufügen der Abhängigkeiten für Spring Web und Spring Data JPA. Spring Web ist ein Modul, das die wesentliche Webunterstützung für die Erstellung von RESTful APIs mit Spring bietet. Spring Data JPA ist ein Modul, das den Zugriff auf und die Bearbeitung von Daten in relationalen Datenbanken mithilfe von JPA und Hibernate vereinfacht.
Um diese Abhängigkeiten hinzuzufügen, können Sie wie oben erwähnt Spring Initializr verwenden, oder Sie können die Datei pom.xml Ihres Projekts manuell bearbeiten und die folgenden Abhängigkeiten hinzufügen:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
Konfigurieren der Anwendungseigenschaften
Der nächste Schritt ist die Konfiguration der Anwendungseigenschaften. Die Datei application.properties ist eine Datei, die die Schlüssel-Wert-Paare enthält, die das Verhalten und die Einstellungen Ihrer Anwendung definieren. Für dieses Beispiel verwenden wir die folgenden Eigenschaften:
# Aktivieren Sie die H2-Konsole für den Zugriff auf die Datenbank
spring.h2.console.enabled=true
# Legen Sie den Pfad der H2-Konsole fest
spring.h2.console.path=/h2-console
# Legen Sie die URL der Datenbank fest
spring.datasource.url=jdbc:h2:mem:testdb
# Legen Sie den Benutzernamen der Datenbank fest
spring.datasource.username=sa
# Legen Sie das Passwort der Datenbank fest
spring.datasource.password=
# Legen Sie den Dialekt der Datenbank fest
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
# Zeigen Sie die SQL-Anweisungen in der Konsole an
spring.jpa.show-sql=true
# Generieren Sie das Datenbankschema aus den Entitätsklassen
spring.jpa.hibernate.ddl-auto=update
# Aktivieren Sie die Swagger-UI zum Dokumentieren der API
springdoc.swagger-ui.enabled=true
# Legen Sie den Pfad der Swagger-UI fest
springdoc.swagger-ui.path=/swagger-ui.html
Erstellen der API
Der nächste Schritt ist die Erstellung der API. Die API besteht aus einem Domänenmodell, einem Repository und einem Controller für eine einfache Entität namens Book. Ein Book hat die folgenden Eigenschaften: id, title, author und price.
Erstellen des Domänenmodells und eines Repositorys für eine einfache Entität
Das Domänenmodell ist eine Klasse, die die Daten und das Verhalten der Entität darstellt. Das Repository ist eine Schnittstelle, die die JpaRepository-Schnittstelle erweitert und die Methoden für den Zugriff auf und die Bearbeitung der Daten der Entität bereitstellt.
Um das Domänenmodell und das Repository für die Book-Entität zu erstellen, gehen Sie wie folgt vor:
- Erstellen Sie ein neues Paket namens com.example.apidogdemo.model und erstellen Sie darin eine neue Klasse namens Book.java.
- Kommentieren Sie die Klasse mit @Entity, um sie als JPA-Entität zu markieren, und @Table, um den Namen der Tabelle in der Datenbank anzugeben.
- Definieren Sie die Eigenschaften der Klasse und kommentieren Sie sie mit @Id, @GeneratedValue, @Column und @NotNull, um den Primärschlüssel, die Generierungsstrategie, den Spaltennamen bzw. die Validierungseinschränkung anzugeben.
- Generieren Sie die Getter und Setter, den Konstruktor und die toString-Methode für die Klasse.
Die Klasse Book.java sollte so aussehen:
package com.example.apidogdemo.model;
import javax.persistence.*;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
@Entity
@Table(name = "books")
public class Book {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "title")
@NotNull
private String title;
@Column(name = "author")
@NotNull
private String author;
@Column(name = "price")
@NotNull
private BigDecimal price;
public Book() {
}
public Book(Long id, String title, String author, BigDecimal price) {
this.id = id;
this.title = title;
this.author = author;
this.price = price;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public BigDecimal getPrice() {
return price;
}
public void setPrice(BigDecimal price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"id=" + id +
", title='" + title + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
- Erstellen Sie ein neues Paket namens com.example.apidogdemo.repository und erstellen Sie darin eine neue Schnittstelle namens BookRepository.java.
- Kommentieren Sie die Schnittstelle mit @Repository, um sie als Spring Data JPA-Repository zu markieren.
- Erweitern Sie die JpaRepository-Schnittstelle und geben Sie den Entitätstyp und den Primärschlüsseltyp als generische Parameter an.
- Optional können Sie benutzerdefinierte Methoden zum Abfragen der Daten der Entität definieren.
Die Schnittstelle BookRepository.java sollte so aussehen:
package com.example.apidogdemo.repository;
import com.example.apidogdemo.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
// You can define custom methods here
}
Erstellen eines Controllers und Definieren der Endpunkte für CRUD-Operationen
Der Controller ist eine Klasse, die die Anforderungen und Antworten der API verarbeitet. Der Controller definiert die Endpunkte für die CRUD-Operationen (Erstellen, Lesen, Aktualisieren und Löschen) für die Entität.
Um den Controller zu erstellen und die Endpunkte für die Book-Entität zu definieren, gehen Sie wie folgt vor:
- Erstellen Sie ein neues Paket namens com.example.apidogdemo.controller und erstellen Sie darin eine neue Klasse namens BookController.java.
- Kommentieren Sie die Klasse mit @RestController, um sie als Spring MVC-Controller zu markieren, der JSON-Antworten zurückgibt.
- Kommentieren Sie die Klasse mit @RequestMapping, um den Basispfad der Endpunkte anzugeben.
- Injizieren Sie die BookRepository-Instanz mithilfe der @Autowired-Annotation.
- Definieren Sie die Endpunkte für die CRUD-Operationen mithilfe der Annotationen @GetMapping, @PostMapping, @PutMapping und @DeleteMapping und geben Sie den Pfad und die Parameter jedes Endpunkts an.
- Verwenden Sie die Klasse ResponseEntity, um die Antwortdaten und den Statuscode für jeden Endpunkt zu umschließen.
- Verwenden Sie die Annotation @Valid, um den Anforderungstext für die Erstellungs- und Aktualisierungs-Endpunkte zu validieren.
- Verwenden Sie die Annotationen @ExceptionHandler und @ResponseStatus, um die Ausnahmen zu behandeln und den entsprechenden Statuscode und die entsprechende Meldung zurückzugeben.
Die Klasse BookController.java sollte so aussehen:
package com.example.apidogdemo.controller;
import com.example.apidogdemo.model.Book;
import com.example.apidogdemo.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.server.ResponseStatusException;
import javax.validation.Valid;
import java.util.List;
import java.util.Optional;
@RestController
@RequestMapping("/api/books")
public class BookController {
@Autowired
private BookRepository bookRepository;
// Get all books
@GetMapping
public ResponseEntity<List<Book>> getAllBooks() {
List<Book> books = bookRepository.findAll();
return new ResponseEntity<>(books, HttpStatus.OK);
}
// Get a book by id
@GetMapping("/{id}")
public ResponseEntity<Book> getBookById(@PathVariable Long id) {
Optional<Book> book = bookRepository.findById(id);
if (book.isPresent()) {
return new ResponseEntity<>(book.get(), HttpStatus.OK);
} else {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Book not found");
}
}
// Create a book
@PostMapping
public ResponseEntity<Book> createBook(@Valid @RequestBody Book book) {
Book savedBook = bookRepository.save(book);
return new ResponseEntity<>(savedBook, HttpStatus.CREATED);
}
// Update a book by id
@PutMapping("/{id}")
public ResponseEntity<Book> updateBook(@PathVariable Long id, @Valid @RequestBody Book book) {
Optional<Book> existingBook = bookRepository.findById(id);
if (existingBook.isPresent()) {
book.setId(id);
Book updatedBook = bookRepository.save(book);
return new ResponseEntity<>(updatedBook, HttpStatus.OK);
} else {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Book not found");
}
}
// Delete a book by id
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteBook(@PathVariable Long id) {
Optional<Book> existingBook = bookRepository.findById(id);
if (existingBook.isPresent()) {
bookRepository.deleteById(id);
return new ResponseEntity<>(HttpStatus.NO_CONTENT);
} else {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Book not found");
}
}
// Handle the validation exceptions
@ExceptionHandler(javax.validation.ConstraintViolationException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public String handleValidationExceptions(javax.validation.ConstraintViolationException ex) {
return ex.getMessage();
}
}
Testen der Spring Boot API mit APIdog
Der letzte Schritt ist das Testen der API mit Apidog. Apidog ist ein Tool, mit dem Sie Ihre APIs auf einfache und intuitive Weise testen können. Es ermöglicht Ihnen, sich mit Ihrer API zu verbinden, die Endpunkte zu erkunden und Testfälle für Ihre API zu erstellen und auszuführen.
Um die API mit Apidog zu testen, gehen Sie wie folgt vor:
- Starten Sie Apidog und erstellen Sie ein neues Projekt, indem Sie auf die Schaltfläche Neues Projekt klicken.
- Geben Sie den Namen und die Beschreibung Ihres Projekts ein und klicken Sie auf die Schaltfläche Erstellen.
- Geben Sie die Basis-URL Ihrer API ein und klicken Sie auf die Schaltfläche Verbinden.
- Sie können die Liste der Endpunkte Ihrer API im linken Bereich sehen. Sie können auf jeden Endpunkt klicken, um die Details und die Beispiele im rechten Bereich anzuzeigen.
- Sie können Testfälle für Ihre API erstellen und ausführen, indem Sie im rechten Bereich auf die Registerkarte Testfälle klicken. Sie können den Code-Editor verwenden, um Ihre Testfälle mit JavaScript und Chai-Assertions zu schreiben und zu bearbeiten.
Sie können den Test-Runner verwenden, um Ihre Testfälle auszuführen und den Status, die Ausgabe und die Fehler jedes Tests anzuzeigen. Sie können den Berichtsgenerator verwenden, um einen umfassenden und anpassbaren Bericht über Ihre Testergebnisse zu erstellen.
Fazit
In diesem Blogbeitrag haben Sie gelernt, wie Sie eine Spring Boot API mit Apidog erstellen und testen. Sie haben eine einfache RESTful API mit Spring Boot erstellt und sie mit Apidog getestet.
Spring Boot ist ein Framework, das die Webentwicklung mit Java vereinfacht. Es bietet Funktionen wie Auto-Konfiguration, eingebettete Server, Starter-Abhängigkeiten und mehr. Mit Spring Boot können Sie sich auf das Schreiben Ihrer Geschäftslogik konzentrieren, anstatt sich mit dem Boilerplate-Code zu befassen.
Apidog ist ein Tool, mit dem Sie Ihre APIs testen und debuggen können. Es ermöglicht Ihnen, sich mit Ihrer API zu verbinden und die Endpunkte zu erkunden, Testfälle zu erstellen und auszuführen sowie Berichte zu generieren. Mit Apidog können Sie Ihre API schneller und einfacher testen, ohne Code schreiben zu müssen.
