动手实践感受下企业微信的网页授权登录、扫码授权登录

已于 2022-04-02 17:22:25 修改
阅读量3.8k 收藏 9
点赞数
分类专栏： JAVA springMVC 文章标签： java 微信开放平台
于 2022-04-02 14:02:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heshiyuan1406146854/article/details/123913435
版权

一、网页授权登录：

1.使用内网穿透工具为“本地ip+端口”映射一个公网域名，比如：xxx.xxx.xxx.com 表示我本地的 127.0.0.1:8080。

2.申请一个测试用的企业微信，新建一个应用，比如叫：test_app_0001.

3.新建一个springboot工程：

企业微信的几个工具类：

QyOauthApi.java：

package com.test.qywechat.api;

import com.test.qywechat.httpclient.LocalHttpClient;
import com.test.qywechat.model.QyAuthUser;
import com.test.qywechat.model.QyAuthUserInfo;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class QyOauthApi extends QyWechatBaseApi{

	private static Logger logger = LoggerFactory.getLogger(QyOauthApi.class);
	/**
	 * 生成网页授权 URL  (第三方平台开发)
	 * @param appid appid
	 * @param redirect_uri 自动URLEncoder
	 * @param snsapi_userinfo snsapi_userinfo
	 * @param state 可以为空
	 * @param component_appid 第三方平台开发，可以为空。
	 * 			 服务方的appid，在申请创建公众号服务成功后，可在公众号服务详情页找到
	 * @return url
	 */
	public static String connectOauth2Authorize(String appid,String redirect_uri,boolean snsapi_userinfo,String state,String component_appid){
		try {
			StringBuilder sb = new StringBuilder();
			sb.append(OPEN_URI + "/connect/oauth2/authorize?")
					.append("appid=").append(appid)
					.append("&redirect_uri=").append(URLEncoder.encode(redirect_uri, "utf-8"))
					.append("&response_type=code")
					.append("&scope=").append(snsapi_userinfo?"snsapi_userinfo":"snsapi_base")
					.append("&state=").append(state==null?"":state);
			if(component_appid!=null){
				sb.append("&component_appid=").append(component_appid);
			}
			sb.append("#wechat_redirect");
			return sb.toString();
		} catch (UnsupportedEncodingException e) {
			logger.error("", e);
		}
		return null;
	}

	/**
	 * 获取企业微信当前登录账号
	 * @param accessToken access_token
	 * @param code 通过成员授权获取到的code，最大为512字节。每次成员授权带上的code将不一样，code只能使用一次，5分钟未被使用自动过期。
	 * @return 登录账号
	 */
	public static QyAuthUser getAuthUserInfo(String accessToken, String code){
		HttpUriRequest httpUriRequest = RequestBuilder.get()
				.setUri(BASE_URI + "/cgi-bin/user/getuserinfo")
				.addParameter(PARAM_ACCESS_TOKEN, accessToken)
				.addParameter("code", code)
				.build();
		return LocalHttpClient.executeJsonResult(httpUriRequest,QyAuthUser.class);
	}

	/**
	 * 根据userId获取通讯录成员用户详情信息
	 * （注：应用须拥有指定成员的查看权限）
	 * @param accessToken access_token
	 * @param userId 登录账号
	 * @return 登录账号详情信息
	 */
	public static QyAuthUserInfo queryAuthUserInfo(String accessToken, String userId){
		HttpUriRequest httpUriRequest = RequestBuilder.get()
				.setUri(BASE_URI + "/cgi-bin/user/get")
				.addParameter(PARAM_ACCESS_TOKEN, accessToken)
				.addParameter("userid", userId)
				.build();
		return LocalHttpClient.executeJsonResult(httpUriRequest, QyAuthUserInfo.class);
	}
}

QyTokenApi.java：

package com.test.qywechat.api;

import com.test.qywechat.httpclient.LocalHttpClient;
import com.test.qywechat.model.QyToken;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;

public class QyTokenApi extends QyWechatBaseApi{

	public static QyToken token(String corpId, String secret){
		HttpUriRequest httpUriRequest = RequestBuilder.get()
				.setUri(BASE_URI + "/cgi-bin/gettoken")
				.addParameter("corpid", corpId)
				.addParameter("corpsecret", secret)
				.build();
		return LocalHttpClient.executeJsonResult(httpUriRequest,QyToken.class);
	}
}

QyWechatBaseApi.java：

package com.test.qywechat.api;

public class QyWechatBaseApi {

	protected static final String BASE_URI = "https://qyapi.weixin.qq.com";
	protected static final String OPEN_URI = "https://open.weixin.qq.com";
	protected static final String PARAM_ACCESS_TOKEN = "access_token";

}

QyAuthUser.java:

package com.test.qywechat.model;

import lombok.Data;

@Data
public class QyAuthUser extends QyBaseResult {

	private String userId;

	private String deviceId;

	@Override
	public String toString() {
		return "QyAuthUser [userId=" + userId + ", deviceId=" + deviceId + ", errcode=" + errcode + ", errmsg=" + errmsg + "]";
	}
}


QyAuthUserInfo.java:

package com.test.qywechat.model;

import lombok.Data;

@Data
public class QyAuthUserInfo extends QyBaseResult {

	private String userid;
	private String name;
	private String mobile;
	private Integer[] department;
	private String position;
	//0表示未定义，1表示男性，2表示女性
	private String gender;
	private String email;
	private String status;
	private String main_department;

}


QyBaseResult.java:

package com.test.qywechat.model;

import lombok.Data;

@Data
public class QyBaseResult {

	private static final String SUCCESS_CODE = "0";

	public String errcode;
	public String errmsg;

	public boolean isSuccess() {
		return errcode == null || errcode.isEmpty() || errcode.equals(SUCCESS_CODE);
	}

}


QyToken.java:

package com.test.qywechat.model;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class QyToken extends QyBaseResult {

	private String access_token;
	private int expires_in;
}

HttpClientFactory.java:

package com.test.qywechat.httpclient;

import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpRequest;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.protocol.HttpContext;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;
import java.security.*;

/**
 * httpclient 4.3.x
 *
 */
public class HttpClientFactory{
	
	private static final String[] supportedProtocols = new String[]{"TLSv1"};
	
	public static CloseableHttpClient createHttpClient() {
		return createHttpClient(100,10,5000,2);
	}

	/**
	 * 
	 * @param maxTotal
	 * @param maxPerRoute
	 * @param timeout
	 * @param retryExecutionCount
	 * @return
	 */
	public static CloseableHttpClient createHttpClient(int maxTotal, int maxPerRoute, int timeout, int retryExecutionCount) {
		try {
			SSLContext sslContext = SSLContexts.custom().useSSL().build();
			SSLConnectionSocketFactory sf = new SSLConnectionSocketFactory(sslContext, SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
			PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager();
			poolingHttpClientConnectionManager.setMaxTotal(maxTotal);
			poolingHttpClientConnectionManager.setDefaultMaxPerRoute(maxPerRoute);
			SocketConfig socketConfig = SocketConfig.custom().setSoTimeout(timeout).build();
			poolingHttpClientConnectionManager.setDefaultSocketConfig(socketConfig);
			return HttpClientBuilder.create()
									.setConnectionManager(poolingHttpClientConnectionManager)
									.setSSLSocketFactory(sf)
									.setRetryHandler(new HttpRequestRetryHandlerImpl(retryExecutionCount))
									.build();
		} catch (KeyManagementException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * Key store 类型HttpClient
	 * @param keystore
	 * @param keyPassword
	 * @return
	 */
	public static CloseableHttpClient createKeyMaterialHttpClient(KeyStore keystore, String keyPassword, int timeout, int retryExecutionCount) {
		return createKeyMaterialHttpClient(keystore, keyPassword, supportedProtocols,timeout,retryExecutionCount);
	}
	
	/**
	 * Key store 类型HttpClient
	 * @param keystore
	 * @param keyPassword
	 * @param supportedProtocols
	 * @return
	 */
	public static CloseableHttpClient createKeyMaterialHttpClient(KeyStore keystore, String keyPassword, String[] supportedProtocols, int timeout, int retryExecutionCount) {
		try {
			SSLContext sslContext = SSLContexts.custom().useSSL().loadKeyMaterial(keystore, keyPassword.toCharArray()).build();
			SSLConnectionSocketFactory sf = new SSLConnectionSocketFactory(sslContext,supportedProtocols,
	                null, SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
			SocketConfig socketConfig = SocketConfig.custom().setSoTimeout(timeout).build();
			return HttpClientBuilder.create()
									.setDefaultSocketConfig(socketConfig)
									.setSSLSocketFactory(sf)
									.setRetryHandler(new HttpRequestRetryHandlerImpl(retryExecutionCount))
									.build();
		} catch (KeyManagementException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (UnrecoverableKeyException e) {
			e.printStackTrace();
		} catch (KeyStoreException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * HttpClient  超时重试
	 */
	private static class HttpRequestRetryHandlerImpl implements HttpRequestRetryHandler {
		
		private int retryExecutionCount;
		
		public HttpRequestRetryHandlerImpl(int retryExecutionCount){
			this.retryExecutionCount = retryExecutionCount;
		}
		
		@Override
	    public boolean retryRequest(
	            IOException exception,
	            int executionCount,
	            HttpContext context) {
			if (executionCount > retryExecutionCount) {
	            return false;
	        }
	        if (exception instanceof InterruptedIOException) {
	            return false;
	        }
	        if (exception instanceof UnknownHostException) {
	            return false;
	        }
	        if (exception instanceof ConnectTimeoutException) {
	            return true;
	        }
	        if (exception instanceof SSLException) {
	            return false;
	        }
	        HttpClientContext clientContext = HttpClientContext.adapt(context);
	        HttpRequest request = clientContext.getRequest();
	        boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
	        if (idempotent) {
	            // Retry if the req is considered idempotent
	            return true;
	        }
	        return false;
	    }

	}
	
}


JsonResponseHandler.java:

package com.test.qywechat.httpclient;

import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Maps;
import org.apache.http.HttpEntity;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.ResponseHandler;
import org.apache.http.util.EntityUtils;

import java.util.Map;

public class JsonResponseHandler{

	private static Map<String, ResponseHandler<?>> map = Maps.newHashMap();

	@SuppressWarnings("unchecked")
	public static <T> ResponseHandler<T> createResponseHandler(final Class<T> clazz){

		if(map.containsKey(clazz.getName())){
			return (ResponseHandler<T>)map.get(clazz.getName());
		}else{
			ResponseHandler<T> responseHandler = response -> {
				int status = response.getStatusLine().getStatusCode();
				if (status >= 200 && status < 300) {
					HttpEntity entity = response.getEntity();
					String str = EntityUtils.toString(entity);
					return JSONObject.parseObject(str, clazz);
				} else {
					throw new ClientProtocolException("Unexpected res status: " + status);
				}
			};
			map.put(clazz.getName(), responseHandler);
			return responseHandler;
		}
	}

}


LocalHttpClient.java:
 

package com.test.qywechat.httpclient;

import org.apache.http.HttpEntity;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.entity.ContentType;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.util.HashMap;
import java.util.Map;

public class LocalHttpClient {
	
	private static final Logger logger = LoggerFactory.getLogger(LocalHttpClient.class);
	
	private static int timeout = 5000;
	
	private static int retryExecutionCount = 2;

	protected static CloseableHttpClient httpClient = HttpClientFactory
			.createHttpClient(100,10,timeout,retryExecutionCount);

	private static Map<String, CloseableHttpClient> httpClient_mchKeyStore = new HashMap<String, CloseableHttpClient>();
	
	/**
	 * @since 2.7.0
	 * @param timeout
	 */
	public static void setTimeout(int timeout) {
		LocalHttpClient.timeout = timeout;
	}

	/**
	 * @since 2.7.0
	 * @param retryExecutionCount
	 */
	public static void setRetryExecutionCount(int retryExecutionCount) {
		LocalHttpClient.retryExecutionCount = retryExecutionCount;
	}

	public static void init(int maxTotal,int maxPerRoute){
		try {
			httpClient.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		httpClient = HttpClientFactory.createHttpClient(maxTotal,maxPerRoute,timeout,retryExecutionCount);
	}

	/**
	 * 初始化   MCH HttpClient KeyStore
	 * @param mch_id
	 * @param keyStoreFilePath
	 */
	public static void initMchKeyStore(String mch_id,String keyStoreFilePath){
		try {
			KeyStore keyStore = KeyStore.getInstance("PKCS12");
			 FileInputStream instream = new FileInputStream(new File(keyStoreFilePath));
			 keyStore.load(instream,mch_id.toCharArray());
			 instream.close();
			 CloseableHttpClient httpClient = HttpClientFactory
					 .createKeyMaterialHttpClient(keyStore, mch_id,timeout,retryExecutionCount);
			 httpClient_mchKeyStore.put(mch_id, httpClient);
		} catch (KeyStoreException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (CertificateException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}


	public static CloseableHttpResponse execute(HttpUriRequest request){
		loggerCatch(request);
		try {
			return httpClient.execute(request, HttpClientContext.create());
		} catch (Exception e) {
			e.printStackTrace();
			logger.error(e.getMessage());
		}
		return null;
	}

	public static <T> T execute(HttpUriRequest request, ResponseHandler<T> responseHandler){
		loggerCatch(request);
		try {
			return httpClient.execute(request, responseHandler, HttpClientContext.create());
		} catch (Exception e) {
			e.printStackTrace();
			logger.error(e.getMessage());
		}
		return null;
	}

	/**
	 * 数据返回自动JSON对象解析
	 * @param request
	 * @param clazz
	 * @return
	 */
	public static <T> T executeJsonResult(HttpUriRequest request, Class<T> clazz){
		return execute(request,JsonResponseHandler.createResponseHandler(clazz));
	}


	
	/**
	 * 日志记录
	 * @param request
	 */
	private static void loggerCatch(HttpUriRequest request){
		if((logger.isInfoEnabled()||logger.isDebugEnabled())){
			if(request instanceof HttpEntityEnclosingRequestBase){
				HttpEntityEnclosingRequestBase request_base = (HttpEntityEnclosingRequestBase)request;
				HttpEntity entity = request_base.getEntity();
				String content = null;
				//MULTIPART_FORM_DATA 请求类型判断
				if(entity.getContentType().toString().indexOf(ContentType.MULTIPART_FORM_DATA.getMimeType()) == -1){
					try {
						content = EntityUtils.toString(entity);
					} catch (Exception e) {
						e.printStackTrace();
						logger.error(e.getMessage());
					}
				}
				logger.info("URI:{} {} ContentLength:{} Content:{}",
				request.getURI().toString(),
				entity.getContentType(),
				entity.getContentLength(),
				content == null?"multipart_form_data":content);
			}else{
				logger.info("URI:{}",request.getURI().toString());
			}
		}
	}
	
}

TestController.java:

package com.test.controller;

import com.alibaba.fastjson.JSONObject;
import com.test.qywechat.model.QyAuthUser;
import com.test.qywechat.api.QyOauthApi;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

@Slf4j
@RestController
@RequestMapping("/test")
@Api(value = "测试Controller", description = "测试Controller")
public class TestController {

    private static final String corpId = "xxxxx";
    private static final String secret_test_app_0001 = "xxx-xxxx";

    /**
     * 也即时用来根据 code 查询用户信息的
     * @param action
     * @param code
     * @param state
     * @return
     */
    @ApiOperation(value = "企业微信code回调")
    @GetMapping( "/receive/qywx/code" )
    public String receiveQywxCode( @RequestParam( "action" ) String action,
                                   @RequestParam( "code" ) String code,
                                   @RequestParam( "state" ) String state){
        System.out.println( "action = " + action );
        System.out.println( "code = " + code );
        System.out.println( "state = " + state );
        // ps：调用 QyTokenApi.token( code,secret_test_app_0001 ).getAccess_token() 获取的，实际需要缓存起来，防止频繁调用
        String accessToken = "xxx-xxx-xxx-xxx-xxx-xxx";
        QyAuthUser userInfo = QyOauthApi.getAuthUserInfo(accessToken, code);
        // userId 就是企业微信控制台--》通讯录--》成员详情 中的账号字段
        String userId = userInfo.getUserId();
        String deviceId = userInfo.getDeviceId();
        JSONObject result = new JSONObject();
        result.put( "姓名",userId );
        result.put( "设备编码",deviceId );
        return result.toJSONString();
    }

    @ApiOperation(value = "构造网页授权链接")
    @GetMapping( "/oauth2_link" )
    public String oauth2_link( ){
        String redirect_uri = "http://xxx.xxx.xxx.com/test/receive/qywx/code?action=get";
        String click_url = QyOauthApi.connectOauth2Authorize(corpId, redirect_uri, false, null,null);
        System.out.println( "click_url is " + click_url );
        String html = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"\n" +
                        "        \"http://www.w3.org/TR/html4/loose.dtd\">\n" +
                        "<html>\n" +
                        "<head>\n" +
                        "    <meta charset=\"utf-8\">\n" +
                        "    <meta http-equiv=\"refresh\" content=\"0; URL=" + click_url + "\">\n" +
                        "    <title>个人信息</title>\n" +
                        "</head>\n" +
                        "<body>\n" +
                        "    loading..." +
                        "</body>\n" +
                        "</html>";
        return html;
    }
}

企业微信管理端为应用“test_app_0001”新建一个菜单，菜单内容设置为“跳转到网页”，网址设置为 http://xxx.xxx.xxx.com/test/oauth2_link,其中xxx.xxx.xxx.com也就是为127.0.0.1:8080映射的公网域名，供微信回调使用， /test/oauth2_link为TestController中的接口:

为应用"test_app_0001"设置网页授权可信域名：

在手机端企业微信打开应用“test_app_0001”，点击菜单“个人信息”，就查询出了当前的用户的信息了：

二、在自己的web页面实现企业微信扫码登录：

1.在企业微信管理端对应应用中设置企业微信授权登录授权回调域：

2.TestController 中新增两个接口：

    @ApiOperation(value = "企业微信授权登录二维码")
    @GetMapping( "/show_qr_code" )
    public String showQrCode( ) throws UnsupportedEncodingException {
        System.out.println( "request /test/sso_qr_connect_link" );
        String redirect_uri = "http://" + domain_ngrok_mock + "/test/home?action=get";
        String sso_qr_connect_link = "https://open.work.weixin.qq.com/wwopen/sso/qrConnect?" +
                                        "appid=" + corpId + "&" +
                                        "agentid=" + agentId_test_app_0001 + "&" +
                                        "redirect_uri=" + URLEncoder.encode(redirect_uri, "utf-8") + "&" +
                                        "state=";
        System.out.println( "sso_qr_connect_link is " + sso_qr_connect_link );
        String html = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"\n" +
                "        \"http://www.w3.org/TR/html4/loose.dtd\">\n" +
                "<html>\n" +
                "<head>\n" +
                "    <meta charset=\"utf-8\">\n" +
                // todo 作用是该页面被打开后立即重定向到 click_url
                "    <meta http-equiv=\"refresh\" content=\"0; URL=" + sso_qr_connect_link + "\">\n" +
                "    <title>个人信息</title>\n" +
                "</head>\n" +
                "<body>\n" +
                "    loading..." +
                "</body>\n" +
                "</html>";
        return html;
    }


    @ApiOperation(value = "测试主页")
    @GetMapping( "/home" )
    public String home( @RequestParam( "code" ) String code,
                        @RequestParam( value = "state",required = false ) String state ){
        System.out.println( "request /test/home" );
        System.out.println( "code = " + code );
        System.out.println( "state = " + state );
        // ps：调用 QyTokenApi.token( code,secret_test_app_0001 ).getAccess_token() 获取的，实际需要缓存起来，防止频繁调用
        String accessToken = "xxx-xxx-xxx-xxx";
        QyAuthUser userInfo = QyOauthApi.getAuthUserInfo(accessToken, code);
        String userId = userInfo.getUserId();
        QyAuthUserInfo userDetailInfo = QyOauthApi.queryAuthUserInfo(accessToken, userId);
        return "welcome you! " + JSONObject.toJSONString( userDetailInfo );
    }

效果：

 

 

 

狄龙疤
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
uniapp 实现企业微信网页授权登录
郭宝的博客
04-03 2417
需求： 想在企业微信中打开网页获取成员的身份信息，从而免去登录的环节，实现无感登录。4、然后打开自建应用，设置应用打开时默认访问的H5地址。REDIRECT_URI 网页授权回调地址。例如：xxx.com:8083。3、输入应用相关数据，进行创建。CORPID 为企业微信id。AGENTID 应用id。1、进入企业微信管理后台（7、设置企业微信授权地址。8、前端拼接网页授权链接。6、配置企业可信IP。5、然后设置可信域名。
企业微信 身份验证 网页授权登录.docx
07-15
企业微信网页授权登录流程： 1、用户同意授权，获取code 2、通过企业ID和应用的凭证密钥换取网页授权access_token信息 3、通过access_token和code获取该用户的用户userid信息
企业微信-构造网页授权链接实现登录
JFENG14的博客
05-04 1956
添加之后可以在企业微信-工作台中找到相关的应用，点击后会跳转到https://test.com?code=CODE，可以通过code请求后端获取到用户的相关信息。2.scope：如果需要获取成员的头像、手机号等信息需要设为snsapi_privateinfo。1.redirect_uri：回调链接地址，需要。以下为JAVA使用 weixin-java-cp的实现代码。例如前端地址为：https://test.com。
企业微信H5授权登录
最新发布
qq_35946021的博客
05-28 876
在企业中如果需要在打开的网页里面携带用户的身份信息，第一步需要获取code参数如何实现企业微信H5获取当前用户信息即accessToken？
记录企业微信授权登录流程实现
qq_48795670的博客
08-17 381
如果用户是有token， 但不在首页，就获取不到用户信息了，所以我是在app.vue中判断是否有用户信息，没有的话，再次请求（这里会有问题，就是如果一上来就在首页， 会获取两次用户信息， 求指点指点）登录流程：用户进入首页点击登录=》后端会给一个url地址给你跳转进行授权，授权后后端会帮你跳转回首页并携带query参数，你可以根据query参数获取用户token。1.有的话，弹窗让用户输入用户名（因为后端只能通过企业微信获取到手机号和用户id，名字是获取不到的），再请求用户信息。
vue中企业微信 第三方应用扫码登录（pc端）
xiasohuai的博客
05-20 2444
企业微信 第三方应用扫码登录参考文档：接入指引 - 接口文档 - 企业微信开发者中心 首先在login页面，写一个按钮，触发点击事件,引导用户进入登录授权页： <button @click="toWxLogin">企业微信扫码登录</button> toWxLogin(){ //授权登录之后目的跳转网址，需要做urlencode处理。所在域名需要与授权完成回调域名一致 let url = 'http://....' //服务商的Cor
对接企业微信3：网页授权登录
zhaofuqiangmycomm的博客
11-24 6791
构造网页授权链接 如果企业需要在打开的网页里面携带用户的身份信息，第一步需要构造如下的链接来获取code参数： https://open.weixin.qq.com/connect/oauth2/authorize?appid=CORPID&redirect_uri=REDIRECT_URI&response_type=code&scope=snsapi_base&state=STATE#wechat_redirect 参数说明： 参数 必须 说明
ASP网页调用微信扫码登录方法
08-17
微信扫码登录基于OAuth2.0授权协议，允许用户在不泄露密码的情况下授权第三方应用访问其在微信的部分信息。在这个过程中，用户会通过微信客户端扫描网页上的二维码，然后在微信APP内确认授权。 3. **获取授权URL**...
基于Winfrom的企业微信扫码登录案例
02-02
而在这个“基于Winfrom的企业微信扫码登录案例”中，我们将探讨如何利用C#编程语言集成企业微信的扫码登录功能，为用户提供安全、便捷的身份验证方式。 首先，企业微信扫码登录的核心在于调用其提供的API接口。企业...
Python-weixinlogin微信网页授权实现扫码登录
08-10
本文将深入探讨如何使用Python来实现微信网页授权的扫码登录功能。这个过程涉及到的主要知识点包括OAuth2.0授权框架、微信开放平台API以及Python的请求库。 微信网页授权是微信提供的一种服务，允许第三方网站通过...
.NET Core 企业微信网页授权登录.doc
07-11
.NET Core 企业微信网页授权登录 .NET Core 企业微信网页授权登录是指使用微信企业号的 OAuth2 授权机制来实现网页登录的功能。在这个过程中，需要获取企业的唯一标识 corpid 和访问密钥 secret，然后使用这两个...
PHP微信扫码关注公众号并授权登录.zip
04-18
PHP微信扫码关注公众号并授权登录，网站使用公众号授权登录，上传资料中已经数据库和代码全部生成，未删减
企业微信之网页授权登录
qiuhx909922的专栏
01-19 5170
企业微信之网页授权登录 场景：要在企业微信里面集成企业自建应用，点击应用进入应用功能列表，获取当前企业微信用户信息。 Ⅰ.概述 企业微信提供了OAuth的授权登录方式，可以让网页和企业微信共享用户ID，从而免去登录的环节。 此文档面向网页开发者介绍企业微信网页授权如何使用及相关注意事项。 Ⅱ.企业微信OAuth2接入流程 Ⅲ.准备工作 企业微信后台，应用管理-创建应用，新建应用 secret是企业应用里面用于保障数据安全的“钥匙”，每一个应用都有一个独立的访问密钥，为了保证数据的安全，secre
Java实现微信扫码登录
热门推荐
Cike___的博客
02-06 1万+
微信扫码授权登录
企业微信集成网页应用（spring-boot）
lishizeng的博客
11-10 6951
第一步：进入企业微信，微信扫一扫，创建一个临时测试公司，然后“创建应用”，如下图“述职&转正” 第二步：点击应用，设置可信域名 第三步：设置主页，也就是在企业微信客户端工作台里点击自己应用时的主页，这个流程是：1、企业微信API得到请求 2、企业微信跳转你设置的重定向url并写到code给你 3、进入自身应用的Controller对应方法，获取code+生成的acc
vue实现网页端企业微信扫码登录功能（前端部分）
LeeBrook0的博客
01-11 9944
时至今日，企业微信在企业日常工作中的使用越来越频繁也越来越重要，不少企业已使用企业微信进行着日常的工作安排管理。在这种背景下，各类系统和企业微信对接的需求也不断增加，今天要说的就是一个比较常见的需求：在网页前端实现扫描企业微信二维码进行系统登录。以下是vue框架下实现的方式，主要是前端部分。要完成这个需求主要有两点关键技术问题需要解决：一是如何在网页端产生企业微信的二维码。二是用户扫码完成后，如何知道是哪个用户扫的二维码，或者如何告诉后端哪个用户扫的二维码呢。我们一步步来说。
企业微信 网页授权登入
weixin_42903592的博客
12-05 3699
企业微信 网页授权登入 官网地址：https://work.weixin.qq.com/api/doc/90000/90135/91020 企业微信提供了OAuth的授权登录方式，可以让从企业微信终端打开的网页获取成员的身份信息，从而免去登录的环节。 企业应用中的URL链接（包括自定义菜单或者消息中的链接），均可通过OAuth2.0验证接口来获取成员的UserId身份信息。 OAuth2简介 OAuth2的设计背景，在于允许用户在不告知第三方自己的帐号密码情况下，通过授权方式，让第三方服务可以获取自己的资源
企业微信 web 项目工业级蜕变
腾讯技术工程
08-16 1603
作者：chriscai，腾讯 WXG 前端开发工程师企业微信 web 项目从以前的小而简单的 web 项目，历经五载，蜕变成了平台级的项目。这几年伴随着前端工业化和前端技术变革，本文将介绍...
.net Core2.2 WebApi通过OAuth2.0实现微信登录
dotNET跨平台
03-15 1419
前言微信相关配置请参考微信公众平台的这篇文章。注意授权回调域名一定要修改正确。微信网页授权是通过OAuth2.0机制实现的，所以我们可以使用https://gith...
企业微信 网页授权 最佳实践
09-06
企业微信网页授权最佳实践是通过微信公众平台进行配置操作。首先，在微信公众平台官网的“开发 - 接口权限 - 网页服务 - 网页帐号 - 网页授权获取用户基本信息”中进行配置。这样就可以在企业微信中请求用户的网页...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值