正文

揭秘Spring Boot登录实战：从零开始实现安全高效的用户认证

/0 浏览量
0510

在开发过程中，用户认证是一个核心功能，它决定了系统的安全性。Spring Boot作为当前最受欢迎的Java后端框架之一，提供了丰富的功能来简化开发流程。本文将带你从零开始，使用Spring Boot实现一个安全高效的用户认证系统。

一、准备工作

在开始之前，我们需要准备以下环境：

  1. Java Development Kit (JDK) 1.8+
  2. Maven 3.5+
  3. Spring Boot 2.x 版本
  4. MySQL 5.7+
  5. IntelliJ IDEA 或其他Java开发工具

二、创建Spring Boot项目

  1. 打开IntelliJ IDEA，创建一个新的Spring Boot项目。
  2. 选择“Spring Initializr”。
  3. 选择“Web”作为项目依赖。
  4. 选择“MySQL Driver”作为数据库依赖。
  5. 点击“Next”。
  6. 输入项目信息，例如项目名称、版本等。
  7. 点击“Finish”完成项目创建。

三、配置数据库连接

  1. 打开application.properties文件。
  2. 添加以下配置信息：
# 数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/your_database?useUnicode=true&characterEncoding=UTF-8&useSSL=false
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.jpa.hibernate.ddl-auto=update
  1. 替换your_database、your_username和your_password为你的数据库信息。

四、创建用户实体

  1. 在项目中创建一个名为User的实体类，用于表示用户信息。
  2. 添加以下代码：
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

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

    @Column(name = "username", nullable = false, unique = true)
    private String username;

    @Column(name = "password", nullable = false)
    private String password;

    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(name = "user_roles",
            joinColumns = @JoinColumn(name = "user_id"),
            inverseJoinColumns = @JoinColumn(name = "role_id"))
    private Set<Role> roles = new HashSet<>();

    // 省略getter和setter方法
}
  1. 在User类中，我们使用了@Entity注解表示这是一个实体类，@Table注解用于指定数据库表名。@Column注解用于指定字段名和属性名，@ManyToMany注解用于指定多对多关系。

五、创建角色实体

  1. 在项目中创建一个名为Role的实体类，用于表示角色信息。
  2. 添加以下代码：
import javax.persistence.*;
import java.util.Set;

@Entity
@Table(name = "roles")
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name", nullable = false, unique = true)
    private String name;

    @ManyToMany(mappedBy = "roles")
    private Set<User> users = new HashSet<>();

    // 省略getter和setter方法
}
  1. 在Role类中，我们使用了@Entity和@Table注解，用于表示实体类和数据库表。@Column注解用于指定字段名和属性名，@ManyToMany注解用于指定多对多关系。

六、创建用户服务

  1. 在项目中创建一个名为UserService的服务类，用于处理用户相关的业务逻辑。
  2. 添加以下代码：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

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

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

    public List<User> findAll() {
        return userRepository.findAll();
    }

    public User save(User user) {
        return userRepository.save(user);
    }

    public void deleteById(Long id) {
        userRepository.deleteById(id);
    }
}
  1. 在UserService类中，我们使用了@Service注解表示这是一个服务类，并注入了UserRepository用于数据库操作。

七、创建用户仓库

  1. 在项目中创建一个名为UserRepository的仓库接口，用于定义用户相关的数据库操作。
  2. 添加以下代码：
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
}
  1. 在UserRepository接口中，我们使用了@Repository注解表示这是一个仓库接口，并继承JpaRepository用于简化数据库操作。

八、创建角色服务

  1. 在项目中创建一个名为RoleService的服务类，用于处理角色相关的业务逻辑。
  2. 添加以下代码：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class RoleService {
    @Autowired
    private RoleRepository roleRepository;

    public Optional<Role> findById(Long id) {
        return roleRepository.findById(id);
    }

    public List<Role> findAll() {
        return roleRepository.findAll();
    }

    public Role save(Role role) {
        return roleRepository.save(role);
    }

    public void deleteById(Long id) {
        roleRepository.deleteById(id);
    }
}
  1. 在RoleService类中，我们使用了@Service注解表示这是一个服务类，并注入了RoleRepository用于数据库操作。

九、创建角色仓库

  1. 在项目中创建一个名为RoleRepository的仓库接口，用于定义角色相关的数据库操作。
  2. 添加以下代码：
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface RoleRepository extends JpaRepository<Role, Long> {
}
  1. 在RoleRepository接口中，我们使用了@Repository注解表示这是一个仓库接口，并继承JpaRepository用于简化数据库操作。

十、创建登录控制器

  1. 在项目中创建一个名为LoginController的控制器类，用于处理登录请求。
  2. 添加以下代码：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LoginController {
    @Autowired
    private AuthenticationManager authenticationManager;

    @PostMapping("/login")
    public String login(@RequestBody LoginRequest loginRequest) {
        Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword())
        );
        SecurityContextHolder.getContext().setAuthentication(authentication);
        return "登录成功";
    }
}
  1. 在LoginController类中，我们使用了@RestController注解表示这是一个控制器类，并注入了AuthenticationManager用于处理认证逻辑。

十一、创建登录请求实体

  1. 在项目中创建一个名为LoginRequest的实体类，用于封装登录请求参数。
  2. 添加以下代码：
import javax.validation.constraints.NotBlank;

public class LoginRequest {
    @NotBlank(message = "用户名不能为空")
    private String username;

    @NotBlank(message = "密码不能为空")
    private String password;

    // 省略getter和setter方法
}
  1. 在LoginRequest类中，我们使用了@NotBlank注解用于校验用户名和密码是否为空。

十二、配置Spring Security

  1. 在项目中创建一个名为SecurityConfig的配置类，用于配置Spring Security。
  2. 添加以下代码：
import org.springframework.context.annotation.Bean;
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;

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

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

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

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/login").permitAll()
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .httpBasic();
    }
}
  1. 在SecurityConfig类中，我们使用了@EnableWebSecurity注解启用Spring Security，并配置了用户认证和授权策略。

十三、创建自定义用户详情服务

  1. 在项目中创建一个名为CustomUserDetailsService的接口，用于自定义用户详情服务。
  2. 添加以下代码：
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Optional;

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

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Optional<User> user = userService.findByUsername(username);
        if (user.isEmpty()) {
            throw new UsernameNotFoundException("用户不存在");
        }
        return User.withUsername(user.get().getUsername())
                .password(user.get().getPassword())
                .roles(user.get().getRoles().stream().map(Role::getName).toArray(String[]::new))
                .build();
    }
}
  1. 在CustomUserDetailsService类中，我们实现了UserDetailsService接口，并注入了UserService用于获取用户信息。

十四、运行项目

  1. 在IntelliJ IDEA中运行项目。
  2. 打开浏览器，访问http://localhost:8080/login。
  3. 输入用户名和密码，点击“登录”按钮。

总结

通过本文的讲解，我们成功地使用Spring Boot实现了一个安全高效的用户认证系统。在实际开发过程中，可以根据需求进一步完善和优化系统，例如添加注册功能、角色权限控制等。希望本文对你有所帮助！

-- 展开阅读全文 --