设计模式之(五):建造者设计模式

建造者模式概要

一.定义

将一个复杂对象的构建与表示分离,使得同样的构建过程可以创建不同的表示

二.使用场景

  • 1.一个对象有非常复杂的内部结构(有很多属性)
  • 2.想把复杂对象的创建和使用分离

三.优缺点

1.优点
  • 1.封装性好,创建和使用分离
  • 2.扩展性好、建造类之间分离、一定程度上解耦
2.缺点
  • 1.产生多余的Builder对象
  • 2.产品结构发生变化,建造者都要修改,成本较大

四.角色

  • 产品 : 具体的产品类
  • 产品建造者 : 构造产品的类

五.实例

  1. package com.shixinke.practise.design.pattern.content.creation.builder;
  2. import java.math.BigDecimal;
  3. /**
  4. * 商品实体(数据库实体)
  5. * @author shixinke
  6. */
  7. public class Item {
  8. /**
  9. * 商品ID
  10. */
  11. private Long itemId;
  12. /**
  13. * 商品名称
  14. */
  15. private String itemName;
  16. /**
  17. * 商品标识名称
  18. */
  19. private String itemMarketName;
  20. /**
  21. * 商品原价
  22. */
  23. private BigDecimal originalPrice;
  24. /**
  25. * 市场价
  26. */
  27. private BigDecimal marketPrice;
  28. /**
  29. * 在售状态
  30. */
  31. private Short saleStatus;
  32. /**
  33. * 创建时间
  34. */
  35. private Integer createTime;
  36. /**
  37. * 更新时间
  38. */
  39. private Integer updateTime;
  40. public Long getItemId() {
  41. return itemId;
  42. }
  43. public String getItemName() {
  44. return itemName;
  45. }
  46. public String getItemMarketName() {
  47. return itemMarketName;
  48. }
  49. public BigDecimal getOriginalPrice() {
  50. return originalPrice;
  51. }
  52. public BigDecimal getMarketPrice() {
  53. return marketPrice;
  54. }
  55. public Short getSaleStatus() {
  56. return saleStatus;
  57. }
  58. public Integer getCreateTime() {
  59. return createTime;
  60. }
  61. public Integer getUpdateTime() {
  62. return updateTime;
  63. }
  64. @Override
  65. public String toString() {
  66. return "Item{" +
  67. "itemId=" + itemId +
  68. ", itemName='" + itemName + '\'' +
  69. ", itemMarketName='" + itemMarketName + '\'' +
  70. ", originalPrice=" + originalPrice +
  71. ", marketPrice=" + marketPrice +
  72. ", saleStatus=" + saleStatus +
  73. ", createTime=" + createTime +
  74. ", updateTime=" + updateTime +
  75. '}';
  76. }
  77. /**
  78. * 调用建造者方法
  79. * @return
  80. */
  81. public static Builder builder() {
  82. return new Builder();
  83. }
  84. /**
  85. * Item建造者类
  86. */
  87. public static class Builder {
  88. //建立一个指向产品类的实例(这里也可以把产品类的所有属性都放置于此)
  89. private Item item;
  90. private Builder() {
  91. //初始化实例对象
  92. item = new Item();
  93. }
  94. /*
  95. * 设置属性
  96. */
  97. public Builder setItemId(Long itemId) {
  98. item.itemId = itemId;
  99. return this;
  100. }
  101. public Builder setItemName(String itemName) {
  102. item.itemName = itemName;
  103. return this;
  104. }
  105. public Builder setItemMarketName(String itemMarketName) {
  106. item.itemMarketName = itemMarketName;
  107. return this;
  108. }
  109. public Builder setOriginalPrice(BigDecimal originalPrice) {
  110. item.originalPrice = originalPrice;
  111. return this;
  112. }
  113. public Builder setMarketPrice(BigDecimal marketPrice) {
  114. item.marketPrice = marketPrice;
  115. return this;
  116. }
  117. public Builder setSaleStatus(Short saleStatus) {
  118. item.saleStatus = saleStatus;
  119. return this;
  120. }
  121. public Builder setCreateTime(Integer createTime) {
  122. item.createTime = createTime;
  123. return this;
  124. }
  125. public Builder setUpdateTime(Integer updateTime) {
  126. item.updateTime = updateTime;
  127. return this;
  128. }
  129. /**
  130. * 最终建造的方法
  131. */
  132. public Item build() {
  133. return item;
  134. }
  135. }
  136. }
  • 一般将建造者放置于产品类的内部,作为一个静态内部类来调用

六.建造者模式在源码中的应用

1.建造者模式在JDK中的使用
(1)StringBuilder
  1. public final class StringBuilder
  2. extends AbstractStringBuilder
  3. implements java.io.Serializable, CharSequence
  4. {
  5. /*
  6. * 类似于设置各种属性
  7. */
  8. @Override
  9. public StringBuilder append(String str) {
  10. super.append(str);
  11. return this;
  12. }
  13. public StringBuilder append(StringBuffer sb) {
  14. super.append(sb);
  15. return this;
  16. }
  17. @Override
  18. public StringBuilder append(CharSequence s) {
  19. super.append(s);
  20. return this;
  21. }
  22. /*
  23. * 相当于build方法
  24. */
  25. @Override
  26. public String toString() {
  27. // Create a copy, don't share the array
  28. return new String(value, 0, count);
  29. }
  30. }
(2)StringBuffer
  1. public final class StringBuffer
  2. extends AbstractStringBuilder
  3. implements java.io.Serializable, CharSequence
  4. {
  5. /*
  6. * 类似于设置各种属性
  7. */
  8. @Override
  9. public synchronized StringBuffer append(Object obj) {
  10. toStringCache = null;
  11. super.append(String.valueOf(obj));
  12. return this;
  13. }
  14. @Override
  15. public synchronized StringBuffer append(String str) {
  16. toStringCache = null;
  17. super.append(str);
  18. return this;
  19. }
  20. public synchronized StringBuffer append(StringBuffer sb) {
  21. toStringCache = null;
  22. super.append(sb);
  23. return this;
  24. }
  25. @Override
  26. synchronized StringBuffer append(AbstractStringBuilder asb) {
  27. toStringCache = null;
  28. super.append(asb);
  29. return this;
  30. }
  31. /**
  32. * 类似于build方法
  33. */
  34. @Override
  35. public synchronized String toString() {
  36. if (toStringCache == null) {
  37. toStringCache = Arrays.copyOfRange(value, 0, count);
  38. }
  39. return new String(toStringCache, true);
  40. }
  41. }
2.建造者模式在Spring中的应用
  1. public final class BeanDefinitionBuilder {
  2. public static BeanDefinitionBuilder genericBeanDefinition() {
  3. return new BeanDefinitionBuilder(new GenericBeanDefinition());
  4. }
  5. public BeanDefinitionBuilder setParentName(String parentName) {
  6. this.beanDefinition.setParentName(parentName);
  7. return this;
  8. }
  9. public BeanDefinitionBuilder setFactoryMethod(String factoryMethod) {
  10. this.beanDefinition.setFactoryMethodName(factoryMethod);
  11. return this;
  12. }
  13. public BeanDefinitionBuilder setFactoryMethodOnBean(String factoryMethod, String factoryBean) {
  14. this.beanDefinition.setFactoryMethodName(factoryMethod);
  15. this.beanDefinition.setFactoryBeanName(factoryBean);
  16. return this;
  17. }
  18. }