private static final Long REFRESH_TOKEN_EXPIRATION_TIME = 24 * 60 * 60 * 1000L * 14;
    public String issueRefreshToken(final Authentication authentication){
        return generateToken(authentication, REFRESH_TOKEN_EXPIRATION_TIME);
    }

    @Transactional
    public UserJoinResponse createMember(
            MemberCreateDto memberCreateDto
    ) {
        Member member = memberRepository.save(
                Member.create(memberCreateDto.name(), memberCreateDto.part(), memberCreateDto.age())
        );
        Long memberId = member.getId();
        UserAuthentication userAuthentication = UserAuthentication.createUserAuthentication(memberId);
        String accessToken = jwtTokenProvider.issueAccessToken(userAuthentication);
        String refreshToken = jwtTokenProvider.issueRefreshToken(userAuthentication);
//        redisTokenService.saveRefreshToken(memberId, refreshToken);
        Token refreshTokenEntity = new Token(memberId, refreshToken);
        redisTokenRepository.save(refreshTokenEntity);
        return UserJoinResponse.of(accessToken, refreshToken, memberId.toString());
    }

@Configuration
public class RedisConfig {
    @Value("${spring.data.redis.host}")
    private String host;

    @Value("${spring.data.redis.port}")
    private int port;

    @Bean
    public RedisConnectionFactory redisConnectionFactory(){

        return new LettuceConnectionFactory(host, port);
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(redisConnectionFactory());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

public class RedisTokenService {

    private final RedisTokenRepository redisTokenRepository;
    private final JwtTokenProvider jwtTokenProvider;
    private final RedisTemplate<String, Object> redisTemplate;

    public CreateTokenByRefreshTokenResponse refreshToken(String token, HttpServletRequest request){
        JwtValidationType jwtValidationType = jwtTokenProvider.validateToken(token);

        if(jwtValidationType == JwtValidationType.VALID_JWT){
            Long memberId = jwtTokenProvider.getUserFromJwt(token);
            Token refreshToken = redisTokenRepository.findById(memberId).orElseThrow(
                    () -> new RuntimeException("refresh token expired or not exists")
            );
            UserAuthentication authentication = UserAuthentication.createUserAuthentication(memberId);
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
            SecurityContextHolder.getContext().setAuthentication(authentication);
            return CreateTokenByRefreshTokenResponse.of(jwtTokenProvider.issueAccessToken(authentication));
        }
        throw new RuntimeException("invalid token");
    }

    private Optional<Token> findById(Long memberId) {
        ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        Token token = (Token) valueOperations.get(memberId.toString());
        return Optional.ofNullable(token);
    }

    public <S extends Token> S save(S token) {
        ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        valueOperations.set(token.getId().toString(), token);
        return token;
    }

    public void deleteById(Long memberId) {
        redisTemplate.delete(memberId.toString());
    }
}

@Controller
@RequiredArgsConstructor
@RequestMapping("/api/v1/token")
public class TokenController {

    private final RedisTokenService redisTokenService;

    @PostMapping("/refresh")
    public ResponseEntity<CreateTokenByRefreshTokenResponse> refreshToken(HttpServletRequest request) {
        final String authHeader = request.getHeader(HttpHeaders.AUTHORIZATION);
        final String token;

        if (authHeader == null || !authHeader.startsWith("Bearer ")){
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
        token = authHeader.substring(7);
        CreateTokenByRefreshTokenResponse response = redisTokenService.refreshToken(token, request);

        return ResponseEntity.status(HttpStatus.CREATED)
                .header("Location", response.accessToken())
                .body(response);
    }
}

//        redisTokenService.saveRefreshToken(memberId, refreshToken);
        Token refreshTokenEntity = new Token(memberId, refreshToken);
        redisTokenRepository.save(refreshTokenEntity);