java 设计模式之建造者模式

你的名字 2021-01-19 11:06 593阅读 0赞

#### 前言： ####

Builder 模式平时开发用的少，主要是有很大的缺陷：  
1.使用 builder 模式要求相关类有很多相似性  
2.类的内部方法复杂多变的不适合使用 builder 模式

##### 1.作用 #####

Builder 模式的作用就是为了对类赋值构建对象，最开始学习的时候疑问很大，构建对象用构造方法或者 set、get 方法不好吗？看了很多其他blog，个人感觉说服力不太大，唯一让我觉得有点说服力的是，使用 builder 模式赋值构建对象看起来很好看，写代码有美感。  
Builder 模式有两种表现方式，第一种是使用内部类；第二种是构建不同传参

##### 2.内部类实现 builder 模式 #####

如果用过 lombok ，应该知道 @Builder 注解，这就是 builder 模式的使用典范。这里实现一下这种方法。  
写一个带有内部类实现构建对象的类 Work

/**
     * Work 表示职业类型的类
     * name（职业名称）
     * payment（薪水）
     */
    public class Work {
        private String name;
        private int payment;
    
        /**
         * 属于 Work 的内部类
         */
        public static class Builder {
            /**
             * 复制 Work 所有的属性
             */
            private String name;
            private int payment;
    
            /**
             * 通过Builder 赋值
             */
            public Builder name(String name) {
                this.name = name;
                return this;
            }
    
            /**
             * 通过Builder 赋值
             */
            public Builder payment(int payment) {
                this.payment = payment;
                return this;
            }
    
            /**
             * 调用外部类构建方法返回外部类的对象
             */
            public Work build() {
                return new Work(this);
            }
        }
    
        /**
         * 外部类的构建方法
         */
        private Work(Builder builder) {
            name = builder.name;
            payment = builder.payment;
        }
    
        /**
         * 调用内部类
         */
        public static Work.Builder builder() {
            return new Work.Builder();
        }
    
        public String getName() {
            return name;
        }
    
        public int getPayment() {
            return payment;
        }
    }

**测试：**

public class Main {
        public static void main(String[] args) {
            Work work= Work.builder()
                    .name("医生")
                    .payment(12000)
                    .build();
            System.out.println(work.getName());
        }
    }

**结果：**

医生

**tips**  
这种方式适合本身没有复杂方法的类，如果类有很多复杂的计算方法，在内部类里面实现就会变得很麻烦，写起来就很难受。

##### 3.构建传参实现 builder 模式 #####

**首先声明一个Job类，这个类是最后生成的对象的类**

public class Job {
        private String name;
        private int payment;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getPayment() {
            return payment;
        }
    
        public void setPayment(int payment) {
            this.payment = payment;
        }
    }

**抽象建造者 Builder 类，这个类直接和Job类相关联**

public abstract class Builder {
    
        abstract Job getJob();
    
        abstract void setName(String name);
        abstract void setPayment(int payment);
    
    }

**创建两个和Job相似的类，Teacher 和 Docter，同时实现 Builder 类里面的方法**

public class Teacher extends Builder {
        private Job job = new Job();
    
        Job getJob() {
            return job;
        }
    
        @Override
        public void setName(String name) {
            job.setName(name);
        }
    
        @Override
        public void setPayment(int payment){
            job.setPayment(payment);
        }
    }

public class Doctor extends Builder{
        private Job job = new Job();
    
        Job getJob() {
            return job;
        }
    
        @Override
        public void setName(String name) {
            job.setName(name);
        }
    
        @Override
        public void setPayment(int payment){
            job.setPayment(payment);
        }
    }

**创建指挥者 Director 类，这个类直接指导构建什么样的Job**

public class Director {
        public Job build(Builder builder, String name, int payment) {
            builder.setName(name);
            builder.setPayment(payment);
            return builder.getJob();
        }
    }

**测试**

public class Main {
        public static void main(String[] args) {
            Director director = new Director();
            Teacher teacher = new Teacher();
            System.out.println(director.build(teacher, "教师", 10).getName());
    
            Doctor doctor = new Doctor();
            System.out.println(director.build(doctor, "医生", 15).getName());
        }
    }

**结果：**

教师
    医生

**tips:**  
Job：产品角色  
Builder：抽象建造者，定义产品接口  
Teacher、Doctor：具体建造者，实现Builder定义的接口，并且返回组装好的类  
Director：指挥者，属于这里面的老大，你需要生产什么产品都直接找它

##### 4.总结 #####

Builder 模式因为不好用，所以不常见，但是需要了解它的核心思想 – 让构建对象和类本身进行一定的解耦，让类构建更加灵活和美观。

**这里说一下和Factory的区别：  
Factory 模式是生产不同的对象，最后的产品是多个  
Builder 模式是生产同一个对象，只是参数不一样**