Spring Boot Backend Development Course, Implement Login and Logout with Spring Security, Membership Registration, Creating Member Domain

Hello! In this course, we will learn about backend development using Spring Boot, with a particular focus on implementing login, logout, and signup using Spring Security. This course is aimed at beginners and will cover real application development cases through practical exercises and examples. The course content generally includes the following:

  • Introduction to Spring Boot
  • Overview of Spring Security
  • Creating a member domain
  • Implementing signup functionality
  • Implementing login and logout
  • Using JWT tokens
  • Testing and conclusion

1. Introduction to Spring Boot

Spring Boot is a lightweight application framework based on the Spring Framework that helps develop applications quickly and easily. Using Spring Boot allows for simple configuration without complex XML settings, significantly contributing to productivity.

2. Overview of Spring Security

Spring Security is a framework that provides security features for Spring-based applications. It offers various functions necessary for handling authentication and authorization, helping to enhance the security of web applications.

3. Creating a member domain

To create a member domain, we first need to define the necessary entities. In this course, we will create a Member domain and set the required fields. Below is an example code of the member entity:

 
import javax.persistence.*;

@Entity
@Table(name = "members")
public class Member {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String username;

    @Column(nullable = false)
    private String password;

    @Column(nullable = false)
    private String email;

    // Getters and Setters
}

4. Implementing signup functionality

Now, let’s implement the signup functionality. We will create a REST API to handle signup requests, allowing clients to send member information to the server. Below is the controller code for handling signup:


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/members")
public class MemberController {

    @Autowired
    private MemberService memberService;

    @PostMapping("/register")
    public ResponseEntity register(@RequestBody Member member) {
        memberService.register(member);
        return new ResponseEntity<>("Signup successful", HttpStatus.CREATED);
    }
}

5. Implementing login and logout

We will use Spring Security to implement the login functionality. This will allow us to handle authentication and maintain the logged-in state of users. We will add a configuration class for Spring Security:


import org.springframework.beans.factory.annotation.Autowired;
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;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CustomUserDetailsService customUserDetailsService;

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

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

    // PasswordEncoder bean configuration
}

6. Using JWT tokens

JWT (JSON Web Token) is a token used for exchanging secure information. We will generate JWT during signup and login to authenticate users. We will add code to issue JWT in this process:


import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;

public class JwtUtil {

    private final String SECRET_KEY = "secret";

    public String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10)) // Valid for 10 hours
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }
}

7. Testing and conclusion

Now that all functionalities have been implemented, we will write unit tests to verify that everything works correctly. It is important to check that each feature operates as expected through testing. Below is a simple example of a unit test:


import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class MemberServiceTest {

    @Test
    public void testRegister() {
        Member member = new Member("testuser", "password", "test@example.com");
        memberService.register(member);
        assertNotNull(memberService.findMemberByUsername("testuser"));
    }
}

Conclusion

In this course, we explored backend development methods using Spring Boot and how to implement login, logout, and signup functionalities using Spring Security. I hope this practical experience has been helpful for you. Now, you can implement stronger user management and security features in your application.

Reference Materials