10์ฃผ์ฐจ ๋ฏธ์ - ์ธ์ฆ๊ณผ ์ธ๊ฐ, ํ์ด์ง ์ฒ๋ฆฌ
build.gradle โ ์์กด์ฑ ์ถ๊ฐ
implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5', 'io.jsonwebtoken:jjwt-jackson:0.11.5'
ํ์๊ฐ์
JwtTokenProvider
package com.example.baemin.util;
import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.nio.charset.StandardCharsets;
import java.security.Key;
import java.util.Date;
@Slf4j
@Component
public class JwtTokenProvider {
@Value("${secret.jwt-secret-key}")
private String JWT_SECRET_KEY;
@Value("${secret.jwt-expired-in}")
private long JWT_EXPIRED_IN;
public String createToken(String principal) {
log.info("JWT key={}", JWT_SECRET_KEY);
Claims claims = Jwts.claims().setSubject(principal);
Date now = new Date();
Date validity = new Date(now.getTime() + JWT_EXPIRED_IN);
// JWT_SECRET_KEY -> Key ๊ฐ์ฒด๋ก ๋ณํ
Key key = Keys.hmacShaKeyFor(JWT_SECRET_KEY.getBytes(StandardCharsets.UTF_8));
return Jwts.builder()
.setClaims(claims)
.setIssuedAt(now)
.setExpiration(validity)
.signWith(key, SignatureAlgorithm.HS256)
.compact();
}
}
๐ฅ 'signWith(io.jsonwebtoken.SignatureAlgorithm, java.lang.String)' is deprecated
โ secretKey(String)์ Key ๊ฐ์ฒด๋ก ๋ฃ์ด์ค๋ค!
[์ฐธ๊ณ ] https://velog.io/@chodakk/Spring-Security-Kotlin-Jwts-signWith-deprecated-์ค๋ฅ
PostUserResponse โ jwt ํ๋ ์ถ๊ฐ
UserService โ ํ์๊ฐ์ ์งํ ์ JwtTokenProvider์ createToken ๋ฉ์๋๋ฅผ ํธ์ถํด์ ํ ํฐ์ ๋ฐ๊ธํด์ฃผ๊ณ , PostUserResponse(userId, jwt)๋ฅผ ๋ฆฌํดํ๋ค.
๋ก๊ทธ์ธ
์ธ๊ฐ
JwtTokenProvider
public String getPrincipal(String token) {
return Jwts.parserBuilder()
.setSigningKey(getKey(JWT_SECRET_KEY)).build()
.parseClaimsJws(token)
.getBody().getSubject();
}
public boolean isExpiredToken(String token) throws JwtInvalidTokenException {
try {
Jws<Claims> claims = Jwts.parserBuilder()
.setSigningKey(getKey(JWT_SECRET_KEY)).build()
.parseClaimsJws(token);
return claims.getBody().getExpiration().before(new Date());
} catch (ExpiredJwtException e) {
return true;
} catch (UnsupportedJwtException e) {
throw new JwtUnsupportedTokenException(UNSUPPORTED_TOKEN_TYPE);
} catch (MalformedJwtException e) {
throw new JwtMalformedTokenException(MALFORMED_TOKEN);
} catch (IllegalArgumentException e) {
throw new JwtInvalidTokenException(INVALID_TOKEN);
} catch (JwtException e) {
log.error("[JwtTokenProvider.validateAccessToken]", e);
throw e;
}
}
private Key getKey(String key) {
return Keys.hmacShaKeyFor(key.getBytes(StandardCharsets.UTF_8));
}
JwtAuthInterceptor
package com.example.baemin.common.interceptor;
import com.example.baemin.common.exception.jwt.JwtExpiredTokenException;
import com.example.baemin.common.exception.jwt.JwtInvalidTokenException;
import com.example.baemin.common.exception.jwt.JwtNoTokenException;
import com.example.baemin.common.exception.jwt.JwtUnsupportedTokenException;
import com.example.baemin.service.AuthService;
import com.example.baemin.util.JwtTokenProvider;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import static com.example.baemin.common.response.status.BaseExceptionResponseStatus.*;
@Slf4j
@Component
@RequiredArgsConstructor
public class JwtAuthInterceptor implements HandlerInterceptor {
private static final String JWT_TOKEN_PREFIX = "Bearer ";
private final JwtTokenProvider jwtTokenProvider;
private final AuthService authService;
// ์ธ๊ฐ ๊ณผ์ -> ์ปจํธ๋กค๋ฌ ํธ์ถ ์ ์ ์งํ๋์ด์ผ ํ๋ค.
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
log.info("[JwtAuthInterceptor.preHandle]");
String accessToken = resolveAccessToken(request);
validateAccessToken(accessToken);
String email = jwtTokenProvider.getPrincipal(accessToken);
validatePayload(email);
long userId = authService.getUserIdByEmail(email);
request.setAttribute("userId", userId);
return true;
}
private String resolveAccessToken(HttpServletRequest request) {
String token = request.getHeader(HttpHeaders.AUTHORIZATION);
validateToken(token);
return token.substring(JWT_TOKEN_PREFIX.length());
}
private void validateToken(String token) {
if (token == null) {
throw new JwtNoTokenException(TOKEN_NOT_FOUND);
}
if (!token.startsWith(JWT_TOKEN_PREFIX)) {
throw new JwtUnsupportedTokenException(UNSUPPORTED_TOKEN_TYPE);
}
}
private void validateAccessToken(String accessToken) {
if (jwtTokenProvider.isExpiredToken(accessToken)) {
throw new JwtExpiredTokenException(EXPIRED_TOKEN);
}
}
private void validatePayload(String email) {
if (email == null) {
throw new JwtInvalidTokenException(INVALID_TOKEN);
}
}
}
PreAuthorize (์ฌ์ฉ์ ์ ์ ์ด๋ ธํ ์ด์ )
package com.example.baemin.common.argument_resolver;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface PreAuthorize {
}
JwtAuthHandlerArgumentResolver
package com.example.baemin.common.argument_resolver;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
@Slf4j
@Component
public class JwtAuthHandlerArgumentResolver implements HandlerMethodArgumentResolver {
// ArgumentResolver๊ฐ ํด๋น ํ๋ผ๋ฏธํฐ๋ฅผ ์ง์ํ๋์ง ๋จผ์ ์ฒดํฌ
@Override
public boolean supportsParameter(MethodParameter parameter) {
log.info("[JwtAuthHandlerArgumentResolver.supportsParameter]");
boolean hasAnnotation = parameter.hasParameterAnnotation(PreAuthorize.class);
boolean hasType = long.class.isAssignableFrom(parameter.getParameterType());
return hasAnnotation && hasType;
}
// ์ง์๋๋ ํ๋ผ๋ฏธํฐ๋ผ๋ฉด ์ปจํธ๋กค๋ฌ๊ฐ ํธ์ถ๋๊ธฐ ์ง์ ์ ํด๋น ๋ฉ์๋ ํธ์ถ
// -> ํ์ํ ํ๋ผ๋ฏธํฐ ์ ๋ณด๋ฅผ ์์ฑํด์ ๋ฃ์ด์ค๋ค.
@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
log.info("[JwtAuthHandlerArgumentResolver.resolveArgument]");
HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
return request.getAttribute("userId");
}
}
WebConfig
package com.example.baemin.config;
import com.example.baemin.common.argument_resolver.JwtAuthHandlerArgumentResolver;
import com.example.baemin.common.interceptor.JwtAuthInterceptor;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.List;
@Configuration
@RequiredArgsConstructor
public class WebConfig implements WebMvcConfigurer {
private final JwtAuthInterceptor jwtAuthenticationInterceptor;
private final JwtAuthHandlerArgumentResolver jwtAuthHandlerArgumentResolver;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(jwtAuthenticationInterceptor)
.order(1)
.addPathPatterns("/auth/test",
"/users/nickname", "/users/address", "/users/address/{addressId}/status", "/users/deleted");
}
@Override
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
resolvers.add(jwtAuthHandlerArgumentResolver);
}
}
JWT ์์ธ ์ฒ๋ฆฌ
๋๋ค์ ๋ณ๊ฒฝ, ํ์ ํํด, ์ฃผ์ ๋ฑ๋ก/์กฐํ/์ํ ๋ณ๊ฒฝ API โ ์ธ๊ฐ ๊ตฌํ
public List<GetStoreResponse> getStores(long lastId) {
String sql = "select store.store_id, store.name, store.category, store_delivery.delivery_tip_max, store_delivery.least_order_price " +
"from store, store_delivery " +
"where store.store_id = store_delivery.store_id " +
"and store.store_id > :lastId limit 10";
Map<String, Object> param = Map.of("lastId", lastId);
return jdbcTemplate.query(sql, param,
(rs, rowNum) -> new GetStoreResponse(
rs.getLong("store_id"),
rs.getString("name"),
rs.getString("category"),
rs.getInt("delivery_tip_max"),
rs.getInt("least_order_price"))
);
}
Refresh Token ํ๋ ค๊ณ ํ๋๋ฐ ๊น๋นกํ๋ค ! ! ! ๋์ค์ . . .