Spring Repository Annotation
Die Spring Repository Annotation wird verwendet, um anzuzeigen, dass die Klasse den Mechanismus für Speicherung, Abruf, Suche, Aktualisierung und Löschoperationen an Objekten bereitstellt.
Die Spring Repository Annotation ist eine Spezialisierung der @Component Annotation, daher werden Spring Repository Klassen durch das Spring Framework mittels Klassenpfad-Scanning automatisch erkannt. Spring Repository ähnelt sehr dem DAO-Muster, bei dem DAO-Klassen für die Bereitstellung von CRUD-Operationen auf Datenbanktabellen verantwortlich sind. Wenn Sie jedoch Spring Data für die Verwaltung von Datenbankoperationen verwenden, sollten Sie die Spring Data Repository Schnittstelle verwenden.
Spring Repository Beispiel
Lassen Sie uns ein einfaches Beispiel betrachten, in dem wir eine Spring Repository Klasse erstellen werden. Wir werden keine Datenbankoperationen verwenden, sondern ein Repository für ein Objekt bereitstellen. Erstellen Sie ein Maven-Projekt in Eclipse oder einer anderen von Ihnen verwendeten IDE und fügen Sie dann die Spring Core Abhängigkeit hinzu.
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.6.RELEASE</version>
</dependency>
Das folgende Bild zeigt unsere endgültige Projektstruktur in Eclipse.
Lassen Sie uns die Modellklasse erstellen, für die wir ein Spring Repository implementieren werden.
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;
}
}
Bevor wir die Repository-Klasse implementieren, habe ich eine generische ObjectRepository-Schnittstelle erstellt, um den Vertrag für unsere zu implementierende Repository-Klasse bereitzustellen.
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);
}
Ich verwende hier Generics, eine leistungsstarke Technologie, um einen locker gekoppelten Vertrag für die Implementierung durch Anwendungen bereitzustellen. Lassen Sie uns nun unsere Repository-Klassenimplementierung betrachten.
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;
}
}
Beachten Sie, dass ich eine In-Memory-Map verwende, um die Objektdaten zu speichern, Sie können auch andere Mechanismen verwenden.
Spring Repository Annotation Test
Unser Spring Repository Annotation ist fertig, lassen Sie uns eine Hauptklasse erstellen und sie testen.
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);
// delete
Employee editor = repository.delete(2);
System.out.println(editor);
// close the spring context
context.close();
}
}
Führen Sie einfach die Klasse als Java-Anwendung aus und Sie sollten folgende Ausgabe erhalten.
1,Pankaj,CEO
3,Meghna,CFO
2,Anupam,Editor
