文章目录
- 前言
- 一、建造者模式介绍
- 二、Spring框架中建造者模式的应用
- 总结
前言
Spring是目前Java企业级开发应用广泛的框架之一，其具有强大的生态，且得益于其提供的高扩展能力，能够减少开发成本，提高开发效率。如此优秀的框架，当然离不开各种设计模式，本文主要介绍设计模式中的建造者模式在Spring框架中的应用。
一、建造者模式介绍
建造者模式属于三种设计模式分类中的创建者模式，与工厂模式、单例模式相同，其都是用于进行对象创建的设计模式。建造者模式实际上是将复杂的对象构建过程进行抽取封装，并暴露出来对象的创建方法，使得不同的对象展示，可以通过同样的建造者来实现不同的表象。下面介绍一下建造者模式的实现方式。
建造者模式属于创建者模式，也是对象的创建的一种设计模式，因此，首先需要一个创建对象的类。
//创建的对象
public class Computer{
private String mouse;
private String keyBoard;
private String display;
//getter...
//setter...
//构造器
}
public class DellComputer extends Computer{
}接下来，就是针对此对象的Builder的设计了。
//builder的抽象设计
public abstract class ComputerBuilder {
abstract void buildMouse(String mouse);
abstract void buildKeyBoard(String keyBoard);
abstract void buildDisplay(String display);
abstract Computer build();
}
//DellComputerBuilder的设计
public class DellComputerBuilder extends ComputerBuilder {
private DellComputer dellComputer = new DellComputer();
@Override
void buildMouse(String mouse) {
dellComputer.setMouse(mouse);
}
@Override
void buildBoard(String keyBoard) {
dellComputer.setKeyBoard(keyBoard);
}
@Override
void buildDisplay(String display) {
dellComputer.setDisplay(display);
}
@Override
Computer build() {
return dellComputer;
}
}最后，经典的建造者模式会有一个指挥者（或者叫做导演者），用于调用builder的方法来实现对象的创建，也算是一种封装，实际开发过程中有时会省略这个指挥者，然后通过链式调用（即在使用builder创建对象的过程中返回builder对象）的方法，来使用builder创建一个对象。
//指挥者
public class Director {
private ComputerBuilder computerBuilder ;
public Director(ComputerBuilder computerBuilder) {
this.computerBuilder = computerBuilder;
}
//构建对象
public Computer createComputer() {
computerBuilder.buildMouse();
computerBuilder.buildBoard();
computerBuilder.buildDisplay();
return computerBuilder.build();
}
}采用建造者模式，将一个复杂的对象一步一步通过建造者去构建而成，将对象的创建过程抽取并利用面向对象封装性可以实现有效构建和表示的分离，提高解耦程度，方便扩展。
二、Spring框架中建造者模式的应用
Spring框架中的建造者模式的应用有很多，例如BeanDefinitionBuilder用于构建Bean定义信息对象，将BeanDefinition的创建过程进行封装，并提供BeanDefinitionBuilder各种Bean定义信息对象的创建方法，其实现更加的简洁（省略了抽象builder以及指挥者）并且符合实际开发需求。
public final class BeanDefinitionBuilder {
//通用Bean定义信息对象的创建
public static BeanDefinitionBuilder genericBeanDefinition() {
return new BeanDefinitionBuilder(new GenericBeanDefinition());
}
public static BeanDefinitionBuilder genericBeanDefinition(String beanClassName) {
BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
builder.beanDefinition.setBeanClassName(beanClassName);
return builder;
}
public static BeanDefinitionBuilder genericBeanDefinition(Class<?> beanClass) {
BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
builder.beanDefinition.setBeanClass(beanClass);
return builder;
}
public static <T> BeanDefinitionBuilder genericBeanDefinition(Class<T> beanClass, Supplier<T> instanceSupplier) {
BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
builder.beanDefinition.setBeanClass(beanClass);
builder.beanDefinition.setInstanceSupplier(instanceSupplier);
return builder;
}
//根BeanDefinition对象的创建
public static BeanDefinitionBuilder rootBeanDefinition(String beanClassName) {
return rootBeanDefinition(beanClassName, null);
}
public static BeanDefinitionBuilder rootBeanDefinition(String beanClassName, @Nullable String factoryMethodName) {
BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new RootBeanDefinition());
builder.beanDefinition.setBeanClassName(beanClassName);
builder.beanDefinition.setFactoryMethodName(factoryMethodName);
return builder;
}
public static BeanDefinitionBuilder rootBeanDefinition(Class<?> beanClass) {
return rootBeanDefinition(beanClass, (String) null);
}
public static BeanDefinitionBuilder rootBeanDefinition(Class<?> beanClass, @Nullable String factoryMethodName) {
BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new RootBeanDefinition());
builder.beanDefinition.setBeanClass(beanClass);
builder.beanDefinition.setFactoryMethodName(factoryMethodName);
return builder;
}
public static <T> BeanDefinitionBuilder rootBeanDefinition(ResolvableType beanType, Supplier<T> instanceSupplier) {
RootBeanDefinition beanDefinition = new RootBeanDefinition();
beanDefinition.setTargetType(beanType);
beanDefinition.setInstanceSupplier(instanceSupplier);
return new BeanDefinitionBuilder(beanDefinition);
}
public static <T> BeanDefinitionBuilder rootBeanDefinition(Class<T> beanClass, Supplier<T> instanceSupplier) {
return rootBeanDefinition(ResolvableType.forClass(beanClass), instanceSupplier);
}
//子BeanDefinition对象的创建
public static BeanDefinitionBuilder childBeanDefinition(String parentName) {
return new BeanDefinitionBuilder(new ChildBeanDefinition(parentName));
}
private final AbstractBeanDefinition beanDefinition;
private int constructorArgIndex;
private BeanDefinitionBuilder(AbstractBeanDefinition beanDefinition) {
this.beanDefinition = beanDefinition;
}
public AbstractBeanDefinition getRawBeanDefinition() {
return this.beanDefinition;
}
public AbstractBeanDefinition getBeanDefinition() {
this.beanDefinition.validate();
return this.beanDefinition;
}
/*******以下方法为链式调用创建对象**********/
public BeanDefinitionBuilder setParentName(String parentName) {
this.beanDefinition.setParentName(parentName);
return this;
}
public BeanDefinitionBuilder setFactoryMethod(String factoryMethod) {
this.beanDefinition.setFactoryMethodName(factoryMethod);
return this;
}
public BeanDefinitionBuilder setFactoryMethodOnBean(String factoryMethod, String factoryBean) {
this.beanDefinition.setFactoryMethodName(factoryMethod);
this.beanDefinition.setFactoryBeanName(factoryBean);
return this;
}
public BeanDefinitionBuilder addConstructorArgValue(@Nullable Object value) {
this.beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(
this.constructorArgIndex++, value);
return this;
}
public BeanDefinitionBuilder addConstructorArgReference(String beanName) {
this.beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(
this.constructorArgIndex++, new RuntimeBeanReference(beanName));
return this;
}
public BeanDefinitionBuilder addPropertyValue(String name, @Nullable Object value) {
this.beanDefinition.getPropertyValues().add(name, value);
return this;
}
public BeanDefinitionBuilder addPropertyReference(String name, String beanName) {
this.beanDefinition.getPropertyValues().add(name, new RuntimeBeanReference(beanName));
return this;
}
public BeanDefinitionBuilder addAutowiredProperty(String name) {
this.beanDefinition.getPropertyValues().add(name, AutowiredPropertyMarker.INSTANCE);
return this;
}
public BeanDefinitionBuilder setInitMethodName(@Nullable String methodName) {
this.beanDefinition.setInitMethodName(methodName);
return this;
}
public BeanDefinitionBuilder setDestroyMethodName(@Nullable String methodName) {
this.beanDefinition.setDestroyMethodName(methodName);
return this;
}
public BeanDefinitionBuilder setScope(@Nullable String scope) {
this.beanDefinition.setScope(scope);
return this;
}
public BeanDefinitionBuilder setAbstract(boolean flag) {
this.beanDefinition.setAbstract(flag);
return this;
}
public BeanDefinitionBuilder setLazyInit(boolean lazy) {
this.beanDefinition.setLazyInit(lazy);
return this;
}
public BeanDefinitionBuilder setAutowireMode(int autowireMode) {
this.beanDefinition.setAutowireMode(autowireMode);
return this;
}
public BeanDefinitionBuilder setDependencyCheck(int dependencyCheck) {
this.beanDefinition.setDependencyCheck(dependencyCheck);
return this;
}
public BeanDefinitionBuilder addDependsOn(String beanName) {
if (this.beanDefinition.getDependsOn() == null) {
this.beanDefinition.setDependsOn(beanName);
}
else {
String[] added = ObjectUtils.addObjectToArray(this.beanDefinition.getDependsOn(), beanName);
this.beanDefinition.setDependsOn(added);
}
return this;
}
public BeanDefinitionBuilder setPrimary(boolean primary) {
this.beanDefinition.setPrimary(primary);
return this;
}
public BeanDefinitionBuilder setRole(int role) {
this.beanDefinition.setRole(role);
return this;
}
public BeanDefinitionBuilder setSynthetic(boolean synthetic) {
this.beanDefinition.setSynthetic(synthetic);
return this;
}
public BeanDefinitionBuilder applyCustomizers(BeanDefinitionCustomizer... customizers) {
for (BeanDefinitionCustomizer customizer : customizers) {
customizer.customize(this.beanDefinition);
}
return this;
}
}总结
本文简述了建造模式的实现方式以及Spring中建造者模式的设计。建造者模式是将不同对象的创建方式进行封装，将构建与表示进行分离与解耦。有了建造者模式，我们可以不用去关注内部如何创建，并提高创建的可扩展性，在面向对象设计中运用广泛。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
