jeecgboot通过反射处理实体 导出word,pdf使用

@Component
public class ReflectDataUtils {

    @Autowired
    private ISysBaseAPI sysBaseAPI;

    private static Map<String,Object> baseTypeList;

    static{
        baseTypeList = new HashMap<>();
        baseTypeList.put("int", 0);
        baseTypeList.put("long", 0L);
        baseTypeList.put("java.lang.Integer", 0);
        baseTypeList.put("java.lang.String", "");
        baseTypeList.put("BigDecimal",new BigDecimal(0));
        baseTypeList.put("java.math.BigDecimal",new BigDecimal(0));
    }

    /**
     * 字典为null时设置默认值
     * @param type
     * @return
     */
    private Object setInitValue(String type){
        Iterator<String> iterator = baseTypeList.keySet().iterator();
        while (iterator.hasNext()){
            String key = iterator.next();
            if(type.toLowerCase().contains(key.toLowerCase())){
               return baseTypeList.get(key);
            }
        }
        return null;
    }

    /**
     * 字典转数据
     * @param obj
     * @param cls
     */
    public void toDictText(Object obj, Class cls) {
        Field[] fileds = cls.getDeclaredFields();
        for (Field filed : fileds) {
            filed.setAccessible(true);
            try {
                if(filed.isAnnotationPresent(Dict.class) ){
                    //判断是否有默认字典值，如没有设置默认的值
                    if(ObjectUtil.isNotEmpty(filed.get(obj))){
                        Dict dict = filed.getAnnotation(Dict.class);
                        List<DictModel> dictModelList = sysBaseAPI.queryDictItemsByCode(dict.dicCode());
                        StringBuilder text = new StringBuilder();
                        for (DictModel dictModel : dictModelList) {
                            if (filed.get(obj).toString().contains(",")) {
                                String[] val = filed.get(obj).toString().split(",");
                                for (int i = 0; i < val.length; i++) {
                                    if (val[i].equals(dictModel.getValue())) {
                                        if (i == val.length-1) {
                                            text.append(dictModel.getText());
                                        } else {
                                            text.append(dictModel.getText());
                                            text.append(",");
                                        }
                                    }
                                }
                            } else {
                                if (filed.get(obj).equals(dictModel.getValue())) {
                                    filed.set(obj, dictModel.getText());
                                }
                            }
                        }
                        if (filed.get(obj).toString().contains(",")) {
                            filed.set(obj, text.toString());
                        }
                    }else{
                        filed.set(obj, setInitValue(filed.getGenericType().toString()));
                    }
                }else{
                    if(ObjectUtil.isEmpty(filed.get(obj))) {
                        filed.set(obj, setInitValue(filed.getGenericType().toString()));
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 对象数据 + 字典数据 转 JSON
     * @param obj
     * @param cls
     */
    public JSONObject addDictToJSONOBj(Object obj, Class cls){
        JSONObject o = new JSONObject();
        Field[] fileds = cls.getDeclaredFields();
        for (Field filed : fileds) {
            filed.setAccessible(true);
            try {
                if(filed.isAnnotationPresent(Dict.class)){
                    o.put(filed.getName(), filed.get(obj));
                    if(ObjectUtil.isNotEmpty(filed.get(obj))){
                        Dict dict = filed.getAnnotation(Dict.class);
                        List<DictModel> dictModelList = sysBaseAPI.queryDictItemsByCode(dict.dicCode());
                        for (DictModel dictModel : dictModelList) {
                            if (dictModel.getValue().equals(String.valueOf(filed.get(obj)))) {
                                o.put(filed.getName() + "_dictText", dictModel.getText());
                            }
                        }
                    }
                }else{
                    o.put(filed.getName(), filed.get(obj));
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return o;
    }

    /**
     * 处理对象
     * @param obj
     */
    public void handleObject(Object obj) {
        Class<?> cls = obj.getClass();
        toDictText(obj, cls);
    }

    /**
     * 处理集合
     * @param list
     */
    public void handleList(List<Object> list) {
        for (Object obj : list) {
            Class<?> cls = obj.getClass();
            toDictText(obj, cls);
        }
    }

    /**############################## 反射设置属性值 ##############################*/


    private static List<String> defaultOffList;

    static{
        defaultOffList = new ArrayList<>();
        defaultOffList.add("updateby");
        defaultOffList.add("updatetime");
    }

    public Object setObjectData(Object obj, Object data){
        return setObjectData(obj, data, null);
    }

    public Object setDefaultObjectData(Object obj, Object data){
        return setObjectData(obj, data, defaultOffList);
    }

    public Object setObjectData(Object obj, Object data, List<String> off){
        Map<String, Object> map = BeanUtil.beanToMap(data);
        if(ObjectUtil.isNotEmpty(off)){
            off = off.stream().map(String::toLowerCase).collect(Collectors.toList());
        }
        Class cls = obj.getClass();
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            if(ObjectUtil.isNotEmpty(off) && off.contains(field.getName().toLowerCase())){
                break;
            }
            Object value = map.get(field.getName());
            if(ObjectUtil.isNotEmpty(value)){
                try {
                    field.set(obj, value);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        return obj;
    }

}