记一次关于参数过长的代码优化

2018-08-12  本文已影响0人  dengchengchao_

背景:
现在有一个POJO作为HTTP Controller参数以及Service参数。
ControllerRESTFul风格
具体如下:

@RequestMapping(value = "xxxxx/apps/{app_id}/groups/{group_id}/faces/{face_id}", method = RequestMethod.POST)
    public ResultMsg add(@PathVariable("face_id") String faceId,
                         @PathVariable("app_id") String appId,
                         @PathVariable("group_id") String groupId,
                         @RequestBody FaceRequestBody faceBody
    ) {
        Face face = new Face(faceId,groupId,appId,faceBody.getName(),faceBody.getImage(),faceBody.getRemark(),false);
        return faceService(face);
    }

可以看到Service层由于特殊原因需要一个POJOFace,Face包含7个属性,并且每个属性都是必须的。

public class Face {

    @JSONField(name = "face_id")
    private String id;

    @JSONField(name = "face_name")
    private String name;


    private String image;

    @JSONField(name = "face_remark")
    private String remark;


    @JSONField(serialize = false)
    private boolean obsolete;

    @JSONField(name = "group_id")
    private String groupId;

    @JSONField(name = "app_id")
    private String appId;
     
    //setter & getter
}

Face 的构造器参数有7个,基本每个都是String类型,这样及其不方便并且容易出错,想着用建造者模式优化。


思路:可以看见,由于没有可选参数,于是传统的建造者模式是不适用于现在的场景,但是我们可以借鉴建造者模式的返回this的“连点”技巧。

  1. 分析7个参数,从应用场景来说,7个参数可以分为3类,````id类,info类,obsolete```类,因此我们可以创建3个嵌套类。
  2. 如果直接暴力拆分为3个类,代码依然不美观,每次新建一个Face类都要new其他3个类。
    Infos infos=new Infos(...);
    Ids id=new Ids(...);
    Obsolete obsolete=new Obsolete(...);
    Face face = new Face(infos,id,obsolete);
    
    
  3. 正如最开始所说,借鉴建造者模式的“连点”语法技巧。
    /**
     * Face 构造器
     * 由于Face参数过多,并且每个参数都是必须参数。
     * 此嵌套类可以将相关属性分开构造,防止因为参数过多传错参数
     * 使用方法如下:
     * Face face = Face.buildIds(faceId,groupId,appId).
     *                  buildFaceInfo(name,image,remark).
     *                  buildObsolete(false);
     */
     
    //第一层,返回下一层的新对象
    public static FaceInfoBuilder buildIds(String id, String groupId, String appId) {
        return new FaceInfoBuilder(id, groupId, appId);
    }

    public static final class FaceInfoBuilder {

        private String id;
        private String groupId;
        private String appId;

        private FaceInfoBuilder(String id, String groupId, String appId) {
            this.id = id;
            this.groupId = groupId;
            this.appId = appId;
        }
        //第二层,返回第三层的对象
        public FaceObsoleteBuilder buildFaceInfo(String name, String image, String remark) {
            return new FaceObsoleteBuilder(id, groupId, appId, name, image, remark);
        }

        public static final class FaceObsoleteBuilder {
            private String id;
            private String groupId;
            private String appId;
            private String image;
            private String name;
            private String remark;

            private FaceObsoleteBuilder(String id, String groupId, String appId, String image, String name, String remark) {
                this.id = id;
                this.groupId = groupId;
                this.appId = appId;
                this.image = image;
                this.name = name;
                this.remark = remark;
            }
            //最后一层,返回Fac对象
            public Face buildObsolete(boolean obsolete) {
                return new Face(id, groupId, appId, name, image, remark, obsolete);
            }
        }

    }

核心思想:使用3个嵌套类,每一层返回下一层的嵌套类,同时将构造函数设为private类型,防止外部实例化。

优化过后新建一个Face对象如下:

Face face = Face.buildIds(faceId,groupId,appId).
                 buildFaceInfo(name,image,remark).
                 buildObsolete(false);
上一篇下一篇

猜你喜欢

热点阅读