Schnellstarter
Wie man ein Backend für Spring Boot erstellt?

33min
Einführung
In diesem Tutorial lernen Sie, wie Sie ein Backend für Spring Boot mit Back4App erstellen.
Wir werden durch die Verbindung Ihrer Spring Boot-Anwendung (einer Java-basierten Webanwendung, die das Spring Framework nutzt) zu den wesentlichen Funktionen von Back4App gehen – wie Datenbankverwaltung, Cloud Code, REST- und GraphQL-APIs, Benutzerauthentifizierung, Dateispeicherung und Echtzeitanfragen.
Indem Sie diese Schritte befolgen, werden Sie in der Lage sein, die Funktionalität von Spring Boot nahtlos mit der leistungsstarken Parse-Plattform von Back4App zu integrieren.
Die Nutzung von Back4App als Ihr Backend vereinfacht erheblich Ihre Datenbankverbindung, Sicherheitskonfiguration und den Bereitstellungsprozess.
Es befreit Sie von den Komplexitäten der Servereinrichtung und der manuellen Datenbankverwaltung, sodass Sie sich auf das Schreiben der Geschäftslogik Ihrer Spring Boot-Anwendung konzentrieren können.
Am Ende dieses Tutorials werden Sie ein solides, skalierbares Backend haben, das die Grundlage für Ihre Webanwendungen oder Java-Anwendungen bildet, die auf Spring Web laufen, und das sich leicht auf produktionsbereite Bereitstellungen erweitern lässt.
Voraussetzungen
Um diesen Leitfaden abzuschließen, stellen Sie sicher, dass Sie Folgendes bereit haben:
Ein Back4App-Konto und ein neues Back4App-Projekt
Erste Schritte mit Back4app.
Melden Sie sich kostenlos an, wenn Sie kein Konto haben.
Eine Java-Entwicklungsumgebung
Sie müssen Java SE 8 oder höher und Maven oder Gradle. Dies ist entscheidend für die Einrichtung Ihrer Entwicklungsumgebung.
Grundlagen von Spring Boot
Vertrautheit mit der Erstellung einer Spring Boot-Anwendung. Bei Bedarf können Sie sich auf die offiziellen Spring Boot-Dokumentation beziehen, um mehr über Spring Security, Controller, Services und mehr zu erfahren.
Grundkenntnisse von Parse/Back4App
Zu wissen, wie die Parse-Plattform funktioniert, ist von Vorteil. Wenn Sie neu sind, überprüfen Sie die Dokumentation von Back4App.
Wenn Sie diese Voraussetzungen bereit haben, sorgt das für ein reibungsloses Tutorial-Erlebnis. Lassen Sie uns mit dem Aufbau Ihres Backends mit Back4App beginnen!
Schritt 1 – Erstellen eines neuen Projekts auf Back4App und Verbindung herstellen
Warum dieser Schritt notwendig ist
Ein neues Back4App-Projekt zu erstellen, ist die Grundlage Ihres Backends. Dies wird Ihre Datenbank, Konfigurationseinstellungen, Sicherheitsregeln enthalten und es Ihnen ermöglichen, Ihre Spring Boot-Anwendung-Daten über die Parse-Plattform zu verwalten.
Ein Back4App-Projekt erstellen
Melden Sie sich bei Ihrem Back4App-Konto an.
Klicken Sie auf „Neue App“ auf Ihrem Back4App-Dashboard.
Geben Sie einen Namen für Ihr Projekt an (z. B. „SpringBoot-Backend-Tutorial“) und schließen Sie die Einrichtung ab.
﻿
Sobald Sie fertig sind, sehen Sie Ihr neues Projekt im Back4App-Dashboard aufgeführt.
Installieren und Konfigurieren des Parse Java SDK (Optional)
Back4App verwendet die Parse-Plattform, die ein Java SDK bereitstellt, das sich in Ihre Spring Boot-App integrieren lässt. Wenn Sie möchten, können Sie auch REST/GraphQL-Aufrufe direkt aus Ihrem Java-Entwickler-Code durchführen. Die Verwendung des SDK kann jedoch Operationen wie das Speichern von Daten, Abfragen und die Benutzerauthentifizierung vereinfachen.
Maven-Abhängigkeit (Beispiel):
XML
<dependency>
  <groupId>com.parse</groupId>
  <artifactId>parse</artifactId>
  <version>1.26.0</version>
</dependency>
<dependency>
  <groupId>com.parse</groupId>
  <artifactId>parse</artifactId>
  <version>1.26.0</version>
</dependency>
﻿
In Ihrer Spring Boot Hauptanwendungsklasse oder einer Konfigurationsklasse initialisieren Sie Parse:
Java
@SpringBootApplication
public class SpringBootBackendTutorialApplication {
    public static void main(String[] args) {
        // Initialize Parse before running the application
        Parse.initialize(new Parse.Configuration.Builder("YOUR_APP_ID")
            .server("https://parseapi.back4app.com/")
            .clientKey("YOUR_CLIENT_KEY")
            .build()
        );
        
        SpringApplication.run(SpringBootBackendTutorialApplication.class, args);
    }
}
@SpringBootApplication
public class SpringBootBackendTutorialApplication {
    public static void main(String[] args) {
        // Initialize Parse before running the application
        Parse.initialize(new Parse.Configuration.Builder("YOUR_APP_ID")
            .server("https://parseapi.back4app.com/")
            .clientKey("YOUR_CLIENT_KEY")
            .build()
        );
        
        SpringApplication.run(SpringBootBackendTutorialApplication.class, args);
    }
}
﻿
Stellen Sie sicher, dass Sie „YOUR_APP_ID“ und „YOUR_CLIENT_KEY“ durch die Anmeldeinformationen ersetzen, die Sie in Ihrem Back4App-Dashboard finden. Sie können sie unter App-Einstellungen oder Sicherheit & Schlüssel sehen.
Schritt 2 – Datenbank einrichten
1. Erstellen eines Datenmodells
Ihre Datenbankverbindung wird von Back4App verwaltet. Sie können Datenmodelle (Klassen) im Dashboard erstellen oder sie dynamisch erstellen lassen, indem Sie Objekte über das Parse SDK speichern. Für eine bessere Kontrolle gehen Sie zum Back4App Dashboard und:
Klicken Sie auf „Datenbank“
Erstellen Sie eine neue Klasse (z.B. „Todo“)
Fügen Sie Spalten hinzu (Felder) wie Titel (String) und istAbgeschlossen (Boolean)
Neue Klasse erstellen
﻿
2. Erstellen eines Datenmodells mit dem KI-Agenten
Back4App bietet einen KI-Agenten an, der ein Schema für Sie generieren kann:
Öffnen Sie den KI-Agenten vom Dashboard oder aus dem Menü.
Beschreiben Sie Ihr Datenmodell in einfacher Sprache.
Lassen Sie den KI-Agenten die Erstellung relevanter Klassen und Felder übernehmen.
﻿
3. Daten lesen und schreiben mit dem SDK
Wenn Sie das Parse Java SDK zu Ihrem spring framework Projekt hinzugefügt haben, können Sie mit Klassen wie folgt interagieren:
Java
@Service
public class TodoService {

    public ParseObject createTodoItem(String title, boolean isCompleted) throws ParseException {
        ParseObject todo = new ParseObject("Todo");
        todo.put("title", title);
        todo.put("isCompleted", isCompleted);
        return todo.save(); // Throws ParseException if something goes wrong
    }

    public List<ParseObject> fetchTodos() throws ParseException {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Todo");
        return query.find(); 
    }
}
@Service
public class TodoService {

    public ParseObject createTodoItem(String title, boolean isCompleted) throws ParseException {
        ParseObject todo = new ParseObject("Todo");
        todo.put("title", title);
        todo.put("isCompleted", isCompleted);
        return todo.save(); // Throws ParseException if something goes wrong
    }

    public List<ParseObject> fetchTodos() throws ParseException {
        ParseQuery<ParseObject> query = ParseQuery.getQuery("Todo");
        return query.find(); 
    }
}
﻿
4. Daten lesen und schreiben mit der REST API
Alternativ können Sie über REST-Endpunkte mit der Back4App-Datenbank interagieren:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
5. Daten lesen und schreiben mit der GraphQL-API
Back4App hat auch einen GraphQL-Endpunkt:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
6. Arbeiten mit Live-Abfragen (Optional)
Wenn Ihre Webanwendungen Echtzeit-Updates benötigen, können Sie Live-Abfragen im Back4App-Dashboard aktivieren und Ihre Spring-Web-Anwendung verbinden. Typischerweise würden Sie in einem Java-Client auf Ereignisse abonnieren oder Front-End-Tools verwenden, die Live-Abfragen unterstützen.
Schritt 3 – Anwendung von Sicherheit mit ACLs und CLPs
Kurze Übersicht
Die ACLs (Zugriffskontrolllisten) und CLPs (Klassenebene-Berechtigungen) von Back4App schützen Ihre Daten. Dies kann Spring-Sicherheit ergänzen oder unterstützen, um Ihre Java-Anwendung weiter zu schützen.
Schritt-für-Schritt
Klassenebene-Berechtigungen (CLPs): Konfigurieren Sie sie im Tab „Datenbank“ unter „Klassenebene-Berechtigungen.“
ACLs: Setzen Sie objektbezogene Berechtigungen im Code oder vom Dashboard aus.
﻿
Für weitere Details siehe die App-Sicherheitsrichtlinien.
Schritt 4 – Schreiben von Cloud-Code-Funktionen
Warum Cloud Code
Cloud Code ermöglicht es Ihnen, sensible Geschäftslogik auf den Server zu verschieben oder zu schützen, der in einer kontrollierten Umgebung läuft. Dies ist besonders hilfreich, wenn Sie Logik haben, die nicht auf der Client-Seite exponiert werden sollte, oder wenn Sie externe APIs integrieren möchten.
Beispiel-Funktion
JS
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) throw new Error('No text provided');
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) throw new Error('No text provided');
  return { length: text.length };
});
﻿
Bereitstellung
Verwenden Sie die Back4App CLI oder das Back4App Dashboard, um Ihren Code bereitzustellen. Sie können die Funktion dann direkt von Spring Boot über das Java SDK, REST oder GraphQL aufrufen.
Schritt 5 – Authentifizierung konfigurieren
Benutzerauthentifizierung
Die Parse User-Klasse verwaltet die Benutzeranmeldung, das Einloggen und die Sitzungstoken. Sie können dies in Ihre Spring Boot-Anwendung integrieren, indem Sie entweder das Java SDK aufrufen oder REST-Calls verwenden.
Registrieren (Java SDK-Beispiel):
Java
public ParseUser signUpUser(String username, String password, String email) throws ParseException {
    ParseUser user = new ParseUser();
    user.setUsername(username);
    user.setPassword(password);
    user.setEmail(email);
    return user.signUp(); // returns the newly created user
}
public ParseUser signUpUser(String username, String password, String email) throws ParseException {
    ParseUser user = new ParseUser();
    user.setUsername(username);
    user.setPassword(password);
    user.setEmail(email);
    return user.signUp(); // returns the newly created user
}
﻿
Soziale Anmeldung
Für Anbieter wie Google oder Facebook unterstützt Parse OAuth-basierte Anmeldungen. Überprüfen Sie die Dokumentation zur sozialen Anmeldung für zusätzliche Einrichtungsdetails.
Schritt 6 – Umgang mit Dateispeicher
Einrichten des Dateispeichers
Verwenden Sie die ParseFile-Klasse, um Dateien hochzuladen. Oder Sie können REST verwenden, wenn Sie es bevorzugen:
Java
// Example using Java SDK
ParseFile file = new ParseFile("myImage.png", fileBytes);
file.save(); // uploads to Back4App

ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", file);
photo.save();
// Example using Java SDK
ParseFile file = new ParseFile("myImage.png", fileBytes);
file.save(); // uploads to Back4App

ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", file);
photo.save();
﻿
Beispiel
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: text/plain" \
  --data-binary '@myImage.png' \
  https://parseapi.back4app.com/files/myImage.png
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: text/plain" \
  --data-binary '@myImage.png' \
  https://parseapi.back4app.com/files/myImage.png
﻿
Schritt 7 – E-Mail-Verifizierung und Passwortzurücksetzung
Übersicht
Um sichere Benutzerkonten in Ihrem java developer-Workflow zu gewährleisten, aktivieren Sie die E-Mail-Verifizierung und die Passwortzurücksetzung in Ihrem Back4App-Dashboard.
Konfiguration
E-Mail-Verifizierung aktivieren unter den E-Mail-Einstellungen Ihrer App.
E-Mail-Vorlagen einrichten für ein besseres Benutzererlebnis.
Schritt 8 – Aufgaben mit Cloud-Jobs planen
Was Cloud-Jobs tun
Cloud Jobs ermöglichen es Ihnen, Aufgaben wie die regelmäßige Datenbereinigung, das Versenden täglicher Benachrichtigungen oder die systemweite Wartung zu automatisieren. Hier ist ein Beispieljob:
JS
Parse.Cloud.job('cleanupOldTodos', async () => {
  const query = new Parse.Query('Todo');
  // Example: remove todos older than 30 days
  // ...
  // implement the job logic here
});
Parse.Cloud.job('cleanupOldTodos', async () => {
  const query = new Parse.Query('Todo');
  // Example: remove todos older than 30 days
  // ...
  // implement the job logic here
});
﻿
Planen Sie es von Ihrem Back4App-Dashboard unter Servereinstellungen > Hintergrundjobs.
Planung eines Cloud-Jobs
﻿
Schritt 9 – Integration von Webhooks
Definition und Konfiguration
Webhooks ermöglichen es Ihrer Java-Anwendung, ereignisgesteuerte HTTP-Anfragen zu senden oder zu empfangen. Zum Beispiel können Sie einen externen Dienst benachrichtigen, wann immer ein Objekt in Ihrer Back4App-Datenbank erstellt wird.
Gehen Sie zum Back4App-Dashboard > Mehr > WebHooks
Webhook hinzufügen mit dem Zielendpunkt
Trigger einrichten für Ereignisse (erstellen, aktualisieren, löschen)
Hinzufügen eines Webhooks
﻿
Schritt 10 – Erforschen des Back4App-Admin-Panels
Wo man es findet
Die Back4App Admin App ist eine modellzentrierte, benutzerfreundliche Schnittstelle für nicht-technische Teammitglieder, um Daten anzuzeigen und zu ändern. Gehen Sie zu App-Dashboard > Mehr > Admin-App um sie zu aktivieren.
Admin-App aktivieren
﻿
Wählen Sie eine Subdomain und erstellen Sie Ihren ersten Administrationsbenutzer. Melden Sie sich dann an, um Ihre Daten zu verwalten, ohne den Code zu berühren.
﻿
Fazit
Herzlichen Glückwunsch zum Abschluss Ihrer Spring Boot-Integration mit Back4App! Sie haben gesehen, wie man ein Backend für Spring Boot erstellt, das Daten, Authentifizierung, Dateien, Echtzeit-Abonnements und geplante Aufgaben verwaltet – alles mit minimalem Aufwand.
Dieser robuste, skalierbare Ansatz ermöglicht es Ihnen, sich auf das Schreiben von Geschäftslogik zu konzentrieren, anstatt sich um niedrigstufige Server- oder Datenbankdetails zu kümmern.
Sie haben:
Ein Back4App-Projekt erstellt und es mit Ihrem Spring-Framework verbunden.
Gelernt, wie man die Datenbankverbindung mit Klassen und Datenmodellen verwaltet.
ACLs, CLPs, Cloud-Code-Funktionen und Zeitplanung mit Cloud-Jobs implementiert.
Dateispeicher, Benutzerauthentifizierung und erweiterte Funktionen wie Webhooks konfiguriert.
Mit diesen Grundlagen ist Ihre Spring-Boot-Anwendung bereit, sich zu einem produktionsreifen System mit vollwertiger Spring-Sicherheit oder komplexeren Datenbeziehungen weiterzuentwickeln.
Wir ermutigen Sie, weitere Funktionen von Back4App und die Funktionen von Spring Boot zu erkunden, die die Entwicklung moderner Webanwendungen beschleunigen.
Nächste Schritte
Für die Produktion skalieren: Leistung optimieren, Caching hinzufügen und erweiterte Rollen in CLPs konfigurieren.
Weitere Integrationen hinzufügen: Verbinden Sie sich über Cloud-Code oder Webhooks mit externen Diensten (Zahlungsgateways, Analysen usw.).
Offizielle Dokumentation konsultieren: Vertiefen Sie Ihr Verständnis von der Dokumentation von Back4App und fortgeschrittenen Parse-Techniken.
Tutorials erkunden: Suchen Sie nach spezialisierten Tutorials zu Echtzeit-Chat, Push-Benachrichtigungen oder standortbasierten Diensten. Kombinieren Sie diese mit Ihrem Spring-Boot-Setup, um modernste Webanwendungen zu erstellen.
Durch die Nutzung der Synergie zwischen Spring Boot und Back4App können Sie Ihre Java-Anwendung schnell entwickeln, warten und skalieren, während Sie den Code sauber halten und den Bereitstellungsprozess einfach gestalten.
Aktualisiert 23 Jan 2025
Hat Ihnen diese Seite geholfen?
Wie man ein Backend für das Play Framework erstellt?
ALS NÄCHSTES
Wie man ein Backend für Java erstellt?