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

已于 2023-09-19 17:30:49 修改
阅读量205 收藏
点赞数
文章标签： 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
    评论
OAuth 2 实现简单登录授权
zouyang920的博客
01-04 3070
1.OAuth2.0 进阶 根据官方标准，OAuth 2.0 共用四种授权模式： Authorization Code: 用在服务端应用之间，这种最复杂，也是本文采用的模式； Implicit: 用在移动app或者webapp(这些app是在用户的设备上的，如在手机上调起微信来进行认证授权) Resource Owner Password Credentials(password): 应用直接都是受信任的(都是由一家公司开发的，本例子使用) Client Credentials: 用在应用API访问。
SpringBoot整合OAuth2.0看完你就会了！
qq_41826150的博客
08-05 5186
OAuth 2.0是一种开放的授权协议，它允许用户授权第三方应用访问其账户（或资源），而无需共享其用户账户凭据。在Spring Boot中，我们可以使用Spring Security的OAuth2.0模块来实现授权验证。
SpringBoot搭建OAuth2
最新发布
m0_60681411的博客
05-28 1513
本文描述了通过SpringBoot从无到有的搭建OAuth2服务器的一系列实践过程。其中包括OAuth2的授权方式介绍，测试场景，过程中遇到的困难等，对新接触OAuth2的人有较大帮助。
SpringBoot集成Oauth2.0（密码模式）
m0_71817461的博客
07-03 4064
SpringBoot集成Oauth2.0（密码模式）
SpringSecurity(二十四）--OAuth2:使用JWT和加密签名(下）非对称密钥加密
学习不止境的博客
12-30 2107
由于上文对称密钥涉及到的内容比较多，所以这一节的非对称密钥加密拆开成这一节单独讲解。 所以大家尽量先阅读完上一章的内容后再浏览这一章内容会更好。本节将实现OAuth2身份验证的一个示例，其中授权服务器和资源服务器会使用一个非对称密钥对来对令牌签名和验证令牌。有时只让授权服务器和资源服务器共享一个密钥的做法是不可行的。通常，如果授权服务器和资源服务器不是由同一组织开发的，就会发生这种情况。在这种情况下，就可以认为授权服务器不“信任：资源服务器，因此我们不希望授权服务器与资源服务器共享密钥。而且，使用对称密钥，
SpringBoot整合OAuth 2.0
xjj1040249553的专栏
08-20 2705
OAuth 2.0为OAuth的协议的延续版本，是一个关于授权的开放网络标准，在全世界得到广泛应用。基于OAuth 2.0授权有一下几个特点：1、安全：平台商无需使用用户的用户名与密码就可以申请获得该用户资源的授权；2、开放：任何消费方都可以使用 OAuth 认证服务，任何服务提供方 ( Service Provider) 都可以实现自身的 OAuth 认证服务。3、简单：不管是消费方还是服务提供...
基于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是一个授权框架，允许第三方应用在用户授权的情况下访问其受保护的资源，而...
SpringBoot OAuth2.0认证管理流程详解
u012477420的博客
12-12 1万+
OAuth2.0是一个开放的授权协议，可以用来实现第三方应用对我们API的访问控制，OAuth2.0中定义的角色包括: 1) Resource Owner(资源拥有者) 2) Client (第三方接入平台，请求者) 3) Resource Server (服务器资源: 数据中心) 4) Authorization Server (认证服务器) 授权认证的基本流程包括: 首先Client需要向Resource Ow......
SpringBoot整合OAuth2
xwnxwn的专栏
10-03 2066
资源拥有者扫描二维码表示资源拥有者同意给客户端授权，微信会对资源拥有者的身份进行验证， 验证通过后，微信会询问用户是否给授权黑马程序员访问自己的微信数据，用户点击“确认登录”表示同意授权，微信认证服务器会颁发一个授权码，并重定向到黑马程序员的网站。完全是A服务与B服务内部的交互，与用户无关了。第一步：【A服务客户端】将用户自动导航到【B服务认证服务】，这一步用户需要提供一个回调地址，以备【B服务认证服务】返回token使用，还会携带一个【A服务客户端】的状态标识state。
springboot整合springsecurity+oauth2.0密码授权模式
qq_45072555的博客
01-15 6972
本文采用的springboot去整合springsecurity，采用oauth2.0授权认证，使用jwt对token增强。本文仅为学习记录，如有不足多谢提出。
SpringBoot 整合 Oauth2.0
weixin_43727535的博客
12-14 1627
SpringBoot 整合 Oauth2.0 Oauth2.0 简介 OAuth2.0是OAuth协议的延续版本，但不向前兼容OAuth 1.0(即完全废止了OAuth1.0)。 OAuth 2.0关注客户端开发者的简易性。要么通过组织在资源拥有者和HTTP服务商之间的被批准的交互动作代表用户，要么允许第三方应用代表用户获得访问的权限。同时为Web应用，桌面应用和手机，和起居室设备提供专门的认证流...
Spring Boot 最新版3.x 集成 OAuth 2.0实现认证授权服务、第三方应用客户端以及资源服务
热门推荐
太空眼睛的专栏
02-05 1万+
Spring Boot 3已经发布一段时间，网上关于Spring Boot 3的资料不是很多，本着对新技术的热情，学习和研究了大量Spring Boot 3新功能和新特性，感兴趣的同学可以参考Spring官方资料全面详细的新功能/新改进介绍新特性有很多，本文主要针对OAuth 2.0的集成，如果快速开发自己的认证授权服务、OAuth客户端以及资源服务新建三个服务，分别对应认证授权服务、OAuth客户端以及资源服务Spring发布了spring-security-oauth2-authorization-se
SpringBoot集成OAuth2身份验证机制
禅与计算机程序设计艺术
08-01 2773
随着互联网技术的飞速发展、应用场景的多样化以及对安全性的需求越来越高，越来越多的人开始关注并实践“OAuth2”（开放授权）协议。在本文中，我将会通过对 Spring Boot 的集成 OAuth2 身份验证机制，来实现身份认证功能的支持。OAuth2 是一种授权框架协议，它为用户资源提供一个安全的访问通道，让用户可以分享他/她的账号信息给第三方应用或者网站，而不用暴露自己的密码等敏感信息。
【springboot】OAuth2（安全框架）
GodFatherMisZhao的博客
03-04 1199
springboot集成OAuth2
springsecurity oauth2.0 springboot整合 spring security自定义登录页面5
健康平安的活着的专栏
08-08 4021
一 自定义认证页面 1.1 说明 1. 如果用户没有自定义登录页面，spring security 默认会启动自身内部的登录页面，尽管自动生成的登录页面很方便 快速启动和运行，但大多数应用程序都希望定义自己的登录页面。 1.2 自定义登录页面 在新建一个webapp目录，和resouces目录，平级，将login.jsp页面考配到这个页面下 页面代码： <%@ page contentType="text/html;charset=UTF-8" pageEncoding="utf-.
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、付费专栏及课程。

余额充值