Skip to content

J
jiwei-api
Commit 5202f30d authored by matianhao's avatar matianhao
Browse files
Options

[鸿程接口] <add> 浙江杭州规划和自然资源局不动产权属查询

parent a1b6e8e7
Hide whitespace changes
Inline Side-by-side
Showing with 1049 additions and 1 deletion
pom.xml
View file @ 5202f30d
......@@ -99,6 +99,17 @@
<version>2.6</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.11</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.module</groupId>
<artifactId>jackson-module-jaxb-annotations</artifactId>
<version>2.10.2</version>
</dependency>
<dependency>
<groupId>org.dom4j</groupId>
<artifactId>dom4j</artifactId>
......
src/main/java/com/mth/requestsecret/controller/HongChengController.java 0 → 100644
View file @ 5202f30d
package com.mth.requestsecret.controller;
import com.google.common.collect.Lists;
import com.mth.requestsecret.service.RestTemplateService;
import com.mth.requestsecret.util.DSLUtils;
import com.mth.requestsecret.vo.hongcheng.HongChengUser;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
* @author MaTianHao
* @date 2021/3/16
*/
@RestController
@Slf4j
public class HongChengController {
@Autowired
private RestTemplateService restTemplateService;
/**
* 浙江杭州规划和自然资源局不动产权属查询
*
* @param user
* @return
*/
@PostMapping("/realEstateOwnership")
public ResponseEntity realEstateOwnership(HongChengUser user) throws UnsupportedEncodingException {
// api签名
String apiMethod = "30160300772/20210308111381091663091696";
// api参数
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("timestamp", DSLUtils.dateToLong(new Date()) + "");
// 查档编号，自定义流水号，例：Q20200610-00001
paramMap.put("cdbh", "Q20200610-00001");
// 行政区编码，例：330101
paramMap.put("xzqbm", "330101");
// 是否启用全大市查询 1:是 0:否
paramMap.put("isAllCity", "1");
// 是否查询限制信息 1:是 0:否
paramMap.put("isShowXzxx", "1");
// 是否启用电子签章 1:启用 0:不启用
paramMap.put("qyca", "0");
// 生成的pdf的说明一栏文字
paramMap.put("sm", "");
// 查询范围
paramMap.put("cxfw", "");
// 查档用途
paramMap.put("cdyt", "无房证明");
// 机构名称
paramMap.put("jgmc", "");
// 背景水印
paramMap.put("bjsy", "");
// 查询标题
paramMap.put("cxbt", "不动产登记信息查询记录");
// 姓名，证件号
paramMap.put("querymanList", Lists.newArrayList(user));
return restTemplateService.hongChengSendRequest(paramMap, apiMethod);
}
}
src/main/java/com/mth/requestsecret/service/RestTemplateService.java
View file @ 5202f30d
......@@ -13,6 +13,8 @@ import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
......@@ -70,9 +72,21 @@ public class RestTemplateService {
/**
* 资产资源接口地址
*/
@Value(("${zczy.address}"))
@Value("${zczy.address}")
private String zczyAddress;
/**
* 鸿程相关
*/
@Value("${hongcheng.address}")
private String hongchengAddress;
@Value("${hongcheng.userId}")
private String hongchengUserId;
@Value("${hongcheng.appSecret}")
private String hongchengAppSecret;
@Value("${hongcheng.priviteKey}")
private String hongchengPriviteKey;
/**
* 瑞成平台接口发送请求
*
......@@ -368,4 +382,43 @@ public class RestTemplateService {
.header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
.body(decryptStr);
}
/**
* 鸿程 浙江杭州规划和自然资源局不动产权属查询
* @param paramMap
* @param apiMethod
*/
public ResponseEntity hongChengSendRequest(Map<String, Object> paramMap, String apiMethod) throws UnsupportedEncodingException {
String url = hongchengAddress + apiMethod;
String jsonParam = JsonMapper.toJsonString(paramMap);
jsonParam = URLEncoder.encode(jsonParam, "UTF-8");
// 私钥加密参数
String encryptParam = RsaUtil.encryptByPrivateKey(hongchengPriviteKey, jsonParam);
// 生成数字签名
String sign = RsaUtil.sign(hongchengPriviteKey, encryptParam);
// 构建请求头
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
body.add("appSecret", hongchengAppSecret);
body.add("userId", hongchengUserId);
body.add("encryptParam", encryptParam);
body.add("sign", sign);
HttpEntity httpEntity = new HttpEntity<>(body, headers);
log.info("不动产权属查询api：{}", apiMethod);
log.info("api url：{}", url);
log.info("原参数：{}", paramMap);
log.info("加密参数encryptParam：{}", encryptParam);
log.info("签名sign：{}", sign);
// 发送请求
ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.POST, httpEntity, String.class);
log.info("api response：{}", responseEntity);
return responseEntity;
}
}
\ No newline at end of file
src/main/java/com/mth/requestsecret/util/JsonMapper.java 0 → 100644
View file @ 5202f30d
package com.mth.requestsecret.util;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser.Feature;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.util.JSONPObject;
import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
/**
* 简单封装Jackson，实现JSON String<->Java Object的Mapper.
* 封装不同的输出风格, 使用不同的builder函数创建实例.
* @author ThinkGem
* @version 2013-11-15
*/
public class JsonMapper extends ObjectMapper {
private static final long serialVersionUID = 1L;
private static Logger logger = LoggerFactory.getLogger(JsonMapper.class);
private static JsonMapper mapper;
public JsonMapper() {
this(Include.ALWAYS); //修改这里控制把对象转换成json数组，不管对象属性有没有值，都创建节点
}
public JsonMapper(Include include) {
// 设置输出时包含属性的风格
if (include != null) {
this.setSerializationInclusion(include);
}
// 允许单引号、允许不带引号的字段名称
this.enableSimple();
// 设置输入时忽略在JSON字符串中存在但Java对象实际没有的属性
this.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
// 空值处理为空串
this.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>(){
@Override
public void serialize(Object value, JsonGenerator jgen,
SerializerProvider provider) throws IOException,
JsonProcessingException {
jgen.writeString("");
}
});
// 进行HTML解码。
this.registerModule(new SimpleModule().addSerializer(String.class, new JsonSerializer<String>(){
@Override
public void serialize(String value, JsonGenerator jgen,
SerializerProvider provider) throws IOException,
JsonProcessingException {
jgen.writeString(StringEscapeUtils.unescapeHtml4(value));
}
}));
// 设置时区
this.setTimeZone(TimeZone.getDefault());//getTimeZone("GMT+8:00")
}
/**
* 创建只输出非Null且非Empty(如List.isEmpty)的属性到Json字符串的Mapper,建议在外部接口中使用.
*/
public static JsonMapper getInstance() {
if (mapper == null){
mapper = new JsonMapper().enableSimple();
}
return mapper;
}
/**
* 创建只输出初始值被改变的属性到Json字符串的Mapper, 最节约的存储方式，建议在内部接口中使用。
*/
public static JsonMapper nonDefaultMapper() {
if (mapper == null){
mapper = new JsonMapper(Include.NON_DEFAULT);
}
return mapper;
}
/**
* Object可以是POJO，也可以是Collection或数组。
* 如果对象为Null, 返回"null".
* 如果集合为空集合, 返回"[]".
*/
public String toJson(Object object) {
try {
return this.writeValueAsString(object);
} catch (IOException e) {
logger.warn("write to json string error:" + object, e);
return null;
}
}
/**
* 反序列化POJO或简单Collection如List<String>.
*
* 如果JSON字符串为Null或"null"字符串, 返回Null.
* 如果JSON字符串为"[]", 返回空集合.
*
* 如需反序列化复杂Collection如List<MyBean>, 请使用fromJson(String,JavaType)
* @see #fromJson(String, JavaType)
*/
public <T> T fromJson(String jsonString, Class<T> clazz) {
if (StringUtils.isEmpty(jsonString)) {
return null;
}
try {
return this.readValue(jsonString, clazz);
} catch (IOException e) {
logger.warn("parse json string error:" + jsonString, e);
return null;
}
}
/**
* 反序列化复杂Collection如List<Bean>, 先使用函數createCollectionType构造类型,然后调用本函数.
* @see #createCollectionType(Class, Class...)
*/
@SuppressWarnings("unchecked")
public <T> T fromJson(String jsonString, JavaType javaType) {
if (StringUtils.isEmpty(jsonString)) {
return null;
}
try {
return (T) this.readValue(jsonString, javaType);
} catch (IOException e) {
logger.warn("parse json string error:" + jsonString, e);
return null;
}
}
/**
* 構造泛型的Collection Type如:
* ArrayList<MyBean>, 则调用constructCollectionType(ArrayList.class,MyBean.class)
* HashMap<String,MyBean>, 则调用(HashMap.class,String.class, MyBean.class)
*/
public JavaType createCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
return this.getTypeFactory().constructParametricType(collectionClass, elementClasses);
}
/**
* 當JSON裡只含有Bean的部分屬性時，更新一個已存在Bean，只覆蓋該部分的屬性.
*/
@SuppressWarnings("unchecked")
public <T> T update(String jsonString, T object) {
try {
return (T) this.readerForUpdating(object).readValue(jsonString);
} catch (JsonProcessingException e) {
logger.warn("update json string:" + jsonString + " to object:" + object + " error.", e);
} catch (IOException e) {
logger.warn("update json string:" + jsonString + " to object:" + object + " error.", e);
}
return null;
}
/**
* 輸出JSONP格式數據.
*/
public String toJsonP(String functionName, Object object) {
return toJson(new JSONPObject(functionName, object));
}
/**
* 設定是否使用Enum的toString函數來讀寫Enum,
* 為False時時使用Enum的name()函數來讀寫Enum, 默認為False.
* 注意本函數一定要在Mapper創建後, 所有的讀寫動作之前調用.
*/
public JsonMapper enableEnumUseToString() {
this.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
this.enable(DeserializationFeature.READ_ENUMS_USING_TO_STRING);
return this;
}
/**
* 支持使用Jaxb的Annotation，使得POJO上的annotation不用与Jackson耦合。
* 默认会先查找jaxb的annotation，如果找不到再找jackson的。
*/
public JsonMapper enableJaxbAnnotation() {
JaxbAnnotationModule module = new JaxbAnnotationModule();
this.registerModule(module);
return this;
}
/**
* 允许单引号
* 允许不带引号的字段名称
*/
public JsonMapper enableSimple() {
this.configure(Feature.ALLOW_SINGLE_QUOTES, true);
this.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
return this;
}
/**
* 取出Mapper做进一步的设置或使用其他序列化API.
*/
public ObjectMapper getMapper() {
return this;
}
/**
* 对象转换为JSON字符串
* @param object
* @return
*/
public static String toJsonString(Object object){
return JsonMapper.getInstance().toJson(object);
}
/**
* JSON字符串转换为对象
* @param jsonString
* @param clazz
* @return
*/
public static Object fromJsonString(String jsonString, Class<?> clazz){
return JsonMapper.getInstance().fromJson(jsonString, clazz);
}
/**
* 测试
*/
public static void main(String[] args) {
List<Map<String, Object>> list = Lists.newArrayList();
Map<String, Object> map = Maps.newHashMap();
map.put("id", 1);
map.put("pId", -1);
map.put("name", "根节点");
list.add(map);
map = Maps.newHashMap();
map.put("id", 2);
map.put("pId", 1);
map.put("name", "你好");
map.put("open", true);
list.add(map);
//String json = JsonMapper.getInstance().toJson(list);
//System.out.println(json);
Map<String, Object> map2 = Maps.newHashMap();
map2.put("id", 2);
map2.put("pId", 1);
map2.put("name", "你好");
map2.put("open", true);
String json2 = JsonMapper.getInstance().toJson(map2);
JavaType javaType = JsonMapper.getInstance().createCollectionType(
Map.class, String.class, Object.class);
Map<String, Object> map3 = JsonMapper.getInstance().fromJson(json2,
javaType);
System.out.println(map3.toString());
}
}
src/main/java/com/mth/requestsecret/util/RsaUtil.java 0 → 100644
View file @ 5202f30d
package com.mth.requestsecret.util;
/**
* Created by huangxp on 2017/8/15 0015.
*/
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class RsaUtil {
/**
* 定义加密方式
*/
private final static String KEY_RSA = "RSA";
/**
* 定义签名算法
*/
private final static String KEY_RSA_SIGNATURE = "MD5withRSA";
/**
* 定义公钥算法
*/
// private final static String KEY_RSA_PUBLICKEY = "RSAPublicKey";
private final static String KEY_RSA_PUBLICKEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCXuIlt/WT+G630oWjQbpKCEtSvFhjcfUf4gEQHxG468/6aT9vpEmtFfosWywGolQgCwMo8v3f7RyMBCJZ1fMZ3opX9yntklS5Zv8VjWwW2dzLPneko8XryiroNVqI6DXbgqj8OqOHTj8r9XNcA4MOHrWr+7tGF+fF7QVozmi7ALwIDAQAB";
/**
* 定义私钥算法
*/
// private final static String KEY_RSA_PRIVATEKEY = "RSAPrivateKey";
private final static String KEY_RSA_PRIVATEKEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJe4iW39ZP4brfShaNBukoIS1K8WGNx9R/iARAfEbjrz/ppP2+kSa0V+ixbLAaiVCALAyjy/d/tHIwEIlnV8xneilf3Ke2SVLlm/xWNbBbZ3Ms+d6SjxevKKug1WojoNduCqPw6o4dOPyv1c1wDgw4etav7u0YX58XtBWjOaLsAvAgMBAAECgYBAjN/TrwqH3mjterroaxLkSnS4pVMghCDZxmCrWVR4upSpPK7Yg+Cl6Yftw6NKAVYuLa4dmGzIuORYrTmudM7PLCzrjNrfnKtoMf0t3TuvJu4dDxIL+aFbRGyIXMXd7izW1eBBdkaclO7Kt+21t/N407BNJFBz8aPiiREqw7JgIQJBAP/CN4hiRLyL4EKgNzi+HdDjtkA4N7OKTdYWvgQRx5k1cZRw9yiSPSwyvD4k50xGK6gGHMUhFj6KwCsDrbQj0/8CQQCX3TAOM7V8aLwv0Ujw18sDHphEYwMAW8etzLzL7b/Xnezqm0eiK6mjFrEymL6f8jOj/UQHbbkr+UxYA5TYzVPRAkBuPu/lMEbk536h+aIUKY98rcuv3wvTrrhioqcB5hAd8LWnARLpQDByTuRp/UpezJig8xGPv/VwvCqd4BYOYqtNAkAtM74hDA0iCb6x8PZoEaMwu4ORH3N+QNNPjRhJDuxCTpR9RFjvEVX94DxAFizvSNVMI4+DMoqiZyLtM6uzWHJxAkEAtpWQPLmFBYACeyuuU66M4TkPXoCLNsSgl0Gi2WBLZQTccbnVIacJZ+bIiMTZItZbiUjfVeAoDBmcU+yMmYo0kg==";
/**
* RSA最大加密明文大小
*/
private static final int MAX_ENCRYPT_BLOCK = 117;
/**
* RSA最大解密密文大小
*/
private static final int MAX_DECRYPT_BLOCK = 128;
private RsaUtil() {
}
/**
* 创建密钥
*
* @return
*/
public static Map<String, Object> generateKey() {
Map<String, Object> map = null;
try {
KeyPairGenerator generator = KeyPairGenerator.getInstance(KEY_RSA);
generator.initialize(1024);
KeyPair keyPair = generator.generateKeyPair();
// 公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
// 私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
// 将密钥封装为map
map = new HashMap<>(2);
map.put(KEY_RSA_PUBLICKEY, publicKey);
map.put(KEY_RSA_PRIVATEKEY, privateKey);
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
}
return map;
}
/**
* 用私钥对信息生成数字签名
*
* @param data 加密数据
* @param privateKey 私钥
* @return
*/
public static String sign(String privateKey, byte[] data) {
String str = "";
try {
// 解密由base64编码的私钥
byte[] bytes = decryptBase64(privateKey);
// 构造PKCS8EncodedKeySpec对象
PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(bytes);
// 指定的加密算法
KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
// 取私钥对象
PrivateKey key = factory.generatePrivate(pkcs);
// 用私钥对信息生成数字签名
Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
signature.initSign(key);
signature.update(data);
str = encryptBase64(signature.sign());
} catch (Exception e) {
throw new RuntimeException(e);
}
return str;
}
/**
* 用私钥对信息生成数字签名
*
* @param privateKey
* @param dataStr
* @return
*/
public static String sign(String privateKey, String dataStr) {
String str = "";
try {
byte[] data = dataStr.getBytes("UTF-8");
return sign(privateKey, data);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 校验数字签名
*
* @param data 加密数据
* @param publicKey 公钥
* @param sign 数字签名
* @return 校验成功返回true，失败返回false
*/
public static boolean verify(String publicKey, byte[] data, String sign) {
boolean flag = false;
try {
// 解密由base64编码的公钥
byte[] bytes = decryptBase64(publicKey);
// 构造X509EncodedKeySpec对象
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
// 指定的加密算法
KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
// 取公钥对象
PublicKey key = factory.generatePublic(keySpec);
// 用公钥验证数字签名
Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE);
signature.initVerify(key);
signature.update(data);
flag = signature.verify(decryptBase64(sign));
} catch (Exception e) {
throw new RuntimeException(e);
}
return flag;
}
public static boolean verify(String publicKey, String dataStr, String sign) {
try {
byte[] data = dataStr.getBytes("UTF-8");
return verify(publicKey, data, sign);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 公钥加密
*
* @param key 公钥
* @param data 待加密数据
* @return
*/
public static byte[] encryptByPublicKey(String key, byte[] data) {
byte[] result = null;
try {
// 获取公钥字符串时,进行了encryptBase64操作,因此此处需对公钥钥解密
byte[] bytes = decryptBase64(key);
// 取得公钥
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
PublicKey publicKey = factory.generatePublic(keySpec);
// 对数据加密
Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
/*int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_ENCRYPT_BLOCK;
}
byte[] encryptedData = out.toByteArray();
out.close();
return encryptedData;*/
return blockEncrypt(cipher, data);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 公钥加密
*
* @param key
* @param dataStr
* @return
*/
public static String encryptByPublicKey(String key, String dataStr) {
try {
byte[] result = encryptByPublicKey(key, dataStr.getBytes("UTF-8"));
return encryptBase64(result);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
/**
* 私钥解密
*
* @param data 加密数据
* @param key 私钥
* @return
*/
public static byte[] decryptByPrivateKey(String key, byte[] data) {
byte[] result = null;
try {
// 获取私钥字符串时,进行了encryptBase64操作,因此此处需对私钥解密
byte[] bytes = decryptBase64(key);
// 取得私钥
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
PrivateKey privateKey = factory.generatePrivate(keySpec);
// 对数据解密
Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
/*int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段解密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
cache = cipher
.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
} else {
cache = cipher
.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_DECRYPT_BLOCK;
}
byte[] decryptedData = out.toByteArray();
out.close();
return decryptedData;*/
return blockDecrypt(cipher, data);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static String decryptByPrivateKey(String key, String dataStr) {
try {
byte[] result = decryptByPrivateKey(key, decryptBase64(dataStr));
return new String(result);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
/**
* 私钥加密
*
* @param data 待加密数据
* @param key 私钥
* @return
*/
public static byte[] encryptByPrivateKey(String key, byte[] data) {
byte[] result = null;
try {
byte[] bytes = decryptBase64(key);
// 取得私钥
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
PrivateKey privateKey = factory.generatePrivate(keySpec);
// 对数据加密
Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
/*int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_ENCRYPT_BLOCK;
}
byte[] encryptedData = out.toByteArray();
out.close();
return encryptedData;*/
return blockEncrypt(cipher, data);
} catch (Exception e) {
throw new RuntimeException(e);
}
//return result;
}
/**
* 对数据分块加密，防止太长超出加密长度
* @param cipher
* @param data
* @return
*/
private static byte[] blockEncrypt(Cipher cipher, byte[] data) {
int inputLen = data.length;
int offSet = 0;
byte[] cache;
int i = 0;
ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
// 对数据分段加密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_ENCRYPT_BLOCK;
}
byte[] encryptedData = out.toByteArray();
return encryptedData;
} catch (Exception ex) {
throw new RuntimeException(ex);
} finally {
if (out != null) {
try {
out.close();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
}
}
/**
* 私钥加密
*
* @param key
* @param dataStr
* @return
*/
public static String encryptByPrivateKey(String key, String dataStr) {
try {
byte[] result = encryptByPrivateKey(key, dataStr.getBytes("UTF-8"));
return encryptBase64(result);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
/**
* 公钥钥解密
*
* @param key 公钥
* @param data 加密数据
* @return
*/
public static byte[] decryptByPublicKey(String key, byte[] data) {
byte[] result = null;
try {
// 对公钥解密
byte[] bytes = decryptBase64(key);
// 取得公钥
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
KeyFactory factory = KeyFactory.getInstance(KEY_RSA);
PublicKey publicKey = factory.generatePublic(keySpec);
// 对数据解密
Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, publicKey);
// int inputLen = data.length;
// ByteArrayOutputStream out = new ByteArrayOutputStream();
//
// int offSet = 0;
// byte[] cache;
// int i = 0;
// // 对数据分段解密
// while (inputLen - offSet > 0) {
// if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
// cache = cipher
// .doFinal(data, offSet, MAX_DECRYPT_BLOCK);
// } else {
// cache = cipher
// .doFinal(data, offSet, inputLen - offSet);
// }
// out.write(cache, 0, cache.length);
// i++;
// offSet = i * MAX_DECRYPT_BLOCK;
// }
// byte[] decryptedData = out.toByteArray();
// out.close();
// return decryptedData;
return blockDecrypt(cipher, data);
//result = cipher.doFinal(data);
} catch (Exception e) {
throw new RuntimeException(e);
}
// return result;
}
/**
* 分块解密
*
* @param cipher
* @param data
* @return
*/
private static byte[] blockDecrypt(Cipher cipher, byte[] data) {
int inputLen = data.length;
int offSet = 0;
byte[] cache;
int i = 0;
ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
// 对数据分段解密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
cache = cipher
.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
} else {
cache = cipher
.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_DECRYPT_BLOCK;
}
byte[] decryptedData = out.toByteArray();
return decryptedData;
} catch (Exception ex) {
throw new RuntimeException(ex);
} finally {
if (out != null) {
try {
out.close();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
}
}
public static String decryptByPublicKey(String key, String dataStr) {
try {
byte[] result = decryptByPublicKey(key, decryptBase64(dataStr));
return new String(result);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
/**
* 获取公钥
*
* @param map
* @return
*/
public static String getPublicKey(Map<String, Object> map) {
String str = "";
try {
Key key = (Key) map.get(KEY_RSA_PUBLICKEY);
str = encryptBase64(key.getEncoded());
} catch (Exception e) {
throw new RuntimeException(e);
}
return str;
}
/**
* 获取私钥
*
* @param map
* @return
*/
public static String getPrivateKey(Map<String, Object> map) {
String str = "";
try {
Key key = (Key) map.get(KEY_RSA_PRIVATEKEY);
str = encryptBase64(key.getEncoded());
} catch (Exception e) {
throw new RuntimeException(e);
}
return str;
}
/**
* BASE64 解密
*
* @param key 需要解密的字符串
* @return 字节数组
* @throws Exception
*/
public static byte[] decryptBase64(String key) {
return javax.xml.bind.DatatypeConverter.parseBase64Binary(key);
}
/**
* BASE64 加密
*
* @param key 需要加密的字节数组
* @return 字符串
* @throws Exception
*/
public static String encryptBase64(byte[] key) {
return javax.xml.bind.DatatypeConverter.printBase64Binary(key);
}
public static void main(String[] args) {
try {
Map<String, Object> map = generateKey();
String privateKey = getPrivateKey(map);
String publicKey = getPublicKey(map);
//输出公钥私钥
System.out.println("【userId】："+ UUID.randomUUID().toString());
System.out.println("【私钥privateKey】："+privateKey);
System.out.println("【公钥publicKey】："+publicKey);
Map<String, String> mapParam = new HashMap<>();
mapParam.put("user", "省国土资源厅");
mapParam.put("password", "phz");
mapParam.put("req_ip", "127.0.0.1");
String jsonParam = JsonMapper.toJsonString(mapParam);
//加密
// String e = encryptBase64(jsonParam.getBytes("UTF-8"));
// byte[] d = decryptBase64(e);
// String str = new String(d);
String encryptParam = encryptByPrivateKey(privateKey, jsonParam);
//加签
// String strSign = sign(privateKey, encryptParam);
encryptParam = URLEncoder.encode(encryptParam, "UTF-8");//进行编码，防止中文乱码
encryptParam = URLDecoder.decode(encryptParam, "UTF-8");//进行解码，防止中文乱码
//验签
//boolean boolSign = verify(publicKey, encryptParam, strSign);
//解密
String decryptParam = decryptByPublicKey(publicKey, encryptParam);
System.out.print("");
// my test
String privateKey1 = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJe4iW39ZP4brfShaNBukoIS1K8WGNx9R/iARAfEbjrz/ppP2+kSa0V+ixbLAaiVCALAyjy/d/tHIwEIlnV8xneilf3Ke2SVLlm/xWNbBbZ3Ms+d6SjxevKKug1WojoNduCqPw6o4dOPyv1c1wDgw4etav7u0YX58XtBWjOaLsAvAgMBAAECgYBAjN/TrwqH3mjterroaxLkSnS4pVMghCDZxmCrWVR4upSpPK7Yg+Cl6Yftw6NKAVYuLa4dmGzIuORYrTmudM7PLCzrjNrfnKtoMf0t3TuvJu4dDxIL+aFbRGyIXMXd7izW1eBBdkaclO7Kt+21t/N407BNJFBz8aPiiREqw7JgIQJBAP/CN4hiRLyL4EKgNzi+HdDjtkA4N7OKTdYWvgQRx5k1cZRw9yiSPSwyvD4k50xGK6gGHMUhFj6KwCsDrbQj0/8CQQCX3TAOM7V8aLwv0Ujw18sDHphEYwMAW8etzLzL7b/Xnezqm0eiK6mjFrEymL6f8jOj/UQHbbkr+UxYA5TYzVPRAkBuPu/lMEbk536h+aIUKY98rcuv3wvTrrhioqcB5hAd8LWnARLpQDByTuRp/UpezJig8xGPv/VwvCqd4BYOYqtNAkAtM74hDA0iCb6x8PZoEaMwu4ORH3N+QNNPjRhJDuxCTpR9RFjvEVX94DxAFizvSNVMI4+DMoqiZyLtM6uzWHJxAkEAtpWQPLmFBYACeyuuU66M4TkPXoCLNsSgl0Gi2WBLZQTccbnVIacJZ+bIiMTZItZbiUjfVeAoDBmcU+yMmYo0kg==";
String publicKey1 = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCXuIlt/WT+G630oWjQbpKCEtSvFhjcfUf4gEQHxG468/6aT9vpEmtFfosWywGolQgCwMo8v3f7RyMBCJZ1fMZ3opX9yntklS5Zv8VjWwW2dzLPneko8XryiroNVqI6DXbgqj8OqOHTj8r9XNcA4MOHrWr+7tGF+fF7QVozmi7ALwIDAQAB";
String jsonParam1 = "{\"timestamp\":\"1615941355707\",\"cdbh\":\"Q20200610-00001\",\"querymanList\":[{\"name\":\"陈卓安\",\"zjh\":\"330124198108180015\"}],\"xzqbm\":\"330101\",\"isAllCity\":\"1\",\"isShowXzxx\":\"1\",\"qyca\":\"0\",\"sm\":\"\",\"cxfw\":\"\",\"cdyt\":\"无房证明\",\"jgmc\":\"\",\"bjsy\":\"\",\"cxbt\":\"不动产登记信息查询记录\"}";
jsonParam1 = URLEncoder.encode(jsonParam1, "UTF-8");//进行编码，防止中文乱码
String encryptParam1 = encryptByPrivateKey(privateKey1, jsonParam1);
System.out.println("encryptParam：" + encryptParam1);
String sign = sign(privateKey1, encryptParam1);
// String encryptParam2 = encryptByPrivateKey(privateKey, encryptParam1);
System.out.println("sign：" + sign);
String decryptParam1 = decryptByPublicKey(publicKey1, encryptParam1);
decryptParam1 = URLDecoder.decode(decryptParam1, "UTF-8");//进行解码，防止中文乱码
System.out.println("解密：" + decryptParam1);
String responseData = "";
responseData = URLDecoder.decode(responseData, "UTF-8");//进行解码，防止中文乱码
String response = decryptByPublicKey(publicKey1, responseData);
response = URLDecoder.decode(response, "UTF-8");//进行解码，防止中文乱码
System.out.println("响应值解密：" + response);
System.out.println(decryptBase64(responseData).toString());
} catch (Exception ex) {
System.out.print(ex);
}
}
}
src/main/java/com/mth/requestsecret/vo/hongcheng/HongChengUser.java 0 → 100644
View file @ 5202f30d
package com.mth.requestsecret.vo.hongcheng;
import lombok.Data;
/**
* @author MaTianHao
* @date 2021/3/17
*/
@Data
public class HongChengUser {
/**
* 姓名
*/
private String name;
/**
* 证件号
*/
private String zjh;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment