[Rest API] Spring JPA를 통한 CRUD 구현하기

728x90

💡 PURPOSE

개인 프로젝트를 진행하려고 했으나 스스로 생각하기에 아직 api 작성에 대해 많이 부족한 것 같아 어디서부터 시작해야할 지 모르겠어서 일단 jpa에 대한 기초적인 지식을 쌓기 위해 공부한 것을 복습할 겸 포스팅해보겠다.

💡 STUDY LIST

# Subject 2 : Spring JPA를 통한 CRUD 구현하기

1. 사용자 인증 (31~35)
2. 사용자 인증 (2) (36~42)
3. 사용자 인증 토큰 발행 (43~47)
4. 사용자 관리 (48~55)
5.사용자 관리 (2) 통계 (56~60)

💡 CONTENTS

(31) 사용자 등록시 입력값이 유효하지 않은 경우 예외를 발생시키는 기능

입력값 이메일(ID), 이름, 비밀번호, 연락처
사용자 정의 에러 모델을 이용하여 에러를 리턴

/*
user/dto/UserDto.java 생성
*/
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Data
public class UserDto {

  @Email(message = "이메일 형식에 맞게 입력해 주세요.")
  @NotBlank(message = "이메일은 필수 항목 입니다.")
  private String email;

  @NotBlank(message = "이름은 필수 항목 입니다.")
  private String userName;

  @Size(min = 4, message = "비밀번호는 4자 이상 입력해야 합니다.")
  @NotBlank(message = "비밀번호는 필수 항목 입니다.")
  private String password;

  @Size(max = 20, message = "연락처는 최대 20자 이하로 입력해야 합니다.")
  @NotBlank(message = "연락처는 필수 항목 입니다.")
  private String phone;

}

/*
user/controller/UserController.java 생성
*/
@RestController
public class UserController {

  @PostMapping("/api/user")
  public ResponseEntity<?> addUser(@RequestBody @Valid UserDto userDto, Errors errors) {

    List<ResponseError> responseErrorList = new ArrayList<>();
    if (errors.hasErrors()) {
      errors.getAllErrors().forEach((e) -> {
        responseErrorList.add(ResponseError.of((FieldError) e));
      });
      return new ResponseEntity<>(responseErrorList, HttpStatus.BAD_REQUEST);
    }
    return ResponseEntity.ok().build();
  }

}

(32) 사용자 정보를 입력받아서 저장하는 API

입력값 : 이메일(유일한 값 확인), 이름, 비밀번호, 연락처, 가입일 (현재일시)

/*
user/entity/User.java 생성
*/
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Data
@Entity
public class User {

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

  @Column
  private String email;

  @Column
  private String userName;

  @Column
  private String password;

  @Column
  private String phone;

  @Column
  private LocalDateTime regDate;

}

/*
user/repository/UserRepository.java 생성
*/
@Repository
public interface UserRepository extends JpaRepository<User, Long> {

}

@RequiredArgsConstructor
@RestController
public class UserController {

  private final UserRepository userRepository;

  @PostMapping("/api/user")
  public ResponseEntity<?> addUser(@RequestBody @Valid UserDto userDto, Errors errors) {

    List<ResponseError> responseErrorList = new ArrayList<>();
    if (errors.hasErrors()) {
      errors.getAllErrors().forEach((e) -> {
        responseErrorList.add(ResponseError.of((FieldError) e));
      });
      return new ResponseEntity<>(responseErrorList, HttpStatus.BAD_REQUEST);
    }
    
    User user = User.builder()
        .email(userDto.getEmail())
        .userName(userDto.getUserName())
        .password(userDto.getPassword())
        .phone(userDto.getPhone())
        .regDate(LocalDateTime.now())
        .build();
    userRepository.save(user);
    
    return ResponseEntity.ok().build();
  }
}

(33) 사용자 정보를 수정하는 API

사용자 정보가 없는 경우 UserNOtFoundException 발생
수정정보는 연락처만 수정가능, 수정일자는 현재 날짜
에러메시지는 "사용자 정보가 없습니다."

/*
user/dto/UserUpdateDto.java 생성
*/
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Data
public class UserDto {

  @Size(max = 20, message = "연락처는 최대 20자 이하로 입력해야 합니다.")
  @NotBlank(message = "연락처는 필수 항목 입니다.")
  private String phone;

}

/*
user/entity/User.java에 칼럼 추가
*/
@Column
private LocalDateTime regDate;

@RequiredArgsConstructor
@RestController
public class UserController {

  private final UserRepository userRepository;

  @ExceptionHandler(UserNotFoundException.class)
  public ResponseEntity<String> handlerUserNotFoundException(UserNotFoundException exception) {

    return new ResponseEntity<>(exception.getMessage(), HttpStatus.BAD_REQUEST);
  }

  @PutMapping("/api/user/{id}")
  public ResponseEntity<?> updateUser(@PathVariable Long id,
      @RequestBody @Valid UserUpdateDto userUpdateDto, Errors errors) {

    List<ResponseError> responseErrorList = new ArrayList<>();
    if (errors.hasErrors()) {
      errors.getAllErrors().forEach((e) -> {
        responseErrorList.add(ResponseError.of((FieldError) e));
      });
      return new ResponseEntity<>(responseErrorList, HttpStatus.BAD_REQUEST);
    }

    User user = userRepository.findById(id)
        .orElseThrow(() -> new UserNotFoundException("사용자 정보가 없습니다."));

    user.setPhone(userUpdateDto.getPhone());
    user.setUpdateDate(LocalDateTime.now());
    userRepository.save(user);

    return ResponseEntity.ok().build();
  }
}

(34) 사용자 정보 조회 (가입한 아이디에 대한)의 기능을 수행하는 API

다만 보안상 비밀번호와 가입일, 회원정보 수정일은 내리지 않는다.

/*
user/dto/UserResponseDto.java 생성
*/
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Data
public class UserResponseDto {

  private long id;
  private String email;
  private String userName;
  private String phone;

  public static UserResponseDto of(User user) {
    return UserResponseDto.builder()
            .id(user.getId())
            .userName(user.getUserName())
            .phone(user.getPhone())
            .email(user.getEmail())
            .build();
  }
}

@RequiredArgsConstructor
@RestController
public class UserController {

  private final UserRepository userRepository;

  @ExceptionHandler(UserNotFoundException.class)
  public ResponseEntity<String> handlerUserNotFoundException(UserNotFoundException exception) {

    return new ResponseEntity<>(exception.getMessage(), HttpStatus.BAD_REQUEST);
  }

  @GetMapping("/api/user/{id}")
  public UserResponseDto getUser(@PathVariable Long id) {

    User user = userRepository.findById(id)
        .orElseThrow(() -> new UserNotFoundException("사용자 정보가 없습니다."));

    UserResponseDto userResponseDto = UserResponseDto.of(user);

    return userResponseDto;
  }
}

(35) 내가 작성한 공지사항 목록에 대한 API 작성

다만 보안상 삭제일과 삭제자 아이디는 내리지 않음
작성자정보를 모두 내리지 않고, 작성자와 아이디와 이름만 내림

/*
notice/entity/Notice.java에 칼럼 추가
*/
@JoinColumn
@ManyToOne
private User user;

/*
notice/repository/NoticeRepository.java에 추가
*/
List<Notice> findByUser(User user);

/*
notice/dto/NoticeResponseDto.java 생성
*/
@Builder
@Data
@NoArgsConstructor
@AllArgsConstructor
public class NoticeResponseDto {

  private long id;

  private long regUserId;
  private String regUserName;

  private String title;
  private String contents;
  private LocalDateTime regDate;
  private LocalDateTime updateDate;
  private int hits;
  private int likes;

  public static NoticeResponseDto of(Notice notice) {
    return NoticeResponseDto.builder()
        .id(notice.getId())
        .title(notice.getTitle())
        .contents(notice.getContents())
        .regDate(notice.getRegDate())
        .regUserId(notice.getUser().getId())
        .regUserName(notice.getUser().getUserName())
        .updateDate(notice.getUpdateDate())
        .hits(notice.getHits())
        .likes(notice.getLikes())
        .build();
  }
}

@RequiredArgsConstructor
@RestController
public class UserController {

  private final UserRepository userRepository;
  private final NoticeRepository noticeRepository;

  @GetMapping("/api/user/{id}/notice")
  public List<NoticeResponseDto> userNotice(@PathVariable Long id) {

    User user = userRepository.findById(id)
        .orElseThrow(() -> new UserNotFoundException("사용자 정보가 없습니다."));

    List<Notice> noticeList = noticeRepository.findByUser(user);

    List<NoticeResponseDto> noticeResponseDtoList = new ArrayList<>();

    noticeList.stream().forEach((e) -> {
      noticeResponseDtoList.add(NoticeResponseDto.of(e));
    });

    return noticeResponseDtoList;
  }

  @ExceptionHandler(UserNotFoundException.class)
  public ResponseEntity<String> handlerUserNotFoundException(UserNotFoundException exception) {

    return new ResponseEntity<>(exception.getMessage(), HttpStatus.BAD_REQUEST);
  }
]

(36) 사용자 등록시 이미 존재하는 이메일(유일)인 경우 예외를 발생시키는 API

동일한 이메일에 가입된 회원정보가 존재하는 경우 ExistEmailException

/*
exception/ExistsEmailException.java 생성
*/
public class UserNotFoundException extends RuntimeException{
  public UserNotFoundException(String message) {
    super(message);
  }
}

/*
user/repository/UserRepository.java에 추가
*/
int countByEmail(String email);

@RequiredArgsConstructor
@RestController
public class UserController {

  private final UserRepository userRepository;
  private final NoticeRepository noticeRepository;

  @PostMapping("/api/user")
  public ResponseEntity<?> addUser(@RequestBody @Valid UserDto userDto, Errors errors) {

    List<ResponseError> responseErrorList = new ArrayList<>();
    if (errors.hasErrors()) {
      errors.getAllErrors().forEach((e) -> {
        responseErrorList.add(ResponseError.of(e));
      });
      return new ResponseEntity<>(responseErrorList, HttpStatus.BAD_REQUEST);
    }

    if (userRepository.countByEmail(userDto.getEmail()) > 0) {
      throw new ExistsEmailException("이미 존재하는 이메일입니다.");
    }

    User user = User.builder()
        .email(userDto.getEmail())
        .userName(userDto.getUserName())
        .phone(userDto.getPhone())
        .password(userDto.getPassword())
        .regDate(LocalDateTime.now())
        .build();
    userRepository.save(user);

    return ResponseEntity.ok().build();
  }

  @ExceptionHandler(ExistsEmailException.class)
  public ResponseEntity<String> handlerExistsEmailException(ExistsEmailException exception) {

    return new ResponseEntity<>(exception.getMessage(), HttpStatus.BAD_REQUEST);
  }
}

(37) 사용자 비밀번호를 수정하는 API

이전비밀번호와 일치하는 경우 수정
일치하지 않는경우 PasswordNotMatchExeption 발생
발생메시지는 "비밀번호가 일치하지 않습니다."

/*
user/dto/UserPasswordDto.java 생성
*/
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Data
public class UserPasswordDto {

  @NotBlank(message = "현재 비밀번호는 필수 항목 입니다.")
  private String password;

  @Size(min = 4, max = 20, message = "신규 비밀번호는 4-20사이의 길이로 입력해 주세요.")
  @NotBlank(message = "신규 비밀번호는 필수 항목 입니다.")
  private String newPassword;
}

/*
user/repository/UserRepository.java에 추가
*/
Optional<User> findByIdAndPassword(Long id, String password);

/*
exception/UserNotFoundException.java 생성
*/
public class UserNotFoundException extends RuntimeException{
  public UserNotFoundException(String message) {
    super(message);
  }
}

@RequiredArgsConstructor
@RestController
public class UserController {

  private final UserRepository userRepository;
  private final NoticeRepository noticeRepository;


  @PatchMapping("/api/user/{id}/password")
  public ResponseEntity<?> updateUserPassword(@PathVariable Long id, @RequestBody UserPasswordDto userPasswordDto, Errors errors) {

    List<ResponseError> responseErrorList = new ArrayList<>();
    if (errors.hasErrors()) {
      errors.getAllErrors().forEach((e) -> {
        responseErrorList.add(ResponseError.of(e));
      });
      return new ResponseEntity<>(responseErrorList, HttpStatus.BAD_REQUEST);
    }

    User user = userRepository.findByIdAndPassword(id, userPasswordDto.getPassword())
        .orElseThrow(() -> new PasswordNotMatchException("비밀번호가 일치하지 않습니다."));

    user.setPassword(userPasswordDto.getNewPassword());
    userRepository.save(user);

    return ResponseEntity.ok().build();
  }

  @ExceptionHandler(PasswordNotMatchException.class)
  public ResponseEntity<String> handlerPasswordNotMatchException(PasswordNotMatchException exception) {

    return new ResponseEntity<>(exception.getMessage(), HttpStatus.BAD_REQUEST);
  }
}

(38) 회원가입시 비밀번호를 암호화하여 저장하는 API

@RequiredArgsConstructor
@RestController
public class UserController {

  private final UserRepository userRepository;
  private final NoticeRepository noticeRepository;

  private String getEncryptPassword(String password) {
    BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
    return bCryptPasswordEncoder.encode(password);
  }

  @PostMapping("/api/user")
  public ResponseEntity<?> addUser(@RequestBody @Valid UserDto userDto, Errors errors) {

    List<ResponseError> responseErrorList = new ArrayList<>();
    if (errors.hasErrors()) {
      errors.getAllErrors().forEach((e) -> {
        responseErrorList.add(ResponseError.of(e));
      });
      return new ResponseEntity<>(responseErrorList, HttpStatus.BAD_REQUEST);
    }

    if (userRepository.countByEmail(userDto.getEmail()) > 0) {
      throw new ExistsEmailException("이미 존재하는 이메일입니다.");
    }

    String encryptPassword = getEncryptPassword(userDto.getPassword());

    User user = User.builder()
        .email(userDto.getEmail())
        .userName(userDto.getUserName())
        .phone(userDto.getPhone())
        .password(encryptPassword)
        .regDate(LocalDateTime.now())
        .build();
    userRepository.save(user);

    return ResponseEntity.ok().build();
  }
}

(39) 사용자 회원 탈퇴 기능에 대한 API

회원정보가 존재하지 않은 경우 예외처리
만약, 회원이 게시판에 글을 쓴 경우는 회원삭제가 되지 않음

@RequiredArgsConstructor
@RestController
public class UserController {

  private final UserRepository userRepository;
  private final NoticeRepository noticeRepository;

  @DeleteMapping("/api/user/{id}")
  public ResponseEntity<?> deleteUser(@PathVariable Long id) {

    User user = userRepository.findById(id)
        .orElseThrow(() -> new UserNotFoundException("사용자 정보가 없습니다."));

    try {
      userRepository.delete(user);
    } catch (DataIntegrityViolationException e) {
      String message = "제약조건에 문제가 발생하였습니다.";
      return new ResponseEntity<>(message, HttpStatus.BAD_REQUEST);
    } catch (Exception e) {
      String message = "회원 탈퇴 중 문제가 발생하였습니다.";
      return new ResponseEntity<>(message, HttpStatus.BAD_REQUEST);
    }

    return ResponseEntity.ok().build();
  }
}

(40) 사용자 아이디(이메일)을 찾는 API

이름과 전화번호에 해당하는 이메일을 찾는다.

728x90

'Web Develop > Spring' 카테고리의 다른 글

[Spring JPA] ORM 그리고 Spring Data JPA (1)	2023.11.22
[Rest API] 컨트롤러를 통한 게시판 기능 구현하기_SpringBoot (0)	2023.10.25
스프링 Swagger 오류 해결 - Failed to start bean 'documentationPluginsBootstrapper'; nested exception is java.lang.NullPointerException (0)	2023.09.02
스프링 프레임워크 (0)	2023.06.17

TripleUp develog

[Rest API] Spring JPA를 통한 CRUD 구현하기_SpringBoot

💡 PURPOSE

💡 STUDY LIST

# Subject 2 : Spring JPA를 통한 CRUD 구현하기

💡 CONTENTS

'Web Develop > Spring' 카테고리의 다른 글

댓글

티스토리툴바

[Rest API] Spring JPA를 통한 CRUD 구현하기_SpringBoot

💡 PURPOSE

💡 STUDY LIST

# Subject 2 : Spring JPA를 통한 CRUD 구현하기

💡 CONTENTS

'Web Develop > Spring' 카테고리의 다른 글

관련글

댓글

티스토리툴바