Spring @Repository Annotation with Example

03 Dec, 2021
Spring is one of the most popular Java EE frameworks. It is an open-source lightweight framework that allows Java EE 7 developers to build simple, reliable, and scalable enterprise applications. This framework mainly focuses on providing various ways to help you manage your business objects. It made the development of Web applications much easier than compared to classic Java frameworks and application programming interfaces (APIs), such as Java database connectivity (JDBC), JavaServer Pages(JSP), and Java Servlet. This framework uses various new techniques such as Aspect-Oriented Programming (AOP), Plain Old Java Object (POJO), and dependency injection (DI), to develop enterprise applications. Now talking about Spring Annotation
Spring Annotations are a form of metadata that provides data about a program. Annotations are used to provide supplemental information about a program. It does not have a direct effect on the operation of the code they annotate. It does not change the action of the compiled program. 
There are many annotations are available in Spring Framework. Some of the Spring Framework Annotations are listed below as follows where here we are going to discuss one of the most important annotations that is @Repository Annotation
@Required
@Autowired
@Configuration
@ComponentScan
@Bean
@Component
@Controller
@Service
@Repository, etc.
@Repository Annotation is a specialization of @Component annotation which is used to indicate that the class provides the mechanism for storage, retrieval, update, delete and search operation on objects. Though it is a specialization of @Component annotation, so Spring Repository classes are autodetected by spring framework through classpath scanning. This annotation is a general-purpose stereotype annotation which very close to the DAO pattern where DAO classes are responsible for providing CRUD operations on database tables. 
Step 1: Create a Simple Spring Boot Project
Refer to this article Create and Setup Spring Boot Project in Eclipse IDE and create a simple spring boot project. 
Step 2: Add the spring-context dependency in your pom.xml file. Go to the pom.xml file inside your project and add the following spring-context dependency.
XML
<dependency>    <groupId>org.springframework</groupId>    <artifactId>spring-context</artifactId>    <version>5.3.13</version></dependency>
Step 3: In your project create two packages and name the package as “entity” and “repository”. In the entity, package creates a class name it as Student. In the repository, the package creates a Generic Interface named as DemoRepository and a class name it as StudentRepository. This is going to be our final project structure.
Step 4: Create an entity class for which we will implement a spring repository. Here our entity class is Student. Below is the code for the Student.java file. This is a simple POJO (Plain Old Java Object) class in java. 
Java
package com.example.demo.entity;  public class Student {      private Long id;    private String name;    private int age;      public Student(Long id, String name, int age) {        this.id = id;        this.name = name;        this.age = age;    }      public Long getId() {        return id;    }      public void setId(Long id) {        this.id = id;    }      public String getName() {        return name;    }      public void setName(String name) {        this.name = name;    }      public int getAge() {        return age;    }      public void setAge(int age) {        this.age = age;    }      @Override    public String toString() {        return "Student{" +                "id=" + id +                ", name='" + name + '\'' +                ", age=" + age +                '}';    }}
Step 5: Before implementing the Repository class we have created a generic DemoRepository interface to provide the contract for our repository class to implement. Below is the code for the DemoRepository.java file.
Java
// Java Program to illustrate DemoRepository File  package com.example.demo.repository;  public interface DemoRepository<T> {      // Save method    public void save(T t);      // Find a student by its id    public T findStudentById(Long id);  }
Step 6: Now let’s look at our StudentRepository class implementation. 
Java
// Java Program to illustrate StudentRepository File  package com.example.demo.repository;  import com.example.demo.entity.Student;import org.springframework.stereotype.Repository;  import java.util.HashMap;import java.util.Map;  @Repositorypublic class StudentRepository implements DemoRepository<Student> {      // Using an in-memory Map    // to store the object data    private Map<Long, Student> repository;      public StudentRepository() {        this.repository = new HashMap<>();    }      // Implementation for save method    @Override    public void save(Student student) {        repository.put(student.getId(), student);    }      // Implementation for findStudentById method    @Override    public Student findStudentById(Long id) {        return repository.get(id);    }}
In this StudentRepository.java file, you can notice that we have added the @Repository annotation to indicate that the class provides the mechanism for storage, retrieval, update, delete and search operation on objects.
Note: Here we have used an in-memory Map to store the object data, you can use any other mechanisms too. In the real world, we use Databases to store object data. 
Step 7: Spring Repository Test
So now our Spring Repository is ready, let’s test it out. Go to the DemoApplication.java file and refer to the below code. 
Java
package com.example.demo;  import com.example.demo.entity.Student;import com.example.demo.repository.StudentRepository;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.context.annotation.AnnotationConfigApplicationContext;  @SpringBootApplicationpublic class DemoApplication {      public static void main(String[] args) {                  AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();        context.scan("com.example.demo");        context.refresh();          StudentRepository repository = context.getBean(StudentRepository.class);          // testing the store method        repository.save(new Student(1L, "Anshul", 25));        repository.save(new Student(2L, "Mayank", 23));          // testing the retrieve method        Student student = repository.findStudentById(1L);        System.out.println(student);          // close the spring context        context.close();    }  }
Output: Lastly, run your application and you should get the following output as shown below as follows:
Java-Spring
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.