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

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

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

Erstellen Sie die folgenden 3 Klassen als Domänenebene.

• User.java
• UserRepository.java
• USerService.java

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

User.java Eine Klasse zum Ausdrücken des Konzepts eines Benutzers in einer Anwendung. Diesmal gibt es kein bestimmtes Verhalten. Halten Sie einfach die erforderlichen Informationen bereit. Es wird kurz mit Lombok beschrieben.

User.java

package com.example.springapi.domain.object;

import lombok.Builder;
import lombok.Data;

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

    /**
     *Benutzeridentifikation
     */
    private String id;

    /**
     *Nutzerinformation
     */
    private String value;
}

※ Lombok @Data Die folgende Methode wird automatisch erstellt.

• Getter
• Setter
• Equals
• HashCode
• ToString
• Konstruktor, der nur das letzte Feld als Argument verwendet

So was.

package com.example.springapi.domain.object;

import lombok.Builder;

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

    /**
     *Benutzeridentifikation
     */
    private String id;

    /**
     *Nutzerinformation
     */
    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 Sie können die Instanzerstellung in einer Methodenkette beschreiben. Ich mag das. Sie können eine Benutzerinstanz wie diese erstellen.

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

Tatsächlich wird der folgende Code von Lombok generiert.

package com.example.springapi.domain.object;

import lombok.Data;

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

    /**
     *Benutzeridentifikation
     */
    private String id;

    /**
     *Nutzerinformation
     */
    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 Schnittstelle zwischen Domänenschicht und Infrastrukturschicht. Hier wird die Schnittstelle definiert, die Sie auf der Domänenebene verwenden möchten. Diese Schnittstelle kehrt die Abhängigkeiten zwischen der Domänenschicht und der Infrastrukturschicht um (das Prinzip der Abhängigkeitsumkehr).

UserRepository.java

package com.example.springapi.domain.repository;

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

import java.util.Optional;

/**
 *Schnittstelle zur Infrastrukturschicht
 */
public interface UserRepository {

    /**
     *Benutzersuche
     *
     * @param id Benutzer-ID, nach der Sie suchen möchten
     * @wiederkehrender Benutzer
     */
    Optional<User> findById(String id);

    /**
     *Benutzer erstellt und aktualisiert
     *
     * @param user Benutzer erstellt und aktualisiert
     * @Benutzer nach dem Update zurückgeben
     */
    User save(User user);

    /**
     *User Löschung
     *
     * @param id Benutzer-ID, die Sie löschen möchten
     */
    void deleteById(String id);
}

UserService.java Eine Klasse, die unnatürliche Geschäftslogik in User.java beschreibt. Bearbeiten Sie die persistierten Benutzerinformationen über die zuvor definierte Schnittstelle. Die Implementierungsklasse von UserRepository wird mithilfe des Mechanismus DI Container of Spring gelöst. (Wenn keine Schnittstellenimplementierung vorhanden ist, tritt an dieser Stelle immer noch ein Kompilierungsfehler auf.)

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;

/**
 *Benutzeroperationslogik
 */
@Service
@RequiredArgsConstructor
public class UserService {

    @NonNull
    private final UserRepository userRepository;

    /**
     *Benutzersuche
     *
     * @param id Benutzer-ID, nach der Sie suchen möchten
     * @wiederkehrender Benutzer
     */
    public Optional<User> findById(String id) {
        return this.userRepository.findById(id);
    }

    /**
     *Benutzer erstellt und aktualisiert
     *
     * @param user Benutzer erstellt und aktualisiert
     * @Benutzer nach dem Update zurückgeben
     */
    public User save(User user) {
        return this.userRepository.save(user);
    }

    /**
     *User Löschung
     *
     * @param id Benutzer-ID, die Sie löschen möchten
     */
    public void deleteById(String id) {
        this.userRepository.deleteById(id);
    }
}

* DI bis zum Frühjahr

Im Frühjahr wird DI durch einen Mechanismus namens DI-Container implementiert.

Normale Java-Abhängigkeiten

A.java

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

Klasse A ** hängt von Klasse B ** ab.

Für Spring DI

In Spring gibt es einen Mechanismus namens DI-Container, der Instanzen automatisch in die deklarierten Variablen einfügt. Durch Hinzufügen von @Autowired wird automatisch eine Instanz erstellt und eingefügt.

A.java

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

B.java

@Compornent
public class B {
}

Der angegebene Autowired ist jedoch nur gültig **, wenn die zu injizierende Klasse (A) über den DI-Container ** erhalten wird. Das heißt, wenn Sie eine neue Klasse A wie eine normale Java-Anwendung verwenden, bleibt b null. Daher ist es bei Verwendung von Autowired erforderlich, sich im DI-Container zu registrieren. Es gibt verschiedene Möglichkeiten, sich in einem Container zu registrieren. In Spring Boot wird es jedoch grundsätzlich registriert, indem der Klasse @Compornent zugewiesen wird. Der diesmal verwendete @ Service ist ein Alias von @Compornent.

* Arten von DI bis zum Frühjahr

Der DI of Spring hat die folgende Notation. IntelliJ wird wütend, wenn ich eine Feldinjektion mache. (Aus verschiedenen Gründen wie Wiederverwendbarkeit, Unveränderlichkeit von Instanzen und explizite Abhängigkeit) Es gibt auch eine Setter-Injektion, aber ich habe sie nicht verwendet, deshalb werde ich sie weglassen.

• Feldinjektion

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

• Konstruktorinjektion

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

* Konstruktorinjektion mit Lombok

@Autowired kann weggelassen werden, wenn nur ein Konstruktor vorhanden ist. Dies kann durch Verwendung der Annotation der Lombok-Konstruktorgeneration weggelassen werden.

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