S02L07 - Tutorial de Spring Boot JWT usando OAuth

html


स्प्रिंग अनुप्रयोगों में Swagger UI और सुरक्षा एकीकृत करना: एक व्यापक मार्गदर्शिका
लेखक: [Your Name]

प्रकाशित: अक्टूबर 2023

अनुक्रमणिका

परिचय .............................................................. 1
Swagger UI को समझना ............................................. 3

Swagger UI क्या है? .................................................. 3
स्प्रिंग में Swagger UI सेटअप करना .................................. 4
Swagger UI को कस्टमाइज़ करना ................................................. 5


स्प्रिंग अनुप्रयोगों में सुरक्षा लागू करना ................. 7

Spring Security का अवलोकन ......................................... 7
OAuth2 Resource Server को कॉन्फ़िगर करना ................................. 8
JWT प्रमाणीकरण और प्राधिकरण ........................... 10


Swagger UI को Spring Security के साथ एकीकृत करना ................. 13

Swagger Endpoints को सुरक्षित करना ......................................... 13
व्यावहारिक कार्यान्वयन ................................................ 14


निष्कर्ष ................................................................. 17
संसाधन ................................................................. 18


परिचय
वेब विकास के लगातार विकसित हो रहे परिदृश्य में, सुरक्षित और अच्छी तरह से दस्तावेजीकृत APIs बनाना अत्यंत महत्वपूर्ण है। Spring Boot, एक व्यापक रूप से उपयोग किया जाने वाला फ्रेमवर्क, इस प्रक्रिया को सरल बनाने के लिए मजबूत सुविधाएँ प्रदान करता है। इस पारिस्थितिकी तंत्र में दो आवश्यक उपकरण हैं Swagger UI API दस्तावेजीकरण के लिए और Spring Security आपके अनुप्रयोग की सुरक्षा के लिए।
यह ईबुक Swagger UI को Spring Security के साथ एकीकृत करने में गहराई से प्रवेश करती है, शुरुआती और बुनियादी ज्ञान वाले डेवलपर्स के लिए एक व्यापक मार्गदर्शिका प्रदान करती है। हम सेटअप, कस्टमाइज़ेशन और सुरक्षा कॉन्फ़िगरेशन का अन्वेषण करेंगे जो एक निर्बाध और सुरक्षित API वातावरण बनाने के लिए आवश्यक हैं।
Swagger UI और Spring Security को क्यों एकीकृत करें?

Swagger UI इंटरैक्टिव दस्तावेजीकरण प्रदान करता है, जिससे डेवलपर्स API endpoints को आसानी से दृश्य और परीक्षण कर सकते हैं।
Spring Security एक शक्तिशाली और कस्टमाइज़ेबल प्रमाणीकरण और प्राधिकरण फ्रेमवर्क प्रदान करता है, यह सुनिश्चित करते हुए कि APIs अनधिकृत पहुंच के खिलाफ सुरक्षित हैं।

फायदे और नुकसान


特性
优点
缺点


Swagger UI
交互式API文档，易于测试
需要维护以确保准确性


Spring Security
强大的安全功能，高度可定制
学习曲线较陡


集成优势
增强的安全性，改善的开发者体验
额外的配置开销


何时何地使用这些工具

Swagger UI非常适合在开发过程中记录和测试API。
Spring Security应在任何需要认证和授权机制的应用程序中实现。


理解Swagger UI
什么是Swagger UI？
Swagger UI是一个开源工具，允许开发人员可视化和交互API端点。它从API的文档生成一个用户友好的界面，支持实时测试和探索。
在Spring中设置Swagger UI
要将Swagger UI集成到您的Spring应用中，请按照以下步骤操作：

添加Swagger依赖





		
		
			
			
Java
			
			&lt;!-- pom.xml --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;io.springfox&lt;/groupId&gt;
    &lt;artifactId&gt;springfox-boot-starter&lt;/artifactId&gt;
    &lt;version&gt;3.0.0&lt;/version&gt;
&lt;/dependency&gt;
			
				
					
				
					1
2
3
4
5
6
				
						&lt;!-- pom.xml --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;io.springfox&lt;/groupId&gt;
    &lt;artifactId&gt;springfox-boot-starter&lt;/artifactId&gt;
    &lt;version&gt;3.0.0&lt;/version&gt;
&lt;/dependency&gt;
					
				
			
		



在Spring中配置Swagger

创建一个配置类来设置Swagger：




		
		
			
			
Java
			
			// SwaggerConfig.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;

@Configuration
public class SwaggerConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.OAS_30)
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.demo"))
                .paths(PathSelectors.any())
                .build();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						// SwaggerConfig.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
 
@Configuration
public class SwaggerConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.OAS_30)
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.demo"))
                .paths(PathSelectors.any())
                .build();
    }
}
					
				
			
		


代码中的注释：

@Configuration: 表示该类具有@Bean定义方法。
Docket Bean: 配置Swagger扫描指定的包中的API端点。

自定义Swagger UI
自定义允许您根据应用程序的需求调整Swagger UI。

修改Swagger UI外观

通过修改配置来调整外观：




		
		
			
			
Java
			
			@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .info(new Info().title("My API")
            .version("1.0")
            .description("API documentation with customized Swagger UI"));
}
			
				
					
				
					1
2
3
4
5
6
7
				
						@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .info(new Info().title("My API")
            .version("1.0")
            .description("API documentation with customized Swagger UI"));
}
					
				
			
		



向Swagger UI添加认证

要保护Swagger UI端点，请更新配置以包括认证方案：




		
		
			
			
Java
			
			@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .addSecurityItem(new SecurityRequirement().addList("JWT"))
            .components(new Components().addSecuritySchemes("JWT",
                    new SecurityScheme().name("JWT").type(SecurityScheme.Type.HTTP)
                            .scheme("bearer").bearerFormat("JWT")))
            .info(new Info().title("Secure API").version("1.0"));
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .addSecurityItem(new SecurityRequirement().addList("JWT"))
            .components(new Components().addSecuritySchemes("JWT",
                    new SecurityScheme().name("JWT").type(SecurityScheme.Type.HTTP)
                            .scheme("bearer").bearerFormat("JWT")))
            .info(new Info().title("Secure API").version("1.0"));
}
					
				
			
		


解释：

SecurityRequirement: 定义API的安全需求。
SecurityScheme: 指定安全类型（此例中为JWT）。


在Spring应用中实现安全性
Spring Security概述
Spring Security是一个强大且高度可定制的认证和访问控制框架。它为基于Spring的应用程序提供全面的安全服务，包括：

认证和授权
防止常见漏洞
与各种认证机制集成（例如JWT，OAuth2）

配置OAuth2资源服务器
要使用Spring Security设置OAuth2资源服务器：

添加OAuth2依赖





		
		
			
			
Java
			
			&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-oauth2-resource-server&lt;/artifactId&gt;
&lt;/dependency&gt;
			
				
					
				
					1
2
3
4
				
						&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-oauth2-resource-server&lt;/artifactId&gt;
&lt;/dependency&gt;
					
				
			
		



配置安全设置





		
		
			
			
Java
			
			@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/public/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .oauth2ResourceServer().jwt();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/public/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .oauth2ResourceServer().jwt();
    }
}
					
				
			
		


代码中的注释：

csrf().disable(): 禁用CSRF保护（谨慎使用）。
authorizeRequests(): 配置基于URL的授权。
oauth2ResourceServer().jwt(): 启用基于JWT的认证。

JWT认证与授权
JSON Web Tokens (JWT)是一个紧凑且自包含的方式，用于在各方之间安全传输信息。在Spring中实现JWT包括：

生成JWT





		
		
			
			
Java
			
			public String generateToken(Authentication authentication) {
    UserDetails userDetails = (UserDetails) authentication.getPrincipal();
    return Jwts.builder()
            .setSubject(userDetails.getUsername())
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + 86400000)) // 1 day
            .signWith(SignatureAlgorithm.HS512, "secretKey")
            .compact();
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						public String generateToken(Authentication authentication) {
    UserDetails userDetails = (UserDetails) authentication.getPrincipal();
    return Jwts.builder()
            .setSubject(userDetails.getUsername())
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + 86400000)) // 1 day
            .signWith(SignatureAlgorithm.HS512, "secretKey")
            .compact();
}
					
				
			
		


解释：

setSubject: 将用户名设置为令牌主题。
setExpiration: 定义令牌的有效期。
signWith: 使用指定的算法和密钥对令牌进行签名。


验证JWT





		
		
			
			
Java
			
			public boolean validateToken(String token) {
    try {
        Jwts.parser().setSigningKey("secretKey").parseClaimsJws(token);
        return true;
    } catch (JwtException | IllegalArgumentException e) {
        // 无效令牌
    }
    return false;
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						public boolean validateToken(String token) {
    try {
        Jwts.parser().setSigningKey("secretKey").parseClaimsJws(token);
        return true;
    } catch (JwtException | IllegalArgumentException e) {
        // 无效令牌
    }
    return false;
}
					
				
			
		


解释：

使用密钥解析和验证令牌。
如果有效，返回true；否则，返回false。

示例程序代码
以下是一个完整的示例，演示了在Spring应用中进行JWT认证：




		
		
			
			
Java
			
			// JwtAuthenticationFilter.java
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import io.jsonwebtoken.*;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private String secretKey = "secretKey";

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String token = getJwtFromRequest(request);

        if (StringUtils.hasText(token) && validateToken(token)) {
            String username = getUsernameFromJWT(token);

            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                    username, null, new ArrayList<>());
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

            SecurityContextHolder.getContext().setAuthentication(authentication);
        }

        filterChain.doFilter(request, response);
    }

    private String getJwtFromRequest(HttpServletRequest request) {
        String bearer = request.getHeader("Authorization");
        if (StringUtils.hasText(bearer) && bearer.startsWith("Bearer ")) {
            return bearer.substring(7);
        }
        return null;
    }

    private boolean validateToken(String authToken) {
        try {
            Jwts.parser().setSigningKey(secretKey).parseClaimsJws(authToken);
            return true;
        } catch (JwtException ex) {
            // 无效令牌
        }
        return false;
    }

    private String getUsernameFromJWT(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(token)
                .getBody();

        return claims.getSubject();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
				
						// JwtAuthenticationFilter.java
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import io.jsonwebtoken.*;
 
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
 
public class JwtAuthenticationFilter extends OncePerRequestFilter {
 
    private String secretKey = "secretKey";
 
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String token = getJwtFromRequest(request);
 
        if (StringUtils.hasText(token) && validateToken(token)) {
            String username = getUsernameFromJWT(token);
 
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                    username, null, new ArrayList<>());
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
 
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
 
        filterChain.doFilter(request, response);
    }
 
    private String getJwtFromRequest(HttpServletRequest request) {
        String bearer = request.getHeader("Authorization");
        if (StringUtils.hasText(bearer) && bearer.startsWith("Bearer ")) {
            return bearer.substring(7);
        }
        return null;
    }
 
    private boolean validateToken(String authToken) {
        try {
            Jwts.parser().setSigningKey(secretKey).parseClaimsJws(authToken);
            return true;
        } catch (JwtException ex) {
            // 无效令牌
        }
        return false;
    }
 
    private String getUsernameFromJWT(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(token)
                .getBody();
 
        return claims.getSubject();
    }
}
					
				
			
		


代码解释：

特性	优点	缺点
Swagger UI	交互式API文档，易于测试	需要维护以确保准确性
Spring Security	强大的安全功能，高度可定制	学习曲线较陡
集成优势	增强的安全性，改善的开发者体验	额外的配置开销

JwtAuthenticationFilter: 扩展OncePerRequestFilter，确保每个请求只执行一次。

getJwtFromRequest: 从Authorization头中提取JWT。


validateToken: 使用密钥验证JWT。
getUsernameFromJWT: 从JWT声明中获取用户名。
Authentication Setup: 如果令牌有效，在安全上下文中设置认证。


示例输出：

当在Authorization头中提供有效的JWT时，用户将被认证，并获得对受保护端点的访问权限。如果JWT无效或缺失，则访问将被拒绝。



将Swagger UI与Spring Security集成
保护Swagger端点
在允许必要访问的同时保护Swagger UI端点：

更新安全配置

修改SecurityConfig以允许访问Swagger资源：






		
		
			
			
Java
			
			@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .csrf().disable()
        .authorizeRequests()
        .antMatchers(
            "/swagger-resources/**",
            "/swagger-ui/**",
            "/v3/api-docs/**",
            "/public/**"
        ).permitAll()
        .anyRequest().authenticated()
        .and()
        .oauth2ResourceServer().jwt();
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .csrf().disable()
        .authorizeRequests()
        .antMatchers(
            "/swagger-resources/**",
            "/swagger-ui/**",
            "/v3/api-docs/**",
            "/public/**"
        ).permitAll()
        .anyRequest().authenticated()
        .and()
        .oauth2ResourceServer().jwt();
}
					
				
			
		


解释：

antMatchers: 指定无需认证即可许可的URLs。
/swagger-resources/**, /swagger-ui/**, /v3/api-docs/**: 重要的Swagger端点。

实用实现
让我们一步步实施集成：

添加依赖项





		
		
			
			
Java
			
			&lt;!-- Spring Security 和 OAuth2 --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
&lt;/dependency&gt;
&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-oauth2-resource-server&lt;/artifactId&gt;
&lt;/dependency&gt;

&lt;!-- Swagger --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;io.springfox&lt;/groupId&gt;
    &lt;artifactId&gt;springfox-boot-starter&lt;/artifactId&gt;
    &lt;version&gt;3.0.0&lt;/version&gt;
&lt;/dependency&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						&lt;!-- Spring Security 和 OAuth2 --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
&lt;/dependency&gt;
&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-oauth2-resource-server&lt;/artifactId&gt;
&lt;/dependency&gt;
 
&lt;!-- Swagger --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;io.springfox&lt;/groupId&gt;
    &lt;artifactId&gt;springfox-boot-starter&lt;/artifactId&gt;
    &lt;version&gt;3.0.0&lt;/version&gt;
&lt;/dependency&gt;
					
				
			
		



使用安全性配置Swagger





		
		
			
			
Java
			
			@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .addSecurityItem(new SecurityRequirement().addList("JWT"))
            .components(new Components().addSecuritySchemes("JWT",
                    new SecurityScheme().name("JWT").type(SecurityScheme.Type.HTTP)
                            .scheme("bearer").bearerFormat("JWT")))
            .info(new Info().title("Secure API").version("1.0"));
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .addSecurityItem(new SecurityRequirement().addList("JWT"))
            .components(new Components().addSecuritySchemes("JWT",
                    new SecurityScheme().name("JWT").type(SecurityScheme.Type.HTTP)
                            .scheme("bearer").bearerFormat("JWT")))
            .info(new Info().title("Secure API").version("1.0"));
}
					
				
			
		



实施JWT认证过滤器

如前一节所示，实施JwtAuthenticationFilter并在安全配置中注册它。



测试设置


访问公共端点: 应该可以无需认证即可访问。
访问受保护端点: 需要有效的JWT。
访问Swagger UI: 如果配置正确，应该可以无需认证即可访问。

示例交互：

公共API调用





		
		
			
			
Java
			
			GET /public/hello
			
				
					
				
					1
				
						GET /public/hello
					
				
			
		


响应：




		
		
			
			
Java
			
			{
    "message": "Hello, World!"
}
			
				
					
				
					1
2
3
				
						{
    "message": "Hello, World!"
}
					
				
			
		



无JWT的受保护API调用





		
		
			
			
Java
			
			GET /api/secure-data
			
				
					
				
					1
				
						GET /api/secure-data
					
				
			
		


响应：




		
		
			
			
Java
			
			{
    "error": "Unauthorized"
}
			
				
					
				
					1
2
3
				
						{
    "error": "Unauthorized"
}
					
				
			
		



使用有效JWT的受保护API调用





		
		
			
			
Java
			
			GET /api/secure-data
Authorization: Bearer <valid_jwt>
			
				
					
				
					1
2
				
						GET /api/secure-data
Authorization: Bearer <valid_jwt>
					
				
			
		


响应：




		
		
			
			
Java
			
			{
    "data": "Secure Information"
}
			
				
					
				
					1
2
3
				
						{
    "data": "Secure Information"
}
					
				
			
		



结论
在Spring应用中将Swagger UI与Spring Security集成，增强了API的文档和安全性。通过遵循本指南中概述的步骤，开发人员可以创建文档完善、并且安全的API，这些API既用户友好，又能有效防范未经授权的访问。
主要结论

Swagger UI简化了API文档和测试，改善了开发者体验。
Spring Security提供了全面的工具来保护应用程序，支持JWT和OAuth2。
正确的集成确保了Swagger端点的安全性，同时允许授权用户访问。

有效地实施这些工具可以显著简化您的API开发过程，确保您的应用程序既透明又安全。
SEO关键词：Spring Boot, Swagger UI, Spring Security, JWT Authentication, OAuth2, API Documentation, Secure APIs, Spring Boot Security Configuration, JSON Web Token, API Development

资源

Spring Boot Documentation
Swagger UI Official Site
Spring Security Reference
OAuth2 Overview
JSON Web Tokens (JWT) Introduction
Springfox GitHub Repository


Note: This article is AI-generated.

html


Spring 애플리케이션에서 Swagger UI 및 보안 통합하기: 종합 가이드
저자: [Your Name]

발행일: 2023년 10월

목차

소개 .............................................................. 1
Swagger UI 이해하기 ............................................. 3

Swagger UI란? .................................................. 3
Spring에서 Swagger UI 설정하기 .................................. 4
Swagger UI 커스터마이징 ................................................. 5


Spring 애플리케이션에서 보안 구현하기 ................. 7

Spring Security 개요 ......................................... 7
OAuth2 리소스 서버 구성 ................................. 8
JWT 인증 및 권한 부여 ........................... 10


Swagger UI를 Spring Security와 통합하기 ................. 13

Swagger 엔드포인트 보안 강화 ......................................... 13
실용적인 구현 ................................................ 14


결론 ................................................................. 17
자료 ................................................................. 18


소개
끊임없이 발전하는 웹 개발 환경에서 안전하고 문서화가 잘 된 API를 구축하는 것이 중요합니다. 널리 사용되는 프레임워크인 Spring Boot는 이 과정을 간소화하기 위한 강력한 기능을 제공합니다. 이 생태계에서 두 가지 필수 도구는 API 문서화를 위한 Swagger UI와 애플리케이션을 보호하기 위한 Spring Security입니다.
이 전자책은 Swagger UI를 Spring Security와 통합하는 방법을 깊이 있게 다루며, 초보자와 기본 지식을 가진 개발자를 위한 종합 가이드를 제공합니다. 우리는 원활하고 안전한 API 환경을 만들기 위해 필요한 설정, 커스터마이징 및 보안 구성을 탐구할 것입니다.
Swagger UI와 Spring Security를 통합해야 하는 이유는?

Swagger UI는 상호작용 문서화를 제공하여 개발자들이 API 엔드포인트를 쉽게 시각화하고 테스트할 수 있게 합니다.
Spring Security는 강력하고 커스터마이징 가능한 인증 및 권한 부여 프레임워크를 제공하여 API가 무단 액세스로부터 보호되도록 보장합니다.

장단점


Característica
Prós
Contras


Swagger UI
Documentação de API interativa, fácil teste
Requer manutenção para precisão


Spring Security
Recursos de segurança robustos, altamente personalizável
Curva de aprendizado mais íngreme


Benefícios da Integração
Segurança aprimorada, melhor experiência do desenvolvedor
Sobrecarrega com configurações adicionais


Quando e Onde Usar Estas Ferramentas

Swagger UI é ideal para documentar e testar APIs durante o desenvolvimento.
Spring Security deve ser implementado em qualquer aplicação que requeira mecanismos de autenticação e autorização.


Entendendo o Swagger UI
O que é Swagger UI?
Swagger UI é uma ferramenta de código aberto que permite aos desenvolvedores visualizar e interagir com endpoints de API. Ele gera uma interface amigável a partir da documentação de uma API, permitindo testes e exploração em tempo real.
Configurando o Swagger UI no Spring
Para integrar o Swagger UI em sua aplicação Spring, siga estes passos:

Adicionar Dependência do Swagger





		
		
			
			
Java
			
			&lt;!-- pom.xml --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;io.springfox&lt;/groupId&gt;
    &lt;artifactId&gt;springfox-boot-starter&lt;/artifactId&gt;
    &lt;version&gt;3.0.0&lt;/version&gt;
&lt;/dependency&gt;
			
				
					
				
					1
2
3
4
5
6
				
						&lt;!-- pom.xml --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;io.springfox&lt;/groupId&gt;
    &lt;artifactId&gt;springfox-boot-starter&lt;/artifactId&gt;
    &lt;version&gt;3.0.0&lt;/version&gt;
&lt;/dependency&gt;
					
				
			
		



Configurar Swagger no Spring

Crie uma classe de configuração para configurar o Swagger:




		
		
			
			
Java
			
			// SwaggerConfig.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;

@Configuration
public class SwaggerConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.OAS_30)
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.demo"))
                .paths(PathSelectors.any())
                .build();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						// SwaggerConfig.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
 
@Configuration
public class SwaggerConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.OAS_30)
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.demo"))
                .paths(PathSelectors.any())
                .build();
    }
}
					
				
			
		


Comentários no Código:

@Configuration: Indica que a classe tem métodos de definição de @Bean.
Docket Bean: Configura o Swagger para escanear o pacote especificado em busca de endpoints de API.

Personalizando o Swagger UI
A personalização permite que você ajuste o Swagger UI para atender às necessidades da sua aplicação.

Modificar Aparência do Swagger UI

Ajuste a aparência modificando a configuração:




		
		
			
			
Java
			
			@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .info(new Info().title("My API")
            .version("1.0")
            .description("API documentation with customized Swagger UI"));
}
			
				
					
				
					1
2
3
4
5
6
7
				
						@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .info(new Info().title("My API")
            .version("1.0")
            .description("API documentation with customized Swagger UI"));
}
					
				
			
		



Adicionando Autenticação ao Swagger UI

Para proteger os endpoints do Swagger UI, atualize a configuração para incluir esquemas de autenticação:




		
		
			
			
Java
			
			@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .addSecurityItem(new SecurityRequirement().addList("JWT"))
            .components(new Components().addSecuritySchemes("JWT",
                    new SecurityScheme().name("JWT").type(SecurityScheme.Type.HTTP)
                            .scheme("bearer").bearerFormat("JWT")))
            .info(new Info().title("Secure API").version("1.0"));
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .addSecurityItem(new SecurityRequirement().addList("JWT"))
            .components(new Components().addSecuritySchemes("JWT",
                    new SecurityScheme().name("JWT").type(SecurityScheme.Type.HTTP)
                            .scheme("bearer").bearerFormat("JWT")))
            .info(new Info().title("Secure API").version("1.0"));
}
					
				
			
		


Explicação:

SecurityRequirement: Define a exigência de segurança para a API.
SecurityScheme: Especifica o tipo de segurança (JWT neste caso).


Implementando Segurança em Aplicações Spring
Visão Geral do Spring Security
Spring Security é um framework de autenticação e controle de acesso poderoso e altamente personalizável. Ele fornece serviços de segurança abrangentes para aplicações baseadas em Spring, incluindo:

Autenticação e autorização
Proteção contra vulnerabilidades comuns
Integração com vários mecanismos de autenticação (e.g., JWT, OAuth2)

Configurando o Servidor de Recursos OAuth2
Para configurar um Servidor de Recursos OAuth2 com Spring Security:

Adicionar Dependência OAuth2





		
		
			
			
Java
			
			&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-oauth2-resource-server&lt;/artifactId&gt;
&lt;/dependency&gt;
			
				
					
				
					1
2
3
4
				
						&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-oauth2-resource-server&lt;/artifactId&gt;
&lt;/dependency&gt;
					
				
			
		



Configurar Configurações de Segurança





		
		
			
			
Java
			
			@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/public/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .oauth2ResourceServer().jwt();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/public/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .oauth2ResourceServer().jwt();
    }
}
					
				
			
		


Comentários no Código:

csrf().disable(): Desativa a proteção CSRF (use com cautela).
authorizeRequests(): Configura a autorização baseada em URL.
oauth2ResourceServer().jwt(): Habilita autenticação baseada em JWT.

Autenticação e Autorização JWT
JSON Web Tokens (JWT) são uma maneira compacta e auto-contida de transmitir informações de forma segura entre as partes. Implementar JWT no Spring envolve:

Gerando JWTs





		
		
			
			
Java
			
			public String generateToken(Authentication authentication) {
    UserDetails userDetails = (UserDetails) authentication.getPrincipal();
    return Jwts.builder()
            .setSubject(userDetails.getUsername())
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + 86400000)) // 1 dia
            .signWith(SignatureAlgorithm.HS512, "secretKey")
            .compact();
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						public String generateToken(Authentication authentication) {
    UserDetails userDetails = (UserDetails) authentication.getPrincipal();
    return Jwts.builder()
            .setSubject(userDetails.getUsername())
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + 86400000)) // 1 dia
            .signWith(SignatureAlgorithm.HS512, "secretKey")
            .compact();
}
					
				
			
		


Explicação:

setSubject: Define o nome de usuário como o sujeito do token.
setExpiration: Define a duração de validade do token.
signWith: Assina o token usando o algoritmo e a chave secreta especificados.


Validando JWTs





		
		
			
			
Java
			
			public boolean validateToken(String token) {
    try {
        Jwts.parser().setSigningKey("secretKey").parseClaimsJws(token);
        return true;
    } catch (JwtException | IllegalArgumentException e) {
        // Token inválido
    }
    return false;
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						public boolean validateToken(String token) {
    try {
        Jwts.parser().setSigningKey("secretKey").parseClaimsJws(token);
        return true;
    } catch (JwtException | IllegalArgumentException e) {
        // Token inválido
    }
    return false;
}
					
				
			
		


Explicação：

Analisa e valida o token usando a chave secreta.
Retorna true se válido; caso contrário, false.

Código de Programa de Exemplo
Abaixo está um exemplo completo que demonstra a autenticação JWT em uma aplicação Spring:




		
		
			
			
Java
			
			// JwtAuthenticationFilter.java
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import io.jsonwebtoken.*;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private String secretKey = "secretKey";

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String token = getJwtFromRequest(request);

        if (StringUtils.hasText(token) && validateToken(token)) {
            String username = getUsernameFromJWT(token);

            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                    username, null, new ArrayList<>());
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

            SecurityContextHolder.getContext().setAuthentication(authentication);
        }

        filterChain.doFilter(request, response);
    }

    private String getJwtFromRequest(HttpServletRequest request) {
        String bearer = request.getHeader("Authorization");
        if (StringUtils.hasText(bearer) && bearer.startsWith("Bearer ")) {
            return bearer.substring(7);
        }
        return null;
    }

    private boolean validateToken(String authToken) {
        try {
            Jwts.parser().setSigningKey(secretKey).parseClaimsJws(authToken);
            return true;
        } catch (JwtException ex) {
            // Token inválido
        }
        return false;
    }

    private String getUsernameFromJWT(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(token)
                .getBody();

        return claims.getSubject();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
				
						// JwtAuthenticationFilter.java
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import io.jsonwebtoken.*;
 
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
 
public class JwtAuthenticationFilter extends OncePerRequestFilter {
 
    private String secretKey = "secretKey";
 
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String token = getJwtFromRequest(request);
 
        if (StringUtils.hasText(token) && validateToken(token)) {
            String username = getUsernameFromJWT(token);
 
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                    username, null, new ArrayList<>());
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
 
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
 
        filterChain.doFilter(request, response);
    }
 
    private String getJwtFromRequest(HttpServletRequest request) {
        String bearer = request.getHeader("Authorization");
        if (StringUtils.hasText(bearer) && bearer.startsWith("Bearer ")) {
            return bearer.substring(7);
        }
        return null;
    }
 
    private boolean validateToken(String authToken) {
        try {
            Jwts.parser().setSigningKey(secretKey).parseClaimsJws(authToken);
            return true;
        } catch (JwtException ex) {
            // Token inválido
        }
        return false;
    }
 
    private String getUsernameFromJWT(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(token)
                .getBody();
 
        return claims.getSubject();
    }
}
					
				
			
		


Explicação do Código：

Característica	Prós	Contras
Swagger UI	Documentação de API interativa, fácil teste	Requer manutenção para precisão
Spring Security	Recursos de segurança robustos, altamente personalizável	Curva de aprendizado mais íngreme
Benefícios da Integração	Segurança aprimorada, melhor experiência do desenvolvedor	Sobrecarrega com configurações adicionais

JwtAuthenticationFilter: Extende OncePerRequestFilter para garantir uma única execução por solicitação.

getJwtFromRequest: Extrai o JWT do cabeçalho Authorization.


validateToken: Valida o JWT usando a chave secreta.
getUsernameFromJWT: Recupera o nome de usuário das reivindicações JWT.
Authentication Setup: Se o token for válido, configura a autenticação no contexto de segurança.


Exemplo de Saída：

Quando um JWT válido é fornecido no cabeçalho Authorization, o usuário é autenticado e o acesso aos endpoints protegidos é concedido. Se o JWT for inválido ou estiver ausente, o acesso será negado.



Integrando o Swagger UI com Spring Security
Protegendo Endpoints do Swagger
Para proteger os endpoints do Swagger UI enquanto permite o acesso necessário:

Atualizar Configuração de Segurança

Modifique o SecurityConfig para permitir acesso aos recursos do Swagger:






		
		
			
			
Java
			
			@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .csrf().disable()
        .authorizeRequests()
        .antMatchers(
            "/swagger-resources/**",
            "/swagger-ui/**",
            "/v3/api-docs/**",
            "/public/**"
        ).permitAll()
        .anyRequest().authenticated()
        .and()
        .oauth2ResourceServer().jwt();
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .csrf().disable()
        .authorizeRequests()
        .antMatchers(
            "/swagger-resources/**",
            "/swagger-ui/**",
            "/v3/api-docs/**",
            "/public/**"
        ).permitAll()
        .anyRequest().authenticated()
        .and()
        .oauth2ResourceServer().jwt();
}
					
				
			
		


Explicação:

antMatchers: Especifica URLs para permitir sem autenticação.
/swagger-resources/**, /swagger-ui/**, /v3/api-docs/**: Endpoints essenciais do Swagger.

Implementação Prática
Vamos implementar a integração passo a passo:

Adicionar Dependências





		
		
			
			
Java
			
			&lt;!-- Spring Security e OAuth2 --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
&lt;/dependency&gt;
&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-oauth2-resource-server&lt;/artifactId&gt;
&lt;/dependency&gt;

&lt;!-- Swagger --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;io.springfox&lt;/groupId&gt;
    &lt;artifactId&gt;springfox-boot-starter&lt;/artifactId&gt;
    &lt;version&gt;3.0.0&lt;/version&gt;
&lt;/dependency&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						&lt;!-- Spring Security e OAuth2 --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
&lt;/dependency&gt;
&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-oauth2-resource-server&lt;/artifactId&gt;
&lt;/dependency&gt;
 
&lt;!-- Swagger --&gt;
&lt;dependency&gt;
    &lt;groupId&gt;io.springfox&lt;/groupId&gt;
    &lt;artifactId&gt;springfox-boot-starter&lt;/artifactId&gt;
    &lt;version&gt;3.0.0&lt;/version&gt;
&lt;/dependency&gt;
					
				
			
		



Configurar Swagger com Segurança





		
		
			
			
Java
			
			@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .addSecurityItem(new SecurityRequirement().addList("JWT"))
            .components(new Components().addSecuritySchemes("JWT",
                    new SecurityScheme().name("JWT").type(SecurityScheme.Type.HTTP)
                            .scheme("bearer").bearerFormat("JWT")))
            .info(new Info().title("Secure API").version("1.0"));
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .addSecurityItem(new SecurityRequirement().addList("JWT"))
            .components(new Components().addSecuritySchemes("JWT",
                    new SecurityScheme().name("JWT").type(SecurityScheme.Type.HTTP)
                            .scheme("bearer").bearerFormat("JWT")))
            .info(new Info().title("Secure API").version("1.0"));
}
					
				
			
		



Implementar Filtro de Autenticação JWT

Como mostrado na seção anterior, implemente JwtAuthenticationFilter e registre-o na configuração de segurança.



Testar a Configuração


Acessar Endpoint Público: Deve ser acessível sem autenticação.
Acessar Endpoint Protegido: Exige um JWT válido.
Acessar Swagger UI: Acessível sem autenticação, se configurado adequadamente.

Exemplo de Interação:

Chamada API Pública





		
		
			
			
Java
			
			GET /public/hello
			
				
					
				
					1
				
						GET /public/hello
					
				
			
		


Resposta:




		
		
			
			
Java
			
			{
    "message": "Hello, World!"
}
			
				
					
				
					1
2
3
				
						{
    "message": "Hello, World!"
}
					
				
			
		



Chamada API Protegida sem JWT





		
		
			
			
Java
			
			GET /api/secure-data
			
				
					
				
					1
				
						GET /api/secure-data
					
				
			
		


Resposta:




		
		
			
			
Java
			
			{
    "error": "Unauthorized"
}
			
				
					
				
					1
2
3
				
						{
    "error": "Unauthorized"
}
					
				
			
		



Chamada API Protegida com JWT Válido





		
		
			
			
Java
			
			GET /api/secure-data
Authorization: Bearer <valid_jwt>
			
				
					
				
					1
2
				
						GET /api/secure-data
Authorization: Bearer <valid_jwt>
					
				
			
		


Resposta:




		
		
			
			
Java
			
			{
    "data": "Secure Information"
}
			
				
					
				
					1
2
3
				
						{
    "data": "Secure Information"
}
					
				
			
		



Conclusão
Integrar Swagger UI com Spring Security em aplicações Spring aprimora tanto a documentação quanto a segurança das suas APIs. Ao seguir os passos descritos neste guia, desenvolvedores podem criar APIs bem documentadas e seguras que são amigáveis para o usuário e robustas contra acessos não autorizados.
Principais Conclusões

Swagger UI simplifica a documentação e o teste de APIs, melhorando a experiência do desenvolvedor.
Spring Security oferece ferramentas abrangentes para proteger aplicações, com suporte para JWT e OAuth2.
A integração adequada garante que os endpoints do Swagger estejam protegidos enquanto permanecem acessíveis para usuários autorizados.

Implementar essas ferramentas de forma eficaz pode simplificar significativamente seu processo de desenvolvimento de API, garantindo que suas aplicações sejam transparentes e seguras.
Palavras-chave de SEO: Spring Boot, Swagger UI, Spring Security, JWT Authentication, OAuth2, API Documentation, Secure APIs, Spring Boot Security Configuration, JSON Web Token, API Development

Recursos

Spring Boot Documentation
Swagger UI Official Site
Spring Security Reference
OAuth2 Overview
JSON Web Tokens (JWT) Introduction
Springfox GitHub Repository


Note: This article is AI-generated.

html


Integrando Swagger UI y Seguridad en Aplicaciones Spring: Una Guía Completa
Autor: [Your Name]

Publicado: Octubre 2023

Tabla de Contenidos

Introducción .............................................................. 1
Comprendiendo Swagger UI ............................................. 3

¿Qué es Swagger UI? .................................................. 3
Configurando Swagger UI en Spring .................................. 4
Personalizando Swagger UI ................................................. 5


Implementando Seguridad en Aplicaciones Spring ................. 7

Visión General de Spring Security ......................................... 7
Configurando el Servidor de Recursos OAuth2 ................................. 8
Autenticación y Autorización JWT ........................... 10


Integrando Swagger UI con Spring Security ................. 13

Protegiendo Endpoints de Swagger ......................................... 13
Implementación Práctica ................................................ 14


Conclusión ................................................................. 17
Recursos ................................................................. 18


Introducción
En el panorama en constante evolución del desarrollo web, construir APIs seguras y bien documentadas es fundamental. Spring Boot, un framework ampliamente utilizado, ofrece características robustas para agilizar este proceso. Dos herramientas esenciales en este ecosistema son Swagger UI para la documentación de APIs y Spring Security para proteger tu aplicación.
Este eBook profundiza en la integración de Swagger UI con Spring Security, proporcionando una guía completa para principiantes y desarrolladores con conocimientos básicos. Exploraremos la configuración, personalización y las configuraciones de seguridad necesarias para crear un entorno de API fluido y seguro.
¿Por qué integrar Swagger UI y Spring Security?

Swagger UI ofrece documentación interactiva, permitiendo a los desarrolladores visualizar y probar endpoints de APIs sin esfuerzo.
Spring Security proporciona un marco de autenticación y autorización poderoso y personalizable, asegurando que las APIs estén protegidas contra accesos no autorizados.

Pros y Contras
Englishहिन्दी
Español
中文 (中国)
Português
한국어


Recent Posts


S03L14 – Soma dos dígitos – Exercício
S03L13 – Laços aninhados em Java
S03L12 – Para cada em Java
S03L11 – Break e Continue em Java
S03L10 – Laços Revisitados



Categories


	Hibernate Articles (pt)

	Java Articles (pt)

	JavaScript Articles (pt)

	JSP & Servlets Articles (pt)

	react-framework (pt)

	Restful API Overview Articles (pt)

	Spring Articles (pt)

	Spring Boot Articles (pt)

	Spring Boot RESTFUL API Articles (pt)





	© 2025 - StudyEasy.org



	StudyEasy On Udemy
Privacy Policy
Terms Of Service
Refund Policy
About
support