Google第三方登录的实现

最新推荐文章于 2024-09-10 11:54:13 发布
最新推荐文章于 2024-09-10 11:54:13 发布
阅读量8.8k 收藏 11
点赞数
分类专栏： 第三方登录 文章标签： OAuth2.0 Google第三方登录 java 谷歌第三方登录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MadSoulChild/article/details/90479085
版权

谷歌第三方登录实现

  1. Controller类的实现
import cn.stylefeng.guns.core.util.HttpClientUtil;
import net.sf.json.JSONObject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
* @ClassName: LoginController
* @Description: Google第三方登录
* @param
* @date Mar 13, 2017
*/
@Controller
public class GLoginController {

   private static String client_id = "693702919517-g5jgaqdt3et1k81kh8k1otgdlkuvkf04.apps.googleusercontent.com";
   private static String client_secret = "JupmsoPgdrm9ph9dhkC-wq25";
   private static String scope = "https://www.googleapis.com/auth/drive.metadata.readonly";
   private static String redirect_url = "http://localhost:8081/GoogleUserInfo";
   private static String code_url = "https://accounts.google.com/o/oauth2/v2/auth";
   private static String token_url = "https://www.googleapis.com/oauth2/v4/token";
   private static String user_url = "https://www.googleapis.com/oauth2/v2/userinfo";
   private static String verify_url = "https://www.googleapis.com/oauth2/v3/tokeninfo";

   /**
    * @Title: Login
    * @Description: google登录验证后会重定向到此地址，并附带访问授权码，不能为公开的ip地址
    * @author 此方法是用带回的code换取accessToken，然后用accessToken换取用户信息，这个地址就是在创建应用时定义的重定向地址
    * @return Object
    * @date Mar 23, 2017 10:37:38 AM
    * @throws
    */
   @RequestMapping(value = "/GoogleUserInfo")
   @ResponseBody
   public static Object Login(HttpServletRequest request) {
       String code = request.getParameter("code");
       System.out.println(code);

//		String idToken = getGoogleAccessToken(code);
//		System.out.println(idToken);
//		JSONObject verifyToken = verifyToken(idToken);
//		System.out.println(verifyToken);

       String accessToken = getGoogleAccessToken(code);
       System.out.println(accessToken);
       JSONObject userInfo = getUserInfo(accessToken);
       System.out.println(userInfo);
       return userInfo;
   }

   /**
    * @throws Exception
    * @Title: sendRedirect
    * @Description:发送授权请求
    * @author 第二步，在google.jsp中用户登录成功以后回跳转到这个路径，发送请求让用户授权，授权成功后重定向到/GoogleUserInfo，也就是创建应用时定义的重定向地址
    * @return String
    * @date Mar 24, 2017 3:11:36 PM
    * @throws
    */
   @RequestMapping(value = "/sendRedirect")
   public void sendRedirect(HttpServletResponse response) throws Exception {
       // 随机字符串，防止csrf攻击
       String state = UUID.randomUUID() + "";
       Map<String, String> params = new HashMap<String, String>();
       params.put("client_id", client_id);
       params.put("redirect_uri", redirect_url);
       params.put("response_type", "code");
       params.put("scope", scope);
       params.put("access_type", "offline");
       params.put("state", state);
       params.put("include_granted_scopes", "true");
       String url = code_url+"?"+ "client_id=" +client_id+
                                  "&redirect_uri="+ redirect_url+
                                  "&response_type=code" +
                                  "&scope="+ scope+
                                  "&access_type=offline"+
                                  "&state="+ state+
                                  "&include_granted_scopes=true";
       //String url = HttpClientUtil.getUrl(code_url, params);
       response.sendRedirect(url);
   }

   /**
    * @Title: getGoogleAccessToken
    * @Description: 获取accessToken
    * @author 第三步，用重定向带回来的code换取accessToken
    * @return String
    * @date Mar 25, 2017 10:25:00 AM
    * @throws
    */
   public static String getGoogleAccessToken(String code) {
       HashMap<String, String> params = new HashMap<String, String>();
       params.put("client_id", client_id);
       params.put("redirect_uri", redirect_url);
       params.put("client_secret", client_secret);
       params.put("grant_type", "authorization_code");
       params.put("code", code);
       String httpClientResult = null;
       String accessToken =null;
       String idToken=null;
       try {
           httpClientResult = HttpClientUtil.doPost(token_url, params, "utf-8");
       } catch (Exception e) {
           e.printStackTrace();
       }
       if (null != httpClientResult ) {
           //String result = httpClientResult.getContent();
           String result = httpClientResult;
           JSONObject jsonObject = JSONObject.fromObject(result);
           accessToken = jsonObject.getString("access_token");
           idToken=jsonObject.getString("id_token");
       }
       return accessToken;
//		return idToken;
   }

   /**
    * @Title: getUserInfo
    * @Description: 获取用户信息
    * @author第四步，用accessToken获取用户信息
    * @return String
    * @date Mar 25, 2017 11:50:23 AM
    * @throws
    */
   public static JSONObject getUserInfo(String accessToken) {
       HashMap<String, String> params = new HashMap<String,String>();
       params.put("access_token", accessToken);
       String responseResult =null;
       JSONObject userInfo=null;
       try {
           responseResult = HttpClientUtil.doGet(user_url, params);
       } catch (Exception e) {
           e.printStackTrace();
       }
       if (null != responseResult) {
           String result = responseResult;
           userInfo =  JSONObject.fromObject(result);
       }
       return userInfo;
   }

   /**
    * @Title: verifyToken
    * @Description:验证用户token是否是来自本应用的请求，校验aud和clientID是否相同
    * @author第五步，验证用户是否来自你的应用，防刷，根据需要加到逻辑里
    * @return String
    * @date Mar 25, 2017 7:36:33 PM
    * @throws
    */
   public static JSONObject verifyToken(String idToken){
       HashMap<String, String> params = new HashMap<String,String>();
       params.put("id_token", idToken);
       String responseResult =null;
       JSONObject verifyInfo=null;
       try {
           responseResult = HttpClientUtil.doGet(verify_url, params);
       } catch (Exception e) {
           e.printStackTrace();
       }
       if (null != responseResult) {
           String result = "";
       verifyInfo =  JSONObject.fromObject(result);
   }
       return verifyInfo;
   }

}
  1. Utils类的实现
import java.io.Serializable;

/**
 * Description: 封装httpClient响应结果
 *
 * @author JourWon
 * @date Created on 2018年4月19日
 */
public class HttpClientResult implements Serializable {

    private static final long serialVersionUID = 2168152194164783950L;

    /**
     * 响应状态码
     */
    private int code;

    /**
     * 响应数据
     */
    private String content;

    public HttpClientResult() {
    }

    public HttpClientResult(int code) {
        this.code = code;
    }

    public HttpClientResult(String content) {
        this.content = content;
    }

    public HttpClientResult(int code, String content) {
        this.code = code;
        this.content = content;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "HttpClientResult [code=" + code + ", content=" + content + "]";
    }

}

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;


public class HttpClientUtil {

    private static final Logger LOG = Logger.getLogger(HttpClientUtil.class);

    public static String doGet(String url, Map<String, String> param) throws Exception {

        // 创建Httpclient对象
//        CloseableHttpClient httpclient = HttpClients.createDefault();
        CloseableHttpClient httpclient = new SSLClient();

        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);

            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } catch (Exception e) {
            LOG.error(e);
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                // httpclient.close();
            } catch (IOException e) {
                LOG.error(e);
            }
        }
        return resultString;
    }

    public static String doPost(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            LOG.error(e);

        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                LOG.error(e);
            }
        }

        return resultString;
    }

    public static String doPostOfJson(String url, String json) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            LOG.error(e);

        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                LOG.error(e);
            }
        }

        return resultString;
    }

    public static String doPutOfJson(String url, String json) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Put请求
            HttpPut httpPut = new HttpPut(url);
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPut.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPut);
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            LOG.error(e);

        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                LOG.error(e);
            }
        }

        return resultString;
    }

    public static String doDelete(String url, Map<String, String> param) {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();
            // 创建Http Delete请求
            HttpDelete httpDelete = new HttpDelete(uri);
            // 执行http请求
            response = httpClient.execute(httpDelete);
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            LOG.error(e);

        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                LOG.error(e);
            }
        }

        return resultString;
    }

    public static String doDeleteOfJson(String url, String json) {
        /**
         * 没有现成的delete可以带json的，自己实现一个，参考HttpPost的实现
         */
        class HttpDeleteWithBody extends HttpEntityEnclosingRequestBase {
            public static final String METHOD_NAME = "DELETE";

            @SuppressWarnings("unused")
            public HttpDeleteWithBody() {
            }

            @SuppressWarnings("unused")
            public HttpDeleteWithBody(URI uri) {
                setURI(uri);
            }

            public HttpDeleteWithBody(String uri) {
                setURI(URI.create(uri));
            }

            @Override
            public String getMethod() {
                return METHOD_NAME;
            }
        }

        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            HttpDeleteWithBody httpDelete = new HttpDeleteWithBody(url);
            StringEntity params = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpDelete.setEntity(params);
            // 执行http请求
            response = httpClient.execute(httpDelete);
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            LOG.error(e);

        } finally {
            try {
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                LOG.error(e);
            }
        }

        return resultString;
    }

    /*
     * 利用HttpClient进行post请求的工具类,键值对方式组装数据
     */
    public static String doPost(String url, Map<String, String> map, String charset) {
        HttpClient httpClient = null;
        HttpPost httpPost = null;
        String result = null;
        try {
            httpClient = new SSLClient();
            httpPost = new HttpPost(url);
            //设置参数
            List<NameValuePair> list = new ArrayList<NameValuePair>();
            Iterator iterator = map.entrySet().iterator();
            while (iterator.hasNext()) {
                Entry<String, String> elem = (Entry<String, String>) iterator.next();
                list.add(new BasicNameValuePair(elem.getKey(), elem.getValue()));
            }
            if (list.size() > 0) {
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, charset);
                httpPost.setEntity(entity);
            }
            HttpResponse response = httpClient.execute(httpPost);
            if (response != null) {
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    result = EntityUtils.toString(resEntity, charset);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return result;
    }

}

import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

public class SSLClient extends DefaultHttpClient {
    //用于进行Https请求的HttpClient
    public SSLClient() throws Exception {
        super();
        SSLContext ctx = SSLContext.getInstance("TLS");
        X509TrustManager tm = new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { }
            @Override
            public void checkServerTrusted(X509Certificate[] chain,String authType) throws CertificateException { }
            @Override
            public X509Certificate[] getAcceptedIssuers() {return null; }
        };
        ctx.init(null, new TrustManager[]{tm}, null);
        SSLSocketFactory ssf = new SSLSocketFactory(ctx, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
        ClientConnectionManager ccm = this.getConnectionManager();
        SchemeRegistry sr = ccm.getSchemeRegistry();
        sr.register(new Scheme("https", 443, ssf));
    }
}
  1. 前端页面的实现
//引入openid-jquery.js
/*
   Simple OpenID Plugin
   http://code.google.com/p/openid-selector/
   
   This code is licensed under the New BSD License.
*/

var providers;
var openid;
(function ($) {
openid = {
   version : '1.3', // version constant
   demo : false,
   demo_text : null,
   cookie_expires : 6 * 30, // 6 months.
   cookie_name : 'openid_provider',
   cookie_path : '/',

   img_path : 'images/',
   locale : null, // is set in openid-<locale>.js
   sprite : null, // usually equals to locale, is set in
   // openid-<locale>.js
   signin_text : null, // text on submit button on the form
   all_small : false, // output large providers w/ small icons
   no_sprite : false, // don't use sprite image
   image_title : '{provider}', // for image title

   input_id : null,
   provider_url : null,
   provider_id : null,

   /**
    * Class constructor
    * 
    * @return {Void}
    */
   init : function(input_id) {
   	providers = $.extend({}, providers_large, providers_small);
   	var openid_btns = $('#openid_btns');
   	this.input_id = input_id;
   	$('#openid_choice').show();
   	$('#openid_input_area').empty();
   	var i = 0;
   	// add box for each provider
   	for (id in providers_large) {
   		box = this.getBoxHTML(id, providers_large[id], (this.all_small ? 'small' : 'large'), i++);
   		openid_btns.append(box);
   	}
   	if (providers_small) {
   		openid_btns.append('<br/>');
   		for (id in providers_small) {
   			box = this.getBoxHTML(id, providers_small[id], 'small', i++);
   			openid_btns.append(box);
   		}
   	}
   	$('#openid_form').submit(this.submit);
   	var box_id = this.readCookie();
   	if (box_id) {
   		this.signin(box_id, true);
   	}
   },

   /**
    * @return {String}
    */
   getBoxHTML : function(box_id, provider, box_size, index) {
   	if (this.no_sprite) {
   		var image_ext = box_size == 'small' ? '.ico.gif' : '.gif';
   		return '<a title="' + this.image_title.replace('{provider}', provider["name"]) + '" href="javascript:openid.signin(\'' + box_id + '\');"'
   				+ ' style="background: #FFF url(' + this.img_path + '../images.' + box_size + '/' + box_id + image_ext + ') no-repeat center center" '
   				+ 'class="' + box_id + ' openid_' + box_size + '_btn"></a>';
   	}
   	var x = box_size == 'small' ? -index * 24 : -index * 100;
   	var y = box_size == 'small' ? -60 : 0;
   	return '<a title="' + this.image_title.replace('{provider}', provider["name"]) + '" href="javascript:openid.signin(\'' + box_id + '\');"'
   			+ ' style="background: #FFF url(' + this.img_path + 'openid-providers-' + this.sprite + '.png); background-position: ' + x + 'px ' + y + 'px" '
   			+ 'class="' + box_id + ' openid_' + box_size + '_btn"></a>';
   },

   /**
    * Provider image click
    * 
    * @return {Void}
    */
   signin : function(box_id, onload) {
   	var provider = providers[box_id];
   	if (!provider) {
   		return;
   	}
   	this.highlight(box_id);
   	this.setCookie(box_id);
   	this.provider_id = box_id;
   	this.provider_url = provider['url'];
   	// prompt user for input?
   	if (provider['label']) {
   		this.useInputBox(provider);
   	} else {
   		$('#openid_input_area').empty();
   		if (!onload) {
   			$('#openid_form').submit();
   		}
   	}
   },

   /**
    * Sign-in button click
    * 
    * @return {Boolean}
    */
   submit : function() {
   	var url = openid.provider_url;
   	if (url) {
   		url = url.replace('{username}', $('#openid_username').val());
   		openid.setOpenIdUrl(url);
   	}
   	if (openid.demo) {
   		alert(openid.demo_text + "\r\n" + document.getElementById(openid.input_id).value);
   		return false;
   	}
   	if (url.indexOf("javascript:") == 0) {
   		url = url.substr("javascript:".length);
   		eval(url);
   		return false;
   	}
   	return true;
   },

   /**
    * @return {Void}
    */
   setOpenIdUrl : function(url) {
   	var hidden = document.getElementById(this.input_id);
   	if (hidden != null) {
   		hidden.value = url;
   	} else {
   		$('#openid_form').append('<input type="hidden" id="' + this.input_id + '" name="' + this.input_id + '" value="' + url + '"/>');
   	}
   },

   /**
    * @return {Void}
    */
   highlight : function(box_id) {
   	// remove previous highlight.
   	var highlight = $('#openid_highlight');
   	if (highlight) {
   		highlight.replaceWith($('#openid_highlight a')[0]);
   	}
   	// add new highlight.
   	$('.' + box_id).wrap('<div id="openid_highlight"></div>');
   },

   setCookie : function(value) {
   	var date = new Date();
   	date.setTime(date.getTime() + (this.cookie_expires * 24 * 60 * 60 * 1000));
   	var expires = "; expires=" + date.toGMTString();
   	document.cookie = this.cookie_name + "=" + value + expires + "; path=" + this.cookie_path;
   },

   readCookie : function() {
   	var nameEQ = this.cookie_name + "=";
   	var ca = document.cookie.split(';');
   	for ( var i = 0; i < ca.length; i++) {
   		var c = ca[i];
   		while (c.charAt(0) == ' ')
   			c = c.substring(1, c.length);
   		if (c.indexOf(nameEQ) == 0)
   			return c.substring(nameEQ.length, c.length);
   	}
   	return null;
   },

   /**
    * @return {Void}
    */
   useInputBox : function(provider) {
   	var input_area = $('#openid_input_area');
   	var html = '';
   	var id = 'openid_username';
   	var value = '';
   	var label = provider['label'];
   	var style = '';
   	if (label) {
   		html = '<p>' + label + '</p>';
   	}
   	if (provider['name'] == 'OpenID') {
   		id = this.input_id;
   		value = 'http://';
   		style = 'background: #FFF url(' + this.img_path + 'openid-inputicon.gif) no-repeat scroll 0 50%; padding-left:18px;';
   	}
   	html += '<input id="' + id + '" type="text" style="' + style + '" name="' + id + '" value="' + value + '" />'
   			+ '<input id="openid_submit" type="submit" value="' + this.signin_text + '"/>';
   	input_area.empty();
   	input_area.append(html);
   	$('#' + id).focus();
   },

   setDemoMode : function(demoMode) {
   	this.demo = demoMode;
   }
};
})(jQuery);

//添加谷歌图标的点击按钮（注：下面的一些参数需要在谷歌的https://console.developers.google.com/apis/credentials/oauthclient网址中配置）

<a href="https://accounts.google.com/o/oauth2/auth?response_type=code&client_id=693702919517-g5jgaqdt3et1k81kh8k1otgdlkuvkf04.apps.googleusercontent.com&redirect_uri=http://localhost:8081/GoogleUserInfo&scope=https://www.googleapis.com/auth/userinfo.email"><i class="iconfont layui-extend-google"></i></a>
方恨少_
关注
专栏目录
Java实现第三方登录
03-15
Java中实现第三方登录，我们可以使用各种库来简化这个过程，例如Spring Security OAuth2，这是一个强大的安全框架，提供了对OAuth2的支持。以下是一般步骤： 1. **配置OAuth2客户端**：在你的项目中，你需要配置...
Google登录授权详细过程
热门推荐
qq_37754001的博客
03-23 3万+
这篇文章包含了google登录授权从API创建、到使用Java代码完成登录的一个完整demo。 目录 了解Auth2.0 创建API服务 使用API 了解Auth2.0 google相关文档:https://developers.google.com/identity/protocols/oauth2 google账号授权登录用的就是Auth2.0协议。 举一个例子了解Auth2.0的设计模式。 令牌 Token 你在公司某个周五的下午点了一杯奶茶，楼下有个需要密码才能进来的门禁，你当然不
Google Gmail Oauth Client ID 认证指南
hantangduhey的博客
09-05 3321
Google Gmail Oauth Client ID 认证指南
java集成google登录（gmail）
m0_72293405的博客
09-10 739
SpringClous+Vue2集成实现google邮箱一键登录
Google新版第三方登录（Javascript SDK）
weixin_43240744的博客
08-06 3822
谷歌第三方登录javascript SDK方案
Java实现Google第三方登录
qq_43548590的博客
12-14 6505
Java实现Google第三方登录
Vue和C#通过Google OAuth 2.0授权登录并获取用户信息
让梦想疯狂
06-26 1303
Vue和C#通过Google OAuth 2.0授权登录并获取用户信息
第三方单点登录Ecology方案
03-20
- **第三方SSO**：由外部服务提供商提供SSO服务，例如Google、Facebook等，用户可以通过这些平台的身份验证来登录其他应用。 2. **方案背景**： 随着互联网服务的多样化，用户需要记忆众多账号和密码，这既不便捷...
google第三方登录
04-28
google 谷歌第三方登录（facebook twitter 登录 第三方登录 web 可以参考，如果是oauth2.0协议 流程都是一样的）
基于C#实现的第三方OAuth2授权登录源码
最新发布
09-25
该项目为C#语言编写的第三方OAuth2授权登录解决方案源码，共包含24个文件，其中19个为C#源文件。支持QQ、微信开放平台、微信公众平台、微博、淘宝、支付宝、钉钉、飞书、码云、GitHub、微软、StackOverflow和谷歌等...
账号密码第三方登录网页模板
01-22
3. **第三方登录**：这是一种允许用户使用已有的社交媒体账号（如微信、支付宝、Google等）登录新网站的服务。这种方式简化了注册流程，减少了用户记忆多个账号和密码的负担，有助于提升用户留存率。 4. **网页模板...
google 第三方授权登录oauth2.0登录
qq_43958998的博客
05-22 2638
创建权限请求页面和凭据。
web项目集成Google 登录教程
老吴的博客
02-02 6334
web项目集成Google 登录手把手教程
谷歌身份验证器的使用超详细步骤
weixin_48974246的博客
11-01 3万+
谷歌身份验证器Google Authenticator是谷歌推出的一款动态口令工具，解决大家各平台账户遭到恶意攻击的问题，一般在相关的服务平台登陆中除了用正常用户名和密码外，需要再输入一次谷歌认证器生成的动态口令才能验证成功，相当于输入二次密码，以达到账户的高安全性。例如交易所、金融平台、以及一些钱包等项目等等，都会使用谷歌身份验证器Google Authenticator来做二次认证，开启谷歌身份验证之后，登录账户，除了输入用户名和密码，还需要输入谷歌验证器上的动态密码。4.4.扫描生成的二维码，即可。
实现谷歌第三方登录步骤
ljb376766764的博客
04-24 1321
谷歌第三方登录
第三方登陆--接入谷歌和FaceBook
weixin_42972832的博客
09-06 5986
第三方登陆
实现 Google 第三方授权登录
christinxu的博客
08-09 1万+
实现Google的第三方登录
Google三方登录流程及注意事项，获取用户的更多数据
qq_43540406的博客
03-09 8395
Google play三方登录流程 准备 注册一个google账号（方法自行百度） 步骤 打开GoogleAPIs,登录，看到如下界面 打开Google登录Android文档官方文档 添加Google Play服务 在项目的顶级build.gradle文件中，确保包含Google的Maven存储库： allprojects { repositories { google() // If you're using a version of Gradle
（出海必备）Android三方登录之Google登录
wangchaojing的博客
07-08 1万+
背景：之前一直做国内的项目，最近公司要做一款国外上架的app，因为海外和国内的文档，账号注册，demo测试等流程和国内大有不同，中间遇到了不少坑，在这里总结一下，有用到的小伙伴，可以借鉴下；1.先撸官方文档https://developers.google.com/identity/sign-in/android/sign-in2.Google的Demo;GitHub - googlesamples/google-services: A collection of quickstart samples de
QQ第三方登录源码快速集成指南
目前市场上除了QQ，还有许多其他服务提供者支持第三方登录，如Facebook、Google、微博、微信等。每家提供的接入方式和认证流程都有所差异，但原理都是基于OAuth 2.0协议。开发者可以按照相应平台的接入文档来进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值