회원가입 코드

어떻게 로그인을 처리하냐에 따라 코드가 살짝 달라진다. (회원가입은 아님)

로그인 코드 관련해서는 아래 링크를 참고한다.

2022.06.18 - [Project] - 로그인 코드

2022.06.19 - [WIL] - 40주차 - 로그인 문제 해결

 

 

LoginController

 

@RequiredArgsConstructor
@RestController
public class LoginController {
    private final UserService userService;

    // id 중복 확인
    @PostMapping("/user/signup/username")
    public String checkId(@ModelAttribute SignupRequestDto requestDto) {
        return userService.checkId(requestDto);
    }

    // username 중복 확인
    @PostMapping("/user/signup/nickname")
    public String checkNickname(@ModelAttribute SignupRequestDto requestDto) {
        return userService.checkNickname(requestDto);
    }

    // password 중복 확인
    @PostMapping("/user/signup/password")
    public String checkPassword(@ModelAttribute SignupRequestDto requestDto) {
        return userService.checkPasswordConfirm(requestDto);
    }

    // 회원 가입 페이지
    @PostMapping("/user/signup")
    public String signUp(@ModelAttribute SignupRequestDto requestDto) {
        return userService.signUp(requestDto);
    }


    // 로그인 페이지
    @PostMapping("/user/login/input")
    public String login(@ModelAttribute LoginDto loginDto) {
        return userService.login(loginDto);
    }

}

 

 

 

 

UserService

 

@RequiredArgsConstructor
@Service
public class UserService {
    private final PasswordEncoder passwordEncoder;
    private final UserRepository userRepository;


    public User registerUser(SignupRequestDto requestDto) {
        String username = requestDto.getUsername();
        // 회원 ID 중복 확인
        Optional<User> found = userRepository.findByUsername(username);
        if (found.isPresent()) {
            throw new IllegalArgumentException("중복된 사용자 ID 가 존재합니다.");
        }

        String nickname = requestDto.getNickname();
        // 회원 닉네임 중복 확인
        Optional<User> found2 = userRepository.findByNickname(nickname);
        if (found2.isPresent()) {
            throw new IllegalArgumentException("중복된 닉네임이 존재합니다.");
        }

        // 패스워드 인코딩
        String password = passwordEncoder.encode(requestDto.getPassword());
        String passwordConfirm = passwordEncoder.encode(requestDto.getPasswordConfirm());
        String email = requestDto.getEmail();

        User user = new User(username, nickname, password, passwordConfirm, email);
        userRepository.save(user);
        return user;
    }

    // id 중복 체크
    public String checkId(SignupRequestDto requestDto) {
        String username = requestDto.getUsername();
        System.out.println("username = " + username);
        // 회원 ID 중복 확인
        Optional<User> found = userRepository.findByUsername(username);
        if (found.isPresent()) { // isPresent : 값이 있는지 check
            return "중복된 사용자 ID 가 존재합니다.";
        } else {
            if (username == null || username.isEmpty()) {
                return "아이디를 입력해주세요";
            }
            return "사용가능한 ID 입니다.";
        }
    };


    public String checkNickname(SignupRequestDto requestDto) {
        String nickname = requestDto.getNickname();
        System.out.println("nickname = " + nickname);
        // 회원 닉네임 중복 확인
        Optional<User> found2 = userRepository.findByNickname(nickname);
        if (found2.isPresent()) { // isPresent : 값이 있는지 check
            return "중복된 닉네임이 존재합니다.";
        } else {
            if (nickname == null || nickname.isEmpty()) {
                return "닉네임을 입력해주세요";
            }
            return "사용가능한 닉네임 입니다.";
        }
    };


    // 비밀번호 확인 체크
    public String checkPasswordConfirm(SignupRequestDto requestDto) {
        String password = requestDto.getPassword();
        String passwordConfirm = requestDto.getPasswordConfirm();

        System.out.println("password = " + password);
        System.out.println("passwordConfirm = " + passwordConfirm);

        if (passwordConfirm == null || passwordConfirm.isEmpty()) {
            return "비밀번호를 입력해주세요";
        } else {
            if (!password.equals(passwordConfirm)) {
                return "비밀번호가 다릅니다.";
            } else {
                return "비밀번호가 일치합니다.";
            }
        }
    }

    // 회원가입
    public String signUp(SignupRequestDto requestDto) {
        try {
            registerUser(requestDto);
            return "회원가입이 완료되었습니다.";
        } catch (Exception e) {
            throw new IllegalArgumentException();
        }
    }


    // 로그인 페이지
    public String login(LoginDto loginDto) {
        String username = loginDto.getUsername();
        String password = loginDto.getPassword();

        System.out.println("service");
        // id 찾기
        Optional<User> foundId = userRepository.findByUsername(username);

        //pw 찾기
        Optional<User> foundPw = userRepository.findAllByUsername(username);
        System.out.println("foundPw = " + foundPw);


        if (foundId.isPresent()) {
            String encodedPw = foundPw.get().getPassword();
            System.out.println("encodedPw = " + encodedPw);
            if (passwordEncoder.matches(password, encodedPw) && (!password.equals(encodedPw))) {
                return "환영합니다.";
            } else {
                return "비밀번호를 잘 못 입력하셨습니다.";
            }
        } else {
            return "등록된 사용자가 없습니다.";
        }

    }

}

 

 

 

UserController 

 

@Controller
public class UserController {

    private final UserService userService;

    // userService 생성자 생성
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }


    // 회원 로그인 페이지
    @GetMapping("/user/login")
    public String login(){
        return "login";
    }

    @GetMapping("/user/login/error")
    public Model loginError(@RequestParam(value = "error", required = false) String error,
                            @RequestParam(value = "exception", required = false)
                                    String exception, Model model) {
        model.addAttribute("error", error);
        model.addAttribute("exception", exception);

        return model;
    }



//    @GetMapping("/user/login/error")
//    public String loginError(Model model) {
//        model.addAttribute("loginError", true);
//        return "error"; //login
//    }

    // 회원 가입 페이지
    @GetMapping("/user/signup")
    public String signup() {
        return "login";
    }

    // 회원 가입 요청 처리
//    @PostMapping("/user/signup")
//    public String registerUser(SignupRequestDto requestDto) {
//        userService.registerUser(requestDto);
//        return "redirect:/";
//    }

    @GetMapping("/")
    public String home(Model model, @AuthenticationPrincipal UserDetailsImpl userDetails) {
        model.addAttribute("nickname", userDetails.getUser().getNickname());
        return "index";
    }
}

 

 

 

User

 

@Setter
@Getter // get 함수를 일괄적으로 만들어줍니다.
@NoArgsConstructor // 기본 생성자를 만들어줍니다.
@Entity // DB 테이블 역할을 합니다.
public class User extends Timestamped {

    public User(String username, String nickname, String password, String passwordConfirm, String email) {
        this.username = username;
        this.nickname = nickname;
        this.password = password;
        this.passwordConfirm = passwordConfirm;
        this.email = email;
    }

    // ID가 자동으로 생성 및 증가합니다.
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    private Long id;

    // 반드시 값을 가지도록 합니다.
    @Column(nullable = false)
    private String username;

    @Column(nullable = false)
    private String nickname;

    @Column(nullable = false)
    private String password;

    @Column(nullable = true)
    private String passwordConfirm;

    @Column(nullable = false)
    private String email;

}

 

 

 

SignupRequestDto

 

@Setter
@Getter
public class SignupRequestDto {
    private String username;
    private String nickname;
    private String password;
    private String passwordConfirm;
    private String email;
}

 

 

 

UserRepository

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
    Optional<User> findByNickname(String nickname);
    Optional<User> findAllByUsername(String username);
}

 

* security > UserDetailsImpl, UserDetailsServiceImpl, WebSecurityConfig 파일은 

2022.06.18 - [Project] - 로그인 코드 링크를 통해 확인