[JAVA] Implémenter l'API REST avec Spring Boot et JPA (couche d'infrastructure)

Implémentation d'un serveur API REST Web simple avec Spring Boot + MySQL --Qiita

Outline Implémentez la couche d'infrastructure selon la conception suivante. Considérez l'architecture de l'API Web implémentée par Spring Boot --Qiita

Créez les 3 classes suivantes.

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

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

UserEntity.java La classe à laquelle les enregistrements MySQL sont mappés. Définissez une méthode de conversion bidirectionnelle avec 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;

/**
 *Classe de mappage d'enregistrement RDB
 */
@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;

    /**
     *Créer une instance à partir d'un objet de domaine
     *
     * @objet de domaine utilisateur param
     * @return UserEntity
     */
    public static UserEntity build(User user) {
        return UserEntity.builder()
                .id(user.getId())
                .value(user.getValue())
                .build();
    }

    /**
     *Convertir en objet de domaine
     *
     * @objet de domaine de retour
     */
    public User toDomainUser() {
        return User.builder()
                .id(this.id)
                .value(this.value)
                .build();
    }
}

* Annotation JPA

@Entity Cela exprime l'entité JPA (classe mappée). @Table Spécifiez le nom de la table. @id Spécifie qu'il s'agit de la clé primaire. Dans le cas d'une clé composée, la méthode d'écriture change. @Column Spécifiez le nom de colonne de la table.

* Annotation Lombok

@NoArgsConstructor Créez automatiquement un constructeur sans arguments. Un constructeur sans argument est requis en raison du cycle de vie de l'entité JPA. Non requis si la configuration a un constructeur sans argument. (Lorsqu'il n'y a pas de champ final, etc. C'est absolument nécessaire si vous utilisez @Builder) @AllArgsConstructor Créez un constructeur qui prend tous les champs comme arguments. Si NoArgsConstructor est spécifié, @Builder ne fonctionnera que si cela est également spécifié (@Builder génère automatiquement un constructeur qui prend tous les champs comme arguments, mais ne crée pas de constructeur pour les classes avec xxxArgsConstructor. Et ça ne marche pas.)

UserJpaRepository.java Interface requise pour utiliser l'implémentation JPA. Héritez JpaRepository et spécifiez la classe Entity et le type de clé primaire. Lors de l'exécution, l'implémentation standard fournie par spring-data-jpa appelée SimpleJpaRepository est injectée par le conteneur DI, il n'est donc pas nécessaire d'écrire une classe d'implémentation.

UserJpaRepository.java

package com.example.springapi.infrastructure.repository;

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

/**
 *Interface pour utiliser JPA
 */
public interface UserJpaRepository extends JpaRepository<UserEntity, String> {
}

UserRepositoryImpl.java Classe d'implémentation de l'interface UserRepository définie dans la couche de domaine. Le traitement proprement dit est effectué par 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;

/**
 *Classe d'implémentation de persistance
 *Convertir un objet de domaine en entité et encapsuler JPA
 */
@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 Un autre nom pour @Compornent. Avec @Service.