精华内容
下载资源
问答
  • Java实现GitHub第三方登录详解

    千次阅读 2018-12-26 17:14:16
    GitHub第三方登录实现效果如下: 实现流程如下: 1.注册一个GitHub账号 2.注册一个授权的网站 保存一个你的Client ID和Client Secret 3.准备一个页面,有一个链接跳转到授权的页面 <a href="...

    GitHub第三方登录实现效果如下:

    实现流程如下:

    1.注册一个GitHub账号
    2.注册一个授权的网站
        保存一个你的Client IDClient Secret
    3.准备一个页面,有一个链接跳转到授权的页面
        <a href="https://github.com/login/oauth/authorize?client_id=xx&state=STATE&redirect_uri=xx">GitHub登录</a>
    4.准备controller去处理callback回调的请求
        ① 获取到请求参数中的code
        ② 拿到code去发送请求请求token
        ③ 拿到token发送请求请求用户信息
        ④ 将用户信息做持久化处理(放到请求范围中)
        ⑤ 在主页面通过el表单获取到前面取到的用户信息...

    OAuth2.0的认证原理

    OAUTH协议为用户资源的授权提供了一个安全的、开放而又简易的标准。与以往的授权方式不同之处是OAUTH的授权不会使第三方触及到用户的帐号信息(如用户名与密码),即第三方无需使用用户的用户名与密码就可以申请获得该用户资源的授权,因此OAUTH是安全的。oAuth是Open Authorization的简写,目前的版本是2.0版。  https://oauth.net/2/ 

    GitHub第三方登录的认证授权流程

    申请 Client ID 和 ClientSecret

    首先到GitHub官网注册账号: https://github.com/

    登录:https://github.com/login

    登录进去之后点击你的头像,选择Settings

    选择左下方的Developer settings创建一个应用

    注册应用之后,可以获取到 Client ID 和 Client Secret  

    申请clientID和clientSecret的用途???

    clientID:应用的唯一标识。

    clientSecretclientID对应的密钥,访问用户资源时用来验证应用的合法性。

    申请地址: https://github.com/settings/developers

    注意:clientIDclientSecret信息进行保密,不要随意泄漏。

    GitHub的登录授权实现

    第三方登录流程是:先获取code --> 然后获取access_token --> 根据token获取用户信息。

    前台页面实现步骤:点击登录按钮 --> 打开一个窗口,进行授权 --> 授权完成,跳转到首页或上次浏览的页面。

    前台准备一个页面,有一个链接跳转到GitHub的授权页面

    https://github.com/login/oauth/authorize?client_id=xx&state=xx&redirect_uri=xx;

    点击跳转到GitHub第三方登录页面

    登录账号进行授权

    授权之后就会跳转到自己之前创建应用时设置的回调路径

    温馨小提示:如果是本地测试可将回调地址修改成本地路径

    温馨小提示:可在GitHub上 https://github.com/settings/applications 取消授权的应用

    登录就算完成了,那么我们怎么去获取用户信息来实现我们的其他功能呢??比如获取用户账号,头像等信息绑定到自己系统的数据库里面

    代码实现   (温馨小提示:这里我将代码都一个文件了,有3个类,需要自己弄出来哦)

    package com.zhengqing.web.controller;
    
    import com.alibaba.fastjson.JSONObject;
    import org.apache.commons.lang.StringUtils;
    import org.apache.http.HttpEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.util.EntityUtils;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    @Controller
    public class GitHubCallBackController {
        //授权成功后的回调,我们需要在这个方法中拿到code去请求token
        @RequestMapping("/callback")
        public String callback(String code, String state) throws Exception{
            //获取到code和state
            System.out.println("code:"+code);
            System.out.println("state:"+state);
    
            if(!StringUtils.isEmpty(code)&&!StringUtils.isEmpty(state)){
                //拿到我们的code,去请求token
                //发送一个请求到
                String token_url = GitHubConstants.TOKEN_URL.replace("CLIENT_ID", GitHubConstants.CLIENT_ID)
                        .replace("CLIENT_SECRET", GitHubConstants.CLIENT_SECRET)
                        .replace("CALLBACK", GitHubConstants.CALLBACK)
                        .replace("CODE", code);
    //           System.out.println("用户信息数据"+token_url);//这个里面有我们想要的用户信息数据
                String responseStr = HttpClientUtils.doGet(token_url);
                String token = HttpClientUtils.parseResponseEntity(responseStr).get("access_token");
    
                //根据token发送请求获取登录人的信息
                String userinfo_url = GitHubConstants.USER_INFO_URL.replace("TOKEN", token);
                responseStr = HttpClientUtils.doGet(userinfo_url);//json
    
                Map<String, String> responseMap = HttpClientUtils.parseResponseEntityJSON(responseStr);
                System.out.println("登录用户信息:"+responseMap);//responseMap里面保存着用户登录信息
                System.out.println("获取登录用户的用户名:"+responseMap.get("login"));
            }
            return "main";// TODO 修改成自己需要返回的页面...
        }
    }
    //抽取出来的参数【代码拷贝下来只需要修改成自己的CLIENT_ID,Client CLIENT_SECRET,CALLBACK即可】
    class GitHubConstants {
        public static final String CLIENT_ID = "xx"; // TODO 修改成自己的
        public static final String CLIENT_SECRET = "xx";  // TODO 修改成自己的
        public static final String CALLBACK = "xx";  // TODO 修改成自己的  [注意:callback要和注册的回调路径保持一致  否则登录授权之后会报NullPointerException]
    
        //获取code的url
        public static final String CODE_URL = "https://github.com/login/oauth/authorize?client_id=CLIENT_ID&state=STATE&redirect_uri=CALLBACK";
        //获取token的url
        public static final String TOKEN_URL = "https://github.com/login/oauth/access_token?client_id=CLIENT_ID&client_secret=CLIENT_SECRET&code=CODE&redirect_uri=CALLBACK";
        //获取用户信息的url
        public static final String USER_INFO_URL = "https://api.github.com/user?access_token=TOKEN";
    }
    //工具类
    class HttpClientUtils {
        /**
         * 使用HttpClient发送一个Get方式的请求
         * @param url 请求的路径 请求参数拼接到url后面
         * @return 响应的数据
         * @throws Exception
         */
        public static String doGet(String url)throws Exception{
            CloseableHttpClient httpclient = HttpClients.createDefault();
            HttpGet httpGet = new HttpGet(url);
            CloseableHttpResponse response = httpclient.execute(httpGet); //发送一个http请求
            //如果响应成功,解析响应结果
            if(response.getStatusLine().getStatusCode()==200){
                HttpEntity responseEntity = response.getEntity(); //获取响应的内容
                return EntityUtils.toString(responseEntity);
            }
            return null;
        }
    
        // 参数的封装
        public static Map<String,String> parseResponseEntity(String responseEntityStr){
            Map<String,String> map = new HashMap<>();
            String[] strs = responseEntityStr.split("\\&");
            for (String str : strs) {
                String[] mapStrs = str.split("=");
                String value = null;
                String key = mapStrs[0];
                if(mapStrs.length>1){
                    value = mapStrs[1];
                }
                map.put(key, value);
            }
            return map;
        }
    
        //json字符串转map
        public static Map<String,String> parseResponseEntityJSON(String responseEntityStr){
            Map<String,String> map = new HashMap<>();
            JSONObject jsonObject = JSONObject.parseObject(responseEntityStr); //解析json格式的字符串
            Set<Map.Entry<String, Object>> entries = jsonObject.entrySet();
            for (Map.Entry<String, Object> entry : entries) {
                String key = entry.getKey();
                String value = String.valueOf(entry.getValue());
                map.put(key, value);
            }
            return map;
        }
    
    }

    maven项目中还需要额外引入如下,其余的就是自己项目的配置,比如上面的代码是springmvc配置通过 @Controller 进行跳转...

        <!-- GitHub第三方登录所需 -->
        <dependency>
          <groupId>org.apache.httpcomponents</groupId>
          <artifactId>httpclient</artifactId>
          <version>4.5.6</version>
        </dependency>
        <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>1.2.47</version>
        </dependency>

     

    可直接拷贝到自己的项目中使用哦,注意修改以下部分哦

    以及注意这个 responseMap 里面封装了我们想要的用户信息数据哦

    ex:repos_url里面有很多我们想要的数据   

    代码最后运行结果: 可根据自己的需求去拿数据

     

    展开全文
  • 主要介绍了使用SpringBoot+OkHttp+fastjson实现Github的OAuth第三方登录,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • GitHub在用户认证过程中采用了双匙机制,在双匙加密机制中,只有合法用户才拥有私匙,只要GitHub在收到请求时可以证明提交请求的客户端上拥有该私匙,即可以确认该操作是由合法用户发起的。我们通过ruby来简单模拟...
  • vue+koa实现github第三方登录

    OAuth(授权)

      三方登入主要基于OAuth 2.0。OAuth协议为用户资源的授权提供了一个安全的、开放而又简易的标准。与以往的授权方式不同之处是OAUTH的授权不会使第三方触及到用户的帐号信息(如用户名与密码),即第三方无需使用用户的用户名与密码就可以申请获得该用户资源的授权,因此OAUTH是安全的。
    在这里插入图片描述

    实际应用

    这里介绍在前端使用vue,后端使用koa的前后端分离环境下github作为第三方登录的情况

    github配置

    首先进入github -> settings -> Developer settings -> GitHub Apps -> OAuth Apps ->点击New OAuth App,进入如下界面
    在这里插入图片描述
    应用的名称随便填,Homepage URL 填写http://localhost:8080(后台服务地址),跳转网址填写 http://localhost:8080/github/callback

    vue下的代码

       login(){
                this.$axios({
                    method: 'get',
                    url: '/test/github/login',
                    params: {
                        path: 'http://localhost:8080'+this.$route.fullPath
                    }
                }).then((res)=>{
                    console.log(res)
                    window.location.href=res.data;
                })
              }
    

    前端向后台请求,并带上当前地址(方便后续跳转回来)。后台返回认证地址及参数,使用window.location.href进行跳转。

    koa下的实现

    const config={
        client_id:'xxxx',    //github生成的ID及密码
        client_secret:'xxxxxxx'
    };
    let redirectPath='http://localhost:8080/'
    router.get('/github/login',async (ctx)=>{
        if(ctx.query.path) redirectPath=ctx.query.path
        var dataStr=(new Date()).valueOf();
        //重定向到认证接口,并配置参数
        var path="https://github.com/login/oauth/authorize";
        path+='?client_id='+config.client_id;
        //将地址及参数返回前端
        ctx.body=path;
    });
    //认证后的github回调
    router.get('/github/callback',async (ctx)=>{
        console.log('callback...')
        const code=ctx.query.code;    //返回的授权码
        const params={
            client_id:config.client_id,
            client_secret: config.client_secret,
            code:code
        }
        //使用这个授权码,向 GitHub 请求令牌
        let res=await axios.post('https://github.com/login/oauth/access_token', params)
        const access_token=querystring.parse(res.data).access_token
        //再通过令牌获取用户信息
        res=await axios.get('https://api.github.com/user?access_token=' + access_token)
        // console.log('userAccess:', res.data)
         // ctx.body = res.data
        ctx.cookies.set('user',res.data.login)  //用户名称
        ctx.cookies.set('icon',res.data.avatar_url)  //用户图片
        ctx.redirect(redirectPath)  //重定向到请求页面
    })
    

    后端通过一系列的请求获取到用户信息,将其通过cookies的形式返回到前端界面(当然也可以通过参数的形式)
    至此前后端就完整的完成了一次github的第三方登录。

    展开全文
  • Node.js实现GitHub第三方登录

    千次阅读 2017-08-28 16:50:27
    后来在使用阿里巴巴矢量图库-http://www.iconfont.cn/ 的时候看见了使用GitHub第三方登录,这个是Web端的,今天就自己动手实现了这个功能。登录流程 上图就是基本的登录流程了。GitHub设置填写应用信息1.首先登录你...

    之前在《Node.js+express+MySQL仿美团注册登录绑定第三方登录》这里做的是app的第三方登录,里面有app的流程。后来在使用阿里巴巴矢量图库-http://www.iconfont.cn/ 的时候看见了使用GitHub第三方登录,这个是Web端的,今天就自己动手实现了这个功能。

    登录流程

    这里写图片描述
    上图就是基本的登录流程了。

    GitHub设置

    填写应用信息

    1.首先登录你的GitHub,然后点击进入Settings;
    这里写图片描述
    2.选择OAuth Apps
    这里写图片描述
    3.注册应用信息
    这里写图片描述
    4.填写应用信息
    这里写图片描述
    这里主要是Authorization callback URL的填写;
    这个应用回调地址就是上面登录流程授权之后返回的redirect_uri

    获取Client_id和Client_secret

    上面填写应用信息中,其实就可以看见着连个了。
    这里写图片描述
    上面的0 users说明目前还没GitHub账号登录应用。
    上面的GitHub设置的官方文档-Registering OAuth Apps

    看文档

    在代码实现之前还是先看看文档。
    About authorization options for OAuth Apps
    其实文档里面已经清晰的说明了授权登录的主要3个步骤:
    1.web端重定向http://github.com/login/oauth/authorize
    2.根据code获取access_token;
    3.根据access_token获取用户信息;
    这里的第2步和第3步,建议在后端实现,为什么在后端实现了,因为第2不接口里面需要Client_secret这个参数。

    代码实现

    效果

    在代码实现之前先看效果:
    http://manage.hgdqdev.cn/
    这里写图片描述
    1.用户点击GitHub图标;
    2.重定向到GitHub授权登录页面;
    3.授权成功,向后端发送请求获取用户信息,显示用户名。

    前端代码实现

    前端代码这里基本就是上面的流程,具体代码可以去这里看,这个前端项目我已经开源了:https://github.com/zhuming3834/manage/blob/master/src/components/page/Login.vue

    后端代码实现

    前端把获取到的code发送个后端,后端获取到用户信息后返回给前端。

    /*
     *  github 第三方 登录
     */
    var express = require('express');
    var router = express.Router();
    var request = require('request'); 
    var githubConfig = {
        // 客户ID
        client_ID: '7***************6',
        // 客户密匙
        client_Secret: '4******************************f',
        // 获取 access_token
        // eg: https://github.com/login/oauth/access_token?client_id=7***************6&client_secret=4***************f&code=9dbc60118572de060db4&redirect_uri=http://manage.hgdqdev.cn/#/login
        access_token_url: 'https://github.com/login/oauth/access_token',
        // 获取用户信息
        // eg: https://api.github.com/user?access_token=86664b010dbb841a86d4ecc38dfeb8ac673b9430&scope=&token_type=bearer
        user_info_url: 'https://api.github.com/user?',
        // 回调地址
        redirect_uri: 'http://manage.hgdqdev.cn/#/login'
    }
    router.all('/api/github/user_info', function(req, res, next) {
        var param = req.query || req.params; 
        var code = param.code || '';
        if (code == '') {
            res.end(JSON.stringify({
                msg: '请传入正确的参数',
                status: 103
            }));
            return;
        }
        request({
            url: githubConfig.access_token_url,
            form: {
                client_id: githubConfig.client_ID,
                client_secret: githubConfig.client_Secret,
                code: code,
                redirect_uri: githubConfig.redirect_uri
            }},
            function(error, response, body){
                if (!error && response.statusCode == 200) {
                    var urlStr = githubConfig.user_info_url + body;
                    request({
                            url: urlStr,
                            headers: {
                                'User-Agent': 'zhuming3834'
                            }
                        },
                        function(error, response, resbody){
                            if (!error) {
                                res.end(JSON.stringify({
                                    msg: '获取成功',
                                    status: 100,
                                    data: JSON.parse(resbody)
                                }));
                            }else{
                                res.end(JSON.stringify({
                                    msg: '获取用户信息失败',
                                    status: 102
                                }));
                            }
                        }
                    )
                }else{
                    res.end(JSON.stringify({
                        msg: '获取用户信息失败',
                        status: 101
                    }));
                }
            }
        )
    })

    其实这里的代码没什么难度,主要是流程。但是在第2个请求的时候我设置了一个:

    headers: {
      'User-Agent': 'zhuming3834'
    }

    为什么呢?其实也是踩坑过来了。如果不设置会报错导致请求不成功,报错信息:

    Request forbidden by administrative rules. Please make sure your request has a User-Agent header (http://developer.github.com/v3/#user-agent-required). Check https://developer.github.com for other possible causes.\n'

    其实也就是HTTP请求的403错误,但是这个请求在浏览器端是没有任何问题了。为什么呢?
    这里还是看官方的说明:User Agent Required
    这里写图片描述
    这里其实告诉了我们解决办法,就是把User-Agent设置成你的GitHub的用户名或者应用名,这里我设置的是GitHub的用户名。

    最后

    最后我们发现第三方登录的流程其实都差不多,差别就是不同的平台,和自己应用的业务会有点不一样。所以呢,在做之前先要理清思路,仔细看文档。

    展开全文
  • 实现GitHub第三方登陆详细过程

    千次阅读 2018-12-27 18:39:12
    二步:创建一个应用并填写信息 在这里插入图片描述 四步:在前台准备一个按钮用于GitHub账号登陆: &lt;a href="https://github.com/login/oauth/authorize?client_id=对应自己申请的client id &...
    • 第一步:登陆GitHub官网注册账号登陆后:
      在这里插入图片描述
    • 第二步:创建一个应用并填写信息
      在这里插入图片描述在这里插入图片描述在这里插入图片描述
      在这里插入图片描述
    • 第四步:在前台准备一个按钮用于GitHub账号登陆:
    <a href="https://github.com/login/oauth/authorize?client_id=对应自己申请的client id
    &state=STATE&redirect_uri=http://localhost/callback;">github登录</a>
    

    注意:redirect_uri是回调地址,必须和在注册应用时候填写的回调地址一致。

    • 第五步:准备java代码,这步中的部分方法和常量依赖于后面的:【常量类】、【自定义工具类】
    package cn.itsource.crm.web.controller;
    
    import cn.itsource.crm.domain.Github;
    import cn.itsource.crm.service.IGithubService;
    import cn.itsource.util.GitHubConstant;
    import cn.itsource.util.HttpClientUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Map;
    
    /**
     * @Created with IDEA
     * @author: Super Zheng
     * @Description: 第三方登陆GitHub
     * @Date:2018/12/26
     * @Time:18:59
     */
    @Controller
    public class GithubLoginController {
    
        @Autowired
        private IGithubService githubService;
    	//回调地址
        @RequestMapping("/callback")
        public String callback(String code, String state, Model model, HttpServletRequest req) throws Exception{
    
            if(!StringUtils.isEmpty(code)&&!StringUtils.isEmpty(state)){
                //拿到我们的code,去请求token
                //发送一个请求到
                String token_url = GitHubConstant.TOKEN_URL.replace("CODE", code);
    	 	    //得到的responseStr是一个字符串需要将它解析放到map中
                String responseStr = HttpClientUtils.doGet(token_url);
                // 调用方法从map中获得返回的--》 令牌
                String token = HttpClientUtils.getMap(responseStr).get("access_token");
    
                //根据token发送请求获取登录人的信息  ,通过令牌去获得用户信息
                String userinfo_url = GitHubConstant.USER_INFO_URL.replace("TOKEN", token);
                responseStr = HttpClientUtils.doGet(userinfo_url);//json
    
                Map<String, String> responseMap = HttpClientUtils.getMapByJson(responseStr);
                // 成功则登陆
                return "/main";
            }
            // 否则返回到登陆页面
            return "/login/login";
        }
    }
    
    
    • 代码中的常量字段:
    package cn.itsource.util;
    
    /**
     * @Created with IDEA
     * @author: Super Zheng
     * @Description: java类作用描述
     * @Date:2018/12/26
     * @Time:12:20
     */
    public class GitHubConstant {
        // 这里填写在GitHub上注册应用时候获得 CLIENT ID
        public static final String  CLIENT_ID="a7dc7e3d";
    	//这里填写在GitHub上注册应用时候获得 CLIENT_SECRET
        public static final String CLIENT_SECRET="1faa46333a4d1c904";
        // 回调路径
        public static final String CALLBACK = "http://localhost/callback";
    
        //获取code的url
        public static final String CODE_URL = "https://github.com/login/oauth/authorize?client_id="+CLIENT_ID+"&state=STATE&redirect_uri="+CALLBACK+"";
        //获取token的url
        public static final String TOKEN_URL = "https://github.com/login/oauth/access_token?client_id="+CLIENT_ID+"&client_secret="+CLIENT_SECRET+"&code=CODE&redirect_uri="+CALLBACK+"";
        //获取用户信息的url
        public static final String USER_INFO_URL = "https://api.github.com/user?access_token=TOKEN";
    
    }
    
    
    • 第三方登陆工具类中用到的依赖包:
    <dependencies>
            <!--java代码发送请求依赖包-->
            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpclient</artifactId>
                <version>4.5.6</version>
            </dependency>
            <!--将json转换成map-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.47</version>
            </dependency>
      </dependencies>
    
    • 第三方登陆工具类:
    package cn.itsource.util;
    import com.alibaba.fastjson.JSONObject;
    import org.apache.http.HttpEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.util.EntityUtils;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @Created with IDEA
     * @author: Super Zheng
     * @Description: java类作用描述
     * @Date:2018/12/26
     * @Time:12:58
     */
    public class HttpClientUtils {
    
        /**
         * 发送get请求,利用java代码发送请求
         * @param url
         * @return
         * @throws Exception
         */
        public static String doGet(String url) throws Exception{
    
            CloseableHttpClient httpclient = HttpClients.createDefault();
    
            HttpGet httpGet = new HttpGet(url);
            // 发送了一个http请求
            CloseableHttpResponse response = httpclient.execute(httpGet);
            // 如果响应200成功,解析响应结果
            if(response.getStatusLine().getStatusCode()==200){
                // 获取响应的内容
                HttpEntity responseEntity = response.getEntity();
    
                return EntityUtils.toString(responseEntity);
            }
            return null;
        }
    
        /**
         * 将字符串转换成map
         * @param responseEntity
         * @return
         */
        public static Map<String,String> getMap(String responseEntity) {
    
            Map<String, String> map = new HashMap<>();
            // 以&来解析字符串
            String[] result = responseEntity.split("\\&");
    
            for (String str : result) {
                // 以=来解析字符串
                String[] split = str.split("=");
                // 将字符串存入map中
                if (split.length == 1) {
                    map.put(split[0], null);
                } else {
                    map.put(split[0], split[1]);
                }
    
            }
            return map;
        }
    
        /**
         * 通过json获得map
         * @param responseEntity
         * @return
         */
        public static Map<String,String> getMapByJson(String responseEntity) {
            Map<String, String> map = new HashMap<>();
            // 阿里巴巴fastjson  将json转换成map
            JSONObject jsonObject = JSONObject.parseObject(responseEntity);
            for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
                String key = entry.getKey();
                // 将obj转换成string
                String value = String.valueOf(entry.getValue()) ;
                map.put(key, value);
            }
            return map;
        }
    }
    
    
    • 第六步:测试
      -在这里插入图片描述
      在这里插入图片描述
    • 总结:整体原理分析:
      在这里插入图片描述
    展开全文
  • JAVA-网站应用接入GitHub第三方登录

    千次阅读 2019-05-25 14:45:35
    JAVA-网站应用接入GitHub第三方登录 相对 网站应用接入 QQ 登录,简单很多,Github 直接创建应用就可以用,不需要长时间的审核 GitHub 开发者官方文档:...
  • 最近一直在学习springboot,刚刚看完雷丰阳老师讲的...找到了现在学习的这个视频,码匠社区项目,看了几节,感觉还可以,项目中用到了GitHub第三方登录,第一次接触,感觉挺好用的,自然要写篇博客记录一下啦...
  • github第三方登录 本质就是OAuth授权 分析 应用开发方先在第三方的开放认证平台申请app的授权,得到id和key 应用前端账号密码登录区域,提供入口让用户跳到第三方的授权登录页 跳转链接:...
  • 用Python实现使用GitHub账号...下面就以 GitHub 为例,写一个最简单的应用,演示第三方登录。 一、第三方登录的原理 所谓第三方登录,实质就是 OAuth 授权。用户想要登录 A 网站,A 网站让用户提供第三方网站的数据...
  • 以下将采用一个实例,实现第三方网站登录 Github
  • 使使用用SpringBoot+OkHttp+fastjson实实现现Github的的OAuth第第三三方方登登录录 这篇文章主要介绍了使用SpringBoot+OkHttp+fastjson实现Github的OAuth第三方登录文中通过示例代码介绍的 非常详细对大家的学习或者...
  • django实现github第三方本地登录

    千次阅读 2016-04-26 12:36:29
    实现github第三方登录,首先你必须要有github账号呀,so,登陆到 github官网 注册 在你的github账号中的profile里面找到Oauth application ,在Homepage URL和Authorization callback URL里面都填 ...
  • 第三方登录Github登录篇

    千次阅读 2020-05-12 11:10:29
    文章目录前言正文创建App图解流程: 前言 在前面项目的学习中用来练手的都是本地的项目,进行一个用户名和密码登录即可,也做过一些的限制操作等,比如...今天这里来介绍一下Github第三方验证登录,后续的还有gitee,QQ
  • spring boot 使用 github进行第三方登录

    千次阅读 2019-06-12 00:07:52
    github作为网站的第三方登录,首先需要了解github给我们提供了怎样的api.登录github官网(略),点击底部“API” 下面这个就是我们需要用的,点击“Read the docs”看看具体怎么说 可以看到github给我们提供了...
  • GitHub OAuth 第三方登录示例教程 很多网站登录时,允许使用第三方网站的身份,这称为"第三方登录"。 下面就以 GitHub 为例,写一个最简单的应用,演示第三方登录。 一、第三方登录的原理 所谓第三方登录,实质就是...
  • 【第三方互联】十四、Github授权第三方登录

    千次阅读 多人点赞 2020-04-08 20:44:41
    今天我们继续学习:Github授权第三方登录,前面我们已经学习了 码云(Gitee)授权第三方登录Github授权第三方登录实现过程其实和 码云(Gitee)授权第三方登录实现过程类似,只是有一些细节需要注意,下面我们...
  • github 和gitee 第三方登录 实现过程

    千次阅读 2019-12-04 13:24:07
    现在很多站点都支持第三方登录功能, 如何实现第三方登录,做以下记录: 首先有一个GitHub账号 登录Github 点击 setting 点击开发者设置 新建一个授权应用 填写信息 获取Client ID和Client Secret 后端程序...
  • Github 第三方授权登陆

    2020-05-13 10:58:56
    1.在Github上创建一个OAuth App 在Github上按照官方文档【Creating an OAuth App】进行操作 主要是填写: 创建成功之后会得到授权用户数目和授权需要用到的参数: 2.授权登陆【Authorizing OAuth Apps官方文档】 ...
  • Github第三方登录

    千次阅读 2016-01-15 11:08:36
    第三方登录的定义 所谓的第三方登录,就是利用用户在第三方平台上已有的账号来快速完成自己应用的登录或者注册的...要实现第三方登录,首先你需要选择一个第三方平台。新浪微博和QQ空间都是好的选择,这些平台拥有大
  • 在讲解支付宝、QQ、微博、Github、百度账号第三方登录之前,我们有必要先了解一下第三登录所使用的协议。具体的详细内容请看我的这篇博客: https://blog.csdn.net/weixin_43885417/article/details/91163338 开始入...
  • Github是专为github精心打造的一款Android客户端,该客户端功能强大,包含常用的github浏览以及部分操作功能;界面绚丽,适配Material Design;操作简便,可以说是为githuber们量身而作的口袋神器! 效果图 功能Tab...
  • 第三方授权登录原理 网页登录认证,请求后台服务器 后台服务器重定向到GitHub认证 GitHub服务器第三方认证 GitHub服务器认证成功,回调带回认证状态code给后台服务器 后台 服务器用code想GitHub服务器申请令牌 申请...
  • Vue + Java 实现QQ第三方登录授权

    千次阅读 2019-09-22 00:34:15
    Vue 实现QQ第三方登录授权需要获取到 APP_ID和回调域地址,关于这2个的获取方式可以参考小编的另外一篇文章 Java 实现QQ第三方登录 温馨小提示: 本文基于springboot+vue前后端分离的架构实现三方登录授权 主要实现...
  • java 实现 github第三方登陆代码模板

    千次阅读 2020-05-24 23:52:32
    } } 发出请求后回调的地址 这里为了方便一点用servlet实现 import javax.servlet.annotation.WebServlet; import java.io.IOException; /** * @author cimo */ @WebServlet(name = "GithubLogingCallBack") public ...
  • 7月7日,今天是高考的日子,没错是受疫情影响高考...如题,要想实现GitHub授权登录,你必须拥有GitHub账号,并且创建自己的OAuth App。 1. 创建OAuth App。 github个人主页 ➡ Settings ➡ Developer settings ➡ OA.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 134,096
精华内容 53,638
关键字:

怎么实现github第三方登录