java：spring-security的简单例子

最新推荐文章于 2024-07-05 14:51:01 发布
最新推荐文章于 2024-07-05 14:51:01 发布
阅读量857 收藏 16
点赞数 23
分类专栏： java spring boot / cloud 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenhz2284/article/details/139902518
版权

【pom.xml】

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.3.12.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
    <version>2.3.12.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
    <version>2.3.12.RELEASE</version>
</dependency>

【/resources/public/login.html】

<!DOCTYPE html>
<html>
    <head>
        <title>Spring Security Example </title>
    </head>
    <body>
        <form action="/security/login2" method="get">
            <div><label> User Name : <input type="text" name="username" value="user"/> </label></div>
            <div><label> Password: <input type="password" name="password" value="123"/> </label></div>
            <div><input type="submit" value="Sign In"/></div>
        </form>
    </body>
</html>

【SecurityConfig.java】

package com.chz.mySpringSecurity.config;

import com.chz.mySpringSecurity.filter.AccessTokenFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter
{
    @Autowired
    private AccessTokenFilter accessTokenFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception
    {
        http.authorizeRequests()
                //访问"/"和"/home"路径的请求都允许
                .antMatchers(
                        "/",            // 这个会跳转到主页，要放过
                        "/home",           // 这是主页的地址，要放过
                        "/security/login2"          // 这个是提交登录的地址，要放过
                )
                .permitAll()
                //而其他的请求都需要认证
                .anyRequest()
                .authenticated()
                .and()
                //修改Spring Security默认的登陆界面
                .formLogin()
                .loginPage("/security/login")       // 登录地址是【/security/login】
                .permitAll()
                .and()
                .logout()
                .permitAll();

        http.addFilterBefore(accessTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();     // 这个会对用户提交的密码进行编码，然后才跟密码库里面的密码进行比较
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

【PublicController.java】

package com.chz.mySpringSecurity.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Slf4j
@Controller
@RequestMapping("/")
public class PublicController
{
    @GetMapping(value = {"/home","/"})
    @ResponseBody
    public String home(){
        log.info("chz >>> SecurityController.home(): ");
        return "this is home page!";
    }
 
}

【SecurityController.java】

package com.chz.mySpringSecurity.controller;

import com.chz.mySpringSecurity.entity.LoginUser;
import com.chz.mySpringSecurity.entity.LoginUsers;
import com.chz.mySpringSecurity.entity.ResponseResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Enumeration;
import java.util.Objects;
import java.util.concurrent.ThreadLocalRandom;

@Slf4j
@Controller
@RequestMapping("/security")
public class SecurityController 
{
    @Autowired
    private AuthenticationManager authenticationManager;

    @GetMapping(value = "/hello")
    @ResponseBody
    public String hello(){
        log.info("chz >>> SecurityController.hello(): ");
        return "this is hello page!";
    }

 
    @GetMapping(value = "/login")
    public String login(HttpServletRequest request, HttpServletResponse response){
        log.info("chz >>> SecurityController.login(): ");
        return "/login.html";
    }

    @GetMapping(value = "/login2")
    @ResponseBody
    public ResponseResult login2(@RequestParam String username, @RequestParam String password)
    {
        log.info("chz >>> SecurityController.login2(): username={}, password={}", username, password);

        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username, password);
        Authentication authenticate = authenticationManager.authenticate(authenticationToken);      // 这个会触发【UserDetailsService.loadUserByUsername(String username)】方法被调用
        if(Objects.isNull(authenticate)){
            log.info("chz >>> SecurityController.login2(): 用户名或密码错误");
            throw new RuntimeException("用户名或密码错误");
        }

        LoginUser loginUser = (LoginUser)authenticate.getPrincipal();
        loginUser.setRefreshToken(Math.abs(ThreadLocalRandom.current().nextLong())+"");
        loginUser.setAccessToken(Math.abs(ThreadLocalRandom.current().nextLong())+"");
        LoginUsers.users.put(loginUser.getAccessToken(), loginUser);
        log.info("chz >>> accessToken: " + loginUser.getAccessToken());

        // context里面设置了【authenticationToken】就表示用户已经登录了，但是这个是根据cookie里面有sessionId判断的，跟accessToken无关
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);

        return new ResponseResult(200,"登陆成功", loginUser.getAccessToken());
    }

    @GetMapping(value = "/logout2")
    @ResponseBody
    public ResponseResult logout2(@RequestParam String accessToken)
    {
        log.info("chz >>> SecurityController.login2(): accessToken={}", accessToken);
        LoginUsers.users.remove(accessToken);

        // context里面清除了【authenticationToken】就表示用户已经退出登录了，但是这个是根据cookie里面有sessionId判断的，跟accessToken无关
        SecurityContextHolder.getContext().setAuthentication(null);

        return new ResponseResult(200,"退出成功");
    }
}

【LoginUser.java】

package com.chz.mySpringSecurity.entity;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import java.util.Collection;
import java.util.HashSet;

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser implements UserDetails
{
    private String accessToken;
    private String refreshToken;
    private HashSet<GrantedAuthority> authorities = new HashSet<>();

    private User user;

    public LoginUser(User user)
    {
        this.user = user;
    }

    public void addAuthority(String authority)
    {
        authorities.add(new SimpleGrantedAuthority(authority));
    }

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

 
    @Override
    public String getPassword() {
        return user.getPassword();
    }

 
    @Override
    public String getUsername() {
        return user.getUserName();
    }

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

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

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

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

【LoginUsers.java】

package com.chz.mySpringSecurity.entity;

import java.util.concurrent.ConcurrentHashMap;

public class LoginUsers
{
    // 这个map模拟的是分布式缓存redis的数据，代表已登录的用户列表
    public static ConcurrentHashMap<String, LoginUser> users = new ConcurrentHashMap<>();
}

【ResponseResult.java】

package com.chz.mySpringSecurity.entity;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class ResponseResult<T> {

    private Integer code;
    private String msg;
    private T data;

 
    public ResponseResult(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

 
    public ResponseResult(Integer code, T data) {
        this.code = code;
        this.data = data;
    }

 
    public ResponseResult(Integer code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
}

【User.java】

package com.chz.mySpringSecurity.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable 
{
    private String userName;
    private String password;
}

【MyExceptionHandler.java】

package com.chz.mySpringSecurity.exceptions;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@Slf4j
@RestControllerAdvice
public class MyExceptionHandler 
{
    @ExceptionHandler(Exception.class)
    public String handleException(Exception e){
        log.error("chz >>> err", e);
        return "发生异常了";
    }
}

【AccessTokenFilter.java】

package com.chz.mySpringSecurity.filter;

import com.chz.mySpringSecurity.entity.LoginUser;
import com.chz.mySpringSecurity.entity.LoginUsers;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Slf4j
@Component
public class AccessTokenFilter extends OncePerRequestFilter
{
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException
    {
        log.info("chz >>> ChzAuthenticationTokenFilter.doFilterInternal(): uri:{}, queryParam={}", request.getRequestURI(), request.getQueryString());
        LoginUser loginUser = null;
        String accessToken = request.getParameter("accessToken");
        if( !StringUtils.isEmpty(accessToken) ) {
            loginUser = StringUtils.isEmpty(accessToken) ? null : LoginUsers.users.get(accessToken);
        }

        if( loginUser!=null ){
            // 这是登录过的，可以访问受限资源
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser, loginUser.getPassword(), loginUser.getAuthorities());
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        }else {
            // 没有accessToken清空掉authentication，不让访问受限资源
            SecurityContextHolder.getContext().setAuthentication(null);
        }
        // 不管有没有登录，后面的【UsernamePasswordAuthenticationFilter】会进行权限判断，也直接放过
        filterChain.doFilter(request, response);
    }
}

【UserRepository.java】

package com.chz.mySpringSecurity.repository;

import com.chz.mySpringSecurity.entity.User;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import java.util.concurrent.ConcurrentHashMap;

public class UserRepository 
{
    // 这个用于模拟数据库里面的可登录用户的信息
    public static ConcurrentHashMap<String, User> users = new ConcurrentHashMap<>();

    static {
        //
        User user = new User();
        user.setUserName("user");
        user.setPassword(new BCryptPasswordEncoder().encode("123"));
        users.put(user.getUserName(), user);
        //
        User admin = new User();
        admin.setUserName("admin");
        admin.setPassword(new BCryptPasswordEncoder().encode("456"));
        users.put(admin.getUserName(), admin);
    }
}

【UserDetailsServiceImpl.java】

package com.chz.mySpringSecurity.service;

import com.chz.mySpringSecurity.entity.LoginUser;
import com.chz.mySpringSecurity.entity.User;
import com.chz.mySpringSecurity.repository.UserRepository;
import lombok.extern.slf4j.Slf4j;
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;

@Slf4j
@Service
public class UserDetailsServiceImpl implements UserDetailsService
{
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException
    {
        log.info("chz >>> UserDetailsServiceImpl.loadUserByUsername(): username={}", username);
        User user = UserRepository.users.get(username);
        if( user==null ){
            throw new UsernameNotFoundException("用户名不存在");
        }

        LoginUser loginUser = new LoginUser(user);
        loginUser.addAuthority("chz_role1");
        return loginUser;
    }
}

【MySpringSecurityMain.java】

package com.chz.mySpringSecurity;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;

@EnableGlobalMethodSecurity(prePostEnabled = true)
@SpringBootApplication
public class MySpringSecurityMain
{
    public static void main(String[] args)
    {
        SpringApplication.run(MySpringSecurityMain.class, args);
    }
}

运行【MySpringSecurityMain】。

访问【http://localhost:8080/security/hello】 ，可以看到被重定向到登录页面【http://localhost:8080/security/login】
在这里插入图片描述

用户名输入【user】，密码输入【123】，点击【Sign In】登录。
在这里插入图片描述
可以得到一个【accessToken】=【8496842402128172477】
再次访问【http://localhost:8080/security/hello】，可以看到虽然已经登录成功了，但还是被重定向到了登录页面【http://localhost:8080/security/login】。
这是因为【url】里面没有带上【accessToken】，【AccessTokenFilter】自动将用户的登录信息清除了。
带上accessToken再试试试访问【http://localhost:8080/security/hello?accessToken=848234722712551727】
在这里插入图片描述
可以看到访问成功了。

陈鸿圳
关注
  • 23
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring-boot-security-basic-demo:spring-boot-security的基础功能例子
06-24
Spring Boot Security是一个强大的工具，用于在Spring Boot应用中轻松实现安全控制。这个"spring-boot-security-basic-demo"项目是...该项目是Java开发者的宝贵资源，可以帮助他们快速掌握Spring Security的基础知识。
spring-security-login:SpringBoot-整合SpringSecurity实现登入登出简单例子
05-25
SpringBoot整合SpringSecurity简单实现登入登出从零搭建这是SpringSecurity实现登录和登出的一个简单示例，基于 Spring Boot 1.5.6基本实现 : 用户信息存储在数据库中,登陆时从数据库中查询匹配用户信息。...
Spring Security（2）案例：包含spring-security.xml等配置
учёба
11-08 998
底层是基于过滤器的 第一步：工程搭建 创建maven工程，打包方式为war <!-- Spring --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version&gt
java学习笔记(二)：Spring-security的Remember-me配置，以及配置Session管理器防止Session fixation
fuermoda的博客
12-18 645
java学习笔记(二)：Spring-security的Remember-me配置，以及配置Session管理器防止Session fixation Remember-me配置 今天在完善自己毕设的登录操作时，想为我的登录弄一个记住我的选项，能够使我短时间内可以免登录。好在Spring-security封装好了这个功能，我们只要调用就好。而这个功能在Spring-security有两种实现方式：1）将登录信息发送给浏览器以Cookie的方式存储，登录的时候进行验证拿出Cookie来进行比较。2）将登录信息
spring-cloud-starter-security和spring-cloud-starter-oauth2
热门推荐
qq_30359369的博客
12-02 2万+
之前学过spring-security,最近又在学习spring-cloud-starter-security和spring-cloud-starter-oauth2, 脑子里顿时冒出一个问题: 之前学的spring-security和最近学的spring-cloud-starter-security有什么关系, spring-cloud-starter-security和spring-clou......
spring-security
migo_的专栏
02-25 1226
Spring Security是一个框架，致力于为Java应用程序提供身份验证和授权。像所有Spring项目一样，Spring Security的真正强大之处在于它可以轻松扩展以满足定制需求的能力。Spring Security是Spring采用 `AOP`思想，基于 `servlet过滤器`实现的安全框架。它提供了完善的认证机制和方法级的授权功能。Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它是用于保护基于Spring的应用程序的事实上的标准。
snsjava源码-tech-talk-spring-oauth2-wechat-mp:spring-cloud-security与微信MP的
06-18
简单示例演示如何使用spring-cloud-security配置微信公众号平台的网页认证 说明 因为微信公众号的oauth过程不复合标准, 比如client_id变成了appid等 如果不想麻烦配置spring-oauth2, 可以使用weixin-java-mp自己处理...
spring-Security简单例子
05-22
这个"spring-Security简单例子"旨在展示如何在项目中配置和使用Spring Security进行用户登录和访问权限控制的基本操作。下面将详细阐述Spring Security的核心概念、配置步骤以及实现原理。 1. **核心概念** - **...
spring-security_examples:Spring 安全示例
06-18
Spring Security 是一个强大的和高度可定制的身份验证和访问控制框架，用于保护 Java 应用程序。这个名为 "spring-security_examples" 的项目是为了演示和测试 Spring Security 的各种功能而创建的。下面将详细介绍 ...
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1240
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 511
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
ShardingSphere
Casual_Lei的博客
07-04 634
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 313
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
如何使用缓存提升SpringBoot性能（EhCache和Redis方式）
三两肉的博客
07-03 1009
缓存是指将文件或数据的副本存储在缓存或临时存储位置中，以便未来对该数据的请求可以更快地提供服务。当从存储中检索数据时，会在缓存中创建该数据的副本。如果再次需要该数据，可以从缓存中比从主存储器中更快地检索到该数据，主存储器可能涉及复杂的计算或较慢的访问速度。如何使用缓存提升SpringBoot性能（EhCache和Redis方式）
maven配置使用nexus仓库
ApexPredator的博客
07-03 212
maven配置使用nexus仓库
图片压缩代码和实际操作页面
最新发布
英雄汉孑的博客
07-05 904
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
JavaSE阶段面试题（一）
tq02的博客
07-03 597
本章节主要讲述SE阶段的常见面试题
返回值处理器器【Spring源码学习】
weixin_44794897的博客
07-05 236
定义返回值类型处理器的组合；测试使用的controller测试方法。
spring-security 配置放行资源
06-08
在 Spring Security 中，可以使用 `WebSecurity` 配置类来定义安全策略和访问控制列表。如果需要放行某些资源，可以使用 `WebSecurity` 的 `ignoring()` 方法来配置忽略的资源。 以下是一个示例配置，将 `/resources/**` 和 `/public/**` 路径下的资源放行： ```java @Configuration @EnableWebSecurity public class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Override public void configure(WebSecurity web) throws Exception { web.ignoring().antMatchers("/resources/**", "/public/**"); } //其他配置... } ``` 在这个例子中，`WebSecurity` 的 `ignoring()` 方法接受一个 `AntPathRequestMatcher` 对象或者多个 `String` 类型的 ant-style 路径模式。`AntPathRequestMatcher` 对象可以指定更复杂的匹配规则，例如使用 HTTP 方法、请求参数等。如果需要放行更多的资源，可以在 `ignoring()` 方法中添加更多的 ant-style 路径模式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈鸿圳

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值