邮箱发送和微信登录

业务场景
发布日期:   2022-03-19

关于邮箱发送和微信登录的问题

邮箱发送

先从简单的讲起
要使用邮箱发送验证码的功能首先要开启邮箱的一些配置
打开QQ邮箱–>设置–>账户–>打开POP3服务

开启后会提供给你一个16位的秘钥
在项目的配置文件中加上如下的配置

spring.mail.password=你的密匙
spring.mail.username=你的邮箱
spring.mail.host=smtp.qq.com
spring.mail.properties.mail.smtp.ssl.enable=true

#配置redis配置信息
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.database= 0
spring.redis.timeout=1800000
spring.redis.lettuce.pool.max-active=20
spring.redis.lettuce.pool.max-wait=-1
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-idle=5
spring.redis.lettuce.pool.min-idle=0

在这次的学习中我是把邮箱的验证码放入到redis中设置一定的过期时间

登陆的逻辑一般是这样的：首先用户输入个人的电子邮箱后，点击发送验证码，前端调用发送验证码接口，将验证码存入redis数据库中，然后用户收到验证码输入文本框中点击登录进行验证。在点击登录是，前端又请求后端登录接口，前端将用户的电子邮箱，用户输入的验证码等信息传到后端进行校验。

后端首先要判断邮箱和验证码是否为空，如果为空抛出异常，然后取出redis中存的验证码和用户输入的进行比对，不相等则抛出异常，如果相等的话，查询用户数据库中是否有该用户信息，判断时候是首次登录，如果首次登录自动注册，添加用户的邮箱，设置状态放入数据库。 如果不是首次登录判断该用户状态，如果状态正常，将用户的信息封装到map中传给前端，同时根据JWT生成token放入map中传给前端。后端删除redis中存放的验证码。

前端login成功时，拿到后端传的token等信息，存入到cookie中，便于判断用户登录状态。

大概代码如下

@GetMapping("sendEmail/{email}")
    public Result sendEmailCode(@PathVariable String email){

       //从redis获取验证码，如果获取获取到，返回ok
       // key 手机号  value 验证码
      String code =  redisTemplate.opsForValue().get(email);
       if(!StringUtils.isEmpty(code)) {
           return Result.ok();
       }
       //如果从redis获取不到，
       // 生成验证码，
       code = msmService.getCode();
       msmService.sendEmail(email,code);
       redisTemplate.opsForValue().set(email,code,5, TimeUnit.MINUTES);
       return Result.ok();

   }

发送验证码方法 需要引入
JavaMailSender javaMailSender;和改依赖

    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
            <version>2.5.4</version>
        </dependency>

 @Override
    @Async
    public void sendEmail(String email, String code) {
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setSubject("登录验证码");
        simpleMailMessage.setText("尊敬的:"+email+"您的注册校验验证码为：" + code + "有效期5分钟");
        simpleMailMessage.setTo(email);
        simpleMailMessage.setFrom("1584504718@qq.com");
        javaMailSender.send(simpleMailMessage);
    }

//验证码生成规则
    @Override
    public String getCode() {
        int random = (int) (Math.random() * 1000000);
        System.out.println(random);
        String code = String.format("%06d", random);
        System.out.println(code);
        return code;
    }

生成token的规则

package com.atguigu.yygh.common.helper;


import io.jsonwebtoken.*;
import org.springframework.util.StringUtils;

import java.util.Date;

public class JwtHelper {
    private static long tokenExpiration = 24*60*60*1000;
    private static String tokenSignKey = "123456";

    public static String createToken(Long userId, String userName) {
        String token = Jwts.builder()
                .setSubject("YYGH-USER")
                .setExpiration(new Date(System.currentTimeMillis() + tokenExpiration))
                .claim("userId", userId)
                .claim("userName", userName)
                .signWith(SignatureAlgorithm.HS512, tokenSignKey)
                .compressWith(CompressionCodecs.GZIP)
                .compact();
        return token;
    }

    public static Long getUserId(String token) {
        if(StringUtils.isEmpty(token)) return null;
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token);
        Claims claims = claimsJws.getBody();
        Integer userId = (Integer)claims.get("userId");
        return userId.longValue();
    }

    public static String getUserName(String token) {
        if(StringUtils.isEmpty(token)) return "";
        Jws<Claims> claimsJws
                = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token);
        Claims claims = claimsJws.getBody();
        return (String)claims.get("userName");
    }

    public static void main(String[] args) {
        String token = JwtHelper.createToken(1L, "55");
        System.out.println(token);
        System.out.println(JwtHelper.getUserId(token));
        System.out.println(JwtHelper.getUserName(token));
    }
}

 @Override
    public Map<String, Object> loginUser(LoginVo loginVo) {
        //从loginVO获取手机号  验证码
        String phone = loginVo.getPhone();
        String code = loginVo.getCode();
        //判断是否为空
        if(StringUtils.isEmpty(phone) || StringUtils.isEmpty(code)){
            throw new YyghException(ResultCodeEnum.PARAM_ERROR);
        }

        //todo 判断验证码是否一致
        String mobleCode=redisTemplate.opsForValue().get(phone).toString();
        System.out.println("test");
            if(!code.equals(mobleCode)){
                throw  new YyghException(ResultCodeEnum.CODE_ERROR);
            }else {
                 //这是加入微信登录的代码与邮箱登录无关
                //绑定手机号码
                UserInfo userInfo = null;
                if(!StringUtils.isEmpty(loginVo.getOpenid())) {
                    userInfo = this.selectWxInfoOpenId(loginVo.getOpenid());
                    if(null != userInfo) {
                        userInfo.setPhone(loginVo.getPhone());
                        this.updateById(userInfo);
                    } else {
                        throw new YyghException(ResultCodeEnum.DATA_ERROR);
                    }
                }
             //这是加入微信登录的代码的结尾与邮箱登录无关

                //如果为空做正常的手机登录
                if(userInfo ==null){
                    //判断是否是第一次登录  （根据手机号查询数据库比对）
                    QueryWrapper<UserInfo> wrapper = new QueryWrapper<>();
                    wrapper.eq("phone", phone);
                    userInfo = baseMapper.selectOne(wrapper);
                    if (userInfo == null) {
                        userInfo = new UserInfo();
                        userInfo.setName("");
                        userInfo.setPhone(phone);
                        userInfo.setStatus(1);
                        baseMapper.insert(userInfo);
                    }
                }

                if (userInfo.getStatus() == 0) {
                    throw new YyghException(ResultCodeEnum.LOGIN_DISABLED_ERROR);
                }

                //校验用户状态
                //不是第一次直接登陆
                //返回信息（用户名  token）
                //返回页面显示名称
                Map<String, Object> map = new HashMap<>();
                String name = userInfo.getName();
                if (StringUtils.isEmpty(name)) {
                    name = userInfo.getNickName();
                }
                if (StringUtils.isEmpty(name)) {
                    name = userInfo.getPhone();
                }
                map.put("name", name);
                // JWT生成
                String token = JwtHelper.createToken(userInfo.getId(), name);
                map.put("token", token);
                redisTemplate.delete(phone);
                return map;
            }
    }

同时前端需要写的代码也很多，这里就不一一赘述，主要讲后端的部分。

微信扫码登录的实现

微信登录的过程也比较繁琐，引用微信开发平台的内容

网站应用微信登录是基于OAuth2.0协议标准构建的微信OAuth2.0授权登录系统。 在进行微信OAuth2.0授权登录接入之前，在微信开放平台注册开发者帐号，并拥有一个已审核通过的网站应用，并获得相应的AppID和AppSecret，申请微信登录且通过审核后，可开始接入流程。

授权流程说明
微信OAuth2.0授权登录让微信用户使用微信身份安全登录第三方应用或网站，在微信用户授权登录已接入微信OAuth2.0的第三方应用后，第三方可以获取到用户的接口调用凭证（access_token），通过access_token可以进行微信开放平台授权关系接口调用，从而可实现获取微信用户基本开放信息和帮助用户实现基础开放功能等。 微信OAuth2.0授权登录目前支持authorization_code模式，适用于拥有server端的应用授权。该模式整体流程为：

  1. 第三方发起微信授权登录请求，微信用户允许授权第三方应用后，微信会拉起应用或重定向到第三方网站，并且带上授权临时票据code参数；2. 通过code参数加上AppID和AppSecret等，通过API换取access_token；3. 通过access_token进行接口调用，获取用户基本数据资源或帮助用户实现基本操作。

微信登录也需要获得微信访问的一些授权和验证

基本配置

wx.open.app_id=你的app_id
wx.open.app_secret=你的app_secret
wx.open.redirect_url=http://localhost:8160/api/ucenter/wx/callback
yygh.baseUrl=http://localhost:3000

添加配置类

@Component
public class ConstantWxPropertiesUtils implements InitializingBean {
    @Value("${wx.open.app_id}")
    private String appId;

    @Value("${wx.open.app_secret}")
    private String appSecret;

    @Value("${wx.open.redirect_url}")
    private String redirectUrl;

    @Value("${yygh.baseUrl}")
    private String yyghBaseUrl;

    public static String WX_OPEN_APP_ID;
    public static String WX_OPEN_APP_SECRET;
    public static String WX_OPEN_REDIRECT_URL;

    public static String YYGH_BASE_URL;


    @Override
    public void afterPropertiesSet() throws Exception {
        WX_OPEN_APP_ID = appId;
        WX_OPEN_APP_SECRET = appSecret;
        WX_OPEN_REDIRECT_URL = redirectUrl;
        YYGH_BASE_URL = yyghBaseUrl;
    }
}

前端也要引入微信官方的一些规定代码

第一步：生成微信登录的二维码

 mounted() {
    // 注册全局登录事件对象
    window.loginEvent = new Vue();
    // 监听登录事件
    loginEvent.$on('loginDialogEvent', function () {
      document.getElementById("loginDialog").click();
    })
    // 触发事件，显示登录层：loginEvent.$emit('loginDialogEvent')
    //初始化微信js
    const script = document.createElement('script')
    script.type = 'text/javascript'
    script.src = 'https://res.wx.qq.com/connect/zh_CN/htmledition/js/wxLogin.js'
    document.body.appendChild(script)

    // 微信登录回调处理
    let self = this;
    window["loginCallback"] = (name,token, openid) => {
      self.loginCallback(name, token, openid);
    }
  },

实例化微信JS对象,添加微信登录方法

loginCallback(name, token, openid) {
    // 打开手机登录层，绑定手机号，改逻辑与手机登录一致
    if(openid != null) {
       this.userInfo.openid = openid
       this.showLogin()
    } else {
       this.setCookies(name, token)
    }
},

weixinLogin() {
  this.dialogAtrr.showLoginType = 'weixin'

  weixinApi.getLoginParam().then(response => {
    var obj = new WxLogin({
      self_redirect:true,
      id: 'weixinLogin', // 需要显示的容器id
      appid: response.data.appid, // 公众号appid wx*******
      scope: response.data.scope, // 网页默认即可
      redirect_uri: response.data.redirectUri, // 授权成功后回调的url
      state: response.data.state, // 可设置为简单的随机数加session用来校验
      style: 'black', // 提供"black"、"white"可选。二维码的样式
      href: '' // 外部css文件url，需要https
    })
  })
},

写Controller接口

  //生成微信扫描二维码 返回二维码需要参数
    @GetMapping("getLoginParam")
    @ResponseBody
    public Result genQrConnect(){
        try {
            Map<String, Object> map = new HashMap<>();
            map.put("appid", ConstantWxPropertiesUtils.WX_OPEN_APP_ID);
            map.put("scope", "snsapi_login");
            String wxOpenRedirectUrl = ConstantWxPropertiesUtils.WX_OPEN_REDIRECT_URL;
            wxOpenRedirectUrl = URLEncoder.encode(wxOpenRedirectUrl,"utf-8");
            map.put("redirect_uri", wxOpenRedirectUrl);
            map.put("state", System.currentTimeMillis() + "");
            return Result.ok(map);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

第二步

第一步中生成了微信登陆的二维码，用户点击确认后，需要去调用微信后台的回调地址，回调域名地址跳转到当前自己写的controller中

微信扫描后回调方法

//回调方法
    @GetMapping("callback")
    public String callback(String code,String state){
        System.out.println(code);
        //根据code  和微信id 和秘钥  请求微信固定地址 得到两个值

        StringBuffer baseAccessTokenUrl = new StringBuffer()
                .append("https://api.weixin.qq.com/sns/oauth2/access_token")
                .append("?appid=%s")
                .append("&secret=%s")
                .append("&code=%s")
                .append("&grant_type=authorization_code");

        String accessTokenUrl = String.format(baseAccessTokenUrl.toString(),
               ConstantWxPropertiesUtils.WX_OPEN_APP_ID,
                ConstantWxPropertiesUtils.WX_OPEN_APP_SECRET,
                code);

        try {
            //请求微信提供的接口 获取到的数据库  返回的数据有access_token和openid
            String accesstokenInfo = HttpClientUtils.get(accessTokenUrl);
            System.out.println("accessTokenInfo"+accesstokenInfo);
            //从返回字符串获取数据、
            JSONObject jsonObject= JSONObject.parseObject(accesstokenInfo);
            String access_token=jsonObject.getString("access_token");
            String openid=jsonObject.getString("openid");


            //判断数据库是否存在微信扫码人信息 根据openid判断
          UserInfo userInfo=userInfoService.selectWxInfoOpenId(openid);

          if(userInfo == null)
          {
              //使用access_token换取受保护的资源：微信的个人信息
              String baseUserInfoUrl = "https://api.weixin.qq.com/sns/userinfo" +
                      "?access_token=%s" +
                      "&openid=%s";
              String userInfoUrl = String.format(baseUserInfoUrl, access_token, openid);
              String resultInfo = HttpClientUtils.get(userInfoUrl);
              System.out.println("扫码人信息"+resultInfo);

              JSONObject resultUserInfoJson = JSONObject.parseObject(resultInfo);

              //解析用户信息
              String nickname = resultUserInfoJson.getString("nickname");  //昵称
              String headimgurl = resultUserInfoJson.getString("headimgurl");  //头像

               userInfo = new UserInfo();
              userInfo.setName(nickname);
              userInfo.setOpenid(openid);
              userInfo.setStatus(1);
              userInfoService.save(userInfo);

          }


            //返回name和token的字符串
            Map<String, Object> map = new HashMap<>();
            String name = userInfo.getName();
            if(StringUtils.isEmpty(name)) {
                name = userInfo.getNickName();
            }
            if(StringUtils.isEmpty(name)) {
                name = userInfo.getPhone();
            }
            map.put("name", name);

            //判断userInfo是否有手机号  如果手机号为空  返回openid
            //如果openid不为空  返回openid时空字符串
            //如果openid不为空 绑定手机号 如果为空则 不需要绑定手机号

            if(StringUtils.isEmpty(userInfo.getPhone())) {
                map.put("openid", userInfo.getOpenid());
            } else {
                map.put("openid", "");
            }

            String token = JwtHelper.createToken(userInfo.getId(), name);
            map.put("token", token);
            return
                    "redirect:" + ConstantWxPropertiesUtils.YYGH_BASE_URL + "/weixin/callback?token="+map.get("token")+"&openid="+map.get("openid")+"&name="+URLEncoder.encode((String) map.get("name"),"utf-8");

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }


    }

获取扫描人信息的过程
第一步获取回调返回的code值 临时票据
第二步 拿着获取的code值请求微信提供的地址 得到地址返回的两个值access_token 和openid
第三步：拿着access_token获取扫码人信息
第四步：绑定手机号 把手机号和微信扫描人信息添加到数据库中

我们使用httpclient请求地址 使用json转换获取数据

httpclient工具类

package com.atguigu.yygh.user.utils;

import com.google.protobuf.MapEntry;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.client.config.RequestConfig.Builder;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import java.io.IOException;
import java.net.SocketTimeoutException;
import java.security.GeneralSecurityException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.io.IOUtils;
import org.apache.http.ssl.SSLContextBuilder;

public class HttpClientUtils {

    public static final int connTimeout=10000;
    public static final int readTimeout=10000;
    public static final String charset="UTF-8";
    private static HttpClient client = null;

    static {
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
        cm.setMaxTotal(128);
        cm.setDefaultMaxPerRoute(128);
        client = HttpClients.custom().setConnectionManager(cm).build();
    }

    public static String postParameters(String url, String parameterStr) throws ConnectTimeoutException, SocketTimeoutException, Exception{
        return post(url,parameterStr,"application/x-www-form-urlencoded",charset,connTimeout,readTimeout);
    }

    public static String postParameters(String url, String parameterStr,String charset, Integer connTimeout, Integer readTimeout) throws ConnectTimeoutException, SocketTimeoutException, Exception{
        return post(url,parameterStr,"application/x-www-form-urlencoded",charset,connTimeout,readTimeout);
    }

    public static String postParameters(String url, Map<String, String> params) throws ConnectTimeoutException,
            SocketTimeoutException, Exception {
        return postForm(url, params, null, connTimeout, readTimeout);
    }

    public static String postParameters(String url, Map<String, String> params, Integer connTimeout,Integer readTimeout) throws ConnectTimeoutException,
            SocketTimeoutException, Exception {
        return postForm(url, params, null, connTimeout, readTimeout);
    }

    public static String get(String url) throws Exception {
        return get(url, charset, null, null);
    }

    public static String get(String url, String charset) throws Exception {
        return get(url, charset, connTimeout, readTimeout);
    }

    /**
     * 发送一个 Post 请求, 使用指定的字符集编码.
     *
     * @param url
     * @param body RequestBody
     * @param mimeType 例如 application/xml "application/x-www-form-urlencoded" a=1&b=2&c=3
     * @param charset 编码
     * @param connTimeout 建立链接超时时间,毫秒.
     * @param readTimeout 响应超时时间,毫秒.
     * @return ResponseBody, 使用指定的字符集编码.
     * @throws ConnectTimeoutException 建立链接超时异常
     * @throws SocketTimeoutException  响应超时
     * @throws Exception
     */
    public static String post(String url, String body, String mimeType,String charset, Integer connTimeout, Integer readTimeout)
            throws ConnectTimeoutException, SocketTimeoutException, Exception {
        HttpClient client = null;
        HttpPost post = new HttpPost(url);
        String result = "";
        try {
            if (StringUtils.isNotBlank(body)) {
                HttpEntity entity = new StringEntity(body, ContentType.create(mimeType, charset));
                post.setEntity(entity);
            }
            // 设置参数
            Builder customReqConf = RequestConfig.custom();
            if (connTimeout != null) {
                customReqConf.setConnectTimeout(connTimeout);
            }
            if (readTimeout != null) {
                customReqConf.setSocketTimeout(readTimeout);
            }
            post.setConfig(customReqConf.build());

            HttpResponse res;
            if (url.startsWith("https")) {
                // 执行 Https 请求.
                client = createSSLInsecureClient();
                res = client.execute(post);
            } else {
                // 执行 Http 请求.
                client = HttpClientUtils.client;
                res = client.execute(post);
            }
            result = IOUtils.toString(res.getEntity().getContent(), charset);
        } finally {
            post.releaseConnection();
            if (url.startsWith("https") && client != null&& client instanceof CloseableHttpClient) {
                ((CloseableHttpClient) client).close();
            }
        }
        return result;
    }


    /**
     * 提交form表单
     *
     * @param url
     * @param params
     * @param connTimeout
     * @param readTimeout
     * @return
     * @throws ConnectTimeoutException
     * @throws SocketTimeoutException
     * @throws Exception
     */
    public static String postForm(String url, Map<String, String> params, Map<String, String> headers, Integer connTimeout,Integer readTimeout) throws ConnectTimeoutException,
            SocketTimeoutException, Exception {

        HttpClient client = null;
        HttpPost post = new HttpPost(url);
        try {
            if (params != null && !params.isEmpty()) {
                List<NameValuePair> formParams = new ArrayList<NameValuePair>();
                Set<Map.Entry<String, String>> entrySet = params.entrySet();
                for (Map.Entry<String, String> entry : entrySet) {
                    formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
                }
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formParams, Consts.UTF_8);
                post.setEntity(entity);
            }

            if (headers != null && !headers.isEmpty()) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    post.addHeader(entry.getKey(), entry.getValue());
                }
            }
            // 设置参数
            Builder customReqConf = RequestConfig.custom();
            if (connTimeout != null) {
                customReqConf.setConnectTimeout(connTimeout);
            }
            if (readTimeout != null) {
                customReqConf.setSocketTimeout(readTimeout);
            }
            post.setConfig(customReqConf.build());
            HttpResponse res = null;
            if (url.startsWith("https")) {
                // 执行 Https 请求.
                client = createSSLInsecureClient();
                res = client.execute(post);
            } else {
                // 执行 Http 请求.
                client = HttpClientUtils.client;
                res = client.execute(post);
            }
            return IOUtils.toString(res.getEntity().getContent(), "UTF-8");
        } finally {
            post.releaseConnection();
            if (url.startsWith("https") && client != null
                    && client instanceof CloseableHttpClient) {
                ((CloseableHttpClient) client).close();
            }
        }
    }

    /**
     * 发送一个 GET 请求
     */
    public static String get(String url, String charset, Integer connTimeout,Integer readTimeout)
            throws ConnectTimeoutException,SocketTimeoutException, Exception {

        HttpClient client = null;
        HttpGet get = new HttpGet(url);
        String result = "";
        try {
            // 设置参数
            Builder customReqConf = RequestConfig.custom();
            if (connTimeout != null) {
                customReqConf.setConnectTimeout(connTimeout);
            }
            if (readTimeout != null) {
                customReqConf.setSocketTimeout(readTimeout);
            }
            get.setConfig(customReqConf.build());

            HttpResponse res = null;

            if (url.startsWith("https")) {
                // 执行 Https 请求.
                client = createSSLInsecureClient();
                res = client.execute(get);
            } else {
                // 执行 Http 请求.
                client = HttpClientUtils.client;
                res = client.execute(get);
            }

            result = IOUtils.toString(res.getEntity().getContent(), charset);
        } finally {
            get.releaseConnection();
            if (url.startsWith("https") && client != null && client instanceof CloseableHttpClient) {
                ((CloseableHttpClient) client).close();
            }
        }
        return result;
    }

    /**
     * 从 response 里获取 charset
     */
    @SuppressWarnings("unused")
    private static String getCharsetFromResponse(HttpResponse ressponse) {
        // Content-Type:text/html; charset=GBK
        if (ressponse.getEntity() != null  && ressponse.getEntity().getContentType() != null && ressponse.getEntity().getContentType().getValue() != null) {
            String contentType = ressponse.getEntity().getContentType().getValue();
            if (contentType.contains("charset=")) {
                return contentType.substring(contentType.indexOf("charset=") + 8);
            }
        }
        return null;
    }

    /**
     * 创建 SSL连接
     * @return
     * @throws GeneralSecurityException
     */
    private static CloseableHttpClient createSSLInsecureClient() throws GeneralSecurityException {
        try {
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                public boolean isTrusted(X509Certificate[] chain,String authType) throws CertificateException {
                    return true;
                }
            }).build();

            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {

                @Override
                public boolean verify(String arg0, SSLSession arg1) {
                    return true;
                }

                @Override
                public void verify(String host, SSLSocket ssl)
                        throws IOException {
                }

                @Override
                public void verify(String host, X509Certificate cert)
                        throws SSLException {
                }

                @Override
                public void verify(String host, String[] cns,
                                   String[] subjectAlts) throws SSLException {
                }
            });
            return HttpClients.custom().setSSLSocketFactory(sslsf).build();

        } catch (GeneralSecurityException e) {
            throw e;
        }
    }
}

获取到数据就跟绑定邮箱差不多了

文章作者: 蛰伏
文章链接: https://zhefu-jy.github.io/2022/03/19/%E5%BE%AE%E4%BF%A1%E7%99%BB%E5%BD%95%E5%92%8C%E9%82%AE%E7%AE%B1%E5%8F%91%E9%80%81/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 蛰伏 !
业务场景
赏
  目录