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

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

@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层由于特殊原因需要一个POJO：Face,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);