SpringSecurity的简单使用

已于 2022-08-12 15:02:09 修改
阅读量1.3k 收藏 7
点赞数 2
分类专栏： JAVA框架 文章标签： spring boot spring java
于 2022-08-07 21:53:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37161651/article/details/126217793
版权

目录

概述

SpringSecurity基于Spring框架，提供了一套Web应用安全性的完整解决方案，核心功能包括：用户认证、用户授权；

  • 用户认证：
    验证某个用户是否为系统中的合法主体，用户能否访问该系统。
  • 用户授权：验证某个用户是否有权限执行某个操作。

SpringSecurity的特点：

  • 和Spring无缝整合
  • 全面的权限控制
  • 专门为web开发而设计
    1.旧版本不能脱离Web环境使用；
    2.新版本对整个框架进行了分层抽取，分成了核心模块和Web模块，单独引入核心木块就可以脱离Web环境；
  • 重量级

**Shiro的特点：

  • 轻量级：Shiro主张把复杂问题简单化，针对性能有更高要求的互联网应用有更好表现；
  • 通用性：
    1.好处：不局限于Web环境，可以头里Web环境使用
    2.缺陷：在Web环境下的一些特定的需求需要手动编写代码定制

HelloWorld

依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>per.xgt</groupId>
    <artifactId>SpringSecurity-01-HelloWorld</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringSecurity-01-HelloWorld</name>
    <description>Demo project for Spring Boot</description>
    <packaging>jar</packaging>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.2.1.RELEASE</spring-boot.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>per.xgt.SpringSecurity01HelloWorldApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

写一个Controller

package per.xgt.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 12:04
 * @Description: TODO
 * @Version: 1.0
 */
@RestController
@RequestMapping("/test")
public class TestController {

    @RequestMapping("/hello")
    public String add(){
        return "hello";
    }

}

访问接口

访问接口：http://localhost:8081/login

自动跳转到如下页面
在这里插入图片描述

默认登录用户名和密码：
默认的用户名是user
默认密码在控制台，如下：
在这里插入图片描述

用户认证

设置登录的用户名和密码

通过配置文件
# 应用名称
spring.application.name=SpringSecurity-01-HelloWorld

server.port=8081

spring.security.user.name=admin
spring.security.user.password=123456
通过配置类
package per.xgt.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.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 14:15
 * @Description: TODO
 * @Version: 1.0
 */
@Configuration
public class SecutiryConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 密码加密
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        String password = passwordEncoder.encode("123456");
        // 设置账号 密码 角色
        auth.inMemoryAuthentication().withUser("user").password(password).roles("admin");
    }

    /**
     * 注入 PasswordEncoder Bean
     * @return
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

}
自定义编写实现类
  • 配置类
package per.xgt.config;

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.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:52
 * @Description: TODO
 * @Version: 1.0
 */
@Configuration
public class SecurityMyConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

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

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

}
  • userDetailsService的实现类
package per.xgt.service;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
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.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:56
 * @Description: TODO
 * @Version: 1.0
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        // 权限集合
        List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList("test");
        // 用户认证
        return new User("xgt",new BCryptPasswordEncoder().encode("123456"),authorities);
    }
}

查询数据库的用户认证

  • 依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>per.xgt</groupId>
    <artifactId>SpringSecurity-01-HelloWorld</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringSecurity-01-HelloWorld</name>
    <description>Demo project for Spring Boot</description>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.2.1.RELEASE</spring-boot.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>per.xgt.SpringSecurity01HelloWorldApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>
  • 实体类
package per.xgt.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 16:21
 * @Description: TODO
 * @Version: 1.0
 */
@Data
@TableName("users")
public class User {

    @TableId(value = "id",type = IdType.AUTO)
    private Integer id;
    @TableField(value = "userName")
    private String userName;
    @TableField(value = "password")
    private String password;

}
  • Mapper接口
package per.xgt.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import per.xgt.entity.User;

/**
 * @author Valen
 * @version V1.0
 * @date 2022/8/7 16:27
 */
@Mapper
public interface UserMapper extends BaseMapper<User> {
    
}
  • 在UserDetailsService实现类中用mapper获取账号密码
package per.xgt.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
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.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import per.xgt.mapper.UserMapper;

import java.util.List;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:56
 * @Description: TODO
 * @Version: 1.0
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    /**
     * @param s 用户名
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        // 调用mapper根据用户名查询数据库
        QueryWrapper<per.xgt.entity.User> wrapper = new QueryWrapper<>();
        wrapper.eq("userName",s);
        per.xgt.entity.User user = userMapper.selectOne(wrapper);
        if (null == user){
            // 没用这个用户
            throw new UsernameNotFoundException("用户不存在!");
        }
        // 权限集合
        List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList("test");
        // 得到用户名和密码，返回
        return new User(user.getUserName(),new BCryptPasswordEncoder().encode(user.getPassword()),authorities);
    }
}
  • 配置Mapper扫描
package per.xgt;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan(basePackages = "per.xgt.mapper")
public class SpringSecurity01HelloWorldApplication {

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

}

自定义登录页面

  • 配置
package per.xgt.config;

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.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:52
 * @Description: TODO
 * @Version: 1.0
 */
@Configuration
public class SecurityMyConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

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

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

    /**
     * 配置自定义用户登录页面
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 自定义自己编写的登录页面
        http.formLogin()
                // 登录页面的地址
                .loginPage("/login.html")
                // 登录访问路径
                .loginProcessingUrl("/test/login")
                // 登录成功后访问的路径
                .defaultSuccessUrl("/test/index").permitAll()
                .and().authorizeRequests()
                // 设置不需要认证可以访问的路径
                .antMatchers("/","/test/hello","/test/login").permitAll()
                .anyRequest().authenticated()
                // 关闭CSRF防护
                .and().csrf().disable();
    }
}
  • 相关页面

表单提交的账户名必须为username，密码必须为password；

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
  <form action="/test/login" method="post">
    <input type="text" name="username">
    <br>
    <input type="password" name="password">
    <br>
    <input type="submit" value="登录">
  </form>
</body>
</html>
  • 引入thymeleaf
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
  • controller类
package per.xgt.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 12:04
 * @Description: TODO
 * @Version: 1.0
 */
@Controller
@RequestMapping("/test")
public class TestController {

    @RequestMapping("/hello")
    @ResponseBody
    public String add(){
        return "hello";
    }

    @RequestMapping("/index")
    public String index(){
        return "index";
    }

}

用户授权

基于权限访问控制

单个权限hasAuthority

如果当前的主题具有指定的权限则返回true，否则返回false

修改配置类
package per.xgt.config;

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.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:52
 * @Description: TODO
 * @Version: 1.0
 */
@Configuration
public class SecurityMyConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

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

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

    /**
     * 配置自定义用户登录页面
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 自定义自己编写的登录页面
        http.formLogin()
                // 登录页面的地址
                .loginPage("/login.html")
                // 登录访问路径
                .loginProcessingUrl("/test/login")
                // 登录成功后访问的路径
                .defaultSuccessUrl("/test/index").permitAll()
                .and().authorizeRequests()
                // 设置不需要认证可以访问的路径
                .antMatchers("/","/test/hello","/test/login").permitAll()
                // 当前用户只有具有admin权限才可以访问这个路径
                .antMatchers("/test/index").hasAuthority("admin")
                .anyRequest().authenticated()
                // 关闭CSRF防护
                .and().csrf().disable();
    }
}


package per.xgt.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
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.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import per.xgt.mapper.UserMapper;

import java.util.List;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:56
 * @Description: TODO
 * @Version: 1.0
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    /**
     * @param s 用户名
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        // 调用mapper根据用户名查询数据库
        QueryWrapper<per.xgt.entity.User> wrapper = new QueryWrapper<>();
        wrapper.eq("userName",s);
        per.xgt.entity.User user = userMapper.selectOne(wrapper);
        if (null == user){
            // 没用这个用户
            throw new UsernameNotFoundException("用户不存在!");
        }
        // 权限集合
        List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList("admin");
        // 得到用户名和密码，返回
        return new User(user.getUserName(),new BCryptPasswordEncoder().encode(user.getPassword()),authorities);
    }
}

在这里插入图片描述

多个权限hasAnyAuthority

修改配置类
package per.xgt.config;

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.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:52
 * @Description: TODO
 * @Version: 1.0
 */
@Configuration
public class SecurityMyConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

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

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

    /**
     * 配置自定义用户登录页面
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 自定义自己编写的登录页面
        http.formLogin()
                // 登录页面的地址
                .loginPage("/login.html")
                // 登录访问路径
                .loginProcessingUrl("/test/login")
                // 登录成功后访问的路径
                .defaultSuccessUrl("/test/index").permitAll()
                .and().authorizeRequests()
                // 设置不需要认证可以访问的路径
                .antMatchers("/","/test/hello","/test/login").permitAll()
                // 当前用户只有具有admin权限才可以访问这个路径
//                .antMatchers("/test/index").hasAuthority("admin")
                .antMatchers("/test/index").hasAnyAuthority("admin","manager")
                .anyRequest().authenticated()
                // 关闭CSRF防护
                .and().csrf().disable();
    }
}

在这里插入图片描述

基于角色访问控制

如果用户具备给定角色就返回true：允许访问，否则出现403

基于单个角色访问控制hasRole

修改配置类
package per.xgt.config;

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.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:52
 * @Description: TODO
 * @Version: 1.0
 */
@Configuration
public class SecurityMyConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

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

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

    /**
     * 配置自定义用户登录页面
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 自定义自己编写的登录页面
        http.formLogin()
                // 登录页面的地址
                .loginPage("/login.html")
                // 登录访问路径
                .loginProcessingUrl("/test/login")
                // 登录成功后访问的路径
                .defaultSuccessUrl("/test/index").permitAll()
                .and().authorizeRequests()
                // 设置不需要认证可以访问的路径
                .antMatchers("/","/test/hello","/test/login").permitAll()
                // 当前用户只有具有admin权限才可以访问这个路径
//                .antMatchers("/test/index").hasAuthority("admin")
//                .antMatchers("/test/index").hasAnyAuthority("admin","manager")
                // 当前角色只有是admin角色才可以访问
                .antMatchers("/test/index").hasRole("admin")
                .anyRequest().authenticated()
                // 关闭CSRF防护
                .and().csrf().disable();
    }
}


package per.xgt.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
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.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import per.xgt.mapper.UserMapper;

import java.util.List;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:56
 * @Description: TODO
 * @Version: 1.0
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    /**
     * @param s 用户名
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        // 调用mapper根据用户名查询数据库
        QueryWrapper<per.xgt.entity.User> wrapper = new QueryWrapper<>();
        wrapper.eq("userName",s);
        per.xgt.entity.User user = userMapper.selectOne(wrapper);
        if (null == user){
            // 没用这个用户
            throw new UsernameNotFoundException("用户不存在!");
        }
        // 权限集合
        List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList("manager,ROLE_admin");
        // 得到用户名和密码，返回
        return new User(user.getUserName(),new BCryptPasswordEncoder().encode(user.getPassword()),authorities);
    }
}

在验证是否具有当前角色的时候，String会自动在前面拼接一个"ROLE_"，所以存储用户角色的时候可以加上前缀
在这里插入图片描述

基于多个角色访问控制hasAnyRole

修改配置

表示用户用户具备任何一个条件都可以访问

package per.xgt.config;

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.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:52
 * @Description: TODO
 * @Version: 1.0
 */
@Configuration
public class SecurityMyConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

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

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

    /**
     * 配置自定义用户登录页面
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 自定义自己编写的登录页面
        http.formLogin()
                // 登录页面的地址
                .loginPage("/login.html")
                // 登录访问路径
                .loginProcessingUrl("/test/login")
                // 登录成功后访问的路径
                .defaultSuccessUrl("/test/index").permitAll()
                .and().authorizeRequests()
                // 设置不需要认证可以访问的路径
                .antMatchers("/","/test/hello","/test/login").permitAll()
                // 当前用户只有具有admin权限才可以访问这个路径
//                .antMatchers("/test/index").hasAuthority("admin")
//                .antMatchers("/test/index").hasAnyAuthority("admin","manager")
                // 当前角色只有是admin角色才可以访问
//                .antMatchers("/test/index").hasRole("admin")
                .antMatchers("/test/index").hasAnyRole("admin,manager")
                .anyRequest().authenticated()
                // 关闭CSRF防护
                .and().csrf().disable();
    }
}

自定义403页面

修改配置类

配置没有权限返回跳转到指定的自定义的页面

package per.xgt.config;

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.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:52
 * @Description: TODO
 * @Version: 1.0
 */
@Configuration
public class SecurityMyConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

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

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

    /**
     * 配置自定义用户登录页面
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 配置没有权限访问跳转到自己自定义的页面
        http.exceptionHandling().accessDeniedPage("/error/unAuth.html");
        // 自定义自己编写的登录页面
        http.formLogin()
                // 登录页面的地址
                .loginPage("/login.html")
                // 登录访问路径
                .loginProcessingUrl("/test/login")
                // 登录成功后访问的路径
                .defaultSuccessUrl("/test/index").permitAll()
                .and().authorizeRequests()
                // 设置不需要认证可以访问的路径
                .antMatchers("/","/test/hello","/test/login").permitAll()
                // 当前用户只有具有admin权限才可以访问这个路径
//                .antMatchers("/test/index").hasAuthority("admin")
//                .antMatchers("/test/index").hasAnyAuthority("admin","manager")
                // 当前角色只有是admin角色才可以访问
//                .antMatchers("/test/index").hasRole("admin")
                .antMatchers("/test/index").hasAnyRole("admin,manager")
                .anyRequest().authenticated()
                // 关闭CSRF防护
                .and().csrf().disable();
    }
}

错误页面必须以 “/” 开始
在这里插入图片描述

注解使用

开启注解功能

将 @EnableGlobalMethodSecurity(securedEnabled = true) 放在启动了或者配置类上

@Secured

在controller的方法上使用注解 @Secured ：用户具有某个角色，可以访问方法

@RequestMapping("/update")
    @ResponseBody
    @Secured({"ROLE_haha","ROLE_hehe"})
    public String update(){
        return "index";
    }
@PreAuthorize

适合进入方法前的权限验证，可以将登录用户的roles/permissions参数传到方法中

需要开启相关功能

@EnableGlobalMethodSecurity(securedEnabled = true,prePostEnabled = true)

在Controller方法上添加注解

@RequestMapping("/update")
    @ResponseBody
    @PreAuthorize("hasAnyRole('admin')")
    public String update(){
        return "index";
    }
@PostAuthorize

在方法执行后再进行权限验证，适合验证带有返回值的权限

需要开启相关功能

@EnableGlobalMethodSecurity(securedEnabled = true,prePostEnabled = true)

在方法上添加注解

@RequestMapping("/update")
    @ResponseBody
    @PostAuthorize("hasAnyAuthority('admins')")
    public String update(){
        System.out.println("update......");
        return "index";
    }

即使没有权限访问，方法也执行了

@PreFilter

传入方法数据进行过滤

@RequestMapping("update")
    @PreAuthorize("hasRole('ROLE_admin')")
    @PreFilter(value = "filterObject.id%2==0")
    @ResponseBody
    public List<User> update(@RequestBody List<User>
                                                   list){
        list.forEach(t-> {
            System.out.println(t.getId()+"\t"+t.getUserName());
        });
        return list;
    }
@PostFilter

方法返回数据进行过滤

@RequestMapping("/update")
    @ResponseBody
    @PostAuthorize("hasAnyAuthority('admin')")
    @PostFilter(value = "filterObject.userName == admin")
    public List<User> update(){

        List list = new ArrayList<User>();
        list.add(new User(1,"xgt","xgt"));
        list.add(new User(2,"admin","admin"));

        return list;
    }

注销

/**
     * 配置自定义用户登录页面
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 退出登录
        http.logout().logoutUrl("/logout").logoutSuccessUrl("/test/hello").permitAll();
        // 配置没有权限访问跳转到自己自定义的页面
        http.exceptionHandling().accessDeniedPage("/error/unAuth.html");
        // 自定义自己编写的登录页面
        http.formLogin()
                // 登录页面的地址
                .loginPage("/login.html")
                // 登录访问路径
                .loginProcessingUrl("/test/login")
                // 登录成功后访问的路径
                .defaultSuccessUrl("/test/index").permitAll()
                .and().authorizeRequests()
                // 设置不需要认证可以访问的路径
                .antMatchers("/","/test/hello","/test/login").permitAll()
                // 当前用户只有具有admin权限才可以访问这个路径
//                .antMatchers("/test/index").hasAuthority("admin")
//                .antMatchers("/test/index").hasAnyAuthority("admin","manager")
                // 当前角色只有是admin角色才可以访问
//                .antMatchers("/test/index").hasRole("admin")
                .antMatchers("/test/index").hasAnyRole("admin,manager")
                .anyRequest().authenticated()
                // 关闭CSRF防护
                .and().csrf().disable();
    }

自动登录

相关表结构


CREATE TABLE `persistent_logins` (
`username` varchar(64) NOT NULL,
`series` varchar(64) NOT NULL,
`token` varchar(64) NOT NULL,
`last_used` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE
CURRENT_TIMESTAMP,
PRIMARY KEY (`series`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

配置类相关内容

注册相关数据库操作对象 注入数据源

/**
     * 配置数据库操作对象
     * @return
     */
    @Bean
    public PersistentTokenRepository persistentTokenRepository(){
        JdbcTokenRepositoryImpl repository = new JdbcTokenRepositoryImpl();
        // 可以自动生成相关表
        //repository.setCreateTableOnStartup(true);
        repository.setDataSource(dataSource);
        return repository;
    }

配置类中配置自动登录

package per.xgt.config;

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.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;
import org.springframework.security.web.authentication.rememberme.PersistentTokenRepository;

import javax.sql.DataSource;

/**
 * @Author: gentao9527
 * @date: 2022/8/7 15:52
 * @Description: TODO
 * @Version: 1.0
 */
@Configuration
public class SecurityMyConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private DataSource dataSource;

    /**
     * 配置数据库操作对象
     * @return
     */
    @Bean
    public PersistentTokenRepository persistentTokenRepository(){
        JdbcTokenRepositoryImpl repository = new JdbcTokenRepositoryImpl();
        // 可以自动生成相关表
        //repository.setCreateTableOnStartup(true);
        repository.setDataSource(dataSource);
        return repository;
    }

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

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

    /**
     * 配置自定义用户登录页面
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 退出登录
        http.logout().logoutUrl("/logout").logoutSuccessUrl("/test/hello").permitAll();
        // 配置没有权限访问跳转到自己自定义的页面
        http.exceptionHandling().accessDeniedPage("/error/unAuth.html");
        // 自定义自己编写的登录页面
        http.formLogin()
                // 登录页面的地址
                .loginPage("/login.html")
                // 登录访问路径
                .loginProcessingUrl("/test/login")
                // 登录成功后访问的路径
                .defaultSuccessUrl("/test/index").permitAll()
                .and().authorizeRequests()
                // 设置不需要认证可以访问的路径
                .antMatchers("/","/test/hello","/test/login").permitAll()
                // 当前用户只有具有admin权限才可以访问这个路径
//                .antMatchers("/test/index").hasAuthority("admin")
//                .antMatchers("/test/index").hasAnyAuthority("admin","manager")
                // 当前角色只有是admin角色才可以访问
//                .antMatchers("/test/index").hasRole("admin")
                .antMatchers("/test/index").hasAnyRole("admin,manager")
                .anyRequest().authenticated()
                .and().rememberMe().tokenRepository(persistentTokenRepository()).tokenValiditySeconds(600).userDetailsService(userDetailsService)
                // 关闭CSRF防护
                .and().csrf().disable();
    }
}

登录页，name必须是 remember-me

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
  <form action="/test/login" method="post">
    <input type="text" name="username">
    <br>
    <input type="password" name="password">
    <br>
    <input type="submit" value="登录">
      <br>
      <input type="checkbox" name="remember-me">
  </form>
</body>
</html>

CSRF

配置类中启用csrf防护机制（SpringSecurity4.0开始默认开启）

@Override
    protected void configure(HttpSecurity http) throws Exception {
        // 退出登录
        http.logout().logoutUrl("/logout").logoutSuccessUrl("/test/hello").permitAll();
        // 配置没有权限访问跳转到自己自定义的页面
        http.exceptionHandling().accessDeniedPage("/error/unAuth.html");
        // 自定义自己编写的登录页面
        http.formLogin()
                // 登录页面的地址
                .loginPage("/login.html")
                // 登录访问路径
                .loginProcessingUrl("/test/login")
                // 登录成功后访问的路径
                .defaultSuccessUrl("/test/index").permitAll()
                .and().authorizeRequests()
                // 设置不需要认证可以访问的路径
                .antMatchers("/","/test/hello","/test/login").permitAll()
                // 当前用户只有具有admin权限才可以访问这个路径
//                .antMatchers("/test/index").hasAuthority("admin")
//                .antMatchers("/test/index").hasAnyAuthority("admin","manager")
                // 当前角色只有是admin角色才可以访问
//                .antMatchers("/test/index").hasRole("admin")
                .antMatchers("/test/index").hasAnyRole("admin,manager")
                .anyRequest().authenticated()
                .and().rememberMe().tokenRepository(persistentTokenRepository()).tokenValiditySeconds(600).userDetailsService(userDetailsService)
                // 关闭CSRF防护
                .and().csrf().disable();
    }

在这里插入图片描述

在登录页添加一个隐藏域


<input
type="hidden"th:if="${_csrf}!=null"th:value="${_csrf.token}"name="_csrf />
醉眼望云烟
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Security如何使用URL地址进行权限控制
08-25
Spring Security如何使用URL地址进行权限控制 Spring Security是一个功能强大且广泛应用的Java安全框架，它提供了许多功能，包括身份验证、授权、加密等。其中，权限控制是Spring Security的一个重要组件，它允许...
最简单的springSecurity入门使用教程
as189098的博客
12-28 421
2、写路径 3、总结：当访问这个路径时，只要不是/login路径，那么浏览器会自动跳到这个路径 用户名默认：user密码是一个UUID，在控制台会自动打印：
SpringSecurity的使用
zuochangping的博客
11-01 1768
SpringSecurity的使用,运行原理及源码的查看，还有在不同场景的应用
Spring Security 基础使用教程
最新发布
qq_44286009的博客
05-23 854
实际的项目开发中，我们往往会自定义一个登录的页面，而不会使用spring security提供的默认登录页面进行登录。所以下面将介绍如何自定义这些配置。引入thymeleaf依赖创建templates文件夹，创建登录页面，登录成功页面，登录失败页面和index页面，放入templates中。其中登录页面的代码如下：新建配置类新建一个controller访问http://localhost:8080/index.html进入我们自定义的登录界面。
如何使用SpringSecurity
weixin_41553701的博客
08-17 3554
如何使用Spring Security
Spring Security详细介绍使用
书启鸿蒙知秋枫
03-08 4471
Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。正如你可能知道的关于安全方面的两个核心功能是“
Spring Security的基础使用
m0_48972623的博客
03-10 8231
目录 一. 什么是spring security 二. Spring security 的使用 1.创建springboot项目 2.主启动类 2.配置controller层 3.配置config类 4.配置多用户登录以及注入权限及登录config注入 5.配置config层 6.登录成功处理类及无权限处理类 7.配置工具类 8.启动测试 三. 总结 一. 什么是spring security Spring Security是一个能够为基于Spring的企业应用系统提供声明.
SpringSecurity介绍及基本使用
qq_47075878的博客
05-13 1202
Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。
Spring Security模块
09-03
综上所述，Spring Security 为 Java 开发者提供了一个全面而灵活的安全框架，使得在 Web 应用中实现安全功能变得相对简单，只需进行适当的配置和定制即可。在实际项目中，开发者可以根据需求选择合适的配置方式，...
详解Spring Security 简单配置
08-30
在本篇文章中，我们将详细介绍 Spring Security 的简单配置，以便大家更好地理解和使用 Spring Security。 开发环境 在开始配置 Spring Security 之前，我们需要安装好以下开发环境： 1. Maven：Maven 是一个项目...
spring security 官方文档
10-08
10. **与其他Spring框架的集成**：Spring Security与Spring Boot、Spring MVC、Spring Data等其他Spring组件无缝集成，使得构建安全应用变得更加简单。 在Spring Security的官方文档中，包含了详细的配置指南、API...
详解spring security 配置多个AuthenticationProvider
08-30
在上面的代码中，我们使用 Spring Security 的 Java 配置方式，注册了我们的自定义 AuthenticationProvider 到 Spring Security 中。 最后，我们可以在应用程序中使用我们的自定义 AuthenticationProvider 进行身份...
servlet中文传值乱码_学习JavaWeb这一篇就够了 Servlet （4/8）
weixin_39945523的博客
11-22 340
学习java这一篇就够了，从入门到精通，由浅至深，共8章，此篇为第四章中第2小节。附带安装包下载。配套资料，免费下载链接：https://pan.baidu.com/s/1G1YUANaBvGjzE-c-Z0xUWw 提取码：txnf4.5、Servlet继承体系其实我们不难发现，现有的Servlet它的方法比较多，而且大多需要我们自己来实现，那有没有一种它的实现子类，把大部分方法都是实现了，而我...
SpringSecurity 简单使用
qq_43560701的博客
01-25 5012
SpringSecurity 简单使用 在 Web 开发中安全是不可忽视的问题（软件安全技术！），现在从 SpringSecurity 和 Shiro 两个框架来学习一下安全框架在 Web 应用中的使用。 Spring Security is a powerful and highly customizable authentication and access-control framework. It is the de-facto standard for securing Spring-based
SpringSecurity安全框架通俗详解与使用示例
某位奇思妙想的IT人员
05-28 2925
有关Spring Security的原理介绍和使用详解，结合相关实例进行解释，通俗易懂。
SpringSecurity（一）基本使用
YLXCA的博客
01-13 460
Spring Security核心功能关于安全方面的两个主要区域是认证和授权（或者访问控制），这两点也是Spring Security核心功能用户认证：验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。用户授权：验证谋而用户是否有权限执行某一操作。在一个系统中，不同用户所具有的权限是不同的。本质：就是一堆过滤器链。
Spring Security 入门使用
weixin_53604412的博客
05-16 386
用户身份认证即用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问。常见的用户身份认证表现形式有：用户名密码登录，微信扫码等方式。项目包括学生、学习机构的老师、平台运营人员三类用户，不管哪一类用户在访问项目受保护资源时都需要进行身份认证。比如：发布课程操作，需要学习机构的老师首先登录系统成功，然后再执行发布课程操作。创建订单，需要学生用户首先登录系统，才可以创建订单。
Spring Security 的使用
weixin_42679286的博客
12-01 1155
*** 提供给 security 的用户信息的 service，要复写 loadUserByUsername 方法返回数据库中的用户信息*/@Service@Autoware/*** 加载数据库中的认证的用户的信息：用户名、密码、用户的权限列表* 通过username查询用户的信息，(密码，权限列表等)封装成 UserDetails 返回，交给 security。*/@Overridethrow new UsernameNotFoundException("无效的用户名");
springsecurity简单使用
09-12
Spring Security 是一个功能强大且灵活的框架，用于在 Java 应用程序中实现身份验证和授权。以下是一个简单的示例，演示了如何在 Spring Security 中进行基本配置和使用。 首先，在 pom.xml 文件中添加 Spring Security 的依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> ``` 接下来，创建一个配置类来配置 Spring Security。可以创建一个类，并使用 `@EnableWebSecurity` 注解进行标记： ```java @Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers("/public").permitAll() .anyRequest().authenticated() .and() .formLogin().permitAll() .and() .logout().permitAll(); } @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication() .withUser("admin").password(passwordEncoder().encode("password")).roles("ADMIN") .and() .withUser("user").password(passwordEncoder().encode("password")).roles("USER"); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } } ``` 上述配置类中，我们通过 `configure(HttpSecurity http)` 方法定义了 URL 的访问权限规则，并配置了登录和登出行为。通过 `configure(AuthenticationManagerBuilder auth)` 方法，我们在内存中定义了两个用户（admin 和 user）及其密码和角色。 最后，创建一个简单的控制器类来定义一些访问路径。可以使用 `@RestController` 注解来标记该类，并使用 `@RequestMapping` 注解来定义请求路径： ```java @RestController public class HelloController { @RequestMapping("/public") public String publicEndpoint() { return "Public endpoint"; } @RequestMapping("/private") public String privateEndpoint() { return "Private endpoint"; } } ``` 以上示例中，`/public` 路径是公开访问的，而 `/private` 路径需要进行身份验证才能访问。 这只是一个简单的示例，展示了 Spring Security 的基本用法。你可以根据自己的需求进行更复杂的配置和定制化。希望对你有所帮助！如果有更多问题，请继续提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值