[Spring Data JPA] 신혜빈 미션 제출합니다.

.run/MissionStepTest.삼단계.run.xml

@@ -0,0 +1,31 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="MissionStepTest.삼단계" type="GradleRunConfiguration" factoryName="Gradle">
+    <ExternalSystemSettings>
+      <option name="env">
+        <map>
+          <entry key="JWT_SECRET_KEY" value="bOjgcSvj4CvncQT6+XFS7IJSdTCvsSdIjLaVBAyKG6g=" />
+        </map>
+      </option>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value=":test" />
+          <option value="--tests" />
+          <option value="&quot;roomescape.MissionStepTest.삼단계&quot;" />
+        </list>
+      </option>
+      <option name="vmOptions" />
+    </ExternalSystemSettings>
+    <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
+    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
+    <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>true</RunAsTest>
+    <method v="2" />
+  </configuration>
+</component>

build.gradle

@@ -15,7 +15,7 @@ repositories {
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
-    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
 
     implementation 'dev.akkinoc.spring.boot:logback-access-spring-boot-starter:4.0.0'
 
@@ -26,7 +26,12 @@ dependencies {
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'io.rest-assured:rest-assured:5.3.1'
 
+    implementation 'com.h2database:h2'
     runtimeOnly 'com.h2database:h2'
+
+    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.1.0'
+    implementation 'jakarta.servlet:jakarta.servlet-api:6.0.0'
+
 }
 
 test {

src/main/java/jwt/JwtConfiguration.java

@@ -0,0 +1,17 @@
+package jwt;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class JwtConfiguration {
+
+    @Value("${jwt.secret}")
+    private String secretKey;
+
+    @Bean
+    public JwtUtils jwtUtils() {
+        return new JwtUtils();
+    }
+}

src/main/java/jwt/JwtService.java

@@ -0,0 +1,35 @@
+package jwt;
+
+import io.jsonwebtoken.Claims;
+import org.springframework.stereotype.Service;
+import roomescape.member.Member;
+import roomescape.member.MemberRepository;
+
+@Service
+public class JwtService {
+    private final JwtUtils jwtUtils;
+    private final MemberRepository memberRepository;
+
+    public JwtService(JwtUtils jwtUtils, MemberRepository memberRepository) {
+        this.jwtUtils = jwtUtils;
+        this.memberRepository = memberRepository;
+    }
+
+    public Long getUserIdFromToken(String token) {
+        Claims claims = jwtUtils.getClaimsFromToken(token);
+        try {
+            return Long.valueOf(claims.getSubject());
+        } catch (Exception e) {
+            throw new IllegalArgumentException("Claims에서 User ID를 추출할 수 없습니다.", e);
+        }
+    }
+
+    public Member getMemberFromToken(String token) {
+        Long userId = getUserIdFromToken(token);
+        Member member = memberRepository.findById(userId).get();
+        if (member == null) {
+            throw new IllegalArgumentException("토큰으로부터 유저를 찾을 수 없습니다.");
+        }
+        return member;
+    }
+}

src/main/java/jwt/JwtUtils.java

@@ -0,0 +1,49 @@
+package jwt;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import org.springframework.beans.factory.annotation.Value;
+import roomescape.member.Role;
+
+import javax.crypto.spec.SecretKeySpec;
+import java.security.Key;
+import java.util.Date;
+
+public class JwtUtils {
+    private static final long EXPIRATION_TIME = 86400000;
+    private String secretKey;
+
+    @Value("${jwt.secret}")
+    public void setSecretKey(String secretKey) {
+        this.secretKey = secretKey;
+    }
+
+    private Key generateKey() {
+        return new SecretKeySpec(secretKey.getBytes(), SignatureAlgorithm.HS256.getJcaName());
+    }
+
+    public String generateToken(Long userId, Role role) {
+        Key key = generateKey();
+        return Jwts.builder()
+                .setSubject(String.valueOf(userId))
+                .claim("role", role.name())
+                .setIssuedAt(new Date())
+                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
+                .signWith(key, SignatureAlgorithm.HS256)
+                .compact();
+    }
+
+    public Claims getClaimsFromToken(String token) {
+        try {
+            Key key = generateKey();
+            return Jwts.parserBuilder()
+                    .setSigningKey(key)
+                    .build()
+                    .parseClaimsJws(token)
+                    .getBody();
+        } catch (Exception e) {
+            throw new IllegalArgumentException("유효하지 않은 토큰입니다.", e);
+        }
+    }
+}

src/main/java/roomescape/ExceptionController.java

@@ -1,14 +1,33 @@
 package roomescape;
 
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ControllerAdvice;
 import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.HashMap;
+import java.util.Map;
 
 @ControllerAdvice
 public class ExceptionController {
+
+    @ExceptionHandler(ResponseStatusException.class)
+    public ResponseEntity<Void> handleResponseStatusException(ResponseStatusException e) {
+        return ResponseEntity.status(e.getStatusCode()).build();
+    }
+
+    @ExceptionHandler(IllegalArgumentException.class)
+    public ResponseEntity<Map<String, Object>> handleIllegalArgumentException(IllegalArgumentException e) {
+        Map<String, Object> errorResponse = new HashMap<>();
+        errorResponse.put("message", e.getMessage());
+        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(errorResponse);
+    }
+
     @ExceptionHandler(Exception.class)
     public ResponseEntity<Void> handleRuntimeException(Exception e) {
         e.printStackTrace();
         return ResponseEntity.badRequest().build();
     }
 }
+

src/main/java/roomescape/RoomescapeApplication.java

@@ -2,8 +2,10 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.ComponentScan;
 
 @SpringBootApplication
+@ComponentScan(basePackages = {"roomescape", "jwt"})
 public class RoomescapeApplication {
     public static void main(String[] args) {
         SpringApplication.run(RoomescapeApplication.class, args);

src/main/java/roomescape/SwaggerConfig.java

@@ -0,0 +1,51 @@
+package roomescape;
+
+
+import io.swagger.v3.oas.annotations.OpenAPIDefinition;
+import io.swagger.v3.oas.annotations.info.Info;
+import io.swagger.v3.oas.models.Components;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.security.SecurityRequirement;
+import io.swagger.v3.oas.models.security.SecurityScheme;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+
+@OpenAPIDefinition(
+        info = @Info(
+                title = "roomescape API 명세서",
+                description = "roomescape 서비스 API 명세서",
+                version = "v1"
+        )
+)
+
+@Configuration
+public class SwaggerConfig {
+
+    @Bean
+    public OpenAPI customOpenAPI() {
+        return new OpenAPI()
+                .addSecurityItem(new SecurityRequirement().addList("bearerAuth"))
+                .components(new Components()
+                        .addSecuritySchemes("bearerAuth",
+                                new SecurityScheme()
+                                        .type(SecurityScheme.Type.HTTP)
+                                        .scheme("bearer")
+                                        .bearerFormat("JWT")));
+    }
+
+    @Bean
+    public CorsConfigurationSource corsConfigurationSource() {
+        CorsConfiguration configuration = new CorsConfiguration();
+        configuration.addAllowedOriginPattern("*");
+        configuration.addAllowedMethod("*");
+        configuration.addAllowedHeader("*");
+        configuration.setAllowCredentials(true);
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        source.registerCorsConfiguration("/**", configuration);
+        return source;
+    }
+}
+

src/main/java/roomescape/auth/AdminInterceptor.java

@@ -0,0 +1,50 @@
+package roomescape.auth;
+
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jwt.JwtService;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Component;
+import org.springframework.web.server.ResponseStatusException;
+import org.springframework.web.servlet.HandlerInterceptor;
+import roomescape.member.Member;
+import roomescape.member.Role;
+
+import java.util.Arrays;
+
+@Component
+public class AdminInterceptor implements HandlerInterceptor {
+    private final JwtService jwtService;
+
+    public AdminInterceptor(JwtService jwtService) {
+        this.jwtService = jwtService;
+    }
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
+        String token = extractTokenFromCookies(request.getCookies());
+        if (token == null) {
+            throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "토큰을 찾을 수 없습니다.");
+        }
+
+        Member member = jwtService.getMemberFromToken(token);
+        if (!Role.ADMIN.equals(member.getRole())) {
+            throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "사용자를 찾을 수 없습니다.");
+        }
+
+        return true;
+    }
+
+    private String extractTokenFromCookies(Cookie[] cookies) {
+        if (cookies == null) {
+            return null;
+        }
+
+        return Arrays.stream(cookies)
+                .filter(cookie -> "token".equals(cookie.getName()))
+                .map(Cookie::getValue)
+                .findFirst()
+                .orElse(null);
+    }
+}

src/main/java/roomescape/auth/Authentication.java

@@ -0,0 +1,9 @@
+package roomescape.auth;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Authentication {
+}

src/main/java/roomescape/auth/AuthenticationArgumentResolver.java

@@ -0,0 +1,36 @@
+package roomescape.auth;
+
+import jwt.JwtService;
+import org.springframework.beans.factory.annotation.Autowired;
+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;
+import roomescape.member.Member;
+
+@Component
+public class AuthenticationArgumentResolver implements HandlerMethodArgumentResolver {
+
+    @Autowired
+    private JwtService jwtService;
+
+    @Override
+    public boolean supportsParameter(MethodParameter parameter) {
+        return parameter.hasParameterAnnotation(Authentication.class)
+                && parameter.getParameterType().equals(Member.class);
+    }
+
+    @Override
+    public Object resolveArgument(MethodParameter parameter,
+                                  ModelAndViewContainer mavContainer,
+                                  NativeWebRequest webRequest,
+                                  WebDataBinderFactory binderFactory) {
+
+        String token = CookieUtil.extractTokenFromHeader(webRequest)
+                .orElseThrow(() -> new IllegalArgumentException("토큰이 존재하지 않습니다. 로그인이 필요합니다."));
+
+        return jwtService.getMemberFromToken(token);
+    }
+}

src/main/java/roomescape/auth/CookieUtil.java

@@ -0,0 +1,32 @@
+package roomescape.auth;
+
+import jakarta.servlet.http.Cookie;
+import org.springframework.web.context.request.NativeWebRequest;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+public class CookieUtil {
+
+    public static Optional<String> extractTokenFromCookies(Cookie[] cookies) {
+        if (cookies == null) {
+            return Optional.empty();
+        }
+        return Arrays.stream(cookies)
+                .filter(cookie -> "token".equals(cookie.getName()))
+                .map(Cookie::getValue)
+                .findFirst();
+    }
+
+    public static Optional<String> extractTokenFromHeader(NativeWebRequest webRequest) {
+        String cookieHeader = webRequest.getHeader("Cookie");
+        if (cookieHeader == null) {
+            return Optional.empty();
+        }
+        return Arrays.stream(cookieHeader.split(";"))
+                .map(String::trim)
+                .filter(cookie -> cookie.startsWith("token="))
+                .map(cookie -> cookie.substring("token=".length()))
+                .findFirst();
+    }
+}