[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.
- User.java
- UserRepository.java
- USerService.java
├── 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.
- Getter
- Setter
- Equals
- HashCode
- ToString --Constructeur qui ne prend que le champ final comme argument
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.
- Injection sur le terrain
@Compornent
public class A {
@Autowired
private B b;
}
- Injection de constructeur
@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