精华内容
下载资源
问答
  • 每个用户对每个公众号的OpenID是唯一的)组成。一次拉取调用最多拉取10000个关注者的OpenID,可以通过多次拉取的方式来满足需求。 所以在调用原来的<code>wechatpy.client.api.WeChatUser.get_...
  • 微信平台开发获取微信用户的OPENID

    千次阅读 2016-01-14 13:55:49
    当我们进行微信平台相关内容开发时,如果想做一些针对微信用户进行一些信息获取及消息推送,那我们第一步先要拿到微信用户的OPENID(用户唯一标识,建立在一个公众号与一个微信用户之间,即针对一个公众号,所有的微信...

    当我们进行微信平台相关内容开发时,如果想做一些针对微信用户进行一些信息获取及消息推送,那我们第一步先要拿到微信用户的OPENID(用户唯一标识,建立在一个公众号与一个微信用户之间,即针对一个公众号,所有的微信用户都享有一个独立不变的标识);


    1 . 如果微信用户已经关注自己的公众号, 那可以通过微信接口里面的用户管理模板直接获取到对应公众号的所有已关注用户OPENID的列表;
    1). 在调用所有的微信接口之前,我们先要请求授权,拿到access_token

        @Getter
        @Config("wechat.appid")
        private static String WECHATAPPID;
    
        @Getter
        @Config("wechat.appsecret")
        private static String WECHATAPPSECRET;
    
        public static final String ACCESS_TOKEN = "access_token";
        public final static String WECHATACCESSTOKEN = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=";
            /**
         * <p>
         * 成功: {"access_token":"ACCESS_TOKEN","expires_in":7200}
         * </p>
         * <p>
         * 失败: {"errcode":40013,"errmsg":"invalid appid"}
         * </p>
         * @return 如果没有获取到有效的凭据,就返回 null
         */
        private static Map getWechatAPPAccessTokenFromWeChat() {
            StringBuilder accessTokenUrl = new StringBuilder().append(WECHATACCESSTOKEN).append(WECHATAPPID)
                            .append("&secret=").append(WECHATAPPSECRET);
            Map result = HttpClientUtil.readHttpContent(accessTokenUrl.toString());
            if (result != null && result.get(ACCESS_TOKEN) != null)
                return result;
            return null;
        }
    
        //HttpClientUtil.class static method
        /**
         * get json content and transform to Map from the urlStr
         * If occuer one error just return null.
         * @param urlStr
         * @return
         */
        public static Map<String,Object> readHttpContent(String urlStr){
            Map<String, Object> result = null;
            HttpEntity httpEntity = null;
            try {
                HttpResponse response = Request.Get(urlStr).execute().returnResponse();
                httpEntity = response.getEntity();
            }catch (IOException e) {
                logger.error("Get resouse from {} had occurred an error: {}", urlStr, e.toString());
                return result;
            }
            try (
                InputStream in = httpEntity.getContent();
            ){
                ObjectMapper mapper = new ObjectMapper();
                result = mapper.readValue(in, HashMap.class);
            }catch (IOException e) {
                logger.error("Get json content from {} had occurred an error: {}", urlStr, e.toString());
                return result;
            }
            return result;
        }

    2). 使用前面得到的access_token获取公众号的微信关注用户列表

        public static final String ERRMSG = "errmsg";
        public final static String WECHATUSERLISTURL = "https://api.weixin.qq.com/cgi-bin/user/get?access_token=";
        /**
         *<p>
         * 获取成功:{
         *  "total":23000,
         *  "count":10000,
         *  "data":{"
         *    openid":[
         *      "OPENID1",
         *      "OPENID2",
         *      ...,
         *      "OPENID10000"
         *    ]
         *  },
         *  "next_openid":"OPENID10000"
         *  }
         *</p>
         *
         *<p>
         * 获取失败:{"errcode":40013,"errmsg":"invalid appid"}
         *</p>
         *
         *
         * 获取微信公众帐号的关注者列表(wechat user openID),每次最多10000个
         *
         * @param accessToken
         * @param next_openid: 没有此参数,则默认从关注列表的第一个开始获取
         * @return
         */
        public static Map getWechatUserOpenIDList(String accessToken, String next_openid) {
            StringBuilder urlB = new StringBuilder().append(WECHATUSERLISTURL).append(accessToken);
            if (!Strings.isBlank(next_openid))
                urlB.append("&next_openid=").append(next_openid);
            Map result = HttpClientUtil.readHttpContent(urlB.toString());
            if (result != null && result.get(ERRMSG) == null)
                return result;
            return null;
        }
    采用方法一,到此便得到了用户openID列表,可以进行后面获取微信用户信息及向用户推送模板消息等;
    

    2 . 无论微信用户是否关注自己的公众号, 当微信用户访问我们的web站点时(通过微信内置浏览器),我们可以通过页面授权的方式拿到微信用户的OpendID(页面授权需要跳转到微信服务器拿到oauth_code然后再换取access_token及OpendID);
    1). 为我们的web站点服务添加一个filter,拦截来自微信浏览器的请求,进行302跳转到微信站点,拿到授权码再回调回来;

    public class WechatFilter implements Filter {
    
        private static final Logger logger             = LoggerFactory.getLogger(WechatFilter.class);
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {}
    
        @Override
        public void doFilter(ServletRequest request, ServletResponse response,
                             FilterChain chain) throws IOException, ServletException {
            HttpServletRequest httpRequest = (HttpServletRequest) request;
    
            if (response.isCommitted()) {
                chain.doFilter(request, response);
                return;
            }
            //判断请求是否来自微信浏览器
            if (!WebUtil.isWechatRequest(httpRequest)) {
                chain.doFilter(request, response);
                return;
            }
            String requestURL = WebUtil.getRequsetUrl(httpRequest, true, true);
            logger.debug("Request from wechat client:{}", requestURL);
            HttpSession session = httpRequest.getSession();
            String weChatOpenId = (String) session.getAttribute(WeChatManager.WECHATOPENID);
            if (weChatOpenId == null) {
                if (httpRequest.getParameter(WeChatManager.CODE) == null) {
                    StringBuilder url = new StringBuilder("http://").append(WebUtil.getRequsetUrl(httpRequest, true, true));
                    response.reset();
                    ((HttpServletResponse) response).sendRedirect(url.toString());
                    return;
                } else {
                    String oauthCode = httpRequest.getParameter(WeChatManager.CODE);
                    if (!Strings.isBlank(oauthCode)) {
                        Map<String, Object> oauth_data = WeChatPageInterface.getWechatPageAccessToken(oauthCode);
                        weChatOpenId = oauthCode != null && oauth_data.get(WeChatManager.OPENID) != null ? (String) oauth_data.get(WeChatManager.OPENID) : null;
                        session.setAttribute(WeChatManager.WECHATOPENID, weChatOpenId);
                    } else {
                        logger.warn("The oauth_code is empty!");
                    }
                }
            }
            chain.doFilter(request, response);
        }
    
        @Override
        public void destroy() {
        }
    
    }
        //WeChatPageInterface.class static method
        /**
         * <p>
         * 微信获取授权成功:{ "access_token":"ACCESS_TOKEN", "expires_in":7200, "refresh_token":"REFRESH_TOKEN",
         * "openid":"OPENID", "scope":"SCOPE", "unionid": "o6_bmasdasdsad6_2sgVt7hMZOPfL" }
         * </p>
         * <p>
         * 微信获取授权失败:{"errcode":40029,"errmsg":"invalid code"}
         * </p>
         *
         * 请求微信公众号的网页授权,得到用户OpenID和access_token
         * 微信网页授权是通过OAuth2.0机制实现的,在用户授权给公众号后,公众号可以获取到一个网页授权特有的接口调用凭证( 网页授权access_token),
         * 通过网页授权access_token可以进行授权后接口调用,如获取用户基本信息;
         *
         * @return 如果没有获取到有效的凭据,就返回 null
         */
        public static Map<String, Object> getWechatPageAccessToken(String oauthCode) {
            StringBuilder accessTokenUrl = new StringBuilder().append(WeChatManager.weChatAuthAccessTokenPage).append(WeChatManager.getWECHATAPPID())
                            .append("&secret=").append(WeChatManager.getWECHATAPPSECRET()).append("&code=")
                            .append(oauthCode).append("&grant_type=").append("authorization_code");
            Map<String, Object> accessToken = HttpClientUtil.readHttpContent(accessTokenUrl.toString());
            if (accessToken != null && accessToken.get(WeChatManager.ACCESS_TOKEN) != null) {
                return accessToken;
            }
            return null;
        }

    至此,我们通过两种方式都可以获取微信用户的OpenID了,至于采用哪一种可以根据实际业务环境;

    PS: OpenID是介于微信用户与公众账号之间恒定不变的,所以可以进行三方持久化存储;

    展开全文
  • 2、配置网页授权域名信息 然后再菜单设置网页地址为:域名/wxAuth/login 就可以了 package com.example.demo.uinfo; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import org....

    因为我要做群发功能,所以我要获取关注某个微信公众号的所有用户的openid

     

     前提

    1、有微信公众号(appid与秘钥)

    2、配置网页授权的域名信息

    3、申请模板,有模板id

    4、配置服务器,把域名ip地址添加到白名单

    服务器配置,需要把项目代码部署到服务器上,才能配置,不然会提示错误!

    配置服务器的代码如下

    package com.example.demo.control;
    import com.example.demo.token.SignUtil;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    @RestController
    @RequestMapping("/weixin")
    public class TokenControl {
        /**
         * 微信消息接收和token验证
         */
        @RequestMapping(value = "/token", method = RequestMethod.GET)
        public String get(HttpServletRequest request, HttpServletResponse response) throws Exception {
            System.out.println("----------------验证微信服务号信息开始----------");
            request.setCharacterEncoding("UTF-8");
            response.setCharacterEncoding("UTF-8");
            // 微信加密签名
            String signature = request.getParameter("signature");
            // 时间戳
            String timestamp = request.getParameter("timestamp");
            // 随机数
            String nonce = request.getParameter("nonce");
            // 随机字符串
            String echostr = request.getParameter("echostr");
     
            // 通过检验signature对请求进行校验,若校验成功则原样返回echostr,表示接入成功,否则接入失败
            if (SignUtil.checkSignature(signature, timestamp, nonce)) {
                System.out.println("----验证服务号结束.........");
                return echostr;
            }else{
                return null;
            }
        }//public
    }
    package com.example.demo.token;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.Arrays;
     
    public class SignUtil {
        private static String token = "token";
     
        /**
         * 校验签名
         * @param signature 签名
         * @param timestamp 时间戳
         * @param nonce 随机数
         * @return 布尔值
         */
        public static boolean checkSignature(String signature,String timestamp,String nonce){
            String checktext = null;
            if (null != signature) {
                //对ToKen,timestamp,nonce 按字典排序
                String[] paramArr = new String[]{token,timestamp,nonce};
                Arrays.sort(paramArr);
                //将排序后的结果拼成一个字符串
                String content = paramArr[0].concat(paramArr[1]).concat(paramArr[2]);
     
                try {
                    MessageDigest md = MessageDigest.getInstance("SHA-1");
                    //对接后的字符串进行sha1加密
                    byte[] digest = md.digest(content.toString().getBytes());
                    checktext = byteToStr(digest);
                } catch (NoSuchAlgorithmException e){
                    e.printStackTrace();
                }
            }
            //将加密后的字符串与signature进行对比
            return checktext !=null ? checktext.equals(signature.toUpperCase()) : false;
        }
     
        /**
         * 将字节数组转化我16进制字符串
         * @param byteArrays 字符数组
         * @return 字符串
         */
        private static String byteToStr(byte[] byteArrays){
            String str = "";
            for (int i = 0; i < byteArrays.length; i++) {
                str += byteToHexStr(byteArrays[i]);
            }
            return str;
        }
     
        /**
         *  将字节转化为十六进制字符串
         * @param myByte 字节
         * @return 字符串
         */
        private static String byteToHexStr(byte myByte) {
            char[] Digit = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
            char[] tampArr = new char[2];
            tampArr[0] = Digit[(myByte >>> 4) & 0X0F];
            tampArr[1] = Digit[myByte & 0X0F];
            String str = new String(tampArr);
            return str;
        }
     
    }

     打包成war包或者jar包以后,然后放在服务器上,把这个后台的访问地址填写在微信公众号的服务器配置这里;

    记住,我的令牌是token,如果你设置成其他的,记住在代码里更改一下!!

    5、

    然后再菜单设置网页地址为:域名/wxAuth/login

    就可以了


    把你的域名ip地址加入到白名单里面,直接复制ip地址到白名单里面就可以了!!

    如果你没有域名,就算了!!!不用做了!!

     现在我们再来看一下推送消息的代码

     

    package com.example.demo.uinfo;
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.net.URLEncoder;
    @RestController
    @RequestMapping("/wxAuth")
    public class WxLoginController {
        @RequestMapping("/login")
        public void wxLogin(HttpServletResponse response) throws IOException {
            //请求获取code的回调地址
            //用线上环境的域名或者用内网穿透,不能用ip
            String callBack = "http://www.lifan-keji.cn/wxAuth/callBack";
            System.out.println("进入登陆状态了......");
            //请求地址
            String url = "https://open.weixin.qq.com/connect/oauth2/authorize" +
                    "?appid=" + "你的微信公众号appid" +
                    "&redirect_uri=" + URLEncoder.encode(callBack) +
                    "&response_type=code" +
                    "&scope=snsapi_userinfo" +
                    "&state=STATE#wechat_redirect";
            //重定向
            response.sendRedirect(url);
        }
    
        //	回调方法
        @RequestMapping("/callBack")
        public void wxCallBack(HttpServletRequest request, HttpServletResponse response) throws IOException {
            System.out.println("回掉方法.....");
            String code = request.getParameter("code");
            System.out.println(code);
            //获取access_token
            String url = "https://api.weixin.qq.com/sns/oauth2/access_token" +
                    "?appid=" + "你的公众号的appid" +
                    "&secret=" + "你的公众号的秘钥" +
                    "&code=" + code +
                    "&grant_type=authorization_code";
    
            String result = HttpClientUtil.doGet(url);
            System.out.println("请求获取access_token:" + result);
            //返回结果的json对象
            JSONObject resultObject = JSON.parseObject(result);
    
            //请求获取userInfo
            String infoUrl = "https://api.weixin.qq.com/sns/userinfo" +
                    "?access_token=" + resultObject.getString("access_token") +
                    "&openid=" + resultObject.getString("openid") +
                    "&lang=zh_CN";
            String resultInfo = HttpClientUtil.doGet(infoUrl);
            //此时已获取到userInfo,再根据业务进行处理
            //把里面的信息获取出来
            JSONObject json =  JSON.parseObject(resultInfo);
            //把这个结果给前端页面
            String info= (String) json.get("openid");
            System.out.println(info);
            String myurl="你获取openid成功以后要跳转的路径";
            response.sendRedirect(myurl);
        }
    }

     工具类

    package com.example.demo.uinfo;
    import org.apache.http.NameValuePair;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    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 java.io.IOException;
    import java.net.URI;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    public class HttpClientUtil {
        public static String doGet(String url, Map<String, String> param) {
            // 创建Httpclient对象
            CloseableHttpClient httpclient = HttpClients.createDefault();
    
            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) {
                e.printStackTrace();
            } finally {
                try {
                    if (response != null) {
                        response.close();
                    }
                    httpclient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return resultString;
        }
    
        public static String doGet(String url) {
            return doGet(url, null);
        }
    
        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) {
                e.printStackTrace();
            } finally {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
            return resultString;
        }
    
        public static String doPost(String url) {
            return doPost(url, null);
        }
    
        public static String doPostJson(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) {
                e.printStackTrace();
            } finally {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
            return resultString;
        }
    }

    当然还有一些依赖

     <!--微信模版消息推送三方sdk-->
            <dependency>
                <groupId>com.github.binarywang</groupId>
                <artifactId>weixin-java-mp</artifactId>
                <version>3.3.0</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.7</version>
            </dependency>
            <dependency>
                <groupId>net.sf.json-lib</groupId>
                <artifactId>json-lib</artifactId>
                <version>2.4</version>
                <classifier>jdk15</classifier>
            </dependency>
            <!--微信模版消息推送三方sdk-->

     

    展开全文
  • 如果需要在多公众号、移动应用之间做用户共通,则需前往微信开放平台,将这些公众号和应用绑定到一个开放平台账号下,绑定后,一个用户虽然对多个公众号和应用有多个不同的OpenID,但他对所有这些同一开放平台账号下...

    一,首先说明下这个微信的openid
      为了识别用户,每个用户针对每个公众号会产生一个安全的OpenID,如果需要在多公众号、移动应用之间做用户共通,则需前往微信开放平台,将这些公众号和应用绑定到一个开放平台账号下,绑定后,一个用户虽然对多个公众号和应用有多个不同的OpenID,但他对所有这些同一开放平台账号下的公众号和应用,只有一个UnionID

    我用简单自己理解的话来说就是 这个 你在每个公众号 或者小程序 都是在这个小程序或者这个公众号下会有一个openid 你去别的公众号 或者 小程序 这个是会改变的 但是unionid是不管你在哪个小程序或者公众号是唯一不变的。

    微信官方提供了 了一个 可以通过用户的openid来获取用户信息,前提是用户必须关注了你的公众号,这个好像要做的话需要关联一个需要三百块钱认证的那个啥来着。这个就先不说了吧,现在我们要说的问题是如何获取openid

    二,小程序获取openid
    1,工具类

    /**
     * 微信小程序获取openid
     * @author Mr.Lin
     */
    public class GetOpenIDUtil {
    	// 网页授权接口
    //	public final static String GetPageAccessTokenUrl = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=APPID&secret=SECRET&code=CODE&grant_type=authorization_code";//
    //	public final static String GetPageAccessTokenUrl = "https://api.weixin.qq.com/sns/jscode2session?appid=APPID&secret=SECRET&js_code=CODE&grant_type=authorization_code";
    	public final static String GetPageAccessTokenUrl = "https://api.weixin.qq.com/sns/jscode2session?appid=APPID&secret=SECRET&js_code=CODE&grant_type=authorization_code";
        public  static Map<String,Object> oauth2GetOpenid(String appid,String code,String appsecret) {
            String requestUrl = GetPageAccessTokenUrl.replace("APPID", appid).replace("SECRET", appsecret).replace("CODE", code);  
            HttpClient client = null;  
            Map<String,Object> result =new HashMap<String,Object>();  
            try {     
                client = new DefaultHttpClient();  
                HttpGet httpget = new HttpGet(requestUrl);  
                ResponseHandler<String> responseHandler = new BasicResponseHandler();  
                String response = client.execute(httpget, responseHandler);  
                JSONObject OpenidJSONO=JSONObject.fromObject(response);
                String openid =String.valueOf(OpenidJSONO.get("openid"));
                String session_key=String.valueOf(OpenidJSONO.get("session_key"));
                String unionid=String.valueOf(OpenidJSONO.get("unionid"));
                String errcode=String.valueOf(OpenidJSONO.get("errcode"));
                String errmsg=String.valueOf(OpenidJSONO.get("errmsg"));
    
                result.put("openid", openid);
                result.put("sessionKey", session_key);
                result.put("unionid", unionid);
                result.put("errcode", errcode);
                result.put("errmsg", errmsg);
            } catch (Exception e) {
                e.printStackTrace();   
            } finally {  
                client.getConnectionManager().shutdown();  
            }  
            return result;  
        }  
    }
    
    

    2,接口

    /**
         * 小程序换取openid
         *
         * @param code 识别得到用户id必须的一个值 得到网页授权凭证和用户id
         * @return
         */
        @RequestMapping("/get/openid")
        public @ResponseBody
        Object GetOpenid(String 你的小程序APPID, String code, String 你的小程序对应秘钥) {
            if (code == null || code.length() == 0) {
                throw new CustomException("code不能为空!");
            }
            return GetOpenIDUtil.oauth2GetOpenid(appid, code, appsecret);
    
        }
        这个code的话我这个一般是前端生成比较好,所以你后台的话,把接口给前端,让他那边传个code
    
    
    
    三,获取公众号openid~
    
    

    1,工具类

    public class HttpGetUtil {
        public static String httpRequestToString(String url,
                                                 Map<String,String> params) {
            String result = null;
            try {
                InputStream is = httpRequestToStream(url,  params);
                BufferedReader in = new BufferedReader(new InputStreamReader(is,
                        "UTF-8"));
                StringBuffer buffer = new StringBuffer();
                String line = "";
                while ((line = in.readLine()) != null) {
                    buffer.append(line);
                }
                result = buffer.toString();
            } catch (Exception e) {
                return null;
            }
            return result;
        }
    
        private static InputStream httpRequestToStream(String url,
                                                       Map<String, String> params) {
            InputStream is = null;
            try {
                String parameters = "";
                boolean hasParams = false;
                for(String key : params.keySet()){
                    String value = null;
                    try {
                        value = URLEncoder.encode(params.get(key), "UTF-8");
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    }
                    parameters += key +"="+ value +"&";
                    hasParams = true;
                }
                if(hasParams){
                    parameters = parameters.substring(0, parameters.length()-1);
                }
    
    
                url += "?"+ parameters;
    
                URL u = new URL(url);
                HttpURLConnection conn = (HttpURLConnection) u.openConnection();
                conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
                conn.setRequestProperty("Accept-Charset", "UTF-8");
                conn.setRequestProperty("contentType", "utf-8");
                conn.setConnectTimeout(50000);
                conn.setReadTimeout(50000);
                conn.setDoInput(true);
                //设置请求方式,默认为GET
                conn.setRequestMethod("GET");
    
    
                is = conn.getInputStream();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return is;
        }
    
        public static String  GetCodeRequest1 = "https://open.weixin.qq.com/connect/oauth2/authorize?appid=APPID&redirect_uri=REDIRECT_URI&response_type=code&scope=SCOPE&state=STATE#wechat_redirect";
        public static String getCodeRequest(String appid){
            HttpClient client = null;
            String result = null;
            String appId = appid;
            String REDIRECT_URI= "";//回调请求地址
            String SCOPE="snsapi_base";
    
            GetCodeRequest1  = GetCodeRequest1.replace("APPID", urlEnodeUTF8(appId));
            GetCodeRequest1  = GetCodeRequest1.replace("REDIRECT_URI",urlEnodeUTF8(REDIRECT_URI));
            GetCodeRequest1 = GetCodeRequest1.replace("SCOPE", SCOPE);
            result = GetCodeRequest1;
    
            System.out.println(REDIRECT_URI);
    
            return result;
        }
        public static String urlEnodeUTF8(String str){
            String result = str;
            try {
                result = URLEncoder.encode(str,"UTF-8");
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    }
    
    

    2,接口

    @RequestMapping("/get/gzh/openid")
        public @ResponseBody
        String GetGZHOpenid(HttpServletRequest request, HttpServletResponse response) throws IOException {
    
    
            String code = request.getParameter("code");//获取code
            Map params = new HashMap();
            params.put("secret", 你的公众号秘钥);
            params.put("appid", 你的公众号APPID);
            params.put("grant_type", "authorization_code");
            params.put("code", code);
            String result = HttpGetUtil.httpRequestToString(
                    "https://api.weixin.qq.com/sns/oauth2/access_token", params);
            JSONObject jsonObject = JSONObject.fromObject(result);
    
            String openid = jsonObject.get("openid").toString();
            LOGGER.debug("code------" + code);
            LOGGER.debug("得到的openid为:" + openid);
            return openid;
    
        }
    
    
    四,通过微信获取的openid来获取用户信息
    
    

    1,工具类

    /**
     * 获取accessToken
     *
     */
    public class GetAccessTokenUtil {
        // 网页授权接口
        public final static String GetPageAccessTokenUrl = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET";
        public static Map<String, String> getAccessToken(String appid, String appsecret) {
            String requestUrl = GetPageAccessTokenUrl.replace("APPID", appid).replace("APPSECRET", appsecret);
            HttpClient client = null;
            Map<String, String> result = new HashMap<String, String>();
            String accessToken = null;
            try {
                client = new DefaultHttpClient();
                HttpGet httpget = new HttpGet(requestUrl);
                ResponseHandler<String> responseHandler = new BasicResponseHandler();
                String response = client.execute(httpget, responseHandler);
                JSONObject OpenidJSONO = JSONObject.fromObject(response);
                accessToken = String.valueOf(OpenidJSONO.get("access_token"));
                result.put("accessToken", accessToken);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                client.getConnectionManager().shutdown();
            }
            return result;
        }
    }
    
    
    //通过openid获取用户的信息,这个看你需要获取用户的哪些信息,
    //  https://mp.weixin.qq.com/wiki?t=resource/res_main&id=mp1421140839   这个是微信官方的获取unionid机制  用户信息
    public class GetBasicInformation {
        // 网页授权接口
        public final static String GetPageAccessTokenUrl = "https://api.weixin.qq.com/cgi-bin/user/info?access_token=ACCESS_TOKEN&openid=OPENID&lang=zh_CN";
    
        public static Map<String, String> getAccessToken(String access_token, String openid) {
            String requestUrl = GetPageAccessTokenUrl.replace("ACCESS_TOKEN", access_token).replace("OPENID", openid);
            HttpClient client = null;
            Map<String, String> result = new HashMap<String, String>();
            try {
                client = new DefaultHttpClient();
                HttpGet httpget = new HttpGet(requestUrl);
                ResponseHandler<String> responseHandler = new BasicResponseHandler();
                String response = client.execute(httpget, responseHandler);
                JSONObject OpenidJSONO = JSONObject.fromObject(response);
    
    //            String accessToken = String.valueOf(OpenidJSONO.get("access_token"));
                String subscribe = String.valueOf(OpenidJSONO.get("subscribe"));
                String nickname = new String(String.valueOf(OpenidJSONO.get("nickname")).getBytes("ISO8859-1"),"UTF-8");
                String sex = String.valueOf(OpenidJSONO.get("sex"));
                String language = String.valueOf(OpenidJSONO.get("language"));
                String city = new String(String.valueOf(OpenidJSONO.get("city")).getBytes("ISO8859-1"),"UTF-8");
                String province = new String(String.valueOf(OpenidJSONO.get("province")).getBytes("ISO8859-1"),"UTF-8");
                String country = new String(String.valueOf(OpenidJSONO.get("country")).getBytes("ISO8859-1"),"UTF-8");
                String headimgurl = String.valueOf(OpenidJSONO.get("headimgurl"));
                String subscribeTime = String.valueOf(OpenidJSONO.get("subscribe_time"));
                String unionid = String.valueOf(OpenidJSONO.get("unionid"));
    //            String accessToken =new String(String.valueOf(OpenidJSONO.get("access_token")).getBytes("ISO8859-1"),"UTF-8");
    //            String openid =new String(String.valueOf(OpenidJSONO.get("openid")).getBytes("ISO8859-1"),"UTF-8");
    //            String openid =new String(String.valueOf(OpenidJSONO.get("openid")).getBytes("ISO8859-1"),"UTF-8");
    //            String openid =new String(String.valueOf(OpenidJSONO.get("openid")).getBytes("ISO8859-1"),"UTF-8");
    //            String openid =new String(String.valueOf(OpenidJSONO.get("openid")).getBytes("ISO8859-1"),"UTF-8");
    //            String openid =new String(String.valueOf(OpenidJSONO.get("openid")).getBytes("ISO8859-1"),"UTF-8");
    //            String openid =new String(String.valueOf(OpenidJSONO.get("openid")).getBytes("ISO8859-1"),"UTF-8");
    //            String openid =new String(String.valueOf(OpenidJSONO.get("openid")).getBytes("ISO8859-1"),"UTF-8");
    //            String openid =new String(String.valueOf(OpenidJSONO.get("openid")).getBytes("ISO8859-1"),"UTF-8");
    //            String openid =new String(String.valueOf(OpenidJSONO.get("openid")).getBytes("ISO8859-1"),"UTF-8");
    //            String openid =new String(String.valueOf(OpenidJSONO.get("openid")).getBytes("ISO8859-1"),"UTF-8");
    
    //            String openid = String.valueOf(OpenidJSONO.get("openid"));
    //            result.put("accessToken", accessToken);
                result.put("subscribe", subscribe);
                result.put("nickname", nickname);
                result.put("sex", sex);
                result.put("language", language);
                result.put("city", city);
                result.put("province", province);
                result.put("country", country);
                result.put("headimgurl", headimgurl);
                result.put("subscribeTime", subscribeTime);
                result.put("unionid", unionid);
                
    //            System.out.println(accessToken+"==================="+unionid);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                client.getConnectionManager().shutdown();
            }
            return result;
        }
    }
    
    

    2,接口

    /**
         * 微信公众号获取微信unionid和其他个人信息   需要关注公众号
         *
         * @param openid
         * @return
         */
        @RequestMapping("/basic/Information")
        public @ResponseBody
        Map basicInformation(String openid) {
            //得到access_token
            String accessToken = GetAccessTokenUtil.getAccessToken(你的公众号APPID, 你的公众号APPID对应的秘钥).get("accessToken");
            LOGGER.debug("accessToken------" + accessToken);
            return GetBasicInformation.getAccessToken(accessToken, openid);
        }
    
    
    
    总结:这个就是微信小程序和微信公众号获取openid  以及通过openid获取unionid以及用户信息的代码,微信开发文档上面看感觉功力不深厚是很难看懂的,这个我也是通过网上或者同事慢慢总结出来的。  请大家多多指教,谢谢!
    [这是我博客园地址](https://www.cnblogs.com/lxwt/p/10154540.html)
    
    展开全文
  • openid是微信小程序用户的唯一标识,是开发者很需要获取的信息。 传统的小程序开发,获取用户openid,十分的繁琐,要进行一系列的校验及数据交换。 但是云开发获取起来就十分的简单。 我们创建一个云函数,取名为...

    现在微信小程序越来越火,遍布各个行业,也有越来越多的开发者涉及小程序的开发。
    在这里插入图片描述

    云开发的发展也越来越迅速,对于个人开发及初学者十分的友好。
    云存储、云数据库、云函数可以基本满足开发者的所有需求。
    在这里插入图片描述

    openid是微信小程序用户的唯一标识,是开发者很需要获取的信息。
    传统的小程序开发,获取用户openid,十分的繁琐,要进行一系列的校验及数据交换。
    但是云开发获取起来就十分的简单。
    我们创建一个云函数,取名为getOpenId,创建完成之后,我们可以发现初始的代码片段,就有返回openid的操作。

    // 云函数入口文件
    const cloud = require('wx-server-sdk')
    cloud.init()
    // 云函数入口函数
    exports.main = async (event, context) => {
      const wxContext = cloud.getWXContext()
      return {
        event,
        openid: wxContext.OPENID,
        appid: wxContext.APPID,
        unionid: wxContext.UNIONID,
      }
    }
    

    这里面return的有openid,appid,unionid,我们只需要openid,所以删掉其它多余代码片段。

    // 云函数入口文件
    const cloud = require('wx-server-sdk')
    cloud.init()
    // 云函数入口函数
    exports.main = async (event, context) => {
      const wxContext = cloud.getWXContext()
      return {
        openid: wxContext.OPENID
      }
    }
    

    云函数代码编写完毕,我们记得右键上传并部署一下。
    我们写一下JS代码,就是调用云函数的代码。

    wx.cloud.callFunction({
      name:'getOpenId',
      success(res){
        console.log(res.result.openid)
      }
    })
    

    代码很简单,就是一个基本的调用,我们输出一下返回值res,就可以在其中找到openid的值
    在这里插入图片描述
    大家有什么关于小程序云开发的问题可以联系我QQ:505417246
    关注下面微信公众号,可以领取微信小程序、Vue、TypeScript、前端、uni-app、全栈、Nodejs等实战学习资料
    在这里插入图片描述

    展开全文
  • PHP 微信开发(获取用户信息): ...snsapi_userinfo ,需要用户点击授权,能获取openid所有用户信息; 第一步:先获取用户的code值; 第二步:根据code值去获取access_token,每次请求的值都不一...
  • 这就要求先获取用户的openid(微信公众号的用户唯一凭证),然后与业务系统的用户信息进行验证和绑定。如何获取用户的openid在开发指引中,微信网页授权章节里,做了详细的介绍。获取用户信息,需要四步。第一步:用户...
  • 小程序开发者密码(AppSecret)是一个非常重要字段,使用该...开发者应将Appsecret保存到后台服务器中,通过服务器使用Appsecert获取Accesstoken。微信公众平台小程序后台服务器地址设置也将禁止将“api.we...
  • 1.通过微信开放 获取用户列表接口,获取所有的用户openid。 2.通过网页授权获取openid(当前授权的用户)。 一、通过微信开放 获取用户列表接口,获取所有的用户openid 微信官方文档地址:...
  • 微信每次访问 请求 首先经过授权 拿到code换取openidopenid存入cookie 这以后的所有访问url 全部都从cookie中获取openid 如果没有在获取code换取 可以解决问题: 1,如何存储获取用户信息及调用第三方...
  • 获取微信openid

    2017-06-01 16:22:03
    为了识别用户,每个用户针对每个公众号会产生一个安全的OpenID,如果需要在多公众号、移动应用之间做用户共通,则需前往微信开放平台,将这些公众号和应用绑定到一个开放平台账号下,绑定后,一个用户虽然对多个...
  • 为了识别用户,每个用户针对每个公众号会产生一个安全的OpenID,如果需要在多公众号、移动应用之间做用户共通,则需前往微信开放平台,将这些公众号和应用绑定到一个开放平台账号下,绑定后,一个用户虽然对多个...
  • 注意:如果设置是域名则该网站下的所有页面都可以作为回调页面,如果设置是某个目录则回调页面只能在该目录下 二、开始授权 1、获取code: 引导用户访问下面地址(是直接跳转还是点击链接按钮跳转自己决定...
  • 讲解用户在微信客户端中访问第三方网页,公众号可以通过微信网页授权机制,来获取用户基本信息,进而实现业务逻辑。 获取code、access_token、openid、用户...08-获取微信用户的所有信息 09-用户头像、昵称、区域、性别
  • 讲解用户在微信客户端中访问第三方网页,公众号可以通过微信网页授权机制,来获取用户基本信息,进而实现业务逻辑。 获取code、access_token、openid、用户昵称、地区、性别、头像等 ...09-获取最终用户的所有信息
  • 讲解用户在微信客户端中访问第三方网页,公众号可以通过微信网页授权机制,来获取用户 基本信息,进而实现业务逻辑。 获取code、access_token...07-PHP获取微信用户所有数据 08-PHP获取微信用户头像、昵称、区域、性别
  • 公众号可通过本接口来获取帐号的关注者列表,关注者列表由一串OpenID(加密后的微信号,每个用户对每个公众号的OpenID是唯一的)组成。一次拉取调用最多拉取10000个关注者的OpenID,可以通过多次拉取的方式来满足需求...
  • 注意:为了识别用户,每个用户针对每个公众号会产生一个安全的OpenID,如果需要在多公众号、移动应用之间做用户共通,则需前往微信开放平台,将这些公众号和应用绑定到一个开放平台账号下,绑定后,一个用户虽然对多...
  •  需要做一套微信签到、抽奖系统,我要在后台存储微信用户的相关信息,openIDNickname之类的信息。在开发前有一点准备工作,先去授权权限,在权限表里进行设置,如图:   填写这个网站地址的时候一定要注意填写...
  • node获取微信授权拿到openid 需要了解网站 1.微信授权。 先说一下流程(一张图代替所有): 流程步骤: 1.用户同意,获取code。 2.通过code获取网页授权access_token. 3.获取用户信息。 开始搞事情: ...
  • 该方法获取所有关注公共账号的微信用户的openId集合,再通过openId集合既可以获取所有的用户的信息。/*** 获取所有的关注用户** @return*/public List getAllWeiXinUser() {GetExistAccessToken getExistAccessToken...
  • 微信官方给出解密算法,下载PYTHON...在项目APP中新建一个WXBizDataCrypt.py,将微信给WXBizDataCrypt.py文件中所有内容粘贴进去。 import base64 import json from Crypto.Cipher import AES class WXBizDataCr...
  • 获得openid用户信息

    2015-10-12 17:33:00
    b、通过查询所有用户OPenid接口获取所有用户。 string url = "https://api.weixin.qq.com/cgi-bin/user/get?access_token=" + access_token; c、通过获取用户openid,然后通过openid获取用户数据 d...
  • 该方法获取所有关注公共账号的微信用户的openId集合,再通过openId集合既可以获取所有的用户的信息。 /** * 获取所有的关注用户 * * @return */ public List<String> getAllWeiXinUser() { ...
  • 接到项目就麻溜写,对微信一无所知以为最后和支付宝一样接支付就好, 谁知道一直不通,最后请教别人才知道 所有公众号里微信网页一进来就是要微信授权获得openid 以备后面支付其用户信息使用。 判断浏览器 如果...
  • 我们保存了数十万个微信用户的openid。由于历史原因,却没有保存openid以外的信息。现在需要做一个操作把所有的关注者的微信资料补充完整。如何获取微信用户的资料?参考官方接口文档, ...
  • OpenID Connect OpenID Connect 1.0是OAuth 2.0协议之上的一个简单的身份层。...OpenID Connect允许所有类型的客户端(包括基于Web的移动和JavaScript客户端)请求和接收关于认证会话和最终用户的信息。 规范套件...
  • 然后前端在所有页面前拦截如login页面,查看是否有token或openid, 然后没有去请求获取授权地址, 然后后台通过授权码模式拿到微信信息,返回系统自建token返回给前端 2, 在公众号底部菜单栏地址配置 code授权码模式去...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 145
精华内容 58
关键字:

获取所有用户的openid