devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

小程序微信登录功能的实现_微信小程序微信登录代码

作者：我家自动化 | 2024-06-07 09:45:06

赞

踩

微信小程序微信登录代码
业务代码 
  1. /**
  2.      * 微信登录
  3.      */
  4.     @Override
  5.     @Transactional(rollbackFor = Exception.class)
  6.     public AjaxResult wxLogin(WeChatCodeRequest request, HttpServletRequest httpServletRequest) {
  7.         String code = request.getCode();
  8.         //通过code获取手机号
  9.         JSONObject jsonObject = WechatUtil.getPhoneNumber(code);
  10.         JSONObject js = (JSONObject) jsonObject.get("phone_info");
  11.         String phoneNumber = (String) js.get("phoneNumber");
  12.         //对手机号进行判断，登录
  13.         //剩下的是校验成功的情况
  14.         if (iSysUserService.getLoginUserByPhone(phoneNumber) == null) {
  15.             return AjaxResult.error("登录失败，用户不存在或不可用，请联系管理员注册");
  16.         } else {
  17.             AjaxResult ajax = new AjaxResult();
  18.             //说明在User表中已经存在，则将二者绑定到一起,使用user信息进行登录
  19.             redisCache.deleteObject(CacheConstants.CAPTCHA_CODE_KEY + phoneNumber);
  20. //            LoginUser loginUser = tokenService.getLoginUser(httpServletRequest);
  21.             LoginUser loginUser = iSysUserService.getLoginUserByPhone(phoneNumber);
  22.             List<SysUserRole> sysUserRoles = sysUserRoleMapper.selectList(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, loginUser.getUserId()));
  23.             List<SysRole> collect = sysUserRoles.stream().map(i -> {
  24.                 //拿着roleid查询role
  25.                 SysRole sysRole = roleMapper.selectRoleById(i.getRoleId());
  26.                 return sysRole;
  27.             }).collect(Collectors.toList());
  28.             LambdaUpdateWrapper<SysUser> uw = new LambdaUpdateWrapper<SysUser>()
  29.                     .set(SysUser::getLoginIp, ServletUtil.getClientIP(httpServletRequest))
  30.                     .set(SysUser::getLoginDate, new Date())
  31.                     .set(SysUser::getUpdateTime, new Date())
  32.                     .eq(SysUser::getPhonenumber, phoneNumber)
  33.                     .eq(SysUser::getStatus, "0")
  34.                     .eq(SysUser::getDelFlag, "0");
  35.             iSysUserService.update(uw);
  36.             // 生成token
  37.             //设置角色
  38.             loginUser.getUser().setRoles(collect);
  39.             //设置权限
  40. //            loginUser.setPermissions();
  41.             String token = tokenService.createToken(loginUser);
  42.             ajax.put(Constants.TOKEN, token);
  43.             tokenService.setLoginUser(loginUser);
  44.             return ajax;
  45.         }
  46.     }
  tokenService工具类 
  1. package mmm.crm.system.web.service;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.concurrent.TimeUnit;
  6. import javax.servlet.http.HttpServletRequest;
  7.  
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.beans.factory.annotation.Value;
  10. import org.springframework.stereotype.Component;
  11. import mmm.crm.common.constant.CacheConstants;
  12. import mmm.crm.common.constant.Constants;
  13. import mmm.crm.common.core.domain.model.LoginUser;
  14. import mmm.crm.common.core.redis.RedisCache;
  15. import mmm.crm.common.utils.ServletUtils;
  16. import mmm.crm.common.utils.StringUtils;
  17. import mmm.crm.common.utils.ip.AddressUtils;
  18. import mmm.crm.common.utils.ip.IpUtils;
  19. import mmm.crm.common.utils.uuid.IdUtils;
  20. import eu.bitwalker.useragentutils.UserAgent;
  21. import io.jsonwebtoken.Claims;
  22. import io.jsonwebtoken.Jwts;
  23. import io.jsonwebtoken.SignatureAlgorithm;
  24.  
  25. /**
  26.  * token验证处理
  27.  */
  28. @Component
  29. public class TokenService {
  30.     // 令牌自定义标识
  31.     @Value("${token.header}")
  32.     private String header;
  33.  
  34.     // 令牌秘钥
  35.     @Value("${token.secret}")
  36.     private String secret;
  37.  
  38.     // 令牌有效期（默认30分钟）
  39.     @Value("${token.expireTime}")
  40.     private int expireTime;
  41.  
  42.     protected static final long MILLIS_SECOND = 1000;
  43.  
  44.     protected static final long MILLIS_MINUTE = 60 * MILLIS_SECOND;
  45.  
  46.     private static final Long MILLIS_MINUTE_TEN = 20 * 60 * 1000L;
  47.  
  48.     @Autowired
  49.     private RedisCache redisCache;
  50.  
  51.     /**
  52.      * 获取用户身份信息
  53.      *
  54.      * @return 用户信息
  55.      */
  56.     public LoginUser getLoginUser(HttpServletRequest request) {
  57.         // 获取请求携带的令牌
  58.         String token = getToken(request);
  59.         if (StringUtils.isNotEmpty(token)) {
  60.             try {
  61.                 Claims claims = parseToken(token);
  62.                 // 解析对应的权限以及用户信息
  63.                 String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
  64.                 String userKey = getTokenKey(uuid);
  65.                 LoginUser user = redisCache.getCacheObject(userKey);
  66.                 return user;
  67.             } catch (Exception e) {
  68.             }
  69.         }
  70.         return null;
  71.     }
  72.  
  73.     /**
  74.      * 设置用户身份信息
  75.      */
  76.     public void setLoginUser(LoginUser loginUser) {
  77.         if (StringUtils.isNotNull(loginUser) && StringUtils.isNotEmpty(loginUser.getToken())) {
  78.             refreshToken(loginUser);
  79.         }
  80.     }
  81.  
  82.     /**
  83.      * 删除用户身份信息
  84.      */
  85.     public void delLoginUser(String token) {
  86.         if (StringUtils.isNotEmpty(token)) {
  87.             String userKey = getTokenKey(token);
  88.             redisCache.deleteObject(userKey);
  89.         }
  90.     }
  91.  
  92.     /**
  93.      * 创建令牌
  94.      *
  95.      * @param loginUser 用户信息
  96.      * @return 令牌
  97.      */
  98.     public String createToken(LoginUser loginUser) {
  99.         String token = IdUtils.fastUUID();
  100.         loginUser.setToken(token);
  101.         setUserAgent(loginUser);
  102.         refreshToken(loginUser);
  103.  
  104.         Map<String, Object> claims = new HashMap<>();
  105.         claims.put(Constants.LOGIN_USER_KEY, token);
  106.         return createToken(claims);
  107.     }
  108.  
  109.     /**
  110.      * 验证令牌有效期，相差不足20分钟，自动刷新缓存
  111.      *
  112.      * @param loginUser
  113.      * @return 令牌
  114.      */
  115.     public void verifyToken(LoginUser loginUser) {
  116.         long expireTime = loginUser.getExpireTime();
  117.         long currentTime = System.currentTimeMillis();
  118.         if (expireTime - currentTime <= MILLIS_MINUTE_TEN) {
  119.             refreshToken(loginUser);
  120.         }
  121.     }
  122.  
  123.     /**
  124.      * 刷新令牌有效期
  125.      *
  126.      * @param loginUser 登录信息
  127.      */
  128.     public void refreshToken(LoginUser loginUser) {
  129.  
  130.         loginUser.setLoginTime(System.currentTimeMillis());
  131.         loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
  132.         // 根据uuid将loginUser缓存
  133.         String userKey = getTokenKey(loginUser.getToken());
  134.         redisCache.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES);
  135.     }
  136.  
  137.     /**
  138.      * 设置用户代理信息
  139.      *
  140.      * @param loginUser 登录信息
  141.      */
  142.     public void setUserAgent(LoginUser loginUser) {
  143.         UserAgent userAgent = UserAgent.parseUserAgentString(ServletUtils.getRequest().getHeader("User-Agent"));
  144.         String ip = IpUtils.getIpAddr();
  145.         loginUser.setIpaddr(ip);
  146.         loginUser.setLoginLocation(AddressUtils.getRealAddressByIP(ip));
  147.         loginUser.setBrowser(userAgent.getBrowser().getName());
  148.         loginUser.setOs(userAgent.getOperatingSystem().getName());
  149.     }
  150.  
  151.     /**
  152.      * 从数据声明生成令牌
  153.      *
  154.      * @param claims 数据声明
  155.      * @return 令牌
  156.      */
  157.     private String createToken(Map<String, Object> claims) {
  158.         String token = Jwts.builder()
  159.                 .setClaims(claims)
  160.                 .signWith(SignatureAlgorithm.HS512, secret).compact();
  161.         return token;
  162.     }
  163.  
  164.     /**
  165.      * 从令牌中获取数据声明
  166.      *
  167.      * @param token 令牌
  168.      * @return 数据声明
  169.      */
  170.     private Claims parseToken(String token) {
  171.         return Jwts.parser()
  172.                 .setSigningKey(secret)
  173.                 .parseClaimsJws(token)
  174.                 .getBody();
  175.     }
  176.  
  177.     /**
  178.      * 从令牌中获取用户名
  179.      *
  180.      * @param token 令牌
  181.      * @return 用户名
  182.      */
  183.     public String getUsernameFromToken(String token) {
  184.         Claims claims = parseToken(token);
  185.         return claims.getSubject();
  186.     }
  187.  
  188.     /**
  189.      * 获取请求token
  190.      *
  191.      * @param request
  192.      * @return token
  193.      */
  194.     public String getToken(HttpServletRequest request) {
  195.         String token = request.getHeader(header);
  196.         if (StringUtils.isNotEmpty(token) && token.startsWith(Constants.TOKEN_PREFIX)) {
  197.             token = token.replace(Constants.TOKEN_PREFIX, "");
  198.         }
  199.         return token;
  200.     }
  201.  
  202.     private String getTokenKey(String uuid) {
  203.         return CacheConstants.LOGIN_TOKEN_KEY + uuid;
  204.     }
  205. }

 微信登录工具类

  1. package mmm.crm.common.utils;
  2.  
  3. import cn.hutool.http.Header;
  4. import cn.hutool.http.HttpRequest;
  5. import cn.hutool.http.HttpResponse;
  6. import cn.hutool.http.HttpUtil;
  7. import cn.hutool.json.JSONUtil;
  8. import com.alibaba.fastjson2.JSON;
  9. import com.alibaba.fastjson2.JSONObject;
  10.  
  11. import com.google.common.net.HttpHeaders;
  12. import com.google.gson.Gson;
  13. import com.google.gson.JsonObject;
  14. import lombok.extern.log4j.Log4j;
  15. import mmm.crm.common.utils.http.HttpUtils;
  16. import mmm.crm.common.utils.sign.Base64;
  17. import org.apache.http.HttpEntity;
  18. import org.apache.http.client.methods.CloseableHttpResponse;
  19. import org.apache.http.client.methods.HttpGet;
  20. import org.apache.http.impl.client.DefaultHttpClient;
  21. import org.apache.http.util.EntityUtils;
  22. import org.bouncycastle.jce.provider.BouncyCastleProvider;
  23. import org.springframework.beans.factory.annotation.Autowired;
  24. import org.springframework.web.bind.annotation.PostMapping;
  25. import org.springframework.web.bind.annotation.RequestParam;
  26. import org.springframework.web.client.RestTemplate;
  27.  
  28. import javax.crypto.BadPaddingException;
  29. import javax.crypto.Cipher;
  30. import javax.crypto.IllegalBlockSizeException;
  31. import javax.crypto.NoSuchPaddingException;
  32. import javax.crypto.spec.IvParameterSpec;
  33. import javax.crypto.spec.SecretKeySpec;
  34. import javax.servlet.FilterConfig;
  35. import javax.xml.bind.ValidationException;
  36. import java.io.IOException;
  37. import java.io.UnsupportedEncodingException;
  38. import java.security.*;
  39. import java.security.spec.InvalidParameterSpecException;
  40. import java.util.Arrays;
  41. import java.util.HashMap;
  42. import java.util.Map;
  43.  
  44. /**
  45.  * @Author：XGY
  46.  * @Date：2023/4/24 18:14
  47.  */
  48. public class WechatUtil {
  49.  
  50.     public static JSONObject getSessionKeyOrOpenId(String code) throws IOException {
  51.         //微信端登录code
  52.         String wxCode = code;
  53.         String requestUrl = "https://api.weixin.qq.com/sns/jscode2session";
  54.         Map<String, String> requestUrlParam = new HashMap<>();
  55.         //小程序appId
  56.         requestUrlParam.put("appid", "wx88c4501ad86e1174");
  57.         //小程序secret
  58.         requestUrlParam.put("secret", "c08515ced6cd60e976028be5d0d43498");
  59.         //小程序端返回的code
  60.         requestUrlParam.put("js_code", wxCode);
  61.         //默认参数
  62.         requestUrlParam.put("grant_type", "authorization_code");
  63.         //发送post请求读取调用微信接口获取openid用户唯一标识
  64.         JSONObject jsonObject = JSON.parseObject(HttpClientUtil.doPost(requestUrl, requestUrlParam));
  65.         return jsonObject;
  66.     }
  67.  
  68.     public static com.alibaba.fastjson2.JSONObject getUserInfo(String encryptedData, String sessionKey, String iv) {
  69.         // 被加密的数据
  70.         byte[] dataByte = Base64.decode(encryptedData);
  71.         // 加密秘钥
  72.         byte[] keyByte = Base64.decode(sessionKey);
  73.         // 偏移量
  74.         byte[] ivByte = Base64.decode(iv);
  75.         try {
  76.             // 如果密钥不足16位，那么就补足.  这个if 中的内容很重要
  77.             int base = 16;
  78.             if (keyByte.length % base != 0) {
  79.                 int groups = keyByte.length / base + (keyByte.length % base != 0 ? 1 : 0);
  80.                 byte[] temp = new byte[groups * base];
  81.                 Arrays.fill(temp, (byte) 0);
  82.                 System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
  83.                 keyByte = temp;
  84.             }
  85.             // 初始化
  86.             Security.addProvider(new BouncyCastleProvider());
  87.             Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding", "BC");
  88.             SecretKeySpec spec = new SecretKeySpec(keyByte, "AES");
  89.             AlgorithmParameters parameters = AlgorithmParameters.getInstance("AES");
  90.             parameters.init(new IvParameterSpec(ivByte));
  91.             cipher.init(Cipher.DECRYPT_MODE, spec, parameters);// 初始化
  92.             byte[] resultByte = cipher.doFinal(dataByte);
  93.             if (null != resultByte && resultByte.length > 0) {
  94.                 String result = new String(resultByte, "UTF-8");
  95.                 return JSON.parseObject(result);
  96.             }
  97.         } catch (Exception e) {
  98.             new Exception(e);
  99.         }
  100.         return null;
  101.     }
  102.  
  103. //    public static String getPhone(String code) throws ValidationException, IOException {
  104. //        final String appID = "wx88c4501ad86e1174";
  105. //        final String appSecret = "c08515ced6cd60e976028be5d0d43498";
  106. //        //使用appid和密钥获取access_token
  107.         String url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=" + appID + "&secret=" + appSecret;
  108.         String s = HttpUtils.sendGet(url);
  109.         JSONObject jsonObject = HttpUtils.doGetJson(url);
  110. //        //使用access_token和code获取手机号
  111. //        JSONObject accessToken = getAccessToken(appID, appSecret);
  112. //        String url1 = "https://api.weixin.qq.com/wxa/business/getuserphonenumber?access_token=" + accessToken.getString("access_token");
  113. //        JSONObject data = new JSONObject();
  114. //        data.put("code", code);
  115. //        String phoneNumber = null;
  116. //        try {
  117. //            JSONObject jsonObject1 = HttpUtils.doPost(url1, code);
  118. //            JSONObject phone_info = (JSONObject) jsonObject1.get("phone_info");
  119. //            phoneNumber = phone_info.getString("phoneNumber");
  120. //        } catch (Exception e) {
  121. //            throw new RuntimeException(e);
  122. //        }
  123. //        return phoneNumber;
  124. //    }
  125. //    public static JSONObject getAccessToken(String appid, String secretKey) {
  126. //        String result = null;
  127. //        try {
  128. //            String baseUrl = "https://api.weixin.qq.com/cgi-bin/token";
  129. //            HashMap<String, Object> requestParam = new HashMap<>();
  130. //            // 小程序 appId
  131. //            requestParam.put("grant_type", "client_credential");
  132. //            // 小程序唯一凭证id
  133. //            requestParam.put("appid", appid);
  134. //            // 小程序 appSecret（小程序的唯一凭证密钥）
  135. //            requestParam.put("secret", secretKey);
  136. //            // 发送GET请求读取调用微信接口获取openid用户唯一标识
  137. //            result = HttpUtil.get(baseUrl, requestParam);
  138. //        } catch (Exception e) {
  139. //            e.printStackTrace();
  140. //        }
  141. //        return JSONObject.parseObject(result);
  142. //    }
  143. public static String getAccessTokenOne(String appId,String appSecret) {
  144.  
  145.     String url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid="
  146.             + appId + "&secret=" + appSecret;
  147.  
  148.     System.out.println("request user info from url: {" + url + "}");
  149.     JsonObject accessTokenInfo = null;
  150.     try {
  151.  
  152.         DefaultHttpClient httpClient = new DefaultHttpClient();
  153.         HttpGet httpGet = new HttpGet(url);
  154.         CloseableHttpResponse httpResponse = httpClient.execute(httpGet);
  155.         HttpEntity entity = httpResponse.getEntity();
  156.         String response = EntityUtils.toString(entity, "utf-8");
  157.         //LOGGER.error("获取Token-------------------"+response);
  158.         Gson token_gson = new Gson();
  159.  
  160.         accessTokenInfo = token_gson.fromJson(response, JsonObject.class);
  161.  
  162.         return accessTokenInfo.get("access_token").toString().replaceAll("\"", "");
  163.  
  164.     } catch (Exception ex) {
  165.         System.out.println("fail to request wechat user info. [error={" + ex + "}]");
  166.     }
  167.     return "";
  168. }
  169.  
  170.     /**
  171.      * 请求微信接口服务，用code换取用户手机号（每个code只能使用一次，code的有效期为5min）
  172.      * https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/phonenumber/phonenumber.getPhoneNumber.html
  173.      *
  174.      * @param code
  175.      * @param accessToken
  176.      * @return
  177.      */
  178.     public static JSONObject getPhoneNumber(String code) {
  179.         final String appID = "wx88c4501ad86e1174";
  180.         final String appSecret = "c08515ced6cd60e976028be5d0d43498";
  181.         String accessTokenOne = getAccessTokenOne(appID, appSecret);
  182.         String result = null;
  183.         try {
  184.             // 接口调用凭证：accessToken
  185.             String baseUrl = "https://api.weixin.qq.com/wxa/business/getuserphonenumber?access_token=" + accessTokenOne;
  186.             HashMap<String, Object> requestParam = new HashMap<>();
  187.             // 手机号调用凭证
  188.             requestParam.put("code", code);
  189.             // 发送post请求读取调用微信接口获取openid用户唯一标识
  190.             String jsonStr = JSONUtil.toJsonStr(requestParam);
  191.             HttpResponse response = HttpRequest.post(baseUrl)
  192.                     .header(Header.CONTENT_ENCODING, "UTF-8")
  193.                     // 发送json数据需要设置contentType
  194.                     .header(Header.CONTENT_TYPE, "application/x-www-form-urlencoded")
  195.                     .body(jsonStr)
  196.                     .execute();
  197.             if (response.getStatus() == HttpStatus.SUCCESS) {
  198.                 result = response.body();
  199.             }
  200.         } catch (Exception e) {
  201.             e.printStackTrace();
  202.         }
  203.         return JSONObject.parseObject(result);
  204.     }
  205. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/684865
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号