当前位置： 移动技术网 > IT编程>开发语言>Java > Java工具类——通过配置XML验证Map

Java工具类——通过配置XML验证Map

2019年04月03日  | 移动技术网IT编程  | 我要评论

健康之路网站,展会兼职,龙炎电商开启财富自由人生

java工具类——通过配置xml验证map

背景

在javaweb项目中，接收前端过来的参数时通常是使用我们的实体类进行接收的。但是呢，我们不能去决定已经搭建好的框架是怎么样的，在我接触的框架中有一种就是通过map来接收前端过来的所有参数，框架中没有实体类的说法，从接收参数，验证参数到参数至持久层整个过程都是通过map来传递数据。

而在开发的过程中，减少了实体类的存在，有时是感觉挺方便的，比如：一个系统中有100多个表，这里我们可以减少工作量（虽然对应表的实体可以代码生成），因为我们开发过程中是需要返回多个表关联后的结果的，这里可能我们需要创建dto，这些步骤确实是挺烦人的。但是，前端过来的参数我们需不需要验证呢？客户的输入不管有意或者是无意，我认为都应该让系统的容错能力更强悍一些。所以，在验证前端过来的参数时，使用了map就着实让人头痛。每个需要强制验证的参数都需要get，然后判断类型，强制转型，判断参数符不符合期望值边界等。

所以，我就考虑了，实体类可以通过spring mvc中hibernate的validation使用注解的方式进行参数校验，那么，少了实体类，我是不是可以通过配置xml的方式来达到类似有实体类的效果。网上找了类似关键词的工具类，发现没有我所期望的，所以就动手来了一个。

大致的想法

在web开发时，有许多if-else语句的出现都是在为了验证前端参数合不合法真的是挺无奈的，而且有些代码虽然长起来类似但是呢要去重构成一个公用的方法好像有些困难，时常问自己，要怎么去搞，java不是javascript，语句没那么灵活。

于是想着通过xml配置试试，大致就是通过配置好的xml代替我们的实体类，并且有个入口将xml中的实体映射，并传入待验证的map，验证之后传出一个数组，如果验证通过数组为空，不通过则是我们xml中配置的对应错误语句。

如何设计xml格式

动手在这之前，需要想好我们大致的xml结构是怎么样的。这里，我的想法是，在我们一般遇到的参数主要就是integer，string，double，date，list了（这里居然没有考虑boolean，算了，之后再做补充也行）。所以基于以上，设计的结构大致如下：

<?xml version="1.0" encoding="utf-8"?>
<map-verify
    xmlns="https://www.lger.cn/verify"
    xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
    xsi:schemalocation="https://www.lger.cn/verify map-verify-util.xsd"
    >
    <!--
    在长度的方面分别使用了
    lt; lte; gt; gte; eq;分别代表<; <=; >; >=; =
    -->
    <entity name="user01">
        <!--casterrmsg为当验证过程中类型解析错误时返回提示-->
        <string name="username" casterrmsg="username必须为字符串类型">
            <length>
                <lt errmsg="当前值不能小于2">2</lt>
            </length>
            <notnull errmsg="当前值不能为空"/>
            <notblank errmsg="当前值不能为空（去掉首尾空格）"/>
            <pattern>
                <!--如果不匹配则发出错误-->
                <value errmsg="号码d[0-8]{4}">[0-8]{4}</value>
                <value errmsg="号码d[0-7]{4}">[0-7]{4}</value>
            </pattern>
        </string>
        <integer name="age" casterrmsg="必须为整型">
            <lt errmsg="岁数必须大于2">2</lt>
            <gt>150</gt>
            <notnull/>
        </integer>
        <list name="details">
            <notempty/>
            <size>
                <gte>0</gte>
            </size>
            <!-- 遍历list内容，遍历的entity映射为name为user02的实体 -->
            <foreach entity="user02" />
        </list>
        <date name="birthday">
            <lt>1900-07-21</lt>
            <notnull/>
        </date>
        <double name="money">
            <lt>1</lt>
            <gt>150</gt>
            <notnull/>
        </double>
    </entity>

    <entity name="user02">
        <string name="username">
            <length>
                <lt errmsg="当前值不能小于2">2</lt>
                <gt errmsg="当前值不能大于10">10</gt>
            </length>
            <notblank errmsg="当前值不能为空（去掉空格）"/>
        </string>
    </entity>
</map-verify>

需要写出一个具有一定格式的xml那么还需要写出一个约束文件了验证是否xml格式写的正确。这里还小学了一下xsd，这里就不贴出代码了。

以上的xml大致的说了下怎么使用其替代实体类。写到了这里其实有时还觉得使用实体类可能更方便，何必使用map呢？但是，别人框架已经写了，参数只能接收到map那我只能屈服了。

类结构设计

首先，每一个entity就是一个实体对象，这里我认为每个entity都应该包含有一个验证方法和一个初始化方法，因为在进行xml解析时就调用init，在进行map验证时就调用verify方法这样，那些string节点也是类似的，解析初始化时就把xml中配置的信息保存起来，等到验证时就通过之前保存的信息进行判断即可，不必重新解析了。

这里以解析一个integerentity为例，首先是其父类，不论是xml中哪个节点，都是实现verifyentity接口，代码如下：

public interface verifyentity {

    /**
     * 一个实体初始化，当实体被创建时将由创建方主动调用
     * @param currentele 被创建的实体节点
     * @param factory 实体创建工厂，可以通过此工厂创建entity
     */
    void init(element currentele, entityfactory factory);

    /**
     * 验证当前节点是否匹配xml的配置
     * @param value 需要验证的值
     * @return 异常字符串集
     */
    string[] verify(object value);

    /**
     * 初始化完毕后调用，传入包含所有entity的map
     * @param entitymap entitymap
     */
    void finished(map<string, verifyentity> entitymap);


}

首先解析xml时当获取到entity节点下的子节点将会通过一个工厂类创建子节点的对应实现verifyentity，之后调用init方法对当前的子节点进行解析。这里先看下integerentity的源码：

public class integerentity implements verifyentity {

    private abstractequation<integer> integerequation;

    private boolean notnull = false;
    private string notnullerrmsg;

    private string casterrmsg;

    @override
    public void init(element currentele, entityfactory factory) {
        // 开始解析当前节点<integer/>
        string name = currentele.attributevalue("name");
        // 获取节点属性casterrmsg，看是否存在casterrmsg
        this.casterrmsg = currentele.attributevalue("casterrmsg");
        if (util.isempty(this.casterrmsg)) {
            this.casterrmsg = name + ": this is not integer type.";
        } else {
            this.casterrmsg = name + ": " + this.casterrmsg;
        }
        // 获取子节点notnull
        element element = currentele.element("notnull");
        if (element != null) {
            this.notnull = true;
            this.notnullerrmsg = element.attributevalue("errmsg");
            if (util.isempty(this.notnullerrmsg)) {
                this.notnullerrmsg = name + ": this is not null";
            } else {
                this.notnullerrmsg = name + ": " + this.notnullerrmsg;
            }
        }
        // 这里是新建一个抽象的equation类，主要是因为lt和lte等等的这些节点在其他实体中也有，为了代码复用所以使用了抽象类来定义
        //这里实现后与上面解析notnull代码差异不大
        integerequation = new abstractequation<integer>(currentele, name) {
            @override
            integer valueof(string value) {
                try {
                    return integer.valueof(value);
                }catch (numberformatexception e) {
                    throw new convertexception(casterrmsg);
                }
            }
            @override
            boolean lessthan(integer value, integer lt) {
                return value < lt;
            }

            @override
            boolean greaterthan(integer value, integer gt) {
                return value > gt;
            }

            @override
            boolean lessthanorequals(integer value, integer lte) {
                return value <= lte;
            }

            @override
            boolean greaterthanorequals(integer value, integer gte) {
                return value <= gte;
            }

            @override
            boolean equals(integer value, integer eq) {
                return value.equals(eq);
            }
        };

    }
    
    @override
    public string[] verify(object value) {
        //正式验证参数是否合法
        if (value == null) {
            //如果之前解析包含notnull，则这里为true，那么将返回解析的notnullerrmsg
            if (this.notnull) {
                return new string[]{this.notnullerrmsg};
            }
            return null;
        }
        try {
            //使用上面实现的抽象类进行验证
            return integerequation.verify(integer.valueof(value.tostring()));
        }catch (numberformatexception e) {
            return new string[]{this.casterrmsg};
        }
    }

    @override
    public void finished(map<string, verifyentity> entitymap) {
        //这里是在entity解析完毕后调用，并将保存entity的map传入
    }

}

其实根据以上的代码可以看出，就是xml的节点对应着一个verifyentity实现，每一个实现都保存着其中定义的<notnull/>等信息。

实现后运行效果

这里我们的测试代码如下，其中demo.xml为设计xml所示的代码：

        //初始化mapverify，将定义好xml以数组方式传入
        final string[] xmls = {"demo.xml"};
        mapverify.init(xmls);

        final map<string, object> map = new hashmap<>(5);
        map.put("username", "12312371237123778");
        map.put("age", 1);
        map.put("birthday", "2000-07-21");
        map.put("money", 149);

        list<map<string, object>> list = new arraylist<>(2);
        map<string, object> map1 = new hashmap<>(1);
        map1.put("username", "abcab");
        map<string, object> map2 = new hashmap<>(1);
        map2.put("username", "cc");
        list.add(map1);
        list.add(map2);
        map.put("details", list);
        system.out.println(arrays.tostring(mapverify.verifybyreturnarr("user01", map)));

运行的结果如下：

[age: 岁数必须大于2]

总结

此想法是半年前的了，现在利用了空余的时间实现了自己的想法，趁热打铁写下博客，希望有这个需求的小伙伴能节省自己的时间（注：这里boolean的判断没有实现，如果有需要就需要自己动手了：-））。以后也希望自己如果有什么小想法尽量的抽时间去做，不论做的好不好。

源码已经上传至 github，包含demo

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网