个人主页:金鳞踏雨
个人简介:大家好,我是金鳞,一个初出茅庐的Java小白
目前状况:22届普通本科毕业生,几经波折了,现在任职于一家国内大型知名日化公司,从事Java开发工作
我的博客:这里是CSDN,是我学习技术,总结知识的地方。希望和各位大佬交流,共同进步 ~
比较简单,但是很经常用!
个人感悟:
为什么会有这种设计模式?往往是因为语言或者框架本身的缺陷而导致的。这个语言或者框架本身就不支持这种开发形式,我们必须使用一种开发"套路"来解决这个问题!
那为什么有一些设计模式我们在开发中很少见呢?因为本身一些框架就提供了这些功能!我们使用起来就很简单,所以就没有那么重要了!
一、原理
Builder 模式,中文翻译为建造者模式或者构建者模式,也有人叫它生成器模式。
实际上,建造者模式的原理和代码实现非常简单,掌握起来并不难,难点在于应用场景。比如,你有没有考虑过这样几个问题:直接使用构造函数或者配合 set 方法就能创建对象,为什么还需要建造者模式来创建呢?建造者模式和工厂模式都可以创建对象,那它们两个的区别在哪里呢,话不多说,我们直接来学习:
角色
- 产品(Product):表示将要被构建的复杂对象。
- 抽象创建者(Abstract Builder):定义构建产品的接口,通常包含创建和获取产品的方法。
- 具体创建者(Concrete Builder):实现抽象创建者定义的接口,为产品的各个部分提供具体实现。
- 指挥者(Director):负责调用具体创建者来构建产品的各个部分,控制构建过程。
示例代码
我们考虑一个文档编辑器的例子。假设我们需要创建一个复杂的HTML文档,它包含了标题、段落和图像等元素。
1、产品(Product)类 - HTML文档(HtmlDocument):
public class HtmlDocument {private String header = "";private String body = "";private String footer = "";public void addHeader(String header) {this.header = header;}public void addBody(String body) {this.body = body;}public void addFooter(String footer) {this.footer = footer;}@Overridepublic String toString() {return "<html><head>" + header + "</head><body>" + body + "</body><footer>" + footer + "</footer></html>";}
}
2、抽象创建者(Abstract Builder)类 - HtmlDocumentBuilder:
public abstract class HtmlDocumentBuilder {protected HtmlDocument document;public HtmlDocument getDocument() {return document;}public void createNewHtmlDocument() {document = new HtmlDocument();}public abstract void buildHeader();public abstract void buildBody();public abstract void buildFooter();
}
3、具体创建者(Concrete Builder)类 - ArticleHtmlDocumentBuilder:
// 实现抽象
public class ArticleHtmlDocumentBuilder extends HtmlDocumentBuilder {@Overridepublic void buildHeader() {document.addHeader("Article Header");}@Overridepublic void buildBody() {document.addBody("Article Body");}@Overridepublic void buildFooter() {document.addFooter("Article Footer");}
}
4、指挥者(Director)类 - HtmlDirector:
public class HtmlDirector {private HtmlDocumentBuilder builder;public HtmlDirector(HtmlDocumentBuilder builder) {this.builder = builder;}public void constructDocument() {builder.createNewHtmlDocument();builder.buildHeader();builder.buildBody();builder.buildFooter();}public HtmlDocument getDocument() {return builder.getDocument();}
}
现在我们可以使用创建者设计模式来构建一个HTML文档对象:
public class Main {public static void main(String[] args) {HtmlDocumentBuilder articleBuilder = new ArticleHtmlDocumentBuilder();HtmlDirector director = new HtmlDirector(articleBuilder);director.constructDocument();HtmlDocument document = director.getDocument();System.out.println("Constructed HTML Document: \n" + document);}
}
在这个例子中,我们创建了一个表示HTML文档的产品类(HtmlDocument),一个抽象的创建者类(HtmlDocumentBuilder),一个具体的创建者类(ArticleHtmlDocumentBuilder)和一个指挥者类(HtmlDirector)。当我们需要创建一个新的HTML文档对象时,我们可以使用指挥者类来控制构建过程,从而实现了将构建过程与表示过程的分离。
以上是一个创建者设计模式的标准写法,事实,我们在工作中往往不会写的这么复杂,为了创建一个对象,我们创建了很多辅助的类,总觉得不太合适,在这个案例中,我们可以使用内部类来简化代码,以下是修改后的代码(甚至我们还移除了抽象层)
public class HtmlDocument {private String header = "";private String body = "";private String footer = "";public void addHeader(String header) {this.header = header;}public void addBody(String body) {this.body = body;}public void addFooter(String footer) {this.footer = footer;}@Overridepublic String toString() {return "<html><head>" + header + "</head><body>" + body + "</body><footer>" + footer + "</footer></html>";}public static class Builder {protected HtmlDocument document;public Builder() {document = new HtmlDocument();}public Builder addHeader(String header) {document.addHeader(header);return this;}public Builder addBody(String body) {document.addBody(body);return this;}public Builder addFooter(String footer) {document.addFooter(footer);return this;}public HtmlDocument build() {return document;}}
}
创建一个HTML文档对象
public class Main {public static void main(String[] args) {HtmlDocument.Builder builder = new HtmlDocument.Builder();HtmlDocument document = builder.addHeader("This is the header").addBody("This is the body").addFooter("This is the footer").build();System.out.println("Constructed HTML Document: \n" + document);}
}
将创建者类(Builder)作为HTML文档类(HtmlDocument)的内部类。
这样做可以让代码更加紧凑。此外,我们使用了一种流式接口,使得在客户端代码中创建HTML文档对象更加简洁。
二、为什么需要建造者模式
1. 根据复杂的配置项进行定制化构建
首先,我们先看一个mybaits中经典的案例,这个案例中使用了装饰器和创建者设计模式:
public class CacheBuilder {private final String id;private Class<? extends Cache> implementation;private final List<Class<? extends Cache>> decorators;private Integer size;private Long clearInterval;private boolean readWrite;private Properties properties;private boolean blocking;public CacheBuilder(String id) {this.id = id;this.decorators = new ArrayList<>();}public CacheBuilder size(Integer size) {this.size = size;return this;}public CacheBuilder clearInterval(Long clearInterval) {this.clearInterval = clearInterval;return this;}public CacheBuilder blocking(boolean blocking) {this.blocking = blocking;return this;}public CacheBuilder properties(Properties properties) {this.properties = properties;return this;}// 构建public Cache build() {// 使用了装饰器模式,添加 LruCachesetDefaultImplementations();Cache cache = newBaseCacheInstance(implementation, id);setCacheProperties(cache);// 根据配置的装饰器对原有缓存进行增强,如增加淘汰策略等if (PerpetualCache.class.equals(cache.getClass())) {// 遍历装饰器,使其与目标对象绑定for (Class<? extends Cache> decorator : decorators) {cache = newCacheDecoratorInstance(decorator, cache);setCacheProperties(cache);}cache = setStandardDecorators(cache);} else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {cache = new LoggingCache(cache);}return cache;}
}
我们总结这个案例中的几个特点:
1、参数有必填项id,有很多可选填的内容;通常必选项id通过构造器传入,可选项通过方法传递。
2、真正的构建过程需要调用build()方法,构建时需要根据已配置的成员变量的内容选择合适的装饰器,对目标cache进行增强。
2. 实现不可变对象
创建者设计模式(Builder Design Pattern)可以实现不可变对象,即一旦创建完成,对象的状态就不能改变。这有助于保证对象的线程安全和数据完整性。
public final class ImmutablePerson {private final String name;private final int age;private final String address;private ImmutablePerson(Builder builder) {this.name = builder.name;this.age = builder.age;this.address = builder.address;}public String getName() {return name;}public int getAge() {return age;}public String getAddress() {return address;}public static class Builder {private String name;private int age;private String address;public Builder() {}public Builder setName(String name) {this.name = name;return this;}public Builder setAge(int age) {this.age = age;return this;}public Builder setAddress(String address) {this.address = address;return this;}public ImmutablePerson build() {return new ImmutablePerson(this);}}
}
在这个例子中,ImmutablePerson 类具有三个属性:name、age 和 address。这些属性都是 final 的,一旦设置就不能更改。
ImmutablePerson 的构造函数是私有的,外部无法直接创建该类的实例。要创建一个 ImmutablePerson 实例,需要使用内部的 Builder 类。通过连续调用 Builder 类的方法,我们可以为 ImmutablePerson 设置属性。最后,通过调用 build() 方法,我们创建一个具有指定属性的不可变 ImmutablePerson 实例。
实际上,使用建造者模式创建对象,还能避免对象存在无效状态。我再举个例子解释一下。比如我们定义了一个长方形类,如果不使用建造者模式,采用先创建后 set 的方式,那就会导致在第一个 set 之后,对象处于无效状态。
Rectangle r = new Rectange(); // r is invalid
r.setWidth(2); // r is invalid
r.setHeight(3); // r is valid
为了避免这种无效状态的存在,我们就需要使用构造函数一次性初始化好所有的成员变量。如果构造函数参数过多,我们就需要考虑使用建造者模式,先设置建造者的变量,然后再一次性地创建对象,让对象一直处于有效状态。
实际上,如果我们并不是很关心对象是否有短暂的无效状态,也不是太在意对象是否是可变的。比如,对象只是用来映射数据库读出来的数据,那我们直接暴露 set() 方法来设置类的成员变量值是完全没问题的。而且,使用建造者模式来构建对象,代码实际上是有点重复的。
小结
建造者模式是用来创建一种类型的复杂对象,通过设置不同的可选参数,“定制化”地创建不同的对象。
我们把类的必填属性放到构造函数中,强制创建对象的时候就设置。
- 如果必填的属性有很多,把这些必填属性都放到构造函数中设置,那构造函数就又会出现参数列表很长的问题。
- 如果我们把必填属性通过 set() 方法设置,那校验这些必填属性是否已经填写的逻辑就无处安放了。
- 如果类的属性之间有一定的依赖关系或者约束条件,我们继续使用构造函数配合 set() 方法的设计思路,那这些依赖关系或约束条件的校验逻辑就无处安放了。
- 如果我们希望创建不可变对象,也就是说,对象在创建好之后,就不能再修改内部的属性值,要实现这个功能,我们就不能在类中暴露 set() 方法。构造函数配合 set() 方法来设置属性值的方式就不适用了。
建造者与工厂模式有何区别?
实际上,其实不用非得把工厂模式、建造者模式分得那么清楚,我们需要知道的是,每个模式为什么这么设计,能解决什么问题。只有了解了这些最本质的东西,我们才能不生搬硬套,才能灵活应用,甚至可以混用各种模式创造出新的模式,来解决特定场景的问题。
三、源码应用
创建者设计模式在源码中有广泛的使用常见:
1、JDK中,如StringBuilder和StringBuffer,他们的实现不是完全按照标准的创建者设计模式设计,但也是一样的思想:
这两个类用于构建和修改字符串。它们实现了创建者模式,允许客户端通过方法链来修改字符串。这些类在性能上优于 String 类,因为它们允许在同一个对象上执行多次修改,而不需要每次修改都创建一个新的对象。
StringBuilder builder = new StringBuilder();
builder.append("Hello").append(" ").append("World!");
String result = builder.toString();
2、在SSM源码中很多类都使用创建者设计模式,如Spring中的BeanDefinitionBuilder 类,mybatis中的 SqlSessionFactoryBuilder、XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuilder、CacheBuilder等,因为实现都比较简单就不带着大家一个一个看了。
3、使用lombok简单的实现创建者设计模式
Lombok 是一个 Java 库,它可以简化代码,提高开发效率,尤其是在实现模式和生成常用方法(例如 getter、setter、equals、hashCode 和 toString)时。
要使用 Lombok 简单地实现创建者设计模式,可以使用 @Builder 注解。自动生成创建者类和相关方法。
首先,引入 Lombok 库。
<dependencies><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.20</version><scope>provided</scope></dependency>
</dependencies>
然后,创建一个使用 Lombok 的创建者设计模式的类:
@Getter
@ToString
@Builder
public class Person {private String name;private int age;private String address;
}
在上面的示例中,我们使用了 @Builder 注解来自动生成创建者类和相关方法。此外,我们还使用了 @Getter 注解来自动生成 getter 方法,以及 @ToString 注解来自动生成 toString 方法。
自动生成的创建者类创建 Person 对象
Person person = Person.builder().name("John Doe").age(30).address("123 Main St").build();
通过 Lombok,可以轻松地实现创建者设计模式,减少样板代码,提高代码可读性。
文章到这里就结束了,如果有什么疑问的地方,可以在评论区指出~
希望能和大佬们一起努力,诸君顶峰相见
再次感谢各位小伙伴儿们的支持!!!