Spring Security框架从入门到实战

最新推荐文章于 2024-07-28 14:44:48 发布
最新推荐文章于 2024-07-28 14:44:48 发布
阅读量454 收藏 2
点赞数 1
分类专栏： Spring生态圈 微服务架构与分布式 文章标签： spring 数据库 spring boot shiro
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MarkZQP/article/details/107915906
版权

在看完Shiro框架文章时，我们大致应该知道了，了解了安全框架应该去做哪些事情，并且随着微服务架构的发展，Spring Security框架在安全框架的地位也发展的越来越好，所以，了解Spring Security框架的使用还是很有必要的。这篇博客是用来巩固自己的学习内容，博客来源与：江南一点雨，所发的视频及他发的文章。

Spring Security框架能做什么呢

它和上一篇文章讲的Shiro一样，它用来做授权和认证相关功能

快速了解一下Spring Security的强大之处

  1. 首先创建一个Spring Boot项目，勾上一个 web依赖和一个Spring Security依赖后，创建一个Hello接口
    如下图所示：在这里插入图片描述
    在这里插入图片描述
  2. 然后，直接启动项目，在启动项目过程中，我们会看到如下一行日志：
Using generated security password: ed9c6238-9afe-4204-9750-6528bb924e44
  1. 项目启动成功后，像平常一样去访问http://localhost:8080/hello接口，我们会发现，和平时不太一样了，平时都能够直接弹出一个hello的字符串，这次竟然弹出了一个登录界面，再说，我们也压根没有写登录界面呀！
    在这里插入图片描述
    不用说也知道，肯定是因为有了Spring Security依赖的关系了。那么我们该如何登录呢？
    在登录页面，默认的用户名就是 user，默认的登录密码则是项目启动时控制台打印出来的密码，输入用户名密码之后，就登录成功了，登录成功后，我们就可以访问到 /hello 接口了。
    我们可以一个知道：一个依赖就保护了所以接口，应该比Shiro框架要强大很多吧！

Spring Security结合数据库的完整配置

首先添加依赖

结合了Spring Data jpa，所以导入了下列依赖

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.mark</groupId>
    <artifactId>security</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>security</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</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-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </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>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

</project>

完成配置文件的配置

spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url= jdbc:mysql:///test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai

spring.jpa.database=mysql
spring.jpa.database-platform=mysql
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect

项目的目录结构展示图

在这里插入图片描述

创建实体类(共两个实体类)

  1. Role(角色类）
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

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

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNameZh() {
        return nameZh;
    }

    public void setNameZh(String nameZh) {
        this.nameZh = nameZh;
    }
}
  1. User（用户类）

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

@Entity(name = "t_user")
public class User implements UserDetails {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    private boolean accountNonExpired;
    private boolean accountNonLocked;
    private boolean credentialsNonExpired;
    private boolean enabled;
    //这是多对多的一个注解，
    @ManyToMany(fetch = FetchType.EAGER,cascade = CascadeType.PERSIST)
    private List<Role> roles;

    public void setAccountNonExpired(boolean accountNonExpired) {
        this.accountNonExpired = accountNonExpired;
    }

    public void setAccountNonLocked(boolean accountNonLocked) {
        this.accountNonLocked = accountNonLocked;
    }

    public void setCredentialsNonExpired(boolean credentialsNonExpired) {
        this.credentialsNonExpired = credentialsNonExpired;
    }

    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        List<SimpleGrantedAuthority> authorities = new ArrayList<>();
        for (Role role : getRoles()) {
            authorities.add(new SimpleGrantedAuthority(role.getName()));
        }
        return authorities;
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public boolean isAccountNonExpired() {
        return accountNonExpired;
    }

    @Override
    public boolean isAccountNonLocked() {
        return accountNonLocked;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return credentialsNonExpired;
    }

    @Override
    public boolean isEnabled() {
        return enabled;
    }
}

可以看到这两个类当中有Spring data jpa 的相关注解，并且可以看到，我们写的User类它实现了一个UserDetails类，因为Spring Security需要对User进行相关安全控制，所以必要满足Spring Security的相关方法。并且采用Spring Data Jpa 还会生成实体类相对应的表格

Dao层

import com.mark.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserDao extends JpaRepository<User,Long> {
    User findUserByUsername(String username);
}

Service层

import com.mark.dao.UserDao;
import com.mark.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class UserService implements UserDetailsService {
    @Autowired
    UserDao userDao;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userDao.findUserByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("用户不存在");
        }
        return user;
    }
}

可以看到，这个service ，实现了一个UserDetailsService类，这个也是为了Spring Security的相关配置

在配置Spring Security 配置之前

先启动项目，由于配置了Spring Data Jpa 的关系，它会自动在数据库中生成两个表，为啥是三个表呢？，不是仅仅才两个实体类吗？，除了生成了两个实体类的表还生成了一个，两个实体类的关联表。再使用一个测试类来往数据库的表格插入数据。


import com.mark.dao.UserDao;
import com.mark.model.Role;
import com.mark.model.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import javax.transaction.Transactional;
import java.util.ArrayList;
import java.util.List;

@SpringBootTest
class SecurityApplicationTests {

    @Autowired
    UserDao userDao;
    @Test
    void contextLoads() {
        User u1 = new User();
        u1.setUsername("ncu");
        u1.setPassword("123");
        u1.setAccountNonExpired(true);
        u1.setAccountNonLocked(true);
        u1.setCredentialsNonExpired(true);
        u1.setEnabled(true);
        List<Role> rs1 = new ArrayList<>();
        Role r1 = new Role();
        r1.setName("ROLE_admin");
        r1.setNameZh("管理员");
        rs1.add(r1);
        u1.setRoles(rs1);
        userDao.save(u1);
        User u2 = new User();
        u2.setUsername("MarkZQP");
        u2.setPassword("123");
        u2.setAccountNonExpired(true);
        u2.setAccountNonLocked(true);
        u2.setCredentialsNonExpired(true);
        u2.setEnabled(true);
        List<Role> rs2 = new ArrayList<>();
        Role r2 = new Role();
        r2.setName("ROLE_user");
        r2.setNameZh("普通用户");
        rs2.add(r2);
        u2.setRoles(rs2);
        userDao.save(u2);
    }
}

数据库及运行结果截图：
在这里插入图片描述

下面是最重要的Spring Security的相关配置

import com.fasterxml.jackson.databind.ObjectMapper;
import com.mark.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.hierarchicalroles.RoleHierarchy;
import org.springframework.security.access.hierarchicalroles.RoleHierarchyImpl;
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.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

import java.io.PrintWriter;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    UserService userService;
    @Bean
    PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

    @Bean
    RoleHierarchy roleHierarchy() {
        RoleHierarchyImpl hierarchy = new RoleHierarchyImpl();
        // 权限的相关设计
        // 可以看到，admin权限比user权限大，只有有了admin权限
        hierarchy.setHierarchy("ROLE_admin > ROLE_user");
        return hierarchy;
    }

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

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/js/**", "/css/**", "/images/**");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("admin") //只有有admin角色才能访问/admin/**接口
                .antMatchers("/user/**").hasRole("user") //只有user角色才能访问/user/**接口
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .loginProcessingUrl("/doLogin")     // 登录界面提交时需要访问的接口"/doLogin"
                .successHandler((req, resp, authentication) -> {
                // 这是登录成功是所调的函数，返回相关的JSON数据
                // 有了相关的JSON数据，前端就可以进行相关的处理
                    Object principal = authentication.getPrincipal();
                    resp.setContentType("application/json;charset=utf-8");
                    PrintWriter out = resp.getWriter();
                    out.write(new ObjectMapper().writeValueAsString(principal));
                    out.flush();
                    out.close();
                })
                .failureHandler((req, resp, e) -> {
                // 这是登录失败所调的函数，也是返回相关的JSON数据
                // 有了相关的JSON数据，前端就可以进行相关的处理
                    resp.setContentType("application/json;charset=utf-8");
                    PrintWriter out = resp.getWriter();
                    out.write(e.getMessage());
                    out.flush();
                    out.close();
                })
                .permitAll()
                .and()
                .logout()
                .logoutUrl("/logout") // 注销链接所调用的logout接口
                .logoutSuccessHandler((req, resp, authentication) -> {
                    resp.setContentType("application/json;charset=utf-8");
                    PrintWriter out = resp.getWriter();
                    out.write("注销成功");
                    out.flush();
                    out.close();
                })
                .permitAll()
                .and()
                .csrf().disable().exceptionHandling()
                .authenticationEntryPoint((req, resp, authException) -> {
                            resp.setContentType("application/json;charset=utf-8");
                            PrintWriter out = resp.getWriter();
                            out.write("尚未登录，请先登录");
                            out.flush();
                            out.close();
                        }
                );
    }
}

代码这么多，先来了解每一个函数对应的功能吧

  1. 首先，我们创建了一个 SecurityConfig的类，它继承了WebSecurityConfigurerAdapter这个类(这是因为它是Spring Security的相关配置)，并且加上了@Configuration这个注解让它成为了一个配置类。并且可以重写WebSecurityConfigurerAdapter的相关方法以完成相关功能。
  2. 首先我们提供了一个 PasswordEncoder 的实例，因为目前的案例还比较简单，因此我暂时先不给密码进行加密，所以返回 NoOpPasswordEncoder 的实例即可。
  3. 第一个configure, 直接就一行代码auth.userDetailsService(userService)，它完成的功能就是验证用户的账号密码。
  4. 第二个configure，不拦截"/js/**", "/css/**", "/images/**",这些个信息
  5. 第三个configure，有相关注解。

使用postman进行测试

  1. 直接访问hello接口
    在这里插入图片描述
  2. 登录 nuc账号，它的角色为admin
    在这里插入图片描述
    登录成功后，在去访问接口/hello，/admin/hello，/user/hello接口都能访问成功，虽然在权限上设置了user下的接口需要user角色才能访问，但是在权限上给了其它的设置，admin角色可以访问user角色所能访问的。
  3. 登录 mark账号，它的角色为user
    在这里插入图片描述
    登录成功后，在去访问接口/hello，/user/hello接口都能访问成功，但是，/admin/hello接口，不能访问成功，因为有权限的设置

博客到这里就结束了，可能介绍的不够详细，不过— 江南一点雨— 这个大佬写的特别好，可以去看他的文章。

MarkZQP
关注
专栏目录
SpringSecurity框架【详解】
m0_67266585的博客
07-28 1183
SpringSecurity是Spring家族中的一个安全管理框架。相比与另外一个安全框架Shiro，它提供了更丰富的功能，社区资源也比Shiro丰富；是一个功能强大且高度可定制的身份验证和访问控制框架。它是用于保护基于Spring的应用程序的实际标准；SpringSecurity是一个框架，致力于为Java应用程序提供身份验证和授权。与所有Spring项目一样，SpringSecurity的真正强大之处在于可以轻松扩展以满足自定义要求。在Java生态中，目前有和认证和授权。...
Spring Security框架
Leuke的博客
08-26 551
Spring Security框架 1.1. Spring Security简介 Spring Security是一个安全框架，在常规使用时，主要使用它的： 框架内自带对密码进行加密的工具包，可以对密码进行加密处理； 自带登录验证及获取登录用户的信息的机制（包括页面、提交数据后的处理），可以更加简单的实现登录、获取权限； 可以便利的实现授权访问（即访问某个路径需要某个权限等）； 结合其它框架实现更多功能。 1.2. 添加依赖 在使用时，还是先在straw父级项目的pom.xml中添加依赖： <!-
Spring Security（安全框架）
weixin_53455615的博客
11-03 1505
利用Spring IoC/DI和AOP功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。导入依赖后默认会有一个登录页，并且没有登录时访问其他资源会自动跳到登录页，用户名为user，密码会打印在控制台。认证用户的主要凭证之一。可以是账号、邮箱、手机号等。在java中主体是Object类型。应用程序确认用户身份的过程，常见认证：登录。Spring Security所有功能都是。用户认证过程中的依据之一。判断用户具有哪些权限或角色。
【Spring Boot】Spring 的安全框架：Spring Security
书山有路，学海无涯。记录成长，追逐梦想
07-28 1139
Spring Security 提供了声明式的安全访问控制解决方案（仅支持基于 Spring 的应用程序），对访问权限进行认证和授权，它基于 Spring AOP 和 Servlet 过滤器，提供了安全性方面的全面解决方案。
SpringSecurity安全框架
weixin_60257072的博客
12-11 3166
1、框架介绍Spring 是一个非常流行和成功的 Java 应用开发框架。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。一般来说，Web 应用的安全性包括用户认证（）和用户授权（）两个部分。（1）用户认证指的是：验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。（2）用户授权指的是验证某个用户是否有权限执行某个操作。
Spring Security入门到实践
GitChat
10-10 2177
Spring Security是Spring在安全领域的顶级项目，在用户认证方面支持众多主流认证标准，包括但不限于HTTP基本认证、HTTP表单验证、HTTP摘要认证、OpenID和LDAP等，在用户授权方面，Spring Security不仅支持最常用的基于URL的Web请求授权，还支持基于角色的访问控制（Role-Based Access Control，RBAC）以及访问控制列表（Acces...
Spring Security实战
rhwayfun专栏
08-20 3481
spring security是一个多方面的安全认证框架，提供了基于JavaEE规范的完整的安全认证解决方案。并且可以很好与目前主流的认证框架（如CAS，中央授权系统）集成。使用spring security的初衷是解决不同用户登录不同应用程序的权限问题，说到权限包括两部分：认证和授权。认证是告诉系统你是谁，授权是指知道你是谁后是否有权限访问系统（授权后一般会在服务端创建一个token，之后用这个t
从入门到高级实战-深度探索SpringSecurity安全框架视频.zip
最新发布
08-29
01.初识 Spring Security 02.Spring Security 初体验 03.基于内存定义 Spring Security 用户 04.Spring Security 自定义表单登录 05.Spring Security 登录表单配置细节 06.Spring Security 表单登录源码 07.Spring ...
全套Spring Security入门到项目实战课程
03-21
### Spring Security 全套入门到项目实战课程知识点详解 #### 一、Spring Security 概述 **1.1 Spring Security 介绍** - **定义**: Spring Security 是一款基于 Spring 框架的身份认证(Authentication)与用户...
掌握Spring框架：从基础到实战
最近开始研究AIGC领域技术，欢迎交流
06-13 325
Spring是目前广泛应用于web开发的主流框架，深入了解其原理对于开发人员至关重要。日常工作中经常能遇到新手一边模仿（Ctrl+C），一边实操（Ctrl+V）的情景，一段时间下来除了熟练IDE，个人成长并不大。究其原因，主要是现在网络查问题和代码参考太方便，基本不用太多思考和钻研就能解决80%的技术问题。长此以往，消磨了技术人员的理想信念，难以实现技术跨越，失去职场上的竞争力。本系列文章将带领大家深入学习和探索Spring框架的技术原理，期望能解开Spring神秘的面纱，早日成为技术大牛，祝成功！
Spring Boot 入门到实战
09-19
《Spring Boot 入门到实战》是一门针对初学者精心设计的课程，旨在帮助开发者快速掌握Spring Boot这一强大且流行的Java开发框架。Spring Boot简化了Spring应用的初始搭建以及开发过程，通过“约定优于配置”的理念，...
10年IT老兵亲述SpringCloud开发从入门到实战文档
ma_xiao_qi的博客
06-13 600
java学习 成长思维导图：骆驼祥子思维导图 - GitMind首先给大家看一张图，不知道图上这些springcloud的技术知识点，大家是否都精通而灵活运用了呢？ 如果没有精通灵活运用的话，小编将用此文来带大家一步步来深入学习这些技术知识，接下来将从Spring Boot微框架搭建、Spring Cloud常用组件应用，到微服务案例实战，层层剥茧式分析，全流程讲解Spring Cloud开发应用，实战案例拿来就用，带大家快速上手。本文主要分为21章的内容给大家介绍springcloud开发从入门到实战，大
SpringSecurity框架
m0_58677725的博客
09-01 567
安全框架的核心： 认证和授权 基于SpringBoot框架开发 依赖于SpringBoot框架 授权基于Spring的AOP进行授权 认证基于Spring的IOC进行认证 安全框架pom依赖： <!--安全框架依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值