소셜 로그인 템플릿 적용

build.gradle

@@ -25,13 +25,30 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'
     implementation 'org.springframework.boot:spring-boot-starter-security'
+    implementation 'org.springframework.boot:spring-boot-starter-validation'
     implementation 'org.springframework.boot:spring-boot-starter-web'
     compileOnly 'org.projectlombok:lombok'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'
     runtimeOnly 'com.mysql:mysql-connector-j'
     annotationProcessor 'org.projectlombok:lombok'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'org.springframework.security:spring-security-test'
+
+    // Redis
+    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
+
+    // jwt
+    implementation group: 'io.jsonwebtoken', name: 'jjwt-api', version: '0.11.5'
+    runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-impl', version: '0.11.5'
+    runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-jackson', version: '0.11.5'
+
+    // Swagger
+    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2'
+
+    // Apple 로그인 연동시 필요한 설정
+    implementation group: 'com.nimbusds', name: 'nimbus-jose-jwt', version: '9.30.1'
+    implementation group: 'org.bouncycastle', name: 'bcpkix-jdk15on', version: '1.70'
+    implementation 'org.apache.directory.studio:org.apache.commons.io:2.4'
 }
 
 tasks.named('test') {

src/main/java/dorun/project/routineapp/RoutineAppApplication.java

@@ -1,9 +1,16 @@
 package dorun.project.routineapp;
 
+import dorun.project.routineapp.config.properties.AppProperties;
+import dorun.project.routineapp.config.properties.CorsProperties;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
 
 @SpringBootApplication
+@EnableConfigurationProperties({
+        CorsProperties.class,
+        AppProperties.class
+})
 public class RoutineAppApplication {
 
     public static void main(String[] args) {

src/main/java/dorun/project/routineapp/api/controller/AuthController.java

@@ -0,0 +1,92 @@
+package dorun.project.routineapp.api.controller;
+
+import dorun.project.routineapp.api.entity.RefreshToken;
+import dorun.project.routineapp.common.APIResponse;
+import dorun.project.routineapp.config.properties.AppProperties;
+import dorun.project.routineapp.oauth.entity.RoleType;
+import dorun.project.routineapp.oauth.token.Token;
+import dorun.project.routineapp.oauth.token.TokenProvider;
+import dorun.project.routineapp.oauth.util.HeaderUtil;
+import dorun.project.routineapp.api.repository.RefreshTokenRepository;
+import io.jsonwebtoken.Claims;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/v1/auth")
+@RequiredArgsConstructor
+public class AuthController {
+    private final AppProperties appProperties;
+    private final TokenProvider tokenProvider;
+    private final RefreshTokenRepository refreshTokenRepository;
+
+    private static final long UPDATE_TOKEN_STRATEGY = 259200000; // 3일
+    private static final String ACCESS_TOKEN = "access_token";
+    private static final String REFRESH_TOKEN = "refresh_token";
+
+    @PostMapping("/refresh")
+    public APIResponse<Map<String, String>> refreshToken(HttpServletRequest request, HttpServletResponse response) {
+        String accessToken = HeaderUtil.getToken(request, ACCESS_TOKEN);
+        Token authToken = tokenProvider.convertToken(accessToken);
+        if (!authToken.validate()) {
+            return APIResponse.invalidRefreshToken();
+        }
+
+        Claims claims = authToken.getExpiredTokenClaims();
+        if (claims == null) {
+            return APIResponse.notExpiredTokenYet();
+        }
+
+        String userId = claims.getSubject();
+        RoleType roleType = RoleType.of(claims.get("role", String.class));
+
+        String refreshToken = HeaderUtil.getToken(request, REFRESH_TOKEN);
+        Token authRefreshToken = tokenProvider.convertToken(refreshToken);
+
+        if (authRefreshToken.validate()) {
+            return APIResponse.invalidRefreshToken();
+        }
+
+        Optional<RefreshToken> searchedRefreshToken = refreshTokenRepository.findByUserId(userId);
+        RefreshToken userRefreshToken;
+        if (searchedRefreshToken.isEmpty()) {
+            return APIResponse.invalidRefreshToken();
+        }
+        userRefreshToken = searchedRefreshToken.get();
+
+        Date now = new Date();
+        Token newAccessToken = tokenProvider.createToken(
+                userId,
+                roleType.getCode(),
+                new Date(now.getTime() + appProperties.getAuth().getTokenExpiry())
+        );
+
+        long validTime = authRefreshToken.getTokenClaims().getExpiration().getTime() - now.getTime();
+
+        if (validTime <= UPDATE_TOKEN_STRATEGY) {
+            long refreshTokenExpiry = appProperties.getAuth().getRefreshTokenExpiry();
+
+            authRefreshToken = tokenProvider.createToken(
+                    appProperties.getAuth().getTokenSecret(),
+                    new Date(now.getTime() + refreshTokenExpiry)
+            );
+
+            userRefreshToken.updateRefreshToken(authRefreshToken.getToken());
+            refreshTokenRepository.save(userRefreshToken);
+        }
+
+        Map<String, String> tokens = new HashMap<>();
+        tokens.put(ACCESS_TOKEN, newAccessToken.getToken());
+        tokens.put(REFRESH_TOKEN, userRefreshToken.getRefreshToken());
+
+        return APIResponse.success("tokens", tokens);
+    }
+}

src/main/java/dorun/project/routineapp/api/entity/BaseEntity.java

@@ -0,0 +1,24 @@
+package dorun.project.routineapp.api.entity;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.EntityListeners;
+import jakarta.persistence.MappedSuperclass;
+import java.time.LocalDateTime;
+import lombok.Getter;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+@MappedSuperclass
+@Getter
+@EntityListeners(AuditingEntityListener.class)
+public abstract class BaseEntity {
+
+    @Column(name = "CREATED_AT")
+    @CreatedDate
+    private LocalDateTime createdAt;
+
+    @Column(name = "MODIFIED_AT")
+    @LastModifiedDate
+    private LocalDateTime modifiedAt;
+}

src/main/java/dorun/project/routineapp/api/entity/RefreshToken.java

@@ -0,0 +1,22 @@
+package dorun.project.routineapp.api.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.redis.core.RedisHash;
+import org.springframework.data.redis.core.index.Indexed;
+
+@Getter
+@AllArgsConstructor
+@RedisHash(value = "refreshToken", timeToLive = 60 * 60 * 24 * 3)
+public class RefreshToken {
+    @Id
+    private String UUID;
+    @Indexed
+    private String userId;
+    private String refreshToken;
+
+    public void updateRefreshToken(String refreshToken) {
+        this.refreshToken = refreshToken;
+    }
+}

src/main/java/dorun/project/routineapp/api/entity/User.java

@@ -0,0 +1,81 @@
+package dorun.project.routineapp.api.entity;
+
+import dorun.project.routineapp.oauth.entity.ProviderType;
+import dorun.project.routineapp.oauth.entity.RoleType;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Builder
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "USER")
+public class User extends BaseEntity {
+    @JsonIgnore
+    @Id
+    @Column(name = "USER_SEQ")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long userSeq;
+
+    @Column(name = "USER_ID", length = 64, unique = true)
+    @NotNull
+    @Size(max = 64)
+    private String userId;
+
+    @Column(name = "USERNAME", length = 100)
+    @NotNull
+    @Size(max = 100)
+    private String username;
+
+    @JsonIgnore
+    @Column(name = "PASSWORD", length = 128)
+    @NotNull
+    @Size(max = 128)
+    private String password;
+
+    @Column(name = "EMAIL", length = 512, unique = true)
+    @NotNull
+    @Size(max = 512)
+    private String email;
+
+    @Column(name = "PROVIDER_TYPE", length = 20)
+    @Enumerated(EnumType.STRING)
+    @NotNull
+    private ProviderType providerType;
+
+    @Column(name = "ROLE_TYPE", length = 20)
+    @Enumerated(EnumType.STRING)
+    @NotNull
+    private RoleType roleType;
+
+    public User(
+            @NotNull @Size(max = 64) String userId,
+            @NotNull @Size(max = 100) String username,
+            @NotNull @Size(max = 512) String email,
+            @NotNull ProviderType providerType,
+            @NotNull RoleType roleType
+    ) {
+        this.userId = userId;
+        this.username = username;
+        this.password = "NO_PASS";
+        this.email = email != null ? email : "NO_EMAIL";
+        this.providerType = providerType;
+        this.roleType = roleType;
+    }
+}

src/main/java/dorun/project/routineapp/api/repository/RefreshTokenRepository.java

@@ -0,0 +1,11 @@
+package dorun.project.routineapp.api.repository;
+
+import dorun.project.routineapp.api.entity.RefreshToken;
+import java.util.Optional;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface RefreshTokenRepository extends CrudRepository<RefreshToken, String> {
+    Optional<RefreshToken> findByUserId(String userId);
+}

src/main/java/dorun/project/routineapp/api/repository/UserRepository.java

@@ -0,0 +1,10 @@
+package dorun.project.routineapp.api.repository;
+
+import dorun.project.routineapp.api.entity.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+    User findByUserId(String userId);
+}

src/main/java/dorun/project/routineapp/common/APIResponse.java

@@ -0,0 +1,47 @@
+package dorun.project.routineapp.common;
+
+import java.util.HashMap;
+import java.util.Map;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public class APIResponse<T> {
+
+    private final static int SUCCESS = 200;
+    private final static int NOT_FOUND = 400;
+    private final static int FAILED = 500;
+    private final static String SUCCESS_MESSAGE = "SUCCESS";
+    private final static String NOT_FOUND_MESSAGE = "NOT FOUND";
+    private final static String FAILED_MESSAGE = "서버에서 오류가 발생하였습니다.";
+    private final static String INVALID_ACCESS_TOKEN = "Access Token이 유효하지 않습니다.";
+    private final static String INVALID_REFRESH_TOKEN = "Refresh Token이 유효하지 않습니다.";
+    private final static String NOT_EXPIRED_TOKEN_YET = "Token이 아직 만료되지 않았습니다.";
+
+    private final APIResponseHeader header;
+    private final Map<String, T> body;
+
+    public static <T> APIResponse<T> success(String name, T body) {
+        Map<String, T> map = new HashMap<>();
+        map.put(name, body);
+
+        return new APIResponse<>(new APIResponseHeader(SUCCESS, SUCCESS_MESSAGE), map);
+    }
+
+    public static <T> APIResponse<T> fail() {
+        return new APIResponse<>(new APIResponseHeader(FAILED, FAILED_MESSAGE), null);
+    }
+
+    public static <T> APIResponse<T> invalidAccessToken() {
+        return new APIResponse<>(new APIResponseHeader(FAILED, INVALID_ACCESS_TOKEN), null);
+    }
+
+    public static <T> APIResponse<T> invalidRefreshToken() {
+        return new APIResponse<>(new APIResponseHeader(FAILED, INVALID_REFRESH_TOKEN), null);
+    }
+
+    public static <T> APIResponse<T> notExpiredTokenYet() {
+        return new APIResponse<>(new APIResponseHeader(FAILED, NOT_EXPIRED_TOKEN_YET), null);
+    }
+}

src/main/java/dorun/project/routineapp/common/APIResponseHeader.java

@@ -0,0 +1,13 @@
+package dorun.project.routineapp.common;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public class APIResponseHeader {
+    private int code;
+    private String message;
+}

src/main/java/dorun/project/routineapp/config/JwtConfig.java

@@ -0,0 +1,17 @@
+package dorun.project.routineapp.config;
+
+import dorun.project.routineapp.oauth.token.TokenProvider;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class JwtConfig {
+    @Value("${jwt.secret}")
+    private String secret;
+
+    @Bean
+    public TokenProvider jwtProvider() {
+        return new TokenProvider(secret);
+    }
+}

src/main/java/dorun/project/routineapp/config/OpenApiConfig.java

@@ -0,0 +1,21 @@
+package dorun.project.routineapp.config;
+
+import io.swagger.v3.oas.models.Components;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Info;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class OpenApiConfig {
+    @Bean
+    public OpenAPI openAPI() {
+        Info info = new Info()
+                .title("소셜 로그인 템플릿 프로젝트 API Document")
+                .version("v0.0.1")
+                .description("소셜 로그인 템플릿 프로젝트의 API 명세서입니다.");
+        return new OpenAPI()
+                .components(new Components())
+                .info(info);
+    }
+}