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 modulepackagecom.example.demo.service;// Importing required classesimportorg.springframework.stereotype.Service;// Annotation@Service// ClasspublicclassMyServiceClass {    // Method    // To compute factorial    publicintfactorial(intn)    {        // Base case        if(n == 0)            return1;        returnn * 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 fragmentpackagecom.example.demo;// Importing required classesimportcom.example.demo.service.MyServiceClass;importorg.springframework.boot.autoconfigure.SpringBootApplication;importorg.springframework.context.annotation.AnnotationConfigApplicationContext;// Annotation@SpringBootApplication// Main classpublicclassDemoApplication {    // MAin driver method    publicstaticvoidmain(String[] args)    {        AnnotationConfigApplicationContext context            = newAnnotationConfigApplicationContext();        context.scan("com.example.demo");        context.refresh();        MyServiceClass myServiceClass            = context.getBean(MyServiceClass.class);        // Testing the factorial method        intfactorialOf5 = 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) Classpackagecom.example.demo.entity;// ClasspublicclassStudent {    // Attributes    privateLong id;    privateString name;    privateintage;    // Generating the constructor    publicStudent(Long id, String name, intage)    {        this.id = id;        this.name = name;        this.age = age;    }    // Getter-setters    publicLong getId() { returnid; }    publicvoidsetId(Long id) { this.id = id; }    publicString getName() { returnname; }    publicvoidsetName(String name) { this.name = name; }    publicintgetAge() { returnage; }    publicvoidsetAge(intage) { this.age = age; }    // Overriding toString() method of String class    @OverridepublicString 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 Filepackagecom.example.demo.repository;publicinterfaceDemoRepository<T> {    // Save method    publicvoidsave(T t);    // Find a student by its id    publicT findStudentById(Long id);} | 
Step 6: Now let’s look at our StudentRepository class implementation.
Java
| // Java Program to Illustrate StudentRepository Filepackagecom.example.demo.repository;importcom.example.demo.entity.Student;importorg.springframework.stereotype.Repository;importjava.util.HashMap;importjava.util.Map;@RepositorypublicclassStudentRepository implementsDemoRepository<Student> {    // Using an in-memory Map    // to store the object data    privateMap<Long, Student> repository;    publicStudentRepository() {        this.repository = newHashMap<>();    }    // Implementation for save method    @Override    publicvoidsave(Student student) {        repository.put(student.getId(), student);    }    // Implementation for findStudentById method    @Override    publicStudent findStudentById(Long id) {        returnrepository.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 Testpackagecom.example.demo;importcom.example.demo.entity.Student;importcom.example.demo.repository.StudentRepository;importorg.springframework.boot.autoconfigure.SpringBootApplication;importorg.springframework.context.annotation.AnnotationConfigApplicationContext;// Class@SpringBootApplicationpublicclassDemoApplication {    // Main driver method    publicstaticvoidmain(String[] args)    {        AnnotationConfigApplicationContext context            = newAnnotationConfigApplicationContext();        context.scan("com.example.demo");        context.refresh();        StudentRepository repository            = context.getBean(StudentRepository.class);        // Testing the store method        repository.save(newStudent(1L, "Anshul", 25));        repository.save(newStudent(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. | 

 
                                    








