스프링 부트 백엔드 개발 강좌, 스프링 시큐리티로 로그인 로그아웃, 회원 가입 구현, 로그인, 회원 가입 실행 테스트하기

스프링 시큐리티로 로그인/로그아웃, 회원 가입 구현

안녕하세요, 오늘은 스프링 부트를 이용한 백엔드 개발 강좌를 진행하겠습니다. 본 강좌에서는 스프링 시큐리티를 활용하여 로그인과 로그아웃 기능, 그리고 회원 가입 기능을 구현하는 방법에 대해 자세히 알아보겠습니다. 스프링 부트는 자바 기반의 웹 애플리케이션을 신속하고 쉽게 개발할 수 있는 프레임워크이며, 이 것을 통해 강력하고 안전한 웹 애플리케이션을 만드는 과정에 대해 다룰 것입니다.

1. 개발 환경 설정

강좌에 앞서, 먼저 개발 환경을 설정해야 합니다. 다음은 필요한 도구와 설정 방법입니다.

  • Java Development Kit (JDK) 11 이상
  • Spring Boot 2.5.x 이상
  • IntelliJ IDEA 또는 Eclipse와 같은 IDE
  • Gradle 또는 Maven (빌드 도구)
  • H2 데이터베이스 (임베디드 데이터베이스)

2. 스프링 부트 프로젝트 생성

스프링 부트 프로젝트를 생성하기 위해 Spring Initializr를 사용합니다. 다음 단계를 따라 프로젝트를 만들어 주세요.

  1. 웹 브라우저에서 Spring Initializr에 접속합니다.
  2. 프로젝트 메타데이터를 입력합니다.
    • Project: Maven Project 또는 Gradle Project
    • Language: Java
    • Spring Boot: 2.x.x로 설정
    • Group: com.example
    • Artifact: demo
    • Name: demo
    • Description: Spring Boot demo project
    • Package name: com.example.demo
    • Packaging: Jar
    • Java: 11
  3. Dependencies에서 다음을 선택합니다.
    • Spring Web
    • Spring Security
    • Spring Data JPA
    • H2 Database
  4. Generate 버튼을 클릭하여 프로젝트 ZIP 파일을 다운로드합니다.

3. 프로젝트 구조

프로젝트를 열면 기본적인 패키지 구조가 생성되어 있습니다. 주요 디렉터리와 파일의 역할을 설명하겠습니다.

  • src/main/java/com/example/demo: 자바 소스 파일이 위치하는 디렉토리입니다.
  • src/main/resources/application.properties: 애플리케이션 설정 파일입니다.
  • src/test/java/com/example/demo: 테스트 파일이 위치하는 디렉토리입니다.

4. 스프링 시큐리티 설정

스프링 시큐리티를 설정하여 로그인과 로그아웃 기능을 구현하겠습니다.

4.1 Dependency 추가

pom.xml 또는 build.gradle 파일에 필요한 의존성을 추가합니다. 만약 Maven을 사용한다면 아래의 의존성을 추가해주세요.

        
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-security</artifactId>
            </dependency>
        
    

4.2 SecurityConfig 클래스 생성

스프링 시큐리티의 설정을 정의하기 위해 SecurityConfig 클래스를 생성합니다.

        
            package com.example.demo.config;

            import org.springframework.context.annotation.Bean;
            import org.springframework.context.annotation.Configuration;
            import org.springframework.security.config.annotation.web.builders.HttpSecurity;
            import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
            import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

            @Configuration
            @EnableWebSecurity
            public class SecurityConfig extends WebSecurityConfigurerAdapter {
                
                @Override
                protected void configure(HttpSecurity http) throws Exception {
                    http
                        .authorizeRequests()
                        .antMatchers("/register", "/h2-console/**").permitAll()
                        .anyRequest().authenticated()
                        .and()
                        .formLogin()
                        .loginPage("/login")
                        .permitAll()
                        .and()
                        .logout()
                        .permitAll();
                }

                @Bean
                public void init() {
                    // H2 Console 사용을 위한 설정
                    java.sql.Connection conn = DriverManager.getConnection("jdbc:h2:mem:testdb", "sa", "");
                    conn.createStatement().execute("SET MODE MySQL");
                }
            }
        
    

5. 회원 가입 기능 구현

이제 기본적인 회원 가입 기능을 구현해 보겠습니다.

5.1 User 엔티티 생성

회원 정보를 저장할 User 엔티티 클래스를 생성합니다.

        
            package com.example.demo.model;

            import javax.persistence.Entity;
            import javax.persistence.GeneratedValue;
            import javax.persistence.GenerationType;
            import javax.persistence.Id;

            @Entity
            public class User {
                @Id
                @GeneratedValue(strategy = GenerationType.IDENTITY)
                private Long id;

                private String username;
                private String password;

                // getters and setters
            }
        
    

5.2 UserRepository 인터페이스 생성

회원 정보를 관리할 UserRepository를 생성합니다.

        
            package com.example.demo.repository;

            import com.example.demo.model.User;
            import org.springframework.data.jpa.repository.JpaRepository;

            public interface UserRepository extends JpaRepository {
                User findByUsername(String username);
            }
        
    

5.3 UserService 클래스 생성

회원 가입 로직을 처리할 UserService 클래스를 생성합니다.

        
            package com.example.demo.service;

            import com.example.demo.model.User;
            import com.example.demo.repository.UserRepository;
            import org.springframework.beans.factory.annotation.Autowired;
            import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
            import org.springframework.stereotype.Service;

            @Service
            public class UserService {
                @Autowired
                private UserRepository userRepository;

                @Autowired
                private BCryptPasswordEncoder passwordEncoder;

                public void register(User user) {
                    user.setPassword(passwordEncoder.encode(user.getPassword()));
                    userRepository.save(user);
                }

                public User findByUsername(String username) {
                    return userRepository.findByUsername(username);
                }
            }
        
    

5.4 RegistrationController 클래스 생성

회원 가입 페이지와 로직을 처리할 RegistrationController 클래스를 생성합니다.

        
            package com.example.demo.controller;

            import com.example.demo.model.User;
            import com.example.demo.service.UserService;
            import org.springframework.beans.factory.annotation.Autowired;
            import org.springframework.stereotype.Controller;
            import org.springframework.ui.Model;
            import org.springframework.web.bind.annotation.GetMapping;
            import org.springframework.web.bind.annotation.PostMapping;
            import org.springframework.web.bind.annotation.ModelAttribute;

            @Controller
            public class RegistrationController {

                @Autowired
                private UserService userService;

                @GetMapping("/register")
                public String showRegistrationForm(Model model) {
                    model.addAttribute("user", new User());
                    return "register";
                }

                @PostMapping("/register")
                public String registerUser(@ModelAttribute User user) {
                    userService.register(user);
                    return "redirect:/login";
                }
            }
        
    

5.5 HTML 뷰 템플릿 생성

회원 가입 HTML 뷰를 생성합니다. templates/register.html 파일을 다음과 같이 작성합니다.

        
            <!DOCTYPE html>
            <html xmlns:th="http://www.thymeleaf.org">
            <head>
                <title>회원 가입</title>
            </head>
            <body>
                <h1>회원 가입</h1>
                <form action="#" th:action="@{/register}" th:object="${user}" method="post">
                    <div>
                        <label for="username">사용자 이름:</label>
                        <input type="text" th:field="*{username}" required/>
                    </div>
                    <div>
                        <label for="password">비밀번호:</label>
                        <input type="password" th:field="*{password}" required/>
                    </div>
                    <div>
                        <button type="submit">가입하기</button>
                    </div>
                </form>
            </body>
            </html>
        
    

6. 로그인 기능 구현

이제 로그인 기능을 구현하겠습니다. 스프링 시큐리티에서는 사용자 인증을 처리해 주므로, 우리는 사용자 정보와 관련된 부분만 구현하면 됩니다.

6.1 SecurityConfig 변경

SecurityConfig에서 사용자 인증 정보를 설정합니다.

        
            import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;

            @Override
            protected void configure(AuthenticationManagerBuilder auth) throws Exception {
                auth.userDetailsService(userDetailsService())
                    .passwordEncoder(passwordEncoder());
            }
        
    

6.2 UserDetailsService 구현

사용자의 인증 정보를 처리할 UserDetailsService를 생성합니다.

        
            package com.example.demo.service;

            import org.springframework.security.core.userdetails.UserDetails;
            import org.springframework.security.core.userdetails.UserDetailsService;
            import org.springframework.security.core.userdetails.UsernameNotFoundException;
            import org.springframework.stereotype.Service;

            @Service
            public class CustomUserDetailsService implements UserDetailsService {
                
                @Autowired
                private UserService userService;

                @Override
                public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
                    User user = userService.findByUsername(username);
                    if (user == null) {
                        throw new UsernameNotFoundException("사용자를 찾을 수 없습니다: " + username);
                    }
                    return org.springframework.security.core.userdetails.User.withUsername(user.getUsername())
                            .password(user.getPassword())
                            .roles("USER")
                            .build();
                }
            }
        
    

7. 로그인 및 로그아웃 페이지

로그인 페이지와 로그아웃 확인 페이지를 구현합니다.

7.1 login.html 템플릿 생성

        
            <!DOCTYPE html>
            <html xmlns:th="http://www.thymeleaf.org">
            <head>
                <title>로그인</title>
            </head>
            <body>
                <h1>로그인</h1>
                <form action="#" th:action="@{/login}" method="post">
                    <div>
                        <label for="username">사용자 이름:</label>
                        <input type="text" name="username" required/>
                    </div>
                    <div>
                        <label for="password">비밀번호:</label>
                        <input type="password" name="password" required/>
                    </div>
                    <div>
                        <button type="submit">로그인</button>
                    </div>
                </form>
            </body>
            </html>
        
    

7.2 logout.html 템플릿 생성

        
            <!DOCTYPE html>
            <html xmlns:th="http://www.thymeleaf.org">
            <head>
                <title>로그아웃</title>
            </head>
            <body>
                <h1>로그아웃 되었습니다.</h1>
                <a href="/login">로그인 페이지로 이동</a>
            </body>
            </html>
        
    

8. 실행 및 테스트

이제 모든 설정과 구현을 마쳤으니, 애플리케이션을 실행하고 테스트해 보겠습니다.

8.1 애플리케이션 실행

애플리케이션을 실행합니다. IDE에서 Run 또는 Terminal을 통해 다음 명령어를 실행합니다.

        
            ./mvnw spring-boot:run
        
    

브라우저에서 http://localhost:8080/register를 입력하여 회원 가입 페이지로 이동합니다.

8.2 회원 가입 테스트

사용자 이름과 비밀번호를 입력하여 회원 가입을 테스트합니다. 가입 후, http://localhost:8080/login으로 이동하여 로그인 테스트를 진행합니다.

8.3 로그인 및 로그아웃 테스트

정상적으로 로그인한 후 로그아웃 버튼을 클릭하여 로그아웃이 잘 되는지 확인합니다.

9. 마무리

이번 강좌에서는 스프링 부트를 사용하여 스프링 시큐리티로 로그인, 로그아웃, 회원 가입 기능을 구현하는 방법을 배웠습니다. 이러한 기본 기능을 통해 여러분은 나만의 웹 애플리케이션을 안전하게 운영할 수 있는 기반을 마련했습니다. 스프링 부트를 활용한 다양한 기능들과 연동하여 더욱 발전된 웹 애플리케이션을 만들어 보세요!

스프링 부트 백엔드 개발 강좌, 스프링 시큐리티로 로그인 로그아웃, 회원 가입 구현, 리포지터리 만들기

안녕하세요! 이번 블로그 포스트에서는 스프링 부트를 이용하여 백엔드 개발을 하는 방법을 배우고, 스프링 시큐리티를 활용하여 로그인 및 로그아웃 기능을 구현하는 방법, 그리고 회원 가입 기능을 추가하는 방법에 대해 자세히 알아보겠습니다. 또한, 데이터베이스와의 상호작용을 위해 리포지터리를 만드는 방법도 함께 다뤄볼 것입니다. 이 강좌는 초보자부터 중급者까지 모두에게 적합한 내용으로 구성되어 있습니다.

1. 스프링 부트란?

스프링 부트(Spring Boot)는 스프링 프레임워크를 기반으로 하여 빠르게 애플리케이션을 개발할 수 있도록 도와주는 프레임워크입니다. 스프링 부트를 사용하면 복잡한 설정을 최소화하고 신속하게 마이크로서비스 또는 독립 실행형 애플리케이션을 제작할 수 있습니다. 스프링 부트의 주요 특징은 다음과 같습니다:

  • 자동 구성(Auto Configuration): 복잡한 XML 설정 없이 코드와 어노테이션을 통해 쉽게 설정할 수 있습니다.
  • 스타터(Starters): 필요한 의존성을 묶어놓은 스타터를 사용하여 손쉬운 의존성 관리가 가능합니다.
  • 배포 용이성: 단독 실행 가능한 JAR 파일로 쉽게 배포할 수 있습니다.

2. 프로젝트 설정하기

스프링 부트 프로젝트는 Spring Initializr를 사용하여 빠르게 생성할 수 있습니다. 필요한 의존성을 선택하고, Maven 프로젝트를 생성하여 IDE에 불러옵니다. 아래는 필수 의존성 리스트입니다:

  • Spring Web
  • Spring Security
  • Spring Data JPA
  • H2 Database

2.1 인텔리J를 이용한 프로젝트 생성

인텔리J를 이용하여 프로젝트를 생성하는 방법을 살펴보겠습니다. 먼저, 인텔리J를 열고 다음 단계를 따릅니다:

  1. File > New > Project 선택
  2. Spring Initializr 선택 후 ‘Next’
  3. Group, Artifact, Name 입력 후 ‘Next’
  4. 필요한 의존성 선택 후 ‘Finish’

3. 스프링 시큐리티 설정

스프링 시큐리티(Spring Security)는 스프링 애플리케이션에 보안 기능을 추가하는 데 사용되는 강력한 프레임워크입니다. 인증(Authentication)과 인가(Authorization) 기능을 쉽게 구현할 수 있도록 지원합니다. 여기서는 기본적인 로그인/로그아웃 기능을 구현해보겠습니다.

3.1 스프링 시큐리티 의존성 추가

Spring Initializr에서 선택한 의존성에 이미 포함되어 있지만, 추가로 필요시 pom.xml 파일에 스프링 시큐리티 의존성을 추가할 수 있습니다:


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

3.2 SecurityConfig 클래스 생성

스프링 시큐리티를 설정하기 위해 `SecurityConfig` 클래스를 생성합니다. 이 클래스는 스프링 시큐리티의 보안 필터 체인을 구성합니다:


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/login", "/register").permitAll() // 로그인, 회원가입 페이지 접근 허용
                .anyRequest().authenticated() // 다른 모든 요청은 인증 필요
            .and()
            .formLogin()
                .loginPage("/login") // 로그인 페이지 설정
                .permitAll() // 모든 사용자 접근 허용
            .and()
            .logout()
                .permitAll(); // 로그아웃 기능 허용
    }
}

4. 회원 가입 구현

회원 가입 기능을 구현하기 위해 User 엔티티와 UserRepository를 생성하겠습니다. 이후 회원 정보를 데이터베이스에 저장하는 서비스를 만들어 보겠습니다.

4.1 User 엔티티 생성


import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    
    // getters and setters
}

4.2 UserRepository 인터페이스 생성


import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;

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

4.3 회원가입 서비스 구현

회원 가입을 위해 UserService 클래스를 생성하여 사용자 정보를 처리합니다:


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    private BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

    public void registerUser(User user) {
        String encodedPassword = passwordEncoder.encode(user.getPassword());
        user.setPassword(encodedPassword); // 비밀번호 암호화
        userRepository.save(user); // 사용자 정보 저장
    }
}

4.4 회원가입 컨트롤러 구현

회원가입 요청을 처리할 컨트롤러를 생성합니다:


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ModelAttribute;

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/register")
    public String showRegistrationForm(Model model) {
        model.addAttribute("user", new User());
        return "register"; // 회원가입 페이지로 이동
    }

    @PostMapping("/register")
    public String registerUser(@ModelAttribute User user) {
        userService.registerUser(user); // 사용자 등록 처리
        return "redirect:/login"; // 로그인 페이지로 리다이렉트
    }
}

5. 뷰 템플릿 구현

스프링 부트에서는 Thymeleaf를 주로 사용하여 HTML 템플릿을 작성합니다. 뷰 템플릿을 생성하여 로그인 및 회원가입 페이지를 만들어 보겠습니다.

5.1 로그인 페이지


<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>로그인 페이지</title>
</head>
<body>
    <h1>로그인</h1>
    <form th:action="@{/login}" method="post">
        <div>
            <label>아이디:</label>
            <input type="text" name="username" required />
        </div>
        <div>
            <label>비밀번호:</label>
            <input type="password" name="password" required />
        </div>
        <button type="submit">로그인</button>
    </form>
    <a th:href="@{/register}">회원가입 하러가기</a>
</body>
</html>

5.2 회원가입 페이지


<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>회원가입 페이지</title>
</head>
<body>
    <h1>회원가입</h1>
    <form th:action="@{/register}" method="post">
        <div>
            <label>아이디:</label>
            <input type="text" name="username" required />
        </div>
        <div>
            <label>비밀번호:</label>
            <input type="password" name="password" required />
        </div>
        <button type="submit">가입하기</button>
    </form>
    <a th:href="@{/login}">로그인 하러가기</a>
</body>
</html>

6. 결론

이번 포스트에서는 스프링 부트를 사용하여 백엔드 애플리케이션을 개발하는 방법과 스프링 시큐리티를 통한 로그인 및 회원가입 기능을 구현하는 방법에 대해 알아보았습니다. 간단한 예제를 통해 스프링 부트의 기본 사용법과 보안 기능을 이해할 수 있었습니다. 실습을 통해 효과적인 학습이 이뤄지길 바랍니다.

향후 프로젝트를 진행하면서 더 복잡한 기능들을 구현하고 심화된 기술을 배워보세요. 계속해서 학습하고 성장해 가는 개발자가 되시길 바랍니다. 감사합니다!

스프링 부트 백엔드 개발 강좌, 스프링 시큐리티로 로그인 로그아웃, 회원 가입 구현, 로그아웃 뷰 추가하기

본 강좌에서는 스프링 부트를 이용한 백엔드 개발을 진행하면서 주로 스프링 시큐리티를 통한 로그인/로그아웃 기능과 회원 가입 기능을 구현하는 방법에 대해 다루겠습니다. 또한, 로그아웃 뷰 추가 방법도 구체적으로 설명할 것입니다. 이 강좌는 기본적인 스프링 부트 프로젝트부터 시작하여, 점진적으로 필요한 기능을 추가해나가는 형태로 진행됩니다.

1. 스프링 부트 프로젝트 설정

스프링 부트는 자바 기반의 웹 애플리케이션을 빠르게 개발할 수 있도록 돕는 프레임워크입니다. 본 강좌에서는 최신 버전의 스프링 부트를 사용하여 프로젝트를 설정할 것입니다. 다음은 스프링 부트 프로젝트를 설정하는 단계입니다.

1. Spring Initializr를 사용하여 기본 프로젝트 생성
   - https://start.spring.io/로 이동합니다.
   - Project: Maven Project
   - Language: Java
   - Spring Boot: 최신 버전 선택
   - Project Metadata 설정:
     - Group: com.example
     - Artifact: demo
   - Dependencies 추가:
     - Spring Web
     - Spring Security
     - Spring Data JPA
     - H2 Database (내장 데이터베이스)
   - Generate 버튼 클릭하여 ZIP 파일 다운로드 후 압축 해제

1.1. IDE에서 프로젝트 열기

다운로드 받은 프로젝트를 IDE에서 열어줍니다. IntelliJ IDEA 혹은 Eclipse와 같은 IDE를 사용할 수 있습니다. 각 IDE에서 Maven을 통해 의존성 라이브러리를 자동으로 다운로드합니다.

2. 도메인 모델 설계

회원 가입과 로그인을 위해 사용자 정보를 저장할 도메인 모델을 설계합니다. User라는 클래스를 만들고, JPA를 활용하여 데이터베이스에 매핑합니다.

package com.example.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    private String email;

    // Getter and Setter
}

2.1. User Repository 생성

사용자 데이터를 조작하기 위해 UserRepository 인터페이스를 생성합니다. JPA의 CrudRepository를 확장하여 기본적인 CRUD 기능을 사용할 수 있도록 합니다.

package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.repository.CrudRepository;

public interface UserRepository extends CrudRepository {
    User findByUsername(String username);
}

3. 스프링 시큐리티 설정

로그인 및 회원 가입 기능을 구현하기 위해 스프링 시큐리티를 설정합니다. 스프링 시큐리티는 애플리케이션의 보안 성능을 높여주는 강력한 프레임워크입니다.

3.1. Security Configuration 클래스

스프링 시큐리티의 설정을 위한 클래스를 생성합니다. SecurityConfig 클래스를 작성하여 인증 및 인가에 대한 기본적인 설정을 합니다.

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // UserDetailsService와 PasswordEncoder 설정
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/register").permitAll() // 회원 가입 페이지는 모두 허용
                .anyRequest().authenticated() // 나머지 요청은 인증 필요
                .and()
            .formLogin()
                .loginPage("/login") // 커스터마이징된 로그인 페이지
                .permitAll()
                .and()
            .logout()
                .permitAll(); // 로그아웃을 허용
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

4. 회원 가입 기능 구현

회원 가입 기능을 위한 REST Controller와 회원 가입 뷰를 구현합니다. 사용자에게 입력받은 정보를 이용해 User 객체를 생성하고, 패스워드는 안전하게 해시 처리하여 저장해야 합니다.

4.1. User Controller 클래스 생성

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/register")
public class UserController {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private PasswordEncoder passwordEncoder;

    @GetMapping
    public String showRegistrationForm(Model model) {
        model.addAttribute("user", new User());
        return "register";
    }

    @PostMapping
    public String registerUser(User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword())); // 패스워드 해싱
        userRepository.save(user); // 사용자 저장
        return "redirect:/login"; // 회원 가입 후 로그인 페이지로 리디렉션
    }
}

4.2. 회원 가입 뷰

회원 가입을 위한 Thymeleaf 뷰를 생성합니다. 이는 HTML 파일로 존재하며, 사용자가 정보를 입력하고 제출할 수 있는 폼을 제공합니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>회원 가입</title>
</head>
<body>
    <h1>회원 가입</h1>
    <form action="/register" method="post">
        <label for="username">사용자 이름</label>
        <input type="text" id="username" name="username" required>
        <label for="password">패스워드</label>
        <input type="password" id="password" name="password" required>
        <label for="email">이메일</label>
        <input type="email" id="email" name="email" required>
        <button type="submit">가입하기</button>
    </form>
</body>
</html>

5. 로그인 기능 구현

로그인 기능을 위해 추가적인 컨트롤러와 뷰를 설정합니다. 사용자가 로그인할 때 입력한 정보를 바탕으로 인증을 진행합니다.

5.1. 로그인 페이지 설정

로그인 페이지를 위한 HTML 파일을 생성합니다. 사용자 이름과 패스워드를 입력받는 필드가 포함되어야 합니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>로그인</title>
</head>
<body>
    <h1>로그인</h1>
    <form action="/login" method="post">
        <label for="username">사용자 이름</label>
        <input type="text" id="username" name="username" required>
        <label for="password">패스워드</label>
        <input type="password" id="password" name="password" required>
        <button type="submit">로그인</button>
    </form>
    <a href="/register">회원 가입하러 가기</a>
</body>
</html>

6. 로그아웃 구현 및 뷰 추가

로그아웃 기능을 추가합니다. 로그아웃 후에는 메인 화면으로 리디렉션되도록 설정합니다.

6.1. 로그아웃 기능 설정

이미 설정된 HttpSecurity를 통해 로그아웃 기능은 쉽게 구현할 수 있습니다. 사용자가 로그아웃을 요청하면, 인증 세션이 무효화되며 리디렉션됩니다.

6.2. 로그아웃 후 리디렉션 페이지 생성

로그아웃 후 사용자가 볼 수 있는 페이지를 만들어줍니다. 여기서 적절한 메시지를 제공할 수 있습니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>로그아웃</title>
</head>
<body>
    <h1>로그아웃 되었습니다.</h1>
    <p>다시 로그인하려면 아래 버튼을 클릭하세요.</p>
    <a href="/login">로그인 페이지로 이동</a>
</body>
</html>

7. 결론 및 다음 단계

이번 강좌에서는 스프링 부트를 활용하여 백엔드 개발을 진행하며 스프링 시큐리티로 로그인 및 로그아웃 기능, 회원 가입 기능을 구현하였습니다. 이러한 기초적인 기능들을 익히고 나면, 추가적으로 JWT(JSON Web Token) 기반의 인증, OAuth2를 이용한 소셜 로그인, 비밀번호 재설정 기능 등 보다 확장된 기능을 구현하는 것도 가능합니다.

또한, 이 강좌를 바탕으로 RESTful API를 통해 웹 프론트엔드와의 통신, 클라우드 배포, 테스트 및 배포 자동화 등의 고급 주제에 대해서도 학습해보시기를 권장합니다.

여러분의 개발 여정에 도움이 되었길 바라며, 질문이나 더 궁금한 사항이 있으시다면 댓글로 남겨주세요. 감사합니다!

스프링 부트 백엔드 개발 강좌, 스프링 시큐리티로 로그인 로그아웃, 회원 가입 구현, 로그아웃 실행 테스트하기

소개

본 강좌는 스프링 부트를 이용한 백엔드 개발을 다룹니다. 특히, 스프링 시큐리티를 통해 로그인/로그아웃 기능과 회원 가입 시스템을 구현하는 방법을 배워보겠습니다. 강좌를 통해 완전한 사용자 인증 및 권한 부여 시스템을 구축할 수 있습니다. 이 글은 스프링 부트와 시큐리티를 처음 접하는 분들을 위해 준비하였으며, 단계별로 자세히 설명합니다.

기본 환경 설정

스프링 부트 프로젝트를 시작하기 전에 필요한 환경을 설정합니다. JDK와 Maven이 설치되어 있어야 하며, IntelliJ IDEA 또는 Eclipse와 같은 IDE를 사용하는 것이 좋습니다.

  • JDK 8 이상 설치
  • Maven 또는 Gradle 설치
  • IDE(예: IntelliJ IDEA, Eclipse) 설치

스프링 부트 프로젝트 생성

스프링 부트 프로젝트는 Spring Initializr를 이용하여 생성할 수 있습니다. 다음 옵션을 선택하여 프로젝트를 생성합니다:

  • Project: Maven Project
  • Language: Java
  • Spring Boot: 2.5.x (혹은 최신 버전)
  • Dependencies: Spring Web, Spring Security, Spring Data JPA, H2 Database

프로젝트를 생성한 후, 압축 파일을 다운로드하고 원하는 디렉토리에 풀어줍니다. IDE에서 프로젝트를 열고 필요한 라이브러리들이 포함되었는지 확인합니다.

스프링 시큐리티 설정

스프링 시큐리티를 이용하여 기본적인 인증 기능을 구현합니다. 먼저 SecurityConfig 클래스를 작성하여 사용자 인증 설정을 정의합니다.

        java
        import org.springframework.context.annotation.Bean;
        import org.springframework.context.annotation.Configuration;
        import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
        import org.springframework.security.config.annotation.web.builders.HttpSecurity;
        import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
        import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
        import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
        import org.springframework.security.crypto.password.PasswordEncoder;

        @Configuration
        @EnableWebSecurity
        public class SecurityConfig extends WebSecurityConfigurerAdapter {
            @Override
            protected void configure(AuthenticationManagerBuilder auth) throws Exception {
                auth.inMemoryAuthentication()
                    .withUser("user").password(passwordEncoder().encode("password")).roles("USER")
                    .and()
                    .withUser("admin").password(passwordEncoder().encode("admin")).roles("ADMIN");
            }

            @Override
            protected void configure(HttpSecurity http) throws Exception {
                http
                    .authorizeRequests()
                    .antMatchers("/", "/register", "/login").permitAll()
                    .anyRequest().authenticated()
                    .and()
                    .formLogin()
                    .loginPage("/login")
                    .permitAll()
                    .and()
                    .logout()
                    .permitAll();
            }

            @Bean
            public PasswordEncoder passwordEncoder() {
                return new BCryptPasswordEncoder();
            }
        }
        
    

회원 가입 기능 구현

회원 가입을 위한 REST API를 구현합니다. 사용자 정보를 저장하기 위해 JPA를 사용합니다. User 엔티티 클래스를 작성하여 사용자 정보를 정의합니다.

        java
        import javax.persistence.Entity;
        import javax.persistence.GeneratedValue;
        import javax.persistence.GenerationType;
        import javax.persistence.Id;

        @Entity
        public class User {
            @Id
            @GeneratedValue(strategy = GenerationType.IDENTITY)
            private Long id;
            private String username;
            private String password;
            private String role;

            // getters and setters
        }
        
    

UserRepository 인터페이스 작성

사용자 정보를 저장하기 위한 Repository 인터페이스를 생성합니다.

        java
        import org.springframework.data.jpa.repository.JpaRepository;

        public interface UserRepository extends JpaRepository {
            User findByUsername(String username);
        }
        
    

회원 가입 REST API 구현

회원 가입을 처리하는 컨트롤러 클래스를 작성합니다. 사용자가 입력한 정보를 바탕으로 데이터베이스에 사용자 정보를 저장합니다.

        java
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.web.bind.annotation.*;

        @RestController
        @RequestMapping("/api")
        public class UserController {
            @Autowired
            private UserRepository userRepository;

            @PostMapping("/register")
            public String register(@RequestBody User user) {
                user.setPassword(new BCryptPasswordEncoder().encode(user.getPassword()));
                userRepository.save(user);
                return "회원 가입 성공!";
            }
        }
        
    

로그인 및 로그아웃 기능 테스트

이제 우리는 로그인 및 로그아웃 기능을 테스트할 준비가 되었습니다. Postman 또는 cURL과 같은 도구를 이용하여 REST API를 테스트할 수 있습니다.

회원 가입 테스트

회원 가입 API를 테스트하기 위해 다음과 같은 POST 요청을 보내세요:

        bash
        curl -X POST http://localhost:8080/api/register -H "Content-Type: application/json" -d '{"username":"testuser", "password":"testpassword"}'
        
    

응답으로 “회원 가입 성공!”을 받을 것입니다.

로그인 테스트

로그인 테스트는 다음과 같은 POST 요청으로 진행합니다.

        bash
        curl -X POST -d "username=testuser&password=testpassword" http://localhost:8080/login
        
    

요청이 성공하면, 응답으로 로그인 성공 메시지를 받을 수 있습니다.

로그아웃 테스트

로그아웃 테스트는 다음과 같은 GET 요청으로 진행합니다.

        bash
        curl -X GET http://localhost:8080/logout
        
    

요청이 성공하면, 응답으로 로그아웃 성공 메시지를 받을 수 있습니다.

결론

이번 강좌에서는 스프링 부트를 이용하여 백엔드 개발을 하고, 스프링 시큐리티를 통해 로그인, 로그아웃 및 회원 가입 기능을 구현해 보았습니다. 이를 통해 보안이 강화된 웹 어플리케이션을 만드는 데 필요한 기초를 익힐 수 있었습니다. 계속해서 스프링 부트와 시큐리티를 활용하여 더욱 복잡한 기능을 구현해 보기를 권장합니다.

추가 자료

스프링 부트 백엔드 개발 강좌, 스프링 시큐리티로 로그인 로그아웃, 회원 가입 구현, 로그아웃 구현하기

스프링 시큐리티로 로그인/로그아웃, 회원 가입 구현

안녕하세요! 이번 강좌에서는 스프링 부트를 이용한 백엔드 개발에 대해 알아보겠습니다. 본 강좌의 주요 목표는 스프링 시큐리티를 사용하여 login/logout 및 회원 가입 기능을 구현하는 것입니다. 전체 과정은 다음과 같은 단계로 진행됩니다.

  • 스프링 부트 프로젝트 설정
  • 스프링 시큐리티 설정
  • 회원가입 기능 구현
  • 로그인 및 로그아웃 기능 구현

1. 스프링 부트 프로젝트 설정

먼저, 스프링 부트 프로젝트를 설정하겠습니다. [Spring Initializr](https://start.spring.io/)를 사용하여 프로젝트를 생성할 수 있습니다. 다음과 같은 설정을 선택해 주세요.

프로젝트 설정

  • Project: Maven Project
  • Language: Java
  • Spring Boot: 2.5.x (최신 안정 버전 선택)
  • Dependencies:
    • Spring Web
    • Spring Security
    • Spring Data JPA
    • H2 Database (개발 및 테스트 용도로 사용할 수 있는 인메모리 데이터베이스)

설정을 완료하면 GENERATE 버튼을 클릭하여 ZIP 파일을 다운로드 받을 수 있습니다. 다운로드한 후 압축을 해제하고 원하는 IDE로 프로젝트를 엽니다.

2. 스프링 시큐리티 설정

스프링 시큐리티를 설정하기 위해, SecurityConfig.java 클래스를 생성합니다. 이 클래스에서는 사용자의 인증 및 권한 부여를 위해 필요한 설정을 정의합니다.

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user")
            .password(passwordEncoder().encode("password"))
            .roles("USER");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/register").permitAll()
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

위 코드는 인메모리 사용자 저장소를 포함하여 사용자 인증 및 권한 부여를 설정하는 방법을 보여줍니다. BCryptPasswordEncoder를 사용하여 비밀번호를 암호화합니다.

3. 회원 가입 기능 구현

회원 가입 기능을 구현하기 위해, 사용자의 정보를 저장할 User 엔티티와 사용자 정보를 저장할 UserRepository 인터페이스를 작성합니다.

package com.example.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;

    // getters and setters
}
package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository {
    User findByUsername(String username);
}

다음으로, 회원가입을 처리할 서비스와 컨트롤러를 작성합니다.

package com.example.demo.service;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    public void register(User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        userRepository.save(user);
    }
}
package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

@Controller
public class AuthController {

    @Autowired
    private UserService userService;

    @GetMapping("/register")
    public String showRegistrationForm(Model model) {
        model.addAttribute("user", new User());
        return "register";
    }

    @PostMapping("/register")
    public String registerUser(User user) {
        userService.register(user);
        return "redirect:/login";
    }
}

이제 회원가입을 위한 HTML 양식을 작성하겠습니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>회원가입</title>
</head>
<body>
    <h1>회원가입</h1>
    <form action="/register" method="post">
        <label for="username">사용자 이름</label>
        <input type="text" id="username" name="username" required><br>

        <label for="password">비밀번호</label>
        <input type="password" id="password" name="password" required><br>

        <input type="submit" value="가입">
    </form>
</body>
</html>

4. 로그인 및 로그아웃 기능 구현

이제 로그인 페이지와 로그아웃 기능을 구현하겠습니다. 로그인 페이지를 위해 다시 한 번 HTML을 작성합니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>로그인</title>
</head>
<body>
    <h1>로그인</h1>
    <form action="/login" method="post">
        <label for="username">사용자 이름</label>
        <input type="text" id="username" name="username" required><br>

        <label for="password">비밀번호</label>
        <input type="password" id="password" name="password" required><br>

        <input type="submit" value="로그인">
    </form>
    <a href="/register">회원가입하기</a>
</body>
</html>

로그아웃 기능은 스프링 시큐리티가 기본적으로 제공하므로 별도의 추가 구현이 필요하지 않습니다. 로그아웃 킬을 호출하면 세션이 종료되고 로그인 페이지로 리다이렉트됩니다.

5. 마무리

이번 강좌를 통해 스프링 부트를 이용한 백엔드 개발의 기초를 다지며 스프링 시큐리티를 활용한 로그인, 로그아웃 및 회원가입 기능을 구현하는 방법을 배웠습니다. 이 과정은 여러분이 웹 애플리케이션에서 사용자 인증을 어떻게 처리하고 관리하는지 이해하는 데 도움이 될 것입니다. 앞으로 더 발전된 기능으로 나아가기 위한 기초를 확보하셨기를 바랍니다. 다음 강좌에서는 REST API 및 JWT 인증에 대해 알아보겠습니다.

감사합니다!