La anotación @Repository de Spring

La anotación @Repository de Spring se utiliza para indicar que la clase proporciona el mecanismo para almacenar, recuperar, buscar, actualizar y eliminar operaciones en objetos.

Spring @Repository Annotation

La anotación Spring Repository es una especialización de @Component, por lo que las clases de Spring Repository son detectadas automáticamente por el framework de Spring a través del escaneo del classpath. Spring Repository es muy cercano al patrón DAO donde las clases DAO son responsables de proporcionar operaciones CRUD en las tablas de la base de datos. Sin embargo, si estás utilizando Spring Data para gestionar las operaciones de la base de datos, deberías usar la interfaz Spring Data Repository.

Ejemplo de Spring Repository

Veamos un ejemplo simple en el que crearemos una clase Repositorio de Spring. No utilizaremos operaciones de base de datos, sino que proporcionaremos un repositorio para un Objeto. Cree un proyecto Maven en Eclipse o en cualquier otro IDE que utilice, luego agregue la dependencia de Spring Core.

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

La imagen siguiente muestra la estructura final de nuestro proyecto en Eclipse. Creemos la clase de modelo para la cual implementaremos un repositorio de 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;
	}
}

Antes de implementar la clase Repository, he creado una interfaz genérica ObjectRepository para proporcionar el contrato que nuestra clase de repositorio debe implementar.

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;
	}

}

Tenga en cuenta que estoy utilizando un Map en memoria para almacenar los datos del objeto, también puede utilizar otros mecanismos.

Prueba del Repositorio de Spring

Nuestro Repositorio de Spring está listo, creemos una clase principal y probémoslo.

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);

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

		// cerrar el contexto de Spring
		context.close();
	}

}

Solo ejecute la clase como Aplicación Java y debería obtener la siguiente salida.

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

Puede descargar el código de ejemplo desde nuestro Repositorio de GitHub.

Referencia: Documentación de la API