[JAVA] Implémenter l'API REST avec Spring Boot et JPA (Domain Layer Edition)

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

Outline Implémentez la couche de domaine 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 comme couche de domaine.

├── domain
│   ├── object
│   │   └── User.java
│   ├── repository
│   │   └── UserRepository.java
│   └── service
│       └── UserService.java

User.java Une classe pour exprimer le concept d'utilisateur sur une application. Il n'y a pas de comportement particulier cette fois, il suffit de détenir les informations nécessaires. Il est décrit brièvement en utilisant Lombok.

User.java


package com.example.springapi.domain.object;

import lombok.Builder;
import lombok.Data;

/**
 *Utilisateur
 */
@Data
@Builder
public class User {

    /**
     *Identifiant d'utilisateur
     */
    private String id;

    /**
     *Informations de l'utilisateur
     */
    private String value;
}

※ Lombok @Data La méthode suivante est créée automatiquement.

Comme ça.


package com.example.springapi.domain.object;

import lombok.Builder;

/**
 *Utilisateur
 */
@Builder
public class User {

    /**
     *Identifiant d'utilisateur
     */
    private String id;

    /**
     *Informations de l'utilisateur
     */
    private String value;

    public String getId() {
        return this.id;
    }

    public String getValue() {
        return this.value;
    }

    public void setId(String id) {
        this.id = id;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public boolean equals(Object o) {
        if (o == this) return true;
        if (!(o instanceof User)) return false;
        final User other = (User) o;
        if (!other.canEqual((Object) this)) return false;
        final Object this$id = this.getId();
        final Object other$id = other.getId();
        if (this$id == null ? other$id != null : !this$id.equals(other$id)) return false;
        final Object this$value = this.getValue();
        final Object other$value = other.getValue();
        if (this$value == null ? other$value != null : !this$value.equals(other$value)) return false;
        return true;
    }

    public int hashCode() {
        final int PRIME = 59;
        int result = 1;
        final Object $id = this.getId();
        result = result * PRIME + ($id == null ? 43 : $id.hashCode());
        final Object $value = this.getValue();
        result = result * PRIME + ($value == null ? 43 : $value.hashCode());
        return result;
    }

    protected boolean canEqual(Object other) {
        return other instanceof User;
    }

    public String toString() {
        return "User(id=" + this.getId() + ", value=" + this.getValue() + ")";
    }
}

@Builder Vous pourrez décrire la création d'instances dans une chaîne de méthodes. J'aime ça. Vous pouvez créer une instance User comme celle-ci.

String id;
String value;
User user = User.builder()
                .id(id)
                .value(value)
                .build();

En fait, le code suivant est généré par Lombok.

package com.example.springapi.domain.object;

import lombok.Data;

/**
 *Utilisateur
 */
@Data
public class User {

    /**
     *Identifiant d'utilisateur
     */
    private String id;

    /**
     *Informations de l'utilisateur
     */
    private String value;

    @java.beans.ConstructorProperties({"id", "value"})
    User(String id, String value) {
        this.id = id;
        this.value = value;
    }

    public static UserBuilder builder() {
        return new UserBuilder();
    }

    public static class UserBuilder {
        private String id;
        private String value;

        UserBuilder() {
        }

        public UserBuilder id(String id) {
            this.id = id;
            return this;
        }

        public UserBuilder value(String value) {
            this.value = value;
            return this;
        }

        public User build() {
            return new User(id, value);
        }

        public String toString() {
            return "User.UserBuilder(id=" + this.id + ", value=" + this.value + ")";
        }
    }
}

UserRepository.java Interface entre la couche de domaine et la couche d'infrastructure. L'interface que vous souhaitez utiliser au niveau de la couche de domaine est définie ici. Cette interface inverse les dépendances entre la couche domaine et la couche infrastructure (principe de l'inversion des dépendances).

UserRepository.java


package com.example.springapi.domain.repository;

import com.example.springapi.domain.object.User;

import java.util.Optional;

/**
 *Interface avec la couche infrastructure
 */
public interface UserRepository {

    /**
     *Recherche d'utilisateurs
     *
     * @param id ID utilisateur que vous souhaitez rechercher
     * @retour utilisateur
     */
    Optional<User> findById(String id);

    /**
     *Utilisateur créé et mis à jour
     *
     * @utilisateur param Utilisateur créé et mis à jour
     * @retourner l'utilisateur après la mise à jour
     */
    User save(User user);

    /**
     *Suppression de l'utilisateur
     *
     * @param id ID utilisateur que vous souhaitez supprimer
     */
    void deleteById(String id);
}

UserService.java Une classe qui décrit la logique métier non naturelle dans User.java. Manipulez les informations utilisateur persistantes à l'aide de l'interface définie précédemment. La classe d'implémentation de UserRepository est résolue en utilisant le mécanisme appelé conteneur DI de Spring. (S'il n'y a pas d'implémentation d'interface, une erreur de compilation se produira toujours à ce stade.)

UserService.java


package com.example.springapi.domain.service;

import com.example.springapi.domain.object.User;
import com.example.springapi.domain.repository.UserRepository;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.Optional;

/**
 *Logique de fonctionnement de l'utilisateur
 */
@Service
@RequiredArgsConstructor
public class UserService {

    @NonNull
    private final UserRepository userRepository;

    /**
     *Recherche d'utilisateurs
     *
     * @param id ID utilisateur que vous souhaitez rechercher
     * @retour utilisateur
     */
    public Optional<User> findById(String id) {
        return this.userRepository.findById(id);
    }

    /**
     *Utilisateur créé et mis à jour
     *
     * @utilisateur param Utilisateur créé et mis à jour
     * @retourner l'utilisateur après la mise à jour
     */
    public User save(User user) {
        return this.userRepository.save(user);
    }

    /**
     *Suppression de l'utilisateur
     *
     * @param id ID utilisateur que vous souhaitez supprimer
     */
    public void deleteById(String id) {
        this.userRepository.deleteById(id);
    }
}

* DI par Spring

Dans Spring, DI est implémenté par un mécanisme appelé conteneur DI.

Dépendances Java normales

A.java


public class A {
    private B b = new B();
}

La classe A ** dépend de la classe B **.

Pour Spring DI

Dans Spring, il existe un mécanisme appelé conteneur DI qui injecte automatiquement des instances dans les variables déclarées. En ajoutant @Autowired, une instance est automatiquement créée et injectée.

A.java


@Compornent
public class A {
    @Autowired
    private B b;
}

B.java


@Compornent
public class B {
}

Cependant, l'Autowired donné n'est valide que ** lorsque la classe (A) à injecter est obtenue via le conteneur DI **. Autrement dit, si vous créez une nouvelle classe A comme une application Java normale, b reste nul. Par conséquent, lors de l'utilisation d'Autowired, il est nécessaire de s'enregistrer dans le conteneur DI. Il existe différentes façons de s'inscrire dans un conteneur, mais dans Spring Boot, il est essentiellement enregistré en attribuant @Compornent à la classe. Le @Service utilisé cette fois est un alias de @Compornent.

* Types de DI par printemps

Le DI de Spring a la notation suivante. IntelliJ se met en colère quand je fais une injection de champ. (Pour diverses raisons telles que la réutilisabilité, l'immuabilité des instances et la dépendance explicite) Il y a aussi l'injection de setter, mais je ne l'ai pas utilisé, donc je vais l'omettre.

@Compornent
public class A {
    @Autowired
    private B b;
}
@Compornent
public class A {
    private B b;
    
    @Autowired
    public A(B b) {
        this.b = b;
    }
}

* Injection de constructeur avec Lombok

@Autowired peut être omis s'il n'y a qu'un seul constructeur. Si vous utilisez l'annotation de la génération du constructeur de Lombok, vous pouvez l'omettre jusqu'à présent.

@RequiredArgsConstructor
@Compornent
public class A {
    @NonNull
    private final B b;
}

Recommended Posts

Implémenter l'API REST avec Spring Boot et JPA (Domain Layer Edition)
Implémenter l'API REST avec Spring Boot et JPA (Application Layer)
Implémenter l'API REST avec Spring Boot et JPA (couche d'infrastructure)
Implémentez une API Rest simple avec Spring Security avec Spring Boot 2.0
Implémenter l'API REST avec Spring Boot
Implémentez une API Rest simple avec Spring Security & JWT avec Spring Boot 2.0
Implémentez un serveur API Web REST simple avec Spring Boot + MySQL
Implémenter GraphQL avec Spring Boot
Hello World (API REST) avec Apache Camel + Spring Boot 2
Personnalisez la réponse aux erreurs de l'API REST avec Spring Boot (Partie 2)
Personnalisez la réponse aux erreurs de l'API REST avec Spring Boot (Partie 1)
Spring avec Kotorin - 4 Conception d'API REST
Gérez l'API de date et d'heure Java 8 avec Thymeleaf avec Spring Boot
Connectez-vous à la base de données avec spring boot + spring jpa et effectuez l'opération CRUD
Développement piloté par domaine avec Java et Spring Boot-Layer et division de modules
[Débutant] Essayez d'écrire l'API REST pour l'application Todo avec Spring Boot
Créer une API REST avec Spring JPA Data avec REST et Lombok incroyablement facile.
HTTPS avec Spring Boot et Let's Encrypt
Implémenter CRUD avec Spring Boot + Thymeleaf + MySQL
Implémenter la fonction de pagination avec Spring Boot + Thymeleaf
Méthode d'implémentation pour source multi-données avec Spring boot (Mybatis et Spring Data JPA)
Essayez d'implémenter la fonction de connexion avec Spring Boot
Créer un serveur API Web avec Spring Boot
Télécharger avec Spring Boot
Test des entités et référentiels JPA à l'aide de Spring Boot @DataJpaTest
Essayez d'utiliser un conteneur DI avec Laravel et Spring Boot
J'ai créé un domaine api avec Spring Framework. Partie 2
Changer d'environnement avec Spring Boot application.properties et l'annotation @Profile
Mappez automatiquement DTO aux entités avec l'API Spring Boot
Mémo d'utilisation de Spring Security: coopération avec Spring MVC et Boot
Spring Boot avec les paramètres du filtre de sécurité Spring et les points addictifs
Un mémorandum lors de la création d'un service REST avec Spring Boot
J'ai créé un domaine api avec Spring Framework. Partie 1
Présentez swagger-ui à l'API REST implémentée dans Spring Boot
Tentative de SSR Vue.js avec Spring Boot et GraalJS
Connectez Spring Boot et Angular en toute sécurité avec OpenAPI Generator
Générer un code à barres avec Spring Boot
J'ai essayé le guide d'introduction de Spring Boot [Accès aux données avec JPA]
Démarrez avec Spring Boot
Bonjour tout le monde avec Spring Boot!
Exécutez LIFF avec Spring Boot
Connexion SNS avec Spring Boot
Téléchargement de fichiers avec Spring Boot
Spring Boot commençant par copie
Faisons une API simple avec EC2 + RDS + Spring boot ①
Jusqu'à INSERT et SELECT sur Postgres avec botte de printemps et feuille de thym
Ressort avec Kotorin ―― 7. Couche de service
Essayez d'utiliser l'API de recherche de code postal avec Spring Boot
Spring Boot à partir de Docker
Définir des cookies avec Spring Boot
Test de l'API REST avec REST Assured
Utiliser Spring JDBC avec Spring Boot
Avec Spring Boot, hachez le mot de passe et utilisez l'enregistrement des membres et la sécurité Spring pour implémenter la fonction de connexion.
Ajouter un module avec Spring Boot
Premiers pas avec Spring Boot
Lier l'API avec Spring + Vue.js
Créer un micro service avec Spring Boot
Envoyer du courrier avec Spring Boot
8 choses à insérer dans DB en utilisant Spring Boot et JPA
Découvrons comment recevoir avec Request Body avec l'API REST de Spring Boot
Paramètres de proxy et de délai d'expiration lors de l'appel de l'API avec le modèle Spring Rest