微信小程序手机号-springboot

最新推荐文章于 2024-08-25 17:22:44 发布
最新推荐文章于 2024-08-25 17:22:44 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： SpingBoot 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/biancheng4/article/details/124049344
版权

1.前端传数据只需要传递code

在这里插入图片描述

post请求携带参数为code,请求中的access_token需要用APPID和密钥获取

在这里插入图片描述

2.后台代码

   /*
       *  获取小程序用户手机号
       */

      @ResponseBody
      @ApiOperation(value = "获取小程序用户基本信息（手机号）", httpMethod = "GET")
      @RequestMapping(value = "/code2Session", method = RequestMethod.GET)
      @ApiImplicitParams({
              @ApiImplicitParam(paramType = "query", name = "code", dataType = "String", value = "微信的 code", required = true),
              @ApiImplicitParam(paramType = "query", name = "openid", dataType = "String", value = "微信的 openid", required = true),
      })
      public CommonResponse code2Session(String code, String openid) throws Exception {

            //使用appid和密钥获取access_token
            String url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=" + appID + "&secret=" + appSecret;
            JSONObject jsonObject = HttpUtil.doGetJson(url);
            
            log.info(jsonObject.getString("access_token"));
            
            //使用access_token和code获取手机号
            String url1 = "https://api.weixin.qq.com/wxa/business/getuserphonenumber?access_token=" + jsonObject.getString("access_token");
            log.info(jsonObject.toString());
            JSONObject data = new JSONObject();
            data.put("code", code);
            JSONObject jsonObject1 = HttpUtil.DO_POST(url1,data);
            log.info(jsonObject1.toString());
            JSONObject phone_info = (JSONObject) jsonObject1.get("phone_info");
            String phoneNumber = phone_info.getString("phoneNumber");

            log.info(phoneNumber);

            UserInfo user = userService.findByOpenID(openid);
            if (user == null){
                return CommonResponse.fail(201, "请先授权");
            }

            user.setPhonenumber(phoneNumber);

            userService.upDate(user);
            return CommonResponse.ok(phoneNumber);
      }

3.HttpUtils

 package com.school.zhaoban.utils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.school.zhaoban.response.CommonResponse;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.AuthSchemes;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
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.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.BufferedHttpEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;


import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.*;

/*************************************************************
 * Description: HttpClient 4.5 Utils
 * Author: Liu Botian
 * CreateTime: 2017/6/7
 *
 ************************************************************/
public class HttpUtil {

    private static Certificate cert = null;

    private static SSLConnectionSocketFactory socketFactory;//私密连接工厂

    private static TrustManager manager = new X509TrustManager() {
        @Override
        public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

        }

        @Override
        public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    };

    /**
     * 是否忽略证书.https网站一般情况下使用了安全系数较低的SHA-1签名，因此首先我们在调用SSL之前需要重写验证方法，取消检测SSL。
     */
    private static void enableSSl(boolean isIgnore) {
        try {
            SSLContext context = SSLContext.getInstance("TLS");
            if (isIgnore) {
                context.init(null, new TrustManager[]{manager}, null);
            } else {
                context.init(null, new TrustManager[]{httpsManager}, null);
            }
            socketFactory = new SSLConnectionSocketFactory(context, NoopHostnameVerifier
                    .INSTANCE);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
    }

    /**
     * 证书获取
     * @param certificateUrl 证书地址.
     */
    private static void initHttpsCertificate(String certificateUrl) {
        try {
            FileInputStream fis = new FileInputStream(certificateUrl);
            BufferedInputStream bis = new BufferedInputStream(fis);

            CertificateFactory cf = CertificateFactory.getInstance("X.509");

            while (bis.available() > 0) {
                cert = cf.generateCertificate(bis);
            }
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (CertificateException e) {
            e.printStackTrace();
        }
    }

    private static TrustManager httpsManager = new X509TrustManager() {
        @Override
        public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String s) throws CertificateException {

        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[] { (X509Certificate) cert };
        }
    };


    /**
     * get
     *
     * @throws Exception
     */
    public static  String Method(Map<String,String> map, String token,String creat_url) throws IOException {
        URL restURL = new URL(creat_url);
        JSONObject jsonObject = new JSONObject();
        // jsonObject.put("Type","ChatRoom");
        jsonObject.put("no",map.get("no"));

        String s1 = jsonObject.toJSONString();
        HttpURLConnection conn = (HttpURLConnection) restURL.openConnection();
        conn.setRequestMethod("GET");
        conn.setRequestProperty("Authorization", token);
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);
        PrintStream ps = new PrintStream(conn.getOutputStream());
        ps.print(s1);
        ps.close();
        BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String line;
        String str = null;
        while((line = br.readLine()) != null ){
            str = line;
        }
        br.close();
//        String str =JSONObject.parseObject(str).getString("GroupId");
        return str;



    }


    /**
     * 发送post请求
     * @param url
     * @param json
     * @return
     */
    public static JSONObject DO_POST(String url, JSONObject json){
        DefaultHttpClient client = new DefaultHttpClient();
        HttpPost post = new HttpPost(url);
        JSONObject response = null;
        try {
            StringEntity s = new StringEntity(json.toString());
            s.setContentEncoding("UTF-8");
            s.setContentType("application/json");//发送json数据需要设置contentType
            post.setEntity(s);
            HttpResponse res = client.execute(post);
            if(res.getStatusLine().getStatusCode() == HttpStatus.SC_OK){
                HttpEntity entity = res.getEntity();
                String result = EntityUtils.toString(res.getEntity());// 返回json格式：
                response = JSONObject.parseObject(result);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return response;
    }



    public static CommonResponse getExpress(String no) throws  Exception{
        String host = "https://wuliu.market.alicloudapi.com";       //【1】请求地址  支持http 和 https 及 WEBSOCKET
        String path = "/kdi";                                     //【2】后缀
        String appcode = "70b8fac5a1e84b478b3115f0f3e6e7de";                             //【3】AppCode  你自己的AppCode 在买家中心查看
        //String no = "75315515586562";                                     //【4】参数，具体参照api接口参数
        //String type = "zto";                                            //【5】参数，具体参照api接口参数
        String urlSend = host + path + "?no=" + no ;   //【6】拼接请求链接
        /*【1】 ~ 【6】 需要修改为对应的 可以参考产品详情 */
        URL url = new URL(urlSend);
        HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
        httpURLConnection.setRequestProperty("Authorization", "APPCODE " + appcode);//格式Authorization:APPCODE (中间是英文空格)
        int httpCode = httpURLConnection.getResponseCode();
        if (httpCode==200){
            String json = read(httpURLConnection.getInputStream());
            System.out.println("/* 获取服务器响应状态码 200 正常；400 权限错误 ； 403 次数用完； */ ");
            System.out.println(httpCode);
            System.out.println("/* 获取返回的json   */ ");
            System.out.print(json);
            JSONObject jo = JSONObject.parseObject(json);
            int status = jo.getInteger("status");
            if (status==0){
                String str = jo.getString("result");
                JSONObject jo1 = JSONObject.parseObject(str);
                String strList = jo1.getString("list");
                JSONArray jsonArray = JSONArray.parseArray(strList);
                return CommonResponse.ok(jsonArray);
            }
            return CommonResponse.fail(200,"单号输入有误或暂无物流信息");

        }
        return CommonResponse.fail();




    }
    /*
        读取返回结果
     */
    private static String read(InputStream is) throws IOException {
        StringBuffer sb = new StringBuffer();
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        String line = null;
        while ((line = br.readLine()) != null) {
            line = new String(line.getBytes(), "utf-8");
            sb.append(line);
        }
        br.close();
        return sb.toString();
    }




    /**
     * httpClient get http 请求.
     * @param url     请求路径.
     * @param values  请求参数.
     * @return response 请求结果状态.
     */
    public static String doGet(String url, List<NameValuePair> values) throws IOException {
        RequestConfig config = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT).build();
        //最新版的httpClient使用实现类的是closeableHTTPClient,以前的default作废了.设置可关闭的httpclient
        CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(config).build();

        StringBuilder urlBuffer = new StringBuilder(url);
        if (!url.contains("?")) {
            urlBuffer.append("?");
        }

        if (values != null) {
            for (NameValuePair nameValuePair : values) {
                urlBuffer.append("&").append(nameValuePair.getName()).append("=")
                        .append(URLEncoder.encode(nameValuePair.getValue(), "UTF-8"));
            }
        }

        HttpGet get = new HttpGet(urlBuffer.toString());
        CloseableHttpResponse response = httpClient.execute(get);
        return getResponseContent(response);
    }
    /**
     * get请求,设置headers
     * get
     * @param path
     * @param values
     * @param headers
     * @return
     * @throws Exception
     */
    public static String doGet(String path, List<NameValuePair> values,
                               Map<String, String> headers)
            throws Exception {
        RequestConfig config = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT).build();
        //最新版的httpClient使用实现类的是closeableHTTPClient,以前的default作废了.设置可关闭的httpclient
        CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(config).build();
        StringBuilder urlBuffer = new StringBuilder(path);
        if (!path.contains("?")) {
            urlBuffer.append("?");
        }
        if (values != null) {
            for (NameValuePair nameValuePair : values) {
                urlBuffer.append("&").append(nameValuePair.getName()).append("=")
                        .append(URLEncoder.encode(nameValuePair.getValue(), "UTF-8"));
            }
        }
        HttpGet request = new HttpGet(urlBuffer.toString());
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        CloseableHttpResponse response = httpClient.execute(request);
        return getResponseContent(response);
    }

    /**
     * httpClient post http 请求.
     * @param url     请求路径.
     * @param values  请求参数.
     * @return response 请求结果状态.
     */
    public static String doPost(String url, List<NameValuePair> values) throws IOException {
        RequestConfig config = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT).build();
        CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(config).build();

        HttpPost post = new HttpPost(url);

        if (values != null) {
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity((List<? extends NameValuePair>) values,"UTF-8");
            //StringEntity entity = new StringEntity(values);
            post.setEntity(entity);
        }
        CloseableHttpResponse response = httpClient.execute(post);
        return getResponseContent(response);

    }


    /**
     * http请求 数据流传参
     * @param url  请求地址
     * @param json json参数
     * @return
     * @throws IOException
     */
    public static String doPostForFlow(String url,String json) throws IOException{
        RequestConfig config = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT).build();
        CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(config).build();
        HttpPost httpPost = new HttpPost(url);
        if(StringUtils.isNotBlank(json)){
            StringEntity entity = new StringEntity(json,"UTF-8");
            entity.setContentEncoding("UTF-8");
            entity.setContentType("application/json");
            httpPost.setEntity(entity);
        }
        CloseableHttpResponse response = httpClient.execute(httpPost);
        return getResponseContent(response);
    }


    /**
     * httpClient post http 请求.
     * @param url
     * @param values
     * @param headers
     * @return
     * @throws IOException
     */
    public static String doPost(String url, List<NameValuePair> values, Map<String, String> headers) throws IOException {
        RequestConfig config = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT).build();
        CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(config).build();

        HttpPost post = new HttpPost(url);
        String charset = "UTF-8";
        if (values != null) {
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(values,charset);
            post.setEntity(entity);
        }
        for (Map.Entry<String, String> e : headers.entrySet()) {
            post.addHeader(e.getKey(), e.getValue());
        }
        CloseableHttpResponse response = httpClient.execute(post);
        return getResponseContent(response);

    }

    /**
     * httpClient get https 请求.
     * @param url     请求路径.
     * @param values  请求参数.
     * @return response 请求结果状态.
     */
    public static String ignoreGetForHttps(String url, List<NameValuePair> values, boolean isIgnoreSSL) throws
            IOException {
        enableSSl(isIgnoreSSL);
        RequestConfig config = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT)
                .setExpectContinueEnabled(true).setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM,
                        AuthSchemes.DIGEST)).setProxyPreferredAuthSchemes(Collections.singletonList(AuthSchemes.BASIC))
                .build();
        //创建可用Scheme
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.INSTANCE).register("https", socketFactory).build();
        //创建ConnectionManager，添加Connection配置信息
        PoolingHttpClientConnectionManager connectionManager = new
                PoolingHttpClientConnectionManager(socketFactoryRegistry);

        CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(connectionManager)
                .setDefaultRequestConfig(config).build();

        StringBuilder urlBuffer = new StringBuilder(url);
        if (!url.contains("?")) {
            urlBuffer.append("?");
        }

        if (values != null) {
            for (NameValuePair nameValuePair : values) {
                urlBuffer.append("&").append(nameValuePair.getName()).append("=")
                        .append(URLEncoder.encode(nameValuePair.getValue(), "UTF-8"));
            }
        }

        HttpGet get = new HttpGet(urlBuffer.toString());

        CloseableHttpResponse response = httpClient.execute(get);

        return getResponseContent(response);
    }

    /**
     * httpClient get https 请求.
     * @param url     请求路径.
     * @return response 请求结果状态.
     */
    public static String ignoreGetForHttps(String url, boolean isIgnoreSSL) throws
            IOException {
        enableSSl(isIgnoreSSL);
        RequestConfig config = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT)
                .setExpectContinueEnabled(true).setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM,
                        AuthSchemes.DIGEST)).setProxyPreferredAuthSchemes(Collections.singletonList(AuthSchemes.BASIC))
                .build();
        //创建可用Scheme
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.INSTANCE).register("https", socketFactory).build();
        //创建ConnectionManager，添加Connection配置信息
        PoolingHttpClientConnectionManager connectionManager = new
                PoolingHttpClientConnectionManager(socketFactoryRegistry);

        CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(connectionManager)
                .setDefaultRequestConfig(config).build();

        HttpGet get = new HttpGet(url);

        CloseableHttpResponse response = httpClient.execute(get);

        return getResponseContent(response);
    }


    /**
     * httpClient post https 请求.
     * @param url     请求路径.
     * @param values  请求参数.
     * @return response 请求结果状态.
     */
    public static String ignorePostForHttps(String url, List<NameValuePair> values, boolean isIgnoreSSL)
            throws IOException {
        enableSSl(isIgnoreSSL);
        //首先设置全局的标准cookie策略
        RequestConfig config = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT)
                .setExpectContinueEnabled(true).setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM,
                        AuthSchemes.DIGEST)).setProxyPreferredAuthSchemes(Collections.singletonList(AuthSchemes.BASIC))
                .build();

        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.INSTANCE).register("https", socketFactory).build();

        PoolingHttpClientConnectionManager connectionManager = new
                PoolingHttpClientConnectionManager(socketFactoryRegistry);

        CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(connectionManager)
                .setDefaultRequestConfig(config).build();

        HttpPost post = new HttpPost(url);

        if (values != null) {
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(values,Charset.forName("UTF-8"));
            post.setEntity(entity);
        }
        CloseableHttpResponse response = httpClient.execute(post);
        return getResponseContent(response);
    }

    /**
     * 获取请求返回值.
     */
    private static String getResponseContent(CloseableHttpResponse response)
            throws IOException {
        try {
            if (HttpStatus.SC_OK == response.getStatusLine().getStatusCode()) {
                HttpEntity httpEntity = response.getEntity();
                httpEntity = new BufferedHttpEntity(httpEntity);
                return EntityUtils.toString(httpEntity);
            }
        } finally {
            response.close();
        }
        return null;
    }
    public static String post(String URL,JSONObject json) {
        HttpClient client = new DefaultHttpClient();
        HttpPost post = new HttpPost(URL);

        post.setHeader("Content-Type", "application/json");
        post.addHeader("Authorization", "Basic YWRtaW46");
        String result = "";

        try {

            StringEntity s = new StringEntity(json.toString(), "utf-8");
            s.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE,
                    "application/json"));
            post.setEntity(s);

            // 发送请求
            HttpResponse httpResponse = client.execute(post);

            // 获取响应输入流
            InputStream inStream = httpResponse.getEntity().getContent();
            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    inStream, "utf-8"));
            StringBuilder strber = new StringBuilder();
            String line = null;
            while ((line = reader.readLine()) != null)
                strber.append(line + "\n");
            inStream.close();

            result = strber.toString();
            System.out.println(result);

            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {

                System.out.println("请求服务器成功，做相应处理");

            } else {

                System.out.println("请求服务端失败");

            }


        } catch (Exception e) {
            System.out.println("请求异常");
            throw new RuntimeException(e);
        }

        return result;
    }


    public static void main(String[] args) {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost httpPost = new HttpPost("https://webapi.sms.mob.com/sms/verify");
        httpPost.setHeader("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:60.0) Gecko/20100101 Firefox/60.0");
        List<NameValuePair> nvp = new ArrayList<NameValuePair>();
        nvp.add(new BasicNameValuePair("appkey", "301d78dadaf84"));
        nvp.add(new BasicNameValuePair("phone", "15829037255"));
        nvp.add(new BasicNameValuePair("zone", "86"));
        nvp.add(new BasicNameValuePair("code", "992891"));
        CloseableHttpResponse response = null;
        String postEntity = null;
        try {
            httpPost.setEntity(new UrlEncodedFormEntity(nvp));
            response = httpClient.execute(httpPost);
            System.out.println(response.getStatusLine());
            HttpEntity entity = response.getEntity();
            postEntity = EntityUtils.toString(entity,"utf-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println(postEntity);
        net.sf.json.JSONObject jo = net.sf.json.JSONObject.fromObject(postEntity);
        String status = jo.getString("status");
        System.out.println("status=="+status);
    }






    public static JSONObject doGetJson(String url) throws ClientProtocolException, IOException{
        JSONObject jsonObject = null;
        DefaultHttpClient client = new DefaultHttpClient();
        HttpGet httpGet = new HttpGet(url);
        HttpResponse response = client.execute(httpGet);//发送请求
        HttpEntity entity = response.getEntity();
        if(entity !=null) {
            String result = EntityUtils.toString(entity, "UTF-8");
            jsonObject = JSONObject.parseObject(result);
        }
        httpGet.releaseConnection();//释放连接
        return jsonObject;

    }







    public static String doHttpsGetJson(String Url)
    {
        String message = "";
        try
        {
            System.out.println("doHttpsGetJson");//TODO:dd
            URL urlGet = new URL(Url);
            HttpURLConnection http = (HttpURLConnection) urlGet.openConnection();
            http.setRequestMethod("GET");      //必须是get方式请求    24
            http.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
            http.setDoOutput(true);
            http.setDoInput(true);
            System.setProperty("sun.net.client.defaultConnectTimeout", "30000");//连接超时30秒28
            System.setProperty("sun.net.client.defaultReadTimeout", "30000"); //读取超时30秒29 30
            http.connect();
            InputStream is =http.getInputStream();
            int size =is.available();
            byte[] jsonBytes =new byte[size];
            is.read(jsonBytes);
            message=new String(jsonBytes,"UTF-8");
        }
        catch (MalformedURLException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return message;
    }


}
又菜又爱玩呜呜呜~
关注
专栏目录
uniapp(vue3) - 实现微信小程序平台端微信授权登录功能，Java后端实现前端uniApp小程序微信授权登录，uni-app+SpringBoot微信小程序登录授权获取用户昵称头像手机号源码
王佳斌
10-26 5790
uniapp，vue3，微信小程序，java，SpringBoot，微信授权登录，uni-app微信小程序+SpringBoot(java)实现小程序授权登录获取用户的数据，获取用户头像昵称等信息，微信小程序与Java后端实现微信授权登录功能，Uniapp微信小程序 + Java实现微信授权登录，uniapp vue3微信小程序登录授权，拿到用户手机号，一键登录，UNIAPP实现微信小程序登录授权和手机号授权功能(uniapp做微信小程序)，前后端源码，详细示例代码，调用微信提供的第三方接口来实现，Java
SpringBoot中获取微信用户信息的方法
08-25
主要介绍了SpringBoot中获取微信用户信息的方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
微信小程序获取手机号Springboot 服务端
qq_53722480的博客
01-04 630
4.微信开发者工具小程序调用。
微信小程序一键登录获取手机号
最新发布
weixin_73318685的博客
08-25 1708
小程序报错：stop:fail api scope is not declared in the privacy agreement 。 解决方案：需要去小程序后台添加隐私操作 登录小程序后台设置隐私权限：打开获取用户手机号权限，我的-设置-基本设置-服务内容声明-用户隐私保护指引更新=>选择手机号栏后填写完善信息，等待审核通过即可。；设置button 组件的 open-type值为getPhoneNumber；将小程序获取到的 code 值传给后端 ，后端进行处理
springboot 微信小程序获取用户手机号 最新方式
qq_43025316的博客
09-20 3482
springboot 小程序获取用户手机号
微信小程序获取手机号，，加后端SpringBoot接口
weixin_52184611的博客
06-11 1303
微信小程序获取手机号，前端+后端接口。
springboot获取微信电话
AYANBAO的博客
04-18 360
【代码】springboot获取微信电话。
微信小程序+springboot后台.zip
09-02
微信小程序和SpringBoot后台是两种常见的技术，它们在构建现代互联网应用中发挥着重要作用。本项目结合了这两种技术，提供了一个完整的解决方案，用于创建和管理活动投票。 微信小程序是一种轻量级的应用运行环境，...
微信小程序 springboot后台如何获取用户的openid
08-25
微信小程序 SpringBoot 后台获取用户的 OpenID 微信小程序 SpringBoot 后台获取用户的 OpenID 是指在微信小程序中，通过 SpringBoot 后台来获取用户的 OpenID，这个过程需要通过微信 API 来实现。下面将详细介绍...
微信小程序获取手机号授权用户登录功能
08-28
微信小程序获取手机号授权用户登录功能 微信小程序获取手机号授权用户登录功能是微信小程序中一个重要的功能，旨在让用户快速获取微信绑定手机号码，无须用户手动填写。这个功能可以使用户注册用户信息更加便捷，...
SpringBoot微信小程序登录/授权获取手机号
u010128060的博客
10-09 2627
/** * 微信登录 * * @param encryptedData * @param iv * @param code * @param session * @return */ @RequestMapping(value = "/loginWX", method = RequestMethod.POST) @ResponseBody public Object loginWX(String enc.
微信小程序如何通过用户授权获取手机号(getPhoneNumber)
10-15
主要介绍了微信小程序如何通过用户授权获取手机号(getPhoneNumber),文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot微信小程序获取手机号、Ali的ocr识别身份证
m0_55841258的博客
05-11 446
1.1方法1.2httpPostRaw请求工具类。
SpringBoot整合微信小程序登录获取手机号并解密
m0_54228224的博客
08-12 3705
微信小程序获取手机号码并解密
Java SpringBoot 实现微信小程序登录，获取用户信息、手机号、用户公众号openId
weixin_43910274的博客
03-17 7881
Java 微信小程序登录 获取用户信息、用户手机号、小程序绑定的用户公众号openId
springboot 微信小程序 实现获取手机号登录
weixin_42487883的博客
07-19 905
要在 Spring Boot 应用中实现与微信小程序的手机号登录功能，首先需要了解微信小程序的登录机制以及如何将其与 Spring Boot 后端整合。
java springboot微信小程序获取手机号码
weixin_42413860的博客
04-18 2785
开发前提，注册小程序获取appid和secret 小程序端添加获取手机号码按钮 <button size="mini" class="mobile" open-type="getPhoneNumber" bindgetphonenumber="getPhoneNumber" wx:if="{{!mobile}}">获取手机号码</button> 添加绑定事件 g...
uniapp+SpringBoot实现微信小程序手机号一键登录全流程（附前后端代码及详细解释）
man2017的博客
05-22 1580
实现微信小程序手机号一键登录的全流程涉及前端（uni-app）和后端（Spring Boot）的协同工作。这个过程主要包括以下几个步骤：用户授权、获取手机号码、后端验证与生成Token、前端存储Token。下面我将分步骤详细介绍，并提供简化版的示例代码。
springboot 实现微信小程序授权并解密手机号
iamlzyoco的博客
10-23 2166
1.授权 授权是有前端完成的，授权后，前端可以获取到code，后台根据code获取微信小程序用户对应的openid和session_key，并根据openid判断是否是新用户，代码如下： @Value("${app.weixin.mn.appid}") String appidxcx; @Value("${app.weixin.mn.secret}") String secretxcx; @ApiOperation(value = "微信小程序校验用户是否存在", httpMethod =
微信小程序获取手机号 springboot
04-08
您好，关于微信小程序获取手机号的问题，可以使用微信提供的API，具体实现可以参考Spring Boot官方文档或相关的开发教程。另外，如果您对Spring Boot或微信小程序开发有任何疑问或需要帮助，我也很乐意为您提供帮助。 顺便讲个笑话，为什么大象不能打网球？因为他们的网球拍太大了！哈哈哈。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值