微信小程序手机号快捷登录

package com.example.auth.integration;

import com.jfinal.kit.Kv;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.time.Instant;
import java.util.Map;
import nexus.io.tio.boot.exception.BusinessException;
import nexus.io.tio.utils.environment.EnvUtils;
import nexus.io.tio.utils.json.Json;

public class WechatMiniClient {
  private final HttpClient http = HttpClient.newBuilder()
      .connectTimeout(Duration.ofSeconds(5)).build();
  private String cachedToken;
  private String cachedAppId;
  private long tokenExpiresAt;

  public Kv session(String code) {
    String path = "/sns/jscode2session?appid=" + encode(appId())
        + "&secret=" + encode(secret())
        + "&js_code=" + encode(code)
        + "&grant_type=authorization_code";
    Kv result = request(path, null);
    check(result);
    return result;
  }

  public Kv phone(String code) {
    String token = accessToken(null);
    Kv result = request("/wxa/business/getuserphonenumber?access_token="
        + encode(token), Kv.by("code", code));
    Integer error = result.getInt("errcode");
    if (error != null && (error == 40001 || error == 40014 || error == 42001)) {
      token = accessToken(token);
      result = request("/wxa/business/getuserphonenumber?access_token="
          + encode(token), Kv.by("code", code));
    }
    check(result);
    Object phoneInfo = result.get("phone_info");
    if (!(phoneInfo instanceof Map<?, ?> values)) {
      throw unavailable();
    }
    return Kv.create().set(values);
  }

  private synchronized String accessToken(String rejectedToken) {
    String id = appId();
    long now = Instant.now().getEpochSecond();
    boolean rejected = rejectedToken != null && rejectedToken.equals(cachedToken);
    if (!rejected && id.equals(cachedAppId) && cachedToken != null
        && tokenExpiresAt > now) {
      return cachedToken;
    }
    Kv body = Kv.by("grant_type", "client_credential")
        .set("appid", id).set("secret", secret())
        .set("force_refresh", rejected);
    Kv result = request("/cgi-bin/stable_token", body);
    check(result);
    String token = result.getStr("access_token");
    Long expiresIn = result.getLong("expires_in");
    if (token == null || token.isBlank() || expiresIn == null || expiresIn <= 60) {
      throw unavailable();
    }
    cachedAppId = id;
    cachedToken = token;
    tokenExpiresAt = now + expiresIn - 60;
    return token;
  }

  private Kv request(String path, Kv body) {
    try {
      HttpRequest.Builder builder = HttpRequest.newBuilder(
          URI.create("https://api.weixin.qq.com" + path))
          .timeout(Duration.ofSeconds(10))
          .header("Accept", "application/json");
      if (body == null) {
        builder.GET();
      } else {
        builder.header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(
                Json.getJson().toJson(body), StandardCharsets.UTF_8));
      }
      HttpResponse<String> response = http.send(
          builder.build(), HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
      if (response.statusCode() != 200) throw unavailable();
      Object parsed = Json.getJson().parse(response.body());
      if (!(parsed instanceof Map<?, ?> values)) throw unavailable();
      return Kv.create().set(values);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      throw unavailable();
    } catch (Exception e) {
      throw unavailable();
    }
  }

  private void check(Kv result) {
    Integer error = result.getInt("errcode");
    if (error == null || error == 0) return;
    if (error == 40029 || error == 40163) {
      throw new BusinessException(400, "微信授权已失效，请重新点击登录");
    }
    if (error == 45011 || error == 45009) {
      throw new BusinessException(429, "微信请求频繁，请稍后重试");
    }
    throw unavailable();
  }

  public String appId() {
    return required("WECHAT_MINI_APP_ID");
  }

  private String secret() {
    return required("WECHAT_MINI_APP_SECRET");
  }

  private String required(String name) {
    String value = EnvUtils.get(name);
    if (value == null || value.isBlank()) {
      throw new BusinessException(503, "微信登录尚未配置");
    }
    return value.trim();
  }

  private static String encode(String value) {
    return URLEncoder.encode(value, StandardCharsets.UTF_8);
  }

  private static BusinessException unavailable() {
    return new BusinessException(503, "微信服务暂不可用");
  }
}

package com.example.auth.service;

import com.jfinal.kit.Kv;
import com.example.auth.integration.WechatMiniClient;
import java.util.Map;
import nexus.io.jfinal.aop.Aop;
import nexus.io.tio.boot.exception.BusinessException;

public class WechatPhoneLoginService {
  public Kv login(String loginCode, String phoneCode) {
    WechatMiniClient client = Aop.get(WechatMiniClient.class);
    Kv session = client.session(loginCode);
    String openid = session.getStr("openid");
    if (openid == null || openid.isBlank()) {
      throw new BusinessException(503, "微信身份信息不可用");
    }

    Kv phoneInfo = client.phone(phoneCode);
    String phone = phoneInfo.getStr("purePhoneNumber");
    Object watermark = phoneInfo.get("watermark");
    String appId = watermark instanceof Map<?, ?> values
        ? String.valueOf(values.get("appid")) : null;
    if (phone == null || phone.isBlank() || !client.appId().equals(appId)) {
      throw new BusinessException(503, "微信手机号信息不可用");
    }

    // 在事务中按手机号、openid 和账号唯一约束完成查询、创建或绑定。
    // 手机号与微信身份分别属于不同账号时返回 409，不直接合并业务数据。
    return accountService().loginOrCreate(phone, openid,
        session.getStr("unionid"));
  }

  private AccountService accountService() {
    return Aop.get(AccountService.class);
  }
}

router.add(HttpMethod.POST, "/api/mi/auth/wechat/phone-login",
    authHandler::wechatPhoneLogin,
    Map.of(AuthInterceptor.ACCESS, AccessPolicy.PUBLIC));

public HttpResponse wechatPhoneLogin(HttpRequest request) {
  Kv body = request.getBodyObject(Kv.class);
  String loginCode = ParameterValidator.text(body.getStr("loginCode"),
      "loginCode", 256);
  String phoneCode = ParameterValidator.text(body.getStr("phoneCode"),
      "phoneCode", 256);
  String inviterUserId = body.getStr("inviterUserId");
  RespBodyVo result = service.login(loginCode, phoneCode, inviterUserId);
  return TioRequestContext.getResponse().respond(result);
}