代码备记（自用）

概述

以下为工作中用到的一些代码记录

工具类代码

ObjectUtils

说明：
object工具类，目前提供了快速创建java对象并赋值的方法，避免对象嵌套反复的new对象。

import cn.org.chiss.rhin._2015.Address;
import cn.org.chiss.rhin._2015.CodedValueType;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;

@Slf4j
public class ObjectUtils<T> {
    public static void main(String[] args) throws Exception {
        Address object = (Address) ObjectUtils.getObject(Address.class, JsonUtils.builder()
                .put("country", ObjectUtils.getObject(cn.org.chiss.rhin._2015.String.class, "value", "中国"))
                .put("city", ObjectUtils.getObject(cn.org.chiss.rhin._2015.String.class, "value", "武汉"))
                .put("text", ObjectUtils.getObject(cn.org.chiss.rhin._2015.String.class, "value", "test"))
                .build());
        CodedValueType obj1 = ObjectUtils.getObj(CodedValueType::new, "code", "中国");
        log.info("{}", object);
    }

    public static <T> T getObj(Supplier<T> obj, String field, Object value) throws Exception{
        return (T) getObject(obj.get(), field, value);
    }

    public static <T> T getObj(Supplier<T> obj, JSONObject parameterJson) throws Exception{
        return (T) getObject(obj.get(), parameterJson);
    }



     /**
      * 获取利用反射获取类里面的值和名称
      *
      * @param obj
      * @return
      * @throws IllegalAccessException
      */
     public static Map<String, Object> objectToMap(Object obj, List<String> ignoreFieldNameList) throws IllegalAccessException {
         Map<String, Object> map = new HashMap<>();
         Class<?> clazz = obj.getClass();
         System.out.println(clazz);
         for (Field field : clazz.getDeclaredFields()) {
             field.setAccessible(true);
             String fieldName = field.getName();
             Object value = field.get(obj);
             if(ignoreFieldNameList != null && ignoreFieldNameList.size() > 0
                && ignoreFieldNameList.contains(fieldName)){
                continue;
             }
             map.put(fieldName, value);
         }
         return map;
     }




    /**
     * 快速创建对象并赋值
     * @param classt
     */
    private static Object getObject(@NotNull Class classt, @NotNull java.lang.String field, Object value) throws Exception{
        return getObject(classt.newInstance(), field, value);
    }

    /**
     * 快速创建对象并赋值
     * @param classt
     */
    private static Object getObject(@NotNull Class classt, @NotNull JSONObject parameterJson) throws Exception{
        return getObject(classt.newInstance(), parameterJson);
    }

    private static Object getObject(@NotNull Object obj, @NotNull JSONObject parameterJson) {
        try {
            for (Object key : parameterJson.keySet()) {
                Object value = parameterJson.get(key);
                obj = getObject(obj, String.valueOf(key), value);
            }
        } catch (Exception e) {
            log.error("快速创建对象并赋值异常", e);
        }
        return obj;
    }

    /**
     * 给对象字段赋值
     * @param obj
     * @param field
     * @param value
     * @return
     * @throws Exception
     */
    private static Object getObject(@NotNull Object obj, @NotNull java.lang.String field,Object value) throws Exception{
        Class<?> classt = null;
        try {
            classt = obj.getClass();
            Field declaredField = classt.getDeclaredField(field);
            declaredField.setAccessible(true);
            declaredField.set(obj, value);
        } catch (Exception e) {
            if(!(e instanceof NoSuchFieldException)){
                log.error("快速创建对象并赋值异常: object: {}" , obj.getClass());
                log.error("快速创建对象并赋值异常: field: {}" , field);
                log.error("快速创建对象并赋值异常: value: {}" , value);
                throw e;
            }
            // 如果当前类没有获取到该字段，可以尝试从父类中获取
            classt = classt.getSuperclass();
            if(null == classt || classt == Object.class){
                // 没有父类，直接抛出异常
                throw new RuntimeException(e);
            }
            return getObject(obj,  field, value);
        }
        return obj;
    }
}

使用示例：

 ActiveParticipantType activeParticipantType = ObjectUtils.getObj(ActiveParticipantType::new, JsonUtils.builder()
	     .put("userName", "医疗卫生机构信息提供者")
	     .put("userIsRequestor", true)
	     .put("roleIDCode", Arrays.asList(ObjectUtils.getObj(CodedValueType::new, JsonUtils.builder()
	             .put("code", "Source")
	             .put("displayName", "事件源")
	             .put("codeSystemName", "参与者角色代码（CV_RoleIDCode）”")
	             .build())))
	     .build()),

ValidateUtils

import cn.org.chiss.rhin._2015.*;
import com.alibaba.fastjson.JSONObject;
import com.ksyun.nhip.register.common.enums.SoapFaultCode;
import com.ksyun.nhip.register.common.enums.WebServiceFaultCode;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;

import javax.xml.soap.SOAPException;
import java.lang.Boolean;
import java.lang.String;
import java.lang.reflect.Field;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 入参校验工具类
 */
@Slf4j
public class ValidateUtils {
    /**
     * 1:非空
     * 2:范围校验
     * 3:对象不为空时必填字段校验
     *
     * @param obj            对象
     * @param checkFieldJson 要检查的属性集合
     *                       eg: {
     *                       "name": "姓名不能为空",
     *                       "age": "年龄不能为空",
     *                       "sex": {"validaType":"R,FW", "validaFW":[1,2],"messageR":"性别不能为空", "messageFW":"性别只能为男或女"}
     *                       "address": "地址不能为空",
     *                       "address/contry": "国家不能为空",
     *                       "address/city": "城市不能为空",
     *                       "address/street": "街道不能为空"
     *                       "address/street/door": "门牌号不能为空"
     *                       "contactInformation/phone": {"validaType":"0","message0":"联系电话不为空时，电话是必填项"},
     *                       }
     *                       默认字段后面跟非空提示，
     *                       如果字段是对象，可以用/分割，表示对象中的属性
     *                       validaType表示校验类型，其中R表示必填校验，FW表示范围校验，0表示对象不为空时是必填项
     * @throws IllegalAccessException
     */
    public static void checkObjFieldIsNullAndRange(Object obj, JSONObject checkFieldJson) throws SOAPException {
        try {
            if (null == checkFieldJson || checkFieldJson.isEmpty()) {
                throw new RuntimeException("checkFieldJson is null");
            }
            Set<String> validSet = new HashSet<>();
            List<String> messageList = new ArrayList<>();
            for (Map.Entry<String, Object> entry : checkFieldJson.entrySet()) {
                String k = entry.getKey();
                Object v = entry.getValue();
                k = k.contains("@") ? k.replace("@", "") : k;
                String[] fieldSplit = k.split("/");
                List<String> splitList = Arrays.stream(fieldSplit).filter((item) -> {
                    // 过滤掉空字符串。
                    return StringUtils.isNotBlank(item);
                }).collect(Collectors.toList());
                if (splitList.size() == 1) {
                    // 根节点
                    if (null == obj) {
                        throw SOAPFaultExceptionUtil.createSOAPFaultException(SoapFaultCode.Sender.getFaultCode(),
                                WebServiceFaultCode.IncompleteParametersFault.getFaultCode(), (String) v + "不能为空！");
                    }
                } else if (splitList.size() > 1) {
                    // 递归取子对象fieldSplit末节点字段值
                    if (null == obj) {
                        // 根节点为空时，不做子节点校验
                        continue;
                    }
                    Object targetObj = null;
                    Object targetFiledValue = obj;
                    int continueIndex = 1;
                    verifyFieldValues(validSet, messageList, k, v, splitList, targetObj, targetFiledValue, continueIndex);
                }
            }
            if (!CollectionUtils.isEmpty(messageList)) {
                // 去重
                messageList = messageList.stream().collect(Collectors.toSet()).stream().collect(Collectors.toList());
            }

            if (validSet.contains("null")) {
                throw SOAPFaultExceptionUtil.createSOAPFaultException(SoapFaultCode.Sender.getFaultCode(),
                        WebServiceFaultCode.IncompleteParametersFault.getFaultCode(), messageList.toString());
            } else if (validSet.contains("fw")) {
                throw SOAPFaultExceptionUtil.createSOAPFaultException(SoapFaultCode.Sender.getFaultCode(),
                        WebServiceFaultCode.ParameterRangeFault.getFaultCode(), messageList.toString());
            }

        } catch (Exception e) {
            throw SOAPFaultExceptionUtil.createSOAPFaultException(SoapFaultCode.Receiver.getFaultCode(),
                    WebServiceFaultCode.ServerExceptionFault.getFaultCode(), e.getMessage());
        }
    }

    /**
     * 验证字段值
     * @param validSet
     * @param messageList
     * @param k
     * @param v
     * @param splitList
     * @param targetObj
     * @param targetFiledValue
     * @param continueIndex
     * @return
     * @throws Exception
     */
    private static Object verifyFieldValues(Set<String> validSet, List<String> messageList, String k,
                                                Object v, List<String> splitList, Object targetObj,
                                                Object targetFiledValue, int continueIndex) throws Exception {
        int index = 1;
        Object parentObj = null; // 消除递归子集赋值的影响
        if (null == parentObj) {
            parentObj = targetFiledValue;
        }
        for (String f : splitList) {
            if (index <= continueIndex) {
                index++;
                // 跳过第一层
                continue;
            }
            targetFiledValue = getObjectFieldValue(parentObj, f, parentObj.getClass());
            if (targetFiledValue instanceof Collection) {
                // 集合遍历验证
                Collection collection = (Collection) targetFiledValue;
                for (Object item : collection) {
                    parentObj = item;
                    targetFiledValue = verifyFieldValues(validSet, messageList, k, v, splitList, targetObj, item, index);
                }
                if (null == targetFiledValue || (targetFiledValue instanceof Collection && CollectionUtils.isEmpty((Collection) targetFiledValue))) {
                    break;
                }
                if (index != splitList.size()) {
                    targetObj = targetFiledValue;
                }
            } else {
                if (index != splitList.size()) {
                    parentObj = targetFiledValue;
                    targetObj = targetFiledValue;
                }
                if (null == targetFiledValue || (targetFiledValue instanceof Collection && CollectionUtils.isEmpty((Collection) targetFiledValue))) {
                    break;
                }
            }


            index++;
        }
        validJson(parentObj, messageList, targetFiledValue, k, v, validSet, (index == splitList.size()));
        return targetFiledValue;
    }


    /**
     * 递归获取对象属性值
     *
     * @param obj
     * @param field
     */
    private static Object getObjectFieldValue(Object obj, String field, Class objClass) throws Exception {
        Class<?> aClass = objClass;
        if (null == aClass) {
            aClass = obj.getClass();
        }
        if (obj instanceof Collection) {
            // 如果是集合则需要遍历验证
            Collection collection = (Collection) obj;
            for (Object item : collection) {
                return getObjectFieldValue(item, field, item.getClass());
            }
        }
        Field declaredField = null;
        try {
            // 尝试获取字段
            declaredField = aClass.getDeclaredField(field);
        } catch (Exception e) {
            // 没有获取到字段，尝试从父类中获取字段
            String classStr = aClass.toString();
            aClass = aClass.getSuperclass();
            if (null == aClass || StringUtils.equalsIgnoreCase(aClass.toString(), "class java.lang.Object")) {
                log.error("类 {} 获取不到字段：{}", classStr, field);
                // 没有父类，找不到对应字段，抛出异常！
                throw SOAPFaultExceptionUtil.createSOAPFaultException(SoapFaultCode.Receiver.getFaultCode(),
                        WebServiceFaultCode.ServerExceptionFault.getFaultCode(), "系统异常：参数校验时没有获取到对应字段！");
            }
            return getObjectFieldValue(obj, field, aClass);
        }
        declaredField.setAccessible(true);
        return declaredField.get(obj);
    }


    /**
     * 校验值是否为空
     *
     * @param targetObj
     * @param messageList
     * @param fieldValue
     * @param key
     * @param v
     * @return
     * @throws IllegalAccessException
     */
    private static Set<String> validJson(Object targetObj, List<String> messageList, Object fieldValue, String key, Object v, Set<String> resultSet, boolean valida0LevelFlag) throws Exception {
        String messageNull = "";
        String message0 = "";
        String messageFW = "";
        String validaType = "";
        if (v instanceof String) {
            messageNull = (String) v;
            messageFW = (String) v;
            message0 = (String) v;
        } else if (v instanceof JSONObject) {
            JSONObject jsonObject = (JSONObject) v;
            validaType = jsonObject.getString("validaType");
            if (StringUtils.contains(validaType, "0")) {
                message0 = jsonObject.getString("message0");
            } else if (StringUtils.contains(validaType, "R")) {
                messageNull = jsonObject.getString("messageR");
            } else if (StringUtils.contains(validaType, "FW")) {
                messageFW = jsonObject.getString("messageFW");
            } else {
                throw SOAPFaultExceptionUtil.createSOAPFaultException(SoapFaultCode.Receiver.getFaultCode(),
                        WebServiceFaultCode.ServerExceptionFault.getFaultCode(), "系统异常：（" + key + "）参数校验时没有获取到对应校验失败返回信息！");
            }
        }
        String nullMessage = "字段：" + key + "（" + messageNull + "）是必填项，不能为空！";
        String fwMessage = "字段：" + key + "（" + messageFW + "）的值不在规定范围内！";
        String rMessage = "字段：" + key + "，" + message0 + "是必填项！";
        if (v instanceof String) {
            if (null == fieldValue || (fieldValue instanceof Collection && CollectionUtils.isEmpty((Collection) fieldValue))) {
                resultSet.add("null");
                messageList.add(nullMessage);
            }
        } else if (v instanceof JSONObject) {
            JSONObject jsonObject = (JSONObject) v;
            if (StringUtils.contains("R", validaType)) {
                if (fieldValue == null || (fieldValue instanceof Collection && CollectionUtils.isEmpty((Collection) fieldValue))) {
                    resultSet.add("null");
                    messageList.add(nullMessage);
                }
            } else if (StringUtils.contains("FW", validaType)) {
                boolean flag = false;
                for (Object item : (Collection) jsonObject.get("validaFW")) {
                    if (StringUtils.equals(String.valueOf(item), String.valueOf(fieldValue))) {
                        flag = true;
                        break;
                    }
                }
                if (!flag) {
                    resultSet.add("fw");
                    messageList.add(fwMessage);
                }
            } else if (StringUtils.contains("0", validaType)) {
                // 对象非空时，部分字段是必填值校验。
                if (valida0LevelFlag && targetObj != null && (fieldValue == null || (fieldValue instanceof Collection && CollectionUtils.isEmpty((Collection) fieldValue)))) {
                    resultSet.add("null");
                    messageList.add(rMessage);
                }
            }
        }
        return resultSet;
    }
}

使用示例：

JSONObject validJson = JsonUtils.builder()
      .put("/AuditMessage", "审计信息")
      .put("/AuditMessage/eventIdentification", "事件类型")
      .put("/AuditMessage/eventIdentification/eventActionCode", JsonUtils.builder().put("validaType","FW").put("messageFW","事件活动代码").put("validaFW",valueList).build())
      .put("/AuditMessage/eventIdentification/eventDateTime", "事件日期时间")
      .put("/AuditMessage/eventIdentification/eventOutcomeIndicator", "事件结果代码")
      .put("/AuditMessage/eventIdentification/eventTypeCode", "事件类型代码")
      .put("/AuditMessage/eventIdentification/eventTypeCode/code", "事件类型代码code")
      .put("/AuditMessage/eventIdentification/eventID", "事件标识")
      .put("/AuditMessage/eventIdentification/eventID/code", "事件标识code")
      .put("/AuditMessage/activeParticipant", "参与者类型")
      .put("/AuditMessage/activeParticipant/userID", "用户标识")
      .put("/AuditMessage/activeParticipant/roleIDCode/code", JsonUtils.builder().put("validaType", "0").put("message0","角色ID代码code，在roleIDCode不为空时").build())
      .put("/AuditMessage/auditSourceIdentification", "审计源类型")
      .put("/AuditMessage/auditSourceIdentification/auditSourceID", "审计源类型")
      .put("/AuditMessage/auditSourceIdentification/auditSourceTypeCode/code", JsonUtils.builder().put("validaType", "0").put("message0","审计源类型代码，在auditSourceTypeCode不为空时").build())
      .put("/AuditMessage/participantObjectIdentification/participantObjectID", JsonUtils.builder().put("validaType", "0").put("message0","参与者具体对象类型，在participantObjectIdentification不为空时").build())
      .put("/AuditMessage/participantObjectIdentification/participantObjectIDTypeCode", JsonUtils.builder().put("validaType", "0").put("message0","参与对象ID类型代码，在participantObjectIdentification不为空时").build())
      .put("/AuditMessage/participantObjectIdentification/participantObjectIDTypeCode/code", JsonUtils.builder().put("validaType", "0").put("message0","参与对象ID类型代码code，在participantObjectIdentification不为空时").build())
      .put("/AuditMessage/participantObjectIdentification/participantObjectDetail/type", JsonUtils.builder().put("validaType", "0").put("message0","参与者具体对象描述type，在participantObjectDetail不为空时").build())
      .put("/AuditMessage/participantObjectIdentification/participantObjectDetail/value", JsonUtils.builder().put("validaType", "0").put("message0","参与者具体对象描述value，在participantObjectDetail不为空时").build())
      .build();
ValidateUtils.checkObjFieldIsNullAndRange(getAuditMessage(), validJson);

示例返回的结果：

javax.xml.ws.soap.SOAPFaultException: [字段：/AuditMessage/participantObjectIdentification/participantObjectDetail/value，参与者具体对象描述value，在participantObjectDetail不为空时是必填项！, 字段：/AuditMessage/participantObjectIdentification/participantObjectDetail/type，参与者具体对象描述type，在participantObjectDetail不为空时是必填项！, 字段：/AuditMessage/activeParticipant/roleIDCode/code，角色ID代码code，在roleIDCode不为空时是必填项！]

	at com.ksyun.nhip.register.common.utils.SOAPFaultExceptionUtil.createSOAPFaultException(SOAPFaultExceptionUtil.java:46)
	at com.ksyun.nhip.register.common.utils.ValidateUtils.checkObjFieldIsNullAndRange(ValidateUtils.java:221)
	at com.ksyun.nhip.register.service.impl.AuditProvider_AuditWebserviceImplPort_Client.testAuditValidate(AuditProvider_AuditWebserviceImplPort_Client.java:187)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:69)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater$1.execute(IdeaTestRunner.java:38)
	at com.intellij.rt.execution.junit.TestsRepeater.repeat(TestsRepeater.java:11)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:35)
	at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:232)
	at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:55)