SpringSecurity数据库进行认证和授权的使用

SpringSecurity是一个专门用于处理应用程序安全认证和授权的框架。它提供了一系列的功能能够让我们轻松地实现基于角色、基于资源的权限控制。为了实现安全认证和授权，SpringSecurity可以使用多种数据源，其中最常用的是数据库。在本篇文章中，我将会详细讲解如何使用数据库进行SpringSecurity的认证和授权，包括以下内容：

导入相关依赖

在使用SpringSecurity进行认证和授权之前，我们需要在pom.xml中添加相关的依赖，这些依赖包括spring-security-core、spring-security-config、spring-security-web、spring-jdbc等。

<dependencies>
    <!-- Spring Security -->
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-core</artifactId>
        <version>${springsecurity.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-config</artifactId>
        <version>${springsecurity.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-web</artifactId>
        <version>${springsecurity.version}</version>
    </dependency>
    <!-- Spring JDBC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
  </dependencies>

其中${springsecurity.version}和${spring.version}分别为SpringSecurity和Spring Framework的版本号。

配置数据库连接

在SpringSecurity中，我们可以使用JDBC来查询数据库中的用户认证和授权信息。为了使用JDBC，我们需要在Spring的配置文件中配置数据源和JdbcTemplate。这里使用MySQL数据库作为例子，展示相应的数据库配置。

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf8"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
</bean>

在这里，我们使用了Apache Commons DBCP来配置数据源，其中包括驱动类名、数据库URL、用户名和密码。同样地，我们创建了一个JdbcTemplate实例并将其注入到Spring容器中。

定义数据库表结构

在SpringSecurity中，认证和授权数据通常存储在数据库中。因此，我们需要在数据库中创建相应的数据表。下面是一些常见的表结构（可以根据自己的需求进行调整）：

用户表users：

DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password` varchar(100) NOT NULL,
  `enabled` tinyint(1) NOT NULL DEFAULT '1',
  PRIMARY KEY (`id`),
  UNIQUE KEY `username` (`username`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

角色表roles：

DROP TABLE IF EXISTS `roles`;
CREATE TABLE `roles` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `name` (`name`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

用户角色关系表user_roles：

DROP TABLE IF EXISTS `user_roles`;
CREATE TABLE `user_roles` (
  `user_id` bigint(20) NOT NULL,
  `role_id` bigint(20) NOT NULL,
  PRIMARY KEY (`user_id`,`role_id`),
  KEY `role_id` (`role_id`),
  CONSTRAINT `user_roles_ibfk_1` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`),
  CONSTRAINT `user_roles_ibfk_2` FOREIGN KEY (`role_id`) REFERENCES `roles` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

在这里，我们定义了三个表：用户表users、角色表roles和用户角色关系表user_roles。其中，用户表使用username和password来认证用户；角色表使用name来定义不同的角色；用户角色关系表用于建立用户和角色之间的关系。

实现用户认证和授权逻辑

在这一步，我们需要实现SpringSecurity中用户认证和授权的逻辑。首先，我们创建一个实现UserDetailsService的UserService，用于从数据库中获取用户的认证信息。

@Service
public class UserService implements UserDetailsService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        String sql = "select * from users where username=?";
        List<User> userList = jdbcTemplate.query(sql, new Object[]{username}, new BeanPropertyRowMapper<>(User.class));
        if (userList.isEmpty()) {
            throw new UsernameNotFoundException("用户不存在");
        }
        User user = userList.get(0);
        List<GrantedAuthority> authorities = new ArrayList<>();
        String roleSql = "select r.* from roles r,user_roles ur where ur.user_id=? and r.id=ur.role_id";
        List<Role> roleList = jdbcTemplate.query(roleSql, new Object[]{user.getId()}, new BeanPropertyRowMapper<>(Role.class));
        roleList.stream().map(role -> new SimpleGrantedAuthority(role.getName())).forEach(authorities::add);
        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), user.getEnabled() == 1, true, true, true, authorities);
    }
}

在这里，我们使用JdbcTemplate来查询用户的认证信息，并同时查询出该用户所拥有的角色信息。最后，我们使用User类和GrantedAuthority类创建一个UserDetails对象，并返回它作为用户的认证信息。

接下来，我们需要实现授权逻辑，即创建一个实现SecurityConfigurerAdapter的SecurityConfig类。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserService userService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated().and().formLogin();
    }

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

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

在这里，我们使用了@EnableWebSecurity注解启用了SpringSecurity的Web安全功能。然后，我们使用configure(HttpSecurity http)方法来配置授权规则，我们定义了admin路径需要ADMIN角色，user路径需要USER或ADMIN角色访问。最后，我们使用configure(AuthenticationManagerBuilder auth)方法来配置用户认证逻辑，即注入UserService实例，并使用BCryptPasswordEncoder加密用户密码。

至此，我们已经成功地使用数据库进行了SpringSecurity的认证和授权操作。下面是一些使用上述配置进行测试的例子：

配置文件

spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=root

spring.datasource.maxIdle=8
spring.datasource.maxActive=8
spring.datasource.minIdle=8
spring.datasource.initialSize=8

spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=Asia/Shanghai

spring.security.user.name=admin
spring.security.user.password=admin123
spring.security.user.role=ADMIN,USER

启动类

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

控制器类

@RestController
public class DemoController {

    @GetMapping("/")
    public String index() {
        return "Hello, Spring Security!";
    }

    @GetMapping("/admin")
    public String admin() {
        return "Hello, Admin!";
    }

    @GetMapping("/user")
    public String user() {
        return "Hello, User!";
    }
}

测试

访问 http://localhost:8080/ ，将会返回“Hello, Spring Security!”；

使用admin登录，访问 http://localhost:8080/admin ，将会返回“Hello, Admin!”；

使用user登录，访问http://localhost:8080/user ，将会返回“Hello, User!”。

上面的例子可以帮助读者理解如何使用SpringSecurity进行基于数据库的认证和授权操作，读者可以根据自己的需求进行相应的调整。最后，需要注意的是，该方案只是此类功能的一种实现方式，不是唯一的正确方式。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：SpringSecurity数据库进行认证和授权的使用 - Python技术站

SpringSecurity数据库进行认证和授权的使用

相关文章