Computer Science Knowledge Storage

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁

스프링부트와 리액트를 활용해 로그인을 구현 프로젝트를 진행합니다. 순서는
1. 프로젝트 초기화
2. 쿠키를 이용한 로그인 구현
3. 세션을 이용한 로그인 구현
4. JWT 토큰을 활용한 로그인 구현
입니다. 

네번째는 Security + JWT Token 로그인 구현입니다.

JwtProvider

Spring Security에서 JWT를 생성, 검증, 토큰 해석을 하는 클래스 입니다.

사용자 로그인이 완료되면 JWT 토큰을 생성하거나 인증정보를 확인합니다.

생성자

public JwtProvider(@Value("${hiro.jwtSecret}") String jwtSecret,
                   @Value("${hiro.jwtAccessExpiration}") int jwtAccessExpiration,
                   @Value("${hiro.jwtRefreshExpiration}") int jwtRefreshExpiration
) {
    this.jwtSecret = jwtSecret;
    this.jwtAccessExpiration = jwtAccessExpiration;
    this.jwtRefreshExpiration = jwtRefreshExpiration;

    this.key = Keys.hmacShaKeyFor(this.jwtSecret.getBytes());
}

• @Value 어노테이션을 통해 설정 파일(application.properties 또는 application.yml)에 저장된 JWT 관련 설정 값을 주입합니다.
  • hiro.jwtSecret → JWT 서명을 위한 비밀키
  • hiro.jwtAccessExpiration → 액세스 토큰 만료 시간(ms)
  • hiro.jwtRefreshExpiration → 리프레시 토큰 만료 시간(ms)
  • 해당 값들은 노출되면 안되기에 환경변수로 저장하는 것이 안전합니다.
• HMAC SHA 알고리즘을 사용하여 JWT 서명에 사용할 키를 생성

generateJwtToken

public String generateJwtToken(Authentication authentication) {
    String roles = authentication.getAuthorities().stream()
            .map(GrantedAuthority::getAuthority)
            .collect(Collectors.joining(","));

    return Jwts.builder()
            .setSubject(authentication.getName())  // JWT의 subject 설정 (사용자명)
            .claim("role", roles)                  // 사용자의 역할(권한) 저장
            .setIssuedAt(new Date())               // 발급 시간
            .setExpiration(new Date((new Date()).getTime() + jwtAccessExpiration)) // 만료 시간 설정
            .signWith(key, SignatureAlgorithm.HS256) // 서명 알고리즘 사용
            .compact();
}

Jwts 클래스는 Java에서 JWT를 생성하고 파싱하는데 사용하는 JJWT의 클래스입니다.

빌더 패턴을 이용하여 토큰을 생성하고 토큰을 검증하고 해석할 때에는 Jwts.parserBuilder()를 이용합니다.

JWT 구조

header.payload.signature

• Header
  • 사용화 알고리즘과 토큰 유형
• Payload(Claims)
  • sub (Subject): 토큰을 발급받은 사용자 ID
  • role: 사용자의 역할 정보 (ex: ROLE_USER, ROLE_ADMIN)
  • iat (Issued At): 토큰 발급 시간 (Unix Timestamp)
  • exp (Expiration): 토큰 만료 시간 (Unix Timestamp)
• Signature(서명)
  • 서명(Signature)은 JWT의 무결성을 보장하기 위해 사용됩니다.

주요 필드 설명

• authentication.getAuthorities() → 사용자의 권한(ROLE_USER, ROLE_ADMIN 등)을 가져옴.
• setSubject(authentication.getName()) → JWT의 subject(보통 사용자 ID/username) 설정.
• claim("role", roles) → 사용자 역할 정보를 JWT의 Claims에 추가.
• setExpiration(...) → 액세스 토큰의 만료 시간을 설정.
• signWith(key, SignatureAlgorithm.HS256) → HMAC SHA256 알고리즘을 사용하여 JWT 서명.

getAuthentication

public Authentication getAuthentication(String token) {
    try {
        Claims claims = Jwts.parserBuilder()
                .setSigningKey(key)
                .build()
                .parseClaimsJws(token)
                .getBody();

        Collection<? extends GrantedAuthority> authorities = Arrays.stream(claims.get("role").toString().split(","))
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());

        return new UsernamePasswordAuthenticationToken(claims.getSubject(), token, authorities);
    } catch (MalformedJwtException e) {
        log.error("Invalid JWT token: {}", e.getMessage());
    } catch (ExpiredJwtException e) {
        log.error("JWT token is expired: {}", e.getMessage());
    } catch (UnsupportedJwtException e) {
        log.error("JWT token is unsupported: {}", e.getMessage());
    } catch (IllegalArgumentException e) {
        log.error("JWT claims string is empty: {}", e.getMessage());
    }

    return null;
}

• Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token).getBody()
  → JWT를 파싱하여 Claims(토큰의 정보)를 추출.
• claims.get("role").toString().split(",")
  → JWT에 저장된 사용자 권한(role)을 가져와서 리스트로 변환.
• new UsernamePasswordAuthenticationToken(claims.getSubject(), token, authorities);
  → JWT에서 가져온 사용자 정보를 기반으로 Authentication 객체 생성.
  -> UsernamePasswordAuthenticationToken은 Authentication 객체의 구현체

validateToken

public boolean validateToken(String token) {
    try {
        Jwts.parserBuilder()
                .setSigningKey(key)
                .build()
                .parseClaimsJws(token);
        return true;
    } catch (SecurityException | MalformedJwtException e) {
        log.info("Invalid JWT Token", e);
    } catch (ExpiredJwtException e) {
        log.info("Expired JWT Token", e);
    } catch (UnsupportedJwtException e) {
        log.info("Unsupported JWT Token", e);
    } catch (IllegalArgumentException e) {
        log.info("JWT claims string is empty.", e);
    }
    return false;
}

• parseClaimsJws(token)을 호출하여 토큰이 유효한지 검사.
• 예외 처리:
  • SecurityException | MalformedJwtException: 토큰이 변조되었거나 잘못된 형식인 경우.
  • ExpiredJwtException: 토큰이 만료된 경우.
  • UnsupportedJwtException: 지원되지 않는 JWT 형식.
  • IllegalArgumentException: 토큰이 비어있거나 유효하지 않은 경우.

JwtFilter

@Component
public class JwtFilter extends OncePerRequestFilter {

    private final JwtProvider jwtProvider;

    public JwtFilter(JwtProvider jwtProvider) {
        this.jwtProvider = jwtProvider;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String authHeader = request.getHeader("Authorization");

        if (authHeader == null) {
            filterChain.doFilter(request, response);
        } else {
            String jwtToken = authHeader.split(" ")[1];
            if (jwtProvider.validateToken(jwtToken)) {
                Authentication authentication = jwtProvider.getAuthentication(jwtToken);
                SecurityContextHolder.getContext().setAuthentication(authentication);
                filterChain.doFilter(request, response);
            }
        }
    }
}

OncePerRequestFilter

oncePerRequestFilter는 Spring Security에서 제공되는 필터로 HTTP 요청마다 단 한번만 실행되는 필터를 구현할 때 사용됩니다.
(여러번 실행되지 않도록 보장)

따라서 JWT 검증하는 filter로 적절합니다.(요청 때 한번만 검증)

• HttpServletRequest에서 Header("Authorization")을 확인
  • 클라이언트가 보낸 HTTP 요청에서 Authorization 헤더를 가져옵니다.
  • JWT는 일반적으로 "Bearer <토큰값>" 형식으로 전달됩니다.
• authHeader == null
  • 다음 필터로 넘김.
  • 로그인, 회원가입, 공개 API 요청 등
• else => 토큰 값 읽어오기
  • Bearer <토큰값> 형식에서 공백(" ")을 기준으로 split하여 토큰만 추출.
  • authHeader.split(" ")[0] → "Bearer"
  • authHeader.split(" ")[1] → "<토큰값>"
• jwtProvider로 validateToken()를 통해 Token을 검증
  • 유효하지 않으면(만료됨, 변조됨 등) 인증을 진행하지 않고 요청을 그대로 통과.
• 인증 객체 생성 및 설정
  • jwtProvider.getAuthentication(jwtToken)을 호출하여 JWT에서 사용자 정보를 추출하고 Authentication 객체를 생성.
  • SecurityContextHolder.getContext().setAuthentication(authentication);
    → Spring Security의 SecurityContext에 인증 객체를 저장하여 이후 요청에서 인증된 사용자로 처리.

SecurityConfig

SecurityConfig는 Security의 보안 설정을 구성하는 역할을 합니다.

사용자의 권한에 따라서 API 접근 권한을 설정할 수 있고(RBAC) HttpMethod에 따라서도 설정이 가능합니다.

해당 클래스를 위해서는 @EnableWebSecurity 어노테이션이 필요합니다

@EnableWebSecurity

Spring Security를 활성화하고, 보안 구성을 정의할 수 있도록 해주는 어노테이션입니다.

• Spring Security의 기본 보안 설정을 비활성화하고, 개발자가 직접 설정을 정의할 수 있도록 함.
• SecurityFilterChain을 통해 보안 규칙을 커스터마이징할 수 있도록 해줌.

PasswordEncoder

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

PasswordEncoder는 Spring Security에서 비밀번호를 안전하게 암호화하고, 검증하는 인터페이스입니다.

비밀번호를 평문(Plain Text)으로 저장하는 것은 보안적으로 위험하기 때문에, 해싱(Hashing) 알고리즘을 사용하여 비밀번호를 암호화하고, 로그인 시 입력된 비밀번호와 저장된 해시 값을 비교하여 검증하는 역할을 합니다.

• BCryptPasswordEncoder는 BCrypt 알고리즘을 사용하여 비밀번호를 안전하게 암호화합니다.
• @Bean을 사용하여 Spring 컨텍스트에서 PasswordEncoder 빈으로 관리하도록 설정함.

BCryptPasswordEncoder의 특징

• Salt를 자동으로 추가하여 해싱
  • 동일한 비밀번호라도 해싱 결과가 항상 다르게 생성됨 → Rainbow Table 공격 방어 가능
• 반복 연산(Work Factor) 조절 가능
  • 기본적으로 10번의 해싱 작업 수행 (BCryptPasswordEncoder(10))
  • 연산 횟수를 증가시켜 보안성을 강화할 수 있음
• 비밀번호 검증 기능 제공
  • matches(rawPassword, encodedPassword): 입력된 비밀번호와 암호화된 비밀번호 비교

AuthenticationManager

@Bean
public AuthenticationManager authenticationManager(
        AuthenticationConfiguration authConfig) throws Exception {
    return authConfig.getAuthenticationManager();
}

AuthenticationManager는 Spring Security에서 인증(Authentication) 요청을 처리하는 핵심 인터페이스입니다.

• 사용자의 로그인 요청을 받아 인증을 수행하고, 결과를 반환하는 역할을 합니다.
• 인증 과정에서 UserDetailsService를 이용해 사용자 정보를 조회하고, 비밀번호를 검증하는 등의 작업을 수행합니다.
• 해당 AuthenticationManager가 CustomDetailsService()를 호출하게 됩니다.

1. Spring Security의 AuthenticationManager 빈을 생성하는 역할
2. AuthenticationConfiguration을 통해 Spring Security의 기본 인증 설정을 가져와 AuthenticationManager를 반환
   1. Spring Security에서 AuthenticationManager의 기본 구현체는 DaoAuthenticationProvider 입니다.
   2. 따라서 여기서는 Spring Security가 자동으로 생성한 ProviderManager 인스턴스를 반환합니다.

SecurityFilterChain

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
            .csrf(AbstractHttpConfigurer::disable)
            .headers(headersConfigurer -> headersConfigurer.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable))
            .formLogin(AbstractHttpConfigurer::disable)
            .httpBasic(AbstractHttpConfigurer::disable)
            .sessionManagement((sessionManagement) ->
                    sessionManagement.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> {
                auth.requestMatchers(permitAllUrl).permitAll();
                auth.requestMatchers(permitAdminUrl).hasRole("ADMIN");
                auth.anyRequest().authenticated();
            })
            .addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class)
            .addFilter(webConfig.corsFilter())
            .build();
}

해당 메소드는 Spring Security의 SecurityFilterChain을 구성하여 애플리케이션의 보안 규칙을 설정합니다.

• CSRF 보호 비활성화 (csrf().disable())
  • REST API는 주로 JWT를 사용하여 상태(State) 없이 인증을 수행하므로 CSRF 보호가 필요 없음
  • CSRF는 세션 기반 인증에서 주로 필요하지만, JWT 인증을 사용할 경우 불필요
• X-Frame-Options 비활성화 (frameOptions().disable())
  
  • H2 데이터베이스 콘솔 같은 프레임 기반 UI를 허용하기 위해 설정
• 폼 로그인 비활성화 (formLogin().disable())
  
  • JWT 기반 인증을 사용하기 때문에 기본 로그인 폼을 사용하지 않도록 설정
• HTTP Basic 인증 비활성화 (httpBasic().disable())
  • HTTP Basic 인증(아이디 & 비밀번호를 요청 헤더에 포함하여 전송하는 방식)을 비활성화
  • JWT 인증 방식을 사용할 것이므로 필요 없음
• SessionCreationPolicy.STATELESS
  • 세션을 사용하지 않는 Stateless 인증 방식 적용
  • SessionCreationPolicy.STATELESS → Spring Security가 세션을 생성하거나 저장하지 않도록 설정
• authorizeHttpRequest -> HTTP 요청에 대한 권한 설정
  • requestMatchers(permitAllUrl).permitAll();
    → 특정 URL(로그인, 회원가입, Swagger 등)은 인증 없이 접근 허용
  • requestMatchers(permitAdminUrl).hasRole("ADMIN");
    → 관리자 페이지(예: /status/admin)는 "ADMIN" 역할이 있는 사용자만 접근 가능
  • anyRequest().authenticated();
    → 그 외 모든 요청은 인증이 필요함
• JWT Filter 및 CORS 필터 추가
  • addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class)
    → JWT 필터(JwtFilter)를 UsernamePasswordAuthenticationFilter 앞에 추가
    • Spring Security의 기본 로그인 방식(폼 로그인, 세션 로그인 등)보다 먼저 JWT를 확인하도록 설정
  • .addFilter(webConfig.corsFilter())
    → CORS 필터 추가

UserDetails

@RequiredArgsConstructor
public class UserDetailsImpl implements UserDetails {

    @Getter
    private final Long id;
    private final String username;
    private final String password;
    private final Collection<? extends GrantedAuthority> authorities;

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return authorities;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    public static UserDetailsImpl build(Member member) {
        List<GrantedAuthority> authorities = member.getRoles().stream()
                .map(role -> new SimpleGrantedAuthority("ROLE_" + role.name()))
                .collect(Collectors.toList());

        return new UserDetailsImpl(
                member.getId(),
                member.getUsername(),
                member.getPassword(),
                authorities
        );
    }
}

커스텀한 UserDetails 클래스를 생성합니다.

UserDetailsImpl이 필요한 이유

• Spring Security는 UserDetailsService를 통해 사용자 정보를 불러오며,
  이때 UserDetails를 구현한 클래스(UserDetailsImpl)가 필요
• UserDetailsImpl은 Spring Security에서 인증된 사용자의 정보를 저장하는 역할을 함.

UserDetailsService

@Service
@RequiredArgsConstructor
public class UserDetailsServiceImpl implements UserDetailsService {

    private final MemberRepository memberRepository;

    @Override
    @Transactional
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Member member = memberRepository.findByUsername(username);

        return UserDetailsImpl.build(member);
    }
}

UserDetailsService는 Spring Security의 UserDetailsService 인터페이스를 구현한 클래스로,
Spring Security가 로그인 요청을 처리할 때 사용자 정보를 불러오는 역할을 합니다.

• Spring Security가 로그인 요청을 받을 때 자동으로 실행되는 메서드
  • 해당 메소드는 AuthenticationManager가 로그인 요청을할 때 UserDetailsService를 호출합니다.
• username을 이용해 DB에서 사용자 정보를 조회 (memberRepository.findByUsername(username))
• 조회된 Member 엔티티를 Spring Security에서 사용할 수 있도록 UserDetailsImpl로 변환
  • UserDetailsService를 구현해야 Spring Security가 사용자 인증을 수행할 수 있습니다.

AuthService

public JwtResponse loginMember(String username, String password) {
    if (!repository.existsByUsername(username)) {
        throw new RuntimeErrorException(new Error("not Found Member"));
    }
    log.info("login Member");

    final Authentication authentication = authenticationManager.authenticate(
            new UsernamePasswordAuthenticationToken(username, password)
    );

    final String jwtAccessToken = jwtProvider.generateJwtToken(authentication);
    final String jwtRefreshToken = null;

    final UserDetailsImpl userDetails = (UserDetailsImpl) authentication.getPrincipal();
    List<String> roles = userDetails.getAuthorities().stream()
            .map(GrantedAuthority::getAuthority).toList();

    return new JwtResponse(jwtAccessToken, jwtRefreshToken, userDetails.getUsername(), roles);
}

로그인 화면

다음와 같이 정상 동작하는 것을 확인할 수 있습니다.

프론트에서는 다음에 헤더에 accessToken을 추가하면 Security가 설정된 프로젝트와 통신을 할 수 있습니다.

깃허브 및 참조

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁

스프링 정리를 위한 포스팅입니다.
해당 포스팅은 Swagger 정리입니다.

서론

Swagger는 RESTful API를 웹 단에서 설계, 빌드, 문서화, 테스트하는데 사용하는 도구입니다.
이를 통해서 프론트엔드 개발자와 백엔드 개발자가 효율적으로 협업을 진행할 수 있고, 문서화에도 도움을 줍니다.

Spring Boot와 함께 Swagger를 적용하면 백엔드 개발자는 API 문서를 자동으로 생성하고 팀 간 협업 및 테스트를 효율적으로 진행할 수 있습니다.

해당 포스팅에서는 Swagger와 OpenAPI의 개념, Spring Boot 프로젝트에서 Swagger를 설정하는 방법 등을 소개합니다.

Swagger

Swagger란 무엇인가?

Swagger는 REST API를 문서화하고, API 설계와 구현을 더 쉽게 하기 위해 제공되는 도구입니다.
현재는 OpenAPI Initiative의 표준으로 자리 잡았으며, OpenAPI 스펙 기반으로 API 문서를 자동 생성합니다.

Swagger의 주요 기능

• API 문서화: REST API의 모든 엔드포인트, 메서드, 요청/응답 형식 등을 정리
• Swagger UI 제공: API 테스트와 시뮬레이션을 위한 사용자 인터페이스
• 클라이언트 코드 생성: OpenAPI 스펙을 기반으로 클라이언트 SDK 생성

Spring Boot에서 Swagger 설정하기

1. 의존성 추가

Swagger와 OpenAPI를 사용하려면 Spring Boot 프로젝트의 build.gradle 또는 pom.xml에 의존성을 추가해야 합니다.

Gradle 예시

// Swagger
implementation group: 'org.springdoc', name: 'springdoc-openapi-starter-webmvc-ui', version: '2.6.0'

1. 기본 설정

Spring Boot에서는 별도의 설정 없이도 swagger-ui와 OpenAPI 문서를 사용할 수 있습니다.
SpringDoc 라이브러리를 추가하면 /swagger-ui.html 또는 /swagger-ui/index.html 경로에서 Swagger UI에 접근할 수 있습니다.

1. SwaggerConfig 설정

SwaggerConfig 클래스는 OpenAPI 문서의 기본적인 설정을 커스터마이징할 수 있도록 작성됩니다.
Spring Boot와 SpringDoc을 사용하면 Swagger UI와 OpenAPI 문서를 별도의 설정 없이 기본적으로 사용할 수 있지만, 프로젝트 이름, API 설명, 버전 정보 등을 명확히 하기 위해 SwaggerConfig 클래스에서 OpenAPI 객체를 설정할 수 있습니다.

@Configuration
public class SwaggerConfig {
    @Bean
    public OpenAPI openAPI() {
        return new OpenAPI()
                .info(new Info().title("Hiro Backend")
                        .description("Hiro Backend 서버")
                        .version("v0.0.1"));
    }
}

@Bean
public OpenAPI openAPI() {
    SecurityScheme securityScheme = new SecurityScheme()
            .type(SecurityScheme.Type.HTTP)
            .scheme("bearer")
            .bearerFormat("JWT")
            .in(SecurityScheme.In.HEADER)
            .name("Authorization");

    SecurityRequirement securityItem = new SecurityRequirement().addList("bearerAuth");

    return new OpenAPI()
            .openapi("3.0.1")  // OpenAPI 버전 명시
            .components(new Components().addSecuritySchemes("bearerAuth", securityScheme))
            .security(List.of(securityItem))
            .info(apiInfo());
}

@Configuration
public class SwaggerConfig {

    @Bean
    public GroupedOpenApi userApi() {
        return GroupedOpenApi.builder()
                .group("user-api") // 사용자 관련 API 그룹
                .pathsToMatch("/users/**", "/profile/**")
                .build();
    }

    @Bean
    public GroupedOpenApi adminApi() {
        return GroupedOpenApi.builder()
                .group("admin-api") // 관리자 관련 API 그룹
                .pathsToMatch("/admin/**", "/management/**")
                .build();
    }

    @Bean
    public GroupedOpenApi publicApi() {
        return GroupedOpenApi.builder()
                .group("public-api") // 공개 API 그룹
                .pathsToMatch("/public/**", "/auth/**")
                .build();
    }
    /*
     * ...
     */
}

1. 컨트롤러에 Swagger 어노테이션 추가

컨트롤러에 @Tag, @Operation, @ApiResponse 등 OpenAPI 3 스펙 기반의 애노테이션을 추가하여 API 엔드포인트를 문서화할 수 있습니다.

@RestController
@RequestMapping("/api/users")
@Tag(name = "User API", description = "Operations for managing users")
public class UserController {

    @Operation(summary = "Get all users", description = "Retrieve a list of all users.")
    @GetMapping
    public List<User> getAllUsers() {
        return List.of(new User(1L, "John", "john@example.com"));
    }

    @Operation(summary = "Create a user", description = "Add a new user to the system.")
    @ApiResponse(responseCode = "201", description = "User created successfully.")
    @PostMapping
    public User createUser(@RequestBody User user) {
        return user; // For demonstration purposes
    }
}

• @Tag
  @Tag는 OpenAPI 스펙에서 API의 그룹화를 위한 어노테이션입니다.
  주로 컨트롤러 레벨에서 사용되며, Swagger UI에서 API를 그룹별로 정리해서 보여줍니다.
  • 주요속성
    • name: 태그의 이름. Swagger UI에서 그룹명으로 표시됩니다.
    • description: 태그에 대한 설명을 작성합니다.
• @Operation
  @Operation은 API 엔드포인트(메서드) 수준에서 사용됩니다.
  해당 메서드에 대한 요약, 설명, 요청/응답에 대한 정보 등을 문서화합니다.
  • 주요속성
    • summary: API 엔드포인트에 대한 간단한 설명 (Swagger UI에서 메서드 옆에 표시).
    • description: API 엔드포인트에 대한 상세 설명.
    • tags: 이 엔드포인트에 추가적으로 적용할 태그 목록. 컨트롤러에 정의된 @Tag와는 별개로 추가 가능.
    • parameters: 요청에 필요한 매개변수 정의 (필요시 사용).
    • responses: 응답에 대한 설명을 추가 (일반적으로 @ApiResponse와 함께 사용).
• @ApiResponse
  @ApiResponse는 특정 API 엔드포인트의 응답 정보를 문서화하는 데 사용됩니다.
  응답 상태 코드와 메시지, 반환되는 데이터에 대한 설명을 추가할 수 있습니다.
  • 주요속성
    • responseCode: HTTP 응답 상태 코드 (예: "200", "404", "500").
    • description: 응답에 대한 간단한 설명.
    • content: 반환되는 데이터의 형식을 정의 (JSON, XML 등).

결과

localhost:8080/swagger-ui/index.html로 접근하면 Swagger 화면이 렌더링 됩니다.

/json-users를 클릭 후 Execute를 하면

결과가 잘 나오는 것을 확인할 수 있습니다.

코드

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁
접은 글을 통해 먼저 답변을 해보시고 제가 정리한 답을 확인해보시기 바라겠습니다!!

면접 리스트

소켓이란 무엇인가요?

쿠키와 세션의 차이를 설명해주세요

세션과 JWT Token을 비교해서 설명해주세요

TCP가 어떻게 신뢰성을 보장하나요?

TCP가 어떻게 흐름제어를 구현하나요? 그리고 윈도우 사이즈는 무엇인가요?

TCP 재전송 매커니즘을 설명해보세요

TCP 혼잡제어를 어떻게 관리하나요? 네트워크 혼잡을 예방하기 위한 메커니즘은 무엇인가요?