feat: 가계부·게시판 백엔드 API 구현

- com.sb.web 패키지로 재구성: account / auth / board / user / admin / common
- 가계부(account): 내역(필터), 계좌·순자산, 예산, 분류, 정기 거래, 투자 포트폴리오
  (종목·매매 이력, 이동평균 평단·실현/평가손익)
- MyBatis + MariaDB + Redis 세션, BCrypt
- 스키마 자동 초기화(db/*.sql, 멱등), 사용자별 데이터 격리(member_id)
- 문서: docs/BACKEND.md, .env.example

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
ByungCheol
2026-05-31 15:43:09 +09:00
co-authored by Claude Opus 4.8
parent 9243a41385
commit 2a2f81dc32
121 changed files with 5899 additions and 31 deletions
@@ -0,0 +1,51 @@
package com.sb.web.auth.controller;
import com.sb.web.auth.dto.LoginRequest;
import com.sb.web.auth.dto.LoginResponse;
import com.sb.web.auth.dto.MemberResponse;
import com.sb.web.auth.dto.SessionUser;
import com.sb.web.auth.dto.SignupRequest;
import com.sb.web.auth.service.AuthService;
import com.sb.web.auth.web.AuthInterceptor;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
/**
* 인증 API.
* POST /api/auth/signup 회원가입 (비보호)
* POST /api/auth/login 로그인 (비보호)
* POST /api/auth/logout 로그아웃 (보호)
* GET /api/auth/me 내 정보 (보호)
*/
@RestController
@RequestMapping("/api/auth")
@RequiredArgsConstructor
public class AuthController {
private final AuthService authService;
@PostMapping("/signup")
public ResponseEntity<MemberResponse> signup(@Valid @RequestBody SignupRequest req) {
return ResponseEntity.status(HttpStatus.CREATED).body(authService.signup(req));
}
@PostMapping("/login")
public LoginResponse login(@Valid @RequestBody LoginRequest req) {
return authService.login(req);
}
@PostMapping("/logout")
public ResponseEntity<Void> logout(HttpServletRequest request) {
authService.logout(AuthInterceptor.resolveToken(request));
return ResponseEntity.noContent().build();
}
@GetMapping("/me")
public SessionUser me(@RequestAttribute(AuthInterceptor.CURRENT_MEMBER) SessionUser current) {
return current;
}
}
@@ -0,0 +1,32 @@
package com.sb.web.auth.domain;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 회원 도메인. member 테이블과 매핑.
* 로컬(아이디/비밀번호) + 소셜(네이버 등) 로그인을 함께 수용한다.
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Member implements Serializable {
private Long id;
private String loginId; // 로컬 로그인 아이디 (소셜 전용은 null)
private String password; // BCrypt 해시 (소셜 전용은 null)
private String name;
private String email;
private String provider; // LOCAL / NAVER
private String providerId; // 소셜 제공자 측 고유 ID
private String role; // USER / ADMIN
private String status; // ACTIVE / SUSPENDED / WITHDRAWN
private LocalDateTime createdAt;
private LocalDateTime updatedAt;
}
@@ -0,0 +1,17 @@
package com.sb.web.auth.dto;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
/**
* 로컬 로그인 요청 (아이디/비밀번호).
*/
@Data
public class LoginRequest {
@NotBlank(message = "아이디를 입력하세요.")
private String loginId;
@NotBlank(message = "비밀번호를 입력하세요.")
private String password;
}
@@ -0,0 +1,17 @@
package com.sb.web.auth.dto;
import lombok.Builder;
import lombok.Data;
/**
* 로그인 성공 응답. 프론트는 token 을 localStorage 에 저장하고
* 이후 요청 시 Authorization: Bearer {token} 으로 전송한다.
*/
@Data
@Builder
public class LoginResponse {
private String token;
private long expiresInSeconds;
private MemberResponse member;
}
@@ -0,0 +1,31 @@
package com.sb.web.auth.dto;
import com.sb.web.auth.domain.Member;
import lombok.Builder;
import lombok.Data;
/**
* 클라이언트로 내려보내는 회원 정보 (비밀번호 등 민감 정보 제외).
*/
@Data
@Builder
public class MemberResponse {
private Long id;
private String loginId;
private String name;
private String email;
private String provider;
private String role;
public static MemberResponse from(Member m) {
return MemberResponse.builder()
.id(m.getId())
.loginId(m.getLoginId())
.name(m.getName())
.email(m.getEmail())
.provider(m.getProvider())
.role(m.getRole())
.build();
}
}
@@ -0,0 +1,36 @@
package com.sb.web.auth.dto;
import com.sb.web.auth.domain.Member;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* Redis 세션에 저장되는 인증 주체 정보 (경량).
* 인터셉터 통과 후 컨트롤러에서 현재 로그인 사용자로 사용한다.
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SessionUser implements Serializable {
private Long id;
private String loginId;
private String name;
private String role;
private String provider;
public static SessionUser from(Member m) {
return SessionUser.builder()
.id(m.getId())
.loginId(m.getLoginId())
.name(m.getName())
.role(m.getRole())
.provider(m.getProvider())
.build();
}
}
@@ -0,0 +1,27 @@
package com.sb.web.auth.dto;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
import lombok.Data;
/**
* 로컬 회원가입 요청.
*/
@Data
public class SignupRequest {
@NotBlank(message = "아이디를 입력하세요.")
@Size(min = 4, max = 50, message = "아이디는 4~50자여야 합니다.")
private String loginId;
@NotBlank(message = "비밀번호를 입력하세요.")
@Size(min = 8, max = 64, message = "비밀번호는 8~64자여야 합니다.")
private String password;
@NotBlank(message = "이름을 입력하세요.")
private String name;
@Email(message = "이메일 형식이 올바르지 않습니다.")
private String email;
}
@@ -0,0 +1,23 @@
package com.sb.web.auth.mapper;
import com.sb.web.auth.domain.Member;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 회원 MyBatis 매퍼. SQL 은 resources/mapper/MemberMapper.xml 에 정의.
*/
@Mapper
public interface MemberMapper {
Member findById(@Param("id") Long id);
Member findByLoginId(@Param("loginId") String loginId);
Member findByProvider(@Param("provider") String provider,
@Param("providerId") String providerId);
int countByLoginId(@Param("loginId") String loginId);
int insert(Member member);
}
@@ -0,0 +1,102 @@
package com.sb.web.auth.service;
import com.sb.web.auth.domain.Member;
import com.sb.web.auth.dto.LoginRequest;
import com.sb.web.auth.dto.LoginResponse;
import com.sb.web.auth.dto.MemberResponse;
import com.sb.web.auth.dto.SessionUser;
import com.sb.web.auth.dto.SignupRequest;
import com.sb.web.common.exception.ApiException;
import com.sb.web.auth.mapper.MemberMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
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.time.Duration;
import java.util.UUID;
/**
* 인증 서비스.
* - 회원가입: BCrypt 해시 저장
* - 로그인: 비밀번호 검증 후 세션 토큰 발급 → Redis 저장
* - 세션: Redis 에서 토큰으로 조회(슬라이딩 만료), 로그아웃 시 삭제
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class AuthService {
private final MemberMapper memberMapper;
private final PasswordEncoder passwordEncoder;
private final RedisTemplate<String, Object> redisTemplate;
private static final String SESSION_PREFIX = "session:";
private static final Duration SESSION_TTL = Duration.ofMinutes(60);
@Transactional
public MemberResponse signup(SignupRequest req) {
if (memberMapper.countByLoginId(req.getLoginId()) > 0) {
throw new ApiException(HttpStatus.CONFLICT, "이미 사용 중인 아이디입니다.");
}
Member member = Member.builder()
.loginId(req.getLoginId())
.password(passwordEncoder.encode(req.getPassword()))
.name(req.getName())
.email(req.getEmail())
.provider("LOCAL")
.role("USER")
.status("ACTIVE")
.build();
memberMapper.insert(member);
log.info("[signup] new member: {}", member.getLoginId());
return MemberResponse.from(member);
}
public LoginResponse login(LoginRequest req) {
Member member = memberMapper.findByLoginId(req.getLoginId());
if (member == null
|| member.getPassword() == null
|| !passwordEncoder.matches(req.getPassword(), member.getPassword())) {
throw new ApiException(HttpStatus.UNAUTHORIZED, "아이디 또는 비밀번호가 올바르지 않습니다.");
}
if (!"ACTIVE".equals(member.getStatus())) {
throw new ApiException(HttpStatus.FORBIDDEN, "사용할 수 없는 계정입니다.");
}
String token = UUID.randomUUID().toString().replace("-", "");
redisTemplate.opsForValue().set(SESSION_PREFIX + token, SessionUser.from(member), SESSION_TTL);
log.info("[login] {} (token issued)", member.getLoginId());
return LoginResponse.builder()
.token(token)
.expiresInSeconds(SESSION_TTL.getSeconds())
.member(MemberResponse.from(member))
.build();
}
/**
* 토큰으로 세션을 조회하고, 유효하면 TTL 을 갱신(슬라이딩 만료)한다.
*/
public SessionUser getSession(String token) {
if (token == null || token.isBlank()) {
return null;
}
String key = SESSION_PREFIX + token;
Object cached = redisTemplate.opsForValue().get(key);
if (cached instanceof SessionUser user) {
redisTemplate.expire(key, SESSION_TTL);
return user;
}
return null;
}
public void logout(String token) {
if (token != null && !token.isBlank()) {
redisTemplate.delete(SESSION_PREFIX + token);
}
}
}
@@ -0,0 +1,36 @@
package com.sb.web.auth.web;
import com.sb.web.auth.dto.SessionUser;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import java.nio.charset.StandardCharsets;
/**
* 관리자 전용 경로 보호. AuthInterceptor 가 먼저 실행되어 세팅한 SessionUser 의 role 을 검사한다.
*/
@Component
public class AdminInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
if (HttpMethod.OPTIONS.matches(request.getMethod())) {
return true;
}
Object attr = request.getAttribute(AuthInterceptor.CURRENT_MEMBER);
if (attr instanceof SessionUser user && "ADMIN".equals(user.getRole())) {
return true;
}
response.setStatus(HttpStatus.FORBIDDEN.value());
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
response.getWriter().write("{\"status\":403,\"message\":\"관리자 권한이 필요합니다.\"}");
return false;
}
}
@@ -0,0 +1,59 @@
package com.sb.web.auth.web;
import com.sb.web.auth.dto.SessionUser;
import com.sb.web.auth.service.AuthService;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import java.nio.charset.StandardCharsets;
/**
* 보호 경로 접근 시 Authorization: Bearer {token} 을 검증한다.
* 유효한 세션이면 SessionUser 를 요청 속성으로 전달, 아니면 401 JSON 응답.
*/
@Component
@RequiredArgsConstructor
public class AuthInterceptor implements HandlerInterceptor {
public static final String CURRENT_MEMBER = "currentMember";
private final AuthService authService;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// CORS preflight 는 통과
if (HttpMethod.OPTIONS.matches(request.getMethod())) {
return true;
}
SessionUser user = authService.getSession(resolveToken(request));
if (user == null) {
writeUnauthorized(response);
return false;
}
request.setAttribute(CURRENT_MEMBER, user);
return true;
}
public static String resolveToken(HttpServletRequest request) {
String header = request.getHeader(HttpHeaders.AUTHORIZATION);
if (header != null && header.startsWith("Bearer ")) {
return header.substring(7);
}
return null;
}
private void writeUnauthorized(HttpServletResponse response) throws Exception {
response.setStatus(HttpStatus.UNAUTHORIZED.value());
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
response.getWriter().write("{\"status\":401,\"message\":\"로그인이 필요합니다.\"}");
}
}