이번 강좌에서는 스프링 부트를 사용하여 백엔드 애플리케이션을 개발하는 방법을 배워보겠습니다. 특히, 스프링 시큐리티를 활용한 로그인/로그아웃 기능과 회원 가입 시스템을 구현하고, 뷰 작성하는 데 필요한 내용들을 다룰 것입니다. 이 과정을 통해 웹 애플리케이션의 기본 구조와 보안적인 측면에 대해 이해할 수 있게 될 것입니다.

1. 스프링 부트 소개

스프링 부트(Spring Boot)는 자바 기반의 프레임워크로, 간단하고 빠르게 스프링 애플리케이션을 개발할 수 있는 도구입니다. 스프링 부트는 전통적인 스프링 개발에서 자주 발생하는 복잡한 설정들을 간소화하여, 개발자가 비즈니스 로직에 집중할 수 있도록 해줍니다.

1.1 스프링 부트의 장점

• 자동 구성: 스프링 부트는 애플리케이션을 실행할 때 필요한 설정을 자동으로 구성합니다.
• 독립 실행형: 스프링 부트 애플리케이션은 내장형 톰캣 서버를 포함하여 독립적으로 실행될 수 있습니다.
• 편리한 의존성 관리: Maven 또는 Gradle을 통해 라이브러리 의존성을 쉽게 관리할 수 있습니다.

2. 스프링 시큐리티로 보안 설정하기

스프링 시큐리티(Spring Security)는 스프링 기반 애플리케이션의 보안을 위한 강력한 인증 및 권한 부여 기능을 제공합니다. 이번 섹션에서는 스프링 시큐리티를 설정하고 로그인, 로그아웃 기능을 구현하는 방법을 배워보겠습니다.

2.1 의존성 추가하기

스프링 시큐리티를 사용하기 위해, build.gradle 파일에 다음과 같은 의존성을 추가합니다:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-security'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    runtimeOnly 'com.h2database:h2'
}

2.2 스프링 시큐리티 설정 클래스 작성하기

스프링 시큐리티 설정을 위해 SecurityConfig 클래스를 작성합니다. 아래 코드는 기본적인 로그인 및 로그아웃 설정을 포함합니다:

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").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }

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

3. 회원 가입 기능 구현하기

회원 가입 기능을 구현하기 위해 사용자 정보를 저장할 엔티티와 DB 연동을 위한 리포지토리를 생성합니다. 그 후, 회원 가입 처리를 위한 컨트롤러를 만들어 보겠습니다.

3.1 User 엔티티 생성하기

User 정보를 저장하기 위한 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;
    private String email;

    // getters and setters
}

3.2 UserRepository 작성하기

JPA를 사용하여 User 정보를 관리하기 위한 리포지토리를 생성합니다:

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

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

3.3 회원 가입 폼 및 컨트롤러 작성하기

회원 가입을 위한 HTML 폼을 작성하고 이를 처리하는 컨트롤러를 만듭니다. RegisterController를 생성하여 회원 가입 요청을 처리합니다:

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.RequestMapping;

@Controller
@RequestMapping("/register")
public class RegisterController {

    @Autowired
    private UserRepository userRepository;

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

    @PostMapping
    public String registerUser(User user) {
        user.setPassword(new BCryptPasswordEncoder().encode(user.getPassword()));
        userRepository.save(user);
        return "redirect:/login";
    }
}

3.4 회원 가입 HTML 폼 작성하기

회원 가입을 위한 폼을 작성합니다:

    


    
회원가입
    

        사용자 이름:
        
        

        비밀번호:
        
        

        이메일:
        
        

        가입하기
    

4. 로그인/로그아웃 기능 구현하기

로그인 및 로그아웃 기능을 구현하여 사용자가 안전하게 시스템에 접근할 수 있도록 합니다.

4.1 로그인 HTML 폼 작성하기

로그인 폼을 작성합니다:

    


    
로그인
    

        사용자 이름:
        
        

        비밀번호:
        
        

        로그인
    

4.2 로그아웃 처리하기

로그아웃 기능은 스프링 시큐리티에서 기본적으로 제공되는 기능으로, 로그아웃 URL을 지정하고 이를 통해 로그아웃 처리가 됩니다. 기본적으로 /logout 경로를 사용합니다.

5. 뷰 작성하기

이제 회원 가입 및 로그인 기능을 구현했으니, 사용자에게 보여질 뷰를 작성합니다. 스프링 부트를 사용할 때는 주로 Thymeleaf라는 템플릿 엔진을 사용합니다.

5.1 Thymeleaf 설정하기

Thymeleaf를 사용하려면 build.gradle 파일에 다음 의존성을 추가합니다:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
}

5.2 기본 홈 페이지 만들기

홈 페이지를 표시하기 위한 컨트롤러와 뷰를 작성합니다. 아래는 홈 페이지를 나타내는 HTML 코드입니다:

    


    
홈 페이지
    

        안녕하세요, 사용자님!
        로그아웃
    
    

        로그인
        

        회원가입
    

6. 마무리

이렇게 하여 스프링 부트를 사용하여 간단한 회원 가입 및 로그인/로그아웃 기능을 가진 웹 애플리케이션을 구축했습니다. 프로젝트를 통해 스프링 부트의 기본적인 사용법과 스프링 시큐리티를 활용한 보안 기능 구현에 대해 이해할 수 있습니다.

6.1 다음 단계

이제 더 복잡한 기능을 추가해 보거나, RESTful API를 개발하여 프론트엔드와 통신하는 방식으로 확장해 볼 수 있습니다. 모바일 애플리케이션이나 다른 클라이언트와의 통합을 고려해보는 것도 좋습니다. 필요하다면 OAuth2와 같은 외부 인증 서비스를 연동하는 것도 좋은 방향입니다.

6.2 추가 자료

더 많은 정보를 원하신다면, 공식 스프링 부트 문서와 스프링 시큐리티 문서를 참조하시기 바랍니다:

• Spring Boot 프로젝트
• Spring Security 프로젝트

안녕하세요! 이번 강좌에서는 스프링 부트를 사용하여 기본적인 백엔드 애플리케이션을 개발하는 방법을 알아보겠습니다. 특히, 스프링 시큐리티를 활용하여 로그인 및 로그아웃 기능, 회원 가입 기능을 구현하고, 뷰 컨트롤러를 통해 사용자 경험을 향상시키는 방법에 대해 심도 있게 다뤄보겠습니다.

1. 스프링 부트 및 시큐리티 소개

스프링 부트는 스프링 프레임워크를 기반으로 한 애플리케이션 개발 도구로, 복잡한 설정 없이 빠르게 애플리케이션을 구축할 수 있도록 도와줍니다. 스프링 시큐리티는 애플리케이션의 보안을 관리하는 강력한 도구로, 인증 및 인가를 손쉽게 처리할 수 있습니다.

1.1. 필요 사항

• JDK 8 이상
• IDE (IntelliJ IDEA, Eclipse 등)
• Maven 또는 Gradle

1.2. 프로젝트 설정

스프링 부트 프로젝트를 생성하기 위해 스프링 이니셔터를 사용합니다. 아래와 같은 의존성을 추가해주세요:

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
    

2. 회원 가입 기능 구현하기

회원 가입을 위해 다음 단계를 따라 진행합니다:

2.1. 엔티티 생성

사용자 정보를 담기 위한 User 엔티티를 생성합니다.

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

        private String username;
        private String password;
        private String email;

        // Getters and Setters
    }
    

2.2. 레포지토리 인터페이스 생성

JPA를 이용하여 데이터베이스와 상호작용할 UserRepository를 생성합니다.

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

2.3. 서비스 클래스 작성

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

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

        public User registerNewUser(User user) {
            // 추가적인 비즈니스 로직 (예: 비밀번호 암호화 등)
            return userRepository.save(user);
        }
    }
    

2.4. 컨트롤러 생성

회원 가입을 위한 REST API를 제공하는 UserController를 작성합니다.

    @RestController
    @RequestMapping("/api/users")
    public class UserController {
        @Autowired
        private UserService userService;

        @PostMapping("/register")
        public ResponseEntity<User> registerUser(@RequestBody User user) {
            User newUser = userService.registerNewUser(user);
            return ResponseEntity.ok(newUser);
        }
    }
    

2.5. 비밀번호 암호화

비밀번호를 안전하게 저장하기 위해 bcrypt 해시 함수를 사용할 것입니다. UserService에서 비밀번호를 암호화합니다.

    @Autowired
    private PasswordEncoder passwordEncoder;

    public User registerNewUser(User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        return userRepository.save(user);
    }
    

3. 로그인 및 로그아웃 기능 구현하기

이제 회원 가입이 완료되었으므로, 로그인 및 로그아웃 기능을 구현하겠습니다.

3.1. 스프링 시큐리티 설정

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

    @Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        @Autowired
        private UserDetailsService userDetailsService;

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

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

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

3.2. 로그인 페이지 및 로그아웃 기능 구현

로그인 페이지를 생성하고, 로그아웃 기능을 구현합니다. 로그인 페이지는 HTML로 작성합니다.

    <form action="/login" method="post">
        <label>Username:</label>
        <input type="text" name="username" required>
        <label>Password:</label>
        <input type="password" name="password" required>
        <button type="submit">로그인</button>
    </form>
    

4. 뷰 컨트롤러 구현하기

마지막으로 뷰 컨트롤러를 생성하여 데이터를 사용자에게 보여주는 기능을 추가하겠습니다.

4.1. 컨트롤러 생성

스프링 MVC의 뷰 컨트롤러를 활용하여 HTML 페이지를 반환하는 컨트롤러를 만듭니다.

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

        @GetMapping("/login")
        public String loginForm() {
            return "login";
        }
    }
    

4.2. Thymeleaf 템플릿 사용

뷰 레이어에는 Thymeleaf를 사용하여 HTML을 렌더링합니다. resources/templates 폴더에 register.html 파일을 추가합니다.

    <html xmlns:th="http://www.w3.org/1999/xhtml">
    <body>
        <form action="@{/api/users/register}" th:object="${user}" method="post">
            <label>Username:</label>
            <input type="text" th:field="*{username}" required>
            <label>Password:</label>
            <input type="password" th:field="*{password}" required>
            <button type="submit">회원가입</button>
        </form>
    </body>
    

5. 결론

이제 스프링 부트를 사용하여 회원 가입, 로그인 및 로그아웃 기능이 포함된 간단한 백엔드 애플리케이션을 구축하는 방법을 배우셨습니다. 이는 스프링 부트를 사용하는 더 복잡한 애플리케이션을 개발할 수 있는 기초가 됩니다. 다음 단계로는 데이터베이스와의 통합, API 문서화, 프론트엔드와의 연동 등을 고려할 수 있습니다. 추가적인 질문이나 도움이 필요하신 경우, 댓글로 남겨주세요!

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

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를 통해 웹 프론트엔드와의 통신, 클라우드 배포, 테스트 및 배포 자동화 등의 고급 주제에 대해서도 학습해보시기를 권장합니다.

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