利用建设者模式告别传统的setter

利用建设者模式告别传统的setter

1.什么是建设者模式？
建造者模式属于创建型设计模式，它主要是将一个复杂对象的构建与表示分离，使用多个简单的对象一步一步构建成一个复杂的对象，它提供了一种创建对象的最佳方式。

建造者模式将复杂产品的构建过程封装在不同的方法中，使得创建过程非常清晰，能够让我们更加精确的控制复杂产品对象的创建过程，同时它隔离了复杂产品对象的创建和使用，使得相同的创建过程能够创建不同的产品。
2.使用建设者模式之前
在我们初学的时候，如果要创建这个对象会怎么写？一般会有两种方法：
1.将属性配在构造函数上，然后直接调构造器，传入参数
2.调用多个set方法

package domain;

/**
 * @Author：huangzhimin
 * @Date：2020/7/16
 * @描述：传统的对象
 **/
public class OldUserBean {

    private int userId;

    private String userName;

    private int age;

    private String phone;
    public OldUserBean(){

    };

    public OldUserBean(int userId,String userName,int age,String phone){
        this.userId = userId;
        this.userName = userName;
        this.age = age;
        this.phone = phone;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "OldUserBean{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", phone='" + phone + '\'' +
                '}';
    }
}

使用

package service;

import domain.OldUserBean;

/**
 * @Author：huangzhimin
 * @Date：2020/7/16
 * @描述：传统对象创建方式
 **/
public class OldUserService {
    public static void main(String[] args) {
        //1.利用构造函数
        OldUserBean oldUserBean = new OldUserBean(1,"黄治敏",26,"1889535");
        //2.多次调用set方法
        OldUserBean userBean = new OldUserBean();
        userBean.setUserId(2);
        userBean.setUserName("黄治敏");
        userBean.setAge(26);
        userBean.setPhone("1889535");

        System.out.println(oldUserBean);
        System.out.println(userBean);
    }
}

存在的问题：
1.日常使用的话，应该是多次调用set方法比较多的，而set方法写起来不太方便，如果对象的属性较多，也会有一大串的set代码。显得很low.
2.从代码层面上，构造器传参的代码是最简短的，但在现实层面上我们很难每次都可以通过构造器传参的方式去完成对象的创建（更多的时候每个对象的属性都是不一致的）。
3.使用了建设者模式以后

package service;

import domain.UserBean;

/**
 * @Author：huangzhimin
 * @Date：2020/7/16
 * @描述：测试手写的建设者模式
 **/
public class UserService {
    public static void main(String[] args) {
        UserBean.Builder builder = new UserBean.Builder();
        UserBean userBean = builder.setUserId(20)
                .setUserName("黄治敏")
                .setAge(26)
                .setPhone("1889535").build();
        System.out.println(userBean.toString());
    }
}

builer链式调用代码变得更加简练，且可读性也更高了。
4.自己实现建设者模式
实现方式：
1.在实体类上创建一个静态内部类 Builder，Builder拥有实体类所有的属性
2.在实体类上创建一个private的构造函数，参数为Builder类型，里边将Builder的属性赋值给实体类的属性
3.在Builder内部类创建实体类属性的赋值方法，返回值是Builder
4.Builder内部类创建一个build方法，返回实体类实例
具体实现代码如下

package domain;

/**
 * @Author：huangzhimin
 * @Date：2020/7/16
 * @描述：手写建设者模式 1.在domain类上创建一个静态内部类 Builder，Builder拥有domain所有的属性
 * 2.在domain类上创建一个private的构造函数，参数为Builder类型，里边将Builder的属性赋值给domain的属性
 * 3.在Builder内部类创建domain属性的赋值方法，返回值是Builder
 * 4.Builder内部类创建一个build方法，返回domain实例
 **/
public class UserBean {

    private int userId;

    private String userName;

    private int age;

    private String phone;

    /**
     * 在domain类上创建一个private的构造函数，参数为Builder类型，里边是将Builder的属性赋值给domain的属性
     *
     * @param builder
     */
    private UserBean(Builder builder) {
        this.userId = builder.userId;
        this.userName = builder.userName;
        this.age = builder.age;
        this.phone = builder.phone;
    }

    /**
     * 创建一个静态内部类
     */
    public static class Builder {
        private int userId;

        private String userName;

        private int age;

        private String phone;

        public Builder setUserId(int userId) {
            this.userId = userId;
            return this;
        }

        public Builder setUserName(String userName) {
            this.userName = userName;
            return this;
        }

        public Builder setAge(int age) {
            this.age = age;
            return this;
        }

        public Builder setPhone(String phone) {
            this.phone = phone;
            return this;
        }

        public UserBean build() {
            return new UserBean(this);
        }
    }

    @Override
    public String toString() {
        return "UserBean{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", phone='" + phone + '\'' +
                '}';
    }
}

具体使用见第三点。
5.利用lombok工具实现建设者模式
如果工程中运用了lombok插件那么实现起来就非常方便了
1.引入相关的依赖

<!--lombok组件 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.16</version>
        </dependency>

2.在实体类上添加@Builder注解

package domain;

import lombok.Builder;
import lombok.ToString;

/**
 * @Author：huangzhimin
 * @Date：2020/7/16
 * @描述：利用lombok  使用建设者模式
 * 使用Builder注解就可以轻松实现
 **/

@Builder
@ToString
public class GroupBean {
    private int deptId;
    private String deptName;
    private String deptUser;
}

3.使用方式

package service;

import domain.GroupBean;

/**
 * @Author：huangzhimin
 * @Date：2020/7/16
 * @描述：
 **/
public class GroupService {
    public static void main(String[] args) {
        GroupBean groupBean = GroupBean.builder()
                .deptId(1)
                .deptName("大数据研发部")
                .deptUser("黄治敏").build();
        System.out.println(groupBean);
    }
}

好了，文字到此结束，以后再写代码，不要在写一堆的setter方法了哦。

本文地址：https://blog.csdn.net/qq_37140416/article/details/107376957