package com.common.core.service;
|
|
import com.common.annotation.NoEncryption;
|
import com.common.core.crypto.ColumnHandler;
|
import com.common.core.crypto.CryptoHandler;
|
import com.common.core.enums.ResultCodeEnum;
|
import com.common.core.exception.BizException;
|
import com.jfinal.plugin.activerecord.Model;
|
import com.jfinal.plugin.activerecord.Record;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
|
import java.lang.reflect.Array;
|
import java.lang.reflect.Field;
|
import java.lang.reflect.Method;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author 廖振钦
|
* @Date 2022-01-11 20:05
|
* */
|
@Slf4j
|
@Service
|
public class CryptoService {
|
// 用于数据库的某些字段加密解密
|
public static final CryptoHandler<String, String> CRYPTO_HANDLER = new ColumnHandler();
|
|
/**
|
* @Title: 对record某些列解密
|
*/
|
public List<Record> decryptoColumnRecord(List<Record> list, String[] columns){
|
int size = list.size();
|
for(int i = 0; i < size; i++){
|
Record record = list.get(i);
|
decryptoColumnRecord(record, columns);
|
}
|
return list;
|
}
|
|
public List<Record> decryptoColumnRecord(List<Record> list){
|
int size = list.size();
|
for(int i = 0; i < size; i++){
|
Record record = list.get(i);
|
decryptoRecord(record);
|
}
|
return list;
|
}
|
|
/**
|
* @Title: 对record某些列解密
|
*/
|
public Record decryptoColumnRecord(Record record, String[] columns){
|
for(String column : columns){
|
if(isSM(column)) {
|
record.set(column, CRYPTO_HANDLER.decrypto(record.getStr(column)));
|
}
|
}
|
return record;
|
}
|
|
public Record decryptoRecord(Record record){
|
String[] columns = record.getColumnNames();
|
for(String column : columns){
|
if(isSM(column)) {
|
record.set(column, CRYPTO_HANDLER.decrypto(record.getStr(column)));
|
}
|
}
|
return record;
|
}
|
|
/** ======================== model加密 start ======================== **/
|
|
/**
|
* @Title: 对model全部列加密
|
*/
|
public <T extends Model<T>> List<T> encryptoModel(List<T> list){
|
int size = list.size();
|
for(int i = 0; i < size; i++){
|
T model = list.get(i);
|
encryptoModel(model);
|
}
|
return list;
|
}
|
|
/**
|
* @Title: 对model某些列加密
|
*/
|
// public <T extends Model<T>> List<T> encryptoColumnModel(List<T> list, String[] columns){
|
// int size = list.size();
|
// for(int i = 0; i < size; i++){
|
// T model = list.get(i);
|
// encryptoColumnModel(model, columns);
|
// }
|
// return list;
|
// }
|
|
/**
|
* @Title: 对model全部列加密
|
*/
|
public <T extends Model<T>> T encryptoModel(T model){
|
String[] columnNames = model._getAttrNames();
|
for(String column : columnNames){
|
if(isSM(column)) {
|
model.set(column, CRYPTO_HANDLER.encrypto(model.getStr(column)));
|
}
|
}
|
return model;
|
}
|
|
/**
|
* @Title: 对model某些列加密
|
*/
|
public <T extends Model<T>> T encryptoColumnModel(T model, String[] columns){
|
for(String column : columns){
|
if(isSM(column)) {
|
model.set(column, CRYPTO_HANDLER.encrypto(model.getStr(column)));
|
}
|
}
|
return model;
|
}
|
|
/**
|
*
|
* @param model
|
* @param <T>
|
* @param columns
|
* @return
|
*/
|
// public <T> T encryptColumnModel(T model, String[] columns){
|
// List<T> modelList = new ArrayList<>();
|
// if (model instanceof Object) {
|
//// modelList.add(models);
|
// T t = encryptColumn(model, columns);
|
// return t;
|
// }else if (model instanceof List) {
|
// List models= (List) model;
|
// modelList.addAll(models);
|
// for(int i = 0; i < modelList.size(); i++){
|
// T modelOne = modelList.get(i);
|
// T t = encryptColumn(modelOne, columns);
|
// modelList.add(t);
|
// }
|
// return (T) modelList;
|
// }
|
//// int size = modelList.size();
|
//// List<T> ts = new ArrayList<>();
|
//// for(int i = 0; i < size; i++){
|
//// T model = modelList.get(i);
|
//// T t = encryptColumn(model, columns);
|
////// modelList.add(t);
|
//// }
|
//
|
// return null;
|
// }
|
|
/**
|
* @Title: 对model某些列加密
|
*/
|
public <T> List<T> encryptColumnModel(List<T> list, String[] columns) {
|
List<T> modelList = new ArrayList<>();
|
int size = list.size();
|
for(int i = 0; i < size; i++){
|
T model = list.get(i);
|
T t = encryptColumn(model, columns);
|
modelList.add(t);
|
}
|
return modelList;
|
}
|
|
/**
|
* @Title: 对model某些列加密
|
*/
|
public <T> T encryptColumnModel(T model, String[] columns) {
|
T t = encryptColumn(model, columns);
|
return t;
|
}
|
|
/**
|
* 对model字段加密
|
* @param model
|
* @param columns
|
* @param <T>
|
* @return
|
*/
|
public <T> T encryptColumn(T model, String[] columns) {
|
Field[] fields = model.getClass().getDeclaredFields();
|
for(String column : columns){
|
if(isSM(column)) {
|
for (int i = 0; i < fields.length; i++) {
|
if (column.equals(fields[i].getName())) {
|
String encrypto = CRYPTO_HANDLER.encrypto((String) getFieldValueByName(fields[i].getName(), model));
|
fields[i].setAccessible(true);
|
try {
|
fields[i].set(model,encrypto);
|
} catch (IllegalAccessException e) {
|
log.error("encryptColumn failed",e);
|
}
|
}
|
}
|
}
|
}
|
return model;
|
}
|
|
/**
|
* 对model没有@NoEncryption字段加密
|
* @param model
|
* @param <T>
|
* @return
|
*/
|
public <T> T encryptModelColumns(T model) {
|
Field[] fields = model.getClass().getDeclaredFields();
|
for (Field field : fields) {
|
if (isSM(field.getName()) && !field.isAnnotationPresent(NoEncryption.class)) {
|
Object value=getFieldValueByName(field.getName(), model);
|
if(value!=null && value.getClass().isArray()){
|
String[] valueArray=(String[])value;
|
ArrayList<String> list=new ArrayList();
|
for (String s : valueArray) {
|
list.add(CRYPTO_HANDLER.encrypto(s));
|
}
|
field.setAccessible(true);
|
try {
|
field.set(model, list.toArray(new String[0]));
|
} catch (IllegalAccessException e) {
|
log.error("encryptModelColumns failed",e);
|
}
|
}else {
|
String encrypto = CRYPTO_HANDLER.encrypto((String) value);
|
field.setAccessible(true);
|
try {
|
field.set(model, encrypto);
|
} catch (IllegalAccessException e) {
|
log.error("encryptModelColumns failed",e);
|
}
|
}
|
}
|
}
|
return model;
|
}
|
|
/**
|
* 对model字段解密
|
* @param model
|
* @param columns
|
* @param <T>
|
* @return
|
*/
|
public <T> T decryptColumn(T model, String[] columns) {
|
try {
|
Field[] fields = model.getClass().getDeclaredFields();
|
for (String column : columns) {
|
if (isSM(column)) {
|
for (int i = 0; i < fields.length; i++) {
|
if (column.equals(fields[i].getName())) {
|
String encrypto = CRYPTO_HANDLER.decrypto((String) getFieldValueByName(fields[i].getName(), model));
|
fields[i].setAccessible(true);
|
fields[i].set(model, encrypto);
|
}
|
}
|
}
|
}
|
return model;
|
}catch (Exception e){
|
throw new BizException(ResultCodeEnum.DECRYPT_ERROR);
|
}
|
}
|
|
/**
|
* 对model没有@NoEncryption字段解密
|
* @param model
|
* @param <T>
|
* @return
|
*/
|
public <T> T decryptModelColumns(T model,Class clz) {
|
Field[] fields = clz.getDeclaredFields();
|
for (Field field : fields) {
|
if (isSM(field.getName()) && !field.isAnnotationPresent(NoEncryption.class)) {
|
String decrypto = CRYPTO_HANDLER.decrypto((String) getFieldValueByName(field.getName(), model));
|
field.setAccessible(true);
|
try {
|
if(decrypto!=null)
|
field.set(model, decrypto);
|
} catch (IllegalAccessException e) {
|
log.error("decryptModelColumns failed",e);
|
}
|
}
|
}
|
return model;
|
}
|
|
/**
|
* 对List<Model>没有@NoEncryption字段解密
|
* @param models
|
* @return
|
*/
|
public <T> List<T> decryptModelListColumns(List<T> models,Class clz) {
|
return models.stream().map(model -> decryptModelColumns(model,clz)).collect(Collectors.toList());
|
}
|
|
/**
|
* 根据属性名获取属性值
|
* @param fieldName
|
* @param o
|
* @return
|
*/
|
private Object getFieldValueByName(String fieldName, Object o) {
|
try {
|
String firstLetter = fieldName.substring(0, 1).toUpperCase();
|
String getter = "get" + firstLetter + fieldName.substring(1);
|
Method method = o.getClass().getMethod(getter, new Class[]{});
|
Object value = method.invoke(o, new Object[]{});
|
return value;
|
} catch (Exception e) {
|
log.error("getFieldValueByName failed",e);
|
}
|
return null;
|
}
|
|
/** ======================== model加密 end ======================== **/
|
|
|
|
/** ======================== model解密 start ======================== **/
|
|
/**
|
* @param <T>
|
* @Title: 对model全部列解密
|
*/
|
|
public <T extends Model<T>> List<T> decryptoModel(List<T> list){
|
int size = list.size();
|
for(int i = 0; i < size; i++){
|
T model = list.get(i);
|
decryptoModel(model);
|
}
|
return list;
|
}
|
|
/**
|
* @param <T>
|
* @Title: 对model某些列解密
|
*/
|
|
public <T extends Model<T>> List<T> decryptoColumnModel(List<T> list, String[] columns){
|
int size = list.size();
|
for(int i = 0; i < size; i++){
|
T model = list.get(i);
|
decryptoColumnModel(model, columns);
|
}
|
return list;
|
}
|
|
/**
|
* @Title: 对model全部列解密
|
*/
|
public <T extends Model<T>> T decryptoModel(T model){
|
String[] columnNames = model._getAttrNames();
|
for(String column : columnNames){
|
if(isSM(column)) {
|
model.set(column, CRYPTO_HANDLER.decrypto(model.getStr(column)));
|
}
|
}
|
return model;
|
}
|
|
/**
|
* @Title: 对model某些列解密
|
*/
|
public <T extends Model<T>> T decryptoColumnModel(T model, String[] columns){
|
for(String column : columns){
|
if(isSM(column)) {
|
model.set(column, CRYPTO_HANDLER.decrypto(model.getStr(column)));
|
}
|
}
|
return model;
|
}
|
|
public boolean isSM(String column){
|
if(!"id".equals(column) && !"create_time".equals(column) && !"update_time".equals(column) && !"is_delete".equals(column)
|
&& !"dataId".equals(column)&& !"isDelete".equals(column)&& !"sfRecordId".equals(column)) {
|
return true;
|
}else{
|
return false;
|
}
|
}
|
|
|
/** ======================== model解密 end ======================== **/
|
|
|
public Object convertor(Object src, Object target){
|
Class<?> srcClass = src.getClass();
|
Class<?> targetClass = target.getClass();
|
Field[] fields = srcClass.getDeclaredFields();
|
for (Field field : fields) {
|
if (isSM(field.getName()) && !field.getName().contains("Encrypt")) {
|
field.setAccessible(true);
|
Object value = null;
|
try {
|
value = field.get(src);
|
Class<?> methodParamTypes = getMethodParamTypes(target, "set" + captureName(field.getName())+"Encrypt");
|
Method method = targetClass.getDeclaredMethod("set" +captureName(field.getName())+"Encrypt",methodParamTypes);
|
method.setAccessible(true);
|
method.invoke(target,value);
|
} catch (Exception e) {
|
log.error("convertor failed",e);
|
}
|
}
|
}
|
return target;
|
}
|
|
public String captureName(String name){
|
name = name.substring(0,1).toUpperCase()+name.substring(1);
|
return name;
|
}
|
|
public Class<?> getMethodParamTypes(Object classInstance,String methodName){
|
Method[] methods = classInstance.getClass().getMethods();
|
Class<?> param = null;
|
for (int i = 0; i < methods.length; i++) {
|
if (methodName.equals(methods[i].getName())) {
|
param = methods[i].getParameterTypes()[0];
|
}
|
}
|
return param;
|
}
|
}
|
