devbox
爱喝兽奶帝天荒
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot基于数据库的认证Spring Security_spring boot+spring security实现用户的登录登出配置基于数据库的认证信息和角

作者：爱喝兽奶帝天荒 | 2024-07-03 16:04:09

赞

踩

spring boot+spring security实现用户的登录登出配置基于数据库的认证信息和角色

Spring Boot针对Spring Security提供了自动化配置方案，因此可以使Spring Security非常容易地整合进Spring Boot项目中，这也是在Spring Boot项目中使用Spring Security的优势。

基本用法

创建项目，添加依赖

创建一个Spring Boot Web项目，然后添加spring-boot-starter-security依赖即可，代码如下：

  1.         <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-security</artifactId>
  4.         </dependency>
  5.         <dependency>
  6.             <groupId>org.springframework.boot</groupId>
  7.             <artifactId>spring-boot-starter-web</artifactId>
  8.         </dependency>

只要开发者在项目中添加了spring-boot-starter-security依赖，项目中所有资源都会被保护起来。

添加hello接口

接下来在项目中添加一个简单的/hello接口，内容如下：

  1. package com.shrimpking.controller;
  2.  
  3. import org.springframework.web.bind.annotation.GetMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  5.  
  6. /**
  7.  * Created by IntelliJ IDEA.
  8.  *
  9.  * @Author : Shrimpking
  10.  * @create 2023/6/6 17:22
  11.  */
  12. @RestController
  13. public class HelloController
  14. {
  15.     @GetMapping("/hello")
  16.     public String hello()
  17.     {
  18.         return "hello";
  19.     }
  20. }

配置用户名和密码

如果开发者对默认的用户名和密码不满意，可以在application.properties中配置默认的用户名、密码以及用户角色，配置方式如下：

  1. server.port=8099
  2.  
  3. spring.security.user.name=user
  4. spring.security.user.password=1234
  5. spring.security.user.roles=admin

启动项目测试

接下来启动项目，启动成功后，访问/hello接口会自动跳转到登录页面，这个登录页面是由Spring Security提供的，如图所示。

 

 基于数据库的认证

 在真实项目中，用户的基本信息以及角色等都存储在数据库中，因此需要从数据库中获取数据进行认证。介绍如何使用数据库中的数据进行认证和授权。

设计数据表

首先需要设计一个基本的用户角色表，一共三张表，分别是用户表、角色表以及用户角色关联表。为了方便测试，预置几条测试数据

  1. drop table if EXISTS r_user; 
  2. create table r_user(
  3. 	id int(11) not null auto_increment primary key,
  4. 	userName varchar(32) not null,
  5. 	password varchar(50) not null,
  6. 	enabled tinyint default 1 comment '是否启用，0未启用，1启用',
  7. 	locked tinyint default 0 comment '是否锁定，0锁定，1未锁定'
  8. ) comment '用户表';
  9. insert into r_user(userName,password) values ('root','1234');
  10. insert into r_user(userName,password) values ('admin','1234');
  11. insert into r_user(userName,password) values ('king','1234');
  12.  
  13. drop table if EXISTS r_role;
  14. create table r_role(
  15. 	id int(11) not null auto_increment,
  16. 	name varchar(32) not null comment '角色英文名称',
  17. 	displayName varchar(32) not null comment '角色中文名称',
  18. 	primary key(id)
  19. ) comment '角色表';
  20. insert into r_role(name,displayName) values('ROLE_dba','数据库管理员');
  21. insert into r_role(name,displayName) values('ROLE_admin','系统管理员');
  22. insert into r_role(name,displayName) values('ROLE_user','用户');
  23.  
  24. drop table if EXISTS r_user_role;
  25. create table r_user_role(
  26. 	id int(11) not null auto_increment primary key,
  27. 	userId int not null comment '用户id',
  28. 	roleId int not null comment '角色id'
  29. ) comment '用户角色关联表';
  30. insert into r_user_role(userId,roleId) values (1,1);
  31. insert into r_user_role(userId,roleId) values (1,2);
  32. insert into r_user_role(userId,roleId) values (1,3);
  33. insert into r_user_role(userId,roleId) values (2,2);
  34. insert into r_user_role(userId,roleId) values (2,3);
  35. insert into r_user_role(userId,roleId) values (3,3);
  36.  
  37.

创建项目，选择MyBatis，因此创建Spring Boot Web项目添加如下依赖：

  1.         <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-security</artifactId>
  4.         </dependency>
  5.         <dependency>
  6.             <groupId>org.springframework.boot</groupId>
  7.             <artifactId>spring-boot-starter-web</artifactId>
  8.         </dependency>
  9.         <dependency>
  10.             <groupId>org.mybatis.spring.boot</groupId>
  11.             <artifactId>mybatis-spring-boot-starter</artifactId>
  12.             <version>1.3.2</version>
  13.         </dependency>
  14.         <dependency>
  15.             <groupId>mysql</groupId>
  16.             <artifactId>mysql-connector-java</artifactId>
  17.             <version>5.1.47</version>
  18.         </dependency>
  19.         <dependency>
  20.             <groupId>com.alibaba</groupId>
  21.             <artifactId>druid</artifactId>
  22.             <version>1.1.10</version>
  23.         </dependency>

  

配置数据库

 在application.properties中进行数据库连接配置：

  1. server.port=8099
  2. #数据源
  3. spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  5. spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimeZone=UTC
  6. spring.datasource.username=root
  7. spring.datasource.password=mysql123

创建实体类

分别创建角色表和用户表对应的实体类，代码如下：

Role.java

  1. package com.shrimpking.pojo;
  2.  
  3. /**
  4.  * Created by IntelliJ IDEA.
  5.  *
  6.  * @Author : Shrimpking
  7.  * @create 2023/6/6 18:27
  8.  */
  9. public class Role
  10. {
  11.     private String id;
  12.     private String name;
  13.     private String displayName;
  14.  
  15.     public Role()
  16.     {
  17.     }
  18.  
  19.     public Role(String name, String displayName)
  20.     {
  21.         this.name = name;
  22.         this.displayName = displayName;
  23.     }
  24.  
  25.     public String getId()
  26.     {
  27.         return id;
  28.     }
  29.  
  30.     public void setId(String id)
  31.     {
  32.         this.id = id;
  33.     }
  34.  
  35.     public String getName()
  36.     {
  37.         return name;
  38.     }
  39.  
  40.     public void setName(String name)
  41.     {
  42.         this.name = name;
  43.     }
  44.  
  45.     public String getDisplayName()
  46.     {
  47.         return displayName;
  48.     }
  49.  
  50.     public void setDisplayName(String displayName)
  51.     {
  52.         this.displayName = displayName;
  53.     }
  54.  
  55.     @Override
  56.     public String toString()
  57.     {
  58.         return "Role{" + "id='" + id + '\'' + ", name='" + name + '\'' + ", displayName='" + displayName + '\'' + '}';
  59.     }
  60. }

User.java

  1. package com.shrimpking.pojo;
  2.  
  3. import org.springframework.security.core.GrantedAuthority;
  4. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  5. import org.springframework.security.core.userdetails.UserDetails;
  6.  
  7. import java.util.ArrayList;
  8. import java.util.Collection;
  9. import java.util.List;
  10.  
  11. /**
  12.  * Created by IntelliJ IDEA.
  13.  *
  14.  * @Author : Shrimpking
  15.  * @create 2023/6/6 18:29
  16.  */
  17. public class User implements UserDetails
  18. {
  19.     private int id;
  20.     private String userName;
  21.     private String password;
  22.     private boolean enabled;
  23.     private boolean locked;
  24.     private List<Role> roles;
  25.  
  26.     public User()
  27.     {
  28.     }
  29.  
  30.     public User(String userName, String password)
  31.     {
  32.         this.userName = userName;
  33.         this.password = password;
  34.     }
  35.  
  36.     public int getId()
  37.     {
  38.         return id;
  39.     }
  40.  
  41.     public void setId(int id)
  42.     {
  43.         this.id = id;
  44.     }
  45.  
  46.     public String getUserName()
  47.     {
  48.         return userName;
  49.     }
  50.  
  51.     public void setUserName(String userName)
  52.     {
  53.         this.userName = userName;
  54.     }
  55.  
  56.     /**
  57.      * 获取当前用户对象的密码
  58.      * @return
  59.      */
  60.     @Override
  61.     public String getPassword()
  62.     {
  63.         return password;
  64.     }
  65.  
  66.     public void setPassword(String password)
  67.     {
  68.         this.password = password;
  69.     }
  70.  
  71.     /**
  72.      * 当前账号是否可用
  73.      * @return
  74.      */
  75.     @Override
  76.     public boolean isEnabled()
  77.     {
  78.         return enabled;
  79.     }
  80.  
  81.     public void setEnabled(boolean enabled)
  82.     {
  83.         this.enabled = enabled;
  84.     }
  85.  
  86.     public boolean isLocked()
  87.     {
  88.         return locked;
  89.     }
  90.  
  91.     public void setLocked(boolean locked)
  92.     {
  93.         this.locked = locked;
  94.     }
  95.  
  96.     public List<Role> getRoles()
  97.     {
  98.         return roles;
  99.     }
  100.  
  101.     public void setRoles(List<Role> roles)
  102.     {
  103.         this.roles = roles;
  104.     }
  105.  
  106.     @Override
  107.     public String toString()
  108.     {
  109.         return "User{" + "id=" + id + ", userName='" + userName + '\'' + ", password='" + password + '\'' + ", enabled=" + enabled + ", locked=" + locked + ", roles=" + roles + '}';
  110.     }
  111.  
  112.  
  113.     /**
  114.      * 获取当前用户对象所具有的角色信息
  115.      * @return
  116.      */
  117.     @Override
  118.     public Collection<? extends GrantedAuthority> getAuthorities()
  119.     {
  120.  
  121.         List<SimpleGrantedAuthority> authorities = new ArrayList<>();
  122.         for (Role role : roles)
  123.         {
  124.             authorities.add(new SimpleGrantedAuthority(role.getName()));
  125.         }
  126.         return authorities;
  127.     }
  128.  
  129.     /**
  130.      * 获取当前用户对象的用户名
  131.      * @return
  132.      */
  133.     @Override
  134.     public String getUsername()
  135.     {
  136.         return userName;
  137.     }
  138.  
  139.     /**
  140.      * 当前账号是否未过期
  141.      * @return
  142.      */
  143.     @Override
  144.     public boolean isAccountNonExpired()
  145.     {
  146.         return true;
  147.     }
  148.  
  149.     /**
  150.      * 当前账号是否未锁定
  151.      * @return
  152.      */
  153.     @Override
  154.     public boolean isAccountNonLocked()
  155.     {
  156.         return !locked;
  157.     }
  158.  
  159.     /**
  160.      * 当前账号密码是否未过期
  161.      * @return
  162.      */
  163.     @Override
  164.     public boolean isCredentialsNonExpired()
  165.     {
  166.         return true;
  167.     }
  168. }

代码解释：

• 用户实体类需要实现UserDetails接口，并实现该接口中的7个方法，getAuthorities，getUsername，isAccountNonExpired，isAccountNonLocked，isCredentialsNonExpired，isEnabled，getPassword。

用户根据实际情况设置这7个方法的返回值。因为默认情况下不需要开发者自己进行密码角色等信息的比对，开发者只需要提供相关信息即可，例如getPassword()方法返回的密码和用户输入的登录密码不匹配，会自动抛出BadCredentialsException异常，isAccountNonExpired()方法返回了false，会自动抛出AccountExpiredException异常，因此对开发者而言，只需要按照数据库中的数据在这里返回相应的配置即可。本案例因为数据库中只有enabled和locked字段，故账户未过期和密码未过期两个方法都返回true。

• getAuthorities()方法用来获取当前用户所具有的角色信息，本案例中，用户所具有的角色存储在roles属性中，因此该方法直接遍历roles属性，然后构造SimpleGrantedAuthority集合并返回。

创建UserService

接下来创建UserService，代码如下：

  1. package com.shrimpking.service;
  2.  
  3. import com.shrimpking.mapper.UserMapper;
  4. import com.shrimpking.pojo.User;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.security.core.userdetails.UserDetails;
  7. import org.springframework.security.core.userdetails.UserDetailsService;
  8. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  9. import org.springframework.stereotype.Service;
  10.  
  11. /**
  12.  * Created by IntelliJ IDEA.
  13.  *
  14.  * @Author : Shrimpking
  15.  * @create 2023/6/6 19:01
  16.  */
  17. @Service
  18. public class UserService implements UserDetailsService
  19. {
  20.     @Autowired
  21.     private UserMapper userMapper;
  22.  
  23.     @Override
  24.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException
  25.     {
  26.         User user = userMapper.loadUserByUsername(username);
  27.         if(user == null)
  28.         {
  29.             throw new UsernameNotFoundException("账号不存在");
  30.         }
  31.         user.setRoles(userMapper.getUserRolesByUid(user.getId()));
  32.         return user;
  33.     }
  34. }

代码解释：

定义UserService实现UserDetailsService接口，并实现该接口中的loadUserByUsername方法，该方法的参数就是用户登录时输入的用户名，通过用户名去数据库中查找用户，如果没有查找到用户，就抛出一个账户不存在的异常，如果查找到了用户，就继续查找该用户所具有的角色信息，并将获取到的user对象返回，再由系统提供的DaoAuthenticationProvider类去比对密码是否正确。

• loadUserByUsername方法将在用户登录时自动调用。

还涉及UserMapper和UserMapper.xml，相关源码如下：

UserMapper.java

  1. package com.shrimpking.mapper;
  2.  
  3.  
  4. import com.shrimpking.pojo.Role;
  5. import com.shrimpking.pojo.User;
  6. import org.apache.ibatis.annotations.Mapper;
  7.  
  8. import java.util.List;
  9.  
  10. /**
  11.  * Created by IntelliJ IDEA.
  12.  *
  13.  * @Author : Shrimpking
  14.  * @create 2023/6/6 19:02
  15.  */
  16. @Mapper
  17. public interface UserMapper
  18. {
  19.     User loadUserByUsername(String username);
  20.     List<Role> getUserRolesByUid(int id);
  21. }

UserMapper.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  3.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  4. <mapper namespace="com.shrimpking.mapper.UserMapper">
  5.  
  6.     <select id="loadUserByUsername" resultType="com.shrimpking.pojo.User">
  7.         select id,userName,password,enabled,locked
  8.         from r_user where userName = #{userName}
  9.     </select>
  10.  
  11.     <select id="getUserRolesByUid" resultType="com.shrimpking.pojo.Role">
  12.         select
  13.         r.id,
  14.         r.name,
  15.         r.displayName
  16.         from r_role r,r_user_role ur
  17.         where r.id = ur.roleId
  18.         and ur.userId = #{id}
  19.     </select>
  20.  
  21. </mapper>

配置Spring Security

接下来对Spring Security进行配置，代码如下：

  1. package com.shrimpking.config;
  2.  
  3. import com.shrimpking.service.UserService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
  8. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  9. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  10. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  11. import org.springframework.security.crypto.password.NoOpPasswordEncoder;
  12. import org.springframework.security.crypto.password.PasswordEncoder;
  13.  
  14. /**
  15.  * Created by IntelliJ IDEA.
  16.  *
  17.  * @Author : Shrimpking
  18.  * @create 2023/6/6 19:20
  19.  */
  20. @Configuration
  21. public class WebSecurityConfig extends WebSecurityConfigurerAdapter
  22. {
  23.     @Autowired
  24.     private UserService userService;
  25.  
  26.     @Bean
  27.     PasswordEncoder passwordEncoder()
  28.     {
  29.         //return new BCryptPasswordEncoder(10); //默认10,取值范围4-31之间
  30.  
  31.         //本案例使用NoOpPasswordEncoder，即不对密码进行加密。
  32.         return NoOpPasswordEncoder.getInstance();
  33.     }
  34.  
  35.     @Override
  36.     protected void configure(AuthenticationManagerBuilder auth) throws Exception
  37.     {
  38.         auth.userDetailsService(userService);
  39.     }
  40.  
  41.     @Override
  42.     protected void configure(HttpSecurity http) throws Exception
  43.     {
  44.         http.authorizeRequests()
  45.                 .antMatchers("/admin/**").hasRole("admin")
  46.                 .antMatchers("/db/**").hasRole("dba")
  47.                 .antMatchers("/user/**").hasRole("user")
  48.                 .anyRequest().authenticated()
  49.                 .and()
  50.                 .formLogin()
  51.                 .loginProcessingUrl("/login").permitAll()
  52.                 .and()
  53.                 .csrf().disable();
  54.     }
  55.  
  56. }
  57.  
  58.     /*
  59.     首先配置了三个用户，
  60.     root用户具备ADMIN和DBA的角色，
  61.     admin用户具备ADMIN和USER的角色，
  62.     king用户具备USER的角色。
  63.  
  64.     调用authorizeRequests()方法开启HttpSecurity的配置，
  65.     antMatchers配置分别表示用户访问“/admin/**”模式的URL必须具备ADMIN的角色；
  66.     antMatchers用户访问“/user/**”模式的URL必须具备ADMIN或USER的角色；
  67.     antMatchers用户访问“/db/**”模式的URL必须具备ADMIN和DBA的角色。
  68.     anyRequest用户访问URL都必须认证后访问（登录后访问）。
  69.     formLogin表示开启表单登录，即读者一开始看到的登录页面，
  70.     loginProcessingUrl同时配置了登录接口为“/login”，即可以直接调用“/login”接口，
  71.     发起一个POST请求进行登录，登录参数中用户名必须命名为username，
  72.     密码必须命名为password，
  73.     配置loginProcessingUrl接口主要是方便Ajax或者移动端调用登录接口。
  74.     permitAll，表示和登录相关的接口都不需要认证即可访问。
  75.     表示关闭csrf。
  76.      */

创建Controller进行测试了，

 HelloController.java

  1. package com.shrimpking.controller;
  2.  
  3. import org.springframework.web.bind.annotation.GetMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  5.  
  6. /**
  7.  * Created by IntelliJ IDEA.
  8.  *
  9.  * @Author : Shrimpking
  10.  * @create 2023/6/6 19:29
  11.  */
  12. @RestController
  13. public class HelloController
  14. {
  15.     @GetMapping("/admin/hello")
  16.     public String admin()
  17.     {
  18.         return "hello admin";
  19.     }
  20.  
  21.     @GetMapping("/user/hello")
  22.     public String user()
  23.     {
  24.         return "hello user";
  25.     }
  26.  
  27.     @GetMapping("/db/hello")
  28.     public String dba()
  29.     {
  30.         return "hello dba";
  31.     }
  32.  
  33.     @GetMapping("/hello")
  34.     public String hello()
  35.     {
  36.         return "hello";
  37.     }
  38. }

记得pom.xml中过滤条件的配置

  1.         <resources>
  2.             <resource>
  3.                 <directory>src/main/java</directory>
  4.                 <includes>
  5.                     <include>**/*.xml</include>
  6.                     <include>**/*.properties</include>
  7.                 </includes>
  8.                 <filtering>false</filtering>
  9.             </resource>
  10.             <resource>
  11.                 <directory>src/main/resources</directory>
  12.                 <includes>
  13.                     <include>**/*.xml</include>
  14.                     <include>**/*.properties</include>
  15.                 </includes>
  16.                 <filtering>false</filtering>
  17.             </resource>
  18.         </resources>

 

权限大小依次为 root > admin > king。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/爱喝兽奶帝天荒/article/detail/783735
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号