[SpringBoot] mallangLOG_Level2

1 Project Info

1️⃣ 서비스 요구사항

API 구분	기능
회원가입	- 회원명, 비밀번호 Client에서 전달받기 - username : 4 ~ 10자, 알파벳소문자(a ~ z), 숫자(0 ~ 9) 구성 - password : 8 ~ 15자, 알파벳대소문자(a ~ z, A ~ Z), 숫자(0 ~ 9) 구성 - 회원 DB 중복확인 후, 저장 - 회원가입 성공 시, Client로 성공메시지 + 상태코드 반환
로그인	- 회원명, 비밀번호 Client에서 전달받기 - 회원 DB에서 username을 사용해 조회 → password 유효성검사 - 로그인성공 → username과 JWT 통해 Token 발급 - Token → Response Header에 추가, 성공메시지 + 상태코드 Client 반환
게시글 작성	- Client Token 유효성검사 → 게시글작성 가능 - 제목, 회원명, 작성내용 저장 - 저장된게시글 Client 반환
전체게시글 목록조회	- 제목, 회원명, 작성내용, 작성날짜 조회 - 작성날짜 기준 내림차순 정렬
선택한게시글 조회	- 선택한게시글 제목, 회원명, 작성날짜, 작성내용 조회
선택한게시글 수정	- 수정요청 시, Client Token 유효성검사 + 동일 회원일 경우에만 게시글 수정가능 - 제목, 작성내용 수정 - 수정된게시글 Client 반환
선택한게시글 삭제	- 삭제요청 시, Client Token 유효성검사 + 동일 회원일 경우에만 게시글 삭제가능 - 성공메시지 + 상태코드 Client 반환

2️⃣ ERD

3️⃣ API 명세서

기능	URL	Method	RequestHeader	Request	ResponseHeader	Response
회원가입	/auth/signup	POST	-	{   "username" : String,   "password" : String }	-	{   "status" : 200,   "message" : "You have successfully signed up" }
로그인	/auth/login	POST	-	{   "username" : String,   "password" : String }	Authorization: Bearer <JWT>	{   "status" : 200,   "message" : "You have successfully logged in" }
게시글작성	/post	POST	Authorization: Bearer <JWT>	{   "title" : String,   "content" : String }	-	{   "id" : Long,   "username" : String,   "title" : String,   "content" : String,   "createAt" : String,   "modifiedAt" : String }
전체게시글목록조회	/posts	GET	-	-	-	[ {   "id" : Long,   "username" : String,   "title" : String,    "content" : String,   "createdAt" : String,   "modifiedAt" : String }, {   "id" : Long,   "username" : String,   "title" : String,    "content" : String,   "createdAt" : String,   "modifiedAt" : String }, ••• ]
선택한게시글조회	/post/{post-id}	GET	-	-	-	{   "id" : Long,   "username" : String,   "title" : String,    "content" : String,   "createdAt" : String,   "modifiedAt" : String }
선택한게시글수정	/post/{post-id}	PUT	Authorization: Bearer <JWT>	{   "title" : String,   "content" : String }	-	{   "id" : Long,   "username" : String,   "title" : String,    "content" : String,   "createdAt" : String,   "modifiedAt" : String }
선택한게시글삭제	/post/{post-id}	DELETE	Authorization: Bearer <JWT>	-	-	{   "status" : 200,   "message" : "Your post has been deleted successfully" }

---

2 User 설계

1️⃣ entity > User.java

@Entity(name = "users")
@NoArgsConstructor
@Getter
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    @Column(nullable = false)
    private String password;

    // 생성자
    @Builder
    private User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    // 정적팩토리메서드
    public static User of(String username, String password) {
        return User.builder()
                .username(username)
                .password(password)
                .build();
    }

}

2️⃣ repository > UserRepository.java

public interface UserRepository extends JpaRepository<User, Long> {
}

3️⃣ dto > SignupRequestDto.java

@Getter
public class SignupRequestDto {
    
    // build.gradle -> validation 의존성추가
    @Size(min = 4, max = 10, message = "최소 4자, 최대 10자까지 설정 가능합니다")
    @Pattern(regexp = "[a-z0-9]*$", message = "알파벳소문자 및 숫자로만 설정 가능합니다")
    private String username;

    @Size(min = 8, max = 15, message = "최소 8자, 최대 15자까지 설정 가능합니다")
    @Pattern(regexp = "[a-zA-Z0-9]*$", message = "알파벳대소문자 및 숫자로만 설정 가능합니다")
    private String password;

}

/*build.gradle -> validation 의존성추가*/

// 정규표현식 @Size, @Pattern
    implementation 'org.springframework.boot:spring-boot-starter-validation'

4️⃣ dto > LoginRequestDto.java

@Getter
public class LoginRequestDto {

    private String username;

    private String password;

}

---

3 EntityMapping (User&Post)

1️⃣ entity > Post.java

@Entity
@Getter
@NoArgsConstructor // 파라미터없는 기본생성자
public class Post extends Timestamped {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String title;

    @Column(nullable = false)
    private String content;

    // User Entity -> Post Entity ; 단방향연관관계
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_Id")
    private User user;

    // Client Request 값 -> Dto에서 받아와서 -> 덮어씌움
    @Builder // 빌더패턴 : 생성자를 통해 값을 받음 (-> 정적팩토리메서드)
    private Post(String title, String content, User user) {
        this.title = title;
        this.content = content;
        this.user = user;
    }

    // 정적팩토리메서드
    public static Post of(PostRequestDto postRequestDto, User user) {
        return Post.builder()
                .title(postRequestDto.getTitle())
                .content(postRequestDto.getContent())
                .user(user)
                .build();
    }

    // Post 수정 (Service -> RequestDto -> update 메서드)
    public void update(PostRequestDto postRequestDto) {
        this.title = postRequestDto.getTitle();
        this.content = postRequestDto.getContent();
    }

}

• username, password → 컬럼 삭제

• 생성자 및 정적팩토리메서드 User 부분 추가

• 단방향연관관계 설정

  • 1(User) : N(Post)
  • N인 Post Entity에 @ManyToOne 설정

2️⃣ dto > PostRequestDto.java

@Getter
public class PostRequestDto {

    private String title;

    private String content;

}

• username, password → 삭제

3️⃣ dto > PostResponseDto.java

@Getter
public class PostResponseDto {

    private Long id;

    private String title;

    private String username;

    private String content;

    private LocalDateTime createdAt;

    private LocalDateTime modifiedAt;

    // 생성자
    @Builder
    private PostResponseDto(Long id,
                            String title, String username, String content,
                            LocalDateTime createdAt, LocalDateTime modifiedAt) {
        this.id = id;
        this.title = title;
        this.username = username;
        this.content = content;
        this.createdAt = createdAt;
        this.modifiedAt = modifiedAt;
    }

    // 정적팩토리메서드
    public static PostResponseDto of(Post post) {
        return PostResponseDto.builder()
                .id(post.getId())
                .title(post.getTitle())
                .username(post.getUser().getUsername())
                .content(post.getContent())
                .createdAt(post.getCreatedAt())
                .modifiedAt(post.getModifiedAt())
                .build();
    }

}

• 정적팩토리메서드 → username 가져오는부분 수정

---

4 JWT 설계

1️⃣ build.gradle > jwt dependency 추가

// JWT
compileOnly group: 'io.jsonwebtoken', name: 'jjwt-api', version: '0.11.2'
runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-impl', version: '0.11.2'
runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-jackson', version: '0.11.2'

2️⃣ application.properties > SecretKey 추가

# JWT SecretKey
jwt.secret.key=<암호화코드>

3️⃣ jwt > JwtUtil.java

@Slf4j
@Component
@RequiredArgsConstructor
public class JwtUtil {

    /* JWT Token 생성 필요값 */
    // Header key
    public static final String AUTHORIZATION_HEADER = "Authorization";

    // 사용자 권한값 key
    public static final String AUTHORIZATION_KEY = "auth";

    // JWT Token 인증방식 (Bearer + JWT Token 같이 전송)
    private static final String BEARER_PREFIX = "Bearer ";

    // JWT Token 만료시간 (1h)
    private static final long TOKEN_TIME = 60 * 60 * 1000L;

    // WT SecretKey 불러오기
    @Value("${jwt.secret.key}")
    private String secretKey;

    // JWT Token 서명 및 검증용도
    private Key key;

    // JWT Token 생성(서명) 알고리즘
    private final SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

    // SecretKey 디코딩 후, 서명 및 검증에 필요한 key 생성
    @PostConstruct
    public void init() {
        // secretKey -> 디코딩 -> byte배열에 담음
        byte[] bytes = Base64.getDecoder().decode(secretKey);

        // 디코딩 한 byte배열 -> JWT Token 서명 및 검증에 필요한 key 생성
        key = Keys.hmacShaKeyFor(bytes);
    }


    /* 1. Client Request Header -> JWT Token 가져오기 */
    public String getToken(HttpServletRequest httpServletRequest) {

        // Header에 있는 JWT Token -> clientToken에 담음
        String clientToken = httpServletRequest.getHeader(AUTHORIZATION_HEADER);

        // clientToken 존재 + Bearer로 시작 -> JWT Token 값만 추출
        if (StringUtils.hasText(clientToken) && clientToken.startsWith(BEARER_PREFIX)) {
            return clientToken.substring(7);
        }

        return null;

    }


    /* 2. JWT Token 생성 */
    public String createToken(String username) {

        Date date = new Date();

        return BEARER_PREFIX +
                Jwts.builder()
                        .setSubject(username)
                        .setExpiration(new Date(date.getTime() + TOKEN_TIME))
                        .setIssuedAt(date)
                        .signWith(key, signatureAlgorithm)
                        .compact();

    }


    /* 3. JWT Token 검증 */
    public boolean validateToken(String token) {

        try {

            Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
            return true;

        } catch  (SecurityException | MalformedJwtException exception) {
            log.info("Invalid JWT signature, 유효하지 않는 JWT 서명 입니다");
        } catch (ExpiredJwtException exception) {
            log.info("Expired JWT Token, 만료된 JWT Token 입니다");
        } catch (UnsupportedJwtException exception) {
            log.info("Unsupported JWT Token, 지원되지 않는 JWT Token 입니다");
        } catch (IllegalArgumentException exception) {
            log.info("JWT claims is empty, 잘못된 JWT Token 입니다");
        }

        return false;

    }


    /* 4. JWT Token -> 회원정보 가져오기 */
    public Claims getUserInfoFromToken(String token) {

        return Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token).getBody();

    }

}

---

5 회원가입 설계

1️⃣ StatusMessageResponseDto.java

@Getter
public class StatusMessageResponseDto {

    private Integer status;

    private String message;

    // 생성자
    @Builder
    private StatusMessageResponseDto(Integer status, String message) {
        this.status = status;
        this.message = message;
    }

    // 정적팩토리메서드
    public static StatusMessageResponseDto of(Integer status, String message) {
        return StatusMessageResponseDto.builder()
                .status(status)
                .message(message)
                .build();
    }

}

2️⃣ UserController.java

@RestController
@RequiredArgsConstructor
@RequestMapping("/auth")
public class UserController {

    private final UserService userService;

    // 회원가입
    @PostMapping("/signup")
    public ResponseEntity<StatusMessageResponseDto> signup(@Valid @RequestBody SignupRequestDto signupRequestDto) {

        return userService.signup(signupRequestDto);

    }

}

3️⃣ UserService.java

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;

    private final JwtUtil jwtUtil;

    // 회원가입
    @Transactional
    public ResponseEntity<StatusMessageResponseDto> signup(SignupRequestDto signupRequestDto) {

        // id/pw 가져오기
        String username = signupRequestDto.getUsername();
        String password = signupRequestDto.getPassword();

        // 회원중복확인 (Optional -> 결과값 Null 허용)
        Optional<User> duplicationTest = userRepository.findByUsername(username);

        if (duplicationTest.isPresent()) {
            throw new IllegalArgumentException("A Duplicate user already exists");
        }

        // 회원정보 -> Entity 초기화
        User user = User.of(username, password);

        // Entity -> DB 저장
        userRepository.save(user);

        // 회원가입 성공 시, Client로 성공메시지 + 상태코드 반환
        return ResponseEntity.ok(StatusMessageResponseDto.of(200, "You have successfully signed up"));

    }

}

4️⃣ UserRepository.java

public interface UserRepository extends JpaRepository<User, Long> {

    // 회원가입 -> 중복검사
    Optional<User> findByUsername(String username);

}

---

6 로그인 설계

1️⃣ UserController.java

/* 앞부분 생략 */

// 로그인
@PostMapping("/login")
public ResponseEntity<StatusMessageResponseDto> login(@RequestBody LoginRequestDto loginRequestDto,
                                                      HttpServletResponse httpServletResponse) {

        return userService.login(loginRequestDto, httpServletResponse);

}

/* 뒷부분 생략 */

2️⃣ UserService.java

/* 앞부분 생략 */

// 로그인
@Transactional(readOnly = true)
public ResponseEntity<StatusMessageResponseDto> login(LoginRequestDto loginRequestDto,
                                                      HttpServletResponse httpServletResponse) {

    // id/pw 가져오기
    String username = loginRequestDto.getUsername();
    String password = loginRequestDto.getPassword();

    // 회원유효성검사
    User user = userRepository.findByUsername(username).orElseThrow(
            () -> new IllegalArgumentException("This account does not exist")
    );

    // 비밀번호유효성검사
    if (! user.getPassword().equals(password)) {
        throw new IllegalArgumentException("This password is invalid");
    }

    // 로그인성공 -> ResponseHeader에 JWT Token 보냄
    httpServletResponse.addHeader(JwtUtil.AUTHORIZATION_HEADER, jwtUtil.createToken(user.getUsername()));

    // 로그인 성공 시, Client로 성공메시지 + 상태코드 반환
    return ResponseEntity.ok(StatusMessageResponseDto.of(200, "You have successfully logged in"));

}

/* 뒷부분 생략 */

---

7 게시글작성 JWT인가설계

1️⃣ PostController.java

/* 앞부분 생략 */

// Post 생성
@PostMapping("/post")
public PostResponseDto createPost(@RequestBody PostRequestDto postRequestDto,
                                  HttpServletRequest httpServletRequest) {

    return postService.createPost(postRequestDto, httpServletRequest);

}

/* 뒷부분 생략 */

2️⃣ PostService.java

/* 앞부분 생략 */

private final PostRepository postRepository;

private final UserRepository userRepository;

private final JwtUtil jwtUtil;

// Post 생성
@Transactional // DB처리 작업 중 오류 -> 모든작업 원상태로 복구
public PostResponseDto createPost(PostRequestDto postRequestDto,
                                  HttpServletRequest httpServletRequest) {

    // 1. HTTP Request Header -> JWT Token 가져오기
    String token = jwtUtil.getToken(httpServletRequest);
    Claims claims;

    // 2. JWT Token 유효 -> Post 생성 가능
    if (token != null) {

        // 2-1. JWT Token 검증
        if (jwtUtil.validateToken(token)) {

            // JWT Token 에서 사용자정보 가져오기
            claims = jwtUtil.getUserInfoFromToken(token);

        } else {
            throw new IllegalArgumentException("Token Error");
        }

        // 2-2. Token에서 가져온 사용자 정보 -> DB 조회
        User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                () -> new IllegalArgumentException("This account does not exist")
        );

        // 2-3. 요청받은 DTO -> DB에 저장할 객체생성
        Post post = postRepository.saveAndFlush(Post.of(postRequestDto, user));

        // 2-4. ResponseDto에 객체담아 반환
        return PostResponseDto.of(post);

    } else {

        return null;

    }

}

/* 뒷부분 생략 */

---

8 게시글수정 JWT인가설계

1️⃣ PostController.java

/* 앞부분 생략 */

// Post 수정
@PutMapping("/post/{post-id}")
public PostResponseDto updatePost(@PathVariable(name="post-id") Long postId,
                                  @RequestBody PostRequestDto postRequestDto,
                                  HttpServletRequest httpServletRequest) {

    return postService.updatePost(postId, postRequestDto, httpServletRequest);

}

/* 뒷부분 생략 */

2️⃣ PostService.java

/* 앞부분 생략 */

// Post 수정
@Transactional
public PostResponseDto updatePost(Long postId, PostRequestDto postRequestDto,
                                  HttpServletRequest httpServletRequest) {

    // 1. HTTP Request Header -> JWT Token 가져오기
    String token = jwtUtil.getToken(httpServletRequest);
    Claims claims;

    // 2. JWT Token 유효 -> Post 수정 가능
    if (token != null) {

        // 2-1. JWT Token 검증
        if (jwtUtil.validateToken(token)) {

            // JWT Token 에서 사용자정보 가져오기
            claims = jwtUtil.getUserInfoFromToken(token);

        } else {
            throw new IllegalArgumentException("Token Error");
        }

        // 2-2. User 유효성검사
        User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                () -> new IllegalArgumentException("This account does not exist")
        );

        // 2-3. Post 유효성검사
        Post updatePost = postRepository.findById(postId).orElseThrow(
                () -> new IllegalArgumentException("The Post does not exist")
        );

        // 2-4. 회원소유 유효성검사
        if (! updatePost.getUser().getUsername().equals(user.getUsername())) {
            throw new IllegalArgumentException("You are not authorized to update this post");
        }

        // 2-5. Post 수정
        updatePost.update(postRequestDto);

       // 2-6. update 된 Post 반환
       return PostResponseDto.of(updatePost);

    } else {

        return null;

    }

}

/* 뒷부분 생략 */

---

9 게시글삭제 JWT인가설계

1️⃣ PostController.java

/* 앞부분 생략 */

// Post 삭제
@DeleteMapping("/post/{post-id}")
public ResponseEntity<StatusMessageResponseDto> deletePost(@PathVariable(name="post-id") Long postId,
                                                           HttpServletRequest httpServletRequest) {

    return postService.deletePost(postId, httpServletRequest);

}

/* 뒷부분 생략 */

2️⃣ PostService.java

/* 앞부분 생략 */

// Post 삭제
@Transactional
public ResponseEntity<StatusMessageResponseDto> deletePost(Long postId,
                                                           HttpServletRequest httpServletRequest) {

    // 1. HTTP Request Header -> JWT Token 가져오기
    String token = jwtUtil.getToken(httpServletRequest);
    Claims claims;

    // 2. JWT Token 유효 -> Post 수정 가능
    if (token != null) {

        // 2-1. JWT Token 검증
        if (jwtUtil.validateToken(token)) {

            // JWT Token 에서 사용자정보 가져오기
            claims = jwtUtil.getUserInfoFromToken(token);

        } else {
            throw new IllegalArgumentException("Token Error");
        }

        // 2-2. User 유효성검사
        User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                () -> new IllegalArgumentException("This account does not exist")
        );

        // 2-3. Post 유효성검사
        Post deletePost = postRepository.findById(postId).orElseThrow(
                () -> new IllegalArgumentException("The Post does not exist")
        );

        // 2-4. 회원소유 유효성검사
        if (!deletePost.getUser().getUsername().equals(user.getUsername())) {
            throw new IllegalArgumentException("You are not authorized to delete this post");
        }

        // 2-5. Post 삭제
        postRepository.delete(deletePost);

        // 2-6. Post삭제 성공 시, Client로 성공메시지 + 상태코드 반환
        return ResponseEntity.ok(StatusMessageResponseDto.of(200, "Your Post has been deleted successfully"));

    } else {

        return null;

    }

}

/* 뒷부분 생략 */

---

10 Postman 확인

1️⃣ signup(회원가입)

2️⃣ login(로그인)

3️⃣ createPost(게시글작성)

4️⃣ getPosts(전체게시글목록조회)

5️⃣ getSelectedPost(선택게시글조회)

6️⃣ updatePost(선택게시글수정)

7️⃣ deletePost(선택게시글삭제)