[Spring] 스프링 회원가입, 로그인 기능 구현 with Spring Security

Spring 2023. 9. 14. 22:29

📌 요약
- BCryptPasswordEncoder를 통해 비밀번호 암호화하여 회원가입 진행.
- Spring Security를 이용하여 로그인 구현

간단하게 스프링으로 게시판을 만들면서, 회원가입, 로그인 기능을 구현하였다.

1. 환경 셋팅

spring boot
Project - Gradle
Spring boot - 2.7.15
Jar
java - 11
MariaDB
JSP
JPA
Lombok
Spring Security

2. 회원가입 구현

[로직 요약]

유저로부터, “아이디”, “패스워드”, “닉네임” 입력 받기
유효성 체크 후 회원가입 API 호출
회원가입 로직 실행
아이디 중복 발견 시 “중복 alert 창 표시. 문제 없으면 로그인 페이지로 이동.

1) 유저로부터, “아이디”, “패스워드”, “닉네임” 입력 받기

<form id="joinForm" class="space-y-6" action="/users/join" method="POST">
                <div>
                    <label for="loginId" class="block text-sm font-medium leading-6 text-gray-900">아이디</label>
                    <div class="mt-2">
                        <input id="loginId"
                               name="loginId"
                               type="text"
                               class="block w-full rounded-md border-0 px-2 py-1.5 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-indigo-600 sm:text-sm sm:leading-6"
                        >
                        <form:errors path="loginId"/>
                    </div>
                </div>

                <div>
                    <label for="password" class="block text-sm font-medium leading-6 text-gray-900">패스워드</label>
                    <div class="mt-2">
                        <input id="password" name="password" type="password" required class="block w-full rounded-md border-0 px-2 py-1.5 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-indigo-600 sm:text-sm sm:leading-6">
                    </div>
                </div>

                <div>
                    <label for="username" class="block text-sm font-medium leading-6 text-gray-900">닉네임</label>
                    <div class="mt-2">
                        <input id="username" name="username" type="text" required class="block w-full rounded-md border-0 px-2 py-1.5 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-indigo-600 sm:text-sm sm:leading-6">
                    </div>
                </div>

                <div>
                    <button type="button"
                            id="joinBtn"
                            onclick="join()"
                            class="flex w-full justify-center rounded-md bg-indigo-500 px-3 py-3 text-sm font-semibold leading-6 text-white shadow-sm hover:bg-indigo-400 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-indigo-600">
                        회원가입
                    </button>
                </div>
                
</form>

2) 유효성 체크 후 회원가입 API 호출

const join = async ()=>{
        const loginId = $("#loginId").val();
        const password = $("#password").val();
        const username = $("#username").val();

        // 유효성 검사
        if(!checkValidation(loginId, password, username)){
            return;
        }

        // api 진행
        const requestBody = {
            loginId,
            password,
            username
        }
        const resultStatus = await proceedJoinAPI(requestBody);
        if(resultStatus ==200){
            alert("회원가입 축하드립니다. 로그인 부탁드립니다.")
            location.href="/users/login"
        }else if(resultStatus==409){
            alert("아이디가 중복됩니다. 다른 아이디로 시도해주세요.")
        }

}

const checkValidation = (loginId, password, username)=>{
        const regIdPw = /^[a-zA-Z0-9]{4,12}$/;
        const regName = /^[가-힣a-zA-Z0-9]{2,15}$/;

        if (!regIdPw.test(loginId)) {
            alert("아이디는 숫자, 영문 4글자 이상 12자 이하만 가능합니다.")
            return false;
        }
        if (!regIdPw.test(password)) {
            alert("패스워드 숫자, 영문 4글자 이상 12자 이하만 가능합니다.")
            return false;
        }
        if (!regName.test(username)) {
            alert("닉네임은 숫자, 영문, 한글 2글자 이상 15글자 이하만 가능합니다.")
            return false;
        }
        return true;

}

const proceedJoinAPI = async (requestBody)=>{
        const resp = await fetch("http://localhost:8080/users/join", {
            method:"POST",
            headers: {
                "Content-Type": "application/json",
            },
            body: JSON.stringify(requestBody)
        });
        return resp.status
}

아이디, 패스워드, 닉네임에 대한 유효성 검사 진행
유효성 검사에 통과되지 못하면 alert 표시
유효성 검사에 통과된 후, 회원가입 API 호출
- request body에 loginId, password, username 전달

3) 회원가입 로직 실행

controller

@PostMapping("/users/join")
@ResponseBody
public ResponseEntity<String> join(@RequestBody UserJoinDto userJoinDto){
    log.info(userJoinDto.toString());

    // 중복 검사
    if(userService.existsDuplicatedUser(userJoinDto)){
       log.info("중복 존재");
       return new ResponseEntity<>("fail", HttpStatus.CONFLICT);
    }

	  userService.join(userJoinDto);
    return new ResponseEntity<>("success", HttpStatus.OK);
}

“/users/join” API 호출하여, 위의 컨트롤러 로직 실행
@RequestBody : request body에 온 data를 꺼내어서 사용할 수 있는 애노테이션
userService.existsDuplicatedUser(userJoinDto) : 비즈니스 로직이 담겨있는 서비스 층에서, 유저 로그인 아이디가 중복되었는지 확인.
userService.join(userJoinDto) : 비즈니스 로직이 담겨있는 서비스 층에서, 유저의 회원가입 진행.

service

@Service
@Transactional(readOnly = true)
@RequiredArgsConstructor
public class UserService {
    private final UserRepository userRepository;
    private final BCryptPasswordEncoder encoder;

    @Transactional
    public void join(UserJoinDto userJoinDto){
        String encodedPassword = encoder.encode(userJoinDto.getPassword());
        userRepository.save(userJoinDto.toEntity(encodedPassword));
    }

    public boolean existsDuplicatedUser(UserJoinDto userJoinDto){
        // 아이디 중복 체크
        if(userRepository.existsByLoginId(userJoinDto.getLoginId())){
            return true;
        }
        return false;
    }
}

BCryptPasswordEncoder : 비밀번호 암호화하는데 사용하는 encoder. 아래에서 설명할 Spring Security 프레임워크를 사용해 로그인을 구현하기 위해서는 Security가 제공하는 BcryptPasswordEncoder를 사용해야 한다.
existsDuplicatedUser : repository 에서 existsByLoginId를 이용하여 login 아이디가 존재하는지 체크하는 함수
join : 비밀번호를 암호화하고 entity 객체로 변환 후 repository에 user 저장. (UserJoinDto 를 User 엔티티로 변환하는 로직은 builder()를 통해 진행)

repository

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    ...
    Boolean existsByLoginId(String loginId);
}

Boolean existsByLoginId(String loginId) : User Table에서 파라미터로 넘어온 loginId 값과 일치한 loginId가 있는지 확인하는 함수. (추상화가 잘되어있기 때문에, 직접 구현안해도 됨)

3. 로그인 기능 구현

로그인 기능에 들어가기 앞서 먼저, Spring Security에 대해 알고 가야한다.

📍 [Spring Security]

spring security는 스프링 기반의 애플리케이션에서 보안(인증, 인가)을 담당하는 프레임워크.

filter 흐름에 따라 로직을 처리하는게 특징이다.

인증(Authentication) : 사용자가 ‘인증’하는 과정 → 로그인 과정 처리
인가(Authorization) : 서버가 사용자에 대한 권한 부여

spring security에 대한 특정 셋팅 없이, 시작하면 모든 페이지에 대해 로그인한 사람에 대해 접근 가능하도록 설정되어 있기 때문에 로그인 페이지로 강제적으로 이동하게 된다. 그래서, 페이지별 권한 설정이 필요하다.

먼저 SecurityConfig 파일을 생성하자.

// SecurityConfig

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig  {
    // 비밀번호 암호화 encoder 
		@Bean
    public BCryptPasswordEncoder encoder(){
        return new BCryptPasswordEncoder();
    }

    // 로그인하지 않은 유저들만 접근 가능한 URL
    private static final String[] anonymousUserUrl = {"/users/login", "/users/join"};

    // 로그인한 유저들만 접근 가능한 URL
    private static final String[] authenticatedUserUrl = {"/boards/write","/boards/**/**/edit", "/boards/**/**/delete", "/likes/**", "/users/boards/**"};
    
		@Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity httpSecurity) throws Exception {
        return httpSecurity
                .csrf().disable()
                .cors().and()
				// 페이지별 권한 처리
                .authorizeRequests()
                .antMatchers(anonymousUserUrl).anonymous()
                .antMatchers(authenticatedUserUrl).authenticated()
                .anyRequest().permitAll()
                .and()
                .exceptionHandling()
                .and()
                .build();
    }

}

authorizeRequests() : URL에 따른 페이지에 대한 권한을 부여하기 위해 시작하는 메소드
antMatchers(anonymousUserUrl).anonymous() : anonymousUserUrl 페이지에 대해서는 로그인하지 않은 유저만 접근 가능.
antMatchers(authenticatedUserUrl).authenticated() : authenticatedUserUrl에 대해서는 로그인한 유저만 접근 가능.
anyRequest().permitAll() : 특정 URL을 제외한 나머지 URL에 대해서는 전부 인가해줌.

[로그인 로직 요약]

1) 유저로부터 ‘아이디’와 ‘패스워드’ 입력 받음

2) form action을 통해 loginId, password 전달

3) spring security가 로그인 기능 수행

1) 유저로부터 ‘아이디’, ‘패스워드’ 입력받음.

<form class="space-y-6" method="POST">
                <div>
                    <label for="loginId" class="block text-sm font-medium leading-6 text-gray-900">아이디</label>
                    <div class="mt-2">
                        <input id="loginId" name="loginId" type="text" required class="block w-full rounded-md border-0 px-2 py-1.5 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-indigo-600 sm:text-sm sm:leading-6">
                    </div>
                </div>
                <div>
                    <label for="password" class="block text-sm font-medium leading-6 text-gray-900">패스워드</label>
                    <div class="mt-2">
                        <input id="password" name="password" type="password" required class="block w-full rounded-md border-0 px-2 py-1.5 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-indigo-600 sm:text-sm sm:leading-6">
                    </div>
                </div>

                <div>
                    <button type="submit"
                            class="flex w-full justify-center rounded-md bg-indigo-500 px-3 py-3 text-sm font-semibold leading-6 text-white shadow-sm hover:bg-indigo-400 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-indigo-600">
                        로그인
                    </button>
                </div>
</form>

나는 여기서 아이디에 해당하는 파라미터 키 값을 'loginId', 비밀번호에 해당하는 키 값을 'password'로 지정하였다.

2. form action을 통해 loginId, password 전달

로그인 버튼 클릭시, form action 진행

3. Spring Security가 로그인 진행

Spring Security를 이용하면, form action을 통해 진행하는 로그인 구현 기능을 Spring Security에 위임할 수 있다.

// SecurityConfig

package com.grampus.commnuity.config;


import com.grampus.commnuity.config.auth.LoginSuccessHandler;
import com.grampus.commnuity.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig  {
    @Bean
    public BCryptPasswordEncoder encoder(){
        return new BCryptPasswordEncoder();
    }

    private final UserRepository userRepository;

    // 로그인하지 않은 유저들만 접근 가능한 URL
    private static final String[] anonymousUserUrl = {"/users/login", "/users/join"};

    // 로그인한 유저들만 접근 가능한 URL
    private static final String[] authenticatedUserUrl = {"/boards/write","/boards/**/**/edit", "/boards/**/**/delete", "/likes/**", "/users/boards/**", "/users/edit", "/users/delete"};
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity httpSecurity) throws Exception {
        return httpSecurity
                .csrf().disable()
                .cors().and()
                // url 별 권한 처리
                .authorizeRequests()
                .antMatchers(anonymousUserUrl).anonymous()
                .antMatchers(authenticatedUserUrl).authenticated()
                .antMatchers("/users/admin/**").hasAuthority("ADMIN")
                .anyRequest().permitAll()
                .and()
                .exceptionHandling()
                .and()
                // 폼 로그인
                .formLogin()
                .loginPage("/users/login")      // 로그인 페이지
                .usernameParameter("loginId")   // 로그인에 사용될 id
                .passwordParameter("password")  // 로그인에 사용될 password
                .failureUrl("/users/login?fail")         // 로그인 실패 시 redirect 될 URL => 실패 메세지 출력
                .successHandler(new LoginSuccessHandler(userRepository))
                .and()
                // 로그아웃
                .logout()
                .logoutUrl("/users/logout")     // 로그아웃 URL
                .invalidateHttpSession(true).deleteCookies("JSESSIONID")
                .and()
                .build();
    }

}

formLogin() : form 로그인 처리
loginPage("/users/login") : 로그인할 페이지
usernameParameter("loginId") : 로그인에 사용될 아이디에 대한 파라미터 KEY 값을 기입
passwordParameter("password") : 로그인에 사용될 비밀번호에 대한 파라미터 KEY 값을 기입
failureUrl("/users/login?fail") : 로그인 실패시 redirect 하는 url
successHandler(new LoginSuccessHandler(userRepository)) : 로그인 성공 시, 실행되는 핸들러

즉, 위의 코드는 다음과 같이 해석이 된다.

“/users/login” 페이지에서 form을 통해 액션이 들어오면,
파라미터에서 아이디(loginId)와 패스워드(password)를 가져와 로그인을 실행.
로그인 성공시, LoginSuccessHandler()가 실행되며, 로그인 실패시, “url/login?fail”로 이동이 된다.

추가적으로, 직접 db에서 회원정보를 가져와 로그인이 실행되도록 해야 함으로,

UserDetailsService에서 loadUserByUsername를 오버로드 해준다.

@Service
@RequiredArgsConstructor
public class UserDetailService implements UserDetailsService {
    private final UserRepository userRepository;
    // db에서 회원정보를 가져오는 역할.
    @Override
    public UserDetails loadUserByUsername(String loginId) throws UsernameNotFoundException {
        User user = userRepository.findByLoginId(loginId).orElseThrow(()-> {
            return new UsernameNotFoundException("해당 유저를 찾을 수 없습니다.");
        });
        return new UserDetail(user);
    }
}

public class UserDetail implements UserDetails {
    private User user;

    public UserDetail(User user) {
        this.user = user;
    }

    // 계정이 가지고 있는 권한 목록 return
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        Collection<GrantedAuthority> collection = new ArrayList<>();
        collection.add(() -> {
            return user.getRole().toString();
        });
        return collection;
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getLoginId();
    }

    // 계정이 만료되었는지 (true: 만료 X)
    @Override
    public boolean isAccountNonExpired() { return true; }

    // 계정이 잠겼는지 (true : 잠김 X)
    @Override
    public boolean isAccountNonLocked() { return true; }

    // 비밀번호가 만료되었는지 (ture: 만료 X)
    @Override
    public boolean isCredentialsNonExpired() { return true; }

    // 계정이 활성화(사용 가능)인지 (true: 활성화)
    @Override
    public boolean isEnabled() { return true; }

}

Spring Security를 이용하여 회원가입과 로그인을 구현하였다.

보통 로그인 방식을 구현할 때, 세션, 쿠키, jwt 토큰을 이용하는 방법이 있는데,

세션과 쿠키는 방법이 유사하며, 위의 방법은 세션 방식으로 구현 한 것이다.

jwt 토큰은 주로 서버가 상태를 갖지 않아도 되는 stateless 특징이 있는데, 주로 rest api로 구현할 때 자주 사용하는 방식이다.

여기서는 클라이언트에서 rest api를 호출하는 방식이 아닌, jsp를 이용하여 서버사이드 렌더링 방식을 챼택하였으므로

간단한 구현을 위해 세션 방식으로 진행하였다.

나중에 시간이 된다면 jwt 토큰 방식도 알아보겠다.

'Spring' 카테고리의 다른 글

[6주차] 스프링 스터디 (0)	2021.05.08
[자바 스터디] 4주차 정리 (0)	2021.04.03
자바 스프링 스터디 3주차 (0)	2021.03.25
[스프링 스터디] 2주차 (0)	2021.03.20
Java Spring 스터디 1주차 (0)	2021.03.13

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

인기포스트

ABOUT ME

uni's code uni's code

1. 환경 셋팅

2. 회원가입 구현

[로직 요약]

1) 유저로부터, “아이디”, “패스워드”, “닉네임” 입력 받기

2) 유효성 체크 후 회원가입 API 호출

3) 회원가입 로직 실행

3. 로그인 기능 구현

📍 [Spring Security]

[로그인 로직 요약]

1) 유저로부터 ‘아이디’, ‘패스워드’ 입력받음.

2. form action을 통해 loginId, password 전달

3. Spring Security가 로그인 진행

'Spring' 카테고리의 다른 글

티스토리툴바

개인정보

단축키

내 블로그

블로그 게시글

모든 영역

인기포스트

ABOUT ME

1. 환경 셋팅

2. 회원가입 구현

[로직 요약]

1) 유저로부터, “아이디”, “패스워드”, “닉네임” 입력 받기

2) 유효성 체크 후 회원가입 API 호출

3) 회원가입 로직 실행

3. 로그인 기능 구현

📍 [Spring Security]

[로그인 로직 요약]

1) 유저로부터 ‘아이디’, ‘패스워드’ 입력받음.

2. form action을 통해 loginId, password 전달

3. Spring Security가 로그인 진행

'Spring' 카테고리의 다른 글

관련글 관련글 더보기

티스토리툴바

개인정보

단축키

내 블로그

블로그 게시글

모든 영역