Créez une couche d'accès aux données basée sur ORM à l'aide de Spring Boot et JPA

Dans le développement d'applications modernes, la couche d'accès aux données joue un rôle clé en tant que pont entre l'application et la base de données. ORM (Object Relational Mapping) est devenu une technologie importante pour améliorer l'efficacité du développement de la couche d'accès aux données et simplifier la programmation des bases de données. Cet article explique comment utiliser Spring Boot et JPA pour créer une couche d'accès aux données basée sur ORM.

1. Introduction

Spring Boot est un framework Java léger permettant de créer rapidement des applications Web. Il offre de nombreuses fonctionnalités pratiques telles qu'une configuration automatique et un développement rapide. Pendant ce temps, JPA (Java Persistence API) est un framework Java ORM qui mappe des objets Java aux tables d'une base de données relationnelle. Grâce à Spring Boot et JPA, nous pouvons créer rapidement et efficacement une couche d'accès aux données basée sur ORM.

2. Configurer les dépendances

Spring Boot fournit de nombreuses dépendances qui peuvent facilement intégrer d'autres frameworks. Tout d'abord, nous devons ajouter les dépendances suivantes dans le fichier pom. starter-data-jpa" pour utiliser le framework JPA et "h2" pour la base de données en mémoire, nous permettant de développer et de tester rapidement notre application.

Création de classes d'entités

3. Avant de commencer à utiliser JPA pour l'accès aux données, nous devons créer des classes d'entités correspondant aux tables de la base de données. Ici, je vais créer une classe d'entité appelée "Utilisateur" qui sera mappée à une table de base de données appelée "utilisateurs". Voici le code de la classe d'entité :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Dans le code ci-dessus, l'annotation "@Entity" est utilisée pour mapper la classe Java à la classe d'entité, et l'annotation "@Table" est utilisé pour spécifier la table correspondante dans le nom de la base de données. De plus, l'annotation "@Id" permet d'identifier la clé primaire de l'entité, et l'annotation "@GeneratedValue" précise la stratégie de génération de la clé primaire.

Créer une couche d'accès aux données

Maintenant, nous pouvons créer une couche d'accès aux données pour utiliser JPA pour l'accès aux données. Ici, je vais créer une interface appelée "UserRepository" qui héritera de l'interface "CrudRepository" de Spring Data JPA. Voici le code de "UserRepository":

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String firstName;
    
    private String lastName;
    
    private String email;
    
    // getters and setters
}

Dans le code ci-dessus, l'annotation "@Repository" est utilisée pour identifier la couche d'accès aux données en tant que composant Spring, et l'interface "CrudRepository" fournit certaines opérations CRUD de base (par exemple, enregistrer, mettre à jour ou supprimer des entités).

Injecter la couche d'accès aux données

Maintenant, nous pouvons injecter la couche d'accès aux données précédemment créée dans la couche de service de l'application. Ici, je vais créer une classe appelée "UserService" qui utilisera "UserRepository" pour effectuer l'accès aux données. Voici le code de "UserService":

@Repository
public interface UserRepository extends CrudRepository<User, Long> {
    
}

Dans le code ci-dessus, l'annotation "@Service" est utilisée pour identifier la couche de service en tant que composant Spring, et l'annotation "@Autowired" est utilisé pour injecter "UserRepository" dans "UserService" pour l'accès aux données. De plus, la méthode « getUsers » récupère tous les utilisateurs de la base de données à l'aide de la méthode « findAll », la méthode « saveUser » enregistre les utilisateurs dans la base de données et la méthode « deleteUsers » supprime tous les utilisateurs.

Écrire une classe de contrôleur

Enfin, nous devons écrire une classe de contrôleur pour exposer la couche de service en tant qu'API REST. Ici, je vais créer une classe de contrôleur appelée "UserController" qui utilisera "UserService" pour gérer les requêtes HTTP. Voici le code de "UserController" :

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public Iterable<User> getUsers() {
        return userRepository.findAll();
    }
    
    public void saveUser(User user) {
        userRepository.save(user);
    }
    
    public void deleteUsers() {
        userRepository.deleteAll();
    }
}

Dans le code ci-dessus, l'annotation "@RestController" est utilisée pour identifier la classe de contrôleur en tant que contrôleur Spring MVC, et l'annotation "@RequestMapping" est utilisé pour mapper la requête à la classe du contrôleur. De plus, la méthode "getUsers" mappe les requêtes HTTP GET au chemin "/users" et récupère tous les utilisateurs à l'aide de "UserService", et la méthode "saveUser" mappe les requêtes HTTP POST au chemin "/users" et enregistre les utilisateurs dans le chemin "/users". base de données, la méthode "deleteUsers" mappe la requête HTTP DELETE au chemin "/users" et supprime tous les utilisateurs de la base de données.

Conclusion

7. Dans cet article, nous avons présenté comment créer une couche d'accès aux données basée sur ORM à l'aide de Spring Boot et JPA. En créant des classes d'entités, une couche d'accès aux données et une couche de service, en les intégrant aux classes de contrôleurs, nous pouvons facilement effectuer des opérations CRUD de base et exposer les données en tant qu'API REST. L'utilisation d'ORM a changé la façon dont la programmation des bases de données est effectuée et amélioré l'efficacité du développement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!