乐趣区

关于java:lombok中的builder注解居然是一种设计模式让我们了解一下超级实用的建造者模式吧

jiezi

​

 lombok 中的 builder 注解实质上是为你生成了一个结构器 Builder 类，通过这个类咱们能够结构出带此注解的对象。实质上它实现了设计模式中一种经典的模式：建造者模式

1. 意识：

①一句话来说：封装一个简单对象的构建过程，并能够按步骤结构。因为须要对对象一步步建造起来，所以称为建造者模式。

②将简单产品的构建过程封装合成在不同的办法中，使得创立过程十分清晰，可能让咱们更加准确的管制简单产品对象的创立过程，同时它隔离了简单产品对象的创立和应用，使得雷同的创立过程可能创立不同的产品。然而若外部变动简单，会有很多的建造类。

2.UML 类图：

​

UML 阐明：Product（产品角色）：一个具体的产品对象。Builder（形象建造者）：创立一个 Product 对象的各个部件指定的形象接口。ConcreteBuilder（具体建造者）：实现形象接口，构建和拆卸各个部件。Director（指挥者）：构建一个应用 Builder 接口的对象。它次要是用于创立一个简单的对象。它次要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责管制产品对象的生产过程。

3. 代码如下：

1. 产品类：

public class Product {
    private String part1;// 能够是任意类型
    private String part2;
    private String part3;
 /**set get 办法省略
}

2. 形象建造者 

public abstract class Builder{Product product = new Product();
    public abstract void buildPart1();
    public abstract void buildPart2();
    public abstract void buildPart3();
    public Product getResult(){return product;};
}

3. 具体建造者 

public class ConcreteBuilder extends Builder {

    @Override
    public void buildPart1() {System.out.println("建造 part1");
    }

    @Override
    public void buildPart2() {System.out.println("建造 part2");
    }

    @Override
    public void buildPart3() {System.out.println("建造 part3");
    }
}

4. 指挥者：

public class Director {

    private Builder builder;

    public Director(Builder builder) {this.builder = builder;}

    public Product build(){builder.buildPart1();
        builder.buildPart2();
        builder.buildPart3();
        return builder.getResult();}
}

5. 客户端 

public class Client {

    @Test
    public void test() {Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        director.build();}

}

6. 执行后果

​

4. 总结

长处 ：1、建造者独立，易扩大。将简单产品的构建过程封装合成在不同的办法中，使得创立过程十分清晰，可能让咱们更加准确的管制简单产品对象的创立过程。

2、便于管制细节危险。它隔离了简单产品对象的创立和应用，使得雷同的创立过程可能创立不同的产品。

毛病 ：1、产品必须有共同点，范畴有限度。

2、如外部变动简单，会有很多的建造类，导致系统宏大。

利用场景 1、须要生成的对象具备简单的内部结构。2、须要生成的对象外部属性自身相互依赖。

5. 利用场景

JAVA 中的 StringBuilder。

六、集体领会

设计模式是一种解决问题的思维和形式，不要生吞活剥，为了设计模式而模式。

PS：转载请注明出处 作者: TigerChain
地址: www.jianshu.com/p/300cbb9ee…
本文出自 TigerChain 简书 人人都会设计模式

教程简介

  • 1、浏览对象 本篇教程适宜老手浏览，新手间接略过
  • 2、教程难度 高级，自己程度无限，文章内容难免会呈现问题，如果有问题欢送指出，谢谢
  • 3、Demo 地址：github.com/githubchen0…

注释

一、什么是建造者模式

1、生存中的建造者模式

1、盖房子

咱们在生活中盖房子，个别就是打地基，盖框架「用砖头或钢筋混凝土」，而后是粉刷。基本上就是这个路子。当然咱们这些工作全副能够本人做，可也以找几个工人去干，当然还能够能够间接找一个设计师，间接说我就要这样的房子，而后就不论了，最初问设计师「设计师给一张纸给工人，工人就啪啪的干了」验收房子即可「至于你是如何建的过程我不关怀，我只有后果」— 这就是建造者模式

2、组装电脑

咱们买的电脑都是由主板、内存、cpu、显卡等组成，如何把这些货色组装起来给用户这就是建造者模式的作用，不同的人对电脑的配置需要不一样的「打游戏的对显卡要求高」，然而电脑形成部件是固定的，咱们找电脑城的装机人员把电脑装起来这一过程就是建造模式

3、软件开发

咱们开发一款产品，须要技术主管、产品经理、苦逼的程序员。在这里，产品经理就是指挥者「Director」和客户沟通，理解产品需要，技术主管是形象的建造者 [Builder]，让猿们杂做就杂做，而程序员就是膂力劳动者「即具体的建造者，依照技术主管下发的工作去做」— 这就是一个靠近完满的建造者模式「为什么说靠近呢？因为没有百分之百，靠：又遗记吃药了」

2、程序中的建造者模式

建造者模式的定义

将一个简单对象的构建与它的示意拆散，使得同样的构建过程能够创立不同的示意，这是官网定义，艰深的说就是：建造者模式就是如何一步步构建一个蕴含多个组成部件的对象，雷同的构建过程能够创立不同的产品

建造者模式的特点

建造者模式是一种创立型模式，实用于那些流程固定「程序不肯定固定」，建造的指标对象会有所扭转这种场景「比方画一条狗，这个指标不变，然而不同的是有黄狗，胖狗，瘦狗等」，还有一种场景是代替多参数结构器

建造者模式的作用

  • 1、用户不晓得对象的建造过程和细节就能够创立出简单的对象「屏蔽了建造的具体细节」
  • 2、用户只需给出简单对象的内容和类型能够创立出对象
  • 3、建造者模工按流程一步步的创立出简单对象

建造者模式的构造

角色 类别 阐明
Builder 接口或抽象类 形象的建造者，不是必须的
ConcreateBuilder 具体的建造者 能够有多个「因为每个建造格调可能不一样」
Product 一般的类 具体的产品「即被建造的对象」
Director 导演也叫指挥者 统一指挥建造者去建造指标，导演不是必须的

建造者模式简略的 UML

​

二、建造者模式的举例

1、组装电脑

小明想组装一个台式电脑，小明对电脑配置无所不通，就间接跑到电脑城给装机老板说我要一台打游戏十分爽的电脑，麻烦你给装一下「配置什么的你给我举荐一下吧」，于是老板就让它的员工「小美」按小明的要求装了一个性能灰常牛 B 的电脑，1 个小时后电脑装好了，小明交钱拿电脑走人。不一会儿小张又来了，要一个满足平时写文章就能够的电脑，老板针对小张的要求给不同的装机配置。不同的人有不同的配置计划「然而装机流程是一样的」，这就是一个典型的建造者模式

组装电脑简略的 UML

​

依据 UML 撸码

  • 1、创立被建造的对象电脑 — Computer.java
/**
 * Created by TigerChain
 * 产品类 -- 被建造的对象
 */
public class Computer {
    private String cpu ; // cpu
    private String hardDisk ; // 硬盘
    private String mainBoard ; // 主板
    private String memory ; // 内存
    ... 省略 getter 和 setter
}
复制代码
  • 2、形象的建造者 — Builder.java
/**
 * Created by TigerChain
 * 形象的建造者，即装电脑的步骤
 * 至于装置什么型号的主板，不是我关怀，而是具体的建造者关怀的
 */
public interface Builder {
    // 装置主板
    void createMainBoard(String mainBoard) ;
    // 装置 cpu
    void createCpu(String cpu) ;
    // 装置硬盘
    void createhardDisk(String hardDisk) ;
    // 装置内存
    void createMemory(String memory) ;
    // 组成电脑
    Computer createComputer() ;}

复制代码
  • 3、具体建造者，也就是装机工人小美 — AssemblerBuilder.java
/**
 * Created by TigerChain
 * 具体的建造者，这里是商场的一个装机人员
 */
public class AssemblerBuilder implements Builder {private Computer computer = new Computer() ;
    @Override
    public void createCpu(String cpu) {computer.setCpu(cpu);
    }

    @Override
    public void createhardDisk(String hardDisk) {computer.setHardDisk(hardDisk);
    }

    @Override
    public void createMainBoard(String mainBoard) {computer.setMainBoard(mainBoard);
    }

    @Override
    public void createMemory(String memory) {computer.setMemory(memory);
    }

    @Override
    public Computer createComputer() {return computer;}
}
复制代码
  • 4、还有老板「” 指手画脚的人 ”」安顿装机工工作 — Direcror.java
/**
 * Created by TigerChain
 * 申明一个导演类「指挥者，这里能够装电脑的老板」，用来指挥组装过程，也就是组装电脑的流程
 */
public class Director {
    private Builder builder ;
    // 应用多态，装机工十分多，我管你小美，小兰，小猪，我通通收了
    public Direcror(Builder builder){this.builder = builder ;}
    // 老板最初只想看到装成的成品 --- 要交到客户手中
    public Computer createComputer(String cpu,String hardDisk,String mainBoard,String memory){
        // 具体的工作是装机工去做
        this.builder.createMainBoard(mainBoard);
        this.builder.createCpu(cpu) ;
        this.builder.createMemory(memory);
        this.builder.createhardDisk(hardDisk);
        return this.builder.createComputer() ;}
}
复制代码
  • 5、测试类 
/**
 * Created by TigerChain
 * 测试类
 */
public class Test {public static void main(String args[]){
      // 装机员小美
      Builder builder = new AssemblerBuilder() ;
      // 老板把小明的需要转给小美
      Direcror direcror = new Direcror(builder) ;
      // 老板最初拿到成品机子，工作全由小美去做
      Computer computer = direcror.createComputer("Intel 酷睿 i9 7900X","三星 M9T 2TB（HN-M201RAD）","技嘉 AORUS Z270X-Gaming 7","科赋 Cras II 红灯 16GB DDR4 3000") ;
      System.out.println("小明这台电脑应用的是：\n"+computer.getMainBoard()+"主板 \n"+computer.getCpu()+"CPU\n"+computer.getHardDisk()+"硬盘 \n"+computer.getMainBoard()+"内存 \n");

  }
}
复制代码
  • 6、运行查看后果

​

怎么样，至于小张，小猪要装机把本人要的配置给老板即可，而后老板如何装机不必你管，你就等着收装好的机子吧

2、盖房子

盖房子的根本步骤和流程是固定的无非就是打地基、盖框架、而后浇筑「至于盖平房、还是楼房那是每个客户的具体需要」。总体来说盖房子以有以三种形式：

  • 1、本人盖房子「没有方法有的人就是牛 B , 本人设计，本人入手，当然这属于小房子，你让一个人盖个 32 层让我看看」
  • 2、想盖房子的人是一个包工头，本人找一帮工人本人就把房子搞定了
  • 3、想盖房子的人就是一个普通人，啥也不会，找一个设计师说“我就要盖个房子，南北通透，四秀常春”，设计师说没有问题，设计师把设计进去的图纸扔给包工头说：“就照这个样子盖”，包工头拿着图纸给工人们分工派活，最初竣工

盖房子建造者模式简略的 UML

​

依据 UML 撸码

  • 1、房子对象 House.java
/**
 * Created by TigerChain
 * 最终的产品 --- 房子
 */
public class House {
    // 打地基
    private String foundation ;
    // 盖框架
    private String frame ;
    // 浇筑
    private String pouring ;
    ... 省略 setter 和 getter 
}
复制代码
  • 2、形象建造者「包工头」HouseBuilder.java
public interface HouseBuilder {
    // 打地基
    void doFoundation() ;
    // 盖框架
    void doFrame() ;
    // 浇灌
    void dpPouring() ;
    // 房子建成 
    House getHouse() ;}
复制代码
  • 3、具体建造者「工人」– 盖平房 PingFangBuilder.java
/**
 * Created by TigerChain
 * 盖平房
 */
public class PingFangBuilder implements HouseBuilder {private House house = new House() ;

    @Override
    public void doFoundation() {house.setFoundation("盖平房的地基");
    }

    @Override
    public void doFrame() {house.setFrame("盖平房的框架");
    }

    @Override
    public void dpPouring() {house.setPouring("盖平房不必浇灌，间接人工手刷就能够");
    }

    @Override
    public House getHouse() {return house;}
}
复制代码
  • 4、具体建造者「工人」– 盖楼房 LouFangBuilder.java
/**
 * Created by TigerChain
 * 盖楼房
 */
public class LouFangBuilder implements HouseBuilder {private House house = new House() ;
    @Override
    public void doFoundation() {house.setFoundation("盖楼房的地基就打十米深");
    }

    @Override
    public void doFrame() {house.setFrame("楼房的框架要应用十分坚硬钢筋混凝土");
    }

    @Override
    public void dpPouring() {house.setPouring("楼房拿个罐车把框架拿混凝土灌满即可");
    }

    @Override
    public House getHouse() {return house;}
}
复制代码
  • 5、指挥者「设计师」HouseDirector.java
/**
 * Created by TigerChain
 * 设计师
 */
public class HouseDirector {
    // 指挥包工头
    public void buildHouse(HouseBuilder houseBuilder){houseBuilder.doFoundation();
        houseBuilder.doFrame();
        houseBuilder.dpPouring();}
}

复制代码
  • 6、测试一下 Test.java
/**
 * Created by TigerChain
 * 测试
 */
public class Test {public static void main(String args[]){

        // 形式一、客户本人盖房子，亲力亲为
        System.out.println("======== 客户本人建房子，必须晓得盖房的细节 ========");
        House house = new House() ;
        house.setFoundation("用户本人建造房子：打地基");
        house.setFrame("用户本人建造房子：盖框架");
        house.setPouring("用户本人建造房子：浇筑");

        System.out.println(house.getFoundation());
        System.out.println(house.getFrame());
        System.out.println(house.getPouring());

        // 形式二、客户找一个建造者盖房子「充当包工头角色」，然而要晓得如何盖房子「调用建造者盖房子的程序」System.out.println("======== 客户间接找盖房子的工人「建造者」，客户要调用建造者办法去盖房子，客户必须得晓得房子如何造 ========");

        HouseBuilder houseBuilder = new PingFangBuilder() ;
        houseBuilder.doFoundation();
        houseBuilder.doFrame();
        houseBuilder.dpPouring();
        House house1 = houseBuilder.getHouse() ;
        System.out.println(house1.getFoundation());
        System.out.println(house1.getFrame());
        System.out.println(house1.getPouring());

        // 形式三、应用建造者模式，找一个设计师「设计师拉一帮建造者去干活」，通知他我想要什么样的房子，最初客户只问设计师要房子即可
        System.out.println("======== 客户间接找一个设计师，设计师统一指挥建造者盖房子，房子杂盖，客户不关怀，最初只是找设计师要房子即可 ========");

        HouseBuilder pingFangBuilder = new PingFangBuilder() ;
        HouseDirector houseDirector = new HouseDirector() ;
        houseDirector.buildHouse(pingFangBuilder);
        House houseCreateByBuilder = pingFangBuilder.getHouse() ;

        System.out.println(houseCreateByBuilder.getFoundation());
        System.out.println(houseCreateByBuilder.getFrame());
        System.out.println(houseCreateByBuilder.getPouring());
    }
}

复制代码

咱们比照了三种形式，本人盖房子，找工人盖房子，找设计师盖房子来逐渐感受一下建造者模式的长处

  • 6、运行查看后果

​

能够看到最初一种最舒服，盖房子的时候间接外包给设计师本人就不必管了，到时候问设计师要建好的成品房子即可，这样对客户来说具体如何盖房子我不须要晓得，屏蔽细节「只能说有钱就是任性」

​

退出移动版