Forem: Diego Henrique

O Método Equals em Java

Diego Henrique — Wed, 07 Feb 2024 18:15:02 +0000

Se você tem ou ja teve contato com alguma linguagem de programação, sabe que quando queremos comparar valores de variaveis diferentes, utilizamos uma estrutura condicional e um operador, como no exemplo abaixo onde estou verificando se o conteudo da variavel x é igual ao conteudo da variavel y, feito em Python:

variavel1 = "Diego"
variavel2 = "Diego"
if variavel1 == variavel2:
  return true
return false

Fazendo uma breve analise sobre esté codigo, podemos afirmar que o retorno dessa função será true, logo que o conteudo de ambas variaveis, são identicos, e essa afirmação está correta.

Vamos analisar de forma técnica como isso está acontecendo.

Ao declararmos uma váriavel em python, o que está acontecendo é que estamos criando um objeto String na memoria e armazendo o conteudo informado pelo programador, por padrão precisamos definir o nome dessa variavel, que vai ser utilizado como forma de caminho na memoria, na ilustração abaixo, podemos compreender melhor esse comportamento.

Porém, quando tentamos repetir o mesmo código feito anteriormente, mas dessa vez em Java, nos deparamos com um comportamento estranho:


  String variavel1 = new String("hello");
  String variavel2 = new String("hello");
  if (str1 == str2) {
      return true;
  }
  return false;
}

O motivo pela qual afirmei ser estranho, é que o retorno dessa comparação é false!

Ue mas como assim ? ambas variaveis tem o mesmo conteudo, correto? Sim, está correto, porém, em Java o comportamento informado anteriomente sobre como nosso objeto é armazenado na memoria, ocorre de maneira diferente, vamos entender.

Como vimos em Python, nossa variavel está diretamente relacionada com o conteudo na memoria, então quando chamamos o nome da variavel na nossa IDE, estamos acessando diretamente o conteudo na memoria.

O que é diferente em Java, pois quando chamamos a nossa variavel, o que está acontecendo por trás dos panos, é que estamos chamando um valor de refererencia no qual o nosso objeto está armazenado na memoria, segue a ilustração:

Esse é o principal motivo pela qual nossa comparação retornou false, isso porque, o que estamos comparando na realidade, não é o conteudo das variaveis, mas sim o valores de referencia na memoria.

Vamos utilizar um exemplo mais simples para compreendermos melhor esses comportamentos.

No caso vamos imaginar que um entregador precisa entregar um produto para um determinado cliente e para isso precise passar por um tunel, entenda esse tunel como nossa variavel.

Primeiramente vamos simular esse exemplo utilizando como base o Python:

O entregador tem um tunel a sua frente, o destino final desse tunel, tem exatamente a casa do nosso cliente, logo conseguimos acessar a casa do cliente e entregar seu produto.

Agora usando como Java como base para o nosso exemplo:

Agora o nosso entregador está na mesma situação anterior, porém o tunel, não tem exatamente o endereço do nosso cliente, mas sim o endereço da sua cidade, logo para acessarmos a casa do nosso cliente, primeiramente temos que passar pela cidade do cliente que contém o endereço correto de sua casa, logo podemos entregar seu produto.

Espero que dessa forma, tenha compreendido melhor a diferença entre essas duas.

Certo, mas como podemos ajudar o nosso entregador, ter acesso direto a casa do nosso cliente? É aqui que nosso metodo "equals" entra para nos ajudar nessa missão!

O metodo equals do Java, é um metodo booleano que recebe uma String em seu parametro, a funcionalidade dele é comparar o valor do objeto no qual está sendo chamado com o valor que está recebendo em seu parametro.

Note que o metodo equals não está comparando com o valor de referência, mas sim com o valor do conteudo do objeto

public class Main {
    public static void main(String[] args) {
        String variavel = new String("Diego");
        System.out.println(variavel.equals("Diego"));

// Nesse código, o método equals está acessando o valor"Diego" da variável e comparando se é igual ao "Diego" que está sendo passado como parâmetro. Logo seu retorno é true!
    }
}

Entenda nosso metodo "equals" como um atalho para nosso entregador, dessa forma, no final desse atalho, temos a casa do seu cliente.

Agora vamos refatorar nosso codigo anterior em Java:

  String str1 = new String("hello");
  String str2 = new String("hello");
  if (str1.equals(str2)) {
      return true;
  }
  return false;
}

Dessa forma, temos o nosso resultado "true" esperado, e finalmente conseguimos finalizar esse código corretamento.

Observação:

Atualmente em Java, não precisamos fazer a instanciação de uma variavel de tipo String, basta apenas definir o tipo da variavel e o seu valor, dessa forma temos um comportamento um pouco diferente do que abordei no artigo, envolvendo POOL DE STRINGS, que psso abordar em outro artigo. Mas é impontante ressaltar que mesmo assim, ainda é necessário utilzar equals pelos mesmos motivos anteriores.


  private static boolean teste() {
      String str1 = "hello";
      String str2 = "hello";
      return str1.equals(str2);
}

Conclusão:

A forma em que acessamos Strings em Java é um pouco diferente de outras linguagens, dado que nossa variavel não é o caminho direto para o objeto em memoria, mas sim ao um valor de referencia, utilizado para acessar o objeto em si.

Fontes:

(https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#equals-java.lang.Object-)

(https://codegym.cc/pt/quests/lectures/pt.questsyntaxpro.level07.lecture02)

Entendendo o funcionamento de uma API WEB REST

Diego Henrique — Tue, 12 Dec 2023 23:12:56 +0000

Antes de qualquer coisa, é essencial compreender alguns processos básicos.

Introdução às APIs web

Primeiramente precisamos dividir a forma em que vemos a WEB em dois termos, o CLIENT-SIDE (O navegador) e o SERVER-SIDE (O servidor). Ao acessarmos um site, o client tem a função de enviar as solicitações necessárias ao servidor. Por exemplo, ao buscar um item na Amazon, nesse momento o client faria uma solicitação para o servidor, onde após todo o processo de gerenciamento dos dados, retornaria uma resposta ao client com os dados desse item, que seriam exibidos ao usuário no site.

Toda essa comunicação utiliza o protocolo HTTPS em conjunto com a arquitetura REST, que vamos entender agora.

REST ou Representational State Transfer

É uma arquitetura que fornece padrões de comunicações entre Sistemas utilizando a WEB, existem vários conceitos aplicados nessa arquitetura, mas os que vamos abordar aqui, são eles: Verbos e Stateless.

VERBOS: Quando falamos de solicitações ao servidor, utilizamos alguns verbos para determinar o tipo de solicitação que está sendo enviada, sendo elas:

GET- Recuperar um recurso, como a busca de um item específico na Amazon;
POST- Criar um novo recurso;
PUT- Atualizar completamente um recurso;
PATCH- Atualizar parcialmente um recurso;
DELETE- Remover um recurso.

STATELESS: Você pode imaginar que sites famosos como a Amazon por exemplo, possui milhões de acessos todos os dias, pense que para cada usuário utilizando a plataforma, é feita uma solicitação ao servidor. Por conta desses inúmeros acessos, precisamos manter um bom desempenho no servidor, e uma das práticas utilizadas é que o servidor não necessite de contexto, isso quer dizer que ao receber uma solicitação, o servidor não precise saber necessariamente quem é o usuário e o que o mesmo solicitou anteriormente. Dessa forma, toda requisição é única, não armazenando estados e solicitações anteriores. Mesmo assim, o servidor consegue facilmente entender qual é sua solicitação e o que deve fazer por meio do tipo de verbo que está sendo utilizado.

Agora que entendemos um pouco sobre REST, vamos de fato ver sobre a API WEB.

Uma API é, essencialmente, uma interface que nos permite solicitar e receber dados, pense na API como uma espécie de "contrato" entre diferentes sistemas. Ela define como um sistema deve interagir com o outro, quais operações podem ser realizadas e quais dados estão disponíveis para acesso. No contexto WEB, a API é a interface usada para fazermos solicitações ao servidor, no entanto, é necessário especificar a ação que o servidor deve executar, e é aí que entram os ENDPOINTS.

Endpoints

Como o nome sugere, são pontos finais ou caminhos finais, no momento que precisamos acessar um recurso do servidor, precisamos de um caminho que nos leve até esse recurso, até o "caminho final" e esse caminho é um endpoint, vamos ver um exemplo simples disso.

Exemplo: Voltando novamente no exemplo que utilizamos acima, você acessou o site da Amazon e precisa comprar um item, nesse momento você faz uma busca pelo item no site por meio de um campo de pesquisa. Por trás dos panos, o que está acontecendo, é que seu navegador ou client, está fazendo uma solicitação ao servidor e essa solicitação é iniciada por meio de um ENDPOINT, todo esse caminho para iniciarmos nossa solicitação, seria dessa forma:

Tá, vamos quebrar esse caminho em partes, temos primeiramente a URL do servidor da Amazon, que no nosso caso seria essa:

E agora para informar ao servidor necessariamente qual ação ele necessita executar, o endpoint é chamado:

Dessa forma estamos informando ao servidor que ele precisa buscar um item, com o nome "camera", formando assim a URI completa:

Com a URI completa, é feita a request para o servidor, que no final de todo seu processo, nos retorna a response com as informações do nosso item, podendo ser em JSON, XML e YAML, um exemplo em JSON seria assim:

Conclusão

Dessa forma podemos entender que, um endpoint é nada mais nada menos que um caminho específico para informar qual ação o servidor deve executar. Importante lembrar que junto a esse endpoint, também precisamos informar o VERBO da solicitação ao servidor.

Espero que eu tenha te ajudado a entender o funcionamento de uma API WEB de como ela é extremamente importante na internet hoje em dia, caso tenha surgido alguma dúvida ou queira acrescentar alguma coisa, sinta-se a vontade!

Explicando ORM (Object Relational Mapping)

Diego Henrique — Tue, 07 Nov 2023 13:15:35 +0000

Conforme você avança em seus estudos de programação, inevitavelmente chegará à parte de bancos de dados, e isso é óbvio. Em algum momento de sua aplicação, você precisará armazenar grandes quantidades de dados, e é aí que os tão famosos bancos de dados entrarão em cena.

Primeiro, vejamos abaixo como seria uma implementação de operação DEL em um banco de dados em nossa aplicação, sem usar uma ferramenta ORM.

Exemplo simples de código sem ORM em Java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class DeleteStudent {
    public static void main(String[] args) {
        String url = "jdbc:sqlite:exemplo.db";
        int estudanteId = 1;

        try (Connection conn = DriverManager.getConnection(url);
             PreparedStatement pstmt = conn.prepareStatement("DELETE FROM estudantes WHERE id = ?")) {
            pstmt.setInt(1, estudanteId);
            int rowsDeleted = pstmt.executeUpdate();

            if (rowsDeleted > 0) {
                System.out.println("Estudante excluído com sucesso.");
            } else {
                System.out.println("Estudante não encontrado.");
            }
        } catch (Exception e) {
            System.err.println("Erro ao excluir o estudante: " + e.getMessage());
        }
    }
}

Neste código, estamos usando SQL para excluir um estudante do banco de dados. Perceba como o código ficou extenso e, para alguns, até mesmo complexo. Bem, esse é o desafio de programar sem usar o valioso ORM. Agora, deixe-me mostrar uma versão semelhante de código, mas usando uma ferramenta ORM.

Exemplo simples de código com ORM em Java

   public void delete(Estudante estudante) {
        this.filmRepositoryJPA.delete(estudante);
    }

Parece brincadeira, não é? Claro, esse código é apenas uma implementação simples, mas ambos seguem o mesmo objetivo.

O problema que ORM veio resolver.

Hoje em dia, é quase padrão que sua linguagem preferida seja Orientada a Objetos (OOP). Nesse paradigma, tudo é tratado como objeto, com suas propriedades e comportamentos. No entanto, quando se trata de bancos de dados, as coisas mudam, já que a maioria dos bancos de dados tem sua própria maneira de lidar com informações, usando tabelas, colunas e linhas. Você pode imaginar que essas duas formas distintas de trabalhar não se encaixam bem, certo?

Foi aí que o ORM entrou em cena, para facilitar essa relação, sem que o programador precise lidar com cada implementação. Dessa forma, o programador pode usar os próprios atributos da classe/objeto para recuperar os dados do banco.

Exemplo de atualização do usuário por meio de seus atributos

public void atualizarEstudante(Long id, String novoNome, int novaIdade) {
        Student student = studentRepository.findById(id).orElse(null);

        if (student != null) {
            student.setNome(novoNome);
            student.setIdade(novaIdade);
            studentRepository.save(student);
        }
    }

É importante mencionar que, nestes exemplos, estou usando o Spring Boot com o Hibernate (nosso ORM em Java).

Conclusão

Como podemos observar, o ORM veio para simplificar a vida do programador, eliminando a necessidade de passar horas adaptando sua aplicação para funcionar em diferentes paradigmas. Claro que há muito mais a ser explorado sobre essa incrível ferramenta, e recomendo que você leia a documentação específica de cada implementação em sua linguagem favorita. Deixo aqui o link para a documentação do Hibernate com Java, que foi usado em nossos exemplos.
Hibernate

Muito obrigado por ler até aqui!

Como descobri na prática, a importância de uma boa organização e um bom código.

Diego Henrique — Thu, 05 Oct 2023 21:04:58 +0000

Sou novato na área de tecnologia (inclusive, este é o meu primeiro artigo) e estudo de forma autodidata há cerca de sete meses. Comecei com alguns cursos na Udemy para ter um ponto de partida, mas cheguei a um ponto em que não estava satisfeito em apenas seguir tutoriais. Eu queria realmente entender os problemas, cometer erros e pesquisar na internet para encontrar soluções. À medida que comecei a estudar dessa maneira, percebi um progresso constante em meu aprendizado, muito maior do que quando estava apenas seguindo as instruções passo a passo dos tutoriais.

Então, um dia, minha namorada me sugeriu um projeto: criar um BOT na plataforma Discord. Acredito que a maioria de vocês está familiarizada com essa plataforma. O BOT teria várias funcionalidades, mas a mais importante e desafiadora era criar um reprodutor de músicas. Comecei a codificar em Python para implementar essas funcionalidades até chegar ao reprodutor. Continuei pesquisando, e, é claro, usando o GPT para me ajudar, até conseguir criar a primeira versão do BOT. Incrivelmente, funcionava, mas apenas com links de músicas do YouTube.

O verdadeiro desafio surgiu quando decidimos adicionar suporte para links do Spotify. Segui o mesmo processo de pesquisa intensiva até encontrar uma solução. No entanto, quando tentei adicionar o código necessário à classe onde todo o código do reprodutor estava, deparei-me com um problema: essa classe havia se tornado a temida "GOD CLASS". Para quem não sabe, uma GOD CLASS é uma classe que concentra uma quantidade excessiva de código e responsabilidades, muitas vezes até funções que não deveriam estar ali. No meu caso, essa classe não apenas tocava, pausava e pulava músicas, mas também gerenciava pastas, fazia downloads de músicas, validava links e até mesmo enviava mensagens. Agora você pode entender por que foi impossível fazer qualquer alteração nela.

No entanto, naquela época, eu não estava familiarizado com conceitos como "SOLID, CLEAN CODE e CLEAN ARCHITECTURE". Comecei a pesquisar sobre "problemas de refatoração de código" e foi aí que descobri essas boas práticas. Comecei lendo o livro "CLEAN ARCHITECTURE", que me deu uma ideia de como organizar toda a arquitetura do meu projeto. No início do livro, ele também aborda brevemente o SOLID, e foi aí que me apaixonei completamente por esses conceitos e comecei a pesquisar mais sobre eles.

Graças a esse conhecimento, finalmente entendi por que meu código estava tão bagunçado. Não pretendo entrar em detalhes sobre esses princípios e como aplicá-los neste artigo; quem sabe em um próximo? O que eu gostaria de enfatizar é que não basta encher a cabeça de teoria lendo livros e assistindo vídeos sobre boas práticas. Como o próprio nome sugere, são "práticas". Você precisa aplicar esses princípios, na prática, mesmo que seu código esteja sujo e desorganizado. É assim que você realmente compreende a importância e o momento certo de usar todas essas boas práticas. Dessa forma, você evolui consideravelmente como programador. Muito obrigado a todos que leram até aqui. Até a próxima!