[BackEnd][Maven-PJ] 사내 개발자 커뮤니티 서비스 - 회원 관련 : 회원 가입

 

🧑🏻‍💻 Git Hub 주소

 

 

🗂 목차

● [BackEnd][Maven-PJ] 개발자 커뮤니티 서비스 - 게시판 만들기 : 글 등록(작성) / 수정

● [BackEnd][Maven-PJ] 개발자 커뮤니티 서비스 - 게시판 만들기 : 목록 조회

● [BackEnd][Maven-PJ]개발자 커뮤니티 서비스 - 게시판 만들기 : 상세 조회

● [BackEnd][Maven-PJ]개발자 커뮤니티 서비스 - 게시판 만들기 : 삭제

● [BackEnd][Maven-PJ] 사내 개발자 커뮤니티 서비스 - 게시판 : 답변 등록 / 수정

● [BackEnd][Maven-PJ] 사내 개발자 커뮤니티 서비스 - 게시판 : 답변 삭제

 

👨‍👩‍👧‍👦 회원 관련

● [BackEnd][Maven-PJ] 사내 개발자 커뮤니티 서비스 - 회원 관련 : 회원 가입

 

 

📚부 록 

● [BackEnd][Maven-PJ]개발자 커뮤니티 서비스 - 게시판 만들기 : Paging처리

● [Spring] @Valid를 이용한 @RequestBody 검증 / Exception Handling / 정규 표현식

🤔 내가 만난 Exception

● [Exception 정리] org.apache.ibatis.binding.BindingException: Invalid bound statement (not found)

● [Vue.js][Spring] Post Data 전송 간 null값 전송 문제

 

 

 

 

 

 

🚀 회원 관련 - 회원 가입

    🔽  Data Base Table 구성

user Table

 

 

 

 

    🔽  Swagger

 

 

 

 

 

    🔽  Code 분석

        📦 CustomUserDetails.java

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {        // 이용자 권한 목록 반환 Method

        ArrayList<GrantedAuthority> auth = new ArrayList<>();

        auth.add(new SimpleGrantedAuthority(authority));

        return auth;
    } // getAuthorities() 끝

    @Override
    public boolean isAccountNonExpired() {     		// 계정 만료 여부 | true : 만료 안됨, false : 만료
        return true;
    } // isAccountNonExpired() 끝

    @Override
    public boolean isAccountNonLocked() {    		 // 계정 잠김 여부 | true : 안 잠김, false : 잠김
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {     // 비밀번호 만료 여부 | true : 만료 안됨, false : 만료
        return true;
    } // isCredentialsNonExpired() 끝

    @Override
    public boolean isEnabled() {         			// 계정 활성화 여부 | true : 활성화, false : 비 활성화
        return true;
    }

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    @Override
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public String getUserEmail() {
        return userEmail;
    }

    public void setUserEmail(String userEmail) {
        this.userEmail = userEmail;
    }

    public String getUserPhone() {
        return userPhone;
    }

    public void setUserPhone(String userPhone) {
        this.userPhone = userPhone;
    }

    public String getTeamName() {
        return teamName;
    }

    public void setTeamName(String teamName) {
        this.teamName = teamName;
    }

    public String getUserKind() {
        return userKind;
    }

    public void setUserKind(String userKind) {
        this.userKind = userKind;
    }

    public boolean isEnable() {
        return enable;
    }

    public void setEnable(boolean enable) {
        this.enable = enable;
    }

    public String getAuthority() {
        return authority;
    }

    public void setAuthority(String authority) {
        this.authority = authority;
    }

} // class 끝

 

주니하랑은 회원가입 및 Login 시 이용될 Value Object 객체를 `UserDetails`를 구현한 Class를 만들어서 구현한 것이에요.

 

 

 

        📦 DuplicateByIdInfoDTO.java

 

이 DTO는 회원가입 시에 중복 확인등에 확인 절차에서 이용될 값들을 Meber 변수로 이용하는 DTO인 것이에요.

 

        📦 UserController.java

/**
 * 회원 관련 Controller
 * <pre>
 * <b>History:</b>
 *    주니하랑, 1.0.0, 2022.03.24 최초 작성
 * </pre>
 *
 * @author 주니하랑
 * @version 1.0.0, 2022.03.24 최초 작성
 * @See ""
 * @see <a href=""></a>
 */

@Api(tags = {"회원 관리 관련 API"}) @Slf4j @RequiredArgsConstructor
@RequestMapping(ServiceURIMng.USER)
@RestController public class UserController {

    private final UserService userService;

    @ApiOperation(value = SwaggerApiInfo.DUPLICATE_ID, notes = "회원 가입 전 ID 중복 확인 서비스 입니다.")
    @ApiParam(name = "DuplicateByIdInfoDTO", value = "이용을 원하는 이용자가 회원 가입을 위해 ID 중복 확인 합니다.", readOnly = true)
    @ApiResponses(value = {
            @ApiResponse(code = 200, message = "사용 가능"),
            @ApiResponse(code = 409, message = "입력값 중복"),
            @ApiResponse(code = 500, message = "Server Internal Error")
    })

    @ResponseBody
    @PostMapping("/duplicate/userid") public DefaultResponse duplicateUserID(@RequestBody DuplicateByIdInfoDTO duplicateByIdInfoDTO) {

        log.info("UserController의 duplicateUserID(@RequestBody DuplicateByIdInfoDTO duplicateByIdInfoDTO)가 호출 되었습니다! Client로 부터 전달된 값 확인 : " + duplicateByIdInfoDTO.toString());
        log.info("userService.duplicateUserID(duplicateByIdInfoDTO)를 호출하여 비즈니스 로직을 처리하겠습니다!");

        return userService.duplicateUserID(duplicateByIdInfoDTO);

    } // duplicateId(@RequestBody String username) 끝

    @ApiOperation(value = SwaggerApiInfo.DUPLICATE_NICKNAME, notes = "회원 가입 전 별명 중복 확인 서비스 입니다.")
    @ApiParam(name = "DuplicateByIdInfoDTO", value = "이용을 원하는 이용자가 회원 가입을 위해 별명 중복 확인 합니다.", readOnly = true)
    @ApiResponses(value = {
            @ApiResponse(code = 200, message = "사용 가능"),
            @ApiResponse(code = 409, message = "입력값 중복"),
            @ApiResponse(code = 500, message = "Server Internal Error")
    })

    @ResponseBody
    @PostMapping("/duplicate/nickname") public DefaultResponse duplicateUserNickName(@RequestBody DuplicateByIdInfoDTO duplicateByIdInfoDTO) {

        log.info("UserController의 duplicateUserNickName(@RequestBody DuplicateByIdInfoDTO duplicateByIdInfoDTO)가 호출 되었습니다! Client로 부터 전달된 값 확인 : " + duplicateByIdInfoDTO.toString());
        log.info("userService.duplicateUserNickName(duplicateByIdInfoDTO)를 호출하여 비즈니스 로직을 처리하겠습니다!");

        return userService.duplicateUserNickName(duplicateByIdInfoDTO);

    } // duplicateId(@RequestBody String username) 끝

    @ApiOperation(value = SwaggerApiInfo.DUPLICATE_EMAIL, notes = "회원 가입 전 E-mail 중복 확인 서비스 입니다.")
    @ApiParam(name = "DuplicateByIdInfoDTO", value = "이용을 원하는 이용자가 회원 가입을 위해 mail 중복 확인 합니다.", readOnly = true)
    @ApiResponses(value = {
            @ApiResponse(code = 200, message = "사용 가능"),
            @ApiResponse(code = 409, message = "입력값 중복"),
            @ApiResponse(code = 500, message = "Server Internal Error")
    })

    @ResponseBody
    @PostMapping("/duplicate/email") public DefaultResponse duplicateUserEmail(@RequestBody DuplicateByIdInfoDTO duplicateByIdInfoDTO) {

        log.info("UserController의 duplicateUserEmail(@RequestBody DuplicateByIdInfoDTO duplicateByIdInfoDTO)가 호출 되었습니다! Client로 부터 전달된 값 확인 : " + duplicateByIdInfoDTO.toString());
        log.info("userService.duplicateUserEmail(duplicateByIdInfoDTO)를 호출하여 비즈니스 로직을 처리하겠습니다!");

        return userService.duplicateUserEmail(duplicateByIdInfoDTO);

    } // duplicateId(@RequestBody String username) 끝

    @ApiOperation(value = SwaggerApiInfo.DUPLICATE_PHONE_NUMBER, notes = "회원 가입 전 핸드폰 번호 중복 확인 서비스 입니다.")
    @ApiParam(name = "DuplicateByIdInfoDTO", value = "이용을 원하는 이용자가 회원 가입을 위해 핸드폰 번호 중복 확인 합니다.", readOnly = true)
    @ApiResponses(value = {
            @ApiResponse(code = 200, message = "사용 가능"),
            @ApiResponse(code = 409, message = "입력값 중복"),
            @ApiResponse(code = 500, message = "Server Internal Error")
    })

    @ResponseBody
    @PostMapping("/duplicate/phone-number") public DefaultResponse duplicateUserPhoneNumber(@RequestBody DuplicateByIdInfoDTO duplicateByIdInfoDTO) {

        log.info("UserController의 duplicateUserPhoneNumber(@RequestBody DuplicateByIdInfoDTO duplicateByIdInfoDTO)가 호출 되었습니다! Client로 부터 전달된 값 확인 : " + duplicateByIdInfoDTO.toString());
        log.info("userService.duplicateUserPhoneNumber(duplicateByIdInfoDTO)를 호출하여 비즈니스 로직을 처리하겠습니다!");

        return userService.duplicateUserPhoneNumber(duplicateByIdInfoDTO);

    } // duplicateId(@RequestBody String username) 끝

    @ApiOperation(value = SwaggerApiInfo.SIGN_UP, notes = "회원 가입 서비스 입니다.")
    @ApiParam(name = "customUserDetails", value = "이용을 원하는 이용자가 회원 가입을 위해 작성한 내용을 담은 객체 입니다. \n 필수 : 자기 소개, 프로필 사진을 제외한 모든 항목 \n 비밀번호는 암호화 처리", readOnly = true)
    @ApiResponses(value = {
            @ApiResponse(code=200, message = "Email 중복"),
            @ApiResponse(code=201, message = "가입 성공"),
            @ApiResponse(code = 500, message = "Server Internal Error")
    })

    @PostMapping("/signup") public ResponseEntity<DefaultResponse> signUp (@Valid @RequestBody CustomUserDetails customUserDetails) {

        log.info("UserController의 signUp (@Valid @RequestBody UserSignUpRequestDTO userSignUpRequestDTO)이 호출 되었습니다!");
        log.info("userService.signUp(userSignUpRequestDTO)를 호출하여 비즈니스 로직을 처리하겠습니다!");

        return new ResponseEntity<>(userService.signUp(customUserDetails), HttpStatus.OK);

    } // signUp (@Valid @RequestBody UserSignUpRequestDTO userSignUpRequestDTO) 끝

} // class 끝

 

본격적으로 Controller를 분석해 볼 것이에요. 일단, `signUp()`을 제외한 모든 Method는 각 값의 중복 여부를 확인하기 위한 Method인 것이에요. 따라서 이 부분에 대해서는 `ID 중복 확인`에 대한 것만 글을 작성 해 보도록 할 것이에요.

 

► duplicateUserID()

Swagger

Swagger

 

 

UserController.java - 31 ~ 53

최초 Swagger를 이용하여 해당 API가 어떤 API인지 표시를 해 준 것이에요.

그런 뒤 `System.out.println()` 대신 Console에 동작들을 확인하기 위해 출력한 `@Slf4j`를 선언하고, final Member 변수를 이용하면서 생성자를 생성하기 위해 `@RequiredArgsConstructor`를 선언해 준 것이에요.

 

그런 다음 Service를 DI하기 위해 Member 변수로 선언을 해 준 것이에요.

 

`@ResponseBody`를 통해 JSON Type의 Data를 반환할 수 있도록 선언 해 주고, `@PostMapping`으로 HTTP Method `POST`를 통해 Data를 받겠다고 선언하면서 연결 될 URI를 설정 해 준 것이에요. `DefaultResponse`는 주니하랑이 만든 객체인데, 살펴 보자면

 

/**
 * 응답 Message를 위한 Class
 * <pre>
 * <b>History:</b>
 *    주니하랑, 1.0.0, 2022.02.24 최초 작성
 * </pre>
 *
 * @author 주니하랑
 * @version 1.0.0, 2022.02.24 최초 작성
 * @See ""
 * @see <a href=""></a>
 */

@Data @AllArgsConstructor @Builder
public class DefaultResponse<T> {

    // API 상태 코드
    private Integer statusCode;

    // API 부가 설명 (한글)
    private String MessageKo;

    // API 부가 설명 (영어)
    private String MessageEn;

    // API 응답 데이터
    private T data;

    // 상태 코드 + 부가 설명 반환
    public static <T> DefaultResponse<T> response(final Integer statusCode, final String MessageKo, final String MessageEn){
        return (DefaultResponse<T>) DefaultResponse.builder()
                .statusCode(statusCode)
                .MessageKo(MessageKo)
                .MessageEn(MessageEn)
                .build();
    }   // response(final Integer statusCode, final String MessageKo, final String MessageEn) 끝

    // 상태 코드 + 부가 설명 + 응답 데이터 반환
    public static <T> DefaultResponse<T> response(final Integer statusCode, final String MessageKo, final String MessageEn, final T data){
        return (DefaultResponse<T>) DefaultResponse.builder()
                .statusCode(statusCode)
                .MessageKo(MessageKo)
                .MessageEn(MessageEn)
                .data(data)
                .build();
    }   // response(final Integer statusCode, final String MessageKo, final String MessageEn, final T data) 끝
} // class 끝

반응형

바로 이렇게 만들어진 Class인 것이에요.

이 Class를 응답으로 던져준다는 것은 응답 Code, 응답 부가 설명(한글), 응답 부가 설명(영어), API 응답 Data를 객체로 Client에게 전달 해 주기 위한 Class인 것이에요.

주니하랑은 이 Method에서 요청을 `@RequestBody`를 통해  `DuplicateByIdInfoDTO`로 받기로 한 것이에요.

그런 다음 이 Method가 동작했는지 무엇을 할 것인지를 Console에 출력하고 나서 바로 Service에 해당 Method를 호출하는데, `DuplicateByIdInfoDTO`를 매개 변수로 전달하면서 반환값이 오면 바로 반환되도록 한 것이에요.

 

 

► signUp()

UserController.java - 117 ~ 112

위 그림에서 나오는 Method는 회원 가입을 처리 해 주는 Method인 것이에요. 

`@Valid`를 통해 요청값에 대한 유효성 검사를 하게 하고, 매개 변수로 `CustomUserDetails` 객체를 받고 있는 것이에요.

이 Mehotd는 반환할 때, `ResponseEntity<DefaultResponse>`를 반환하고 있어서 122번째 줄에서 ResponseEntity 객체를 하나 만들어 주고, Service에 해당 Method에 결과값이 오면 반환을 해 주는데, 작업이 정상적으로 진행이 되면 반환이 오기 때문에 HTTP Status Code 200(HTTpStatus.OK)를 같이 반환 해 주는 것이에요.

​

 

 

        📦 UserService.java

/**
 * 회원 가입 관련 비즈니스 로직
 * <pre>
 * <b>History:</b>
 *    주니하랑, 1.0.0, 2022.03.24 최초 작성
 *    주니하랑, 1.0.1, 2022.03.24 ID 중복 확인 Logic 구현
 * </pre>
 *
 * @author 주니하랑
 * @version 1.0.1, 2022.03.24 ID 중복 확인 Logic 구현
 * @See ""
 * @see <a href=""></a>
 */

public interface UserService {

    /**
     * 회원 가입 전 등록된 정보 인지 확인
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    DefaultResponse duplicateUserID(DuplicateByIdInfoDTO duplicateByIdInfoDTO);

    /**
     * 회원 가입 전 등록된 정보 인지 확인
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    DefaultResponse duplicateUserNickName(DuplicateByIdInfoDTO duplicateByIdInfoDTO);

    /**
     * 회원 가입 전 등록된 정보 인지 확인
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    DefaultResponse duplicateUserEmail(DuplicateByIdInfoDTO duplicateByIdInfoDTO);

    /**
     * 회원 가입 전 등록된 정보 인지 확인
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    DefaultResponse duplicateUserPhoneNumber(DuplicateByIdInfoDTO duplicateByIdInfoDTO);

    /**
     * 회원 가입 서비스
     * @param customUserDetails - 회원 가입을 위한 이용자 입력값을 담은 Object
     * @return DefaultResponse - 서버 처리 여부에 해당하는 Status Code 반환을 위한 객체
     * @see ""
     */

    DefaultResponse signUp(CustomUserDetails customUserDetails);


} // interface 끝

 

UserService는 단순히 추상 Method를 만들어서 각 Logic에 맞게 구현한 것이에요.

 

 

        📦 UserServiceImpl.java

/**
 * 회원 가입 관련 비즈니스 로직
 * <pre>
 * <b>History:</b>
 *    주니하랑, 1.0.0, 2022.03.24 최초 작성
 * </pre>
 *
 * @author 주니하랑
 * @version 1.0.0, 2022.03.24 최초 작성
 * @See ""
 * @see <a href=""></a>
 */

@RequiredArgsConstructor @Slf4j
@Service public class UserServiceImpl implements UserService {

    private final PasswordEncoder passwordEncoder;
    private final UserMapper userMapper;

    /**
     * 회원 가입 전 등록된 ID 정보 인지 확인
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    @Override
    public DefaultResponse duplicateUserID(DuplicateByIdInfoDTO duplicateByIdInfoDTO) {

        log.info("UserServiceImpl의 duplicateUserID(String username)가 호출 되었습니다! Client로 부터 전달된 값 : " + duplicateByIdInfoDTO);
        log.info("DB에서 회원 가입 요청 이용자가 입력한 UserId(username)를 통해 해당 회원이 등록 되어 있는지 찾겠습니다!");
        Optional<DuplicateByIdInfoDTO> findByUserID = userMapper.findByUserID(duplicateByIdInfoDTO);

        if (findByUserID.isEmpty()) {

            log.info("중복 되는 값이 없습니다! 200 Code와 함께 \"사용 가능!\" 반환 하겠습니다!");

            return DefaultResponse.response(200, "사용 가능", "OK", findByUserID);

        } else {

            log.info("이미 존재하는 ID 입니다! 409 Code와 함께 \"이미 존재하는 값 입니다!\" 반환 하겠습니다!");

        return DefaultResponse.response(409, "이미 존재하는 ID 입니다!", "Conflict");
        } // // if-else (checkEmail.isEmpty()) 끝

    } // duplicateId(String username) 끝

    /**
     * 회원 가입 전 등록된 별명 정보 인지 확인
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    @Override
    public DefaultResponse duplicateUserNickName(DuplicateByIdInfoDTO duplicateByIdInfoDTO) {
        log.info("UserServiceImpl의 duplicateUserID(String username)가 호출 되었습니다! Client로 부터 전달된 값 : " + duplicateByIdInfoDTO);
        log.info("DB에서 회원 가입 요청 이용자가 입력한 별명을 통해 해당 회원이 등록 되어 있는지 찾겠습니다!");
        Optional<DuplicateByIdInfoDTO> findByUserNickName = userMapper.findByUserNickName(duplicateByIdInfoDTO);



        if (findByUserNickName.isEmpty()) {

            log.info("중복 되는 값이 없습니다! 200 Code와 함께 \"사용 가능!\" 반환 하겠습니다!");

            return DefaultResponse.response(200, "사용 가능", "OK", findByUserNickName);

        } else {

            log.info("이미 존재하는 별명 입니다! 409 Code와 함께 \"이미 존재하는 값 입니다!\" 반환 하겠습니다!");

            return DefaultResponse.response(409, "이미 존재하는 별명 입니다!", "Conflict");
        } // // if-else (checkEmail.isEmpty()) 끝
    }

    /**
     * 회원 가입 전 등록된 Email 정보 인지 확인
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    @Override
    public DefaultResponse duplicateUserEmail(DuplicateByIdInfoDTO duplicateByIdInfoDTO) {
        log.info("UserServiceImpl의 duplicateUserID(String username)가 호출 되었습니다! Client로 부터 전달된 값 : " + duplicateByIdInfoDTO);
        log.info("DB에서 회원 가입 요청 이용자가 입력한 UserId(username)를 통해 해당 회원이 등록 되어 있는지 찾겠습니다!");
        Optional<DuplicateByIdInfoDTO> findByUserEmail = userMapper.findByUserEmail(duplicateByIdInfoDTO);

        if (findByUserEmail.isEmpty()) {

            log.info("중복 되는 값이 없습니다! 200 Code와 함께 \"사용 가능!\" 반환 하겠습니다!");

            return DefaultResponse.response(200, "사용 가능", "OK", findByUserEmail);

        } else {

            log.info("이미 존재하는 Email 입니다! 409 Code와 함께 \"이미 존재하는 값 입니다!\" 반환 하겠습니다!");

            return DefaultResponse.response(409, "이미 존재하는 Email 입니다!", "Conflict");
        } // // if-else (checkEmail.isEmpty()) 끝
    }

    /**
     * 회원 가입 전 등록된 핸드폰 번호 정보 인지 확인
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    @Override
    public DefaultResponse duplicateUserPhoneNumber(DuplicateByIdInfoDTO duplicateByIdInfoDTO) {
        log.info("UserServiceImpl의 duplicateUserID(String username)가 호출 되었습니다! Client로 부터 전달된 값 : " + duplicateByIdInfoDTO);
        log.info("DB에서 회원 가입 요청 이용자가 입력한 UserId(username)를 통해 해당 회원이 등록 되어 있는지 찾겠습니다!");
        Optional<DuplicateByIdInfoDTO> findByUserphoneNumber = userMapper.findByUserPhoneNumber(duplicateByIdInfoDTO);

        if (findByUserphoneNumber.isEmpty()) {

            log.info("중복 되는 값이 없습니다! 200 Code와 함께 \"사용 가능!\" 반환 하겠습니다!");

            return DefaultResponse.response(200, "사용 가능", "OK", findByUserphoneNumber);

        } else {

            log.info("이미 존재하는 핸드폰 번호 입니다! 409 Code와 함께 \"이미 존재하는 값 입니다!\" 반환 하겠습니다!");

            return DefaultResponse.response(409, "이미 존재하는 핸드폰 번호 입니다!", "Conflict");
        } // // if-else (checkEmail.isEmpty()) 끝
    }

    /**
     * 회원 가입 서비스
     * @param customUserDetails - 회원 가입을 위한 이용자 입력값을 담은 Object
     * @return DefaultResponse - 서버 처리 여부에 해당하는 Status Code 반환을 위한 객체
     * @see ""
     */

    @Override
    public DefaultResponse signUp(CustomUserDetails customUserDetails) {

        log.info("UserServiceImpl의 signUp(CustomUserDetails customUserDetails)이 호출 되었습니다!");

        log.info("DB에서 회원 가입 요청 이용자가 입력한 UserId(username)를 통해 해당 회원이 등록 되어 있는지 찾겠습니다!");

        log.info("이용자의 패스워드를 암호화 하겠습니다!");
        customUserDetails.setPassword(passwordEncoder.encode(customUserDetails.getPassword()));

        userMapper.signUp(customUserDetails);

        return DefaultResponse.response(200, "회원 가입 완료!", "Success Sign up");
    } // signUp(CustomUserDetails customUserDetails) 끝
} // class 끝

 

 

 

        📦 UserMapper.java

/**
 * 회원 관련 Mapper
 * <pre>
 * <b>History:</b>
 *    주니하랑, 1.0.0, 2022.03.24 최초 작성
 * </pre>
 *
 * @author 주니하랑
 * @version 1.0.0, 2022.03.24 최초 작성
 * @See ""
 * @see <a href=""></a>
 */

@Mapper @Repository public interface UserMapper {

    /**
     * 회원 가입 전 등록된 정보 인지 확인
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    Optional<DuplicateByIdInfoDTO> findByUserID(DuplicateByIdInfoDTO duplicateByIdInfoDTO);

    /**
     * 회원 가입 전 등록된 정보 인지 확인 - 별명
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    Optional<DuplicateByIdInfoDTO> findByUserNickName(DuplicateByIdInfoDTO duplicateByIdInfoDTO);

    /**
     * 회원 가입 전 등록된 정보 인지 확인 - E-mail
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    Optional<DuplicateByIdInfoDTO> findByUserEmail(DuplicateByIdInfoDTO duplicateByIdInfoDTO);

    /**
     * 회원 가입 전 등록된 정보 인지 확인 - 핸드폰 번호
     * @param duplicateByIdInfoDTO - 회원 가입 전 등록 되어 있는 정보 인지 확인을 위한 이용자 입력 정보 DTO
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    Optional<DuplicateByIdInfoDTO> findByUserPhoneNumber(DuplicateByIdInfoDTO duplicateByIdInfoDTO);

    /**
     * 회원 가입을 위한 추상 Method
     * @param customUserDetails - 회원 가입 시 이용자가 입력한 정보 담은 객체
     * @return CustomUserDetails - 해당 회원의 정보 반환
     * @see ""
     */

    void signUp(CustomUserDetails customUserDetails);
} // interface 끝

 

► duplicateUserID()

UserServiceImpl.java - 27 ~ 60

이 친구가 본격적으로 비즈니스 Logic을 담당하게 될 UserService를 Implements(구현)한 구현체인 것이에요.

먼저 해당 Class를 Spring Bean에 해당 Class를 Service로 자동 주입하기 위해 `@Service`를 선언해 준 것이에요. 

그런 다음 회원 가입을 할 때, 이용자의 비밀번호를 암호화 하기 위해 `PasswordEncoder` 객체를 선언하고, DB를 이용하기 위해 `UserMapper `객체를 선언한 것이에요. 이 친구들은 final로 정의되어 있고, 이 때문에 `@RequiredArgsConstructor`를 선언하여 생성자를 이용할 수 있도록 해 준 것이에요.

최초 이 Method가 호출되면 `Mapper`에 해당 Method를 통해 `DuplicateByIdInfoDTO`를 전달해서 호출하는데, 이 때 이용자가 ID 중복 확인 버튼을 누르게 되면 해당 ID를 DB에 Select하게 되고, 그 결과 값을 `Optional`로 `NPE(Null Point Exception)` 방지를 통해 `DuplicateByIdInfoDTO` 객체 자료형 Type의 변수 `findByuserID`에 담아 주는 것이에요.

그런 뒤 47번째 줄에 if문을 통해 해당 변수에 값이 비어 있다면 중복되는 ID가 없다는 것이기 때문에 반환 할 때, HTTP Status Code 200과 함께 응답 Message로 한글은 `사용 가능`과 영어로는 `OK`를 반환하고, 해당 검색 결과를 반환하기 위해 객체를 추가로 반환 해 주는 것이에요. 

만약 검색 결과가 있다면 해당 ID는 존재한다는 의미가 되고, 반환 할 때, HTTP Status Code를 409와 함께 응답 Message로 한글은 `이미 존재하는 ID 입니다!`와 영어로 `Confilct`를 반환 해 주는 것이에요.

 

 

► signUp()

UserServiceImpl.java - 145 ~ 165

회원 가입에 대한 비즈니스 로직은 이 곳에서 처리가 되는 것이에요.

최초 이 친구가 동작을 하게 되면 이용자 비밀번호를 암호화 하기 위해 `PasswordEncoder`에 `encode()`를 호출하는데, 이 때 이용자가 보낸 `CustomUserDetails` 객체 안에 입력된 password라는 Member 변수에 값을 가져와서 그 값을 암호화 하고, 그것을 다시 setter를 통해 저장해 두는 것이에요.

참고로 단순히 이렇게 `PasswordEncoder`를 이용하게 되면 Exception이 뜨게 되는데, 이는 `PasswordEncoder`가 하는 역할은 비밀번호를 암호화하는데, 이를 구현하는 구현체들이 하는 역할이 바로 이 암호화를 어떤 방식으로 할 것인지 암호화 알고리즘에 대한 정의가 있는 것이에요.

이 때문에 `PasswordEncoder`의 구현체를 대입해주고, 이를 Spring Bean에 등록하는 과정이 있어야 하는데,

위에 Code로만 보았을 때는 이 과정이 생략되어 있는 것이에요.

`Spring Security`에 대해 필요한 설정을 하는 Config 객체를 생성해서 위에 설정들을 해 주면 되는 것이랍니다.
Config 객체는 `WebSecurityConfigurerAdapter`를 상속 받아 `configure()`를 구현하면 되는 것이에요.

 

SecurityConfig.java

주니하랑은 `Spring Security` Config 객체를 위와 같이 정의를 한 것이에요.

최초 28번째 줄에 `@Configuration`을 통해 해당 Class가 1개 이상의 Bean을 제공한다고 알려 주는 것이에요.

그런 다음 29번째 줄에 `@EnableWebSecurity`를 통해 `Spring Security`가 작동하도록 작동 Button을 눌러주는 것이에요.

30번째 줄에 `@EnableGlobalMethodSecurity(prePostEnabled = true)`를 사용하여 인가 처리를 하는데, 특정 Method가 호출 된 이 전과 이 후 호출을 요청한 이용자의 권한을 확인하기 위함인 것이에요.

그런 뒤 `@Bean`을 통해 `Srping Framwork`에서 해당 객체를 Bean으로 주입할 수 있게 선언해 준 것이에요.

즉, `@Autowired`를 이용하여 `Spring Framwork`에서 `DI(Dependncy Injection)을 이용할 수 있다는 것이에요. 이렇게 해주면 외부 Class에서 `PasswordEncoder`를 `@Autowird`를 이용하여 쉽게 `DI`할 수 있답니다!

참고로 주니하랑은 `@Autowird` 대신 `@RequiredArgsConstructor`를 이용한 것이에요.

 

 

UserServiceImpl.java - 145 ~ 165

다시 이 곳으로 돌아와서 162번째 줄에 userMappe에 해당 Method를 호출하는데, `CustomUserDetails` 객체를 매개 변수로 전달 해 주는 것이에요.

그런 뒤 Controller에게 반환할 때, HTTP Status Code 200 숫자와 함께, 한글 Message 회원 가입 완료!와 영어 Success Sign up을 전달 해 주는 것이에요.

 

 

 

 

        📦 UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.devcommunity.junyharang.mapper.user.UserMapper">

    <!-- 기 등록된 회원 정보가 있는지 확인 ID -->
    <select id="findByUserID" parameterType="com.devcommunity.junyharang.model.dto.user.DuplicateByIdInfoDTO"
            resultType="com.devcommunity.junyharang.model.dto.user.DuplicateByIdInfoDTO">

        select username
        from user
        where username = #{username}
    </select>

    <!-- 기 등록된 회원 정보가 있는지 확인 별명 -->
    <select id="findByUserNickName" parameterType="com.devcommunity.junyharang.model.dto.user.DuplicateByIdInfoDTO"
            resultType="com.devcommunity.junyharang.model.dto.user.DuplicateByIdInfoDTO">

        select nickname
        from user
        where nickname = #{nickname}
    </select>

    <!-- 기 등록된 회원 정보가 있는지 확인 Email -->
    <select id="findByUserEmail" parameterType="com.devcommunity.junyharang.model.dto.user.DuplicateByIdInfoDTO"
            resultType="com.devcommunity.junyharang.model.dto.user.DuplicateByIdInfoDTO">

        select userEmail
        from user
        where userEmail = #{userEmail}
    </select>

    <!-- 기 등록된 회원 정보가 있는지 확인 핸드폰 번호 -->
    <select id="findByUserPhoneNumber" parameterType="com.devcommunity.junyharang.model.dto.user.DuplicateByIdInfoDTO"
            resultType="com.devcommunity.junyharang.model.dto.user.DuplicateByIdInfoDTO">

        select userPhone
        from user
        where userPhone = #{userPhone}
    </select>


    <!-- 회원 가입을 위해 DB에 회원 정보 저장 -->
    <insert id="signUp" parameterType="com.devcommunity.junyharang.model.vo.member.CustomUserDetails">
        <![CDATA[
        insert into user (
            username,
            password,
            nickname,
            userEmail,
            userPhone,
            enable,
            authority
        ) values (
          #{username},
          #{password},
          #{nickname},
          #{userEmail},
          #{userPhone},
          1,
          "ROLE_USER"
         )
        ]]>
    </insert>
</mapper>

 

► duplicateUserID()

UserMapper.xml - 5 ~ 12

해당 기능은 ID 중복 확인인 것이에요. `Service Layer`에서 해당 Mapper를 호출하여 얻고자 하는 것은 매개 변수로 전달된 이용자가 사용하고자 하는 ID가 존재하는지 여부를 알고 싶은 것이에요.

그렇기 때문에 SQL에 `SELECT`를 통해 username Column에 매개 변수로 전달 된 DTO안에 있을 username이 있는지 찾도록 하고, 이를 다시 `DuplicateByIdInfoDTO`에 담아 반환하게 한 것이에요.

 

 

► signUp()

UserMapper.xml - 42 ~ 63

해당 기능은 본격적인 회원 가입을 위해 DB에 정보를 저장하고 싶은 것이에요.

그렇기 때문에 SQL에 `INSERT`를 통해 회원 가입을 시도하는 이용자가 보낸 값을 각 Column에 입력하여 저장 되게 하고, 해당 계정이 활성화 되어 있다고 표시하기 위해 `enable` Column에 `1` 값을 넣어주고, 해당 이용자의 기본 권한을 `ROLE_USER`로 넣어준 것이에요.

 

 

 

🚀 결과

User Table Value

 

    🔽  ID 중복 확인

        📦 등록되지 않은 ID

 

 

 

        📦 등록된 ID

 

 

    🔽  회원 가입

 

 

짜잔! 😃

정상적으로 처리가 되고 있는 것이에요.

 

 

 

🚀 수정 사항 - Validation

위의 글에서는 유효성 검사 (Validation)이 전혀 진행되고 있지 않은 것이에요.
여기에 대한 내용은 '이 곳'에 준비 해 두었습니다!

 

 

    🔽  회원 ID 중복 확인 - 유효성 검사

DuplicateByUserIDDTO.java

 

 

UserController.java - duplicateUserID()

 

 

        📦 공백 입력에 대한 유효성 검사

 

 

 

        📦 아무 내용도 입력하지 않았을 때 유효성 검사

 

 

 

        📦 Null 입력에 대한 유효성 검사

 

 

 

        📦 특수 문자 입력 시 유효성 검사

 

 

유효성 검사는 모든 중복 확인 및 회원 가입에 추가를 해 둔 것이에요.

자세한 설명은 따로 내용을 정리 해 두었으니 회원 가입에 대한 내용은 여기서 마치도록 하겠습니다!