In this post, we'll explore how to configure OpenAPI in your Spring Boot application and add a convenient redirection from the root URL to the Swagger UI. This setup will improve your API documentation and make it more accessible to developers.
OpenAPI Bean Configuration
First, let's create a configuration class to customize our OpenAPI documentation:
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 org.springframework.boot.info.GitProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class OpenAPIConfig { @Bean public OpenAPI customOpenAPI(GitProperties gitProperties) { return new OpenAPI() .info(new Info() .title("Book Catalog API") .description("REST API for managing a book catalog. Application version: "+ gitProperties.get("build.version")) .version("1.0.0") .contact(new Contact() .name("Book Catalog Team") .email("support@bookcatalog.com") .url("https://github.com/vlaship/book-catalog")) .license(new License() .name("MIT License") .url("https://opensource.org/licenses/MIT")) ); } }
This configuration creates a custom OpenAPI bean with basic information about your API. You can further customize this by adding more details, such as contact information, license, or external documentation.
We can use GitProperties to provide more details.
Root URL Redirection Controller
Next, let's create a controller to redirect users from the root URL to the Swagger UI:
import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping; @Controller public class OpenApiController { @GetMapping("/") public String index() { return "redirect:swagger-ui.html"; } }
This simple controller uses a @GetMapping for the root URL ("/") and redirects to the Swagger UI HTML page.
Updating application.yaml
This configuration file, often named application.yml, plays a crucial role in defining various aspects of your application's behavior.
spring: application: name: book-catalog version: '@project.version@' mvc: problemdetails: enabled: true management: endpoints: web: exposure: include: '*' info: git: mode: full server: port: 8888 servlet: context-path: /${spring.application.name} error: whitelabel: enabled: false
The provided YAML configuration covers several key areas of your Spring Boot application:
- Application Properties:
name: Defines the application's name, here set to book-catalog.
version: References a placeholder, likely populated during the build process, to specify the application's version.
- MVC Configuration:
problemdetails.enabled: Enables detailed problem reports in the response body for exceptions.
- Management Endpoints:
endpoints.web.exposure.include: '*':** Exposes all actuator endpoints for monitoring and management purposes.
info.git.mode: full: Provides detailed Git information in the /info endpoint.
- Server Configuration:
port: Sets the port on which the server listens for incoming requests (default 8080, here set to 8888).
servlet.context-path: Defines the context path for the application, ensuring requests are routed correctly.
error.whitelabel.enabled: false: Disables the default whitelabel error page, allowing for more informative error messages during development.
Adding banner.txt
1. Create banner.txt file
Create a new file named banner.txt within the src/main/resources directory of your Spring Boot project.
2. Add service details to banner.txt
You can add any text or ASCII art to this file. Here's an example:
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 org.springframework.boot.info.GitProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class OpenAPIConfig { @Bean public OpenAPI customOpenAPI(GitProperties gitProperties) { return new OpenAPI() .info(new Info() .title("Book Catalog API") .description("REST API for managing a book catalog. Application version: "+ gitProperties.get("build.version")) .version("1.0.0") .contact(new Contact() .name("Book Catalog Team") .email("support@bookcatalog.com") .url("https://github.com/vlaship/book-catalog")) .license(new License() .name("MIT License") .url("https://opensource.org/licenses/MIT")) ); } }
This approach adds a professional touch to your application startup and provides valuable information at a glance.
Adding Dockerfile
import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping; @Controller public class OpenApiController { @GetMapping("/") public String index() { return "redirect:swagger-ui.html"; } }
Layer Extraction: Creating separate layers for dependencies, improving build efficiency and reducing image size updates.
Multi-stage Build: Utilizing a multi-stage build process to separate the build environment from the runtime environment, resulting in a smaller and more efficient final image.
Lightweight Base Image: Using a minimal base image like azul/zulu-openjdk-alpine:21-jre-headless to further reduce the image size.
This approach leads to faster builds, smaller image sizes, and improved overall performance for your Spring Boot application within a Docker container.
The above is the detailed content of SpringBoot Web Service - Part Initial Configuration. For more information, please follow other related articles on the PHP Chinese website!

Bytecodeachievesplatformindependencebybeingexecutedbyavirtualmachine(VM),allowingcodetorunonanyplatformwiththeappropriateVM.Forexample,JavabytecodecanrunonanydevicewithaJVM,enabling"writeonce,runanywhere"functionality.Whilebytecodeoffersenh

Java cannot achieve 100% platform independence, but its platform independence is implemented through JVM and bytecode to ensure that the code runs on different platforms. Specific implementations include: 1. Compilation into bytecode; 2. Interpretation and execution of JVM; 3. Consistency of the standard library. However, JVM implementation differences, operating system and hardware differences, and compatibility of third-party libraries may affect its platform independence.

Java realizes platform independence through "write once, run everywhere" and improves code maintainability: 1. High code reuse and reduces duplicate development; 2. Low maintenance cost, only one modification is required; 3. High team collaboration efficiency is high, convenient for knowledge sharing.

The main challenges facing creating a JVM on a new platform include hardware compatibility, operating system compatibility, and performance optimization. 1. Hardware compatibility: It is necessary to ensure that the JVM can correctly use the processor instruction set of the new platform, such as RISC-V. 2. Operating system compatibility: The JVM needs to correctly call the system API of the new platform, such as Linux. 3. Performance optimization: Performance testing and tuning are required, and the garbage collection strategy is adjusted to adapt to the memory characteristics of the new platform.

JavaFXeffectivelyaddressesplatforminconsistenciesinGUIdevelopmentbyusingaplatform-agnosticscenegraphandCSSstyling.1)Itabstractsplatformspecificsthroughascenegraph,ensuringconsistentrenderingacrossWindows,macOS,andLinux.2)CSSstylingallowsforfine-tunin

JVM works by converting Java code into machine code and managing resources. 1) Class loading: Load the .class file into memory. 2) Runtime data area: manage memory area. 3) Execution engine: interpret or compile execution bytecode. 4) Local method interface: interact with the operating system through JNI.

JVM enables Java to run across platforms. 1) JVM loads, validates and executes bytecode. 2) JVM's work includes class loading, bytecode verification, interpretation execution and memory management. 3) JVM supports advanced features such as dynamic class loading and reflection.

Java applications can run on different operating systems through the following steps: 1) Use File or Paths class to process file paths; 2) Set and obtain environment variables through System.getenv(); 3) Use Maven or Gradle to manage dependencies and test. Java's cross-platform capabilities rely on the JVM's abstraction layer, but still require manual handling of certain operating system-specific features.


Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Atom editor mac version download
The most popular open source editor

VSCode Windows 64-bit Download
A free and powerful IDE editor launched by Microsoft

Zend Studio 13.0.1
Powerful PHP integrated development environment

SublimeText3 English version
Recommended: Win version, supports code prompts!

Notepad++7.3.1
Easy-to-use and free code editor
