No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Java Spring

Curso de Java Spring

Alejandro Ramírez

Alejandro Ramírez

Documentar nuestra API con Swagger

31/35
Recursos

Aportes 78

Preguntas 11

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Si están utilizando la versión 3.0.0 de swagger, se debe tener en cuenta lo siguiente:

  • En el archivo bundle.gradle se debe añadir las siguientes líneas
    implementation "io.springfox:springfox-boot-starter:3.0.0"
    compile “io.springfox:springfox-swagger-ui:3.0.0”

  • En la clase SwaggerConfig ya no hace falta añadir la anotación @EnableSwagger2

  • La url de acceso a la documentación es: {host}:{puerto} / {contexto} /swagger-ui/index.html

para los que les sale el error de NullPointerException lo unico que deben hacer es ir al application.properties y agregar esta linea spring.mvc.pathmatch.matching-strategy = ANT_PATH_MATCHER

Para el 2023 ya existe una dependencia llamada Spring doc OpenApi, que te permite implementar Swagger sin la necesidad de crear beans.

implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.1.0'

Y en tu application.properties colocar la url de swagger

springdoc.swagger-ui.path=/swagger-ui.html

Y listo, ya tienen el swagger funcionando con pocos pasos

Hola, si llegan a tener un error de NullPointerException sin razón alguna, sólo deben bajar la version de SpringBoot de 2.6.1 a 2.5.5 (estuve rato lidiando con ese error)

Me hubiera gustado que se toque un tema importante en la capa de servicios como lo son las transacciones. Espero que salga el curso avanzado de spring.

Una forma para ponerle un poco mas de detalle a nuestras APIS.


Si usan la versión 3.0.0 de swagger y les aparece un null o
este error :
->Failed to start bean ‘documentationPluginsBootstrapper’; nested exception is java.lang.NullPointerException

pueden solucionarlo agregando:
-> spring.mvc.pathmatch.matching-strategy = ANT_PATH_MATCHER en el application.properties

en el build.gradle:
-> implementation “io.springfox:springfox-boot-starter:3.0.0”

Nota: En mi caso elimine del archivo SwaggerConfig la anotación @EnableSwagger2 .
-> estoy usando la versión 2.6.4 de Spring.

Para los que están usando Spring Boot v3, no tienen que usar las librerías mencionadas en el video, solo tienen que usar Spring doc, para eso agreguen en el build.grade la siguiente linea:

implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2' 

Solo con eso ya van a poder acceder a Swagger a través de la siguiente URL:

http://localhost:8080/platzi-market/api/swagger-ui/index.html

Y para finalizar les dejo la equivalencia de los annotations de Swagger UI en Spring doc que deben usar en el ProductController:

Si quieren más información la pueden encontrar en esta página:

https://springdoc.org/v2/index.html#migrating-from-springfox 

Para el año en que escribo este comentario ya se encuentra la versión 3 de Spring boot, pero la última versión de Swagger, no es compatible con esta, por lo que incorpora Jakarta en vez de Javax, por tal motivo es necesario bajar la versión de Spring boot, ademas hay configuraciones que el maestro hace las cuales ya no son necesarias:

  • En caso que tengas una version 3, te recomiendo bajarla a la 2.7.6.
  • Cambia todas las importaciones que tengas en Jakarta a Javax
  • No es necesario hacer las dos importaciones de swagger y swagger ui, mas ni te funcionará
    unicamente debes agregar esta importación
implementation "io.springfox:springfox-boot-starter:3.0.0"

Esta unica importación ya engloba las dos anterios por que lo necesitas volver a agregarlas

Nota: Recuerda que el puerto debes agregar el que estés usando

Desde la versión 3 de spring la librería de swagger fue modificada, y ahora usada springdoc.
Instalación:
En el build.gredel

implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.1.0'

en el application.properties hacemos la siguiente modificacion:

springdoc.swagger-ui.path=/swagger-ui.html

No es necesario crear el archivo Swagger.config
Con esto ya tendremos la aplicacion deaplegada con la siguiemte url : localhost:{puerto}/{context-path}/swagger-ui/index.html

La forma en la que el profesor implementa Swagger ya no funciona hoy en día, le dejo el link de maven repository para que solo copien y agreguen el archivo build.gradle

// https://mvnrepository.com/artifact/org.springdoc/springdoc-openapi-ui
implementation group: 'org.springdoc', name: 'springdoc-openapi-ui', version: '1.5.12'

lo pueden ver en la documentación: https://mvnrepository.com/artifact/org.springdoc/springdoc-openapi-ui/1.5.12

Recuerden ya no va ser necesario crear en archivo SwaggerConfig que crea el profesor.

para acceder a la documentacion:

http://localhost:8090/api/swagger-ui.html

Espero les sirva !!

Genial, esto era lo que le faltaba que alguien enseñara
Este curso mil veces mejor de lo que esperaba

Este vídeo se me hace que quedó corto. Me parece genial el vídeo pero quizá un par de vídeos extras agregando el uso de examples y tags en los endpoints, así como su uso en conjunto con bean validation hubiese sido de mayor provecho.

Quiero compartir con ustedes el proyecto que he estado usando con el fin de aprender Spring boot y que pueden encontrar en GitLab acá.

Puntos a tener en cuenta:

  1. Estoy usando Maven en lugar de Gradle
  2. Hasta este momento, no pienso usar Spring security
  3. Elegí una jerarquía de paquetes mucho más plana que el usado en este curso
  4. Todo el desarrollo está en inglés
  5. Uso una nomenclatura ligeramente distinta (DAO en lugar de Repository, por ejemplo)
  6. Considero que empleo mejores prácticas que las mostradas en este curso en ciertas partes del proyecto
  7. Si bien tengo años en la industria, particularmente con Java, soy automatizador de pruebas y Spring no ha sido una herramienta con la que tenga experiencia. Por lo tanto, aún me queda mucho por aprender y mejorar.

Excelente swagger2 y muy practico, seria bueno un curso para ver mas detalles

Como más abajo mencionaron, actualmente la clase SwaggerConfig no hay que crearla, tengan en cuenta que usé el spring boot 3.3.0, y usé java 17 (Amazon Coretto). Así fue como me pudo correr la aplicacion:
build.gradle

aplication-dev.properties

ProductoCotroller

Resultado:

Para poder utilizar Swagger 3.0.0 con la versión de Spring 2.7.7 es necesario agregar en el build.gradle:

implementation 'io.springfox:springfox-swagger2:3.0.0'
implementation "io.springfox:springfox-boot-starter:3.0.0"
implementation 'io.springfox:springfox-swagger-ui:3.0.0'
compileOnly "io.springfox:springfox-swagger-ui:3.0.0"

Y en el file de config:

@Configuration
@EnableWebMvc
Siendo el 18/01/2024 a las 11h30, confirmo que esta clase solo es informativa a dia de hoy, ya que si buscan en maven repository, la implementacion springfox-swagger2 en su version 2.9.2 ya no se puede usar debido a que sus recursos generan vulnerabilidades (el website informa de esto en la info sobre esta version) y si la usas e intentas cargar tu server, simplemente arroja error de version deprecada y se detiene. Usen los ejemplos de juan Camilo Sandoval hernandez, Alexandra Jimenez o Victor Hugo Vazquez Gomez, los recomiendo si usan gradle a partir de 2024. Busquen los comentarios mas recientes por favor.

Saludos es genial esta clase y poder Documentar nuestra API con Swagger aunque personalmente he tenido problemas con las versiones que se proponen en esta clase. Tal como se plantea a mi me aparecía el siguiente error justo después de levantar el servicio:

java.lang.NullPointerException: null.

y despueé me lo paraba.

Entonces googleando y después de varios días y de ayuda de los comentarios que Swagger está incluida en springdoc-openapi-ui y que no es necesario configurarlo con la clase Swagger config, basta con añadir la de pendencia en gradle:

implementation 'org.springdoc:springdoc-openapi-ui:1.6.6'

borrar las otras i listo,documentación en el context path.

Referencias.
https://springdoc.org/#migrating-from-springfox
https://www.baeldung.com/spring-rest-openapi-documentation

Me pasé medio hora solucionando un error en el que swagger no indicaba la documentación con el mensaje “No operations defined in spec!”.

Resulta que había puesto la dirección del paquete con ; jajaj excelente curso, espero con ansias el curso avanzado de spring !

Solución que funciono para mi 26-11-2023 ![](https://static.platzi.com/media/user_upload/image-b19a7a84-1a44-4473-9e84-dacaa985f3e6.jpg)
*Para mi proyecto FUNCIONA así,:* En el archivo build.gradle.kts *implementation*("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.3.0") luego en application-dev.properties springdoc.api-docs.enabled=true springdoc.swagger-ui.enabled=true springdoc.swagger-ui.path=/doc/swagger-ui.html sin agregar config

Usando swagger 3.0.0 con spring boot 3.0.6

Retirar annotation de la clase SwaggerConfig

@EnableSwagger

Agregar dependencias

implementation 'io.springfox:springfox-swagger2:3.0.0'
implementation 'io.springfox:springfox-swagger-ui:3.0.0'
implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.4'

Las importaciones en el controller se hacen desde

io.swagger.v3.oas.annotations

Para cambiar la descripción que en clase se hace con (@ApiOperation)

@Operation(summary = "Get all supermarket products")  // Otra propiedad además de summary puede ser description 

La estructura para @ApiResponse

@ApiResponse(responseCode = "200", description = "Ok")

La estructura para @Parameter en lugar de @ApiParam para el id

@Parameter(description = "The id of the product",  required = true, schema = @Schema(implementation = Integer.class)) // Se cambia la implementación según el parámetro

Ojalá pueda ser de utilidad. ¡Saludos!

Wilmar De MelquisedecLisbet

Para los que recien estan viendo el curso, recomiendo otra forma de documentar que es agregando esta dependencia en build.gradle

implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.1.0'

luego agregamos esta linea en application-dev.properties

springdoc.swagger-ui.enabled=true

tambien se puede customizar algunas propiedades, para eso les dejo la documentacion de donde saque la informacion
https://springdoc.org/#getting-started
con esos simples pasos ya no necesitarias crear una configuracion, solo agregando la dependencia y habilitando la propiedad se puede acceder a la documentacion de la api a traves del link por defecto: https://server:port/context-path/swagger-ui.html

Documentar nuestra API con Swagger

¿Por qué documentar nuestra API?

  • Le agregamos una capa de entendimiento
  • Es más fácil de usar
  • Es más profesional
  • Quien consuma tendrá información oficial y de primera mano

Usos

  • Incluir las dependencias en el archivo build.gradle

    • Buscar en MvnRepository Springfox Swagger y Springfox Swagger UI (este último es para el cliente web para visualizar la documentación generada)

      implementation "io.springfox:springfox-boot-starter:3.0.0"
      compile “io.springfox:springfox-swagger-ui:3.0.0
  • Crear dentro del paquete web, uno que se llame config

    • Crear una clase llamada SwaggerConfig
  • Anotar la clase con @Configuration y EnableSwagger2(para esta última, en Swagger 3 no es necesario incluirla)

  • Escribir el siguiente método:

    • Esto es lo mínimo para crear la documentación

      @Bean
      public Docket api() {
      	return new Docket(DocumentationType.SWAGGER_2)
      		.select()
      		.apis(RequestHandlerSelectors.basePackage(
      						"com.platzi.market.web.controller")) // Paquete de las clases que queremos exponer
      		.build(); // Construir la respuesta
      
      			// a partir y después del select -> lo que queremos que exponga en la documentación
      }
      
  • La url de acceso a la documentación en Swagger 3 es: {host}:{puerto} / {contexto} /swagger-ui/index.html

    • En Swagger 2 es {host}:{puerto} / {contexto} /swagger-ui.html
  • Podemos modificar cómo se ve desde Swagger cada controlador

    • En la clase del controlador, en uno de los métodos, se añade @ApiOperation("Descripción") para describir un método HTTP

    • @ApiResponse(code = 200, message = "OK") para especificar el código HTTP que devuelve ese método

      • Especificar diferentes respuestas de códigos HTTP

        @ApiResponses({
        	@ApiResponse(code = 200, message = "OK"),
        	@ApiResponse(code = 404, message = "Product not found")
        })
        
    • Describir un parámetro de un método

      public ResponseEntity<Product> getProduct(@ApiParam(value = "The id of the product", required = true, example = "7")
                                                        @PathVariable("id") int productId) {
      //
      } 
      

Para instalarlo no me funciono nada del video ni de los comentarios mas votados ni nada. Lo que si me funciono fue:

build.gradle:

implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.3'

Eliminamos el archivo de configuracion que se creo en el video.

Vamos a localhost:8080/api/swagger-ui/index.html para ver el Swagger-UI.

Si queremos añadir una configuracion nos creamos ahora si el archivo que vemos en el video, pero de esta manera. Lo de las url de dev y prod las estableci en application.properties.

package dev.victorvazquez.market.web.config;

import java.util.List;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Contact;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import io.swagger.v3.oas.models.servers.Server;

@Configuration
public class OpenAPIConfig {
  @Value("${dev.victorvazquez.openapi.dev-url}")
  private String devUrl;

  @Value("${dev.victorvazquez.openapi.prod-url}")
  private String prodUrl;

  @Bean
  public OpenAPI myOpenAPI() {
    Server devServer = new Server();
    devServer.setUrl(devUrl);
    devServer.setDescription("Server URL in Development environment");

    Server prodServer = new Server();
    prodServer.setUrl(prodUrl);
    prodServer.setDescription("Server URL in Production environment");

    Contact contact = new Contact();
    contact.setEmail("[email protected]");
    contact.setName("Victor Vazquez");
    contact.setUrl("https://victorvazquez.dev");

    License mitLicense = new License().name("MIT License").url("https://choosealicense.com/licenses/mit/");

    Info info = new Info()
      .title("Market API")
      .version("1.0")
      .contact(contact)
      .description("This API is based on a Platzi Course.").termsOfService("https://victorvazquez.dev/terms")
      .license(mitLicense);

    return new OpenAPI().info(info).servers(List.of(devServer, prodServer));
  }
}

Posteriormente a mi comentario anterior sobre sustituir las dos dependencias que mencionó el Profesor por solo una, las anotaciones (como @ApiOperation o @ApiParam) en la clase SwaggerConfig también cambiarán, por lo que los métodos getAll y getProduct fueron modificados de esta manera:

@GetMapping("/all")
    @Operation(summary = "Get all supermarket products")
    @ApiResponse(responseCode = "200", description = "OK")
    public ResponseEntity<List<Product>> getAll() {
        return new ResponseEntity<>(productService.getAll(), HttpStatus.OK);
    }
@GetMapping("/{id}")
    @Operation(summary = "Search a product with an ID")
    @ApiResponses({
            @ApiResponse(responseCode = "200", description = "OK"),
            @ApiResponse(responseCode = "404", description = "Product not found")
    })
    public ResponseEntity<Product> getProduct(@Parameter(description = "The ID of the product", required = true, example = "7")
                                                  @PathVariable("id") int productId) {
        return productService.getProduct(productId)
                .map(product -> new ResponseEntity<>(product, HttpStatus.OK))
                .orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));
    }

Espero les sirva.
Saludos !!

Si llegan a tener problemas de nullPointerException pueden agregar los sigte a application.properties:

spring.mvc.pathmatch.matching-strategy = ANT_PATH_MATCHER

Hola compañeros. Me parece excelente esta clase y que se añada Swagger para documentar nuestra API, creo que es muy importante hacer esto y sobretodo cuando queremos mostrarla a otros developers que no han estado durante la etapa de diseño.

Además les quiero compartir que Swagger no es la única manera de hacer esto, hay otra alternativa llamada RAML que esta bastante interesante y que usé para un proyecto con Node.js hace un tiempo. Les dejo el link:
https://raml.org/

Tengo este error al realizar los cambios en SwaggerConfig, estoy usando springboot 2.6.2. (Hasta abajo la solucion)

Failed to start bean 'documentationPluginsBootstrapper'; nested exception is java.lang.NullPointerException: Cannot invoke "org.springframework.web.servlet.mvc.condition.PatternsRequestCondition.toString()" because the return value of "springfox.documentation.spi.service.contexts.Orderings.patternsCondition(springfox.documentation.RequestHandler)" is null

Por lo cual mejor uso springdoc para swagger documentation. Vean mi respuesta en https://stackoverflow.com/questions/70036953/springboot-2-6-0-spring-fox-3-failed-to-start-bean-documentationpluginsboot

Hola a todos, les voy a compartir lo que a mí me sirvió en Mayo del 2024. Al tener una versión muy actualizada de Spring Boot no quise degradarla para trabajar con Swagger 2, entonces utilicé la dependencia de Spring Doc. Lo 1ro fue agregarla en el Build como se muestra continuación. Ahí también les dejé el enlace para acceder. ![](https://static.platzi.com/media/user_upload/image-0d088a50-3bc3-419f-98a0-22edef2af679.jpg) Lo 2do fueron las anotaciones que cambian un poco. ![](https://static.platzi.com/media/user_upload/image-9443166f-f80e-4cf3-8efa-5af65f84b8e2.jpg) Eso fue todo, en mi caso no tuve que agregar nada al application properties. Espero que les funcione lo que a mí me funcionó.

Hola! A quienes estén usando la versión 3.0.0 de Swagger, les comento que es lo que funcionó en mi caso:

En el build.gradle

dependencies {
	...
	implementation 'io.springfox:springfox-boot-starter:3.0.0'
	implementation 'io.springfox:springfox-swagger-ui:3.0.0'
}

En el archivo SwaggerConfig.java

@Configuration
public class SwaggerConfig {
    private String controllersBasePackage = "com.jessat18.market.web.controller";

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.basePackage(controllersBasePackage))
                .build();
    }
}

Y en PlatziMarketApplication.java

@EnableWebMvc
@SpringBootApplication
public class PlatziMarketApplication {

	public static void main(String[] args) {
		SpringApplication.run(PlatziMarketApplication.class, args);
	}

Para ingresar en esta nueva versión, deben ingresar añadiendo /swagger-ui/index.html, quedando:

{puerto}/{contexto}/swagger-ui/index.html

Hola, gracias por el curso 😀

Si estan utilizando spring 3.X, y quieren utilizar swagger 3, yo no pude implementar las librerías del curso, pero pueden implementar la siguiente librería

org.springdoc:springdoc-openapi-starter-webmvc-ui

y la clase SwaggerConfig quedaría de la siguiente manera:

package com.sample.springapi.web.config;

import org.springdoc.core.models.GroupedOpenApi;
import org.springframework.context.annotation.Bean;

public class SwaggerConfig {
    
    @Bean
    public GroupedOpenApi publicApi() {
        return GroupedOpenApi.builder()
                .group("spring-api")
                .pathsToMatch("/public/**")
                .build();
    }
}

Para los que esten en la version 2.9.2 de swagger solo necesitan la anotacion @EnableSwagger2, no es necesario la de @Configuration ( da error )

Yo estoy trabajando con maven y la version de spring es 3.0.3, agregué esta dependencia que proporcionaron otros compañeros en los comentarios, pero no me funciono. Y revisando esta documentación, encontre que la correcta es la siguiente:

<dependency>
      <groupId>org.springdoc</groupId>
      <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
      <version>2.0.2</version>
   </dependency>

Pero me marco el siguiente error:

Error calling `jakarta.validation.Validation#buildDefaultValidatorFactory`

jakarta.validation.NoProviderFoundException: Unable to create a Configuration, because no Jakarta Bean Validation provider could be found. Add a provider like Hibernate Validator (RI) to your classpath.

Este error indica que no se ha encontrado un proveedor de validación de Jakarta Bean Validation en su classpath. Para solucionar este problema, tuve que agregar una implementación de Bean Validation a su proyecto, como Hibernate Validator:

<!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator -->
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>8.0.0.Final</version>
</dependency>

Otra manera de hacerlo, es utilizando SpringDoc OpenApi. Para esto simplemente debemos buscar la depencia en Maven Reposiotry e integrarla a nuesto build.gradel, ya que SpringDoc OpenApi hace uso de Swagger.

Implementación

implementation 'org.springdoc:springdoc-openapi-ui:1.6.11' 

Una vez integrada la dependencia, podemos consultar nuestra documentacion en : localhost:8080/platzi-market/api/swagger-ui.html

Para mayor información, consultar:

https://www.baeldung.com/spring-rest-openapi-documentation

Para usar la versión 2.9.2 de Swagger con la version de SpringBoot 2.6+, se debe colocar esta propiedad en application.properties

spring.mvc.pathmatch.matching-strategy=ant-path-matcher

Existe un spring boot starter para swagger que incluye las dos dependencias mostradas acá:

    // Maven
    <dependency>
      <groupId>io.springfox</groupId>
      <artifactId>springfox-boot-starter</artifactId>
      <version>${swagger2.version}</version>
    </dependency>
// Gradle
implementation 'io.springfox:springfox-boot-starter:3.0.0'
La dependencia swagger referenciada en este curso ya esta deprecada, la dependencia a hoy julio del 2024 con su archivo de configuración es la siguiente: \ \<dependency> \<groupId>org.springdoc\</groupId> \<artifactId>springdoc-openapi-starter-webmvc-ui\</artifactId> \<version>2.5.0\</version> \</dependency> @OpenAPIDefinition( info = @Info( title = "API de Platzi MArket", description = "API para gestión de productoss", termsOfService = "https://platzi.com/cursos/java-spring/", version = "1.0.0", summary = "Una plataforma para gestionar y productos", contact = @Contact( name = "Platzi", url = "https://platzi.com/cursos/java-spring/", email = "[email protected]" ), license = @License( name = "propiedad", url = "https://platzi.com/cursos/java-spring/" ) ), servers = { @Server( url = "/platzi-market/api" ) } ) public class SwaggerConfig { }
para el build.gradle las dependencias son asi: ![](https://static.platzi.com/media/user_upload/image-5c98c316-a464-4aec-96ee-a10f91706297.jpg) y en los resourse en application.properties el siguiente codigo ```js springdoc.api-docs.enabled=true springdoc.swagger-ui.enabled=true springdoc.swagger-ui.path=/swagger-ui.html springdoc.packagesToScan=com.felipe.market.web.controller ```springdoc.api-docs.enabled=true springdoc.swagger-ui.enabled=true springdoc.swagger-ui.path=/swagger-ui.html springdoc.packagesToScan= el codigo de controler.
Intente instalar swagger a como se muestra en el vídeo pero al compilar el proyecto me marcaba error en el JDK y me lanzaba este error, así que lo intente de otra forma: en mi archivo gradle puse esta línea implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.3.0' y en aplication.properties agregue esto springdoc.api-docs.enabled=true springdoc.swagger-ui.enabled=true springdoc.swagger-ui.path=/swagger-ui.html springdoc.packagesToScan=com.example.demo.web.controller y listo, funciona, esto para spring 3.2.1
Si ha alguien mas le sale este error **"**[**Failed to start bean 'documentationPluginsBootstrapper' in spring data rest**](https://stackoverflow.com/questions/40241843/failed-to-start-bean-documentationpluginsbootstrapper-in-spring-data-rest)**",** se debe al usar springfox-swagger2 y springfox-swagger-ui versión (2.9.2), versión spring-boot (2.6.2), Lo Solucione de la siguiente manera: **Agregando en application.properties:** **spring.mvc.pathmatch.matching-strategy = ANT\_PATH\_MATCHER** Se utiliza para decirle a la aplicación cómo manejar las solicitudes web. Utiliza patrones flexibles para determinar qué parte del código debe ejecutarse según la URL solicitada. Esto facilita la gestión de diferentes rutas en tu aplicación web.

Espero que se realice un curso profundizando un poco más swagger !

A mí lo que me funcionó fue implementar la siguiente en el archivo build.gradle dependencia de a cuerdo a lo leí en: https://stackoverflow.com/questions/74701738/spring-boot-3-springdoc-openapi-ui-doesnt-work
La clase SwaggerConfig.java ya no es necesaria.

implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2'

Y en la clase ProductController.java las anotaciones fueron las siguientes:

 @GetMapping("/all")
    @Operation(summary = "Get all supermarket products")
    @ApiResponse(responseCode = "200", description = "OK")
    public ResponseEntity<List<Product>> getAll() {
        return new ResponseEntity<>(productService.getAll(), HttpStatus.OK);
    }

@GetMapping("/{productId}")
    @Operation(summary = "Search a product with an ID")
    @ApiResponses({
            @ApiResponse(responseCode = "200", description = "OK"),
            @ApiResponse(responseCode = "404", description = "Product not found")
    })
    public ResponseEntity<Product> getProduct(@Parameter(description = "Product ID", required = true, example = "1") @PathVariable("productId") int productId) {
        return productService.getProduct(productId)
                .map(product -> new ResponseEntity<>(product, HttpStatus.OK))
                .orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));
    }

Si también tienen el mismo problema del error fantasma “NullPointerException” pues encontré una solución, agregando la siguiente linea en el archivo de “application.properties”:

spring.mvc.pathmatch.matching-strategy = ANT_PATH_MATCHER

Alejandro buenas tardes, sería bastante interesante complementar el curso con el Update, el cual es parte del CRUD.
Saludos y agradezco se remita alguna documentación al respecto, para complementar el ejercicio.

Cuál es la función de spring-fox? Dar un interfáz grafica.

Los endpoint me funcionan bien, pero no me genera la documentacion, alguien sabe porque ??

Excelente forma de documentar la Apis, he utilizado esta forma y es muy interesante, aprendiendo cada dia mucho mas.

A la fecha el método de springfox ya no funciona para las nuevas versiones de spring-boot, por lo cual sugeriría que se actulice el curso o viceversa migrar a springdoc
```js plugins { id 'java' id 'org.springframework.boot' version '3.3.2' id 'io.spring.dependency-management' version '1.1.6' } group = 'com.platzi' version = '0.0.1-SNAPSHOT' java { toolchain { languageVersion = JavaLanguageVersion.of(22) } } configurations { compileOnly { extendsFrom annotationProcessor } } repositories { mavenCentral() } dependencies { implementation 'org.springframework.boot:spring-boot-starter-data-jpa:3.2.8' implementation 'org.springframework.boot:spring-boot-starter-web' implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.6.0' //implementation 'io.springfox:springfox-swagger-ui:2.9.2' //implementation 'io.springfox:springfox-swagger2:2.9.2' //implementation 'io.springfox:springfox-schema:2.9.2' //implementation 'io.springfox:springfox-boot-starter:3.0.0' runtimeOnly 'org.postgresql:postgresql' implementation 'org.mapstruct:mapstruct:1.5.5.Final' annotationProcessor 'org.mapstruct:mapstruct-processor:1.5.5.Final' compileOnly 'org.projectlombok:lombok' annotationProcessor 'org.projectlombok:lombok' testImplementation 'org.springframework.boot:spring-boot-starter-test' testRuntimeOnly 'org.junit.platform:junit-platform-launcher' } tasks.named('test') { useJUnitPlatform() } ```plugins { id 'java' id 'org.springframework.boot' version '3.3.2' id 'io.spring.dependency-management' version '1.1.6' } group = 'com.platzi' version = '0.0.1-SNAPSHOT' java { toolchain { languageVersion = JavaLanguageVersion.*of*(22) } } configurations { compileOnly { extendsFrom annotationProcessor } } repositories { mavenCentral() } dependencies { implementation 'org.springframework.boot:spring-boot-starter-data-jpa:3.2.8' implementation 'org.springframework.boot:spring-boot-starter-web' implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.6.0' //implementation 'io.springfox:springfox-swagger-ui:2.9.2' //implementation 'io.springfox:springfox-swagger2:2.9.2' //implementation 'io.springfox:springfox-schema:2.9.2' //implementation 'io.springfox:springfox-boot-starter:3.0.0' runtimeOnly 'org.postgresql:postgresql' implementation 'org.mapstruct:mapstruct:1.5.5.Final' annotationProcessor 'org.mapstruct:mapstruct-processor:1.5.5.Final' compileOnly 'org.projectlombok:lombok' annotationProcessor 'org.projectlombok:lombok' testImplementation 'org.springframework.boot:spring-boot-starter-test' testRuntimeOnly 'org.junit.platform:junit-platform-launcher' } tasks.named('test') { useJUnitPlatform() }
S
PRUEBA
alguien tan amable me puede hacer el favor de ayudarme con este mensaje que me sale cuando intento cargar la pagina de swagger. ![](https://static.platzi.com/media/user_upload/image-a64c795c-2682-4ac0-9386-aa352ad2dd42.jpg)
7/12/2023 ![](https://static.platzi.com/media/user_upload/image-9351ea42-7938-4185-9c6e-43bcbd6f61c0.jpg) Estas son algunas de las anotaciones que se usan a la fecha, para que comparen y las vayan reemplazando según sea el caso

Para los de Springboot 3 con Maven, deben incluir esta dos dependencias en su POM.xml:

<!-- Agregar Swagger -->
<dependency>
	<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
	<version>2.2.0</version>
</dependency>
<!-- Controlar el error del Bean de Jakarta -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-validation</artifactId>
	<version>3.1.2</version>
</dependency>

Les dejo mi ajuste en el 2023 para que funcione swagger-ui:

Colocar en las propiedades de la aplicación (application.properties):

springdoc.api-docs.enabled=true
springdoc.swagger-ui.enabled=true
springdoc.swagger-ui.path=/swagger-ui.html
springdoc.packages-to-scan={CAMBIAR_POR_SU_RUTA_PAQUETE_CONTROLADORES}

Y en el (pom.xml) si trabajaron con maven como administrador de dependencias:

<dependency>
	<groupId>org.springdoc</groupId>
	<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
	<version>2.0.2</version>
</dependency>

y para poder ver la documentación utilizar la url: {host}:{puerto}/{contexto}/swagger-ui.html

Para los que usen Maven en este proyecto (como yo jeje) deben incluir las siguientes dependencias a su pom.xml

<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger2</artifactId>
			<version>3.0.0</version>
		</dependency>

		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-boot-starter</artifactId>
			<version>3.0.0</version>
		</dependency>

		<!--
		https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger-ui</artifactId>
			<version>3.0.0</version>
		</dependency>

Una vez descargadas las dependencias pueden lanzar la aplicación.

Hay que entender.

si alguien quiere usar swagger 3.0 aca estan las dependencias.

//	swagger ui 3
	implementation "io.springfox:springfox-boot-starter:3.0.0"
	implementation group: 'io.springfox', name: 'springfox-swagger-ui', version: '3.0.0'

en la clase SwaggerConfig ya no necesitan la etiqueta @EnableSwagger2

Muy desactualizado todo… luego buscaré está parte en otro.
Sería bueno que actualicen el curso. al menos con comentarios en RECURSOS

Las implementaciones correctas son ``` implementation 'io.springfox:springfox-swagger2:3.0.0' implementation 'io.springfox:springfox-swagger-ui:3.0.0' implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.4' ``` Creditos a ``` Wilmar De MelquisedecLisbet ``` Si quieren mas detalles busquenlo en los aportes con ctr + f

Para que me funcionara Swagger2, tuve que remover la anotación @Configuration, y solo dejar @Swagger2

Video para generación de documentación swagger en java

para los que tengan el problema del NullPointerException, les dejo este enlace: https://stackoverflow.com/questions/40241843/failed-to-start-bean-documentationpluginsbootstrapper-in-spring-data-rest

ya otros compañeros indican que hacer para solucionarlo, solo me dio curiosidad entender que habia detras del problema 🐱‍🏍

Si usan spring-boot-starter-actuator no les va a funcionar la dependencia Swagger, con la version mas reciente.

Consideren Cambiarse a SpringDoc tal y como se dice en esta respuesta de StackOverflow

Solo es añadir la dependencia de
SpingDoc
y listo, lo tendrán funcionando en

http://{server}:{port}/{context-path}/swagger-ui/index.html
```.

Al que le aparece este error:
Caused by: java.lang.NullPointerException: Cannot invoke “org.springframework.web.servlet.mvc.condition.PatternsRequestCondition.getPatterns()”

En la version 3.0.0 (No se si entra version funcione) hay que poner en propiertes:
spring.mvc.pathmatch.matching-strategy=ANT_PATH_MATCHER

La forma de ingresar al swagger es con: swagger-ui/index.html.

Ejp:
{host}:{puerto} / {contexto} /swagger-ui/index.htm

Documentación del Controller hacia Swagger

Que gran forma de documentar las apis. Genial!

<dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

No me quedo muy claro el uso de la notacion
@Bean y @Configuration
Para que son y que más se puede implementar con ellas?
Gracias

Swagger se debe utilizar en produccion? si es asi es posible desactivar que se envien los metodos post, put y delete?

Dependencias:

implementation 'io.springfox:springfox-swagger2:2.9.2'
implementation 'io.springfox:springfox-swagger-ui:2.9.2'
Tambien podrían usar la siguiente dependencia llamada springdoc-openapi-starter-webmvc-ui para usar swagger3package com.platzi.market.web.interfaces; import com.platzi.market.domain.Product; import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.responses.ApiResponse; import io.swagger.v3.oas.annotations.responses.ApiResponses; import io.swagger.v3.oas.annotations.tags.Tag; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestBody; import java.util.*List*; @Tag(name = "ProductController", description = "The product API") public interface *IProductController* { @Operation( summary = "Retrieve all products from the supermarket", description = "This operation fetches a list of all products in the supermarket database." ) @ApiResponse(responseCode = "200", description = "OK") ResponseEntity<*List*\<Product>> getAll(); ResponseEntity<*List*\<Product>> getByCategory(@PathVariable("categoryId") int categoryId); @Operation( summary = "Find product by ID", description = "Retrieve details of a specific product by its unique ID. " ) @ApiResponses({ @ApiResponse(responseCode = "200", description = "Ok"), @ApiResponse(responseCode = "404", description = "Product not found") }) ResponseEntity\<Product> getProduct ( @Parameter( description = "The id of product", required = true, example = "7" ) @PathVariable("id") int productId ); ResponseEntity\<Product> save(@RequestBody Product product); ResponseEntity delete(@PathVariable("id") int productId); } Gradle: implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.6.0' (Actualicen la version de ser necesario) Adicionalmente recuerden que swagger puede ser un poco verboso dentro de nuestras clases, pero para solucionar este problema podrian crear una interfaz donde definan los métodos del controlador y adicionalmente agreguen toda la información que esta relacionada con swagger y la implementan desde la clase del controlador de la siguiente manera: ```java package com.platzi.market.web.interfaces; import com.platzi.market.domain.Product; import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.responses.ApiResponse; import io.swagger.v3.oas.annotations.responses.ApiResponses; import io.swagger.v3.oas.annotations.tags.Tag; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestBody; import java.util.List; @Tag(name = "ProductController", description = "The product API") public interface IProductController { @Operation( summary = "Retrieve all products from the supermarket", description = "This operation fetches a list of all products in the supermarket database." ) @ApiResponse(responseCode = "200", description = "OK") ResponseEntity<List<Product>> getAll(); ResponseEntity<List<Product>> getByCategory(@PathVariable("categoryId") int categoryId); @Operation( summary = "Find product by ID", description = "Retrieve details of a specific product by its unique ID. " ) @ApiResponses({ @ApiResponse(responseCode = "200", description = "Ok"), @ApiResponse(responseCode = "404", description = "Product not found") }) ResponseEntity<Product> getProduct ( @Parameter( description = "The id of product", required = true, example = "7" ) @PathVariable("id") int productId ); ResponseEntity<Product> save(@RequestBody Product product); ResponseEntity delete(@PathVariable("id") int productId); } ```

Si teiene el error de
Failed to start bean ‘documentationPluginsBootstrapper’; nested exception is java.lang.NullPointerException:

yo solucione usando la verion de 3.0.0 en
springfox-swagger2 y springfox-swagger-ui
elimine en la linea de @EnableSwagger2
y agrege esta dependencia

<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-boot-starter</artifactId>
<version>3.0.0</version>
</dependency>

y agrege esta linea en
@EnableWebMvc
en el archivo princepal en mi caso
MarketApplication.java

clase super util, gracias profe

jajaja no estoy acostumbrado a ver documentación

Excelente!!