docs: added java docs

docs/linguagens/java/configuracoes-iniciais.mdx

@@ -0,0 +1,148 @@
+---
+title: "Configurações Iniciais"
+displayed_sidebar: javaSidebar
+---
+
+import {Directory} from "../../../src/components/Directory/Directory";
+
+Para acessar o token do seu bot, veja o [guia de como criar uma aplicação no Discord Developer Portal](#)
+
+### Definindo variáveis de ambiente
+Vamos usar o arquivo `.env` para criar as variáveis de ambiente, são pares de chave-valor que ficam salvos no sistema operacional. Geralmente são usadas pra armazenar informações sensíveis, como chaves de API, senhas ou configurações específicas do projeto.
+Nesse caso podemos salvar o token do bot, dessa forma:
+
+```ini title=".env"
+BOT_TOKEN=SEU_TOKEN
+```
+
+### Iniciando o projeto
+
+Antes de tudo, precisamos entender que o Java possui gerenciadores de dependências, o Gradle e o Maven. Nesse guia, vamos usar o Gradle, pois é mais moderno e mais fácil de usar.
+E iremos utilizar uma IDE (Integrated Development Environment) para facilitar o desenvolvimento, nesse caso, vamos usar o IntelliJ IDEA. A versão Community é gratuita e atende perfeitamente para o desenvolvimento de bots.
+
+Para criar um projeto Gradle, abra o IntelliJ IDEA e clique em `New Project`. Depois, digite o nome do projeto, depois, selecione o diretório do projeto, selecione a linguagem `Java`, em seguida, selecione o `Build System` em `Gradle`.
+Depois disso, na opção `JDK`, selecione a versão 21 do Java, caso não encontre, clique na opção `Download JDK` e baixe a versão 21.
+Agora, expanda a opção `Configurações Avançadas` ou `Advanced Settings` altere os campos `GroupId` e `ArtifactId` para o nome do seu projeto.
+O que seria cada campos?
+- `GroupId`: É o nome do pacote do seu projeto, geralmente é o nome do seu domínio ao contrário. (Exemplo: `com.example`)
+- `ArtifactId`: É o nome do seu projeto. (Exemplo: `discordbot`)
+
+A configuração deve ficar assim
+[![image](./assets/intellji-setup.png)](./assets/intellji-setup.png)
+
+Após isso, iremos se deparar com essa seguinte estrutura.
+
+<Directory>
+    <Directory.Folder name='src'>
+        <Directory.Folder name='main'>
+            <Directory.Folder name='java'>
+                <Directory.Folder name='com'>
+                    <Directory.Folder name='example'>
+                        <Directory.File name='Main.java'/>
+                    </Directory.Folder>
+                </Directory.Folder>
+            </Directory.Folder>
+            <Directory.Folder name='resources'/>
+        </Directory.Folder>
+        <Directory.Folder name='test'>
+            <Directory.Folder name='java'/>
+            <Directory.Folder name='resources'/>
+        </Directory.Folder>
+    </Directory.Folder>
+    <Directory.File name='build.gradle'/>
+    <Directory.File name='.gitignore'/>
+    <Directory.File name='gradlew'/>
+    <Directory.File name='gradlew.bat'/>
+    <Directory.File name='settings.gradle'/>
+</Directory>
+
+Explicando a estrutura:
+- `src/main/java`: É onde ficam os códigos fontes do projeto.
+- `src/main/resources`: É onde ficam os recursos do projeto, como arquivos de configuração.
+- `src/test/java`: É onde ficam os testes do projeto.
+- `src/test/resources`: É onde ficam os recursos dos testes.
+- `build.gradle`: É o arquivo de configuração do Gradle, onde ficam as dependências e configurações do projeto.
+- `.gitignore`: É o arquivo que diz ao Git quais arquivos e pastas ignorar.
+- `gradlew` e `gradlew.bat`: São scripts que permitem rodar o Gradle sem precisar instalar ele na máquina.
+- `settings.gradle`: É o arquivo de configuração do Gradle, onde ficam as configurações do projeto.
+
+
+Agora que possuímos a estrutura do projeto, vamos adicionar as dependências necessárias para o bot funcionar.
+Iremos adicionar as dependências do JDA, que é a biblioteca que usaremos para criar o bot.
+Ao abrir o arquivo `build.gradle`, iremos se deparar com o seguinte conteúdo:
+```gradle title="build.gradle"
+plugins {
+    id 'java'
+}
+
+group = 'org.example'
+version = '1.0-SNAPSHOT'
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation platform('org.junit:junit-bom:5.9.1')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+}
+
+test {
+    useJUnitPlatform()
+}
+```
+
+Para adicionar as dependências do JDA, iremos adicionar o seguinte código no arquivo `build.gradle` dentro do bloco `dependencies`:
+```gradle title="build.gradle"
+dependencies {
+    implementation 'net.dv8tion:JDA:5.0.0-beta.22'
+}
+```
+
+A interpreção de um arquivo `.env` é feita através da biblioteca `dotenv`, que não é nativa do Java, então precisamos adicionar ela ao nosso projeto.
+Para isso, vamos adicionar a dependência no arquivo `build.gradle` dentro do bloco `dependencies`:
+```gradle title="build.gradle"
+dependencies {
+    implementation 'io.github.cdimascio:java-dotenv:3.0.0'
+}
+```
+
+Para garantir que o bot esteja funcionando corretamente, vamos adicionar uma biblioteca de Logging, que é uma prática comum para debugar o bot.
+Para isso, vamos adicionar a dependência no arquivo `build.gradle` dentro do bloco `dependencies`:
+```gradle title="build.gradle"
+dependencies {
+    implementation 'ch.qos.logback:logback-classic:1.4.14'
+}
+```
+
+O arquivo `build.gradle` deve ficar assim:
+```gradle title="build.gradle"
+plugins {
+    id 'java'
+}
+
+group = 'org.example'
+version = '1.0-SNAPSHOT'
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation platform('org.junit:junit-bom:5.9.1')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+    implementation 'net.dv8tion:JDA:5.0.0-beta.22'
+    implementation 'io.github.cdimascio:java-dotenv:3.0.0'
+    implementation 'ch.qos.logback:logback-classic:1.4.14'
+}
+
+test {
+    useJUnitPlatform()
+}
+```
+
+Ao alterar, iremos ver que irá aparecer um símbolo de sincronização, clique nele para sincronizar as dependências.
+[![image](./assets/intellji-gradle-setup.png)](./assets/intellji-gradle-setup.png)
+
+É possivel acompanhar o progresso da sincronização no canto inferior direito. Onde existe um ícone de um martelo. Caso esteja marcado sucesso, significa que a sincronização foi bem sucedida.
+[![image](./assets/intellji-gradle-setup-success.png)](./assets/intellji-gradle-setup-success.png)

docs/linguagens/java/definindo-o-bot.mdx

@@ -0,0 +1,75 @@
+---
+title: "Definindo o bot"
+sidebar_position: 3
+displayed_sidebar: javaSidebar
+---
+
+# Definindo o bot
+
+Agora que as bibliotecas estão instaladas e o token já está armazenado no .env, precisamos definir a classe do `bot`.
+Antes de tudo, precisamos apagar o conteúdo do arquivo `Main.java`, pois vamos reescrever o código. Iremos apenas manter isso:
+
+```java title="src/main/java/org/example/Main.java"
+public class Main {
+    public static void main(String[] args) {
+    }
+}
+```
+
+Agora, vamos criar a classe do bot. Crie um novo arquivo chamado `Bot.java` dentro do pacote `org.example`.
+Depois disso, precisamos configurar o dotenv, para que possamos acessar o token do bot. Para isso, adicione o seguinte código no início da classe:
+```java title="src/main/java/org/example/Bot.java"
+package org.example;
+
+import io.github.cdimascio.dotenv.Dotenv;
+
+public class Bot {
+    private final Dotenv dotenv = Dotenv.load();
+    private final String token = dotenv.get("BOT_TOKEN");
+
+    public Bot() {
+    }
+}
+```
+Lembra que falamos sobre o dotenv? Aqui estamos carregando o arquivo `.env` e pegando o token do bot com nome `BOT_TOKEN`. Agora, vamos criar o codigo para que o nosso bot seja carregado e inicie.
+
+```java title="src/main/java/org/example/Bot.java"
+package org.example;
+
+import io.github.cdimascio.dotenv.Dotenv;
+import net.dv8tion.jda.api.JDABuilder;
+import net.dv8tion.jda.api.requests.GatewayIntent;
+
+public class Bot {
+    private final Dotenv dotenv = Dotenv.configure().directory("./.env").load();
+    private final String token = dotenv.get("BOT_TOKEN");
+
+    public Bot() {
+        JDABuilder builder = JDABuilder.createDefault(token);
+        builder.enableIntents(GatewayIntent.MESSAGE_CONTENT, GatewayIntent.GUILD_MESSAGES);
+        builder.build();
+    }
+}
+```
+
+Entendendo o código:
+- `JDABuilder.createDefault(token)` - Cria um novo `JDABuilder` com o token do bot.
+- `builder.enableIntents(GatewayIntent.MESSAGE_CONTENT, GatewayIntent.GUILD_MESSAGES)` - Habilita as intents necessárias para o bot funcionar.
+- `builder.build()` - Inicia o bot.
+
+O que são intents? Intents são uma forma de o Discord saber o que o bot pretende fazer. Por exemplo, se o bot pretende receber mensagens de texto, ele precisa da intent `MESSAGE_CONTENT`. Se o bot pretende receber mensagens de um servidor, ele precisa da intent `GUILD_MESSAGES`. No nosso caso, estamos habilitando as intents `MESSAGE_CONTENT` e `GUILD_MESSAGES`.
+
+Agora, na classe `Main`, vamos instanciar a classe `Bot` para que o bot seja iniciado.
+
+```java title="src/main/java/org/example/Main.java"
+package org.example;
+
+public class Main {
+    public static void main(String[] args) {
+        new Bot();
+    }
+}
+```
+:::warning[Aviso]
+Caso não tenha habilitado as intents no painel do Discord Developer Portal, você receberá um erro na hora de iniciar o bot. Qualquer dúvida consulte o [guia de intents do Discord](#).
+:::

docs/linguagens/java/index.mdx

@@ -0,0 +1,18 @@
+---
+sidebar_position: 1
+displayed_sidebar: javaSidebar
+pagination_prev: linguagens/index
+---
+
+# Instalação
+
+:::info
+Veja nosso [guia de como instalar o java em sua máquina](#), antes de iniciar a criação do bot
+:::
+
+### Requisitos
+- OpenJDK 21
+- [IntelliJ IDEA Community Edition](https://www.jetbrains.com/idea/download/other.html)
+
+### Instalação do Java
+Para instalar o Java, basta entrar no site da [Oracle](https://www.oracle.com/java/technologies/downloads/) e baixar a versão 21 do Java.