S02L07 - OAuth का उपयोग करते हुए Spring Boot JWT वॉकथ्रू

html


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

प्रकाशित: October 2023

सामग्री तालिका

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

Swagger UI क्या है? .................................................. 3
Spring में Swagger UI सेटअप करना .................................. 4
Swagger UI को अनुकूलित करना ................................................. 5


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

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


Spring Security के साथ Swagger UI का एकीकरण ................. 13

Swagger एंडपॉइंट्स को सुरक्षित करना ......................................... 13
व्यावहारिक कार्यान्वयन ................................................ 14


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


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

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

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


विशेषता
फायदे
नुकसान


Swagger UI
Interactive API documentation, easy testing
Requires maintenance for accuracy


Spring Security
Robust security features, highly customizable
Steeper learning curve


Integration Benefits
Enhanced security, improved developer experience
Additional configuration overhead


इन उपकरणों का उपयोग कब और कहाँ करें

Swagger UI विकास के दौरान APIs को दस्तावेजीकृत करने और टेस्ट करने के लिए आदर्श है।
Spring Security किसी भी अनुप्रयोग में लागू किया जाना चाहिए जिसे प्रमाणीकरण और प्राधिकरण तंत्रों की आवश्यकता है।


Swagger UI को समझना
Swagger UI क्या है?
Swagger UI एक ओपन-सोर्स उपकरण है जो डेवलपर्स को API एंडपॉइंट्स को विज़ुअलाइज़ और इंटरैक्ट करने की अनुमति देता है। यह API के दस्तावेज़ से एक उपयोगकर्ता-अनुकूल इंटरफ़ेस जेनरेट करता है, जिससे वास्तविक समय में परीक्षण और अन्वेषण संभव होता है।
Spring में Swagger UI सेटअप करना
अपने Spring अनुप्रयोग में Swagger UI को एकीकृत करने के लिए, निम्न चरणों का पालन करें:

Swagger Dependency जोड़ें





		
		
			
			
Java
			
			<!-- pom.xml -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>
			
				
					
				
					1
2
3
4
5
6
				
						<!-- pom.xml -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>
					
				
			
		



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: निर्दिष्ट पैकेज में API एंडपॉइंट्स को स्कैन करने के लिए Swagger को कॉन्फ़िगर करता है।

Swagger UI को अनुकूलित करना
अनुकूलन आपको Swagger UI को आपके अनुप्रयोग की आवश्यकताओं के अनुसार ढालने की अनुमति देता है।

Swagger UI की उपस्थिति संशोधित करें

कॉन्फ़िगरेशन बदलकर लुक और फील को संशोधित करें:




		
		
			
			
Java
			
			@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .info(new Info().title("My API")
            .version("1.0")
            .description("customized Swagger UI के साथ API दस्तावेजीकरण"));
}
			
				
					
				
					1
2
3
4
5
6
7
				
						@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .info(new Info().title("My API")
            .version("1.0")
            .description("customized Swagger UI के साथ API दस्तावेजीकरण"));
}
					
				
			
		



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-आधारित अनुप्रयोगों के लिए व्यापक सुरक्षा सेवाएँ प्रदान करता है, जिसमें शामिल हैं:

Authentication and authorization
सामान्य कमजोरियों के खिलाफ सुरक्षा
विभिन्न प्रमाणीकरण तंत्रों (जैसे, JWT, OAuth2) के साथ एकीकरण

OAuth2 Resource Server कॉन्फ़िगर करना
Spring Security के साथ OAuth2 Resource Server सेटअप करने के लिए:

OAuth2 Dependency जोड़ें





		
		
			
			
Java
			
			<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>
			
				
					
				
					1
2
3
4
				
						<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>
					
				
			
		



Security सेटिंग्स कॉन्फ़िगर करें





		
		
			
			
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 को लागू करने में शामिल है:

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 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: निर्दिष्ट एल्गोरिदम और गुप्त कुंजी का उपयोग करके टोकन पर हस्ताक्षर करता है।


JWTs को मान्य करना





		
		
			
			
Java
			
			public boolean validateToken(String token) {
    try {
        Jwts.parser().setSigningKey("secretKey").parseClaimsJws(token);
        return true;
    } catch (JwtException | IllegalArgumentException e) {
        // Invalid token
    }
    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) {
        // Invalid token
    }
    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) {
            // Invalid token
        }
        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) {
            // Invalid token
        }
        return false;
    }
 
    private String getUsernameFromJWT(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(token)
                .getBody();
 
        return claims.getSubject();
    }
}
					
				
			
		


कोड व्याख्या:

विशेषता	फायदे	नुकसान
Swagger UI	Interactive API documentation, easy testing	Requires maintenance for accuracy
Spring Security	Robust security features, highly customizable	Steeper learning curve
Integration Benefits	Enhanced security, improved developer experience	Additional configuration overhead

JwtAuthenticationFilter: OncePerRequestFilter का विस्तार करता है यह सुनिश्चित करने के लिए कि प्रति अनुरोध केवल एक बार निष्पादन हो।

getJwtFromRequest: Authorization हेडर से JWT को निकालता है।


validateToken: गुप्त कुंजी का उपयोग करके JWT को मान्य करता है।
getUsernameFromJWT: JWT दावों से उपयोगकर्ता नाम को पुनः प्राप्त करता है।
Authentication Setup: यदि टोकन मान्य है, तो सुरक्षा संदर्भ में प्रमाणीकरण सेट करता है।


नमूना आउटपुट:

यदि Authorization हेडर में एक मान्य JWT प्रदान किया जाता है, तो उपयोगकर्ता प्रमाणीकरण किया जाता है, और सुरक्षित एंडपॉइंट्स तक पहुँच प्रदान की जाती है। यदि JWT अमान्य या गायब है, तो पहुँच अस्वीकृत कर दी जाती है।



Spring Security के साथ Swagger UI का एकीकरण
Swagger एंडपॉइंट्स को सुरक्षित करना
Swagger UI एंडपॉइंट्स को आवश्यक पहुँच प्रदान करते हुए सुरक्षित करने के लिए:

Security कॉन्फ़िगरेशन अपडेट करें

Swagger संसाधनों तक पहुँच की अनुमति देने के लिए SecurityConfig को संशोधित करें:






		
		
			
			
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 एंडपॉइंट्स।

व्यावहारिक कार्यान्वयन
आइए एकीकरण को चरण-दर-चरण लागू करें:

Dependencies जोड़ें





		
		
			
			
Java
			
			<!-- Spring Security and OAuth2 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>

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



Security के साथ 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 के साथ एकीकृत करने से आपके APIs के दस्तावेजीकरण और सुरक्षा दोनों में सुधार होता है। इस मार्गदर्शिका में वर्णित चरणों का पालन करके, डेवलपर्स अच्छी तरह से दस्तावेजीकृत, सुरक्षित APIs बना सकते हैं जो उपयोगकर्ता के अनुकूल होने के साथ-साथ अनधिकृत एक्सेस के खिलाफ मजबूत भी हैं।
मुख्य बिंदु

Swagger UI API दस्तावेजीकरण और परीक्षण को सरल बनाता है, डेवलपर अनुभव में सुधार करता है।
Spring Security अनुप्रयोगों की सुरक्षा के लिए व्यापक टूल प्रदान करता है, JWT और OAuth2 का समर्थन करते हुए।
सही एकीकरण यह सुनिश्चित करता है कि Swagger एंडपॉइंट्स सुरक्षित हैं, जबकि अधिकृत उपयोगकर्ताओं के लिए सुलभ बने रहते हैं।

Implementing these tools effectively can significantly streamline your API development process, ensuring that your applications are both transparent and secure.
इन उपकरणों को प्रभावी ढंग से लागू करने से आपके API विकास प्रक्रिया को काफी हद तक सरल बनाया जा सकता है, यह सुनिश्चित करते हुए कि आपके अनुप्रयोग पारदर्शी और सुरक्षित दोनों हैं।
SEO Keywords: Spring Boot, Swagger UI, Spring Security, JWT Authentication, OAuth2, API Documentation, Secure APIs, Spring Boot Security Configuration, JSON Web Token, API Development

संसाधन

Spring Boot दस्तावेजीकरण
Swagger UI आधिकारिक साइट
Spring Security संदर्भ
OAuth2 अवलोकन
JSON Web Tokens (JWT) परिचय
Springfox GitHub रिपॉजिटरी


नोट: यह लेख AI द्वारा उत्पन्न किया गया है।