基于Springboot、Oauth2.0、JWT、封装登录签名基本业务模型

已于 2023-09-19 17:30:49 修改
阅读量215 收藏
点赞数
文章标签： spring boot 后端 java
于 2023-09-19 16:43:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/testTop/article/details/133034200
版权


底部附源码地址

功能介绍

  1.  集成验证码登录认证
  2. 加入密码输入错误次数超过限制次数，锁定账号
  3.  加入用户登录日志
  4.  基于Oauth2协议的密码登录和token刷新

项目结构

一个公共模块、一个sso模块、可以新加项目增加自己的业务模块

服务搭建

父级引入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>

    <groupId>com.yx</groupId>
    <artifactId>auth-platform</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>auth-common</module>
        <module>auth-sso</module>
    </modules>
    <name>auth-platform</name>
    <description>登录认证系统</description>

    <properties>
        <fast.version>1.0.0</fast.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
        <druid.version>1.2.16</druid.version>
        <bitwalker.version>1.21</bitwalker.version>
        <swagger.version>3.0.0</swagger.version>
        <kaptcha.version>2.3.3</kaptcha.version>
        <fastjson.version>2.0.39</fastjson.version>
        <oshi.version>6.4.4</oshi.version>
        <commons.io.version>2.13.0</commons.io.version>
        <commons.collections.version>3.2.2</commons.collections.version>
        <poi.version>4.1.2</poi.version>
        <velocity.version>2.3</velocity.version>
        <jwt.version>0.9.1</jwt.version>
        <mybatis-plus.version>3.5.2</mybatis-plus.version>
        <lombok.version>1.18.10</lombok.version>
        <hutool.version>5.1.0</hutool.version>
        <redisson.version>3.11.0</redisson.version>
        <spring-boot-version>2.5.15</spring-boot-version>
        <oauth2.version>2.2.6.RELEASE</oauth2.version>
    </properties>

    <!-- 依赖声明 -->
    <dependencyManagement>
        <dependencies>
            <!-- SpringBoot的依赖配置-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- 阿里数据库连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>${druid.version}</version>
            </dependency>

            <dependency>
                <groupId>org.springframework.security.oauth.boot</groupId>
                <artifactId>spring-security-oauth2-autoconfigure</artifactId>
                <version>${oauth2.version}</version>
            </dependency>

            <!--工具包-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>${hutool.version}</version>
            </dependency>

            <!-- io常用工具类 -->
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons.io.version}</version>
            </dependency>

            <!-- collections工具类 -->
            <dependency>
                <groupId>commons-collections</groupId>
                <artifactId>commons-collections</artifactId>
                <version>${commons.collections.version}</version>
            </dependency>

            <!-- 阿里JSON解析器 -->
            <dependency>
                <groupId>com.alibaba.fastjson2</groupId>
                <artifactId>fastjson2</artifactId>
                <version>${fastjson.version}</version>
            </dependency>

            <!-- Token生成与解析-->
            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>${jwt.version}</version>
            </dependency>
            <!-- 解析客户端操作系统、浏览器等 -->
            <dependency>
                <groupId>eu.bitwalker</groupId>
                <artifactId>UserAgentUtils</artifactId>
                <version>${bitwalker.version}</version>
            </dependency>
            <!-- 验证码 -->
            <dependency>
                <groupId>pro.fessional</groupId>
                <artifactId>kaptcha</artifactId>
                <version>${kaptcha.version}</version>
            </dependency>

            <!-- 公共模块-->
            <dependency>
                <groupId>com.yx</groupId>
                <artifactId>auth-common</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
            <!-- 认证模块-->
            <dependency>
                <groupId>com.yx</groupId>
                <artifactId>auth-sso</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
        </dependencies>
    </dependencyManagement>



    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <!--依赖下载仓库地址-->
    <repositories>
        <repository>
            <id>public</id>
            <name>ali  nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>public</id>
            <name>ali  nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

公共模块pom依赖

<!-- Spring框架基本的核心工具 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--常用工具类 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!--工具包-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
        </dependency>
        <!-- 阿里JSON解析器 -->
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
        </dependency>
        <!-- JSON工具类 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.10.1</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.1-android</version>
        </dependency>

        <!-- redis 缓存操作 -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>${redisson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

        <!-- Mysql驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

SSO模块pom依赖

<!-- SpringBoot Web容器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- SpringBoot 拦截器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <!-- Auth2.0-->
        <dependency>
            <groupId>org.springframework.security.oauth.boot</groupId>
            <artifactId>spring-security-oauth2-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>eu.bitwalker</groupId>
            <artifactId>UserAgentUtils</artifactId>
        </dependency>
        <!-- 阿里JSON解析器 -->
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
        </dependency>
        <!-- 验证码 -->
        <dependency>
            <groupId>pro.fessional</groupId>
            <artifactId>kaptcha</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>servlet-api</artifactId>
                    <groupId>javax.servlet</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- pool 对象池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!-- 阿里数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>
        <!-- 通用工具-->
        <dependency>
            <groupId>com.yx</groupId>
            <artifactId>auth-common</artifactId>
        </dependency>

核心配置类

JWT配置

package com.yx.config;

import com.yx.exception.MyWebResponseExceptionTranslator;
import com.yx.service.impl.MyUserDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.ClassPathResource;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.TokenEnhancer;
import org.springframework.security.oauth2.provider.token.TokenEnhancerChain;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
import org.springframework.security.oauth2.provider.token.store.KeyStoreKeyFactory;

import javax.sql.DataSource;
import java.util.Arrays;

/**
 * oauth2.0集成JWT
 * @author cyx
 *
 */
@Configuration
@EnableAuthorizationServer
public class JwtAuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private DataSource dataSource;
    
    @Autowired
    private AuthenticationManager authenticationManager;
    
    @Autowired
    private TokenEnhancer jwtTokenEnhancer;
    
    @Autowired
    private JwtAccessTokenConverter jwtAccessTokenConverter;

    @Autowired
    MyUserDetailsService myUserDetailsService;
    

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        // 让/oauth/token支持client_id以及client_secret作登录认证
        // 请求/oauth/token的，如果配置支持allowFormAuthenticationForClients的，且url中有client_id和client_secret的会走ClientCredentialsTokenEndpointFilter
        security.allowFormAuthenticationForClients();
        security.checkTokenAccess("permitAll()");
        security.tokenKeyAccess("permitAll()");
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.jdbc(dataSource);
    }

    @Override//
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenStore(jwtTokenStore());
        //设置RefreshTokens为不复用,  true:复用是指每次刷新生成的refreshToken的jti不变，所以过期时间使用的还是第一次生成refreshToken的过期时间
        //false:不复用是每次都生成新的jti,新的过期时间
        endpoints.reuseRefreshTokens(false);
		//指定认证管理器
		endpoints.authenticationManager(authenticationManager);

		TokenEnhancerChain enhancerChain = new TokenEnhancerChain();
        enhancerChain.setTokenEnhancers(Arrays.asList(jwtTokenEnhancer,jwtAccessTokenConverter));
    	endpoints.tokenEnhancer(enhancerChain);
    	endpoints.accessTokenConverter(jwtAccessTokenConverter);
    	// 转换异常信息
    	endpoints.exceptionTranslator(new MyWebResponseExceptionTranslator<>());
    	//增强token 包含用户信息
        endpoints.userDetailsService(myUserDetailsService);

    }
    
    @Primary
    @Bean
    public DefaultTokenServices tokenServices() {
    	DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
    	defaultTokenServices.setTokenStore(jwtTokenStore());
    	defaultTokenServices.setSupportRefreshToken(true);
    	TokenEnhancerChain enhancerChain = new TokenEnhancerChain();
        enhancerChain.setTokenEnhancers(Arrays.asList(jwtTokenEnhancer,jwtAccessTokenConverter));
    	defaultTokenServices.setTokenEnhancer(enhancerChain);
        return defaultTokenServices;
    }

    


    /**
     * JWT token 转换器
     * @return
     */
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter jatc = new JwtAccessTokenConverter();
        KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(new ClassPathResource("oauth2.jks"), "LwABFa2JEJR3ezNG".toCharArray());
        jatc.setKeyPair(keyStoreKeyFactory.getKeyPair("oauth2"));
        return jatc;
    }

    /**
     * JWT token Store配置
     * @return
     */
    @Bean
    public JwtTokenStore jwtTokenStore() {
        return new JwtTokenStore(jwtAccessTokenConverter());
    }

    /**
     * 自定义的Token增强器，把更多信息放入Token中
     * @return
     */
    @Bean
    public TokenEnhancer jwtTokenEnhancer(){
        return new JwtTokenEnhancer();
    }
}

JWT增强

package com.yx.config;

import com.yx.constant.Constants;
import com.yx.model.UserInfo;
import com.yx.manager.AsyncManager;
import com.yx.manager.factory.AsyncFactory;
import com.yx.model.MyUser;
import com.yx.service.impl.SysPasswordService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.oauth2.common.DefaultOAuth2AccessToken;
import org.springframework.security.oauth2.common.OAuth2AccessToken;
import org.springframework.security.oauth2.provider.OAuth2Authentication;
import org.springframework.security.oauth2.provider.token.TokenEnhancer;

import java.util.HashMap;
import java.util.Map;

/**
 * 扩展JWT附加信息
 * @author cyx
 *
 */
public class JwtTokenEnhancer implements TokenEnhancer {

	@Autowired
	private SysPasswordService sysPasswordService;

	@Override
	public OAuth2AccessToken enhance(OAuth2AccessToken accessToken, OAuth2Authentication authentication) {
		MyUser user = (MyUser)authentication.getUserAuthentication().getPrincipal();
		UserInfo userInfo = user.getUserInfo();
		Map<String,Object> info = new HashMap<>(16);
		info.put("username" , userInfo.getUsername());
		info.put("nickname", userInfo.getNickname());
		info.put("id",userInfo.getId());
        //设置附加信息
        ((DefaultOAuth2AccessToken)accessToken).setAdditionalInformation(info);
        //记录登录日志
		AsyncManager.me().execute(AsyncFactory.recordLoginInfo(userInfo.getUsername(), Constants.LOGIN_SUCCESS, "登录成功"));
		//登录成功，清除错误日志缓存
		sysPasswordService.clearLoginRecordCache(userInfo.getUsername());
		return accessToken;
	}

}

密码错误次数限制

package com.yx.config;

import com.yx.execption.ErrorCodeEnum;
import com.yx.service.impl.SysPasswordService;
import com.yx.utils.SpringUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.stereotype.Component;
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 LoginRetryCountFilter extends OncePerRequestFilter {


    @Autowired
    private CustomAuthenticationFailureHandler customAuthenticationFailureHandler;


    private final static String OAUTH_TOKEN_URL = "/oauth/token";

    @Override
    public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        if (request.getServletPath().equals(OAUTH_TOKEN_URL) &&
                StringUtils.equalsAnyIgnoreCase(request.getMethod(), "post")) {
            String username = request.getParameter("username");
            SysPasswordService passwordService = SpringUtils.getBean("sysPasswordService");
            if (passwordService.isLock(username)) {
                customAuthenticationFailureHandler.onAuthenticationFailure(request, response, new BadCredentialsException(ErrorCodeEnum.USER_PASSWORD_MAX_RETRY_COUNT.getMessage()));
                return;
            }
        }
        // 无异常即校验成功，放行。
        filterChain.doFilter(request, response);
    }
}

验证码校验

package com.yx.config;

import com.yx.constant.CacheConstants;
import com.yx.constant.Constants;
import com.yx.execption.ErrorCodeEnum;
import com.yx.manager.AsyncManager;
import com.yx.manager.factory.AsyncFactory;
import org.apache.commons.lang3.StringUtils;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.stereotype.Component;
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;

@Component
public class ValidateCodeFilter extends OncePerRequestFilter {

    private static final Logger logger = LoggerFactory.getLogger("sys-user");
    @Autowired
    private RedissonClient redissonClient;

    private final static String OAUTH_TOKEN_URL = "/oauth/token";

    private final static String REFRESH_TOKEN = "refresh_token";

    @Value("${sys.account.captchaEnabled:false}")
    private boolean enabled;

    @Autowired
    private CustomAuthenticationFailureHandler customAuthenticationFailureHandler;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        // authentication/form是认证时的请求接口，验证码校验只需要匹配这个接口即可
        if (request.getServletPath().equals(OAUTH_TOKEN_URL) &&
                StringUtils.equalsAnyIgnoreCase(request.getMethod(), HttpMethod.POST.toString())) {

            String grantType = request.getParameter("grant_type");
            //如果是刷新token,则不需要校验验证码
            if (!REFRESH_TOKEN.equals(grantType)) {
                //获取验证码开关
                if (enabled) {
                    // 从redis中获取验证码
                    String id = request.getParameter("id");
                    // 从客户端接收到的验证码
                    String captchaParam = request.getParameter("code");
                    if (StringUtils.isEmpty(id)) {
                        customAuthenticationFailureHandler.onAuthenticationFailure(request, response, new BadCredentialsException("缺少必要的参数"));
                        return;
                    }
                    if (StringUtils.isEmpty(captchaParam)) {
                        customAuthenticationFailureHandler.onAuthenticationFailure(request, response, new BadCredentialsException(ErrorCodeEnum.CAPTCHA_NULL_EXCEPTION.getMessage()));
                        return;
                    }
                    //获取验证码
                    RBucket<String> bucket = redissonClient.getBucket(CacheConstants.CAPTCHA_CODE_KEY + id);
                    String code = bucket.get();
                    logger.debug("登录获取验证码：key:{},code:{}", id, code);
                    if (!StringUtils.equalsAnyIgnoreCase(captchaParam, code)) {
                        customAuthenticationFailureHandler.onAuthenticationFailure(request, response, new BadCredentialsException(ErrorCodeEnum.CAPTCHA_ERROR_EXCEPTION.getMessage()));
                        AsyncManager.me().execute(AsyncFactory.recordLoginInfo(request.getParameter("username"), Constants.LOGIN_FAIL, "验证码错误"));
                        return;
                    }
                }
            }
        }
        // 无异常即校验成功，放行。
        filterChain.doFilter(request, response);
    }
}

请求案例

通过密码模式获取令牌

http://localhost:9091/oauth/token?password=admin123&grant_type=password&client_id=pda_client&client_secret=user123&captcha=123&id=fb400c0b672c4be39b8c422edb2f801&username=admin2


刷新Token

http://localhost:9091/oauth/token?grant_type=refresh_token&client_id=pda_client&client_secret=user123&refresh_token=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX25hbWUiOiJhZG1pbjIiLCJzY29wZSI6WyJhbGwiXSwiYXRpIjoiNDUxN2NlNTUtNWNjNS00ODI5LWJkM2QtOWM4NjJkMWE0OTcyIiwibmlja25hbWUiOiJhZG1pbiIsImlkIjoyLCJleHAiOjE2OTc3MDA3MTEsImp0aSI6IjQyYjU2ZDhlLTViMGMtNDA4Mi1hODFmLWMzMDBhOWI5YjkzZCIsImNsaWVudF9pZCI6InBkYV9jbGllbnQiLCJ1c2VybmFtZSI6ImFkbWluMiJ9.D1xjWEuhtoCKpMBJKjauBBvYRBIBmOx3ItckyDns5qIOf_sUTNDtSgGlQ-4kCfIBBDSD23g4sTw2mvkMB5Ur3w

不足之处多多指教

Gitee项目地址

还有什么常见的功能。欢迎留下宝贵意见！

一条鱼·
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Security OAuth2.0认证授权知识概括
weixin_41005188的博客
03-31 3294
Spring Security OAuth2.0认证授权知识概括安全框架基本概念基于Session的认证方式Spring SecuritySpringSecurity应用详解 安全框架基本概念 什么是认证： 进入移动互联网时代，大家每天都在刷手机，常用的软件有微信、支付宝、头条等，下边拿微信来举例子说明认证相关的基本概念，在初次使用微信前需要注册成为微信用户，然后输入账号和密码即可登录微信，输入账号和密码 登录微信的过程就是认证。 系统为什么要认证？ ①认证是为了保护系统的隐私数据与资源，用户的身份合法方
Spring Security OAuth2.0认证授权 --- 基础篇
shuai_h的博客
06-19 902
一、基本概念 1.1、什么是认证 进入移动互联网时代，大家每天都在刷手机，常用的软件有微信、支付宝、头条等，下边拿微信来举例子说明认证相关的基本概念，在初次使用微信前需要注册成为微信用户，然后输入账号和密码即可登录微信，输入账号和密码登录微信的过程就是认证。 系统为什么要认证？ 认证是为了保护系统的隐私数据与资源，用户的身份合法方可访问该系统的资源。 认证 ：用户认证就是判断一个用户的身份是否合法的过程，用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问，不合法则拒绝访问。常见的用户身份认
SpringSecurity的使用以及集成JWT、OAuth2.0实现单点登录
prefect_start的博客
07-08 2164
SpringSecurity 框架的介绍以及使用、配合JWT实现分布式权限方案
教程：在Spring Boot应用中集成OAuth 2.0认证
省赚客开发者博客
06-27 1113
通过本教程，我们学习了如何在Spring Boot应用中集成和使用OAuth 2.0认证。从添加依赖、配置OAuth 2.0客户端信息，到配置Spring Security和创建控制器处理认证后的回调，这些步骤帮助开发者快速实现安全的认证机制，并保护应用程序的资源。
鉴权 OAuth 2.0的实现（Spring_Security_Oauth2）
qq_25156781的博客
01-28 2596
可以理解为客户端和服务器之间的一次私密谈话，在一次对话中可能会有多个请求和响应；同时要具有鉴别多个请求是来自同一个客户端的一次对话的功能；用户认证通过后，为了避免用户的每次操作都进行认证，可将用户的信息保证在会话中。会话就是系统为了保持当前用户的登录状态所提供的机制，常见的有基于session方式、基于token方式等。
Spring Security OAuth2.0认证授权
欢迎来到编程小栈
12-09 1135
文章目录1、基本概念1.1.什么是认证1.2 什么是会话1.3什么是授权1.4授权的数据模型1.4 RBAC1.4.1 基于角色的访问控制2、基于Session的认证方式3、整合案例3.1 SpringMVC+Servlet3.0模拟认证、会话、授权3.1.1引入依赖3.1.2 Spring 容器配置ApplicationConfig3.1.3 servletContext配置 WebConfig3.1.4 加载 Spring容器SpringApplicationInitializer3.1.5实现认证功能
Spring Security OAuth2.0 - 学习笔记
瞅你咋滴。
07-24 780
Spring Security是解决安全访问控制的问题，就是认证和授权。Spring Security的重点是对所有进入系统的请求进行拦截，校验每个请求是否能够访问所期望的资源，对web资源的保护是通过Filter来实现的。当初始化Spring Security时，在org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration。
Spring Security 简单理解OAuth2.0
Life And Code
07-31 1911
文章目录1. 基本概念1.1 什么是认证1.2 什么是会话1.3 什么是授权1.4 授权的数据模型1.5 RBAC1.5.1 基于角色的访问控制1.5.2 基于资源的访问控制2. 基于Session的认证方式2.1 认证流程2.2 创建工程2.3 实现认证功能2.3.1 认证页面2.3.2 认证接口2.4 实现会话功能2.5 实现授权功能3. Spring Security快速上手3.1 Spring Security介绍3.2 创建工程3.3 认证3.3.1 认证页面3.3.2 安全配置3.3.3 Spr
OAuth2在开源SpringBoot/SpringCloud微服务框架的最佳实践
编码之旅
06-20 1510
1.结合多年项目经验，介绍了Java开源微服务解决方案的OAuth2服务的权限分离设计思路及实现； 2.JwtToken是权限分离的非常好的载体，重点阐述了如何对spring-authorization-server/spring-security-oauth2-authorization-server框架做扩展，目的是实现基于接口/web页面账号密码认证的统一JwtToken和刷新JwtToken，既可以用作接口鉴权，又可以达成会话管理的效果，这样开源的认证服务就可以通用于各种业务场景，减少代码开发的工作
SpringBoot+OAuth2+Spring Security+Redis+mybatis-plus+mysql+swagger搭建实现
lucky_fang的博客
11-07 4496
SpringBoot+OAuth2+Spring Security+Redis+mybatis-plus+mysql+swagger搭建实现
基于springboot+oauth2.0+jwtToken鉴权认证开发的后台接口，整套架构采用restful风格，车牌识别，阿里云消息推送，短信接口等
04-04
内容只为接口开发，配合前端和移动app调用使用，不包含html页面，基于springboot+oauth2.0+jwttoken鉴权（内有怎么使用redistoken和数据库token注释）+restful风格+阿里短信+阿里消息推送+车牌识别等。该项目为工作...
springboot OAuth2.0-demo
12-17
在"springboot OAuth2.0-demo"这个项目中，开发者已经实现了一个简单的OAuth2.0授权流程的示例。这个项目可能包含以下组件： - `AuthorizationServerConfig`：配置OAuth2.0授权服务器，定义令牌策略和范围。 - `...
使用Springboot搭建OAuth2.0 Server的方法示例
08-27
使用 Springboot 搭建 OAuth2.0 Server 需要了解 OAuth2.0 的设计思路和运行流程，熟悉 Spring Boot 和 Spring Security 的基本概念，掌握 pom.xml 文件的管理依赖关系，并编写实现授权服务提供方的逻辑。
基于springboot2.x的Oauth2.0一键授权登录和微信网页扫码支付测试开发案例(含源码)
08-25
使用idea开发工具，基于springboot2.x、jwt鉴权、nginx集群，前后端分离的微信Oauth2.0一键登录和微信网页扫码支付测试开发demo
springboot集成oauth2.0
07-27
SpringBoot集成OAuth2.0是将流行的OAuth2.0安全框架与SpringBoot应用程序相结合的过程，以便为API和Web应用提供安全的访问控制。OAuth2.0是一个授权框架，允许第三方应用在用户授权的情况下访问其受保护的资源，而...
Spring Boot组成的分布式系统中实现日志跟踪
最新发布
心猿意码
07-25 455
除了使用Sleuth和Zipkin之外，我们还可以自定义日志输出格式，以便更容易地识别请求的追踪信息。Xml深色版本1通过使用Spring Cloud Sleuth和Zipkin，我们可以轻松地为Spring Boot应用实现日志跟踪。这种方式不仅简化了日志跟踪的实现，还提供了强大的可视化工具，帮助我们更好地理解和调试分布式系统。此外，通过自定义日志输出格式和使用MDC，我们可以进一步定制日志以适应特定的需求。
Spring Boot 项目中使用事件发布和监听来实现消息推送和处理
servepeople的博客
07-23 583
首先，定义一个事件类，该类继承自import org} }} }
在Spring Boot中实现文件上传与管理
微赚淘客开发者博客
07-20 1536
在现代应用程序中，文件上传与管理是一个常见的需求。在 Spring Boot 中，可以非常方便地实现文件上传和管理。本文将详细介绍如何在 Spring Boot 中实现文件上传功能，包括创建上传接口、文件存储、文件访问等方面的内容。通过配置文件上传、创建文件上传、下载、列表和删除接口，我们可以轻松地处理文件操作。这个 HTML 文件提供了一个简单的文件上传表单，用户可以选择文件并提交上传请求。中添加相关的依赖，以支持文件上传功能。接下来，我们创建一个文件上传的控制器，处理文件上传请求。作为文件上传的对象。
springboot oauth2.0单点登录
06-06
在诸如Spring Boot之类的Web框架中，OAuth2.0往往被用于实现单点登录（SSO）功能。 SSO是指用户只需使用一组凭据（如用户名和密码）来访问多个关联的应用程序，而不需要多次进行身份验证。通过集成OAuth2.0，Spring...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值