大文本对象特殊字符统一处理

起因
最近系统发现一个隐藏的bug，使用freemarker模板引擎生成pdf导出的时候，发现对于一些特殊字符会报错。因为生成的pdf页数较多，需要填充的字符也有上百个，所以写了个通用的替换方法。
原以为还是挺简单的，后来测试的时候发现有些地方考虑的还不是很周到。目前是能满足基本的要求不再出现bug，但是逻辑还是能更加完善，能满足更多的场景要求。

全部代码如下：

 /**
     * 通过反射改变字符类型对象的特殊字符
     *
     * @param originData
     */
    private void parseSpecialCharacters(Object originData) {
        if (null == originData) {
            return;
        }
        Field[] fields = originData.getClass().getDeclaredFields();
        for (Field s : fields) {
            //获取属性名
            String name = getMethodName(s.getName());
            //获取属性类型
            String type = s.getGenericType().toString();
            if (type.equals("class java.lang.String")) {
                processStringObjectSpecialChars(originData, name);
            } else if (type.contains("java.util.List")) {
                try {
                    Method m = originData.getClass().getMethod("get" + name);
                    // 调用getter方法获取属性值
                    Object invoke = m.invoke(originData);
                    if (invoke instanceof List) {
                        List listObject = (List) invoke;
                        for (Object o : listObject) {
                            // 需要考虑到对象是List<String>
                            if (o instanceof String || o instanceof BigDecimal) {
                                // 数据基本上是坐标轴数据，直接return
                                continue;
                            }
                            //递归处理
                            parseSpecialCharacters(o);
                        }
                    }
                } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
                    logger.error("!!! 处理 list 对象报错：{}", originData.getClass());
                    e.printStackTrace();
                }
            } else if (checkClassAttributes(type)) {
                try {
                    Method m = originData.getClass().getMethod("get" + name);
                    // 调用getter方法获取属性值
                    Object invoke = m.invoke(originData);
                    parseSpecialCharacters(invoke);
                } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
                    logger.error("!!! 处理基础对象报错：{}", originData.getClass());
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 检查类型是否符合条件
     * @param type
     * @return
     */
    public boolean checkClassAttributes(String type) {
        if (!Objects.equals(type, "class java.lang.Long")
                && !Objects.equals(type, "class java.lang.Boolean")
                && !Objects.equals(type, "class java.lang.Integer")
                && !Objects.equals(type, "class java.lang.BigInteger")
                && !Objects.equals(type, "class java.lang.Double")
                && !Objects.equals(type, "class java.util.Date")
                && !Objects.equals(type, "class java.lang.Long")
                && !Objects.equals(type, "class java.math.BigDecimal")
                && !Objects.equals(type, "int")
                && !Objects.equals(type, "long")
                && !Objects.equals(type, "double")) {
            return true;
        }
        return false;
    }


    /**
     *  特殊字符处理
     * @param from
     * @return
     */
    public String replaceCode(String from) {
        if (StringUtils.isBlank(from)) {
            return null;
        } else {
            return from.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
        }
    }

    /**
     * 把一个字符串的第一个字母大写
     * @param filedName
     * @return
     */
    private static String getMethodName(String filedName) {
        byte[] items = filedName.getBytes();
        items[0] = (byte) ((char) items[0] - 'a' + 'A');
        return new String(items);
    }

    private void processStringObjectSpecialChars(Object object, String name) {
        try {
            Method m = object.getClass().getMethod("get" +getMethodName(name));
            String str = (String) m.invoke(object);
            if (null != str) {
                //判断是否包含特殊字符
                if (str.contains("<") || str.contains(">") || str.contains("&")) {
                    m = object.getClass().getMethod("set" + name, String.class);
                    m.invoke(object, replaceCode(str));
                }
            }
        } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
            logger.error("!!!处理字符串报错：{}, 属性：{}", object.getClass(), name);
        }
    }

parseSpecialCharacters方法中传入的对象originData是自定义的需要替换处理的对象。通过反射的方法先获取到对象的全部属性，然后获取到对象类型，对不同对象分别进行处理。若对象中引用了其他自定义对象，进行递归。

processStringObjectSpecialChars是取得当前对象的值，判断是否包裹特殊字段，如包含，进行替换后重新赋值