modify: folder - java/python

2026-06-13 04:49:10 +00:00 · 2025-06-11 14:24:26 +09:00
parent a86d2e47ce
commit 7813f934b9
126 changed files with 1856 additions and 129 deletions
@@ -0,0 +1,20 @@
+package com.won.smarketing.member;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+
+/**
+ * 회원 서비스 메인 애플리케이션 클래스
+ * Spring Boot 애플리케이션의 진입점
+ */
+@SpringBootApplication(scanBasePackages = {"com.won.smarketing.member", "com.won.smarketing.common"})
+@EntityScan(basePackages = {"com.won.smarketing.member.entity"})
+@EnableJpaRepositories(basePackages = {"com.won.smarketing.member.repository"})
+public class MemberServiceApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(MemberServiceApplication.class, args);
+    }
+}
@@ -0,0 +1,13 @@
+package com.won.smarketing.member.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
+
+/**
+ * JPA 설정 클래스
+ * JPA Auditing 기능 활성화
+ */
+@Configuration
+@EnableJpaAuditing
+public class JpaConfig {
+}
@@ -0,0 +1,64 @@
+package com.won.smarketing.member.controller;
+
+import com.won.smarketing.common.dto.ApiResponse;
+import com.won.smarketing.member.dto.*;
+import com.won.smarketing.member.service.AuthService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import jakarta.validation.Valid;
+
+/**
+ * 인증을 위한 REST API 컨트롤러
+ * 로그인, 로그아웃, 토큰 갱신 기능 제공
+ */
+@Tag(name = "인증 관리", description = "로그인, 로그아웃, 토큰 관리 API")
+@RestController
+@RequestMapping("/api/auth")
+@RequiredArgsConstructor
+public class AuthController {
+
+    private final AuthService authService;
+
+    /**
+     * 로그인
+     * 
+     * @param request 로그인 요청 정보
+     * @return 로그인 성공 응답 (토큰 포함)
+     */
+    @Operation(summary = "로그인", description = "사용자 ID와 패스워드로 로그인합니다.")
+    @PostMapping("/login")
+    public ResponseEntity<ApiResponse<LoginResponse>> login(@Valid @RequestBody LoginRequest request) {
+        LoginResponse response = authService.login(request);
+        return ResponseEntity.ok(ApiResponse.success(response, "로그인이 완료되었습니다."));
+    }
+
+    /**
+     * 로그아웃
+     * 
+     * @param request 로그아웃 요청 정보
+     * @return 로그아웃 성공 응답
+     */
+    @Operation(summary = "로그아웃", description = "리프레시 토큰을 무효화하여 로그아웃합니다.")
+    @PostMapping("/logout")
+    public ResponseEntity<ApiResponse<Void>> logout(@Valid @RequestBody LogoutRequest request) {
+        authService.logout(request.getRefreshToken());
+        return ResponseEntity.ok(ApiResponse.success(null, "로그아웃이 완료되었습니다."));
+    }
+
+    /**
+     * 토큰 갱신
+     * 
+     * @param request 토큰 갱신 요청 정보
+     * @return 새로운 토큰 정보
+     */
+    @Operation(summary = "토큰 갱신", description = "리프레시 토큰을 사용하여 새로운 액세스 토큰을 발급받습니다.")
+    @PostMapping("/refresh")
+    public ResponseEntity<ApiResponse<TokenResponse>> refresh(@Valid @RequestBody TokenRefreshRequest request) {
+        TokenResponse response = authService.refresh(request.getRefreshToken());
+        return ResponseEntity.ok(ApiResponse.success(response, "토큰이 갱신되었습니다."));
+    }
+}
@@ -0,0 +1,120 @@
+package com.won.smarketing.member.controller;
+
+import com.won.smarketing.common.dto.ApiResponse;
+import com.won.smarketing.member.dto.DuplicateCheckResponse;
+import com.won.smarketing.member.dto.PasswordValidationRequest;
+import com.won.smarketing.member.dto.RegisterRequest;
+import com.won.smarketing.member.dto.ValidationResponse;
+import com.won.smarketing.member.service.MemberService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import jakarta.validation.Valid;
+
+/**
+ * 회원 관리를 위한 REST API 컨트롤러
+ * 회원가입, 중복 확인, 패스워드 검증 기능 제공
+ */
+@Tag(name = "회원 관리", description = "회원가입 및 회원 정보 관리 API")
+@RestController
+@RequestMapping("/api/member")
+@RequiredArgsConstructor
+public class MemberController {
+
+    private final MemberService memberService;
+
+    /**
+     * 회원가입
+     * 
+     * @param request 회원가입 요청 정보
+     * @return 회원가입 성공 응답
+     */
+    @Operation(summary = "회원가입", description = "새로운 회원을 등록합니다.")
+    @PostMapping("/register")
+    public ResponseEntity<ApiResponse<Void>> register(@Valid @RequestBody RegisterRequest request) {
+        memberService.register(request);
+        return ResponseEntity.ok(ApiResponse.success(null, "회원가입이 완료되었습니다."));
+    }
+
+    /**
+     * 사용자 ID 중복 확인
+     * 
+     * @param userId 확인할 사용자 ID
+     * @return 중복 확인 결과
+     */
+    @Operation(summary = "사용자 ID 중복 확인", description = "사용자 ID의 중복 여부를 확인합니다.")
+    @GetMapping("/check-duplicate/user-id")
+    public ResponseEntity<ApiResponse<DuplicateCheckResponse>> checkUserIdDuplicate(
+            @Parameter(description = "확인할 사용자 ID", required = true)
+            @RequestParam String userId) {
+        
+        boolean isDuplicate = memberService.checkDuplicate(userId);
+        DuplicateCheckResponse response = isDuplicate 
+                ? DuplicateCheckResponse.duplicate("이미 사용 중인 사용자 ID입니다.")
+                : DuplicateCheckResponse.available("사용 가능한 사용자 ID입니다.");
+        
+        return ResponseEntity.ok(ApiResponse.success(response));
+    }
+
+    /**
+     * 이메일 중복 확인
+     * 
+     * @param email 확인할 이메일
+     * @return 중복 확인 결과
+     */
+    @Operation(summary = "이메일 중복 확인", description = "이메일의 중복 여부를 확인합니다.")
+    @GetMapping("/check-duplicate/email")
+    public ResponseEntity<ApiResponse<DuplicateCheckResponse>> checkEmailDuplicate(
+            @Parameter(description = "확인할 이메일", required = true)
+            @RequestParam String email) {
+        
+        boolean isDuplicate = memberService.checkEmailDuplicate(email);
+        DuplicateCheckResponse response = isDuplicate 
+                ? DuplicateCheckResponse.duplicate("이미 사용 중인 이메일입니다.")
+                : DuplicateCheckResponse.available("사용 가능한 이메일입니다.");
+        
+        return ResponseEntity.ok(ApiResponse.success(response));
+    }
+
+    /**
+     * 사업자번호 중복 확인
+     * 
+     * @param businessNumber 확인할 사업자번호
+     * @return 중복 확인 결과
+     */
+    @Operation(summary = "사업자번호 중복 확인", description = "사업자번호의 중복 여부를 확인합니다.")
+    @GetMapping("/check-duplicate/business-number")
+    public ResponseEntity<ApiResponse<DuplicateCheckResponse>> checkBusinessNumberDuplicate(
+            @Parameter(description = "확인할 사업자번호", required = true)
+            @RequestParam String businessNumber) {
+        
+        boolean isDuplicate = memberService.checkBusinessNumberDuplicate(businessNumber);
+        DuplicateCheckResponse response = isDuplicate 
+                ? DuplicateCheckResponse.duplicate("이미 등록된 사업자번호입니다.")
+                : DuplicateCheckResponse.available("사용 가능한 사업자번호입니다.");
+        
+        return ResponseEntity.ok(ApiResponse.success(response));
+    }
+
+    /**
+     * 패스워드 유효성 검증
+     * 
+     * @param request 패스워드 검증 요청
+     * @return 패스워드 검증 결과
+     */
+    @Operation(summary = "패스워드 검증", description = "패스워드가 규칙을 만족하는지 확인합니다.")
+    @PostMapping("/validate-password")
+    public ResponseEntity<ApiResponse<ValidationResponse>> validatePassword(
+            @Valid @RequestBody PasswordValidationRequest request) {
+        
+        ValidationResponse response = memberService.validatePassword(request.getPassword());
+        return ResponseEntity.ok(ApiResponse.success(response));
+    }
+}
+
+
+
@@ -0,0 +1,54 @@
+package com.won.smarketing.member.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 중복 확인 응답 DTO
+ * 사용자 ID, 이메일 등의 중복 확인 결과를 전달합니다.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@Schema(description = "중복 확인 응답")
+public class DuplicateCheckResponse {
+    
+    @Schema(description = "중복 여부", example = "false")
+    private boolean isDuplicate;
+    
+    @Schema(description = "메시지", example = "사용 가능한 ID입니다.")
+    private String message;
+    
+    /**
+     * 중복된 경우의 응답 생성
+     * 
+     * @param message 메시지
+     * @return 중복 응답
+     */
+    public static DuplicateCheckResponse duplicate(String message) {
+        return DuplicateCheckResponse.builder()
+                .isDuplicate(true)
+                .message(message)
+                .build();
+    }
+    
+    /**
+     * 사용 가능한 경우의 응답 생성
+     * 
+     * @param message 메시지
+     * @return 사용 가능 응답
+     */
+    public static DuplicateCheckResponse available(String message) {
+        return DuplicateCheckResponse.builder()
+                .isDuplicate(false)
+                .message(message)
+                .build();
+    }
+}
+
+
+
@@ -0,0 +1,26 @@
+package com.won.smarketing.member.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 로그인 요청 DTO
+ * 로그인 시 필요한 정보를 전달합니다.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "로그인 요청")
+public class LoginRequest {
+    
+    @Schema(description = "사용자 ID", example = "user123", required = true)
+    @NotBlank(message = "사용자 ID는 필수입니다")
+    private String userId;
+    
+    @Schema(description = "패스워드", example = "password123!", required = true)
+    @NotBlank(message = "패스워드는 필수입니다")
+    private String password;
+}
@@ -0,0 +1,47 @@
+package com.won.smarketing.member.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 로그인 응답 DTO
+ * 로그인 성공 시 토큰 정보를 전달합니다.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@Schema(description = "로그인 응답")
+public class LoginResponse {
+    
+    @Schema(description = "액세스 토큰", example = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...")
+    private String accessToken;
+    
+    @Schema(description = "리프레시 토큰", example = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...")
+    private String refreshToken;
+    
+    @Schema(description = "토큰 만료 시간 (초)", example = "3600")
+    private long expiresIn;
+    
+    @Schema(description = "사용자 정보")
+    private UserInfo userInfo;
+    
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @Builder
+    @Schema(description = "사용자 정보")
+    public static class UserInfo {
+        @Schema(description = "사용자 ID", example = "user123")
+        private String userId;
+        
+        @Schema(description = "이름", example = "홍길동")
+        private String name;
+        
+        @Schema(description = "이메일", example = "user@example.com")
+        private String email;
+    }
+}
@@ -0,0 +1,25 @@
+package com.won.smarketing.member.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import jakarta.validation.constraints.NotBlank;
+
+/**
+ * 로그아웃 요청 DTO
+ * 로그아웃 시 무효화할 Refresh Token 정보
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@Schema(description = "로그아웃 요청")
+public class LogoutRequest {
+
+    @Schema(description = "무효화할 Refresh Token", example = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", required = true)
+    @NotBlank(message = "Refresh Token은 필수입니다.")
+    private String refreshToken;
+}
@@ -0,0 +1,22 @@
+package com.won.smarketing.member.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 패스워드 검증 요청 DTO
+ * 패스워드 규칙 검증을 위한 요청 정보를 전달합니다.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "패스워드 검증 요청")
+public class PasswordValidationRequest {
+    
+    @Schema(description = "검증할 패스워드", example = "password123!", required = true)
+    @NotBlank(message = "패스워드는 필수입니다")
+    private String password;
+}
@@ -0,0 +1,49 @@
+package com.won.smarketing.member.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 회원가입 요청 DTO
+ * 회원가입 시 필요한 정보를 전달합니다.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "회원가입 요청")
+public class RegisterRequest {
+    
+    @Schema(description = "사용자 ID", example = "user123", required = true)
+    @NotBlank(message = "사용자 ID는 필수입니다")
+    @Size(min = 4, max = 20, message = "사용자 ID는 4-20자 사이여야 합니다")
+    @Pattern(regexp = "^[a-zA-Z0-9]+$", message = "사용자 ID는 영문과 숫자만 사용 가능합니다")
+    private String userId;
+    
+    @Schema(description = "패스워드", example = "password123!", required = true)
+    @NotBlank(message = "패스워드는 필수입니다")
+    @Size(min = 8, max = 20, message = "패스워드는 8-20자 사이여야 합니다")
+    @Pattern(regexp = "^(?=.*[a-zA-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]+$", 
+             message = "패스워드는 영문, 숫자, 특수문자를 포함해야 합니다")
+    private String password;
+    
+    @Schema(description = "이름", example = "홍길동", required = true)
+    @NotBlank(message = "이름은 필수입니다")
+    @Size(max = 50, message = "이름은 50자 이하여야 합니다")
+    private String name;
+    
+    @Schema(description = "사업자등록번호", example = "123-45-67890")
+    @Pattern(regexp = "^\\d{3}-\\d{2}-\\d{5}$", message = "사업자등록번호 형식이 올바르지 않습니다 (000-00-00000)")
+    private String businessNumber;
+    
+    @Schema(description = "이메일", example = "user@example.com", required = true)
+    @NotBlank(message = "이메일은 필수입니다")
+    @Email(message = "이메일 형식이 올바르지 않습니다")
+    @Size(max = 100, message = "이메일은 100자 이하여야 합니다")
+    private String email;
+}
@@ -0,0 +1,22 @@
+package com.won.smarketing.member.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 토큰 갱신 요청 DTO
+ * 리프레시 토큰을 사용한 액세스 토큰 갱신 요청 정보를 전달합니다.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "토큰 갱신 요청")
+public class TokenRefreshRequest {
+    
+    @Schema(description = "리프레시 토큰", example = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...", required = true)
+    @NotBlank(message = "리프레시 토큰은 필수입니다")
+    private String refreshToken;
+}
@@ -0,0 +1,28 @@
+package com.won.smarketing.member.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 토큰 응답 DTO
+ * 토큰 갱신 시 새로운 토큰 정보를 전달합니다.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@Schema(description = "토큰 응답")
+public class TokenResponse {
+    
+    @Schema(description = "새로운 액세스 토큰", example = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...")
+    private String accessToken;
+    
+    @Schema(description = "새로운 리프레시 토큰", example = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...")
+    private String refreshToken;
+    
+    @Schema(description = "토큰 만료 시간 (초)", example = "3600")
+    private long expiresIn;
+}
@@ -0,0 +1,58 @@
+package com.won.smarketing.member.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+/**
+ * 검증 응답 DTO
+ * 패스워드 등의 검증 결과를 전달합니다.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@Schema(description = "검증 응답")
+public class ValidationResponse {
+    
+    @Schema(description = "유효성 여부", example = "true")
+    private boolean isValid;
+    
+    @Schema(description = "메시지", example = "사용 가능한 패스워드입니다.")
+    private String message;
+    
+    @Schema(description = "오류 목록", example = "[\"영문이 포함되어야 합니다\", \"숫자가 포함되어야 합니다\"]")
+    private List<String> errors;
+    
+    /**
+     * 유효한 경우의 응답 생성
+     * 
+     * @param message 메시지
+     * @return 유효 응답
+     */
+    public static ValidationResponse valid(String message) {
+        return ValidationResponse.builder()
+                .isValid(true)
+                .message(message)
+                .build();
+    }
+    
+    /**
+     * 유효하지 않은 경우의 응답 생성
+     * 
+     * @param message 메시지
+     * @param errors 오류 목록
+     * @return 무효 응답
+     */
+    public static ValidationResponse invalid(String message, List<String> errors) {
+        return ValidationResponse.builder()
+                .isValid(false)
+                .message(message)
+                .errors(errors)
+                .build();
+    }
+}
@@ -0,0 +1,82 @@
+package com.won.smarketing.member.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import java.time.LocalDateTime;
+
+/**
+ * 회원 엔티티
+ * 회원의 기본 정보와 사업자 정보를 관리
+ */
+@Entity
+@Table(name = "members")
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@EntityListeners(AuditingEntityListener.class)
+public class Member {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "member_id")
+    private Long id;
+
+    @Column(name = "user_id", nullable = false, unique = true, length = 50)
+    private String userId;
+
+    @Column(name = "password", nullable = false, length = 100)
+    private String password;
+
+    @Column(name = "name", nullable = false, length = 50)
+    private String name;
+
+    @Column(name = "business_number", length = 12)
+    private String businessNumber;
+
+    @Column(name = "email", nullable = false, unique = true, length = 100)
+    private String email;
+
+    @CreatedDate
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @LastModifiedDate
+    @Column(name = "updated_at")
+    private LocalDateTime updatedAt;
+
+    /**
+     * 회원 정보 업데이트
+     *
+     * @param name 이름
+     * @param email 이메일
+     * @param businessNumber 사업자번호
+     */
+    public void updateProfile(String name, String email, String businessNumber) {
+        if (name != null && !name.trim().isEmpty()) {
+            this.name = name;
+        }
+        if (email != null && !email.trim().isEmpty()) {
+            this.email = email;
+        }
+        if (businessNumber != null && !businessNumber.trim().isEmpty()) {
+            this.businessNumber = businessNumber;
+        }
+    }
+
+    /**
+     * 패스워드 변경
+     *
+     * @param encodedPassword 암호화된 패스워드
+     */
+    public void changePassword(String encodedPassword) {
+        this.password = encodedPassword;
+    }
+}
@@ -0,0 +1,47 @@
+package com.won.smarketing.member.repository;
+
+import com.won.smarketing.member.entity.Member;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+/**
+ * 회원 정보 데이터 접근을 위한 Repository
+ * JPA를 사용한 회원 CRUD 작업 처리
+ */
+@Repository
+public interface MemberRepository extends JpaRepository<Member, Long> {
+    
+    /**
+     * 사용자 ID로 회원 조회
+     * 
+     * @param userId 사용자 ID
+     * @return 회원 정보 (Optional)
+     */
+    Optional<Member> findByUserId(String userId);
+    
+    /**
+     * 사용자 ID 존재 여부 확인
+     * 
+     * @param userId 사용자 ID
+     * @return 존재 여부
+     */
+    boolean existsByUserId(String userId);
+    
+    /**
+     * 이메일 존재 여부 확인
+     * 
+     * @param email 이메일
+     * @return 존재 여부
+     */
+    boolean existsByEmail(String email);
+    
+    /**
+     * 사업자번호 존재 여부 확인
+     * 
+     * @param businessNumber 사업자번호
+     * @return 존재 여부
+     */
+    boolean existsByBusinessNumber(String businessNumber);
+}
@@ -0,0 +1,35 @@
+package com.won.smarketing.member.service;
+
+import com.won.smarketing.member.dto.LoginRequest;
+import com.won.smarketing.member.dto.LoginResponse;
+import com.won.smarketing.member.dto.TokenResponse;
+
+/**
+ * 인증 서비스 인터페이스
+ * 로그인, 로그아웃, 토큰 갱신 관련 비즈니스 로직 정의
+ */
+public interface AuthService {
+    
+    /**
+     * 로그인
+     * 
+     * @param request 로그인 요청 정보
+     * @return 로그인 응답 정보 (토큰 포함)
+     */
+    LoginResponse login(LoginRequest request);
+    
+    /**
+     * 로그아웃
+     * 
+     * @param refreshToken 리프레시 토큰
+     */
+    void logout(String refreshToken);
+    
+    /**
+     * 토큰 갱신
+     * 
+     * @param refreshToken 리프레시 토큰
+     * @return 새로운 토큰 정보
+     */
+    TokenResponse refresh(String refreshToken);
+}
@@ -0,0 +1,175 @@
+package com.won.smarketing.member.service;
+
+import com.won.smarketing.common.exception.BusinessException;
+import com.won.smarketing.common.exception.ErrorCode;
+import com.won.smarketing.common.security.JwtTokenProvider;
+import com.won.smarketing.member.dto.LoginRequest;
+import com.won.smarketing.member.dto.LoginResponse;
+import com.won.smarketing.member.dto.TokenResponse;
+import com.won.smarketing.member.entity.Member;
+import com.won.smarketing.member.repository.MemberRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 인증 서비스 구현체
+ * 로그인, 로그아웃, 토큰 갱신 기능 구현
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class AuthServiceImpl implements AuthService {
+
+        private final MemberRepository memberRepository;
+        private final PasswordEncoder passwordEncoder;
+        private final JwtTokenProvider jwtTokenProvider;
+        private final RedisTemplate<String, String> redisTemplate;
+
+        private static final String REFRESH_TOKEN_PREFIX = "refresh_token:";
+        private static final String BLACKLIST_PREFIX = "blacklist:";
+
+        /**
+         * 로그인
+         *
+         * @param request 로그인 요청 정보
+         * @return 로그인 응답 정보 (토큰 포함)
+         */
+        @Override
+        @Transactional
+        public LoginResponse login(LoginRequest request) {
+                log.info("로그인 시도: {}", request.getUserId());
+
+                // 회원 조회
+                Member member = memberRepository.findByUserId(request.getUserId())
+                        .orElseThrow(() -> new BusinessException(ErrorCode.MEMBER_NOT_FOUND));
+
+                // 패스워드 검증
+                if (!passwordEncoder.matches(request.getPassword(), member.getPassword())) {
+                        throw new BusinessException(ErrorCode.INVALID_PASSWORD);
+                }
+
+                // 토큰 생성
+                String accessToken = jwtTokenProvider.generateAccessToken(member.getUserId());
+                String refreshToken = jwtTokenProvider.generateRefreshToken(member.getUserId());
+
+                // 리프레시 토큰을 Redis에 저장 (7일)
+                redisTemplate.opsForValue().set(
+                        REFRESH_TOKEN_PREFIX + member.getUserId(),
+                        refreshToken,
+                        7,
+                        TimeUnit.DAYS
+                );
+
+                log.info("로그인 성공: {}", request.getUserId());
+
+                return LoginResponse.builder()
+                        .accessToken(accessToken)
+                        .refreshToken(refreshToken)
+                        .expiresIn(jwtTokenProvider.getAccessTokenValidityTime() / 1000)
+                        .userInfo(LoginResponse.UserInfo.builder()
+                                .userId(member.getUserId())
+                                .name(member.getName())
+                                .email(member.getEmail())
+                                .build())
+                        .build();
+        }
+
+        /**
+         * 로그아웃
+         *
+         * @param refreshToken 리프레시 토큰
+         */
+        @Override
+        @Transactional
+        public void logout(String refreshToken) {
+                try {
+                        if (jwtTokenProvider.validateToken(refreshToken)) {
+                                String userId = jwtTokenProvider.getUserIdFromToken(refreshToken);
+
+                                // Redis에서 리프레시 토큰 삭제
+                                redisTemplate.delete(REFRESH_TOKEN_PREFIX + userId);
+
+                                // 리프레시 토큰을 블랙리스트에 추가
+                                redisTemplate.opsForValue().set(
+                                        BLACKLIST_PREFIX + refreshToken,
+                                        "logout",
+                                        7,
+                                        TimeUnit.DAYS
+                                );
+
+                                log.info("로그아웃 완료: {}", userId);
+                        }
+                } catch (Exception ex) {
+                        log.warn("로그아웃 처리 중 오류 발생: {}", ex.getMessage());
+                        // 로그아웃은 실패해도 클라이언트에게는 성공으로 응답
+                }
+        }
+
+        /**
+         * 토큰 갱신
+         *
+         * @param refreshToken 리프레시 토큰
+         * @return 새로운 토큰 정보
+         */
+        @Override
+        @Transactional
+        public TokenResponse refresh(String refreshToken) {
+                // 토큰 유효성 검증
+                if (!jwtTokenProvider.validateToken(refreshToken)) {
+                        throw new BusinessException(ErrorCode.INVALID_TOKEN);
+                }
+
+                // 블랙리스트 확인
+                if (redisTemplate.hasKey(BLACKLIST_PREFIX + refreshToken)) {
+                        throw new BusinessException(ErrorCode.INVALID_TOKEN);
+                }
+
+                String userId = jwtTokenProvider.getUserIdFromToken(refreshToken);
+
+                // Redis에 저장된 리프레시 토큰과 비교
+                String storedRefreshToken = redisTemplate.opsForValue().get(REFRESH_TOKEN_PREFIX + userId);
+                if (!refreshToken.equals(storedRefreshToken)) {
+                        throw new BusinessException(ErrorCode.INVALID_TOKEN);
+                }
+
+                // 회원 존재 확인
+                if (!memberRepository.existsByUserId(userId)) {
+                        throw new BusinessException(ErrorCode.MEMBER_NOT_FOUND);
+                }
+
+                // 새로운 토큰 생성
+                String newAccessToken = jwtTokenProvider.generateAccessToken(userId);
+                String newRefreshToken = jwtTokenProvider.generateRefreshToken(userId);
+
+                // 새로운 리프레시 토큰을 Redis에 저장
+                redisTemplate.opsForValue().set(
+                        REFRESH_TOKEN_PREFIX + userId,
+                        newRefreshToken,
+                        7,
+                        TimeUnit.DAYS
+                );
+
+                // 기존 리프레시 토큰을 블랙리스트에 추가
+                redisTemplate.opsForValue().set(
+                        BLACKLIST_PREFIX + refreshToken,
+                        "refreshed",
+                        7,
+                        TimeUnit.DAYS
+                );
+
+                log.info("토큰 갱신 완료: {}", userId);
+
+                return TokenResponse.builder()
+                        .accessToken(newAccessToken)
+                        .refreshToken(newRefreshToken)
+                        .expiresIn(jwtTokenProvider.getAccessTokenValidityTime() / 1000)
+                        .build();
+        }
+}
@@ -0,0 +1,50 @@
+package com.won.smarketing.member.service;
+
+import com.won.smarketing.member.dto.RegisterRequest;
+import com.won.smarketing.member.dto.ValidationResponse;
+
+/**
+ * 회원 서비스 인터페이스
+ * 회원 관리 관련 비즈니스 로직 정의
+ */
+public interface MemberService {
+    
+    /**
+     * 회원 등록
+     * 
+     * @param request 회원가입 요청 정보
+     */
+    void register(RegisterRequest request);
+    
+    /**
+     * 사용자 ID 중복 확인
+     * 
+     * @param userId 확인할 사용자 ID
+     * @return 중복 여부
+     */
+    boolean checkDuplicate(String userId);
+    
+    /**
+     * 이메일 중복 확인
+     * 
+     * @param email 확인할 이메일
+     * @return 중복 여부
+     */
+    boolean checkEmailDuplicate(String email);
+    
+    /**
+     * 사업자번호 중복 확인
+     * 
+     * @param businessNumber 확인할 사업자번호
+     * @return 중복 여부
+     */
+    boolean checkBusinessNumberDuplicate(String businessNumber);
+    
+    /**
+     * 패스워드 유효성 검증
+     * 
+     * @param password 검증할 패스워드
+     * @return 검증 결과
+     */
+    ValidationResponse validatePassword(String password);
+}
@@ -0,0 +1,146 @@
+package com.won.smarketing.member.service;
+
+import com.won.smarketing.common.exception.BusinessException;
+import com.won.smarketing.common.exception.ErrorCode;
+import com.won.smarketing.member.dto.RegisterRequest;
+import com.won.smarketing.member.dto.ValidationResponse;
+import com.won.smarketing.member.entity.Member;
+import com.won.smarketing.member.repository.MemberRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * 회원 서비스 구현체
+ * 회원 등록, 중복 확인, 패스워드 검증 기능 구현
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class MemberServiceImpl implements MemberService {
+
+    private final MemberRepository memberRepository;
+    private final PasswordEncoder passwordEncoder;
+    
+    // 패스워드 검증 패턴
+    private static final Pattern LETTER_PATTERN = Pattern.compile(".*[a-zA-Z].*");
+    private static final Pattern DIGIT_PATTERN = Pattern.compile(".*\\d.*");
+    private static final Pattern SPECIAL_CHAR_PATTERN = Pattern.compile(".*[@$!%*?&].*");
+
+    /**
+     * 회원 등록
+     * 
+     * @param request 회원가입 요청 정보
+     */
+    @Override
+    @Transactional
+    public void register(RegisterRequest request) {
+        log.info("회원 등록 시작: {}", request.getUserId());
+        
+        // 중복 확인
+        if (memberRepository.existsByUserId(request.getUserId())) {
+            throw new BusinessException(ErrorCode.DUPLICATE_MEMBER_ID);
+        }
+        
+        if (memberRepository.existsByEmail(request.getEmail())) {
+            throw new BusinessException(ErrorCode.DUPLICATE_EMAIL);
+        }
+        
+        if (request.getBusinessNumber() != null && 
+            memberRepository.existsByBusinessNumber(request.getBusinessNumber())) {
+            throw new BusinessException(ErrorCode.DUPLICATE_BUSINESS_NUMBER);
+        }
+        
+        // 회원 엔티티 생성 및 저장
+        Member member = Member.builder()
+                .userId(request.getUserId())
+                .password(passwordEncoder.encode(request.getPassword()))
+                .name(request.getName())
+                .businessNumber(request.getBusinessNumber())
+                .email(request.getEmail())
+                .build();
+        
+        memberRepository.save(member);
+        log.info("회원 등록 완료: {}", request.getUserId());
+    }
+
+    /**
+     * 사용자 ID 중복 확인
+     * 
+     * @param userId 확인할 사용자 ID
+     * @return 중복 여부
+     */
+    @Override
+    public boolean checkDuplicate(String userId) {
+        return memberRepository.existsByUserId(userId);
+    }
+
+    /**
+     * 이메일 중복 확인
+     * 
+     * @param email 확인할 이메일
+     * @return 중복 여부
+     */
+    @Override
+    public boolean checkEmailDuplicate(String email) {
+        return memberRepository.existsByEmail(email);
+    }
+
+    /**
+     * 사업자번호 중복 확인
+     * 
+     * @param businessNumber 확인할 사업자번호
+     * @return 중복 여부
+     */
+    @Override
+    public boolean checkBusinessNumberDuplicate(String businessNumber) {
+        if (businessNumber == null || businessNumber.trim().isEmpty()) {
+            return false;
+        }
+        return memberRepository.existsByBusinessNumber(businessNumber);
+    }
+
+    /**
+     * 패스워드 유효성 검증
+     * 
+     * @param password 검증할 패스워드
+     * @return 검증 결과
+     */
+    @Override
+    public ValidationResponse validatePassword(String password) {
+        List<String> errors = new ArrayList<>();
+        
+        // 길이 검증
+        if (password.length() < 8 || password.length() > 20) {
+            errors.add("패스워드는 8-20자 사이여야 합니다");
+        }
+        
+        // 영문 포함 여부
+        if (!LETTER_PATTERN.matcher(password).matches()) {
+            errors.add("영문이 포함되어야 합니다");
+        }
+        
+        // 숫자 포함 여부
+        if (!DIGIT_PATTERN.matcher(password).matches()) {
+            errors.add("숫자가 포함되어야 합니다");
+        }
+        
+        // 특수문자 포함 여부
+        if (!SPECIAL_CHAR_PATTERN.matcher(password).matches()) {
+            errors.add("특수문자(@$!%*?&)가 포함되어야 합니다");
+        }
+        
+        if (errors.isEmpty()) {
+            return ValidationResponse.valid("사용 가능한 패스워드입니다.");
+        } else {
+            return ValidationResponse.invalid("패스워드 규칙을 확인해 주세요.", errors);
+        }
+    }
+}
@@ -0,0 +1,33 @@
+server:
+  port: ${MEMBER_PORT:8081}
+
+spring:
+  application:
+    name: member-service
+  datasource:
+    url: jdbc:postgresql://${POSTGRES_HOST:localhost}:${POSTGRES_PORT:5432}/${POSTGRES_DB:MemberDB}
+    username: ${POSTGRES_USER:postgres}
+    password: ${POSTGRES_PASSWORD:postgres}
+    driver-class-name: org.postgresql.Driver
+  jpa:
+    hibernate:
+      ddl-auto: ${DDL_AUTO:update}
+    show-sql: ${SHOW_SQL:true}
+    properties:
+      hibernate:
+        dialect: org.hibernate.dialect.PostgreSQLDialect
+        format_sql: true
+  data:
+    redis:
+      host: ${REDIS_HOST:localhost}
+      port: ${REDIS_PORT:6379}
+      password: ${REDIS_PASSWORD:}
+
+jwt:
+  secret: ${JWT_SECRET:mySecretKeyForJWTTokenGenerationAndValidation123456789}
+  access-token-validity: ${JWT_ACCESS_VALIDITY:3600000}
+  refresh-token-validity: ${JWT_REFRESH_VALIDITY:604800000}
+
+logging:
+  level:
+    com.won.smarketing: ${LOG_LEVEL:DEBUG}