SpringBoot2.0集成Security，控制访问权限（最简单的连接数据的验证）

最新推荐文章于 2024-06-19 16:51:28 发布
最新推荐文章于 2024-06-19 16:51:28 发布
阅读量801 收藏
点赞数
分类专栏： springboot security
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33371766/article/details/106586290
版权

1.目录结构

2.pom.xml

<?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.0.5.RELEASE</version>
    </parent>

    <groupId>com.cxb</groupId>
    <artifactId>security</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-security</name>
    <description>security demo project for Spring Boot</description>


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

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

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

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

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

</project>

3.application.yml

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=false
    username: root
    password: 123456

server:
  port: 8081

4.security.sql（数据库脚本）

-- --------------------------------------------------------
-- 主机:                           127.0.0.1
-- 服务器版本:                        5.6.40 - MySQL Community Server (GPL)
-- 服务器操作系统:                      Win64
-- HeidiSQL 版本:                  8.2.0.4675
-- --------------------------------------------------------

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET NAMES utf8 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;

-- 导出 test 的数据库结构
CREATE DATABASE IF NOT EXISTS `test` /*!40100 DEFAULT CHARACTER SET utf8 */;
USE `test`;


-- 导出  表 test.role 结构
CREATE TABLE IF NOT EXISTS `role` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `rolename` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- 正在导出表  test.role 的数据：~2 rows (大约)
DELETE FROM `role`;
/*!40000 ALTER TABLE `role` DISABLE KEYS */;
INSERT INTO `role` (`id`, `rolename`) VALUES
	(1, 'ROLE_USER'),
	(2, 'ROLE_ADMIN');
/*!40000 ALTER TABLE `role` ENABLE KEYS */;


-- 导出  表 test.user 结构
CREATE TABLE IF NOT EXISTS `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- 正在导出表  test.user 的数据：~2 rows (大约)
DELETE FROM `user`;
/*!40000 ALTER TABLE `user` DISABLE KEYS */;
INSERT INTO `user` (`id`, `username`, `password`) VALUES
	(1, 'cxb', '$2a$10$dkBfQakqUo6ybZT7u8vxNOzG3aEPQ4iuepCidq/NZnLcUUr61fyZm'),
	(2, 'frank', '$2a$10$dkBfQakqUo6ybZT7u8vxNOzG3aEPQ4iuepCidq/NZnLcUUr61fyZm');
/*!40000 ALTER TABLE `user` ENABLE KEYS */;


-- 导出  表 test.user_role 结构
CREATE TABLE IF NOT EXISTS `user_role` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) DEFAULT NULL,
  `role_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- 正在导出表  test.user_role 的数据：~2 rows (大约)
DELETE FROM `user_role`;
/*!40000 ALTER TABLE `user_role` DISABLE KEYS */;
INSERT INTO `user_role` (`id`, `user_id`, `role_id`) VALUES
	(1, 1, 2),
	(2, 2, 1);
/*!40000 ALTER TABLE `user_role` ENABLE KEYS */;
/*!40101 SET SQL_MODE=IFNULL(@OLD_SQL_MODE, '') */;
/*!40014 SET FOREIGN_KEY_CHECKS=IF(@OLD_FOREIGN_KEY_CHECKS IS NULL, 1, @OLD_FOREIGN_KEY_CHECKS) */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;

5.SecurityConfig

package com.cxb.security.config;

import com.cxb.security.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true, jsr250Enabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserService userService;

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

}

6.HelloController

package com.cxb.security.controller;

import org.springframework.security.access.annotation.Secured;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

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

    /**
     * 单个角色：@Secured("ROLE_USER")
     * 多个角色任意一个：@Secured({"ROLE_USER","ROLE_ADMIN"})
     */
    @Secured("ROLE_USER")
    @GetMapping("/user")
    public String user() {
        return "Hello Security ROLE_USER";
    }

    @Secured("ROLE_ADMIN")
    @GetMapping("/admin")
    public String admin() {
        return "Hello Security ROLE_ADMIN";
    }

    /**
     * 进入方法之前验证授权，支持表达式
     * 允许所有访问：@PreAuthorize("true")
     * 拒绝所有访问：@PreAuthorize("false")
     * 单个角色：@PreAuthorize("hasRole('ROLE_USER')")
     * 多个角色与条件：@PreAuthorize("hasRole('ROLE_USER') AND hasRole('ROLE_ADMIN')")
     * 多个角色或条件：@PreAuthorize("hasRole('ROLE_USER') OR hasRole('ROLE_ADMIN')")
     */
    @PreAuthorize("true")
    @GetMapping("/authorized")
    public String authorized() {
        return "Hello World";
    }

    @PreAuthorize("false")
    @GetMapping("/denied")
    public String denied() {
        return "Goodbye World";
    }

}

7.Role

package com.cxb.security.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("role")
public class Role implements GrantedAuthority {

    @TableId(type = IdType.AUTO)
    private Long id;
    private String rolename;

    @Override
    public String getAuthority() {
        return this.rolename;
    }
}

8.User

package com.cxb.security.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.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;
import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("user")
public class User implements UserDetails {

    @TableId(type = IdType.AUTO)
    private Long id;
    private String username;
    private String password;
    @TableField(exist = false)
    private List<Role> roleList;

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return this.roleList;
    }

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

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

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

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

}

9.UserRole

package com.cxb.security.entity;

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

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("user_role")
public class UserRole {

    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private Long roleId;

}

10.RoleRepository

package com.cxb.security.repository;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.cxb.security.entity.Role;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface RoleRepository extends BaseMapper<Role> {
}

11.UserRepository

package com.cxb.security.repository;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.cxb.security.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserRepository extends BaseMapper<User> {
}

12.UserRoleRepository

package com.cxb.security.repository;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.cxb.security.entity.UserRole;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserRoleRepository extends BaseMapper<UserRole> {
}

13.UserService 配置security的主要配置了

package com.cxb.security.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.cxb.security.entity.Role;
import com.cxb.security.entity.User;
import com.cxb.security.entity.UserRole;
import com.cxb.security.repository.RoleRepository;
import com.cxb.security.repository.UserRepository;
import com.cxb.security.repository.UserRoleRepository;
import lombok.AllArgsConstructor;
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;

import java.util.List;
import java.util.stream.Collectors;

@AllArgsConstructor
@Service
public class UserService implements UserDetailsService {

    private UserRepository userRepository;
    private RoleRepository roleRepository;
    private UserRoleRepository userRoleRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        if (username == null || username.isEmpty()) {
            throw new UsernameNotFoundException("用户名不能为空");
        }
        User user = userRepository.selectOne(new QueryWrapper<User>().lambda().eq(User::getUsername, username));
        if (user == null) {
            throw new UsernameNotFoundException("用户不存在");
        }
        List<UserRole> userRoles = userRoleRepository.selectList(new QueryWrapper<UserRole>().lambda().eq(UserRole::getUserId, user.getId()));
        if (userRoles != null && !userRoles.isEmpty()) {
            List<Long> roleIds = userRoles.stream().map(UserRole::getRoleId).collect(Collectors.toList());
            List<Role> roles = roleRepository.selectList(new QueryWrapper<Role>().lambda().in(Role::getId, roleIds));
            user.setRoleList(roles);
        }
        return user;
    }

}

14.Tool （BCryptPasswordEncoder加解密的工具）

package com.cxb.security.util;

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public class Tool {
    /**
     *  数据库加密解密
     * @param args
     */
    public static void main(String[] args) {
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        String encodePass = passwordEncoder.encode("123456");
        System.out.println(encodePass);
        boolean matches = passwordEncoder.matches("123456", encodePass);
        System.out.println(matches);
    }
}

15.Application

package com.cxb.security;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

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

}

最后测试：http://localhost:8081/login

登陆用户frank（权限是user）

访问：http://localhost:8081/admin  失败

访问：http://localhost:8081/user 成功

项目代码

小石潭记丶
关注
专栏目录
SpringBoot集成OAuth2身份验证机制
程序员光剑
08-01 2806
随着互联网技术的飞速发展、应用场景的多样化以及对安全性的需求越来越高，越来越多的人开始关注并实践“OAuth2”（开放授权）协议。在本文中，我将会通过对 Spring Boot 的集成 OAuth2 身份验证机制，来实现身份认证功能的支持。OAuth2 是一种授权框架协议，它为用户资源提供一个安全的访问通道，让用户可以分享他/她的账号信息给第三方应用或者网站，而不用暴露自己的密码等敏感信息。
SpringBoot系列教程：集成MyBatis，SpringSecurity
程序员光剑
07-30 1107
Spring Boot是一种新的开源Java开发框架，它极大地简化了基于Java的应用配置，自动装配，消息处理等流程，并提供了运行时的健康检查、外部化配置等功能，因此在实际项目开发中扮演着越来越重要的角色。本系列教程将详细介绍如何利用Spring Boot框架，整合Mybatis和Spring Security，实现对数据库的增删改查及安全管理。Spring Boot介绍MyBatis介绍Spring Security介绍如何整合Mybatis和Spring Security。
Springboot整合SpringSecurity 07-方法访问权限控制
枫林晚丶的博客
09-13 1194
Springboot整合SpringSecurity 07-方法访问权限控制 前面我们已经学会了SpringSecurity的权限访问控制。 但是之前的配置都是直接对请求路径的权限控制，SpringSecurity还提供了访问级别的权限控制。 必须具有相应的权限才能访问该方法。 本系列的按顺序写的，如果对于某些代码不清楚，请看下前面的几篇文章。 Springboot整合SpringSecurity...
Spring Boot整合Spring Security实现权限控制
一行代码敲一天
12-06 761
学习Spring Security过后进行梳理和总结。 Spring Security介绍 ​ Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。由于它是Spring生态系统中的一员，因此它伴随着整个Spring生态系统不断修正、升级，在spring boot项目中加入spring security更是十分简单，使用Spring...
漫步SpringSecurity---在SpringBoot中整合Security技术并实现数据库认证
LeslieLau的博客
06-02 695
最近在做一些练习的demo，所以好久没有更新博客了。这一篇来记录一下在SpringBoot中整合SpringSecurity技术，并实现通过数据库的方式来认证用户。 提前声明一下，这一篇没有授权相关代码配置，只有认证哦. 文章目录maven依赖准备数据库准备(建表语句省略)对应的实体类对象准备:mapper层代码ServiceControllerSecurity的配置类(不使用加密方式):Security的配置类(使用加密方式): maven依赖准备 这里直接上pom.xml文件: <?xml ve
SpringBoot2.* 配置拦截器(Interceptor) 并 集成swagger2 3.0版本
weixin_39527642的博客
09-20 1295
SpringBoot 拦截器 swagger2 V3
SpringBoot中使用Spring Security实现权限控制
波板糖的博客
05-06 1239
Spring Security 基本介绍 这里就不对Spring Security进行过多的介绍了，具体的可以参考官方文档 我就只说下SpringSecurity核心功能: 认证（你是谁） 授权（你能干什么） 攻击防护（防止伪造身份） 基本环境搭建 这里我们以SpringBoot作为项目的基本框架，我这里使用的是maven的方式来进行的包管理，所以这里先给出集成Spring Securi...
SpringBoot2.0实战（16）整合SpringSecurity之最简登录方法鉴权
菜园子丶For丨丶Tomorrow的博客
04-27 465
目标 整合 SpringSecurity 实现最简登陆鉴权及方法鉴权，大致理解 SpringSecurity 的功用。 操作步骤 添加依赖 编码 Controller 层 添加一个最简单的测试接口 启动类 可以看到，除了在 pom 文件加了一个 spring-boot-starter-security 依赖，其它跟创建最简 springBoot 应用...
SpringBoot+SpringSecurity OAuth2 认证服务搭建实战 （一）
最新发布
06-19 1148
配置：Maven，SpringBoot3.3.0，Spring-Security-oauth2-authorization-server 1.3.0(这个在pom中是用starter代替掉了)，最后是JDK17，当然jdk版本不是必须的，其它版本也是可以的，只要别太低。作者当前用的SpringBoot是3.3.0的，算是比较新的版本，在这个版本的依赖列表中，Spring Authorization Server的版本是1.3.0。这里非常确定的告诉大家，资源服务器的代码和授权服务代码是写在一个项目中的。
SpringBoot OAuth2.0认证管理流程详解
begefefsef的博客
08-02 679
添加下方名片，即可获取全套学习资料哦。ExpressionBasedPreInvocationAdvice.before方法即根据定义的注解来校验是否有权限访问该接口，入下图所示，用户具备的权限包括orderDetail和orderInfo，而注解校验是否包含orderInfo权限，故校验通过。返回结果中包含state和code两个参数，state和请求中的参数一致，code表示授权码，客户端只能使用该授权码一次，该返回结果又将请求重定向到localhost8101/login。...
Springboot2.0 设置本机https访问
龙企阁
11-02 562
软件背景：springboot2.0.4 生成证书秘钥 JDK中keytool是一个证书管理工具，可以生成自签名证书 具体生成如下图：【由于之前已经生成了别名为 tomcat的 tomcat.key 了，所以这里别名改成了springboot】 2、将生成好的证书copy到项目中，位置如下图： 3、修改application.yml 配置 http: port: ...
Springboot启动后只能本地访问，无法通过外部IP访问
热门推荐
JayMod
09-05 2万+
启动springboot后，服务可通过127.0.0.1、localhost访问，但无法通过192.168.0.8访问。 排查后发现，原因应该是出在springboot自带的Tomcat上，可修改配置文件application.properties中 server.address = 0.0.0.0 解决。 具体的原因是因为127.0.0.1可能会使用ipv6，修改为0.0.0.0可改为ipv
Spring Security 注解方式权限控制
qq_65142821的博客
01-29 1330
Spring Security除了可以在配置文件中配置权限校验规则，还可以使用注解方式控制类 中方法的调用。例如Controller中的某个方法要求必须具有某个权限才可以访问，此时就 可以使用Spring Security框架提供的注解方式进行控制。
springboot2.0中的management.security.enabled 过时
文盲青年的博客
12-28 4459
在Spring boot 2.0中 management.security.enabled=true 或 management： security: enabled:true 可以采用 management.endpoints.web.exposure.include= 代替的全部放开请使用*，或把需要开放的接口端点使用“,”隔开，如：env,health。 yaml 的配置*请加上“"”（引号）如下 management: endpoints: web: exposure
SpringBoot项目使用切面编程实现数据权限管理
weixin_44792849的博客
03-26 2580
springboot项目使用切面编程实现数据权限管理
5.Spring Security安全注解（@PreAuthorize、@PostAuthorize、@PostFilter、@PreFilter）
相互学习 共同进步
04-24 1288
Spring Security默认是禁用注解的，要想开启注解，需要在继承WebSecurityConfigurerAdapter的类上加@EnableGlobalMethodSecurity注解，并在该类中将AuthenticationManager定义为Bean如果要启用基于注解的方法安全性，要在配置类上使用**@EnableGlobalMethodSecurity**设置了securedEnabled = true，此时Spring将会创建一个切点，并将带有@Secured注解的方法防入切面中。
SpringSecurity实现登录和自定义权限认证
qq_49721447的博客
12-07 4168
springboot整合SpringSecurity实现登录和自定义权限认证
SpringBoot整合SpringSecurity
yj123ab的博客
01-24 1038
搭建完SpringBoot项目后导入依赖 <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-test</artifactId> <version>5.4.2</version> <scope&g
基于java config的springSecurity(四)--启用全局方法安全
weixin_33836223的博客
10-25 103
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringBoot2.0 + SpringSecurity：实现用户权限安全管理详解
通过以上步骤，SpringBoot 2.0与SpringSecurity的集成能让你的应用程序拥有强大且灵活的权限管理系统，有效保护了敏感操作和数据安全。在实际项目中，根据业务需求调整和优化这些设置，确保系统的安全性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值