Anotação @Repository da Primavera

Primavera @Repository a anotação é usada para indicar que a classe fornece o mecanismo para operações de armazenamento, recuperação, pesquisa, atualização e exclusão em objetos.

Primavera @Repository Anotação

A anotação do Repositório Spring é uma especialização da anotação @Component, então as classes do Repositório Spring são detectadas automaticamente pelo framework Spring por meio da varredura do classpath. O Repositório Spring é muito próximo ao padrão DAO onde as classes DAO são responsáveis por fornecer operações CRUD em tabelas de banco de dados. No entanto, se você estiver usando Spring Data para gerenciar operações de banco de dados, então você deve usar a interface Spring Data Repository.

Exemplo de Repositório Spring

Vamos dar uma olhada em um exemplo simples onde iremos criar uma classe de Repositório Spring. Não iremos usar operações de banco de dados, em vez disso, iremos fornecer um repositório para um objeto. Crie um projeto Maven no Eclipse ou em qualquer outra IDE que você use, em seguida, adicione a dependência do Spring Core.

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

A imagem abaixo mostra a estrutura final do nosso projeto no Eclipse. Vamos criar a classe de modelo para a qual implementaremos um repositório 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 implementarmos a classe Repository, criei uma interface genérica ObjectRepository para fornecer o contrato que nossa classe de repositório deve 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;
	}

}

Observe que estou usando um Map em memória para armazenar os dados do objeto, você também pode usar outros mecanismos.

Teste de Repositório Spring

Nosso Repositório Spring está pronto, vamos criar uma classe principal e testá-lo.

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

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

		// fechar o contexto do Spring
		context.close();
	}

}

Basta executar a classe como Aplicação Java e você deverá obter a seguinte saída.

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

Você pode baixar o código de exemplo do nosso Repositório GitHub.

Referência: Documentação da API