Builder
O Builder é um padrão criacional utilizado para construir objetos complexos passo a passo.
Ele é especialmente útil quando um objeto possui:
- Muitos parâmetros.
- Parâmetros opcionais.
- Diferentes combinações de configuração.
Imagine uma classe:
class User {
constructor(
public name: string,
public email: string,
public age?: number,
public phone?: string,
public address?: string
) {}
}
A criação pode ficar confusa:
const user = new User(
"João",
"joao@email.com",
undefined,
"99999-9999",
undefined
);
O Builder resolve esse problema.
Criando o Builder
class UserBuilder {
private name!: string;
private email!: string;
private age?: number;
private phone?: string;
private address?: string;
setName(name: string) {
this.name = name;
return this;
}
setEmail(email: string) {
this.email = email;
return this;
}
setAge(age: number) {
this.age = age;
return this;
}
setPhone(phone: string) {
this.phone = phone;
return this;
}
setAddress(address: string) {
this.address = address;
return this;
}
build() {
return new User(
this.name,
this.email,
this.age,
this.phone,
this.address
);
}
}
Agora podemos construir o objeto:
const user =
new UserBuilder()
.setName("João")
.setEmail("joao@email.com")
.setAge(25)
.setPhone("99999-9999")
.build();
O código fica mais legível.
Validação
O Builder também pode centralizar regras de construção.
Por exemplo:
build() {
if (!this.name) {
throw new Error(
"Nome é obrigatório"
);
}
if (!this.email) {
throw new Error(
"Email é obrigatório"
);
}
return new User(
this.name,
this.email,
this.age,
this.phone,
this.address
);
}
Agora temos um único lugar responsável por validar a criação.
Outro exemplo
O Builder é muito comum na criação de objetos complexos.
Imagine uma requisição HTTP:
const request =
new HttpRequestBuilder()
.setUrl("/users")
.setMethod("POST")
.setHeader(
"Content-Type",
"application/json"
)
.setBody({
name: "João"
})
.build();
A construção ocorre de forma progressiva:
Builder
↓
setUrl()
↓
setMethod()
↓
setHeader()
↓
setBody()
↓
build()
↓
Objeto final
Quando usar?
Use Builder quando:
- O objeto possui muitos parâmetros.
- Existem muitos parâmetros opcionais.
- A construção possui várias etapas.
- Quer tornar a criação mais legível.
- Precisa validar o objeto antes de construí-lo.
Resumo
Sem Builder:
new User(
"João",
"email",
25,
"9999",
"Rua A"
);
Com Builder:
new UserBuilder()
.setName("João")
.setEmail("email")
.setAge(25)
.setPhone("9999")
.setAddress("Rua A")
.build();
A ideia principal é:
Separar o processo de construção de um objeto complexo da representação final desse objeto.