L’annotation @Repository Spring

L’annotation @Repository de Spring est utilisée pour indiquer que la classe fournit le mécanisme de stockage, de récupération, de recherche, de mise à jour et de suppression d’objets.

Annotation Spring @Repository

L’annotation Spring Repository est une spécialisation de l’annotation @Component, donc les classes Spring Repository sont détectées automatiquement par le framework Spring via l’analyse du classpath. Le Repository Spring est très proche du modèle DAO où les classes DAO sont responsables de fournir des opérations CRUD sur les tables de la base de données. Cependant, si vous utilisez Spring Data pour gérer les opérations sur la base de données, vous devriez utiliser l’interface Spring Data Repository.

Exemple de Repository Spring

Jetons un simple exemple où nous allons créer une classe Spring Repository. Nous n’utiliserons pas d’opérations de base de données, mais nous fournirons un référentiel pour un objet. Créez un projet Maven dans Eclipse ou tout autre IDE que vous utilisez, puis ajoutez la dépendance de base Spring.

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.0.6.RELEASE</version>
</dependency>

L’image ci-dessous montre la structure finale de notre projet dans Eclipse. Créons la classe modèle pour laquelle nous implémenterons un référentiel Spring.

package com.journaldev.spring.model;

public class Employee {

	private int id;
	private String name;
	private String jobTitle;

	public Employee() {
	}

	public Employee(int i, String n, String jt) {
		this.id = i;
		this.name = n;
		this.jobTitle = jt;
	}

	public int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getJobTitle() {
		return jobTitle;
	}

	public void setJobTitle(String jobTitle) {
		this.jobTitle = jobTitle;
	}

	@Override
	public String toString() {
		return id + "," + name + "," + jobTitle;
	}
}

Avant d’implémenter la classe Repository, j’ai créé une interface générique ObjectRepository pour définir le contrat que notre classe de référentiel doit implémenter.

package com.journaldev.spring.repository;

public interface ObjectRepository<T> {

	public void store(T t);

	public T retrieve(int id);

	public T search(String name);

	public T delete(int id);
}

I am using Generics here, it’s a powerful technology to provide loosely coupled contract for the applications to implement. Now let’s look at our Repository class implementation.

package com.journaldev.spring.repository;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Repository;

import com.journaldev.spring.model.Employee;

@Repository
public class EmployeeRepository implements ObjectRepository<Employee> {

	private Map<Integer, Employee> repository;

	public EmployeeRepository() {
		this.repository = new HashMap<>();
	}

	@Override
	public void store(Employee emp) {
		repository.put(emp.getId(), emp);
	}

	@Override
	public Employee retrieve(int id) {
		return repository.get(id);
	}

	@Override
	public Employee search(String name) {
		Collection<Employee> emps = repository.values();
		for (Employee emp : emps) {
			if (emp.getName().equalsIgnoreCase(name))
				return emp;
		}
		return null;
	}

	@Override
	public Employee delete(int id) {
		Employee e = repository.get(id);
		this.repository.remove(id);
		return e;
	}

}

Notez que j’utilise une Map en mémoire pour stocker les données de l’objet, vous pouvez également utiliser d’autres mécanismes.

Test du référentiel Spring

Notre référentiel Spring est prêt, créons une classe principale et testons-le.

package com.journaldev.spring;

import java.sql.SQLException;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.journaldev.spring.model.Employee;
import com.journaldev.spring.repository.EmployeeRepository;

public class SpringMainClass {

	public static void main(String[] args) throws SQLException {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
		context.scan("com.journaldev.spring");
		context.refresh();

		EmployeeRepository repository = context.getBean(EmployeeRepository.class);

		// store
		repository.store(new Employee(1, "Pankaj", "CEO"));
		repository.store(new Employee(2, "Anupam", "Editor"));
		repository.store(new Employee(3, "Meghna", "CFO"));

		// retrieve
		Employee emp = repository.retrieve(1);
		System.out.println(emp);

		// search
		Employee cfo = repository.search("Meghna");
		System.out.println(cfo);

		// supprimer
		Employee editor = repository.delete(2);
		System.out.println(editor);

		// fermer le contexte Spring
		context.close();
	}

}

Exécutez simplement la classe en tant qu’application Java et vous devriez obtenir le résultat suivant.

1,Pankaj,CEO
3,Meghna,CFO
2,Anupam,Editor

Vous pouvez télécharger le code d’exemple depuis notre référentiel GitHub.

Référence: Documentation de l’API