Spring es uno de los marcos Java EE más populares. Es un marco ligero de código abierto que permite a los desarrolladores de Java EE 7 crear aplicaciones empresariales sencillas, fiables y escalables. Este marco se centra principalmente en proporcionar varias formas de ayudarlo a administrar sus objetos comerciales. Ahora hablando de Spring Annotation, Spring Annotations es una forma de metadatos que proporciona 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.
Anotaciones de estereotipos
Spring Framework nos proporciona algunas anotaciones especiales. Estas anotaciones se utilizan para crear Spring beans automáticamente en el contexto de la aplicación. La anotación @Component es la principal anotación de estereotipo. Hay algunas meta-anotaciones de estereotipos que se derivan de @Component , esas son
- @Servicio
- @Repositorio
- @Controlador
1: @Service: especificamos una clase con @Service para indicar que mantienen la lógica empresarial. Además de usarse en la capa de servicio, no hay ningún otro uso especial para esta anotación. Las clases de utilidad se pueden marcar como clases de servicio.
2: @Repository: especificamos una clase con @Repository para indicar que se trata de operaciones CRUD , por lo general, se usa con DAO (objeto de acceso a datos) o implementaciones de repositorio que se ocupan de las tablas de la base de datos.
3: @Controller: especificamos una clase con @Controller para indicar que son controladores frontales y responsables de manejar las requests de los usuarios y devolver la respuesta adecuada. Se utiliza principalmente con servicios web REST.
Entonces, las anotaciones de estereotipos en Spring son @Component, @Service, @Repository y @Controller .
Anotación @Component
@Component es una anotación de nivel de clase. Se utiliza para denotar una clase como un Componente. Podemos usar @Component en toda la aplicación para marcar los beans como componentes administrados de Spring. Un componente es responsable de algunas operaciones.
Ilustración: Vamos a crear una aplicación Spring Boot muy simple para mostrar el uso de la anotación Spring Component y cómo Spring lo detecta automáticamente con la configuración basada en anotaciones y el escaneo de classpath.
Paso 1: Cree un proyecto Spring Boot simple. Geek, necesitas un requisito previo para crear y configurar Spring Boot Project
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.
XML
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.13</version> </dependency>
Paso 3: crea una clase de componente simple
Vaya a src > main > java > el nombre de su paquete > haga clic con el botón derecho en > New > Java Class y cree su clase de componente y márquela con la anotación @Component .
Java
// Java Program to Illustrate Component class
package com.example.demo;
import org.springframework.stereotype.Component;
// Annotation
@Component
// Class
public class ComponentDemo {
// Method
public void demoFunction()
{
// Print statement when method is called
System.out.println("Hello GeeksForGeeks");
}
}
Paso 4: Cree un contexto de primavera basado en anotaciones
Ahora vaya a su archivo de aplicación (@SpringBootApplication) y aquí en este archivo cree un contexto de primavera basado en anotaciones y obtenga el bean ComponentDemo de él.
Java
// Java Program to Illustrate Application class
// Importing package here
package com.example.demo;
// Importing required classes
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
// Annotation
@SpringBootApplication
// Class
public class DemoApplication {
// Main driver method
public static void main(String[] args)
{
// Annotation based spring context
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.scan("com.example.demo");
context.refresh();
// Getting the Bean from the component class
ComponentDemo componentDemo = context.getBean(ComponentDemo.class);
componentDemo.demoFunction();
// Closing the context
// using close() method
context.close();
}
}
Producción:
Para que pueda ver el poder de la anotación @Component, no tuvimos que hacer nada para inyectar nuestro componente en el contexto de 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
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.
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 paquete de servicios, cree una clase y asígnele el nombre MyServiceClass . Esta será la estructura final de nuestro proyecto.
A continuación se muestra el código para el archivo MyServiceClass.java .
Java
package com.example.demo.service;
import org.springframework.stereotype.Service;
@Service
public class MyServiceClass {
// Simple program for
// factorial of a number
public int factorial(int n)
{
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 de Spring está listo, vamos a probarlo. Vaya al archivo DemoApplication.java y consulte el siguiente código.
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);
// Testing the factorial method
int factorialOf5 = myServiceClass.factorial(5);
System.out.println("Factorial of 5 is: " + factorialOf5);
// close the spring context
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.
Ejemplo
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.
XML
<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 el paquete de entidades, cree un nombre de clase como Estudiante. En el repositorio, el paquete crea una interfaz genérica , asígnele el nombre DemoRepository y una clase, asígnele el nombre StudentRepository. Esta será la estructura final de nuestro proyecto.
Paso 4: Cree una clase de entidad para la cual implementaremos un repositorio de primavera. Aquí nuestra clase de entidad es Estudiante. A continuación se muestra el código para el archivo Student.java . Esta es una clase POJO (Plain Old Java Object) simple en java.
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 +
'}';
}
}
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. A continuación se muestra el código para el archivo DemoRepository.java .
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);
}
Paso 6: Ahora veamos la implementación de nuestra clase StudentRepository.
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);
}
}
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 de Spring está listo, vamos a probarlo. Vaya al archivo DemoApplication.java y consulte el siguiente código.
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);
// 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);
// close the spring context
context.close();
}
}
Salida: por último, ejecute su aplicación y debería obtener la siguiente salida como se muestra a continuación:
@ Anotación del controlador
La anotación Spring @Controller también 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 . Entendamos todo esto con un ejemplo.
Ejemplo
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.
XML
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
Paso 3: en su proyecto, cree un paquete y nombre el paquete como «controlador». En el paquete del controlador, cree una clase y asígnele el nombre DemoController . Esta será la estructura final de nuestro proyecto.
A continuación se muestra el código para el archivo DemoController.java .
Java
package com.example.demo.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class DemoController {
@RequestMapping("/hello")
@ResponseBody
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 utiliza para vincular el cuerpo de la respuesta HTTP con un objeto de dominio en el tipo de retorno.
Ahora, nuestro controlador está listo. Ejecutemos nuestra aplicación dentro del archivo DemoApplication.java . No es necesario cambiar nada dentro del archivo DemoApplication.java .
Java
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
Producción:
Pruebe esta URL de Tomcat, que se ejecuta en http://localhost:8989/hello
Publicación traducida automáticamente
Artículo escrito por AmiyaRanjanRout y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA