Feat/#7 user&oauth

build.gradle

@@ -25,10 +25,11 @@ repositories {
 
 ext {
 	mapstructVersion = "1.6.3"
-	springDocVersion = "2.5.0"
+	springDocVersion = "2.8.9"
 	jjwtVersion = "0.12.6"
 	awsSdkVersion = "2.25.68"
 	springCloudAwsVersion = "3.1.1"
+	queryDslVersion = "5.1.0"
 }
 
 dependencies {
@@ -80,6 +81,15 @@ dependencies {
 	implementation platform("io.awspring.cloud:spring-cloud-aws-dependencies:${springCloudAwsVersion}")
 	implementation 'io.awspring.cloud:spring-cloud-aws-starter-s3'
 
+	// queryDsl
+	implementation "com.querydsl:querydsl-core:${queryDslVersion}"
+	implementation "com.querydsl:querydsl-jpa:${queryDslVersion}:jakarta"
+	annotationProcessor (
+			"com.querydsl:querydsl-apt:${queryDslVersion}:jakarta",
+			// JPA 메타모델 생성용
+			"jakarta.persistence:jakarta.persistence-api:3.1.0"
+	)
+
 	// db
 	runtimeOnly 'com.h2database:h2'
 	runtimeOnly 'com.mysql:mysql-connector-j'
@@ -90,11 +100,25 @@ dependencies {
 	// redis
 	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
 
+	// Reactive 웹 프레임워크 WebFlux
+	implementation 'org.springframework.boot:spring-boot-starter-webflux'
+
 	// test
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }
 
+/** Q 클래스 생성 경로 지정 **/
+def querydslDir = layout.buildDirectory.dir("generated/querydsl").get().asFile
+
+sourceSets {
+	main { java.srcDirs += querydslDir }
+}
+
+tasks.withType(JavaCompile).configureEach {
+	options.annotationProcessorGeneratedSourcesDirectory = querydslDir
+}
+
 tasks.named('test') {
 	useJUnitPlatform()
 }

docker-compose.yml

@@ -29,6 +29,7 @@
       volumes:
         - redis-data:/data  # 데이터 지속성을 위한 볼륨 추가
       command: redis-server --appendonly yes
+      restart: unless-stopped
       healthcheck:
         test: ["CMD", "redis-cli", "ping"]
         interval: 30s

src/main/java/com/teamEWSN/gitdeun/GitdeunApplication.java

@@ -2,7 +2,12 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
+
+@EnableJpaAuditing
+@EnableScheduling
 @SpringBootApplication
 public class GitdeunApplication {
 

src/main/java/com/teamEWSN/gitdeun/common/config/CacheConfig.java

@@ -0,0 +1,35 @@
+package com.teamEWSN.gitdeun.common.config;
+
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.teamEWSN.gitdeun.common.util.CacheType;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.caffeine.CaffeineCacheManager;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.time.Duration;
+import java.util.Arrays;
+
+@Configuration
+@EnableCaching
+public class CacheConfig {
+    @Bean
+    public CacheManager cacheManager() {
+        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
+
+        // 각 캐시 타입에 대한 설정 등록
+        Arrays.stream(CacheType.values())
+            .forEach(cacheType -> {
+                cacheManager.registerCustomCache(cacheType.getCacheName(),
+                    Caffeine.newBuilder()
+                        .recordStats()   // 캐시 통계 기록
+                        .expireAfterWrite(Duration.ofHours(cacheType.getExpiredAfterWrite()))  // 항목 만료 시간
+                        .maximumSize(cacheType.getMaximumSize())  // 최대 크기
+                        .build()
+                );
+            });
+
+        return cacheManager;
+    }
+}

src/main/java/com/teamEWSN/gitdeun/common/config/QuerydslConfig.java

@@ -0,0 +1,19 @@
+package com.teamEWSN.gitdeun.common.config;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class QuerydslConfig {
+
+    @PersistenceContext
+    private EntityManager em;
+
+    @Bean
+    public JPAQueryFactory jpaQueryFactory() {
+        return new JPAQueryFactory(em);
+    }
+}

src/main/java/com/teamEWSN/gitdeun/common/config/RestTemplateConfig.java

@@ -0,0 +1,14 @@
+package com.teamEWSN.gitdeun.common.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestTemplate;
+
+@Configuration
+public class RestTemplateConfig {
+    @Bean
+    RestTemplate restTemplate() {
+        return new RestTemplate();
+    }
+
+}

src/main/java/com/teamEWSN/gitdeun/common/config/SecurityConfig.java

@@ -0,0 +1,114 @@
+package com.teamEWSN.gitdeun.common.config;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.teamEWSN.gitdeun.common.jwt.*;
+import com.teamEWSN.gitdeun.common.jwt.CustomAccessDeniedHandler;
+import com.teamEWSN.gitdeun.common.oauth.handler.CustomOAuth2FailureHandler;
+import com.teamEWSN.gitdeun.common.oauth.handler.CustomOAuth2SuccessHandler;
+import com.teamEWSN.gitdeun.common.oauth.service.CustomOAuth2UserService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
+import org.springframework.security.config.annotation.web.configurers.HeadersConfigurer;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+
+
+@Configuration
+@EnableWebSecurity
+@RequiredArgsConstructor
+@EnableMethodSecurity(prePostEnabled = true)
+public class SecurityConfig {
+
+  private final CustomOAuth2UserService customOAuth2UserService;
+  private final CustomOAuth2SuccessHandler customOAuth2SuccessHandler;
+  private final CustomOAuth2FailureHandler customOAuthFailureHandler;
+  private final JwtTokenProvider jwtTokenProvider;
+  private final ObjectMapper objectMapper;
+  private final CustomAuthenticationEntryPoint customAuthenticationEntryPoint;
+  private final CustomAccessDeniedHandler customAccessDeniedHandler;
+
+  @Bean
+  public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+
+    http
+        .csrf(AbstractHttpConfigurer::disable)
+        .cors(cors -> cors.configurationSource(corsConfigurationSource()))
+        .formLogin(AbstractHttpConfigurer::disable)
+        .httpBasic(AbstractHttpConfigurer::disable)
+        .sessionManagement(session -> session
+            .sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+        .headers((headerConfig) -> headerConfig
+            .frameOptions(HeadersConfigurer.FrameOptionsConfig::disable));
+
+    // oauth2 로그인 설정
+    http
+        .oauth2Login((oauth2) -> oauth2
+            .userInfoEndpoint(userInfoEndpointConfig -> userInfoEndpointConfig
+                .userService(customOAuth2UserService))
+//                        .defaultSuccessUrl("/oauth/success") // 로그인 성공시 이동할 URL
+            .successHandler(customOAuth2SuccessHandler)
+//                        .failureUrl("/oauth/fail") // 로그인 실패시 이동할 URL
+            .failureHandler(customOAuthFailureHandler))
+        .logout(logout -> logout
+            .logoutUrl("/logout")
+            .logoutSuccessUrl("/oauth/logout") // 로그아웃 성공시 해당 url로 이동
+            .clearAuthentication(true)  // 현재 요청의 SecurityContext 초기화
+            .deleteCookies("refreshToken")  // JWT RefreshToken 쿠키를 프론트에서 제거 명시
+        );
+
+    // 경로별 인가 작업
+    http
+        .authorizeHttpRequests((auth) -> auth
+            .requestMatchers(SecurityPath.ADMIN_ENDPOINTS).hasRole("ADMIN")
+            .requestMatchers(SecurityPath.USER_ENDPOINTS).hasAnyRole("USER", "ADMIN")
+            .requestMatchers(SecurityPath.PUBLIC_ENDPOINTS).permitAll()
+            .anyRequest().permitAll()
+            // .anyRequest().authenticated()
+        );
+
+    // 예외 처리
+    http
+        .exceptionHandling(exceptionHandling -> exceptionHandling
+            .authenticationEntryPoint(customAuthenticationEntryPoint) // 인증 실패 처리
+            .accessDeniedHandler(customAccessDeniedHandler)); // 인가 실패 처리
+
+    // JwtFilter 추가
+    http.addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider, objectMapper), UsernamePasswordAuthenticationFilter.class);
+
+    return http.build();
+  }
+
+  // CORS 설정을 위한 Bean 등록
+  @Bean
+  public CorsConfigurationSource corsConfigurationSource() {
+    CorsConfiguration configuration = getCorsConfiguration();
+    configuration.setAllowedHeaders(java.util.List.of("Authorization", "Content-Type"));
+    configuration.setExposedHeaders(java.util.List.of("Authorization"));
+    configuration.setAllowCredentials(true); // 인증 정보 허용 (쿠키 등)
+
+    org.springframework.web.cors.UrlBasedCorsConfigurationSource source = new org.springframework.web.cors.UrlBasedCorsConfigurationSource();
+    source.registerCorsConfiguration("/**", configuration); // 모든 경로에 대해 적용
+    return source;
+  }
+
+
+  private static CorsConfiguration getCorsConfiguration() {
+    CorsConfiguration configuration = new CorsConfiguration();
+    configuration.addAllowedOrigin("http://localhost:3000"); // 개발 환경
+    configuration.addAllowedOrigin("https://gitdeun.netlify.app");
+    configuration.addAllowedOrigin("https://gitdeun.site"); // 혜택온 도메인
+    configuration.addAllowedOrigin("https://www.gitdeun.site");
+    configuration.addAllowedMethod("*"); // 모든 HTTP 메서드 허용
+    configuration.addAllowedHeader("*"); // 모든 헤더 허용
+    return configuration;
+  }
+
+}

src/main/java/com/teamEWSN/gitdeun/common/config/SecurityPath.java

@@ -0,0 +1,27 @@
+package com.teamEWSN.gitdeun.common.config;
+
+
+public class SecurityPath {
+
+  // permitAll
+  public static final String[] PUBLIC_ENDPOINTS = {
+      "/api/signup",
+      "/api/login",
+      "/api/token/refresh",
+      "/api/users/check-duplicate",
+      "/"
+  };
+
+  // hasRole("USER")
+  public static final String[] USER_ENDPOINTS = {
+      "/api/users/me",
+      "/api/users/me/**",
+      "/api/logout"
+  };
+
+  // hasRole("ADMIN")
+  public static final String[] ADMIN_ENDPOINTS = {
+      "/api/admin/**"
+  };
+}
+

src/main/java/com/teamEWSN/gitdeun/common/config/WebClientConfig.java

@@ -0,0 +1,14 @@
+package com.teamEWSN.gitdeun.common.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@Configuration
+public class WebClientConfig {
+
+    @Bean
+    public WebClient webClient() {
+        return WebClient.builder().build();
+    }
+}

src/main/java/com/teamEWSN/gitdeun/common/config/redis/RedisConfig.java

@@ -0,0 +1,49 @@
+package com.teamEWSN.gitdeun.common.config.redis;
+
+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.RedisPassword;
+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.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+@Configuration
+public class RedisConfig {
+
+    @Value("${spring.data.redis.host}")
+    private String redisHost;
+
+    @Value("${spring.data.redis.port}")
+    private int redisPort;
+
+    @Value("${spring.data.redis.password}")
+    private String redisPassword;
+
+    @Bean
+    public RedisConnectionFactory redisConnectionFactory() {
+        RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
+        redisConfig.setHostName(redisHost);
+        redisConfig.setPort(redisPort);
+
+        if (!redisPassword.isEmpty()) {
+            redisConfig.setPassword(RedisPassword.of(redisPassword));
+        }
+
+        return new LettuceConnectionFactory(redisConfig);
+    }
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
+        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(redisConnectionFactory);
+
+        // Redis에 저장되는 데이터의 직렬화 방식을 지정
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
+        return redisTemplate;
+    }
+}