{"componentChunkName":"component---src-templates-blog-post-js","path":"/go-design-patterns/","result":{"data":{"markdownRemark":{"html":"

Padrões de projeto

\n

São padrões já consagrados com técnicas que nos ajudam no dia-a-dia para solucionar alguns problemas em comum ou fazem com que a nossa aplicação seja mais fácil de mudar no futuro.\nAqui vamos propor um exemplo onde eu tenho uma aplicação que recebe dados que representem uma pessoa, mas uma pessoa aqui pode ser tanto uma pessoa física quanto uma pessoa jurídica. Então temos que decidir qual é o tipo da pessoa que está sendo informada, executar algumas validações e depois salvar os dados em um banco de dados.

\n

Builder

\n

Vamos entender primeiramente o que é esse padrão e como ele nos ajudar aqui.\nO padrão Builder é um padrão para criação de objetos onde são informados os passos necessários para a sua criação.\nVamos imaginar que recebemos os nossos dados no seguinte padrão:

\n
{\n    \"name\": \"Pessoa\",\n    \"document\": \"1234567890\",\n    \"type\": \"PF\"\n}
\n

Aqui temos uma representação mais ou menos do que seria uma entrada de dados e temos que montar o nosso objeto, conseguimos saber que é uma pessoa do tipo pessoa física pelo campo type então vamos começar criando nosso arquivo personBuilder.go:

\n
package builder\n\ntype PersonBuilder interface {\n\tSetName(name string)\n\tSetDocument(document string)\n\tBuild() Person\n}\n\nfunc GetBuilder(tyeName string) PersonBuilder {\n\tif tyeName == \"PF\" {\n\t\treturn &NaturalPerson{\n\t\t\tType: \"PF\",\n\t\t}\n\t}\n\tif tyeName == \"PJ\" {\n\t\treturn &LegalPerson{\n\t\t\tType: \"PJ\",\n\t\t}\n\t}\n\treturn nil\n}
\n

Aqui definimos a nossa interface PersonBuilder com as funções para adicionar o nome, o documento e a função encarregada por realizar a construção. Temos também a função GetBuilder que recebe o type e decide qual é o tipo que deve ser criado, caso seja pessoa física retorna um NaturalPerson caso seja pessoa jurídica retorna um LegalPerson já com um atributo Type.

\n

O que significa esses tipos NaturalPerson e LegalPerson e por que eles são considerados de um tipo PersonBuilder? Vamos ver o arquivo naturalPerson.go para entender:

\n
package builder\n\ntype NaturalPerson struct {\n\tName     string\n\tDocument string\n\tType     string\n}\n\nfunc (person *NaturalPerson) SetName(name string) {\n\tperson.Name = name\n}\n\nfunc (person *NaturalPerson) SetDocument(document string) {\n\tperson.Document = document\n}\n\nfunc (person *NaturalPerson) Build() Person {\n\treturn Person{\n\t\tName:     person.Name,\n\t\tDocument: person.Document,\n\t\tType:     person.Type,\n\t}\n}
\n

Uma coisa interessante no GO é a forma como ele implementa interfaces que é diferente de outras linguagens que são mais orientadas a objetos pois não fica explícito que estamos implementando uma interface e sim ocorre o que se chama Duck Typing que nada mais é do que: se o seu pacote, arquivo ou classe implementar os métodos de uma interface ele passa a ser daquele tipo. Isso segue a idéia de que se um animal anda como um pato, nada como um pato e voa como um pato então esse animal é um pato.

\n

É o que vemos na NaturalPerson que implementa as funções que estão na interface PersonBuilder então concluímos que qualquer arquivo que implemente as funções de PersonBuilder é do mesmo tipo dele.

\n

Podemos ver que a função Build retorna um Person e nessa função são atribuídos Name, Document e Type. Vamos ver esse arquivo:

\n
package builder\n\ntype Person struct {\n\tName               string\n\tDocument           string\n\tType               string\n}
\n

Person nada mais é do que uma struct, relativo ao que seria uma classe em outras linguagens, onde temos a representação do que é uma pessoa para a nossa aplicação.

\n

Temos as peças soltas e agora vamos ver como juntar isso para fazer o nosso Builder funcionar:

\n
\t//Build a PersonBuilder, set values and build a NaturalPerson\n\tpersonBuilder := builder.GetBuilder(\"PF\")\n\n\tpersonBuilder.SetName(\"John Doe\")\n\tpersonBuilder.SetDocument(\"21368063004\")\n\tnaturalPerson := personBuilder.Build()
\n

Aqui basicamente estamos passando como se fosse uma receita de como construir esse objeto e no fim chamamos a nossa função Build que vai construir o nosso objeto e devolvê-lo.

\n

Chain of Responsibility

\n

Então agora temos uma forma de construir os nossos objetos, mas vamos pensar que eu queira executar uma série de passos com esses objetos, sejam validações, transformações e etc. como podemos fazer isso?

\n

Com Chain of Responsibility nós conseguimos criar uma cadeia de responsabilidades onde cada passo consegue processar e decide se passa pro próximo ou não.\nAqui vamos supor que conseguimos criar o objeto e queremos persistir em um banco de dados mas antes disso vamos validar se os dados estão certos, por exemplo se o documento é um CPF ou CNPJ correto para aquele tipo de pessoa e etc.

\n

Vamos executar esse processo em passos, vamos validar se o nome está preenchido e depois vamos validar se o CPF/CNPJ está no formato correto.\nVamos criar a nossa interface Validation:

\n
package chain\n\nimport (\n\t\"github.com/guilhermegarcia86/go-patterns/builder\"\n)\n\n//Validation interface has functions for Chain of Responsability Pattern\ntype Validation interface {\n\tExecute(builder.Person)\n\tSetNext(Validation)\n}
\n

Criamos a nossa interface e ela tem duas funções, uma pra executar a nossa lógica, Execute, que recebe um objeto do tipo Person e executa a nossa lógica e outra que vai chamar a próxima validação, SetNext.

\n

Vamos então criar as nossas validações, primeiro com a ValidationType:

\n
package chain\n\nimport (\n\t\"log\"\n\n\t\"github.com/guilhermegarcia86/go-patterns/builder\"\n)\n\n//ValidationType struct\ntype ValidationType struct {\n\tNext Validation\n}\n\n//Execute a function to implement the user type validation execution\nfunc (validationType *ValidationType) Execute(user builder.Person) {\n\n\tif user.ValidationTypeDone {\n\t\tlog.Println(\"Validation type already done \" + user.Type)\n\t\tvalidationType.Next.Execute(user)\n\t\treturn\n\t}\n\n\tlog.Println(\"Validation type user starting \" + user.Type)\n\tuser.ValidationTypeDone = true\n\tlog.Println(\"Execute next validation\")\n\tvalidationType.Next.Execute(user)\n}\n\n//SetNext a function that set the next call\nfunc (validationType *ValidationType) SetNext(next Validation) {\n\tvalidationType.Next = next\n}
\n

Aqui é somente uma prova de conceito onde poderíamos refinar e fazer tratativas de erros e outras validações mais efetivas, mas o importante aqui é que o nosso Execute recebe um objeto do tipo Person e verifica se validação já ocorreu com o atributo user.ValidationTypeDone e se já aconteceu chama o próximo, caso não tenha ocorrido a validação vai ser executada e chamará o próximo na cadeia.

\n

Para poder ter esse controle de estado, se já executou a validação, precisamos atualizar a nossa Person:

\n
type Person struct {\n\tName               string\n\tDocument           string\n\tType               string\n\tValidationNameDone bool\n\tValidationTypeDone bool\n}
\n

Pronto temos os campos que controlam esse estado e eles são do tipo bool (booleanos).\nUma coisa muito importante para esse padrão funcionar é que deve ser definido quem será o último elo dessa corrente e no nosso caso como estamos fazendo só duas validações isso ficará na ValidationName:

\n
package chain\n\nimport (\n\t\"log\"\n\n\t\"github.com/guilhermegarcia86/go-patterns/builder\"\n)\n\n//ValidationName struct\ntype ValidationName struct {\n\tNext Validation\n}\n\n//Execute a function to implement the user name validation execution\nfunc (validationName *ValidationName) Execute(user builder.Person) {\n\n\tif user.ValidationNameDone {\n\t\tlog.Println(\"Validation name already done \" + user.Name)\n\t\tvalidationName.Next.Execute(user)\n\t\treturn\n\t}\n\n\tlog.Println(\"Validation name user starting \" + user.Name)\n\tuser.ValidationNameDone = true\n\tlog.Println(\"Validation finished\")\n}\n\n//SetNext a function that set the next call\nfunc (validationName *ValidationName) SetNext(next Validation) {\n\tvalidationName.Next = next\n}
\n

Agora vamos ver como seria o funcionamento das validações:

\n
\t//Begin a Validation chain\n\tvalidationName := &chain.ValidationName{}\n\tvalidationType := &chain.ValidationType{}\n\n\tvalidationType.SetNext(validationName)\n\n\tvalidationType.Execute(naturalPerson)
\n

Proxy

\n

Agora pensando que nós já temos o nosso objeto criado e que já validamos e tratamos ele, precisamos seguir o nosso fluxo proposto que seria salvar essa informação em algum lugar, porém essa tarefa pode se tornar muito custosa dependendo de como será implementada.

\n

Por exemplo se formos salvar em um banco de dados temos todo o custo que é se conectar com o banco de dados, abrir uma transação, commitar e depois fechar, pensando em casos assim existe o padrão Proxy.

\n

Mas antes de explorá-lo vamos entender alguns pontos, se abrir a conexão com um banco é tão difícil por que então eu não tento fazer um código mais performático pra abrir a conexão e fazer todo o resto?

\n

A resposta é que nem sempre nós temos acesso ao código que vai ser executado, pensando nessa ideia de acesso ao banco de dados, geralmente temos bibliotecas prontas onde nós só fazemos as chamadas às suas funções sem que o código de como isso é feito seja exposto pra quem chamou.\nPorém se tivéssemos alguém que vai chamar uma vez o código “pesado” e vai guardar isso para nós e depois só usa a parte mais fácil sem chamar a parte pesada de novo, mas quem está chamando acha que está chamando o código pesado?

\n

A ideia de proxy vem de alguém que seja representante de outra pessoa e é isso o que ele vai fazer aqui, vamos criar uma interface chamada Database:

\n
package proxy\n\n// Database interface to access\ntype Database interface {\n\tAccess(url string, port string, user string, pass string) (string, error)\n}
\n

Aqui temos a definição de um acesso à um banco de dados onde são passado os dados de conexão, agora vamos criar o Proxy:

\n
package proxy\n\nimport (\n\t\"log\"\n\t\"time\"\n)\n\n//Proxy struct\ntype Proxy struct {\n\tapplication *Application\n\turl         string\n\tport        string\n\tuser        string\n\tpass        string\n}\n\n//OpenConnection a function that simulates a heavy call to create a database connection\nfunc OpenConnection(url string, port string, user string, pass string) *Proxy {\n\tlog.Println(\"A heavy process to create my connection with database\")\n\ttime.Sleep(2 * time.Second)\n\treturn &Proxy{\n\t\tapplication: &Application{},\n\t\turl:         url,\n\t\tport:        port,\n\t\tuser:        user,\n\t\tpass:        pass,\n\t}\n}\n\n//Access a function that receives params and verifies if has connection opened and do access\nfunc (p *Proxy) Access(url string, port string, user string, pass string) (string, error) {\n\n\tif *p == (Proxy{}) {\n\t\tp = OpenConnection(url, port, user, pass)\n\t}\n\n\tmsg, err := p.application.Access(url, port, user, pass)\n\n\tif err != nil {\n\t\tlog.Fatalln(\"ERROR\")\n\t}\n\n\treturn msg, nil\n}
\n

Aqui é onde iríamos esconder a parte difícil da operação, temos a implementação de Access a função que irá abrir a conexão com o banco e a struct que irá controlar se a conexão já foi criada.

\n

A fim de explicar esse conceito a função OpenConnection tem um Sleep que vai aguardar 2 segundos e depois vai chamar o que seria o nosso acesso através do trecho:

\n
msg, err := p.application.Access(url, port, user, pass)
\n

Então aqui podemos ver que quem usar o proxy tem a impressão de que está acessando a função real Access sendo que na verdade está passando pelo proxy.

\n

E por fim o nosso Application que é a representação do que seria a biblioteca do terceiro:

\n
package proxy\n\nimport (\n\t\"fmt\"\n)\n\n//Application struct\ntype Application struct {\n}\n\n//Access a function that will do the access\nfunc (a *Application) Access(url string, port string, user string, pass string) (string, error) {\n\n\treturn fmt.Sprintf(\"Success to connect database in url: %s port: %s user: %s\", url, port, user), nil\n}
\n

E aqui temos a utilização completa do proxy:

\n
const (\n\t\turl  = \"urlDatabase\"\n\t\tport = \"3306\"\n\t\tuser = \"user\"\n\t\tpass = \"pass\"\n\t)\n\n\t//Open connection, heavy process\n\tconn := proxy.OpenConnection(url, port, user, pass)\n\n\t//Access database\n\tmsgI, err := conn.Access(url, port, user, pass)\n\tif err != nil {\n\t\tlog.Fatalln(\"ERROR \", err)\n\t}\n\tlog.Println(msgI)\n\n\t//Do not open connection again\n\tmsgII, err := conn.Access(url, port, user, pass)\n\tif err != nil {\n\t\tlog.Fatal(\"ERROR \", err)\n\t}\n\tlog.Println(msgII)
\n

A parte interessante aqui é que executando esse código teremos duas chamadas para função Access porém só a primeira vai demorar 2 segundos pois na próxima chamada o proxy já guardou a conexão.

\n

Código completo

\n

Aqui temos a nossa main.go onde temos a entrada de dados, construímos os nossos objetos, fazemos as nossas validações e depois simulamos a abertura com o banco de dados e acessamos:

\n
package main\n\nimport (\n\t\"log\"\n\n\t\"github.com/guilhermegarcia86/go-patterns/builder\"\n\t\"github.com/guilhermegarcia86/go-patterns/chain\"\n\t\"github.com/guilhermegarcia86/go-patterns/proxy\"\n)\n\nfunc main() {\n\n\t//Build a PersonBuilder, set values and build a NaturalPerson\n\tpersonBuilder := builder.GetBuilder(\"PF\")\n\n\tpersonBuilder.SetName(\"John Doe\")\n\tpersonBuilder.SetDocument(\"21368063004\")\n\tnaturalPerson := personBuilder.Build()\n\n\t//Build a PersonBuilder, set values and build a LegalPerson\n\tpersonBuilder = builder.GetBuilder(\"PJ\")\n\tpersonBuilder.SetName(\"Cool Company\")\n\tpersonBuilder.SetDocument(\"47902850000149\")\n\tlegalPerson := personBuilder.Build()\n\n\t//Begin a Validation chain\n\tvalidationName := &chain.ValidationName{}\n\tvalidationType := &chain.ValidationType{}\n\n\tvalidationType.SetNext(validationName)\n\n\tvalidationType.Execute(naturalPerson)\n\n\tvalidationType.Execute(legalPerson)\n\n\tconst (\n\t\turl  = \"urlDatabase\"\n\t\tport = \"3306\"\n\t\tuser = \"user\"\n\t\tpass = \"pass\"\n\t)\n\n\t//Open connection, heavy process\n\tconn := proxy.OpenConnection(url, port, user, pass)\n\n\t//Access database\n\tmsgI, err := conn.Access(url, port, user, pass)\n\tif err != nil {\n\t\tlog.Fatalln(\"ERROR \", err)\n\t}\n\tlog.Println(msgI)\n\n\t//Do not open connection again\n\tmsgII, err := conn.Access(url, port, user, pass)\n\tif err != nil {\n\t\tlog.Fatal(\"ERROR \", err)\n\t}\n\tlog.Println(msgII)\n\n}
\n

E temos a saída no console assim:

\n
Validation type user starting PF\nExecute next validation\nValidation name user starting John Doe\nValidation finished\nValidation type user starting PJ\nExecute next validation\nValidation name user starting Cool Company\nValidation finished\nA heavy process to create my connection with database\nSuccess to connect database in url: urlDatabase port: 3306 user: user\nSuccess to connect database in url: urlDatabase port: 3306 user: user
\n

O código completo pode ser encontrado aqui

","fields":{"slug":"/go-design-patterns/"},"frontmatter":{"date":"18 de setembro de 2020","description":"Utilizando padrões Builder, Proxy e Chain of Responsibility","title":"Padrões de projeto com GO","tags":["Desenvolvimento","Go","Design Patterns"],"author":"Guilherme Alves","image":{"id":"dff67e4a-12da-5cfd-8642-054621b74375","publicURL":"/static/d8fe2ea5a496774381d13cf0a3bbd058/go-design.png","childImageSharp":{"fluid":{"base64":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAALCAYAAAB/Ca1DAAAACXBIWXMAABYlAAAWJQFJUiTwAAACDUlEQVQoz5WT22sTURDG82eKoC9aJa2FPtQ+KErRQvVBq6AFQdQXfVFB+qRoRUOxpXebNNlkk2z37CWbZHebZjfZ7C2fczYtTaN98INhOMyc38ycS8r3fXD1+/3/sn+JMYbUMJArHtrAfXxsw2uubhhh22giY5gQGiYiDlSUUyCln6nsRfGZ6gnoOL6q6Jj9sIRvZRlzP9bwUxBx79cOxEoFqSgIkqQwHiTXegEeHTRws6TjtWahE0X4aLRwS6xhvlpHPYhQtWxMreXwbmMLi6+eYaEgY6GkwlBoZMfrQez0sHnUQZX83bKB58zEV7ONl6qFRdbEDMF32108pkLzUgN1x8V40cC1HepsdRMX9ghYNdDQNKQOux6YF2C95SJjO5gSNOjU5VvdxizBL+cUrBy6SfcbrQ5mynVUFAmTuyLSBL0u1DCW1zGXLUEScqcjc9lBiImCmnT4VG5iuqgn0Ns07hfqeJJin5ptGPUaxvckpAsabuRVXM1ruC8wlAv7g0vpnxw6Ket4eEKwF4qJph8iiGO80Ww8pFGXrXaSo7VdpAk0IehURMOVfRUPKK7J8t/PJqDLKbo9SF0/MX6+J2vm+ehRXkB77mzncSnLCKbg4paIJYkNznAUeETva9lykhG55x1zn7FdfCdvhfScohBi6Tc+sxreywZWDmQ4pgZVHQGe9wNGdV4W/yl/ADYSKHPbv5hzAAAAAElFTkSuQmCC","aspectRatio":1.7877094972067038,"src":"/static/d8fe2ea5a496774381d13cf0a3bbd058/376bf/go-design.png","srcSet":"/static/d8fe2ea5a496774381d13cf0a3bbd058/c67b7/go-design.png 320w,\n/static/d8fe2ea5a496774381d13cf0a3bbd058/d3930/go-design.png 640w,\n/static/d8fe2ea5a496774381d13cf0a3bbd058/376bf/go-design.png 872w","sizes":"(max-width: 872px) 100vw, 872px"}}}},"timeToRead":10}},"pageContext":{"slug":"/go-design-patterns/","previous":{"fields":{"slug":"/factory-strategy/"},"frontmatter":{"title":"Usando padrões de projeto em uma aplicação","date":"14 set, 2020"}},"next":{"fields":{"slug":"/como-me-organizo-para-estudar/"},"frontmatter":{"title":"Como me organizo para estudar?","date":"24 set, 2020"}}}},"staticQueryHashes":["63159454"]}