yanlongqi/jhinno-openapi-java-sdk
1
0
Fork 0
mirror of https://github.com/yanlongqi/jhinno-openapi-java-sdk.git synced 2026-03-22 06:15:10 +08:00
Code Issues Packages Releases Wiki Activity

fix(认证): 新增AccessKey接口安全认证的方式

Browse Source
This commit is contained in:
lqyan
2024-07-24 16:35:44 +08:00
parent 40df7537d1
commit 0ac882f645
26 changed files with 830 additions and 519 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
jhinno-openapi-java-sdk/pom.xml
View File

@@ -5,7 +5,7 @@
<modelVersion>4.0.0</modelVersion>
<artifactId>jhinno-openapi-java-sdk</artifactId>
<version>1.0.2</version>
<version>2.0.2</version>
<packaging>jar</packaging>
<name>Jhinno OpenAPI SDK for Java</name>
<description>The Jhinno OpenAPI SDK for Java used for accessing Jhinno OpenApi Service</description>
@@ -63,12 +63,6 @@
<artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.25</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>

19
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/AuthType.java Normal file
View File

@@ -0,0 +1,19 @@
package com.jhinno.sdk.openapi;
/**
* 目前Appform的认证类型有两个，Token模式和AK/SK的模式。
* 推荐使用AK/SK的模式，Token模式后续将被弃用
*/
public enum AuthType {
/**
* Token模式
*/
TOKEN_MODE,
/**
* AK/SK模式
*/
ACCESS_SECRET_MODE,
}

67
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/CommonConstant.java
View File

@@ -16,18 +16,12 @@ public class CommonConstant {
*/
public static final String FAILED = "failed";
/**
* 默认的token有效时间（单位：分钟）
* AES获取Token格式
*/
public static final int DEFAULT_TOKEN_EFFECTIVE_TIME = 30;
public static final String TokenUserFormat = "%s,%s";
/**
* token 默认剩余时间
*/
public static final int DEFAULT_TOKEN_RESIDUE_TIME = 5;
/**
* 获取token时AES加密的默认key
*/
@@ -39,7 +33,60 @@ public class CommonConstant {
public static final String NORMAL_CHARACTER_COMMA = ",";
/**
* 是否使用服务器的时间
* 签名key
*/
public static final boolean DEFAULT_IS_USED_SERVER_TIME = false;
public static final String SIGNATURE = "signature";
/**
* 集成方Key
*/
public static final String ACCESS_KEY = "accessKey";
/**
* 用户名
*/
public static final String USERNAME = "username";
/**
* 时间戳
*/
public static final String CURRENT_TIME_MILLIS = "currentTimeMillis";
/**
* 签名加密格式
* <ul>
* <li> accessKey </li>
* <li> username </li>
* <li> currentTimeMillis </li>
* </ul>
*/
public static final String SIGNATURE_FORMAT = "#%s#%s#%s#";
/**
* HmacSHA256 算法
*/
public static final String HMAC_SHA_256_ALGORITHM = "HmacSHA256";
/**
* AES 算法
*/
public static final String AES_ALGORITHM = "AES";
/**
* AES ECB Padding
*/
public static final String AES_ECB_PADDING = "AES/ECB/PKCS5Padding";
/**
* 标准日期时间格式，精确到秒：yyyy-MM-dd HH:mm:ss
*/
public static final String NORM_DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
/**
* Rest请求JSON编码
*/
public static final String CONTENT_TYPE_APPLICATION_JSON = "application/json";
}

171
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/api/JHApiExecution.java
View File

@@ -1,17 +1,23 @@
package com.jhinno.sdk.openapi.api;
import cn.hutool.crypto.symmetric.AES;
import cn.hutool.http.ContentType;
import com.fasterxml.jackson.core.type.TypeReference;
import com.jhinno.sdk.openapi.ArgsException;
import com.jhinno.sdk.openapi.CommonConstant;
import com.jhinno.sdk.openapi.ServiceException;
import com.jhinno.sdk.openapi.*;
import com.jhinno.sdk.openapi.api.app.JHAppApiExecution;
import com.jhinno.sdk.openapi.api.auth.AuthPathConstant;
import com.jhinno.sdk.openapi.client.DefaultHttpClientConfig;
import com.jhinno.sdk.openapi.client.JHApiClient;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.lang3.StringUtils;
import com.jhinno.sdk.openapi.api.app.AppPathConstant;
import org.apache.http.entity.ContentType;
import javax.crypto.Cipher;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@@ -33,6 +39,8 @@ import java.util.concurrent.ConcurrentHashMap;
* @date 2024/1/30 19:39
* @see JHAppApiExecution
*/
@Data
@NoArgsConstructor
public class JHApiExecution {
/**
@@ -43,18 +51,39 @@ public class JHApiExecution {
/**
* token的超时时间
*/
private int tokenTimeout = CommonConstant.DEFAULT_TOKEN_EFFECTIVE_TIME;
private int tokenTimeout = DefaultHttpClientConfig.DEFAULT_TOKEN_EFFECTIVE_TIME;
/**
* token提前获取的时间
*/
private int tokenResidueTime = CommonConstant.DEFAULT_TOKEN_RESIDUE_TIME;
private int tokenResidueTime = DefaultHttpClientConfig.DEFAULT_TOKEN_RESIDUE_TIME;
/**
* 是否使用服务器时间，开启可能会导致请求过慢，但是不会太慢，默认token会有缓存
*/
private boolean isUsedServerTime = CommonConstant.DEFAULT_IS_USED_SERVER_TIME;
private boolean isUsedServerTime = DefaultHttpClientConfig.DEFAULT_IS_USED_SERVER_TIME;
/**
* 是否强制获取用户的token，默认{@link DefaultHttpClientConfig#DEFAULT_IS_FORCE_GET_TOKEN},
* 如果强制获取token，则每次请求都去获取token；
*/
private boolean isForceGetToken = DefaultHttpClientConfig.DEFAULT_IS_FORCE_GET_TOKEN;
/**
* 接口请求的认证类型
*/
private AuthType authType = AuthType.ACCESS_SECRET_MODE;
/**
* 访问密钥
*/
private String accessKey;
/**
* 访问密钥密码
*/
private String accessKeySecret;
/**
@@ -66,47 +95,12 @@ public class JHApiExecution {
this.jhApiClient = jhApiClient;
}
/**
* 用户令牌的缓存
*/
private static final Map<String, TokenInfo> TOKEN_INFO_MAP = new ConcurrentHashMap<>(20);
/**
* 设置在JHApiClient实例的实例
*
* @param jhApiClient 客户端实例
*/
public void setJHApiClient(JHApiClient jhApiClient) {
this.jhApiClient = jhApiClient;
}
/**
* 设置token超时的时间，单位：分钟
*
* @param tokenTimeout token的超时时间
*/
public void setTokenTimeout(int tokenTimeout) {
this.tokenTimeout = tokenTimeout;
}
/**
* 设置提前获取token的时间，单位：分钟
*
* @param tokenResidueTime 提前获取token的时间
*/
public void setTokenResidueTime(int tokenResidueTime) {
this.tokenResidueTime = tokenResidueTime;
}
/**
* 是否使用服务器时间
*/
public boolean isUsedServerTime() {
return isUsedServerTime;
}
/**
* 设置是否使用服务器时间
*
@@ -120,10 +114,9 @@ public class JHApiExecution {
* 获取用户的Token
*
* @param username 用户名
* @param isForce 是否强制获取toke
* @return 用户的token
*/
public String getToken(String username, boolean isForce) {
public String getToken(String username) {
if (StringUtils.isBlank(username)) {
throw new ArgsException("用户名称不能为空！");
}
@@ -131,14 +124,23 @@ public class JHApiExecution {
// 防止因为服务器时间的问题二导致token不可用，可以通过此配置提前获取token
int tokenEffectiveTime = (tokenTimeout - tokenResidueTime) * 60 * 1000;
// 如果是强制获取、用户令牌为空、用户令牌过期等，则获取令牌
if (isForce || tokenInfo == null || System.currentTimeMillis() - tokenInfo.getCurrentTimestamp() > tokenEffectiveTime) {
if (isForceGetToken || tokenInfo == null || System.currentTimeMillis() - tokenInfo.getCurrentTimestamp() > tokenEffectiveTime) {
Map<String, Object> params = new HashMap<>(2);
params.put("timeout", tokenTimeout);
long currentTimeMillis = isUsedServerTime ? jhApiClient.requestTimeMillis() : System.currentTimeMillis();
AES aes = new AES(CommonConstant.DEFAULT_AES_KEY.getBytes());
String base64 = aes.encryptBase64(String.format("%s,%s", username, currentTimeMillis));
params.put("username", base64);
String currentTimeMillis = getCurrentTimeMillis();
String beforeEncryption = String.format(CommonConstant.TokenUserFormat, username, currentTimeMillis);
try {
SecretKeySpec secretKey = new SecretKeySpec(CommonConstant.DEFAULT_AES_KEY.getBytes(StandardCharsets.UTF_8), CommonConstant.AES_ALGORITHM);
Cipher cipher = Cipher.getInstance(CommonConstant.AES_ECB_PADDING);
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] encryptBytes = cipher.doFinal(beforeEncryption.getBytes(StandardCharsets.UTF_8));
params.put("username", Base64.getEncoder().encodeToString(encryptBytes));
} catch (Exception e) {
throw new ClientException("AES加密失败，失败原因：" + e.getMessage(), e);
}
String url = JHApiClient.getUrl(AuthPathConstant.AUTH_TOKEN_PATH, params);
Map<String, String> token = get(url, new TypeReference<ResponseResult<Map<String, String>>>() {
});
@@ -151,14 +153,16 @@ public class JHApiExecution {
return tokenInfo.getToken();
}
/**
* 获取用户的Token，获取缓存，不强制获取
*
* @param username 用户名
* @return 用户的token
* @return
*/
public String getToken(String username) {
return getToken(username, false);
private String getCurrentTimeMillis() {
if (authType == AuthType.ACCESS_SECRET_MODE || !isUsedServerTime) {
return String.valueOf(System.currentTimeMillis());
}
// todo 获取服务器的时间
return "";
}
@@ -166,20 +170,57 @@ public class JHApiExecution {
* 构建一个带token的请求头
*
* @param username 用户名
* @param isContentType 是否携带默认的Content-type，默认为{@link ContentType#JSON}
* @param isContentType 是否携带默认的Content-type，默认为{@link ContentType#APPLICATION_JSON}
* @return 请求头
*/
protected Map<String, String> getHeaders(String username, boolean isContentType) {
Map<String, String> headers = new HashMap<>();
protected Map<String, Object> getHeaders(String username, boolean isContentType) {
Map<String, Object> headers = new HashMap<>();
// 默认请求json数据
if (isContentType) {
headers.put("Content-type", ContentType.JSON.getValue());
headers.put("Content-type", ContentType.APPLICATION_JSON.getMimeType());
}
if (authType == AuthType.ACCESS_SECRET_MODE) {
if (StringUtils.isBlank(accessKey)) {
throw new ClientException("AccessKey不能为空");
}
if (StringUtils.isBlank(accessKeySecret)) {
throw new ClientException("AccessKeySecret不能为空");
}
headers.put(CommonConstant.ACCESS_KEY, accessKey);
if (StringUtils.isBlank(username)) {
username = StringUtils.EMPTY;
}
headers.put(CommonConstant.USERNAME, username);
String currentTimeMillis = getCurrentTimeMillis();
headers.put(CommonConstant.CURRENT_TIME_MILLIS, currentTimeMillis);
headers.put(CommonConstant.SIGNATURE, getsSignature(username, currentTimeMillis));
} else if (authType == AuthType.TOKEN_MODE && StringUtils.isNotBlank(username)) {
headers.put("token", getToken(username));
}
return headers;
}
headers.put("token", getToken(username));
return headers;
/**
* 获取签名
*
* @param username 用户名
* @param currentTimeMillis 时间戳
* @return 签名
*/
public String getsSignature(String username, String currentTimeMillis) {
SecretKeySpec secretKey = new SecretKeySpec(accessKeySecret.getBytes(StandardCharsets.UTF_8), CommonConstant.HMAC_SHA_256_ALGORITHM);
try {
Mac mac = Mac.getInstance(CommonConstant.HMAC_SHA_256_ALGORITHM);
mac.init(secretKey);
String beforeSignature = String.format(CommonConstant.SIGNATURE_FORMAT, accessKey, username, currentTimeMillis);
byte[] digest = mac.doFinal(beforeSignature.getBytes(StandardCharsets.UTF_8));
return Hex.encodeHexString(digest);
} catch (Exception e) {
throw new ClientException("签名加密失败，失败信息：" + e.getMessage(), e);
}
}
/**
@@ -188,7 +229,7 @@ public class JHApiExecution {
* @param username 用户名
* @return 请求头
*/
protected Map<String, String> getHeaders(String username) {
protected Map<String, Object> getHeaders(String username) {
return getHeaders(username, true);
}
@@ -381,7 +422,7 @@ public class JHApiExecution {
/**
* 退出用户的登录，释放许可
* 退出用户的登录，释放许可，当用户退出登录后，建议清除用户的token信息
*
* @param username 用户名
*/

4
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/api/app/JHAppApiExecution.java
View File

@@ -1,6 +1,5 @@
package com.jhinno.sdk.openapi.api.app;
import cn.hutool.core.collection.CollectionUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import com.jhinno.sdk.openapi.ArgsException;
import com.jhinno.sdk.openapi.CommonConstant;
@@ -8,6 +7,8 @@ import com.jhinno.sdk.openapi.ServiceException;
import com.jhinno.sdk.openapi.api.JHApiExecution;
import com.jhinno.sdk.openapi.api.ResponseResult;
import com.jhinno.sdk.openapi.client.JHApiClient;
import com.jhinno.sdk.openapi.utils.CollectionUtil;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import java.util.HashMap;
@@ -20,6 +21,7 @@ import java.util.Map;
* @author yanlongqi
* @date 2024/2/1 16:26
*/
@NoArgsConstructor
public class JHAppApiExecution extends JHApiExecution {
/**

4
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/api/data/JHDataApiExecution.java
View File

@@ -1,6 +1,5 @@
package com.jhinno.sdk.openapi.api.data;
import cn.hutool.core.collection.CollectionUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import com.jhinno.sdk.openapi.ArgsException;
import com.jhinno.sdk.openapi.CommonConstant;
@@ -8,6 +7,8 @@ import com.jhinno.sdk.openapi.ServiceException;
import com.jhinno.sdk.openapi.api.JHApiExecution;
import com.jhinno.sdk.openapi.api.ResponseResult;
import com.jhinno.sdk.openapi.client.JHApiClient;
import com.jhinno.sdk.openapi.utils.CollectionUtil;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import java.util.Date;
@@ -21,6 +22,7 @@ import java.util.Map;
* @author yanlongqi
* @date 2024/2/4 17:09
*/
@NoArgsConstructor
public class JHDataApiExecution extends JHApiExecution {
/**

24
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/api/file/JHFileApiExecution.java
View File

@@ -1,6 +1,5 @@
package com.jhinno.sdk.openapi.api.file;
import cn.hutool.core.collection.CollectionUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import com.jhinno.sdk.openapi.ArgsException;
import com.jhinno.sdk.openapi.CommonConstant;
@@ -8,14 +7,11 @@ import com.jhinno.sdk.openapi.ServiceException;
import com.jhinno.sdk.openapi.api.JHApiExecution;
import com.jhinno.sdk.openapi.api.ResponseResult;
import com.jhinno.sdk.openapi.client.JHApiClient;
import com.jhinno.sdk.openapi.utils.CollectionUtil;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -26,6 +22,7 @@ import java.util.Map;
* @author yanlongqi
* @date 2024/2/4 18:58
*/
@NoArgsConstructor
public class JHFileApiExecution extends JHApiExecution {
public JHFileApiExecution(JHApiClient jhApiClient) {
@@ -189,17 +186,14 @@ public class JHFileApiExecution extends JHApiExecution {
if (StringUtils.isBlank(uploadPath)) {
throw new ArgsException("uploadPath是必填参数");
}
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
builder.setCharset(StandardCharsets.UTF_8);
builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
builder.addBinaryBody("file", is, ContentType.MULTIPART_FORM_DATA, fileName);
Map<String, Object> body = new HashMap<>(3);
if (isCover != null) {
builder.addTextBody("isCover", isCover.toString());
body.put("isCover", isCover);
}
builder.addTextBody("uploadPath", uploadPath);
HttpPost httpPost = new HttpPost(jhApiClient.getUrl(FilePathConstant.FILE_UPLOAD_PATH));
httpPost.setEntity(builder.build());
ResponseResult<Object> result = jhApiClient.request(httpPost, getHeaders(username, false), new TypeReference<ResponseResult<Object>>() {
body.put("uploadPath", uploadPath);
ResponseResult<Object> result = jhApiClient.upload(FilePathConstant.FILE_UPLOAD_PATH, "file", fileName, is, getHeaders(username, false), body, new TypeReference<ResponseResult<Object>>() {
});
if (StringUtils.equals(result.getResult(), CommonConstant.FAILED)) {
throw new ServiceException(FilePathConstant.FILE_UPLOAD_PATH, result.getCode(), result.getMessage());

11
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/api/job/JHJobApiExecution.java
View File

@@ -1,7 +1,5 @@
package com.jhinno.sdk.openapi.api.job;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.json.JSONUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import com.jhinno.sdk.openapi.ArgsException;
import com.jhinno.sdk.openapi.CommonConstant;
@@ -10,8 +8,10 @@ import com.jhinno.sdk.openapi.api.JHApiExecution;
import com.jhinno.sdk.openapi.api.ResponseResult;
import com.jhinno.sdk.openapi.api.file.FileInfo;
import com.jhinno.sdk.openapi.client.JHApiClient;
import com.jhinno.sdk.openapi.utils.JsonUtil;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import com.jhinno.sdk.openapi.utils.CollectionUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -20,6 +20,7 @@ import java.util.Map;
* @author yanlongqi
* @date 2024/2/5 18:44
*/
@NoArgsConstructor
public class JHJobApiExecution extends JHApiExecution {
/**
@@ -48,7 +49,7 @@ public class JHJobApiExecution extends JHApiExecution {
}
Map<String, Object> map = new HashMap<>(2);
map.put("appId", appId);
map.put("params", JSONUtil.toJsonStr(params));
map.put("params", JsonUtil.objectToString(params));
String path = JHApiClient.getUrl(JobPathConstant.JOB_SUBMIT_PATH, map);
List<Map<String, String>> result = post(path, username, new TypeReference<ResponseResult<List<Map<String, String>>>>() {
});
@@ -102,7 +103,7 @@ public class JHJobApiExecution extends JHApiExecution {
params.put("status", status.getStatus());
}
if (CollectionUtil.isNotEmpty(condition)) {
params.put("condition", JSONUtil.toJsonStr(params));
params.put("condition", JsonUtil.objectToString(params));
}
String path = JHApiClient.getUrl(JobPathConstant.JOB_PAGE_PATH, params);
return get(path, username, new TypeReference<ResponseResult<PageJobInfo>>() {

2
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/api/organization/JHDepartmentApiExecution.java
View File

@@ -5,6 +5,7 @@ import com.jhinno.sdk.openapi.ArgsException;
import com.jhinno.sdk.openapi.api.JHApiExecution;
import com.jhinno.sdk.openapi.api.ResponseResult;
import com.jhinno.sdk.openapi.client.JHApiClient;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import java.util.List;
@@ -18,6 +19,7 @@ import java.util.Map;
* @author yanlongqi
* @date 2024/2/6 17:37
*/
@NoArgsConstructor
public class JHDepartmentApiExecution extends JHApiExecution {
/**

2
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/api/organization/JHUserApiExecution.java
View File

@@ -6,6 +6,7 @@ import com.jhinno.sdk.openapi.api.JHApiExecution;
import com.jhinno.sdk.openapi.api.PageResult;
import com.jhinno.sdk.openapi.api.ResponseResult;
import com.jhinno.sdk.openapi.client.JHApiClient;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import java.util.HashMap;
@@ -19,6 +20,7 @@ import java.util.Map;
* @author yanlongqi
* @date 2024/2/6 17:37
*/
@NoArgsConstructor
public class JHUserApiExecution extends JHApiExecution {
/**
* 获取一个执行器的实例

24
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/client/DefaultHttpClientConfig.java
View File

@@ -16,7 +16,7 @@ public class DefaultHttpClientConfig {
/**
* 默认服务每次能并行接收的请求数量
*/
public static int MAX_PER_ROUT = 20;
public static int MAX_PER_ROUTE = 20;
/**
@@ -33,4 +33,26 @@ public class DefaultHttpClientConfig {
* 默认请求超时的时间(单位：毫秒)
*/
public static final int CONNECTION_REQUEST_TIMEOUT = 5000;
/**
* 是否使用服务器的时间
*/
public static final boolean DEFAULT_IS_USED_SERVER_TIME = false;
/**
* 默认不强制获取token
*/
public static final boolean DEFAULT_IS_FORCE_GET_TOKEN = false;
/**
* 默认的token有效时间（单位：分钟）
*/
public static final int DEFAULT_TOKEN_EFFECTIVE_TIME = 30;
/**
* token 默认剩余时间
*/
public static final int DEFAULT_TOKEN_RESIDUE_TIME = 5;
}

392
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/client/JHApiClient.java
View File

@@ -1,43 +1,21 @@
package com.jhinno.sdk.openapi.client;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DatePattern;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jhinno.sdk.openapi.ArgsException;
import com.jhinno.sdk.openapi.ClientErrorCode;
import com.jhinno.sdk.openapi.ClientException;
import com.jhinno.sdk.openapi.api.auth.AuthPathConstant;
import com.jhinno.sdk.openapi.CommonConstant;
import com.jhinno.sdk.openapi.api.ResponseResult;
import lombok.Data;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.config.RequestConfig;
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.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.ssl.SSLContextBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
@@ -53,274 +31,69 @@ import java.util.TimeZone;
public class JHApiClient {
/**
* &#x57FA;&#x7840;&#x7684;&#x8BF7;&#x6C42;URL&#x5730;&#x5740;
* 基础的请求URL地址
* <p>
* &#x5982;&#xFF1A;https://192.168.3.12/appform
* 如：https:// 192.168.3.12/appform
* </p>
*/
private String baseUrl;
/**
* 对象转换器
* 设置自定义的jackson序列化配置
*/
private ObjectMapper mapper;
/**
* HTTP的连接客户端
*/
private CloseableHttpClient closeableHttpClient;
/**
* 每次发送请求的配置，如果该配置未进行设置则走 {@link DefaultHttpClientConfig｝ 中的默认配置
* API HTTP 客户端
*/
private RequestConfig requestConfig;
private JHApiHttpClient apiHttpClient;
private int socketTimeout = DefaultHttpClientConfig.SOCKET_TIMEOUT;
private int connectTimeout = DefaultHttpClientConfig.CONNECT_TIMEOUT;
private int connectRequestTimeout = DefaultHttpClientConfig.CONNECTION_REQUEST_TIMEOUT;
private int maxTotal = DefaultHttpClientConfig.MAX_TOTAL;
private int maxPerRout = DefaultHttpClientConfig.MAX_PER_ROUT;
/**
* 初始化一个JHApiClient的实例，可使用自定义的客户端
*
* @param baseUrl 景行接口服务的基础地址
* @param closeableHttpClient 可关闭的HTTP客户端
*/
public JHApiClient(CloseableHttpClient closeableHttpClient, String baseUrl, int socketTimeout, int connectTimeout, int connectRequestTimeout) {
this.baseUrl = baseUrl.endsWith("/") ? baseUrl.substring(0, baseUrl.length() - 1) : baseUrl;
this.closeableHttpClient = closeableHttpClient;
this.socketTimeout = socketTimeout;
this.connectTimeout = connectTimeout;
this.connectRequestTimeout = connectRequestTimeout;
clientInit();
public JHApiClient(String baseUrl) {
if (StringUtils.isBlank(baseUrl)) {
throw new ClientException("服务器的BaseUrl不能为空！");
}
public JHApiClient() {
closeableHttpClient = createHttpClients(maxTotal, maxPerRout);
clientInit();
if (baseUrl.endsWith("/")) {
baseUrl = baseUrl.substring(0, baseUrl.length() - 1);
}
/**
* 初始化客户端
*/
public void clientInit(){
this.requestConfig = RequestConfig.custom()
.setSocketTimeout(socketTimeout)
.setConnectTimeout(connectTimeout)
.setConnectionRequestTimeout(connectRequestTimeout)
.build();
this.baseUrl = baseUrl;
mapper = new ObjectMapper();
mapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
mapper.setDateFormat(new SimpleDateFormat(DatePattern.NORM_DATETIME_PATTERN));
mapper.setDateFormat(new SimpleDateFormat(CommonConstant.NORM_DATETIME_PATTERN));
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
/**
* 通过最大连接数和服务每次能并行接收的请求数量构建一个JHApiClient实例
*
* @param maxTotal 最大连接数
* @param maxPerRout 服务每次能并行接收的请求数量
* @param baseUrl 景行接口服务的基础地址 如: http://192.168.3.4/appform
* @return JHApiClient的实例
*/
public static JHApiClient build(String baseUrl, int maxTotal, int maxPerRout, int socketTimeout, int connectTimeout, int connectRequestTimeout) {
return build(createHttpClients(maxTotal, maxPerRout), baseUrl, socketTimeout, connectTimeout, connectRequestTimeout);
}
/**
* 通过{@link DefaultHttpClientConfig｝默认配置的最大连接数和服务每次能并行接收的请求数量构建一个JHApiClient实例
* <p>
*
* @param baseUrl 景行接口服务的基础地址，如: http://192.168.3.4/appform
* @return JHApiClient的实例
*/
public static JHApiClient build(String baseUrl) {
CloseableHttpClient client = createHttpClients(com.jhinno.sdk.openapi.client.DefaultHttpClientConfig.MAX_TOTAL, com.jhinno.sdk.openapi.client.DefaultHttpClientConfig.MAX_PER_ROUT);
return build(client, baseUrl, com.jhinno.sdk.openapi.client.DefaultHttpClientConfig.SOCKET_TIMEOUT, com.jhinno.sdk.openapi.client.DefaultHttpClientConfig.CONNECT_TIMEOUT, com.jhinno.sdk.openapi.client.DefaultHttpClientConfig.CONNECTION_REQUEST_TIMEOUT);
}
/**
* 通过外部传入的{@link CloseableHttpClient｝构建一个请求客户端.
* <p>
*
* @param httpClient 请求连接池
* @param baseUrl 景行接口服务的基础地址
* @return JHApiClient的实例
*/
public static JHApiClient build(CloseableHttpClient httpClient, String baseUrl, int socketTimeout, int connectTimeout, int connectRequestTimeout) {
return new JHApiClient(httpClient, baseUrl, socketTimeout, connectTimeout, connectRequestTimeout);
}
/**
* 初始化一个HTTP客户端实例
*
* @param maxTotal 设置最大连接数
* @param maxPerRoute 服务每次能并行接收的请求数量
* @return 返回一个可关闭的HTTP客户端示例
*/
public static CloseableHttpClient createHttpClients(int maxTotal, int maxPerRoute) {
SSLContextBuilder builder = new SSLContextBuilder();
try {
builder.loadTrustMaterial(null, (x509Certificates, s) -> true);
SSLConnectionSocketFactory sslref = new SSLConnectionSocketFactory(builder.build(), NoopHostnameVerifier.INSTANCE);
Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create().register("http", new PlainConnectionSocketFactory()).register("https", sslref).build();
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
cm.setMaxTotal(maxTotal);
cm.setDefaultMaxPerRoute(maxPerRoute);
return HttpClients.custom().setSSLSocketFactory(sslref).setConnectionManager(cm).setConnectionManagerShared(true).build();
} catch (NoSuchAlgorithmException | KeyManagementException | KeyStoreException e) {
throw new ClientException(e.getMessage(), ClientErrorCode.SSL_EXCEPTION, e);
}
}
/**
* 关闭JHApiClient实例 (释放所有资源)
* 调用JHApiClient实例的shutdown() 后，JHApiClient实例不可用。
* 如果客户端不存在则不进行任何操作
*/
public void shutdown() {
try {
if (closeableHttpClient != null) {
closeableHttpClient.close();
}
} catch (IOException e) {
throw new ClientException("关闭JHApiClient失败", e);
}
}
/**
* 设置自定义的jackson序列化配置
*
* @param mapper 序列化器
*/
public void setMapper(ObjectMapper mapper) {
this.mapper = mapper;
}
/**
* <p>
* 设置一个HTTP请求的配置
* </p>
*
* <p>
* {@link JHApiClient｝ 默认只配置了 socket连接超时的时间(socketTimeout) 、连接超时的时间(connectTimeout)、
* 请求超时的时间(connectionRequestTimeout)这三项，其默认配置在{@link DefaultHttpClientConfig｝ 中。
* 如果你要自定义你自己的配置，则可以通过{@link HttpClients｝构建自己的RequestConfig来请求接口
* </p>
*
* @param requestConfig HTTP请求的配置
*/
public void setRequestConfig(RequestConfig requestConfig) {
this.requestConfig = requestConfig;
}
/**
* 原始发送请求
*
* @param httpRequest 请求体
* @param headers 请求头
* @return 响应体
*/
public HttpEntity request(HttpRequestBase httpRequest, Map<String, String> headers) {
if (requestConfig == null) {
throw new ClientException("请配置requestConfig");
}
if (httpRequest == null) {
throw new ClientException("httpRequest不能为空");
}
httpRequest.setConfig(requestConfig);
// 添加请求头
if (CollectionUtil.isNotEmpty(headers)) {
for (Map.Entry<String, String> entry : headers.entrySet()) {
httpRequest.setHeader(entry.getKey(), entry.getValue());
}
}
try {
HttpResponse response = closeableHttpClient.execute(httpRequest);
int statusCode = response.getStatusLine().getStatusCode();
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
httpRequest.releaseConnection();
throw new ClientException("发送HTTP请求失败，请求码：" + statusCode, ClientErrorCode.REQUEST_ERROR);
}
return response.getEntity();
} catch (IOException e) {
throw new ClientException(e.getMessage());
}
}
/**
* 请求服务器的时间戳
*
* @return 服务器的时间戳
*/
public Long requestTimeMillis() {
HttpGet httpGet = new HttpGet(getUrl(AuthPathConstant.PING));
httpGet.setConfig(requestConfig);
try {
HttpResponse response = closeableHttpClient.execute(httpGet);
Header header = response.getFirstHeader("Date");
if (header == null) {
return null;
}
String value = header.getValue();
if (StringUtils.isBlank(value)) {
return null;
}
return DatePattern.HTTP_DATETIME_FORMAT.parse(value).getTime();
} catch (IOException e) {
throw new ClientException(e.getMessage());
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
/**
* 发送请求
*
* @param httpRequest HttpRequestBase
* @param headers 请求头
* @param type 返回数据类型
* @param <T> 返回的数据类型
* @return 返回的接口数据
*/
public <T> T request(HttpRequestBase httpRequest, Map<String, String> headers, TypeReference<T> type) {
try {
InputStream content = request(httpRequest, headers).getContent();
return mapper.readValue(content, type);
} catch (IOException e) {
throw new ClientException(e.getMessage());
}
public void initDefaultApiClient() {
JHApiHttpClientImpl jhApiHttpClient = new JHApiHttpClientImpl();
jhApiHttpClient.init();
jhApiHttpClient.createHttpClients();
this.apiHttpClient = jhApiHttpClient;
}
/**
* 发送一个get请求
*
* @param path 接口地址
* @param path 接口路径
* @param headers 请求头
* @param type 请求返回值类型
* @param <T> t
* @return t
* @param type 返回数据类型
* @param <T> 返回数据类型
* @return 返回数据
*/
public <T> T get(String path, Map<String, String> headers, TypeReference<T> type) {
public <T> T get(String path, Map<String, Object> headers, TypeReference<T> type) {
if (StringUtils.isBlank(path)) {
throw new ArgsException("url不能为空");
}
HttpGet httpGet = new HttpGet(getUrl(path));
return request(httpGet, headers, type);
try {
InputStream content = apiHttpClient.get(getUrl(path), headers);
return mapper.readValue(content, type);
} catch (IOException e) {
throw new ClientException(e.getMessage());
}
}
/**
* 发起一个get请求
@@ -360,8 +133,8 @@ public class JHApiClient {
if (value instanceof String) {
urlBuilder.append(URLEncoder.encode((String) value, StandardCharsets.UTF_8.name()));
} else if (value instanceof Date) {
SimpleDateFormat format = new SimpleDateFormat(DatePattern.NORM_DATETIME_PATTERN);
urlBuilder.append(URLEncoder.encode(format.format(value), "utf-8"));
SimpleDateFormat format = new SimpleDateFormat(CommonConstant.NORM_DATETIME_PATTERN);
urlBuilder.append(URLEncoder.encode(format.format(value), StandardCharsets.UTF_8.name()));
} else {
urlBuilder.append(value);
}
@@ -396,18 +169,47 @@ public class JHApiClient {
* @param <K> k body的类型
* @return t
*/
public <T, K> T post(String path, K body, Map<String, String> headers, TypeReference<T> type) {
public <T, K> T post(String path, K body, Map<String, Object> headers, TypeReference<T> type) {
if (StringUtils.isBlank(path)) {
throw new ArgsException("path不能为空");
}
HttpPost httpPost = new HttpPost(getUrl(path));
try {
String bodyStr = null;
if (body != null) {
String bodyStr = mapper.writeValueAsString(body);
httpPost.setEntity(new StringEntity(bodyStr, "utf-8"));
bodyStr = mapper.writeValueAsString(body);
}
return request(httpPost, headers, type);
} catch (Exception e) {
InputStream content = apiHttpClient.post(getUrl(path), bodyStr, headers);
return mapper.readValue(content, type);
} catch (IOException e) {
throw new ClientException(e.getMessage());
}
}
/**
* 发起put请求
*
* @param path 请求地址
* @param params 请求参数
* @param body 请求体
* @param headers 请求头
* @param type 请求数据类型
* @param <T> t 返回的数据的类型
* @param <K> k body的类型
* @return 请求返回的数据
*/
public <T, K> T put(String path, Map<String, Object> params, K body, Map<String, Object> headers, TypeReference<T> type) {
if (StringUtils.isBlank(path)) {
throw new ArgsException("path不能为空");
}
try {
String bodyStr = null;
if (body != null) {
bodyStr = mapper.writeValueAsString(body);
}
InputStream content = apiHttpClient.put(getUrl(path), bodyStr, headers);
return mapper.readValue(content, type);
} catch (IOException e) {
throw new ClientException(e.getMessage());
}
}
@@ -424,20 +226,8 @@ public class JHApiClient {
* @param <K> k body的类型
* @return 请求返回的数据
*/
public <T, K> T put(String path, K body, Map<String, String> headers, TypeReference<T> type) {
if (StringUtils.isBlank(path)) {
throw new ArgsException("url不能为空");
}
HttpPut httpPost = new HttpPut(getUrl(path));
try {
if (body != null) {
String bodyStr = mapper.writeValueAsString(body);
httpPost.setEntity(new StringEntity(bodyStr, "utf-8"));
}
return request(httpPost, headers, type);
} catch (Exception e) {
throw new ClientException(e.getMessage());
}
public <T, K> T put(String path, K body, Map<String, Object> headers, TypeReference<T> type) {
return put(path, null, body, headers, type);
}
@@ -477,12 +267,16 @@ public class JHApiClient {
* @param <T> 响应数据类型
* @return 响应数据
*/
public <T> T delete(String path, Map<String, String> headers, TypeReference<T> type) {
public <T> T delete(String path, Map<String, Object> headers, TypeReference<T> type) {
if (StringUtils.isBlank(path)) {
throw new ArgsException("url不能为空");
throw new ArgsException("path不能为空");
}
try {
InputStream content = apiHttpClient.delete(getUrl(path), headers);
return mapper.readValue(content, type);
} catch (IOException e) {
throw new ClientException(e.getMessage());
}
HttpDelete httpDelete = new HttpDelete(getUrl(path));
return request(httpDelete, headers, type);
}
@@ -497,4 +291,32 @@ public class JHApiClient {
public <T> T delete(String path, TypeReference<T> type) {
return delete(path, null, type);
}
/**
* @param path 请求路径
* @param keyName 文件key
* @param fileName 文件名
* @param is 文件流
* @param headers 请求头
* @param body 请求体其他数据
* @param type 返回数据类型
* @return 请求类型
*/
public ResponseResult<Object> upload(String path,
String keyName,
String fileName,
InputStream is,
Map<String, Object> headers,
Map<String, Object> body,
TypeReference<ResponseResult<Object>> type) {
if (StringUtils.isBlank(path)) {
throw new ArgsException("path不能为空");
}
try {
InputStream content = apiHttpClient.upload(getUrl(path), keyName, fileName, is, body, headers);
return mapper.readValue(content, type);
} catch (IOException e) {
throw new ClientException(e.getMessage());
}
}
}

71
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/client/JHApiHttpClient.java Normal file
View File

@@ -0,0 +1,71 @@
package com.jhinno.sdk.openapi.client;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
/**
* 该接口用户实现发送HTTP请求的方法
*/
public interface JHApiHttpClient {
/**
* 发起一个get请求
*
* @param url 请求url
* @param headers 请求头
* @return 数据流
* @throws IOException io异常
*/
InputStream get(String url, Map<String, Object> headers) throws IOException;
/**
* 发起一个post请求
*
* @param url 请求url
* @param body 请求体
* @param headers 请求头
* @return 数据流
* @throws IOException io异常
*/
InputStream post(String url, String body, Map<String, Object> headers) throws IOException;
/**
* 发起一个put请求
*
* @param url 请求url
* @param body 请求体
* @param headers 请求头
* @return 数据流
* @throws IOException io异常
*/
InputStream put(String url, String body, Map<String, Object> headers) throws IOException;
/**
* 发起一个GET请求
*
* @param url 请求url
* @param headers 请求头
* @return 数据流
* @throws IOException io异常
*/
InputStream delete(String url, Map<String, Object> headers) throws IOException;
/**
* 文件上传
*
* @param url 请求url
* @param keyName 文件key
* @param is 文件流
* @param body 请求体
* @param headers 请求头
* @return 响应
* @throws IOException io异常
*/
InputStream upload(String url, String keyName, String fileName, InputStream is, Map<String, Object> body, Map<String, Object> headers) throws IOException;
}

207
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/client/JHApiHttpClientImpl.java Normal file
View File

@@ -0,0 +1,207 @@
package com.jhinno.sdk.openapi.client;
import com.jhinno.sdk.openapi.ClientErrorCode;
import com.jhinno.sdk.openapi.ClientException;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.config.RequestConfig;
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.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
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.ssl.SSLContextBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.Map;
@Data
@NoArgsConstructor
public class JHApiHttpClientImpl implements JHApiHttpClient {
/**
* HTTP的连接客户端
*/
private CloseableHttpClient closeableHttpClient;
/**
* <p>
* 每次发送请求的配置，如果该配置未进行设置则走 {@link DefaultHttpClientConfig｝ 中的默认配置
* </p>
*
* <p>
* {@link JHApiClient｝ 默认只配置了 socket连接超时的时间(socketTimeout) 、连接超时的时间(connectTimeout)、
* 请求超时的时间(connectionRequestTimeout)这三项，其默认配置在{@link DefaultHttpClientConfig｝ 中。
* 如果你要自定义你自己的配置，则可以通过{@link HttpClients ｝构建自己的RequestConfig来请求接口
* </p>
*
* @param requestConfig HTTP请求的配置
*/
private RequestConfig requestConfig;
/**
* Socket连接超时的时间(单位：毫秒，默认：{@link DefaultHttpClientConfig#SOCKET_TIMEOUT})
*/
private int socketTimeout = DefaultHttpClientConfig.SOCKET_TIMEOUT;
/**
* 连接超时的时间(单位：毫秒，默认：{@link DefaultHttpClientConfig#CONNECT_TIMEOUT})
*/
private int connectTimeout = DefaultHttpClientConfig.CONNECT_TIMEOUT;
/**
* 默认请求超时的时间(单位：毫秒，默认：{@link DefaultHttpClientConfig#CONNECTION_REQUEST_TIMEOUT})
*/
private int connectRequestTimeout = DefaultHttpClientConfig.CONNECTION_REQUEST_TIMEOUT;
/**
* 设置最大连接数(默认：{@link DefaultHttpClientConfig#MAX_TOTAL})
*/
private int maxTotal = DefaultHttpClientConfig.MAX_TOTAL;
/**
* 服务每次能并行接收的请求数量(默认：{@link DefaultHttpClientConfig#MAX_PER_ROUTE})
*/
private int maxPerRoute = DefaultHttpClientConfig.MAX_PER_ROUTE;
/**
* 初始化一个HTTP客户端实例
*
* @return 返回一个可关闭的HTTP客户端示例
*/
public void createHttpClients() {
SSLContextBuilder builder = new SSLContextBuilder();
try {
builder.loadTrustMaterial(null, (x509Certificates, s) -> true);
SSLConnectionSocketFactory sslref = new SSLConnectionSocketFactory(builder.build(), NoopHostnameVerifier.INSTANCE);
Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create().register("http", new PlainConnectionSocketFactory()).register("https", sslref).build();
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
cm.setMaxTotal(maxTotal);
cm.setDefaultMaxPerRoute(maxPerRoute);
closeableHttpClient = HttpClients.custom().setSSLSocketFactory(sslref).setConnectionManager(cm).setConnectionManagerShared(true).build();
} catch (NoSuchAlgorithmException | KeyManagementException | KeyStoreException e) {
throw new ClientException(e.getMessage(), ClientErrorCode.SSL_EXCEPTION, e);
}
}
/**
* 初始化客户端
*/
public void init() {
this.requestConfig = RequestConfig.custom()
.setSocketTimeout(socketTimeout)
.setConnectTimeout(connectTimeout)
.setConnectionRequestTimeout(connectRequestTimeout)
.build();
}
/**
* 原始发送请求
*
* @param httpRequest 请求体
* @param headers 请求头
* @return 响应体
*/
public HttpEntity request(HttpRequestBase httpRequest, Map<String, Object> headers) {
if (requestConfig == null) {
throw new ClientException("请配置requestConfig");
}
if (httpRequest == null) {
throw new ClientException("httpRequest不能为空");
}
httpRequest.setConfig(requestConfig);
// 添加请求头
if (headers != null && !headers.isEmpty()) {
for (Map.Entry<String, Object> entry : headers.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
if (value == null) {
continue;
}
httpRequest.setHeader(key, value.toString());
}
}
try {
HttpResponse response = closeableHttpClient.execute(httpRequest);
int statusCode = response.getStatusLine().getStatusCode();
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
httpRequest.releaseConnection();
throw new ClientException("发送HTTP请求失败，请求码：" + statusCode, ClientErrorCode.REQUEST_ERROR);
}
return response.getEntity();
} catch (IOException e) {
httpRequest.releaseConnection();
throw new ClientException(e.getMessage());
}
}
@Override
public InputStream get(String url, Map<String, Object> headers) throws IOException {
HttpGet httpGet = new HttpGet(url);
return request(httpGet, headers).getContent();
}
@Override
public InputStream post(String url, String body, Map<String, Object> headers) throws IOException {
HttpPost httpPost = new HttpPost(url);
if (StringUtils.isNotBlank(body)) {
httpPost.setEntity(new StringEntity(body, StandardCharsets.UTF_8));
}
return request(httpPost, headers).getContent();
}
@Override
public InputStream put(String url, String body, Map<String, Object> headers) throws IOException {
HttpPut httpPut = new HttpPut(url);
if (StringUtils.isNotBlank(body)) {
httpPut.setEntity(new StringEntity(body, StandardCharsets.UTF_8));
}
return request(httpPut, headers).getContent();
}
@Override
public InputStream delete(String url, Map<String, Object> headers) throws IOException {
HttpDelete httpDelete = new HttpDelete(url);
return request(httpDelete, headers).getContent();
}
@Override
public InputStream upload(String url, String keyName, String fileName, InputStream is, Map<String, Object> body, Map<String, Object> headers) throws IOException {
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
builder.setCharset(StandardCharsets.UTF_8);
builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
builder.addBinaryBody(keyName, is, ContentType.MULTIPART_FORM_DATA, fileName);
if (body != null && !body.isEmpty()) {
for (Map.Entry<String, Object> entry : body.entrySet()) {
builder.addTextBody(entry.getKey(), entry.getValue().toString());
}
}
HttpPost httpPost = new HttpPost(url);
httpPost.setEntity(builder.build());
return request(httpPost, headers).getContent();
}
}

48
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/utils/CollectionUtil.java Normal file
View File

@@ -0,0 +1,48 @@
package com.jhinno.sdk.openapi.utils;
import java.util.Collection;
import java.util.Map;
public class CollectionUtil {
/**
* Map是否为空
*
* @param map 集合
* @return 是否为空
*/
public static boolean isEmpty(Map<?, ?> map) {
return map == null || map.isEmpty();
}
/**
* Map是否为非空
*
* @param map 集合
* @return 是否为非空
*/
public static boolean isNotEmpty(Map<?, ?> map) {
return !isEmpty(map);
}
/**
* Collection是否为空
*
* @param collection 集合
* @return 是否为非空
*/
public static boolean isEmpty(Collection<?> collection) {
return collection == null || collection.isEmpty();
}
/**
* Collection是否为非空
*
* @param collection 集合
* @return 是否为非空
*/
public static boolean isNotEmpty(Collection<?> collection) {
return !isEmpty(collection);
}
}

54
jhinno-openapi-java-sdk/src/main/java/com/jhinno/sdk/openapi/utils/JsonUtil.java Normal file
View File

@@ -0,0 +1,54 @@
package com.jhinno.sdk.openapi.utils;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jhinno.sdk.openapi.CommonConstant;
import lombok.SneakyThrows;
import org.apache.commons.lang3.StringUtils;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.TimeZone;
public class JsonUtil {
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
static {
OBJECT_MAPPER.setTimeZone(TimeZone.getTimeZone("GMT+8"));
OBJECT_MAPPER.setDateFormat(new SimpleDateFormat(CommonConstant.NORM_DATETIME_PATTERN));
OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
@SneakyThrows
public static <T> T stringToObject(String str, Class<T> cls) {
if (StringUtils.isBlank(str)) {
return null;
}
return OBJECT_MAPPER.readValue(str, cls);
}
@SneakyThrows
public static <T> T stringToObject(String str, TypeReference<T> type) {
if (StringUtils.isBlank(str)) {
return null;
}
return OBJECT_MAPPER.readValue(str, type);
}
@SneakyThrows
public static <T> T isToObject(InputStream is, Class<T> cls) {
if (is == null) {
return null;
}
return OBJECT_MAPPER.readValue(is, cls);
}
@SneakyThrows
public static String objectToString(Object object) {
return OBJECT_MAPPER.writeValueAsString(object);
}
}

37
jhinno-openapi-java-sdk/src/test/java/com/jhinno/sdk/openapi/test/JHClientConfig.java
View File

@@ -1,7 +1,18 @@
package com.jhinno.sdk.openapi.test;
import com.jhinno.sdk.openapi.AuthType;
import com.jhinno.sdk.openapi.api.JHApiExecution;
import com.jhinno.sdk.openapi.api.app.JHAppApiExecution;
import com.jhinno.sdk.openapi.api.data.JHDataApiExecution;
import com.jhinno.sdk.openapi.api.file.JHFileApiExecution;
import com.jhinno.sdk.openapi.api.job.JHJobApiExecution;
import com.jhinno.sdk.openapi.api.organization.JHDepartmentApiExecution;
import com.jhinno.sdk.openapi.api.organization.JHUserApiExecution;
import com.jhinno.sdk.openapi.client.JHApiClient;
import java.util.HashMap;
import java.util.Map;
/**
* SDK Client 的配置
*
@@ -13,6 +24,30 @@ public class JHClientConfig {
/**
* 初始化JHApi客户端
*/
public static final JHApiClient client = JHApiClient.build("https://172.17.0.5/appform");
public static final JHApiClient client = new JHApiClient("https://172.17.0.5/appform");
public static final Map<Class<? extends JHApiExecution>, JHApiExecution> jhApiClientMap = new HashMap<>();
public static final String ACCESS_KEY = "3f03747f147942bd8debd81b6c9c6a80";
public static final String ACCESS_KEY_SECRET = "e0681859b91c499eb1d2c8e09cea3242";
static {
client.initDefaultApiClient();
jhApiClientMap.put(JHAppApiExecution.class, new JHAppApiExecution());
jhApiClientMap.put(JHDataApiExecution.class, new JHDataApiExecution());
jhApiClientMap.put(JHFileApiExecution.class, new JHFileApiExecution());
jhApiClientMap.put(JHJobApiExecution.class, new JHJobApiExecution());
jhApiClientMap.put(JHDepartmentApiExecution.class, new JHDepartmentApiExecution());
jhApiClientMap.put(JHUserApiExecution.class, new JHUserApiExecution());
jhApiClientMap.forEach((k, v) -> {
v.setJhApiClient(client);
v.setAuthType(AuthType.ACCESS_SECRET_MODE);
v.setAccessKey(ACCESS_KEY);
v.setAccessKeySecret(ACCESS_KEY_SECRET);
// v.setUsedServerTime(true);
});
}
}

10
jhinno-openapi-java-sdk/src/test/java/com/jhinno/sdk/openapi/test/app/AppApiTest.java
View File

@@ -1,6 +1,5 @@
package com.jhinno.sdk.openapi.test.app;
import cn.hutool.core.lang.ConsoleTable;
import com.jhinno.sdk.openapi.api.app.*;
import com.jhinno.sdk.openapi.test.JHClientConfig;
import org.junit.Test;
@@ -157,14 +156,7 @@ public class AppApiTest {
@Test
public void testGetAppList() {
List<AppInfo> appList = jhAppApiExecution.getAppList("jhadmin");
ConsoleTable consoleTable = ConsoleTable.create();
consoleTable.setSBCMode(false);
consoleTable.addHeader("id", "name", "type", "category", "protocol");
for (AppInfo appInfo : appList) {
consoleTable.addBody(appInfo.getId(), appInfo.getName(), appInfo.getType(), appInfo.getCategory(), appInfo.getProtocol());
}
consoleTable.print();
System.out.println(appList);
}

33
jhinno-openapi-java-sdk/src/test/java/com/jhinno/sdk/openapi/test/auth/AuthApiTest.java
View File

@@ -1,33 +0,0 @@
package com.jhinno.sdk.openapi.test.auth;
import com.jhinno.sdk.openapi.api.app.JHAppApiExecution;
import com.jhinno.sdk.openapi.test.JHClientConfig;
import org.junit.Test;
/**
* 鉴权相关测试累类
*
* @author yanlongqi
* @date 2024/2/1 18:06
*/
public class AuthApiTest {
JHAppApiExecution jhAppApiExecution = new JHAppApiExecution(JHClientConfig.client);
/**
* 测试获取token
*/
@Test
public void testGetToken() {
String token = jhAppApiExecution.getToken("jhadmin");
System.out.println("token:" + token);
}
/**
* 测试退出登录
*/
@Test
public void testLogout(){
jhAppApiExecution.logout("lqyan");
}
}

2
jhinno-openapi-java-sdk/src/test/java/com/jhinno/sdk/openapi/test/data/DataApiTest.java
View File

@@ -14,7 +14,7 @@ import java.util.Arrays;
*/
public class DataApiTest {
public static final JHDataApiExecution execution = new JHDataApiExecution(JHClientConfig.client);
public static final JHDataApiExecution execution = (JHDataApiExecution) JHClientConfig.jhApiClientMap.get(JHDataApiExecution.class);
/**
* 测试获取作业数据区目录列表

16
jhinno-openapi-java-sdk/src/test/java/com/jhinno/sdk/openapi/test/file/FileApiTest.java
View File

@@ -1,6 +1,6 @@
package com.jhinno.sdk.openapi.test.file;
import cn.hutool.core.lang.ConsoleTable;
import com.jhinno.sdk.openapi.api.file.FileInfo;
import com.jhinno.sdk.openapi.api.file.JHFileApiExecution;
import com.jhinno.sdk.openapi.test.JHClientConfig;
@@ -17,7 +17,7 @@ import java.util.List;
*/
public class FileApiTest {
private static final JHFileApiExecution execution = new JHFileApiExecution(JHClientConfig.client);
private static final JHFileApiExecution execution = (JHFileApiExecution) JHClientConfig.jhApiClientMap.get(JHFileApiExecution.class);;
/**
@@ -51,13 +51,7 @@ public class FileApiTest {
@Test
public void testGetFileList() {
List<FileInfo> fileList = execution.getFileList("jhadmin", "$HOME");
ConsoleTable consoleTable = ConsoleTable.create();
consoleTable.setSBCMode(false);
consoleTable.addHeader("fileName", "fileType", "owner", "read", "write", "execute", "path");
for (FileInfo fileInfo : fileList) {
consoleTable.addBody(fileInfo.getFileName(), fileInfo.getFileType(), fileInfo.getOwner(), fileInfo.getRead().toString(), fileInfo.getWrite().toString(), fileInfo.getExecute().toString(), fileInfo.getPath());
}
consoleTable.print();
System.out.println(fileList);
}
/**
@@ -92,9 +86,9 @@ public class FileApiTest {
*/
@Test
public void testUploadFile() throws IOException {
File file = new File("C:\\Users\\yanlongqi\\Desktop\\双色球.xls");
File file = new File("C:\\Users\\yanlongqi\\Desktop\\LdapAdminv1830.exe");
FileInputStream fileInputStream = new FileInputStream(file);
execution.uploadFile("jhadmin", fileInputStream, file.getName(), "$HOME/temp", true);
execution.uploadFile("jhadmin", fileInputStream, file.getName(), "$HOME", true);
}

4
jhinno-openapi-sdk-spring-boot-starter/pom.xml
View File

@@ -14,7 +14,7 @@
<parent>
<groupId>com.jhinno</groupId>
<artifactId>jhinno-openapi-java-sdk-parent</artifactId>
<version>1.0.2</version>
<version>2.0.2</version>
</parent>
@@ -22,7 +22,7 @@
<dependency>
<groupId>com.jhinno</groupId>
<artifactId>jhinno-openapi-java-sdk</artifactId>
<version>1.0.2</version>
<version>2.0.2</version>
</dependency>
<dependency>

23
jhinno-openapi-sdk-spring-boot-starter/src/main/java/com/jhinno/sdk/openapi/autoconfigure/JHOpenapiClientAutoConfigure.java
View File

@@ -1,6 +1,7 @@
package com.jhinno.sdk.openapi.autoconfigure;
import com.jhinno.sdk.openapi.client.JHApiClient;
import com.jhinno.sdk.openapi.client.JHApiHttpClientImpl;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
@@ -8,6 +9,7 @@ import org.springframework.context.annotation.Configuration;
/**
* openapi客户端自动配置
*
* @author yanlongqi
* @date 2024/6/4 16:01
*/
@@ -18,15 +20,18 @@ public class JHOpenapiClientAutoConfigure {
@Bean
@ConditionalOnMissingBean
public JHApiClient jhApiClient(JHOpenapiProperties properties){
return JHApiClient.build(
properties.getServerUrl(),
properties.getMaxTotal(),
properties.getMaxPerRout(),
properties.getSocketTimeout(),
properties.getConnectTimeout(),
properties.getConnectRequestTimeout()
);
public JHApiClient jhApiClient(JHOpenapiProperties properties) {
JHApiClient jhApiClient = new JHApiClient(properties.getServerUrl());
JHApiHttpClientImpl jhApiHttpClient = new JHApiHttpClientImpl();
jhApiHttpClient.setMaxPerRoute(properties.getMaxPerRout());
jhApiHttpClient.setSocketTimeout(properties.getSocketTimeout());
jhApiHttpClient.setMaxTotal(properties.getMaxTotal());
jhApiHttpClient.setConnectTimeout(properties.getConnectTimeout());
jhApiHttpClient.setConnectRequestTimeout(properties.getConnectRequestTimeout());
jhApiHttpClient.init();
jhApiHttpClient.createHttpClients();
jhApiClient.setApiHttpClient(jhApiHttpClient);
return jhApiClient;
}
}

76
jhinno-openapi-sdk-spring-boot-starter/src/main/java/com/jhinno/sdk/openapi/autoconfigure/JHOpenapiExecutionAutoconfigure.java
View File

@@ -12,6 +12,9 @@ import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.ArrayList;
import java.util.List;
/**
* openapi执行器自动配置
*
@@ -27,59 +30,24 @@ public class JHOpenapiExecutionAutoconfigure {
private final JHApiClient client;
@Bean
public JHAppApiExecution appApiExecution() {
JHAppApiExecution execution = new JHAppApiExecution(client);
execution.setTokenTimeout(properties.getTokenTimeout());
execution.setTokenResidueTime(properties.getTokenResidueTime());
execution.setUsedServerTime(properties.isUsedServerTime());
return execution;
}
@Bean
public JHDataApiExecution dataApiExecution() {
JHDataApiExecution execution = new JHDataApiExecution(client);
execution.setTokenTimeout(properties.getTokenTimeout());
execution.setTokenResidueTime(properties.getTokenResidueTime());
execution.setUsedServerTime(properties.isUsedServerTime());
return execution;
}
@Bean
public JHFileApiExecution fileApiExecution() {
JHFileApiExecution execution = new JHFileApiExecution(client);
execution.setTokenTimeout(properties.getTokenTimeout());
execution.setTokenResidueTime(properties.getTokenResidueTime());
execution.setUsedServerTime(properties.isUsedServerTime());
return execution;
}
@Bean
public JHJobApiExecution jobApiExecution() {
JHJobApiExecution execution = new JHJobApiExecution(client);
execution.setTokenTimeout(properties.getTokenTimeout());
execution.setTokenResidueTime(properties.getTokenResidueTime());
execution.setUsedServerTime(properties.isUsedServerTime());
return execution;
}
@Bean
public JHDepartmentApiExecution departmentApiExecution() {
JHDepartmentApiExecution execution = new JHDepartmentApiExecution(client);
execution.setTokenTimeout(properties.getTokenTimeout());
execution.setTokenResidueTime(properties.getTokenResidueTime());
execution.setUsedServerTime(properties.isUsedServerTime());
return execution;
}
@Bean
public JHUserApiExecution userApiExecution() {
JHUserApiExecution execution = new JHUserApiExecution(client);
execution.setTokenTimeout(properties.getTokenTimeout());
execution.setTokenResidueTime(properties.getTokenResidueTime());
execution.setUsedServerTime(properties.isUsedServerTime());
return execution;
public List<JHApiExecution> ApiExecution() {
List<JHApiExecution> executions = new ArrayList<>();
executions.add(new JHAppApiExecution());
executions.add(new JHDataApiExecution());
executions.add(new JHFileApiExecution());
executions.add(new JHJobApiExecution());
executions.add(new JHDepartmentApiExecution());
executions.add(new JHUserApiExecution());
executions.forEach(t -> {
t.setJhApiClient(client);
t.setForceGetToken(properties.isForceGetToken());
t.setAuthType(properties.getAuthType());
t.setAccessKey(properties.getAccessKey());
t.setAccessKeySecret(properties.getAccessKeySecret());
t.setTokenTimeout(properties.getTokenTimeout());
t.setTokenResidueTime(properties.getTokenResidueTime());
t.setUsedServerTime(properties.isUsedServerTime());
});
return executions;
}
}

34
jhinno-openapi-sdk-spring-boot-starter/src/main/java/com/jhinno/sdk/openapi/autoconfigure/JHOpenapiProperties.java
View File

@@ -1,6 +1,6 @@
package com.jhinno.sdk.openapi.autoconfigure;
import com.jhinno.sdk.openapi.CommonConstant;
import com.jhinno.sdk.openapi.AuthType;
import com.jhinno.sdk.openapi.client.DefaultHttpClientConfig;
import com.jhinno.sdk.openapi.constant.CommonConstants;
import lombok.Data;
@@ -26,9 +26,9 @@ public class JHOpenapiProperties {
/**
* 设置服务每次能并行接收的请求数量，默认{@link DefaultHttpClientConfig#MAX_PER_ROUT}
* 设置服务每次能并行接收的请求数量，默认{@link DefaultHttpClientConfig#MAX_PER_ROUTE}
*/
private int maxPerRout = DefaultHttpClientConfig.MAX_PER_ROUT;
private int maxPerRout = DefaultHttpClientConfig.MAX_PER_ROUTE;
/**
* 设置服务socket连接超时的时间(单位：毫秒)，默认{@link DefaultHttpClientConfig#SOCKET_TIMEOUT}
@@ -50,16 +50,38 @@ public class JHOpenapiProperties {
/**
* token的超时时间（单位：分钟）
*/
private int tokenTimeout = CommonConstant.DEFAULT_TOKEN_EFFECTIVE_TIME;
private int tokenTimeout = DefaultHttpClientConfig.DEFAULT_TOKEN_EFFECTIVE_TIME;
/**
* token提前获取的时间（单位：分钟）
*/
private int tokenResidueTime = CommonConstant.DEFAULT_TOKEN_RESIDUE_TIME;
private int tokenResidueTime = DefaultHttpClientConfig.DEFAULT_TOKEN_RESIDUE_TIME;
/**
* 是否使用服务器时间
*/
private boolean usedServerTime = CommonConstant.DEFAULT_IS_USED_SERVER_TIME;
private boolean usedServerTime = DefaultHttpClientConfig.DEFAULT_IS_USED_SERVER_TIME;
/**
* 是否强制获取用户的token，默认{@link DefaultHttpClientConfig#DEFAULT_IS_FORCE_GET_TOKEN},
* 如果强制获取token，则每次请求都去获取token；
*/
private boolean isForceGetToken = DefaultHttpClientConfig.DEFAULT_IS_FORCE_GET_TOKEN;
/**
* 接口请求的认证类型
*/
private AuthType authType = AuthType.ACCESS_SECRET_MODE;
/**
* 访问密钥
*/
private String accessKey;
/**
* 访问密钥密码
*/
private String accessKeySecret;
}

2
pom.xml
View File

@@ -6,7 +6,7 @@
<groupId>com.jhinno</groupId>
<artifactId>jhinno-openapi-java-sdk-parent</artifactId>
<version>1.0.2</version>
<version>2.0.2</version>
<packaging>pom</packaging>
<name>Jhinno OpenAPI SDK for Java parent</name>
<description>The Jhinno OpenAPI SDK for Java used for accessing Jhinno OpenApi Service</description>