Release/#145 v01 develop

build.gradle

@@ -26,6 +26,7 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-websocket'
 	implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.16'
 	implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity6'
+	implementation 'nz.net.ultraq.thymeleaf:thymeleaf-layout-dialect'
 	compileOnly 'org.projectlombok:lombok'
 	developmentOnly 'org.springframework.boot:spring-boot-devtools'
 	developmentOnly 'org.springframework.boot:spring-boot-docker-compose'
@@ -37,6 +38,37 @@ dependencies {
 	testCompileOnly 'org.projectlombok:lombok'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 	testAnnotationProcessor 'org.projectlombok:lombok'
+
+	// QueryDSL
+	implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'
+	annotationProcessor 'com.querydsl:querydsl-apt:5.0.0:jakarta'
+	annotationProcessor 'jakarta.annotation:jakarta.annotation-api'
+	annotationProcessor 'jakarta.persistence:jakarta.persistence-api'
+
+	// 인증 메일
+	implementation 'org.springframework.boot:spring-boot-starter-mail'
+
+  // JWT
+  implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
+  runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5'
+  runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.5'
+}
+
+// Q클래스 경로설정
+def generated = 'src/main/generated'
+
+// 경로에 저장
+tasks.withType(JavaCompile) {
+	options.getGeneratedSourceOutputDirectory().set(file(generated))
+}
+
+// 소스 폴더 인식
+sourceSets {
+	main.java.srcDirs += [generated]
+}
+
+clean {
+	delete file(generated)
 }
 
 tasks.named('test') {

src/main/java/com/knoc/KnocApplication.java

@@ -2,7 +2,11 @@
 
 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 KnocApplication {
 

src/main/java/com/knoc/auth/controller/AuthController.java

@@ -0,0 +1,62 @@
+package com.knoc.auth.controller;
+
+import com.knoc.auth.dto.SignUpDto;
+import com.knoc.global.exception.BusinessException;
+import com.knoc.member.service.MemberService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.validation.BindingResult;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.ModelAttribute;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+@Tag(name="Auth-Controller",description = "회원 인증 관련 API")
+@Controller
+@RequestMapping("/auth")
+@RequiredArgsConstructor
+public class AuthController {
+
+    private final MemberService memberService;
+
+    @Operation(summary = "로그인 페이지 조회", description = "로그인 폼 화면을 반환합니다.")
+    @GetMapping("/login")
+    public String loginForm() {
+        return "auth/login";
+    }
+
+    @Operation(summary = "회원가입 페이지 조회", description = "회원가입 폼 화면을 반환합니다.")
+    @GetMapping("/signup")
+    public String signUpForm(Model model) {
+        model.addAttribute("signupDto", new SignUpDto());
+        return "auth/signup";
+    }
+
+    @Operation(summary = "회원가입 처리", description = "전달받은 정보를 바탕으로 회원가입을 처리합니다.")
+    @PostMapping("/signup")
+    public String processSignUp(@Valid @ModelAttribute("signupDto") SignUpDto dto, BindingResult bindingResult, Model model, RedirectAttributes redirectAttributes) {
+
+        if (dto.getPassword() != null && !dto.getPassword().equals(dto.getPasswordConfirm())) {
+            bindingResult.rejectValue("passwordConfirm", "passwordInCorrect", "비밀번호가 일치하지 않습니다.");
+        }
+        //  폼 형식 검증 에러 처리 (비밀번호 자리수, 이메일 형식 등)
+        if(bindingResult.hasErrors()) {
+            return "auth/signup"; // 에러가 있으면 다시 회원가입 페이지
+        }
+        // 이메일, 닉네임 중복 검사
+        try {
+            memberService.registerMember(dto);
+            redirectAttributes.addFlashAttribute("successMessage", "회원가입이 완료되었습니다!");
+            return "redirect:/auth/login"; // 성공 시 로그인 페이지로 이동
+        } catch(BusinessException e) {
+            model.addAttribute("errorMessage", e.getMessage());
+            model.addAttribute("signupDto", dto);
+            return "auth/signup"; // 에러 발생 시 에러 메시지 출력 후 화원가입 페이지 유지
+        }
+    }
+}

src/main/java/com/knoc/auth/dto/SignUpDto.java

@@ -0,0 +1,26 @@
+package com.knoc.auth.dto;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter @Setter
+public class SignUpDto {
+    @NotBlank(message = "닉네임은 필수 입력값입니다.")
+    @Size(min = 2, max = 10, message = "닉네임은 2~10자리여야 합니다.")
+    private String nickname;
+
+    @NotBlank(message = "이메일은 필수 입력값입니다.")
+    @Email(message = "올바른 이메일 형식이 아닙니다.")
+    private String email;
+
+    @NotBlank(message = "비밀번호는 필수 입력값입니다.")
+    @Pattern(regexp = "(?=.*[0-9])(?=.*[a-zA-Z])(?=.*\\W)(?=\\S+$).{8,16}", message = "비밀번호는 8~16자 영문, 숫자, 특수문자를 사용하세요.")
+    private String password;
+
+    @NotBlank(message = "비밀번호 확인은 필수 입력값입니다.")
+    private String passwordConfirm;
+}

src/main/java/com/knoc/auth/jwt/JwtAuthenticationFilter.java

@@ -0,0 +1,79 @@
+package com.knoc.auth.jwt;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+@RequiredArgsConstructor
+public class JwtAuthenticationFilter extends OncePerRequestFilter {
+
+    private final JwtTokenProvider jwtTokenProvider;
+    private final UserDetailsService userDetailsService;
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
+            throws ServletException, IOException {
+
+        String accessToken = getCookieValue(request, "accessToken");
+        String refreshToken = getCookieValue(request, "refreshToken");
+
+        // access token 살아있으면 통과
+        if(accessToken != null && jwtTokenProvider.validateToken(accessToken)) {
+            setAuthentication(jwtTokenProvider.getEmailFromToken(accessToken));
+        }
+        // access token 만료, refresh token이 유효하면 access token 재발급
+        else if(refreshToken != null && jwtTokenProvider.validateToken(refreshToken)) {
+            String email = jwtTokenProvider.getEmailFromToken(refreshToken);
+            UserDetails userDetails = userDetailsService.loadUserByUsername(email);
+            String role = userDetails.getAuthorities().iterator().next().getAuthority();
+
+            String newAccessToken = jwtTokenProvider.createAccessToken(email, role);
+            Cookie newCookie = new Cookie("accessToken", newAccessToken);
+            newCookie.setPath("/");
+            newCookie.setHttpOnly(true);
+            newCookie.setMaxAge(60 * 30);
+            response.addCookie(newCookie);
+
+            setAuthentication(email);
+
+        }
+        filterChain.doFilter(request, response);
+
+    }
+    @Override
+    protected boolean shouldNotFilter(HttpServletRequest request) {
+        String path = request.getRequestURI();
+        // /ws 로 시작하는 웹소켓 연결 요청은 HTTP 단계에서 토큰 검사를 하지 않도록 예외 처리
+        return path.startsWith("/ws");
+    }
+
+    // 쿠키 배열에서 원하는 쿠키를 가져옴
+    private String getCookieValue(HttpServletRequest request, String cookieName) {
+        if(request.getCookies() == null) return null;
+        return Arrays.stream(request.getCookies())
+                .filter(c -> c.getName().equals(cookieName))
+                .map(Cookie::getValue)
+                .findFirst()
+                .orElse(null);
+
+    }
+
+    private void setAuthentication(String email) {
+        UserDetails userDetails = userDetailsService.loadUserByUsername(email);
+        UsernamePasswordAuthenticationToken authentication =
+                new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
+        SecurityContextHolder.getContext().setAuthentication(authentication);
+    }
+
+}

src/main/java/com/knoc/auth/jwt/JwtHandshakeInterceptor.java

@@ -0,0 +1,67 @@
+package com.knoc.auth.jwt;
+
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import org.jspecify.annotations.Nullable;
+import org.springframework.http.server.ServerHttpRequest;
+import org.springframework.http.server.ServerHttpResponse;
+import org.springframework.http.server.ServletServerHttpRequest;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.WebSocketHandler;
+import org.springframework.web.socket.server.HandshakeInterceptor;
+
+import java.util.Map;
+
+@Component
+@RequiredArgsConstructor
+public class JwtHandshakeInterceptor implements HandshakeInterceptor {
+    /** WebSocket 핸드셰이크 인터셉터
+     * 연결 수립 전 쿠키에서 JWT를 추출해 검증하고,
+     * 인증 정보를 attributes에 저장하여 Principal로 사용할 수 있게 함
+     * 검증 실패 시 false 반환 → 연결 거부
+     */
+
+    private final JwtTokenProvider jwtTokenProvider;
+    private final UserDetailsService userDetailsService;
+
+    @Override
+    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
+        // 쿠키 -> JWT검증 -> 인증정보 저장
+        if (request instanceof ServletServerHttpRequest servletRequest){
+            HttpServletRequest httpRequest = servletRequest.getServletRequest();
+            String accessToken = null;
+            Cookie[] cookies = httpRequest.getCookies();
+            if (cookies != null) {
+                for (Cookie cookie : cookies) {
+                    if ("accessToken".equals(cookie.getName())){
+                        accessToken = cookie.getValue();
+                        break;
+                    }
+                }
+            }
+
+            if(jwtTokenProvider.validateToken(accessToken)){
+                String email = jwtTokenProvider.getEmailFromToken(accessToken);
+
+                UserDetails userDetails = userDetailsService.loadUserByUsername(email);
+
+                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
+
+                attributes.put("principal", authentication);
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, @Nullable Exception exception) {
+        // 핸드셰이크 완료 후 별도 처리 없음
+    }
+}

src/main/java/com/knoc/auth/jwt/JwtTokenProvider.java

@@ -0,0 +1,67 @@
+package com.knoc.auth.jwt;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.security.Keys;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.security.Key;
+import java.util.Date;
+
+@Slf4j
+@Component
+public class JwtTokenProvider {
+    private final Key key;
+    private final long accessTokenValidityTime = 1000L * 60 * 30; // 30분
+    private final long refreshTokenValidityTime = 1000L * 60 * 60 * 24 * 7;  //7일
+
+    // Access Token 생성
+    public JwtTokenProvider(@Value("${jwt.secret:vmsqi69s1iq93p01dnscms938s9d10s2j3nzmcl0s9}")String secretKey) {
+        this.key = Keys.hmacShaKeyFor(secretKey.getBytes());
+    }
+
+    public String createAccessToken(String email, String role) {
+        Claims claims = Jwts.claims().setSubject(email);
+        claims.put("role", role);
+        Date now = new Date();
+
+        return Jwts.builder()
+                .setClaims(claims)
+                .setIssuedAt((now))  // 발급 시간
+                .setExpiration(new Date(now.getTime() + accessTokenValidityTime))  // 만료 시간
+                .signWith(key, SignatureAlgorithm.HS256)
+                .compact();
+    }
+
+    // refreshToken 생성(수명 7일, 이메일 저장)
+    public String createRefreshToken(String email) {
+        Date now = new Date();
+        return Jwts.builder()
+                .setSubject(email)
+                .setIssuedAt(now)
+                .setExpiration(new Date(now.getTime() + refreshTokenValidityTime))
+                .signWith(key, SignatureAlgorithm.HS256)
+                .compact();
+
+    }
+
+    public boolean validateToken(String token) {
+        try {
+            Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
+            return true;
+        } catch (Exception e) {
+            log.error("JWT 검증 실패: {}", e.getMessage());
+            return false;
+        }
+    }
+
+    //  토큰에서 이메일 추출
+    public String getEmailFromToken(String token) {
+        return Jwts.parserBuilder().setSigningKey(key).build()
+                .parseClaimsJws(token).getBody().getSubject();
+    }
+
+}