Java 源码
controller.java
/**
* @return com.ruoyi.framework.web.domain.AjaxResult
* @Author WangChangDian
* @Description //TODO 获取微信公号 JS-SDK 权限签名参数 （调取JS-SDK需要的参数）
* @Date 17:19 2022/4/7
* @Param []
**/
@GetMapping("/getJsApiSign")
@ResponseBody
public AjaxResult getJsApiSign() {
if (Constants.WX_JS_API_TICKET != null) {
Map<String, String> map = WeChatHandler.getJsApiSign("");
map.put("appId", Constants.WX_APP_Id);
return AjaxResult.success(map);
}
return AjaxResult.error();
}WeChatHandler.java
package com.ruoyi.project.utils.cdUtils.wxUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.ruoyi.project.utils.cdUtils.Constants;
import com.ruoyi.project.utils.cdUtils.http.RestTemplateUtils;
import org.springframework.http.ResponseEntity;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Formatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
* @Author 王昌典
* @Date 2019/7/17 19:10
* @Description
*/
public class WeChatHandler {
/**
* 组装 JS-SDK 权限签名参数
*
* @param url
* @return
*/
public static Map<String, String> getJsApiSign(String url) {
Map<String, String> ret = new HashMap<>();
String nonceStr = UUID.randomUUID().toString();
String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
String string1;
String signature = "";
//注意这里参数名必须全部小写，且必须有序
string1 = "jsapi_ticket=" + Constants.WX_JS_API_TICKET +
"&noncestr=" + nonceStr +
"×tamp=" + timestamp +
"&url=" + url;
try {
MessageDigest crypt = MessageDigest.getInstance("SHA-1");
crypt.reset();
crypt.update(string1.getBytes(StandardCharsets.UTF_8));
signature = byteToHex(crypt.digest());
ret.put("url", url);
ret.put("nonceStr", nonceStr);
ret.put("timestamp", timestamp);
ret.put("signature", signature);
} catch (Exception e) {
e.printStackTrace();
}
return ret;
}
/**
* 生成JS-SDK 权限签名
*
* @param hash
* @return
*/
private static String byteToHex(final byte[] hash) {
Formatter formatter = new Formatter();
for (byte b : hash) {
formatter.format("%02x", b);
}
String result = formatter.toString();
formatter.close();
return result;
}
/**
* 获取 ticket
*/
public static void getJsaApiTicket() {
for (int i = 0; i < 3; i++) {
ResponseEntity<String> entity = RestTemplateUtils.get(Constants.WX_AUTH_URL_ACCESS_TOKEN, String.class);
JSONObject accessToken = JSON.parseObject(entity.getBody());
if (accessToken != null && !accessToken.keySet().contains("errcode")) {
ResponseEntity<String> entity2 = RestTemplateUtils.get(Constants.WX_AUTH_URL_TICKET +
accessToken.getString("access_token"), String.class);
JSONObject json = JSON.parseObject(entity2.getBody());
if (json == null || !"ok".equals(json.getString("errmsg"))) {
Constants.WX_JS_API_TICKET = null;
} else {
Constants.WX_JS_API_TICKET = json.getString("ticket");
break;
}
}
}
if (Constants.WX_JS_API_TICKET == null) {
throw new RuntimeException("获取accessToken、ticket异常！\n请检查当前公众号《ip白名单》中是否包含此ip");
}
}
/**
* 获取微信 token
*
* @param code
* @return
*/
public static JSONObject getUserToken(String code) {
ResponseEntity<String> entity = RestTemplateUtils.get(String.format(Constants.WX_AUTH_URL_OPEN_ID, code),
String.class);
JSONObject json = JSONObject.parseObject(entity.getBody());
if (json == null || json.keySet().contains("errcode")) {
throw new RuntimeException("failed in retrieving userinfo:" + json.get("errmsg"));
}
return json;
}
/**
* 根据 token 获取微信信息
*
* @param accessToken
* @param openId
* @return
*/
public static Map<String, String> getUserInfo(String accessToken, String openId) {
ResponseEntity<String> entity = RestTemplateUtils.get(String.format(Constants.WX_AUTH_URL_USER_INFO,
accessToken, openId), String.class);
JSONObject json = JSON.parseObject(entity.getBody());
if (json == null || json.keySet().contains("errcode")) {
throw new RuntimeException("failed in retrieving userinfo:" + json.get("errmsg"));
}
String openid = json.getString("openid");
if (!openId.equalsIgnoreCase(openid)) {
throw new RuntimeException("retrived user is incorrect![" + openId + "] != [" + openid + "]");
}
Map<String, String> userInfo = new HashMap<>();
userInfo.put("headImgUrl", json.getString("headimgurl"));
return userInfo;
}
}
StartupRunner.java
package com.ruoyi.project.utils.runner;
import com.ruoyi.project.utils.cdUtils.wxUtils.WeChatHandler;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.util.Timer;
import java.util.TimerTask;
/**
* @Author 王昌典
* @Date 2019/7/3 17:41
* @Description
*/
@Component
public class StartupRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("系统运行了");
loadJsApiTicket();
}
/**
* 获取 ticket
*/
protected void loadJsApiTicket() {
Timer timer = new Timer(true);
timer.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
WeChatHandler.getJsaApiTicket();
}
}, 0, 7000 * 1000);//凭证有效时间，7200秒，在这个7200秒之前更新
}
}
Constants.java
package com.ruoyi.project.utils.cdUtils;
/**
* @Author 王昌典
* @Date 2019/7/3 15:32
* @Description
*/
public class Constants {
/**
* 域名地址，含http
*/
public static String API_URL;
public static String WX_APP_Id;
public static String WX_APP_SECRET;
public static String REDIRECT_URI;
static {
WX_APP_Id = SystemManager.getInstance().getProperty("weChat.appId");
WX_APP_SECRET = SystemManager.getInstance().getProperty("weChat.appSecret");
REDIRECT_URI = SystemManager.getInstance().getProperty("weChat.redirectUri");
API_URL = SystemManager.getInstance().getProperty("api.url");
}
/**
* 微信网页服务
* 获取jsapi_ticket
*/
public static String WX_JS_API_TICKET;
/**
* 微信认证URL
* 获取 access_token
*/
public static String WX_AUTH_URL_ACCESS_TOKEN = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=" + WX_APP_Id + "&secret=" + WX_APP_SECRET;
/**
* 微信认证URL
* 获取 ticket
*/
public static String WX_AUTH_URL_TICKET = "https://api.weixin.qq.com/cgi-bin/ticket/getticket?type=jsapi&access_token=";
/**
* 1、以snsapi_base为scope发起的网页授权，是用来获取进入页面的用户的openid的，
* 并且是静默授权并自动跳转到回调页的。用户感知的就是直接进入了回调页（往往是业务页面）
*
* 2、以snsapi_userinfo为scope发起的网页授权，是用来获取用户的基本信息的。
* 但这种授权需要用户手动同意，并且由于用户同意过，所以无须关注，就可在授权后获取该用户的基本信息。
*/
/**
* 微信认证URL 自动
* 参数：scope = snsapi_base
* 获取 code
*/
public static String WX_AUTH_URL_CODE_USER_INFO = "https://open.weixin.qq.com/connect/oauth2/authorize?appid=" + WX_APP_Id + "&redirect_uri=" + API_URL + REDIRECT_URI + "&response_type=code&scope=snsapi_base&state=STATE#wechat_redirect";
/**
* 微信认证URL 手动
* 参数：scope = snsapi_userinfo 回调weChatLogin
* 获取微信授权 code
*/
public static String WX_AUTH_URL_CODE_BASE = "https://open.weixin.qq.com/connect/oauth2/authorize?appid=" + WX_APP_Id + "&redirect_uri=" + API_URL + REDIRECT_URI + "&response_type=code&scope=snsapi_userinfo&state=STATE#wechat_redirect";
/**
* 登录授权 手动
* 参数：scope = snsapi_userinfo
* 获取微信授权 code
*/
public static String WX_AUTH_LOGIN_BASE = "https://open.weixin.qq.com/connect/oauth2/authorize?appid=" + WX_APP_Id + "&redirect_uri=" + API_URL + REDIRECT_URI + "&response_type=code&scope=snsapi_userinfo&state=STATE#wechat_redirect";
/**
* 微信认证URL
* 获取 open_id
*/
public static String WX_AUTH_URL_OPEN_ID = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=" + WX_APP_Id + "&secret=" + WX_APP_SECRET + "&code=%s&grant_type=authorization_code";
/**
* 微信认证URL
* 根据accessToken和openId 获取 用户信息
*/
public static final String WX_AUTH_URL_USER_INFO = "https://api.weixin.qq.com/sns/userinfo?access_token=%s&openid=%s&lang=zh_CN";
}
SystemManager.java
package com.ruoyi.project.utils.cdUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.Properties;
@Component
public class SystemManager {
private static final Logger logger = LoggerFactory.getLogger(SystemManager.class);
private static Properties p = new Properties();
private static SystemManager instance;
static {
try {
p.load(SystemManager.class.getResourceAsStream("/system.properties"));
logger.info(p.toString());
} catch (IOException e) {
logger.error(e.getMessage());
}
}
public static synchronized SystemManager getInstance(){
if(instance==null){
instance = new SystemManager();
}
return instance;
}
public String getProperty(String key){
return p.getProperty(key);
}
}
system.properties
# 域名
api.url=https://aidunet.cn/hunqingyun_api
#公众号
weChat.appId=wxd6b26d2a9156b1rf
weChat.appSecret=bc72c27e7d129d953ec2d7a797fc4575
#授权回调地址
weChat.redirectUri=/wx/wedding/user/loginRestTemplateUtils.java
package com.ruoyi.project.utils.cdUtils.http;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.RestTemplate;
import java.nio.charset.StandardCharsets;
import java.util.Map;
/**
* RestTemplate 远程调用工具类
*
* @author wcd
* @createDate 2019-02-08
*
*/
public class RestTemplateUtils {
private static final RestTemplate restTemplate = new RestTemplate();
// ----------------------------------GET-------------------------------------------------------
/**
* GET请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> get(String url, Class<T> responseType) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.getForEntity(url, responseType);
}
/**
* GET请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> get(String url, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.getForEntity(url, responseType, uriVariables);
}
/**
* GET请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> get(String url, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.getForEntity(url, responseType, uriVariables);
}
/**
* 带请求头的GET请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return get(url, httpHeaders, responseType, uriVariables);
}
/**
* 带请求头的GET请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<?> requestEntity = new HttpEntity<>(headers);
return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
}
/**
* 带请求头的GET请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return get(url, httpHeaders, responseType, uriVariables);
}
/**
* 带请求头的GET请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<?> requestEntity = new HttpEntity<>(headers);
return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
}
// ----------------------------------POST-------------------------------------------------------
/**
* POST请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @return
*/
public static <T> ResponseEntity<T> post(String url, Class<T> responseType) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType);
}
/**
* POST请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.postForEntity(url, requestBody, responseType);
}
/**
* POST请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
}
/**
* POST请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
}
/**
* 带请求头的POST请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return post(url, httpHeaders, requestBody, responseType, uriVariables);
}
/**
* 带请求头的POST请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
return post(url, requestEntity, responseType, uriVariables);
}
/**
* 带请求头的POST请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return post(url, httpHeaders, requestBody, responseType, uriVariables);
}
/**
* 带请求头的POST请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
return post(url, requestEntity, responseType, uriVariables);
}
/**
* 自定义请求头和请求体的POST请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
}
/**
* 自定义请求头和请求体的POST请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
}
// ----------------------------------PUT-------------------------------------------------------
/**
* PUT请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> put(String url, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return put(url, HttpEntity.EMPTY, responseType, uriVariables);
}
/**
* PUT请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
return put(url, requestEntity, responseType, uriVariables);
}
/**
* PUT请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
return put(url, requestEntity, responseType, uriVariables);
}
/**
* 带请求头的PUT请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return put(url, httpHeaders, requestBody, responseType, uriVariables);
}
/**
* 带请求头的PUT请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
return put(url, requestEntity, responseType, uriVariables);
}
/**
* 带请求头的PUT请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return put(url, httpHeaders, requestBody, responseType, uriVariables);
}
/**
* 带请求头的PUT请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
return put(url, requestEntity, responseType, uriVariables);
}
/**
* 自定义请求头和请求体的PUT请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
}
/**
* 自定义请求头和请求体的PUT请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
}
// ----------------------------------DELETE-------------------------------------------------------
/**
* DELETE请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
}
/**
* DELETE请求调用方式
*
* @param url 请求URL
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
}
/**
* DELETE请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
return delete(url, requestEntity, responseType, uriVariables);
}
/**
* DELETE请求调用方式
*
* @param url 请求URL
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
return delete(url, requestEntity, responseType, uriVariables);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return delete(url, httpHeaders, responseType, uriVariables);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
return delete(url, requestEntity, responseType, uriVariables);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return delete(url, httpHeaders, responseType, uriVariables);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
return delete(url, requestEntity, responseType, uriVariables);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return delete(url, httpHeaders, requestBody, responseType, uriVariables);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
return delete(url, requestEntity, responseType, uriVariables);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setAll(headers);
return delete(url, httpHeaders, requestBody, responseType, uriVariables);
}
/**
* 带请求头的DELETE请求调用方式
*
* @param url 请求URL
* @param headers 请求头参数
* @param requestBody 请求参数体
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
return delete(url, requestEntity, responseType, uriVariables);
}
/**
* 自定义请求头和请求体的DELETE请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
}
/**
* 自定义请求头和请求体的DELETE请求调用方式
*
* @param url 请求URL
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
}
// ----------------------------------通用方法-------------------------------------------------------
/**
* 通用调用方式
*
* @param url 请求URL
* @param method 请求方法类型
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，按顺序依次对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
}
/**
* 通用调用方式
*
* @param url 请求URL
* @param method 请求方法类型
* @param requestEntity 请求头和请求体封装对象
* @param responseType 返回对象类型
* @param uriVariables URL中的变量，与Map中的key对应
* @return ResponseEntity 响应对象封装类
*/
public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
}
/**
* 获取RestTemplate实例对象，可自由调用其方法
*
* @return RestTemplate实例对象
*/
public static RestTemplate getRestTemplate() {
restTemplate.getMessageConverters().set(1, new
StringHttpMessageConverter(StandardCharsets.UTF_8));
return restTemplate;
}
}uniapp
/* 微信端授权获取位置信息 */
getLocation() {
/* 获取公众号js-sdk调取凭证 */
this.$req({})
.get(this.$api.getJsApiSign, {})
.then(res => {
if (res.code === 200) {
const data = res.data
console.log("获取公众号js-sdk调取凭证:/n", {
...data
})
// 判断是否支持获取定位
jweixin.config({
debug: false, //开启debug模式.正式环境设置为false,测试环境设置为true
"appId": data.appId,
"timestamp": data.timestamp,
"nonceStr": data.nonceStr,
"signature": data.signature,
jsApiList: ["getLocation"] //根据需要看需要哪些SDK的功能
});
// sdk加载完成后执行
jweixin.ready(() => {
jweixin.checkJsApi({
jsApiList: [
'getLocation',
"scanQRCode",
'translateVoice'
],
success: (res) => {
console.log("jweixin.ready", res)
if (res.checkResult.getLocation == false) {
uni.showModal({
title: '微信版本低',
content: '你的微信版本太低，不支持微信JS接口，请升级到最新的微信版本！',
success: (res) => {
if (res.confirm) {
console.log('用户点击确定');
} else if (res.cancel) {
console.log('用户点击取消');
this.findPierList();
}
}
});
return;
}
}
});
jweixin.error((err) => {
console.error("接口调取失败", err)
});
// 获取位置
jweixin.getLocation({
type: 'gcj02',
success: (res) => {
console.log('jssdk获取的位置:', res.longitude, res.latitude)
uni.showModal({
title: '当前GPS坐标',
content: res.longitude + ';' + res.latitude,
});
},
cancel: (res) => {
console.error("您已禁止获取位置信息")
// alert('您已禁止获取位置信息')
}
});
});
}
})
.catch(err => {
})
.finally(() => {});
},
// 两点间距离lat1, lng1, lat2, lng2
findRemoving(lat1, lng1, lat2, lng2) {
// console.error("调试：", lat1, lng1, lat2, lng2)
// lat1 = 109.527052;
// lng1 = 18.219174
// lat2 = 109.4970752298832
// lng2 = 18.21394280706966
let radLat1 = (lat1 * Math.PI) / 180.0;
let radLat2 = (lat2 * Math.PI) / 180.0;
let a = radLat1 - radLat2;
let b = (lng1 * Math.PI) / 180.0 - (lng2 * Math.PI) / 180.0;
let s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) + Math.cos(radLat1) * Math.cos(radLat2) * Math
.pow(Math.sin(b / 2), 2)));
s = s * 6378.137; // EARTH_RADIUS;
s = Math.round(s * 10000) / 10000;
s = s * 1000;
if (isNaN(s)) {
return 0 + 'm';
}
if (s > 1000) {
// 大于1000米时
s = Math.floor((s / 1000) * 100) / 100;
s = s + 'km';
} else {
// 小于1000米直接返回
s = s + 'm';
}
return s;
},