Diferencia entre @Controller y @Service Anotation en Spring

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 Spring @Controller

La anotación Spring @Controller es una especialización de la anotación @Component . La anotación @Controller indica que una clase en particular cumple la función de un controlador . La anotación Spring Controller generalmente se usa en combinación con métodos de controlador anotados basados ​​en la anotación @RequestMapping . Solo se puede aplicar a las clases. Se utiliza para marcar una clase como controlador de requests web. Se usa principalmente con aplicaciones Spring MVC . Esta anotación actúa como un estereotipo de la clase anotada, indicando su rol. El despachador escanea dichas clases anotadas en busca de métodos asignados y detecta anotaciones @RequestMapping .

Implementación: Proyecto 

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 web de primavera en su archivo pom.xml . Vaya al archivo pom.xml dentro de su proyecto y agregue la siguiente dependencia de spring-web.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Paso 3: en su proyecto, cree un paquete y asígnele el nombre de «controlador». En el controlador, el paquete crea una clase y la nombra como DemoController . Esta será la estructura final de nuestro proyecto.

// Java Program to Illustrate DemoController File
 
// Importing package in this code module
package com.example.demo.controller;
// Importing required classes
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
// Annotation
@Controller
// Main class
public class DemoController {
 
    @RequestMapping("/hello")
    @ResponseBody
 
    // Method
    public String helloGFG()
    {
        return "Hello GeeksForGeeks";
    }
}

Hemos utilizado las siguientes anotaciones en nuestra capa de controlador. Aquí, en este ejemplo, la ruta URI es  /hello .

• @Controller : Esto se usa para especificar el controlador.
• @RequestMapping : Esto se usa para mapear al método del controlador Spring MVC.
• @ResponseBody : se usa para vincular el cuerpo de la respuesta HTTP con un objeto de dominio en el tipo de devolución.

Paso 4: Ahora, nuestro controlador está listo. Ejecutemos nuestra aplicación dentro del archivo DemoApplication.java . No es necesario cambiar nada dentro del archivo DemoApplication.java .

Ejemplo 

// Java Program to Illustrate DemoApplication File
 
// Importing package in this code module
package com.example.demo;
// Importing required classes
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
// Annotation
@SpringBootApplication
 
// Main class
public class DemoApplication {
 
    // Main driver method
    public static void main(String[] args)
    {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Producción:

Sugerencia: pruebe la URL de Tomcat que se muestra en los medios a continuación, que se ejecuta en http://localhost:8989/hello

Primavera @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.

Ejemplo: Proyecto

Paso 1: Cree un proyecto Spring Boot simple.

Consejo: Consulte este artículo antes de seguir adelante sobre cómo crear y configurar Spring Boot Project en Eclipse IDE y crear 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.

Archivo: pom.xml

<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 » MyServiceClass» . 

Archivo: MiClaseDeServicio

// 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;
 
        // Returning factorial of input number
        return n * factorial(n - 1);
    }
}

Explicación del código: 

Del código anterior, podemos percibir fácilmente que es una clase Java simple que proporciona 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 de Spring está listo, vamos a probarlo. Vaya al archivo DemoApplication.java y consulte el siguiente código.

Archivo:DemoApplication.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)
    {
        // Creating context of
        // AnnotationConfigApplicationContext class
        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:

Por último, analicemos las diferencias entre la anotación @Controller y la anotación @Service.