微信公众平台网页授权

最近做微信公众号，为了防止以后走歪路所以顺带记录下过程

首先我们现在微信公众平台申请测试账号

位置在开发者者工具-公众平台测试账号，下面可以看到我们测试账号的appid和appsecret

然后我们配置回调域名，**注意 正式公众号配置域名

然后我们在提前准备号的h5页面上进行授权获取code ** 注code只能使用一次，使用过后需要刷新code，具体代码流程如下：

<input id="code" type="hidden" />

function getCode() {
		  let user_appid = "测试id"; //个人开发者appid
		  let local = "192.169.103.148/index.html" //重定向地址
		  let wx_code = this.getUrlParam("code"); // 截取路径中的code，如果没有就去微信授权，如果已经获取到了就直接传code给后台获取openId
		  //判断有没有code
		  if (wx_code == null || wx_code === "") {
			console.log("没有code跳转");
			//获取code的地址。获取成功重定向后地址栏中将会带有code
			window.location.href = `https://open.weixin.qq.com/connect/oauth2/authorize?appid=${user_appid}&redirect_uri=${encodeURIComponent(local)}&response_type=code&scope=snsapi_userinfo&state=110#wechat_redirect`;
		  } else {
			$("#code").val(wx_code);
			console.log("有code开始调用接口:", wx_code);
		  }
		}
		
		//截取code
		//getUrlParam方法就是使用正则截取地址栏里的code，有兴趣可以研究一下，没兴趣直接拿来用
		function getUrlParam(name) {
		  var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
		  var r = window.location.search.substr(1).match(reg);
		  if (r != null) return unescape(r[2]);
		  return null;
		}

我们拿到code 请求接口获取自己的openid access_tocken

接口

import com.alibaba.fastjson.JSONObject;
import com.ruoyi.framework.aspectj.lang.annotation.Log;
import com.ruoyi.framework.aspectj.lang.enums.BusinessType;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.common.wechatUtils.HTTP.GenURL;
import com.ruoyi.common.wechatUtils.HTTP.HTTPClientData;
import com.ruoyi.common.wechatUtils.HTTP.HTTPClientImpl;
import com.ruoyi.project.wechat.userInfo.domain.TbUserInfo;
import com.ruoyi.project.wechat.userInfo.service.ITbUserInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.net.URISyntaxException;

/**
 * @author dwl
 * @createTime 2022/2/22
 */
@RestController
@RequestMapping("/WeCharSignIn")
public class WeChatSignInController {

    /**
     * 获取微信wechatID 然后新增用户信息
     * code 微信code
     * @return AJAX响应
     */
    @Log(title = "用户注册", businessType = BusinessType.GRANT)
    @CrossOrigin(methods = {RequestMethod.GET, RequestMethod.POST, RequestMethod.OPTIONS})
    @PostMapping("registerUserInfo")
    public String registerUserInfo(TbUserInfo userInfo) {
        HTTPClientData httpClientData;
        try {
            //根据传输的code获取微信ID
            httpClientData = new HTTPClientImpl().doGet(GenURL.getWeChatAccessToken(userInfo.getCode()));
            System.out.println("获取的OPENID对象： " + httpClientData.getContent());
            //返回值转换为json对象
            JSONObject jsonObject = JSONObject.parseObject(httpClientData.getContent());
            if (jsonObject.containsKey("errcode")) {
                String errcode = jsonObject.get("errcode").toString();
                System.out.println("微信返回的错误码{}"+errcode);
                return errcode;
            }else{
                return jsonObject.getString("openid");
            }
        } catch (URISyntaxException e) {
            e.printStackTrace();
            return "微信OPEN_ID获取失败";
        }
    }
}

工具包

import org.apache.http.NameValuePair;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.message.BasicNameValuePair;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;

/**
 * @author: dwl
 * @create: 2021-08-05 09:12
 **/
public class GenURL {

    /**
     * @描述 获取网页授权accessToken
     * @author dwl
     * @createTime 2022/2/22
     */
    public static URI getWeChatAccessToken(String code) throws URISyntaxException {
        List<NameValuePair> params = new ArrayList<>();
        params.add(new BasicNameValuePair("appid", ‘测试id’));
        params.add(new BasicNameValuePair("secret",‘test’));
        params.add(new BasicNameValuePair("code",code));
        params.add(new BasicNameValuePair("grant_type","authorization_code"));
        URI uri = new URIBuilder("https://api.weixin.qq.com/sns/oauth2/access_token").setParameters(params).build();
        return uri;
    }
}

package com.ruoyi.common.wechatUtils.HTTP;

import org.apache.http.HttpEntity;
import org.apache.http.ParseException;
import org.apache.http.client.methods.*;
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.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import java.io.IOException;
import java.net.URI;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;

/**
 * @author: RyuZUSUNC
 * @create: 2021-06-07 10:33
 **/

public class HTTPClientImpl {
    final String HTTPS = "https";
    final String HTTP = "http";
    CloseableHttpClient httpClient;
    HTTPClientData httpClientData = new HTTPClientData();

    /**
     * 无参构造方法，创建并初始化httpClient
     */
    public HTTPClientImpl(){
        TrustStrategy acceptingTrustStrategy = (cert, authType) -> true;
        SSLContext sslContext = null;
        try {
            sslContext = SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
        } catch (NoSuchAlgorithmException | KeyManagementException | KeyStoreException e) {
            e.printStackTrace();
        }
        assert sslContext != null;
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext,
                NoopHostnameVerifier.INSTANCE);

        Registry<ConnectionSocketFactory> socketFactoryRegistry =
                RegistryBuilder.<ConnectionSocketFactory> create()
                        .register(HTTPS, sslsf)
                        .register(HTTP, new PlainConnectionSocketFactory())
                        .build();

        BasicHttpClientConnectionManager connectionManager =
                new BasicHttpClientConnectionManager(socketFactoryRegistry);

        // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
        httpClient = HttpClientBuilder.create().setSSLSocketFactory(sslsf).setConnectionManager(connectionManager).build();
    }

    /**
     * GET请求目标URI
     * @param uri 目标URI
     */
    public HTTPClientData doGet(URI uri){
        // 创建Get请求
        HttpGet httpGet = new HttpGet(uri);

        sendRequest(httpGet);
        return httpClientData;
    }

    public HTTPClientData doPostJSON(URI uri, String jsonString){
        // 创建Post请求
        HttpPost httpPost = new HttpPost(uri);

        StringEntity entity = new StringEntity(jsonString, "UTF-8");

        // post请求是将参数放在请求体里面传过去的;这里将entity放入post请求体中
        httpPost.setEntity(entity);

        sendRequest(httpPost);
        return httpClientData;
    }

    public HTTPClientData doDelete(URI uri){
        // 创建Delete请求
        HttpDelete httpDelete = new HttpDelete(uri);

        sendRequest(httpDelete);
        return httpClientData;
    }

    public void sendRequest(HttpRequestBase httpRequest){
        // 响应模型
        CloseableHttpResponse response = null;
        try {
            // 由客户端执行(发送)Get请求
            response = httpClient.execute(httpRequest);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            httpClientData.setAllHeaders(response.getAllHeaders());
            httpClientData.setStatus(response.getStatusLine());
//            System.out.println("响应包头为:" + Arrays.toString(response.getAllHeaders()));
//            System.out.println("响应状态为:" + response.getStatusLine());
            if (responseEntity != null) {
                httpClientData.setContent(EntityUtils.toString(responseEntity));
                httpClientData.setContentLength(responseEntity.getContentLength());
                httpClientData.setContentEncoding(responseEntity.getContentEncoding());
                httpClientData.setContentType(responseEntity.getContentType());
//                System.out.println("响应内容长度为:" + responseEntity.getContentLength());
//                System.out.println("响应内容为:" + EntityUtils.toString(responseEntity));
            }
        } catch (ParseException | IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 释放资源
                if (httpClient != null) {
                    httpClient.close();
                }
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.ruoyi.common.wechatUtils.HTTP;

import org.apache.http.Header;
import org.apache.http.StatusLine;

import java.util.Arrays;

/**
 * @author: RyuZUSUNC
 * @create: 2021-06-16 13:17
 **/

public class HTTPClientData {
    Header[] AllHeaders;
    StatusLine Status;
    long ContentLength;
    Header ContentEncoding;
    Header ContentType;
    String Content;

    public Header[] getAllHeaders() {
        return AllHeaders;
    }

    @Override
    public String toString() {
        return "HTTPClientData{" +
                "AllHeaders=" + Arrays.toString(AllHeaders) +
                ", Content='" + Content + '\'' +
                '}';
    }

    public void setAllHeaders(Header[] allHeaders) {
        AllHeaders = allHeaders;
    }

    public StatusLine getStatus() {
        return Status;
    }

    public void setStatus(StatusLine status) {
        Status = status;
    }

    public long getContentLength() {
        return ContentLength;
    }

    public void setContentLength(long contentLength) {
        ContentLength = contentLength;
    }

    public Header getContentEncoding() {
        return ContentEncoding;
    }

    public void setContentEncoding(Header contentEncoding) {
        ContentEncoding = contentEncoding;
    }

    public Header getContentType() {
        return ContentType;
    }

    public void setContentType(Header contentType) {
        ContentType = contentType;
    }

    public String getContent() {
        return Content;
    }

    public void setContent(String content) {
        Content = content;
    }
}