@Component
public class JwtProvider {

    private final String secretKey = "yourSecretKey"; // 적절히 암호화 필요
    private final long accessTokenValidity = 1000L * 60 * 15;  // 15분
    private final long refreshTokenValidity = 1000L * 60 * 60 * 24 * 14; // 14일

    public String createAccessToken(String userId) {
        return createToken(userId, accessTokenValidity);
    }

    public String createRefreshToken(String userId) {
        return createToken(userId, refreshTokenValidity);
    }

    private String createToken(String userId, long validity) {
        Claims claims = Jwts.claims().setSubject(userId);
        Date now = new Date();
        Date expiry = new Date(now.getTime() + validity);

        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(now)
                .setExpiration(expiry)
                .signWith(SignatureAlgorithm.HS256, secretKey)
                .compact();
    }

    public String getUserIdFromToken(String token) {
        return Jwts.parser().setSigningKey(secretKey)
                .parseClaimsJws(token).getBody().getSubject();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
            return true;
        } catch (ExpiredJwtException e) {
            return false;
        }
    }
}

@PostMapping("/login")
public ResponseEntity<TokenResponse> login(@RequestBody LoginRequest request) {
    // 인증 처리 (생략)
    String userId = "user-id";

    String accessToken = jwtProvider.createAccessToken(userId);
    String refreshToken = jwtProvider.createRefreshToken(userId);

    // Refresh Token을 DB나 Redis에 저장
    refreshTokenService.save(userId, refreshToken);

    return ResponseEntity.ok(new TokenResponse(accessToken, refreshToken));
}

@PostMapping("/token/refresh")
public ResponseEntity<TokenResponse> refreshToken(@RequestBody TokenRequest request) {
    String refreshToken = request.getRefreshToken();

    if (!jwtProvider.validateToken(refreshToken)) {
        throw new RuntimeException("Invalid refresh token");
    }

    String userId = jwtProvider.getUserIdFromToken(refreshToken);

    // 저장된 refresh token과 비교
    String stored = refreshTokenService.get(userId);
    if (!stored.equals(refreshToken)) {
        throw new RuntimeException("Token mismatch");
    }

    String newAccessToken = jwtProvider.createAccessToken(userId);
    return ResponseEntity.ok(new TokenResponse(newAccessToken, refreshToken));
}

@Service
public class RefreshTokenService {

    private final RedisTemplate<String, String> redisTemplate;

    public RefreshTokenService(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public void save(String userId, String token) {
        redisTemplate.opsForValue().set(userId, token, 14, TimeUnit.DAYS); // 유효 기간 설정
    }

    public String get(String userId) {
        return redisTemplate.opsForValue().get(userId);
    }
}

import com.querydsl.jpa.impl.JPAQueryFactory;
import jakarta.persistence.EntityManager;
import jakarta.persistence.LockModeType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ProductService {
    private final JPAQueryFactory queryFactory;

    public ProductService(EntityManager entityManager) {
        this.queryFactory = new JPAQueryFactory(entityManager);
    }

    @Transactional
    public Product findByIdWithLock(Long productId) {
        QProduct product = QProduct.product;

        // Pessimistic Write Lock 설정
        return queryFactory.selectFrom(product)
                .where(product.id.eq(productId))
                .setLockMode(LockModeType.PESSIMISTIC_WRITE)
                .fetchOne();
    }
}