So starten Sie eine Spring Boot + JPA + MySQL-Anwendung

Bevor wir mit der Erstellung des Projekts beginnen, erkläre ich kurz, was die Technologien Spring Boot, JPA und MySQL.

sind.

• Spring Boot: ist ein Java-Framework, das die Entwicklung von Spring-Anwendungen vereinfacht und die Erstellung eigenständiger Anwendungen ermöglicht, die mit einem einfachen Befehl ausgeführt werden können, ohne dass eine komplexe Konfiguration erforderlich ist.
• JPA: Java Persistence API ist eine Java-Spezifikation, die definiert, wie Java-Objekte relationalen Datenbanken (ORM) zugeordnet werden sollen.
• MySQL: Weltbekanntes relationales Open-Source-Datenbankverwaltungssystem (RDBMS). Es wird häufig zum Speichern, Organisieren und Verwalten großer Datenmengen in Web- und Unternehmensanwendungen verwendet.

Mit diesen 3 Technologien können wir robuste, skalierbare und leistungsstarke Webanwendungen entwickeln.

Projekterstellung

Wir werden das Projekt in einem Online-Tool namens Spring Initializr erstellen, das die Erstellung von Spring Boot-Projekten erleichtert.

Wenn Sie die URL eingeben, wird ein Bildschirm wie dieser angezeigt:

Wir werden auf der linken Seite einige Dinge konfigurieren, wie zum Beispiel:

• Projekttyp: Maven
• Sprache: Java
• Spring Boot-Version: 3.3.2

In den Projektmetadaten gehen Sie wie folgt vor:

• Gruppe: br.com.(ex: br.com.josemarinho)
• Artefakt und Name: spring-jpa-mysql
• Beschreibung: Projekt mit Spring Boot, JPA und MySQL
• Paketname: wird automatisch basierend auf Gruppe und Artefakt generiert.
• Verpackung: Glas
• Java: 17

Auf der rechten Seite sehen Sie die Abhängigkeiten unseres Projekts, wir müssen 3 hinzufügen, nämlich:

• Frühlingsnetz
• Spring Data JPA
• MySQL-Treiber

Am Ende wird es so aussehen:

Nach der Konfiguration klicken Sie einfach auf die Schaltfläche Generieren, wo Sie mit dem Herunterladen einer Zip-Datei beginnen, die alle Projektverzeichnisse/-dateien enthält. Anschließend einfach entpacken und in Ihrer bevorzugten IDE öffnen.

Erster Lauf

Sobald Sie das Projekt öffnen und versuchen, das Programm auszuführen, wird ein Laufzeitfehler mit folgender Meldung gemeldet:

Description:

Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.

Reason: Failed to determine a suitable driver class

Dies liegt daran, dass Spring Boot nicht automatisch eine DataSource für die Anwendung konfigurieren kann. Sollen wir konfigurieren?

Im Projekt gibt es ein Verzeichnis namens resources. In diesem Verzeichnis befinden sich einige Dateien, darunter eine Datei namens application.properties, in der sich die Einstellungen eines Spring-Boot-Projekts befinden. Ich verwende gerne die YAML/YML-Version, also löschen Sie einfach diese Datei und erstellen Sie eine neue mit dem Namen application.yml, die so aussieht:

Lassen Sie uns die URL definieren, unter der sich unsere App verbindet, den Treiber, den Benutzernamen und das Passwort:

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: username
    password: password
    url: jdbc:mysql://127.0.0.1:3306/seu_banco_de_dados

In application.properties würde es so aussehen:

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=username
spring.datasource.password=password
spring.datasource.url=jdbc:mysql://localhost:3306/seu_banco_de_dados

Okay, jetzt führen Sie das Projekt einfach noch einmal aus und Sie werden eine Ausgabe wie diese sehen.

Entitätserstellung

In meiner Datenbank habe ich eine einfache Tabelle namens „Benutzer“, die zwei Felder enthält:

• ID: Primärschlüssel-Ganzzahl, automatische Inkrementierung
• Benutzer: varchar(255)

Damit werden wir den ersten Schritt unternehmen, um diese Tabelle in einem Java-Kontext abzubilden und eine Entität zu erstellen. Erstellen Sie dazu eine Klasse namens User, am Ende sollte sie so aussehen:

@Entity
@Table(name = "usuarios")
public class Usuario {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String usuario;

    // Getters e Setters
}

• @Entity: Marca a classe como uma entidade JPA. Isso indica ao JPA que a classe deve ser persistida em um banco de dados.
• @Table(name = "produto"): Especifica o nome da tabela no banco de dados à qual a entidade está mapeada. Se essa anotação não for fornecida, o JPA assumirá que o nome da tabela é o mesmo que o nome da classe.
• @Id: Indica que o campo é a chave primária da entidade.
• @GeneratedValue: Indica a estratégia que iremos gerar os valores, no caso escolhemos que o próprio banco de dados irá gerar automaticamente para nós, o padrão é o GenerationType.AUTO.

Agora que temos nossa entidade já desenvolvida precisamos criar nossos Repositórios que implementarão o JPA para realizar manipulações no Banco de Dados.

Criação dos Repositórios utilizando JPA

Para iniciar crie uma interface chamada UsuarioRepositorio, essa interface vai herdar as características de JpaRepository<> passando dois valores genéricos, o primeiro é a entidade e o segundo é o tipo do Id. Não podemos deixar de esquecer de anotar a classe com a anotação @Repository, ficando dessa forma:

@Repository
public interface UsuarioRepositorio extends JpaRepository<Usuario, Integer> { }

O JpaRepository é uma interface do Spring Data JPA que fornece diversos métodos prontos para realizar operações de acesso a dados em uma aplicação, como por exemplo o findAll() que retorna todos os dados de uma determinada tabela de banco de dados. No final do artigo estarei deixando alguns links falando mais sobre.

Já temos o suficiente para realizar algumas consultas, vamos criar um ponto de entrada na nossa aplicação para ver esses dados.
Crie uma controller chamada: UsuariosController.
Nela vamos anotar com 2 anotações: @RestController e @RequestMapping("/v1/usuarios") para mapear a rota da nossa controller

Vamos fazer injeção de dependência da UsuarioRepository e criar um endpoint GET para obter os dados da controller.

No final ficará assim:

@RestController
@RequestMapping("/v1/usuarios")
public class UsuarioController {

    private UsuarioRepositorio usuarioRepositorio;

    public UsuarioController(UsuarioRepositorio usuarioRepositorio) {
        this.usuarioRepositorio = usuarioRepositorio;
    }

    @GetMapping()
    public ResponseEntity getUsuarios() {
        return ResponseEntity.status(HttpStatus.OK).body(usuarioRepositorio.findAll());
    }
}

Note que estou utilizando o método findAll() que mencionei mais acima existente na repository.

Em minha tabela de banco de dados, já possuo alguns dados. Fazendo uma consulta simples, virá o seguinte resultado:

Vimos que temos 3 dados na tabela.

Após salvar o conteúdo da controller e executar novamente o projeto, quando realizarmos uma requisição do tipo GET na url localhost:8080/v1/usuarios, virá o seguinte resultado:

Vemos que o resultado que foi resgatado ao realizar uma consulta no banco de dados foi exatamente o mesmo ao fazer uma requisição GET em nossa aplicação graças ao JPA e ao Spring Boot.

Chegamos ao final de mais um post. Estarei deixando alguns links de referência:

• Jpa Repository
• Anotação Generated Value
• Driver MySQL JPA
• Spring Boot YAML vs Properties
• Spring Data JPA

O repositório do artigo se encontra nesse link: Repositório Projeto

Um abraço e bons estudos! Até mais.

Das obige ist der detaillierte Inhalt vonSo starten Sie eine Spring Boot + JPA + MySQL-Anwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!