be_better

[Springboot] Test code "csrf" 403 Forbidden

NiceTry — Tue, 9 Jan 2024 22:22:53 +0900

에러내용

Springboot 2.x버전으로 프로젝트 진행 중 3.x버전으로 변경하게 되었고 SpringSecurity도 6.x 버전으로 Upgrade를 해야하는 상황이었다.

Springboot, Security 둘다 버전업을 하고 Postman에서 정상적으로 동작하는것까지 확인했는데,

잘되던 Test Code Controller test에서 말썽이었다.

Controller Test중 Body에는 아무값도 들어있지 않고 403 Forbidden이 발생한 상황

원인

Spring Security의 어노테이션인 EnableWebSecurity에는 기본적으로 CSRF 공격을 방지하는 기능을 갖고있다.

CSRF(Cross-Site Request Forgery) 공격이란

사이트 간 요청 위조의 줄임말로

웹 애플리케이션 취약점 중 하나로 사용자가 자신의 의지와 무관하게 공격자가 의도한 행동을 해서 특정 웹페이지를 보안에 취약하게 한다거나 수정, 삭제 등의 작업을 하게 만드는 공격 방법이다.

이것을 방지하기위해 대표적으로 CSRF Token 방식이 활용되는데,

우리의 Test code에는 CSRF Token이 존재하지 않아서 접근제한을 둔것이다.

해결

정말 간단하게 mockMvc.perform uri 요청에 .with(csrf()) 코드를 추가하면 해결할 수 있다.

mockMvc.perform(post("/api/v1/sign-in")
        .contentType(MediaType.APPLICATION_JSON)
        .content(objectMapper.writeValueAsString(
            new SignInRequest("testUid", "password")
        ))
        .with(csrf()))  // 추가한 부분
    .andExpect(jsonPath("$.result.uid").value("testUid"))
    .andExpect(jsonPath("$.result.roles[0]").value("ROLE_VIEWER"))
    .andExpect(jsonPath("$.result.accessToken").value("testAccessToken"))
    .andExpect(jsonPath("$.result.refreshToken").value("testRefreshToken"))
    .andExpect(status().isOk())
    .andDo(print());

원래 비어있던 Parameters에 {_csrf=[]} 값이 생긴것을 확인할 수 있다.

[Springboot] ImmutableCollections 에러 해결

NiceTry — Wed, 3 Jan 2024 17:36:32 +0900

에러 내용

User 권한 추가 테스트 코드 작성 중 ImmutableCollections 에러가 발생했다.

나의 경우 User 권한 roles를 Set 타입으로 지정하고 관리하고 있다.

mock으로 가상의 유저를 만들어주고 권한도 지정해준다.

Set<String> roleSet = Set.of("ROLE_VIEWER");
given(userRepository.findByUidAndDeletedAtNull(anyString()))
    .willReturn(Optional.of(User.builder()
            .uid("testId")
            .roles(roleSet)
            .build()
        )
    );

원인

원인은 roleSet을 선언해줄때 new HashSet<>() 이 아닌 Set.of() 로 지정해줬기 때문이다.

Set.of()를 사용하면 불변 컬렉션으로 만들라는 의미인데, 말그대로 불변 컬렉션은 삽입, 삭제, 수정 을 할 수 없게된다.

ImmutableCollections의 내부를 살펴보면

static UnsupportedOperationException uoe() { return new UnsupportedOperationException(); }

static abstract class AbstractImmutableCollection<E> extends AbstractCollection<E> {
    // all mutating methods throw UnsupportedOperationException
    @Override public boolean add(E e) { throw uoe(); }
    @Override public boolean addAll(Collection<? extends E> c) { throw uoe(); }
    @Override public void    clear() { throw uoe(); }
    @Override public boolean remove(Object o) { throw uoe(); }
    @Override public boolean removeAll(Collection<?> c) { throw uoe(); }
    @Override public boolean removeIf(Predicate<? super E> filter) { throw uoe(); }
    @Override public boolean retainAll(Collection<?> c) { throw uoe(); }
}

add(), clear(), remove() 등 호출하면 UnsupportedOperationException() 예외를 내보내는것을 볼 수 있다.

해결

해결 방법은 간단하게 Set.of() 를 new HashSet<>() 으로 코드를 수정해주면 된다.

Set<String> roleSet = new HashSet<>(List.of("ROLE_VIEWER"));
given(userRepository.findByUidAndDeletedAtNull(anyString()))
    .willReturn(Optional.of(User.builder()
            .uid("testId")
            .roles(roleSet)
            .build()
        )
    );

[Springboot] test code mockmvc perform header에 jwt 권한 인증처리

NiceTry — Fri, 29 Dec 2023 17:58:04 +0900

프로젝트 진행중에

유저 정보를 update 하는 api를 unit 테스트 하려는데,

header 값으로 넣어줄 jwt accessToken에 대한 유저권한처리가 안돼서 발목을 잡혔다.

해결

SecurityConfig에서 SecurityContext에 유저 권한을 넣어주고 Filter에서 처리하는데

test code를 실행할때도 main module의 SecurityContext를 참조하기 때문에 유저 역할(권한) 처리가 안되는 것이라고 이해했다.

따라서 test module에서 따로 SecurityContext에 필요한 권한을 넣어줘야 한다.

나같은 경우에는 유저 정보 update api는 "USER_VIEWER" 권한을 갖는 유저만 접근할 수 있다.

매번 권한을 설정하는것보다 어노테이션을 만드는게 나아서 customAnnotation을 만들어 사용한다.

어노테이션 정의

/**
 * token 권한이 필요한 test method 에 적용하는 Annotation
 */
@Retention(RetentionPolicy.RUNTIME)
@WithSecurityContext(factory = WithCustomMockUserSecurityContextFactory.class)
public @interface WithCustomMockUser {
  String uid() default "testId";
}

어노테이션 구현

/**
 * security config 와의 의존성을 깨고 test 할때만 사용하게되는 SecurityContext 재설정 class
 */
public class WithCustomMockUserSecurityContextFactory implements
    WithSecurityContextFactory<WithCustomMockUser> {

  @Override
  public SecurityContext createSecurityContext(WithCustomMockUser annotation) {
    String uid = annotation.uid();

    Authentication auth = new UsernamePasswordAuthenticationToken(uid, "",
        List.of(new SimpleGrantedAuthority("ROLE_VIEWER")));

    SecurityContext context = SecurityContextHolder.getContext();
    context.setAuthentication(auth);

    return context;
  }
}

test코드에 적용

@Test
@WithCustomMockUser
@DisplayName("유저 정보 변경 성공")
void success_modify_user() throws Exception {

  ...(생략)
  
  mockMvc.perform(multipart(HttpMethod.PUT, "/api/v1/user/1")
          .file(image)
          .file(new MockMultipartFile("request", "", "application/json",
              valueAsString.getBytes(StandardCharsets.UTF_8)))
          .contentType(MediaType.MULTIPART_FORM_DATA)
          .accept(MediaType.APPLICATION_JSON)
          .characterEncoding("UTF-8")
          .with(csrf())
          .header("X-AUTH-TOKEN", "testAccessToken"))

      .andExpect(status().isOk())
      .andDo(print());
}

MultipartFile 인터페이스로 image를 받아야 하기 때문에 multipart("uri") 메소드 사용
HttpMethod.PUT 설정을 해주지 않으면 자동으로 POST Method가 적용된다.
필요한 header의 키값은 "X-AUTH-TOKEN"이고 value값으로 아무 토큰값을 입력해준다.
@WithCustomMockUser 어노테이션에서 SecurityContext auth에 USER_VIEWER 권한을 넣어줬기 때문에 이상없이 실행 가능

참조링크

테스트코드 Header jwt 권한 설정

[Spring Security + JWT] Spring Security Controller Unit Test하기

Unit Test로 더 작은 단위로 쪼개기 위해서 Controller, Service, Repository 계층별로 테스트를 진행해야 했습니다.하지만, Controller는 Spring Security와 JWT와 깊은 의존성을 가지고 있어 별도의 처리를 해야했

velog.io

[Springboot] Type definition error: [simple type, class java.time.LocalDateTime]; nested exception is com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Java 8 date/time type `java.time.LocalDateTime` not supported by default: add Module "co..

NiceTry — Wed, 27 Dec 2023 23:21:27 +0900

에러 내용

프로젝트 진행 중

Response Dto에 createdAt, updatedAt 을 리턴하는 코드를 구현했는데 결과값을 확인하는 과정에서 이와같은 에러가 발생했다.

그전까진 잘 작동하다가 ObjectMapper를 Bean으로 등록하고나서 생긴 오류이다.

원인

LocalDateTime type 직렬화, 역직렬화에 문제가 있어서 생기는 에러이다.

데이터를 주고받으면서 내부의 MessageConverter의 ObjectMapper가 데이터 형식을 바꾸는데

ObjectMapper를 빈으로 등록해 사용하게되니 적용이 잘 안된게 원인이라고 생각한다.

해결

첫번째 해결책

에러메세지에는

add Module "com.fasterxml.jackson.datatype:jackson-datatype-jsr310"

라는 해결책이 나와있는데 이미 자체적으로 적용되어있는 모듈이다. 따라서 gradle에 따로 build할 필요는 없다.

두번째 해결책

LocalDateTime type을 쓰는 Entity column에 어노테이션 추가

@JsonSerialize(using = LocalDateTimeSerializer.class)
@JsonDeserialize(using = LocalDateTimeDeserializer.class)

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class BaseEntity {

  // 생성일자
  @CreatedDate
  @JsonSerialize(using = LocalDateTimeSerializer.class)
  @JsonDeserialize(using = LocalDateTimeDeserializer.class)
  private LocalDateTime createdAt;

  // 정보 변경 일자
  @LastModifiedDate
  @JsonSerialize(using = LocalDateTimeSerializer.class)
  @JsonDeserialize(using = LocalDateTimeDeserializer.class)
  private LocalDateTime updatedAt;

}

나의 경우는 여기까지도 해결이 안됐다.

세번째 해결책

ObjectMapper Bean 코드 수정

@Configuration
public class ObjectMapperConfig {

  @Bean
  public ObjectMapper objectMapper() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.registerModule(new JavaTimeModule());
    return objectMapper;
  }

}

코드를 수정하고 테스트를 진행해보면 Date Format이 엉망으로 되어있는 것을 볼수있다.

각각 Year, Month, Day, ... 항목들을 디테일하게 나타낸 것인데 간략하게 보이게 하기 위해서 다음 코드를 삽입한다.

objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

@Configuration
public class ObjectMapperConfig {

  @Bean
  public ObjectMapper objectMapper() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.registerModule(new JavaTimeModule());
    // 추가된 코드
    objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    return objectMapper;
  }

}

그럼 정삭적인 결과값을 확인할 수 있게된다.

[Springboot] MultipartFile 로 이미지 업로드

NiceTry — Thu, 14 Dec 2023 12:10:55 +0900

프로젝트 진행 중

유저의 프로필 사진을 받아 AWS s3에 저장하는 기능을 구현하기 전에

로컬 디렉토리에 이미지가 저장되는지 확인하기 위해 간단하게 테스트를 진행했다.

업로드 테스트

편의를 위해 Controller 만 구현하였다.

TestController

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {

  @GetMapping("")
  public String uploadImgFile(@RequestParam(value = "image") MultipartFile image) {

    log.info("[uploadImgFileTest] file name : {}", image.getOriginalFilename());

    try {
      image.transferTo(
          new File("/Users/parktj/Documents/IntelliJ/personal/Onbition/doc/img/"
              + image.getOriginalFilename())
      );
      
    } catch (IOException e) {
      e.printStackTrace();
    }

    return image.getOriginalFilename();
  }
  
}

Postman test

postman test

Postman 에서 테스트를 하려면 Body에 form-data 에서 Key값을 file 형식으로 지정하고 반드시 key name을 써줘야 한다.

postman 에러

file working directory 에러가 뜰 경우에는 다음과 같이 해결한다.

Setting - General - Working directory에서

파일을 찾을 directory를 선택하고 Read files outside working directory를 체크한다.

정상적으로 동작

에러 없이 정상적으로 동작했다면 이미지 파일이 해당 디렉토리에 저장된것을 확인할 수 있다.

시행착오

file pathname

file pathname을 주의하자!!

file pathname을 작업중인 디렉토리가 아닌 ~(루트) 디렉토리부터 써줘야 한다.

RequestParam vs RequestPart

@GetMapping("")
public String uploadImgFile(@RequestPart MultipartFile image) {

  log.info("[uploadImgFileTest] file name : {}", image.getOriginalFilename());

  try {
    image.transferTo(
        new File("/Users/parktj/Documents/IntelliJ/personal/Onbition/doc/img/"
            + image.getOriginalFilename())
    );

  } catch (IOException e) {
    e.printStackTrace();
  }

  return image.getOriginalFilename();
}

RequestParam과 RequestPart는 혼용해서 많이 사용한다는데,,

RequestParam

RequestParam은 다른 RequestParam들과 같이 사용할 때 사용하고

example

@GetMapping("")
public String uploadImgFile(
    @RequestParam("image") MultipartFile image,
    @RequestParam("name") String name) {
    
    ... (생략)
    
}

RequestPart

RequestPart는 RequestBody와 같이 JSON 형식으로 값을 받는것과 같이 사용할 때 사용하면 된다고 이해한다.

example

@GetMapping("")
public String uploadImgFile(
    @RequestPart("image") MultipartFile image,
    @RequestPart RequestDto request) {
    
    ... (생략)
}

만약 RequestPart에 MultipartFile 데이터가 포함되어있지 않다면 RequestBody와 동일한 동작을 한다!

[Springboot] 서비스와 인증과 권한 부여 - 스프링 시큐리티와 JWT 적용

NiceTry — Thu, 7 Dec 2023 16:52:58 +0900

스프링 시큐리티와 JWT 적용

SpringSecurity 의존성

프로젝트 생성후 의존성을 추가

// gradle
dependencies {
  // spring security
  implementation 'org.springframework.boot:spring-boot-starter-security'
  // jwt 토큰
  implementation 'io.jsonwebtoken:jjwt:0.9.1'
}

// maven
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<dependency>
  <groupId>io.jsonwebtoken</groupId>
  <artifactId>jjwt</artifactId>
  <version>0.9.1</version>
</dependency>

UserDetails와 UserDetailsService 구현

data/entity/User.java

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
public class User implements UserDetails {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(nullable = false, unique = true)
    private String uid;

    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    @Column(nullable = false)
    private String password;

    @Column(nullable = false)
    private String name;

    @ElementCollection(fetch = FetchType.EAGER)
    @Builder.Default // 필드값이 초기값을 갖고 있을 때 사용
    private List<String> roles = new ArrayList<>();

    /*
     계정이 가지고 있는 권한 목록 리턴
     */
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return roles
                .stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
    }

    /*
    계정의 이름을 리턴
    일반적으로 아이디(이메일)를 리턴
     */
    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    @Override
    public String getUsername() {
        return this.uid;
    }

    /*
    계정이 만료되었는지를 리턴
    true는 만료되지 않았음을 의미
     */
    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    /*
    계정이 잠겨있는지 리턴
    true는 잠겨있지 않음을 의미
     */
    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    /*
    비밀번호가 만료되었는지 리턴
     */
    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    /*
    계정이 활성화되어 있는지 리턴
     */
    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    @Override
    public boolean isEnabled() {
        return true;
    }
}

UserDetails는

UserDetailsService 를 통해 입력된 로그인 정보를 가지고 데이터베이스에서 사용자 정보를 가져오는 역할

getAuthorities(): 계정이 가지고 있는 권한 목록 리턴
getPassword(): 계정의 비밀번호 리턴
getUsername(): 계정의 이름 리턴, 일반적으로 아이디 리턴
isAccountNonExpired(): 계정이 만료되었는지 리턴. true -> 만료 x
isAccountNonLocked(): 계정이 잠겨있는지 리턴. true -> unLock
isCredentialNonExpired(): 비밀번호가 만료되었는지 리턴. true -> 만료 x
isEnabled(): 계정이 활성화 되어 있는지 리턴. true -> 활성화 상태

UserRepository 구현 (data/repository/UserRepository.java)

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    User getByUid(String uid);
    
}

UserDetailsServiceImpl 구현 (service/impl/UserDetailsService.java)

@Slf4j
@Service
@RequiredArgsConstructor
public class UserDetailsServiceImpl implements UserDetailsService {

    private final UserRepository userRepository;

    /*
    Username(uid) 로 User 조회
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        log.info("[loadUserByUsername] loadUserByUsername 수행, username : {}", username);
        return userRepository.getByUid(username);
    }

}

UserDetailsService

public interface UserDetailsService {

   UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;

}

UserDetails

스프링 시큐리티에서 제공하는 개념.
UserDetails의 username은 각 사용자를 구분하는 ID(email, id, 등..)
UserDetails의 구현체로 User 엔티티를 생성했기 때문에
UserDetailsServiceImpl에서는User 객체를 리턴하게끔 구현한 것

JwtTokenProvider 구현

이제 UserDetails에서 JWT 토큰 생성에 필요한 정보를 얻을 수 있게 되었다.

JWT 토큰을 생성하는 JwtTokenProvider 생성 (config/security/JwtTokenProvider.java)

@Slf4j
@Component
@RequiredArgsConstructor
public class JwtTokenProvider {

    private final UserDetailsService userDetailsService;

    @Value("${springboot.jwt.secret}")
    private String secretKey = "secretKey";
    private final long tokenValidMillisecond = 1000L * 60 * 60;

    @PostConstruct
    protected void init() {
        log.info("[init] JwtTokenProvider 내 secretKey 초기화 시작");
        secretKey = Base64
                .getEncoder()
                .encodeToString(secretKey.getBytes(StandardCharsets.UTF_8));

        log.info("[init] JwtTokenProvider 내 secretKey 초기화 완료");
    }

    public String createToken(String userUid, List<String> roles) {
        log.info("[createToken] 토큰 생성 시작");
        Claims claims = Jwts.claims()
                .setSubject(userUid);
        claims.put("roles", roles);  // 일종의 map

        Date now = new Date(System.currentTimeMillis());

        String token = Jwts.builder()       // 토큰 생성
                .setClaims(claims)
                //  시작 시간 : 현재 시간기준으로 만들어짐
                .setIssuedAt(now)
                // 끝나는 시간 : 지금 시간 + 유지할 시간(입력받아옴)
                .setExpiration(new Date(now.getTime() + tokenValidMillisecond))
                .signWith(SignatureAlgorithm.HS256, secretKey)
                .compact();

        log.info("[createToken] 토큰 생성 완료");
        return token;
    }

    /*
    토큰 인증 정보 조회
     */
    public Authentication getAuthentication(String token) {
        log.info("[getAuthentication] 토큰 인증 정보 조회 시작");
        UserDetails userDetails =
                userDetailsService.loadUserByUsername(this.getUsername(token));
        log.info("[getAuthentication] 토큰 인증 정보 조회 완료, UserDetails Username : {}", userDetails.getUsername());
        return new UsernamePasswordAuthenticationToken(
                userDetails, "", userDetails.getAuthorities()
        );
    }

    /*
    token 으로 uid 추출
     */
    private String getUsername(String token) {
        log.info("[getUsername] 토큰 기반 회원 email 추출");
        String info = Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(token) // Jws<Claims>
                .getBody() // Claims
                .getSubject(); // uid 값
        log.info("[getUsername] 토큰 기반 회원 구별 정보 추출 완료, info : {}", info);
        return info;
    }

    /*
    헤더로부터 token 추출
     */
    public String resolveToken(HttpServletRequest request) {
        log.info("[resolveToken] HTTP 헤더에서 Token 값 추출");
        return request.getHeader("X-AUTH-TOKEN");
    }

    /*
    토큰 유효성 체크
     */
    public boolean validateToken(String token) {
        log.info("[validateToken] 토큰 유효 체크 시작");
        try {
            Jws<Claims> claims =
                    Jwts.parser()
                            .setSigningKey(secretKey)
                            .parseClaimsJws(token);

            return !claims.getBody().getExpiration().before(new Date());
        } catch (Exception e) {
            log.info("[validateToken] 토큰 유효 체크 예외 발생");
            return false;
        }
    }

}

application.yml 파일에 @Value 값 정의

springboot:
  jwt:
    secret: "asdfasdfqwer"

yml 파일에서 값을 가져올 수 없다면 직접 지정해준 'secretKey' 값을 사용한다.

init()

@PostConstruct - 해당 객체가 빈 객체로 주입된 이후 수행되는 메서드를 지칭
secretKey를 Base64 형식으로 인코딩

createToken()

JWT 토큰의 payload 에 값을 넣기 위해 Claims 사용.
User의 uid 값을 setSubject() 를 통해 sub 속성에 추가.
claims.put("key", "value") 로 role 값을 별개로 추가.
Jwts.builder()를 사용해 토큰 생성

getAuthentication()

필터에서 인증 성공 -> SecurityContextHolder에 저장할 Authentication 생성
UsernamePasswordAuthenticationToken 사용해 Authentication 구현

UsernamePasswordAuthenticationToken 구조

Authentication, CredentialContainer 인터페이스를 구현하는

AbstractAuthenticationToken를 상속하는 구조

getUsername()

Jwts.parser()를 통해 secretKey 값을 확인 후 sub 값 추출

resolveToken()

헤더 값으로 전달된 'X-AUTH-TOKEN' 값을 가져와 리턴
클라이언트가 헤더를 통해 JWT 토큰 값을 전달해야 추출 가능
헤더의 이름은 임의로 변경 가능

validateToken()

클레임의 유효기간 체크 후 boolean 타입의 값 리턴

JwtAuthenticationFilter 구현

JwtAuthenticationFilter

- JWT 토큰을 인증하고 SecurityContextHolder에 추가하는 필터 설정 클래스

JwtAuthenticationFilter (config/security/JwtAuthenticationFilter.java)

@Slf4j
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtTokenProvider jwtTokenProvider;

    public JwtAuthenticationFilter(JwtTokenProvider jwtTokenProvider) {
        this.jwtTokenProvider = jwtTokenProvider;
    }

    @Override
    protected void doFilterInternal(
            HttpServletRequest request, HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {
        
        String token = jwtTokenProvider.resolveToken(request);
        log.info("[doFilterInternal] token 값 추출 완료. token : {}", token);

        log.info("[doFilterInternal] token 값 유효성 체크 시작");
        if (token != null && jwtTokenProvider.validateToken(token)) {
            Authentication authentication = jwtTokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(authentication);
            log.info("[doFilterInternal] token 값 유효성 체크 완료");
        }

        filterChain.doFilter(request, response);
        
    }

}

doFilterInternal()

마지막 줄 doFilter()
- 서블릿 실행 메서드.
- doFilter() 앞에 작성한 코드는 서블릿이 실행되기 전에 실행
- 뒤에 작성된 코드는 서블릿이 실행된 후 실행
토큰이 유효하다면 Authentication 객체를 생성해 SecurityContextHolder에 추가

SeuciryConfiguration 구현

스프링 시큐리티 관련 설정.

WebSecurityConfigureAdapter를 상속받는 Configuration 클래스 구현 (대표적인 방법)

SecurityConfiguration 클래스 (config/security/SecurityConfiguration.java)

@Slf4j
@Configuration
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

    private final JwtTokenProvider jwtTokenProvider;

    @Autowired
    public SecurityConfiguration(JwtTokenProvider jwtTokenProvider) {
        this.jwtTokenProvider = jwtTokenProvider;
    }

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        log.info("[configure] Security configure start");
        httpSecurity.httpBasic().disable()

                .csrf().disable()

                .sessionManagement()
                .sessionCreationPolicy(
                        SessionCreationPolicy.STATELESS
                )

                .and()
                .authorizeRequests()
                .antMatchers("/sign-api/sign-up", "/sign-api/sign-in",
                        "/sign-api/exception").permitAll()
                .antMatchers(HttpMethod.GET, "/product/**").permitAll()

                // 그 외
                .antMatchers("**exception**").permitAll()

                .anyRequest().hasRole("ADMIN")

                .and()
                .exceptionHandling().accessDeniedHandler(new CustomAccessDeniedHandler())
                .and()
                .exceptionHandling().authenticationEntryPoint(new CustomAuthenticationEntryPoint())

                .and()
                .addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider),
                        UsernamePasswordAuthenticationFilter.class)
        ;
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring()
                .antMatchers(
                        "/v2/api-docs",
                        "/swagger-resources/**",
                        "/swagger-ui.html",
                        "/webjars/**",
                        "/swagger/**",
                        "/sign-api/exception"
                );
    }
}

HttpSecurity configure()

대표적인 기능

리소스 접근 권한 설정
인증 실패 시 발생하는 예외 처리
인증 로직 커스터마이징
csrf, cors 등의 스프링 시큐리티 설정

세부 로직

httpBasic().disable()
- 기본값인 UI 사용 설정 비활성화
csrf().disable()
- CSRF는 Cross-Site Request Forgery의 줄임말 - '사이트 간 요청 위조'를 의미
- REST API에서는 CSRF 보안이 필요 없기 때문에 비활성화
- csrf() 메서드는 CSRF 토큰을 발급해서 클라이언트로부터 요청을 받을 때마다 토큰 검증
- 브라우저 사용 환경이 아니라면 비활성화해도 크게 문제가 되지 않음

사이트 간 요청 위조

웹 애플리케이션의 취약점 중 하나로서
사용자가 자신의 의지와 무관하게 웹 애플리케이션을 대상으로 공격자가 의도한 행동을 함으로써
특정 페이지의 보안을 취약하게 한다거나 수정, 삭제 등의 작업을 하는 공격 방법

sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
- REST API 기반 애플리케이션의 동작 방식 설정
- Session 대신 JWT 토큰으로 인증 처리 하기 때문에 STATELESS 로 설정
authorizeRequest()
- 애플리케이션에 들어오는 요청에 대한 사용 권한 체크
- antMatchers() 메서드는 antPattern을 통해 권한 설정
- permitAll(): 모두에게 허용
- '/product'로 시작하는 GET 요청 모두 허용
- 'exception' 단어가 들어간 경로는 모두 허용
- 기타 요청은 인증된 권한을 가진 사용자에게 허용
exceptionHandling().accessDeniedHandler()
- 권한 확인 과정에서 예외 발생할 경우 예외 전달
exceptionHandling().authenticationEntryPoint()
- 인증 과정에서 예외 발생할 경우 예외 전달
addFilterBefore()
- 커스텀 필터를 어느 필터 앞에 추가할 것인지 설정할 것인지 결정
- UsernamePasswordAuthenticationFilter 앞에 JwtAuthenticationFilter를 추가한다는 의미

WebSecurity configure()

WebSecurity는 HttpSecurity 앞단에 적용됨.

인증과 인가가 적용되지 않는 리소스 접근에 대해서만 사용됨.

커스텀 AccessDeniedHandler, AuthenticationEntryPoint 구현

CustomAccessDeniedHandler 클래스 (config/secutiry/CustomAccessDeniedHandler.java)

@Slf4j
@Component
public class CustomAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request,
                       HttpServletResponse response,
                       AccessDeniedException accessDeniedException)
            throws IOException, ServletException {

        log.info("[handle] 접근이 막혔을 경우 경로 리다이렉트");
        response.sendRedirect("/sign-api/exception");

    }

}

AccessDeniedException은 액세스 권한이 없는 리소스에 접근할 경우 발생하는 예외.
이 예외를 처리하기 위해 AccessDeniedHandler 인터페이스가 사용됨.

CustomAuthenticationEntryPoint 클래스 (config/secutiry/CustomAuthenticationEntryPoint.java)

@Slf4j
@Component
public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        ObjectMapper objectMapper = new ObjectMapper();
        log.info("[commence] 인증 실패로 response.sendError 발생");

        EntryPointErrorResponse entryPointErrorResponse = new EntryPointErrorResponse();
        entryPointErrorResponse.setMsg("인증이 실패하였습니다.");

        response.setStatus(401);
        response.setContentType("application/json");
        response.setCharacterEncoding("utf-8");
        response.getWriter().write(objectMapper.writeValueAsString(entryPointErrorResponse));
    }
    
}

EntryPointErrorResponse 클래스 (data/dto/EntryPointErrorResponse.java)

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class EntryPointErrorResponse {

    private String msg;

}

회원가입과 로그인 구현

SignUpResultDto 클래스 (data/dto/SignUpResultDto.java)

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class SignUpResultDto {
    
    private boolean success;
    
    private int code;
    
    private String ms;
    
}

SignInResultDto 클래스 (data/dto/SignInResultDto.java)

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class SignInResultDto extends SignUpResultDto{

    private String token;

    @Builder
    public SignInResultDto(boolean success, int code, String msg, String token) {
        super(success, code, msg);
        this.token = token;
    }

}

SignService 인터페이스 (service/SignService.java)

public interface SignService {

    SignUpResultDto signUp(String id, String password, String name, String role);

    SignInResultDto signIn(String id, String password) throws RuntimeException;

}

SignServiceImpl 클래스 (service/impl/SignServiceImpl.java)

@Slf4j
@Service
@RequiredArgsConstructor
public class SignServiceImpl implements SignService {

    public UserRepository userRepository;
    public JwtTokenProvider jwtTokenProvider;
    public PasswordEncoder passwordEncoder;

    @Autowired
    public SignServiceImpl(UserRepository userRepository,
                           JwtTokenProvider jwtTokenProvider,
                           PasswordEncoder passwordEncoder) {
        this.userRepository = userRepository;
        this.jwtTokenProvider = jwtTokenProvider;
        this.passwordEncoder = passwordEncoder;
    }

    @Override
    public SignUpResultDto signUp(String id, String password, String name, String role) {
        log.info("[getSignUpResult] 회원 가입 정보 전달");
        User user;
        if (role.equalsIgnoreCase("admin")) {
            user = User.builder()
                    .uid(id)
                    .name(name)
                    .password(passwordEncoder.encode(password))
                    .roles(Collections.singletonList("ROLE_ADMIN"))
                    .build();
        } else {
            user = User.builder()
                    .uid(id)
                    .name(name)
                    .password(passwordEncoder.encode(password))
                    .roles(Collections.singletonList("ROLE_USER"))
                    .build();
        }

        User savedUser = userRepository.save(user);
        SignUpResultDto signUpResultDto = new SignUpResultDto();
        log.info("[getSignUpResult] userEntity 값이 들어왔는지 확인 후 결과값 주입");

        if (!savedUser.getName().isEmpty()) {
            log.info("[getSignUpResult] 정상 처리 완료");
            setSuccessResult(signUpResultDto);
        } else {
            log.info("[getSignUpResult] 실패 처리 완료");
            setFailResult(signUpResultDto);
        }

        return signUpResultDto;
    }

    @Override
    public SignInResultDto signIn(String id, String password) {
        log.info("[getSignInResult] signDataHandler 로 회원 정보 요청");
        User user = userRepository.getByUid(id);
        log.info("[getSignInResult] id : {}", id);

        log.info("[getSignInResult] 패스워드 비교");
        if (!passwordEncoder.matches(password, user.getPassword())) {
            throw new RuntimeException();
        }
        log.info("[getSignInResult] 패스워드 일치");

        log.info("[getSignInResult] SignInResultDto 객체 생성");
        SignInResultDto signInResultDto =
                SignInResultDto.builder()
                        .token(jwtTokenProvider.createToken(
                                        String.valueOf(user.getUid()),
                                        user.getRoles()
                                )
                        )
                        .build();
        
        log.info("[getSignInResult] SignInResultDto 객체에 값 주입");
        setSuccessResult(signInResultDto);
        
        return signInResultDto;
    }
    
    private void setSuccessResult(SignUpResultDto result) {
        result.setSuccess(true);
        result.setCode(CommonResponse.SUCCESS.getCode());
        result.setMsg(CommonResponse.SUCCESS.getMsg());
    }
    
    private void setFailResult(SignUpResultDto result) {
        result.setSuccess(false);
        result.setCode(CommonResponse.FAIL.getCode());
        result.setMsg(CommonResponse.FAIL.getMsg());
    }
}

PasswordEncoder 활용을 위해 Bean으로 등록해야 함.

PasswordEncoderConfiguration 클래스 (config/PasswordEncoderConfiguration.java)

@Configuration
public class PasswordEncoderConfiguration {
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }
    
}

SignServiceImpl 내부 로직 동작 과정

id를 기반으로 UserRepository에서 User 엔티티를 가져옴.
PasswordEncoder를 사용해 db에 저장되어있는 password 와 입력받은 password 일치 여부 확인
password가 일치해서 인증 통과 -> JwtTokenProvider를 통해 id와 role 값으로 토큰 생성 후 전달

CommonResponse 클래스 (common/CommonResponse.java)

public enum CommonResponse {
    
    SUCCESS(0, "Success"), FAIL(-1, "Fail");
    
    int code;
    String msg;
    
    CommonResponse(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
    
    public int getCode() {
        return code;
    }
    
    public String getMsg() {
        return msg;
    }
    
}

SignController 전체 코드 (controller/SignController.java)

@Slf4j
@RestController
@RequestMapping("/sign-api")
public class SignController {

    private final SignService signService;

    @Autowired
    public SignController(SignService signService) {
        this.signService = signService;
    }

    @PostMapping(value = "/sign-in")
    public SignInResultDto signIn(
            @ApiParam(value = "ID", required = true) @RequestParam String id,
            @ApiParam(value = "Password", required = true) @RequestParam String password)
            throws RuntimeException {
        
        log.info("[signIn] 로그인 시도. id : {}, pw : ****", id);
        SignInResultDto signInResultDto = signService.signIn(id, password);
        
        if (signInResultDto.getCode() == 0) {
            log.info("[signIn] 정상적으로 로그인되었습니다. id : {}, token : {}", id, signInResultDto.getToken());
        }
        
        return signInResultDto;
    }
    
    @PostMapping(value = "/sign-up")
    public SignUpResultDto signUp(
            @ApiParam(value = "ID", required = true) @RequestParam String id,
            @ApiParam(value = "비밀번호", required = true) @RequestParam String password,
            @ApiParam(value = "이름", required = true) @RequestParam String name,
            @ApiParam(value = "권한", required = true) @RequestParam String role) {
        log.info("[signUp] 회원가입을 수행합니다. id : {}, password: ****, name : {}, role : {}", id, name, role);
        SignUpResultDto signUpResultDto = signService.signUp(id, password, name, role);
        
        log.info("[signUp] 회원가입을 완료했습니다. id : {]", id);
        return signUpResultDto;
    }
    
    @PostMapping(value = "exception")
    public void exceptionTest() throws RuntimeException {
        throw new RuntimeException("접근이 금지되었습니다.");
    }
    
    @ExceptionHandler(value = RuntimeException.class)
    public ResponseEntity<Map<String, String>> ExceptionHandler(RuntimeException e) {
        HttpHeaders responseHeaders = new HttpHeaders();
        // responseHeaders.add(HttpHeaders.CONTENT_TYPE, "application/json");
        HttpStatus httpStatus = HttpStatus.BAD_REQUEST;
        
        log.error("ExceptionHandler 호출, {}, {}", e.getCause(), e.getMessage());
        
        Map<String, String> map = new HashMap<>();
        map.put("error type", httpStatus.getReasonPhrase());
        map.put("code", "400");
        map.put("message", "에러 발생");
        
        return new ResponseEntity<>(map, responseHeaders, httpStatus);
    }
}

[Springboot] 서비스의 인증과 권한 부여 - JWT

NiceTry — Wed, 6 Dec 2023 23:44:59 +0900

JWT(JSON Web Token)

JWT 특징

당사자 간의 정보를 JSON 형태로 안전하게 전송하기 위한 토큰.
URL로 이용할 수 있는 문자열로만 구성되어 있으며, 디지털 서명이 적용되어 있어 신뢰 가능.
주로 서버와의 통신에서 권한 인가를 위해 사용.
HTTP 구성요소 어디든 위치할 수 있음.

JWT 구조

JWT는 헤더(Header), 내용(Payload), 서명(Signature) 을 "."으로 구분하여 구성된다.

헤더

검증과 관련된 내용

{
  /*
  해싱 알고리즘 지정,
  SHA256 또는 RSA 사용
  서명 부분에서 사용됨
  "HS256" 은 "HMAC SHA256" 알고리즘 사용을 의미
  */
  "alg": "HS256",
  /*
  토큰의 타입 지정
  */
  "typ": "JWT"
}

이렇게 완성된 헤더는 Base64Url 형식으로 인코딩되어 사용된다.

내용

토큰에 담는 정보 포함.

내용에 담기는 속성들은 클레임(Claim) 이라고 하며

등록된 클레임(Registered Claims)
공개 클레임(Public Claims)
비공개 클레임(Private Claims)

세 가지로 분류된다.

등록된 클레임(Registered Claims)

필수는 아니지만 이미 이름이 정해져 있는 클레임을 뜻함
iss: JWT의 발급자(Issuer) 주체를 나타냄. iss의 값은 문자열이나 URI를 포함하는 대소문자를 구분하는 문자열
sub: JWT의 제목(Subject)
aud: JWT의 수신인(Audience). JWT를 처리하려는 각 주체는 해당 값으로 자신을 식별해야함. 요청을 처리하는 주체가 'aud' 값으로 자신을 식별하지 않으면 JWT는 거부됨.
exp: JWT의 만료기간(Expriation). NumericDate 형식으로 지정
nbf: 'Not Before'를 의미
iat: JWT가 발급된 시간(issued at)
jti: JWT의 식별자(JWT ID). 주로 중복 처리를 방지하기 위해 사용

공개 클레임(Public Claims)

키 값을 마음대로 정의.

충돌이 발생하지 않을 이름으로 설정해야함.

비공개 클레임(Private Claims)

통신 간에 상호 합의되고 등록된 클레임과 공개된 클레임이 아닌 클레임을 의미

JWT 내용 예시

{
  "sub": "wikibooks payload",
  "exp": "1602076408",
  "userId": "wikibooks",
  "username": "jnjeaaaat"
}

이렇게 완성된 내용은 Base64Url 형식으로 인코딩되어 사용된다.

서명

<인코딩된 헤더, 인코딩된 내용, 비밀키, 헤더의 알고리즘 속성값> 으로 생성

HMAC SHA256 알고리즘을 사용해서 서명을 생성한다면,

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret
  )

이와 같은 방식으로 생성됨.

-> 메시지가 도중에 변경되지 않았는지 확인할 때 사용

JWT 디버거 사용하기

https://jwt.io/#debugger-io

JWT.IO

JSON Web Tokens are an open, industry standard RFC 7519 method for representing claims securely between two parties.

jwt.io

사이트에서 Header, Payload, Signature 내용 확인 가능

[Springboot] Spring Security 필터 동작

NiceTry — Wed, 6 Dec 2023 23:25:37 +0900

보안 필터체인 종류 및 순서

보안필터 체인에서 사용하는 필터에는 여러 종류가 있다.

공식 문서에서 소개하는 필터의 실행 순서

ChannelProcessingFilter
WebAsyncManagerIntergrationFilter
SecurityContextPersistenceFilter
HeaderWriterFilter
CorsFilter
CsrfFilter
LogoutFilter
OAuth2AuthorizationRequestRedirectFilter
Saml2WebSsoAuthenticationRequestFilter
X509AuthenticationFilter
AbstractPreAuthenticationedProcessingFilter
CasAuthenticationFilter
OAuth2LoginAuthenticationFilter
Saml2WebSsoAuthenticationFilter
Saml2WebSsoAuthenticationFilter
UsernamePasswordAuthenticationFilter
OpenIDAuthenticationFilter
DefaultLoginPageGeneratingFilter
DefaultLogoutPageGeneratingFilter
ConcurrentSessionFilter
DigestAuthenticationFilter
BearerTokenAuthenticationFilter
BasicAuthenticationFilter
RequestCacheAwareFilter
SecurityContextHolderAwareRequestFilter
JaasApiIntegrationFilter
RememberMeAuthenticationFilter
AnonymousAuthenticationFilter
SessionManagementFilter
ExceptionTraslationFilter
FilterSecurityInterceptor
SwitchUserFilter

보안 필터체인 설정

보안 필터체인은 WebSecurityConfigurerAdapter 클래스를 상속받아 설정 가능

필터체인 프록시는 WebSecurityConfigurerAdapter 클래스를 상속받는 클래스를 여러개 생성하면 여러개의 보안 필터체인을 가질 수 있다.

WebSecurityConfigurerAdapter의 @Order 어노테이션으로 필터 순서를 정의할 수 있다.

별다른 설정이 없다면 UsernamePasswordAuthenticationFilter를 통해 인증 처리

UsernamePasswordAuthenticationFilter를 통한 인증 과정

인증 수행 과정

클라이언트로부터 요청 -> 서블릿 필터에서 SecurityFilterChain 으로 작업 위임, 그중 UsernamePasswordAuthenticationFilter (위 그림에서 AuthenticationFilter에 해당) 에서 인증 처리
AuthenticationFilter는 요청 객체 (HttpServletRequest) 에서 username 과 password 를 추출해서 토큰 생성 후 AuthenticationManager에게 토큰 전달.
AuthenticationManager는 인터페이스, 일반적인 구현체는 ProviderManager
ProviderManager는 인증을 위해 AuthenticationProvider로 토큰 전달
AuthenticationProvider는 토큰의 정보를 UserDetailsService에 전달
UserDetailsService는 전달받은 정보를 통해 데이터베이스에서 일치하는 사용자를 찾아 UserDetails 객체 생성
생성된 UserDetails 객체는 AuthenticationProvider로 전달, 해당 Provider에서 인증 수행 -> 성공하면 ProviderManager로 권한을 담은 토큰 전달
ProviderManager는 검증된 토큰을 AuthenticationFilter로 전달
AuthenticationFilter는 검증된 토큰을 SecurityContextHolder에 있는 SecurityContext에 저장

UsernamePasswordAuthenticationFilter는 접근 권한을 확인.

인증 실패인 경우 로그인 폼이라는 화면을 띄우는 역할 수행

또는 JWT 토큰을 사용해 인증을 수행할 경우

JWT 관련 필터 생성후 UsernamePasswordAuthenticationFilter 앞에 배치해 먼저 인증 수행하도록 설정

JWT 생성, 설정

[Springboot] 서비스의 인증과 권한 부여 - JWT

JWT(JSON Web Token) JWT 특징 당사자 간의 정보를 JSON 형태로 안전하게 전송하기 위한 토큰. URL로 이용할 수 있는 문자열로만 구성되어 있으며, 디지털 서명이 적용되어 있어 신뢰 가능. 주로 서버와의

jnjeaaaat.tistory.com

[Springboot] 서비스의 인증과 권한 부여 - SpringSecurity 소개

NiceTry — Wed, 6 Dec 2023 17:13:16 +0900

보안 용어

인증 - authentication

사용자가 누구인지 확인하는 단계, 대표적인 예로 '로그인' 이 있다.

로그인 성공 -> 사용자에게 토큰(token) 전달

토큰이 없는 사용자는 리소스에 접근 x

인가 - authorization

토큰을 가진 인증된 사용자가 내부 리소스에 접근할 권리가 있는지 확인하는 과정.

사이트 등급에 따라 접근할 수 있는 기능이 다른 것이 대표적인 예시이다.

접근 주체 - principal

애플리케이션의 기능을 사용하는 주체 -> 사용자, 디바이스, 시스템 등이 될 수 있다.

인증 과정(신뢰하는 접근 주체인지 확인) -> 인가 과정(접근 주체에게 부여된 권한 확인)

스프링 시큐리티

스프링에 인증, 인가 등의 보안 기능을 적용할 때 사용함

스프링 시큐리티 동작 구조

서블릿 필터(Servlet Filter)를 기반으로 동작, DispatcherServlet 앞에 필터가 배치

필터체인(FilterChain)은 서블릿 컨테이너에서 관리하는 ApplicationFilterChain을 의미

클라이언트 요청

-> 서블릿 컨테이너에서 URI 확인, 필터와 서블릿 매핑

-> 스프링 시큐리티는 사용하려는 필터체인을 서블릿 컨테이너의 필터 사이에서 동작 - DelegantingFilterProxy 사용

DelegatingFilterProxy

- 서블릿 컨테이너의 생명주기와 스프링 애플리케이션 컨텍스트(Application Context) 다리 역할하는 필터 구현체

- 표준 서블릿 필터 구현, 역할 위임할 필터체인 프록시(FilterChainProxy)를 내부에 갖고 있음

필터체인 프록시

- 스프링 시큐리티에서 제공하는 필터

- 보안 필터체인(SecurityFilterChain)을 통해 많은 보안 필터(Security Filter) 사용

- 사용 가능한 보안 필터 체인은 List 형식으로 담을 수 있게 설정

- URI 패턴에 따라 특정 보안필터 체인 선택해서 사용

보안 필터체인 종류 및 동작순서

[Springboot] Spring Security 필터 동작

보안 필터체인 종류 및 순서 보안필터 체인에서 사용하는 필터에는 여러 종류가 있다. 공식 문서에서 소개하는 필터의 실행 순서 ChannelProcessingFilter WebAsyncManagerIntergrationFilter SecurityContextPersistence

jnjeaaaat.tistory.com

[JPA] @ManyToOne 연관관계에 따른 데이터베이스 오류

NiceTry — Sat, 2 Dec 2023 12:48:14 +0900

에러 내용

프로젝트 진행 중에 하나의 User(유저)에 여러 개의 Shop(상점)을 등록해두기 위해 Shop Entity에 @ManyToOne 단방향 연관관계를 설정해두었다.

@Entity
public class Shop extends BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 상점을 등록한 유저 id
    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "owner_id")
    @ToString.Exclude
    private User owner;

}

ShopServiceImpl에 deleteShop() 구현

@Override
@Transactional
public ShopDeleteResponse deleteShop(Long shopId, ShopDeleteRequest request) {
    log.info("[deleteShop] 상점 삭제 - 상점 id : {}", shopId);

    // 상점 삭제
    shopRepository.deleteById(shopId);
    log.info("[deleteShop] 삭제 완료");

    return ShopDeleteResponse.from(
            ShopDto.builder()
                    .id(shopId)
                    .build()
    );
}

이와 같은 코드를 짜고 postman으로 테스트를 했는데

Shop Table에 foreign key로 저장되어있던 User 정보까지 같이 삭제되는 현상이 있다.

해결

외래키 제약 조건에 의해 데이터베이스에서 오류가 난것이다.

정상적으로 동작시키기 위해

Shop Entity에서 Owner(User) 정보를 null 로 set 한 다음

Shop을 삭제해주면 해결!

@Override
@Transactional
public ShopDeleteResponse deleteShop(Long shopId, ShopDeleteRequest request) {
    log.info("[deleteShop] 상점 삭제 - 상점 id : {}", shopId);

    Shop shop = shopRepository.findById(shopId)
                .orElseThrow(() -> new BaseException(SHOP_NOT_FOUND));
                
    // 상점 삭제
    shop.setOwner(null); // 추가한 내용
    shopRepository.deleteById(shopId);
    log.info("[deleteShop] 삭제 완료");

    return ShopDeleteResponse.from(
            ShopDto.builder()
                    .id(shopId)
                    .build()
    );
}