Spring Boot – Difference Between @Service Annotation and @Repository Annotation
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
package com.example.demo.service;
import org.springframework.stereotype.Service;
@Service
public class MyServiceClass {
public int factorial( int n)
{
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
package com.example.demo;
import com.example.demo.service.MyServiceClass;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args)
{
AnnotationConfigApplicationContext context
= new AnnotationConfigApplicationContext();
context.scan( "com.example.demo" );
context.refresh();
MyServiceClass myServiceClass
= context.getBean(MyServiceClass. class );
int factorialOf5 = myServiceClass.factorial( 5 );
System.out.println( "Factorial of 5 is: "
+ factorialOf5);
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
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.
Java
package com.example.demo.repository;
public interface DemoRepository<T> {
public void save(T t);
public T findStudentById(Long id);
}
|
Step 6: Now let’s look at our StudentRepository class implementation.
Java
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> {
private Map<Long, Student> repository;
public StudentRepository() {
this .repository = new HashMap<>();
}
@Override
public void save(Student student) {
repository.put(student.getId(), student);
}
@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;
@SpringBootApplication
public 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 );
repository.save( new Student(1L, "Anshul" , 25 ));
repository.save( new Student(2L, "Mayank" , 23 ));
Student student = repository.findStudentById(1L);
System.out.println(student);
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. |
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...