精华内容
下载资源
问答
  • java实现OAuth2流程

    2018-04-24 16:36:02
    还在烦恼OAuth2技术只依赖boot吗?我提供了纯java技术实现OAuth2的全部实现,含客户端和服务端的完整解决方案。
  • 主要介绍了使用Java开发实现OAuth安全认证的应用的方法,OAuth安全认证经常出现于社交网络API应用的相关开发中,需要的朋友可以参考下
  • Oauth2实现java

    2018-07-01 12:28:48
    oauth本身不是技术,而是一项资源授权协议,重点是协议!Apache基金会提供了针对Java的oauth封装。我们做Java web项目想要实现oauth协议进行资源授权访问,直接使用该封装就可以。
  • What is the fastest/easiest way to get an OAuth provider running in Java? Specifically, I need to authorize third-party apps to access certain web services (I'm thinking token authentication using OAu...

    What is the fastest/easiest way to get an OAuth provider running in Java? Specifically, I need to authorize third-party apps to access certain web services (I'm thinking token authentication using OAuth).

    I've been looking at Jersey's OAuth extension, but as mentioned here, it doesn't provide a full-fledged Service Provider.

    解决方案

    There are a few Java libraries out there for OAuth. Specifically, I'd have a look at this one. I haven't used it myself, but there is an example for running an OAuth Service Provider.

    There's a list of libraries available on the OAuth website: http://oauth.net/code

    展开全文
  • DeviantArt-OAuth2-Java DeviantArt 的 OAuth2 API v1.20150217 的开源 Java 实现。 这个实现目前是不完整的。 查看问题页面以查看尚未完成的内容。 您可以从 json.org 下载 JSON 库。
  • OAuth2 Server 基于 Java Spring Security 和 MySql。 这是支持 OAuth 2.0 的用户指南。 OAuth 2.0 提供者 OAuth 2.0 提供者负责管理可以代表用户访问其受保护资源的 OAuth 2.0 客户端。 提供者通过管理和验证可...
  • Java实现OAuth授权

    千次阅读 2012-02-15 16:50:17
    OAuth授权的Java实现详解 由于最近在开发一个关于微博整合的小应用,于是开始接触各大微博平台的开放平台(新浪、搜狐、网易、QQ):目前这几大微博的应用开发都采用OAuth授权,要访问大部分API都需要OAuth...
    
    

    OAuth授权的Java实现详解

    由于最近在开发一个关于微博整合的小应用,于是开始接触各大微博平台的开放平台(新浪、搜狐、网易、QQ):目前这几大微博的应用开发都采用OAuth授权,要访问大部分API都需要OAuth方式的身份鉴权。

    OAuth是什么?

    先来简单介绍一下OAuth授权协议:OAUTH协议为用户资源的授权提供了一个安全的、开放而又简易的标准。同时,任何第三方都可以使用OAuth认证服务,任何服务提供商都可以实现自身的OAuth认证服务,因而OAUTH是开放的。业界提供了OAuth的多种实现如PHP,JavaScript,Java,Ruby等各种语言开发包,大大节约了程序员的时间,因而OAuth是简易的。目前互联网很多服务如Open API,很多大头公司如Google,Yahoo,Microsoft等都提供了OAuth认证服务,这些都足以说明OAUTH标准逐渐成为开放资源授权的标准。

    OAuth的授权流程

    你所开发的应用需要流程如下:

    1. 向应用服务商(新浪、搜狐等微博)请求request_token。
    2. 得到request_token后重定向用户到服务商的授权页面。
    3. 如果用户选择授权你得应用,用request_token向服务商请求换取access_token。
    4. 得到access_token等信息访问受限资源。

    而服务商相应的响应如下:

    1. 创建request_token返回给应用。
    2. 询问用户是否授权此应用。如果用户授权重定向用户至应用页面。
    3. 创建access_token并返回给应用。
    4. 响应受限资源请求并返回相关信息。

    通俗点的说法就是“你拿着你得身份证明(request_token)向服务商申请进入用户家的门钥匙(access_token),服务商询问用户同不同意,如果用户同意服务商就给你进入用户家门的钥匙(access_token),拿到钥匙后你就可以进到用户家里”。

    OAuth授权的Java实现

    作为一个开放协议目前有很多现成的Oauth库可供开发者使用,可以点击这里下载。不过有精力有时间的话还是自己去实现一下OAuth授权的流程,可以很好的体会OAuth认证协议的原理。以

    下面就是我使用Java实现Oauth的具体步骤,代码很简单,如果有画蛇添足的地方还望高手一笑而过。

    一、获取Request_token

    首先得准备一下参数及其来源:

    1. oauth_consumer_key —— 注册应用后由应用服务商提供
    2. consumer_secret —— 注册应用后由应用服务商提供
    3. oauth_callback —— 用户授权后的返回地址
    4. oauth_nonce —— 随机字符串,须保证每次都不同
    5. oauth_timestamp —— 时间戳
    6. oauth_signature_method —— 签名base string 的方法,目前支持 HMAC-SHA1
    7. oauth_version —— Oauth协议版本

    还需要下面三个请求地址(这些地址任何一个提供OAuth的服务商都会提供给你,看下API文档就会找到):

    1. requst_token_url —— 上面第1步中的请求地址
    2. authorize_url —— 上面第2步的请求地址
    3. access_token_url —— 上面第3步的请求地址

    至于如何注册应用,新浪微博点此,网易微博点此,腾讯微博点此,搜狐微博需要你发邮件索取,具体看这里。注册成功后就会获得oauth_consumer_key 和 consumer_secret 两个参数。

    oauth_callback 起的作用是当用户授权成功后服务商会把用户重定向到这个网址。

    oauth_nonce 是一个随机字符串下面是我的生成代码:

    public String set_nonce() {
    String base = "abcdefghijklmnopqrstuvwxyz0123456789";
    Random random = new Random();
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < 18; i++) {
    int number = random.nextInt(base.length());
    sb.append(base.charAt(number));
    }
    return sb.toString();
    }

    oauth_timestamp 是请求的时间戳,我的代码如下:

    public String set_timestamp() {

    Date date = new Date();
    long time = date.getTime();
    return (time + "").substring(0, 10);
    }

    需要说明一下的是这里的时间戳为10位而不是13位,因此截取0-10位置。

    其他参数直接指定就行了。

    接下来,有了这些参数就可以组装base string了。准备base string的目的就是为了得到 oauth_signature 这个参数,这个参数向服务商发送请求的时候需要用到。

    组装的方法是用下面8部分

    1. POST(也可以是GET,取决于你应用服务商支持哪个)。
    2. Urlencode之后的requst_token_url 。
    3. oauth_callback=Urlencode之后你的oauth_callback(Urlencode的参数为“utf-8”)。
    4. oauth_consumer_key = 你的oauth_consumer_key 
    5. oauth_nonce = 你的oauth_nonce 
    6. oauth_signature_method = 你的 oauth_signature_method 
    7. oauth_timestamp = 你的oauth_timestamp 
    8. oauth_version = “1.0”——目前大多数OAuth都采用的是1.0或1.0a版本。
    需要注意的是上面除了1跟2外其他参数的格数形如: abc=“abc” ,然后先将上面1和2部分用&号相连得到串A、3-8部分用&相连得到串B,下面需要将串B再进行一次Urlencode得到串C,最后将A跟C以&号相连就得到了base string。这个过程中 oauth_callback 实质上经过了两次 Urlencode ,组装base string是非常容易出错的,一不小心丢一个引号或者格式稍有不对就会出错。

    下面是我的Java实现代码:

    public String set_basestring() throws UnsupportedEncodingException {
    String bss;
    bss = oauth_request_method + "&"
    + URLEncoder.encode(requst_token_url, "utf-8") + "&";
    String bsss = "oauth_callback="
    + URLEncoder.encode(oauth_callback, "utf-8")
    + "&oauth_consumer_key=" + oauth_consumer_key + "&oauth_nonce="
    + oauth_nonce + "&oauth_signature_method="
    + oauth_signature_method + "&oauth_timestamp="
    + oauth_timestamp + "&oauth_version=" + oauth_version;
    bsss = URLEncoder.encode(bsss, "utf-8");
    return bss + bsss;
    }

    有了base string就可以签名生成oauth_signature这个参数,oauth_signature会在请求request_token的时候用到。签名算法是HMAC-SHA1,签名的key就是最开始的consumer_secret后加一个&号,签名算法代码如下:

    public String hmacsha1(String data, String key) {
    byte[] byteHMAC = null;
    try {
    Mac mac = Mac.getInstance("HmacSHA1");
    SecretKeySpec spec = new SecretKeySpec(key.getBytes(), "HmacSHA1");
    mac.init(spec);
    byteHMAC = mac.doFinal(data.getBytes());
    } catch (InvalidKeyException e) {
    e.printStackTrace();
    } catch (NoSuchAlgorithmException ignore) {
    }
    String oauth = new BASE64Encoder().encode(byteHMAC);
    return oauth;
    }

    里面用的的BASE64Encoder这个类可以Google一个。

    得到oauth_signature后就要开始向 requst_token_url 发送请求了,OAuth规范定义了三种传递OAuth参数方式:

    1. httpheader中
    2. url中
    3. post form中

    国内各大微博的支持情况是:新浪Httpheader可用,网易Httpheader可用,腾讯只支持在url,搜狐由于没有appkey所以还没去尝试。

    如果使用Httpheader传递参数头名为“Authorization”,值为下面的格式,将值改为自己应用的。

    OAuth oauth_nonce="9zWH6qe0qG7Lc1telCn7FhUbLyVdjEaL3MO5uHxn8", oauth_signature_method="HMAC-SHA1", oauth_timestamp="1272323047", oauth_consumer_key="GDdmIQH6jhtmLUypg82g", oauth_token="8ldIZyxQeVrFZXFOZH5tAwj6vzJYuLQpl0WUEYtWc", oauth_verifier="pDNg57prOHapMbhv25RNf75lVRd6JDsni1AJJIDYoTY", oauth_signature="PUw%2FdHA4fnlJYM6RhXk5IU%2F0fCc%3D", oauth_version="1.0"

    url和post form两种方式的参数名和参数值也即上面的,完全一样。

    请求发送成功后就会得到的响应如下:

    oauth_token=8ldIZyxQeVrFZXFOZH5tAwj6vzJYuLQpl0WUEYtWc&oauth_token_secret=x6qpRnlEmW9JbQn4PQVVeVG8ZLPEx6A0TOebgwcuA&oauth_callback_confirmed=true

    可以看到响应里面已经包含oauth_token和oauth_token_secret了,存贮之以备后面使用。

    二、用户认证

    拿到了oauth_token之后就需要用户对此oauth_token授权,也即对你的应用授权,具体做法就是发送oauth_token到服务商并请求用户对此oauth_token授权:实现方法为以oauth_token和oauth_callback为参数请求oauthorize_url,Servlet中的代码如下:

    resp.sendRedirect(oauthorize_url+"?oauth_token="+oauth_token+"&oauth_callback="+oauth_callback);

     这是用户就被带到了应用授权页面,并可以选择是否对该应用授权。如果用户授权之后就会被带到oauth_callback 地址。同时如果需要服务商会给oauth_callback返会一个名为oauth_verifier的参数(此参数用于无法跳转的桌面应用,不一定每个微博平台都会返回),这时候我们的oauth_token已经获得用户的授权了。

    三、用oauth_token换取access_token

    这一步跟第一步“获取Request_token”基本相同,也是需要准备 base string 对其签名,然后发送请求,可以参考第一步的代码实现:但是相应的参数有所不用,具体来讲就是第一步组装base string 时候8个部分中第二个部分中的url换为access_token_url 并去掉oauth_callback加上oauth_token(如果有oauth_verifier的话也需要一并加上),组装好之后需要签名以得到oauth_signature,本次签名的方法跟上次一样,但是key变为consumer_secret和oauth_token_secret以&连接的串。

    下来需要向access_token_url发送请求,请求参数包括base string 里的除了请求方法(POST或GET)和请求地址外的所有参数及其值和签名后生成的oauth_signature。例子如下:

    OAuth oauth_nonce="9zWH6qe0qG7Lc1telCn7FhUbLyVdjEaL3MO5uHxn8", oauth_signature_method="HMAC-SHA1", oauth_timestamp="1272323047", oauth_consumer_key="GDdmIQH6jhtmLUypg82g", oauth_token="8ldIZyxQeVrFZXFOZH5tAwj6vzJYuLQpl0WUEYtWc", oauth_verifier="pDNg57prOHapMbhv25RNf75lVRd6JDsni1AJJIDYoTY", oauth_signature="PUw%2FdHA4fnlJYM6RhXk5IU%2F0fCc%3D", oauth_version="1.0""

    请求成功会服务商就会返回oauth_token和oaut_token_secret,这里的oauth_token和oaut_token_secret就是真正访问资源要用的access_token。

    还需要说明的是以上过程只需要经行一次,就是说你拿到的access_token是不会过期的,除非用户手动将授权收回,因此作为access_token的oauth_token和oaut_token_secret要保存起来,以后访问受限资源的时候可以直接使用。至于如何访问受限资源,等以后有时间了再补上。


    本文转自http://www.littlear.com/post/2011/01/0285/

    展开全文
  • OAuth2 OAuth 2 授权服务器。 它支持以下 OAuth2 授权流程: 隐式授予,客户端凭据授予 它支持以下访问令牌类型: 不记名令牌、MAC令牌(即将推出)
  • Javaoauth2.0 服务端与客户端的实现.zip 封装了oauth2.0的基本架构和实现
  • 提供springboot整合apache.oltu.oauth,实现客户端调用认证服务器资源代码案例。使用apache.oltu.oauth2依赖包
  • 基于MAVEN+OLTU开源代码实现javaOauth2.0前后端,数据加密使用MD5。
  • Javaoauth2.0 服务端与客户端的实现
  • 主要介绍了java实现新浪微博Oauth接口发送图片和文字的方法,涉及java调用新浪微博Oauth接口的使用技巧,具有一定参考接借鉴价值,需要的朋友可以参考下
  • SpringCloud实现OAuth2 系列 一文章简述父项目授权服务POM.xmlapplication.ymlWebSecurityConfig 用于配置 Web 相关的AuthorizationServerConfig 认证授权MyUserDetailsService 用于自定义用户信息资源服务pom.xml...

    文章简述

    本系列文章主要介绍以 SpringCloud(Hoxton.SR8) 实现 OAuth2。
    本篇主要讲解以内存方式存储 Token 实现 OAuth2。 这里主要分为两块:

    1. 资源服务:一般对应我们的响应的 Api 服务
    2. 认证授权服务:负责认证和授权资源

    父项目

    POM.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>com</groupId>
    	<artifactId>spring-auth2</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>pom</packaging>
    	<name>spring-auth2</name>
    	<description>父项目</description>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.3.3.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    		<java.version>1.8</java.version>
    		<spring-cloud.version>Hoxton.SR8</spring-cloud.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-starter-oauth2</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-configuration-processor</artifactId>
    			<optional>true</optional>
    		</dependency>
    		<dependency>
    			<groupId>org.projectlombok</groupId>
    			<artifactId>lombok</artifactId>
    			<optional>true</optional>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    			<exclusions>
    				<exclusion>
    					<groupId>org.junit.vintage</groupId>
    					<artifactId>junit-vintage-engine</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    	</dependencies>
    
    	<modules>
    		<module>client</module>
    		<module>server</module>
    	</modules>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>${spring-cloud.version}</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    </project>
    

    授权服务

    这里因为大部分代码都是涉及授权服务,因此先讲授权服务。

    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>com</groupId>
            <artifactId>spring-auth2</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
        <groupId>com</groupId>
        <artifactId>server</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>server</name>
        <description>服务端</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>
    

    application.yml

    server:
     port: 9000
    

    WebSecurityConfig 用于配置 Web 相关的

    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.authentication.builders.AuthenticationManagerBuilder;
    import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    
    /**
     * 注解权限拦截
     * @author luoyy
     */
    @Configuration
    @EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true, jsr250Enabled = true)
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    
    	@Autowired
    	private UserDetailsService userDetailsService;
    
    	/**
    	 * websecurity用户密码和认证服务器客户端密码都需要加密算法
    	 * @return
    	 */
    	@Bean
    	public BCryptPasswordEncoder passwordEncoder() {
    		return new BCryptPasswordEncoder();
    	}
    
    	/**
    	 * 认证服务器需配合Security使用
    	 * @return
    	 * @throws Exception
    	 */
    	@Bean
    	@Override
    	public AuthenticationManager authenticationManagerBean() throws Exception {
    		return super.authenticationManagerBean();
    	}
    
    
    	@Override
    	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    		// 内存中创建用户并为密码加密
    		auth.inMemoryAuthentication()
    				.withUser("jack").password(passwordEncoder().encode("123")).roles("ADMIN")
    				.and()
    				.withUser("admin").password(passwordEncoder().encode("123")).roles("ADMIN");
    	}
    
    	@Override
    	protected void configure(HttpSecurity http) throws Exception {
    		// 表单登录
    		http.formLogin()
    				.and()
    				.csrf().disable()
    				.authorizeRequests()
    				// 开放 oauth 端口
    				.antMatchers("/oauth/**").permitAll()
    				.and()
    				// 对所有请求进行拦截
    				.authorizeRequests()
    				.anyRequest().authenticated();
    	}
    
    }
    

    AuthorizationServerConfig 认证授权

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.HttpMethod;
    import org.springframework.security.authentication.AuthenticationManager;
    import org.springframework.security.crypto.password.PasswordEncoder;
    import org.springframework.security.oauth2.common.DefaultOAuth2AccessToken;
    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.store.InMemoryTokenStore;
    
    import java.util.LinkedHashMap;
    import java.util.Map;
    
    /**
     * @author luoyy
     */
    @Configuration
    @EnableAuthorizationServer
    public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    	@Autowired
    	AuthenticationManager authenticationManager;
    	@Autowired
    	PasswordEncoder passwordEncoder;
    
    	/**
    	 * 在内存中存储测试客户端与凭证(实际应用用数据库,oauth有标准的数据库模板)
    	 * @param clients
    	 * @throws Exception
    	 */
    	@Override
    	public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    		clients.inMemory()
    				// client_id
    				.withClient("client-code")
    				// secret
    				.secret(passwordEncoder.encode("123"))
    				// 授权模式
    				.authorizedGrantTypes("authorization_code")
    				// 授权范围
    				.scopes("app")
    				// 成功之后跳转
    				.redirectUris("https://ww.baidu.com")
    				// 授权资源
    				.resourceIds("goods")
    
    				.and()
    				.withClient("client-credentials")
    				.secret(passwordEncoder.encode("123"))
    				.authorizedGrantTypes("client_credentials")
    				.scopes("app")
    				.resourceIds("goods", "test")
    
    				.and()
    				.withClient("client-password")
    				.secret(passwordEncoder.encode("123"))
    				.authorizedGrantTypes("password","refresh_token")
    				.scopes("app")
    				.resourceIds("goods")
    
    				.and()
    				.withClient("client-implicit")
    				.authorizedGrantTypes("implicit")
    				.scopes("app")
    				.resourceIds("goods");
    
    	}
    
    	/**
    	 * 设置token
    	 * @param endpoints
    	 * @throws Exception
    	 */
    	@Override
    	public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
    		// authenticationManager 配合 password 模式使用
    		endpoints.authenticationManager(authenticationManager)
    				// 这里使用内存存储 token,也可以使用redis和数据库
    				.tokenStore(new InMemoryTokenStore());
    		// 允许请求 token 的请求方式
    		endpoints.allowedTokenEndpointRequestMethods(HttpMethod.GET,HttpMethod.POST);
    		endpoints.tokenEnhancer((oAuth2AccessToken, oAuth2Authentication) -> {
    			// 在返回 token 时,可以自定义一些数据
    			DefaultOAuth2AccessToken token = (DefaultOAuth2AccessToken) oAuth2AccessToken;
    			Map<String, Object> map = new LinkedHashMap<>();
    			map.put("nickname", "张三");
    			token.setAdditionalInformation(map);
    			return token;
    
    		});
    	}
    
    	/**
    	 * /oauth/authorize(授权端,授权码模式使用)
    	 * /oauth/token(令牌端,获取 token)
    	 * /oauth/check_token(资源服务器用来校验token)
    	 * /oauth/confirm_access(用户发送确认授权)
    	 * /oauth/error(认证失败)
    	 * /oauth/token_key(如果使用JWT,可以获的公钥用于 token 的验签)
    	 * @param security
    	 * @throws Exception
    	 */
    	@Override
    	public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
    		// 允许表单认证
    		security.allowFormAuthenticationForClients()
    				// 用于检查令牌(/oauth/check_token和/oauth/token_key)
    				// 端点默认受保护denyAll()
    				.checkTokenAccess("permitAll()")
    				.tokenKeyAccess("isAuthenticated()");
    	}
    }
    

    MyUserDetailsService 用于自定义用户信息

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.core.authority.AuthorityUtils;
    import org.springframework.security.core.userdetails.User;
    import org.springframework.security.core.userdetails.UserDetails;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.core.userdetails.UsernameNotFoundException;
    import org.springframework.security.crypto.password.PasswordEncoder;
    import org.springframework.stereotype.Component;
    
    import java.util.List;
    
    @Slf4j
    @Component
    public class MyUserDetailsService implements UserDetailsService {
    	// 这里就可以注入我们的dao ,查询用户信息,组装相关的权限
    
    	@Autowired
    	private PasswordEncoder passwordEncoder;
    
    	@Override
    	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    		log.info("用户名:{}", username);
    		// 根据用户名查找用户信息
    		List<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("admin");
    		// User user = new User(username, , authorities);
    
    		// 判断用户状态
    		User user = new User(username, passwordEncoder.encode("123"), true, true, true, true, authorities);
    		return user;
    	}
    }
    

    资源服务

    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>com</groupId>
            <artifactId>spring-auth2</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
        <groupId>com.client</groupId>
        <artifactId>client</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>client</name>
        <description>客户端</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    application.yml

    server:
      port: 8080
    
    #配置向认证服务器认证权限
    security:
      oauth2:
        client:
          client-id: client-password
          client-secret: 123
          access-token-uri: http://localhost:9000/oauth/token
          user-authorization-uri: http://localhost:9000/oauth/authorize
        resource:
          token-info-uri: http://localhost:9000/oauth/check_token
    

    ResourceServerConfig

    import com.fasterxml.jackson.databind.ObjectMapper;
    import lombok.Data;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.MediaType;
    import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
    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;
    
    /**
     * @author 
     */
    @Configuration
    @EnableResourceServer
    @EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true, jsr250Enabled = true)
    public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
     
        private ObjectMapper objectMapper = new ObjectMapper();
     
        @Override
        public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
            //设置资源服务器id,需要与认证服务器对应
            resources.resourceId("goods");
            //当权限不足时返回
            resources.accessDeniedHandler((request, response, e) -> {
                response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
                response.getWriter()
                        .write(objectMapper.writeValueAsString(Result.from("10000", "权限不足", null)));
            });
            //当token不正确时返回
            resources.authenticationEntryPoint((request, response, e) -> {
                response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
                response.getWriter()
                        .write(objectMapper.writeValueAsString(Result.from("10100", "access_token错误", null)));
            });
        }
    
        /**
         *     配置uri拦截策略
         */
        @Override
        public void configure(HttpSecurity http) throws Exception {
            http
                    .csrf().disable()
                    .httpBasic().disable()
                    .exceptionHandling()
                    .authenticationEntryPoint((req, resp, exception) -> {
                        resp.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
                        resp.getWriter()
                                .write(objectMapper.writeValueAsString(Result.from("10200", "没有携带token", null)));
                    })
                    .and()
                    // 无需登陆
                    .authorizeRequests().antMatchers("/test").permitAll()
                    .and()
                    // 拦截所有请求,并且检查scope
                    .authorizeRequests().anyRequest().access("isAuthenticated() && #oauth2.hasScope('app')");
        }
    
    }
    

    运行结果

    访问 localhost:9000/oauth/token

    展开全文
  • 适用于 JavaOauth2 提供程序库 该库提供了一个工具包,用于向 Java Web 应用程序添加 OAuth2 提供程序功能。 该库被设计为可与 play 框架、基于 servlet 的 Web 框架一起使用。 该库目前处于测试阶段。 支持的...
  • oauth原理简述 oauth本身不是技术,而是一项资源授权协议,重点是协议!...我们做Java web项目想要实现oauth协议进行资源授权访问,直接使用该封装就可以。 想深入研究原理的 可以参考:阮一峰的博客以及张开...
    原文:https://blog.csdn.net/jing12062011/article/details/78147306/
    
    oauth原理简述

    oauth本身不是技术,而是一项资源授权协议,重点是协议!Apache基金会提供了针对Java的oauth封装。我们做Java web项目想要实现oauth协议进行资源授权访问,直接使用该封装就可以。

    想深入研究原理的 可以参考:阮一峰的博客以及张开涛的博客

    借用开涛老师一张图,就是整个oauth2.0 的协议实现原理,所有的技术层面的开发都是围绕这张图。





    整个开发流程简述一下:

    1、 在客户端web项目中构造一个oauth的客户端请求对象(OAuthClientRequest),在此对象中携带客户端信息(clientId、accessTokenUrl、response_type、redirectUrl),将此信息放入http请求中,重定向到服务端。此步骤对应上图1


    2、 在服务端web项目中接受第一步传过来的request,从中获取客户端信息,可以自行验证信息的可靠性。同时构造一个oauth的code授权许可对象(OAuthAuthorizationResponseBuilder),并在其中设置授权码code,将此对象传回客户端。此步骤对应上图2


    3、 在在客户端web项目中接受第二步的请求request,从中获得code。同时构造一个oauth的客户端请求对象(OAuthClientRequest),此次在此对象中不仅要携带客户端信息(clientId、accessTokenUrl、clientSecretGrantType、redirectUrl),还要携带接受到的code。再构造一个客户端请求工具对象(oAuthClient),这个工具封装了httpclient,用此对象将这些信息以post(一定要设置成post的方式请求到服务端,目的是为了让服务端返回资源访问令牌。此步骤对应上图3。(另外oAuthClient请求服务端以后,会自行接受服务端的响应信息。


    4、 在服务端web项目中接受第三步传过来的request,从中获取客户端信息和code,并自行验证。再按照自己项目的要求生成访问令牌(accesstoken),同时构造一个oauth响应对象(OAuthASResponse),携带生成的访问指令(accesstoken),返回给第三步中客户端的oAuthClient。oAuthClient接受响应之后获取accesstoken,此步骤对应上图4


    5、 此时客户端web项目中已经有了从服务端返回过来的accesstoken,那么在客户端构造一个服务端资源请求对象(OAuthBearerClientRequest),在此对象中设置服务端资源请求URI,并携带上accesstoken。再构造一个客户端请求工具对象(oAuthClient),用此对象去服务端靠accesstoken换取资源。此步骤对应上图5


    6、 在服务端web项目中接受第五步传过来的request,从中获取accesstoken并自行验证。之后就可以将客户端请求的资源返回给客户端了。


    代码:

    客户端:

    一、pom依赖:


    <dependency>

    <groupId>org.apache.oltu.oauth2</groupId>

    <artifactId>org.apache.oltu.oauth2.client</artifactId>

    <version>0.31</version>

    </dependency>


    二、controller方法:

    2.1 向服务端请求授权码code的controller方法:


    @RequestMapping(“/server”)

    @Controller

    public class ServerController{

    String clientId = null;

    String clientSecret = null;

    String accessTokenUrl = null;

    String userInfoUrl = null;

    String redirectUrl = null;

    String response_type = null;

    String code= null;

    //提交申请code的请求

    @RequestMapping(“/requestServerCode”)

    public String requestServerFirst(HttpServletRequestrequest, HttpServletResponseresponse, RedirectAttributesattr) throws OAuthProblemException{

    clientId = “clientId”;

    clientSecret = “clientSecret”;

    accessTokenUrl = “responseCode”;

    redirectUrl = “http://localhost:8081/oauthclient01/server/callbackCode”;

    response_type = “code”;

    OAuthClient oAuthClient =new OAuthClient(new URLConnectionClient());

    String requestUrl = null;

    try {

    //构建oauthd的请求。设置请求服务地址(accessTokenUrl)、clientIdresponse_typeredirectUrl

    OAuthClientRequest accessTokenRequest = OAuthClientRequest

    .authorizationLocation(accessTokenUrl)

    .setResponseType(response_type)

    .setClientId(clientId)

    .setRedirectURI(redirectUrl)

    .buildQueryMessage();

    requestUrl = accessTokenRequest.getLocationUri();

    System.out.println(requestUrl);

    } catch (OAuthSystemExceptione) {

    e.printStackTrace();

    }

    return “redirect:http://localhost:8082/oauthserver/”+requestUrl ;

    }


    此段代码对应开发步骤1.其中accessTokenUrl是服务端返回code的controller方法映射地址。redirectUrl是告诉服务端,code要传回客户端的一个controller方法,该方法的映射地址就是redirectUrl。


    2.2 向服务端请求资源访问令牌access token的controller方法:


    //接受客户端返回的code,提交申请access token的请求

    @RequestMapping(“/callbackCode”)

    public Object toLogin(HttpServletRequestrequest)throws OAuthProblemException{

    System.out.println(“———–客户端/callbackCode——————————————————————————–”);

    clientId = “clientId”;

    clientSecret = “clientSecret”;

    accessTokenUrl=“http://localhost:8082/oauthserver/responseAccessToken”;

    userInfoUrl = “userInfoUrl”;

    redirectUrl = “http://localhost:8081/oauthclient01/server/accessToken”;

    HttpServletRequest httpRequest = (HttpServletRequest)request;

    code = httpRequest.getParameter(“code”);

    System.out.println(code);

    OAuthClient oAuthClient =new OAuthClient(new URLConnectionClient());

    try {

    OAuthClientRequest accessTokenRequest = OAuthClientRequest

    .tokenLocation(accessTokenUrl)

    .setGrantType(GrantType.AUTHORIZATION_CODE)

    .setClientId(clientId)

    .setClientSecret(clientSecret)

    .setCode(code)

    .setRedirectURI(redirectUrl)

    .buildQueryMessage();

    //去服务端请求access token,并返回响应

    OAuthAccessTokenResponse oAuthResponse =oAuthClient.accessToken(accessTokenRequest, OAuth.HttpMethod.POST);

    //获取服务端返回过来的access token

    String accessToken = oAuthResponse.getAccessToken();

    //查看access token是否过期

    Long expiresIn =oAuthResponse.getExpiresIn();

    System.out.println(客户端/callbackCode方法的token:::+accessToken);

    System.out.println(“———–客户端/callbackCode——————————————————————————–”);

    return“redirect:http://localhost:8081/oauthclient01/server/accessToken?accessToken=”+accessToken;

    } catch (OAuthSystemExceptione) {

    e.printStackTrace();

    }

    return null;

    }


    此方法对应开发步骤3的全部和步骤4的一半,也就是还包括接受服务端返回的access token。最后的redirect地址不是服务端的地址,只是将此token传进客户端的另一个方法,该方法就是最后的资源请求方法。


    2.3 利用服务端给的token去请求服务端的资源的controller方法。这里说的资源就是服务端数据库中的user表的uname值的拼接字段。


    //接受服务端传回来的access token,由此token去请求服务端的资源(用户信息等)

    @RequestMapping(“/accessToken”)

    public ModelAndView accessToken(StringaccessToken) {

    System.out.println(“———客户端/accessToken———————————————————————————-“);

    userInfoUrl = “http://localhost:8082/oauthserver/userInfo”;

    System.out.println(“accessToken”);

    OAuthClient oAuthClient =new OAuthClient(new URLConnectionClient());

    try {

    OAuthClientRequest userInfoRequest =new OAuthBearerClientRequest(userInfoUrl)

    .setAccessToken(accessToken).buildQueryMessage();

    OAuthResourceResponse resourceResponse =oAuthClient.resource(userInfoRequest, OAuth.HttpMethod.GET, OAuthResourceResponse.class);

    String username = resourceResponse.getBody();

    System.out.println(username);

    ModelAndView modelAndView =new ModelAndView(“usernamePage”);

    modelAndView.addObject(“username”,username);

    System.out.println(“———客户端/accessToken———————————————————————————-“);

    returnmodelAndView;

    } catch (OAuthSystemExceptione) {

    e.printStackTrace();

    } catch (OAuthProblemExceptione) {

    e.printStackTrace();

    }

    System.out.println(“———客户端/accessToken———————————————————————————-“);

    return null;

    }

    此方法对应开发步骤5的全部和步骤6的一半,也就是还包括接受服务端返回的资源信息。获取了资源信息之后,其余的开发就和平时的springmvc一毛一样了。

    以上三个方法我全部封装在同一个ServerController类中。



    服务端

    pom依赖


    1. <dependency>

    2. <groupId>org.apache.oltu.oauth2</groupId>

    3. <artifactId>org.apache.oltu.oauth2.authzserver</artifactId>

    4. <version>0.31</version>

    5. </dependency>

    6. <dependency>

    7. <groupId>org.apache.oltu.oauth2</groupId>

    8. <artifactId>org.apache.oltu.oauth2.resourceserver</artifactId>

    9. <version>0.31</version>

    10. </dependency>



    四 controller方法

    4.1 向客户端返回授权码code的controller方法

    @Controller

    public class AuthorizeController{

    @Autowired

    private UserServiceuserService;

    //向客户端返回授权许可码 code

    @RequestMapping(“/responseCode”)

    public Object toShowUser(Modelmodel, HttpServletRequestrequest){

    System.out.println(“———-服务端/responseCode————————————————————–”);

    try {

    //构建OAuth授权请求

    OAuthAuthzRequest oauthRequest =new OAuthAuthzRequest(request);

    /*oauthRequest.getClientId();

    oauthRequest.getResponseType();

    oauthRequest.getRedirectURI();

    System.out.println(oauthRequest.getClientId());

    System.out.println(oauthRequest.getResponseType());

    System.out.println(oauthRequest.getRedirectURI());*/

    if(oauthRequest.getClientId()!=null&&oauthRequest.getClientId()!=“”)

    {

    //设置授权码

    String authorizationCode =“authorizationCode”;

    //利用oauth授权请求设置responseType,目前仅支持CODE,另外还有TOKEN

    String responseType =oauthRequest.getParam(OAuth.OAUTH_RESPONSE_TYPE);

    //进行OAuth响应构建

    OAuthASResponse.OAuthAuthorizationResponseBuilderbuilder =

    OAuthASResponse.authorizationResponse(request, HttpServletResponse.SC_FOUND);

    //设置授权码

    builder.setCode(authorizationCode);

    //得到到客户端重定向地址

    String redirectURI =oauthRequest.getParam(OAuth.OAUTH_REDIRECT_URI);

    //构建响应

    final OAuthResponseresponse =builder.location(redirectURI).buildQueryMessage();

    System.out.println(服务端/responseCode内,返回的回调路径:+response.getLocationUri());

    System.out.println(“———-服务端/responseCode————————————————————–”);

    String responceUri =response.getLocationUri();

    //根据OAuthResponse返回ResponseEntity响应

    HttpHeaders headers =new HttpHeaders();

    try {

    headers.setLocation(new URI(response.getLocationUri()));

    } catch (URISyntaxExceptione) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    return“redirect:”+responceUri;

    }

    } catch (OAuthSystemExceptione) {

    e.printStackTrace();

    } catch (OAuthProblemExceptione) {

    e.printStackTrace();

    }

    System.out.println(“———-服务端/responseCode————————————————————–”);

    return null;

    }

    }


    此段代码对应开发步骤2

    4.2 向客户端返回资源访问令牌accesstoken的controller方法

    @Controller

    public class AccessTokenController {

    //获取客户端的code码,向客户端返回access token

    @RequestMapping(value=“/responseAccessToken”,method = RequestMethod.POST)

    public HttpEntity token(HttpServletRequest request){

    System.out.println(“——–服务端/responseAccessToken———————————————————–”);

    OAuthIssuer oauthIssuerImpl=null;

    OAuthResponse response=null;

    //构建OAuth请求

    try {

    OAuthTokenRequest oauthRequest =new OAuthTokenRequest(request);

    String authCode =oauthRequest.getParam(OAuth.OAUTH_CODE);

    String clientSecret = oauthRequest.getClientSecret();

    if(clientSecret!=null||clientSecret!=“”){

    //生成Access Token

    oauthIssuerImpl =new OAuthIssuerImpl(new MD5Generator());

    final StringaccessToken =oauthIssuerImpl.accessToken();

    System.out.println(accessToken);

    System.out.println(“–oooo—”);

    //生成OAuth响应

    response = OAuthASResponse

    .tokenResponse(HttpServletResponse.SC_OK)

    .setAccessToken(accessToken)

    .buildJSONMessage();

    }

    System.out.println(“——–服务端/responseAccessToken———————————————————–”);

    //根据OAuthResponse生成ResponseEntity

    return new ResponseEntity(response.getBody(), HttpStatus.valueOf(response.getResponseStatus()));

    } catch (OAuthSystemExceptione) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    } catch (OAuthProblemExceptione) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    System.out.println(“——–服务端/responseAccessToken———————————————————–”);

    return null;

    }

    }


    此段代码对应开发步骤4的前面一半,即服务端验证code、生成token并给客户端

    4.3 向客户端返回请求资源(username)的controller方法

    @Controller

    public class UserInfoController {

    @Autowired

    private UserServiceuserService;

    @RequestMapping(“/userInfo”)

    public HttpEntity userInfo(HttpServletRequest request)throws OAuthSystemException{

    System.out.println(“———–服务端/userInfo————————————————————-“);

    try {

    //获取客户端传来的OAuth资源请求

    OAuthAccessResourceRequest oauthRequest =new OAuthAccessResourceRequest(request, ParameterStyle.QUERY);

    //获取Access Token

    String accessToken =oauthRequest.getAccessToken();

    System.out.println(“accessToken”);

    //验证Access Token

    /*if (accessToken==null||accessToken==”“) {

    // 如果不存在/过期了,返回未验证错误,需重新验证

    OAuthResponse oauthResponse = OAuthRSResponse

    .errorResponse(HttpServletResponse.SC_UNAUTHORIZED)

    .setError(OAuthError.ResourceResponse.INVALID_TOKEN)

    .buildHeaderMessage();

    HttpHeaders headers = new HttpHeaders();

    headers.add(OAuth.HeaderType.WWW_AUTHENTICATE,

    oauthResponse.getHeader(OAuth.HeaderType.WWW_AUTHENTICATE));

    return new ResponseEntity(headers, HttpStatus.UNAUTHORIZED);

    } */

    //返回用户名

    User user=userService.selectByPrimaryKey(1);

    String username = accessToken+“—”+Math.random()+“—-“+user.getUname();

    System.out.println(username);

    System.out.println(服务端/userInfo::::::ppp”);

    System.out.println(“———–服务端/userInfo———————————————————-“);

    return new ResponseEntity(username, HttpStatus.OK);

    } catch (OAuthProblemExceptione) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    //检查是否设置了错误码

    String errorCode =e.getError();

    if (OAuthUtils.isEmpty(errorCode)) {

    OAuthResponse oauthResponse = OAuthRSResponse

    .errorResponse(HttpServletResponse.SC_UNAUTHORIZED)

    .buildHeaderMessage();

    HttpHeaders headers =new HttpHeaders();

    headers.add(OAuth.HeaderType.WWW_AUTHENTICATE,

    oauthResponse.getHeader(OAuth.HeaderType.WWW_AUTHENTICATE));

    return new ResponseEntity(headers, HttpStatus.UNAUTHORIZED);

    }

    OAuthResponse oauthResponse = OAuthRSResponse

    .errorResponse(HttpServletResponse.SC_UNAUTHORIZED)

    .setError(e.getError())

    .setErrorDescription(e.getDescription())

    .setErrorUri(e.getUri())

    .buildHeaderMessage();

    HttpHeaders headers =new HttpHeaders();

    headers.add(OAuth.HeaderType.WWW_AUTHENTICATE,

    oauthResponse.getHeader(OAuth.HeaderType.WWW_AUTHENTICATE));

    System.out.println(“———–服务端/userInfo——————————————————————————”);

    return new ResponseEntity(HttpStatus.BAD_REQUEST);

    }

    }

    }


    此代码对应开发步骤6的前一半。即服务端验证access token、并将资源信息给客户端


    至此,整个Java集成oauth就完成了。


    另外需要验证的客户端信息,如clientIdclientSecret都是自行指定,与自己的项目相关,同时客户端信息的验证方法也是依情况而定,没有什么具体标准,我的demo里为了方便,基本上省略了客户端信息验证,都是默认合法。但是accessTokenUrluserInfoUrlredirectUrl一定要与自己的项目路径相符合。response_typeGrantType有标准模板,见代码。服务端生成的access token也是有标准的,见代码,too

    其他的所有模块和代码就是普通的spring-springmvc-mybatis了。


    项目运行:

    项目下载地址:点击打开链接

    下载项目压缩包,解压,里面两个maven项目:oauthserver和oauthclient01,分别对应oauth服务端和客户端。

    服务端对应的数据库sql文件在源码压缩包里可以看到。

    两个项目分别用8082端口(服务端端口)和8081端口(客户端端口)部署并启动。

    输入客户端地址:http://localhost:8081/oauthclient01/index,显示如下:


    点击到服务端请求资源,就可以得到如下结果:


    即获取到了服务端的资源。






    展开全文
  • Javaoauth2.0 服务端与客户端的实现。 压缩包解压里面两个maven项目:oauthserver和oauthclient01,分别对应oauth服务端和客户端。
  • mcloud-oauth-server基于Spring OAuth2实现OAuth2认证服务器以及资源服务器,并以Restful API的方式提供了OAuth客户端以及用户的管理功能。 项目中主要使用了以下技术: Java8的 Spring相关的Spring,Spring ...
  • java oauth2.0 将Google和GitHub OAuth登录添加到Java应用程序的指南 我们添加到Takipi的最新功能之一是3rd party登录。 如果您像我一样懒惰,那么我想您也希望跳过填写表单和输入新密码的操作 。 只要有权限,...
  • 关于oauth2,其实是一个规范,本文重点讲解spring对他进行的实现 使用oauth2保护你的应用,可以分为简易的分为三个步骤 1.配置资源服务器 2.配置认证服务器 3.配置spring security spring security oauth...
  • springboot从原理上实现oauth2 一直以来,使用spring-cloud-starter-oauth2进行用户认证,然而只要配置一些配置文件,写一个登陆页,就可以进行简单的使用。这样会造成我们无法理解oauth2的工作原理,从哪跳转到哪,...
  • 资源为在eclipse开发环境中使用Java搭建OAuth Server和OAuth Client 参考代码为http://code.google.com/p/oauth/ OAuth Server为遵守OAuth 1.0协议的OAuth认证服务器 OAuth Client分为Desktop版本和Webapp版本
  • OAuth2 Java Shiro 客户端

    千次阅读 2016-10-25 22:36:37
    OAuth2 Java Shiro 客户端 转自:http://jinnianshilongnian.iteye.com/blog/2038646 客户端 客户端流程:如果需要登录首先跳到oauth2服务端进行登录授权,成功后服务端返回auth code,然后客户端使用auth code...
  • @Qualifier("oauth2ClientContext") OAuth2ClientContext oAuth2ClientContext, OAuth2ProtectedResourceDetails details) { return new OAuth2RestTemplate(details, oAuth2ClientContext); } @ResponseBody ...
  • 最近做oauth2预研,查了相当多的资料 因为现有的项目是使用java 语言来实现的,且不打算直接去实现这一整套的标准。因此先去官网(https://oauth.net/code/)看了下现有的java实现。其实还有其他的实现没有收录...
  • public class OAuth2LoginConfig { @Bean public ClientRegistrationRepository clientRegistrationRepository() { return new InMemoryClientRegistrationRepository(aaaClientRegistration()); } @Value("${...
  • OAuth2-DropWizard是OAuth2安全的RESTful服务器的DropWizard实现。 它提供了/ oauth20端点来管理oauth身份验证。 身份验证令牌存储在客户端上的加密cookie中。 这仅通过使用生成的客户端cookie,就可以在对受保护...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,264
精华内容 8,905
关键字:

java自己实现oauth2

java 订阅