Forem: Thiago Lino

Conhecendo o Kotlin

Thiago Lino — Tue, 13 Sep 2022 11:18:44 +0000

Se como eu lhe foi dado o desafio de aprender Kotlin e já trabalhar com a linguagem ou apenas por conhecimento próprio, espero que este post lhe ajude.

Iniciando pela parte técnica o Kotlin se trata de uma linguagem de tipagem estática, os tipos das variáveis são checados durante a compilação gerando um erro se houver troca de tipo. Sua tipagem é forte, o que significa que não possui flexibilidade nas operações entre variáveis de tipos diferentes.

val nomeOperario: String = "José"
val horasExtra: Int = 1000
println(nomeOperario + horasExtra) //gera um erro na compilacao

A declaração de variáveis, como no exemplo acima, usa a palavra chave val ou var. A primeira não permite alterar o valor que lhe foi atribuído, equivalente ao final em java, a última permite que o valor seja alterado após declarado.

O ponto e vírgula ';' no final da linha de trecho é opcional, porém para aproveitar a sintaxe enxuta da linguagem é indicado não adicionar.

Um detalhe importante é que o Kotlin exige que um valor seja atribuído a variável durante sua declaração.

A visibilidade default das variáveis é public.

No Kotlin temos inferência de tipo, porém podemos deixar o valor explícito com dois pontos ':' seguido do tipo.

E como resultado temos:

val nomeOperario: String = "José"

Já que estamos falando de variáveis uma opção interessante para a concatenação de variáveis a String é a utilização do String template, basta adicionar um cifrão '$' na frente do nome da variável para a concatenação:

println("Senhor(a) $nomeOperario ...") // Senhor(a) José ...

Para realizar a concatenação com a propriedade de um objeto é similar, porém com o objeto e propriedade entre chaves '{':

println("Tamanho nome: ${nomeOperario.length}") // Tamanho nome: 4

Caso necessite escapar caracteres especiais podemos usar o raw Strings, adicionamos a string entre um par de 3 aspas duplas:

val workspace = """/home/dev/workspace"""

Inclusive podemos utilizar as 3 aspas duplas para ter uma quebra de linha:

val cargaSemanal = """Fixadas 30 horas semanais com opções:
I. De segunda a sexta com 6(seis) horas diárias"""

Após esta breve visão geral das variáveis, podemos falar sobre os métodos.

Para a declaração do método se inicia com a visibilidade do método, quando omissa a default é public, palavra reservada 'fun' seguido pelo nome do método acompanhado pela abertura e fechamento de parênteses '(', quando houverem parâmetros estes vão entres os parênteses. Caso possua um retorno, dois pontos ':' são adicionados após o parêntese de fechamento seguido pelo tipo do retorno. O retorno quando não especificado é do tipo Unit.

fun salvarReajusteSalarial(): Boolean {
    //realiza reajuste adequado ao operario
}

Os parâmetros dos métodos necessitam terem seus tipos indicados, com o nome do parâmetro acompanhado por dois pontos e seguido pelo seu tipo:

fun logarNotificacao(emailOperario: String, log: Logger): String {
    //loga notificao c sucesso
}

O Kotlin nos permite informar labels(named arguments) nos argumentos, e com isto ao passar para o método podemos alterar a ordem.

logarNotificacao(log = logger, emailOperario = email)

A convenção da linguagem inclusive recomenda o uso de named arguments quando houverem mais de um parâmetro do mesmo tipo ou para parâmetros Booleanos.

Já que estamos falando de parâmetros, vamos falar dos construtores no Kotlin. A linguagem nos da a opção de dois tipos de construtores.
O primário, que definimos ao lado do nome da classe, no header, onde as parâmetros são declaradas dentro dos parênteses.

class Operario constructor(nome: String) {/*...*/}

Caso o construtor não possua anotações ou modificador de visibilidade podemos omitir a palavra chave constructor:

class Beneficio(
    val nome: String, 
    val tipo: TipoBeneficio,
    val desconto: Boolean = false
) {
  /*...*/
}

No exemplo acima, além do omissão da palavra chave constructor os parâmetros recebidos pelo construtor já foram declarados como propriedade da classe ao adicionar a palavra chave val, também é possível utilizar var.

Um detalhe para que a convenção da lingaguem recomenda uma quebra de linha nos parâmetros, quando houverem muitos, além do parênteses que fecha em uma nova linha.
É possível declarar um valor default, como no exemplo, com a propriedade booleana desconto.

Caso exista alguma lógica que precisa ser realizada no construtor podemos criar um bloco init dentro da classe.

class Beneficio(
    val titulo: String, 
    val tipo: TipoBeneficio,
    val desconto: Boolean = false
) {

  init {
    //realiza alguma logica com alguma das propriedades
  }
}

Como segunda opção temos o construtor secundário, onde podemos implementar alguma lógica existente dentro de um bloco constructor:

class Beneficio() {

  var titulo: String = ""   

  constructor(tituloBeneficio: String) {
    // implementa alguma logica com a propriedade
  }
}

O mais comum que vamos ver no dia a dia irá ser o uso do construtor primário.

E para finalizar, vamos abordar como o Kotlin trabalha com encapsulamento através dos getters e setters.

Por sua existência implícita não se costuma criar getters e setters no Kotlin. O get e set vão possuir as mesmas visibilidades das propriedades a que se referem.

Porém as visibilidades do get e set podem ser customizadas.

 var titulo: String = ""
    private set

No exemplo acima o get para titulo, assim como a propriedade, vão ter uma visibilidade pública, já o set passou a ser private. Logo pode ser lida por qualquer um, porém apenas modificada dentro da classe.

E para os casos em que precisamos adicionar lógica aos get e set?
O Kotlin nos permite customizar isto também:

var titulo: String = ""
  set(tituloBeneficio) {
    if(tituloBeneficio.length <= tamanhoMaximoPermitido) {
      field = tituloBeneficio
    }
  }

No exemplo temos a customização de uma lógica ao set da propriedade titulo. O interessante de notar aqui é a palavra chave field, que se refere a propriedade em questão, titulo.
Portanto, no exemplo temos uma validação da quantidade de caracteres do valor recebido(tituloBeneficio), para então a atribuição a propriedade titulo representado pela palavra chave field.

Concluo aqui este post onde me preocupei em trazer pontos do Kotlin diferentes da maioria das linguagens. A linguagem traz outros pontos interessantes e de destaque, porém creio ser melhor abordar em outras postagens.

Obrigado pelo seu tempo e se pensa que ficou faltando algo, aceito sugestões.

Spring com MongoDB

Thiago Lino — Mon, 22 Nov 2021 12:17:52 +0000

Hoje em dia com tantas opções para armazenamento de informações para necessidades diferentes, saber como trabalhar com estas opções é importante.

Por isso decidi escrever esse tutorial de como criar uma aplicação em java utilizando um banco de dados NoSQL.
E para isto criei uma POC para ilustrar utilizando as tecnologias, java 8, spring(spring data mongodb) e o mongoDB.

Decidi por dividir o tutorial e iniciar este com a integração da nossa aplicação com a base de dados.

Vamos iniciar baixando o spring no Spring Initializr. E lá já podemos especificar as dependências necessárias.

fig. 1 - print com as dependências

Aqui selecionei o Spring Web, já que pretendo montar aqui uma aplicação web e ja vem com o Spring MVC além do servidor web Apache Tomcat, Thymeleaf para ser nosso template e por último o Spring Data MongoDB que vai nos auxiliar a guardar e recuperar nossa informação.

Agora vamos ao MongoDB e aqui invés de subir em um docker container ou até instalar localmente eu optei por usar a versão cloud e lá podemos utilizar a versão trial.

fig. 2 - print mongodb cloud

Esse doc da um passo a passo para:

criação da conta grátis
do cluster
adicionar seu IP para acesso ao cluster
criação de um usuário para o cluster

O doc é bem explicado e tranquilo de seguir, porém só encontrei a versão em inglês.

Com os passos acima realizados é hora de testar conectando nossa aplicação ao cluster recém criado.

Precisamos recuperar nossa string de conexão, para isto acesse seu cluster e no dash clique em Connect

fig. 3 - dash do cluster para pegar o host

E no box que vai abrir selecione Connect your application

fig. 4 - box com opções de conexão

E aqui vamos selecionar o driver para a conexão e neste caso Java e a versão mais recente dele e logo abaixo já temos nossa string de conexão.

fig. 5 - box para seleção de driver e string de conexão

Na fig. 3 no dash do cluster podemos criar nosso database clicando em Browse Data que irá abrir uma tela com nossas collections.

fig. 6 - box para criar database e collection

Clicando em Create Database irá abrir um box para definirmos o nomes da database e collection.

Certo agora podemos definir estar informações em nossa aplicação, no arquivo application.properties dentro de resources.

fig. 7 - localização do arquivo application.properties

Aqui vamos definir as properties necessárias para conectar a nossa database.

spring.data.mongodb.uri={aqui nossa string de conexão}
spring.data.mongodb.database={aqui o nome da database criada}

E ao iniciar nossa aplicação vamos receber uma mensagem similar a esta.

fig.8 - mensagem de conexão criada com o mongodb

Por último podemos já interagir com nossa database e collection recém-criadas, inciando com a criação de um repository.

Dentro do nosso package podemos criar um diretório novo chamado repository e dentro dele nossa interface a PetRepository esta por sua vez vai extender a MongoRepository que traz os métodos como insert(), findAll(), saveAll() para o comunicação com nosso Mongo.

@Repository
public interface PetRepository extends MongoRepository<Pet, String> {
}

Adicionamos a anotação @Repository para o spring saber do que se trata e além disso passamos para nosso MongoRepository a entity Pet que vamos criar agora.

Aqui vamos fazer uma simples Entity com o identificador id(o MongoDB precisa deste) com a anotação @id, name, age e type do pet que vamos manipular. Anotamos a entidade com o nome da collection que vamos mapear.

@Document(collection="pets")
public class Pet {

    @Id
    private String id;

    private String name;
    private int age;
    private String type;

// todos os getters e setters
}

Só um detalhe para o atributo type que aqui pretendo criar uma classe para ele, porém para agilizar o teste fiz com tipo String.

Com isso já podemos criar nosso service que vai chamar os métodos do nosso repository. Criamos um pacote chamado service e dentro dele nosso PetService com um método para retornar todos os pets existentes.
Anotamos a classe com a anotação @Service e injetamos nossa dependência PetRepository com a anotação @Autowired e criamos o nosso método findAll()

@Service
public class PetService {

    @Autowired
    private PetRepository repository;

    public List<Pet> findAll() {
        return repository.findAll();
    }
}

E agora para ver nossos pets cadastrados vamos criar uma controller para através da nossa service resgatar nossos pets. No código abaixo da para ver que algumas partes são similares a nossa service, mudando alguns detalhes como a injeção que desta vez é nossa PetService e as anotações usadas, como a @RequestMapping para mapear as requisições recebidas. E por último recebemos como parâmetro um Model para setar o atributo para nossa view

@Controller
@RequestMapping("/pets")
public class PetController {

    @Autowired
    private PetService petService;

    @RequestMapping("/list")
    public String list(Model model) {
        final List<Pet> petList = petService.findAll();
        model.addAttribute("pets", petList);

        return "pets/list";
    }
}

Só precisamos criar nosso arquivo html em um diretório dentro de resources > templates chamados pets. Aqui fiz um html bem simples, apenas para listar o nome e idade dos nossos pets e neste html como estamos usando a biblioteca thymeleaf usei as propriedades da mesma para iterar e exibir os itens.

<body>
    <div id="listPets">
        <h3>List all pets</h3>
        <table>
            <thead>
            <tr>
                <td>Name: </td>
                <td>Age: </td>
            </tr>
            </thead>
            <tr th:each="pet : ${pets}">
                <td><span th:text="${pet.name}"></span></td>
                <td><span th:text="${pet.age}"></span></td>
            </tr>
        </table>
    </div>
</body>

E quando rodarmos temos uma página sem itens. E por quê? Porque não adicionamos nenhum item e agora é uma boa oportunidade para também testarmos o insert.

Na nossa entity criei um construtor, para facilitar a atribuição da nossa entidade, passando o name, type e age.

public Pet(String name, String type, int age) {
     this.name = name;
     this.type = type;
     this.age = age;
}

No service criamos um novo método chamado save que recebe a entidade Pet e chamamos nosso PetRepository chamando o método save() passando nosso pet.

public void save(Pet pet) {
     repository.save(pet);
}

Nossa controller vai chamar o save() da nossa PetService
passando um novo Pet e retornando uma string com o html que vamos criar

@GetMapping("/populate")
public String populateWithPets() {
     petService.save(new Pet("nina", "cat", 7));
     return "pets/populate";
}

E por fim criamos um html, aqui pode ser vazio, em templates > pets, que já tinhamos criado anteriormente.

E se tudo deu certo depois de acessar nossa url pets/populate podemos conferir nosso pet recém salvo em pets/list ou até mesmo dentro do nosso cluster la no mongodb atlas

fig. - 9 pet salvo no mongodb

E para esta primeira parte do tutorial creio ser o suficiente, pretendo continuar com o tutorial utilizando esta app para nos auxiliar. Se tiverem alguma dúvida, dificuldade ou verem algum ponto que poderia ter feito de outra maneira só comentarem para interagirmos.

Obrigado e nos vemos na continuação =)

Injeção de dependência através de atributos é o ideal?

Thiago Lino — Tue, 23 Feb 2021 11:56:14 +0000

No framework Spring quando queremos fazer alguma injeção de dependência (DI) é comum fazermos por atributos.

 @Autowired
 private InjectedDependency injectedDependency;

Porém este método tem suas desvantagens e vou dizer quais.
Mas antes vamos escolher uma batida para acompanhar.

Agora sim.

Existem 3 maneiras de se realizar a injeção de dependência no Spring, apesar da documentação, no momento que escrevo, citar apenas duas. A já citada e exemplificada por atributo, através do construtor da classe e por setters métodos.

Pelo construtor:

private InjectedDependency injectedDependency;

@Autowired
public MyDependencyInjection(InjectedDependency injectedDependency) {
  this.injectedDependency = injectedDependency;
}

E por setters:

private InjectedDependencyOne injectedDependencyOne;
private InjectedDependencyTwo injectedDependencyTwo;

@Autowired
private void setInjectedDependencyOne(InjectedDependencyOne injectedDependencyOne) {
  this.injectedDependencyOne = injectedDependencyOne;
}

@Autowired
private void setInjectedDependencyTwo(InjectedDependencyTwo injectedDependencyTwo) {
  this.injectedDependencyTwo = injectedDependencyTwo;
}

A primeira vista realizar a injeção de dependência por atributos parece ser, e é, mais simples e menos verbosa. Uma linha e direto ao ponto(tirando a anotação). Porém nem sempre o simples é o melhor, eis os pontos negativos.

Não permite imutabilidade dos nossos atributos

Nossa injeção não funcionará com atributos da classe que forem declarados como final, logo perdemos a imutabilidade destes atributos. Com a injeção através dos construtores não perderiamos a imutabilidade destes atributos.

Ferir o S do SOLID

Adicionar dependências a nossa classe por atributos por ser menos verboso pode trazer o problema de nossa classe possuir várias dependências sem nos darmos conta que a classe esta fazendo mais do que deveria, tendo mais de uma responsabilidade ferindo o Single responsibility principle. A injeção através dos construtores nos ajudaria tornando este construtor cheio e mais visível da quantidade de dependências e responsabilidades da classe .
Aqui diria que é mais questão de dar visibilidade que uma refatoração pode ser necessária.

Esconde as dependências

A classe perde a responsabilidade por obter e gerenciar as dependências, deixando a cargo dos containers de injenção de dependência. Neste cenário seria ideal deixar claro, além de ser recomendável quando se usa DI, quais as dependências utilizadas são obrigatórias e quais são opcionais. O que ficaria inviável através de atributos. Utilizando construtores para obrigatórios e setters para opcionais conseguimos.

Acoplamento do container de DI

Como citado anteriormente a responsabilidade agora será dos containers de DI, neste caso containers Spring. O que deixa nosso desenvolvimento acoplado ao container.
Fora do container da aplicação fica mais dificíl utilizar estas dependências. Em um cenário de testes unitários por exemplo, seria necessário instanciar este Spring container(o que alteraria nosso teste unitário para um de integração) e utilizar reflexão para settar estes atributos.
Utilizando a DI com construtores invés de por atributos, apenas instanciamos estas classes e passamos como nossas dependências.

Conclusão

Realizar a injeção de dependência por construtores ou através de setters apesar de ser mais verboso deixa nosso código mais legível, na minha opinião.
Um dos exemplos seria quando temos um construtor com muito parâmetros, neste caso as dependências, indica que nossa classe faz mas do que deveria e pode caber uma refatoração. Ainda sobre ser tornar o código legível, podemos citar também sobre a obrigatoriedade de uma dependência quando passada através de construtores ou sua opcionalidade quando passada por setteres.

Se você achou que tem um ponto ou vários que não faz sentido comenta ae pra gente debater sobre, uma discussão saúdavel é ótimo para aprender.

Referências que usei