[feat] JWT 기반 로그인, 회원가입 구현

build.gradle

@@ -32,12 +32,19 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-data-elasticsearch'
 	implementation 'org.springframework.boot:spring-boot-starter-validation'
 
+	implementation 'org.springframework.boot:spring-boot-starter-security'
+	implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
+	implementation 'jakarta.servlet:jakarta.servlet-api:6.0.0'
+	runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5'
+	runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.5'
+
 	runtimeOnly 'com.mysql:mysql-connector-j'
 	compileOnly 'org.projectlombok:lombok'
 	annotationProcessor 'org.projectlombok:lombok'
 
 
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
+	testImplementation 'org.springframework.security:spring-security-test'
 	testCompileOnly 'org.projectlombok:lombok'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }

src/main/java/com/wayble/server/common/config/SecurityConfig.java

@@ -0,0 +1,48 @@
+package com.wayble.server.common.config;
+
+import com.wayble.server.common.config.security.jwt.JwtAuthenticationFilter;
+import com.wayble.server.common.config.security.jwt.JwtTokenProvider;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpMethod;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+@Configuration
+@RequiredArgsConstructor
+@EnableMethodSecurity
+public class SecurityConfig {
+
+    private final JwtTokenProvider jwtProvider;
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+
+    @Bean
+    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
+        http
+                .csrf(csrf -> csrf.disable())
+                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+                .authorizeHttpRequests(auth -> auth
+                        .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
+                        .requestMatchers(
+                                "/api/v1/users/signup",
+                                "/api/v1/users/login",
+                                "/swagger-ui/**",
+                                "/v3/api-docs/**"
+                        ).permitAll()
+                        .anyRequest().authenticated()
+                )
+                .addFilterBefore(new JwtAuthenticationFilter(jwtProvider), UsernamePasswordAuthenticationFilter.class);
+
+        return http.build();
+    }
+}

src/main/java/com/wayble/server/common/config/security/JwtProperties.java

@@ -0,0 +1,29 @@
+package com.wayble.server.common.config.security;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@Component
+@ConfigurationProperties(prefix = "jwt")
+public class JwtProperties {
+
+    private String secret;
+    private long accessExp;
+
+
+    public String getSecret() {
+        return secret;
+    }
+
+    public long getAccessExp() {
+        return accessExp;
+    }
+
+    public void setSecret(String secret) {
+        this.secret = secret;
+    }
+
+    public void setAccessExp(long accessExp) {
+        this.accessExp = accessExp;
+    }
+}

src/main/java/com/wayble/server/common/config/security/jwt/JwtAuthentication.java

@@ -0,0 +1,18 @@
+package com.wayble.server.common.config.security.jwt;
+
+import org.springframework.security.authentication.AbstractAuthenticationToken;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import java.util.List;
+
+public class JwtAuthentication extends AbstractAuthenticationToken {
+    private final String email;
+
+    public JwtAuthentication(String email) {
+        super(List.of(new SimpleGrantedAuthority("ROLE_USER")));
+        this.email = email;
+        setAuthenticated(true);
+    }
+
+    @Override public Object getCredentials() { return ""; }
+    @Override public Object getPrincipal() { return email; }
+}

src/main/java/com/wayble/server/common/config/security/jwt/JwtAuthenticationFilter.java

@@ -0,0 +1,37 @@
+package com.wayble.server.common.config.security.jwt;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+@RequiredArgsConstructor
+public class JwtAuthenticationFilter extends OncePerRequestFilter {
+
+    private final JwtTokenProvider jwtProvider;
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest req,
+                                    HttpServletResponse res,
+                                    FilterChain chain) throws ServletException, IOException {
+
+        String header = req.getHeader("Authorization");
+
+        if (header != null && header.startsWith("Bearer ")) {
+            String token = header.substring(7);
+
+            if (jwtProvider.validateToken(token)) {
+                String email = jwtProvider.getEmail(token);
+                var authentication = new JwtAuthentication(email);
+                SecurityContextHolder.getContext().setAuthentication(authentication);
+            }
+        }
+
+        chain.doFilter(req, res);
+    }
+}

src/main/java/com/wayble/server/common/config/security/jwt/JwtTokenProvider.java

@@ -0,0 +1,44 @@
+package com.wayble.server.common.config.security.jwt;
+
+import com.wayble.server.common.config.security.JwtProperties;
+import io.jsonwebtoken.*;
+import io.jsonwebtoken.security.Keys;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.security.Key;
+import java.util.Date;
+
+@Component
+@RequiredArgsConstructor
+public class JwtTokenProvider {
+    private final JwtProperties jwtProperties;
+
+    private Key getSigningKey() {
+        return Keys.hmacShaKeyFor(jwtProperties.getSecret().getBytes());
+    }
+
+    public String generateToken(String email, String role) {
+        return Jwts.builder()
+                .setSubject(email)
+                .claim("role", role)
+                .setIssuedAt(new Date())
+                .setExpiration(new Date(System.currentTimeMillis() + jwtProperties.getAccessExp()))
+                .signWith(getSigningKey(), SignatureAlgorithm.HS256)
+                .compact();
+    }
+
+    public boolean validateToken(String token) {
+        try {
+            Jwts.parserBuilder().setSigningKey(getSigningKey()).build().parseClaimsJws(token);
+            return true;
+        } catch (JwtException | IllegalArgumentException e) {
+            return false;
+        }
+    }
+
+    public String getEmail(String token) {
+        return Jwts.parserBuilder().setSigningKey(getSigningKey()).build()
+                .parseClaimsJws(token).getBody().getSubject();
+    }
+}

src/main/java/com/wayble/server/user/controller/UserController.java

@@ -1,29 +1,60 @@
 package com.wayble.server.user.controller;
 
 import com.wayble.server.common.response.CommonResponse;
+import com.wayble.server.user.dto.UserLoginRequestDto;
+import com.wayble.server.user.dto.UserRegisterRequestDto;
+import com.wayble.server.user.dto.token.TokenResponseDto;
 import com.wayble.server.user.service.UserService;
+import com.wayble.server.user.service.auth.AuthService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
 
 @RestController
+@RequestMapping("/api/v1/users")
 @RequiredArgsConstructor
-@RequestMapping("/users")
+@Validated
 public class UserController {
 
     private final UserService userService;
+    private final AuthService authService;
 
-    // 참고용 컨트롤러(지우셔도 돼요)
-    @GetMapping("/hello")
-    public CommonResponse<String> hello() {
-        return CommonResponse.success("hello");
+    @PostMapping("/signup")
+    @Operation(
+            summary = "유저 회원가입",
+            description = "신규 유저 회원가입을 수행합니다."
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "회원가입 성공",
+                    content = @Content(schema = @Schema(implementation = com.wayble.server.common.response.CommonResponse.class))),
+            @ApiResponse(responseCode = "400", description = "이미 존재하는 회원",
+                    content = @Content(schema = @Schema(implementation = com.wayble.server.common.response.CommonResponse.class)))
+    })
+    public CommonResponse<String> signup(@RequestBody @Valid UserRegisterRequestDto req) {
+        userService.signup(req);
+        return CommonResponse.success("회원가입 성공");
     }
 
-    // 예외 사용 참고용 컨트롤러(지우셔도 돼요)
-    @GetMapping("/ex")
-    public CommonResponse<String> exception() {
-        userService.makeException();
-        return CommonResponse.success("예외 발생!");
+    @PostMapping("/login")
+    @Operation(
+            summary = "유저 로그인",
+            description = "이메일+비밀번호 로그인 및 JWT 발급"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "로그인 성공",
+                    content = @Content(schema = @Schema(implementation = com.wayble.server.common.response.CommonResponse.class))),
+            @ApiResponse(responseCode = "400", description = "아이디 혹은 비밀번호가 잘못됨",
+                    content = @Content(schema = @Schema(implementation = com.wayble.server.common.response.CommonResponse.class)))
+    })
+    public CommonResponse<TokenResponseDto> login(@RequestBody @Valid UserLoginRequestDto req) {
+        TokenResponseDto tokenDto = authService.login(req);
+        return CommonResponse.success(tokenDto);
     }
+
 }

src/main/java/com/wayble/server/user/dto/UserLoginRequestDto.java

@@ -0,0 +1,16 @@
+package com.wayble.server.user.dto;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+
+public record UserLoginRequestDto(
+        @NotBlank(message = "이름 또는 닉네임은 필수입니다")
+        String name,
+
+        @NotBlank(message = "이메일은 필수입니다")
+        @Email(message = "유효한 이메일 형식이 아닙니다")
+        String email,
+
+        @NotBlank(message = "비밀번호는 필수입니다")
+        String password
+) {}

src/main/java/com/wayble/server/user/dto/UserRegisterRequestDto.java

@@ -3,16 +3,36 @@
 import com.wayble.server.user.entity.Gender;
 import com.wayble.server.user.entity.LoginType;
 import com.wayble.server.user.entity.UserType;
+import jakarta.validation.constraints.*;
 
 import java.time.LocalDate;
 
 public record UserRegisterRequestDto(
+        @NotBlank(message = "닉네임은 필수입니다")
+        @Size(max = 8, message = "닉네임은 8자 이하여야 합니다")
         String nickname,
+
+        @NotBlank(message = "사용자명은 필수입니다")
         String username,
+
+        @NotBlank(message = "이메일은 필수입니다")
+        @Email(message = "유효한 이메일 형식이 아닙니다")
         String email,
+
+        @NotBlank(message = "비밀번호는 필수입니다")
+        @Size(min = 8, message = "비밀번호는 8자 이상이어야 합니다")
         String password,
+
+        @NotNull(message = "생년월일은 필수입니다")
+        @Past(message = "생년월일은 과거 날짜여야 합니다")
         LocalDate birthDate,
+
+        @NotNull(message = "성별은 필수입니다")
         Gender gender,
+
+        @NotNull(message = "로그인 타입은 필수입니다")
         LoginType loginType,
+
+        @NotNull(message = "사용자 타입은 필수입니다")
         UserType userType
-) {}
+) {}

src/main/java/com/wayble/server/user/dto/token/TokenResponseDto.java

@@ -0,0 +1,3 @@
+package com.wayble.server.user.dto.token;
+
+public record TokenResponseDto(String accessToken) {}

src/main/java/com/wayble/server/user/entity/User.java

@@ -64,4 +64,26 @@ public class User extends BaseEntity {
 
     @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
     private List<UserPlace> userPlaces = new ArrayList<>();
+
+    public static User createUser(
+            String nickname,
+            String username,
+            String email,
+            String password,
+            LocalDate birthDate,
+            Gender gender,
+            LoginType loginType,
+            UserType userType
+    ) {
+        return User.builder()
+                .nickname(nickname)
+                .username(username)
+                .email(email)
+                .password(password)
+                .birthDate(birthDate)
+                .gender(gender)
+                .loginType(loginType)
+                .userType(userType)
+                .build();
+    }
 }

src/main/java/com/wayble/server/user/exception/UserErrorCase.java

@@ -11,7 +11,9 @@ public enum UserErrorCase implements ErrorCase {
     USER_NOT_FOUND(404, 1001, "사용자를 찾을 수 없습니다."),
     WAYBLE_ZONE_NOT_FOUND(404, 1002, "해당 웨이블존을 찾을 수 없습니다."),
     PLACE_ALREADY_SAVED(400, 1003, "이미 저장한 장소입니다."),
-    INVALID_USER_ID(400, 1004, "요청 경로의 유저 ID와 바디의 유저 ID가 일치하지 않습니다.");
+    INVALID_USER_ID(400, 1004, "요청 경로의 유저 ID와 바디의 유저 ID가 일치하지 않습니다."),
+    USER_ALREADY_EXISTS(400, 1005, "이미 존재하는 회원입니다."),
+    INVALID_CREDENTIALS(400, 1006, "아이디 혹은 비밀번호가 잘못되었습니다.");
 
     private final Integer httpStatusCode;
     private final Integer errorCode;