Spring Boot
记一次 RestTemplate 使用详解，既有GET，又有POST，超详细
package com.demo.oauth.service;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;
import com.alibaba.fastjson.JSON;
/**
* 认证系统
*
* @author wzy
*
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
@Service
public class OauthService {
private final static String URL_SEND_TOKEN = "http://127.0.0.1:8080/user/verification/";
private final static String URL_VERIFIY_TOKEN = "http://127.0.0.1:8080/user/verification/";
private final static String URL_SING_UP = "http://127.0.0.1:8080/user/signUp";
private final static String URL_KEEPUSER = "http://127.0.0.1:8080/user";
private final static String URL_OAUTH_TOKEN = "http://127.0.0.1:8080/oauth/token";
private final static String URL_CHANGE_PASSWORD = "http://127.0.0.1:8080/user/changePassword";
private final static String URL_GET_RESET_PSW_TOKEN = "http://127.0.0.1:8080/user/resetPassword/";
private final static String URL_RESET_PASSWORD = "http://127.0.0.1:8080/user/resetPassword";
private final static Logger LOG = LoggerFactory.getLogger(OauthService.class);
/**
* 请求验证短信
*/
public Map<String, Object> sendToken(Map<String, Object> paramMap) {
// 返回给平台的
Map<String, Object> resultMap = new HashMap<>();
if (!paramMap.containsKey("clientId")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientId = (String) paramMap.get("clientId");
if (!paramMap.containsKey("clientSecret")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientSecret = (String) paramMap.get("clientSecret");
if (!paramMap.containsKey("phone")) {
resultMap.put("success", "false");
resultMap.put("message", "缺少手机号");
return resultMap;
}
String mobile = (String) paramMap.get("phone");
RestTemplate client = new RestTemplate();
// 设置请求头
StringBuilder sb = new StringBuilder();
sb.append("Basic ");
sb.append(new String(Base64.encodeBase64(new String(clientId + ":" + clientSecret).getBytes())));
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.add("accept", "*/*");
requestHeaders.add("authorization", sb.toString());
HttpEntity<String> requestEntity = new HttpEntity<String>(null, requestHeaders);
try {
ResponseEntity<Map> responseMap = client.exchange(URL_SEND_TOKEN + mobile, HttpMethod.GET, requestEntity,
Map.class);
if (responseMap.getStatusCodeValue() == 200) {
resultMap.put("success", true);
resultMap.put("errorCode", 0);
resultMap.put("value", responseMap.getBody().get("payload"));
LOG.info("【认证系统】发送短信，手机号为【{}】，接收到的验证码为【{}】", mobile, responseMap.getBody().get("payload"));
} else {
LOG.error("【认证系统】发送短信，手机号为【{}】，接收到的参数为{}，上游返回结果{}", mobile, paramMap.toString(),
responseMap.toString());
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
}
} catch (HttpClientErrorException e) {
LOG.info("【认证系统】发送短信，手机号【{}】上游返回结果{}", mobile, e.getResponseBodyAsString());
Map<String, String> responseBodyMap = JSON.parseObject(e.getResponseBodyAsString(), Map.class);
if (!responseBodyMap.containsKey("error")) {
LOG.error("【认证系统】发送短信异常，手机号【{}】", mobile);
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String error = responseBodyMap.get("error");
resultMap.put("success", "false");
resultMap.put("message", codeToMsg(error));
return resultMap;
} catch (Exception e) {
LOG.error("【认证系统】发送短信异常，手机号【{}】", mobile);
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
return resultMap;
}
/**
* 验证短信验证码
*/
public Map<String, Object> verifiyToken(Map<String, Object> paramMap) {
// 返回给平台的
Map<String, Object> resultMap = new HashMap<>();
if (!paramMap.containsKey("clientId")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientId = (String) paramMap.get("clientId");
if (!paramMap.containsKey("clientSecret")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientSecret = (String) paramMap.get("clientSecret");
if (!paramMap.containsKey("phone")) {
resultMap.put("success", "false");
resultMap.put("message", "缺少手机号");
return resultMap;
}
String mobile = (String) paramMap.get("phone");
if (!paramMap.containsKey("code")) {
resultMap.put("success", "false");
resultMap.put("message", "缺少验证码");
return resultMap;
}
String token = (String) paramMap.get("code");
RestTemplate client = new RestTemplate();
// 设置请求头
StringBuilder sb = new StringBuilder();
sb.append("Basic ");
sb.append(new String(Base64.encodeBase64(new String(clientId + ":" + clientSecret).getBytes())));
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.add("accept", "*/*");
requestHeaders.add("Content-Type", "application/json");
requestHeaders.add("authorization", sb.toString());
HttpEntity<String> requestEntity = new HttpEntity<String>(token, requestHeaders);
try {
Map<String, Object> responseMap = client.postForObject(URL_VERIFIY_TOKEN + mobile, requestEntity,
Map.class);
LOG.info("【认证系统】验证短信验证码，手机号【{}】上游返回结果{}", mobile, responseMap.toString());
if ("success".equals(responseMap.get("payload"))) {
resultMap.put("success", true);
resultMap.put("errorCode", 0);
}
} catch (HttpClientErrorException e) {
LOG.info("【认证系统】验证短信验证码，手机号【{}】上游返回结果{}", mobile, e.getResponseBodyAsString());
Map<String, String> responseBodyMap = JSON.parseObject(e.getResponseBodyAsString(), Map.class);
if (!responseBodyMap.containsKey("error")) {
LOG.error("【认证系统】验证短信验证码异常，手机号【{}】", mobile);
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String error = responseBodyMap.get("error");
resultMap.put("success", "false");
resultMap.put("message", codeToMsg(error));
return resultMap;
} catch (Exception e) {
LOG.error("【认证系统】短信验证异常，手机号为【{}】", mobile);
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "短信验证失败");
return resultMap;
}
return resultMap;
}
/**
* 注册
*
* @param paramMap
* @return
*/
public Map<String, Object> singUp(Map<String, Object> paramMap) {
// 返回给平台的
Map<String, Object> resultMap = new HashMap<>();
if (!paramMap.containsKey("clientId")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientId = (String) paramMap.get("clientId");
if (!paramMap.containsKey("clientSecret")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientSecret = (String) paramMap.get("clientSecret");
if (!paramMap.containsKey("phone")) {
resultMap.put("success", "false");
resultMap.put("message", "缺少手机号");
return resultMap;
}
String mobile = (String) paramMap.get("phone");
if (!paramMap.containsKey("verified")) {
resultMap.put("success", "false");
resultMap.put("message", "用户未验证");
return resultMap;
}
Boolean verified = (Boolean) paramMap.get("verified");
if (!(verified == true)) {
resultMap.put("success", "false");
resultMap.put("message", "用户未验证");
return resultMap;
}
if (!paramMap.containsKey("loginPassword")) {
resultMap.put("success", "false");
resultMap.put("message", "缺少密码");
return resultMap;
}
String password = (String) paramMap.get("loginPassword");
if (!paramMap.containsKey("loginPassword")) {
resultMap.put("success", "false");
resultMap.put("message", "缺少确认密码");
return resultMap;
}
String matchingPassword = (String) paramMap.get("loginPassword");
// 发送给认证系统参数
Map<String, Object> map = new HashMap<>();
map.put("mobile", mobile);
map.put("password", password);
map.put("matchingPassword", matchingPassword);
map.put("verified", verified.toString());
String mapStr = JSON.toJSONString(map);
RestTemplate client = new RestTemplate();
// 设置请求头
StringBuilder sb = new StringBuilder();
sb.append("Basic ");
sb.append(new String(Base64.encodeBase64(new String(clientId + ":" + clientSecret).getBytes())));
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.add("accept", "*/*");
requestHeaders.add("Content-Type", "application/json");
requestHeaders.add("authorization", sb.toString());
HttpEntity<String> requestEntity = new HttpEntity<String>(mapStr, requestHeaders);
try {
Map<String, Object> responseMap = client.postForObject(URL_SING_UP, requestEntity, Map.class);
LOG.info("【认证系统】注册成功，手机号【{}】上游返回结果{}", mobile, responseMap.toString());
if (!responseMap.containsKey("payload")) {
LOG.error("【认证系统】注册异常，手机号【{}】，缺少payload", mobile);
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
Map<String, Object> payloadMap = (Map<String, Object>) responseMap.get("payload");
if (!payloadMap.containsKey("userInfo")) {
LOG.error("【认证系统】注册异常，手机号【{}】，缺少userInfo", mobile);
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
Map<String, Object> userInfoMap = (Map<String, Object>) payloadMap.get("userInfo");
if (!userInfoMap.containsKey("id")) {
LOG.error("【认证系统】注册异常，手机号【{}】，缺少id", mobile);
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
resultMap.put("success", true);
resultMap.put("value", String.valueOf(userInfoMap.get("id")));
} catch (HttpClientErrorException e) {
LOG.info("【认证系统】注册异常，手机号【{}】上游返回结果{}", mobile, e.getResponseBodyAsString());
Map<String, String> responseBodyMap = JSON.parseObject(e.getResponseBodyAsString(), Map.class);
if (!responseBodyMap.containsKey("error")) {
LOG.error("【认证系统】注册异常，手机号【{}】", mobile);
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String error = responseBodyMap.get("error");
resultMap.put("success", "false");
resultMap.put("message", codeToMsg(error));
return resultMap;
} catch (Exception e) {
LOG.error("【认证系统】注册异常");
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "注册失败");
return resultMap;
}
LOG.info("【认证系统】注册成功，返回主服务【{}】", resultMap.toString());
return resultMap;
}
/**
* 第一次登录同时获取token
*
* @param paramMap
* @return
*/
public Map<String, Object> oauthToken(Map<String, Object> paramMap) {
// 返回给平台的
Map<String, Object> resultMap = new HashMap<>();
if (!paramMap.containsKey("clientId")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientId = (String) paramMap.get("clientId");
if (!paramMap.containsKey("clientSecret")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientSecret = (String) paramMap.get("clientSecret");
if (!paramMap.containsKey("phone")) {
resultMap.put("success", "false");
resultMap.put("message", "账号不能为空");
return resultMap;
}
String username = (String) paramMap.get("phone");
if (!paramMap.containsKey("loginPassword")) {
resultMap.put("success", "false");
resultMap.put("message", "密码不能为空");
return resultMap;
}
String password = (String) paramMap.get("loginPassword");
if (StringUtils.isBlank(password)) {
resultMap.put("success", "false");
resultMap.put("message", "密码不能为空");
return resultMap;
}
StringBuilder sb = new StringBuilder();
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.add("Accept", "application/json, application/x-www-form-urlencoded");
requestHeaders.add("Content-Type", "application/x-www-form-urlencoded");
HttpEntity<String> requestEntity = new HttpEntity<String>(sb.toString(), requestHeaders);
RestTemplate client = new RestTemplate();
try {
Map<String, Object> responseMap = client.postForObject(URL_OAUTH_TOKEN, requestEntity, Map.class);
if (!responseMap.containsKey("access_token")) {
LOG.error("【认证系统】第一次登录同时获取token异常，没有access_token，手机号【{}】，上游返回结果{}", username, responseMap.toString());
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
resultMap.put("success", true);
resultMap.put("value", (String) responseMap.get("access_token"));
LOG.info("【认证系统】第一次登录同时获取token，手机号【{}】,token为【{}】", username, (String) responseMap.get("access_token"));
} catch (HttpClientErrorException e) {
LOG.info("【认证系统】第一次登录同时获取token异常，手机号【{}】，上游返回结果{}", username, e.getResponseBodyAsString());
Map<String, String> responseBodyMap = JSON.parseObject(e.getResponseBodyAsString(), Map.class);
if (!responseBodyMap.containsKey("error")) {
LOG.error("【认证系统】第一次登录同时获取token异常，手机号【{}】，上游返回结果{}", username, e.getResponseBodyAsString());
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String error = responseBodyMap.get("error");
resultMap.put("success", "false");
resultMap.put("message", codeToMsg(error));
return resultMap;
} catch (Exception e) {
LOG.error("【认证系统】第一次登录同时获取token异常，手机号【{}】", username);
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
return resultMap;
}
/**
* 保持用户登录
*
* @param paramMap
* @return
*/
public Map<String, Object> keepUser(Map<String, Object> paramMap) {
// 返回给平台的
Map<String, Object> resultMap = new HashMap<>();
if (!paramMap.containsKey("oauthAccessToken")) {
resultMap.put("success", "false");
resultMap.put("message", "身份已过期，请重新登录");
return resultMap;
}
String token = (String) paramMap.get("oauthAccessToken");
RestTemplate client = new RestTemplate();
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.add("accept", "*/*");
requestHeaders.add("authorization", "Bearer " + token);
HttpEntity<String> requestEntity = new HttpEntity<String>(null, requestHeaders);
try {
ResponseEntity<Map> response = client.exchange(URL_KEEPUSER, HttpMethod.GET, requestEntity, Map.class);
if (response.getStatusCodeValue() == 200) {
Map<String, Object> responseMap = response.getBody();
resultMap.put("success", true);
resultMap.put("value", responseMap);
LOG.info("【认证系统】保持用户登录{}", responseMap.toString());
}
} catch (HttpClientErrorException e) {
LOG.info("【认证系统】保持用户登录，上游返回结果{}", e.getResponseBodyAsString());
Map<String, String> responseBodyMap = JSON.parseObject(e.getResponseBodyAsString(), Map.class);
if (!responseBodyMap.containsKey("error")) {
LOG.error("【认证系统】保持用户登录异常，上游返回结果{}", e.getResponseBodyAsString());
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String error = responseBodyMap.get("error");
resultMap.put("success", "false");
resultMap.put("message", codeToMsg(error));
return resultMap;
} catch (Exception e) {
LOG.error("【认证系统】保持用户登录异常");
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
return resultMap;
}
/**
* 修改密码
*
* @param paramMap
* @return
*/
public Map<String, Object> changePassword(Map<String, Object> paramMap) {
// 返回给平台的
Map<String, Object> resultMap = new HashMap<>();
if (!paramMap.containsKey("oauthAccessToken")) {
resultMap.put("success", "false");
resultMap.put("message", "信息已过期请重新登录");
return resultMap;
}
String token = (String) paramMap.get("oauthAccessToken");
if (!paramMap.containsKey("oldPassword")) {
resultMap.put("success", "false");
resultMap.put("message", "旧密码不能为空");
return resultMap;
}
String oldPassword = (String) paramMap.get("oldPassword");
if (!paramMap.containsKey("password")) {
resultMap.put("success", "false");
resultMap.put("message", "新密码不能为空");
return resultMap;
}
String password = (String) paramMap.get("password");
if (!paramMap.containsKey("newPassword")) {
resultMap.put("success", "false");
resultMap.put("message", "确认新密码不能为空");
return resultMap;
}
String matchingPassword = (String) paramMap.get("newPassword");
if (!password.equals(matchingPassword)) {
resultMap.put("success", "false");
resultMap.put("message", "两次密码不一致");
return resultMap;
}
RestTemplate client = new RestTemplate();
Map<String, String> map = new HashMap<>();
map.put("oldPassword", oldPassword);
map.put("password", password);
map.put("matchingPassword", matchingPassword);
String mapStr = JSON.toJSONString(map);
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.add("accept", "*/*");
requestHeaders.add("Content-Type", "application/json");
requestHeaders.add("authorization", "Bearer " + token);
HttpEntity<String> requestEntity = new HttpEntity<String>(mapStr, requestHeaders);
try {
Map<String, Object> responseMap = client.postForObject(URL_CHANGE_PASSWORD, requestEntity, Map.class);
LOG.info("【认证系统】修改密码，上游返回结果{}", responseMap.toString());
if ("success".equals(responseMap.get("payload"))) {
resultMap.put("success", true);
resultMap.put("errorCode", 0);
}
} catch (HttpClientErrorException e) {
LOG.info("【认证系统】修改密码异常，上游返回结果{}", e.getResponseBodyAsString());
Map<String, String> responseBodyMap = JSON.parseObject(e.getResponseBodyAsString(), Map.class);
if (!responseBodyMap.containsKey("error")) {
LOG.error("【认证系统】修改密码异常");
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String error = responseBodyMap.get("error");
resultMap.put("success", "false");
resultMap.put("message", codeToMsg(error));
return resultMap;
} catch (Exception e) {
LOG.error("【认证系统】修改密码异常");
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
return resultMap;
}
/**
* 获取重置密码Token
*
* @return
*/
public Map<String, Object> getResetPswToken(Map<String, Object> paramMap) {
// 返回给平台的
Map<String, Object> resultMap = new HashMap<>();
if (!paramMap.containsKey("clientId")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientId = (String) paramMap.get("clientId");
if (!paramMap.containsKey("clientSecret")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientSecret = (String) paramMap.get("clientSecret");
if (!paramMap.containsKey("phone")) {
resultMap.put("success", "false");
resultMap.put("message", "缺少手机号");
return resultMap;
}
String mobile = (String) paramMap.get("phone");
RestTemplate client = new RestTemplate();
StringBuilder sb = new StringBuilder();
sb.append("Basic ");
sb.append(new String(Base64.encodeBase64(new String(clientId + ":" + clientSecret).getBytes())));
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.add("accept", "*/*");
requestHeaders.add("authorization", sb.toString());
HttpEntity<String> requestEntity = new HttpEntity<String>(null, requestHeaders);
try {
ResponseEntity<Map> response = client.exchange(URL_GET_RESET_PSW_TOKEN + mobile, HttpMethod.GET,
requestEntity, Map.class);
Map<String, Object> responseMap = response.getBody();
if (!responseMap.containsKey("payload")) {
LOG.error("【认证系统】获取重置密码Token异常，手机号【{}】，上游返回结果{}", mobile, responseMap.toString());
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，请稍后再试");
return resultMap;
}
LOG.info("【认证系统】获取重置密码Token,手机号【{}】，上游返回结果{}", mobile, responseMap.toString());
String payload = (String) responseMap.get("payload");
resultMap.put("success", "true");
resultMap.put("value", payload);
} catch (HttpClientErrorException e) {
LOG.info("【认证系统】获取重置密码Token异常，手机号【{}】上游返回结果{}", mobile, e.getResponseBodyAsString());
Map<String, String> responseBodyMap = JSON.parseObject(e.getResponseBodyAsString(), Map.class);
if (!responseBodyMap.containsKey("error")) {
LOG.error("【认证系统】获取重置密码Token异常，手机号【{}】", mobile);
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String error = responseBodyMap.get("error");
resultMap.put("success", "false");
resultMap.put("message", codeToMsg(error));
return resultMap;
} catch (Exception e) {
LOG.error("【认证系统】获取重置密码Token异常，手机号【{}】", mobile);
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
return resultMap;
}
/**
* 重置密码
*
* @param paramMap
* @return
*/
public Map<String, Object> resetPassword(Map<String, Object> paramMap) {
// 返回给平台的
Map<String, Object> resultMap = new HashMap<>();
if (!paramMap.containsKey("clientId")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientId = (String) paramMap.get("clientId");
if (!paramMap.containsKey("clientSecret")) {
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String clientSecret = (String) paramMap.get("clientSecret");
if (!paramMap.containsKey("phone")) {
resultMap.put("success", "false");
resultMap.put("message", "手机号不能为空");
return resultMap;
}
String mobile = (String) paramMap.get("phone");
if (!paramMap.containsKey("oauthAccessToken")) {
LOG.error("【认证系统】重置密码异常，手机号【{}】，缺少Token", mobile);
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，请稍后再试");
return resultMap;
}
String token = (String) paramMap.get("oauthAccessToken");
if (!paramMap.containsKey("password")) {
resultMap.put("success", "false");
resultMap.put("message", "密码不能为空");
return resultMap;
}
String password = (String) paramMap.get("password");
if (!paramMap.containsKey("password")) {
resultMap.put("success", "false");
resultMap.put("message", "确认密码不能为空");
return resultMap;
}
String matchingPassword = (String) paramMap.get("password");
RestTemplate client = new RestTemplate();
Map<String, String> map = new HashMap<>();
map.put("mobile", mobile);
map.put("password", password);
map.put("matchingPassword", matchingPassword);
map.put("token", token);
String mapStr = JSON.toJSONString(map);
StringBuilder sb = new StringBuilder();
sb.append("Basic ");
sb.append(new String(Base64.encodeBase64(new String(clientId + ":" + clientSecret).getBytes())));
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.add("accept", "*/*");
requestHeaders.add("Content-Type", "application/json");
requestHeaders.add("authorization", sb.toString());
HttpEntity<String> requestEntity = new HttpEntity<String>(mapStr, requestHeaders);
try {
Map<String, Object> responseMap = client.postForObject(URL_RESET_PASSWORD, requestEntity, Map.class);
LOG.info("【认证系统】重置密码成功，手机号【{}】上游返回结果{}", mobile, responseMap.toString());
if ("success".equals(responseMap.get("payload"))) {
resultMap.put("success", true);
resultMap.put("errorCode", 0);
}
} catch (HttpClientErrorException e) {
LOG.info("【认证系统】重置密码异常，上游返回结果{}", e.getResponseBodyAsString());
Map<String, String> responseBodyMap = JSON.parseObject(e.getResponseBodyAsString(), Map.class);
if (!responseBodyMap.containsKey("error")) {
LOG.error("【认证系统】重置密码异常");
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "服务器繁忙，稍后再试");
return resultMap;
}
String error = responseBodyMap.get("error");
resultMap.put("success", "false");
resultMap.put("message", codeToMsg(error));
return resultMap;
} catch (Exception e) {
LOG.error("【认证系统】重置密码异常，手机号为【{}】", mobile);
e.printStackTrace();
resultMap.put("success", "false");
resultMap.put("message", "重置密码失败");
return resultMap;
}
return resultMap;
}
/**
* 错误码转信息
*
* @param code
* @return
*/
private static String codeToMsg(String code) {
Map<String, String> map = new HashMap<>();
map.put("token_blocked", "验证码获取频繁");
map.put("invalid_token", "验证码错误");
map.put("user_already_exist", "用户已存在");
map.put("invalid_password", "无效的密码");
map.put("password_no_change", "请不要与旧密码相同");
return map.getOrDefault(code, "服务器繁忙，稍后再试");
}
}
3360
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
