Variáveis de ambiente no Kotlin
Tags: kotlin, braziliandevs
Published: 2021-09-10 02:56:30

## Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade [Kotlinautas](https://twitter.com/kotlinautas/), uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

![capa Kotlinautas](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jreawpvk6whxigcpmctf.png)

## Variáveis de ambiente no Kotlin (Dotenv)

## O quê são variáveis de ambiente?

Variáveis de ambiente são variáveis que poderão ser usadas em qualquer parte de um projeto, ou de vários projetos ao mesmo tempo. Essas variáveis geralmente são senhas, nomes de usuários, tokens para conexão em serviços externos,etc.

As variáveis de ambiente são usadas principalmente por dois motivos, pela praticidade. Pois poderemos referenciar uma informação na aplicação inteira como uma variável, podendo assim mudar essa informação á qualquer momento. E também pela segurança, Pois a declaração de uma variável de ambiente não é feita dentro do código, mas sim fora em um arquivo específico.

## O quê é dotenv-kotlin?

[dotenv-kotlin](https://github.com/cdimascio/dotenv-kotlin) é uma biblioteca que faz a função de pegar variáveis de ambiente escritas em arquivos ou variáveis de ambiente do sistema, e permitir que essas variáveis sejam usadas no código.

## Materiais

Será necessário ter o [IntelliJ](https://www.jetbrains.com/idea/) instalado na máquina e um conhecimento básico sobre a linguagem [Kotlin](https://kotlinlang.org/).

## Criando projeto

Vá no seu intelliJ, e clique no botão `New Project` para criar um novo projeto:

![Botão new project do intelliJ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0fssshi85g4449wtxnm3.png)

Após isso, na interface de configurações do Gradle deverão ficar assim, habilitando o **Kotlin DSL build script**, e também habilitar a opção **Kotlin/JVM**. Opicionalmente você pode remover a opção **Java**, pois não iremos usar Java nesse projeto.

![Configurações do Gradle](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/22ugmlrmb5n210a2l1gk.png)

Clique agora em **Next** para escolher um nome para o projeto, pode ser qualquer nome que você quiser. Caso não tenha nenhuma ideia, pode ser algo como `kotlin-dotenv` por exemplo.


### Instalando dotenv-kotlin

Vá no arquivo `build.gradle.kts` e adicione o dotenv-kotlin como dependência:

```kotlin
dependencies {
    implementation(kotlin("stdlib"))
    implementation("io.github.cdimascio:dotenv-kotlin:6.2.2")
}
```

Após isso, clique no elefante do Gradle no canto superior direito para instalar a dotenv-kotlin como dependência:

![Elefante do Gradle no canto superior direito](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6ear3utsrj0yhjjfcsk2.png)

Pronto, agora temos o dotenv-kotlin instalado em nosso projeto.

## Usando dotenv-kotlin

`.env` é o arquivo que iremos incialmente armazenar as nossas variáveis de ambiente da nossa aplicação. Crie esse arquivo na raiz do projeto (lembre-se se colocar o . antes do arquivo). Por enquanto, vamos apenas inserir uma variável chamada `DADO`, e colocar um valor padrão como `teste`. Para criar variáveis em arquivos dotenv pode ser feito da seguinte forma:

```
DADO=teste
```

É um padrão que variáveis de ambiente sejam em maíusculo, para separar as variáveis de ambiente, das variáveis normais do nosso código.

Agora vamos criar o arquivo principal da nossa aplicação, o `main.kt` em `src/main/kotlin`. Dentro desse arquivo vamos importar o dotenv-kotlin:

```kotlin
import io.github.cdimascio.dotenv.dotenv
```

Agora vamos criar uma variável global chamada `dotenv` que irá armazenar as variáveis de ambiente. Essa variável pode ser criada dessa maneira:

```kotlin
import io.github.cdimascio.dotenv.dotenv

val dotenv = dotenv()
```

Agora, temos a variável `dotenv` que é uma lista associativo que contém todas as variáveis de dentro do `.env`. Com isso, podemos pegar a variável `DADO` usando `dotenv["DADO"]`. Vamos criar uma função `main` que irá mostrar essa variável `DADO` dessa maneira:

```kotlin
import io.github.cdimascio.dotenv.dotenv

val dotenv = dotenv()

fun main(){
	println(dotenv["DADO"])
}
```

- Mostramos na tela essa variável de ambiente `DADO` com a lista assocativa `dotenv`

O retorno dessa função será o valor da variável de ambiente `DADO`:

```
teste
```

### Configurando dotenv-kotlin

Podemos também adicionar algumas configurações ao dotenv-kotlin. Como por exemplo o diretório que iremos buscar, e se caso o arquivo não seja encontrado, ou invés de retornar um erro, que o retorno seja um `null`. Essas duas configurações podem ser feitas mudando a variável `dotenv` dessa maneira:

```kotlin
import io.github.cdimascio.dotenv.dotenv

val dotenv = dotenv {
	directory = "./src"
	ignoreIfMissing = true
}
```

- `directory` irá determinar qual será a pasta que o dotenv-kotlin irá procurar pelo `.env`;
- `ignoreIfMissing` é a variável que irá determinar se caso o arquivo não seja encontrado, se vamos ignorar esse fato ou vamos fechar o código com um erro;

Agora, mude o arquivo `.env` da raiz do projeto, e move para a `/src`. Caso você rode o código novamente, o resultado será o mesmo:

```
teste
```

Isso aconteceu pois mudamos tanto o lugar que o `.env` está sendo procurado, quanto a localização do próprio `.env`. Busque agora deletar o `.env`. Com isso, o resultado do nosso código será:

```
null
```

Esse resultado ocorreu pois como ignoramos quando o arquivo não é encontrado, qualquer valro que você tente obter usando a `dotenv["NOME DA VARIÁVEL"]` será um `null` (valor nulo).

Caso você precise trocar o nome do arquivo `.env`, também será necessário trocar o arquivo que o dotenv-kotlin irá buscar. Isso pode ser feito mudando a variável `filename` dessa maneira:

```kotlin
import io.github.cdimascio.dotenv.dotenv

val dotenv = dotenv {
	filename = "minhaenv"
}
```

Agora, caso você tenha um arquivo `minhaenv` com variáveis de ambiente sendo declaradas, você poderá usar as variáveis de dentro desse arquivo no seu código.

## Compartilhando o código

> Como posso compartilhar o meu código, e não compartilhar as variáveis de ambiente?

Vamos supor que você está usando o [Git](https://git-scm.com/) controle de versão, e eventualmente um [GitHub](https://github.com) para hospedar esse repositório Git. Para esconder o arquivo `.env` por exemplo (ou qualquer outro) você pode adicionar esse arquivo á uma lista de arquivos que serão ignorados pelo Git, e não irão ser indexados ou enviados em nenhum commit.

Essa lista de arquivos ignorados é chamada de **Git Ignore**. Para você criar essa lista, crie um arquivo chamado `.gitignore` e dentro desse arquivo coloque os nomes dos arquivos que você deseja ignorar. Como:

```
.env
```

Caso seu `.env` esteja dentro da pasta `src/` por exemplo, aumente o caminho do arquivo:

```
src/.env
```

Pronto, agora esse arquivo `.env` será completamente ignorado pelo Git.

## Finalização

Agora você já sabe como usar de maneira básica a biblioteca [dotenv-kotlin](https://github.com/cdimascio/dotenv-kotlin) para armazenar variáveis de ambiente do seu projeto. Procure no GitHub dessa biblioteca por mais informações de casos e configurações específicas dessa lib como conhecimento complementar caso queira. Mas para uso básico esse artigo já é suficiente.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo [@lissatransborda](https://twitter.com/lissatransborda) 👀