Skip to content
Related Articles

Related Articles

Spring Boot – Difference Between @Service Annotation and @Repository Annotation

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 02 May, 2022

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. 

@Service Annotation

In an application, the business logic resides within the service layer so we use the @Service Annotation to indicate that a class belongs to that layer. It is also a specialization of @Component Annotation like the @Repository Annotation. One most important thing about the @Service Annotation is it can be applied only to classes. It is used to mark the class as a service provider. So overall @Service annotation is used with classes that provide some business functionalities. Spring context will autodetect these classes when annotation-based configuration and classpath scanning is used.

Step By Step Implementation

Step 1: 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 one package and name the package as “service”. In the service, the package creates a class and name it as “MyServiceClass”

Java




// Java Program to Illustrate MyServiceClass
 
// Importing package module to code module
package com.example.demo.service;
// Importing required classes
import org.springframework.stereotype.Service;
 
// Annotation
@Service
 
// Class
public class MyServiceClass {
 
    // Method
    // To compute factorial
    public int factorial(int n)
    {
        // Base case
        if (n == 0)
            return 1;
 
        return n * factorial(n - 1);
    }
}


In this code notice that it’s a simple java class that provides functionalities to calculate the factorial of a number. So we can call it a service provider. We have annotated it with @Service annotation so that spring-context can autodetect it and we can get its instance from the context.

Step 4: 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




// Java Program to Illustrate DemoApplication
 
// Importing package module to code fragment
package com.example.demo;
// Importing required classes
import com.example.demo.service.MyServiceClass;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
// Annotation
@SpringBootApplication
 
// Main class
public class DemoApplication {
 
    // MAin driver method
    public static void main(String[] args)
    {
 
        AnnotationConfigApplicationContext context
            = new AnnotationConfigApplicationContext();
        context.scan("com.example.demo");
 
        context.refresh();
 
        MyServiceClass myServiceClass
            = context.getBean(MyServiceClass.class);
 
        // Testing the factorial method
        int factorialOf5 = myServiceClass.factorial(5);
        System.out.println("Factorial of 5 is: "
                           + factorialOf5);
 
        // Closing the spring context
        // using close() method
        context.close();
    }
}


Output: 

@Repository Annotation

@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 By Step Implementation

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. 

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.  

Java




// Java Program to Illustrate Simple POJO (Plain Old Java
// Object) Class
 
package com.example.demo.entity;
 
// Class
public class Student {
 
    // Attributes
    private Long id;
    private String name;
    private int age;
 
    // Generating the constructor
    public Student(Long id, String name, int age)
    {
        this.id = id;
        this.name = name;
        this.age = age;
    }
 
    // Getter-setters
    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; }
 
    // Overriding toString() method of String class
    @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. 

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;
 
@Repository
public 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




// Java Program to Illustrate Spring Repository Test
 
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;
 
// Class
@SpringBootApplication
public class DemoApplication {
 
    // Main driver method
    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);
 
        // Closing the spring context
        // using standard close() method
        context.close();
    }
}


Output: Lastly, run your application and you should get the following output as shown below as follows:

Difference Between @Service Annotation and @Repository Annotation

@Service Annotation

@Repository Annotation

@Service annotation is used with classes that provide some business functionalities. @Repository Annotation is used to indicate that the class provides the mechanism for storage, retrieval, update, delete and search operation on objects.
@Service Annotation is a specialization of @Component Annotation. @Repository Annotation is also a specialization of @Component Annotation.
It can be applied only to classes. It is used at the class level.
It is used to mark the class as a service provider. It is used to mark the interface as DAO (Data Access Object) provider.
It is a Stereotype Annotations. It is also a Stereotype Annotations.

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!