小程序开放能力之用户登录(Java)

最新推荐文章于 2024-08-16 22:30:00 发布
最新推荐文章于 2024-08-16 22:30:00 发布
阅读量417 收藏 1
点赞数
分类专栏： 微信小程序 文章标签： 小程序 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012667477/article/details/106187613
版权

用户登录

获取用户openid

先上效果图：
在这里插入图片描述
在这里插入图片描述

为什么要使用小程序登录？

关于这个问题，小程序api里面是这样描述的。

小程序可以通过微信官方提供的登录能力方便地获取微信提供的用户身份标识，快速建立小程序内的用户体系。

登录流程

这张官方的登录流程图，对于登录流程解释的很详细了，如果不想看图解的，下面会有文字解析。
在这里插入图片描述

  1. 开发者在小程序的js中调用wx.login()方法获取登录凭证（code，有效期五分钟，只能使用一次）,通过凭证进而换取用户登录态信息，包括用户的唯一标识（openid）及本次登录的会话密钥（session_key）等。用户数据的加解密通讯（如解密手机号）需要依赖会话密钥完成。
  2. 带上登录凭证code，向开发者服务器发送HTTP请求，开发者服务器带上appid和appsecret和code向微信接口(https://api.weixin.qq.com/sns/jscode2session?appid=%s&secret=%s&js_code=%s&grant_type=authorization_code)获取用户唯一标识 OpenID 和 会话密钥 session_key。为了应用自身的数据安全，开发者服务器不应该把会话密钥下发到小程序，也不应该对外提供这个密钥。
  3. 将openid存入用户自己的用户体系中，并返回给小程序，在小程序中调用wx.setStorageSync或者wx.setStorage存入本地缓存中。示例：`wx.setStorage({
    key:“key”,
    data:“value”
    });
  4. 到此登录就算结束了，需要用到openid时通过wx.getStorage或者wx.getStorageSync获取就好了。

代码片段

小程序端

<button class='btn1' open-type='getUserInfo' bindgetuserinfo="getUserInfo">
    <image class='btnImg' src='../../images/wechat.png'></image>
    <view>微信授权登录</view>
</button>

//onLoad中调用wx.login方法，至于为什么这样做，看下期获取用户手机号
wx.login({
  complete: (res) => {
    if ("login:ok" == res.errMsg) {
      this.data.authCode = res.code;
    }
  },
})
getUserInfo: function (e) {
  let that = this;
  var header = {
    'Accept': 'application/json',
    'content-type': 'application/json',
    'Authorization': null,
  }
  wx.request({
    url: "http://localhost:8080/user/login",
    method: 'GET',
    header: header,
    data: {
      "authCode": that.data.authCode
    },
    success: function (res) {
      that.data.sessionKey = res.data.sessionkey;
      wx.showToast({
        title: res.data.openid,
        icon:'none'
      })
    },
    fail: function () {}
  })
}

Java

controller
	@Value("${wx.appid}")
    public String appId;
    @Value("${wx.appsecret}")
    public String appSecret;
    @Value("${wx.authapi}")
    public String authApi;

    @GetMapping("login")
    public JSONObject login(String authCode) {
        String url = String.format(authApi, appId, appSecret, authCode);
        return WxUtil.login(url);
    }
WxUtil

ResultCode是一个错误码和错误信息的枚举类。

	public static JSONObject login(String url) {
        JSONObject retJson = new JSONObject();
        //String url = String.format(WxConfig.WX_AUTH_API, WxConfig.APP_ID, WxConfig.APP_SECRET, authCode);
        String ret = HttpHelper.get(url);
        String openid = null;
        logger.info("WX->login->url:" + url + ";result:" + ret);
        if (StringUtils.isNotBlank(ret)) {
            JSONObject obj = JSON.parseObject(ret);
            if (!obj.containsKey("openid") || StringUtils.isBlank((openid = obj.getString("openid")))) {
                retJson.put("status", ResultCode.FAIL.getValue());
                retJson.put("message", ResultCode.RESPONSE_AUTH_ERROR.getDesc());
            } else {
                retJson.put("status", ResultCode.OK.getValue());
                retJson.put("openid", openid);
                retJson.put("sessionkey", obj.getString("session_key"));
            }
        }
        return retJson;
    }
HttpHelper
package cn.idwarf.wxsdk.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.commons.lang3.StringUtils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import javax.servlet.http.HttpServletRequest;

public class HttpHelper {
    private static final String GET = "GET";
    private static final String POST = "POST";
    private static String CHARSET = "UTF-8";
    private static final SSLSocketFactory sslSocketFactory = initSSLSocketFactory();
    private static final HttpHelper.TrustAnyHostnameVerifier trustAnyHostnameVerifier = new HttpHelper.TrustAnyHostnameVerifier();

    private static final Logger logger = LoggerFactory.getLogger(HttpHelper.class);
    private HttpHelper() {
    }

    private static SSLSocketFactory initSSLSocketFactory() {
        try {
            TrustManager[] tm = new TrustManager[]{new HttpHelper.TrustAnyTrustManager()};
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init((KeyManager[]) null, tm, new SecureRandom());
            return sslContext.getSocketFactory();
        } catch (Exception var2) {
            throw new RuntimeException(var2);
        }
    }

    public static void setCharSet(String charSet) {
        if (StringUtils.isBlank(charSet)) {
            throw new IllegalArgumentException("charSet can not be blank.");
        } else {
            CHARSET = charSet;
        }
    }

    private static HttpURLConnection getHttpConnection(String url, String method, Map<String, String> headers) throws IOException, NoSuchAlgorithmException, NoSuchProviderException, KeyManagementException {
        URL _url = new URL(url);
        HttpURLConnection conn = (HttpURLConnection) _url.openConnection();
        if (conn instanceof HttpsURLConnection) {
            ((HttpsURLConnection) conn).setSSLSocketFactory(sslSocketFactory);
            ((HttpsURLConnection) conn).setHostnameVerifier(trustAnyHostnameVerifier);
        }

        conn.setRequestMethod(method);
        conn.setDoOutput(true);
        conn.setDoInput(true);
        conn.setConnectTimeout(19000);
        conn.setReadTimeout(19000);
        conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36");
        if (headers != null && !headers.isEmpty()) {
            Iterator var5 = headers.entrySet().iterator();

            while (var5.hasNext()) {
                Entry<String, String> entry = (Entry) var5.next();
                conn.setRequestProperty((String) entry.getKey(), (String) entry.getValue());
            }
        }

        return conn;
    }

    public static String get(String url, Map<String, String> queryParas, Map<String, String> headers) {
        HttpURLConnection conn = null;

        String var4;
        try {
            conn = getHttpConnection(buildUrlWithQueryString(url, queryParas), "GET", headers);
            conn.connect();
            var4 = readResponseString(conn);
        } catch (Exception var8) {
            throw new RuntimeException(var8);
        } finally {
            if (conn != null) {
                conn.disconnect();
            }

        }

        return var4;
    }

    public static String get(String url, Map<String, String> queryParas) {
        return get(url, queryParas, (Map) null);
    }

    public static String get(String url) {
        return get(url, (Map) null, (Map) null);
    }

    public static String post(String url, Map<String, String> queryParas, String data, Map<String, String> headers) {
        HttpURLConnection conn = null;

        String var11;
        try {
            conn = getHttpConnection(buildUrlWithQueryString(url, queryParas), "POST", headers);
            conn.connect();
            if (data != null) {
                OutputStream out = conn.getOutputStream();
                out.write(data.getBytes(CHARSET));
                out.flush();
                out.close();
            }

            var11 = readResponseString(conn);
        } catch (Exception var9) {
            throw new RuntimeException(var9);
        } finally {
            if (conn != null) {
                conn.disconnect();
            }

        }

        return var11;
    }

    public static String post(String url, Map<String, String> queryParas, String data) {
        return post(url, queryParas, data, (Map) null);
    }

    public static String post(String url, String data, Map<String, String> headers) {
        return post(url, (Map) null, data, headers);
    }

    public static String post(String url, String data) {
        return post(url, (Map) null, data, (Map) null);
    }

    private static String readResponseString(HttpURLConnection conn) {
        BufferedReader reader = null;

        try {
            reader = new BufferedReader(new InputStreamReader(conn.getInputStream(), CHARSET));
            String line = reader.readLine();
            String var4;
            if (line == null) {
                var4 = "";
                return var4;
            } else {
                StringBuilder ret = new StringBuilder();
                ret.append(line);

                while ((line = reader.readLine()) != null) {
                    ret.append('\n').append(line);
                }

                var4 = ret.toString();
                return var4;
            }
        } catch (Exception var14) {
            throw new RuntimeException(var14);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException var13) {
                    logger.error(var13.getMessage(), var13);
                }
            }

        }
    }

    private static String buildUrlWithQueryString(String url, Map<String, String> queryParas) {
        if (queryParas != null && !queryParas.isEmpty()) {
            StringBuilder sb = new StringBuilder(url);
            boolean isFirst;
            if (url.indexOf(63) == -1) {
                isFirst = true;
                sb.append('?');
            } else {
                isFirst = false;
            }

            String key;
            String value;
            for (Iterator var4 = queryParas.entrySet().iterator(); var4.hasNext(); sb.append(key).append('=').append(value)) {
                Entry<String, String> entry = (Entry) var4.next();
                if (isFirst) {
                    isFirst = false;
                } else {
                    sb.append('&');
                }

                key = (String) entry.getKey();
                value = (String) entry.getValue();
                if (StringUtils.isNotBlank(value)) {
                    try {
                        value = URLEncoder.encode(value, CHARSET);
                    } catch (UnsupportedEncodingException var9) {
                        throw new RuntimeException(var9);
                    }
                }
            }

            return sb.toString();
        } else {
            return url;
        }
    }

    public static String readData(HttpServletRequest request) {
        BufferedReader br = null;

        try {
            br = request.getReader();
            String line = br.readLine();
            if (line == null) {
                return "";
            } else {
                StringBuilder ret = new StringBuilder();
                ret.append(line);

                while ((line = br.readLine()) != null) {
                    ret.append('\n').append(line);
                }

                return ret.toString();
            }
        } catch (IOException var4) {
            throw new RuntimeException(var4);
        }
    }

    /**
     * @deprecated
     */
    @Deprecated
    public static String readIncommingRequestData(HttpServletRequest request) {
        return readData(request);
    }

    private static class TrustAnyTrustManager implements X509TrustManager {
        private TrustAnyTrustManager() {
        }

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

        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }
    }

    private static class TrustAnyHostnameVerifier implements HostnameVerifier {
        private TrustAnyHostnameVerifier() {
        }

        public boolean verify(String hostname, SSLSession session) {
            return true;
        }
    }
}
Spring是框架不是春天
关注
专栏目录
javad登录小程序
05-27
一个较为完整的Java登录小程序，包含密码验证以及相应的主题界面
微信商城 小程序 前后台源码 Java后台 ssm框架+MySQL
09-23
微信商城小程序是一个基于微信生态的在线购物平台，其前端通过微信小程序进行展示，后端则由Java技术栈构建，采用SSM（Spring、SpringMVC、MyBatis）框架进行开发，并结合MySQL数据库来存储数据。这个项目是针对毕业...
Java学习：小程序微信登录开发实现
weixin_48800764的博客
03-07 4281
调用微信接口返回OpenId，通过OpenId查询用户数据库，如果能查询到，说明存在用户；然后在Controller层生成jwt令牌，将该用户对象、OpenId和jwt令牌封装成返回对象，返回给小程序端。开发者服务器端接收到参数以后会将openid等参数与自定义登录态关联返回到微信小程序，小程序会将自定义登录态存储，在以后进行业务请求的时候都会携带自定义登录态，开发者服务器端会验证传递过来的自定义登录态是否合法，合法则返回请求业务的数据，不合法则拒绝访问。登录的实现，返回结果应该为一个用户对象。
Java 微信小程序授权登录——引导
最新发布
Mr_likes的博客
08-16 431
对于微信的授权的登录流程和实现方式官网文档已说的很清楚了并且是一直迭代的（比如之前能拿到用户的详细信息，现在拿不到了，之前授权方式和现在授权方式不同了），本文档只是做个Java后端实现小程序用户授权的一个流程引导，应当已官方文档为基准。开放能力 / 用户信息 / 小程序登录 (qq.com)
java后台实现小程序登录功能
weixin_37656125的博客
08-29 3082
前言 最近公司在做小程序开发，其中于微信号进行绑定的微信登录个人感觉不错，就想记录了下来 这篇文件就是讲实现微信登录小程序的相关使用 开发准备 1.微信开发者工具（前端开发公具） 2.idea（后端开发） 3.jdk1.8(这个随意) 4.spring boot 项目（其实就是处理微信请求的接口，只要是接口，你随意） 流通图 流程介绍 注意啦：开发者服务器于开发者业务服务器是一样的（相当...
微信小程序登录流程详情及Java代码
柳落青
06-21 1278
获取手机号，调用wx.getPhoneNumber() ，获取加密串。获取其他用户信息，调用wx.getUserInfor() ，获取加密串 encryptedData。,ivStr )获得解密后的数据；encryptedData 和加密算法的初始向量 ivStr 传到后台，用会话秘钥session_key ，调用。密文串要用 json 格式传输，不能用参数拼接的方式，会把密文串的加号转换为空格，导致解密失败。和加密算法的初始向量 ivStr 传到后台，用会话秘钥session_key ，调用。
java用户登录的小小程序
whyfly456的专栏
04-07 872
import java.util.Scanner; class users { String username;//用户名 String password;//密码 users(String username,String password) {    this.username=username; this.password=password; } } pu
微信小程序如何通过用户授权获取手机号(getPhoneNumber)
11-21
首先，`getPhoneNumber`是微信小程序提供的一种开放能力，它允许用户在授权的情况下获取其绑定在微信上的手机号。由于微信注重用户体验，调用此API必须由用户主动触发，例如通过点击特定按钮来完成。这个过程通常与...
微信支付源码(微信小程序源码+Java源码)
03-23
1. **用户授权**：小程序需要获取用户的微信支付权限，这通常通过调用微信开放接口完成。 2. **生成预支付订单**：在用户确认支付后，小程序向服务器发送请求，生成预支付订单，包含商品信息、金额等。 3. **生成...
springboot+security+jwt+redis 实现微信小程序登录及token权限鉴定.zip
03-10
自2017年正式上线以来，小程序凭借其便捷性、易获取性和出色的用户体验迅速获得市场认可，并成为连接线上线下服务的重要桥梁。 小程序的核心特点包括： 零安装：用户只需通过微信扫一扫或搜索功能，即可打开和...
java毕业设计之文字识别解读小程序源码.zip
07-18
这是一个基于Java的毕业设计项目，主要实现了文字识别与解读功能，提供了一个小程序源码供学习者研究和实践。项目的开发背景可能在于满足日常生活中对图片中文字的快速提取和理解需求，例如，从扫描文档、照片或者...
java实现微信小程序登录态维护的示例代码
08-29
本篇文章主要介绍了java实现微信小程序登录态维护的示例代码，具有一定的参考价值，有兴趣的可以了解一下
javamvc实现登录验证注册验证的小程序
09-25
javamvc实现登录验证注册验证的小程序
Java小程序源码
12-16
里面包含几个经典java小游戏，包括五指棋，贪吃蛇，俄罗斯方块等，适合初学者对自己的能力提升
java 小程序登陆_java 微信小程序登录
weixin_35763787的博客
02-24 460
//前端传给你的codepublic voidwxlogin(String code) {//填写你小程序的appid 和 secret , 还有前端传给你的code ,最后一个参数是固定的String token_url= "https://api.weixin.qq.com/sns/jscode2session?appid=" +WxConfig.APP_ID + "&secret=...
2024年阿里首次分享：内部（珠峰版)Java笔记，看完直接斩获12家offer
m0_72758098的博客
05-03 510
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
java 登录注册小程序
浩气长存在心中的博客
04-06 3201
java 登录注册小程序
java实现微信小程序登录功能
weixin_44750143的博客
08-10 1376
/** * 微信登录 * * @param code * @param encryptedData * @param iv * @param request * @param response * @return */ @RequestMapping("login") @ResponseBody private Map<String, Object> login(String code, String encryptedData, String
Java语言程序设计教程概览
Java Application是独立运行的程序，而Applet是在Web浏览器中运行的小程序，它们都需要遵循特定的主类和入口点规则。 3. 面向对象编程：深入理解面向对象的概念，包括类与对象的创建，属性（字段）和方法的定义，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值