Auth 모듈 스프링 서버로 이전(~ing)

.github/workflows/server-ci-spring.yml

@@ -24,7 +24,7 @@ jobs:
           java-version: 17
           distribution: "adopt"
 
-      - name: Create application.yml
+      - name: Create application.properties
         env:
           DB_HOST_IP: ${{ secrets.SERVER_ENV_DB_HOST_IP }}
           DB_PORT: ${{ secrets.SERVER_ENV_DB_PORT }}
@@ -45,25 +45,33 @@ jobs:
           REDIS_PORT: ${{secrets.REDIS_PORT}}
           REDIS_TTL: ${{secrets.REDIS_TTL}}
         run: |
-          touch application.yml
-          echo "DB_HOST_IP=$DB_HOST_IP" >> application.yml
-          echo "DB_PORT=$DB_PORT" >> application.yml
-          echo "DB_USER_NAME=$DB_USER_NAME" >> application.yml
-          echo "DB_PASSWORD=$DB_PASSWORD" >> application.yml
-          echo "DB_DATABASE_NAME=$DB_DATABASE_NAME" >> application.yml
-          echo "ACCESS_ID=$ACCESS_ID" >> application.yml
-          echo "SECRET_ACCESS_KEY=$SECRET_ACCESS_KEY" >> application.yml
-          echo "JWT_SECRET_KEY=$JWT_SECRET_KEY" >> application.yml
-          echo "GREEN_EYE_SECRET_KEY=$GREEN_EYE_SECRET_KEY" >> application.yml
-          echo "GREEN_EYE_REQUEST_URL=$GREEN_EYE_REQUEST_URL" >> application.yml
-          echo "CLOUD_FUNCTIONS_EXECUTE_URL=$CLOUD_FUNCTIONS_EXECUTE_URL" >> application.yml
-          echo "CLOUD_FUNCTIONS_REQUEST_URL=$CLOUD_FUNCTIONS_REQUEST_URL" >> application.yml
-          echo "API_GW_ACCESS_KEY=$API_GW_ACCESS_KEY" >> application.yml
-          echo "REFRESH_SECRET_KEY=$REFRESH_SECRET_KEY" >> application.yml
-          echo "REDIS_HOST_IP=$REDIS_HOST_IP" >> application.yml
-          echo "REDIS_PASSWORD=$REDIS_PASSWORD" >> application.yml
-          echo "REDIS_PORT=$REDIS_PORT" >> application.yml
-          echo "REDIS_TTL=$REDIS_TTL" >> application.yml
+          touch application.properties
+          echo "DB_HOST_IP=$DB_HOST_IP" >> application.properties
+          echo "DB_PORT=$DB_PORT" >> application.properties
+          echo "DB_USER_NAME=$DB_USER_NAME" >> application.properties
+          echo "DB_PASSWORD=$DB_PASSWORD" >> application.properties
+          echo "DB_DATABASE_NAME=$DB_DATABASE_NAME" >> application.properties
+          echo "ACCESS_ID=$ACCESS_ID" >> application.properties
+          echo "SECRET_ACCESS_KEY=$SECRET_ACCESS_KEY" >> application.properties
+          echo "JWT_SECRET_KEY=$JWT_SECRET_KEY" >> application.properties
+          echo "GREEN_EYE_SECRET_KEY=$GREEN_EYE_SECRET_KEY" >> application.properties
+          echo "GREEN_EYE_REQUEST_URL=$GREEN_EYE_REQUEST_URL" >> application.properties
+          echo "CLOUD_FUNCTIONS_EXECUTE_URL=$CLOUD_FUNCTIONS_EXECUTE_URL" >> application.properties
+          echo "CLOUD_FUNCTIONS_REQUEST_URL=$CLOUD_FUNCTIONS_REQUEST_URL" >> application.properties
+          echo "API_GW_ACCESS_KEY=$API_GW_ACCESS_KEY" >> application.properties
+          echo "REFRESH_SECRET_KEY=$REFRESH_SECRET_KEY" >> application.properties
+          echo "REDIS_HOST_IP=$REDIS_HOST_IP" >> application.properties
+          echo "REDIS_PASSWORD=$REDIS_PASSWORD" >> application.properties
+          echo "REDIS_PORT=$REDIS_PORT" >> application.properties
+          echo "REDIS_TTL=$REDIS_TTL" >> application.properties
+
+      - name: Gradle Caching
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
 
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew

.gitignore

@@ -1,2 +1,5 @@
 # Mac Os
-.DS_Store
+.DS_Store
+
+# VSC setting
+.vscode/**

server/spring/.gitignore

@@ -5,6 +5,10 @@ build/
 !**/src/main/**/build/
 !**/src/test/**/build/
 
+### env file ###
+application.properties
+application-prod.properties
+
 ### STS ###
 .apt_generated
 .classpath

server/spring/build.gradle

@@ -23,9 +23,22 @@ repositories {
 
 dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-web'
+	implementation 'org.springframework.boot:spring-boot-starter-cache'
+	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
+	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+	implementation 'org.springframework.boot:spring-boot-starter-webflux'
+	implementation 'javax.persistence:javax.persistence-api:2.2'
+
+	implementation("org.springframework.boot:spring-boot-starter-security")
+	implementation("io.jsonwebtoken:jjwt-api:0.11.5")
+    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.11.5")
+    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.11.5")
+
 	compileOnly 'org.projectlombok:lombok'
 	runtimeOnly 'com.mysql:mysql-connector-j'
+
 	annotationProcessor 'org.projectlombok:lombok'
+
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
 }
 

server/spring/src/main/java/catchytape/spring/Application.java

@@ -2,8 +2,11 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
+import org.springframework.cache.annotation.EnableCaching;
 
-@SpringBootApplication
+@SpringBootApplication(exclude = SecurityAutoConfiguration.class)
+@EnableCaching
 public class Application {
 
 	public static void main(String[] args) {

server/spring/src/main/java/catchytape/spring/auth/config/RedisConfig.java

@@ -0,0 +1,45 @@
+package catchytape.spring.auth.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+@Configuration
+public class RedisConfig {
+
+    @Value("${spring.data.redis.host}")
+    private String host;
+
+    @Value("${spring.data.redis.port}")
+    private int port;
+
+    @Value("${spring.data.redis.password}")
+    private String password;
+
+    @Bean
+    public RedisConnectionFactory redisConnectionFactory() {
+        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
+
+        config.setHostName(host);        
+        config.setPort(port);        
+        config.setPassword(password);  
+
+        return new LettuceConnectionFactory(config);
+    }
+
+    @Bean
+    public RedisTemplate<String, String> redisTemplate() {
+        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        redisTemplate.setValueSerializer(new StringRedisSerializer());
+        redisTemplate.setConnectionFactory(redisConnectionFactory());
+
+        return redisTemplate;
+    }
+
+}

server/spring/src/main/java/catchytape/spring/auth/controller/AuthController.java

@@ -0,0 +1,61 @@
+package catchytape.spring.auth.controller;
+
+import org.springframework.web.bind.annotation.RestController;
+
+import catchytape.spring.auth.controller.dto.UserSignupRequest;
+import catchytape.spring.auth.controller.dto.UserAuthResponse;
+import catchytape.spring.auth.controller.dto.UserLoginRequest;
+import catchytape.spring.auth.controller.dto.UserRefreshRequest;
+import catchytape.spring.auth.service.AuthService;
+import catchytape.spring.auth.service.RedisService;
+import catchytape.spring.common.exception.CatchyException;
+import catchytape.spring.recentPlayed.RecentPlayed;
+import catchytape.spring.user.User;
+import lombok.AllArgsConstructor;
+import lombok.RequiredArgsConstructor;
+
+import org.springframework.web.bind.annotation.PostMapping;
+
+import java.util.List;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@RestController
+@AllArgsConstructor
+@RequestMapping("/users")
+public class AuthController {
+
+    private final AuthService authService;
+
+    @PostMapping(value="/signup", consumes="application/json;charset=UTF-8")
+    public ResponseEntity<UserAuthResponse> signup(@RequestBody UserSignupRequest request) throws CatchyException{
+        log.info("POST /users/signup - body = nickname: " + request.nickname());
+
+        return ResponseEntity.ok(authService.signup(request.idToken(), request.nickname()));
+    }
+
+    @PostMapping(value="/login", consumes="application/json;charset=UTF-8")
+    public ResponseEntity<UserAuthResponse> login(@RequestBody UserLoginRequest request) throws CatchyException {
+        log.info("POST /users/signup - body = idToken: ");
+
+        return ResponseEntity.ok(authService.login(request.idToken()));
+    }
+
+    @PostMapping(value="/refresh", consumes="application/json;charset=UTF-8")
+    public ResponseEntity<UserAuthResponse> refresh(@RequestBody UserRefreshRequest request) throws CatchyException {
+        log.info("POST /users/refresh - body = refreshToken: ", request.refreshToken());
+
+        return ResponseEntity.ok(this.authService.refreshToken(request.refreshToken()));
+    }
+
+    @GetMapping("/test")
+    public ResponseEntity<User> test() throws CatchyException {
+        return ResponseEntity.ok(this.authService.test());
+    }
+}

server/spring/src/main/java/catchytape/spring/auth/controller/dto/UserAuthResponse.java

@@ -0,0 +1,8 @@
+package catchytape.spring.auth.controller.dto;
+
+import lombok.Builder;
+
+@Builder
+public record UserAuthResponse(String accessToken, String refreshToken) {
+
+}

server/spring/src/main/java/catchytape/spring/auth/controller/dto/UserLoginRequest.java

@@ -0,0 +1,3 @@
+package catchytape.spring.auth.controller.dto;
+
+public record UserLoginRequest(String idToken) {}

server/spring/src/main/java/catchytape/spring/auth/controller/dto/UserRefreshRequest.java

@@ -0,0 +1,3 @@
+package catchytape.spring.auth.controller.dto;
+
+public record UserRefreshRequest(String refreshToken) {}

server/spring/src/main/java/catchytape/spring/auth/controller/dto/UserSignupRequest.java

@@ -0,0 +1,4 @@
+package catchytape.spring.auth.controller.dto;
+
+public record UserSignupRequest(String nickname, String idToken) {
+}

server/spring/src/main/java/catchytape/spring/auth/service/AuthService.java

@@ -0,0 +1,126 @@
+package catchytape.spring.auth.service;
+
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.reactive.function.client.WebClient;
+
+import catchytape.spring.auth.controller.dto.UserAuthResponse;
+import catchytape.spring.auth.service.dto.GoogleTokenResponse;
+import catchytape.spring.common.exception.CatchyException;
+import catchytape.spring.user.User;
+import catchytape.spring.user.UserRepository;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import java.util.UUID;
+
+@Slf4j
+@Service
+@AllArgsConstructor
+@Transactional
+public class AuthService {
+    private final RedisService redisService;
+    private final JwtService jwtService;
+    private final UserRepository userRepository;
+
+    public String getUserEmail(String googleIdToken) throws CatchyException {
+        String googleApiUrl = "https://oauth2.googleapis.com/tokeninfo?id_token="+googleIdToken;
+
+        try {
+            WebClient client = WebClient.create();
+            GoogleTokenResponse response = client.get()
+                .uri(googleApiUrl)
+                .retrieve()
+                .bodyToMono(GoogleTokenResponse.class)
+                .block();
+
+            if(response.email() == null) {
+                throw new CatchyException("UNAUTHORIZED", "EXPIRED_TOKEN");
+            }
+
+            return response.email();
+
+        } catch(Exception e) {
+            if(e instanceof CatchyException) {
+                throw e;
+            }
+
+            throw new CatchyException("INTERNAL_SERVER_ERROR", "SERVER_ERROR");
+        }
+    }
+
+    public UserAuthResponse login(String userEmail) throws CatchyException {
+        try {
+            User user = this.userRepository.findByUserEmail(userEmail);
+
+            if(user == null) {
+                throw new CatchyException("UNAUTHORIZED", "NOT_EXIST_USER");
+            }
+
+            String userId = user.getUserId();
+            String refreshId = UUID.randomUUID().toString();
+            this.redisService.setValue(refreshId, userId);
+
+            return this.jwtService.generateJwtToken(userId, refreshId);
+        } catch(Exception e) {
+            if(e instanceof CatchyException) {
+                throw e;
+            }
+
+            throw new CatchyException("INTERNAL_SERVER_ERROR", "SERVER_ERROR");
+        }
+    }
+
+    public UserAuthResponse signup(String googleIdToken, String nickname) throws CatchyException {
+        try {
+            String userEmail = this.getUserEmail(googleIdToken);
+
+            if(this.userRepository.findByUserEmail(userEmail) != null) {
+                throw new CatchyException("BAD_REQUEST", "ALREADY_EXIST_EMAIL");
+            }
+
+            String userId = UUID.randomUUID().toString();
+            User newUser = new User(userId, nickname, userEmail);
+            this.userRepository.save(newUser);
+
+            return this.login(userEmail);
+        } catch(Exception e) {
+            if(e instanceof CatchyException) {
+                throw e;
+            }
+
+            throw new CatchyException("INTERNAL_SERVER_ERROR", "SERVER_ERROR");
+        }
+    }
+
+    public UserAuthResponse refreshToken(String refreshToken) throws CatchyException {
+        try {
+            this.jwtService.isValidToken(refreshToken);
+
+            String refreshId = this.jwtService.decodeToken("refresh_id", refreshToken);
+
+            String userId = this.redisService.getValue(refreshId);
+
+            if(userId == null) {
+                throw new CatchyException("UNAUTHORIZED", "NOT_EXIST_USER");
+            }
+
+            String newRefreshId = UUID.randomUUID().toString();
+            this.redisService.deleteValue(refreshId);
+            this.redisService.setValue(newRefreshId, userId);
+
+            return this.jwtService.generateJwtToken(userId, newRefreshId);
+        } catch(Exception e) {
+            if(e instanceof CatchyException) {
+                throw e;
+            }
+
+            throw new CatchyException("INTERNAL_SERVER_ERROR", "SERVER_ERROR");
+        }
+    }
+
+    public User test() {
+        User user = this.userRepository.findByUserEmail("[email protected]");
+        return user;
+    }
+}