SpringBoot整合SpringSecurity超详细入门教程

SpringSecurity 框架简介

Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。

SpringSecurity的核心功能：

• 用户认证（Authentication）：系统判断用户是否能登录
• 用户授权（Authorization）：系统判断用户是否有权限去做某些事情

SpringSecurity 特点：

• Spring 技术栈的组成部分，与Spring 无缝整合。
• 全面的权限控制，能提供完整可扩展的认证和授权支持保护
• 专门为 Web 开发而设计。
• 重量级，需要引入各种家族组件与依赖

SpringSecurity 快速入门

1.创建一个项目


2.在pom文件中添加相关依赖：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

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

    <groupId>com.ly</groupId>
    <artifactId>SpringSecurityDemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>spring-security-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3.编写相关测试

目录结构：

编写启动器：

@SpringBootApplication
public class SecurityDemoApplication {

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

}

编写控制层：

@RestController
@RequestMapping("/test")
public class TestController {

    @GetMapping("hello")
    public String hello(){
        return "hello security";
    }
}

当什么也没有配置的时候， Spring Security 会为我们生成账号和随机密码。启动这个项目后，我们就可以在控制台看到生成的随机密码：

之后我们可以在浏览器上访问：http://localhost:端口号/test/hello，SpringBoot项目默认访问8080端口，不过我们可以在配置文件中对其进行修改（server.port=端口号），以防止8080端口被占用。

输入用户名和密码后访问成功：

权限管理中的相关概念：

名称	英文名称	概念
主体	principal	使用系统的用户或设备或从其他系统远程登录的用户等等。
认证	authentication	权限管理系统（通过登录操作）确认一个主体的身份，允许主体进入系统。简单说就是“主体”证明自己是谁。
授权	authorization	给用户分配权限：将操作系统的“权力”“授予”“主体”，这样主体就具备了操作系统中特定功能的能力。

SpringSecurity 基本原理

SpringSecurity 本质是一个过滤器链，由许多过滤器组成，重点看一下几个过滤器：

FilterSecurityInterceptor： 方法级的权限过滤器, 基本位于过滤链的最底部。

ExceptionTranslationFilter： 异常过滤器，用来处理在认证授权过程中抛出的异常

UsernamePasswordAuthenticationFilter ： 对/login 的 POST 请求做拦截，校验表单中用户名，密码。

过滤器的加载过程：DelegatingFilterProxy

自定义用户名密码

方式一：通过配置文件(application.yml)设置

spring:
  security:
    user:
      name: ly
      password: 123456

方式二：通过配置类进行配置

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 创建密码解析器
        BCryptPasswordEncoder pe =new BCryptPasswordEncoder();
        // 对密码进行加密
        String password = pe.encode("123456");
        auth.inMemoryAuthentication()
                .passwordEncoder(pe)  //默认没有，需要手动设置BCryptPasswordEncoder
                .withUser("ly")
                .password(password)
                .roles("admin");
     }

}

PasswordEncoder 接口：

• 把参数按照特定的解析规则进行解析：String encode(CharSequence rawPassword);

• 验证从存储中获取的编码密码与编码后提交的原始密码是否匹配：boolean matches(CharSequence rawPassword, String encodedPassword); //raw：需要被解析的密码。encode：存储的密码。

• 判断解析的密码能否再次进行解析且达到更安全的结果：default boolean upgradeEncoding(String encodedPassword) {return false; }

接口实现类BCryptPasswordEncoder 是 Spring Security 官方推荐的密码解析器，是对 bcrypt 强散列方法的具体实现。平时多使用这个解析器。（BCryptPasswordEncoder基于 Hash 算法实现单向加密，可以通过 strength 控制加密强度，默认 10.）

方式三：自定义实现类完成用户登录

UserDetailsService 接口讲解：

而在实际项目中账号和密码都是从数据库中查询出来的。 所以我们要通过自定义逻辑控制认证逻辑。如果需要自定义逻辑时，只需要实现UserDetailsService 接口即可。

返回值 UserDetails ，这个类是系统默认的用户“主体”

User是 UserDetails 实现类，我们只需要使用 User 这个实体类即可：

编写实现类，实现UserDetailsService接口：

/**
 * @Author: Ly
 * @Date: 2021-04-16 20:09
 */
@Service("userDetailsService")  //将MyUserDetailsService注入
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    private UsersMapper usersMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        List<GrantedAuthority> auths = AuthorityUtils.commaSeparatedStringToAuthorityList("role");  //配置角色
						//用户名，密码可以从数据库查询
        return new User("ly",new BCryptPasswordEncoder().encode("123456"),auths);
    }

}

修改配置类：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

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

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

}

测试：

在数据库中查询用户名密码

创建数据库 security，并创建一个User表：

对应的数据库 Schema 脚本，数据库 Data 脚本如下：

DROP TABLE IF EXISTS users;
CREATE TABLE users(
	id BIGINT(20) PRIMARY KEY AUTO_INCREMENT,
	username VARCHAR(20) UNIQUE NOT NULL,
	password VARCHAR(100)
);

DELETE FROM users;

INSERT INTO users (id, username, password) VALUES
(1, '张三', '123456'),
(2, '李四', '123456'),
(3, '王五', '123456');

通过MybatisPlus完成数据库操作： Mybatis-Plus基本使用

添加依赖：

<!--mybatis-plus 是自己开发的，非官方的！-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.1.tmp</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

创建实体类Users：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;
}

新建mapper包，创建UsersMapper接口：

想要使用接口，需要在启动器或配置类上添加注解：@MapperScan("com.ly.mapper")

@Repository
public interface UsersMapper extends BaseMapper<Users> {
}

配置文件添加数据库配置 ：

spring:
  #配置数据源
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/security?useSSL=false&serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456

在实现类中添加数据库相关操作：

@Service("userDetailsService")
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    private UsersMapper usersMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        //调用usersMapper方法，根据用户名查询数据库
        QueryWrapper<Users> wrapper = new QueryWrapper<>();
        wrapper.eq("username",username);
        Users users = usersMapper.selectOne(wrapper);

        //判断
        if(users==null){//数据库没有数据，认证失败
            throw new UsernameNotFoundException("用户名不存在！");
        }

		//手动设置了role，也可以通过数据库查询获取
        List<GrantedAuthority> auths = AuthorityUtils.commaSeparatedStringToAuthorityList("role");  //配置角色

        return new User(users.getUsername(),
                new BCryptPasswordEncoder().encode(users.getPassword()),auths);
    }

}

测试访问：

自定义页面与权限控制

自定义登陆页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

    <form action="/user/login" method="post">
        <!--注意：页面提交方式必须为 post 请求，用户名，密码必须为username,password
        可以通过 usernameParameter()和 passwordParameter()方法修改默认配置-->
        用户名：<input type="text" name="username">
        <br/>
        用户名：<input type="text" name="password">
        <br/>
        <input type="submit" value="login">

    </form>
</body>
</html>

在配置类实现相关配置：

@Override
protected void configure(HttpSecurity http) throws Exception {
    //配置没有权限访问跳转自定义页面
    http.exceptionHandling().accessDeniedPage("/unauth.html");

    http.formLogin()   //自定义自己编写的登陆页面
            .loginPage("/login.html")  //登陆页面设置
            .loginProcessingUrl("/user/login")  //登陆访问路径
            .defaultSuccessUrl("/test/hello").permitAll() //登陆成功后跳转路径
            .and().authorizeRequests()
                .antMatchers("/","/user/login").permitAll() //设置那些路径可以直接访问，不需要认证
//                .antMatchers("/test/addUser").hasAuthority("addUser")
//                .antMatchers("/test/findAll").hasAnyAuthority("addUser,findAll")
//                .antMatchers("/test/hello").hasRole("admin")
//                .antMatchers("/test/hello").hasAnyRole("admin")  
            .anyRequest().authenticated()
            .and().csrf().disable();  //关闭csrf的保护
}

权限控制：

1.在配置类设置当前访问地址有那些权限

//当前用户只有具有addUser权限时才能访问该路径
.antMatchers("/test/add").hasAuthority("addUser")

相关方法： 角色和权限都可以设置多个，以逗号分开

方法名称	说明
hasAuthority	如果当前的主体具有指定的权限，则可以访问
hasAnyAuthority	如果当前的主体有任何提供的角色的话，就可以访问
hasRole	如果用户具备给定角色就允许访问
hasAnyRole	用户具备任何一个角色都可以访问

2.在UserDetailsService中为User对象设置权限

对于权限可以直接设置，对于角色以ROLE_**的方式设置

List<GrantedAuthority> auths = AuthorityUtils
	.commaSeparatedStringToAuthorityList("addUser,findAll,ROLE_admin,ROLE_user");

当User对象没有对应权限时会返回403错误：

自定义403页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>403</title>
</head>
<body>

<h1>对不起，您没有访问权限！</h1>

</body>
</html>

在配置类实现相关配置：http.exceptionHandling().accessDeniedPage("/403.html");

再次测试：

注解的使用

使用注解前需要在启动器或配置类上添加注解：@EnableGlobalMethodSecurity(securedEnabled=true,...)

@SpringBootApplication
@MapperScan("com.ly.mapper")
@EnableGlobalMethodSecurity(securedEnabled=true,prePostEnabled = true)
public class SecurityDemoApplication {

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

}

@Secured：判断是否具有角色：

@RequestMapping("testSecured")
@ResponseBody
@Secured({"ROLE_normal","ROLE_admin"})
public String testSecured() {
    return "testSecured";
}

登录之后直接访问：http://localhost:10081/test/testSecured

@PreAuthorize：进入方法前进行权限验证， @PreAuthorize 可以将登录用户的 roles/permissions 参数传到方法中。

@RequestMapping("/preAuthorize")
@ResponseBody
//@PreAuthorize("hasRole('ROLE_管理员')")
@PreAuthorize("hasAnyAuthority('findAll')")
public String preAuthorize(){
    System.out.println("preAuthorize");
    return "preAuthorize";
}

登录之后直接访问：http://localhost:10081/test/preAuthorize

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

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

登录之后直接访问：http://localhost:10081/test/postAuthorize

@PostFilter ：权限验证之后对数据进行过滤，留下指定的数据，表达式中的 filterObject 引用的是方法返回值 List 中的某一个元素

@RequestMapping("findAll")
@PostAuthorize("hasAnyAuthority('findAll')")
@PostFilter("filterObject.username == 'admin1'")
@ResponseBody
public List<Users> findAllUser(){
    ArrayList<Users> list = new ArrayList<>();
    list.add(new Users(1,"admin1","123456"));
    list.add(new Users(2,"admin2","123456"));

    return list;
}

登录之后直接访问：http://localhost:10081/test/findAll

@PreFilter: 进入控制器之前对数据进行过滤

@RequestMapping("preFilter")
@PostAuthorize("hasAnyAuthority('findAll')")
@PreFilter(value = "filterObject.id%2==0")
@ResponseBody
public List<Users> testPreFilter(@RequestBody List<Users> list){
    list.forEach(t-> {
        System.out.println(t.getId()+"\t"+t.getUsername());
    });
    return list;
}

先登录，然后使用 postman 进行测试：

测试的 Json 数据：

[
	{"id": "1","username": "admin","password": "666"},
	{"id": "2","username": "admins","password": "888"},
	{"id": "3","username": "admins11","password": "11888"},
	{"id": "4","username": "admins22","password": "22888"}
]

输出结果：

用户注销

1. 在配置类中添加退出映射地址：http.logout().logoutUrl("/logout").logoutSuccessUrl("/login.html").permitAll();

新建一个登录成功页面success.html：

在登录页面添加一个退出连接：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>success</title>
</head>
<body>
登录成功<br> <a href="/logout">退出</a>
</body>
</html>

修改登陆成功后的跳转页面：

测试：退出之后，是无法访问需要登录时才能访问的控制器！

基于数据库实现自动登录

创建表，在JdbcTokenReponsitoryImpl中有创建表的语句，可以直接使用：

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;

创建成功：

在配置类中添加一下信息：

@Autowired
//注入数据源
private DataSource dataSource;

@Autowired
private PersistentTokenRepository tokenRepository;

@Bean
public PersistentTokenRepository persistentTokenRepository(){
    JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
    // 赋值数据源
    jdbcTokenRepository.setDataSource(dataSource);
    //自动创建表,第一次执行会创建，以后要执行就要删除掉！
    //jdbcTokenRepository.setCreateTableOnStartup(true);
    return jdbcTokenRepository;
}

开启记住我功能：

// 开启记住我功能 cookie
http.rememberMe()
	    .tokenRepository(tokenRepository)
	    .tokenValiditySeconds(600) //设置有效期600秒
	    .userDetailsService(userDetailsService);

在登陆页面添加记住我复选框：

<!--name 属性值必须位 remember-me.不能改为其他值-->
记住我：<input type="checkbox" name="remember-me" title="记住密码"/><br/>

界面效果：

点击登陆，可以看到cookies中增加了一条remember-me的数据：

登录成功之后，关闭浏览器再次测试访问 http://localhost:10081/findAll，发现依然可以使用，同时可以看到数据库中存在一条数据：

跨站请求伪造

跨站请求伪造（英语：Cross-site request forgery，CSRF）， 是一种挟制用户在当前已登录的 Web 应用程序上执行非本意的操作的攻击方法。跟跨网站脚本（XSS）相比，XSS利用的是用户对指定网站的信任，CSRF 利用的是网站对用户网页浏览器的信任。

跨站请求攻击，简单地说，是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并运行一些操作。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去运行。

这利用了 web 中用户身份验证的一个漏洞：简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的。

从 Spring Security 4.0 开始，默认情况下会启用 CSRF 保护，以防止 CSRF 攻击应用程序，Spring Security CSRF 会针对 PATCH，POST，PUT 和 DELETE 方法进行防护。

使用CSRF：

需要在pom文件中添加相关依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
    <groupId>org.thymeleaf.extras</groupId>
    <artifactId>thymeleaf-extras-springsecurity5</artifactId>
</dependency>

在登录页面添加一个隐藏域，使用了 Thymeleaf模板： 因为使用了Thymeleaf，我们不能像上面一样访问**.html的静态页面，而是通过controller返回地址，页面才能解析。

@GetMapping( "/login")
public String testLogin() {
   return  "login";
}

在登陆页面添加一个隐藏域：

<input type="hidden" name="_csrf.parameterName" th:value="${_csrf.token}"  th:if="${_csrf}!=null"/>

关闭安全配置的类中的 csrf

//http.csrf().disable();

Spring Security 实现 CSRF 的原理：

1. 生成 csrfToken 保存到 HttpSession 或者 Cookie 中。

CsrfToken接口：

该接口有一个实现类：SaveOnAccessCsrfToken

2. 请求到来时，从请求中提取 csrfToken，和保存的 csrfToken 做比较，进而判断当前请求是否合法。主要通过 CsrfFilter 过滤器来完成。