@Repository: le indicamos a la clase que es la encarga de interactuar con la base de datos.
@Component: le indicamos que es un componente de spring.
El primero es mejor porque indicamos el tipo de componente que es.
Antes de empezar
¿Qué es y qué usaremos de Spring?
¿Java sigue siendo gratuito?
Instalación de ambiente de desarrollo: Windows
Instalación de ambiente de desarrollo: Linux Ubuntu
Instalación de ambiente de desarrollo: macOS
Introducción a Spring boot
Creando aplicaciones autocontenidas con Spring Initializr
Hola mundo con Spring Boot
Configurar Spring Boot
Crear la estructura del proyecto
Spring Data
¿Qué es JPA?
Conocer qué es Spring Data
Conectar la base de datos a nuestra aplicación
Mapear las tablas como clases
Crear Entity cuando su clave primaria es compuesta
Mapear relaciones entre clases
Usar la interface CrudRepository
Query Methods
Construyendo nuestra API
Implementar la anotación @Repository
¿Qué es el patrón Data Mapper y qué resuelve?
Orientar nuestra API al dominio con MapStruct
Orientar nuestro repositorio a términos del dominio
Inyección de dependencias
Implementar la anotación @Service
Implementar la anotación @RestController
Exponer nuestra API
Mejorando nuestra API
Controlar las respuestas HTTP
Crear el dominio de compras
Mapear el dominio de compras
Crear el repositorio de compras
Probando nuestros servicios de compras
Documentar nuestra API con Swagger
Despliegue de nuestra aplicación
Desplegar nuestra API desde la ventana de comandos
Desplegar nuestra base de datos con Heroku
Desplegar nuestra API con Heroku
Conclusiones y despedida del curso
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Convierte tus certificados en títulos universitarios en USA
Antes: $249
$209
Paga en 4 cuotas sin intereses
Termina en:
19 Días
12 Hrs
25 Min
48 Seg
Implementar la anotación @Repository
18/35Recursos
Aportes 16
Preguntas 11
Ordenar por:
Quede con una duda, si ProdcutCrudRepository se creo como una interfaz ¿Por que nunca se llego a implementar, sino que se trato como una clase?
Es posible dejar @Repository en la interfaz?
tengo una duda, por que no @Repository iría en ProductoCrudRepository, y esta clase que es ProductoRepository en seria un @Service si tiene prácticamente todo los parámetros que se están colocando en esta clase, sentía que estamos duplicando código
con la anotacion @Repository indicamos que la clase interactua con la base de datos
Me ha parecido genial el curso! tengo una duda
¿Me podrían ayudar a entender la diferencia entre Optional<Producto> y Producto? min 2:41
Una pregunta:
¿Es correcto poner la anotación @Autowired en:
private ProductoCrudRepository productoCrudRepository;?
Utilizando chatGPT consultando como aplicamos el patrón CQRS nos da la guía siguiente:
Aplicar el patrón CQRS (Command Query Responsibility Segregation) en Spring Boot, puedes seguir los siguientes pasos:
Crea dos interfaces para tu repositorio, una para las operaciones de lectura (query) y otra para las operaciones de escritura (command). Por ejemplo, puedes llamarlas ReadRepository y WriteRepository, respectivamente.
En la interfaz ReadRepository, extiendes de CrudRepository o cualquier otra interfaz de lectura que desees utilizar. En ella, colocas solo los métodos de lectura necesarios para tu aplicación, como findAll(), findById(), etc.
En la interfaz WriteRepository, extiendes de JpaRepository o cualquier otra interfaz de escritura que desees utilizar. En ella, colocas solo los métodos de escritura necesarios para tu aplicación, como save(), delete(), etc.
Crea una clase de implementación para cada interfaz, por ejemplo, ReadRepositoryImpl y WriteRepositoryImpl. Estas clases deben implementar los métodos correspondientes de cada interfaz.
Utiliza estas interfaces y clases en tus servicios para dividir las responsabilidades de lectura y escritura en diferentes capas de tu aplicación.
Con estos pasos estaras implementando el patrón CQRS en tu aplicación con Spring Boot. Sin embargo, es importante mencionar que CQRS no solo se trata de separar las operaciones de lectura y escritura en diferentes capas, sino que también implica una separación lógica en la estructura de la base de datos y en el diseño de las consultas.
Continuemos, todo va bien al parecer hasta este momento, excelente explicación del profesor.
@Repository es la clase que se encarga de interactuar con nuestra base de datos.
desde ProductoRepository hacemos las interacciones con la base de datos.
@Component es una anotacion que generalizacion de anotaciones.
* **@Repository**
Es un estereotipo de spring framework, con esta clase le indicamos a spring que la clase de la anotacion esta interactuando con la base de datos pporque es en NombreRepository (no NombreCrudRepository, esa es la interfaz) donde estamos haciendo las operaciones que queremos aplicar en las tablas
* **@Component**
también se puede utilizar, es una generalizacion de este tipo de anotaciones.
con @Repository indicamos que tipo de componente es.
La diferencia entre `@Repository` y `@Component` está relacionada con su **semántica** y **uso específico** en el contexto de Spring Framework. Aquí tienes una explicación detallada:
1. `@Component`:
* `@Component` es una anotación genérica que se utiliza para marcar una clase como un **componente administrado por Spring**.
* Puede aplicarse a cualquier clase y se utiliza para **descubrir y registrar automáticamente** los componentes en el contexto de la aplicación.
* No proporciona ninguna funcionalidad específica más allá de indicar que la clase es un componente de Spring.
2. `@Repository`:
* `@Repository` es una especialización de `@Component`.
* Se utiliza específicamente para **marcar las clases que acceden a la capa de persistencia de datos**, como las clases DAO (Data Access Object).
* Proporciona algunas características adicionales, como la **traducción automática de excepciones de base de datos** a excepciones de Spring (por ejemplo, `DataAccessException`).
Excelente el profesor. Me quedan muy claros los conceptos.
y cual es la diferencia entre @Repository y @Service, he visto que la interface CrudRepository la usan en un package DAO, y en un package service, usan una interface para hacer el contrato de los métodos a usar y crean una clase de implementación donde usan esta interface y la capa DAO del CrudRepository y en esta implementación usan @Service y @Autowired para indicar que se va a usar una interface de CrudRepository
Muy bien explicado.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?