资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/设计模式之建造者模式

设计模式之建造者模式

banana_pi / 842人阅读

摘要：建造者实现抽象类的所有未实现的方法，具体来说一般是两项任务组建产品返回组建好的产品。

0x01.定义与类型

定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

用户只需指定需要建造的类型就可以得到他们，建造过程及细节不需要知道

类型：创建型

实现建造模式的两种方式

1.抽象建造者

UML：

Java实现

</>复制代码 
  1. /**
  2. * 教练类，封装了具体构建的细节
  3. */
  4. public class Coach {
  5.     private AProductBuilder productBuilder;
  6.     public void setProductBuilder(AProductBuilder productBuilder) {
  7.         this.productBuilder = productBuilder;
  8.     }
  9.     public Product createProduct(String property) {
  10.         productBuilder.buildProperty(property);
  11.         return this.productBuilder.makeProduct();
  12.     }
  13. }
  14. /**
  15. * 抽象的构建，每添加新的构建方式，只需要继承这个抽象类即可
  16. */
  17. public abstract class AProductBuilder {
  18.     /**
  19.     * 构建具体属性，只是mock一个，可以有很多个
  20.     * @param property
  21.     */
  22.     abstract void buildProperty(String property);
  23.     /**
  24.     * 返回被构建的对象
  25.     * @return
  26.     */
  27.     abstract Product makeProduct();
  28. }
  29. /**
  30. * 产品具体的构建类
  31. */
  32. public class ProductActualBuilder extends AProductBuilder {
  33.     private Product product = new Product();
  34.     @Override
  35.     void buildProperty(String property) {
  36.         product.setProperty(property);
  37.     }
  38.     @Override
  39.     Product makeProduct() {
  40.         return product;
  41.     }
  42. }
  43. /**
  44. * 产品类
  45. */
  46. public class Product {
  47.     /**
  48.     * 产品实现细节，可以很多个属性，这里只mock了一个
  49.     */
  50.     private String property;
  51.     public void setProperty(String property) {
  52.         this.property = property;
  53.     }
  54.     public String getProperty() {
  55.         return property;
  56.     }
  57. }

测试应用类

</>复制代码 
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Coach coach = new Coach();
  4.         coach.setProductBuilder(new ProductActualBuilder());
  5.         Product product = coach.createProduct("测试属性");
  6.         System.out.println(product.getProperty());
  7.     }
  8. }

输出结果

</>复制代码 
  1. 测试属性

抽象建造者模式中的元素

产品类：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的类，而非抽象类。实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。

抽象建造者：引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。

建造者：实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。

教练类：负责调用适当的建造者来组建产品，教练类一般不与产品类发生依赖关系，与教练类直接交互的是建造者类。一般来说，教练类被用来封装程序中易变的部分。

2.使用静态内部类和链式调用

UML：

Java实现

</>复制代码 
  1. /**
  2. * 产品类
  3. */
  4. public class Product {
  5.    /**
  6.     * 产品属性，只是举了一个例子，可以有很多个
  7.     */
  8.    private String property;
  9.    /**
  10.     * 产品的构建 构造方法
  11.     * @param productBuilder
  12.     */
  13.    public Product (ProductBuilder productBuilder) {
  14.        this.property = productBuilder.property;
  15.    }
  16.    public String getProperty() {
  17.        return property;
  18.    }
  19.    public void setProperty(String property) {
  20.        this.property = property;
  21.    }
  22.    /**
  23.     * 产品构建类
  24.     */
  25.    public static class ProductBuilder {
  26.        private String property;
  27.        public ProductBuilder builderProperty (String property) {
  28.            this.property = property;
  29.            return this;
  30.        }
  31.        public Product build() {
  32.            return new Product(this);
  33.        }
  34.    }
  35. }

输出结果

</>复制代码 
  1. 测试属性

静态内部类建造者模式的元素

产品：最终我们需要的结果，较为复杂或创建过程较为复杂的对象。

产品的构建类：builder类是整个建造者模式的核心，具体由两项任务，一是构建产品细节，二是返回构建好的产品。

0x02.适用场景

如果一个对象有非常复杂的内部结构（很多属性），这个时候可以考虑适用建造者模式。

想把复杂对象的创建和使用分离的时候。

0x03.优点

封装性好，创建和使用分离，使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的。

扩展性好，建造类之间独立，一定程度上解耦，如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。

0x04.缺点

会产生多余的Builder对象。

产品内部发生变化，建造者都要修改，成本较大。

0x05.具体Java实现

场景介绍：课程有课程名字，视频，PPT和手记，举例构建这个对象

1.抽象建造类的实现

具体的实现

</>复制代码 
  1. /**
  2. * 课程教练类
  3. */
  4. public class Coach {
  5.     private CourseBuilder courseBuilder;
  6.     public void setCourseBuilder(CourseBuilder courseBuilder) {
  7.         this.courseBuilder = courseBuilder;
  8.     }
  9.     public Course makeCourse(String courseName,
  10.                             String coursePPT,
  11.                             String courseVideo,
  12.                             String courseArticle,
  13.                             String courseQA) {
  14.         this.courseBuilder.buildCourseName(courseName);
  15.         this.courseBuilder.buildCoursePPT(coursePPT);
  16.         this.courseBuilder.buildCourseArticle(courseArticle);
  17.         this.courseBuilder.buildCourseVideo(courseVideo);
  18.         this.courseBuilder.buildCourseQA(courseQA);
  19.         return this.courseBuilder.makeCourse();
  20.     }
  21. }
  22. /**
  23. * 建造者的具体实现与应用
  24. */
  25. public abstract class CourseBuilder {
  26.     public abstract void buildCourseName(String courseName);
  27.     public abstract void buildCoursePPT(String coursePPT);
  28.     public abstract void buildCourseVideo(String courseVideo);
  29.     public abstract void buildCourseArticle(String courseArticle);
  30.     public abstract void buildCourseQA(String courseQA);
  31.     public abstract Course makeCourse();
  32. }
  33. /**
  34. * 建造者的具体实现
  35. */
  36. public class CourseActualBuilder extends CourseBuilder {
  37.     private Course course = new Course();
  38.     @Override
  39.     public void buildCourseName(String courseName) {
  40.         course.setCourseName(courseName);
  41.     }
  42.     @Override
  43.     public void buildCoursePPT(String coursePPT) {
  44.         course.setCoursePPT(coursePPT);
  45.     }
  46.     @Override
  47.     public void buildCourseVideo(String courseVideo) {
  48.         course.setCourseVideo(courseVideo);
  49.     }
  50.     @Override
  51.     public void buildCourseArticle(String courseArticle) {
  52.         course.setCourseArticle(courseArticle);
  53.     }
  54.     @Override
  55.     public void buildCourseQA(String courseQA) {
  56.         course.setCourseQA(courseQA);
  57.     }
  58.     @Override
  59.     public Course makeCourse() {
  60.         return course;
  61.     }
  62. }
  63. /**
  64. * 具体产品的实例：课程
  65. */
  66. public class Course {
  67.     private String courseName;
  68.     private String coursePPT;
  69.     private String courseVideo;
  70.     private String courseArticle;
  71.     //question & answer
  72.     private String courseQA;
  73.     public String getCourseName() {
  74.         return courseName;
  75.     }
  76.     public void setCourseName(String courseName) {
  77.         this.courseName = courseName;
  78.     }
  79.     public String getCoursePPT() {
  80.         return coursePPT;
  81.     }
  82.     public void setCoursePPT(String coursePPT) {
  83.         this.coursePPT = coursePPT;
  84.     }
  85.     public String getCourseVideo() {
  86.         return courseVideo;
  87.     }
  88.     public void setCourseVideo(String courseVideo) {
  89.         this.courseVideo = courseVideo;
  90.     }
  91.     public String getCourseArticle() {
  92.         return courseArticle;
  93.     }
  94.     public void setCourseArticle(String courseArticle) {
  95.         this.courseArticle = courseArticle;
  96.     }
  97.     public String getCourseQA() {
  98.         return courseQA;
  99.     }
  100.     public void setCourseQA(String courseQA) {
  101.         this.courseQA = courseQA;
  102.     }
  103.     @Override
  104.     public String toString() {
  105.         return "Course{" +
  106.                 "courseName="" + courseName + """ +
  107.                 ", coursePPT="" + coursePPT + """ +
  108.                 ", courseVideo="" + courseVideo + """ +
  109.                 ", courseArticle="" + courseArticle + """ +
  110.                 ", courseQA="" + courseQA + """ +
  111.                 "}";
  112.     }
  113. }

测试与应用

</>复制代码 
  1. /**
  2. * 测试与应用
  3. */
  4. public class Test {
  5.     public static void main(String[] args) {
  6.         CourseBuilder courseBuilder = new CourseActualBuilder();
  7.         Coach coach = new Coach();
  8.         coach.setCourseBuilder(courseBuilder);
  9.         Course course = coach.makeCourse(
  10.                 "Java设计模式精讲",
  11.                 "Java设计模式精讲PPT",
  12.                 "Java设计模式精讲视频",
  13.                 "Java设计模式精讲手记",
  14.                 "Java设计模式精讲问答"
  15.                 );
  16.         System.out.println(course);
  17.     }
  18. }

输出结果

</>复制代码 
  1. Course{courseName="Java设计模式精讲", coursePPT="Java设计模式精讲PPT", courseVideo="Java设计模式精讲视频", courseArticle="Java设计模式精讲手记", courseQA="Java设计模式精讲问答"}

UML类图

2.静态内部类建造者模式

具体的实现

</>复制代码 
  1. /**
  2.  * 课程类
  3.  */
  4. public class Course {
  5.     private String courseName;
  6.     private String coursePPT;
  7.     private String courseVideo;
  8.     private String courseArticle;
  9.     //question & answer
  10.     private String courseQA;
  11.     public Course(CourseBuilder courseBuilder) {
  12.         this.courseName = courseBuilder.courseName;
  13.         this.courseArticle = courseBuilder.courseArticle;
  14.         this.coursePPT = courseBuilder.coursePPT;
  15.         this.courseVideo = courseBuilder.courseVideo;
  16.         this.courseQA = courseBuilder.courseQA;
  17.     }
  18.     @Override
  19.     public String toString() {
  20.         return "Course{" +
  21.                 "courseName="" + courseName + """ +
  22.                 ", coursePPT="" + coursePPT + """ +
  23.                 ", courseVideo="" + courseVideo + """ +
  24.                 ", courseArticle="" + courseArticle + """ +
  25.                 ", courseQA="" + courseQA + """ +
  26.                 "}";
  27.     }
  28.     /**
  29.      * 课程静态builder类
  30.      */
  31.     public static class CourseBuilder {
  32.         private String courseName;
  33.         private String coursePPT;
  34.         private String courseVideo;
  35.         private String courseArticle;
  36.         //question & answer
  37.         private String courseQA;
  38.         public CourseBuilder buildCourseName(String courseName) {
  39.             this.courseName = courseName;
  40.             return this;
  41.         }
  42.         public CourseBuilder buildCoursePPT(String coursePPT) {
  43.             this.coursePPT = coursePPT;
  44.             return this;
  45.         }
  46.         public CourseBuilder buildCourseVideo(String courseVideo) {
  47.             this.courseVideo = courseVideo;
  48.             return this;
  49.         }
  50.         public CourseBuilder buildCourseArticle(String courseArticle) {
  51.             this.courseArticle = courseArticle;
  52.             return this;
  53.         }
  54.         public CourseBuilder buildCourseQA(String courseQA) {
  55.             this.courseQA = courseQA;
  56.             return this;
  57.         }
  58.         public Course build() {
  59.             return new Course(this);
  60.         }
  61.     }
  62. }

测试与应用

</>复制代码 
  1. /**
  2.  * 测试与应用
  3.  */
  4. public class Test {
  5.     public static void main(String[] args) {
  6.         Course course1 = new Course.CourseBuilder()
  7.                 .buildCourseName("Java课程精讲")
  8.                 .buildCourseArticle("Java课程精讲手机")
  9.                 .buildCoursePPT("Java课程精讲PPT")
  10.                 .buildCourseVideo("Java课程精讲视频")
  11.                 .build();
  12.         System.out.println(course1.toString());
  13.         Course course2 = new Course.CourseBuilder()
  14.                 .buildCourseName("Java课程精讲")
  15.                 .buildCourseVideo("Java课程精讲视频")
  16.                 .build();
  17.         System.out.println(course2.toString());
  18.     }
  19. }

输出结果

</>复制代码 
  1. Course{courseName="Java课程精讲", coursePPT="Java课程精讲PPT", courseVideo="Java课程精讲视频", courseArticle="Java课程精讲手机", courseQA="null"}
  2. Course{courseName="Java课程精讲", coursePPT="null", courseVideo="Java课程精讲视频", courseArticle="null", courseQA="null"}

UML

0x06.建造者和工厂对比

建造者和工厂模式都属于创建类的设计模式，本身的场景很相似。

建造者：注重方法的调用顺序，建造复杂的产品，由很多复杂的部件组成，不止创建产品还要知道产品的组成。

工厂：注重产品，产品基本都是一个样子，只是生产产品，不关心产品组成。

0x07.源码中的建造者模式

StringBuilder

StringBuffer

Guava: ImtableSet

CacheBuilder

Spring: BeanDefinitionBuilder

MyBatis: SqlSessionFactoryBuilder

0x08.样例代码

建造者模式：https://github.com/sigmako/design-pattern/tree/master/builder

0x09.参考

慕课网设计模式精讲: https://coding.imooc.com/class/270.html

23种设计模式（4）：建造者模式: https://blog.csdn.net/zhengzhb/article/details/7375966

GPU云服务器 云服务器 建造者模式 建造者设计模式 android建造者模式 策略者模式

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/74860.html

相关文章

  • 一天一个设计模式之JS实现——建造者模式

    摘要：参考文章设计模式之建造者模式一什么是建造者模式建造者模式是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 参考文章：java设计模式之建造者模式 一、什么是建造者模式建造者模式：是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓...

    boredream 评论0 收藏0

  • Java设计模式之（三）——建造者模式

    摘要：建造者模式实现建造者模式实现创建抽象建造者类创建具体建造者类。建造者模式使用场景建造者模式使用场景相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。1、什么是建造者模式 Separate the construction of a complex object from its representation so that the same constructi...

    Forelax 评论0 收藏0

  • #yyds干货盘点#Java设计模式之（三）——建造者模式

    1、什么是建造者模式Separate the construction of a complex object from its representation so that the same construction process can create different representations.将一个复杂对象的构建与它的表示分离， 使得同样的构建过程可以创建不同的表示。 说人话：将构...

    番茄西红柿 评论0 收藏2637

  • 设计模式之建造者设计模式

    摘要：本质建造者设计模式分离了对象子组件的构造过程和组装过程，实现了构建与组装的解耦，不同的构建器相同的组装顺序以及相同的构建器不同的组装顺序都可以创建出不同的对象，使得构建与组装充分解耦，进而实现构建算法与组装算法的解耦，从而实现更好的复用。 这是设计模式系列的第二篇——建造者设计模式，我希望推送的文章是一个系列的，尽量保持一样的写作风格，尽量把我理解的阐述清楚，关于建造者设计模式主要从以...

    wangxinarhat 评论0 收藏0

发表评论

登陆后可评论

0条评论

banana_pi

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<