oauth2-客户端模式案例-6ren

oauth2-客户端模式案例

转载作者：知者更新时间：2024-03-13 02:13:32

1.项目结构

2.搭建授权服务器(auth-server)

1.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yl</groupId>
    <artifactId>auth-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>auth-server</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-security</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>

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

    </dependencies>

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

</project>

2.application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name = com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root
spring.main.allow-bean-definition-overriding=true

# redis的配置
spring.redis.host=192.168.244.138
spring.redis.port=6379
spring.redis.password=root123
spring.redis.database=0

3.token的配置

package com.yl.authserver.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.InMemoryTokenStore;
import org.springframework.security.oauth2.provider.token.store.redis.RedisTokenStore;

// Token暂时保存在内存中
@Configuration
public class AccessTokenConfig {
    //token存储方式一：存在内存中
//    @Bean
//    TokenStore tokenStore() {
//        return new InMemoryTokenStore();
//    }

    //token存储方式二：存在redis中，由于redis中，可以设置过期时间，所以在redis中存储token有一种天然的优势
    @Autowired
    RedisConnectionFactory redisConnectionFactory;
    @Bean
    TokenStore tokenStore() {
        return new RedisTokenStore(redisConnectionFactory);
    }
}

4.security的配置

package com.yl.authserver.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

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

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("admin")
                .password(passwordEncoder().encode("123"))
                .roles("admin")
                .and()
                .withUser("root")
                .password(passwordEncoder().encode("123"))
                .roles("root");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable().formLogin();
    }
}

5.授权服务器的配置

package com.yl.authserver.config;

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.crypto.password.PasswordEncoder;
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.ClientDetailsService;
import org.springframework.security.oauth2.provider.client.JdbcClientDetailsService;
import org.springframework.security.oauth2.provider.code.AuthorizationCodeServices;
import org.springframework.security.oauth2.provider.code.InMemoryAuthorizationCodeServices;
import org.springframework.security.oauth2.provider.token.AuthorizationServerTokenServices;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.TokenStore;

import javax.sql.DataSource;

//配置授权服务器
@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    @Autowired
    TokenStore tokenStore;
    // 客户端信息
    @Autowired
    ClientDetailsService clientDetailsService;
    @Autowired
    PasswordEncoder passwordEncoder;
    @Autowired
    AuthenticationManager authenticationManager;
//    @Autowired
//    DataSource dataSource;
//
//    @Bean
//    ClientDetailsService clientDetailsService() {
//        return new JdbcClientDetailsService(dataSource);
//    }

    //配置Token服务
    AuthorizationServerTokenServices authorizationServerTokenServices() {
        DefaultTokenServices tokenServices = new DefaultTokenServices();
        tokenServices.setClientDetailsService(clientDetailsService);
        tokenServices.setSupportRefreshToken(true);
        tokenServices.setAccessTokenValiditySeconds(60 * 60 * 2); //token有限期设置为2小时
        tokenServices.setTokenStore(tokenStore);
        tokenServices.setRefreshTokenValiditySeconds(60 * 60 * 24 * 7);//
        return tokenServices;
    }

    //配置token
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security.checkTokenAccess("permitAll()")// /oauth/check_token   带时候会调用这个请求来校验token
                .checkTokenAccess("isAuthenticated()")
                .allowFormAuthenticationForClients();

    }

    //配置客户端的信息(客户端信息存于内存)
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("yl") //客户端名
                .secret(passwordEncoder.encode("123")) //客户端密码
                .scopes("all")
                .resourceIds("res1") //资源id
                .authorizedGrantTypes("authorization_code","refresh_token","implicit","password","client_credentials")
                // authorization_code授权码模式,password密码模式,implicit简化模式,client_credentials客户端模式,可以设置同时支持多种模式
                .autoApprove(true) //自动授权
//                .redirectUris("http://localhost:8082/index.html"); //授权码模式界面
//                .redirectUris("http://localhost:8082/01.html");//简化模式界面
                .redirectUris("http://localhost:8082/02.html");//密码模式界面
    }

//    //配置客户端的信息(客户端信息存于数据库)
//    @Override
//    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
//       clients.withClientDetails(clientDetailsService());
//    }

    //配置端点信息(主要获取授权码，要先拿到授权码，然后再根据授权码去获取token)
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.authorizationCodeServices(authorizationCodeServices())
                .authenticationManager(authenticationManager)
                .tokenServices(authorizationServerTokenServices());
    }

    @Bean
    AuthorizationCodeServices authorizationCodeServices() {
        return new InMemoryAuthorizationCodeServices();
    }
}

3.搭建资源服务器(user-server)

1.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yl</groupId>
    <artifactId>user-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>user-server</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-security</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

</project>

2.application.properties

server.port=8081

3.controller

package com.yl.userserver.controller;

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@CrossOrigin(value = "*")
public class HelloController {

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

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

4.资源服务器的配置

package com.yl.userserver.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.RemoteTokenServices;

//配置资源服务器
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    @Bean
    RemoteTokenServices remoteTokenServices() {
        RemoteTokenServices services = new RemoteTokenServices();
        services.setCheckTokenEndpointUrl("http://localhost:8080/oauth/check_token");
        services.setClientId("yl");
        services.setClientSecret("123");
        return services;
    }

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.resourceId("res1")
                .tokenServices(remoteTokenServices())
                .stateless(true);

    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**")
                .hasRole("admin")
                .anyRequest().authenticated()
                .and().cors();
    }
}

4.测试

1.启动redis
2.启动授权服务器和资源服务器

3.在client-app里的Test里测试

package com.yl.clientapp;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

@SpringBootTest
class ClientAppApplicationTests {
    @Autowired
    RestTemplate restTemplate;

    @Test
    void contextLoads() {
        MultiValueMap<String,String> map = new LinkedMultiValueMap<>();
        map.add("client_id","yl");
        map.add("grant_type","client_credentials");
        map.add("client_secret","123");
        //调用授权服务器接口，获取token
        Map resp = restTemplate.postForObject("http://localhost:8080/oauth/token", map, Map.class);
        HttpHeaders headers = new HttpHeaders();
        //传入token
        headers.add("Authorization","Bearer "+resp.get("access_token"));
        HttpEntity<Object> httpEntity = new HttpEntity<>(headers);
        //调用资源服务器获取资源
        ResponseEntity<String> entity = restTemplate.exchange("http://localhost:8081/hello", HttpMethod.GET, httpEntity, String.class);
        System.out.println(entity.getBody());
    }

}

4.结果可以看到能访问资源服务器的hello接口

文章推荐： leetcode中的python技巧

文章推荐： JavaScript 递归

文章推荐： C++：计算时间——时分秒

文章推荐： Spring读源码系列07----容器扩展功能--中

OAuth:OAuth 实现用例
我有一个 webapp，它使用 php 服务器和数据库服务器执行大量 ajax 请求。我还创建了一个 iPhone 应用程序和一个 Android 应用程序，直到现在它们一直作为离线应用程序工作。现
oauth - OAuth 线程安全吗？
OAuth 的访问 token /刷新 token 流对我来说似乎非常不安全。帮助我更好地理解它。假设我正在与利用 OAuth 的 API 集成(如 this one )。我有我的访问 token
oauth - OAuth 和 OAuth 2.0 有什么区别？
这个问题在这里已经有了答案: 9年前关闭。 Possible Duplicate: How is oauth 2 different from oauth 1 我知道这两个不向后兼容。但是，既然已经实
oauth - 在开发和生产环境中使用 OAuth
我已经看到关于此的其他问题( here 、 here 和 here )，但我对任何解决方案都不满意，所以我再次询问。我正在启动一个 Web 应用程序，它将利用来自多个提供商(Google、Facebo
oauth - OAuth 授权码应何时到期？
我知道(在 OAuth 中使用授权代码“授权代码”时)，访问 token 的生命周期应该很短，但刷新 token 的生命周期可能很长。所以我决定为我的项目: 访问 token 生命周期:1 天刷新
oauth - OAuth 可以与手机应用程序一起使用吗？
在没有浏览器的情况下，我们可以在手机上的应用程序中使用 OAuth 吗？如果没有浏览器，用户是否仍然可以批准 token 请求(以便消费者可以继续从服务提供者那里获取 protected 资源)？
oauth - OAuth 2 与 OAuth 1 有何不同？
用非常简单的术语来说，有人可以解释一下 OAuth 2 和 OAuth 1 之间的区别吗？ OAuth 1 现在已经过时了吗？我们应该实现 OAuth 2 吗？我没有看到很多 OAuth 2 的实现；
oauth - 桥接表单例份验证和 OAUTH
修改表单例份验证登录过程并不难，因此除了正常的表单例份验证之外，WebClient 对象对由使用 Thinktecture IdentityModel 设置的 Web Api DAL 提供的 api/
oauth - OAuth 是否总是假定用户界面？
我想连接到 LinkedIn 并通过他们的 API 提取一些信息。 LinkedIn API 使用 OAuth 2.0。我读过的所有关于 OAuth 的文档(无论是在 LinkedIn 的上下文中还
oauth - OAuth 的接受程度如何？
OAuth 与其他身份验证标准的支持范围有多广？这可能是社区维基的东西，但我还是要问。我需要投资一些与服务器身份验证相关的东西，而且那里似乎有一些不错的东西。最佳答案 OAuth 主要用作授权机
oauth - 雅虎和微软是否支持 Oauth 2.0？以及关于 oAuth 2.0 的几个问题
我有几个问题... 雅虎和微软 api 是否支持 oAuth 2.0？如果是，那么主要是什么应该采取的安全措施转移时受到照顾 oAuth 1.0 到 oAuth 2.0。 Google API
oauth-2.0 - google oAuth - 从 google oAuth 登录后如何删除 cookie
我已经用谷歌 oAuth 开发了一个应用程序，这工作正常。我可以登录并访问我的网站。我的问题是，当我从我的应用程序中注销(注销)时，我删除了所有 session ，但未删除经过身份验证的 cook
oauth - 我认为 OAuth 1.0 已经被 OAuth 2.0 弃用是对的吗？
我在 Internet 上寻找一些关于此的信息，最后在 RFC 上找到了 Oauth 1.0 协议(protocol):https://www.rfc-editor.org/rfc/rfc5849 您
oauth - 带有内部返回 URL 的 Google OpenID+Oauth 混合模式登录 - OAuth 不起作用
我正在尝试制作 Google OpenID/OAuth hybrid签到工作。问题是它是一个可安装的网络(所以没有固定域)，我也试图让它在我的开发机器上工作 - 所以返回 URL 类似于 http:/
oauth - DotNetOpenAuth 2、OAuth.net 和 Microsoft.OWIN.Security.oAuth
我想构建一个独立与任何身份提供者(如 ADFS、OpenAM、oracle 身份)一起工作的应用程序。我的目的是验证来自任何一个 IDP 的登录用户，这些 IDP 配置为实现我的 SSO。我不确定
spring -/oauth/authorize 和/oauth/token 在 Spring OAuth 中如何交互？
我正在深入研究 Spring OAuth，发现一些相互矛盾的信息。具体来说，this tutorial声明 /oauth/token 端点在将刷新 token 授予客户端应用程序之前处理用户名和密码
oauth - 来自命令行的三足 OAuth token
如何通过自定义命令行工具支持三足式 OAuth 工作流？我想允许我的 CLI 工具的用户上网、登录并在本地缓存 token ，类似于 heroku login。正在做。最佳答案你必须扔掉同意屏幕
oauth - 什么是 oauth 域
什么是 oauth 域？是否有任何免费的 oauth 服务？我可以将它用于 StackApps registration 吗？？我在谷歌上搜索了很多，但找不到答案。最佳答案这是redirect_
oauth - Yahoo OAuth 实现无法离线工作
我需要将我的 Delicious 书签下载到非 Web 应用程序，而无需持续的用户交互。我正在使用 Delicious 的 V2 API(使用 oAuth)，但问题是他们的访问 token 似乎在一小
oauth - nginx 负载均衡器和 OAuth
我正在尝试为两台服务器设置一个 nginx 负载均衡器/代理，并在两台服务器上运行 OAuth 身份验证的应用程序。当 nginx 在端口 80 上运行时，一切都运行良好，但是当我将它放在任何其他端

知者

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

oauth2-客户端模式案例

1.项目结构

2.搭建授权服务器(auth-server)

3.搭建资源服务器(user-server)

4.测试