Spring Boot: diferencia entre la anotación @Service y la anotación @Repository

Las anotaciones de Spring son una forma de metadatos que proporcionan datos sobre un programa. Las anotaciones se utilizan para proporcionar información complementaria sobre un programa. No tiene un efecto directo sobre el funcionamiento del código que anotan. No cambia la acción del programa compilado. 

@Anotación de servicio

En una aplicación, la lógica empresarial reside dentro de la capa de servicio, por lo que usamos la anotación @Service para indicar que una clase pertenece a esa capa. También es una especialización de @Component Annotation como @Repository Annotation . Una de las cosas más importantes de la anotación @Service es que solo se puede aplicar a las clases. Se utiliza para marcar la clase como proveedor de servicios. Por lo tanto, la anotación general de @Service se usa con clases que brindan algunas funcionalidades comerciales. Spring context detectará automáticamente estas clases cuando se utilice la configuración basada en anotaciones y el escaneo de classpath.

Implementación paso a paso

Paso 1: Cree un proyecto Spring Boot simple

Paso 2: agregue la dependencia del contexto de resorte en su archivo pom.xml . Vaya al archivo pom.xml dentro de su proyecto y agregue la siguiente dependencia de contexto primaveral.

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.13</version>
</dependency>

Paso 3: en su proyecto, cree un paquete y nombre el paquete como «servicio». En el servicio, el paquete crea una clase y la nombra como » MyServiceClass» . 

// 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);
    }
}

En este código, observe que es una clase Java simple que brinda funcionalidades para calcular el factorial de un número. Así que podemos llamarlo un proveedor de servicios. Lo hemos anotado con la anotación @Service para que Spring-context pueda detectarlo automáticamente y podamos obtener su instancia del contexto.

Paso 4: prueba de repositorio de Spring

Ahora que nuestro Repositorio Spring está listo, vamos a probarlo. Vaya al archivo DemoApplication.java y consulte el siguiente código.

// 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();
    }
}

Producción: 

@Anotación del repositorio

La anotación @Repository es una especialización de la anotación @Component que se utiliza para indicar que la clase proporciona el mecanismo para la operación de almacenamiento, recuperación, actualización, eliminación y búsqueda en objetos. Aunque es una especialización de la anotación @Component, Spring Framework detecta automáticamente las clases de Spring Repository a través del escaneo de classpath. Esta anotación es una anotación de estereotipo de propósito general que se parece mucho al patrón DAO donde las clases DAO son responsables de proporcionar operaciones CRUD en las tablas de la base de datos. 

Implementación paso a paso

Paso 1: Cree un proyecto Spring Boot simple

Consulte este artículo Crear y configurar Spring Boot Project en Eclipse IDE y cree un proyecto Spring Boot simple. 

Paso 2: agregue la dependencia del contexto de resorte en su archivo pom.xml . Vaya al archivo pom.xml dentro de su proyecto y agregue la siguiente dependencia de contexto primaveral.

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.13</version>
</dependency>

 
Paso 3: en su proyecto, cree dos paquetes y nombre el paquete como «entidad» y «repositorio». En la entidad, el paquete crea un nombre de clase como Estudiante. En el repositorio, el paquete crea una interfaz genérica llamada DemoRepository y una clase con el nombre StudentRepository. 

Paso 4: Cree una clase de entidad para la cual implementaremos un repositorio de primavera. Aquí nuestra clase de entidad es Student. A continuación se muestra el código para el archivo Student.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 + '}';
    }
}

Paso 5: antes de implementar la clase de repositorio, hemos creado una interfaz genérica de DemoRepository para proporcionar el contrato para que nuestra clase de repositorio la implemente. 

// 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);
 
}

Paso 6: Ahora veamos la implementación de nuestra clase StudentRepository. 

// 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);
    }
}

En este archivo StudentRepository.java , puede notar que hemos agregado la anotación @Repository para indicar que la clase proporciona el mecanismo para la operación de almacenamiento, recuperación, actualización, eliminación y búsqueda en objetos.

Nota : aquí hemos utilizado un mapa en memoria para almacenar los datos del objeto, también puede utilizar cualquier otro mecanismo. En el mundo real, usamos bases de datos para almacenar datos de objetos. 

Paso 7: prueba de repositorio de Spring

Ahora que nuestro Repositorio Spring está listo, vamos a probarlo. Vaya al archivo DemoApplication.java y consulte el siguiente código. 

// 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();
    }
}

Salida: por último, ejecute su aplicación y debería obtener la siguiente salida como se muestra a continuación:

Diferencia entre la anotación @Service y la anotación @Repository