[JAVA] Implementieren Sie die REST-API mit Spring Boot und JPA (Infrastructure Layer).

Implementierung eines einfachen Web-REST-API-Servers mit Spring Boot + MySQL - Qiita

Outline Implementieren Sie die Infrastrukturschicht gemäß dem folgenden Entwurf. Betrachten Sie die von Spring Boot --Qiita implementierte Architektur der Web-API

Erstellen Sie die folgenden 3 Klassen.

• UserEntity.java
• UserJpaRepository.java
• UserRepository.java

├── infrastructure
│   ├── entity
│   │   └── UserEntity.java
│   └── repository
│       ├── UserJpaRepository.java
│       └── UserRepositoryImpl.java

UserEntity.java Die Klasse, der MySQL-Datensätze zugeordnet sind. Definieren Sie eine Methode zum bidirektionalen Konvertieren mit Domain Object (User.java).

UserEntity.java

package com.example.springapi.infrastructure.entity;

import com.example.springapi.domain.object.User;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 *RDB-Datensatzzuordnungsklasse
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "test_users")
public class UserEntity {
    @Id
    @Column(name = "id")
    private String id;

    @Column(name = "value")
    private String value;

    /**
     *Erstellen Sie eine Instanz aus einem Domänenobjekt
     *
     * @param Benutzerdomänenobjekt
     * @return UserEntity
     */
    public static UserEntity build(User user) {
        return UserEntity.builder()
                .id(user.getId())
                .value(user.getValue())
                .build();
    }

    /**
     *In Domänenobjekt konvertieren
     *
     * @Domain-Objekt zurückgeben
     */
    public User toDomainUser() {
        return User.builder()
                .id(this.id)
                .value(this.value)
                .build();
    }
}

* JPA-Anmerkung

@Entity Dies drückt die JPA-Entität (zugeordnete Klasse) aus. @Table Geben Sie den Tabellennamen an. @id Gibt an, dass es sich um den Primärschlüssel handelt. Bei einem zusammengesetzten Schlüssel ändert sich die Schreibmethode. @Column Geben Sie den Spaltennamen der Tabelle an.

* Lombok-Anmerkung

@NoArgsConstructor Erstellen Sie automatisch einen Konstruktor ohne Argumente. Aufgrund des Lebenszyklus der JPA-Entität ist ein Konstruktor ohne Argumente erforderlich. Nicht erforderlich, wenn die Konfiguration einen Konstruktor ohne Argumente enthält. (Wenn es kein endgültiges Feld usw. gibt. Es ist unbedingt erforderlich, wenn Sie @Builder verwenden.) @AllArgsConstructor Erstellen Sie einen Konstruktor, der alle Felder als Argumente verwendet. Wenn NoArgsConstructor angegeben ist, funktioniert @Builder nur, wenn dies ebenfalls angegeben ist (@Builder generiert automatisch einen Konstruktor, der alle Felder als Argumente verwendet, jedoch keinen Konstruktor für Klassen mit xxxArgsConstructor erstellt. Und es funktioniert nicht.)

UserJpaRepository.java Schnittstelle erforderlich, um die JPA-Implementierung zu verwenden. Erben Sie JpaRepository und geben Sie die Entitätsklasse und den Primärschlüsseltyp an. Zur Laufzeit wird die von spring-data-jpa bereitgestellte Standardimplementierung namens SimpleJpaRepository vom DI-Container injiziert, sodass keine Implementierungsklasse geschrieben werden muss.

UserJpaRepository.java

package com.example.springapi.infrastructure.repository;

import com.example.springapi.infrastructure.entity.UserEntity;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 *Schnittstelle zur Verwendung von JPA
 */
public interface UserJpaRepository extends JpaRepository<UserEntity, String> {
}

UserRepositoryImpl.java Implementierungsklasse der in der Domänenschicht definierten UserRepository-Schnittstelle. Die eigentliche Verarbeitung erfolgt durch SimpleJpaRepository.

UserRepositoryImpl.java

package com.example.springapi.infrastructure.repository;

import com.example.springapi.domain.object.User;
import com.example.springapi.domain.repository.UserRepository;
import com.example.springapi.infrastructure.entity.UserEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.Optional;

/**
 *Persistenz-Implementierungsklasse
 *Konvertieren Sie das Domänenobjekt in eine Entität und schließen Sie JPA ein
 */
@Repository
@RequiredArgsConstructor
public class UserRepositoryImpl implements UserRepository {

    @NonNull
    private final UserJpaRepository userJpaRepository;

    /**
     * {@inheritDoc}
     */
    @Override
    public Optional<User> findById(String id) {
        return this.userJpaRepository.findById(id)
                .map(UserEntity::toDomainUser);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public User save(User user) {
        return this.userJpaRepository.save(UserEntity.build(user))
                .toDomainUser();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void deleteById(String id) {
        this.userJpaRepository.deleteById(id);
    }
}

@Repository Ein anderer Name für @Compornent. Mit @Service.