• 계층형으로 구성된 테이블에서 양방향 매핑을 해 데이터를 들고와야 하는 상황이었다.
• 이런 상황에서 무한루프가 발생했고, 원인을 찾을 수 없었다.

코드

public class Code {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long codeId;
    private String codename;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "upper_code_id")
    @JsonIgnore
    private Code parentCode;

    @OneToMany(mappedBy = "parentCode", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private List<Code> childCodes;

    public CodeDTO toDTO() {
        Set<Long> convertedCodes = new HashSet<>();
        if (convertedCodes.contains(codeId)) {
            return null;
        }

        CodeDTO.CodeDTOBuilder builder = CodeDTO.builder();

        builder.codeId(codeId)
                .codename(codename);


        if(parentCode != null) {
            CodeDTO parentCodeDTO = parentCode.toDTO();
            builder.parentCodeDTO(parentCodeDTO);
        }

        if (childCodes != null && !childCodes.isEmpty()) {
            List<CodeDTO> childCodeDTOs = childCodes.stream()
                    .map(Code::toDTO)
                    .filter(Objects::nonNull)
                    .collect(Collectors.toList());
            builder.childCodesDTO(childCodeDTOs);
        }

        return builder.build();
    }
 }

• 문제가 발생한 CODE테이블은 계층형테이블이며, 자기자신을 참조하고 있다.

무한루프 해결

• 처음에는 쿼리문을 가지고 오는 과정 자체가 문제인 줄 알았다.
• 하지만 날라가는 쿼리문은 이것이 전부였고, 그 후에 stackoverflow가 발생해 쿼리를 가지고오는 과정에서의 문제가 아님을 짐작했다.

Hibernate: select c1_0.code_id,c1_0.codename,c1_0.upper_code_id from code c1_0 where c1_0.codename=?
Hibernate: select c1_0.code_id,c1_0.codename,c1_0.upper_code_id from code c1_0 where c1_0.code_id=?
Hibernate: select c1_0.upper_code_id,c1_0.code_id,c1_0.codename from code c1_0 where c1_0.upper_code_id=?

• 문제가 된 부분은 다음과 같이 엔티티를 DTO로 변환하는 부분이었다.
• 부모는 자식을 변환하고, 자식은 부모를 변환하는 일이 계속 발생하니 stackoverflow가 발생한 것이다.
• 이를 해결하기 위해서는 자식이나 부모 둘 중 하나에서 변환과정을 끊어주면 된다.
• 나는 다음과 같이 자식이 부모를 dto로 변환하는 부분을 주석처리해 주었다.

• dto를 entity로 변환시키는 부분도 마찬가지로 처리해주었다.

N+1 쿼리 해결

• 이렇게 무한루프를 해결하고 나서 부모 + 자식을 가지고오는 과정에서 n+1쿼리문이 생기는 문제가 발생했다.

• 이는 양방향 참조관계를 설정할 때 해놓은 FetchType.LAZY때문으로, 자식이 필요할 때 쿼리를 발생시키는 방식이기 때문에 N+1참조 관계가 발생한다.

• 하지만 그렇다고 해서 한번에 모든 객체를 다 가지고 오면 속도 저하가 생길 수도 있으므로 EAGER로 할 수도 없는 노릇이었다.

• 결국은 부모 + 자식을 한번에 조인해서 가지고 오는 쿼리문을 작성해야했고, 다음과 같은 쿼리문으로 수정했다.

    @Query("SELECT c FROM Code c " +
               "LEFT JOIN FETCH c.parentCode " +
               "LEFT JOIN FETCH c.childCodes " +
               "WHERE c.codename = :codename")
    public Code findByCodename(String codename);

• 하지만 이렇게 작성해도 N+1 문제는 계속되었다. fetch문을 작성하는 과정에서는 join해서 쿼리문을 가지고오지만 FetchType.LAZY때문에 여전히 자식을 사용하는 과정에서 새로운 쿼리문이 발생했기 때문이다.

User
Hibernate: select c1_0.code_id,c2_0.upper_code_id,c2_0.code_id,c2_0.codename,c1_0.codename,p1_0.code_id,p1_0.codename,p1_0.upper_code_id from code c1_0 left join code p1_0 on p1_0.code_id=c1_0.upper_code_id left join code c2_0 on c1_0.code_id=c2_0.upper_code_id where c1_0.codename=?
Hibernate: select c1_0.upper_code_id,c1_0.code_id,c1_0.codename from code c1_0 where c1_0.upper_code_id=?
Hibernate: select c1_0.upper_code_id,c1_0.code_id,c1_0.codename from code c1_0 where c1_0.upper_code_id=?
Hibernate: select c1_0.upper_code_id,c1_0.code_id,c1_0.codename from code c1_0 where c1_0.upper_code_id

• 이 사진에서 childCodes를 childCodeDTOS로 변환하는 과정에서 각각의 자식들을 따로 불러오면서 해당 문제가 발생했다.
• 이를 해결하기 위해서 application.yml에 다음과 같이 설정했다.

  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
        default_batch_fetch_size: 1000

• 이렇게 하면 in을 사용해 쿼리문을 n번이아니라 1번만 더 날려서 해결을 해준다고 한다.
• 그 결과 다음과 같은 쿼리문이 발생했고, 계층형으로 데이터를 불러오는데 성공했다.

Hibernate: select c1_0.code_id,c2_0.upper_code_id,c2_0.code_id,c2_0.codename,c1_0.codename,p1_0.code_id,p1_0.codename,p1_0.upper_code_id from code c1_0 left join code p1_0 on p1_0.code_id=c1_0.upper_code_id left join code c2_0 on c1_0.code_id=c2_0.upper_code_id where c1_0.codename=?
Hibernate: select c1_0.upper_code_id,c1_0.code_id,c1_0.codename from code c1_0 where c1_0.upper_code_id in (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?.....

jwt를 이용한 인증 과정 절차

일반적으로 jwt를 이용한 로그인 구현은 다음과 같은 과정을 통해 진행된다.

1. 유저가 로그인에 성공하면 accessToken과 refreshToken을 발급한다.
2. 발급한 accessToken과 refreshToken을 클라이언트에게 넘겨준다. 이 때, refreshToken은 db에 저장한다.
3. 유저는 인증이 필요한 요청시 마다 accessToken을 넘겨준다.
4. 서버에서는 filter를 통해 해당 accessToken을 검증한다.
5. 검증에 실패할 경우 refreshToken을 클라이언트에게 다시 요청하고, 검증이 성공할 경우 클라이언트의 요청을 수행한다.
6. 클라이언트가 refreshToken을 넘겨주면 해당 refreshToken을 검증한다.
7. refreshToken도 검증이 실패하면, 로그아웃을 시키고 다시 로그인을 유도한다.

이 부분은 크게 다르지 않으므로, 해당 순서와 동일하게 진행하면 된다.

토큰 처리 클래스

우선 jwt토큰과 관련된 부분을 처리할 클래스를 생성한다. 이 클래스에는 토큰 발급, 검증, 추출, 업데이트 등 토큰과 관련된 기능들이 모여있다.

package com.project.bookforeast.common.security.service;


import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import com.project.bookforeast.common.security.error.TokenErrorResult;
import com.project.bookforeast.common.security.error.TokenException;
import com.project.bookforeast.user.dto.UserDTO;
import com.project.bookforeast.user.entity.User;
import com.project.bookforeast.user.repository.UserRepository;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import jakarta.servlet.http.HttpServletRequest;

@Service
public class JwtUtil {


    private final UserRepository userRepository;

    @Autowired
    public JwtUtil(UserRepository userRepository) {
        this.userRepository = userRepository;
    }


    @Value("${jwt.secret-key}")
    private String SECRETKEY;


    private Long ACCESS_TOKEN_EXPIRATION_PERIOD = 600000L;


    private Long REFRESH_TOKEN_EXPIRATION_PERIOD = 3600000L;


    public String generateAccessToken(UserDTO userDTO) {
        return createToken(ACCESS_TOKEN_EXPIRATION_PERIOD, userDTO);
    }


    public String generateRefreshToken(UserDTO userDTO) {
        return createToken(REFRESH_TOKEN_EXPIRATION_PERIOD, userDTO);
    }


    private String createToken(Long expirationPeriod, UserDTO userDTO) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("sub", userDTO.getSocialId());
        claims.put("iss", userDTO.getSocialProvider());

        return Jwts.builder()
                .addClaims(claims)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + expirationPeriod))
                .signWith(SignatureAlgorithm.HS256, SECRETKEY)
                .compact();
    }



    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = Jwts.parser().setSigningKey(SECRETKEY).parseClaimsJws(token).getBody();
        return claimsResolver.apply(claims);
    }



    public boolean validateAccessToken(String accessToken) {
        if(accessToken == null || accessToken.length() <= 0) {
            throw new TokenException(TokenErrorResult.ACCESS_TOKEN_NEED);
        }

        boolean isTokenExpired = checkTokenExpired(accessToken);
        if(isTokenExpired == true) {
            throw new TokenException(TokenErrorResult.TOKEN_EXPIRED);
        } else {
            return isTokenExpired;
        }
    }


    public Boolean validateRefreshToken(String refreshToken) {
        User user = userRepository.findByRefreshToken(refreshToken);

        if(user == null) {
            new TokenException(TokenErrorResult.TOKEN_EXPIRED);
        }

        String refreshTokenInDB = user.getRefreshToken(); 
        if(!refreshToken.equals(refreshTokenInDB) || checkTokenExpired(refreshTokenInDB)) {
            new TokenException(TokenErrorResult.TOKEN_EXPIRED);
        }

        return true;
    }


    public boolean checkTokenExpired(String token) {
        Date expirationDate = extractClaim(token, Claims::getExpiration);
        boolean isTokenExpired = expirationDate.after(new Date());
        return isTokenExpired;
    }


    public Map<String, String> initToken(UserDTO savedOrFindUser) {
        Map<String, String> tokenMap = new HashMap<>();
        String accessToken = generateAccessToken(savedOrFindUser);
        String refreshToken = generateRefreshToken(savedOrFindUser);

        tokenMap.put("accessToken", accessToken);
        tokenMap.put("refreshToken", refreshToken);

        updRefreshTokenInDB(refreshToken, savedOrFindUser);

        return tokenMap;
    }


    public Map<String, String> refreshingAccessToken(UserDTO userDTO, String refreshToken) {
        Map<String, String> tokenMap = new HashMap<>();
        String accessToken = generateAccessToken(userDTO);

        tokenMap.put("accessToken", accessToken);
        tokenMap.put("refreshToken", refreshToken);

        return tokenMap;
    }


    private void updRefreshTokenInDB(String refreshToken, UserDTO savedOrFindUser) {
        savedOrFindUser.setRefreshToken(refreshToken);
        userRepository.save(savedOrFindUser.toEntity());
    }


    public String extractTokenFromHeader(HttpServletRequest request) {
        String header = request.getHeader("Authorization");
        if(StringUtils.hasText(header) && header.startsWith("Bearer ")) {
            return header.substring(7);
        } else {
            throw new TokenException(TokenErrorResult.ACCESS_TOKEN_NEED);
        }
    }
}

물론 처음부터 이 메소드들을 다 작성한 것은 아니지만, 편의를 위해 한 번에 코드로 적어두었다.

토큰 발급

1편을 통해 SecurityContext에 인증정보를 등록하는 것을 성공했으면, controller에서 initToken을 통해서 토큰을 생성해 준다.

    @PostMapping("/social-login")
    public ResponseEntity<Map<String, String>> socialLogin(@RequestBody @Valid SocialLoginDTO socialLoginDTO)
    {

        UserDTO savedOrFindUser = userService.socialLogin(socialLoginDTO);
        securityService.saveUserInSecurityContext(socialLoginDTO);
        Map<String, String> tokenMap = jwtUtil.initToken(savedOrFindUser);

        return ResponseEntity.ok(tokenMap);
    }

토큰 생성시에는 refreshToken정보를 db에서 update해준다. 그 후 토큰 정보를 클라이언트에게 전달한다. 그러면 유저에게 다음과 같은 형태로 토큰 정보가 전달된다.

이번 글에서는 토큰 생성까지만 해보도록 하고, 발급된 토큰을 이용한 검증은 다음 글에서 작성하겠다.